healpy-1.10.3/0000775000175000017500000000000013031130324013314 5ustar zoncazonca00000000000000healpy-1.10.3/cfitsio/0000775000175000017500000000000013031130324014754 5ustar zoncazonca00000000000000healpy-1.10.3/cfitsio/zlib/0000775000175000017500000000000013031130324015714 5ustar zoncazonca00000000000000healpy-1.10.3/cfitsio/zlib/adler32.c0000664000175000017500000001164713010375005017331 0ustar zoncazonca00000000000000/* adler32.c -- compute the Adler-32 checksum of a data stream * Copyright (C) 1995-2007 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ #include "zutil.h" #define local static local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2); #define BASE 65521UL /* largest prime smaller than 65536 */ #define NMAX 5552 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ #define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); #define DO16(buf) DO8(buf,0); DO8(buf,8); /* use NO_DIVIDE if your processor does not do division in hardware */ #ifdef NO_DIVIDE # define MOD(a) \ do { \ if (a >= (BASE << 16)) a -= (BASE << 16); \ if (a >= (BASE << 15)) a -= (BASE << 15); \ if (a >= (BASE << 14)) a -= (BASE << 14); \ if (a >= (BASE << 13)) a -= (BASE << 13); \ if (a >= (BASE << 12)) a -= (BASE << 12); \ if (a >= (BASE << 11)) a -= (BASE << 11); \ if (a >= (BASE << 10)) a -= (BASE << 10); \ if (a >= (BASE << 9)) a -= (BASE << 9); \ if (a >= (BASE << 8)) a -= (BASE << 8); \ if (a >= (BASE << 7)) a -= (BASE << 7); \ if (a >= (BASE << 6)) a -= (BASE << 6); \ if (a >= (BASE << 5)) a -= (BASE << 5); \ if (a >= (BASE << 4)) a -= (BASE << 4); \ if (a >= (BASE << 3)) a -= (BASE << 3); \ if (a >= (BASE << 2)) a -= (BASE << 2); \ if (a >= (BASE << 1)) a -= (BASE << 1); \ if (a >= BASE) a -= BASE; \ } while (0) # define MOD4(a) \ do { \ if (a >= (BASE << 4)) a -= (BASE << 4); \ if (a >= (BASE << 3)) a -= (BASE << 3); \ if (a >= (BASE << 2)) a -= (BASE << 2); \ if (a >= (BASE << 1)) a -= (BASE << 1); \ if (a >= BASE) a -= BASE; \ } while (0) #else # define MOD(a) a %= BASE # define MOD4(a) a %= BASE #endif /* ========================================================================= */ uLong ZEXPORT adler32(adler, buf, len) uLong adler; const Bytef *buf; uInt len; { unsigned long sum2; unsigned n; /* split Adler-32 into component sums */ sum2 = (adler >> 16) & 0xffff; adler &= 0xffff; /* in case user likes doing a byte at a time, keep it fast */ if (len == 1) { adler += buf[0]; if (adler >= BASE) adler -= BASE; sum2 += adler; if (sum2 >= BASE) sum2 -= BASE; return adler | (sum2 << 16); } /* initial Adler-32 value (deferred check for len == 1 speed) */ if (buf == Z_NULL) return 1L; /* in case short lengths are provided, keep it somewhat fast */ if (len < 16) { while (len--) { adler += *buf++; sum2 += adler; } if (adler >= BASE) adler -= BASE; MOD4(sum2); /* only added so many BASE's */ return adler | (sum2 << 16); } /* do length NMAX blocks -- requires just one modulo operation */ while (len >= NMAX) { len -= NMAX; n = NMAX / 16; /* NMAX is divisible by 16 */ do { DO16(buf); /* 16 sums unrolled */ buf += 16; } while (--n); MOD(adler); MOD(sum2); } /* do remaining bytes (less than NMAX, still just one modulo) */ if (len) { /* avoid modulos if none remaining */ while (len >= 16) { len -= 16; DO16(buf); buf += 16; } while (len--) { adler += *buf++; sum2 += adler; } MOD(adler); MOD(sum2); } /* return recombined sums */ return adler | (sum2 << 16); } /* ========================================================================= */ local uLong adler32_combine_(adler1, adler2, len2) uLong adler1; uLong adler2; z_off64_t len2; { unsigned long sum1; unsigned long sum2; unsigned rem; /* the derivation of this formula is left as an exercise for the reader */ rem = (unsigned)(len2 % BASE); sum1 = adler1 & 0xffff; sum2 = rem * sum1; MOD(sum2); sum1 += (adler2 & 0xffff) + BASE - 1; sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; if (sum1 >= BASE) sum1 -= BASE; if (sum1 >= BASE) sum1 -= BASE; if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); if (sum2 >= BASE) sum2 -= BASE; return sum1 | (sum2 << 16); } /* ========================================================================= */ uLong ZEXPORT adler32_combine(adler1, adler2, len2) uLong adler1; uLong adler2; z_off_t len2; { return adler32_combine_(adler1, adler2, len2); } uLong ZEXPORT adler32_combine64(adler1, adler2, len2) uLong adler1; uLong adler2; z_off64_t len2; { return adler32_combine_(adler1, adler2, len2); } healpy-1.10.3/cfitsio/zlib/crc32.c0000664000175000017500000003254013010375005017004 0ustar zoncazonca00000000000000/* crc32.c -- compute the CRC-32 of a data stream * Copyright (C) 1995-2006, 2010 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h * * Thanks to Rodney Brown for his contribution of faster * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing * tables for updating the shift register in one step with three exclusive-ors * instead of four steps with four exclusive-ors. This results in about a * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. */ /* Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore protection on the static variables used to control the first-use generation of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should first call get_crc_table() to initialize the tables before allowing more than one thread to use crc32(). */ #ifdef MAKECRCH # include # ifndef DYNAMIC_CRC_TABLE # define DYNAMIC_CRC_TABLE # endif /* !DYNAMIC_CRC_TABLE */ #endif /* MAKECRCH */ #include "zutil.h" /* for STDC and FAR definitions */ #define local static /* Find a four-byte integer type for crc32_little() and crc32_big(). */ #ifndef NOBYFOUR # ifdef STDC /* need ANSI C limits.h to determine sizes */ # include # define BYFOUR # if (UINT_MAX == 0xffffffffUL) typedef unsigned int u4; # else # if (ULONG_MAX == 0xffffffffUL) typedef unsigned long u4; # else # if (USHRT_MAX == 0xffffffffUL) typedef unsigned short u4; # else # undef BYFOUR /* can't find a four-byte integer type! */ # endif # endif # endif # endif /* STDC */ #endif /* !NOBYFOUR */ /* Definitions for doing the crc four data bytes at a time. */ #ifdef BYFOUR # define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \ (((w)&0xff00)<<8)+(((w)&0xff)<<24)) local unsigned long crc32_little OF((unsigned long, const unsigned char FAR *, unsigned)); local unsigned long crc32_big OF((unsigned long, const unsigned char FAR *, unsigned)); # define TBLS 8 #else # define TBLS 1 #endif /* BYFOUR */ /* Local functions for crc concatenation */ local unsigned long gf2_matrix_times OF((unsigned long *mat, unsigned long vec)); local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2); #ifdef DYNAMIC_CRC_TABLE local volatile int crc_table_empty = 1; local unsigned long FAR crc_table[TBLS][256]; local void make_crc_table OF((void)); #ifdef MAKECRCH local void write_table OF((FILE *, const unsigned long FAR *)); #endif /* MAKECRCH */ /* Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. Polynomials over GF(2) are represented in binary, one bit per coefficient, with the lowest powers in the most significant bit. Then adding polynomials is just exclusive-or, and multiplying a polynomial by x is a right shift by one. If we call the above polynomial p, and represent a byte as the polynomial q, also with the lowest power in the most significant bit (so the byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, where a mod b means the remainder after dividing a by b. This calculation is done using the shift-register method of multiplying and taking the remainder. The register is initialized to zero, and for each incoming bit, x^32 is added mod p to the register if the bit is a one (where x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by x (which is shifting right by one and adding x^32 mod p if the bit shifted out is a one). We start with the highest power (least significant bit) of q and repeat for all eight bits of q. The first table is simply the CRC of all possible eight bit values. This is all the information needed to generate CRCs on data a byte at a time for all combinations of CRC register values and incoming bytes. The remaining tables allow for word-at-a-time CRC calculation for both big-endian and little- endian machines, where a word is four bytes. */ local void make_crc_table() { unsigned long c; int n, k; unsigned long poly; /* polynomial exclusive-or pattern */ /* terms of polynomial defining this crc (except x^32): */ static volatile int first = 1; /* flag to limit concurrent making */ static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; /* See if another task is already doing this (not thread-safe, but better than nothing -- significantly reduces duration of vulnerability in case the advice about DYNAMIC_CRC_TABLE is ignored) */ if (first) { first = 0; /* make exclusive-or pattern from polynomial (0xedb88320UL) */ poly = 0UL; for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++) poly |= 1UL << (31 - p[n]); /* generate a crc for every 8-bit value */ for (n = 0; n < 256; n++) { c = (unsigned long)n; for (k = 0; k < 8; k++) c = c & 1 ? poly ^ (c >> 1) : c >> 1; crc_table[0][n] = c; } #ifdef BYFOUR /* generate crc for each value followed by one, two, and three zeros, and then the byte reversal of those as well as the first table */ for (n = 0; n < 256; n++) { c = crc_table[0][n]; crc_table[4][n] = REV(c); for (k = 1; k < 4; k++) { c = crc_table[0][c & 0xff] ^ (c >> 8); crc_table[k][n] = c; crc_table[k + 4][n] = REV(c); } } #endif /* BYFOUR */ crc_table_empty = 0; } else { /* not first */ /* wait for the other guy to finish (not efficient, but rare) */ while (crc_table_empty) ; } #ifdef MAKECRCH /* write out CRC tables to crc32.h */ { FILE *out; out = fopen("crc32.h", "w"); if (out == NULL) return; fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); fprintf(out, "local const unsigned long FAR "); fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); write_table(out, crc_table[0]); # ifdef BYFOUR fprintf(out, "#ifdef BYFOUR\n"); for (k = 1; k < 8; k++) { fprintf(out, " },\n {\n"); write_table(out, crc_table[k]); } fprintf(out, "#endif\n"); # endif /* BYFOUR */ fprintf(out, " }\n};\n"); fclose(out); } #endif /* MAKECRCH */ } #ifdef MAKECRCH local void write_table(out, table) FILE *out; const unsigned long FAR *table; { int n; for (n = 0; n < 256; n++) fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n], n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); } #endif /* MAKECRCH */ #else /* !DYNAMIC_CRC_TABLE */ /* ======================================================================== * Tables of CRC-32s of all single-byte values, made by make_crc_table(). */ #include "crc32.h" #endif /* DYNAMIC_CRC_TABLE */ /* ========================================================================= * This function can be used by asm versions of crc32() */ const unsigned long FAR * ZEXPORT get_crc_table() { #ifdef DYNAMIC_CRC_TABLE if (crc_table_empty) make_crc_table(); #endif /* DYNAMIC_CRC_TABLE */ return (const unsigned long FAR *)crc_table; } /* ========================================================================= */ #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 /* ========================================================================= */ unsigned long ZEXPORT crc32(crc, buf, len) unsigned long crc; const unsigned char FAR *buf; uInt len; { if (buf == Z_NULL) return 0UL; #ifdef DYNAMIC_CRC_TABLE if (crc_table_empty) make_crc_table(); #endif /* DYNAMIC_CRC_TABLE */ #ifdef BYFOUR if (sizeof(void *) == sizeof(ptrdiff_t)) { u4 endian; endian = 1; if (*((unsigned char *)(&endian))) return crc32_little(crc, buf, len); else return crc32_big(crc, buf, len); } #endif /* BYFOUR */ crc = crc ^ 0xffffffffUL; while (len >= 8) { DO8; len -= 8; } if (len) do { DO1; } while (--len); return crc ^ 0xffffffffUL; } #ifdef BYFOUR /* ========================================================================= */ #define DOLIT4 c ^= *buf4++; \ c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 /* ========================================================================= */ local unsigned long crc32_little(crc, buf, len) unsigned long crc; const unsigned char FAR *buf; unsigned len; { register u4 c; register const u4 FAR *buf4; c = (u4)crc; c = ~c; while (len && ((ptrdiff_t)buf & 3)) { c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); len--; } buf4 = (const u4 FAR *)(const void FAR *)buf; while (len >= 32) { DOLIT32; len -= 32; } while (len >= 4) { DOLIT4; len -= 4; } buf = (const unsigned char FAR *)buf4; if (len) do { c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); } while (--len); c = ~c; return (unsigned long)c; } /* ========================================================================= */ #define DOBIG4 c ^= *++buf4; \ c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 /* ========================================================================= */ local unsigned long crc32_big(crc, buf, len) unsigned long crc; const unsigned char FAR *buf; unsigned len; { register u4 c; register const u4 FAR *buf4; c = REV((u4)crc); c = ~c; while (len && ((ptrdiff_t)buf & 3)) { c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); len--; } buf4 = (const u4 FAR *)(const void FAR *)buf; buf4--; while (len >= 32) { DOBIG32; len -= 32; } while (len >= 4) { DOBIG4; len -= 4; } buf4++; buf = (const unsigned char FAR *)buf4; if (len) do { c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); } while (--len); c = ~c; return (unsigned long)(REV(c)); } #endif /* BYFOUR */ #define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ /* ========================================================================= */ local unsigned long gf2_matrix_times(mat, vec) unsigned long *mat; unsigned long vec; { unsigned long sum; sum = 0; while (vec) { if (vec & 1) sum ^= *mat; vec >>= 1; mat++; } return sum; } /* ========================================================================= */ local void gf2_matrix_square(square, mat) unsigned long *square; unsigned long *mat; { int n; for (n = 0; n < GF2_DIM; n++) square[n] = gf2_matrix_times(mat, mat[n]); } /* ========================================================================= */ local uLong crc32_combine_(crc1, crc2, len2) uLong crc1; uLong crc2; z_off64_t len2; { int n; unsigned long row; unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ /* degenerate case (also disallow negative lengths) */ if (len2 <= 0) return crc1; /* put operator for one zero bit in odd */ odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ row = 1; for (n = 1; n < GF2_DIM; n++) { odd[n] = row; row <<= 1; } /* put operator for two zero bits in even */ gf2_matrix_square(even, odd); /* put operator for four zero bits in odd */ gf2_matrix_square(odd, even); /* apply len2 zeros to crc1 (first square will put the operator for one zero byte, eight zero bits, in even) */ do { /* apply zeros operator for this bit of len2 */ gf2_matrix_square(even, odd); if (len2 & 1) crc1 = gf2_matrix_times(even, crc1); len2 >>= 1; /* if no more bits set, then done */ if (len2 == 0) break; /* another iteration of the loop with odd and even swapped */ gf2_matrix_square(odd, even); if (len2 & 1) crc1 = gf2_matrix_times(odd, crc1); len2 >>= 1; /* if no more bits set, then done */ } while (len2 != 0); /* return combined crc */ crc1 ^= crc2; return crc1; } /* ========================================================================= */ uLong ZEXPORT crc32_combine(crc1, crc2, len2) uLong crc1; uLong crc2; z_off_t len2; { return crc32_combine_(crc1, crc2, len2); } uLong ZEXPORT crc32_combine64(crc1, crc2, len2) uLong crc1; uLong crc2; z_off64_t len2; { return crc32_combine_(crc1, crc2, len2); } healpy-1.10.3/cfitsio/zlib/crc32.h0000664000175000017500000007355013010375005017017 0ustar zoncazonca00000000000000/* crc32.h -- tables for rapid CRC calculation * Generated automatically by crc32.c */ local const unsigned long FAR crc_table[TBLS][256] = { { 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, 0x2d02ef8dUL #ifdef BYFOUR }, { 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, 0x9324fd72UL }, { 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, 0xbe9834edUL }, { 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, 0xde0506f1UL }, { 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, 0x8def022dUL }, { 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, 0x72fd2493UL }, { 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, 0xed3498beUL }, { 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, 0xf10605deUL #endif } }; healpy-1.10.3/cfitsio/zlib/deflate.c0000664000175000017500000020460713010375005017501 0ustar zoncazonca00000000000000/* deflate.c -- compress data using the deflation algorithm * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ /* * ALGORITHM * * The "deflation" process depends on being able to identify portions * of the input text which are identical to earlier input (within a * sliding window trailing behind the input currently being processed). * * The most straightforward technique turns out to be the fastest for * most input files: try all possible matches and select the longest. * The key feature of this algorithm is that insertions into the string * dictionary are very simple and thus fast, and deletions are avoided * completely. Insertions are performed at each input character, whereas * string matches are performed only when the previous match ends. So it * is preferable to spend more time in matches to allow very fast string * insertions and avoid deletions. The matching algorithm for small * strings is inspired from that of Rabin & Karp. A brute force approach * is used to find longer strings when a small match has been found. * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze * (by Leonid Broukhis). * A previous version of this file used a more sophisticated algorithm * (by Fiala and Greene) which is guaranteed to run in linear amortized * time, but has a larger average cost, uses more memory and is patented. * However the F&G algorithm may be faster for some highly redundant * files if the parameter max_chain_length (described below) is too large. * * ACKNOWLEDGEMENTS * * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and * I found it in 'freeze' written by Leonid Broukhis. * Thanks to many people for bug reports and testing. * * REFERENCES * * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". * Available in http://www.ietf.org/rfc/rfc1951.txt * * A description of the Rabin and Karp algorithm is given in the book * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. * * Fiala,E.R., and Greene,D.H. * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 * */ #include "deflate.h" const char deflate_copyright[] = " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler "; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot include such an acknowledgment, I would appreciate that you keep this copyright string in the executable of your product. */ /* =========================================================================== * Function prototypes. */ typedef enum { need_more, /* block not completed, need more input or more output */ block_done, /* block flush performed */ finish_started, /* finish started, need only more output at next deflate */ finish_done /* finish done, accept no more input or output */ } block_state; typedef block_state (*compress_func) OF((deflate_state *s, int flush)); /* Compression function. Returns the block state after the call. */ local void fill_window OF((deflate_state *s)); local block_state deflate_stored OF((deflate_state *s, int flush)); local block_state deflate_fast OF((deflate_state *s, int flush)); #ifndef FASTEST local block_state deflate_slow OF((deflate_state *s, int flush)); #endif local block_state deflate_rle OF((deflate_state *s, int flush)); local block_state deflate_huff OF((deflate_state *s, int flush)); local void lm_init OF((deflate_state *s)); local void putShortMSB OF((deflate_state *s, uInt b)); local void flush_pending OF((z_streamp strm)); local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); #ifdef ASMV void match_init OF((void)); /* asm code initialization */ uInt longest_match OF((deflate_state *s, IPos cur_match)); #else local uInt longest_match OF((deflate_state *s, IPos cur_match)); #endif #ifdef DEBUG local void check_match OF((deflate_state *s, IPos start, IPos match, int length)); #endif /* =========================================================================== * Local data */ #define NIL 0 /* Tail of hash chains */ #ifndef TOO_FAR # define TOO_FAR 4096 #endif /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ /* Values for max_lazy_match, good_match and max_chain_length, depending on * the desired pack level (0..9). The values given below have been tuned to * exclude worst case performance for pathological files. Better values may be * found for specific files. */ typedef struct config_s { ush good_length; /* reduce lazy search above this match length */ ush max_lazy; /* do not perform lazy search above this match length */ ush nice_length; /* quit search above this match length */ ush max_chain; compress_func func; } config; #ifdef FASTEST local const config configuration_table[2] = { /* good lazy nice chain */ /* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ /* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ #else local const config configuration_table[10] = { /* good lazy nice chain */ /* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ /* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ /* 2 */ {4, 5, 16, 8, deflate_fast}, /* 3 */ {4, 6, 32, 32, deflate_fast}, /* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ /* 5 */ {8, 16, 32, 32, deflate_slow}, /* 6 */ {8, 16, 128, 128, deflate_slow}, /* 7 */ {8, 32, 128, 256, deflate_slow}, /* 8 */ {32, 128, 258, 1024, deflate_slow}, /* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ #endif /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different * meaning. */ #define EQUAL 0 /* result of memcmp for equal strings */ #ifndef NO_DUMMY_DECL struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ #endif /* =========================================================================== * Update a hash value with the given input byte * IN assertion: all calls to to UPDATE_HASH are made with consecutive * input characters, so that a running hash key can be computed from the * previous key instead of complete recalculation each time. */ #define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) /* =========================================================================== * Insert string str in the dictionary and set match_head to the previous head * of the hash chain (the most recent string with same hash key). Return * the previous length of the hash chain. * If this file is compiled with -DFASTEST, the compression level is forced * to 1, and no hash chains are maintained. * IN assertion: all calls to to INSERT_STRING are made with consecutive * input characters and the first MIN_MATCH bytes of str are valid * (except for the last MIN_MATCH-1 bytes of the input file). */ #ifdef FASTEST #define INSERT_STRING(s, str, match_head) \ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ match_head = s->head[s->ins_h], \ s->head[s->ins_h] = (Pos)(str)) #else #define INSERT_STRING(s, str, match_head) \ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ s->head[s->ins_h] = (Pos)(str)) #endif /* =========================================================================== * Initialize the hash table (avoiding 64K overflow for 16 bit systems). * prev[] will be initialized on the fly. */ #define CLEAR_HASH(s) \ s->head[s->hash_size-1] = NIL; \ zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); /* ========================================================================= */ int ZEXPORT deflateInit_(strm, level, version, stream_size) z_streamp strm; int level; const char *version; int stream_size; { return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, version, stream_size); /* To do: ignore strm->next_in if we use it as window */ } /* ========================================================================= */ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, version, stream_size) z_streamp strm; int level; int method; int windowBits; int memLevel; int strategy; const char *version; int stream_size; { deflate_state *s; int wrap = 1; static const char my_version[] = ZLIB_VERSION; ushf *overlay; /* We overlay pending_buf and d_buf+l_buf. This works since the average * output size for (length,distance) codes is <= 24 bits. */ if (version == Z_NULL || version[0] != my_version[0] || stream_size != sizeof(z_stream)) { return Z_VERSION_ERROR; } if (strm == Z_NULL) return Z_STREAM_ERROR; strm->msg = Z_NULL; if (strm->zalloc == (alloc_func)0) { strm->zalloc = zcalloc; strm->opaque = (voidpf)0; } if (strm->zfree == (free_func)0) strm->zfree = zcfree; #ifdef FASTEST if (level != 0) level = 1; #else if (level == Z_DEFAULT_COMPRESSION) level = 6; #endif if (windowBits < 0) { /* suppress zlib wrapper */ wrap = 0; windowBits = -windowBits; } #ifdef GZIP else if (windowBits > 15) { wrap = 2; /* write gzip wrapper instead */ windowBits -= 16; } #endif if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { return Z_STREAM_ERROR; } if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); if (s == Z_NULL) return Z_MEM_ERROR; strm->state = (struct internal_state FAR *)s; s->strm = strm; s->wrap = wrap; s->gzhead = Z_NULL; s->w_bits = windowBits; s->w_size = 1 << s->w_bits; s->w_mask = s->w_size - 1; s->hash_bits = memLevel + 7; s->hash_size = 1 << s->hash_bits; s->hash_mask = s->hash_size - 1; s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); s->high_water = 0; /* nothing written to s->window yet */ s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); s->pending_buf = (uchf *) overlay; s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || s->pending_buf == Z_NULL) { s->status = FINISH_STATE; strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); deflateEnd (strm); return Z_MEM_ERROR; } s->d_buf = overlay + s->lit_bufsize/sizeof(ush); s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; s->level = level; s->strategy = strategy; s->method = (Byte)method; return deflateReset(strm); } /* ========================================================================= */ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) z_streamp strm; const Bytef *dictionary; uInt dictLength; { deflate_state *s; uInt length = dictLength; uInt n; IPos hash_head = 0; if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || strm->state->wrap == 2 || (strm->state->wrap == 1 && strm->state->status != INIT_STATE)) return Z_STREAM_ERROR; s = strm->state; if (s->wrap) strm->adler = adler32(strm->adler, dictionary, dictLength); if (length < MIN_MATCH) return Z_OK; if (length > s->w_size) { length = s->w_size; dictionary += dictLength - length; /* use the tail of the dictionary */ } zmemcpy(s->window, dictionary, length); s->strstart = length; s->block_start = (long)length; /* Insert all strings in the hash table (except for the last two bytes). * s->lookahead stays null, so s->ins_h will be recomputed at the next * call of fill_window. */ s->ins_h = s->window[0]; UPDATE_HASH(s, s->ins_h, s->window[1]); for (n = 0; n <= length - MIN_MATCH; n++) { INSERT_STRING(s, n, hash_head); } if (hash_head) hash_head = 0; /* to make compiler happy */ return Z_OK; } /* ========================================================================= */ int ZEXPORT deflateReset (strm) z_streamp strm; { deflate_state *s; if (strm == Z_NULL || strm->state == Z_NULL || strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { return Z_STREAM_ERROR; } strm->total_in = strm->total_out = 0; strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ strm->data_type = Z_UNKNOWN; s = (deflate_state *)strm->state; s->pending = 0; s->pending_out = s->pending_buf; if (s->wrap < 0) { s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ } s->status = s->wrap ? INIT_STATE : BUSY_STATE; strm->adler = #ifdef GZIP s->wrap == 2 ? crc32(0L, Z_NULL, 0) : #endif adler32(0L, Z_NULL, 0); s->last_flush = Z_NO_FLUSH; _tr_init(s); lm_init(s); return Z_OK; } /* ========================================================================= */ int ZEXPORT deflateSetHeader (strm, head) z_streamp strm; gz_headerp head; { if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; if (strm->state->wrap != 2) return Z_STREAM_ERROR; strm->state->gzhead = head; return Z_OK; } /* ========================================================================= */ int ZEXPORT deflatePrime (strm, bits, value) z_streamp strm; int bits; int value; { if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; strm->state->bi_valid = bits; strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); return Z_OK; } /* ========================================================================= */ int ZEXPORT deflateParams(strm, level, strategy) z_streamp strm; int level; int strategy; { deflate_state *s; compress_func func; int err = Z_OK; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; s = strm->state; #ifdef FASTEST if (level != 0) level = 1; #else if (level == Z_DEFAULT_COMPRESSION) level = 6; #endif if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { return Z_STREAM_ERROR; } func = configuration_table[s->level].func; if ((strategy != s->strategy || func != configuration_table[level].func) && strm->total_in != 0) { /* Flush the last buffer: */ err = deflate(strm, Z_BLOCK); } if (s->level != level) { s->level = level; s->max_lazy_match = configuration_table[level].max_lazy; s->good_match = configuration_table[level].good_length; s->nice_match = configuration_table[level].nice_length; s->max_chain_length = configuration_table[level].max_chain; } s->strategy = strategy; return err; } /* ========================================================================= */ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) z_streamp strm; int good_length; int max_lazy; int nice_length; int max_chain; { deflate_state *s; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; s = strm->state; s->good_match = good_length; s->max_lazy_match = max_lazy; s->nice_match = nice_length; s->max_chain_length = max_chain; return Z_OK; } /* ========================================================================= * For the default windowBits of 15 and memLevel of 8, this function returns * a close to exact, as well as small, upper bound on the compressed size. * They are coded as constants here for a reason--if the #define's are * changed, then this function needs to be changed as well. The return * value for 15 and 8 only works for those exact settings. * * For any setting other than those defaults for windowBits and memLevel, * the value returned is a conservative worst case for the maximum expansion * resulting from using fixed blocks instead of stored blocks, which deflate * can emit on compressed data for some combinations of the parameters. * * This function could be more sophisticated to provide closer upper bounds for * every combination of windowBits and memLevel. But even the conservative * upper bound of about 14% expansion does not seem onerous for output buffer * allocation. */ uLong ZEXPORT deflateBound(strm, sourceLen) z_streamp strm; uLong sourceLen; { deflate_state *s; uLong complen, wraplen; Bytef *str; /* conservative upper bound for compressed data */ complen = sourceLen + ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; /* if can't get parameters, return conservative bound plus zlib wrapper */ if (strm == Z_NULL || strm->state == Z_NULL) return complen + 6; /* compute wrapper length */ s = strm->state; switch (s->wrap) { case 0: /* raw deflate */ wraplen = 0; break; case 1: /* zlib wrapper */ wraplen = 6 + (s->strstart ? 4 : 0); break; case 2: /* gzip wrapper */ wraplen = 18; if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ if (s->gzhead->extra != Z_NULL) wraplen += 2 + s->gzhead->extra_len; str = s->gzhead->name; if (str != Z_NULL) do { wraplen++; } while (*str++); str = s->gzhead->comment; if (str != Z_NULL) do { wraplen++; } while (*str++); if (s->gzhead->hcrc) wraplen += 2; } break; default: /* for compiler happiness */ wraplen = 6; } /* if not default parameters, return conservative bound */ if (s->w_bits != 15 || s->hash_bits != 8 + 7) return complen + wraplen; /* default settings: return tight bound for that case */ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + (sourceLen >> 25) + 13 - 6 + wraplen; } /* ========================================================================= * Put a short in the pending buffer. The 16-bit value is put in MSB order. * IN assertion: the stream state is correct and there is enough room in * pending_buf. */ local void putShortMSB (s, b) deflate_state *s; uInt b; { put_byte(s, (Byte)(b >> 8)); put_byte(s, (Byte)(b & 0xff)); } /* ========================================================================= * Flush as much pending output as possible. All deflate() output goes * through this function so some applications may wish to modify it * to avoid allocating a large strm->next_out buffer and copying into it. * (See also read_buf()). */ local void flush_pending(strm) z_streamp strm; { unsigned len = strm->state->pending; if (len > strm->avail_out) len = strm->avail_out; if (len == 0) return; zmemcpy(strm->next_out, strm->state->pending_out, len); strm->next_out += len; strm->state->pending_out += len; strm->total_out += len; strm->avail_out -= len; strm->state->pending -= len; if (strm->state->pending == 0) { strm->state->pending_out = strm->state->pending_buf; } } /* ========================================================================= */ int ZEXPORT deflate (strm, flush) z_streamp strm; int flush; { int old_flush; /* value of flush param for previous deflate call */ deflate_state *s; if (strm == Z_NULL || strm->state == Z_NULL || flush > Z_BLOCK || flush < 0) { return Z_STREAM_ERROR; } s = strm->state; if (strm->next_out == Z_NULL || (strm->next_in == Z_NULL && strm->avail_in != 0) || (s->status == FINISH_STATE && flush != Z_FINISH)) { ERR_RETURN(strm, Z_STREAM_ERROR); } if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); s->strm = strm; /* just in case */ old_flush = s->last_flush; s->last_flush = flush; /* Write the header */ if (s->status == INIT_STATE) { #ifdef GZIP if (s->wrap == 2) { strm->adler = crc32(0L, Z_NULL, 0); put_byte(s, 31); put_byte(s, 139); put_byte(s, 8); if (s->gzhead == Z_NULL) { put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, s->level == 9 ? 2 : (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 4 : 0)); put_byte(s, OS_CODE); s->status = BUSY_STATE; } else { put_byte(s, (s->gzhead->text ? 1 : 0) + (s->gzhead->hcrc ? 2 : 0) + (s->gzhead->extra == Z_NULL ? 0 : 4) + (s->gzhead->name == Z_NULL ? 0 : 8) + (s->gzhead->comment == Z_NULL ? 0 : 16) ); put_byte(s, (Byte)(s->gzhead->time & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); put_byte(s, s->level == 9 ? 2 : (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 4 : 0)); put_byte(s, s->gzhead->os & 0xff); if (s->gzhead->extra != Z_NULL) { put_byte(s, s->gzhead->extra_len & 0xff); put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); } if (s->gzhead->hcrc) strm->adler = crc32(strm->adler, s->pending_buf, s->pending); s->gzindex = 0; s->status = EXTRA_STATE; } } else #endif { uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; uInt level_flags; if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) level_flags = 0; else if (s->level < 6) level_flags = 1; else if (s->level == 6) level_flags = 2; else level_flags = 3; header |= (level_flags << 6); if (s->strstart != 0) header |= PRESET_DICT; header += 31 - (header % 31); s->status = BUSY_STATE; putShortMSB(s, header); /* Save the adler32 of the preset dictionary: */ if (s->strstart != 0) { putShortMSB(s, (uInt)(strm->adler >> 16)); putShortMSB(s, (uInt)(strm->adler & 0xffff)); } strm->adler = adler32(0L, Z_NULL, 0); } } #ifdef GZIP if (s->status == EXTRA_STATE) { if (s->gzhead->extra != Z_NULL) { uInt beg = s->pending; /* start of bytes to update crc */ while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { if (s->pending == s->pending_buf_size) { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); flush_pending(strm); beg = s->pending; if (s->pending == s->pending_buf_size) break; } put_byte(s, s->gzhead->extra[s->gzindex]); s->gzindex++; } if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); if (s->gzindex == s->gzhead->extra_len) { s->gzindex = 0; s->status = NAME_STATE; } } else s->status = NAME_STATE; } if (s->status == NAME_STATE) { if (s->gzhead->name != Z_NULL) { uInt beg = s->pending; /* start of bytes to update crc */ int val; do { if (s->pending == s->pending_buf_size) { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); flush_pending(strm); beg = s->pending; if (s->pending == s->pending_buf_size) { val = 1; break; } } val = s->gzhead->name[s->gzindex++]; put_byte(s, val); } while (val != 0); if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); if (val == 0) { s->gzindex = 0; s->status = COMMENT_STATE; } } else s->status = COMMENT_STATE; } if (s->status == COMMENT_STATE) { if (s->gzhead->comment != Z_NULL) { uInt beg = s->pending; /* start of bytes to update crc */ int val; do { if (s->pending == s->pending_buf_size) { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); flush_pending(strm); beg = s->pending; if (s->pending == s->pending_buf_size) { val = 1; break; } } val = s->gzhead->comment[s->gzindex++]; put_byte(s, val); } while (val != 0); if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); if (val == 0) s->status = HCRC_STATE; } else s->status = HCRC_STATE; } if (s->status == HCRC_STATE) { if (s->gzhead->hcrc) { if (s->pending + 2 > s->pending_buf_size) flush_pending(strm); if (s->pending + 2 <= s->pending_buf_size) { put_byte(s, (Byte)(strm->adler & 0xff)); put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); strm->adler = crc32(0L, Z_NULL, 0); s->status = BUSY_STATE; } } else s->status = BUSY_STATE; } #endif /* Flush as much pending output as possible */ if (s->pending != 0) { flush_pending(strm); if (strm->avail_out == 0) { /* Since avail_out is 0, deflate will be called again with * more output space, but possibly with both pending and * avail_in equal to zero. There won't be anything to do, * but this is not an error situation so make sure we * return OK instead of BUF_ERROR at next call of deflate: */ s->last_flush = -1; return Z_OK; } /* Make sure there is something to do and avoid duplicate consecutive * flushes. For repeated and useless calls with Z_FINISH, we keep * returning Z_STREAM_END instead of Z_BUF_ERROR. */ } else if (strm->avail_in == 0 && flush <= old_flush && flush != Z_FINISH) { ERR_RETURN(strm, Z_BUF_ERROR); } /* User must not provide more input after the first FINISH: */ if (s->status == FINISH_STATE && strm->avail_in != 0) { ERR_RETURN(strm, Z_BUF_ERROR); } /* Start a new block or continue the current one. */ if (strm->avail_in != 0 || s->lookahead != 0 || (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { block_state bstate; bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : (s->strategy == Z_RLE ? deflate_rle(s, flush) : (*(configuration_table[s->level].func))(s, flush)); if (bstate == finish_started || bstate == finish_done) { s->status = FINISH_STATE; } if (bstate == need_more || bstate == finish_started) { if (strm->avail_out == 0) { s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ } return Z_OK; /* If flush != Z_NO_FLUSH && avail_out == 0, the next call * of deflate should use the same flush parameter to make sure * that the flush is complete. So we don't have to output an * empty block here, this will be done at next call. This also * ensures that for a very small output buffer, we emit at most * one empty block. */ } if (bstate == block_done) { if (flush == Z_PARTIAL_FLUSH) { _tr_align(s); } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ _tr_stored_block(s, (char*)0, 0L, 0); /* For a full flush, this empty block will be recognized * as a special marker by inflate_sync(). */ if (flush == Z_FULL_FLUSH) { CLEAR_HASH(s); /* forget history */ if (s->lookahead == 0) { s->strstart = 0; s->block_start = 0L; } } } flush_pending(strm); if (strm->avail_out == 0) { s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ return Z_OK; } } } Assert(strm->avail_out > 0, "bug2"); if (flush != Z_FINISH) return Z_OK; if (s->wrap <= 0) return Z_STREAM_END; /* Write the trailer */ #ifdef GZIP if (s->wrap == 2) { put_byte(s, (Byte)(strm->adler & 0xff)); put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); put_byte(s, (Byte)(strm->total_in & 0xff)); put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); } else #endif { putShortMSB(s, (uInt)(strm->adler >> 16)); putShortMSB(s, (uInt)(strm->adler & 0xffff)); } flush_pending(strm); /* If avail_out is zero, the application will call deflate again * to flush the rest. */ if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ return s->pending != 0 ? Z_OK : Z_STREAM_END; } /* ========================================================================= */ int ZEXPORT deflateEnd (strm) z_streamp strm; { int status; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; status = strm->state->status; if (status != INIT_STATE && status != EXTRA_STATE && status != NAME_STATE && status != COMMENT_STATE && status != HCRC_STATE && status != BUSY_STATE && status != FINISH_STATE) { return Z_STREAM_ERROR; } /* Deallocate in reverse order of allocations: */ TRY_FREE(strm, strm->state->pending_buf); TRY_FREE(strm, strm->state->head); TRY_FREE(strm, strm->state->prev); TRY_FREE(strm, strm->state->window); ZFREE(strm, strm->state); strm->state = Z_NULL; return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; } /* ========================================================================= * Copy the source state to the destination state. * To simplify the source, this is not supported for 16-bit MSDOS (which * doesn't have enough memory anyway to duplicate compression states). */ int ZEXPORT deflateCopy (dest, source) z_streamp dest; z_streamp source; { #ifdef MAXSEG_64K return Z_STREAM_ERROR; #else deflate_state *ds; deflate_state *ss; ushf *overlay; if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { return Z_STREAM_ERROR; } ss = source->state; zmemcpy(dest, source, sizeof(z_stream)); ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); if (ds == Z_NULL) return Z_MEM_ERROR; dest->state = (struct internal_state FAR *) ds; zmemcpy(ds, ss, sizeof(deflate_state)); ds->strm = dest; ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); ds->pending_buf = (uchf *) overlay; if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || ds->pending_buf == Z_NULL) { deflateEnd (dest); return Z_MEM_ERROR; } /* following zmemcpy do not work for 16-bit MSDOS */ zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; ds->l_desc.dyn_tree = ds->dyn_ltree; ds->d_desc.dyn_tree = ds->dyn_dtree; ds->bl_desc.dyn_tree = ds->bl_tree; return Z_OK; #endif /* MAXSEG_64K */ } /* =========================================================================== * Read a new buffer from the current input stream, update the adler32 * and total number of bytes read. All deflate() input goes through * this function so some applications may wish to modify it to avoid * allocating a large strm->next_in buffer and copying from it. * (See also flush_pending()). */ local int read_buf(strm, buf, size) z_streamp strm; Bytef *buf; unsigned size; { unsigned len = strm->avail_in; if (len > size) len = size; if (len == 0) return 0; strm->avail_in -= len; if (strm->state->wrap == 1) { strm->adler = adler32(strm->adler, strm->next_in, len); } #ifdef GZIP else if (strm->state->wrap == 2) { strm->adler = crc32(strm->adler, strm->next_in, len); } #endif zmemcpy(buf, strm->next_in, len); strm->next_in += len; strm->total_in += len; return (int)len; } /* =========================================================================== * Initialize the "longest match" routines for a new zlib stream */ local void lm_init (s) deflate_state *s; { s->window_size = (ulg)2L*s->w_size; CLEAR_HASH(s); /* Set the default configuration parameters: */ s->max_lazy_match = configuration_table[s->level].max_lazy; s->good_match = configuration_table[s->level].good_length; s->nice_match = configuration_table[s->level].nice_length; s->max_chain_length = configuration_table[s->level].max_chain; s->strstart = 0; s->block_start = 0L; s->lookahead = 0; s->match_length = s->prev_length = MIN_MATCH-1; s->match_available = 0; s->ins_h = 0; #ifndef FASTEST #ifdef ASMV match_init(); /* initialize the asm code */ #endif #endif } #ifndef FASTEST /* =========================================================================== * Set match_start to the longest match starting at the given string and * return its length. Matches shorter or equal to prev_length are discarded, * in which case the result is equal to prev_length and match_start is * garbage. * IN assertions: cur_match is the head of the hash chain for the current * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 * OUT assertion: the match length is not greater than s->lookahead. */ #ifndef ASMV /* For 80x86 and 680x0, an optimized version will be provided in match.asm or * match.S. The code will be functionally equivalent. */ local uInt longest_match(s, cur_match) deflate_state *s; IPos cur_match; /* current match */ { unsigned chain_length = s->max_chain_length;/* max hash chain length */ register Bytef *scan = s->window + s->strstart; /* current string */ register Bytef *match; /* matched string */ register int len; /* length of current match */ int best_len = s->prev_length; /* best match length so far */ int nice_match = s->nice_match; /* stop if match long enough */ IPos limit = s->strstart > (IPos)MAX_DIST(s) ? s->strstart - (IPos)MAX_DIST(s) : NIL; /* Stop when cur_match becomes <= limit. To simplify the code, * we prevent matches with the string of window index 0. */ Posf *prev = s->prev; uInt wmask = s->w_mask; #ifdef UNALIGNED_OK /* Compare two bytes at a time. Note: this is not always beneficial. * Try with and without -DUNALIGNED_OK to check. */ register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; register ush scan_start = *(ushf*)scan; register ush scan_end = *(ushf*)(scan+best_len-1); #else register Bytef *strend = s->window + s->strstart + MAX_MATCH; register Byte scan_end1 = scan[best_len-1]; register Byte scan_end = scan[best_len]; #endif /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. * It is easy to get rid of this optimization if necessary. */ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); /* Do not waste too much time if we already have a good match: */ if (s->prev_length >= s->good_match) { chain_length >>= 2; } /* Do not look for matches beyond the end of the input. This is necessary * to make deflate deterministic. */ if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); do { Assert(cur_match < s->strstart, "no future"); match = s->window + cur_match; /* Skip to next match if the match length cannot increase * or if the match length is less than 2. Note that the checks below * for insufficient lookahead only occur occasionally for performance * reasons. Therefore uninitialized memory will be accessed, and * conditional jumps will be made that depend on those values. * However the length of the match is limited to the lookahead, so * the output of deflate is not affected by the uninitialized values. */ #if (defined(UNALIGNED_OK) && MAX_MATCH == 258) /* This code assumes sizeof(unsigned short) == 2. Do not use * UNALIGNED_OK if your compiler uses a different size. */ if (*(ushf*)(match+best_len-1) != scan_end || *(ushf*)match != scan_start) continue; /* It is not necessary to compare scan[2] and match[2] since they are * always equal when the other bytes match, given that the hash keys * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at * strstart+3, +5, ... up to strstart+257. We check for insufficient * lookahead only every 4th comparison; the 128th check will be made * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is * necessary to put more guard bytes at the end of the window, or * to check more often for insufficient lookahead. */ Assert(scan[2] == match[2], "scan[2]?"); scan++, match++; do { } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan+=2) == *(ushf*)(match+=2) && scan < strend); /* The funny "do {}" generates better code on most compilers */ /* Here, scan <= window+strstart+257 */ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); if (*scan == *match) scan++; len = (MAX_MATCH - 1) - (int)(strend-scan); scan = strend - (MAX_MATCH-1); #else /* UNALIGNED_OK */ if (match[best_len] != scan_end || match[best_len-1] != scan_end1 || *match != *scan || *++match != scan[1]) continue; /* The check at best_len-1 can be removed because it will be made * again later. (This heuristic is not always a win.) * It is not necessary to compare scan[2] and match[2] since they * are always equal when the other bytes match, given that * the hash keys are equal and that HASH_BITS >= 8. */ scan += 2, match++; Assert(*scan == *match, "match[2]?"); /* We check for insufficient lookahead only every 8th comparison; * the 256th check will be made at strstart+258. */ do { } while (*++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && scan < strend); Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); len = MAX_MATCH - (int)(strend - scan); scan = strend - MAX_MATCH; #endif /* UNALIGNED_OK */ if (len > best_len) { s->match_start = cur_match; best_len = len; if (len >= nice_match) break; #ifdef UNALIGNED_OK scan_end = *(ushf*)(scan+best_len-1); #else scan_end1 = scan[best_len-1]; scan_end = scan[best_len]; #endif } } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length != 0); if ((uInt)best_len <= s->lookahead) return (uInt)best_len; return s->lookahead; } #endif /* ASMV */ #else /* FASTEST */ /* --------------------------------------------------------------------------- * Optimized version for FASTEST only */ local uInt longest_match(s, cur_match) deflate_state *s; IPos cur_match; /* current match */ { register Bytef *scan = s->window + s->strstart; /* current string */ register Bytef *match; /* matched string */ register int len; /* length of current match */ register Bytef *strend = s->window + s->strstart + MAX_MATCH; /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. * It is easy to get rid of this optimization if necessary. */ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); Assert(cur_match < s->strstart, "no future"); match = s->window + cur_match; /* Return failure if the match length is less than 2: */ if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; /* The check at best_len-1 can be removed because it will be made * again later. (This heuristic is not always a win.) * It is not necessary to compare scan[2] and match[2] since they * are always equal when the other bytes match, given that * the hash keys are equal and that HASH_BITS >= 8. */ scan += 2, match += 2; Assert(*scan == *match, "match[2]?"); /* We check for insufficient lookahead only every 8th comparison; * the 256th check will be made at strstart+258. */ do { } while (*++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && scan < strend); Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); len = MAX_MATCH - (int)(strend - scan); if (len < MIN_MATCH) return MIN_MATCH - 1; s->match_start = cur_match; return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; } #endif /* FASTEST */ #ifdef DEBUG /* =========================================================================== * Check that the match at match_start is indeed a match. */ local void check_match(s, start, match, length) deflate_state *s; IPos start, match; int length; { /* check that the match is indeed a match */ if (zmemcmp(s->window + match, s->window + start, length) != EQUAL) { fprintf(stderr, " start %u, match %u, length %d\n", start, match, length); do { fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); } while (--length != 0); z_error("invalid match"); } if (z_verbose > 1) { fprintf(stderr,"\\[%d,%d]", start-match, length); do { putc(s->window[start++], stderr); } while (--length != 0); } } #else # define check_match(s, start, match, length) #endif /* DEBUG */ /* =========================================================================== * Fill the window when the lookahead becomes insufficient. * Updates strstart and lookahead. * * IN assertion: lookahead < MIN_LOOKAHEAD * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD * At least one byte has been read, or avail_in == 0; reads are * performed for at least two bytes (required for the zip translate_eol * option -- not supported here). */ local void fill_window(s) deflate_state *s; { register unsigned n, m; register Posf *p; unsigned more; /* Amount of free space at the end of the window. */ uInt wsize = s->w_size; do { more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); /* Deal with !@#$% 64K limit: */ if (sizeof(int) <= 2) { if (more == 0 && s->strstart == 0 && s->lookahead == 0) { more = wsize; } else if (more == (unsigned)(-1)) { /* Very unlikely, but possible on 16 bit machine if * strstart == 0 && lookahead == 1 (input done a byte at time) */ more--; } } /* If the window is almost full and there is insufficient lookahead, * move the upper half to the lower one to make room in the upper half. */ if (s->strstart >= wsize+MAX_DIST(s)) { zmemcpy(s->window, s->window+wsize, (unsigned)wsize); s->match_start -= wsize; s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ s->block_start -= (long) wsize; /* Slide the hash table (could be avoided with 32 bit values at the expense of memory usage). We slide even when level == 0 to keep the hash table consistent if we switch back to level > 0 later. (Using level 0 permanently is not an optimal usage of zlib, so we don't care about this pathological case.) */ n = s->hash_size; p = &s->head[n]; do { m = *--p; *p = (Pos)(m >= wsize ? m-wsize : NIL); } while (--n); n = wsize; #ifndef FASTEST p = &s->prev[n]; do { m = *--p; *p = (Pos)(m >= wsize ? m-wsize : NIL); /* If n is not on any hash chain, prev[n] is garbage but * its value will never be used. */ } while (--n); #endif more += wsize; } if (s->strm->avail_in == 0) return; /* If there was no sliding: * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && * more == window_size - lookahead - strstart * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) * => more >= window_size - 2*WSIZE + 2 * In the BIG_MEM or MMAP case (not yet supported), * window_size == input_size + MIN_LOOKAHEAD && * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. * Otherwise, window_size == 2*WSIZE so more >= 2. * If there was sliding, more >= WSIZE. So in all cases, more >= 2. */ Assert(more >= 2, "more < 2"); n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); s->lookahead += n; /* Initialize the hash value now that we have some input: */ if (s->lookahead >= MIN_MATCH) { s->ins_h = s->window[s->strstart]; UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); #if MIN_MATCH != 3 Call UPDATE_HASH() MIN_MATCH-3 more times #endif } /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, * but this is not important since only literal bytes will be emitted. */ } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); /* If the WIN_INIT bytes after the end of the current data have never been * written, then zero those bytes in order to avoid memory check reports of * the use of uninitialized (or uninitialised as Julian writes) bytes by * the longest match routines. Update the high water mark for the next * time through here. WIN_INIT is set to MAX_MATCH since the longest match * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. */ if (s->high_water < s->window_size) { ulg curr = s->strstart + (ulg)(s->lookahead); ulg init; if (s->high_water < curr) { /* Previous high water mark below current data -- zero WIN_INIT * bytes or up to end of window, whichever is less. */ init = s->window_size - curr; if (init > WIN_INIT) init = WIN_INIT; zmemzero(s->window + curr, (unsigned)init); s->high_water = curr + init; } else if (s->high_water < (ulg)curr + WIN_INIT) { /* High water mark at or above current data, but below current data * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up * to end of window, whichever is less. */ init = (ulg)curr + WIN_INIT - s->high_water; if (init > s->window_size - s->high_water) init = s->window_size - s->high_water; zmemzero(s->window + s->high_water, (unsigned)init); s->high_water += init; } } } /* =========================================================================== * Flush the current block, with given end-of-file flag. * IN assertion: strstart is set to the end of the current match. */ #define FLUSH_BLOCK_ONLY(s, last) { \ _tr_flush_block(s, (s->block_start >= 0L ? \ (charf *)&s->window[(unsigned)s->block_start] : \ (charf *)Z_NULL), \ (ulg)((long)s->strstart - s->block_start), \ (last)); \ s->block_start = s->strstart; \ flush_pending(s->strm); \ Tracev((stderr,"[FLUSH]")); \ } /* Same but force premature exit if necessary. */ #define FLUSH_BLOCK(s, last) { \ FLUSH_BLOCK_ONLY(s, last); \ if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ } /* =========================================================================== * Copy without compression as much as possible from the input stream, return * the current block state. * This function does not insert new strings in the dictionary since * uncompressible data is probably not useful. This function is used * only for the level=0 compression option. * NOTE: this function should be optimized to avoid extra copying from * window to pending_buf. */ local block_state deflate_stored(s, flush) deflate_state *s; int flush; { /* Stored blocks are limited to 0xffff bytes, pending_buf is limited * to pending_buf_size, and each stored block has a 5 byte header: */ ulg max_block_size = 0xffff; ulg max_start; if (max_block_size > s->pending_buf_size - 5) { max_block_size = s->pending_buf_size - 5; } /* Copy as much as possible from input to output: */ for (;;) { /* Fill the window as much as possible: */ if (s->lookahead <= 1) { Assert(s->strstart < s->w_size+MAX_DIST(s) || s->block_start >= (long)s->w_size, "slide too late"); fill_window(s); if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; if (s->lookahead == 0) break; /* flush the current block */ } Assert(s->block_start >= 0L, "block gone"); s->strstart += s->lookahead; s->lookahead = 0; /* Emit a stored block if pending_buf will be full: */ max_start = s->block_start + max_block_size; if (s->strstart == 0 || (ulg)s->strstart >= max_start) { /* strstart == 0 is possible when wraparound on 16-bit machine */ s->lookahead = (uInt)(s->strstart - max_start); s->strstart = (uInt)max_start; FLUSH_BLOCK(s, 0); } /* Flush if we may have to slide, otherwise block_start may become * negative and the data will be gone: */ if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { FLUSH_BLOCK(s, 0); } } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } /* =========================================================================== * Compress as much as possible from the input stream, return the current * block state. * This function does not perform lazy evaluation of matches and inserts * new strings in the dictionary only for unmatched strings or for short * matches. It is used only for the fast compression options. */ local block_state deflate_fast(s, flush) deflate_state *s; int flush; { IPos hash_head; /* head of the hash chain */ int bflush; /* set if current block must be flushed */ for (;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the next match, plus MIN_MATCH bytes to insert the * string following the next match. */ if (s->lookahead < MIN_LOOKAHEAD) { fill_window(s); if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { return need_more; } if (s->lookahead == 0) break; /* flush the current block */ } /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ hash_head = NIL; if (s->lookahead >= MIN_MATCH) { INSERT_STRING(s, s->strstart, hash_head); } /* Find the longest match, discarding those <= prev_length. * At this point we have always match_length < MIN_MATCH */ if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ s->match_length = longest_match (s, hash_head); /* longest_match() sets match_start */ } if (s->match_length >= MIN_MATCH) { check_match(s, s->strstart, s->match_start, s->match_length); _tr_tally_dist(s, s->strstart - s->match_start, s->match_length - MIN_MATCH, bflush); s->lookahead -= s->match_length; /* Insert new strings in the hash table only if the match length * is not too large. This saves time but degrades compression. */ #ifndef FASTEST if (s->match_length <= s->max_insert_length && s->lookahead >= MIN_MATCH) { s->match_length--; /* string at strstart already in table */ do { s->strstart++; INSERT_STRING(s, s->strstart, hash_head); /* strstart never exceeds WSIZE-MAX_MATCH, so there are * always MIN_MATCH bytes ahead. */ } while (--s->match_length != 0); s->strstart++; } else #endif { s->strstart += s->match_length; s->match_length = 0; s->ins_h = s->window[s->strstart]; UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); #if MIN_MATCH != 3 Call UPDATE_HASH() MIN_MATCH-3 more times #endif /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not * matter since it will be recomputed at next deflate call. */ } } else { /* No match, output a literal byte */ Tracevv((stderr,"%c", s->window[s->strstart])); _tr_tally_lit (s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; } if (bflush) FLUSH_BLOCK(s, 0); } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } #ifndef FASTEST /* =========================================================================== * Same as above, but achieves better compression. We use a lazy * evaluation for matches: a match is finally adopted only if there is * no better match at the next window position. */ local block_state deflate_slow(s, flush) deflate_state *s; int flush; { IPos hash_head; /* head of hash chain */ int bflush; /* set if current block must be flushed */ /* Process the input block. */ for (;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the next match, plus MIN_MATCH bytes to insert the * string following the next match. */ if (s->lookahead < MIN_LOOKAHEAD) { fill_window(s); if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { return need_more; } if (s->lookahead == 0) break; /* flush the current block */ } /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ hash_head = NIL; if (s->lookahead >= MIN_MATCH) { INSERT_STRING(s, s->strstart, hash_head); } /* Find the longest match, discarding those <= prev_length. */ s->prev_length = s->match_length, s->prev_match = s->match_start; s->match_length = MIN_MATCH-1; if (hash_head != NIL && s->prev_length < s->max_lazy_match && s->strstart - hash_head <= MAX_DIST(s)) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ s->match_length = longest_match (s, hash_head); /* longest_match() sets match_start */ if (s->match_length <= 5 && (s->strategy == Z_FILTERED #if TOO_FAR <= 32767 || (s->match_length == MIN_MATCH && s->strstart - s->match_start > TOO_FAR) #endif )) { /* If prev_match is also MIN_MATCH, match_start is garbage * but we will ignore the current match anyway. */ s->match_length = MIN_MATCH-1; } } /* If there was a match at the previous step and the current * match is not better, output the previous match: */ if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; /* Do not insert strings in hash table beyond this. */ check_match(s, s->strstart-1, s->prev_match, s->prev_length); _tr_tally_dist(s, s->strstart -1 - s->prev_match, s->prev_length - MIN_MATCH, bflush); /* Insert in hash table all strings up to the end of the match. * strstart-1 and strstart are already inserted. If there is not * enough lookahead, the last two strings are not inserted in * the hash table. */ s->lookahead -= s->prev_length-1; s->prev_length -= 2; do { if (++s->strstart <= max_insert) { INSERT_STRING(s, s->strstart, hash_head); } } while (--s->prev_length != 0); s->match_available = 0; s->match_length = MIN_MATCH-1; s->strstart++; if (bflush) FLUSH_BLOCK(s, 0); } else if (s->match_available) { /* If there was no match at the previous position, output a * single literal. If there was a match but the current match * is longer, truncate the previous match to a single literal. */ Tracevv((stderr,"%c", s->window[s->strstart-1])); _tr_tally_lit(s, s->window[s->strstart-1], bflush); if (bflush) { FLUSH_BLOCK_ONLY(s, 0); } s->strstart++; s->lookahead--; if (s->strm->avail_out == 0) return need_more; } else { /* There is no previous match to compare with, wait for * the next step to decide. */ s->match_available = 1; s->strstart++; s->lookahead--; } } Assert (flush != Z_NO_FLUSH, "no flush?"); if (s->match_available) { Tracevv((stderr,"%c", s->window[s->strstart-1])); _tr_tally_lit(s, s->window[s->strstart-1], bflush); s->match_available = 0; } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } #endif /* FASTEST */ /* =========================================================================== * For Z_RLE, simply look for runs of bytes, generate matches only of distance * one. Do not maintain a hash table. (It will be regenerated if this run of * deflate switches away from Z_RLE.) */ local block_state deflate_rle(s, flush) deflate_state *s; int flush; { int bflush; /* set if current block must be flushed */ uInt prev; /* byte at distance one to match */ Bytef *scan, *strend; /* scan goes up to strend for length of run */ for (;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the longest encodable run. */ if (s->lookahead < MAX_MATCH) { fill_window(s); if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { return need_more; } if (s->lookahead == 0) break; /* flush the current block */ } /* See how many times the previous byte repeats */ s->match_length = 0; if (s->lookahead >= MIN_MATCH && s->strstart > 0) { scan = s->window + s->strstart - 1; prev = *scan; if (prev == *++scan && prev == *++scan && prev == *++scan) { strend = s->window + s->strstart + MAX_MATCH; do { } while (prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && scan < strend); s->match_length = MAX_MATCH - (int)(strend - scan); if (s->match_length > s->lookahead) s->match_length = s->lookahead; } } /* Emit match if have run of MIN_MATCH or longer, else emit literal */ if (s->match_length >= MIN_MATCH) { check_match(s, s->strstart, s->strstart - 1, s->match_length); _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); s->lookahead -= s->match_length; s->strstart += s->match_length; s->match_length = 0; } else { /* No match, output a literal byte */ Tracevv((stderr,"%c", s->window[s->strstart])); _tr_tally_lit (s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; } if (bflush) FLUSH_BLOCK(s, 0); } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } /* =========================================================================== * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. * (It will be regenerated if this run of deflate switches away from Huffman.) */ local block_state deflate_huff(s, flush) deflate_state *s; int flush; { int bflush; /* set if current block must be flushed */ for (;;) { /* Make sure that we have a literal to write. */ if (s->lookahead == 0) { fill_window(s); if (s->lookahead == 0) { if (flush == Z_NO_FLUSH) return need_more; break; /* flush the current block */ } } /* Output a literal byte */ s->match_length = 0; Tracevv((stderr,"%c", s->window[s->strstart])); _tr_tally_lit (s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; if (bflush) FLUSH_BLOCK(s, 0); } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } healpy-1.10.3/cfitsio/zlib/deflate.h0000664000175000017500000003055713010375005017507 0ustar zoncazonca00000000000000/* deflate.h -- internal compression state * Copyright (C) 1995-2010 Jean-loup Gailly * For conditions of distribution and use, see copyright notice in zlib.h */ /* WARNING: this file should *not* be used by applications. It is part of the implementation of the compression library and is subject to change. Applications should only use zlib.h. */ #ifndef DEFLATE_H #define DEFLATE_H #include "zutil.h" /* define NO_GZIP when compiling if you want to disable gzip header and trailer creation by deflate(). NO_GZIP would be used to avoid linking in the crc code when it is not needed. For shared libraries, gzip encoding should be left enabled. */ #ifndef NO_GZIP # define GZIP #endif /* =========================================================================== * Internal compression state. */ #define LENGTH_CODES 29 /* number of length codes, not counting the special END_BLOCK code */ #define LITERALS 256 /* number of literal bytes 0..255 */ #define L_CODES (LITERALS+1+LENGTH_CODES) /* number of Literal or Length codes, including the END_BLOCK code */ #define D_CODES 30 /* number of distance codes */ #define BL_CODES 19 /* number of codes used to transfer the bit lengths */ #define HEAP_SIZE (2*L_CODES+1) /* maximum heap size */ #define MAX_BITS 15 /* All codes must not exceed MAX_BITS bits */ #define INIT_STATE 42 #define EXTRA_STATE 69 #define NAME_STATE 73 #define COMMENT_STATE 91 #define HCRC_STATE 103 #define BUSY_STATE 113 #define FINISH_STATE 666 /* Stream status */ /* Data structure describing a single value and its code string. */ typedef struct ct_data_s { union { ush freq; /* frequency count */ ush code; /* bit string */ } fc; union { ush dad; /* father node in Huffman tree */ ush len; /* length of bit string */ } dl; } FAR ct_data; #define Freq fc.freq #define Code fc.code #define Dad dl.dad #define Len dl.len typedef struct static_tree_desc_s static_tree_desc; typedef struct tree_desc_s { ct_data *dyn_tree; /* the dynamic tree */ int max_code; /* largest code with non zero frequency */ static_tree_desc *stat_desc; /* the corresponding static tree */ } FAR tree_desc; typedef ush Pos; typedef Pos FAR Posf; typedef unsigned IPos; /* A Pos is an index in the character window. We use short instead of int to * save space in the various tables. IPos is used only for parameter passing. */ typedef struct internal_state { z_streamp strm; /* pointer back to this zlib stream */ int status; /* as the name implies */ Bytef *pending_buf; /* output still pending */ ulg pending_buf_size; /* size of pending_buf */ Bytef *pending_out; /* next pending byte to output to the stream */ uInt pending; /* nb of bytes in the pending buffer */ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ gz_headerp gzhead; /* gzip header information to write */ uInt gzindex; /* where in extra, name, or comment */ Byte method; /* STORED (for zip only) or DEFLATED */ int last_flush; /* value of flush param for previous deflate call */ /* used by deflate.c: */ uInt w_size; /* LZ77 window size (32K by default) */ uInt w_bits; /* log2(w_size) (8..16) */ uInt w_mask; /* w_size - 1 */ Bytef *window; /* Sliding window. Input bytes are read into the second half of the window, * and move to the first half later to keep a dictionary of at least wSize * bytes. With this organization, matches are limited to a distance of * wSize-MAX_MATCH bytes, but this ensures that IO is always * performed with a length multiple of the block size. Also, it limits * the window size to 64K, which is quite useful on MSDOS. * To do: use the user input buffer as sliding window. */ ulg window_size; /* Actual size of window: 2*wSize, except when the user input buffer * is directly used as sliding window. */ Posf *prev; /* Link to older string with same hash index. To limit the size of this * array to 64K, this link is maintained only for the last 32K strings. * An index in this array is thus a window index modulo 32K. */ Posf *head; /* Heads of the hash chains or NIL. */ uInt ins_h; /* hash index of string to be inserted */ uInt hash_size; /* number of elements in hash table */ uInt hash_bits; /* log2(hash_size) */ uInt hash_mask; /* hash_size-1 */ uInt hash_shift; /* Number of bits by which ins_h must be shifted at each input * step. It must be such that after MIN_MATCH steps, the oldest * byte no longer takes part in the hash key, that is: * hash_shift * MIN_MATCH >= hash_bits */ long block_start; /* Window position at the beginning of the current output block. Gets * negative when the window is moved backwards. */ uInt match_length; /* length of best match */ IPos prev_match; /* previous match */ int match_available; /* set if previous match exists */ uInt strstart; /* start of string to insert */ uInt match_start; /* start of matching string */ uInt lookahead; /* number of valid bytes ahead in window */ uInt prev_length; /* Length of the best match at previous step. Matches not greater than this * are discarded. This is used in the lazy match evaluation. */ uInt max_chain_length; /* To speed up deflation, hash chains are never searched beyond this * length. A higher limit improves compression ratio but degrades the * speed. */ uInt max_lazy_match; /* Attempt to find a better match only when the current match is strictly * smaller than this value. This mechanism is used only for compression * levels >= 4. */ # define max_insert_length max_lazy_match /* Insert new strings in the hash table only if the match length is not * greater than this length. This saves time but degrades compression. * max_insert_length is used only for compression levels <= 3. */ int level; /* compression level (1..9) */ int strategy; /* favor or force Huffman coding*/ uInt good_match; /* Use a faster search when the previous match is longer than this */ int nice_match; /* Stop searching when current match exceeds this */ /* used by trees.c: */ /* Didn't use ct_data typedef below to supress compiler warning */ struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ struct tree_desc_s l_desc; /* desc. for literal tree */ struct tree_desc_s d_desc; /* desc. for distance tree */ struct tree_desc_s bl_desc; /* desc. for bit length tree */ ush bl_count[MAX_BITS+1]; /* number of codes at each bit length for an optimal tree */ int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ int heap_len; /* number of elements in the heap */ int heap_max; /* element of largest frequency */ /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. * The same heap array is used to build all trees. */ uch depth[2*L_CODES+1]; /* Depth of each subtree used as tie breaker for trees of equal frequency */ uchf *l_buf; /* buffer for literals or lengths */ uInt lit_bufsize; /* Size of match buffer for literals/lengths. There are 4 reasons for * limiting lit_bufsize to 64K: * - frequencies can be kept in 16 bit counters * - if compression is not successful for the first block, all input * data is still in the window so we can still emit a stored block even * when input comes from standard input. (This can also be done for * all blocks if lit_bufsize is not greater than 32K.) * - if compression is not successful for a file smaller than 64K, we can * even emit a stored file instead of a stored block (saving 5 bytes). * This is applicable only for zip (not gzip or zlib). * - creating new Huffman trees less frequently may not provide fast * adaptation to changes in the input data statistics. (Take for * example a binary file with poorly compressible code followed by * a highly compressible string table.) Smaller buffer sizes give * fast adaptation but have of course the overhead of transmitting * trees more frequently. * - I can't count above 4 */ uInt last_lit; /* running index in l_buf */ ushf *d_buf; /* Buffer for distances. To simplify the code, d_buf and l_buf have * the same number of elements. To use different lengths, an extra flag * array would be necessary. */ ulg opt_len; /* bit length of current block with optimal trees */ ulg static_len; /* bit length of current block with static trees */ uInt matches; /* number of string matches in current block */ int last_eob_len; /* bit length of EOB code for last block */ #ifdef DEBUG ulg compressed_len; /* total bit length of compressed file mod 2^32 */ ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ #endif ush bi_buf; /* Output buffer. bits are inserted starting at the bottom (least * significant bits). */ int bi_valid; /* Number of valid bits in bi_buf. All bits above the last valid bit * are always zero. */ ulg high_water; /* High water mark offset in window for initialized bytes -- bytes above * this are set to zero in order to avoid memory check warnings when * longest match routines access bytes past the input. This is then * updated to the new high water mark. */ } FAR deflate_state; /* Output a byte on the stream. * IN assertion: there is enough room in pending_buf. */ #define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) /* Minimum amount of lookahead, except at the end of the input file. * See deflate.c for comments about the MIN_MATCH+1. */ #define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) /* In order to simplify the code, particularly on 16 bit machines, match * distances are limited to MAX_DIST instead of WSIZE. */ #define WIN_INIT MAX_MATCH /* Number of bytes after end of data in window to initialize in order to avoid memory checker errors from longest match routines */ /* in trees.c */ void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, int last)); void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, int last)); #define d_code(dist) \ ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) /* Mapping from a distance to a distance code. dist is the distance - 1 and * must not have side effects. _dist_code[256] and _dist_code[257] are never * used. */ #ifndef DEBUG /* Inline versions of _tr_tally for speed: */ #if defined(GEN_TREES_H) || !defined(STDC) extern uch ZLIB_INTERNAL _length_code[]; extern uch ZLIB_INTERNAL _dist_code[]; #else extern const uch ZLIB_INTERNAL _length_code[]; extern const uch ZLIB_INTERNAL _dist_code[]; #endif # define _tr_tally_lit(s, c, flush) \ { uch cc = (c); \ s->d_buf[s->last_lit] = 0; \ s->l_buf[s->last_lit++] = cc; \ s->dyn_ltree[cc].Freq++; \ flush = (s->last_lit == s->lit_bufsize-1); \ } # define _tr_tally_dist(s, distance, length, flush) \ { uch len = (length); \ ush dist = (distance); \ s->d_buf[s->last_lit] = dist; \ s->l_buf[s->last_lit++] = len; \ dist--; \ s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ s->dyn_dtree[d_code(dist)].Freq++; \ flush = (s->last_lit == s->lit_bufsize-1); \ } #else # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) # define _tr_tally_dist(s, distance, length, flush) \ flush = _tr_tally(s, distance, length) #endif #endif /* DEFLATE_H */ healpy-1.10.3/cfitsio/zlib/infback.c0000664000175000017500000005413613010375005017472 0ustar zoncazonca00000000000000/* infback.c -- inflate using a call-back interface * Copyright (C) 1995-2009 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ /* This code is largely copied from inflate.c. Normally either infback.o or inflate.o would be linked into an application--not both. The interface with inffast.c is retained so that optimized assembler-coded versions of inflate_fast() can be used with either inflate.c or infback.c. */ #include "zutil.h" #include "inftrees.h" #include "inflate.h" #include "inffast.h" /* function prototypes */ local void fixedtables OF((struct inflate_state FAR *state)); /* strm provides memory allocation functions in zalloc and zfree, or Z_NULL to use the library memory allocation functions. windowBits is in the range 8..15, and window is a user-supplied window and output buffer that is 2**windowBits bytes. */ int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) z_streamp strm; int windowBits; unsigned char FAR *window; const char *version; int stream_size; { struct inflate_state FAR *state; if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || stream_size != (int)(sizeof(z_stream))) return Z_VERSION_ERROR; if (strm == Z_NULL || window == Z_NULL || windowBits < 8 || windowBits > 15) return Z_STREAM_ERROR; strm->msg = Z_NULL; /* in case we return an error */ if (strm->zalloc == (alloc_func)0) { strm->zalloc = zcalloc; strm->opaque = (voidpf)0; } if (strm->zfree == (free_func)0) strm->zfree = zcfree; state = (struct inflate_state FAR *)ZALLOC(strm, 1, sizeof(struct inflate_state)); if (state == Z_NULL) return Z_MEM_ERROR; Tracev((stderr, "inflate: allocated\n")); strm->state = (struct internal_state FAR *)state; state->dmax = 32768U; state->wbits = windowBits; state->wsize = 1U << windowBits; state->window = window; state->wnext = 0; state->whave = 0; return Z_OK; } /* Return state with length and distance decoding tables and index sizes set to fixed code decoding. Normally this returns fixed tables from inffixed.h. If BUILDFIXED is defined, then instead this routine builds the tables the first time it's called, and returns those tables the first time and thereafter. This reduces the size of the code by about 2K bytes, in exchange for a little execution time. However, BUILDFIXED should not be used for threaded applications, since the rewriting of the tables and virgin may not be thread-safe. */ local void fixedtables(state) struct inflate_state FAR *state; { #ifdef BUILDFIXED static int virgin = 1; static code *lenfix, *distfix; static code fixed[544]; /* build fixed huffman tables if first call (may not be thread safe) */ if (virgin) { unsigned sym, bits; static code *next; /* literal/length table */ sym = 0; while (sym < 144) state->lens[sym++] = 8; while (sym < 256) state->lens[sym++] = 9; while (sym < 280) state->lens[sym++] = 7; while (sym < 288) state->lens[sym++] = 8; next = fixed; lenfix = next; bits = 9; inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); /* distance table */ sym = 0; while (sym < 32) state->lens[sym++] = 5; distfix = next; bits = 5; inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); /* do this just once */ virgin = 0; } #else /* !BUILDFIXED */ # include "inffixed.h" #endif /* BUILDFIXED */ state->lencode = lenfix; state->lenbits = 9; state->distcode = distfix; state->distbits = 5; } /* Macros for inflateBack(): */ /* Load returned state from inflate_fast() */ #define LOAD() \ do { \ put = strm->next_out; \ left = strm->avail_out; \ next = strm->next_in; \ have = strm->avail_in; \ hold = state->hold; \ bits = state->bits; \ } while (0) /* Set state from registers for inflate_fast() */ #define RESTORE() \ do { \ strm->next_out = put; \ strm->avail_out = left; \ strm->next_in = next; \ strm->avail_in = have; \ state->hold = hold; \ state->bits = bits; \ } while (0) /* Clear the input bit accumulator */ #define INITBITS() \ do { \ hold = 0; \ bits = 0; \ } while (0) /* Assure that some input is available. If input is requested, but denied, then return a Z_BUF_ERROR from inflateBack(). */ #define PULL() \ do { \ if (have == 0) { \ have = in(in_desc, &next); \ if (have == 0) { \ next = Z_NULL; \ ret = Z_BUF_ERROR; \ goto inf_leave; \ } \ } \ } while (0) /* Get a byte of input into the bit accumulator, or return from inflateBack() with an error if there is no input available. */ #define PULLBYTE() \ do { \ PULL(); \ have--; \ hold += (unsigned long)(*next++) << bits; \ bits += 8; \ } while (0) /* Assure that there are at least n bits in the bit accumulator. If there is not enough available input to do that, then return from inflateBack() with an error. */ #define NEEDBITS(n) \ do { \ while (bits < (unsigned)(n)) \ PULLBYTE(); \ } while (0) /* Return the low n bits of the bit accumulator (n < 16) */ #define BITS(n) \ ((unsigned)hold & ((1U << (n)) - 1)) /* Remove n bits from the bit accumulator */ #define DROPBITS(n) \ do { \ hold >>= (n); \ bits -= (unsigned)(n); \ } while (0) /* Remove zero to seven bits as needed to go to a byte boundary */ #define BYTEBITS() \ do { \ hold >>= bits & 7; \ bits -= bits & 7; \ } while (0) /* Assure that some output space is available, by writing out the window if it's full. If the write fails, return from inflateBack() with a Z_BUF_ERROR. */ #define ROOM() \ do { \ if (left == 0) { \ put = state->window; \ left = state->wsize; \ state->whave = left; \ if (out(out_desc, put, left)) { \ ret = Z_BUF_ERROR; \ goto inf_leave; \ } \ } \ } while (0) /* strm provides the memory allocation functions and window buffer on input, and provides information on the unused input on return. For Z_DATA_ERROR returns, strm will also provide an error message. in() and out() are the call-back input and output functions. When inflateBack() needs more input, it calls in(). When inflateBack() has filled the window with output, or when it completes with data in the window, it calls out() to write out the data. The application must not change the provided input until in() is called again or inflateBack() returns. The application must not change the window/output buffer until inflateBack() returns. in() and out() are called with a descriptor parameter provided in the inflateBack() call. This parameter can be a structure that provides the information required to do the read or write, as well as accumulated information on the input and output such as totals and check values. in() should return zero on failure. out() should return non-zero on failure. If either in() or out() fails, than inflateBack() returns a Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it was in() or out() that caused in the error. Otherwise, inflateBack() returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format error, or Z_MEM_ERROR if it could not allocate memory for the state. inflateBack() can also return Z_STREAM_ERROR if the input parameters are not correct, i.e. strm is Z_NULL or the state was not initialized. */ int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) z_streamp strm; in_func in; void FAR *in_desc; out_func out; void FAR *out_desc; { struct inflate_state FAR *state; unsigned char FAR *next; /* next input */ unsigned char FAR *put; /* next output */ unsigned have, left; /* available input and output */ unsigned long hold; /* bit buffer */ unsigned bits; /* bits in bit buffer */ unsigned copy; /* number of stored or match bytes to copy */ unsigned char FAR *from; /* where to copy match bytes from */ code here; /* current decoding table entry */ code last; /* parent table entry */ unsigned len; /* length to copy for repeats, bits to drop */ int ret; /* return code */ static const unsigned short order[19] = /* permutation of code lengths */ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; /* Check that the strm exists and that the state was initialized */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; /* Reset the state */ strm->msg = Z_NULL; state->mode = TYPE; state->last = 0; state->whave = 0; next = strm->next_in; have = next != Z_NULL ? strm->avail_in : 0; hold = 0; bits = 0; put = state->window; left = state->wsize; /* Inflate until end of block marked as last */ for (;;) switch (state->mode) { case TYPE: /* determine and dispatch block type */ if (state->last) { BYTEBITS(); state->mode = DONE; break; } NEEDBITS(3); state->last = BITS(1); DROPBITS(1); switch (BITS(2)) { case 0: /* stored block */ Tracev((stderr, "inflate: stored block%s\n", state->last ? " (last)" : "")); state->mode = STORED; break; case 1: /* fixed block */ fixedtables(state); Tracev((stderr, "inflate: fixed codes block%s\n", state->last ? " (last)" : "")); state->mode = LEN; /* decode codes */ break; case 2: /* dynamic block */ Tracev((stderr, "inflate: dynamic codes block%s\n", state->last ? " (last)" : "")); state->mode = TABLE; break; case 3: strm->msg = (char *)"invalid block type"; state->mode = BAD; } DROPBITS(2); break; case STORED: /* get and verify stored block length */ BYTEBITS(); /* go to byte boundary */ NEEDBITS(32); if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { strm->msg = (char *)"invalid stored block lengths"; state->mode = BAD; break; } state->length = (unsigned)hold & 0xffff; Tracev((stderr, "inflate: stored length %u\n", state->length)); INITBITS(); /* copy stored block from input to output */ while (state->length != 0) { copy = state->length; PULL(); ROOM(); if (copy > have) copy = have; if (copy > left) copy = left; zmemcpy(put, next, copy); have -= copy; next += copy; left -= copy; put += copy; state->length -= copy; } Tracev((stderr, "inflate: stored end\n")); state->mode = TYPE; break; case TABLE: /* get dynamic table entries descriptor */ NEEDBITS(14); state->nlen = BITS(5) + 257; DROPBITS(5); state->ndist = BITS(5) + 1; DROPBITS(5); state->ncode = BITS(4) + 4; DROPBITS(4); #ifndef PKZIP_BUG_WORKAROUND if (state->nlen > 286 || state->ndist > 30) { strm->msg = (char *)"too many length or distance symbols"; state->mode = BAD; break; } #endif Tracev((stderr, "inflate: table sizes ok\n")); /* get code length code lengths (not a typo) */ state->have = 0; while (state->have < state->ncode) { NEEDBITS(3); state->lens[order[state->have++]] = (unsigned short)BITS(3); DROPBITS(3); } while (state->have < 19) state->lens[order[state->have++]] = 0; state->next = state->codes; state->lencode = (code const FAR *)(state->next); state->lenbits = 7; ret = inflate_table(CODES, state->lens, 19, &(state->next), &(state->lenbits), state->work); if (ret) { strm->msg = (char *)"invalid code lengths set"; state->mode = BAD; break; } Tracev((stderr, "inflate: code lengths ok\n")); /* get length and distance code code lengths */ state->have = 0; while (state->have < state->nlen + state->ndist) { for (;;) { here = state->lencode[BITS(state->lenbits)]; if ((unsigned)(here.bits) <= bits) break; PULLBYTE(); } if (here.val < 16) { NEEDBITS(here.bits); DROPBITS(here.bits); state->lens[state->have++] = here.val; } else { if (here.val == 16) { NEEDBITS(here.bits + 2); DROPBITS(here.bits); if (state->have == 0) { strm->msg = (char *)"invalid bit length repeat"; state->mode = BAD; break; } len = (unsigned)(state->lens[state->have - 1]); copy = 3 + BITS(2); DROPBITS(2); } else if (here.val == 17) { NEEDBITS(here.bits + 3); DROPBITS(here.bits); len = 0; copy = 3 + BITS(3); DROPBITS(3); } else { NEEDBITS(here.bits + 7); DROPBITS(here.bits); len = 0; copy = 11 + BITS(7); DROPBITS(7); } if (state->have + copy > state->nlen + state->ndist) { strm->msg = (char *)"invalid bit length repeat"; state->mode = BAD; break; } while (copy--) state->lens[state->have++] = (unsigned short)len; } } /* handle error breaks in while */ if (state->mode == BAD) break; /* check for end-of-block code (better have one) */ if (state->lens[256] == 0) { strm->msg = (char *)"invalid code -- missing end-of-block"; state->mode = BAD; break; } /* build code tables -- note: do not change the lenbits or distbits values here (9 and 6) without reading the comments in inftrees.h concerning the ENOUGH constants, which depend on those values */ state->next = state->codes; state->lencode = (code const FAR *)(state->next); state->lenbits = 9; ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), &(state->lenbits), state->work); if (ret) { strm->msg = (char *)"invalid literal/lengths set"; state->mode = BAD; break; } state->distcode = (code const FAR *)(state->next); state->distbits = 6; ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, &(state->next), &(state->distbits), state->work); if (ret) { strm->msg = (char *)"invalid distances set"; state->mode = BAD; break; } Tracev((stderr, "inflate: codes ok\n")); state->mode = LEN; case LEN: /* use inflate_fast() if we have enough input and output */ if (have >= 6 && left >= 258) { RESTORE(); if (state->whave < state->wsize) state->whave = state->wsize - left; inflate_fast(strm, state->wsize); LOAD(); break; } /* get a literal, length, or end-of-block code */ for (;;) { here = state->lencode[BITS(state->lenbits)]; if ((unsigned)(here.bits) <= bits) break; PULLBYTE(); } if (here.op && (here.op & 0xf0) == 0) { last = here; for (;;) { here = state->lencode[last.val + (BITS(last.bits + last.op) >> last.bits)]; if ((unsigned)(last.bits + here.bits) <= bits) break; PULLBYTE(); } DROPBITS(last.bits); } DROPBITS(here.bits); state->length = (unsigned)here.val; /* process literal */ if (here.op == 0) { Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? "inflate: literal '%c'\n" : "inflate: literal 0x%02x\n", here.val)); ROOM(); *put++ = (unsigned char)(state->length); left--; state->mode = LEN; break; } /* process end of block */ if (here.op & 32) { Tracevv((stderr, "inflate: end of block\n")); state->mode = TYPE; break; } /* invalid code */ if (here.op & 64) { strm->msg = (char *)"invalid literal/length code"; state->mode = BAD; break; } /* length code -- get extra bits, if any */ state->extra = (unsigned)(here.op) & 15; if (state->extra != 0) { NEEDBITS(state->extra); state->length += BITS(state->extra); DROPBITS(state->extra); } Tracevv((stderr, "inflate: length %u\n", state->length)); /* get distance code */ for (;;) { here = state->distcode[BITS(state->distbits)]; if ((unsigned)(here.bits) <= bits) break; PULLBYTE(); } if ((here.op & 0xf0) == 0) { last = here; for (;;) { here = state->distcode[last.val + (BITS(last.bits + last.op) >> last.bits)]; if ((unsigned)(last.bits + here.bits) <= bits) break; PULLBYTE(); } DROPBITS(last.bits); } DROPBITS(here.bits); if (here.op & 64) { strm->msg = (char *)"invalid distance code"; state->mode = BAD; break; } state->offset = (unsigned)here.val; /* get distance extra bits, if any */ state->extra = (unsigned)(here.op) & 15; if (state->extra != 0) { NEEDBITS(state->extra); state->offset += BITS(state->extra); DROPBITS(state->extra); } if (state->offset > state->wsize - (state->whave < state->wsize ? left : 0)) { strm->msg = (char *)"invalid distance too far back"; state->mode = BAD; break; } Tracevv((stderr, "inflate: distance %u\n", state->offset)); /* copy match from window to output */ do { ROOM(); copy = state->wsize - state->offset; if (copy < left) { from = put + copy; copy = left - copy; } else { from = put - state->offset; copy = left; } if (copy > state->length) copy = state->length; state->length -= copy; left -= copy; do { *put++ = *from++; } while (--copy); } while (state->length != 0); break; case DONE: /* inflate stream terminated properly -- write leftover output */ ret = Z_STREAM_END; if (left < state->wsize) { if (out(out_desc, state->window, state->wsize - left)) ret = Z_BUF_ERROR; } goto inf_leave; case BAD: ret = Z_DATA_ERROR; goto inf_leave; default: /* can't happen, but makes compilers happy */ ret = Z_STREAM_ERROR; goto inf_leave; } /* Return unused input */ inf_leave: strm->next_in = next; strm->avail_in = have; return ret; } int ZEXPORT inflateBackEnd(strm) z_streamp strm; { if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) return Z_STREAM_ERROR; ZFREE(strm, strm->state); strm->state = Z_NULL; Tracev((stderr, "inflate: end\n")); return Z_OK; } healpy-1.10.3/cfitsio/zlib/inffast.c0000664000175000017500000003217713010375005017530 0ustar zoncazonca00000000000000/* inffast.c -- fast decoding * Copyright (C) 1995-2008, 2010 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ #include "zutil.h" #include "inftrees.h" #include "inflate.h" #include "inffast.h" #ifndef ASMINF /* Allow machine dependent optimization for post-increment or pre-increment. Based on testing to date, Pre-increment preferred for: - PowerPC G3 (Adler) - MIPS R5000 (Randers-Pehrson) Post-increment preferred for: - none No measurable difference: - Pentium III (Anderson) - M68060 (Nikl) */ #ifdef POSTINC # define OFF 0 # define PUP(a) *(a)++ #else # define OFF 1 # define PUP(a) *++(a) #endif /* Decode literal, length, and distance codes and write out the resulting literal and match bytes until either not enough input or output is available, an end-of-block is encountered, or a data error is encountered. When large enough input and output buffers are supplied to inflate(), for example, a 16K input buffer and a 64K output buffer, more than 95% of the inflate execution time is spent in this routine. Entry assumptions: state->mode == LEN strm->avail_in >= 6 strm->avail_out >= 258 start >= strm->avail_out state->bits < 8 On return, state->mode is one of: LEN -- ran out of enough output space or enough available input TYPE -- reached end of block code, inflate() to interpret next block BAD -- error in block data Notes: - The maximum input bits used by a length/distance pair is 15 bits for the length code, 5 bits for the length extra, 15 bits for the distance code, and 13 bits for the distance extra. This totals 48 bits, or six bytes. Therefore if strm->avail_in >= 6, then there is enough input to avoid checking for available input while decoding. - The maximum bytes that a single length/distance pair can output is 258 bytes, which is the maximum length that can be coded. inflate_fast() requires strm->avail_out >= 258 for each loop to avoid checking for output space. */ void ZLIB_INTERNAL inflate_fast(strm, start) z_streamp strm; unsigned start; /* inflate()'s starting value for strm->avail_out */ { struct inflate_state FAR *state; unsigned char FAR *in; /* local strm->next_in */ unsigned char FAR *last; /* while in < last, enough input available */ unsigned char FAR *out; /* local strm->next_out */ unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ unsigned char FAR *end; /* while out < end, enough space available */ #ifdef INFLATE_STRICT unsigned dmax; /* maximum distance from zlib header */ #endif unsigned wsize; /* window size or zero if not using window */ unsigned whave; /* valid bytes in the window */ unsigned wnext; /* window write index */ unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ unsigned long hold; /* local strm->hold */ unsigned bits; /* local strm->bits */ code const FAR *lcode; /* local strm->lencode */ code const FAR *dcode; /* local strm->distcode */ unsigned lmask; /* mask for first level of length codes */ unsigned dmask; /* mask for first level of distance codes */ code here; /* retrieved table entry */ unsigned op; /* code bits, operation, extra bits, or */ /* window position, window bytes to copy */ unsigned len; /* match length, unused bytes */ unsigned dist; /* match distance */ unsigned char FAR *from; /* where to copy match from */ /* copy state to local variables */ state = (struct inflate_state FAR *)strm->state; in = strm->next_in - OFF; last = in + (strm->avail_in - 5); out = strm->next_out - OFF; beg = out - (start - strm->avail_out); end = out + (strm->avail_out - 257); #ifdef INFLATE_STRICT dmax = state->dmax; #endif wsize = state->wsize; whave = state->whave; wnext = state->wnext; window = state->window; hold = state->hold; bits = state->bits; lcode = state->lencode; dcode = state->distcode; lmask = (1U << state->lenbits) - 1; dmask = (1U << state->distbits) - 1; /* decode literals and length/distances until end-of-block or not enough input data or output space */ do { if (bits < 15) { hold += (unsigned long)(PUP(in)) << bits; bits += 8; hold += (unsigned long)(PUP(in)) << bits; bits += 8; } here = lcode[hold & lmask]; dolen: op = (unsigned)(here.bits); hold >>= op; bits -= op; op = (unsigned)(here.op); if (op == 0) { /* literal */ Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? "inflate: literal '%c'\n" : "inflate: literal 0x%02x\n", here.val)); PUP(out) = (unsigned char)(here.val); } else if (op & 16) { /* length base */ len = (unsigned)(here.val); op &= 15; /* number of extra bits */ if (op) { if (bits < op) { hold += (unsigned long)(PUP(in)) << bits; bits += 8; } len += (unsigned)hold & ((1U << op) - 1); hold >>= op; bits -= op; } Tracevv((stderr, "inflate: length %u\n", len)); if (bits < 15) { hold += (unsigned long)(PUP(in)) << bits; bits += 8; hold += (unsigned long)(PUP(in)) << bits; bits += 8; } here = dcode[hold & dmask]; dodist: op = (unsigned)(here.bits); hold >>= op; bits -= op; op = (unsigned)(here.op); if (op & 16) { /* distance base */ dist = (unsigned)(here.val); op &= 15; /* number of extra bits */ if (bits < op) { hold += (unsigned long)(PUP(in)) << bits; bits += 8; if (bits < op) { hold += (unsigned long)(PUP(in)) << bits; bits += 8; } } dist += (unsigned)hold & ((1U << op) - 1); #ifdef INFLATE_STRICT if (dist > dmax) { strm->msg = (char *)"invalid distance too far back"; state->mode = BAD; break; } #endif hold >>= op; bits -= op; Tracevv((stderr, "inflate: distance %u\n", dist)); op = (unsigned)(out - beg); /* max distance in output */ if (dist > op) { /* see if copy from window */ op = dist - op; /* distance back in window */ if (op > whave) { if (state->sane) { strm->msg = (char *)"invalid distance too far back"; state->mode = BAD; break; } #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR if (len <= op - whave) { do { PUP(out) = 0; } while (--len); continue; } len -= op - whave; do { PUP(out) = 0; } while (--op > whave); if (op == 0) { from = out - dist; do { PUP(out) = PUP(from); } while (--len); continue; } #endif } from = window - OFF; if (wnext == 0) { /* very common case */ from += wsize - op; if (op < len) { /* some from window */ len -= op; do { PUP(out) = PUP(from); } while (--op); from = out - dist; /* rest from output */ } } else if (wnext < op) { /* wrap around window */ from += wsize + wnext - op; op -= wnext; if (op < len) { /* some from end of window */ len -= op; do { PUP(out) = PUP(from); } while (--op); from = window - OFF; if (wnext < len) { /* some from start of window */ op = wnext; len -= op; do { PUP(out) = PUP(from); } while (--op); from = out - dist; /* rest from output */ } } } else { /* contiguous in window */ from += wnext - op; if (op < len) { /* some from window */ len -= op; do { PUP(out) = PUP(from); } while (--op); from = out - dist; /* rest from output */ } } while (len > 2) { PUP(out) = PUP(from); PUP(out) = PUP(from); PUP(out) = PUP(from); len -= 3; } if (len) { PUP(out) = PUP(from); if (len > 1) PUP(out) = PUP(from); } } else { from = out - dist; /* copy direct from output */ do { /* minimum length is three */ PUP(out) = PUP(from); PUP(out) = PUP(from); PUP(out) = PUP(from); len -= 3; } while (len > 2); if (len) { PUP(out) = PUP(from); if (len > 1) PUP(out) = PUP(from); } } } else if ((op & 64) == 0) { /* 2nd level distance code */ here = dcode[here.val + (hold & ((1U << op) - 1))]; goto dodist; } else { strm->msg = (char *)"invalid distance code"; state->mode = BAD; break; } } else if ((op & 64) == 0) { /* 2nd level length code */ here = lcode[here.val + (hold & ((1U << op) - 1))]; goto dolen; } else if (op & 32) { /* end-of-block */ Tracevv((stderr, "inflate: end of block\n")); state->mode = TYPE; break; } else { strm->msg = (char *)"invalid literal/length code"; state->mode = BAD; break; } } while (in < last && out < end); /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ len = bits >> 3; in -= len; bits -= len << 3; hold &= (1U << bits) - 1; /* update state and return */ strm->next_in = in + OFF; strm->next_out = out + OFF; strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); strm->avail_out = (unsigned)(out < end ? 257 + (end - out) : 257 - (out - end)); state->hold = hold; state->bits = bits; return; } /* inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): - Using bit fields for code structure - Different op definition to avoid & for extra bits (do & for table bits) - Three separate decoding do-loops for direct, window, and wnext == 0 - Special case for distance > 1 copies to do overlapped load and store copy - Explicit branch predictions (based on measured branch probabilities) - Deferring match copy and interspersed it with decoding subsequent codes - Swapping literal/length else - Swapping window/direct else - Larger unrolled copy loops (three is about right) - Moving len -= 3 statement into middle of loop */ #endif /* !ASMINF */ healpy-1.10.3/cfitsio/zlib/inffast.h0000664000175000017500000000065313010375005017527 0ustar zoncazonca00000000000000/* inffast.h -- header to use inffast.c * Copyright (C) 1995-2003, 2010 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ /* WARNING: this file should *not* be used by applications. It is part of the implementation of the compression library and is subject to change. Applications should only use zlib.h. */ void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); healpy-1.10.3/cfitsio/zlib/inffixed.h0000664000175000017500000001430713010375005017672 0ustar zoncazonca00000000000000 /* inffixed.h -- table for decoding fixed codes * Generated automatically by makefixed(). */ /* WARNING: this file should *not* be used by applications. It is part of the implementation of the compression library and is subject to change. Applications should only use zlib.h. */ static const code lenfix[512] = { {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, {0,9,255} }; static const code distfix[32] = { {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, {22,5,193},{64,5,0} }; healpy-1.10.3/cfitsio/zlib/inflate.c0000664000175000017500000014661713010375005017525 0ustar zoncazonca00000000000000/* inflate.c -- zlib decompression * Copyright (C) 1995-2010 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ /* * Change history: * * 1.2.beta0 24 Nov 2002 * - First version -- complete rewrite of inflate to simplify code, avoid * creation of window when not needed, minimize use of window when it is * needed, make inffast.c even faster, implement gzip decoding, and to * improve code readability and style over the previous zlib inflate code * * 1.2.beta1 25 Nov 2002 * - Use pointers for available input and output checking in inffast.c * - Remove input and output counters in inffast.c * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 * - Remove unnecessary second byte pull from length extra in inffast.c * - Unroll direct copy to three copies per loop in inffast.c * * 1.2.beta2 4 Dec 2002 * - Change external routine names to reduce potential conflicts * - Correct filename to inffixed.h for fixed tables in inflate.c * - Make hbuf[] unsigned char to match parameter type in inflate.c * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) * to avoid negation problem on Alphas (64 bit) in inflate.c * * 1.2.beta3 22 Dec 2002 * - Add comments on state->bits assertion in inffast.c * - Add comments on op field in inftrees.h * - Fix bug in reuse of allocated window after inflateReset() * - Remove bit fields--back to byte structure for speed * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths * - Change post-increments to pre-increments in inflate_fast(), PPC biased? * - Add compile time option, POSTINC, to use post-increments instead (Intel?) * - Make MATCH copy in inflate() much faster for when inflate_fast() not used * - Use local copies of stream next and avail values, as well as local bit * buffer and bit count in inflate()--for speed when inflate_fast() not used * * 1.2.beta4 1 Jan 2003 * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings * - Move a comment on output buffer sizes from inffast.c to inflate.c * - Add comments in inffast.c to introduce the inflate_fast() routine * - Rearrange window copies in inflate_fast() for speed and simplification * - Unroll last copy for window match in inflate_fast() * - Use local copies of window variables in inflate_fast() for speed * - Pull out common wnext == 0 case for speed in inflate_fast() * - Make op and len in inflate_fast() unsigned for consistency * - Add FAR to lcode and dcode declarations in inflate_fast() * - Simplified bad distance check in inflate_fast() * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new * source file infback.c to provide a call-back interface to inflate for * programs like gzip and unzip -- uses window as output buffer to avoid * window copying * * 1.2.beta5 1 Jan 2003 * - Improved inflateBack() interface to allow the caller to provide initial * input in strm. * - Fixed stored blocks bug in inflateBack() * * 1.2.beta6 4 Jan 2003 * - Added comments in inffast.c on effectiveness of POSTINC * - Typecasting all around to reduce compiler warnings * - Changed loops from while (1) or do {} while (1) to for (;;), again to * make compilers happy * - Changed type of window in inflateBackInit() to unsigned char * * * 1.2.beta7 27 Jan 2003 * - Changed many types to unsigned or unsigned short to avoid warnings * - Added inflateCopy() function * * 1.2.0 9 Mar 2003 * - Changed inflateBack() interface to provide separate opaque descriptors * for the in() and out() functions * - Changed inflateBack() argument and in_func typedef to swap the length * and buffer address return values for the input function * - Check next_in and next_out for Z_NULL on entry to inflate() * * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. */ #include "zutil.h" #include "inftrees.h" #include "inflate.h" #include "inffast.h" #ifdef MAKEFIXED # ifndef BUILDFIXED # define BUILDFIXED # endif #endif /* function prototypes */ local void fixedtables OF((struct inflate_state FAR *state)); local int updatewindow OF((z_streamp strm, unsigned out)); #ifdef BUILDFIXED void makefixed OF((void)); #endif local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, unsigned len)); int ZEXPORT inflateReset(strm) z_streamp strm; { struct inflate_state FAR *state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; strm->total_in = strm->total_out = state->total = 0; strm->msg = Z_NULL; strm->adler = 1; /* to support ill-conceived Java test suite */ state->mode = HEAD; state->last = 0; state->havedict = 0; state->dmax = 32768U; state->head = Z_NULL; state->wsize = 0; state->whave = 0; state->wnext = 0; state->hold = 0; state->bits = 0; state->lencode = state->distcode = state->next = state->codes; state->sane = 1; state->back = -1; Tracev((stderr, "inflate: reset\n")); return Z_OK; } int ZEXPORT inflateReset2(strm, windowBits) z_streamp strm; int windowBits; { int wrap; struct inflate_state FAR *state; /* get the state */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; /* extract wrap request from windowBits parameter */ if (windowBits < 0) { wrap = 0; windowBits = -windowBits; } else { wrap = (windowBits >> 4) + 1; #ifdef GUNZIP if (windowBits < 48) windowBits &= 15; #endif } /* set number of window bits, free window if different */ if (windowBits && (windowBits < 8 || windowBits > 15)) return Z_STREAM_ERROR; if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { ZFREE(strm, state->window); state->window = Z_NULL; } /* update state and reset the rest of it */ state->wrap = wrap; state->wbits = (unsigned)windowBits; return inflateReset(strm); } int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) z_streamp strm; int windowBits; const char *version; int stream_size; { int ret; struct inflate_state FAR *state; if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || stream_size != (int)(sizeof(z_stream))) return Z_VERSION_ERROR; if (strm == Z_NULL) return Z_STREAM_ERROR; strm->msg = Z_NULL; /* in case we return an error */ if (strm->zalloc == (alloc_func)0) { strm->zalloc = zcalloc; strm->opaque = (voidpf)0; } if (strm->zfree == (free_func)0) strm->zfree = zcfree; state = (struct inflate_state FAR *) ZALLOC(strm, 1, sizeof(struct inflate_state)); if (state == Z_NULL) return Z_MEM_ERROR; Tracev((stderr, "inflate: allocated\n")); strm->state = (struct internal_state FAR *)state; state->window = Z_NULL; ret = inflateReset2(strm, windowBits); if (ret != Z_OK) { ZFREE(strm, state); strm->state = Z_NULL; } return ret; } int ZEXPORT inflateInit_(strm, version, stream_size) z_streamp strm; const char *version; int stream_size; { return inflateInit2_(strm, DEF_WBITS, version, stream_size); } int ZEXPORT inflatePrime(strm, bits, value) z_streamp strm; int bits; int value; { struct inflate_state FAR *state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; if (bits < 0) { state->hold = 0; state->bits = 0; return Z_OK; } if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; value &= (1L << bits) - 1; state->hold += value << state->bits; state->bits += bits; return Z_OK; } /* Return state with length and distance decoding tables and index sizes set to fixed code decoding. Normally this returns fixed tables from inffixed.h. If BUILDFIXED is defined, then instead this routine builds the tables the first time it's called, and returns those tables the first time and thereafter. This reduces the size of the code by about 2K bytes, in exchange for a little execution time. However, BUILDFIXED should not be used for threaded applications, since the rewriting of the tables and virgin may not be thread-safe. */ local void fixedtables(state) struct inflate_state FAR *state; { #ifdef BUILDFIXED static int virgin = 1; static code *lenfix, *distfix; static code fixed[544]; /* build fixed huffman tables if first call (may not be thread safe) */ if (virgin) { unsigned sym, bits; static code *next; /* literal/length table */ sym = 0; while (sym < 144) state->lens[sym++] = 8; while (sym < 256) state->lens[sym++] = 9; while (sym < 280) state->lens[sym++] = 7; while (sym < 288) state->lens[sym++] = 8; next = fixed; lenfix = next; bits = 9; inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); /* distance table */ sym = 0; while (sym < 32) state->lens[sym++] = 5; distfix = next; bits = 5; inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); /* do this just once */ virgin = 0; } #else /* !BUILDFIXED */ # include "inffixed.h" #endif /* BUILDFIXED */ state->lencode = lenfix; state->lenbits = 9; state->distcode = distfix; state->distbits = 5; } #ifdef MAKEFIXED #include /* Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also defines BUILDFIXED, so the tables are built on the fly. makefixed() writes those tables to stdout, which would be piped to inffixed.h. A small program can simply call makefixed to do this: void makefixed(void); int main(void) { makefixed(); return 0; } Then that can be linked with zlib built with MAKEFIXED defined and run: a.out > inffixed.h */ void makefixed() { unsigned low, size; struct inflate_state state; fixedtables(&state); puts(" /* inffixed.h -- table for decoding fixed codes"); puts(" * Generated automatically by makefixed()."); puts(" */"); puts(""); puts(" /* WARNING: this file should *not* be used by applications."); puts(" It is part of the implementation of this library and is"); puts(" subject to change. Applications should only use zlib.h."); puts(" */"); puts(""); size = 1U << 9; printf(" static const code lenfix[%u] = {", size); low = 0; for (;;) { if ((low % 7) == 0) printf("\n "); printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits, state.lencode[low].val); if (++low == size) break; putchar(','); } puts("\n };"); size = 1U << 5; printf("\n static const code distfix[%u] = {", size); low = 0; for (;;) { if ((low % 6) == 0) printf("\n "); printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, state.distcode[low].val); if (++low == size) break; putchar(','); } puts("\n };"); } #endif /* MAKEFIXED */ /* Update the window with the last wsize (normally 32K) bytes written before returning. If window does not exist yet, create it. This is only called when a window is already in use, or when output has been written during this inflate call, but the end of the deflate stream has not been reached yet. It is also called to create a window for dictionary data when a dictionary is loaded. Providing output buffers larger than 32K to inflate() should provide a speed advantage, since only the last 32K of output is copied to the sliding window upon return from inflate(), and since all distances after the first 32K of output will fall in the output data, making match copies simpler and faster. The advantage may be dependent on the size of the processor's data caches. */ local int updatewindow(strm, out) z_streamp strm; unsigned out; { struct inflate_state FAR *state; unsigned copy, dist; state = (struct inflate_state FAR *)strm->state; /* if it hasn't been done already, allocate space for the window */ if (state->window == Z_NULL) { state->window = (unsigned char FAR *) ZALLOC(strm, 1U << state->wbits, sizeof(unsigned char)); if (state->window == Z_NULL) return 1; } /* if window not in use yet, initialize */ if (state->wsize == 0) { state->wsize = 1U << state->wbits; state->wnext = 0; state->whave = 0; } /* copy state->wsize or less output bytes into the circular window */ copy = out - strm->avail_out; if (copy >= state->wsize) { zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); state->wnext = 0; state->whave = state->wsize; } else { dist = state->wsize - state->wnext; if (dist > copy) dist = copy; zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); copy -= dist; if (copy) { zmemcpy(state->window, strm->next_out - copy, copy); state->wnext = copy; state->whave = state->wsize; } else { state->wnext += dist; if (state->wnext == state->wsize) state->wnext = 0; if (state->whave < state->wsize) state->whave += dist; } } return 0; } /* Macros for inflate(): */ /* check function to use adler32() for zlib or crc32() for gzip */ #ifdef GUNZIP # define UPDATE(check, buf, len) \ (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) #else # define UPDATE(check, buf, len) adler32(check, buf, len) #endif /* check macros for header crc */ #ifdef GUNZIP # define CRC2(check, word) \ do { \ hbuf[0] = (unsigned char)(word); \ hbuf[1] = (unsigned char)((word) >> 8); \ check = crc32(check, hbuf, 2); \ } while (0) # define CRC4(check, word) \ do { \ hbuf[0] = (unsigned char)(word); \ hbuf[1] = (unsigned char)((word) >> 8); \ hbuf[2] = (unsigned char)((word) >> 16); \ hbuf[3] = (unsigned char)((word) >> 24); \ check = crc32(check, hbuf, 4); \ } while (0) #endif /* Load registers with state in inflate() for speed */ #define LOAD() \ do { \ put = strm->next_out; \ left = strm->avail_out; \ next = strm->next_in; \ have = strm->avail_in; \ hold = state->hold; \ bits = state->bits; \ } while (0) /* Restore state from registers in inflate() */ #define RESTORE() \ do { \ strm->next_out = put; \ strm->avail_out = left; \ strm->next_in = next; \ strm->avail_in = have; \ state->hold = hold; \ state->bits = bits; \ } while (0) /* Clear the input bit accumulator */ #define INITBITS() \ do { \ hold = 0; \ bits = 0; \ } while (0) /* Get a byte of input into the bit accumulator, or return from inflate() if there is no input available. */ #define PULLBYTE() \ do { \ if (have == 0) goto inf_leave; \ have--; \ hold += (unsigned long)(*next++) << bits; \ bits += 8; \ } while (0) /* Assure that there are at least n bits in the bit accumulator. If there is not enough available input to do that, then return from inflate(). */ #define NEEDBITS(n) \ do { \ while (bits < (unsigned)(n)) \ PULLBYTE(); \ } while (0) /* Return the low n bits of the bit accumulator (n < 16) */ #define BITS(n) \ ((unsigned)hold & ((1U << (n)) - 1)) /* Remove n bits from the bit accumulator */ #define DROPBITS(n) \ do { \ hold >>= (n); \ bits -= (unsigned)(n); \ } while (0) /* Remove zero to seven bits as needed to go to a byte boundary */ #define BYTEBITS() \ do { \ hold >>= bits & 7; \ bits -= bits & 7; \ } while (0) /* Reverse the bytes in a 32-bit value */ #define REVERSE(q) \ ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) /* inflate() uses a state machine to process as much input data and generate as much output data as possible before returning. The state machine is structured roughly as follows: for (;;) switch (state) { ... case STATEn: if (not enough input data or output space to make progress) return; ... make progress ... state = STATEm; break; ... } so when inflate() is called again, the same case is attempted again, and if the appropriate resources are provided, the machine proceeds to the next state. The NEEDBITS() macro is usually the way the state evaluates whether it can proceed or should return. NEEDBITS() does the return if the requested bits are not available. The typical use of the BITS macros is: NEEDBITS(n); ... do something with BITS(n) ... DROPBITS(n); where NEEDBITS(n) either returns from inflate() if there isn't enough input left to load n bits into the accumulator, or it continues. BITS(n) gives the low n bits in the accumulator. When done, DROPBITS(n) drops the low n bits off the accumulator. INITBITS() clears the accumulator and sets the number of available bits to zero. BYTEBITS() discards just enough bits to put the accumulator on a byte boundary. After BYTEBITS() and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return if there is no input available. The decoding of variable length codes uses PULLBYTE() directly in order to pull just enough bytes to decode the next code, and no more. Some states loop until they get enough input, making sure that enough state information is maintained to continue the loop where it left off if NEEDBITS() returns in the loop. For example, want, need, and keep would all have to actually be part of the saved state in case NEEDBITS() returns: case STATEw: while (want < need) { NEEDBITS(n); keep[want++] = BITS(n); DROPBITS(n); } state = STATEx; case STATEx: As shown above, if the next state is also the next case, then the break is omitted. A state may also return if there is not enough output space available to complete that state. Those states are copying stored data, writing a literal byte, and copying a matching string. When returning, a "goto inf_leave" is used to update the total counters, update the check value, and determine whether any progress has been made during that inflate() call in order to return the proper return code. Progress is defined as a change in either strm->avail_in or strm->avail_out. When there is a window, goto inf_leave will update the window with the last output written. If a goto inf_leave occurs in the middle of decompression and there is no window currently, goto inf_leave will create one and copy output to the window for the next call of inflate(). In this implementation, the flush parameter of inflate() only affects the return code (per zlib.h). inflate() always writes as much as possible to strm->next_out, given the space available and the provided input--the effect documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers the allocation of and copying into a sliding window until necessary, which provides the effect documented in zlib.h for Z_FINISH when the entire input stream available. So the only thing the flush parameter actually does is: when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it will return Z_BUF_ERROR if it has not reached the end of the stream. */ int ZEXPORT inflate(strm, flush) z_streamp strm; int flush; { struct inflate_state FAR *state; unsigned char FAR *next; /* next input */ unsigned char FAR *put; /* next output */ unsigned have, left; /* available input and output */ unsigned long hold; /* bit buffer */ unsigned bits; /* bits in bit buffer */ unsigned in, out; /* save starting available input and output */ unsigned copy; /* number of stored or match bytes to copy */ unsigned char FAR *from; /* where to copy match bytes from */ code here; /* current decoding table entry */ code last; /* parent table entry */ unsigned len; /* length to copy for repeats, bits to drop */ int ret; /* return code */ #ifdef GUNZIP unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ #endif static const unsigned short order[19] = /* permutation of code lengths */ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || (strm->next_in == Z_NULL && strm->avail_in != 0)) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ LOAD(); in = have; out = left; ret = Z_OK; for (;;) switch (state->mode) { case HEAD: if (state->wrap == 0) { state->mode = TYPEDO; break; } NEEDBITS(16); #ifdef GUNZIP if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ state->check = crc32(0L, Z_NULL, 0); CRC2(state->check, hold); INITBITS(); state->mode = FLAGS; break; } state->flags = 0; /* expect zlib header */ if (state->head != Z_NULL) state->head->done = -1; if (!(state->wrap & 1) || /* check if zlib header allowed */ #else if ( #endif ((BITS(8) << 8) + (hold >> 8)) % 31) { strm->msg = (char *)"incorrect header check"; state->mode = BAD; break; } if (BITS(4) != Z_DEFLATED) { strm->msg = (char *)"unknown compression method"; state->mode = BAD; break; } DROPBITS(4); len = BITS(4) + 8; if (state->wbits == 0) state->wbits = len; else if (len > state->wbits) { strm->msg = (char *)"invalid window size"; state->mode = BAD; break; } state->dmax = 1U << len; Tracev((stderr, "inflate: zlib header ok\n")); strm->adler = state->check = adler32(0L, Z_NULL, 0); state->mode = hold & 0x200 ? DICTID : TYPE; INITBITS(); break; #ifdef GUNZIP case FLAGS: NEEDBITS(16); state->flags = (int)(hold); if ((state->flags & 0xff) != Z_DEFLATED) { strm->msg = (char *)"unknown compression method"; state->mode = BAD; break; } if (state->flags & 0xe000) { strm->msg = (char *)"unknown header flags set"; state->mode = BAD; break; } if (state->head != Z_NULL) state->head->text = (int)((hold >> 8) & 1); if (state->flags & 0x0200) CRC2(state->check, hold); INITBITS(); state->mode = TIME; case TIME: NEEDBITS(32); if (state->head != Z_NULL) state->head->time = hold; if (state->flags & 0x0200) CRC4(state->check, hold); INITBITS(); state->mode = OS; case OS: NEEDBITS(16); if (state->head != Z_NULL) { state->head->xflags = (int)(hold & 0xff); state->head->os = (int)(hold >> 8); } if (state->flags & 0x0200) CRC2(state->check, hold); INITBITS(); state->mode = EXLEN; case EXLEN: if (state->flags & 0x0400) { NEEDBITS(16); state->length = (unsigned)(hold); if (state->head != Z_NULL) state->head->extra_len = (unsigned)hold; if (state->flags & 0x0200) CRC2(state->check, hold); INITBITS(); } else if (state->head != Z_NULL) state->head->extra = Z_NULL; state->mode = EXTRA; case EXTRA: if (state->flags & 0x0400) { copy = state->length; if (copy > have) copy = have; if (copy) { if (state->head != Z_NULL && state->head->extra != Z_NULL) { len = state->head->extra_len - state->length; zmemcpy(state->head->extra + len, next, len + copy > state->head->extra_max ? state->head->extra_max - len : copy); } if (state->flags & 0x0200) state->check = crc32(state->check, next, copy); have -= copy; next += copy; state->length -= copy; } if (state->length) goto inf_leave; } state->length = 0; state->mode = NAME; case NAME: if (state->flags & 0x0800) { if (have == 0) goto inf_leave; copy = 0; do { len = (unsigned)(next[copy++]); if (state->head != Z_NULL && state->head->name != Z_NULL && state->length < state->head->name_max) state->head->name[state->length++] = len; } while (len && copy < have); if (state->flags & 0x0200) state->check = crc32(state->check, next, copy); have -= copy; next += copy; if (len) goto inf_leave; } else if (state->head != Z_NULL) state->head->name = Z_NULL; state->length = 0; state->mode = COMMENT; case COMMENT: if (state->flags & 0x1000) { if (have == 0) goto inf_leave; copy = 0; do { len = (unsigned)(next[copy++]); if (state->head != Z_NULL && state->head->comment != Z_NULL && state->length < state->head->comm_max) state->head->comment[state->length++] = len; } while (len && copy < have); if (state->flags & 0x0200) state->check = crc32(state->check, next, copy); have -= copy; next += copy; if (len) goto inf_leave; } else if (state->head != Z_NULL) state->head->comment = Z_NULL; state->mode = HCRC; case HCRC: if (state->flags & 0x0200) { NEEDBITS(16); if (hold != (state->check & 0xffff)) { strm->msg = (char *)"header crc mismatch"; state->mode = BAD; break; } INITBITS(); } if (state->head != Z_NULL) { state->head->hcrc = (int)((state->flags >> 9) & 1); state->head->done = 1; } strm->adler = state->check = crc32(0L, Z_NULL, 0); state->mode = TYPE; break; #endif case DICTID: NEEDBITS(32); strm->adler = state->check = REVERSE(hold); INITBITS(); state->mode = DICT; case DICT: if (state->havedict == 0) { RESTORE(); return Z_NEED_DICT; } strm->adler = state->check = adler32(0L, Z_NULL, 0); state->mode = TYPE; case TYPE: if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; case TYPEDO: if (state->last) { BYTEBITS(); state->mode = CHECK; break; } NEEDBITS(3); state->last = BITS(1); DROPBITS(1); switch (BITS(2)) { case 0: /* stored block */ Tracev((stderr, "inflate: stored block%s\n", state->last ? " (last)" : "")); state->mode = STORED; break; case 1: /* fixed block */ fixedtables(state); Tracev((stderr, "inflate: fixed codes block%s\n", state->last ? " (last)" : "")); state->mode = LEN_; /* decode codes */ if (flush == Z_TREES) { DROPBITS(2); goto inf_leave; } break; case 2: /* dynamic block */ Tracev((stderr, "inflate: dynamic codes block%s\n", state->last ? " (last)" : "")); state->mode = TABLE; break; case 3: strm->msg = (char *)"invalid block type"; state->mode = BAD; } DROPBITS(2); break; case STORED: BYTEBITS(); /* go to byte boundary */ NEEDBITS(32); if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { strm->msg = (char *)"invalid stored block lengths"; state->mode = BAD; break; } state->length = (unsigned)hold & 0xffff; Tracev((stderr, "inflate: stored length %u\n", state->length)); INITBITS(); state->mode = COPY_; if (flush == Z_TREES) goto inf_leave; case COPY_: state->mode = COPY; case COPY: copy = state->length; if (copy) { if (copy > have) copy = have; if (copy > left) copy = left; if (copy == 0) goto inf_leave; zmemcpy(put, next, copy); have -= copy; next += copy; left -= copy; put += copy; state->length -= copy; break; } Tracev((stderr, "inflate: stored end\n")); state->mode = TYPE; break; case TABLE: NEEDBITS(14); state->nlen = BITS(5) + 257; DROPBITS(5); state->ndist = BITS(5) + 1; DROPBITS(5); state->ncode = BITS(4) + 4; DROPBITS(4); #ifndef PKZIP_BUG_WORKAROUND if (state->nlen > 286 || state->ndist > 30) { strm->msg = (char *)"too many length or distance symbols"; state->mode = BAD; break; } #endif Tracev((stderr, "inflate: table sizes ok\n")); state->have = 0; state->mode = LENLENS; case LENLENS: while (state->have < state->ncode) { NEEDBITS(3); state->lens[order[state->have++]] = (unsigned short)BITS(3); DROPBITS(3); } while (state->have < 19) state->lens[order[state->have++]] = 0; state->next = state->codes; state->lencode = (code const FAR *)(state->next); state->lenbits = 7; ret = inflate_table(CODES, state->lens, 19, &(state->next), &(state->lenbits), state->work); if (ret) { strm->msg = (char *)"invalid code lengths set"; state->mode = BAD; break; } Tracev((stderr, "inflate: code lengths ok\n")); state->have = 0; state->mode = CODELENS; case CODELENS: while (state->have < state->nlen + state->ndist) { for (;;) { here = state->lencode[BITS(state->lenbits)]; if ((unsigned)(here.bits) <= bits) break; PULLBYTE(); } if (here.val < 16) { NEEDBITS(here.bits); DROPBITS(here.bits); state->lens[state->have++] = here.val; } else { if (here.val == 16) { NEEDBITS(here.bits + 2); DROPBITS(here.bits); if (state->have == 0) { strm->msg = (char *)"invalid bit length repeat"; state->mode = BAD; break; } len = state->lens[state->have - 1]; copy = 3 + BITS(2); DROPBITS(2); } else if (here.val == 17) { NEEDBITS(here.bits + 3); DROPBITS(here.bits); len = 0; copy = 3 + BITS(3); DROPBITS(3); } else { NEEDBITS(here.bits + 7); DROPBITS(here.bits); len = 0; copy = 11 + BITS(7); DROPBITS(7); } if (state->have + copy > state->nlen + state->ndist) { strm->msg = (char *)"invalid bit length repeat"; state->mode = BAD; break; } while (copy--) state->lens[state->have++] = (unsigned short)len; } } /* handle error breaks in while */ if (state->mode == BAD) break; /* check for end-of-block code (better have one) */ if (state->lens[256] == 0) { strm->msg = (char *)"invalid code -- missing end-of-block"; state->mode = BAD; break; } /* build code tables -- note: do not change the lenbits or distbits values here (9 and 6) without reading the comments in inftrees.h concerning the ENOUGH constants, which depend on those values */ state->next = state->codes; state->lencode = (code const FAR *)(state->next); state->lenbits = 9; ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), &(state->lenbits), state->work); if (ret) { strm->msg = (char *)"invalid literal/lengths set"; state->mode = BAD; break; } state->distcode = (code const FAR *)(state->next); state->distbits = 6; ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, &(state->next), &(state->distbits), state->work); if (ret) { strm->msg = (char *)"invalid distances set"; state->mode = BAD; break; } Tracev((stderr, "inflate: codes ok\n")); state->mode = LEN_; if (flush == Z_TREES) goto inf_leave; case LEN_: state->mode = LEN; case LEN: if (have >= 6 && left >= 258) { RESTORE(); inflate_fast(strm, out); LOAD(); if (state->mode == TYPE) state->back = -1; break; } state->back = 0; for (;;) { here = state->lencode[BITS(state->lenbits)]; if ((unsigned)(here.bits) <= bits) break; PULLBYTE(); } if (here.op && (here.op & 0xf0) == 0) { last = here; for (;;) { here = state->lencode[last.val + (BITS(last.bits + last.op) >> last.bits)]; if ((unsigned)(last.bits + here.bits) <= bits) break; PULLBYTE(); } DROPBITS(last.bits); state->back += last.bits; } DROPBITS(here.bits); state->back += here.bits; state->length = (unsigned)here.val; if ((int)(here.op) == 0) { Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? "inflate: literal '%c'\n" : "inflate: literal 0x%02x\n", here.val)); state->mode = LIT; break; } if (here.op & 32) { Tracevv((stderr, "inflate: end of block\n")); state->back = -1; state->mode = TYPE; break; } if (here.op & 64) { strm->msg = (char *)"invalid literal/length code"; state->mode = BAD; break; } state->extra = (unsigned)(here.op) & 15; state->mode = LENEXT; case LENEXT: if (state->extra) { NEEDBITS(state->extra); state->length += BITS(state->extra); DROPBITS(state->extra); state->back += state->extra; } Tracevv((stderr, "inflate: length %u\n", state->length)); state->was = state->length; state->mode = DIST; case DIST: for (;;) { here = state->distcode[BITS(state->distbits)]; if ((unsigned)(here.bits) <= bits) break; PULLBYTE(); } if ((here.op & 0xf0) == 0) { last = here; for (;;) { here = state->distcode[last.val + (BITS(last.bits + last.op) >> last.bits)]; if ((unsigned)(last.bits + here.bits) <= bits) break; PULLBYTE(); } DROPBITS(last.bits); state->back += last.bits; } DROPBITS(here.bits); state->back += here.bits; if (here.op & 64) { strm->msg = (char *)"invalid distance code"; state->mode = BAD; break; } state->offset = (unsigned)here.val; state->extra = (unsigned)(here.op) & 15; state->mode = DISTEXT; case DISTEXT: if (state->extra) { NEEDBITS(state->extra); state->offset += BITS(state->extra); DROPBITS(state->extra); state->back += state->extra; } #ifdef INFLATE_STRICT if (state->offset > state->dmax) { strm->msg = (char *)"invalid distance too far back"; state->mode = BAD; break; } #endif Tracevv((stderr, "inflate: distance %u\n", state->offset)); state->mode = MATCH; case MATCH: if (left == 0) goto inf_leave; copy = out - left; if (state->offset > copy) { /* copy from window */ copy = state->offset - copy; if (copy > state->whave) { if (state->sane) { strm->msg = (char *)"invalid distance too far back"; state->mode = BAD; break; } #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR Trace((stderr, "inflate.c too far\n")); copy -= state->whave; if (copy > state->length) copy = state->length; if (copy > left) copy = left; left -= copy; state->length -= copy; do { *put++ = 0; } while (--copy); if (state->length == 0) state->mode = LEN; break; #endif } if (copy > state->wnext) { copy -= state->wnext; from = state->window + (state->wsize - copy); } else from = state->window + (state->wnext - copy); if (copy > state->length) copy = state->length; } else { /* copy from output */ from = put - state->offset; copy = state->length; } if (copy > left) copy = left; left -= copy; state->length -= copy; do { *put++ = *from++; } while (--copy); if (state->length == 0) state->mode = LEN; break; case LIT: if (left == 0) goto inf_leave; *put++ = (unsigned char)(state->length); left--; state->mode = LEN; break; case CHECK: if (state->wrap) { NEEDBITS(32); out -= left; strm->total_out += out; state->total += out; if (out) strm->adler = state->check = UPDATE(state->check, put - out, out); out = left; if (( #ifdef GUNZIP state->flags ? hold : #endif REVERSE(hold)) != state->check) { strm->msg = (char *)"incorrect data check"; state->mode = BAD; break; } INITBITS(); Tracev((stderr, "inflate: check matches trailer\n")); } #ifdef GUNZIP state->mode = LENGTH; case LENGTH: if (state->wrap && state->flags) { NEEDBITS(32); if (hold != (state->total & 0xffffffffUL)) { strm->msg = (char *)"incorrect length check"; state->mode = BAD; break; } INITBITS(); Tracev((stderr, "inflate: length matches trailer\n")); } #endif state->mode = DONE; case DONE: ret = Z_STREAM_END; goto inf_leave; case BAD: ret = Z_DATA_ERROR; goto inf_leave; case MEM: return Z_MEM_ERROR; case SYNC: default: return Z_STREAM_ERROR; } /* Return from inflate(), updating the total counts and the check value. If there was no progress during the inflate() call, return a buffer error. Call updatewindow() to create and/or update the window state. Note: a memory error from inflate() is non-recoverable. */ inf_leave: RESTORE(); if (state->wsize || (state->mode < CHECK && out != strm->avail_out)) if (updatewindow(strm, out)) { state->mode = MEM; return Z_MEM_ERROR; } in -= strm->avail_in; out -= strm->avail_out; strm->total_in += in; strm->total_out += out; state->total += out; if (state->wrap && out) strm->adler = state->check = UPDATE(state->check, strm->next_out - out, out); strm->data_type = state->bits + (state->last ? 64 : 0) + (state->mode == TYPE ? 128 : 0) + (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) ret = Z_BUF_ERROR; return ret; } int ZEXPORT inflateEnd(strm) z_streamp strm; { struct inflate_state FAR *state; if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; if (state->window != Z_NULL) ZFREE(strm, state->window); ZFREE(strm, strm->state); strm->state = Z_NULL; Tracev((stderr, "inflate: end\n")); return Z_OK; } int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) z_streamp strm; const Bytef *dictionary; uInt dictLength; { struct inflate_state FAR *state; unsigned long id; /* check state */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; if (state->wrap != 0 && state->mode != DICT) return Z_STREAM_ERROR; /* check for correct dictionary id */ if (state->mode == DICT) { id = adler32(0L, Z_NULL, 0); id = adler32(id, dictionary, dictLength); if (id != state->check) return Z_DATA_ERROR; } /* copy dictionary to window */ if (updatewindow(strm, strm->avail_out)) { state->mode = MEM; return Z_MEM_ERROR; } if (dictLength > state->wsize) { zmemcpy(state->window, dictionary + dictLength - state->wsize, state->wsize); state->whave = state->wsize; } else { zmemcpy(state->window + state->wsize - dictLength, dictionary, dictLength); state->whave = dictLength; } state->havedict = 1; Tracev((stderr, "inflate: dictionary set\n")); return Z_OK; } int ZEXPORT inflateGetHeader(strm, head) z_streamp strm; gz_headerp head; { struct inflate_state FAR *state; /* check state */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; /* save header structure */ state->head = head; head->done = 0; return Z_OK; } /* Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found or when out of input. When called, *have is the number of pattern bytes found in order so far, in 0..3. On return *have is updated to the new state. If on return *have equals four, then the pattern was found and the return value is how many bytes were read including the last byte of the pattern. If *have is less than four, then the pattern has not been found yet and the return value is len. In the latter case, syncsearch() can be called again with more data and the *have state. *have is initialized to zero for the first call. */ local unsigned syncsearch(have, buf, len) unsigned FAR *have; unsigned char FAR *buf; unsigned len; { unsigned got; unsigned next; got = *have; next = 0; while (next < len && got < 4) { if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) got++; else if (buf[next]) got = 0; else got = 4 - got; next++; } *have = got; return next; } int ZEXPORT inflateSync(strm) z_streamp strm; { unsigned len; /* number of bytes to look at or looked at */ unsigned long in, out; /* temporary to save total_in and total_out */ unsigned char buf[4]; /* to restore bit buffer to byte string */ struct inflate_state FAR *state; /* check parameters */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; /* if first time, start search in bit buffer */ if (state->mode != SYNC) { state->mode = SYNC; state->hold <<= state->bits & 7; state->bits -= state->bits & 7; len = 0; while (state->bits >= 8) { buf[len++] = (unsigned char)(state->hold); state->hold >>= 8; state->bits -= 8; } state->have = 0; syncsearch(&(state->have), buf, len); } /* search available input */ len = syncsearch(&(state->have), strm->next_in, strm->avail_in); strm->avail_in -= len; strm->next_in += len; strm->total_in += len; /* return no joy or set up to restart inflate() on a new block */ if (state->have != 4) return Z_DATA_ERROR; in = strm->total_in; out = strm->total_out; inflateReset(strm); strm->total_in = in; strm->total_out = out; state->mode = TYPE; return Z_OK; } /* Returns true if inflate is currently at the end of a block generated by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored block. When decompressing, PPP checks that at the end of input packet, inflate is waiting for these length bytes. */ int ZEXPORT inflateSyncPoint(strm) z_streamp strm; { struct inflate_state FAR *state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; return state->mode == STORED && state->bits == 0; } int ZEXPORT inflateCopy(dest, source) z_streamp dest; z_streamp source; { struct inflate_state FAR *state; struct inflate_state FAR *copy; unsigned char FAR *window; unsigned wsize; /* check input */ if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)source->state; /* allocate space */ copy = (struct inflate_state FAR *) ZALLOC(source, 1, sizeof(struct inflate_state)); if (copy == Z_NULL) return Z_MEM_ERROR; window = Z_NULL; if (state->window != Z_NULL) { window = (unsigned char FAR *) ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); if (window == Z_NULL) { ZFREE(source, copy); return Z_MEM_ERROR; } } /* copy state */ zmemcpy(dest, source, sizeof(z_stream)); zmemcpy(copy, state, sizeof(struct inflate_state)); if (state->lencode >= state->codes && state->lencode <= state->codes + ENOUGH - 1) { copy->lencode = copy->codes + (state->lencode - state->codes); copy->distcode = copy->codes + (state->distcode - state->codes); } copy->next = copy->codes + (state->next - state->codes); if (window != Z_NULL) { wsize = 1U << state->wbits; zmemcpy(window, state->window, wsize); } copy->window = window; dest->state = (struct internal_state FAR *)copy; return Z_OK; } int ZEXPORT inflateUndermine(strm, subvert) z_streamp strm; int subvert; { struct inflate_state FAR *state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; state = (struct inflate_state FAR *)strm->state; state->sane = !subvert; #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR return Z_OK; #else state->sane = 1; return Z_DATA_ERROR; #endif } long ZEXPORT inflateMark(strm) z_streamp strm; { struct inflate_state FAR *state; if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; state = (struct inflate_state FAR *)strm->state; return ((long)(state->back) << 16) + (state->mode == COPY ? state->length : (state->mode == MATCH ? state->was - state->length : 0)); } healpy-1.10.3/cfitsio/zlib/inflate.h0000664000175000017500000001437713010375005017527 0ustar zoncazonca00000000000000/* inflate.h -- internal inflate state definition * Copyright (C) 1995-2009 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ /* WARNING: this file should *not* be used by applications. It is part of the implementation of the compression library and is subject to change. Applications should only use zlib.h. */ /* define NO_GZIP when compiling if you want to disable gzip header and trailer decoding by inflate(). NO_GZIP would be used to avoid linking in the crc code when it is not needed. For shared libraries, gzip decoding should be left enabled. */ #ifndef NO_GZIP # define GUNZIP #endif /* Possible inflate modes between inflate() calls */ typedef enum { HEAD, /* i: waiting for magic header */ FLAGS, /* i: waiting for method and flags (gzip) */ TIME, /* i: waiting for modification time (gzip) */ OS, /* i: waiting for extra flags and operating system (gzip) */ EXLEN, /* i: waiting for extra length (gzip) */ EXTRA, /* i: waiting for extra bytes (gzip) */ NAME, /* i: waiting for end of file name (gzip) */ COMMENT, /* i: waiting for end of comment (gzip) */ HCRC, /* i: waiting for header crc (gzip) */ DICTID, /* i: waiting for dictionary check value */ DICT, /* waiting for inflateSetDictionary() call */ TYPE, /* i: waiting for type bits, including last-flag bit */ TYPEDO, /* i: same, but skip check to exit inflate on new block */ STORED, /* i: waiting for stored size (length and complement) */ COPY_, /* i/o: same as COPY below, but only first time in */ COPY, /* i/o: waiting for input or output to copy stored block */ TABLE, /* i: waiting for dynamic block table lengths */ LENLENS, /* i: waiting for code length code lengths */ CODELENS, /* i: waiting for length/lit and distance code lengths */ LEN_, /* i: same as LEN below, but only first time in */ LEN, /* i: waiting for length/lit/eob code */ LENEXT, /* i: waiting for length extra bits */ DIST, /* i: waiting for distance code */ DISTEXT, /* i: waiting for distance extra bits */ MATCH, /* o: waiting for output space to copy string */ LIT, /* o: waiting for output space to write literal */ CHECK, /* i: waiting for 32-bit check value */ LENGTH, /* i: waiting for 32-bit length (gzip) */ DONE, /* finished check, done -- remain here until reset */ BAD, /* got a data error -- remain here until reset */ MEM, /* got an inflate() memory error -- remain here until reset */ SYNC /* looking for synchronization bytes to restart inflate() */ } inflate_mode; /* State transitions between above modes - (most modes can go to BAD or MEM on error -- not shown for clarity) Process header: HEAD -> (gzip) or (zlib) or (raw) (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> HCRC -> TYPE (zlib) -> DICTID or TYPE DICTID -> DICT -> TYPE (raw) -> TYPEDO Read deflate blocks: TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK STORED -> COPY_ -> COPY -> TYPE TABLE -> LENLENS -> CODELENS -> LEN_ LEN_ -> LEN Read deflate codes in fixed or dynamic block: LEN -> LENEXT or LIT or TYPE LENEXT -> DIST -> DISTEXT -> MATCH -> LEN LIT -> LEN Process trailer: CHECK -> LENGTH -> DONE */ /* state maintained between inflate() calls. Approximately 10K bytes. */ struct inflate_state { inflate_mode mode; /* current inflate mode */ int last; /* true if processing last block */ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ int havedict; /* true if dictionary provided */ int flags; /* gzip header method and flags (0 if zlib) */ unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ unsigned long check; /* protected copy of check value */ unsigned long total; /* protected copy of output count */ gz_headerp head; /* where to save gzip header information */ /* sliding window */ unsigned wbits; /* log base 2 of requested window size */ unsigned wsize; /* window size or zero if not using window */ unsigned whave; /* valid bytes in the window */ unsigned wnext; /* window write index */ unsigned char FAR *window; /* allocated sliding window, if needed */ /* bit accumulator */ unsigned long hold; /* input bit accumulator */ unsigned bits; /* number of bits in "in" */ /* for string and stored block copying */ unsigned length; /* literal or length of data to copy */ unsigned offset; /* distance back to copy string from */ /* for table and code decoding */ unsigned extra; /* extra bits needed */ /* fixed and dynamic code tables */ code const FAR *lencode; /* starting table for length/literal codes */ code const FAR *distcode; /* starting table for distance codes */ unsigned lenbits; /* index bits for lencode */ unsigned distbits; /* index bits for distcode */ /* dynamic table building */ unsigned ncode; /* number of code length code lengths */ unsigned nlen; /* number of length code lengths */ unsigned ndist; /* number of distance code lengths */ unsigned have; /* number of code lengths in lens[] */ code FAR *next; /* next available space in codes[] */ unsigned short lens[320]; /* temporary storage for code lengths */ unsigned short work[288]; /* work area for code table building */ code codes[ENOUGH]; /* space for code tables */ int sane; /* if false, allow invalid distance too far */ int back; /* bits back of last unprocessed length/lit */ unsigned was; /* initial length of match */ }; healpy-1.10.3/cfitsio/zlib/inftrees.c0000664000175000017500000003271113010375005017707 0ustar zoncazonca00000000000000/* inftrees.c -- generate Huffman trees for efficient decoding * Copyright (C) 1995-2010 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ #include "zutil.h" #include "inftrees.h" #define MAXBITS 15 const char inflate_copyright[] = " inflate 1.2.5 Copyright 1995-2010 Mark Adler "; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot include such an acknowledgment, I would appreciate that you keep this copyright string in the executable of your product. */ /* Build a set of tables to decode the provided canonical Huffman code. The code lengths are lens[0..codes-1]. The result starts at *table, whose indices are 0..2^bits-1. work is a writable array of at least lens shorts, which is used as a work area. type is the type of code to be generated, CODES, LENS, or DISTS. On return, zero is success, -1 is an invalid code, and +1 means that ENOUGH isn't enough. table on return points to the next available entry's address. bits is the requested root table index bits, and on return it is the actual root table index bits. It will differ if the request is greater than the longest code or if it is less than the shortest code. */ int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) codetype type; unsigned short FAR *lens; unsigned codes; code FAR * FAR *table; unsigned FAR *bits; unsigned short FAR *work; { unsigned len; /* a code's length in bits */ unsigned sym; /* index of code symbols */ unsigned min, max; /* minimum and maximum code lengths */ unsigned root; /* number of index bits for root table */ unsigned curr; /* number of index bits for current table */ unsigned drop; /* code bits to drop for sub-table */ int left; /* number of prefix codes available */ unsigned used; /* code entries in table used */ unsigned huff; /* Huffman code */ unsigned incr; /* for incrementing code, index */ unsigned fill; /* index for replicating entries */ unsigned low; /* low bits for current root entry */ unsigned mask; /* mask for low root bits */ code here; /* table entry for duplication */ code FAR *next; /* next available space in table */ const unsigned short FAR *base; /* base value table to use */ const unsigned short FAR *extra; /* extra bits table to use */ int end; /* use base and extra for symbol > end */ unsigned short count[MAXBITS+1]; /* number of codes of each length */ unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ static const unsigned short lbase[31] = { /* Length codes 257..285 base */ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; static const unsigned short lext[31] = { /* Length codes 257..285 extra */ 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 73, 195}; static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0}; static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64}; /* Process a set of code lengths to create a canonical Huffman code. The code lengths are lens[0..codes-1]. Each length corresponds to the symbols 0..codes-1. The Huffman code is generated by first sorting the symbols by length from short to long, and retaining the symbol order for codes with equal lengths. Then the code starts with all zero bits for the first code of the shortest length, and the codes are integer increments for the same length, and zeros are appended as the length increases. For the deflate format, these bits are stored backwards from their more natural integer increment ordering, and so when the decoding tables are built in the large loop below, the integer codes are incremented backwards. This routine assumes, but does not check, that all of the entries in lens[] are in the range 0..MAXBITS. The caller must assure this. 1..MAXBITS is interpreted as that code length. zero means that that symbol does not occur in this code. The codes are sorted by computing a count of codes for each length, creating from that a table of starting indices for each length in the sorted table, and then entering the symbols in order in the sorted table. The sorted table is work[], with that space being provided by the caller. The length counts are used for other purposes as well, i.e. finding the minimum and maximum length codes, determining if there are any codes at all, checking for a valid set of lengths, and looking ahead at length counts to determine sub-table sizes when building the decoding tables. */ /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ for (len = 0; len <= MAXBITS; len++) count[len] = 0; for (sym = 0; sym < codes; sym++) count[lens[sym]]++; /* bound code lengths, force root to be within code lengths */ root = *bits; for (max = MAXBITS; max >= 1; max--) if (count[max] != 0) break; if (root > max) root = max; if (max == 0) { /* no symbols to code at all */ here.op = (unsigned char)64; /* invalid code marker */ here.bits = (unsigned char)1; here.val = (unsigned short)0; *(*table)++ = here; /* make a table to force an error */ *(*table)++ = here; *bits = 1; return 0; /* no symbols, but wait for decoding to report error */ } for (min = 1; min < max; min++) if (count[min] != 0) break; if (root < min) root = min; /* check for an over-subscribed or incomplete set of lengths */ left = 1; for (len = 1; len <= MAXBITS; len++) { left <<= 1; left -= count[len]; if (left < 0) return -1; /* over-subscribed */ } if (left > 0 && (type == CODES || max != 1)) return -1; /* incomplete set */ /* generate offsets into symbol table for each length for sorting */ offs[1] = 0; for (len = 1; len < MAXBITS; len++) offs[len + 1] = offs[len] + count[len]; /* sort symbols by length, by symbol order within each length */ for (sym = 0; sym < codes; sym++) if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; /* Create and fill in decoding tables. In this loop, the table being filled is at next and has curr index bits. The code being used is huff with length len. That code is converted to an index by dropping drop bits off of the bottom. For codes where len is less than drop + curr, those top drop + curr - len bits are incremented through all values to fill the table with replicated entries. root is the number of index bits for the root table. When len exceeds root, sub-tables are created pointed to by the root entry with an index of the low root bits of huff. This is saved in low to check for when a new sub-table should be started. drop is zero when the root table is being filled, and drop is root when sub-tables are being filled. When a new sub-table is needed, it is necessary to look ahead in the code lengths to determine what size sub-table is needed. The length counts are used for this, and so count[] is decremented as codes are entered in the tables. used keeps track of how many table entries have been allocated from the provided *table space. It is checked for LENS and DIST tables against the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in the initial root table size constants. See the comments in inftrees.h for more information. sym increments through all symbols, and the loop terminates when all codes of length max, i.e. all codes, have been processed. This routine permits incomplete codes, so another loop after this one fills in the rest of the decoding tables with invalid code markers. */ /* set up for code type */ switch (type) { case CODES: base = extra = work; /* dummy value--not used */ end = 19; break; case LENS: base = lbase; base -= 257; extra = lext; extra -= 257; end = 256; break; default: /* DISTS */ base = dbase; extra = dext; end = -1; } /* initialize state for loop */ huff = 0; /* starting code */ sym = 0; /* starting code symbol */ len = min; /* starting code length */ next = *table; /* current table to fill in */ curr = root; /* current table index bits */ drop = 0; /* current bits to drop from code for index */ low = (unsigned)(-1); /* trigger new sub-table when len > root */ used = 1U << root; /* use root table entries */ mask = used - 1; /* mask for comparing low */ /* check available table space */ if ((type == LENS && used >= ENOUGH_LENS) || (type == DISTS && used >= ENOUGH_DISTS)) return 1; /* process all codes and make table entries */ for (;;) { /* create table entry */ here.bits = (unsigned char)(len - drop); if ((int)(work[sym]) < end) { here.op = (unsigned char)0; here.val = work[sym]; } else if ((int)(work[sym]) > end) { here.op = (unsigned char)(extra[work[sym]]); here.val = base[work[sym]]; } else { here.op = (unsigned char)(32 + 64); /* end of block */ here.val = 0; } /* replicate for those indices with low len bits equal to huff */ incr = 1U << (len - drop); fill = 1U << curr; min = fill; /* save offset to next table */ do { fill -= incr; next[(huff >> drop) + fill] = here; } while (fill != 0); /* backwards increment the len-bit code huff */ incr = 1U << (len - 1); while (huff & incr) incr >>= 1; if (incr != 0) { huff &= incr - 1; huff += incr; } else huff = 0; /* go to next symbol, update count, len */ sym++; if (--(count[len]) == 0) { if (len == max) break; len = lens[work[sym]]; } /* create new sub-table if needed */ if (len > root && (huff & mask) != low) { /* if first time, transition to sub-tables */ if (drop == 0) drop = root; /* increment past last table */ next += min; /* here min is 1 << curr */ /* determine length of next table */ curr = len - drop; left = (int)(1 << curr); while (curr + drop < max) { left -= count[curr + drop]; if (left <= 0) break; curr++; left <<= 1; } /* check for enough space */ used += 1U << curr; if ((type == LENS && used >= ENOUGH_LENS) || (type == DISTS && used >= ENOUGH_DISTS)) return 1; /* point entry in root table to sub-table */ low = huff & mask; (*table)[low].op = (unsigned char)curr; (*table)[low].bits = (unsigned char)root; (*table)[low].val = (unsigned short)(next - *table); } } /* Fill in rest of table for incomplete codes. This loop is similar to the loop above in incrementing huff for table indices. It is assumed that len is equal to curr + drop, so there is no loop needed to increment through high index bits. When the current sub-table is filled, the loop drops back to the root table to fill in any remaining entries there. */ here.op = (unsigned char)64; /* invalid code marker */ here.bits = (unsigned char)(len - drop); here.val = (unsigned short)0; while (huff != 0) { /* when done with sub-table, drop back to root table */ if (drop != 0 && (huff & mask) != low) { drop = 0; len = root; next = *table; here.bits = (unsigned char)len; } /* put invalid code marker in table */ next[huff >> drop] = here; /* backwards increment the len-bit code huff */ incr = 1U << (len - 1); while (huff & incr) incr >>= 1; if (incr != 0) { huff &= incr - 1; huff += incr; } else huff = 0; } /* set return parameters */ *table += used; *bits = root; return 0; } healpy-1.10.3/cfitsio/zlib/inftrees.h0000664000175000017500000000556013010375005017716 0ustar zoncazonca00000000000000/* inftrees.h -- header to use inftrees.c * Copyright (C) 1995-2005, 2010 Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ /* WARNING: this file should *not* be used by applications. It is part of the implementation of the compression library and is subject to change. Applications should only use zlib.h. */ /* Structure for decoding tables. Each entry provides either the information needed to do the operation requested by the code that indexed that table entry, or it provides a pointer to another table that indexes more bits of the code. op indicates whether the entry is a pointer to another table, a literal, a length or distance, an end-of-block, or an invalid code. For a table pointer, the low four bits of op is the number of index bits of that table. For a length or distance, the low four bits of op is the number of extra bits to get after the code. bits is the number of bits in this code or part of the code to drop off of the bit buffer. val is the actual byte to output in the case of a literal, the base length or distance, or the offset from the current table to the next table. Each entry is four bytes. */ typedef struct { unsigned char op; /* operation, extra bits, table bits */ unsigned char bits; /* bits in this part of the code */ unsigned short val; /* offset in table or code value */ } code; /* op values as set by inflate_table(): 00000000 - literal 0000tttt - table link, tttt != 0 is the number of table index bits 0001eeee - length or distance, eeee is the number of extra bits 01100000 - end of block 01000000 - invalid code */ /* Maximum size of the dynamic table. The maximum number of code structures is 1444, which is the sum of 852 for literal/length codes and 592 for distance codes. These values were found by exhaustive searches using the program examples/enough.c found in the zlib distribtution. The arguments to that program are the number of symbols, the initial root table size, and the maximum bit length of a code. "enough 286 9 15" for literal/length codes returns returns 852, and "enough 30 6 15" for distance codes returns 592. The initial root table size (9 or 6) is found in the fifth argument of the inflate_table() calls in inflate.c and infback.c. If the root table size is changed, then these maximum sizes would be need to be recalculated and updated. */ #define ENOUGH_LENS 852 #define ENOUGH_DISTS 592 #define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) /* Type of code to build for inflate_table() */ typedef enum { CODES, LENS, DISTS } codetype; int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, unsigned codes, code FAR * FAR *table, unsigned FAR *bits, unsigned short FAR *work)); healpy-1.10.3/cfitsio/zlib/trees.c0000664000175000017500000013025113010375005017210 0ustar zoncazonca00000000000000/* trees.c -- output deflated data using Huffman coding * Copyright (C) 1995-2010 Jean-loup Gailly * detect_data_type() function provided freely by Cosmin Truta, 2006 * For conditions of distribution and use, see copyright notice in zlib.h */ /* * ALGORITHM * * The "deflation" process uses several Huffman trees. The more * common source values are represented by shorter bit sequences. * * Each code tree is stored in a compressed form which is itself * a Huffman encoding of the lengths of all the code strings (in * ascending order by source values). The actual code strings are * reconstructed from the lengths in the inflate process, as described * in the deflate specification. * * REFERENCES * * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc * * Storer, James A. * Data Compression: Methods and Theory, pp. 49-50. * Computer Science Press, 1988. ISBN 0-7167-8156-5. * * Sedgewick, R. * Algorithms, p290. * Addison-Wesley, 1983. ISBN 0-201-06672-6. */ /* #define GEN_TREES_H */ #include "deflate.h" #ifdef DEBUG # include #endif /* =========================================================================== * Constants */ #define MAX_BL_BITS 7 /* Bit length codes must not exceed MAX_BL_BITS bits */ #define END_BLOCK 256 /* end of block literal code */ #define REP_3_6 16 /* repeat previous bit length 3-6 times (2 bits of repeat count) */ #define REPZ_3_10 17 /* repeat a zero length 3-10 times (3 bits of repeat count) */ #define REPZ_11_138 18 /* repeat a zero length 11-138 times (7 bits of repeat count) */ local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; local const int extra_dbits[D_CODES] /* extra bits for each distance code */ = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; local const uch bl_order[BL_CODES] = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; /* The lengths of the bit length codes are sent in order of decreasing * probability, to avoid transmitting the lengths for unused bit length codes. */ #define Buf_size (8 * 2*sizeof(char)) /* Number of bits used within bi_buf. (bi_buf might be implemented on * more than 16 bits on some systems.) */ /* =========================================================================== * Local data. These are initialized only once. */ #define DIST_CODE_LEN 512 /* see definition of array dist_code below */ #if defined(GEN_TREES_H) || !defined(STDC) /* non ANSI compilers may not accept trees.h */ local ct_data static_ltree[L_CODES+2]; /* The static literal tree. Since the bit lengths are imposed, there is no * need for the L_CODES extra codes used during heap construction. However * The codes 286 and 287 are needed to build a canonical tree (see _tr_init * below). */ local ct_data static_dtree[D_CODES]; /* The static distance tree. (Actually a trivial tree since all codes use * 5 bits.) */ uch _dist_code[DIST_CODE_LEN]; /* Distance codes. The first 256 values correspond to the distances * 3 .. 258, the last 256 values correspond to the top 8 bits of * the 15 bit distances. */ uch _length_code[MAX_MATCH-MIN_MATCH+1]; /* length code for each normalized match length (0 == MIN_MATCH) */ local int base_length[LENGTH_CODES]; /* First normalized length for each code (0 = MIN_MATCH) */ local int base_dist[D_CODES]; /* First normalized distance for each code (0 = distance of 1) */ #else # include "trees.h" #endif /* GEN_TREES_H */ struct static_tree_desc_s { const ct_data *static_tree; /* static tree or NULL */ const intf *extra_bits; /* extra bits for each code or NULL */ int extra_base; /* base index for extra_bits */ int elems; /* max number of elements in the tree */ int max_length; /* max bit length for the codes */ }; local static_tree_desc static_l_desc = {static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; local static_tree_desc static_d_desc = {static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; local static_tree_desc static_bl_desc = {(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; /* =========================================================================== * Local (static) routines in this file. */ local void tr_static_init OF((void)); local void init_block OF((deflate_state *s)); local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); local void build_tree OF((deflate_state *s, tree_desc *desc)); local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); local int build_bl_tree OF((deflate_state *s)); local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, int blcodes)); local void compress_block OF((deflate_state *s, ct_data *ltree, ct_data *dtree)); local int detect_data_type OF((deflate_state *s)); local unsigned bi_reverse OF((unsigned value, int length)); local void bi_windup OF((deflate_state *s)); local void bi_flush OF((deflate_state *s)); local void copy_block OF((deflate_state *s, charf *buf, unsigned len, int header)); #ifdef GEN_TREES_H local void gen_trees_header OF((void)); #endif #ifndef DEBUG # define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) /* Send a code of the given tree. c and tree must not have side effects */ #else /* DEBUG */ # define send_code(s, c, tree) \ { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ send_bits(s, tree[c].Code, tree[c].Len); } #endif /* =========================================================================== * Output a short LSB first on the stream. * IN assertion: there is enough room in pendingBuf. */ #define put_short(s, w) { \ put_byte(s, (uch)((w) & 0xff)); \ put_byte(s, (uch)((ush)(w) >> 8)); \ } /* =========================================================================== * Send a value on a given number of bits. * IN assertion: length <= 16 and value fits in length bits. */ #ifdef DEBUG local void send_bits OF((deflate_state *s, int value, int length)); local void send_bits(s, value, length) deflate_state *s; int value; /* value to send */ int length; /* number of bits */ { Tracevv((stderr," l %2d v %4x ", length, value)); Assert(length > 0 && length <= 15, "invalid length"); s->bits_sent += (ulg)length; /* If not enough room in bi_buf, use (valid) bits from bi_buf and * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) * unused bits in value. */ if (s->bi_valid > (int)Buf_size - length) { s->bi_buf |= (ush)value << s->bi_valid; put_short(s, s->bi_buf); s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); s->bi_valid += length - Buf_size; } else { s->bi_buf |= (ush)value << s->bi_valid; s->bi_valid += length; } } #else /* !DEBUG */ #define send_bits(s, value, length) \ { int len = length;\ if (s->bi_valid > (int)Buf_size - len) {\ int val = value;\ s->bi_buf |= (ush)val << s->bi_valid;\ put_short(s, s->bi_buf);\ s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ s->bi_valid += len - Buf_size;\ } else {\ s->bi_buf |= (ush)(value) << s->bi_valid;\ s->bi_valid += len;\ }\ } #endif /* DEBUG */ /* the arguments must not have side effects */ /* =========================================================================== * Initialize the various 'constant' tables. */ local void tr_static_init() { #if defined(GEN_TREES_H) || !defined(STDC) static int static_init_done = 0; int n; /* iterates over tree elements */ int bits; /* bit counter */ int length; /* length value */ int code; /* code value */ int dist; /* distance index */ ush bl_count[MAX_BITS+1]; /* number of codes at each bit length for an optimal tree */ if (static_init_done) return; /* For some embedded targets, global variables are not initialized: */ #ifdef NO_INIT_GLOBAL_POINTERS static_l_desc.static_tree = static_ltree; static_l_desc.extra_bits = extra_lbits; static_d_desc.static_tree = static_dtree; static_d_desc.extra_bits = extra_dbits; static_bl_desc.extra_bits = extra_blbits; #endif /* Initialize the mapping length (0..255) -> length code (0..28) */ length = 0; for (code = 0; code < LENGTH_CODES-1; code++) { base_length[code] = length; for (n = 0; n < (1< dist code (0..29) */ dist = 0; for (code = 0 ; code < 16; code++) { base_dist[code] = dist; for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ for ( ; code < D_CODES; code++) { base_dist[code] = dist << 7; for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { _dist_code[256 + dist++] = (uch)code; } } Assert (dist == 256, "tr_static_init: 256+dist != 512"); /* Construct the codes of the static literal tree */ for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; n = 0; while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; /* Codes 286 and 287 do not exist, but we must include them in the * tree construction to get a canonical Huffman tree (longest code * all ones) */ gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); /* The static distance tree is trivial: */ for (n = 0; n < D_CODES; n++) { static_dtree[n].Len = 5; static_dtree[n].Code = bi_reverse((unsigned)n, 5); } static_init_done = 1; # ifdef GEN_TREES_H gen_trees_header(); # endif #endif /* defined(GEN_TREES_H) || !defined(STDC) */ } /* =========================================================================== * Genererate the file trees.h describing the static trees. */ #ifdef GEN_TREES_H # ifndef DEBUG # include # endif # define SEPARATOR(i, last, width) \ ((i) == (last)? "\n};\n\n" : \ ((i) % (width) == (width)-1 ? ",\n" : ", ")) void gen_trees_header() { FILE *header = fopen("trees.h", "w"); int i; Assert (header != NULL, "Can't open trees.h"); fprintf(header, "/* header created automatically with -DGEN_TREES_H */\n\n"); fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); for (i = 0; i < L_CODES+2; i++) { fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); } fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); for (i = 0; i < D_CODES; i++) { fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); } fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); for (i = 0; i < DIST_CODE_LEN; i++) { fprintf(header, "%2u%s", _dist_code[i], SEPARATOR(i, DIST_CODE_LEN-1, 20)); } fprintf(header, "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { fprintf(header, "%2u%s", _length_code[i], SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); } fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); for (i = 0; i < LENGTH_CODES; i++) { fprintf(header, "%1u%s", base_length[i], SEPARATOR(i, LENGTH_CODES-1, 20)); } fprintf(header, "local const int base_dist[D_CODES] = {\n"); for (i = 0; i < D_CODES; i++) { fprintf(header, "%5u%s", base_dist[i], SEPARATOR(i, D_CODES-1, 10)); } fclose(header); } #endif /* GEN_TREES_H */ /* =========================================================================== * Initialize the tree data structures for a new zlib stream. */ void ZLIB_INTERNAL _tr_init(s) deflate_state *s; { tr_static_init(); s->l_desc.dyn_tree = s->dyn_ltree; s->l_desc.stat_desc = &static_l_desc; s->d_desc.dyn_tree = s->dyn_dtree; s->d_desc.stat_desc = &static_d_desc; s->bl_desc.dyn_tree = s->bl_tree; s->bl_desc.stat_desc = &static_bl_desc; s->bi_buf = 0; s->bi_valid = 0; s->last_eob_len = 8; /* enough lookahead for inflate */ #ifdef DEBUG s->compressed_len = 0L; s->bits_sent = 0L; #endif /* Initialize the first block of the first file: */ init_block(s); } /* =========================================================================== * Initialize a new block. */ local void init_block(s) deflate_state *s; { int n; /* iterates over tree elements */ /* Initialize the trees. */ for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; s->dyn_ltree[END_BLOCK].Freq = 1; s->opt_len = s->static_len = 0L; s->last_lit = s->matches = 0; } #define SMALLEST 1 /* Index within the heap array of least frequent node in the Huffman tree */ /* =========================================================================== * Remove the smallest element from the heap and recreate the heap with * one less element. Updates heap and heap_len. */ #define pqremove(s, tree, top) \ {\ top = s->heap[SMALLEST]; \ s->heap[SMALLEST] = s->heap[s->heap_len--]; \ pqdownheap(s, tree, SMALLEST); \ } /* =========================================================================== * Compares to subtrees, using the tree depth as tie breaker when * the subtrees have equal frequency. This minimizes the worst case length. */ #define smaller(tree, n, m, depth) \ (tree[n].Freq < tree[m].Freq || \ (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) /* =========================================================================== * Restore the heap property by moving down the tree starting at node k, * exchanging a node with the smallest of its two sons if necessary, stopping * when the heap property is re-established (each father smaller than its * two sons). */ local void pqdownheap(s, tree, k) deflate_state *s; ct_data *tree; /* the tree to restore */ int k; /* node to move down */ { int v = s->heap[k]; int j = k << 1; /* left son of k */ while (j <= s->heap_len) { /* Set j to the smallest of the two sons: */ if (j < s->heap_len && smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { j++; } /* Exit if v is smaller than both sons */ if (smaller(tree, v, s->heap[j], s->depth)) break; /* Exchange v with the smallest son */ s->heap[k] = s->heap[j]; k = j; /* And continue down the tree, setting j to the left son of k */ j <<= 1; } s->heap[k] = v; } /* =========================================================================== * Compute the optimal bit lengths for a tree and update the total bit length * for the current block. * IN assertion: the fields freq and dad are set, heap[heap_max] and * above are the tree nodes sorted by increasing frequency. * OUT assertions: the field len is set to the optimal bit length, the * array bl_count contains the frequencies for each bit length. * The length opt_len is updated; static_len is also updated if stree is * not null. */ local void gen_bitlen(s, desc) deflate_state *s; tree_desc *desc; /* the tree descriptor */ { ct_data *tree = desc->dyn_tree; int max_code = desc->max_code; const ct_data *stree = desc->stat_desc->static_tree; const intf *extra = desc->stat_desc->extra_bits; int base = desc->stat_desc->extra_base; int max_length = desc->stat_desc->max_length; int h; /* heap index */ int n, m; /* iterate over the tree elements */ int bits; /* bit length */ int xbits; /* extra bits */ ush f; /* frequency */ int overflow = 0; /* number of elements with bit length too large */ for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; /* In a first pass, compute the optimal bit lengths (which may * overflow in the case of the bit length tree). */ tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ for (h = s->heap_max+1; h < HEAP_SIZE; h++) { n = s->heap[h]; bits = tree[tree[n].Dad].Len + 1; if (bits > max_length) bits = max_length, overflow++; tree[n].Len = (ush)bits; /* We overwrite tree[n].Dad which is no longer needed */ if (n > max_code) continue; /* not a leaf node */ s->bl_count[bits]++; xbits = 0; if (n >= base) xbits = extra[n-base]; f = tree[n].Freq; s->opt_len += (ulg)f * (bits + xbits); if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); } if (overflow == 0) return; Trace((stderr,"\nbit length overflow\n")); /* This happens for example on obj2 and pic of the Calgary corpus */ /* Find the first bit length which could increase: */ do { bits = max_length-1; while (s->bl_count[bits] == 0) bits--; s->bl_count[bits]--; /* move one leaf down the tree */ s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ s->bl_count[max_length]--; /* The brother of the overflow item also moves one step up, * but this does not affect bl_count[max_length] */ overflow -= 2; } while (overflow > 0); /* Now recompute all bit lengths, scanning in increasing frequency. * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all * lengths instead of fixing only the wrong ones. This idea is taken * from 'ar' written by Haruhiko Okumura.) */ for (bits = max_length; bits != 0; bits--) { n = s->bl_count[bits]; while (n != 0) { m = s->heap[--h]; if (m > max_code) continue; if ((unsigned) tree[m].Len != (unsigned) bits) { Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); s->opt_len += ((long)bits - (long)tree[m].Len) *(long)tree[m].Freq; tree[m].Len = (ush)bits; } n--; } } } /* =========================================================================== * Generate the codes for a given tree and bit counts (which need not be * optimal). * IN assertion: the array bl_count contains the bit length statistics for * the given tree and the field len is set for all tree elements. * OUT assertion: the field code is set for all tree elements of non * zero code length. */ local void gen_codes (tree, max_code, bl_count) ct_data *tree; /* the tree to decorate */ int max_code; /* largest code with non zero frequency */ ushf *bl_count; /* number of codes at each bit length */ { ush next_code[MAX_BITS+1]; /* next code value for each bit length */ ush code = 0; /* running code value */ int bits; /* bit index */ int n; /* code index */ /* The distribution counts are first used to generate the code values * without bit reversal. */ for (bits = 1; bits <= MAX_BITS; bits++) { next_code[bits] = code = (code + bl_count[bits-1]) << 1; } /* Check that the bit counts in bl_count are consistent. The last code * must be all ones. */ Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; const ct_data *stree = desc->stat_desc->static_tree; int elems = desc->stat_desc->elems; int n, m; /* iterate over heap elements */ int max_code = -1; /* largest code with non zero frequency */ int node; /* new node being created */ /* Construct the initial heap, with least frequent element in * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. * heap[0] is not used. */ s->heap_len = 0, s->heap_max = HEAP_SIZE; for (n = 0; n < elems; n++) { if (tree[n].Freq != 0) { s->heap[++(s->heap_len)] = max_code = n; s->depth[n] = 0; } else { tree[n].Len = 0; } } /* The pkzip format requires that at least one distance code exists, * and that at least one bit should be sent even if there is only one * possible code. So to avoid special checks later on we force at least * two codes of non zero frequency. */ while (s->heap_len < 2) { node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); tree[node].Freq = 1; s->depth[node] = 0; s->opt_len--; if (stree) s->static_len -= stree[node].Len; /* node is 0 or 1 so it does not have extra bits */ } desc->max_code = max_code; /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, * establish sub-heaps of increasing lengths: */ for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); /* Construct the Huffman tree by repeatedly combining the least two * frequent nodes. */ node = elems; /* next internal node of the tree */ do { pqremove(s, tree, n); /* n = node of least frequency */ m = s->heap[SMALLEST]; /* m = node of next least frequency */ s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ s->heap[--(s->heap_max)] = m; /* Create a new node father of n and m */ tree[node].Freq = tree[n].Freq + tree[m].Freq; s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ? s->depth[n] : s->depth[m]) + 1); tree[n].Dad = tree[m].Dad = (ush)node; #ifdef DUMP_BL_TREE if (tree == s->bl_tree) { fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); } #endif /* and insert the new node in the heap */ s->heap[SMALLEST] = node++; pqdownheap(s, tree, SMALLEST); } while (s->heap_len >= 2); s->heap[--(s->heap_max)] = s->heap[SMALLEST]; /* At this point, the fields freq and dad are set. We can now * generate the bit lengths. */ gen_bitlen(s, (tree_desc *)desc); /* The field len is now set, we can generate the bit codes */ gen_codes ((ct_data *)tree, max_code, s->bl_count); } /* =========================================================================== * Scan a literal or distance tree to determine the frequencies of the codes * in the bit length tree. */ local void scan_tree (s, tree, max_code) deflate_state *s; ct_data *tree; /* the tree to be scanned */ int max_code; /* and its largest code of non zero frequency */ { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ int curlen; /* length of current code */ int nextlen = tree[0].Len; /* length of next code */ int count = 0; /* repeat count of the current code */ int max_count = 7; /* max repeat count */ int min_count = 4; /* min repeat count */ if (nextlen == 0) max_count = 138, min_count = 3; tree[max_code+1].Len = (ush)0xffff; /* guard */ for (n = 0; n <= max_code; n++) { curlen = nextlen; nextlen = tree[n+1].Len; if (++count < max_count && curlen == nextlen) { continue; } else if (count < min_count) { s->bl_tree[curlen].Freq += count; } else if (curlen != 0) { if (curlen != prevlen) s->bl_tree[curlen].Freq++; s->bl_tree[REP_3_6].Freq++; } else if (count <= 10) { s->bl_tree[REPZ_3_10].Freq++; } else { s->bl_tree[REPZ_11_138].Freq++; } count = 0; prevlen = curlen; if (nextlen == 0) { max_count = 138, min_count = 3; } else if (curlen == nextlen) { max_count = 6, min_count = 3; } else { max_count = 7, min_count = 4; } } } /* =========================================================================== * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ local void send_tree (s, tree, max_code) deflate_state *s; ct_data *tree; /* the tree to be scanned */ int max_code; /* and its largest code of non zero frequency */ { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ int curlen; /* length of current code */ int nextlen = tree[0].Len; /* length of next code */ int count = 0; /* repeat count of the current code */ int max_count = 7; /* max repeat count */ int min_count = 4; /* min repeat count */ /* tree[max_code+1].Len = -1; */ /* guard already set */ if (nextlen == 0) max_count = 138, min_count = 3; for (n = 0; n <= max_code; n++) { curlen = nextlen; nextlen = tree[n+1].Len; if (++count < max_count && curlen == nextlen) { continue; } else if (count < min_count) { do { send_code(s, curlen, s->bl_tree); } while (--count != 0); } else if (curlen != 0) { if (curlen != prevlen) { send_code(s, curlen, s->bl_tree); count--; } Assert(count >= 3 && count <= 6, " 3_6?"); send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); } else if (count <= 10) { send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); } else { send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); } count = 0; prevlen = curlen; if (nextlen == 0) { max_count = 138, min_count = 3; } else if (curlen == nextlen) { max_count = 6, min_count = 3; } else { max_count = 7, min_count = 4; } } } /* =========================================================================== * Construct the Huffman tree for the bit lengths and return the index in * bl_order of the last bit length code to send. */ local int build_bl_tree(s) deflate_state *s; { int max_blindex; /* index of last bit length code of non zero freq */ /* Determine the bit length frequencies for literal and distance trees */ scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); /* Build the bit length tree: */ build_tree(s, (tree_desc *)(&(s->bl_desc))); /* opt_len now includes the length of the tree representations, except * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. */ /* Determine the number of bit length codes to send. The pkzip format * requires that at least 4 bit length codes be sent. (appnote.txt says * 3 but the actual value used is 4.) */ for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; } /* Update opt_len to include the bit length tree and counts */ s->opt_len += 3*(max_blindex+1) + 5+5+4; Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", s->opt_len, s->static_len)); return max_blindex; } /* =========================================================================== * Send the header for a block using dynamic Huffman trees: the counts, the * lengths of the bit length codes, the literal tree and the distance tree. * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ local void send_all_trees(s, lcodes, dcodes, blcodes) deflate_state *s; int lcodes, dcodes, blcodes; /* number of codes for each tree */ { int rank; /* index in bl_order */ Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, "too many codes"); Tracev((stderr, "\nbl counts: ")); send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ send_bits(s, dcodes-1, 5); send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ for (rank = 0; rank < blcodes; rank++) { Tracev((stderr, "\nbl code %2d ", bl_order[rank])); send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); } Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); } /* =========================================================================== * Send a stored block */ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) deflate_state *s; charf *buf; /* input block */ ulg stored_len; /* length of input block */ int last; /* one if this is the last block for a file */ { send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ #ifdef DEBUG s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; s->compressed_len += (stored_len + 4) << 3; #endif copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ } /* =========================================================================== * Send one empty static block to give enough lookahead for inflate. * This takes 10 bits, of which 7 may remain in the bit buffer. * The current inflate code requires 9 bits of lookahead. If the * last two codes for the previous block (real code plus EOB) were coded * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode * the last real code. In this case we send two empty static blocks instead * of one. (There are no problems if the previous block is stored or fixed.) * To simplify the code, we assume the worst case of last real code encoded * on one bit only. */ void ZLIB_INTERNAL _tr_align(s) deflate_state *s; { send_bits(s, STATIC_TREES<<1, 3); send_code(s, END_BLOCK, static_ltree); #ifdef DEBUG s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ #endif bi_flush(s); /* Of the 10 bits for the empty block, we have already sent * (10 - bi_valid) bits. The lookahead for the last real code (before * the EOB of the previous block) was thus at least one plus the length * of the EOB plus what we have just sent of the empty static block. */ if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { send_bits(s, STATIC_TREES<<1, 3); send_code(s, END_BLOCK, static_ltree); #ifdef DEBUG s->compressed_len += 10L; #endif bi_flush(s); } s->last_eob_len = 7; } /* =========================================================================== * Determine the best encoding for the current block: dynamic trees, static * trees or store, and output the encoded block to the zip file. */ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) deflate_state *s; charf *buf; /* input block, or NULL if too old */ ulg stored_len; /* length of input block */ int last; /* one if this is the last block for a file */ { ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ int max_blindex = 0; /* index of last bit length code of non zero freq */ /* Build the Huffman trees unless a stored block is forced */ if (s->level > 0) { /* Check if the file is binary or text */ if (s->strm->data_type == Z_UNKNOWN) s->strm->data_type = detect_data_type(s); /* Construct the literal and distance trees */ build_tree(s, (tree_desc *)(&(s->l_desc))); Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, s->static_len)); build_tree(s, (tree_desc *)(&(s->d_desc))); Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, s->static_len)); /* At this point, opt_len and static_len are the total bit lengths of * the compressed block data, excluding the tree representations. */ /* Build the bit length tree for the above two trees, and get the index * in bl_order of the last bit length code to send. */ max_blindex = build_bl_tree(s); /* Determine the best encoding. Compute the block lengths in bytes. */ opt_lenb = (s->opt_len+3+7)>>3; static_lenb = (s->static_len+3+7)>>3; Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, s->last_lit)); if (static_lenb <= opt_lenb) opt_lenb = static_lenb; } else { Assert(buf != (char*)0, "lost buf"); opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ } #ifdef FORCE_STORED if (buf != (char*)0) { /* force stored block */ #else if (stored_len+4 <= opt_lenb && buf != (char*)0) { /* 4: two words for the lengths */ #endif /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. * Otherwise we can't have processed more than WSIZE input bytes since * the last block flush, because compression would have been * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to * transform a block into a stored block. */ _tr_stored_block(s, buf, stored_len, last); #ifdef FORCE_STATIC } else if (static_lenb >= 0) { /* force static trees */ #else } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { #endif send_bits(s, (STATIC_TREES<<1)+last, 3); compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); #ifdef DEBUG s->compressed_len += 3 + s->static_len; #endif } else { send_bits(s, (DYN_TREES<<1)+last, 3); send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, max_blindex+1); compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); #ifdef DEBUG s->compressed_len += 3 + s->opt_len; #endif } Assert (s->compressed_len == s->bits_sent, "bad compressed size"); /* The above check is made mod 2^32, for files larger than 512 MB * and uLong implemented on 32 bits. */ init_block(s); if (last) { bi_windup(s); #ifdef DEBUG s->compressed_len += 7; /* align on byte boundary */ #endif } Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, s->compressed_len-7*last)); } /* =========================================================================== * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. */ int ZLIB_INTERNAL _tr_tally (s, dist, lc) deflate_state *s; unsigned dist; /* distance of matched string */ unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ { s->d_buf[s->last_lit] = (ush)dist; s->l_buf[s->last_lit++] = (uch)lc; if (dist == 0) { /* lc is the unmatched char */ s->dyn_ltree[lc].Freq++; } else { s->matches++; /* Here, lc is the match length - MIN_MATCH */ dist--; /* dist = match distance - 1 */ Assert((ush)dist < (ush)MAX_DIST(s) && (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; s->dyn_dtree[d_code(dist)].Freq++; } #ifdef TRUNCATE_BLOCK /* Try to guess if it is profitable to stop the current block here */ if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { /* Compute an upper bound for the compressed length */ ulg out_length = (ulg)s->last_lit*8L; ulg in_length = (ulg)((long)s->strstart - s->block_start); int dcode; for (dcode = 0; dcode < D_CODES; dcode++) { out_length += (ulg)s->dyn_dtree[dcode].Freq * (5L+extra_dbits[dcode]); } out_length >>= 3; Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", s->last_lit, in_length, out_length, 100L - out_length*100L/in_length)); if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; } #endif return (s->last_lit == s->lit_bufsize-1); /* We avoid equality with lit_bufsize because of wraparound at 64K * on 16 bit machines and because stored blocks are restricted to * 64K-1 bytes. */ } /* =========================================================================== * Send the block data compressed using the given Huffman trees */ local void compress_block(s, ltree, dtree) deflate_state *s; ct_data *ltree; /* literal tree */ ct_data *dtree; /* distance tree */ { unsigned dist; /* distance of matched string */ int lc; /* match length or unmatched char (if dist == 0) */ unsigned lx = 0; /* running index in l_buf */ unsigned code; /* the code to send */ int extra; /* number of extra bits to send */ if (s->last_lit != 0) do { dist = s->d_buf[lx]; lc = s->l_buf[lx++]; if (dist == 0) { send_code(s, lc, ltree); /* send a literal byte */ Tracecv(isgraph(lc), (stderr," '%c' ", lc)); } else { /* Here, lc is the match length - MIN_MATCH */ code = _length_code[lc]; send_code(s, code+LITERALS+1, ltree); /* send the length code */ extra = extra_lbits[code]; if (extra != 0) { lc -= base_length[code]; send_bits(s, lc, extra); /* send the extra length bits */ } dist--; /* dist is now the match distance - 1 */ code = d_code(dist); Assert (code < D_CODES, "bad d_code"); send_code(s, code, dtree); /* send the distance code */ extra = extra_dbits[code]; if (extra != 0) { dist -= base_dist[code]; send_bits(s, dist, extra); /* send the extra distance bits */ } } /* literal or match pair ? */ /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, "pendingBuf overflow"); } while (lx < s->last_lit); send_code(s, END_BLOCK, ltree); s->last_eob_len = ltree[END_BLOCK].Len; } /* =========================================================================== * Check if the data type is TEXT or BINARY, using the following algorithm: * - TEXT if the two conditions below are satisfied: * a) There are no non-portable control characters belonging to the * "black list" (0..6, 14..25, 28..31). * b) There is at least one printable character belonging to the * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). * - BINARY otherwise. * - The following partially-portable control characters form a * "gray list" that is ignored in this detection algorithm: * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). * IN assertion: the fields Freq of dyn_ltree are set. */ local int detect_data_type(s) deflate_state *s; { /* black_mask is the bit mask of black-listed bytes * set bits 0..6, 14..25, and 28..31 * 0xf3ffc07f = binary 11110011111111111100000001111111 */ unsigned long black_mask = 0xf3ffc07fUL; int n; /* Check for non-textual ("black-listed") bytes. */ for (n = 0; n <= 31; n++, black_mask >>= 1) if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0)) return Z_BINARY; /* Check for textual ("white-listed") bytes. */ if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 || s->dyn_ltree[13].Freq != 0) return Z_TEXT; for (n = 32; n < LITERALS; n++) if (s->dyn_ltree[n].Freq != 0) return Z_TEXT; /* There are no "black-listed" or "white-listed" bytes: * this stream either is empty or has tolerated ("gray-listed") bytes only. */ return Z_BINARY; } /* =========================================================================== * Reverse the first len bits of a code, using straightforward code (a faster * method would use a table) * IN assertion: 1 <= len <= 15 */ local unsigned bi_reverse(code, len) unsigned code; /* the value to invert */ int len; /* its bit length */ { register unsigned res = 0; do { res |= code & 1; code >>= 1, res <<= 1; } while (--len > 0); return res >> 1; } /* =========================================================================== * Flush the bit buffer, keeping at most 7 bits in it. */ local void bi_flush(s) deflate_state *s; { if (s->bi_valid == 16) { put_short(s, s->bi_buf); s->bi_buf = 0; s->bi_valid = 0; } else if (s->bi_valid >= 8) { put_byte(s, (Byte)s->bi_buf); s->bi_buf >>= 8; s->bi_valid -= 8; } } /* =========================================================================== * Flush the bit buffer and align the output on a byte boundary */ local void bi_windup(s) deflate_state *s; { if (s->bi_valid > 8) { put_short(s, s->bi_buf); } else if (s->bi_valid > 0) { put_byte(s, (Byte)s->bi_buf); } s->bi_buf = 0; s->bi_valid = 0; #ifdef DEBUG s->bits_sent = (s->bits_sent+7) & ~7; #endif } /* =========================================================================== * Copy a stored block, storing first the length and its * one's complement if requested. */ local void copy_block(s, buf, len, header) deflate_state *s; charf *buf; /* the input data */ unsigned len; /* its length */ int header; /* true if block header must be written */ { bi_windup(s); /* align on byte boundary */ s->last_eob_len = 8; /* enough lookahead for inflate */ if (header) { put_short(s, (ush)len); put_short(s, (ush)~len); #ifdef DEBUG s->bits_sent += 2*16; #endif } #ifdef DEBUG s->bits_sent += (ulg)len<<3; #endif while (len--) { put_byte(s, *buf++); } } healpy-1.10.3/cfitsio/zlib/trees.h0000664000175000017500000002043013010375005017212 0ustar zoncazonca00000000000000/* header created automatically with -DGEN_TREES_H */ local const ct_data static_ltree[L_CODES+2] = { {{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, {{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, {{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, {{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, {{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, {{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, {{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, {{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, {{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, {{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, {{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, {{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, {{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, {{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, {{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, {{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, {{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, {{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, {{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, {{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, {{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, {{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, {{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, {{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, {{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, {{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, {{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, {{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, {{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, {{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, {{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, {{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, {{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, {{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, {{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, {{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, {{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, {{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, {{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, {{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, {{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, {{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, {{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, {{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, {{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, {{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, {{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, {{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, {{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, {{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, {{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, {{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, {{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, {{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, {{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, {{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, {{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, {{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} }; local const ct_data static_dtree[D_CODES] = { {{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, {{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, {{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, {{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, {{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, {{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} }; const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 }; const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 }; local const int base_length[LENGTH_CODES] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0 }; local const int base_dist[D_CODES] = { 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 }; healpy-1.10.3/cfitsio/zlib/uncompr.c0000664000175000017500000000367113010375005017556 0ustar zoncazonca00000000000000/* uncompr.c -- decompress a memory buffer * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. * For conditions of distribution and use, see copyright notice in zlib.h */ #define ZLIB_INTERNAL #include "zlib.h" /* =========================================================================== Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size of the destination buffer, which must be large enough to hold the entire uncompressed data. (The size of the uncompressed data must have been saved previously by the compressor and transmitted to the decompressor by some mechanism outside the scope of this compression library.) Upon exit, destLen is the actual size of the compressed buffer. uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if there was not enough room in the output buffer, or Z_DATA_ERROR if the input data was corrupted. */ int ZEXPORT uncompress (dest, destLen, source, sourceLen) Bytef *dest; uLongf *destLen; const Bytef *source; uLong sourceLen; { z_stream stream; int err; stream.next_in = (Bytef*)source; stream.avail_in = (uInt)sourceLen; /* Check for source > 64K on 16-bit machine: */ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; stream.next_out = dest; stream.avail_out = (uInt)*destLen; if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; stream.zalloc = (alloc_func)0; stream.zfree = (free_func)0; err = inflateInit(&stream); if (err != Z_OK) return err; err = inflate(&stream, Z_FINISH); if (err != Z_STREAM_END) { inflateEnd(&stream); if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) return Z_DATA_ERROR; return err; } *destLen = stream.total_out; err = inflateEnd(&stream); return err; } healpy-1.10.3/cfitsio/zlib/zcompress.c0000664000175000017500000004230313010375005020113 0ustar zoncazonca00000000000000#include #include #include #include #include "zlib.h" #define GZBUFSIZE 115200 /* 40 FITS blocks */ #define BUFFINCR 28800 /* 10 FITS blocks */ /* prototype for the following functions */ int uncompress2mem(char *filename, FILE *diskfile, char **buffptr, size_t *buffsize, void *(*mem_realloc)(void *p, size_t newsize), size_t *filesize, int *status); int uncompress2mem_from_mem( char *inmemptr, size_t inmemsize, char **buffptr, size_t *buffsize, void *(*mem_realloc)(void *p, size_t newsize), size_t *filesize, int *status); int uncompress2file(char *filename, FILE *indiskfile, FILE *outdiskfile, int *status); int compress2mem_from_mem( char *inmemptr, size_t inmemsize, char **buffptr, size_t *buffsize, void *(*mem_realloc)(void *p, size_t newsize), size_t *filesize, int *status); int compress2file_from_mem( char *inmemptr, size_t inmemsize, FILE *outdiskfile, size_t *filesize, /* O - size of file, in bytes */ int *status); /*--------------------------------------------------------------------------*/ int uncompress2mem(char *filename, /* name of input file */ FILE *diskfile, /* I - file pointer */ char **buffptr, /* IO - memory pointer */ size_t *buffsize, /* IO - size of buffer, in bytes */ void *(*mem_realloc)(void *p, size_t newsize), /* function */ size_t *filesize, /* O - size of file, in bytes */ int *status) /* IO - error status */ /* Uncompress the disk file into memory. Fill whatever amount of memory has already been allocated, then realloc more memory, using the supplied input function, if necessary. */ { int err, len; char *filebuff; z_stream d_stream; /* decompression stream */ if (*status > 0) return(*status); /* Allocate memory to hold compressed bytes read from the file. */ filebuff = (char*)malloc(GZBUFSIZE); if (!filebuff) return(*status = 113); /* memory error */ d_stream.zalloc = (alloc_func)0; d_stream.zfree = (free_func)0; d_stream.opaque = (voidpf)0; d_stream.next_out = (unsigned char*) *buffptr; d_stream.avail_out = *buffsize; /* Initialize the decompression. The argument (15+16) tells the decompressor that we are to use the gzip algorithm */ err = inflateInit2(&d_stream, (15+16)); if (err != Z_OK) return(*status = 414); /* loop through the file, reading a buffer and uncompressing it */ for (;;) { len = fread(filebuff, 1, GZBUFSIZE, diskfile); if (ferror(diskfile)) { inflateEnd(&d_stream); free(filebuff); return(*status = 414); } if (len == 0) break; /* no more data */ d_stream.next_in = (unsigned char*)filebuff; d_stream.avail_in = len; for (;;) { /* uncompress as much of the input as will fit in the output */ err = inflate(&d_stream, Z_NO_FLUSH); if (err == Z_STREAM_END ) { /* We reached the end of the input */ break; } else if (err == Z_OK ) { if (!d_stream.avail_in) break; /* need more input */ /* need more space in output buffer */ if (mem_realloc) { *buffptr = mem_realloc(*buffptr,*buffsize + BUFFINCR); if (*buffptr == NULL){ inflateEnd(&d_stream); free(filebuff); return(*status = 414); /* memory allocation failed */ } d_stream.avail_out = BUFFINCR; d_stream.next_out = (unsigned char*) (*buffptr + *buffsize); *buffsize = *buffsize + BUFFINCR; } else { /* error: no realloc function available */ inflateEnd(&d_stream); free(filebuff); return(*status = 414); } } else { /* some other error */ inflateEnd(&d_stream); free(filebuff); return(*status = 414); } } if (feof(diskfile)) break; d_stream.next_out = (unsigned char*) (*buffptr + d_stream.total_out); d_stream.avail_out = *buffsize - d_stream.total_out; } /* Set the output file size to be the total output data */ *filesize = d_stream.total_out; free(filebuff); /* free temporary output data buffer */ err = inflateEnd(&d_stream); /* End the decompression */ if (err != Z_OK) return(*status = 414); return(*status); } /*--------------------------------------------------------------------------*/ int uncompress2mem_from_mem( char *inmemptr, /* I - memory pointer to compressed bytes */ size_t inmemsize, /* I - size of input compressed file */ char **buffptr, /* IO - memory pointer */ size_t *buffsize, /* IO - size of buffer, in bytes */ void *(*mem_realloc)(void *p, size_t newsize), /* function */ size_t *filesize, /* O - size of file, in bytes */ int *status) /* IO - error status */ /* Uncompress the file in memory into memory. Fill whatever amount of memory has already been allocated, then realloc more memory, using the supplied input function, if necessary. */ { int err; z_stream d_stream; /* decompression stream */ if (*status > 0) return(*status); d_stream.zalloc = (alloc_func)0; d_stream.zfree = (free_func)0; d_stream.opaque = (voidpf)0; /* Initialize the decompression. The argument (15+16) tells the decompressor that we are to use the gzip algorithm */ err = inflateInit2(&d_stream, (15+16)); if (err != Z_OK) return(*status = 414); d_stream.next_in = (unsigned char*)inmemptr; d_stream.avail_in = inmemsize; d_stream.next_out = (unsigned char*) *buffptr; d_stream.avail_out = *buffsize; for (;;) { /* uncompress as much of the input as will fit in the output */ err = inflate(&d_stream, Z_NO_FLUSH); if (err == Z_STREAM_END) { /* We reached the end of the input */ break; } else if (err == Z_OK ) { /* need more space in output buffer */ if (mem_realloc) { *buffptr = mem_realloc(*buffptr,*buffsize + BUFFINCR); if (*buffptr == NULL){ inflateEnd(&d_stream); return(*status = 414); /* memory allocation failed */ } d_stream.avail_out = BUFFINCR; d_stream.next_out = (unsigned char*) (*buffptr + *buffsize); *buffsize = *buffsize + BUFFINCR; } else { /* error: no realloc function available */ inflateEnd(&d_stream); return(*status = 414); } } else { /* some other error */ inflateEnd(&d_stream); return(*status = 414); } } /* Set the output file size to be the total output data */ if (filesize) *filesize = d_stream.total_out; /* End the decompression */ err = inflateEnd(&d_stream); if (err != Z_OK) return(*status = 414); return(*status); } /*--------------------------------------------------------------------------*/ int uncompress2file(char *filename, /* name of input file */ FILE *indiskfile, /* I - input file pointer */ FILE *outdiskfile, /* I - output file pointer */ int *status) /* IO - error status */ /* Uncompress the file into another file. */ { int err, len; unsigned long bytes_out = 0; char *infilebuff, *outfilebuff; z_stream d_stream; /* decompression stream */ if (*status > 0) return(*status); /* Allocate buffers to hold compressed and uncompressed */ infilebuff = (char*)malloc(GZBUFSIZE); if (!infilebuff) return(*status = 113); /* memory error */ outfilebuff = (char*)malloc(GZBUFSIZE); if (!outfilebuff) return(*status = 113); /* memory error */ d_stream.zalloc = (alloc_func)0; d_stream.zfree = (free_func)0; d_stream.opaque = (voidpf)0; d_stream.next_out = (unsigned char*) outfilebuff; d_stream.avail_out = GZBUFSIZE; /* Initialize the decompression. The argument (15+16) tells the decompressor that we are to use the gzip algorithm */ err = inflateInit2(&d_stream, (15+16)); if (err != Z_OK) return(*status = 414); /* loop through the file, reading a buffer and uncompressing it */ for (;;) { len = fread(infilebuff, 1, GZBUFSIZE, indiskfile); if (ferror(indiskfile)) { inflateEnd(&d_stream); free(infilebuff); free(outfilebuff); return(*status = 414); } if (len == 0) break; /* no more data */ d_stream.next_in = (unsigned char*)infilebuff; d_stream.avail_in = len; for (;;) { /* uncompress as much of the input as will fit in the output */ err = inflate(&d_stream, Z_NO_FLUSH); if (err == Z_STREAM_END ) { /* We reached the end of the input */ break; } else if (err == Z_OK ) { if (!d_stream.avail_in) break; /* need more input */ /* flush out the full output buffer */ if ((int)fwrite(outfilebuff, 1, GZBUFSIZE, outdiskfile) != GZBUFSIZE) { inflateEnd(&d_stream); free(infilebuff); free(outfilebuff); return(*status = 414); } bytes_out += GZBUFSIZE; d_stream.next_out = (unsigned char*) outfilebuff; d_stream.avail_out = GZBUFSIZE; } else { /* some other error */ inflateEnd(&d_stream); free(infilebuff); free(outfilebuff); return(*status = 414); } } if (feof(indiskfile)) break; } /* write out any remaining bytes in the buffer */ if (d_stream.total_out > bytes_out) { if ((int)fwrite(outfilebuff, 1, (d_stream.total_out - bytes_out), outdiskfile) != (d_stream.total_out - bytes_out)) { inflateEnd(&d_stream); free(infilebuff); free(outfilebuff); return(*status = 414); } } free(infilebuff); /* free temporary output data buffer */ free(outfilebuff); /* free temporary output data buffer */ err = inflateEnd(&d_stream); /* End the decompression */ if (err != Z_OK) return(*status = 414); return(*status); } /*--------------------------------------------------------------------------*/ int compress2mem_from_mem( char *inmemptr, /* I - memory pointer to uncompressed bytes */ size_t inmemsize, /* I - size of input uncompressed file */ char **buffptr, /* IO - memory pointer for compressed file */ size_t *buffsize, /* IO - size of buffer, in bytes */ void *(*mem_realloc)(void *p, size_t newsize), /* function */ size_t *filesize, /* O - size of file, in bytes */ int *status) /* IO - error status */ /* Compress the file into memory. Fill whatever amount of memory has already been allocated, then realloc more memory, using the supplied input function, if necessary. */ { int err; z_stream c_stream; /* compression stream */ if (*status > 0) return(*status); c_stream.zalloc = (alloc_func)0; c_stream.zfree = (free_func)0; c_stream.opaque = (voidpf)0; /* Initialize the compression. The argument (15+16) tells the compressor that we are to use the gzip algorythm. Also use Z_BEST_SPEED for maximum speed with very minor loss in compression factor. */ err = deflateInit2(&c_stream, Z_BEST_SPEED, Z_DEFLATED, (15+16), 8, Z_DEFAULT_STRATEGY); if (err != Z_OK) return(*status = 413); c_stream.next_in = (unsigned char*)inmemptr; c_stream.avail_in = inmemsize; c_stream.next_out = (unsigned char*) *buffptr; c_stream.avail_out = *buffsize; for (;;) { /* compress as much of the input as will fit in the output */ err = deflate(&c_stream, Z_FINISH); if (err == Z_STREAM_END) { /* We reached the end of the input */ break; } else if (err == Z_OK ) { /* need more space in output buffer */ if (mem_realloc) { *buffptr = mem_realloc(*buffptr,*buffsize + BUFFINCR); if (*buffptr == NULL){ deflateEnd(&c_stream); return(*status = 413); /* memory allocation failed */ } c_stream.avail_out = BUFFINCR; c_stream.next_out = (unsigned char*) (*buffptr + *buffsize); *buffsize = *buffsize + BUFFINCR; } else { /* error: no realloc function available */ deflateEnd(&c_stream); return(*status = 413); } } else { /* some other error */ deflateEnd(&c_stream); return(*status = 413); } } /* Set the output file size to be the total output data */ if (filesize) *filesize = c_stream.total_out; /* End the compression */ err = deflateEnd(&c_stream); if (err != Z_OK) return(*status = 413); return(*status); } /*--------------------------------------------------------------------------*/ int compress2file_from_mem( char *inmemptr, /* I - memory pointer to uncompressed bytes */ size_t inmemsize, /* I - size of input uncompressed file */ FILE *outdiskfile, size_t *filesize, /* O - size of file, in bytes */ int *status) /* Compress the memory file into disk file. */ { int err; unsigned long bytes_out = 0; char *outfilebuff; z_stream c_stream; /* compression stream */ if (*status > 0) return(*status); /* Allocate buffer to hold compressed bytes */ outfilebuff = (char*)malloc(GZBUFSIZE); if (!outfilebuff) return(*status = 113); /* memory error */ c_stream.zalloc = (alloc_func)0; c_stream.zfree = (free_func)0; c_stream.opaque = (voidpf)0; /* Initialize the compression. The argument (15+16) tells the compressor that we are to use the gzip algorythm. Also use Z_BEST_SPEED for maximum speed with very minor loss in compression factor. */ err = deflateInit2(&c_stream, Z_BEST_SPEED, Z_DEFLATED, (15+16), 8, Z_DEFAULT_STRATEGY); if (err != Z_OK) return(*status = 413); c_stream.next_in = (unsigned char*)inmemptr; c_stream.avail_in = inmemsize; c_stream.next_out = (unsigned char*) outfilebuff; c_stream.avail_out = GZBUFSIZE; for (;;) { /* compress as much of the input as will fit in the output */ err = deflate(&c_stream, Z_FINISH); if (err == Z_STREAM_END) { /* We reached the end of the input */ break; } else if (err == Z_OK ) { /* need more space in output buffer */ /* flush out the full output buffer */ if ((int)fwrite(outfilebuff, 1, GZBUFSIZE, outdiskfile) != GZBUFSIZE) { deflateEnd(&c_stream); free(outfilebuff); return(*status = 413); } bytes_out += GZBUFSIZE; c_stream.next_out = (unsigned char*) outfilebuff; c_stream.avail_out = GZBUFSIZE; } else { /* some other error */ deflateEnd(&c_stream); free(outfilebuff); return(*status = 413); } } /* write out any remaining bytes in the buffer */ if (c_stream.total_out > bytes_out) { if ((int)fwrite(outfilebuff, 1, (c_stream.total_out - bytes_out), outdiskfile) != (c_stream.total_out - bytes_out)) { deflateEnd(&c_stream); free(outfilebuff); return(*status = 413); } } free(outfilebuff); /* free temporary output data buffer */ /* Set the output file size to be the total output data */ if (filesize) *filesize = c_stream.total_out; /* End the compression */ err = deflateEnd(&c_stream); if (err != Z_OK) return(*status = 413); return(*status); } healpy-1.10.3/cfitsio/zlib/zconf.h0000664000175000017500000003205113010375005017211 0ustar zoncazonca00000000000000/* zconf.h -- configuration of the zlib compression library * Copyright (C) 1995-2010 Jean-loup Gailly. * For conditions of distribution and use, see copyright notice in zlib.h */ #ifndef ZCONF_H #define ZCONF_H /* * If you *really* need a unique prefix for all types and library functions, * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. * Even better than compiling with -DZ_PREFIX would be to use configure to set * this permanently in zconf.h using "./configure --zprefix". */ #ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ /* all linked symbols */ # define _dist_code z__dist_code # define _length_code z__length_code # define _tr_align z__tr_align # define _tr_flush_block z__tr_flush_block # define _tr_init z__tr_init # define _tr_stored_block z__tr_stored_block # define _tr_tally z__tr_tally # define adler32 z_adler32 # define adler32_combine z_adler32_combine # define adler32_combine64 z_adler32_combine64 # define compress z_compress # define compress2 z_compress2 # define compressBound z_compressBound # define crc32 z_crc32 # define crc32_combine z_crc32_combine # define crc32_combine64 z_crc32_combine64 # define deflate z_deflate # define deflateBound z_deflateBound # define deflateCopy z_deflateCopy # define deflateEnd z_deflateEnd # define deflateInit2_ z_deflateInit2_ # define deflateInit_ z_deflateInit_ # define deflateParams z_deflateParams # define deflatePrime z_deflatePrime # define deflateReset z_deflateReset # define deflateSetDictionary z_deflateSetDictionary # define deflateSetHeader z_deflateSetHeader # define deflateTune z_deflateTune # define deflate_copyright z_deflate_copyright # define get_crc_table z_get_crc_table # define gz_error z_gz_error # define gz_intmax z_gz_intmax # define gz_strwinerror z_gz_strwinerror # define gzbuffer z_gzbuffer # define gzclearerr z_gzclearerr # define gzclose z_gzclose # define gzclose_r z_gzclose_r # define gzclose_w z_gzclose_w # define gzdirect z_gzdirect # define gzdopen z_gzdopen # define gzeof z_gzeof # define gzerror z_gzerror # define gzflush z_gzflush # define gzgetc z_gzgetc # define gzgets z_gzgets # define gzoffset z_gzoffset # define gzoffset64 z_gzoffset64 # define gzopen z_gzopen # define gzopen64 z_gzopen64 # define gzprintf z_gzprintf # define gzputc z_gzputc # define gzputs z_gzputs # define gzread z_gzread # define gzrewind z_gzrewind # define gzseek z_gzseek # define gzseek64 z_gzseek64 # define gzsetparams z_gzsetparams # define gztell z_gztell # define gztell64 z_gztell64 # define gzungetc z_gzungetc # define gzwrite z_gzwrite # define inflate z_inflate # define inflateBack z_inflateBack # define inflateBackEnd z_inflateBackEnd # define inflateBackInit_ z_inflateBackInit_ # define inflateCopy z_inflateCopy # define inflateEnd z_inflateEnd # define inflateGetHeader z_inflateGetHeader # define inflateInit2_ z_inflateInit2_ # define inflateInit_ z_inflateInit_ # define inflateMark z_inflateMark # define inflatePrime z_inflatePrime # define inflateReset z_inflateReset # define inflateReset2 z_inflateReset2 # define inflateSetDictionary z_inflateSetDictionary # define inflateSync z_inflateSync # define inflateSyncPoint z_inflateSyncPoint # define inflateUndermine z_inflateUndermine # define inflate_copyright z_inflate_copyright # define inflate_fast z_inflate_fast # define inflate_table z_inflate_table # define uncompress z_uncompress # define zError z_zError # define zcalloc z_zcalloc # define zcfree z_zcfree # define zlibCompileFlags z_zlibCompileFlags # define zlibVersion z_zlibVersion /* all zlib typedefs in zlib.h and zconf.h */ # define Byte z_Byte # define Bytef z_Bytef # define alloc_func z_alloc_func # define charf z_charf # define free_func z_free_func # define gzFile z_gzFile # define gz_header z_gz_header # define gz_headerp z_gz_headerp # define in_func z_in_func # define intf z_intf # define out_func z_out_func # define uInt z_uInt # define uIntf z_uIntf # define uLong z_uLong # define uLongf z_uLongf # define voidp z_voidp # define voidpc z_voidpc # define voidpf z_voidpf /* all zlib structs in zlib.h and zconf.h */ # define gz_header_s z_gz_header_s # define internal_state z_internal_state #endif #if defined(__MSDOS__) && !defined(MSDOS) # define MSDOS #endif #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) # define OS2 #endif #if defined(_WINDOWS) && !defined(WINDOWS) # define WINDOWS #endif #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) # ifndef WIN32 # define WIN32 # endif #endif #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) # if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) # ifndef SYS16BIT # define SYS16BIT # endif # endif #endif /* * Compile with -DMAXSEG_64K if the alloc function cannot allocate more * than 64k bytes at a time (needed on systems with 16-bit int). */ #ifdef SYS16BIT # define MAXSEG_64K #endif #ifdef MSDOS # define UNALIGNED_OK #endif #ifdef __STDC_VERSION__ # ifndef STDC # define STDC # endif # if __STDC_VERSION__ >= 199901L # ifndef STDC99 # define STDC99 # endif # endif #endif #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) # define STDC #endif #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) # define STDC #endif #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) # define STDC #endif #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) # define STDC #endif #if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ # define STDC #endif #ifndef STDC # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ # define const /* note: need a more gentle solution here */ # endif #endif /* Some Mac compilers merge all .h files incorrectly: */ #if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) # define NO_DUMMY_DECL #endif /* Maximum value for memLevel in deflateInit2 */ #ifndef MAX_MEM_LEVEL # ifdef MAXSEG_64K # define MAX_MEM_LEVEL 8 # else # define MAX_MEM_LEVEL 9 # endif #endif /* Maximum value for windowBits in deflateInit2 and inflateInit2. * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files * created by gzip. (Files created by minigzip can still be extracted by * gzip.) */ #ifndef MAX_WBITS # define MAX_WBITS 15 /* 32K LZ77 window */ #endif /* The memory requirements for deflate are (in bytes): (1 << (windowBits+2)) + (1 << (memLevel+9)) that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) plus a few kilobytes for small objects. For example, if you want to reduce the default memory requirements from 256K to 128K, compile with make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" Of course this will generally degrade compression (there's no free lunch). The memory requirements for inflate are (in bytes) 1 << windowBits that is, 32K for windowBits=15 (default value) plus a few kilobytes for small objects. */ /* Type declarations */ #ifndef OF /* function prototypes */ # ifdef STDC # define OF(args) args # else # define OF(args) () # endif #endif /* The following definitions for FAR are needed only for MSDOS mixed * model programming (small or medium model with some far allocations). * This was tested only with MSC; for other MSDOS compilers you may have * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, * just define FAR to be empty. */ #ifdef SYS16BIT # if defined(M_I86SM) || defined(M_I86MM) /* MSC small or medium model */ # define SMALL_MEDIUM # ifdef _MSC_VER # define FAR _far # else # define FAR far # endif # endif # if (defined(__SMALL__) || defined(__MEDIUM__)) /* Turbo C small or medium model */ # define SMALL_MEDIUM # ifdef __BORLANDC__ # define FAR _far # else # define FAR far # endif # endif #endif #if defined(WINDOWS) || defined(WIN32) /* If building or using zlib as a DLL, define ZLIB_DLL. * This is not mandatory, but it offers a little performance increase. */ # ifdef ZLIB_DLL # if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) # ifdef ZLIB_INTERNAL # define ZEXTERN extern __declspec(dllexport) # else # define ZEXTERN extern __declspec(dllimport) # endif # endif # endif /* ZLIB_DLL */ /* If building or using zlib with the WINAPI/WINAPIV calling convention, * define ZLIB_WINAPI. * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. */ # ifdef ZLIB_WINAPI # ifdef FAR # undef FAR # endif # include /* No need for _export, use ZLIB.DEF instead. */ /* For complete Windows compatibility, use WINAPI, not __stdcall. */ # define ZEXPORT WINAPI # ifdef WIN32 # define ZEXPORTVA WINAPIV # else # define ZEXPORTVA FAR CDECL # endif # endif #endif #if defined (__BEOS__) # ifdef ZLIB_DLL # ifdef ZLIB_INTERNAL # define ZEXPORT __declspec(dllexport) # define ZEXPORTVA __declspec(dllexport) # else # define ZEXPORT __declspec(dllimport) # define ZEXPORTVA __declspec(dllimport) # endif # endif #endif #ifndef ZEXTERN # define ZEXTERN extern #endif #ifndef ZEXPORT # define ZEXPORT #endif #ifndef ZEXPORTVA # define ZEXPORTVA #endif #ifndef FAR # define FAR #endif #if !defined(__MACTYPES__) typedef unsigned char Byte; /* 8 bits */ #endif typedef unsigned int uInt; /* 16 bits or more */ typedef unsigned long uLong; /* 32 bits or more */ #ifdef SMALL_MEDIUM /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ # define Bytef Byte FAR #else typedef Byte FAR Bytef; #endif typedef char FAR charf; typedef int FAR intf; typedef uInt FAR uIntf; typedef uLong FAR uLongf; #ifdef STDC typedef void const *voidpc; typedef void FAR *voidpf; typedef void *voidp; #else typedef Byte const *voidpc; typedef Byte FAR *voidpf; typedef Byte *voidp; #endif #if !defined(MSDOS) && !defined(WINDOWS) && !defined(WIN32) # define Z_HAVE_UNISTD_H #endif #ifdef STDC # include /* for off_t */ #endif /* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even * though the former does not conform to the LFS document), but considering * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as * equivalently requesting no 64-bit operations */ #if -_LARGEFILE64_SOURCE - -1 == 1 # undef _LARGEFILE64_SOURCE #endif #if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) # include /* for SEEK_* and off_t */ # ifdef VMS # include /* for off_t */ # endif # ifndef z_off_t # define z_off_t off_t # endif #endif #ifndef SEEK_SET # define SEEK_SET 0 /* Seek from beginning of file. */ # define SEEK_CUR 1 /* Seek from current position. */ # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ #endif #ifndef z_off_t # define z_off_t long #endif #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 # define z_off64_t off64_t #else # define z_off64_t z_off_t #endif #if defined(__OS400__) # define NO_vsnprintf #endif #if defined(__MVS__) # define NO_vsnprintf #endif /* MVS linker does not support external names larger than 8 bytes */ #if defined(__MVS__) #pragma map(deflateInit_,"DEIN") #pragma map(deflateInit2_,"DEIN2") #pragma map(deflateEnd,"DEEND") #pragma map(deflateBound,"DEBND") #pragma map(inflateInit_,"ININ") #pragma map(inflateInit2_,"ININ2") #pragma map(inflateEnd,"INEND") #pragma map(inflateSync,"INSY") #pragma map(inflateSetDictionary,"INSEDI") #pragma map(compressBound,"CMBND") #pragma map(inflate_table,"INTABL") #pragma map(inflate_fast,"INFA") #pragma map(inflate_copyright,"INCOPY") #endif #endif /* ZCONF_H */ healpy-1.10.3/cfitsio/zlib/zlib.h0000664000175000017500000023331413010375005017037 0ustar zoncazonca00000000000000/* zlib.h -- interface of the 'zlib' general purpose compression library version 1.2.5, April 19th, 2010 Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). */ #ifndef ZLIB_H #define ZLIB_H #include "zconf.h" #ifdef __cplusplus extern "C" { #endif #define ZLIB_VERSION "1.2.5" #define ZLIB_VERNUM 0x1250 #define ZLIB_VER_MAJOR 1 #define ZLIB_VER_MINOR 2 #define ZLIB_VER_REVISION 5 #define ZLIB_VER_SUBREVISION 0 /* The 'zlib' compression library provides in-memory compression and decompression functions, including integrity checks of the uncompressed data. This version of the library supports only one compression method (deflation) but other algorithms will be added later and will have the same stream interface. Compression can be done in a single step if the buffers are large enough, or can be done by repeated calls of the compression function. In the latter case, the application must provide more input and/or consume the output (providing more output space) before each call. The compressed data format used by default by the in-memory functions is the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped around a deflate stream, which is itself documented in RFC 1951. The library also supports reading and writing files in gzip (.gz) format with an interface similar to that of stdio using the functions that start with "gz". The gzip format is different from the zlib format. gzip is a gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. This library can optionally read and write gzip streams in memory as well. The zlib format was designed to be compact and fast for use in memory and on communications channels. The gzip format was designed for single- file compression on file systems, has a larger header than zlib to maintain directory information, and uses a different, slower check method than zlib. The library does not install any signal handler. The decoder checks the consistency of the compressed data, so the library should never crash even in case of corrupted input. */ typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); typedef void (*free_func) OF((voidpf opaque, voidpf address)); struct internal_state; typedef struct z_stream_s { Bytef *next_in; /* next input byte */ uInt avail_in; /* number of bytes available at next_in */ uLong total_in; /* total nb of input bytes read so far */ Bytef *next_out; /* next output byte should be put there */ uInt avail_out; /* remaining free space at next_out */ uLong total_out; /* total nb of bytes output so far */ char *msg; /* last error message, NULL if no error */ struct internal_state FAR *state; /* not visible by applications */ alloc_func zalloc; /* used to allocate the internal state */ free_func zfree; /* used to free the internal state */ voidpf opaque; /* private data object passed to zalloc and zfree */ int data_type; /* best guess about the data type: binary or text */ uLong adler; /* adler32 value of the uncompressed data */ uLong reserved; /* reserved for future use */ } z_stream; typedef z_stream FAR *z_streamp; /* gzip header information passed to and from zlib routines. See RFC 1952 for more details on the meanings of these fields. */ typedef struct gz_header_s { int text; /* true if compressed data believed to be text */ uLong time; /* modification time */ int xflags; /* extra flags (not used when writing a gzip file) */ int os; /* operating system */ Bytef *extra; /* pointer to extra field or Z_NULL if none */ uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ uInt extra_max; /* space at extra (only when reading header) */ Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ uInt name_max; /* space at name (only when reading header) */ Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ uInt comm_max; /* space at comment (only when reading header) */ int hcrc; /* true if there was or will be a header crc */ int done; /* true when done reading gzip header (not used when writing a gzip file) */ } gz_header; typedef gz_header FAR *gz_headerp; /* The application must update next_in and avail_in when avail_in has dropped to zero. It must update next_out and avail_out when avail_out has dropped to zero. The application must initialize zalloc, zfree and opaque before calling the init function. All other fields are set by the compression library and must not be updated by the application. The opaque value provided by the application will be passed as the first parameter for calls of zalloc and zfree. This can be useful for custom memory management. The compression library attaches no meaning to the opaque value. zalloc must return Z_NULL if there is not enough memory for the object. If zlib is used in a multi-threaded application, zalloc and zfree must be thread safe. On 16-bit systems, the functions zalloc and zfree must be able to allocate exactly 65536 bytes, but will not be required to allocate more than this if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers returned by zalloc for objects of exactly 65536 bytes *must* have their offset normalized to zero. The default allocation function provided by this library ensures this (see zutil.c). To reduce memory requirements and avoid any allocation of 64K objects, at the expense of compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). The fields total_in and total_out can be used for statistics or progress reports. After compression, total_in holds the total size of the uncompressed data and may be saved for use in the decompressor (particularly if the decompressor wants to decompress everything in a single step). */ /* constants */ #define Z_NO_FLUSH 0 #define Z_PARTIAL_FLUSH 1 #define Z_SYNC_FLUSH 2 #define Z_FULL_FLUSH 3 #define Z_FINISH 4 #define Z_BLOCK 5 #define Z_TREES 6 /* Allowed flush values; see deflate() and inflate() below for details */ #define Z_OK 0 #define Z_STREAM_END 1 #define Z_NEED_DICT 2 #define Z_ERRNO (-1) #define Z_STREAM_ERROR (-2) #define Z_DATA_ERROR (-3) #define Z_MEM_ERROR (-4) #define Z_BUF_ERROR (-5) #define Z_VERSION_ERROR (-6) /* Return codes for the compression/decompression functions. Negative values * are errors, positive values are used for special but normal events. */ #define Z_NO_COMPRESSION 0 #define Z_BEST_SPEED 1 #define Z_BEST_COMPRESSION 9 #define Z_DEFAULT_COMPRESSION (-1) /* compression levels */ #define Z_FILTERED 1 #define Z_HUFFMAN_ONLY 2 #define Z_RLE 3 #define Z_FIXED 4 #define Z_DEFAULT_STRATEGY 0 /* compression strategy; see deflateInit2() below for details */ #define Z_BINARY 0 #define Z_TEXT 1 #define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ #define Z_UNKNOWN 2 /* Possible values of the data_type field (though see inflate()) */ #define Z_DEFLATED 8 /* The deflate compression method (the only one supported in this version) */ #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ #define zlib_version zlibVersion() /* for compatibility with versions < 1.0.2 */ /* basic functions */ ZEXTERN const char * ZEXPORT zlibVersion OF((void)); /* The application can compare zlibVersion and ZLIB_VERSION for consistency. If the first character differs, the library code actually used is not compatible with the zlib.h header file used by the application. This check is automatically made by deflateInit and inflateInit. */ /* ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); Initializes the internal stream state for compression. The fields zalloc, zfree and opaque must be initialized before by the caller. If zalloc and zfree are set to Z_NULL, deflateInit updates them to use default allocation functions. The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: 1 gives best speed, 9 gives best compression, 0 gives no compression at all (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION requests a default compromise between speed and compression (currently equivalent to level 6). deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if level is not a valid compression level, or Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible with the version assumed by the caller (ZLIB_VERSION). msg is set to null if there is no error message. deflateInit does not perform any compression: this will be done by deflate(). */ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); /* deflate compresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce some output latency (reading input without producing any output) except when forced to flush. The detailed semantics are as follows. deflate performs one or both of the following actions: - Compress more input starting at next_in and update next_in and avail_in accordingly. If not all input can be processed (because there is not enough room in the output buffer), next_in and avail_in are updated and processing will resume at this point for the next call of deflate(). - Provide more output starting at next_out and update next_out and avail_out accordingly. This action is forced if the parameter flush is non zero. Forcing flush frequently degrades the compression ratio, so this parameter should be set only when necessary (in interactive applications). Some output may be provided even if flush is not set. Before the call of deflate(), the application should ensure that at least one of the actions is possible, by providing more input and/or consuming more output, and updating avail_in or avail_out accordingly; avail_out should never be zero before the call. The application can consume the compressed output when it wants, for example when the output buffer is full (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK and with zero avail_out, it must be called again after making room in the output buffer because there might be more output pending. Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to decide how much data to accumulate before producing output, in order to maximize compression. If the parameter flush is set to Z_SYNC_FLUSH, all pending output is flushed to the output buffer and the output is aligned on a byte boundary, so that the decompressor can get all input data available so far. (In particular avail_in is zero after the call if enough output space has been provided before the call.) Flushing may degrade compression for some compression algorithms and so it should be used only when necessary. This completes the current deflate block and follows it with an empty stored block that is three bits plus filler bits to the next byte, followed by four bytes (00 00 ff ff). If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the output buffer, but the output is not aligned to a byte boundary. All of the input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. This completes the current deflate block and follows it with an empty fixed codes block that is 10 bits long. This assures that enough bytes are output in order for the decompressor to finish the block before the empty fixed code block. If flush is set to Z_BLOCK, a deflate block is completed and emitted, as for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to seven bits of the current block are held to be written as the next byte after the next deflate block is completed. In this case, the decompressor may not be provided enough bits at this point in order to complete decompression of the data provided so far to the compressor. It may need to wait for the next block to be emitted. This is for advanced applications that need to control the emission of deflate blocks. If flush is set to Z_FULL_FLUSH, all output is flushed as with Z_SYNC_FLUSH, and the compression state is reset so that decompression can restart from this point if previous compressed data has been damaged or if random access is desired. Using Z_FULL_FLUSH too often can seriously degrade compression. If deflate returns with avail_out == 0, this function must be called again with the same value of the flush parameter and more output space (updated avail_out), until the flush is complete (deflate returns with non-zero avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that avail_out is greater than six to avoid repeated flush markers due to avail_out == 0 on return. If the parameter flush is set to Z_FINISH, pending input is processed, pending output is flushed and deflate returns with Z_STREAM_END if there was enough output space; if deflate returns with Z_OK, this function must be called again with Z_FINISH and more output space (updated avail_out) but no more input data, until it returns with Z_STREAM_END or an error. After deflate has returned Z_STREAM_END, the only possible operations on the stream are deflateReset or deflateEnd. Z_FINISH can be used immediately after deflateInit if all the compression is to be done in a single step. In this case, avail_out must be at least the value returned by deflateBound (see below). If deflate does not return Z_STREAM_END, then it must be called again as described above. deflate() sets strm->adler to the adler32 checksum of all input read so far (that is, total_in bytes). deflate() may update strm->data_type if it can make a good guess about the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered binary. This field is only for information purposes and does not affect the compression algorithm in any manner. deflate() returns Z_OK if some progress has been made (more input processed or more output produced), Z_STREAM_END if all input has been consumed and all output has been produced (only when flush is set to Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and deflate() can be called again with more input and more output space to continue compressing. */ ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending output. deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state was inconsistent, Z_DATA_ERROR if the stream was freed prematurely (some input or output was discarded). In the error case, msg may be set but then points to a static string (which must not be deallocated). */ /* ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); Initializes the internal stream state for decompression. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized before by the caller. If next_in is not Z_NULL and avail_in is large enough (the exact value depends on the compression method), inflateInit determines the compression method from the zlib header and allocates all data structures accordingly; otherwise the allocation will be deferred to the first call of inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to use default allocation functions. inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_VERSION_ERROR if the zlib library version is incompatible with the version assumed by the caller, or Z_STREAM_ERROR if the parameters are invalid, such as a null pointer to the structure. msg is set to null if there is no error message. inflateInit does not perform any decompression apart from possibly reading the zlib header if present: actual decompression will be done by inflate(). (So next_in and avail_in may be modified, but next_out and avail_out are unused and unchanged.) The current implementation of inflateInit() does not process any header information -- that is deferred until inflate() is called. */ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); /* inflate decompresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce some output latency (reading input without producing any output) except when forced to flush. The detailed semantics are as follows. inflate performs one or both of the following actions: - Decompress more input starting at next_in and update next_in and avail_in accordingly. If not all input can be processed (because there is not enough room in the output buffer), next_in is updated and processing will resume at this point for the next call of inflate(). - Provide more output starting at next_out and update next_out and avail_out accordingly. inflate() provides as much output as possible, until there is no more input data or no more space in the output buffer (see below about the flush parameter). Before the call of inflate(), the application should ensure that at least one of the actions is possible, by providing more input and/or consuming more output, and updating the next_* and avail_* values accordingly. The application can consume the uncompressed output when it wants, for example when the output buffer is full (avail_out == 0), or after each call of inflate(). If inflate returns Z_OK and with zero avail_out, it must be called again after making room in the output buffer because there might be more output pending. The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much output as possible to the output buffer. Z_BLOCK requests that inflate() stop if and when it gets to the next deflate block boundary. When decoding the zlib or gzip format, this will cause inflate() to return immediately after the header and before the first block. When doing a raw inflate, inflate() will go ahead and process the first block, and will return when it gets to the end of that block, or when it runs out of data. The Z_BLOCK option assists in appending to or combining deflate streams. Also to assist in this, on return inflate() will set strm->data_type to the number of unused bits in the last byte taken from strm->next_in, plus 64 if inflate() is currently decoding the last block in the deflate stream, plus 128 if inflate() returned immediately after decoding an end-of-block code or decoding the complete header up to just before the first byte of the deflate stream. The end-of-block will not be indicated until all of the uncompressed data from that block has been written to strm->next_out. The number of unused bits may in general be greater than seven, except when bit 7 of data_type is set, in which case the number of unused bits will be less than eight. data_type is set as noted here every time inflate() returns for all flush options, and so can be used to determine the amount of currently consumed input in bits. The Z_TREES option behaves as Z_BLOCK does, but it also returns when the end of each deflate block header is reached, before any actual data in that block is decoded. This allows the caller to determine the length of the deflate block header for later use in random access within a deflate block. 256 is added to the value of strm->data_type when inflate() returns immediately after reaching the end of the deflate block header. inflate() should normally be called until it returns Z_STREAM_END or an error. However if all decompression is to be performed in a single step (a single call of inflate), the parameter flush should be set to Z_FINISH. In this case all pending input is processed and all pending output is flushed; avail_out must be large enough to hold all the uncompressed data. (The size of the uncompressed data may have been saved by the compressor for this purpose.) The next operation on this stream must be inflateEnd to deallocate the decompression state. The use of Z_FINISH is never required, but can be used to inform inflate that a faster approach may be used for the single inflate() call. In this implementation, inflate() always flushes as much output as possible to the output buffer, and always uses the faster approach on the first call. So the only effect of the flush parameter in this implementation is on the return value of inflate(), as noted below, or when it returns early because Z_BLOCK or Z_TREES is used. If a preset dictionary is needed after this call (see inflateSetDictionary below), inflate sets strm->adler to the adler32 checksum of the dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise it sets strm->adler to the adler32 checksum of all output produced so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described below. At the end of the stream, inflate() checks that its computed adler32 checksum is equal to that saved by the compressor and returns Z_STREAM_END only if the checksum is correct. inflate() can decompress and check either zlib-wrapped or gzip-wrapped deflate data. The header type is detected automatically, if requested when initializing with inflateInit2(). Any information contained in the gzip header is not retained, so applications that need that information should instead use raw inflate, see inflateInit2() below, or inflateBack() and perform their own processing of the gzip header and trailer. inflate() returns Z_OK if some progress has been made (more input processed or more output produced), Z_STREAM_END if the end of the compressed data has been reached and all uncompressed output has been produced, Z_NEED_DICT if a preset dictionary is needed at this point, Z_DATA_ERROR if the input data was corrupted (input stream not conforming to the zlib format or incorrect check value), Z_STREAM_ERROR if the stream structure was inconsistent (for example next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no progress is possible or if there was not enough room in the output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and inflate() can be called again with more input and more output space to continue decompressing. If Z_DATA_ERROR is returned, the application may then call inflateSync() to look for a good compression block if a partial recovery of the data is desired. */ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending output. inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state was inconsistent. In the error case, msg may be set but then points to a static string (which must not be deallocated). */ /* Advanced functions */ /* The following functions are needed only in some special applications. */ /* ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy)); This is another version of deflateInit with more compression options. The fields next_in, zalloc, zfree and opaque must be initialized before by the caller. The method parameter is the compression method. It must be Z_DEFLATED in this version of the library. The windowBits parameter is the base two logarithm of the window size (the size of the history buffer). It should be in the range 8..15 for this version of the library. Larger values of this parameter result in better compression at the expense of memory usage. The default value is 15 if deflateInit is used instead. windowBits can also be -8..-15 for raw deflate. In this case, -windowBits determines the window size. deflate() will then generate raw deflate data with no zlib header or trailer, and will not compute an adler32 check value. windowBits can also be greater than 15 for optional gzip encoding. Add 16 to windowBits to write a simple gzip header and trailer around the compressed data instead of a zlib wrapper. The gzip header will have no file name, no extra data, no comment, no modification time (set to zero), no header crc, and the operating system will be set to 255 (unknown). If a gzip stream is being written, strm->adler is a crc32 instead of an adler32. The memLevel parameter specifies how much memory should be allocated for the internal compression state. memLevel=1 uses minimum memory but is slow and reduces compression ratio; memLevel=9 uses maximum memory for optimal speed. The default value is 8. See zconf.h for total memory usage as a function of windowBits and memLevel. The strategy parameter is used to tune the compression algorithm. Use the value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no string match), or Z_RLE to limit match distances to one (run-length encoding). Filtered data consists mostly of small values with a somewhat random distribution. In this case, the compression algorithm is tuned to compress them better. The effect of Z_FILTERED is to force more Huffman coding and less string matching; it is somewhat intermediate between Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy parameter only affects the compression ratio but not the correctness of the compressed output even if it is not set appropriately. Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications. deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible with the version assumed by the caller (ZLIB_VERSION). msg is set to null if there is no error message. deflateInit2 does not perform any compression: this will be done by deflate(). */ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, const Bytef *dictionary, uInt dictLength)); /* Initializes the compression dictionary from the given byte sequence without producing any compressed output. This function must be called immediately after deflateInit, deflateInit2 or deflateReset, before any call of deflate. The compressor and decompressor must use exactly the same dictionary (see inflateSetDictionary). The dictionary should consist of strings (byte sequences) that are likely to be encountered later in the data to be compressed, with the most commonly used strings preferably put towards the end of the dictionary. Using a dictionary is most useful when the data to be compressed is short and can be predicted with good accuracy; the data can then be compressed better than with the default empty dictionary. Depending on the size of the compression data structures selected by deflateInit or deflateInit2, a part of the dictionary may in effect be discarded, for example if the dictionary is larger than the window size provided in deflateInit or deflateInit2. Thus the strings most likely to be useful should be put at the end of the dictionary, not at the front. In addition, the current implementation of deflate will use at most the window size minus 262 bytes of the provided dictionary. Upon return of this function, strm->adler is set to the adler32 value of the dictionary; the decompressor may later use this value to determine which dictionary has been used by the compressor. (The adler32 value applies to the whole dictionary even if only a subset of the dictionary is actually used by the compressor.) If a raw deflate was requested, then the adler32 value is not computed and strm->adler is not set. deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is inconsistent (for example if deflate has already been called for this stream or if the compression method is bsort). deflateSetDictionary does not perform any compression: this will be done by deflate(). */ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, z_streamp source)); /* Sets the destination stream as a complete copy of the source stream. This function can be useful when several compression strategies will be tried, for example when there are several ways of pre-processing the input data with a filter. The streams that will be discarded should then be freed by calling deflateEnd. Note that deflateCopy duplicates the internal compression state which can be quite large, so this strategy is slow and can consume lots of memory. deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc being Z_NULL). msg is left unchanged in both source and destination. */ ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); /* This function is equivalent to deflateEnd followed by deflateInit, but does not free and reallocate all the internal compression state. The stream will keep the same compression level and any other attributes that may have been set by deflateInit2. deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being Z_NULL). */ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, int level, int strategy)); /* Dynamically update the compression level and compression strategy. The interpretation of level and strategy is as in deflateInit2. This can be used to switch between compression and straight copy of the input data, or to switch to a different kind of input data requiring a different strategy. If the compression level is changed, the input available so far is compressed with the old level (and may be flushed); the new level will take effect only at the next call of deflate(). Before the call of deflateParams, the stream state must be set as for a call of deflate(), since the currently available input may have to be compressed and flushed. In particular, strm->avail_out must be non-zero. deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if strm->avail_out was zero. */ ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain)); /* Fine tune deflate's internal compression parameters. This should only be used by someone who understands the algorithm used by zlib's deflate for searching for the best matching string, and even then only by the most fanatic optimizer trying to squeeze out the last compressed bit for their specific input data. Read the deflate.c source code for the meaning of the max_lazy, good_length, nice_length, and max_chain parameters. deflateTune() can be called after deflateInit() or deflateInit2(), and returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. */ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, uLong sourceLen)); /* deflateBound() returns an upper bound on the compressed size after deflation of sourceLen bytes. It must be called after deflateInit() or deflateInit2(), and after deflateSetHeader(), if used. This would be used to allocate an output buffer for deflation in a single pass, and so would be called before deflate(). */ ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, int bits, int value)); /* deflatePrime() inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the bits leftover from a previous deflate stream when appending to it. As such, this function can only be used for raw deflate, and must be used before the first deflate() call after a deflateInit2() or deflateReset(). bits must be less than or equal to 16, and that many of the least significant bits of value will be inserted in the output. deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. */ ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, gz_headerp head)); /* deflateSetHeader() provides gzip header information for when a gzip stream is requested by deflateInit2(). deflateSetHeader() may be called after deflateInit2() or deflateReset() and before the first call of deflate(). The text, time, os, extra field, name, and comment information in the provided gz_header structure are written to the gzip header (xflag is ignored -- the extra flags are set according to the compression level). The caller must assure that, if not Z_NULL, name and comment are terminated with a zero byte, and that if extra is not Z_NULL, that extra_len bytes are available there. If hcrc is true, a gzip header crc is included. Note that the current versions of the command-line version of gzip (up through version 1.3.x) do not support header crc's, and will report that it is a "multi-part gzip file" and give up. If deflateSetHeader is not used, the default gzip header has text false, the time set to zero, and os set to 255, with no extra, name, or comment fields. The gzip header is returned to the default state by deflateReset(). deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. */ /* ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, int windowBits)); This is another version of inflateInit with an extra parameter. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized before by the caller. The windowBits parameter is the base two logarithm of the maximum window size (the size of the history buffer). It should be in the range 8..15 for this version of the library. The default value is 15 if inflateInit is used instead. windowBits must be greater than or equal to the windowBits value provided to deflateInit2() while compressing, or it must be equal to 15 if deflateInit2() was not used. If a compressed stream with a larger window size is given as input, inflate() will return with the error code Z_DATA_ERROR instead of trying to allocate a larger window. windowBits can also be zero to request that inflate use the window size in the zlib header of the compressed stream. windowBits can also be -8..-15 for raw inflate. In this case, -windowBits determines the window size. inflate() will then process raw deflate data, not looking for a zlib or gzip header, not generating a check value, and not looking for any check values for comparison at the end of the stream. This is for use with other formats that use the deflate compressed data format such as zip. Those formats provide their own check values. If a custom format is developed using the raw deflate format for compressed data, it is recommended that a check value such as an adler32 or a crc32 be applied to the uncompressed data as is done in the zlib, gzip, and zip formats. For most applications, the zlib format should be used as is. Note that comments above on the use in deflateInit2() applies to the magnitude of windowBits. windowBits can also be greater than 15 for optional gzip decoding. Add 32 to windowBits to enable zlib and gzip decoding with automatic header detection, or add 16 to decode only the gzip format (the zlib format will return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a crc32 instead of an adler32. inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_VERSION_ERROR if the zlib library version is incompatible with the version assumed by the caller, or Z_STREAM_ERROR if the parameters are invalid, such as a null pointer to the structure. msg is set to null if there is no error message. inflateInit2 does not perform any decompression apart from possibly reading the zlib header if present: actual decompression will be done by inflate(). (So next_in and avail_in may be modified, but next_out and avail_out are unused and unchanged.) The current implementation of inflateInit2() does not process any header information -- that is deferred until inflate() is called. */ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, const Bytef *dictionary, uInt dictLength)); /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate, if that call returned Z_NEED_DICT. The dictionary chosen by the compressor can be determined from the adler32 value returned by that call of inflate. The compressor and decompressor must use exactly the same dictionary (see deflateSetDictionary). For raw inflate, this function can be called immediately after inflateInit2() or inflateReset() and before any call of inflate() to set the dictionary. The application must insure that the dictionary that was used for compression is provided. inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the expected one (incorrect adler32 value). inflateSetDictionary does not perform any decompression: this will be done by subsequent calls of inflate(). */ ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); /* Skips invalid compressed data until a full flush point (see above the description of deflate with Z_FULL_FLUSH) can be found, or until all available input is skipped. No output is provided. inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. In the success case, the application may save the current current value of total_in which indicates where valid compressed data was found. In the error case, the application may repeatedly call inflateSync, providing more input each time, until success or end of the input data. */ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, z_streamp source)); /* Sets the destination stream as a complete copy of the source stream. This function can be useful when randomly accessing a large stream. The first pass through the stream can periodically record the inflate state, allowing restarting inflate at those points when randomly accessing the stream. inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc being Z_NULL). msg is left unchanged in both source and destination. */ ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); /* This function is equivalent to inflateEnd followed by inflateInit, but does not free and reallocate all the internal decompression state. The stream will keep attributes that may have been set by inflateInit2. inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being Z_NULL). */ ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, int windowBits)); /* This function is the same as inflateReset, but it also permits changing the wrap and window size requests. The windowBits parameter is interpreted the same as it is for inflateInit2. inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent (such as zalloc or state being Z_NULL), or if the windowBits parameter is invalid. */ ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, int bits, int value)); /* This function inserts bits in the inflate input stream. The intent is that this function is used to start inflating at a bit position in the middle of a byte. The provided bits will be used before any bytes are used from next_in. This function should only be used with raw inflate, and should be used before the first inflate() call after inflateInit2() or inflateReset(). bits must be less than or equal to 16, and that many of the least significant bits of value will be inserted in the input. If bits is negative, then the input stream bit buffer is emptied. Then inflatePrime() can be called again to put bits in the buffer. This is used to clear out bits leftover after feeding inflate a block description prior to feeding inflate codes. inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. */ ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); /* This function returns two values, one in the lower 16 bits of the return value, and the other in the remaining upper bits, obtained by shifting the return value down 16 bits. If the upper value is -1 and the lower value is zero, then inflate() is currently decoding information outside of a block. If the upper value is -1 and the lower value is non-zero, then inflate is in the middle of a stored block, with the lower value equaling the number of bytes from the input remaining to copy. If the upper value is not -1, then it is the number of bits back from the current bit position in the input of the code (literal or length/distance pair) currently being processed. In that case the lower value is the number of bytes already emitted for that code. A code is being processed if inflate is waiting for more input to complete decoding of the code, or if it has completed decoding but is waiting for more output space to write the literal or match data. inflateMark() is used to mark locations in the input data for random access, which may be at bit positions, and to note those cases where the output of a code may span boundaries of random access blocks. The current location in the input stream can be determined from avail_in and data_type as noted in the description for the Z_BLOCK flush parameter for inflate. inflateMark returns the value noted above or -1 << 16 if the provided source stream state was inconsistent. */ ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, gz_headerp head)); /* inflateGetHeader() requests that gzip header information be stored in the provided gz_header structure. inflateGetHeader() may be called after inflateInit2() or inflateReset(), and before the first call of inflate(). As inflate() processes the gzip stream, head->done is zero until the header is completed, at which time head->done is set to one. If a zlib stream is being decoded, then head->done is set to -1 to indicate that there will be no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be used to force inflate() to return immediately after header processing is complete and before any actual data is decompressed. The text, time, xflags, and os fields are filled in with the gzip header contents. hcrc is set to true if there is a header CRC. (The header CRC was valid if done is set to one.) If extra is not Z_NULL, then extra_max contains the maximum number of bytes to write to extra. Once done is true, extra_len contains the actual extra field length, and extra contains the extra field, or that field truncated if extra_max is less than extra_len. If name is not Z_NULL, then up to name_max characters are written there, terminated with a zero unless the length is greater than name_max. If comment is not Z_NULL, then up to comm_max characters are written there, terminated with a zero unless the length is greater than comm_max. When any of extra, name, or comment are not Z_NULL and the respective field is not present in the header, then that field is set to Z_NULL to signal its absence. This allows the use of deflateSetHeader() with the returned structure to duplicate the header. However if those fields are set to allocated memory, then the application will need to save those pointers elsewhere so that they can be eventually freed. If inflateGetHeader is not used, then the header information is simply discarded. The header is always checked for validity, including the header CRC if present. inflateReset() will reset the process to discard the header information. The application would need to call inflateGetHeader() again to retrieve the header from the next gzip stream. inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source stream state was inconsistent. */ /* ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, unsigned char FAR *window)); Initialize the internal stream state for decompression using inflateBack() calls. The fields zalloc, zfree and opaque in strm must be initialized before the call. If zalloc and zfree are Z_NULL, then the default library- derived memory allocation routines are used. windowBits is the base two logarithm of the window size, in the range 8..15. window is a caller supplied buffer of that size. Except for special applications where it is assured that deflate was used with small window sizes, windowBits must be 15 and a 32K byte window must be supplied to be able to decompress general deflate streams. See inflateBack() for the usage of these routines. inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of the paramaters are invalid, Z_MEM_ERROR if the internal state could not be allocated, or Z_VERSION_ERROR if the version of the library does not match the version of the header file. */ typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc)); /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is more efficient than inflate() for file i/o applications in that it avoids copying between the output and the sliding window by simply making the window itself the output buffer. This function trusts the application to not change the output buffer passed by the output function, at least until inflateBack() returns. inflateBackInit() must be called first to allocate the internal state and to initialize the state with the user-provided window buffer. inflateBack() may then be used multiple times to inflate a complete, raw deflate stream with each call. inflateBackEnd() is then called to free the allocated state. A raw deflate stream is one with no zlib or gzip header or trailer. This routine would normally be used in a utility that reads zip or gzip files and writes out uncompressed files. The utility would decode the header and process the trailer on its own, hence this routine expects only the raw deflate stream to decompress. This is different from the normal behavior of inflate(), which expects either a zlib or gzip header and trailer around the deflate stream. inflateBack() uses two subroutines supplied by the caller that are then called by inflateBack() for input and output. inflateBack() calls those routines until it reads a complete deflate stream and writes out all of the uncompressed data, or until it encounters an error. The function's parameters and return types are defined above in the in_func and out_func typedefs. inflateBack() will call in(in_desc, &buf) which should return the number of bytes of provided input, and a pointer to that input in buf. If there is no input available, in() must return zero--buf is ignored in that case--and inflateBack() will return a buffer error. inflateBack() will call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() should return zero on success, or non-zero on failure. If out() returns non-zero, inflateBack() will return with an error. Neither in() nor out() are permitted to change the contents of the window provided to inflateBackInit(), which is also the buffer that out() uses to write from. The length written by out() will be at most the window size. Any non-zero amount of input may be provided by in(). For convenience, inflateBack() can be provided input on the first call by setting strm->next_in and strm->avail_in. If that input is exhausted, then in() will be called. Therefore strm->next_in must be initialized before calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in must also be initialized, and then if strm->avail_in is not zero, input will initially be taken from strm->next_in[0 .. strm->avail_in - 1]. The in_desc and out_desc parameters of inflateBack() is passed as the first parameter of in() and out() respectively when they are called. These descriptors can be optionally used to pass any information that the caller- supplied in() and out() functions need to do their job. On return, inflateBack() will set strm->next_in and strm->avail_in to pass back any unused input that was provided by the last in() call. The return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR if in() or out() returned an error, Z_DATA_ERROR if there was a format error in the deflate stream (in which case strm->msg is set to indicate the nature of the error), or Z_STREAM_ERROR if the stream was not properly initialized. In the case of Z_BUF_ERROR, an input or output error can be distinguished using strm->next_in which will be Z_NULL only if in() returned an error. If strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning non-zero. (in() will always be called before out(), so strm->next_in is assured to be defined if out() returns non-zero.) Note that inflateBack() cannot return Z_OK. */ ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); /* All memory allocated by inflateBackInit() is freed. inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream state was inconsistent. */ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); /* Return flags indicating compile-time options. Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: 1.0: size of uInt 3.2: size of uLong 5.4: size of voidpf (pointer) 7.6: size of z_off_t Compiler, assembler, and debug options: 8: DEBUG 9: ASMV or ASMINF -- use ASM code 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention 11: 0 (reserved) One-time table building (smaller code, but not thread-safe if true): 12: BUILDFIXED -- build static block decoding tables when needed 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed 14,15: 0 (reserved) Library content (indicates missing functionality): 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking deflate code when not needed) 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect and decode gzip streams (to avoid linking crc code) 18-19: 0 (reserved) Operation variations (changes in library functionality): 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate 21: FASTEST -- deflate algorithm with only one, lowest compression level 22,23: 0 (reserved) The sprintf variant used by gzprintf (zero is best): 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! 26: 0 = returns value, 1 = void -- 1 means inferred string length returned Remainder: 27-31: 0 (reserved) */ /* utility functions */ /* The following utility functions are implemented on top of the basic stream-oriented functions. To simplify the interface, some default options are assumed (compression level and memory usage, standard memory allocation functions). The source code of these utility functions can be modified if you need special options. */ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)); /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size of the destination buffer, which must be at least the value returned by compressBound(sourceLen). Upon exit, destLen is the actual size of the compressed buffer. compress returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if there was not enough room in the output buffer. */ ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level)); /* Compresses the source buffer into the destination buffer. The level parameter has the same meaning as in deflateInit. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size of the destination buffer, which must be at least the value returned by compressBound(sourceLen). Upon exit, destLen is the actual size of the compressed buffer. compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if there was not enough room in the output buffer, Z_STREAM_ERROR if the level parameter is invalid. */ ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); /* compressBound() returns an upper bound on the compressed size after compress() or compress2() on sourceLen bytes. It would be used before a compress() or compress2() call to allocate the destination buffer. */ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)); /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size of the destination buffer, which must be large enough to hold the entire uncompressed data. (The size of the uncompressed data must have been saved previously by the compressor and transmitted to the decompressor by some mechanism outside the scope of this compression library.) Upon exit, destLen is the actual size of the uncompressed buffer. uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if there was not enough room in the output buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. */ /* gzip file access functions */ /* This library supports reading and writing files in gzip (.gz) format with an interface similar to that of stdio, using the functions that start with "gz". The gzip format is different from the zlib format. gzip is a gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. */ typedef voidp gzFile; /* opaque gzip file descriptor */ /* ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); Opens a gzip (.gz) file for reading or writing. The mode parameter is as in fopen ("rb" or "wb") but can also include a compression level ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' for fixed code compression as in "wb9F". (See the description of deflateInit2 for more information about the strategy parameter.) Also "a" can be used instead of "w" to request that the gzip stream that will be written be appended to the file. "+" will result in an error, since reading and writing to the same gzip file is not supported. gzopen can be used to read a file which is not in gzip format; in this case gzread will directly read from the file without decompression. gzopen returns NULL if the file could not be opened, if there was insufficient memory to allocate the gzFile state, or if an invalid mode was specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). errno can be checked to determine if the reason gzopen failed was that the file could not be opened. */ ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); /* gzdopen associates a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or fileno (if the file has been previously opened with fopen). The mode parameter is as in gzopen. The next call of gzclose on the returned gzFile will also close the file descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, mode);. The duplicated descriptor should be saved to avoid a leak, since gzdopen does not close fd if it fails. gzdopen returns NULL if there was insufficient memory to allocate the gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not provided, or '+' was provided), or if fd is -1. The file descriptor is not used until the next gz* read, write, seek, or close operation, so gzdopen will not detect if fd is invalid (unless fd is -1). */ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); /* Set the internal buffer size used by this library's functions. The default buffer size is 8192 bytes. This function must be called after gzopen() or gzdopen(), and before any other calls that read or write the file. The buffer memory allocation is always deferred to the first read or write. Two buffers are allocated, either both of the specified size when writing, or one of the specified size and the other twice that size when reading. A larger buffer size of, for example, 64K or 128K bytes will noticeably increase the speed of decompression (reading). The new buffer size also affects the maximum length for gzprintf(). gzbuffer() returns 0 on success, or -1 on failure, such as being called too late. */ ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); /* Dynamically update the compression level or strategy. See the description of deflateInit2 for the meaning of these parameters. gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not opened for writing. */ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); /* Reads the given number of uncompressed bytes from the compressed file. If the input file was not in gzip format, gzread copies the given number of bytes into the buffer. After reaching the end of a gzip stream in the input, gzread will continue to read, looking for another gzip stream, or failing that, reading the rest of the input file directly without decompression. The entire input file will be read if gzread is called until it returns less than the requested len. gzread returns the number of uncompressed bytes actually read, less than len for end of file, or -1 for error. */ ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len)); /* Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of uncompressed bytes written or 0 in case of error. */ ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); /* Converts, formats, and writes the arguments to the compressed file under control of the format string, as in fprintf. gzprintf returns the number of uncompressed bytes actually written, or 0 in case of error. The number of uncompressed bytes written is limited to 8191, or one less than the buffer size given to gzbuffer(). The caller should assure that this limit is not exceeded. If it is exceeded, then gzprintf() will return an error (0) with nothing written. In this case, there may also be a buffer overflow with unpredictable consequences, which is possible only if zlib was compiled with the insecure functions sprintf() or vsprintf() because the secure snprintf() or vsnprintf() functions were not available. This can be determined using zlibCompileFlags(). */ ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); /* Writes the given null-terminated string to the compressed file, excluding the terminating null character. gzputs returns the number of characters written, or -1 in case of error. */ ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); /* Reads bytes from the compressed file until len-1 characters are read, or a newline character is read and transferred to buf, or an end-of-file condition is encountered. If any characters are read or if len == 1, the string is terminated with a null character. If no characters are read due to an end-of-file or len < 1, then the buffer is left untouched. gzgets returns buf which is a null-terminated string, or it returns NULL for end-of-file or in case of error. If there was an error, the contents at buf are indeterminate. */ ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); /* Writes c, converted to an unsigned char, into the compressed file. gzputc returns the value that was written, or -1 in case of error. */ ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); /* Reads one byte from the compressed file. gzgetc returns this byte or -1 in case of end of file or error. */ ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); /* Push one character back onto the stream to be read as the first character on the next read. At least one character of push-back is allowed. gzungetc() returns the character pushed, or -1 on failure. gzungetc() will fail if c is -1, and may fail if a character has been pushed but not read yet. If gzungetc is used immediately after gzopen or gzdopen, at least the output buffer size of pushed characters is allowed. (See gzbuffer above.) The pushed character will be discarded if the stream is repositioned with gzseek() or gzrewind(). */ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); /* Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. The return value is the zlib error number (see function gzerror below). gzflush is only permitted when writing. If the flush parameter is Z_FINISH, the remaining data is written and the gzip stream is completed in the output. If gzwrite() is called again, a new gzip stream will be started in the output. gzread() is able to read such concatented gzip streams. gzflush should be called only when strictly necessary because it will degrade compression if called too often. */ /* ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, z_off_t offset, int whence)); Sets the starting position for the next gzread or gzwrite on the given compressed file. The offset represents a number of bytes in the uncompressed data stream. The whence parameter is defined as in lseek(2); the value SEEK_END is not supported. If the file is opened for reading, this function is emulated but can be extremely slow. If the file is opened for writing, only forward seeks are supported; gzseek then compresses a sequence of zeroes up to the new starting position. gzseek returns the resulting offset location as measured in bytes from the beginning of the uncompressed stream, or -1 in case of error, in particular if the file is opened for writing and the new starting position would be before the current position. */ ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); /* Rewinds the given file. This function is supported only for reading. gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) */ /* ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); Returns the starting position for the next gzread or gzwrite on the given compressed file. This position represents a number of bytes in the uncompressed data stream, and is zero when starting, even if appending or reading a gzip stream from the middle of a file using gzdopen(). gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) */ /* ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); Returns the current offset in the file being read or written. This offset includes the count of bytes that precede the gzip stream, for example when appending or when using gzdopen() for reading. When reading, the offset does not include as yet unused buffered input. This information can be used for a progress indicator. On error, gzoffset() returns -1. */ ZEXTERN int ZEXPORT gzeof OF((gzFile file)); /* Returns true (1) if the end-of-file indicator has been set while reading, false (0) otherwise. Note that the end-of-file indicator is set only if the read tried to go past the end of the input, but came up short. Therefore, just like feof(), gzeof() may return false even if there is no more data to read, in the event that the last read request was for the exact number of bytes remaining in the input file. This will happen if the input file size is an exact multiple of the buffer size. If gzeof() returns true, then the read functions will return no more data, unless the end-of-file indicator is reset by gzclearerr() and the input file has grown since the previous end of file was detected. */ ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); /* Returns true (1) if file is being copied directly while reading, or false (0) if file is a gzip stream being decompressed. This state can change from false to true while reading the input file if the end of a gzip stream is reached, but is followed by data that is not another gzip stream. If the input file is empty, gzdirect() will return true, since the input does not contain a gzip stream. If gzdirect() is used immediately after gzopen() or gzdopen() it will cause buffers to be allocated to allow reading the file to determine if it is a gzip file. Therefore if gzbuffer() is used, it should be called before gzdirect(). */ ZEXTERN int ZEXPORT gzclose OF((gzFile file)); /* Flushes all pending output if necessary, closes the compressed file and deallocates the (de)compression state. Note that once file is closed, you cannot call gzerror with file, since its structures have been deallocated. gzclose must not be called more than once on the same file, just as free must not be called more than once on the same allocation. gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a file operation error, or Z_OK on success. */ ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); /* Same as gzclose(), but gzclose_r() is only for use when reading, and gzclose_w() is only for use when writing or appending. The advantage to using these instead of gzclose() is that they avoid linking in zlib compression or decompression code that is not used when only reading or only writing respectively. If gzclose() is used, then both compression and decompression code will be included the application when linking to a static zlib library. */ ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); /* Returns the error message for the last error which occurred on the given compressed file. errnum is set to zlib error number. If an error occurred in the file system and not in the compression library, errnum is set to Z_ERRNO and the application may consult errno to get the exact error code. The application must not modify the returned string. Future calls to this function may invalidate the previously returned string. If file is closed, then the string previously returned by gzerror will no longer be available. gzerror() should be used to distinguish errors from end-of-file for those functions above that do not distinguish those cases in their return values. */ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); /* Clears the error and end-of-file flags for file. This is analogous to the clearerr() function in stdio. This is useful for continuing to read a gzip file that is being written concurrently. */ /* checksum functions */ /* These functions are not related to compression but are exported anyway because they might be useful in applications using the compression library. */ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. If buf is Z_NULL, this function returns the required initial value for the checksum. An Adler-32 checksum is almost as reliable as a CRC32 but can be computed much faster. Usage example: uLong adler = adler32(0L, Z_NULL, 0); while (read_buffer(buffer, length) != EOF) { adler = adler32(adler, buffer, length); } if (adler != original_adler) error(); */ /* ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, z_off_t len2)); Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. */ ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); /* Update a running CRC-32 with the bytes buf[0..len-1] and return the updated CRC-32. If buf is Z_NULL, this function returns the required initial value for the for the crc. Pre- and post-conditioning (one's complement) is performed within this function so it shouldn't be done by the application. Usage example: uLong crc = crc32(0L, Z_NULL, 0); while (read_buffer(buffer, length) != EOF) { crc = crc32(crc, buffer, length); } if (crc != original_crc) error(); */ /* ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); Combine two CRC-32 check values into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, CRC-32 check values were calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and len2. */ /* various hacks, don't look :) */ /* deflateInit and inflateInit are macros to allow checking the zlib version * and the compiler's view of z_stream: */ ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, const char *version, int stream_size)); ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, const char *version, int stream_size)); ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size)); ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, const char *version, int stream_size)); ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, unsigned char FAR *window, const char *version, int stream_size)); #define deflateInit(strm, level) \ deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) #define inflateInit(strm) \ inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ (strategy), ZLIB_VERSION, sizeof(z_stream)) #define inflateInit2(strm, windowBits) \ inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) #define inflateBackInit(strm, windowBits, window) \ inflateBackInit_((strm), (windowBits), (window), \ ZLIB_VERSION, sizeof(z_stream)) /* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if * both are true, the application gets the *64 functions, and the regular * functions are changed to 64 bits) -- in case these are set on systems * without large file support, _LFS64_LARGEFILE must also be true */ #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); #endif #if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0 # define gzopen gzopen64 # define gzseek gzseek64 # define gztell gztell64 # define gzoffset gzoffset64 # define adler32_combine adler32_combine64 # define crc32_combine crc32_combine64 # ifdef _LARGEFILE64_SOURCE ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); # endif #else ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); #endif /* hack for buggy compilers */ #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) struct internal_state {int dummy;}; #endif /* undocumented functions */ ZEXTERN const char * ZEXPORT zError OF((int)); ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); #ifdef __cplusplus } #endif #endif /* ZLIB_H */ healpy-1.10.3/cfitsio/zlib/zuncompress.c0000664000175000017500000004005113010375005020454 0ustar zoncazonca00000000000000/* gzcompress.h -- definitions for the .Z decompression routine used in CFITSIO */ #include #include #include #include #define get_char() get_byte() /* gzip.h -- common declarations for all gzip modules */ #define OF(args) args typedef void *voidp; #define memzero(s, n) memset ((voidp)(s), 0, (n)) typedef unsigned char uch; typedef unsigned short ush; typedef unsigned long ulg; /* private version of MIN function */ #define MINZIP(a,b) ((a) <= (b) ? (a) : (b)) /* Return codes from gzip */ #define OK 0 #define ERROR 1 #define COMPRESSED 1 #define DEFLATED 8 #define INBUFSIZ 0x8000 /* input buffer size */ #define INBUF_EXTRA 64 /* required by unlzw() */ #define OUTBUFSIZ 16384 /* output buffer size */ #define OUTBUF_EXTRA 2048 /* required by unlzw() */ #define DIST_BUFSIZE 0x8000 /* buffer for distances, see trees.c */ #define WSIZE 0x8000 /* window size--must be a power of two, and */ #define DECLARE(type, array, size) type array[size] #define tab_suffix window #define tab_prefix prev /* hash link (see deflate.c) */ #define head (prev+WSIZE) /* hash head (see deflate.c) */ #define LZW_MAGIC "\037\235" /* Magic header for lzw files, 1F 9D */ #define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf(0)) /* Diagnostic functions */ # define Assert(cond,msg) # define Trace(x) # define Tracev(x) # define Tracevv(x) # define Tracec(c,x) # define Tracecv(c,x) /* lzw.h -- define the lzw functions. */ #ifndef BITS # define BITS 16 #endif #define INIT_BITS 9 /* Initial number of bits per code */ #define BIT_MASK 0x1f /* Mask for 'number of compression bits' */ #define BLOCK_MODE 0x80 #define LZW_RESERVED 0x60 /* reserved bits */ #define CLEAR 256 /* flush the dictionary */ #define FIRST (CLEAR+1) /* first free entry */ /* prototypes */ #define local static void ffpmsg(const char *err_message); local int fill_inbuf OF((int eof_ok)); local void write_buf OF((voidp buf, unsigned cnt)); local void error OF((char *m)); local int unlzw OF((FILE *in, FILE *out)); typedef int file_t; /* Do not use stdio */ int (*work) OF((FILE *infile, FILE *outfile)) = unlzw; /* function to call */ local void error OF((char *m)); /* global buffers */ static DECLARE(uch, inbuf, INBUFSIZ +INBUF_EXTRA); static DECLARE(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA); static DECLARE(ush, d_buf, DIST_BUFSIZE); static DECLARE(uch, window, 2L*WSIZE); #ifndef MAXSEG_64K static DECLARE(ush, tab_prefix, 1L< 0) return(*status); /* save input parameters into global variables */ ifname[0] = '\0'; strncat(ifname, filename, 127); ifd = indiskfile; memptr = (void **) buffptr; memsize = buffsize; realloc_fn = mem_realloc; /* clear input and output buffers */ insize = inptr = 0; bytes_in = bytes_out = 0L; magic[0] = (char)get_byte(); magic[1] = (char)get_byte(); if (memcmp(magic, LZW_MAGIC, 2) != 0) { error("ERROR: input .Z file is in unrecognized compression format.\n"); return(-1); } work = unlzw; method = COMPRESSED; last_member = 1; /* do the uncompression */ if ((*work)(ifd, ofd) != OK) { method = -1; /* force cleanup */ *status = 414; /* report some sort of decompression error */ } if (filesize) *filesize = bytes_out; return(*status); } /*=========================================================================*/ /*=========================================================================*/ /* this marks the begining of the original file 'unlzw.c' */ /*=========================================================================*/ /*=========================================================================*/ /* unlzw.c -- decompress files in LZW format. * The code in this file is directly derived from the public domain 'compress' * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies, * Ken Turkowski, Dave Mack and Peter Jannesen. */ typedef unsigned char char_type; typedef long code_int; typedef unsigned long count_int; typedef unsigned short count_short; typedef unsigned long cmp_code_int; #define MAXCODE(n) (1L << (n)) #ifndef REGISTERS # define REGISTERS 2 #endif #define REG1 #define REG2 #define REG3 #define REG4 #define REG5 #define REG6 #define REG7 #define REG8 #define REG9 #define REG10 #define REG11 #define REG12 #define REG13 #define REG14 #define REG15 #define REG16 #if REGISTERS >= 1 # undef REG1 # define REG1 register #endif #if REGISTERS >= 2 # undef REG2 # define REG2 register #endif #if REGISTERS >= 3 # undef REG3 # define REG3 register #endif #if REGISTERS >= 4 # undef REG4 # define REG4 register #endif #if REGISTERS >= 5 # undef REG5 # define REG5 register #endif #if REGISTERS >= 6 # undef REG6 # define REG6 register #endif #if REGISTERS >= 7 # undef REG7 # define REG7 register #endif #if REGISTERS >= 8 # undef REG8 # define REG8 register #endif #if REGISTERS >= 9 # undef REG9 # define REG9 register #endif #if REGISTERS >= 10 # undef REG10 # define REG10 register #endif #if REGISTERS >= 11 # undef REG11 # define REG11 register #endif #if REGISTERS >= 12 # undef REG12 # define REG12 register #endif #if REGISTERS >= 13 # undef REG13 # define REG13 register #endif #if REGISTERS >= 14 # undef REG14 # define REG14 register #endif #if REGISTERS >= 15 # undef REG15 # define REG15 register #endif #if REGISTERS >= 16 # undef REG16 # define REG16 register #endif #ifndef BYTEORDER # define BYTEORDER 0000 #endif #ifndef NOALLIGN # define NOALLIGN 0 #endif union bytes { long word; struct { #if BYTEORDER == 4321 char_type b1; char_type b2; char_type b3; char_type b4; #else #if BYTEORDER == 1234 char_type b4; char_type b3; char_type b2; char_type b1; #else # undef BYTEORDER int dummy; #endif #endif } bytes; }; #if BYTEORDER == 4321 && NOALLIGN == 1 # define input(b,o,c,n,m){ \ (c) = (*(long *)(&(b)[(o)>>3])>>((o)&0x7))&(m); \ (o) += (n); \ } #else # define input(b,o,c,n,m){ \ REG1 char_type *p = &(b)[(o)>>3]; \ (c) = ((((long)(p[0]))|((long)(p[1])<<8)| \ ((long)(p[2])<<16))>>((o)&0x7))&(m); \ (o) += (n); \ } #endif #ifndef MAXSEG_64K /* DECLARE(ush, tab_prefix, (1<>1] # define clear_tab_prefixof() \ memzero(tab_prefix0, 128), \ memzero(tab_prefix1, 128); #endif #define de_stack ((char_type *)(&d_buf[DIST_BUFSIZE-1])) #define tab_suffixof(i) tab_suffix[i] int block_mode = BLOCK_MODE; /* block compress mode -C compatible with 2.0 */ /* ============================================================================ * Decompress in to out. This routine adapts to the codes in the * file building the "string" table on-the-fly; requiring no table to * be stored in the compressed file. * IN assertions: the buffer inbuf contains already the beginning of * the compressed data, from offsets iptr to insize-1 included. * The magic header has already been checked and skipped. * bytes_in and bytes_out have been initialized. */ local int unlzw(FILE *in, FILE *out) /* input and output file descriptors */ { REG2 char_type *stackp; REG3 code_int code; REG4 int finchar; REG5 code_int oldcode; REG6 code_int incode; REG7 long inbits; REG8 long posbits; REG9 int outpos; /* REG10 int insize; (global) */ REG11 unsigned bitmask; REG12 code_int free_ent; REG13 code_int maxcode; REG14 code_int maxmaxcode; REG15 int n_bits; REG16 int rsize; ofd = out; #ifdef MAXSEG_64K tab_prefix[0] = tab_prefix0; tab_prefix[1] = tab_prefix1; #endif maxbits = get_byte(); block_mode = maxbits & BLOCK_MODE; if ((maxbits & LZW_RESERVED) != 0) { error( "warning, unknown flags in unlzw decompression"); } maxbits &= BIT_MASK; maxmaxcode = MAXCODE(maxbits); if (maxbits > BITS) { error("compressed with too many bits; cannot handle file"); exit_code = ERROR; return ERROR; } rsize = insize; maxcode = MAXCODE(n_bits = INIT_BITS)-1; bitmask = (1<= 0 ; --code) { tab_suffixof(code) = (char_type)code; } do { REG1 int i; int e; int o; resetbuf: e = insize-(o = (posbits>>3)); for (i = 0 ; i < e ; ++i) { inbuf[i] = inbuf[i+o]; } insize = e; posbits = 0; if (insize < INBUF_EXTRA) { /* modified to use fread instead of read - WDP 10/22/97 */ /* if ((rsize = read(in, (char*)inbuf+insize, INBUFSIZ)) == EOF) { */ if ((rsize = fread((char*)inbuf+insize, 1, INBUFSIZ, in)) == EOF) { error("unexpected end of file"); exit_code = ERROR; return ERROR; } insize += rsize; bytes_in += (ulg)rsize; } inbits = ((rsize != 0) ? ((long)insize - insize%n_bits)<<3 : ((long)insize<<3)-(n_bits-1)); while (inbits > posbits) { if (free_ent > maxcode) { posbits = ((posbits-1) + ((n_bits<<3)-(posbits-1+(n_bits<<3))%(n_bits<<3))); ++n_bits; if (n_bits == maxbits) { maxcode = maxmaxcode; } else { maxcode = MAXCODE(n_bits)-1; } bitmask = (1<= 256) { error("corrupt input."); exit_code = ERROR; return ERROR; } outbuf[outpos++] = (char_type)(finchar = (int)(oldcode=code)); continue; } if (code == CLEAR && block_mode) { clear_tab_prefixof(); free_ent = FIRST - 1; posbits = ((posbits-1) + ((n_bits<<3)-(posbits-1+(n_bits<<3))%(n_bits<<3))); maxcode = MAXCODE(n_bits = INIT_BITS)-1; bitmask = (1<= free_ent) { /* Special case for KwKwK string. */ if (code > free_ent) { if (outpos > 0) { write_buf((char*)outbuf, outpos); bytes_out += (ulg)outpos; } error("corrupt input."); exit_code = ERROR; return ERROR; } *--stackp = (char_type)finchar; code = oldcode; } while ((cmp_code_int)code >= (cmp_code_int)256) { /* Generate output characters in reverse order */ *--stackp = tab_suffixof(code); code = tab_prefixof(code); } *--stackp = (char_type)(finchar = tab_suffixof(code)); /* And put them out in forward order */ { /* REG1 int i; already defined above (WDP) */ if (outpos+(i = (de_stack-stackp)) >= OUTBUFSIZ) { do { if (i > OUTBUFSIZ-outpos) i = OUTBUFSIZ-outpos; if (i > 0) { memcpy(outbuf+outpos, stackp, i); outpos += i; } if (outpos >= OUTBUFSIZ) { write_buf((char*)outbuf, outpos); bytes_out += (ulg)outpos; outpos = 0; } stackp+= i; } while ((i = (de_stack-stackp)) > 0); } else { memcpy(outbuf+outpos, stackp, i); outpos += i; } } if ((code = free_ent) < maxmaxcode) { /* Generate the new entry. */ tab_prefixof(code) = (unsigned short)oldcode; tab_suffixof(code) = (char_type)finchar; free_ent = code+1; } oldcode = incode; /* Remember previous code. */ } } while (rsize != 0); if (outpos > 0) { write_buf((char*)outbuf, outpos); bytes_out += (ulg)outpos; } return OK; } /* ========================================================================*/ /* this marks the start of the code from 'util.c' */ local int fill_inbuf(int eof_ok) /* set if EOF acceptable as a result */ { int len; /* Read as much as possible from file */ insize = 0; do { len = fread((char*)inbuf+insize, 1, INBUFSIZ-insize, ifd); if (len == 0 || len == EOF) break; insize += len; } while (insize < INBUFSIZ); if (insize == 0) { if (eof_ok) return EOF; error("unexpected end of file"); exit_code = ERROR; return ERROR; } bytes_in += (ulg)insize; inptr = 1; return inbuf[0]; } /* =========================================================================== */ local void write_buf(voidp buf, unsigned cnt) /* copy buffer into memory; allocate more memory if required*/ { if (!realloc_fn) { /* append buffer to file */ /* added 'unsigned' to get rid of compiler warning (WDP 1/1/99) */ if ((unsigned long) fwrite(buf, 1, cnt, ofd) != cnt) { error ("failed to write buffer to uncompressed output file (write_buf)"); exit_code = ERROR; return; } } else { /* get more memory if current buffer is too small */ if (bytes_out + cnt > *memsize) { *memptr = realloc_fn(*memptr, bytes_out + cnt); *memsize = bytes_out + cnt; /* new memory buffer size */ if (!(*memptr)) { error("malloc failed while uncompressing (write_buf)"); exit_code = ERROR; return; } } /* copy into memory buffer */ memcpy((char *) *memptr + bytes_out, (char *) buf, cnt); } } /* ======================================================================== */ local void error(char *m) /* Error handler */ { ffpmsg(ifname); ffpmsg(m); } healpy-1.10.3/cfitsio/zlib/zutil.c0000664000175000017500000001620013010375005017232 0ustar zoncazonca00000000000000/* zutil.c -- target dependent utility functions for the compression library * Copyright (C) 1995-2005, 2010 Jean-loup Gailly. * For conditions of distribution and use, see copyright notice in zlib.h */ #include "zutil.h" #ifndef NO_DUMMY_DECL struct internal_state {int dummy;}; /* for buggy compilers */ #endif const char * const z_errmsg[10] = { "need dictionary", /* Z_NEED_DICT 2 */ "stream end", /* Z_STREAM_END 1 */ "", /* Z_OK 0 */ "file error", /* Z_ERRNO (-1) */ "stream error", /* Z_STREAM_ERROR (-2) */ "data error", /* Z_DATA_ERROR (-3) */ "insufficient memory", /* Z_MEM_ERROR (-4) */ "buffer error", /* Z_BUF_ERROR (-5) */ "incompatible version",/* Z_VERSION_ERROR (-6) */ ""}; const char * ZEXPORT zlibVersion() { return ZLIB_VERSION; } uLong ZEXPORT zlibCompileFlags() { uLong flags; flags = 0; switch ((int)(sizeof(uInt))) { case 2: break; case 4: flags += 1; break; case 8: flags += 2; break; default: flags += 3; } switch ((int)(sizeof(uLong))) { case 2: break; case 4: flags += 1 << 2; break; case 8: flags += 2 << 2; break; default: flags += 3 << 2; } switch ((int)(sizeof(voidpf))) { case 2: break; case 4: flags += 1 << 4; break; case 8: flags += 2 << 4; break; default: flags += 3 << 4; } switch ((int)(sizeof(z_off_t))) { case 2: break; case 4: flags += 1 << 6; break; case 8: flags += 2 << 6; break; default: flags += 3 << 6; } #ifdef DEBUG flags += 1 << 8; #endif #if defined(ASMV) || defined(ASMINF) flags += 1 << 9; #endif #ifdef ZLIB_WINAPI flags += 1 << 10; #endif #ifdef BUILDFIXED flags += 1 << 12; #endif #ifdef DYNAMIC_CRC_TABLE flags += 1 << 13; #endif #ifdef NO_GZCOMPRESS flags += 1L << 16; #endif #ifdef NO_GZIP flags += 1L << 17; #endif #ifdef PKZIP_BUG_WORKAROUND flags += 1L << 20; #endif #ifdef FASTEST flags += 1L << 21; #endif #ifdef STDC # ifdef NO_vsnprintf flags += 1L << 25; # ifdef HAS_vsprintf_void flags += 1L << 26; # endif # else # ifdef HAS_vsnprintf_void flags += 1L << 26; # endif # endif #else flags += 1L << 24; # ifdef NO_snprintf flags += 1L << 25; # ifdef HAS_sprintf_void flags += 1L << 26; # endif # else # ifdef HAS_snprintf_void flags += 1L << 26; # endif # endif #endif return flags; } #ifdef DEBUG # ifndef verbose # define verbose 0 # endif int ZLIB_INTERNAL z_verbose = verbose; void ZLIB_INTERNAL z_error (m) char *m; { fprintf(stderr, "%s\n", m); exit(1); } #endif /* exported to allow conversion of error code to string for compress() and * uncompress() */ const char * ZEXPORT zError(err) int err; { return ERR_MSG(err); } #if defined(_WIN32_WCE) /* The Microsoft C Run-Time Library for Windows CE doesn't have * errno. We define it as a global variable to simplify porting. * Its value is always 0 and should not be used. */ int errno = 0; #endif #ifndef HAVE_MEMCPY void ZLIB_INTERNAL zmemcpy(dest, source, len) Bytef* dest; const Bytef* source; uInt len; { if (len == 0) return; do { *dest++ = *source++; /* ??? to be unrolled */ } while (--len != 0); } int ZLIB_INTERNAL zmemcmp(s1, s2, len) const Bytef* s1; const Bytef* s2; uInt len; { uInt j; for (j = 0; j < len; j++) { if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; } return 0; } void ZLIB_INTERNAL zmemzero(dest, len) Bytef* dest; uInt len; { if (len == 0) return; do { *dest++ = 0; /* ??? to be unrolled */ } while (--len != 0); } #endif #ifdef SYS16BIT #ifdef __TURBOC__ /* Turbo C in 16-bit mode */ # define MY_ZCALLOC /* Turbo C malloc() does not allow dynamic allocation of 64K bytes * and farmalloc(64K) returns a pointer with an offset of 8, so we * must fix the pointer. Warning: the pointer must be put back to its * original form in order to free it, use zcfree(). */ #define MAX_PTR 10 /* 10*64K = 640K */ local int next_ptr = 0; typedef struct ptr_table_s { voidpf org_ptr; voidpf new_ptr; } ptr_table; local ptr_table table[MAX_PTR]; /* This table is used to remember the original form of pointers * to large buffers (64K). Such pointers are normalized with a zero offset. * Since MSDOS is not a preemptive multitasking OS, this table is not * protected from concurrent access. This hack doesn't work anyway on * a protected system like OS/2. Use Microsoft C instead. */ voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) { voidpf buf = opaque; /* just to make some compilers happy */ ulg bsize = (ulg)items*size; /* If we allocate less than 65520 bytes, we assume that farmalloc * will return a usable pointer which doesn't have to be normalized. */ if (bsize < 65520L) { buf = farmalloc(bsize); if (*(ush*)&buf != 0) return buf; } else { buf = farmalloc(bsize + 16L); } if (buf == NULL || next_ptr >= MAX_PTR) return NULL; table[next_ptr].org_ptr = buf; /* Normalize the pointer to seg:0 */ *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; *(ush*)&buf = 0; table[next_ptr++].new_ptr = buf; return buf; } void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) { int n; if (*(ush*)&ptr != 0) { /* object < 64K */ farfree(ptr); return; } /* Find the original pointer */ for (n = 0; n < next_ptr; n++) { if (ptr != table[n].new_ptr) continue; farfree(table[n].org_ptr); while (++n < next_ptr) { table[n-1] = table[n]; } next_ptr--; return; } ptr = opaque; /* just to make some compilers happy */ Assert(0, "zcfree: ptr not found"); } #endif /* __TURBOC__ */ #ifdef M_I86 /* Microsoft C in 16-bit mode */ # define MY_ZCALLOC #if (!defined(_MSC_VER) || (_MSC_VER <= 600)) # define _halloc halloc # define _hfree hfree #endif voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) { if (opaque) opaque = 0; /* to make compiler happy */ return _halloc((long)items, size); } void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) { if (opaque) opaque = 0; /* to make compiler happy */ _hfree(ptr); } #endif /* M_I86 */ #endif /* SYS16BIT */ #ifndef MY_ZCALLOC /* Any system without a special alloc function */ #ifndef STDC extern voidp malloc OF((uInt size)); extern voidp calloc OF((uInt items, uInt size)); extern void free OF((voidpf ptr)); #endif voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) voidpf opaque; unsigned items; unsigned size; { if (opaque) items += size - size; /* make compiler happy */ return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : (voidpf)calloc(items, size); } void ZLIB_INTERNAL zcfree (opaque, ptr) voidpf opaque; voidpf ptr; { free(ptr); if (opaque) return; /* make compiler happy */ } #endif /* MY_ZCALLOC */ healpy-1.10.3/cfitsio/zlib/zutil.h0000664000175000017500000001574013010375005017247 0ustar zoncazonca00000000000000/* zutil.h -- internal interface and configuration of the compression library * Copyright (C) 1995-2010 Jean-loup Gailly. * For conditions of distribution and use, see copyright notice in zlib.h */ /* WARNING: this file should *not* be used by applications. It is part of the implementation of the compression library and is subject to change. Applications should only use zlib.h. */ #ifndef ZUTIL_H #define ZUTIL_H #if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) # define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) #else # define ZLIB_INTERNAL #endif #include "zlib.h" #ifdef STDC # if !(defined(_WIN32_WCE) && defined(_MSC_VER)) # include # endif # include # include #endif #ifndef local # define local static #endif /* compile with -Dlocal if your debugger can't find static symbols */ typedef unsigned char uch; typedef uch FAR uchf; typedef unsigned short ush; typedef ush FAR ushf; typedef unsigned long ulg; extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ /* (size given to avoid silly warnings with Visual C++) */ #define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] #define ERR_RETURN(strm,err) \ return (strm->msg = (char*)ERR_MSG(err), (err)) /* To be used only when the state is known to be valid */ /* common constants */ #ifndef DEF_WBITS # define DEF_WBITS MAX_WBITS #endif /* default windowBits for decompression. MAX_WBITS is for compression only */ #if MAX_MEM_LEVEL >= 8 # define DEF_MEM_LEVEL 8 #else # define DEF_MEM_LEVEL MAX_MEM_LEVEL #endif /* default memLevel */ #define STORED_BLOCK 0 #define STATIC_TREES 1 #define DYN_TREES 2 /* The three kinds of block type */ #define MIN_MATCH 3 #define MAX_MATCH 258 /* The minimum and maximum match lengths */ #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ /* target dependencies */ #if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) # define OS_CODE 0x00 # if defined(__TURBOC__) || defined(__BORLANDC__) # if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) /* Allow compilation with ANSI keywords only enabled */ void _Cdecl farfree( void *block ); void *_Cdecl farmalloc( unsigned long nbytes ); # else # include # endif # else /* MSC or DJGPP */ # include # endif #endif #ifdef AMIGA # define OS_CODE 0x01 #endif #if defined(VAXC) || defined(VMS) # define OS_CODE 0x02 # define F_OPEN(name, mode) \ fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") #endif #if defined(ATARI) || defined(atarist) # define OS_CODE 0x05 #endif #ifdef OS2 # define OS_CODE 0x06 # ifdef M_I86 # include # endif #endif #if defined(MACOS) || defined(TARGET_OS_MAC) # define OS_CODE 0x07 # if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os # include /* for fdopen */ # else # ifndef fdopen # define fdopen(fd,mode) NULL /* No fdopen() */ # endif # endif #endif #ifdef TOPS20 # define OS_CODE 0x0a #endif #ifdef WIN32 # ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */ # define OS_CODE 0x0b # endif #endif #ifdef __50SERIES /* Prime/PRIMOS */ # define OS_CODE 0x0f #endif #if defined(_BEOS_) || defined(RISCOS) # define fdopen(fd,mode) NULL /* No fdopen() */ #endif #if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX # if defined(_WIN32_WCE) # define fdopen(fd,mode) NULL /* No fdopen() */ # ifndef _PTRDIFF_T_DEFINED typedef int ptrdiff_t; # define _PTRDIFF_T_DEFINED # endif # else # define fdopen(fd,type) _fdopen(fd,type) # endif #endif #if defined(__BORLANDC__) #pragma warn -8004 #pragma warn -8008 #pragma warn -8066 #endif /* provide prototypes for these when building zlib without LFS */ #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); #endif /* common defaults */ #ifndef OS_CODE # define OS_CODE 0x03 /* assume Unix */ #endif #ifndef F_OPEN # define F_OPEN(name, mode) fopen((name), (mode)) #endif /* functions */ #if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) # ifndef HAVE_VSNPRINTF # define HAVE_VSNPRINTF # endif #endif #if defined(__CYGWIN__) # ifndef HAVE_VSNPRINTF # define HAVE_VSNPRINTF # endif #endif #ifndef HAVE_VSNPRINTF # ifdef MSDOS /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), but for now we just assume it doesn't. */ # define NO_vsnprintf # endif # ifdef __TURBOC__ # define NO_vsnprintf # endif # ifdef WIN32 /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ # if !defined(vsnprintf) && !defined(NO_vsnprintf) # if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) # define vsnprintf _vsnprintf # endif # endif # endif # ifdef __SASC # define NO_vsnprintf # endif #endif #ifdef VMS # define NO_vsnprintf #endif #if defined(pyr) # define NO_MEMCPY #endif #if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) /* Use our own functions for small and medium model with MSC <= 5.0. * You may have to use the same strategy for Borland C (untested). * The __SC__ check is for Symantec. */ # define NO_MEMCPY #endif #if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) # define HAVE_MEMCPY #endif #ifdef HAVE_MEMCPY # ifdef SMALL_MEDIUM /* MSDOS small or medium model */ # define zmemcpy _fmemcpy # define zmemcmp _fmemcmp # define zmemzero(dest, len) _fmemset(dest, 0, len) # else # define zmemcpy memcpy # define zmemcmp memcmp # define zmemzero(dest, len) memset(dest, 0, len) # endif #else void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); #endif /* Diagnostic functions */ #ifdef DEBUG # include extern int ZLIB_INTERNAL z_verbose; extern void ZLIB_INTERNAL z_error OF((char *m)); # define Assert(cond,msg) {if(!(cond)) z_error(msg);} # define Trace(x) {if (z_verbose>=0) fprintf x ;} # define Tracev(x) {if (z_verbose>0) fprintf x ;} # define Tracevv(x) {if (z_verbose>1) fprintf x ;} # define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} # define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} #else # define Assert(cond,msg) # define Trace(x) # define Tracev(x) # define Tracevv(x) # define Tracec(c,x) # define Tracecv(c,x) #endif voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, unsigned size)); void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); #define ZALLOC(strm, items, size) \ (*((strm)->zalloc))((strm)->opaque, (items), (size)) #define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) #define TRY_FREE(s, p) {if (p) ZFREE(s, p);} #endif /* ZUTIL_H */ healpy-1.10.3/cfitsio/CMakeLists.txt0000664000175000017500000000537013010375004017524 0ustar zoncazonca00000000000000PROJECT(CFITSIO) CMAKE_MINIMUM_REQUIRED(VERSION 2.8.0) # Allow the developer to select if Dynamic or Static libraries are built OPTION (BUILD_SHARED_LIBS "Build Shared Libraries" ON) OPTION (USE_PTHREADS "Thread-safe build (using pthreads)" OFF) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}") # Define project version SET(${PROJECT_NAME}_MAJOR_VERSION 3) SET(${PROJECT_NAME}_MINOR_VERSION 36) SET(${PROJECT_NAME}_VERSION ${${PROJECT_NAME}_MAJOR_VERSION}.${${PROJECT_NAME}_MINOR_VERSION}) IF(WIN32) SET(LIB_NAME cfitsio) ELSE() SET(LIB_NAME libcfitsio) ENDIF() # Define IF(MSVC) ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE) ENDIF() #add_subdirectory (src) SET (LIB_TYPE STATIC) IF (BUILD_SHARED_LIBS) SET (LIB_TYPE SHARED) ENDIF (BUILD_SHARED_LIBS) FILE(GLOB H_FILES "*.h") IF (USE_PTHREADS) FIND_PACKAGE(pthreads REQUIRED) INCLUDE_DIRECTORIES(${PTHREADS_INCLUDE_DIR}) ADD_DEFINITIONS(-D_REENTRANT) ENDIF() SET(SRC_FILES buffers.c cfileio.c checksum.c drvrfile.c drvrmem.c drvrnet.c drvrsmem.c drvrgsiftp.c editcol.c edithdu.c eval_l.c eval_y.c eval_f.c fitscore.c getcol.c getcolb.c getcold.c getcole.c getcoli.c getcolj.c getcolk.c getcoll.c getcols.c getcolsb.c getcoluk.c getcolui.c getcoluj.c getkey.c group.c grparser.c histo.c iraffits.c modkey.c putcol.c putcolb.c putcold.c putcole.c putcoli.c putcolj.c putcolk.c putcoluk.c putcoll.c putcols.c putcolsb.c putcolu.c putcolui.c putcoluj.c putkey.c region.c scalnull.c swapproc.c wcssub.c wcsutil.c imcompress.c quantize.c ricecomp.c pliocomp.c fits_hcompress.c fits_hdecompress.c zlib/zuncompress.c zlib/zcompress.c zlib/adler32.c zlib/crc32.c zlib/inffast.c zlib/inftrees.c zlib/trees.c zlib/zutil.c zlib/deflate.c zlib/infback.c zlib/inflate.c zlib/uncompr.c f77_wrap1.c f77_wrap2.c f77_wrap3.c f77_wrap4.c ) ADD_LIBRARY(${LIB_NAME} ${LIB_TYPE} ${H_FILES} ${SRC_FILES}) TARGET_LINK_LIBRARIES(${LIB_NAME} ${PTHREADS_LIBRARY} ) SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES VERSION ${PROJECT_NAME}_VERSION ) ENABLE_TESTING() ADD_EXECUTABLE(TestProg testprog.c) TARGET_LINK_LIBRARIES(TestProg ${LIB_NAME}) ADD_TEST(TestProg TestProg) ADD_EXECUTABLE(cookbook cookbook.c) TARGET_LINK_LIBRARIES(cookbook ${LIB_NAME}) ADD_TEST(cookbook cookbook) ADD_EXECUTABLE(FPack fpack.c fpackutil.c) TARGET_LINK_LIBRARIES(FPack ${LIB_NAME}) ADD_EXECUTABLE(Funpack funpack.c fpackutil.c) TARGET_LINK_LIBRARIES(Funpack ${LIB_NAME}) # To expands the command line arguments in Windows, see: # http://msdn.microsoft.com/en-us/library/8bch7bkk.aspx if(MSVC) set_target_properties(FPack Funpack PROPERTIES LINK_FLAGS "setargv.obj" ) endif(MSVC) healpy-1.10.3/cfitsio/FindPthreads.cmake0000664000175000017500000000621113010375004020334 0ustar zoncazonca00000000000000# - Find the Pthreads library # This module searches for the Pthreads library (including the # pthreads-win32 port). # # This module defines these variables: # # PTHREADS_FOUND # True if the Pthreads library was found # PTHREADS_LIBRARY # The location of the Pthreads library # PTHREADS_INCLUDE_DIR # The include path of the Pthreads library # PTHREADS_DEFINITIONS # Preprocessor definitions to define # # This module responds to the PTHREADS_EXCEPTION_SCHEME # variable on Win32 to allow the user to control the # library linked against. The Pthreads-win32 port # provides the ability to link against a version of the # library with exception handling. IT IS NOT RECOMMENDED # THAT YOU USE THIS because most POSIX thread implementations # do not support stack unwinding. # # PTHREADS_EXCEPTION_SCHEME # C = no exceptions (default) # (NOTE: This is the default scheme on most POSIX thread # implementations and what you should probably be using) # CE = C++ Exception Handling # SE = Structure Exception Handling (MSVC only) # # # Define a default exception scheme to link against # and validate user choice. # IF(NOT DEFINED PTHREADS_EXCEPTION_SCHEME) # Assign default if needed SET(PTHREADS_EXCEPTION_SCHEME "C") ELSE(NOT DEFINED PTHREADS_EXCEPTION_SCHEME) # Validate IF(NOT PTHREADS_EXCEPTION_SCHEME STREQUAL "C" AND NOT PTHREADS_EXCEPTION_SCHEME STREQUAL "CE" AND NOT PTHREADS_EXCEPTION_SCHEME STREQUAL "SE") MESSAGE(FATAL_ERROR "See documentation for FindPthreads.cmake, only C, CE, and SE modes are allowed") ENDIF(NOT PTHREADS_EXCEPTION_SCHEME STREQUAL "C" AND NOT PTHREADS_EXCEPTION_SCHEME STREQUAL "CE" AND NOT PTHREADS_EXCEPTION_SCHEME STREQUAL "SE") IF(NOT MSVC AND PTHREADS_EXCEPTION_SCHEME STREQUAL "SE") MESSAGE(FATAL_ERROR "Structured Exception Handling is only allowed for MSVC") ENDIF(NOT MSVC AND PTHREADS_EXCEPTION_SCHEME STREQUAL "SE") ENDIF(NOT DEFINED PTHREADS_EXCEPTION_SCHEME) # # Find the header file # FIND_PATH(PTHREADS_INCLUDE_DIR pthread.h) # # Find the library # SET(names) IF(MSVC) SET(names pthreadV${PTHREADS_EXCEPTION_SCHEME}2 pthread ) ELSEIF(MINGW) SET(names pthreadG${PTHREADS_EXCEPTION_SCHEME}2 pthread ) ELSE(MSVC) # Unix / Cygwin / Apple SET(names pthread) ENDIF(MSVC) FIND_LIBRARY(PTHREADS_LIBRARY ${names} DOC "The Portable Threads Library") IF(PTHREADS_INCLUDE_DIR AND PTHREADS_LIBRARY) SET(PTHREADS_FOUND true) SET(PTHREADS_DEFINITIONS -DHAVE_PTHREAD_H) SET(PTHREADS_INCLUDE_DIRS ${PTHREADS_INCLUDE_DIR}) SET(PTHREADS_LIBRARIES ${PTHREADS_LIBRARY}) ENDIF(PTHREADS_INCLUDE_DIR AND PTHREADS_LIBRARY) IF(PTHREADS_FOUND) IF(NOT PTHREADS_FIND_QUIETLY) MESSAGE(STATUS "Found Pthreads: ${PTHREADS_LIBRARY}") ENDIF(NOT PTHREADS_FIND_QUIETLY) ELSE(PTHREADS_FOUND) IF(PTHREADS_FIND_REQUIRED) MESSAGE(FATAL_ERROR "Could not find the Pthreads Library") ENDIF(PTHREADS_FIND_REQUIRED) ENDIF(PTHREADS_FOUND) healpy-1.10.3/cfitsio/License.txt0000664000175000017500000000260213010375004017102 0ustar zoncazonca00000000000000Copyright (Unpublished--all rights reserved under the copyright laws of the United States), U.S. Government as represented by the Administrator of the National Aeronautics and Space Administration. No copyright is claimed in the United States under Title 17, U.S. Code. Permission to freely use, copy, modify, and distribute this software and its documentation without fee is hereby granted, provided that this copyright notice and disclaimer of warranty appears in all copies. DISCLAIMER: THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND FREEDOM FROM INFRINGEMENT, AND ANY WARRANTY THAT THE DOCUMENTATION WILL CONFORM TO THE SOFTWARE, OR ANY WARRANTY THAT THE SOFTWARE WILL BE ERROR FREE. IN NO EVENT SHALL NASA BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM, OR IN ANY WAY CONNECTED WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY, CONTRACT, TORT , OR OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM, OR AROSE OUT OF THE RESULTS OF, OR USE OF, THE SOFTWARE OR SERVICES PROVIDED HEREUNDER. healpy-1.10.3/cfitsio/Makefile.in0000664000175000017500000001252213010375004017026 0ustar zoncazonca00000000000000# # Makefile for cfitsio library: # libcfits.a # # Oct-96 : original version by # # JDD/WDP # NASA GSFC # Oct 1996 # # 25-Jan-01 : removed conditional drvrsmem.c compilation because this # is now handled within the source file itself. # 09-Mar-98 : modified to conditionally compile drvrsmem.c. Also # changes to target all (deleted clean), added DEFS, LIBS, added # DEFS to .c.o, added SOURCES_SHMEM and MY_SHMEM, expanded getcol* # and putcol* in SOURCES, modified OBJECTS, mv changed to /bin/mv # (to bypass aliasing), cp changed to /bin/cp, add smem and # testprog targets. See also changes and comments in configure.in # CFITSIO version numbers: CFITSIO_MAJOR = @CFITSIO_MAJOR@ CFITSIO_MINOR = @CFITSIO_MINOR@ CFITSIO_SONAME = @CFITSIO_SONAME@ prefix = @prefix@ exec_prefix = @exec_prefix@ DESTDIR = CFITSIO_LIB = ${DESTDIR}@libdir@ CFITSIO_INCLUDE = ${DESTDIR}@includedir@ INSTALL_DIRS = @INSTALL_ROOT@ ${CFITSIO_INCLUDE} ${CFITSIO_LIB} ${CFITSIO_LIB}/pkgconfig SHELL = /bin/sh ARCHIVE = @ARCHIVE@ RANLIB = @RANLIB@ CC = @CC@ CFLAGS = @CFLAGS@ SSE_FLAGS = @SSE_FLAGS@ FC = @FC@ LDFLAGS = $(CFLAGS) DEFS = @DEFS@ LIBS = @LIBS@ FLEX = flex BISON = bison SHLIB_LD = @SHLIB_LD@ SHLIB_SUFFIX = @SHLIB_SUFFIX@ CFITSIO_SHLIB = @CFITSIO_SHLIB@ CFITSIO_SHLIB_SONAME = @CFITSIO_SHLIB_SONAME@ CORE_SOURCES = buffers.c cfileio.c checksum.c drvrfile.c drvrmem.c \ drvrnet.c drvrsmem.c drvrgsiftp.c editcol.c edithdu.c eval_l.c \ eval_y.c eval_f.c fitscore.c getcol.c getcolb.c getcold.c getcole.c \ getcoli.c getcolj.c getcolk.c getcoll.c getcols.c getcolsb.c \ getcoluk.c getcolui.c getcoluj.c getkey.c group.c grparser.c \ histo.c iraffits.c \ modkey.c putcol.c putcolb.c putcold.c putcole.c putcoli.c \ putcolj.c putcolk.c putcoluk.c putcoll.c putcols.c putcolsb.c \ putcolu.c putcolui.c putcoluj.c putkey.c region.c scalnull.c \ swapproc.c wcssub.c wcsutil.c imcompress.c quantize.c ricecomp.c \ pliocomp.c fits_hcompress.c fits_hdecompress.c ZLIB_SOURCES = zlib/adler32.c zlib/crc32.c zlib/deflate.c zlib/infback.c \ zlib/inffast.c zlib/inflate.c zlib/inftrees.c zlib/trees.c \ zlib/uncompr.c zlib/zcompress.c zlib/zuncompress.c zlib/zutil.c SOURCES = ${CORE_SOURCES} ${ZLIB_SOURCES} @F77_WRAPPERS@ OBJECTS = ${SOURCES:.c=.o} CORE_OBJECTS = ${CORE_SOURCES:.c=.o} ${ZLIB_SOURCES:.c=.o} FITSIO_SRC = f77_wrap1.c f77_wrap2.c f77_wrap3.c f77_wrap4.c # ============ description of all targets ============= # - <<-- ignore error code all: @if [ "x${FC}" = x ]; then \ ${MAKE} all-nofitsio; \ else \ ${MAKE} stand_alone; \ fi all-nofitsio: ${MAKE} stand_alone "FITSIO_SRC=" stand_alone: libcfitsio.a libcfitsio.a: ${OBJECTS} ${ARCHIVE} libcfitsio.a ${OBJECTS}; \ ${RANLIB} libcfitsio.a; shared: libcfitsio${SHLIB_SUFFIX} libcfitsio${SHLIB_SUFFIX}: ${OBJECTS} ${SHLIB_LD} ${LDFLAGS} -o ${CFITSIO_SHLIB} ${OBJECTS} -lm ${LIBS} @if [ "x${CFITSIO_SHLIB_SONAME}" != x ]; then \ ln -sf ${CFITSIO_SHLIB} ${CFITSIO_SHLIB_SONAME}; \ ln -sf ${CFITSIO_SHLIB_SONAME} $@; \ fi install: libcfitsio.a $(INSTALL_DIRS) /bin/cp -a libcfitsio* ${CFITSIO_LIB} /bin/cp fitsio.h fitsio2.h longnam.h drvrsmem.h ${CFITSIO_INCLUDE} /bin/cp cfitsio.pc ${CFITSIO_LIB}/pkgconfig .c.o: $(CC) -c -o ${ eval_l.c1 /bin/sed -e 's/yy/ff/g' -e 's/YY/FF/g' eval_l.c1 > eval_l.c /bin/rm -f eval_l.c1 $(BISON) -d -v -y eval.y /bin/sed -e 's/yy/ff/g' -e 's/YY/FF/g' y.tab.c > eval_y.c /bin/sed -e 's/yy/ff/g' -e 's/YY/FF/g' y.tab.h > eval_tab.h /bin/rm -f y.tab.c y.tab.h clean: - /bin/rm -f *.o zlib/*.o libcfitsio* fpack funpack \ smem testprog y.output so_locations distclean: clean - /bin/rm -f Makefile cfitsio.pc config.log config.status configure.lineno # Make target which outputs the list of the .o contained in the cfitsio lib # usefull to build a single big shared library containing Tcl/Tk and other # extensions. used for the Tcl Plugin. cfitsioLibObjs: @echo ${CORE_OBJECTS} cfitsioLibSrcs: @echo ${SOURCES} # This target actually builds the objects needed for the lib in the above # case objs: ${CORE_OBJECTS} $(INSTALL_DIRS): @if [ ! -d $@ ]; then mkdir -p $@; fi healpy-1.10.3/cfitsio/README0000664000175000017500000001360713010375004015646 0ustar zoncazonca00000000000000 CFITSIO Interface Library CFITSIO is a library of ANSI C routines for reading and writing FITS format data files. A set of Fortran-callable wrapper routines are also included for the convenience of Fortran programmers. This README file gives a brief summary of how to build and test CFITSIO, but the CFITSIO User's Guide, found in the files cfitsio.doc (plain text), cfitsio.tex (LaTeX source file), cfitsio.ps, or cfitsio.pdf should be referenced for the latest and most complete information. BUILDING CFITSIO ---------------- The CFITSIO code is contained in about 40 *.c source files and several *.h header files. The CFITSIO library is built on Unix systems by typing: > ./configure [--prefix=/target/installation/path] > make (or 'make shared') > make install (this step is optional) at the operating system prompt. The configure command customizes the Makefile for the particular system, then the `make' command compiles the source files and builds the library. Type `./configure' and not simply `configure' to ensure that the configure script in the current directory is run and not some other system-wide configure script. The optional 'prefix' argument to configure gives the path to the directory where the CFITSIO library and include files should be installed via the later 'make install' command. For example, > ./configure --prefix=/usr1/local will cause the 'make install' command to copy the CFITSIO libcfitsio file to /usr1/local/lib and the necessary include files to /usr1/local/include (assuming of course that the process has permission to write to these directories). On VAX/VMS and ALPHA/VMS systems the make.com command file may be used to build the cfitsio.olb object library using the default G-floating point option for double variables. The make\_dfloat.com and make\_ieee.com files may be used instead to build the library with the other floating point options. A precompiled DLL version of CFITSIO is available for IBM-PC users of the Borland or Microsoft Visual C++ compilers in the files cfitsiodll_xxxx_borland.zip and cfitsiodll_xxxx_vcc.zip, where 'xxxx' represents the current release number. These zip archives also contains other files and instructions on how to use the CFITSIO DLL library. The CFITSIO library may also be built from the source code using the makefile.bc or makefile.vcc files. Finally, the makepc.bat file gives an example of building CFITSIO with the Borland C++ v4.5 compiler using simpler DOS commands. When building on Mac OS-X, users should follow the Unix instructions, above. Previous MacOS versions of the cfitsio library can be built by (1) un binhex and unstuff cfitsio_mac.sit.hqx, (2) put CFitsioPPC.mcp in the cfitsio directory, and (3) load CFitsioPPC.mcp into CodeWarrior Pro 5 and make. This builds the cfitsio library for PPC. There are also targets for both the test program and the speed test program. To use the MacOS port you can add Cfitsio PPC.lib to your Codewarrior Pro 5 project. Note that this only has been tested for the PPC and probably won't work on 68k macs. TESTING CFITSIO --------------- The CFITSIO library should be tested by building and running the testprog.c program that is included with the release. On Unix systems, type: - % make testprog % testprog > testprog.lis % diff testprog.lis testprog.out % cmp testprog.fit testprog.std - On VMS systems, (assuming cc is the name of the C compiler command), type: - $ cc testprog.c $ link testprog, cfitsio/lib $ run testprog - The testprog program should produce a FITS file called `testprog.fit' that is identical to the testprog.std FITS file included in this release. The diagnostic messages (which were piped to the file testprog.lis in the Unix example) should be identical to the listing contained in the file testprog.out. The 'diff' and 'cmp' commands shown above should not report any differences in the files. USING CFITSIO ------------- The CFITSIO User's Guide, contained in the files cfitsio.doc (plain text file) and cfitsio.ps (postscript file), provides detailed documentation about how to build and use the CFITSIO library. It contains a description of every user-callable routine in the CFITSIO interface. The cookbook.c file provides some sample routines for performing common operations on various types of FITS files. Programmers are urged to examine these routines for recommended programming practices when using CFITSIO. Users are free to copy or modify these routines for their own purposes. SUPPORTED PLATFORMS ------------------- CFITSIO has currently been tested on the following platforms: Operating System Compiler ---------------- -------- OPERATING SYSTEM COMPILER Sun OS gcc and cc (3.0.1) Sun Solaris gcc and cc Silicon Graphics IRIX gcc and cc Silicon Graphics IRIX64 MIPS Dec Alpha OSF/1 gcc and cc DECstation Ultrix gcc Dec Alpha OpenVMS cc DEC VAX/VMS gcc and cc HP-UX gcc IBM AIX gcc Linux gcc MkLinux DR3 Windows 95/98/NT Borland C++ V4.5 Windows 95/98/NT/ME/XP Microsoft/Compaq Visual C++ v5.0, v6.0 Windows 95/98/NT Cygwin gcc OS/2 gcc + EMX Mac OS 7.1 or greater Metrowerks 10.+ Mac OS-X 10.1 or greater cc (gcc) CFITSIO will probably run on most other Unix platforms without modification. Cray supercomputers and IBM mainframe computers are currently not supported. Reports of any success or failure to run CFITSIO on other platforms would be appreciated. Any problem reports or suggestions for improvements are also welcome and should be sent to the primary author. ------------------------------------------------------------------------- William D. Pence HEASARC, NASA/GSFC email: William.D.Pence@nasa.gov healpy-1.10.3/cfitsio/README.MacOS0000664000175000017500000000414013010375004016577 0ustar zoncazonca00000000000000To build CFITSIO library on an Intel Mac as a Universal Binary Unzip the library: - tar xzf cfitsio3060.tar.gz (or whatever version this is) - cd cfitsio/ - copy the cfitsio-xcodeproj.zip file here - unzip cfitsio-xcodeproj.zip - start Xcode and open cfitsio.xcodeproj - expand the "Targets" menu under "Groups & Files" - choose one of the following build options: * right-click on Build PPC -> Build "Build PPC" * right-click on Build i386 -> Build "Build i386" * right-click on Build x86_64 -> Build "Build x86_64" * right-click on Build Universal -> Build "Build Universal" (Builds all three of the above options, i.e. a Universal Binary usable on ppc, i386, and x86_64 architectures) (For some reason clicking on the menu "Build" icon doesn't seem to work correctly, but the right-click menus do). ------------------------------------------------------- Another way to build the universal binary: - unpack the cfitsio source code tar file - cd cfitsio Set the CFLAGS environment variable for building a Universal Binary: C-Shell variants: setenv CFLAGS "-arch ppc -arch i386 -arch x86_64 -g -O2" Bourne Shell variants: export CFLAGS="-arch ppc -arch i386 -arch x86_64 -g -O2" Then proceed with the standard cfitsio build, i.e.: - ./configure - make - make install ------------------------------------------------------- Below, are the old (and now obsolete) instructions for building CFITSIO on classic Mac OS-9 or earlier versions: 1. Un binhex and unstuff cfitsio_mac.sit.hqx 2. put CFitsioPPC.mcp in the cfitsio directory. 2. Load CFitsioPPC.mcp into CodeWarrior Pro 5 and make. This builds the cfitsio library for PPC. There are also targets for both the test program and the speed test program. To use the MacOS port you can add Cfitsio PPC.lib to your Codewarrior Pro 5 project. Note that this only has been tested for the PPC. It probably won't work on 68k macs. Also note that the fortran bindings aren't included. I haven't worked with the codewarrior f2c plugin so I don't know how these would work. If one is interested, please write and I can look into this. healpy-1.10.3/cfitsio/README.win0000664000175000017500000001376613010375004016450 0ustar zoncazonca00000000000000Instructions on building and using CFITSIO on Windows platforms for C programmers using Microsoft Visual Studio or Borland C++. These instructions for building the CFITSIO library under Windows use the CMake build system that is available from http://www.cmake.org. =============================================================================== 1. Build the CFITSIO dll library This step will create the cfitsio.dll, and cfitsio.lib files. If you have downloaded the CFITSIO DLL .zip file that already contains the pre-built versions of these files, then SKIP THIS STEP. a. If CMAKE is not already installed on your machine, download it from http://www.cmake.org. It is recommended that you choose the "Add CMake to the system PATH for current user" option during the installation setup process for convenience when running CMake later on. b. Unzip the CFITSIO .zip file (e.g. cfit3360.zip) that was obtained from the CFITSIO Web site (http://heasarc.gsfc.nasa.gov/fitsio/). This will create a new \cfitsio subdirectory that contains the source code and documentation files. It should also contain a CMakeLists.txt file that will be used during the CMake build process. c. Open the Visual Studio Command Prompt window, likely using a desktop icon with this same name, (or the equivalent Borland command window) and CD (change directory) into the parent directory that is one level above the directory containing the CFITSIO source files that was created in the previous step. d. Create a new "cfitsio.build" subdirectory, and CD into it with the following commands: mkdir cfitsio.build cd cfitsio.build When using Visual Studio, all the files that are generated during the CMake process will be created in or under this subdirectory. e. Decide which CMake Generator you will want to use in the following step. This depends on which C/C++ compiler you are using and will likely have a name such as: "Visual Studio 10" "Visual Studio 10 Win64" (for 64-bit builds) "Visual Studio 11" "Visual Studio 11 Win64" (for 64-bit builds) "Visual Studio 12" "Visual Studio 12 Win64" (for 64-bit builds) "Borland Makefiles" "NMake Makefiles" You can see a list of all the available CMake Generators by executing the command cmake.exe /? Note that these names are case-sensitive and must be entered in the following step exactly as displayed. f. Execute the following commands to build the CFITSIO library: cmake.exe -G "" ..\cfitsio cmake.exe --build . --config Release Where the string is the string that was selected in step e. Note that the "..\cfitsio" argument in the first command gives the path to the directory that contains the CFITSIO source files and the CMakeLists.txt file. The "." argument in the second command (following --build) tells CMake to build the files in the current directory (i.e., the cfitsio.build directory). If this process completes successfully, you should find the CFITSIO library files that were created in the "cfitsio.build\Release" subdirectory. To verify that CFITSIO is working correctly, execute the testprog.exe file (in that Release directory). This should generate a long stream of diagnostic messages ending with the line "Status = 0: OK - no error". g. Other CMake options. CMake has many other build options that may be useful in some situations. Refer to the CMake documentation for more information. For example, one can build a 'debug' version of the CFITSIO library by executing the command "cmake.exe --build ." instead of the 2nd command listed above in section f. One can also make a thread safe version of CFITSIO using the pthread library with the following procedure: a. Download the precompiled files from the pthread-win32 project (http://sourceware.org/pthreads-win32/). Put the files for your specific platform (.h, .lib, .dll) into a folder 'pthread', parallel to the cfitsio source folder. b. For the compilation of cfitsio follow the cmake steps, but use this change as a replacement for the commands in step f: cmake.exe -G "" ..\cfitsio -DUSE_PTHREADS=1 -DCMAKE_INCLUDE_PATH=..\pthread -DCMAKE_LIBRARY_PATH=..\pthread cmake.exe --build . --config Release You may need to adapt the paths for the source directory and the pthread library. ============================================================================ 2. Using CFITSIO when compiling and linking application programs First, depending on your particular programming environment, it may be necessary to copy the cfitsio.lib and cfitsio.dll files into another directory where your compiler expects to find them. Or equivalently, you may need to specify the directory path to the location of the CFITSIO library files when creating a project that uses them. You may also need to copy the fitsio.h and longnam.h include files from the \cfitsio source file directory to a standard 'include' directory on your system. When using the Visual Studio command line window, application programs can be compiled and linked with CFITSIO using the following command: cl /MD your_program.c cfitsio.lib The /MD command line switch must be specified to force the compiler/linker to use the appropriate runtime library. If this switch is omitted, then the fits_report_error function in CFITSIO will likely crash. When building programs in the Visual Studio graphical environment, one can force the equivalent of the /MD switch by selecting 'Settings...' under the 'Project' menu, then click on the C/C++ tab and select the 'Code Generator' category. Then under 'User Run-time Library' select 'Multithreaded DLL'. =============================================================================== healpy-1.10.3/cfitsio/README_OLD.win0000664000175000017500000000671613010375004017143 0ustar zoncazonca00000000000000=============================================================================== =============================================================================== = NOTE: This is the old version of the README.win32 file that was distributed = with CFITSIO up until version 3.35 in 2013. These instruction may still work = with more recent versions of CFITSIO, however, users are strongly urged to = use the CMake procedures that are now documented in the new README.win32 file. =============================================================================== =============================================================================== Instructions on using CFITSIO on Windows platforms for C programmers These instructions use a simple DOS-style command window. It is also possible to build and use CFITSIO within a GUI programming environment such as Visual Studio, but this is not supported here. =============================================================================== 1. Build the CFITSIO dll library This step will create the cfitsio.def, cfitsio.dll, and cfitsio.lib files. (If you downloaded the CFITSIO .zip file that contains the pre-built binary .dll file, then SKIP THIS STEP). A. With Microsoft Visual C++: 1. Open a DOS command window and execute the vcvars32.bat file that is distributed with older versions of Visual C++, or simply open the Visual C++ command window (e.g., when using Visual Studio 2010). 2. Unpack the CFITSIO source files (cfitxxxx.zip) into a new empty directory 3. In the DOS command window, cd to that directory and enter the following commands: nmake winDumpExts.mak nmake makefile.vcc (ignore the compiler warning messages) B: With Borland C++: First, follow the instructions provided by Borland to set up the proper environment variables and configure files for the compiler. Unpack the cfitsio.zip source file distribution into a suitable directory. In a DOS command window, cd to that directory and then execute the makepc.bat batch file on the command line to build the CFITSIO library, and the testprog and cookbook sample programs. =============================================================================== 2. Test the CFITSIO library with Visual C++ Compile and link the testprog.c test program. When using Visual Studio, the command is: cl /MD testprog.c cfitsio.lib This will create the testprog.exe executable program. Running this program should print out a long series of diagnostic messages that should end with "Status = 0; OK - no error" =============================================================================== 3. Compile and link an application program that calls CFITSIO routines with Visual C++ Include the fitsio.h and longnam.h header files in the C source code. Link the program with the cfitsio.lib file: cl /MD your_program.c cfitsio.lib NOTE: The /MD command line switch must be specified on the cl command line to force the compiler/linker to use the appropriete runtime library. If this switch is omitted, then the fits_report_error function in CFITSIO will likely crash. When building programs in the Visual Studio environment, one can force the equivalent of the /MD switch by selecting 'Settings...' under the 'Project' menu, then click on the C/C++ tab and select the 'Code Generator' category. Then under 'User Run-time Library' select 'Multithreaded DLL'. healpy-1.10.3/cfitsio/buffers.c0000664000175000017500000014772613010375004016600 0ustar zoncazonca00000000000000/* This file, buffers.c, contains the core set of FITSIO routines */ /* that use or manage the internal set of IO buffers. */ /* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ #include #include #include "fitsio2.h" /*--------------------------------------------------------------------------*/ int ffmbyt(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG bytepos, /* I - byte position in file to move to */ int err_mode, /* I - 1=ignore error, 0 = return error */ int *status) /* IO - error status */ { /* Move to the input byte location in the file. When writing to a file, a move may sometimes be made to a position beyond the current EOF. The err_mode parameter determines whether such conditions should be returned as an error or simply ignored. */ long record; if (*status > 0) return(*status); if (bytepos < 0) return(*status = NEG_FILE_POS); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); record = (long) (bytepos / IOBUFLEN); /* zero-indexed record number */ /* if this is not the current record, then load it */ if ( ((fptr->Fptr)->curbuf < 0) || (record != (fptr->Fptr)->bufrecnum[(fptr->Fptr)->curbuf])) ffldrc(fptr, record, err_mode, status); if (*status <= 0) (fptr->Fptr)->bytepos = bytepos; /* save new file position */ return(*status); } /*--------------------------------------------------------------------------*/ int ffpbyt(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG nbytes, /* I - number of bytes to write */ void *buffer, /* I - buffer containing the bytes to write */ int *status) /* IO - error status */ /* put (write) the buffer of bytes to the output FITS file, starting at the current file position. Write large blocks of data directly to disk; write smaller segments to intermediate IO buffers to improve efficiency. */ { int ii, nbuff; LONGLONG filepos; long recstart, recend; long ntodo, bufpos, nspace, nwrite; char *cptr; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); if (nbytes > LONG_MAX) { ffpmsg("Number of bytes to write is greater than LONG_MAX (ffpbyt)."); *status = WRITE_ERROR; return(*status); } ntodo = (long) nbytes; cptr = (char *)buffer; if ((fptr->Fptr)->curbuf < 0) /* no current data buffer for this file */ { /* so reload the last one that was used */ ffldrc(fptr, (long) (((fptr->Fptr)->bytepos) / IOBUFLEN), REPORT_EOF, status); } if (nbytes >= MINDIRECT) { /* write large blocks of data directly to disk instead of via buffers */ /* first, fill up the current IO buffer before flushing it to disk */ nbuff = (fptr->Fptr)->curbuf; /* current IO buffer number */ filepos = (fptr->Fptr)->bytepos; /* save the write starting position */ recstart = (fptr->Fptr)->bufrecnum[nbuff]; /* starting record */ recend = (long) ((filepos + nbytes - 1) / IOBUFLEN); /* ending record */ /* bufpos is the starting position within the IO buffer */ bufpos = (long) (filepos - ((LONGLONG)recstart * IOBUFLEN)); nspace = IOBUFLEN - bufpos; /* amount of space left in the buffer */ if (nspace) { /* fill up the IO buffer */ memcpy((fptr->Fptr)->iobuffer + (nbuff * IOBUFLEN) + bufpos, cptr, nspace); ntodo -= nspace; /* decrement remaining number of bytes */ cptr += nspace; /* increment user buffer pointer */ filepos += nspace; /* increment file position pointer */ (fptr->Fptr)->dirty[nbuff] = TRUE; /* mark record as having been modified */ } for (ii = 0; ii < NIOBUF; ii++) /* flush any affected buffers to disk */ { if ((fptr->Fptr)->bufrecnum[ii] >= recstart && (fptr->Fptr)->bufrecnum[ii] <= recend ) { if ((fptr->Fptr)->dirty[ii]) /* flush modified buffer to disk */ ffbfwt(fptr->Fptr, ii, status); (fptr->Fptr)->bufrecnum[ii] = -1; /* disassociate buffer from the file */ } } /* move to the correct write position */ if ((fptr->Fptr)->io_pos != filepos) ffseek(fptr->Fptr, filepos); nwrite = ((ntodo - 1) / IOBUFLEN) * IOBUFLEN; /* don't write last buff */ ffwrite(fptr->Fptr, nwrite, cptr, status); /* write the data */ ntodo -= nwrite; /* decrement remaining number of bytes */ cptr += nwrite; /* increment user buffer pointer */ (fptr->Fptr)->io_pos = filepos + nwrite; /* update the file position */ if ((fptr->Fptr)->io_pos >= (fptr->Fptr)->filesize) /* at the EOF? */ { (fptr->Fptr)->filesize = (fptr->Fptr)->io_pos; /* increment file size */ /* initialize the current buffer with the correct fill value */ if ((fptr->Fptr)->hdutype == ASCII_TBL) memset((fptr->Fptr)->iobuffer + (nbuff * IOBUFLEN), 32, IOBUFLEN); /* blank fill */ else memset((fptr->Fptr)->iobuffer + (nbuff * IOBUFLEN), 0, IOBUFLEN); /* zero fill */ } else { /* read next record */ ffread(fptr->Fptr, IOBUFLEN, (fptr->Fptr)->iobuffer + (nbuff * IOBUFLEN), status); (fptr->Fptr)->io_pos += IOBUFLEN; } /* copy remaining bytes from user buffer into current IO buffer */ memcpy((fptr->Fptr)->iobuffer + (nbuff * IOBUFLEN), cptr, ntodo); (fptr->Fptr)->dirty[nbuff] = TRUE; /* mark record as having been modified */ (fptr->Fptr)->bufrecnum[nbuff] = recend; /* record number */ (fptr->Fptr)->logfilesize = maxvalue((fptr->Fptr)->logfilesize, (LONGLONG)(recend + 1) * IOBUFLEN); (fptr->Fptr)->bytepos = filepos + nwrite + ntodo; } else { /* bufpos is the starting position in IO buffer */ bufpos = (long) ((fptr->Fptr)->bytepos - ((LONGLONG)(fptr->Fptr)->bufrecnum[(fptr->Fptr)->curbuf] * IOBUFLEN)); nspace = IOBUFLEN - bufpos; /* amount of space left in the buffer */ while (ntodo) { nwrite = minvalue(ntodo, nspace); /* copy bytes from user's buffer to the IO buffer */ memcpy((fptr->Fptr)->iobuffer + ((fptr->Fptr)->curbuf * IOBUFLEN) + bufpos, cptr, nwrite); ntodo -= nwrite; /* decrement remaining number of bytes */ cptr += nwrite; (fptr->Fptr)->bytepos += nwrite; /* increment file position pointer */ (fptr->Fptr)->dirty[(fptr->Fptr)->curbuf] = TRUE; /* mark record as modified */ if (ntodo) /* load next record into a buffer */ { ffldrc(fptr, (long) ((fptr->Fptr)->bytepos / IOBUFLEN), IGNORE_EOF, status); bufpos = 0; nspace = IOBUFLEN; } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffpbytoff(fitsfile *fptr, /* I - FITS file pointer */ long gsize, /* I - size of each group of bytes */ long ngroups, /* I - number of groups to write */ long offset, /* I - size of gap between groups */ void *buffer, /* I - buffer to be written */ int *status) /* IO - error status */ /* put (write) the buffer of bytes to the output FITS file, with an offset between each group of bytes. This function combines ffmbyt and ffpbyt for increased efficiency. */ { int bcurrent; long ii, bufpos, nspace, nwrite, record; char *cptr, *ioptr; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); if ((fptr->Fptr)->curbuf < 0) /* no current data buffer for this file */ { /* so reload the last one that was used */ ffldrc(fptr, (long) (((fptr->Fptr)->bytepos) / IOBUFLEN), REPORT_EOF, status); } cptr = (char *)buffer; bcurrent = (fptr->Fptr)->curbuf; /* number of the current IO buffer */ record = (fptr->Fptr)->bufrecnum[bcurrent]; /* zero-indexed record number */ bufpos = (long) ((fptr->Fptr)->bytepos - ((LONGLONG)record * IOBUFLEN)); /* start pos */ nspace = IOBUFLEN - bufpos; /* amount of space left in buffer */ ioptr = (fptr->Fptr)->iobuffer + (bcurrent * IOBUFLEN) + bufpos; for (ii = 1; ii < ngroups; ii++) /* write all but the last group */ { /* copy bytes from user's buffer to the IO buffer */ nwrite = minvalue(gsize, nspace); memcpy(ioptr, cptr, nwrite); cptr += nwrite; /* increment buffer pointer */ if (nwrite < gsize) /* entire group did not fit */ { (fptr->Fptr)->dirty[bcurrent] = TRUE; /* mark record as having been modified */ record++; ffldrc(fptr, record, IGNORE_EOF, status); /* load next record */ bcurrent = (fptr->Fptr)->curbuf; ioptr = (fptr->Fptr)->iobuffer + (bcurrent * IOBUFLEN); nwrite = gsize - nwrite; memcpy(ioptr, cptr, nwrite); cptr += nwrite; /* increment buffer pointer */ ioptr += (offset + nwrite); /* increment IO buffer pointer */ nspace = IOBUFLEN - offset - nwrite; /* amount of space left */ } else { ioptr += (offset + nwrite); /* increment IO bufer pointer */ nspace -= (offset + nwrite); } if (nspace <= 0) /* beyond current record? */ { (fptr->Fptr)->dirty[bcurrent] = TRUE; record += ((IOBUFLEN - nspace) / IOBUFLEN); /* new record number */ ffldrc(fptr, record, IGNORE_EOF, status); bcurrent = (fptr->Fptr)->curbuf; bufpos = (-nspace) % IOBUFLEN; /* starting buffer pos */ nspace = IOBUFLEN - bufpos; ioptr = (fptr->Fptr)->iobuffer + (bcurrent * IOBUFLEN) + bufpos; } } /* now write the last group */ nwrite = minvalue(gsize, nspace); memcpy(ioptr, cptr, nwrite); cptr += nwrite; /* increment buffer pointer */ if (nwrite < gsize) /* entire group did not fit */ { (fptr->Fptr)->dirty[bcurrent] = TRUE; /* mark record as having been modified */ record++; ffldrc(fptr, record, IGNORE_EOF, status); /* load next record */ bcurrent = (fptr->Fptr)->curbuf; ioptr = (fptr->Fptr)->iobuffer + (bcurrent * IOBUFLEN); nwrite = gsize - nwrite; memcpy(ioptr, cptr, nwrite); } (fptr->Fptr)->dirty[bcurrent] = TRUE; /* mark record as having been modified */ (fptr->Fptr)->bytepos = (fptr->Fptr)->bytepos + (ngroups * gsize) + (ngroups - 1) * offset; return(*status); } /*--------------------------------------------------------------------------*/ int ffgbyt(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG nbytes, /* I - number of bytes to read */ void *buffer, /* O - buffer to read into */ int *status) /* IO - error status */ /* get (read) the requested number of bytes from the file, starting at the current file position. Read large blocks of data directly from disk; read smaller segments via intermediate IO buffers to improve efficiency. */ { int ii; LONGLONG filepos; long recstart, recend, ntodo, bufpos, nspace, nread; char *cptr; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); cptr = (char *)buffer; if (nbytes >= MINDIRECT) { /* read large blocks of data directly from disk instead of via buffers */ filepos = (fptr->Fptr)->bytepos; /* save the read starting position */ /* note that in this case, ffmbyt has not been called, and so */ /* bufrecnum[(fptr->Fptr)->curbuf] does not point to the intended */ /* output buffer */ recstart = (long) (filepos / IOBUFLEN); /* starting record */ recend = (long) ((filepos + nbytes - 1) / IOBUFLEN); /* ending record */ for (ii = 0; ii < NIOBUF; ii++) /* flush any affected buffers to disk */ { if ((fptr->Fptr)->dirty[ii] && (fptr->Fptr)->bufrecnum[ii] >= recstart && (fptr->Fptr)->bufrecnum[ii] <= recend) { ffbfwt(fptr->Fptr, ii, status); /* flush modified buffer to disk */ } } /* move to the correct read position */ if ((fptr->Fptr)->io_pos != filepos) ffseek(fptr->Fptr, filepos); ffread(fptr->Fptr, (long) nbytes, cptr, status); /* read the data */ (fptr->Fptr)->io_pos = filepos + nbytes; /* update the file position */ } else { /* read small chucks of data using the IO buffers for efficiency */ if ((fptr->Fptr)->curbuf < 0) /* no current data buffer for this file */ { /* so reload the last one that was used */ ffldrc(fptr, (long) (((fptr->Fptr)->bytepos) / IOBUFLEN), REPORT_EOF, status); } /* bufpos is the starting position in IO buffer */ bufpos = (long) ((fptr->Fptr)->bytepos - ((LONGLONG)(fptr->Fptr)->bufrecnum[(fptr->Fptr)->curbuf] * IOBUFLEN)); nspace = IOBUFLEN - bufpos; /* amount of space left in the buffer */ ntodo = (long) nbytes; while (ntodo) { nread = minvalue(ntodo, nspace); /* copy bytes from IO buffer to user's buffer */ memcpy(cptr, (fptr->Fptr)->iobuffer + ((fptr->Fptr)->curbuf * IOBUFLEN) + bufpos, nread); ntodo -= nread; /* decrement remaining number of bytes */ cptr += nread; (fptr->Fptr)->bytepos += nread; /* increment file position pointer */ if (ntodo) /* load next record into a buffer */ { ffldrc(fptr, (long) ((fptr->Fptr)->bytepos / IOBUFLEN), REPORT_EOF, status); bufpos = 0; nspace = IOBUFLEN; } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffgbytoff(fitsfile *fptr, /* I - FITS file pointer */ long gsize, /* I - size of each group of bytes */ long ngroups, /* I - number of groups to read */ long offset, /* I - size of gap between groups (may be < 0) */ void *buffer, /* I - buffer to be filled */ int *status) /* IO - error status */ /* get (read) the requested number of bytes from the file, starting at the current file position. This function combines ffmbyt and ffgbyt for increased efficiency. */ { int bcurrent; long ii, bufpos, nspace, nread, record; char *cptr, *ioptr; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); if ((fptr->Fptr)->curbuf < 0) /* no current data buffer for this file */ { /* so reload the last one that was used */ ffldrc(fptr, (long) (((fptr->Fptr)->bytepos) / IOBUFLEN), REPORT_EOF, status); } cptr = (char *)buffer; bcurrent = (fptr->Fptr)->curbuf; /* number of the current IO buffer */ record = (fptr->Fptr)->bufrecnum[bcurrent]; /* zero-indexed record number */ bufpos = (long) ((fptr->Fptr)->bytepos - ((LONGLONG)record * IOBUFLEN)); /* start pos */ nspace = IOBUFLEN - bufpos; /* amount of space left in buffer */ ioptr = (fptr->Fptr)->iobuffer + (bcurrent * IOBUFLEN) + bufpos; for (ii = 1; ii < ngroups; ii++) /* read all but the last group */ { /* copy bytes from IO buffer to the user's buffer */ nread = minvalue(gsize, nspace); memcpy(cptr, ioptr, nread); cptr += nread; /* increment buffer pointer */ if (nread < gsize) /* entire group did not fit */ { record++; ffldrc(fptr, record, REPORT_EOF, status); /* load next record */ bcurrent = (fptr->Fptr)->curbuf; ioptr = (fptr->Fptr)->iobuffer + (bcurrent * IOBUFLEN); nread = gsize - nread; memcpy(cptr, ioptr, nread); cptr += nread; /* increment buffer pointer */ ioptr += (offset + nread); /* increment IO buffer pointer */ nspace = IOBUFLEN - offset - nread; /* amount of space left */ } else { ioptr += (offset + nread); /* increment IO bufer pointer */ nspace -= (offset + nread); } if (nspace <= 0 || nspace > IOBUFLEN) /* beyond current record? */ { if (nspace <= 0) { record += ((IOBUFLEN - nspace) / IOBUFLEN); /* new record number */ bufpos = (-nspace) % IOBUFLEN; /* starting buffer pos */ } else { record -= ((nspace - 1 ) / IOBUFLEN); /* new record number */ bufpos = IOBUFLEN - (nspace % IOBUFLEN); /* starting buffer pos */ } ffldrc(fptr, record, REPORT_EOF, status); bcurrent = (fptr->Fptr)->curbuf; nspace = IOBUFLEN - bufpos; ioptr = (fptr->Fptr)->iobuffer + (bcurrent * IOBUFLEN) + bufpos; } } /* now read the last group */ nread = minvalue(gsize, nspace); memcpy(cptr, ioptr, nread); cptr += nread; /* increment buffer pointer */ if (nread < gsize) /* entire group did not fit */ { record++; ffldrc(fptr, record, REPORT_EOF, status); /* load next record */ bcurrent = (fptr->Fptr)->curbuf; ioptr = (fptr->Fptr)->iobuffer + (bcurrent * IOBUFLEN); nread = gsize - nread; memcpy(cptr, ioptr, nread); } (fptr->Fptr)->bytepos = (fptr->Fptr)->bytepos + (ngroups * gsize) + (ngroups - 1) * offset; return(*status); } /*--------------------------------------------------------------------------*/ int ffldrc(fitsfile *fptr, /* I - FITS file pointer */ long record, /* I - record number to be loaded */ int err_mode, /* I - 1=ignore EOF, 0 = return EOF error */ int *status) /* IO - error status */ { /* low-level routine to load a specified record from a file into a physical buffer, if it is not already loaded. Reset all pointers to make this the new current record for that file. Update ages of all the physical buffers. */ int ibuff, nbuff; LONGLONG rstart; /* check if record is already loaded in one of the buffers */ /* search from youngest to oldest buffer for efficiency */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); for (ibuff = NIOBUF - 1; ibuff >= 0; ibuff--) { nbuff = (fptr->Fptr)->ageindex[ibuff]; if (record == (fptr->Fptr)->bufrecnum[nbuff]) { goto updatebuf; /* use 'goto' for efficiency */ } } /* record is not already loaded */ rstart = (LONGLONG)record * IOBUFLEN; if ( !err_mode && (rstart >= (fptr->Fptr)->logfilesize) ) /* EOF? */ return(*status = END_OF_FILE); if (ffwhbf(fptr, &nbuff) < 0) /* which buffer should we reuse? */ return(*status = TOO_MANY_FILES); if ((fptr->Fptr)->dirty[nbuff]) ffbfwt(fptr->Fptr, nbuff, status); /* write dirty buffer to disk */ if (rstart >= (fptr->Fptr)->filesize) /* EOF? */ { /* initialize an empty buffer with the correct fill value */ if ((fptr->Fptr)->hdutype == ASCII_TBL) memset((fptr->Fptr)->iobuffer + (nbuff * IOBUFLEN), 32, IOBUFLEN); /* blank fill */ else memset((fptr->Fptr)->iobuffer + (nbuff * IOBUFLEN), 0, IOBUFLEN); /* zero fill */ (fptr->Fptr)->logfilesize = maxvalue((fptr->Fptr)->logfilesize, rstart + IOBUFLEN); (fptr->Fptr)->dirty[nbuff] = TRUE; /* mark record as having been modified */ } else /* not EOF, so read record from disk */ { if ((fptr->Fptr)->io_pos != rstart) ffseek(fptr->Fptr, rstart); ffread(fptr->Fptr, IOBUFLEN, (fptr->Fptr)->iobuffer + (nbuff * IOBUFLEN), status); (fptr->Fptr)->io_pos = rstart + IOBUFLEN; /* set new IO position */ } (fptr->Fptr)->bufrecnum[nbuff] = record; /* record number contained in buffer */ updatebuf: (fptr->Fptr)->curbuf = nbuff; /* this is the current buffer for this file */ if (ibuff < 0) { /* find the current position of the buffer in the age index */ for (ibuff = 0; ibuff < NIOBUF; ibuff++) if ((fptr->Fptr)->ageindex[ibuff] == nbuff) break; } /* increment the age of all the buffers that were younger than it */ for (ibuff++; ibuff < NIOBUF; ibuff++) (fptr->Fptr)->ageindex[ibuff - 1] = (fptr->Fptr)->ageindex[ibuff]; (fptr->Fptr)->ageindex[NIOBUF - 1] = nbuff; /* this is now the youngest buffer */ return(*status); } /*--------------------------------------------------------------------------*/ int ffwhbf(fitsfile *fptr, /* I - FITS file pointer */ int *nbuff) /* O - which buffer to use */ { /* decide which buffer to (re)use to hold a new file record */ return(*nbuff = (fptr->Fptr)->ageindex[0]); /* return oldest buffer */ } /*--------------------------------------------------------------------------*/ int ffflus(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* Flush all the data in the current FITS file to disk. This ensures that if the program subsequently dies, the disk FITS file will be closed correctly. */ { int hdunum, hdutype; if (*status > 0) return(*status); ffghdn(fptr, &hdunum); /* get the current HDU number */ if (ffchdu(fptr,status) > 0) /* close out the current HDU */ ffpmsg("ffflus could not close the current HDU."); ffflsh(fptr, FALSE, status); /* flush any modified IO buffers to disk */ if (ffgext(fptr, hdunum - 1, &hdutype, status) > 0) /* reopen HDU */ ffpmsg("ffflus could not reopen the current HDU."); return(*status); } /*--------------------------------------------------------------------------*/ int ffflsh(fitsfile *fptr, /* I - FITS file pointer */ int clearbuf, /* I - also clear buffer contents? */ int *status) /* IO - error status */ { /* flush all dirty IO buffers associated with the file to disk */ int ii; /* no need to move to a different HDU if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); */ for (ii = 0; ii < NIOBUF; ii++) { /* flush modified buffer to disk */ if ((fptr->Fptr)->bufrecnum[ii] >= 0 &&(fptr->Fptr)->dirty[ii]) ffbfwt(fptr->Fptr, ii, status); if (clearbuf) (fptr->Fptr)->bufrecnum[ii] = -1; /* set contents of buffer as undefined */ } if (*status != READONLY_FILE) ffflushx(fptr->Fptr); /* flush system buffers to disk */ return(*status); } /*--------------------------------------------------------------------------*/ int ffbfeof(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ { /* clear any buffers beyond the end of file */ int ii; for (ii = 0; ii < NIOBUF; ii++) { if ( (LONGLONG) (fptr->Fptr)->bufrecnum[ii] * IOBUFLEN >= fptr->Fptr->filesize) { (fptr->Fptr)->bufrecnum[ii] = -1; /* set contents of buffer as undefined */ } } return(*status); } /*--------------------------------------------------------------------------*/ int ffbfwt(FITSfile *Fptr, /* I - FITS file pointer */ int nbuff, /* I - which buffer to write */ int *status) /* IO - error status */ { /* write contents of buffer to file; If the position of the buffer is beyond the current EOF, then the file may need to be extended with fill values, and/or with the contents of some of the other i/o buffers. */ int ii,ibuff; long jj, irec, minrec, nloop; LONGLONG filepos; static char zeros[IOBUFLEN]; /* initialized to zero by default */ if (!(Fptr->writemode) ) { ffpmsg("Error: trying to write to READONLY file."); if (Fptr->driver == 8) { /* gzip compressed file */ ffpmsg("Cannot write to a GZIP or COMPRESS compressed file."); } Fptr->dirty[nbuff] = FALSE; /* reset buffer status to prevent later probs */ *status = READONLY_FILE; return(*status); } filepos = (LONGLONG)Fptr->bufrecnum[nbuff] * IOBUFLEN; if (filepos <= Fptr->filesize) { /* record is located within current file, so just write it */ /* move to the correct write position */ if (Fptr->io_pos != filepos) ffseek(Fptr, filepos); ffwrite(Fptr, IOBUFLEN, Fptr->iobuffer + (nbuff * IOBUFLEN), status); Fptr->io_pos = filepos + IOBUFLEN; if (filepos == Fptr->filesize) /* appended new record? */ Fptr->filesize += IOBUFLEN; /* increment the file size */ Fptr->dirty[nbuff] = FALSE; } else /* if record is beyond the EOF, append any other records */ /* and/or insert fill values if necessary */ { /* move to EOF */ if (Fptr->io_pos != Fptr->filesize) ffseek(Fptr, Fptr->filesize); ibuff = NIOBUF; /* initialize to impossible value */ while(ibuff != nbuff) /* repeat until requested buffer is written */ { minrec = (long) (Fptr->filesize / IOBUFLEN); /* write lowest record beyond the EOF first */ irec = Fptr->bufrecnum[nbuff]; /* initially point to the requested buffer */ ibuff = nbuff; for (ii = 0; ii < NIOBUF; ii++) { if (Fptr->bufrecnum[ii] >= minrec && Fptr->bufrecnum[ii] < irec) { irec = Fptr->bufrecnum[ii]; /* found a lower record */ ibuff = ii; } } filepos = (LONGLONG)irec * IOBUFLEN; /* byte offset of record in file */ /* append 1 or more fill records if necessary */ if (filepos > Fptr->filesize) { nloop = (long) ((filepos - (Fptr->filesize)) / IOBUFLEN); for (jj = 0; jj < nloop && !(*status); jj++) ffwrite(Fptr, IOBUFLEN, zeros, status); /* ffseek(Fptr, filepos); */ Fptr->filesize = filepos; /* increment the file size */ } /* write the buffer itself */ ffwrite(Fptr, IOBUFLEN, Fptr->iobuffer + (ibuff * IOBUFLEN), status); Fptr->dirty[ibuff] = FALSE; Fptr->filesize += IOBUFLEN; /* increment the file size */ } /* loop back if more buffers need to be written */ Fptr->io_pos = Fptr->filesize; /* currently positioned at EOF */ } return(*status); } /*--------------------------------------------------------------------------*/ int ffgrsz( fitsfile *fptr, /* I - FITS file pionter */ long *ndata, /* O - optimal amount of data to access */ int *status) /* IO - error status */ /* Returns an optimal value for the number of rows in a binary table or the number of pixels in an image that should be read or written at one time for maximum efficiency. Accessing more data than this may cause excessive flushing and rereading of buffers to/from disk. */ { int typecode, bytesperpixel; /* There are NIOBUF internal buffers available each IOBUFLEN bytes long. */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header to get hdu struct */ return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU ) /* calc pixels per buffer size */ { /* image pixels are in column 2 of the 'table' */ ffgtcl(fptr, 2, &typecode, NULL, NULL, status); bytesperpixel = typecode / 10; *ndata = ((NIOBUF - 1) * IOBUFLEN) / bytesperpixel; } else /* calc number of rows that fit in buffers */ { *ndata = (long) (((NIOBUF - 1) * IOBUFLEN) / maxvalue(1, (fptr->Fptr)->rowlength)); *ndata = maxvalue(1, *ndata); } return(*status); } /*--------------------------------------------------------------------------*/ int ffgtbb(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG firstrow, /* I - starting row (1 = first row) */ LONGLONG firstchar, /* I - starting byte in row (1=first) */ LONGLONG nchars, /* I - number of bytes to read */ unsigned char *values, /* I - array of bytes to read */ int *status) /* IO - error status */ /* read a consecutive string of bytes from an ascii or binary table. This will span multiple rows of the table if nchars + firstchar is greater than the length of a row. */ { LONGLONG bytepos, endrow; if (*status > 0 || nchars <= 0) return(*status); else if (firstrow < 1) return(*status=BAD_ROW_NUM); else if (firstchar < 1) return(*status=BAD_ELEM_NUM); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); /* check that we do not exceed number of rows in the table */ endrow = ((firstchar + nchars - 2) / (fptr->Fptr)->rowlength) + firstrow; if (endrow > (fptr->Fptr)->numrows) { ffpmsg("attempt to read past end of table (ffgtbb)"); return(*status=BAD_ROW_NUM); } /* move the i/o pointer to the start of the sequence of characters */ bytepos = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * (firstrow - 1)) + firstchar - 1; ffmbyt(fptr, bytepos, REPORT_EOF, status); ffgbyt(fptr, nchars, values, status); /* read the bytes */ return(*status); } /*--------------------------------------------------------------------------*/ int ffgi1b(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG byteloc, /* I - position within file to start reading */ long nvals, /* I - number of pixels to read */ long incre, /* I - byte increment between pixels */ unsigned char *values, /* O - returned array of values */ int *status) /* IO - error status */ /* get (read) the array of values from the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { LONGLONG postemp; if (incre == 1) /* read all the values at once (contiguous bytes) */ { if (nvals < MINDIRECT) /* read normally via IO buffers */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbyt(fptr, nvals, values, status); } else /* read directly from disk, bypassing IO buffers */ { postemp = (fptr->Fptr)->bytepos; /* store current file position */ (fptr->Fptr)->bytepos = byteloc; /* set to the desired position */ ffgbyt(fptr, nvals, values, status); (fptr->Fptr)->bytepos = postemp; /* reset to original position */ } } else /* have to read each value individually (not contiguous ) */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbytoff(fptr, 1, nvals, incre - 1, values, status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffgi2b(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG byteloc, /* I - position within file to start reading */ long nvals, /* I - number of pixels to read */ long incre, /* I - byte increment between pixels */ short *values, /* O - returned array of values */ int *status) /* IO - error status */ /* get (read) the array of values from the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { LONGLONG postemp; if (incre == 2) /* read all the values at once (contiguous bytes) */ { if (nvals * 2 < MINDIRECT) /* read normally via IO buffers */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbyt(fptr, nvals * 2, values, status); } else /* read directly from disk, bypassing IO buffers */ { postemp = (fptr->Fptr)->bytepos; /* store current file position */ (fptr->Fptr)->bytepos = byteloc; /* set to the desired position */ ffgbyt(fptr, nvals * 2, values, status); (fptr->Fptr)->bytepos = postemp; /* reset to original position */ } } else /* have to read each value individually (not contiguous ) */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbytoff(fptr, 2, nvals, incre - 2, values, status); } #if BYTESWAPPED ffswap2(values, nvals); /* reverse order of bytes in each value */ #endif return(*status); } /*--------------------------------------------------------------------------*/ int ffgi4b(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG byteloc, /* I - position within file to start reading */ long nvals, /* I - number of pixels to read */ long incre, /* I - byte increment between pixels */ INT32BIT *values, /* O - returned array of values */ int *status) /* IO - error status */ /* get (read) the array of values from the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { LONGLONG postemp; if (incre == 4) /* read all the values at once (contiguous bytes) */ { if (nvals * 4 < MINDIRECT) /* read normally via IO buffers */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbyt(fptr, nvals * 4, values, status); } else /* read directly from disk, bypassing IO buffers */ { postemp = (fptr->Fptr)->bytepos; /* store current file position */ (fptr->Fptr)->bytepos = byteloc; /* set to the desired position */ ffgbyt(fptr, nvals * 4, values, status); (fptr->Fptr)->bytepos = postemp; /* reset to original position */ } } else /* have to read each value individually (not contiguous ) */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbytoff(fptr, 4, nvals, incre - 4, values, status); } #if BYTESWAPPED ffswap4(values, nvals); /* reverse order of bytes in each value */ #endif return(*status); } /*--------------------------------------------------------------------------*/ int ffgi8b(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG byteloc, /* I - position within file to start reading */ long nvals, /* I - number of pixels to read */ long incre, /* I - byte increment between pixels */ long *values, /* O - returned array of values */ int *status) /* IO - error status */ /* get (read) the array of values from the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! This routine reads 'nvals' 8-byte integers into 'values'. This works both on platforms that have sizeof(long) = 64, and 32, as long as 'values' has been allocated to large enough to hold 8 * nvals bytes of data. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ { LONGLONG postemp; if (incre == 8) /* read all the values at once (contiguous bytes) */ { if (nvals * 8 < MINDIRECT) /* read normally via IO buffers */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbyt(fptr, nvals * 8, values, status); } else /* read directly from disk, bypassing IO buffers */ { postemp = (fptr->Fptr)->bytepos; /* store current file position */ (fptr->Fptr)->bytepos = byteloc; /* set to the desired position */ ffgbyt(fptr, nvals * 8, values, status); (fptr->Fptr)->bytepos = postemp; /* reset to original position */ } } else /* have to read each value individually (not contiguous ) */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbytoff(fptr, 8, nvals, incre - 8, values, status); } #if BYTESWAPPED ffswap8((double *) values, nvals); /* reverse bytes in each value */ #endif return(*status); } /*--------------------------------------------------------------------------*/ int ffgr4b(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG byteloc, /* I - position within file to start reading */ long nvals, /* I - number of pixels to read */ long incre, /* I - byte increment between pixels */ float *values, /* O - returned array of values */ int *status) /* IO - error status */ /* get (read) the array of values from the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { LONGLONG postemp; #if MACHINE == VAXVMS long ii; #elif (MACHINE == ALPHAVMS) && (FLOATTYPE == GFLOAT) short *sptr; long ii; #endif if (incre == 4) /* read all the values at once (contiguous bytes) */ { if (nvals * 4 < MINDIRECT) /* read normally via IO buffers */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbyt(fptr, nvals * 4, values, status); } else /* read directly from disk, bypassing IO buffers */ { postemp = (fptr->Fptr)->bytepos; /* store current file position */ (fptr->Fptr)->bytepos = byteloc; /* set to the desired position */ ffgbyt(fptr, nvals * 4, values, status); (fptr->Fptr)->bytepos = postemp; /* reset to original position */ } } else /* have to read each value individually (not contiguous ) */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbytoff(fptr, 4, nvals, incre - 4, values, status); } #if MACHINE == VAXVMS ii = nvals; /* call VAX macro routine to convert */ ieevur(values, values, &ii); /* from IEEE float -> F float */ #elif (MACHINE == ALPHAVMS) && (FLOATTYPE == GFLOAT) ffswap2( (short *) values, nvals * 2); /* swap pairs of bytes */ /* convert from IEEE float format to VMS GFLOAT float format */ sptr = (short *) values; for (ii = 0; ii < nvals; ii++, sptr += 2) { if (!fnan(*sptr) ) /* test for NaN or underflow */ values[ii] *= 4.0; } #elif BYTESWAPPED ffswap4((INT32BIT *)values, nvals); /* reverse order of bytes in values */ #endif return(*status); } /*--------------------------------------------------------------------------*/ int ffgr8b(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG byteloc, /* I - position within file to start reading */ long nvals, /* I - number of pixels to read */ long incre, /* I - byte increment between pixels */ double *values, /* O - returned array of values */ int *status) /* IO - error status */ /* get (read) the array of values from the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { LONGLONG postemp; #if MACHINE == VAXVMS long ii; #elif (MACHINE == ALPHAVMS) && (FLOATTYPE == GFLOAT) short *sptr; long ii; #endif if (incre == 8) /* read all the values at once (contiguous bytes) */ { if (nvals * 8 < MINDIRECT) /* read normally via IO buffers */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbyt(fptr, nvals * 8, values, status); } else /* read directly from disk, bypassing IO buffers */ { postemp = (fptr->Fptr)->bytepos; /* store current file position */ (fptr->Fptr)->bytepos = byteloc; /* set to the desired position */ ffgbyt(fptr, nvals * 8, values, status); (fptr->Fptr)->bytepos = postemp; /* reset to original position */ } } else /* have to read each value individually (not contiguous ) */ { ffmbyt(fptr, byteloc, REPORT_EOF, status); ffgbytoff(fptr, 8, nvals, incre - 8, values, status); } #if MACHINE == VAXVMS ii = nvals; /* call VAX macro routine to convert */ ieevud(values, values, &ii); /* from IEEE float -> D float */ #elif (MACHINE == ALPHAVMS) && (FLOATTYPE == GFLOAT) ffswap2( (short *) values, nvals * 4); /* swap pairs of bytes */ /* convert from IEEE float format to VMS GFLOAT float format */ sptr = (short *) values; for (ii = 0; ii < nvals; ii++, sptr += 4) { if (!dnan(*sptr) ) /* test for NaN or underflow */ values[ii] *= 4.0; } #elif BYTESWAPPED ffswap8(values, nvals); /* reverse order of bytes in each value */ #endif return(*status); } /*--------------------------------------------------------------------------*/ int ffptbb(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG firstrow, /* I - starting row (1 = first row) */ LONGLONG firstchar, /* I - starting byte in row (1=first) */ LONGLONG nchars, /* I - number of bytes to write */ unsigned char *values, /* I - array of bytes to write */ int *status) /* IO - error status */ /* write a consecutive string of bytes to an ascii or binary table. This will span multiple rows of the table if nchars + firstchar is greater than the length of a row. */ { LONGLONG bytepos, endrow, nrows; char message[81]; if (*status > 0 || nchars <= 0) return(*status); else if (firstrow < 1) return(*status=BAD_ROW_NUM); else if (firstchar < 1) return(*status=BAD_ELEM_NUM); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart < 0) /* rescan header if data undefined */ ffrdef(fptr, status); endrow = ((firstchar + nchars - 2) / (fptr->Fptr)->rowlength) + firstrow; /* check if we are writing beyond the current end of table */ if (endrow > (fptr->Fptr)->numrows) { /* if there are more HDUs following the current one, or */ /* if there is a data heap, then we must insert space */ /* for the new rows. */ if ( !((fptr->Fptr)->lasthdu) || (fptr->Fptr)->heapsize > 0) { nrows = endrow - ((fptr->Fptr)->numrows); /* ffirow also updates the heap address and numrows */ if (ffirow(fptr, (fptr->Fptr)->numrows, nrows, status) > 0) { sprintf(message, "ffptbb failed to add space for %.0f new rows in table.", (double) nrows); ffpmsg(message); return(*status); } } else { /* manally update heap starting address */ (fptr->Fptr)->heapstart += ((LONGLONG)(endrow - (fptr->Fptr)->numrows) * (fptr->Fptr)->rowlength ); (fptr->Fptr)->numrows = endrow; /* update number of rows */ } } /* move the i/o pointer to the start of the sequence of characters */ bytepos = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * (firstrow - 1)) + firstchar - 1; ffmbyt(fptr, bytepos, IGNORE_EOF, status); ffpbyt(fptr, nchars, values, status); /* write the bytes */ return(*status); } /*--------------------------------------------------------------------------*/ int ffpi1b(fitsfile *fptr, /* I - FITS file pointer */ long nvals, /* I - number of pixels in the values array */ long incre, /* I - byte increment between pixels */ unsigned char *values, /* I - array of values to write */ int *status) /* IO - error status */ /* put (write) the array of values to the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { if (incre == 1) /* write all the values at once (contiguous bytes) */ ffpbyt(fptr, nvals, values, status); else /* have to write each value individually (not contiguous ) */ ffpbytoff(fptr, 1, nvals, incre - 1, values, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffpi2b(fitsfile *fptr, /* I - FITS file pointer */ long nvals, /* I - number of pixels in the values array */ long incre, /* I - byte increment between pixels */ short *values, /* I - array of values to write */ int *status) /* IO - error status */ /* put (write) the array of values to the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { #if BYTESWAPPED ffswap2(values, nvals); /* reverse order of bytes in each value */ #endif if (incre == 2) /* write all the values at once (contiguous bytes) */ ffpbyt(fptr, nvals * 2, values, status); else /* have to write each value individually (not contiguous ) */ ffpbytoff(fptr, 2, nvals, incre - 2, values, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffpi4b(fitsfile *fptr, /* I - FITS file pointer */ long nvals, /* I - number of pixels in the values array */ long incre, /* I - byte increment between pixels */ INT32BIT *values, /* I - array of values to write */ int *status) /* IO - error status */ /* put (write) the array of values to the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { #if BYTESWAPPED ffswap4(values, nvals); /* reverse order of bytes in each value */ #endif if (incre == 4) /* write all the values at once (contiguous bytes) */ ffpbyt(fptr, nvals * 4, values, status); else /* have to write each value individually (not contiguous ) */ ffpbytoff(fptr, 4, nvals, incre - 4, values, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffpi8b(fitsfile *fptr, /* I - FITS file pointer */ long nvals, /* I - number of pixels in the values array */ long incre, /* I - byte increment between pixels */ long *values, /* I - array of values to write */ int *status) /* IO - error status */ /* put (write) the array of values to the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! This routine writes 'nvals' 8-byte integers from 'values'. This works both on platforms that have sizeof(long) = 64, and 32, as long as 'values' has been allocated to large enough to hold 8 * nvals bytes of data. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ { #if BYTESWAPPED ffswap8((double *) values, nvals); /* reverse bytes in each value */ #endif if (incre == 8) /* write all the values at once (contiguous bytes) */ ffpbyt(fptr, nvals * 8, values, status); else /* have to write each value individually (not contiguous ) */ ffpbytoff(fptr, 8, nvals, incre - 8, values, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffpr4b(fitsfile *fptr, /* I - FITS file pointer */ long nvals, /* I - number of pixels in the values array */ long incre, /* I - byte increment between pixels */ float *values, /* I - array of values to write */ int *status) /* IO - error status */ /* put (write) the array of values to the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { #if MACHINE == VAXVMS long ii; ii = nvals; /* call VAX macro routine to convert */ ieevpr(values, values, &ii); /* from F float -> IEEE float */ #elif (MACHINE == ALPHAVMS) && (FLOATTYPE == GFLOAT) long ii; /* convert from VMS FFLOAT float format to IEEE float format */ for (ii = 0; ii < nvals; ii++) values[ii] *= 0.25; ffswap2( (short *) values, nvals * 2); /* swap pairs of bytes */ #elif BYTESWAPPED ffswap4((INT32BIT *) values, nvals); /* reverse order of bytes in values */ #endif if (incre == 4) /* write all the values at once (contiguous bytes) */ ffpbyt(fptr, nvals * 4, values, status); else /* have to write each value individually (not contiguous ) */ ffpbytoff(fptr, 4, nvals, incre - 4, values, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffpr8b(fitsfile *fptr, /* I - FITS file pointer */ long nvals, /* I - number of pixels in the values array */ long incre, /* I - byte increment between pixels */ double *values, /* I - array of values to write */ int *status) /* IO - error status */ /* put (write) the array of values to the FITS file, doing machine dependent format conversion (e.g. byte-swapping) if necessary. */ { #if MACHINE == VAXVMS long ii; ii = nvals; /* call VAX macro routine to convert */ ieevpd(values, values, &ii); /* from D float -> IEEE float */ #elif (MACHINE == ALPHAVMS) && (FLOATTYPE == GFLOAT) long ii; /* convert from VMS GFLOAT float format to IEEE float format */ for (ii = 0; ii < nvals; ii++) values[ii] *= 0.25; ffswap2( (short *) values, nvals * 4); /* swap pairs of bytes */ #elif BYTESWAPPED ffswap8(values, nvals); /* reverse order of bytes in each value */ #endif if (incre == 8) /* write all the values at once (contiguous bytes) */ ffpbyt(fptr, nvals * 8, values, status); else /* have to write each value individually (not contiguous ) */ ffpbytoff(fptr, 8, nvals, incre - 8, values, status); return(*status); } healpy-1.10.3/cfitsio/cfileio.c0000664000175000017500000072305113010375004016545 0ustar zoncazonca00000000000000/* This file, cfileio.c, contains the low-level file access routines. */ /* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ #include #include #include #include #include #include /* apparently needed to define size_t */ #include "fitsio2.h" #include "group.h" #define MAX_PREFIX_LEN 20 /* max length of file type prefix (e.g. 'http://') */ #define MAX_DRIVERS 24 /* max number of file I/O drivers */ typedef struct /* structure containing pointers to I/O driver functions */ { char prefix[MAX_PREFIX_LEN]; int (*init)(void); int (*shutdown)(void); int (*setoptions)(int option); int (*getoptions)(int *options); int (*getversion)(int *version); int (*checkfile)(char *urltype, char *infile, char *outfile); int (*open)(char *filename, int rwmode, int *driverhandle); int (*create)(char *filename, int *drivehandle); int (*truncate)(int drivehandle, LONGLONG size); int (*close)(int drivehandle); int (*remove)(char *filename); int (*size)(int drivehandle, LONGLONG *size); int (*flush)(int drivehandle); int (*seek)(int drivehandle, LONGLONG offset); int (*read)(int drivehandle, void *buffer, long nbytes); int (*write)(int drivehandle, void *buffer, long nbytes); } fitsdriver; fitsdriver driverTable[MAX_DRIVERS]; /* allocate driver tables */ FITSfile *FptrTable[NMAXFILES]; /* this table of Fptr pointers is */ /* used by fits_already_open */ int need_to_initialize = 1; /* true if CFITSIO has not been initialized */ int no_of_drivers = 0; /* number of currently defined I/O drivers */ static int pixel_filter_helper(fitsfile **fptr, char *outfile, char *expr, int *status); static int find_quote(char **string); static int find_doublequote(char **string); static int find_paren(char **string); static int find_bracket(char **string); static int find_curlybracket(char **string); int comma2semicolon(char *string); #ifdef _REENTRANT pthread_mutex_t Fitsio_InitLock = PTHREAD_MUTEX_INITIALIZER; #endif /*--------------------------------------------------------------------------*/ int fitsio_init_lock(void) { static int need_to_init = 1; int status = 0; #ifdef _REENTRANT pthread_mutexattr_t mutex_init; FFLOCK1(Fitsio_InitLock); if (need_to_init) { /* Init the main fitsio lock here since we need a a recursive lock */ status = pthread_mutexattr_init(&mutex_init); if (status) { ffpmsg("pthread_mutexattr_init failed (fitsio_init_lock)"); return(status); } #ifdef linux status = pthread_mutexattr_settype(&mutex_init, PTHREAD_MUTEX_RECURSIVE_NP); #else status = pthread_mutexattr_settype(&mutex_init, PTHREAD_MUTEX_RECURSIVE); #endif if (status) { ffpmsg("pthread_mutexattr_settu[e failed (fitsio_init_lock)"); return(status); } status = pthread_mutex_init(&Fitsio_Lock,&mutex_init); if (status) { ffpmsg("pthread_mutex_init failed (fitsio_init_lock)"); return(status); } need_to_init = 0; } FFUNLOCK1(Fitsio_InitLock); #endif return(status); } /*--------------------------------------------------------------------------*/ int ffomem(fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - name of file to open */ int mode, /* I - 0 = open readonly; 1 = read/write */ void **buffptr, /* I - address of memory pointer */ size_t *buffsize, /* I - size of buffer, in bytes */ size_t deltasize, /* I - increment for future realloc's */ void *(*mem_realloc)(void *p, size_t newsize), /* function */ int *status) /* IO - error status */ /* Open an existing FITS file in core memory. This is a specialized version of ffopen. */ { int ii, driver, handle, hdutyp, slen, movetotype, extvers, extnum; char extname[FLEN_VALUE]; LONGLONG filesize; char urltype[MAX_PREFIX_LEN], infile[FLEN_FILENAME], outfile[FLEN_FILENAME]; char extspec[FLEN_FILENAME], rowfilter[FLEN_FILENAME]; char binspec[FLEN_FILENAME], colspec[FLEN_FILENAME]; char imagecolname[FLEN_VALUE], rowexpress[FLEN_FILENAME]; char *url, errmsg[FLEN_ERRMSG]; char *hdtype[3] = {"IMAGE", "TABLE", "BINTABLE"}; if (*status > 0) return(*status); *fptr = 0; /* initialize null file pointer */ if (need_to_initialize) /* this is called only once */ { *status = fits_init_cfitsio(); if (*status > 0) return(*status); } url = (char *) name; while (*url == ' ') /* ignore leading spaces in the file spec */ url++; /* parse the input file specification */ fits_parse_input_url(url, urltype, infile, outfile, extspec, rowfilter, binspec, colspec, status); strcpy(urltype, "memkeep://"); /* URL type for pre-existing memory file */ *status = urltype2driver(urltype, &driver); if (*status > 0) { ffpmsg("could not find driver for pre-existing memory file: (ffomem)"); return(*status); } /* call driver routine to open the memory file */ FFLOCK; /* lock this while searching for vacant handle */ *status = mem_openmem( buffptr, buffsize,deltasize, mem_realloc, &handle); FFUNLOCK; if (*status > 0) { ffpmsg("failed to open pre-existing memory file: (ffomem)"); return(*status); } /* get initial file size */ *status = (*driverTable[driver].size)(handle, &filesize); if (*status > 0) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed get the size of the memory file: (ffomem)"); return(*status); } /* allocate fitsfile structure and initialize = 0 */ *fptr = (fitsfile *) calloc(1, sizeof(fitsfile)); if (!(*fptr)) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate structure for following file: (ffomem)"); ffpmsg(url); return(*status = MEMORY_ALLOCATION); } /* allocate FITSfile structure and initialize = 0 */ (*fptr)->Fptr = (FITSfile *) calloc(1, sizeof(FITSfile)); if (!((*fptr)->Fptr)) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate structure for following file: (ffomem)"); ffpmsg(url); free(*fptr); *fptr = 0; return(*status = MEMORY_ALLOCATION); } slen = strlen(url) + 1; slen = maxvalue(slen, 32); /* reserve at least 32 chars */ ((*fptr)->Fptr)->filename = (char *) malloc(slen); /* mem for file name */ if ( !(((*fptr)->Fptr)->filename) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for filename: (ffomem)"); ffpmsg(url); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* mem for headstart array */ ((*fptr)->Fptr)->headstart = (LONGLONG *) calloc(1001, sizeof(LONGLONG)); if ( !(((*fptr)->Fptr)->headstart) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for headstart array: (ffomem)"); ffpmsg(url); free( ((*fptr)->Fptr)->filename); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* mem for file I/O buffers */ ((*fptr)->Fptr)->iobuffer = (char *) calloc(NIOBUF, IOBUFLEN); if ( !(((*fptr)->Fptr)->iobuffer) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for iobuffer array: (ffomem)"); ffpmsg(url); free( ((*fptr)->Fptr)->headstart); /* free memory for headstart array */ free( ((*fptr)->Fptr)->filename); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* initialize the ageindex array (relative age of the I/O buffers) */ /* and initialize the bufrecnum array as being empty */ for (ii = 0; ii < NIOBUF; ii++) { ((*fptr)->Fptr)->ageindex[ii] = ii; ((*fptr)->Fptr)->bufrecnum[ii] = -1; } /* store the parameters describing the file */ ((*fptr)->Fptr)->MAXHDU = 1000; /* initial size of headstart */ ((*fptr)->Fptr)->filehandle = handle; /* file handle */ ((*fptr)->Fptr)->driver = driver; /* driver number */ strcpy(((*fptr)->Fptr)->filename, url); /* full input filename */ ((*fptr)->Fptr)->filesize = filesize; /* physical file size */ ((*fptr)->Fptr)->logfilesize = filesize; /* logical file size */ ((*fptr)->Fptr)->writemode = mode; /* read-write mode */ ((*fptr)->Fptr)->datastart = DATA_UNDEFINED; /* unknown start of data */ ((*fptr)->Fptr)->curbuf = -1; /* undefined current IO buffer */ ((*fptr)->Fptr)->open_count = 1; /* structure is currently used once */ ((*fptr)->Fptr)->validcode = VALIDSTRUC; /* flag denoting valid structure */ ffldrc(*fptr, 0, REPORT_EOF, status); /* load first record */ fits_store_Fptr( (*fptr)->Fptr, status); /* store Fptr address */ if (ffrhdu(*fptr, &hdutyp, status) > 0) /* determine HDU structure */ { ffpmsg( "ffomem could not interpret primary array header of file: (ffomem)"); ffpmsg(url); if (*status == UNKNOWN_REC) ffpmsg("This does not look like a FITS file."); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ } /* ---------------------------------------------------------- */ /* move to desired extension, if specified as part of the URL */ /* ---------------------------------------------------------- */ imagecolname[0] = '\0'; rowexpress[0] = '\0'; if (*extspec) { /* parse the extension specifier into individual parameters */ ffexts(extspec, &extnum, extname, &extvers, &movetotype, imagecolname, rowexpress, status); if (*status > 0) return(*status); if (extnum) { ffmahd(*fptr, extnum + 1, &hdutyp, status); } else if (*extname) /* move to named extension, if specified */ { ffmnhd(*fptr, movetotype, extname, extvers, status); } if (*status > 0) { ffpmsg("ffomem could not move to the specified extension:"); if (extnum > 0) { sprintf(errmsg, " extension number %d doesn't exist or couldn't be opened.",extnum); ffpmsg(errmsg); } else { sprintf(errmsg, " extension with EXTNAME = %s,", extname); ffpmsg(errmsg); if (extvers) { sprintf(errmsg, " and with EXTVERS = %d,", extvers); ffpmsg(errmsg); } if (movetotype != ANY_HDU) { sprintf(errmsg, " and with XTENSION = %s,", hdtype[movetotype]); ffpmsg(errmsg); } ffpmsg(" doesn't exist or couldn't be opened."); } return(*status); } } return(*status); } /*--------------------------------------------------------------------------*/ int ffdkopn(fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - full name of file to open */ int mode, /* I - 0 = open readonly; 1 = read/write */ int *status) /* IO - error status */ /* Open an existing FITS file on magnetic disk with either readonly or read/write access. The routine does not support CFITSIO's extended filename syntax and simply uses the entire input 'name' string as the name of the file. */ { if (*status > 0) return(*status); *status = OPEN_DISK_FILE; ffopen(fptr, name, mode, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffdopn(fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - full name of file to open */ int mode, /* I - 0 = open readonly; 1 = read/write */ int *status) /* IO - error status */ /* Open an existing FITS file with either readonly or read/write access. and move to the first HDU that contains 'interesting' data, if the primary array contains a null image (i.e., NAXIS = 0). */ { if (*status > 0) return(*status); *status = SKIP_NULL_PRIMARY; ffopen(fptr, name, mode, status); return(*status); } /*--------------------------------------------------------------------------*/ int fftopn(fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - full name of file to open */ int mode, /* I - 0 = open readonly; 1 = read/write */ int *status) /* IO - error status */ /* Open an existing FITS file with either readonly or read/write access. and move to the first HDU that contains 'interesting' table (not an image). */ { int hdutype; if (*status > 0) return(*status); *status = SKIP_IMAGE; ffopen(fptr, name, mode, status); if (ffghdt(*fptr, &hdutype, status) <= 0) { if (hdutype == IMAGE_HDU) *status = NOT_TABLE; } return(*status); } /*--------------------------------------------------------------------------*/ int ffiopn(fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - full name of file to open */ int mode, /* I - 0 = open readonly; 1 = read/write */ int *status) /* IO - error status */ /* Open an existing FITS file with either readonly or read/write access. and move to the first HDU that contains 'interesting' image (not an table). */ { int hdutype; if (*status > 0) return(*status); *status = SKIP_TABLE; ffopen(fptr, name, mode, status); if (ffghdt(*fptr, &hdutype, status) <= 0) { if (hdutype != IMAGE_HDU) *status = NOT_IMAGE; } return(*status); } /*--------------------------------------------------------------------------*/ int ffopentest(int soname, /* I - CFITSIO shared library version */ /* application program (fitsio.h file) */ fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - full name of file to open */ int mode, /* I - 0 = open readonly; 1 = read/write */ int *status) /* IO - error status */ /* Open an existing FITS file with either readonly or read/write access. First test that the SONAME of fitsio.h used to build the CFITSIO library is the same as was used in compiling the application program that links to the library. */ { if (soname != CFITSIO_SONAME) { printf("\nERROR: Mismatch in the CFITSIO_SONAME value in the fitsio.h include file\n"); printf("that was used to build the CFITSIO library, and the value in the include file\n"); printf("that was used when compiling the application program:\n"); printf(" Version used to build the CFITSIO library = %d\n",CFITSIO_SONAME); printf(" Version included by the application program = %d\n",soname); printf("\nFix this by recompiling and then relinking this application program \n"); printf("with the CFITSIO library.\n"); *status = FILE_NOT_OPENED; return(*status); } /* now call the normal file open routine */ ffopen(fptr, name, mode, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffopen(fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - full name of file to open */ int mode, /* I - 0 = open readonly; 1 = read/write */ int *status) /* IO - error status */ /* Open an existing FITS file with either readonly or read/write access. */ { fitsfile *newptr; int ii, driver, hdutyp, hdunum, slen, writecopy, isopen; LONGLONG filesize; long rownum, nrows, goodrows; int extnum, extvers, handle, movetotype, tstatus = 0, only_one = 0; char urltype[MAX_PREFIX_LEN], infile[FLEN_FILENAME], outfile[FLEN_FILENAME]; char origurltype[MAX_PREFIX_LEN], extspec[FLEN_FILENAME]; char extname[FLEN_VALUE], rowfilter[FLEN_FILENAME], tblname[FLEN_VALUE]; char imagecolname[FLEN_VALUE], rowexpress[FLEN_FILENAME]; char binspec[FLEN_FILENAME], colspec[FLEN_FILENAME], pixfilter[FLEN_FILENAME]; char histfilename[FLEN_FILENAME]; char filtfilename[FLEN_FILENAME], compspec[FLEN_FILENAME]; char wtcol[FLEN_VALUE]; char minname[4][FLEN_VALUE], maxname[4][FLEN_VALUE]; char binname[4][FLEN_VALUE]; char *url; double minin[4], maxin[4], binsizein[4], weight; int imagetype, naxis = 1, haxis, recip; int skip_null = 0, skip_image = 0, skip_table = 0, open_disk_file = 0; char colname[4][FLEN_VALUE]; char errmsg[FLEN_ERRMSG]; char *hdtype[3] = {"IMAGE", "TABLE", "BINTABLE"}; char *rowselect = 0; if (*status > 0) return(*status); if (*status == SKIP_NULL_PRIMARY) { /* this special status value is used as a flag by ffdopn to tell */ /* ffopen to skip over a null primary array when opening the file. */ skip_null = 1; *status = 0; } else if (*status == SKIP_IMAGE) { /* this special status value is used as a flag by fftopn to tell */ /* ffopen to move to 1st significant table when opening the file. */ skip_image = 1; *status = 0; } else if (*status == SKIP_TABLE) { /* this special status value is used as a flag by ffiopn to tell */ /* ffopen to move to 1st significant image when opening the file. */ skip_table = 1; *status = 0; } else if (*status == OPEN_DISK_FILE) { /* this special status value is used as a flag by ffdkopn to tell */ /* ffopen to not interpret the input filename using CFITSIO's */ /* extended filename syntax, and simply open the specified disk file */ open_disk_file = 1; *status = 0; } *fptr = 0; /* initialize null file pointer */ writecopy = 0; /* have we made a write-able copy of the input file? */ if (need_to_initialize) { /* this is called only once */ *status = fits_init_cfitsio(); } if (*status > 0) return(*status); url = (char *) name; while (*url == ' ') /* ignore leading spaces in the filename */ url++; if (*url == '\0') { ffpmsg("Name of file to open is blank. (ffopen)"); return(*status = FILE_NOT_OPENED); } if (open_disk_file) { /* treat the input URL literally as the name of the file to open */ /* and don't try to parse the URL using the extended filename syntax */ if (strlen(url) > FLEN_FILENAME - 1) { ffpmsg("Name of file to open is too long. (ffopen)"); return(*status = FILE_NOT_OPENED); } strcpy(infile,url); strcpy(urltype, "file://"); outfile[0] = '\0'; extspec[0] = '\0'; binspec[0] = '\0'; colspec[0] = '\0'; rowfilter[0] = '\0'; pixfilter[0] = '\0'; compspec[0] = '\0'; } else { /* parse the input file specification */ /* NOTE: This routine tests that all the strings do not */ /* overflow the standard buffer sizes (FLEN_FILENAME, etc.) */ /* therefore in general we do not have to worry about buffer */ /* overflow of any of the returned strings. */ /* call the newer version of this parsing routine that supports 'compspec' */ ffifile2(url, urltype, infile, outfile, extspec, rowfilter, binspec, colspec, pixfilter, compspec, status); } if (*status > 0) { ffpmsg("could not parse the input filename: (ffopen)"); ffpmsg(url); return(*status); } imagecolname[0] = '\0'; rowexpress[0] = '\0'; if (*extspec) { slen = strlen(extspec); if (extspec[slen - 1] == '#') { /* special symbol to mean only copy this extension */ extspec[slen - 1] = '\0'; only_one = 1; } /* parse the extension specifier into individual parameters */ ffexts(extspec, &extnum, extname, &extvers, &movetotype, imagecolname, rowexpress, status); if (*status > 0) return(*status); } /*-------------------------------------------------------------------*/ /* special cases: */ /*-------------------------------------------------------------------*/ histfilename[0] = '\0'; filtfilename[0] = '\0'; if (*outfile && (*binspec || *imagecolname || *pixfilter)) { /* if binspec or imagecolumn are specified, then the */ /* output file name is intended for the final image, */ /* and not a copy of the input file. */ strcpy(histfilename, outfile); outfile[0] = '\0'; } else if (*outfile && (*rowfilter || *colspec)) { /* if rowfilter or colspece are specified, then the */ /* output file name is intended for the filtered file */ /* and not a copy of the input file. */ strcpy(filtfilename, outfile); outfile[0] = '\0'; } /*-------------------------------------------------------------------*/ /* check if this same file is already open, and if so, attach to it */ /*-------------------------------------------------------------------*/ FFLOCK; if (fits_already_open(fptr, url, urltype, infile, extspec, rowfilter, binspec, colspec, mode, &isopen, status) > 0) { FFUNLOCK; return(*status); } FFUNLOCK; if (isopen) { goto move2hdu; } /* get the driver number corresponding to this urltype */ *status = urltype2driver(urltype, &driver); if (*status > 0) { ffpmsg("could not find driver for this file: (ffopen)"); ffpmsg(urltype); ffpmsg(url); return(*status); } /*------------------------------------------------------------------- deal with all those messy special cases which may require that a different driver be used: - is disk file compressed? - are ftp:, gsiftp:, or http: files compressed? - has user requested that a local copy be made of the ftp or http file? -------------------------------------------------------------------*/ if (driverTable[driver].checkfile) { strcpy(origurltype,urltype); /* Save the urltype */ /* 'checkfile' may modify the urltype, infile and outfile strings */ *status = (*driverTable[driver].checkfile)(urltype, infile, outfile); if (*status) { ffpmsg("checkfile failed for this file: (ffopen)"); ffpmsg(url); return(*status); } if (strcmp(origurltype, urltype)) /* did driver changed on us? */ { *status = urltype2driver(urltype, &driver); if (*status > 0) { ffpmsg("could not change driver for this file: (ffopen)"); ffpmsg(url); ffpmsg(urltype); return(*status); } } } /* call appropriate driver to open the file */ if (driverTable[driver].open) { FFLOCK; /* lock this while searching for vacant handle */ *status = (*driverTable[driver].open)(infile, mode, &handle); FFUNLOCK; if (*status > 0) { ffpmsg("failed to find or open the following file: (ffopen)"); ffpmsg(url); return(*status); } } else { ffpmsg("cannot open an existing file of this type: (ffopen)"); ffpmsg(url); return(*status = FILE_NOT_OPENED); } /* get initial file size */ *status = (*driverTable[driver].size)(handle, &filesize); if (*status > 0) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed get the size of the following file: (ffopen)"); ffpmsg(url); return(*status); } /* allocate fitsfile structure and initialize = 0 */ *fptr = (fitsfile *) calloc(1, sizeof(fitsfile)); if (!(*fptr)) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate structure for following file: (ffopen)"); ffpmsg(url); return(*status = MEMORY_ALLOCATION); } /* allocate FITSfile structure and initialize = 0 */ (*fptr)->Fptr = (FITSfile *) calloc(1, sizeof(FITSfile)); if (!((*fptr)->Fptr)) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate structure for following file: (ffopen)"); ffpmsg(url); free(*fptr); *fptr = 0; return(*status = MEMORY_ALLOCATION); } slen = strlen(url) + 1; slen = maxvalue(slen, 32); /* reserve at least 32 chars */ ((*fptr)->Fptr)->filename = (char *) malloc(slen); /* mem for file name */ if ( !(((*fptr)->Fptr)->filename) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for filename: (ffopen)"); ffpmsg(url); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* mem for headstart array */ ((*fptr)->Fptr)->headstart = (LONGLONG *) calloc(1001, sizeof(LONGLONG)); if ( !(((*fptr)->Fptr)->headstart) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for headstart array: (ffopen)"); ffpmsg(url); free( ((*fptr)->Fptr)->filename); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* mem for file I/O buffers */ ((*fptr)->Fptr)->iobuffer = (char *) calloc(NIOBUF, IOBUFLEN); if ( !(((*fptr)->Fptr)->iobuffer) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for iobuffer array: (ffopen)"); ffpmsg(url); free( ((*fptr)->Fptr)->headstart); /* free memory for headstart array */ free( ((*fptr)->Fptr)->filename); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* initialize the ageindex array (relative age of the I/O buffers) */ /* and initialize the bufrecnum array as being empty */ for (ii = 0; ii < NIOBUF; ii++) { ((*fptr)->Fptr)->ageindex[ii] = ii; ((*fptr)->Fptr)->bufrecnum[ii] = -1; } /* store the parameters describing the file */ ((*fptr)->Fptr)->MAXHDU = 1000; /* initial size of headstart */ ((*fptr)->Fptr)->filehandle = handle; /* file handle */ ((*fptr)->Fptr)->driver = driver; /* driver number */ strcpy(((*fptr)->Fptr)->filename, url); /* full input filename */ ((*fptr)->Fptr)->filesize = filesize; /* physical file size */ ((*fptr)->Fptr)->logfilesize = filesize; /* logical file size */ ((*fptr)->Fptr)->writemode = mode; /* read-write mode */ ((*fptr)->Fptr)->datastart = DATA_UNDEFINED; /* unknown start of data */ ((*fptr)->Fptr)->curbuf = -1; /* undefined current IO buffer */ ((*fptr)->Fptr)->open_count = 1; /* structure is currently used once */ ((*fptr)->Fptr)->validcode = VALIDSTRUC; /* flag denoting valid structure */ ((*fptr)->Fptr)->only_one = only_one; /* flag denoting only copy single extension */ ffldrc(*fptr, 0, REPORT_EOF, status); /* load first record */ fits_store_Fptr( (*fptr)->Fptr, status); /* store Fptr address */ if (ffrhdu(*fptr, &hdutyp, status) > 0) /* determine HDU structure */ { ffpmsg( "ffopen could not interpret primary array header of file: "); ffpmsg(url); if (*status == UNKNOWN_REC) ffpmsg("This does not look like a FITS file."); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } /* ------------------------------------------------------------- */ /* At this point, the input file has been opened. If outfile was */ /* specified, then we have opened a copy of the file, not the */ /* original file so it is safe to modify it if necessary */ /* ------------------------------------------------------------- */ if (*outfile) writecopy = 1; move2hdu: /* ---------------------------------------------------------- */ /* move to desired extension, if specified as part of the URL */ /* ---------------------------------------------------------- */ if (*extspec) { if (extnum) /* extension number was specified */ { ffmahd(*fptr, extnum + 1, &hdutyp, status); } else if (*extname) /* move to named extension, if specified */ { ffmnhd(*fptr, movetotype, extname, extvers, status); } if (*status > 0) /* clean up after error */ { ffpmsg("ffopen could not move to the specified extension:"); if (extnum > 0) { sprintf(errmsg, " extension number %d doesn't exist or couldn't be opened.",extnum); ffpmsg(errmsg); } else { sprintf(errmsg, " extension with EXTNAME = %s,", extname); ffpmsg(errmsg); if (extvers) { sprintf(errmsg, " and with EXTVERS = %d,", extvers); ffpmsg(errmsg); } if (movetotype != ANY_HDU) { sprintf(errmsg, " and with XTENSION = %s,", hdtype[movetotype]); ffpmsg(errmsg); } ffpmsg(" doesn't exist or couldn't be opened."); } ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } } else if (skip_null || skip_image || skip_table || (*imagecolname || *colspec || *rowfilter || *binspec)) { /* ------------------------------------------------------------------ If no explicit extension specifier is given as part of the file name, and, if a) skip_null is true (set if ffopen is called by ffdopn) or b) skip_image or skip_table is true (set if ffopen is called by fftopn or ffdopn) or c) other file filters are specified, then CFITSIO will attempt to move to the first 'interesting' HDU after opening an existing FITS file (or to first interesting table HDU if skip_image is true); An 'interesting' HDU is defined to be either an image with NAXIS > 0 (i.e., not a null array) or a table which has an EXTNAME value which does not contain any of the following strings: 'GTI' - Good Time Interval extension 'OBSTABLE' - used in Beppo SAX data files The main purpose for this is to allow CFITSIO to skip over a null primary and other non-interesting HDUs when opening an existing file, and move directly to the first extension that contains significant data. ------------------------------------------------------------------ */ fits_get_hdu_num(*fptr, &hdunum); if (hdunum == 1) { fits_get_img_dim(*fptr, &naxis, status); if (naxis == 0 || skip_image) /* skip primary array */ { while(1) { /* see if the next HDU is 'interesting' */ if (fits_movrel_hdu(*fptr, 1, &hdutyp, status)) { if (*status == END_OF_FILE) *status = 0; /* reset expected error */ /* didn't find an interesting HDU so move back to beginning */ fits_movabs_hdu(*fptr, 1, &hdutyp, status); break; } if (hdutyp == IMAGE_HDU && skip_image) { continue; /* skip images */ } else if (hdutyp != IMAGE_HDU && skip_table) { continue; /* skip tables */ } else if (hdutyp == IMAGE_HDU) { fits_get_img_dim(*fptr, &naxis, status); if (naxis > 0) break; /* found a non-null image */ } else { tstatus = 0; tblname[0] = '\0'; fits_read_key(*fptr, TSTRING, "EXTNAME", tblname, NULL,&tstatus); if ( (!strstr(tblname, "GTI") && !strstr(tblname, "gti")) && strncasecmp(tblname, "OBSTABLE", 8) ) break; /* found an interesting table */ } } /* end while */ } } /* end if (hdunum==1) */ } if (*imagecolname) { /* ----------------------------------------------------------------- */ /* we need to open an image contained in a single table cell */ /* First, determine which row of the table to use. */ /* ----------------------------------------------------------------- */ if (isdigit((int) *rowexpress)) /* is the row specification a number? */ { sscanf(rowexpress, "%ld", &rownum); if (rownum < 1) { ffpmsg("illegal rownum for image cell:"); ffpmsg(rowexpress); ffpmsg("Could not open the following image in a table cell:"); ffpmsg(extspec); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status = BAD_ROW_NUM); } } else if (fits_find_first_row(*fptr, rowexpress, &rownum, status) > 0) { ffpmsg("Failed to find row matching this expression:"); ffpmsg(rowexpress); ffpmsg("Could not open the following image in a table cell:"); ffpmsg(extspec); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } if (rownum == 0) { ffpmsg("row statisfying this expression doesn't exist::"); ffpmsg(rowexpress); ffpmsg("Could not open the following image in a table cell:"); ffpmsg(extspec); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status = BAD_ROW_NUM); } /* determine the name of the new file to contain copy of the image */ if (*histfilename && !(*pixfilter) ) strcpy(outfile, histfilename); /* the original outfile name */ else strcpy(outfile, "mem://_1"); /* create image file in memory */ /* Copy the image into new primary array and open it as the current */ /* fptr. This will close the table that contains the original image. */ /* create new empty file to hold copy of the image */ if (ffinit(&newptr, outfile, status) > 0) { ffpmsg("failed to create file for copy of image in table cell:"); ffpmsg(outfile); return(*status); } if (fits_copy_cell2image(*fptr, newptr, imagecolname, rownum, status) > 0) { ffpmsg("Failed to copy table cell to new primary array:"); ffpmsg(extspec); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } /* close the original file and set fptr to the new image */ ffclos(*fptr, status); *fptr = newptr; /* reset the pointer to the new table */ writecopy = 1; /* we are now dealing with a copy of the original file */ /* add some HISTORY; fits_copy_image_cell also wrote HISTORY keywords */ /* disable this; leave it up to calling routine to write any HISTORY keywords if (*extname) sprintf(card,"HISTORY in HDU '%.16s' of file '%.36s'",extname,infile); else sprintf(card,"HISTORY in HDU %d of file '%.45s'", extnum, infile); ffprec(*fptr, card, status); */ } /* --------------------------------------------------------------------- */ /* edit columns (and/or keywords) in the table, if specified in the URL */ /* --------------------------------------------------------------------- */ if (*colspec) { /* the column specifier will modify the file, so make sure */ /* we are already dealing with a copy, or else make a new copy */ if (!writecopy) /* Is the current file already a copy? */ writecopy = fits_is_this_a_copy(urltype); if (!writecopy) { if (*filtfilename && *outfile == '\0') strcpy(outfile, filtfilename); /* the original outfile name */ else strcpy(outfile, "mem://_1"); /* will create copy in memory */ writecopy = 1; } else { ((*fptr)->Fptr)->writemode = READWRITE; /* we have write access */ outfile[0] = '\0'; } if (ffedit_columns(fptr, outfile, colspec, status) > 0) { ffpmsg("editing columns in input table failed (ffopen)"); ffpmsg(" while trying to perform the following operation:"); ffpmsg(colspec); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } } /* ------------------------------------------------------------------- */ /* select rows from the table, if specified in the URL */ /* or select a subimage (if this is an image HDU and not a table) */ /* ------------------------------------------------------------------- */ if (*rowfilter) { fits_get_hdu_type(*fptr, &hdutyp, status); /* get type of HDU */ if (hdutyp == IMAGE_HDU) { /* this is an image so 'rowfilter' is an image section specification */ if (*filtfilename && *outfile == '\0') strcpy(outfile, filtfilename); /* the original outfile name */ else if (*outfile == '\0') /* output file name not already defined? */ strcpy(outfile, "mem://_2"); /* will create file in memory */ /* create new file containing the image section, plus a copy of */ /* any other HDUs that exist in the input file. This routine */ /* will close the original image file and return a pointer */ /* to the new file. */ if (fits_select_image_section(fptr, outfile, rowfilter, status) > 0) { ffpmsg("on-the-fly selection of image section failed (ffopen)"); ffpmsg(" while trying to use the following section filter:"); ffpmsg(rowfilter); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } } else { /* this is a table HDU, so the rowfilter is really a row filter */ if (*binspec) { /* since we are going to make a histogram of the selected rows, */ /* it would be a waste of time and memory to make a whole copy of */ /* the selected rows. Instead, just construct an array of TRUE */ /* or FALSE values that indicate which rows are to be included */ /* in the histogram and pass that to the histogram generating */ /* routine */ fits_get_num_rows(*fptr, &nrows, status); /* get no. of rows */ rowselect = (char *) calloc(nrows, 1); if (!rowselect) { ffpmsg( "failed to allocate memory for selected columns array (ffopen)"); ffpmsg(" while trying to select rows with the following filter:"); ffpmsg(rowfilter); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } if (fits_find_rows(*fptr, rowfilter, 1L, nrows, &goodrows, rowselect, status) > 0) { ffpmsg("selection of rows in input table failed (ffopen)"); ffpmsg(" while trying to select rows with the following filter:"); ffpmsg(rowfilter); free(rowselect); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } } else { if (!writecopy) /* Is the current file already a copy? */ writecopy = fits_is_this_a_copy(urltype); if (!writecopy) { if (*filtfilename && *outfile == '\0') strcpy(outfile, filtfilename); /* the original outfile name */ else if (*outfile == '\0') /* output filename not already defined? */ strcpy(outfile, "mem://_2"); /* will create copy in memory */ } else { ((*fptr)->Fptr)->writemode = READWRITE; /* we have write access */ outfile[0] = '\0'; } /* select rows in the table. If a copy of the input file has */ /* not already been made, then this routine will make a copy */ /* and then close the input file, so that the modifications will */ /* only be made on the copy, not the original */ if (ffselect_table(fptr, outfile, rowfilter, status) > 0) { ffpmsg("on-the-fly selection of rows in input table failed (ffopen)"); ffpmsg(" while trying to select rows with the following filter:"); ffpmsg(rowfilter); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } /* write history records */ ffphis(*fptr, "CFITSIO used the following filtering expression to create this table:", status); ffphis(*fptr, name, status); } /* end of no binspec case */ } /* end of table HDU case */ } /* end of rowfilter exists case */ /* ------------------------------------------------------------------- */ /* make an image histogram by binning columns, if specified in the URL */ /* ------------------------------------------------------------------- */ if (*binspec) { if (*histfilename && !(*pixfilter) ) strcpy(outfile, histfilename); /* the original outfile name */ else strcpy(outfile, "mem://_3"); /* create histogram in memory */ /* if not already copied the file */ /* parse the binning specifier into individual parameters */ ffbins(binspec, &imagetype, &haxis, colname, minin, maxin, binsizein, minname, maxname, binname, &weight, wtcol, &recip, status); /* Create the histogram primary array and open it as the current fptr */ /* This will close the table that was used to create the histogram. */ ffhist2(fptr, outfile, imagetype, haxis, colname, minin, maxin, binsizein, minname, maxname, binname, weight, wtcol, recip, rowselect, status); if (rowselect) free(rowselect); if (*status > 0) { ffpmsg("on-the-fly histogramming of input table failed (ffopen)"); ffpmsg(" while trying to execute the following histogram specification:"); ffpmsg(binspec); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } /* write history records */ ffphis(*fptr, "CFITSIO used the following expression to create this histogram:", status); ffphis(*fptr, name, status); } if (*pixfilter) { if (*histfilename) strcpy(outfile, histfilename); /* the original outfile name */ else strcpy(outfile, "mem://_4"); /* create in memory */ /* if not already copied the file */ /* Ensure type of HDU is consistent with pixel filtering */ fits_get_hdu_type(*fptr, &hdutyp, status); /* get type of HDU */ if (hdutyp == IMAGE_HDU) { pixel_filter_helper(fptr, outfile, pixfilter, status); if (*status > 0) { ffpmsg("pixel filtering of input image failed (ffopen)"); ffpmsg(" while trying to execute the following:"); ffpmsg(pixfilter); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ return(*status); } /* write history records */ ffphis(*fptr, "CFITSIO used the following expression to create this image:", status); ffphis(*fptr, name, status); } else { ffpmsg("cannot use pixel filter on non-IMAGE HDU"); ffpmsg(pixfilter); ffclos(*fptr, status); *fptr = 0; /* return null file pointer */ *status = NOT_IMAGE; return(*status); } } /* parse and save image compression specification, if given */ if (*compspec) { ffparsecompspec(*fptr, compspec, status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffreopen(fitsfile *openfptr, /* I - FITS file pointer to open file */ fitsfile **newfptr, /* O - pointer to new re opened file */ int *status) /* IO - error status */ /* Reopen an existing FITS file with either readonly or read/write access. The reopened file shares the same FITSfile structure but may point to a different HDU within the file. */ { if (*status > 0) return(*status); /* check that the open file pointer is valid */ if (!openfptr) return(*status = NULL_INPUT_PTR); else if ((openfptr->Fptr)->validcode != VALIDSTRUC) /* check magic value */ return(*status = BAD_FILEPTR); /* allocate fitsfile structure and initialize = 0 */ *newfptr = (fitsfile *) calloc(1, sizeof(fitsfile)); (*newfptr)->Fptr = openfptr->Fptr; /* both point to the same structure */ (*newfptr)->HDUposition = 0; /* set initial position to primary array */ (((*newfptr)->Fptr)->open_count)++; /* increment the file usage counter */ return(*status); } /*--------------------------------------------------------------------------*/ int fits_store_Fptr(FITSfile *Fptr, /* O - FITS file pointer */ int *status) /* IO - error status */ /* store the new Fptr address for future use by fits_already_open */ { int ii; if (*status > 0) return(*status); FFLOCK; for (ii = 0; ii < NMAXFILES; ii++) { if (FptrTable[ii] == 0) { FptrTable[ii] = Fptr; break; } } FFUNLOCK; return(*status); } /*--------------------------------------------------------------------------*/ int fits_clear_Fptr(FITSfile *Fptr, /* O - FITS file pointer */ int *status) /* IO - error status */ /* clear the Fptr address from the Fptr Table */ { int ii; FFLOCK; for (ii = 0; ii < NMAXFILES; ii++) { if (FptrTable[ii] == Fptr) { FptrTable[ii] = 0; break; } } FFUNLOCK; return(*status); } /*--------------------------------------------------------------------------*/ int fits_already_open(fitsfile **fptr, /* I/O - FITS file pointer */ char *url, char *urltype, char *infile, char *extspec, char *rowfilter, char *binspec, char *colspec, int mode, /* I - 0 = open readonly; 1 = read/write */ int *isopen, /* O - 1 = file is already open */ int *status) /* IO - error status */ /* Check if the file to be opened is already open. If so, then attach to it. */ /* the input strings must not exceed the standard lengths */ /* of FLEN_FILENAME, MAX_PREFIX_LEN, etc. */ /* this function was changed so that for files of access method FILE:// the file paths are compared using standard URL syntax and absolute paths (as opposed to relative paths). This eliminates some instances where a file is already opened but it is not realized because it was opened with another file path. For instance, if the CWD is /a/b/c and I open /a/b/c/foo.fits then open ./foo.fits the previous version of this function would not have reconized that the two files were the same. This version does recognize that the two files are the same. */ { FITSfile *oldFptr; int ii; char oldurltype[MAX_PREFIX_LEN], oldinfile[FLEN_FILENAME]; char oldextspec[FLEN_FILENAME], oldoutfile[FLEN_FILENAME]; char oldrowfilter[FLEN_FILENAME]; char oldbinspec[FLEN_FILENAME], oldcolspec[FLEN_FILENAME]; char cwd[FLEN_FILENAME]; char tmpStr[FLEN_FILENAME]; char tmpinfile[FLEN_FILENAME]; *isopen = 0; /* When opening a file with readonly access then we simply let the operating system open the file again, instead of using the CFITSIO trick of attaching to the previously opened file. This is required if CFITSIO is running in a multi-threaded environment, because 2 different threads cannot share the same FITSfile pointer. If the file is opened/reopened with write access, then the file MUST only be physically opened once.. */ if (mode == 0) return(*status); if(strcasecmp(urltype,"FILE://") == 0) { fits_path2url(infile,tmpinfile,status); if(tmpinfile[0] != '/') { fits_get_cwd(cwd,status); strcat(cwd,"/"); if (strlen(cwd) + strlen(tmpinfile) > FLEN_FILENAME-1) { ffpmsg("File name is too long. (fits_already_open)"); return(*status = FILE_NOT_OPENED); } strcat(cwd,tmpinfile); fits_clean_url(cwd,tmpinfile,status); } } else strcpy(tmpinfile,infile); for (ii = 0; ii < NMAXFILES; ii++) /* check every buffer */ { if (FptrTable[ii] != 0) { oldFptr = FptrTable[ii]; fits_parse_input_url(oldFptr->filename, oldurltype, oldinfile, oldoutfile, oldextspec, oldrowfilter, oldbinspec, oldcolspec, status); if (*status > 0) { ffpmsg("could not parse the previously opened filename: (ffopen)"); ffpmsg(oldFptr->filename); return(*status); } if(strcasecmp(oldurltype,"FILE://") == 0) { fits_path2url(oldinfile,tmpStr,status); if(tmpStr[0] != '/') { fits_get_cwd(cwd,status); strcat(cwd,"/"); strcat(cwd,tmpStr); fits_clean_url(cwd,tmpStr,status); } strcpy(oldinfile,tmpStr); } if (!strcmp(urltype, oldurltype) && !strcmp(tmpinfile, oldinfile) ) { /* identical type of file and root file name */ if ( (!rowfilter[0] && !oldrowfilter[0] && !binspec[0] && !oldbinspec[0] && !colspec[0] && !oldcolspec[0]) /* no filtering or binning specs for either file, so */ /* this is a case where the same file is being reopened. */ /* It doesn't matter if the extensions are different */ || /* or */ (!strcmp(rowfilter, oldrowfilter) && !strcmp(binspec, oldbinspec) && !strcmp(colspec, oldcolspec) && !strcmp(extspec, oldextspec) ) ) /* filtering specs are given and are identical, and */ /* the same extension is specified */ { if (mode == READWRITE && oldFptr->writemode == READONLY) { /* cannot assume that a file previously opened with READONLY can now be written to (e.g., files on CDROM, or over the the network, or STDIN), so return with an error. */ ffpmsg( "cannot reopen file READWRITE when previously opened READONLY"); ffpmsg(url); return(*status = FILE_NOT_OPENED); } *fptr = (fitsfile *) calloc(1, sizeof(fitsfile)); if (!(*fptr)) { ffpmsg( "failed to allocate structure for following file: (ffopen)"); ffpmsg(url); return(*status = MEMORY_ALLOCATION); } (*fptr)->Fptr = oldFptr; /* point to the structure */ (*fptr)->HDUposition = 0; /* set initial position */ (((*fptr)->Fptr)->open_count)++; /* increment usage counter */ if (binspec[0]) /* if binning specified, don't move */ extspec[0] = '\0'; /* all the filtering has already been applied, so ignore */ rowfilter[0] = '\0'; binspec[0] = '\0'; colspec[0] = '\0'; *isopen = 1; } } } } return(*status); } /*--------------------------------------------------------------------------*/ int fits_is_this_a_copy(char *urltype) /* I - type of file */ /* specialized routine that returns 1 if the file is known to be a temporary copy of the originally opened file. Otherwise it returns 0. */ { int iscopy; if (!strncmp(urltype, "mem", 3) ) iscopy = 1; /* file copy is in memory */ else if (!strncmp(urltype, "compress", 8) ) iscopy = 1; /* compressed diskfile that is uncompressed in memory */ else if (!strncmp(urltype, "http", 4) ) iscopy = 1; /* copied file using http protocol */ else if (!strncmp(urltype, "ftp", 3) ) iscopy = 1; /* copied file using ftp protocol */ else if (!strncmp(urltype, "gsiftp", 6) ) iscopy = 1; /* copied file using gsiftp protocol */ else if (!strncpy(urltype, "stdin", 5) ) iscopy = 1; /* piped stdin has been copied to memory */ else iscopy = 0; /* file is not known to be a copy */ return(iscopy); } /*--------------------------------------------------------------------------*/ static int find_quote(char **string) /* look for the closing single quote character in the input string */ { char *tstr; tstr = *string; while (*tstr) { if (*tstr == '\'') { /* found the closing quote */ *string = tstr + 1; /* set pointer to next char */ return(0); } else { /* skip over any other character */ tstr++; } } return(1); /* opps, didn't find the closing character */ } /*--------------------------------------------------------------------------*/ static int find_doublequote(char **string) /* look for the closing double quote character in the input string */ { char *tstr; tstr = *string; while (*tstr) { if (*tstr == '"') { /* found the closing quote */ *string = tstr + 1; /* set pointer to next char */ return(0); } else { /* skip over any other character */ tstr++; } } return(1); /* opps, didn't find the closing character */ } /*--------------------------------------------------------------------------*/ static int find_paren(char **string) /* look for the closing parenthesis character in the input string */ { char *tstr; tstr = *string; while (*tstr) { if (*tstr == ')') { /* found the closing parens */ *string = tstr + 1; /* set pointer to next char */ return(0); } else if (*tstr == '(') { /* found another level of parens */ tstr++; if (find_paren(&tstr)) return(1); } else if (*tstr == '[') { tstr++; if (find_bracket(&tstr)) return(1); } else if (*tstr == '{') { tstr++; if (find_curlybracket(&tstr)) return(1); } else if (*tstr == '"') { tstr++; if (find_doublequote(&tstr)) return(1); } else if (*tstr == '\'') { tstr++; if (find_quote(&tstr)) return(1); } else { tstr++; } } return(1); /* opps, didn't find the closing character */ } /*--------------------------------------------------------------------------*/ static int find_bracket(char **string) /* look for the closing bracket character in the input string */ { char *tstr; tstr = *string; while (*tstr) { if (*tstr == ']') { /* found the closing bracket */ *string = tstr + 1; /* set pointer to next char */ return(0); } else if (*tstr == '(') { /* found another level of parens */ tstr++; if (find_paren(&tstr)) return(1); } else if (*tstr == '[') { tstr++; if (find_bracket(&tstr)) return(1); } else if (*tstr == '{') { tstr++; if (find_curlybracket(&tstr)) return(1); } else if (*tstr == '"') { tstr++; if (find_doublequote(&tstr)) return(1); } else if (*tstr == '\'') { tstr++; if (find_quote(&tstr)) return(1); } else { tstr++; } } return(1); /* opps, didn't find the closing character */ } /*--------------------------------------------------------------------------*/ static int find_curlybracket(char **string) /* look for the closing curly bracket character in the input string */ { char *tstr; tstr = *string; while (*tstr) { if (*tstr == '}') { /* found the closing curly bracket */ *string = tstr + 1; /* set pointer to next char */ return(0); } else if (*tstr == '(') { /* found another level of parens */ tstr++; if (find_paren(&tstr)) return(1); } else if (*tstr == '[') { tstr++; if (find_bracket(&tstr)) return(1); } else if (*tstr == '{') { tstr++; if (find_curlybracket(&tstr)) return(1); } else if (*tstr == '"') { tstr++; if (find_doublequote(&tstr)) return(1); } else if (*tstr == '\'') { tstr++; if (find_quote(&tstr)) return(1); } else { tstr++; } } return(1); /* opps, didn't find the closing character */ } /*--------------------------------------------------------------------------*/ int comma2semicolon(char *string) /* replace commas with semicolons, unless the comma is within a quoted or bracketed expression */ { char *tstr; tstr = string; while (*tstr) { if (*tstr == ',') { /* found a comma */ *tstr = ';'; tstr++; } else if (*tstr == '(') { /* found another level of parens */ tstr++; if (find_paren(&tstr)) return(1); } else if (*tstr == '[') { tstr++; if (find_bracket(&tstr)) return(1); } else if (*tstr == '{') { tstr++; if (find_curlybracket(&tstr)) return(1); } else if (*tstr == '"') { tstr++; if (find_doublequote(&tstr)) return(1); } else if (*tstr == '\'') { tstr++; if (find_quote(&tstr)) return(1); } else { tstr++; } } return(0); /* reached end of string */ } /*--------------------------------------------------------------------------*/ int ffedit_columns( fitsfile **fptr, /* IO - pointer to input table; on output it */ /* points to the new selected rows table */ char *outfile, /* I - name for output file */ char *expr, /* I - column edit expression */ int *status) /* modify columns in a table and/or header keywords in the HDU */ { fitsfile *newptr; int ii, hdunum, slen, colnum = -1, testnum, deletecol = 0, savecol = 0; int numcols = 0, *colindex = 0, tstatus = 0; char *cptr, *cptr2, *cptr3, *clause = NULL, keyname[FLEN_KEYWORD]; char colname[FLEN_VALUE], oldname[FLEN_VALUE], colformat[FLEN_VALUE]; char *file_expr = NULL, testname[FLEN_VALUE], card[FLEN_CARD]; if (*outfile) { /* create new empty file in to hold the selected rows */ if (ffinit(&newptr, outfile, status) > 0) { ffpmsg("failed to create file for copy (ffedit_columns)"); return(*status); } fits_get_hdu_num(*fptr, &hdunum); /* current HDU number in input file */ /* copy all HDUs to the output copy, if the 'only_one' flag is not set */ if (!((*fptr)->Fptr)->only_one) { for (ii = 1; 1; ii++) { if (fits_movabs_hdu(*fptr, ii, NULL, status) > 0) break; fits_copy_hdu(*fptr, newptr, 0, status); } if (*status == END_OF_FILE) { *status = 0; /* got the expected EOF error; reset = 0 */ } else if (*status > 0) { ffclos(newptr, status); ffpmsg("failed to copy all HDUs from input file (ffedit_columns)"); return(*status); } } else { /* only copy the primary array and the designated table extension */ fits_movabs_hdu(*fptr, 1, NULL, status); fits_copy_hdu(*fptr, newptr, 0, status); fits_movabs_hdu(*fptr, hdunum, NULL, status); fits_copy_hdu(*fptr, newptr, 0, status); if (*status > 0) { ffclos(newptr, status); ffpmsg("failed to copy all HDUs from input file (ffedit_columns)"); return(*status); } hdunum = 2; } /* close the original file and return ptr to the new image */ ffclos(*fptr, status); *fptr = newptr; /* reset the pointer to the new table */ /* move back to the selected table HDU */ if (fits_movabs_hdu(*fptr, hdunum, NULL, status) > 0) { ffpmsg("failed to copy the input file (ffedit_columns)"); return(*status); } } /* remove the "col " from the beginning of the column edit expression */ cptr = expr + 4; while (*cptr == ' ') cptr++; /* skip leading white space */ /* Check if need to import expression from a file */ if( *cptr=='@' ) { if( ffimport_file( cptr+1, &file_expr, status ) ) return(*status); cptr = file_expr; while (*cptr == ' ') cptr++; /* skip leading white space... again */ } tstatus = 0; ffgncl(*fptr, &numcols, &tstatus); /* get initial # of cols */ /* as of July 2012, the CFITSIO column filter syntax was modified */ /* so that commas may be used to separate clauses, as well as semi-colons. */ /* This was done because users cannot enter the semi-colon in the HEASARC's */ /* Hera on-line data processing system for computer security reasons. */ /* Therefore, we must convert those commas back to semi-colons here, but we */ /* must not convert any columns that occur within parenthesies. */ if (comma2semicolon(cptr)) { ffpmsg("parsing error in column filter expression"); ffpmsg(cptr); if( file_expr ) free( file_expr ); *status = PARSE_SYNTAX_ERR; return(*status); } /* parse expression and get first clause, if more than 1 */ while ((slen = fits_get_token2(&cptr, ";", &clause, NULL, status)) > 0 ) { if( *cptr==';' ) cptr++; clause[slen] = '\0'; if (clause[0] == '!' || clause[0] == '-') { /* ===================================== */ /* Case I. delete this column or keyword */ /* ===================================== */ if (ffgcno(*fptr, CASEINSEN, &clause[1], &colnum, status) <= 0) { /* a column with this name exists, so try to delete it */ if (ffdcol(*fptr, colnum, status) > 0) { ffpmsg("failed to delete column in input file:"); ffpmsg(clause); if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if( clause ) free(clause); return(*status); } deletecol = 1; /* set flag that at least one col was deleted */ numcols--; colnum = -1; } else { ffcmsg(); /* clear previous error message from ffgcno */ /* try deleting a keyword with this name */ *status = 0; if (ffdkey(*fptr, &clause[1], status) > 0) { ffpmsg("column or keyword to be deleted does not exist:"); ffpmsg(clause); if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if( clause ) free(clause); return(*status); } } } else { /* ===================================================== */ /* Case II: this is either a column name, (case 1) or a new column name followed by double = ("==") followed by the old name which is to be renamed. (case 2A) or a column or keyword name followed by a single "=" and a calculation expression (case 2B) */ /* ===================================================== */ cptr2 = clause; slen = fits_get_token(&cptr2, "( =", colname, NULL); if (slen == 0) { ffpmsg("error: column or keyword name is blank:"); ffpmsg(clause); if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if (clause) free(clause); return(*status= URL_PARSE_ERROR); } /* If this is a keyword of the form #KEYWORD# then transform to the form #KEYWORDn where n is the previously used column number */ if (colname[0] == '#' && strstr(colname+1, "#") == (colname + strlen(colname) - 1)) { if (colnum <= 0) { ffpmsg("The keyword name:"); ffpmsg(colname); ffpmsg("is invalid unless a column has been previously"); ffpmsg("created or editted by a calculator command"); if( file_expr ) free( file_expr ); if (clause) free(clause); return(*status = URL_PARSE_ERROR); } colname[strlen(colname)-1] = '\0'; /* Make keyword name and put it in oldname */ ffkeyn(colname+1, colnum, oldname, status); if (*status) return (*status); /* Re-copy back into colname */ strcpy(colname+1,oldname); } else if (strstr(colname, "#") == (colname + strlen(colname) - 1)) { /* colname is of the form "NAME#"; if a) colnum is defined, and b) a column with literal name "NAME#" does not exist, and c) a keyword with name "NAMEn" (where n=colnum) exists, then transfrom the colname string to "NAMEn", otherwise do nothing. */ if (colnum > 0) { /* colnum must be defined */ tstatus = 0; ffgcno(*fptr, CASEINSEN, colname, &testnum, &tstatus); if (tstatus != 0 && tstatus != COL_NOT_UNIQUE) { /* OK, column doesn't exist, now see if keyword exists */ ffcmsg(); /* clear previous error message from ffgcno */ strcpy(testname, colname); testname[strlen(testname)-1] = '\0'; /* Make keyword name and put it in oldname */ ffkeyn(testname, colnum, oldname, status); if (*status) { if( file_expr ) free( file_expr ); if (clause) free(clause); return (*status); } tstatus = 0; if (!fits_read_card(*fptr, oldname, card, &tstatus)) { /* Keyword does exist; copy real name back into colname */ strcpy(colname,oldname); } } } } /* if we encountered an opening parenthesis, then we need to */ /* find the closing parenthesis, and concatinate the 2 strings */ /* This supports expressions like: [col #EXTNAME(Extension name)="GTI"] */ if (*cptr2 == '(') { fits_get_token(&cptr2, ")", oldname, NULL); strcat(colname, oldname); strcat(colname, ")"); cptr2++; } while (*cptr2 == ' ') cptr2++; /* skip white space */ if (*cptr2 != '=') { /* ------------------------------------ */ /* case 1 - simply the name of a column */ /* ------------------------------------ */ /* look for matching column */ ffgcno(*fptr, CASEINSEN, colname, &testnum, status); while (*status == COL_NOT_UNIQUE) { /* the column name contained wild cards, and it */ /* matches more than one column in the table. */ colnum = testnum; /* keep this column in the output file */ savecol = 1; if (!colindex) colindex = (int *) calloc(999, sizeof(int)); colindex[colnum - 1] = 1; /* flag this column number */ /* look for other matching column names */ ffgcno(*fptr, CASEINSEN, colname, &testnum, status); if (*status == COL_NOT_FOUND) *status = 999; /* temporary status flag value */ } if (*status <= 0) { colnum = testnum; /* keep this column in the output file */ savecol = 1; if (!colindex) colindex = (int *) calloc(999, sizeof(int)); colindex[colnum - 1] = 1; /* flag this column number */ } else if (*status == 999) { /* this special flag value does not represent an error */ *status = 0; } else { ffpmsg("Syntax error in columns specifier in input URL:"); ffpmsg(cptr2); if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if (clause) free(clause); return(*status = URL_PARSE_ERROR); } } else { /* ----------------------------------------------- */ /* case 2 where the token ends with an equals sign */ /* ----------------------------------------------- */ cptr2++; /* skip over the first '=' */ if (*cptr2 == '=') { /*................................................. */ /* Case A: rename a column or keyword; syntax is "new_name == old_name" */ /*................................................. */ cptr2++; /* skip the 2nd '=' */ while (*cptr2 == ' ') cptr2++; /* skip white space */ fits_get_token(&cptr2, " ", oldname, NULL); /* get column number of the existing column */ if (ffgcno(*fptr, CASEINSEN, oldname, &colnum, status) <= 0) { /* modify the TTYPEn keyword value with the new name */ ffkeyn("TTYPE", colnum, keyname, status); if (ffmkys(*fptr, keyname, colname, NULL, status) > 0) { ffpmsg("failed to rename column in input file"); ffpmsg(" oldname ="); ffpmsg(oldname); ffpmsg(" newname ="); ffpmsg(colname); if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if (clause) free(clause); return(*status); } /* keep this column in the output file */ savecol = 1; if (!colindex) colindex = (int *) calloc(999, sizeof(int)); colindex[colnum - 1] = 1; /* flag this column number */ } else { /* try renaming a keyword */ ffcmsg(); /* clear error message stack */ *status = 0; if (ffmnam(*fptr, oldname, colname, status) > 0) { ffpmsg("column or keyword to be renamed does not exist:"); ffpmsg(clause); if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if (clause) free(clause); return(*status); } } } else { /*...................................................... */ /* Case B: */ /* this must be a general column/keyword calc expression */ /* "name = expression" or "colname(TFORM) = expression" */ /*...................................................... */ /* parse the name and TFORM values, if present */ colformat[0] = '\0'; cptr3 = colname; fits_get_token(&cptr3, "(", oldname, NULL); if (cptr3[0] == '(' ) { cptr3++; /* skip the '(' */ fits_get_token(&cptr3, ")", colformat, NULL); } /* calculate values for the column or keyword */ /* cptr2 = the expression to be calculated */ /* oldname = name of the column or keyword */ /* colformat = column format, or keyword comment string */ if (fits_calculator(*fptr, cptr2, *fptr, oldname, colformat, status) > 0) { ffpmsg("Unable to calculate expression"); if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if (clause) free(clause); return(*status); } /* test if this is a column and not a keyword */ tstatus = 0; ffgcno(*fptr, CASEINSEN, oldname, &testnum, &tstatus); if (tstatus == 0) { /* keep this column in the output file */ colnum = testnum; savecol = 1; if (!colindex) colindex = (int *) calloc(999, sizeof(int)); colindex[colnum - 1] = 1; if (colnum > numcols)numcols++; } else { ffcmsg(); /* clear the error message stack */ } } } } if (clause) free(clause); /* free old clause before getting new one */ clause = NULL; } if (savecol && !deletecol) { /* need to delete all but the specified columns */ for (ii = numcols; ii > 0; ii--) { if (!colindex[ii-1]) /* delete this column */ { if (ffdcol(*fptr, ii, status) > 0) { ffpmsg("failed to delete column in input file:"); ffpmsg(clause); if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if (clause) free(clause); return(*status); } } } } if( colindex ) free( colindex ); if( file_expr ) free( file_expr ); if (clause) free(clause); return(*status); } /*--------------------------------------------------------------------------*/ int fits_copy_cell2image( fitsfile *fptr, /* I - point to input table */ fitsfile *newptr, /* O - existing output file; new image HDU will be appended to it */ char *colname, /* I - column name / number containing the image*/ long rownum, /* I - number of the row containing the image */ int *status) /* IO - error status */ /* Copy a table cell of a given row and column into an image extension. The output file must already have been created. A new image extension will be created in that file. This routine was written by Craig Markwardt, GSFC */ { unsigned char buffer[30000]; int hdutype, colnum, typecode, bitpix, naxis, maxelem, tstatus; LONGLONG naxes[9], nbytes, firstbyte, ntodo; LONGLONG repeat, startpos, elemnum, rowlen, tnull; long twidth, incre; double scale, zero; char tform[20]; char card[FLEN_CARD]; char templt[FLEN_CARD] = ""; /* Table-to-image keyword translation table */ /* INPUT OUTPUT */ /* 01234567 01234567 */ char *patterns[][2] = {{"TSCALn", "BSCALE" }, /* Standard FITS keywords */ {"TZEROn", "BZERO" }, {"TUNITn", "BUNIT" }, {"TNULLn", "BLANK" }, {"TDMINn", "DATAMIN" }, {"TDMAXn", "DATAMAX" }, {"iCTYPn", "CTYPEi" }, /* Coordinate labels */ {"iCTYna", "CTYPEia" }, {"iCUNIn", "CUNITi" }, /* Coordinate units */ {"iCUNna", "CUNITia" }, {"iCRVLn", "CRVALi" }, /* WCS keywords */ {"iCRVna", "CRVALia" }, {"iCDLTn", "CDELTi" }, {"iCDEna", "CDELTia" }, {"iCRPXn", "CRPIXi" }, {"iCRPna", "CRPIXia" }, {"ijPCna", "PCi_ja" }, {"ijCDna", "CDi_ja" }, {"iVn_ma", "PVi_ma" }, {"iSn_ma", "PSi_ma" }, {"iCRDna", "CRDERia" }, {"iCSYna", "CSYERia" }, {"iCROTn", "CROTAi" }, {"WCAXna", "WCSAXESa"}, {"WCSNna", "WCSNAMEa"}, {"LONPna", "LONPOLEa"}, {"LATPna", "LATPOLEa"}, {"EQUIna", "EQUINOXa"}, {"MJDOBn", "MJD-OBS" }, {"MJDAn", "MJD-AVG" }, {"RADEna", "RADESYSa"}, {"iCNAna", "CNAMEia" }, {"DAVGn", "DATE-AVG"}, /* Delete table keywords related to other columns */ {"T????#a", "-" }, {"TC??#a", "-" }, {"TWCS#a", "-" }, {"TDIM#", "-" }, {"iCTYPm", "-" }, {"iCUNIm", "-" }, {"iCRVLm", "-" }, {"iCDLTm", "-" }, {"iCRPXm", "-" }, {"iCTYma", "-" }, {"iCUNma", "-" }, {"iCRVma", "-" }, {"iCDEma", "-" }, {"iCRPma", "-" }, {"ijPCma", "-" }, {"ijCDma", "-" }, {"iVm_ma", "-" }, {"iSm_ma", "-" }, {"iCRDma", "-" }, {"iCSYma", "-" }, {"iCROTm", "-" }, {"WCAXma", "-" }, {"WCSNma", "-" }, {"LONPma", "-" }, {"LATPma", "-" }, {"EQUIma", "-" }, {"MJDOBm", "-" }, {"MJDAm", "-" }, {"RADEma", "-" }, {"iCNAma", "-" }, {"DAVGm", "-" }, {"EXTNAME", "-" }, /* Remove structural keywords*/ {"EXTVER", "-" }, {"EXTLEVEL","-" }, {"CHECKSUM","-" }, {"DATASUM", "-" }, {"*", "+" }}; /* copy all other keywords */ int npat; if (*status > 0) return(*status); /* get column number */ if (ffgcno(fptr, CASEINSEN, colname, &colnum, status) > 0) { ffpmsg("column containing image in table cell does not exist:"); ffpmsg(colname); return(*status); } /*---------------------------------------------------*/ /* Check input and get parameters about the column: */ /*---------------------------------------------------*/ if ( ffgcprll(fptr, colnum, rownum, 1L, 1L, 0, &scale, &zero, tform, &twidth, &typecode, &maxelem, &startpos, &elemnum, &incre, &repeat, &rowlen, &hdutype, &tnull, (char *) buffer, status) > 0 ) return(*status); /* get the actual column name, in case a column number was given */ ffkeyn("", colnum, templt, &tstatus); ffgcnn(fptr, CASEINSEN, templt, colname, &colnum, &tstatus); if (hdutype != BINARY_TBL) { ffpmsg("This extension is not a binary table."); ffpmsg(" Cannot open the image in a binary table cell."); return(*status = NOT_BTABLE); } if (typecode < 0) { /* variable length array */ typecode *= -1; /* variable length arrays are 1-dimensional by default */ naxis = 1; naxes[0] = repeat; } else { /* get the dimensions of the image */ ffgtdmll(fptr, colnum, 9, &naxis, naxes, status); } if (*status > 0) { ffpmsg("Error getting the dimensions of the image"); return(*status); } /* determine BITPIX value for the image */ if (typecode == TBYTE) { bitpix = BYTE_IMG; nbytes = repeat; } else if (typecode == TSHORT) { bitpix = SHORT_IMG; nbytes = repeat * 2; } else if (typecode == TLONG) { bitpix = LONG_IMG; nbytes = repeat * 4; } else if (typecode == TFLOAT) { bitpix = FLOAT_IMG; nbytes = repeat * 4; } else if (typecode == TDOUBLE) { bitpix = DOUBLE_IMG; nbytes = repeat * 8; } else if (typecode == TLONGLONG) { bitpix = LONGLONG_IMG; nbytes = repeat * 8; } else if (typecode == TLOGICAL) { bitpix = BYTE_IMG; nbytes = repeat; } else { ffpmsg("Error: the following image column has invalid datatype:"); ffpmsg(colname); ffpmsg(tform); ffpmsg("Cannot open an image in a single row of this column."); return(*status = BAD_TFORM); } /* create new image in output file */ if (ffcrimll(newptr, bitpix, naxis, naxes, status) > 0) { ffpmsg("failed to write required primary array keywords in the output file"); return(*status); } npat = sizeof(patterns)/sizeof(patterns[0][0])/2; /* skip over the first 8 keywords, starting just after TFIELDS */ fits_translate_keywords(fptr, newptr, 9, patterns, npat, colnum, 0, 0, status); /* add some HISTORY */ sprintf(card,"HISTORY This image was copied from row %ld of column '%s',", rownum, colname); /* disable this; leave it up to the caller to write history if needed. ffprec(newptr, card, status); */ /* the use of ffread routine, below, requires that any 'dirty' */ /* buffers in memory be flushed back to the file first */ ffflsh(fptr, FALSE, status); /* finally, copy the data, one buffer size at a time */ ffmbyt(fptr, startpos, TRUE, status); firstbyte = 1; /* the upper limit on the number of bytes must match the declaration */ /* read up to the first 30000 bytes in the normal way with ffgbyt */ ntodo = minvalue(30000, nbytes); ffgbyt(fptr, ntodo, buffer, status); ffptbb(newptr, 1, firstbyte, ntodo, buffer, status); nbytes -= ntodo; firstbyte += ntodo; /* read any additional bytes with low-level ffread routine, for speed */ while (nbytes && (*status <= 0) ) { ntodo = minvalue(30000, nbytes); ffread((fptr)->Fptr, (long) ntodo, buffer, status); ffptbb(newptr, 1, firstbyte, ntodo, buffer, status); nbytes -= ntodo; firstbyte += ntodo; } /* Re-scan the header so that CFITSIO knows about all the new keywords */ ffrdef(newptr,status); return(*status); } /*--------------------------------------------------------------------------*/ int fits_copy_image2cell( fitsfile *fptr, /* I - pointer to input image extension */ fitsfile *newptr, /* I - pointer to output table */ char *colname, /* I - name of column containing the image */ long rownum, /* I - number of the row containing the image */ int copykeyflag, /* I - controls which keywords to copy */ int *status) /* IO - error status */ /* Copy an image extension into a table cell at a given row and column. The table must have already been created. If the "colname" column exists, it will be used, otherwise a new column will be created in the table. The "copykeyflag" parameter controls which keywords to copy from the input image to the output table header (with any appropriate translation). copykeyflag = 0 -- no keywords will be copied copykeyflag = 1 -- essentially all keywords will be copied copykeyflag = 2 -- copy only the WCS related keywords This routine was written by Craig Markwardt, GSFC */ { tcolumn *colptr; unsigned char buffer[30000]; int ii, hdutype, colnum, typecode, bitpix, naxis, ncols, hdunum; char tformchar, tform[20], card[FLEN_CARD]; LONGLONG imgstart, naxes[9], nbytes, repeat, ntodo,firstbyte; char filename[FLEN_FILENAME+20]; int npat; int naxis1; LONGLONG naxes1[9] = {0,0,0,0,0,0,0,0,0}, repeat1, width1; int typecode1; unsigned char dummy = 0; LONGLONG headstart, datastart, dataend; /* Image-to-table keyword translation table */ /* INPUT OUTPUT */ /* 01234567 01234567 */ char *patterns[][2] = {{"BSCALE", "TSCALn" }, /* Standard FITS keywords */ {"BZERO", "TZEROn" }, {"BUNIT", "TUNITn" }, {"BLANK", "TNULLn" }, {"DATAMIN", "TDMINn" }, {"DATAMAX", "TDMAXn" }, {"CTYPEi", "iCTYPn" }, /* Coordinate labels */ {"CTYPEia", "iCTYna" }, {"CUNITi", "iCUNIn" }, /* Coordinate units */ {"CUNITia", "iCUNna" }, {"CRVALi", "iCRVLn" }, /* WCS keywords */ {"CRVALia", "iCRVna" }, {"CDELTi", "iCDLTn" }, {"CDELTia", "iCDEna" }, {"CRPIXj", "jCRPXn" }, {"CRPIXja", "jCRPna" }, {"PCi_ja", "ijPCna" }, {"CDi_ja", "ijCDna" }, {"PVi_ma", "iVn_ma" }, {"PSi_ma", "iSn_ma" }, {"WCSAXESa","WCAXna" }, {"WCSNAMEa","WCSNna" }, {"CRDERia", "iCRDna" }, {"CSYERia", "iCSYna" }, {"CROTAi", "iCROTn" }, {"LONPOLEa","LONPna"}, {"LATPOLEa","LATPna"}, {"EQUINOXa","EQUIna"}, {"MJD-OBS", "MJDOBn" }, {"MJD-AVG", "MJDAn" }, {"RADESYSa","RADEna"}, {"CNAMEia", "iCNAna" }, {"DATE-AVG","DAVGn"}, {"NAXISi", "-" }, /* Remove structural keywords*/ {"PCOUNT", "-" }, {"GCOUNT", "-" }, {"EXTEND", "-" }, {"EXTNAME", "-" }, {"EXTVER", "-" }, {"EXTLEVEL","-" }, {"CHECKSUM","-" }, {"DATASUM", "-" }, {"*", "+" }}; /* copy all other keywords */ if (*status > 0) return(*status); if (fptr == 0 || newptr == 0) return (*status = NULL_INPUT_PTR); if (ffghdt(fptr, &hdutype, status) > 0) { ffpmsg("could not get input HDU type"); return (*status); } if (hdutype != IMAGE_HDU) { ffpmsg("The input extension is not an image."); ffpmsg(" Cannot open the image."); return(*status = NOT_IMAGE); } if (ffghdt(newptr, &hdutype, status) > 0) { ffpmsg("could not get output HDU type"); return (*status); } if (hdutype != BINARY_TBL) { ffpmsg("The output extension is not a table."); return(*status = NOT_BTABLE); } if (ffgiprll(fptr, 9, &bitpix, &naxis, naxes, status) > 0) { ffpmsg("Could not read image parameters."); return (*status); } /* Determine total number of pixels in the image */ repeat = 1; for (ii = 0; ii < naxis; ii++) repeat *= naxes[ii]; /* Determine the TFORM value for the table cell */ if (bitpix == BYTE_IMG) { typecode = TBYTE; tformchar = 'B'; nbytes = repeat; } else if (bitpix == SHORT_IMG) { typecode = TSHORT; tformchar = 'I'; nbytes = repeat*2; } else if (bitpix == LONG_IMG) { typecode = TLONG; tformchar = 'J'; nbytes = repeat*4; } else if (bitpix == FLOAT_IMG) { typecode = TFLOAT; tformchar = 'E'; nbytes = repeat*4; } else if (bitpix == DOUBLE_IMG) { typecode = TDOUBLE; tformchar = 'D'; nbytes = repeat*8; } else if (bitpix == LONGLONG_IMG) { typecode = TLONGLONG; tformchar = 'K'; nbytes = repeat*8; } else { ffpmsg("Error: the image has an invalid datatype."); return (*status = BAD_BITPIX); } /* get column number */ ffpmrk(); ffgcno(newptr, CASEINSEN, colname, &colnum, status); ffcmrk(); /* Column does not exist; create it */ if (*status) { *status = 0; sprintf(tform, "%.0f%c", (double) repeat, tformchar); ffgncl(newptr, &ncols, status); colnum = ncols+1; fficol(newptr, colnum, colname, tform, status); ffptdmll(newptr, colnum, naxis, naxes, status); if (*status) { ffpmsg("Could not insert new column into output table."); return *status; } } else { ffgtdmll(newptr, colnum, 9, &naxis1, naxes1, status); if (*status > 0 || naxis != naxis1) { ffpmsg("Input image dimensions and output table cell dimensions do not match."); return (*status = BAD_DIMEN); } for (ii=0; ii 0) || (typecode1 != typecode) || (repeat1 != repeat)) { ffpmsg("Input image data type does not match output table cell type."); return (*status = BAD_TFORM); } } /* copy keywords from input image to output table, if required */ if (copykeyflag) { npat = sizeof(patterns)/sizeof(patterns[0][0])/2; if (copykeyflag == 2) { /* copy only the WCS-related keywords */ patterns[npat-1][1] = "-"; } /* The 3rd parameter value = 5 means skip the first 4 keywords in the image */ fits_translate_keywords(fptr, newptr, 5, patterns, npat, colnum, 0, 0, status); } /* Here is all the code to compute offsets: * * byte offset from start of row to column (dest table) * * byte offset from start of file to image data (source image) */ /* Force the writing of the row of the table by writing the last byte of the array, which grows the table, and/or shifts following extensions */ ffpcl(newptr, TBYTE, colnum, rownum, repeat, 1, &dummy, status); /* byte offset within the row to the start of the image column */ colptr = (newptr->Fptr)->tableptr; /* point to first column */ colptr += (colnum - 1); /* offset to correct column structure */ firstbyte = colptr->tbcol + 1; /* get starting address of input image to be read */ ffghadll(fptr, &headstart, &datastart, &dataend, status); imgstart = datastart; sprintf(card, "HISTORY Table column '%s' row %ld copied from image", colname, rownum); /* Don't automatically write History keywords; leave this up to the caller. ffprec(newptr, card, status); */ /* write HISTORY keyword with the file name (this is now disabled)*/ filename[0] = '\0'; hdunum = 0; strcpy(filename, "HISTORY "); ffflnm(fptr, filename+strlen(filename), status); ffghdn(fptr, &hdunum); sprintf(filename+strlen(filename),"[%d]", hdunum-1); /* ffprec(newptr, filename, status); */ /* the use of ffread routine, below, requires that any 'dirty' */ /* buffers in memory be flushed back to the file first */ ffflsh(fptr, FALSE, status); /* move to the first byte of the input image */ ffmbyt(fptr, imgstart, TRUE, status); ntodo = minvalue(30000L, nbytes); ffgbyt(fptr, ntodo, buffer, status); /* read input image */ ffptbb(newptr, rownum, firstbyte, ntodo, buffer, status); /* write to table */ nbytes -= ntodo; firstbyte += ntodo; /* read any additional bytes with low-level ffread routine, for speed */ while (nbytes && (*status <= 0) ) { ntodo = minvalue(30000L, nbytes); ffread(fptr->Fptr, (long) ntodo, buffer, status); ffptbb(newptr, rownum, firstbyte, ntodo, buffer, status); nbytes -= ntodo; firstbyte += ntodo; } /* Re-scan the header so that CFITSIO knows about all the new keywords */ ffrdef(newptr,status); return(*status); } /*--------------------------------------------------------------------------*/ int fits_select_image_section( fitsfile **fptr, /* IO - pointer to input image; on output it */ /* points to the new subimage */ char *outfile, /* I - name for output file */ char *expr, /* I - Image section expression */ int *status) { /* copies an image section from the input file to a new output file. Any HDUs preceding or following the image are also copied to the output file. */ fitsfile *newptr; int ii, hdunum; /* create new empty file to hold the image section */ if (ffinit(&newptr, outfile, status) > 0) { ffpmsg( "failed to create output file for image section:"); ffpmsg(outfile); return(*status); } fits_get_hdu_num(*fptr, &hdunum); /* current HDU number in input file */ /* copy all preceding extensions to the output file, if 'only_one' flag not set */ if (!(((*fptr)->Fptr)->only_one)) { for (ii = 1; ii < hdunum; ii++) { fits_movabs_hdu(*fptr, ii, NULL, status); if (fits_copy_hdu(*fptr, newptr, 0, status) > 0) { ffclos(newptr, status); return(*status); } } /* move back to the original HDU position */ fits_movabs_hdu(*fptr, hdunum, NULL, status); } if (fits_copy_image_section(*fptr, newptr, expr, status) > 0) { ffclos(newptr, status); return(*status); } /* copy any remaining HDUs to the output file, if 'only_one' flag not set */ if (!(((*fptr)->Fptr)->only_one)) { for (ii = hdunum + 1; 1; ii++) { if (fits_movabs_hdu(*fptr, ii, NULL, status) > 0) break; fits_copy_hdu(*fptr, newptr, 0, status); } if (*status == END_OF_FILE) *status = 0; /* got the expected EOF error; reset = 0 */ else if (*status > 0) { ffclos(newptr, status); return(*status); } } else { ii = hdunum + 1; /* this value of ii is required below */ } /* close the original file and return ptr to the new image */ ffclos(*fptr, status); *fptr = newptr; /* reset the pointer to the new table */ /* move back to the image subsection */ if (ii - 1 != hdunum) fits_movabs_hdu(*fptr, hdunum, NULL, status); else { /* may have to reset BSCALE and BZERO pixel scaling, */ /* since the keywords were previously turned off */ if (ffrdef(*fptr, status) > 0) { ffclos(*fptr, status); return(*status); } } return(*status); } /*--------------------------------------------------------------------------*/ int fits_copy_image_section( fitsfile *fptr, /* I - pointer to input image */ fitsfile *newptr, /* I - pointer to output image */ char *expr, /* I - Image section expression */ int *status) { /* copies an image section from the input file to a new output HDU */ int bitpix, naxis, numkeys, nkey; long naxes[] = {1,1,1,1,1,1,1,1,1}, smin, smax, sinc; long fpixels[] = {1,1,1,1,1,1,1,1,1}; long lpixels[] = {1,1,1,1,1,1,1,1,1}; long incs[] = {1,1,1,1,1,1,1,1,1}; char *cptr, keyname[FLEN_KEYWORD], card[FLEN_CARD]; int ii, tstatus, anynull; long minrow, maxrow, minslice, maxslice, mincube, maxcube; long firstpix; long ncubeiter, nsliceiter, nrowiter, kiter, jiter, iiter; int klen, kk, jj; long outnaxes[9], outsize, buffsize; double *buffer, crpix, cdelt; if (*status > 0) return(*status); /* get the size of the input image */ fits_get_img_type(fptr, &bitpix, status); fits_get_img_dim(fptr, &naxis, status); if (fits_get_img_size(fptr, naxis, naxes, status) > 0) return(*status); if (naxis < 1 || naxis > 4) { ffpmsg( "Input image either had NAXIS = 0 (NULL image) or has > 4 dimensions"); return(*status = BAD_NAXIS); } /* create output image with same size and type as the input image */ /* Will update the size later */ fits_create_img(newptr, bitpix, naxis, naxes, status); /* copy all other non-structural keywords from the input to output file */ fits_get_hdrspace(fptr, &numkeys, NULL, status); for (nkey = 4; nkey <= numkeys; nkey++) /* skip the first few keywords */ { fits_read_record(fptr, nkey, card, status); if (fits_get_keyclass(card) > TYP_CMPRS_KEY) { /* write the record to the output file */ fits_write_record(newptr, card, status); } } if (*status > 0) { ffpmsg("error copying header from input image to output image"); return(*status); } /* parse the section specifier to get min, max, and inc for each axis */ /* and the size of each output image axis */ cptr = expr; for (ii=0; ii < naxis; ii++) { if (fits_get_section_range(&cptr, &smin, &smax, &sinc, status) > 0) { ffpmsg("error parsing the following image section specifier:"); ffpmsg(expr); return(*status); } if (smax == 0) smax = naxes[ii]; /* use whole axis by default */ else if (smin == 0) smin = naxes[ii]; /* use inverted whole axis */ if (smin > naxes[ii] || smax > naxes[ii]) { ffpmsg("image section exceeds dimensions of input image:"); ffpmsg(expr); return(*status = BAD_NAXIS); } fpixels[ii] = smin; lpixels[ii] = smax; incs[ii] = sinc; if (smin <= smax) outnaxes[ii] = (smax - smin + sinc) / sinc; else outnaxes[ii] = (smin - smax + sinc) / sinc; /* modify the NAXISn keyword */ fits_make_keyn("NAXIS", ii + 1, keyname, status); fits_modify_key_lng(newptr, keyname, outnaxes[ii], NULL, status); /* modify the WCS keywords if necessary */ if (fpixels[ii] != 1 || incs[ii] != 1) { for (kk=-1;kk<26; kk++) /* modify any alternate WCS keywords */ { /* read the CRPIXn keyword if it exists in the input file */ fits_make_keyn("CRPIX", ii + 1, keyname, status); if (kk != -1) { klen = strlen(keyname); keyname[klen]='A' + kk; keyname[klen + 1] = '\0'; } tstatus = 0; if (fits_read_key(fptr, TDOUBLE, keyname, &crpix, NULL, &tstatus) == 0) { /* calculate the new CRPIXn value */ if (fpixels[ii] <= lpixels[ii]) { crpix = (crpix - (fpixels[ii])) / incs[ii] + 1.0; /* crpix = (crpix - (fpixels[ii] - 1.0) - .5) / incs[ii] + 0.5; */ } else { crpix = (fpixels[ii] - crpix) / incs[ii] + 1.0; /* crpix = (fpixels[ii] - (crpix - 1.0) - .5) / incs[ii] + 0.5; */ } /* modify the value in the output file */ fits_modify_key_dbl(newptr, keyname, crpix, 15, NULL, status); if (incs[ii] != 1 || fpixels[ii] > lpixels[ii]) { /* read the CDELTn keyword if it exists in the input file */ fits_make_keyn("CDELT", ii + 1, keyname, status); if (kk != -1) { klen = strlen(keyname); keyname[klen]='A' + kk; keyname[klen + 1] = '\0'; } tstatus = 0; if (fits_read_key(fptr, TDOUBLE, keyname, &cdelt, NULL, &tstatus) == 0) { /* calculate the new CDELTn value */ if (fpixels[ii] <= lpixels[ii]) cdelt = cdelt * incs[ii]; else cdelt = cdelt * (-incs[ii]); /* modify the value in the output file */ fits_modify_key_dbl(newptr, keyname, cdelt, 15, NULL, status); } /* modify the CDi_j keywords if they exist in the input file */ fits_make_keyn("CD1_", ii + 1, keyname, status); if (kk != -1) { klen = strlen(keyname); keyname[klen]='A' + kk; keyname[klen + 1] = '\0'; } for (jj=0; jj < 9; jj++) /* look for up to 9 dimensions */ { keyname[2] = '1' + jj; tstatus = 0; if (fits_read_key(fptr, TDOUBLE, keyname, &cdelt, NULL, &tstatus) == 0) { /* calculate the new CDi_j value */ if (fpixels[ii] <= lpixels[ii]) cdelt = cdelt * incs[ii]; else cdelt = cdelt * (-incs[ii]); /* modify the value in the output file */ fits_modify_key_dbl(newptr, keyname, cdelt, 15, NULL, status); } } } /* end of if (incs[ii]... loop */ } /* end of fits_read_key loop */ } /* end of for (kk loop */ } } /* end of main NAXIS loop */ if (ffrdef(newptr, status) > 0) /* force the header to be scanned */ { return(*status); } /* turn off any scaling of the pixel values */ fits_set_bscale(fptr, 1.0, 0.0, status); fits_set_bscale(newptr, 1.0, 0.0, status); /* to reduce memory foot print, just read/write image 1 row at a time */ outsize = outnaxes[0]; buffsize = (abs(bitpix) / 8) * outsize; buffer = (double *) malloc(buffsize); /* allocate memory for the image row */ if (!buffer) { ffpmsg("fits_copy_image_section: no memory for image section"); return(*status = MEMORY_ALLOCATION); } /* read the image section then write it to the output file */ minrow = fpixels[1]; maxrow = lpixels[1]; if (minrow > maxrow) { nrowiter = (minrow - maxrow + incs[1]) / incs[1]; } else { nrowiter = (maxrow - minrow + incs[1]) / incs[1]; } minslice = fpixels[2]; maxslice = lpixels[2]; if (minslice > maxslice) { nsliceiter = (minslice - maxslice + incs[2]) / incs[2]; } else { nsliceiter = (maxslice - minslice + incs[2]) / incs[2]; } mincube = fpixels[3]; maxcube = lpixels[3]; if (mincube > maxcube) { ncubeiter = (mincube - maxcube + incs[3]) / incs[3]; } else { ncubeiter = (maxcube - mincube + incs[3]) / incs[3]; } firstpix = 1; for (kiter = 0; kiter < ncubeiter; kiter++) { if (mincube > maxcube) { fpixels[3] = mincube - (kiter * incs[3]); } else { fpixels[3] = mincube + (kiter * incs[3]); } lpixels[3] = fpixels[3]; for (jiter = 0; jiter < nsliceiter; jiter++) { if (minslice > maxslice) { fpixels[2] = minslice - (jiter * incs[2]); } else { fpixels[2] = minslice + (jiter * incs[2]); } lpixels[2] = fpixels[2]; for (iiter = 0; iiter < nrowiter; iiter++) { if (minrow > maxrow) { fpixels[1] = minrow - (iiter * incs[1]); } else { fpixels[1] = minrow + (iiter * incs[1]); } lpixels[1] = fpixels[1]; if (bitpix == 8) { ffgsvb(fptr, 1, naxis, naxes, fpixels, lpixels, incs, 0, (unsigned char *) buffer, &anynull, status); ffpprb(newptr, 1, firstpix, outsize, (unsigned char *) buffer, status); } else if (bitpix == 16) { ffgsvi(fptr, 1, naxis, naxes, fpixels, lpixels, incs, 0, (short *) buffer, &anynull, status); ffppri(newptr, 1, firstpix, outsize, (short *) buffer, status); } else if (bitpix == 32) { ffgsvk(fptr, 1, naxis, naxes, fpixels, lpixels, incs, 0, (int *) buffer, &anynull, status); ffpprk(newptr, 1, firstpix, outsize, (int *) buffer, status); } else if (bitpix == -32) { ffgsve(fptr, 1, naxis, naxes, fpixels, lpixels, incs, FLOATNULLVALUE, (float *) buffer, &anynull, status); ffppne(newptr, 1, firstpix, outsize, (float *) buffer, FLOATNULLVALUE, status); } else if (bitpix == -64) { ffgsvd(fptr, 1, naxis, naxes, fpixels, lpixels, incs, DOUBLENULLVALUE, buffer, &anynull, status); ffppnd(newptr, 1, firstpix, outsize, buffer, DOUBLENULLVALUE, status); } else if (bitpix == 64) { ffgsvjj(fptr, 1, naxis, naxes, fpixels, lpixels, incs, 0, (LONGLONG *) buffer, &anynull, status); ffpprjj(newptr, 1, firstpix, outsize, (LONGLONG *) buffer, status); } firstpix += outsize; } } } free(buffer); /* finished with the memory */ if (*status > 0) { ffpmsg("fits_copy_image_section: error copying image section"); return(*status); } return(*status); } /*--------------------------------------------------------------------------*/ int fits_get_section_range(char **ptr, long *secmin, long *secmax, long *incre, int *status) /* Parse the input image section specification string, returning the min, max and increment values. Typical string = "1:512:2" or "1:512" */ { int slen, isanumber; char token[FLEN_VALUE]; if (*status > 0) return(*status); slen = fits_get_token(ptr, " ,:", token, &isanumber); /* get 1st token */ /* support [:2,:2] type syntax, where the leading * is implied */ if (slen==0) strcpy(token,"*"); if (*token == '*') /* wild card means to use the whole range */ { *secmin = 1; *secmax = 0; } else if (*token == '-' && *(token+1) == '*' ) /* invert the whole range */ { *secmin = 0; *secmax = 1; } else { if (slen == 0 || !isanumber || **ptr != ':') return(*status = URL_PARSE_ERROR); /* the token contains the min value */ *secmin = atol(token); (*ptr)++; /* skip the colon between the min and max values */ slen = fits_get_token(ptr, " ,:", token, &isanumber); /* get token */ if (slen == 0 || !isanumber) return(*status = URL_PARSE_ERROR); /* the token contains the max value */ *secmax = atol(token); } if (**ptr == ':') { (*ptr)++; /* skip the colon between the max and incre values */ slen = fits_get_token(ptr, " ,", token, &isanumber); /* get token */ if (slen == 0 || !isanumber) return(*status = URL_PARSE_ERROR); *incre = atol(token); } else *incre = 1; /* default increment if none is supplied */ if (**ptr == ',') (*ptr)++; while (**ptr == ' ') /* skip any trailing blanks */ (*ptr)++; if (*secmin < 0 || *secmax < 0 || *incre < 1) *status = URL_PARSE_ERROR; return(*status); } /*--------------------------------------------------------------------------*/ int ffselect_table( fitsfile **fptr, /* IO - pointer to input table; on output it */ /* points to the new selected rows table */ char *outfile, /* I - name for output file */ char *expr, /* I - Boolean expression */ int *status) { fitsfile *newptr; int ii, hdunum; if (*outfile) { /* create new empty file in to hold the selected rows */ if (ffinit(&newptr, outfile, status) > 0) { ffpmsg( "failed to create file for selected rows from input table"); ffpmsg(outfile); return(*status); } fits_get_hdu_num(*fptr, &hdunum); /* current HDU number in input file */ /* copy all preceding extensions to the output file, if the 'only_one' flag is not set */ if (!((*fptr)->Fptr)->only_one) { for (ii = 1; ii < hdunum; ii++) { fits_movabs_hdu(*fptr, ii, NULL, status); if (fits_copy_hdu(*fptr, newptr, 0, status) > 0) { ffclos(newptr, status); return(*status); } } } else { /* just copy the primary array */ fits_movabs_hdu(*fptr, 1, NULL, status); if (fits_copy_hdu(*fptr, newptr, 0, status) > 0) { ffclos(newptr, status); return(*status); } } fits_movabs_hdu(*fptr, hdunum, NULL, status); /* copy all the header keywords from the input to output file */ if (fits_copy_header(*fptr, newptr, status) > 0) { ffclos(newptr, status); return(*status); } /* set number of rows = 0 */ fits_modify_key_lng(newptr, "NAXIS2", 0, NULL,status); (newptr->Fptr)->numrows = 0; (newptr->Fptr)->origrows = 0; if (ffrdef(newptr, status) > 0) /* force the header to be scanned */ { ffclos(newptr, status); return(*status); } } else newptr = *fptr; /* will delete rows in place in the table */ /* copy rows which satisfy the selection expression to the output table */ /* or delete the nonqualifying rows if *fptr = newptr. */ if (fits_select_rows(*fptr, newptr, expr, status) > 0) { if (*outfile) ffclos(newptr, status); return(*status); } if (*outfile) { /* copy any remaining HDUs to the output copy */ if (!((*fptr)->Fptr)->only_one) { for (ii = hdunum + 1; 1; ii++) { if (fits_movabs_hdu(*fptr, ii, NULL, status) > 0) break; fits_copy_hdu(*fptr, newptr, 0, status); } if (*status == END_OF_FILE) *status = 0; /* got the expected EOF error; reset = 0 */ else if (*status > 0) { ffclos(newptr, status); return(*status); } } else { hdunum = 2; } /* close the original file and return ptr to the new image */ ffclos(*fptr, status); *fptr = newptr; /* reset the pointer to the new table */ /* move back to the selected table HDU */ fits_movabs_hdu(*fptr, hdunum, NULL, status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffparsecompspec(fitsfile *fptr, /* I - FITS file pointer */ char *compspec, /* I - image compression specification */ int *status) /* IO - error status */ /* Parse the image compression specification that was give in square brackets following the output FITS file name, as in these examples: myfile.fits[compress] - default Rice compression, row by row myfile.fits[compress TYPE] - the first letter of TYPE defines the compression algorithm: R = Rice G = GZIP H = HCOMPRESS HS = HCOMPRESS (with smoothing) B - BZIP2 P = PLIO myfile.fits[compress TYPE 100,100] - the numbers give the dimensions of the compression tiles. Default is NAXIS1, 1, 1, ... other optional parameters may be specified following a semi-colon myfile.fits[compress; q 8.0] q specifies the floating point mufile.fits[compress TYPE; q -.0002] quantization level; myfile.fits[compress TYPE 100,100; q 10, s 25] s specifies the HCOMPRESS integer scaling parameter The compression parameters are saved in the fptr->Fptr structure for use when writing FITS images. */ { char *ptr1; /* initialize with default values */ int ii, compresstype = RICE_1, smooth = 0; int quantize_method = SUBTRACTIVE_DITHER_1; long tilesize[MAX_COMPRESS_DIM] = {0,0,0,0,0,0}; float qlevel = -99., scale = 0.; ptr1 = compspec; while (*ptr1 == ' ') /* ignore leading blanks */ ptr1++; if (strncmp(ptr1, "compress", 8) && strncmp(ptr1, "COMPRESS", 8) ) { /* apparently this string does not specify compression parameters */ return(*status = URL_PARSE_ERROR); } ptr1 += 8; while (*ptr1 == ' ') /* ignore leading blanks */ ptr1++; /* ========================= */ /* look for compression type */ /* ========================= */ if (*ptr1 == 'r' || *ptr1 == 'R') { compresstype = RICE_1; while (*ptr1 != ' ' && *ptr1 != ';' && *ptr1 != '\0') ptr1++; } else if (*ptr1 == 'g' || *ptr1 == 'G') { compresstype = GZIP_1; while (*ptr1 != ' ' && *ptr1 != ';' && *ptr1 != '\0') ptr1++; } /* else if (*ptr1 == 'b' || *ptr1 == 'B') { compresstype = BZIP2_1; while (*ptr1 != ' ' && *ptr1 != ';' && *ptr1 != '\0') ptr1++; } */ else if (*ptr1 == 'p' || *ptr1 == 'P') { compresstype = PLIO_1; while (*ptr1 != ' ' && *ptr1 != ';' && *ptr1 != '\0') ptr1++; } else if (*ptr1 == 'h' || *ptr1 == 'H') { compresstype = HCOMPRESS_1; ptr1++; if (*ptr1 == 's' || *ptr1 == 'S') smooth = 1; /* apply smoothing when uncompressing HCOMPRESSed image */ while (*ptr1 != ' ' && *ptr1 != ';' && *ptr1 != '\0') ptr1++; } /* ======================== */ /* look for tile dimensions */ /* ======================== */ while (*ptr1 == ' ') /* ignore leading blanks */ ptr1++; ii = 0; while (isdigit( (int) *ptr1) && ii < 9) { tilesize[ii] = atol(ptr1); /* read the integer value */ ii++; while (isdigit((int) *ptr1)) /* skip over the integer */ ptr1++; if (*ptr1 == ',') ptr1++; /* skip over the comma */ while (*ptr1 == ' ') /* ignore leading blanks */ ptr1++; } /* ========================================================= */ /* look for semi-colon, followed by other optional parameters */ /* ========================================================= */ if (*ptr1 == ';') { ptr1++; while (*ptr1 == ' ') /* ignore leading blanks */ ptr1++; while (*ptr1 != 0) { /* haven't reached end of string yet */ if (*ptr1 == 's' || *ptr1 == 'S') { /* this should be the HCOMPRESS "scale" parameter; default = 1 */ ptr1++; while (*ptr1 == ' ') /* ignore leading blanks */ ptr1++; scale = (float) strtod(ptr1, &ptr1); while (*ptr1 == ' ' || *ptr1 == ',') /* skip over blanks or comma */ ptr1++; } else if (*ptr1 == 'q' || *ptr1 == 'Q') { /* this should be the floating point quantization parameter */ ptr1++; if (*ptr1 == 'z' || *ptr1 == 'Z') { /* use the subtractive_dither_2 option */ quantize_method = SUBTRACTIVE_DITHER_2; ptr1++; } else if (*ptr1 == '0') { /* do not dither */ quantize_method = NO_DITHER; ptr1++; } while (*ptr1 == ' ') /* ignore leading blanks */ ptr1++; qlevel = (float) strtod(ptr1, &ptr1); while (*ptr1 == ' ' || *ptr1 == ',') /* skip over blanks or comma */ ptr1++; } else { return(*status = URL_PARSE_ERROR); } } } /* ================================= */ /* finished parsing; save the values */ /* ================================= */ fits_set_compression_type(fptr, compresstype, status); fits_set_tile_dim(fptr, MAX_COMPRESS_DIM, tilesize, status); if (compresstype == HCOMPRESS_1) { fits_set_hcomp_scale (fptr, scale, status); fits_set_hcomp_smooth(fptr, smooth, status); } if (qlevel != -99.) { fits_set_quantize_level(fptr, qlevel, status); fits_set_quantize_method(fptr, quantize_method, status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffdkinit(fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - name of file to create */ int *status) /* IO - error status */ /* Create and initialize a new FITS file on disk. This routine differs from ffinit in that the input 'name' is literally taken as the name of the disk file to be created, and it does not support CFITSIO's extended filename syntax. */ { if (*status > 0) return(*status); *status = CREATE_DISK_FILE; ffinit(fptr, name,status); return(*status); } /*--------------------------------------------------------------------------*/ int ffinit(fitsfile **fptr, /* O - FITS file pointer */ const char *name, /* I - name of file to create */ int *status) /* IO - error status */ /* Create and initialize a new FITS file. */ { int ii, driver, slen, clobber = 0; char *url; char urltype[MAX_PREFIX_LEN], outfile[FLEN_FILENAME]; char tmplfile[FLEN_FILENAME], compspec[80]; int handle, create_disk_file = 0; if (*status > 0) return(*status); if (*status == CREATE_DISK_FILE) { create_disk_file = 1; *status = 0; } *fptr = 0; /* initialize null file pointer */ if (need_to_initialize) { /* this is called only once */ *status = fits_init_cfitsio(); } if (*status > 0) return(*status); url = (char *) name; while (*url == ' ') /* ignore leading spaces in the filename */ url++; if (*url == '\0') { ffpmsg("Name of file to create is blank. (ffinit)"); return(*status = FILE_NOT_CREATED); } if (create_disk_file) { if (strlen(url) > FLEN_FILENAME - 1) { ffpmsg("Filename is too long. (ffinit)"); return(*status = FILE_NOT_CREATED); } strcpy(outfile, url); strcpy(urltype, "file://"); tmplfile[0] = '\0'; compspec[0] = '\0'; } else { /* check for clobber symbol, i.e, overwrite existing file */ if (*url == '!') { clobber = TRUE; url++; } else clobber = FALSE; /* parse the output file specification */ /* this routine checks that the strings will not overflow */ ffourl(url, urltype, outfile, tmplfile, compspec, status); if (*status > 0) { ffpmsg("could not parse the output filename: (ffinit)"); ffpmsg(url); return(*status); } } /* find which driver corresponds to the urltype */ *status = urltype2driver(urltype, &driver); if (*status) { ffpmsg("could not find driver for this file: (ffinit)"); ffpmsg(url); return(*status); } /* delete pre-existing file, if asked to do so */ if (clobber) { if (driverTable[driver].remove) (*driverTable[driver].remove)(outfile); } /* call appropriate driver to create the file */ if (driverTable[driver].create) { FFLOCK; /* lock this while searching for vacant handle */ *status = (*driverTable[driver].create)(outfile, &handle); FFUNLOCK; if (*status) { ffpmsg("failed to create new file (already exists?):"); ffpmsg(url); return(*status); } } else { ffpmsg("cannot create a new file of this type: (ffinit)"); ffpmsg(url); return(*status = FILE_NOT_CREATED); } /* allocate fitsfile structure and initialize = 0 */ *fptr = (fitsfile *) calloc(1, sizeof(fitsfile)); if (!(*fptr)) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate structure for following file: (ffopen)"); ffpmsg(url); return(*status = MEMORY_ALLOCATION); } /* allocate FITSfile structure and initialize = 0 */ (*fptr)->Fptr = (FITSfile *) calloc(1, sizeof(FITSfile)); if (!((*fptr)->Fptr)) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate structure for following file: (ffopen)"); ffpmsg(url); free(*fptr); *fptr = 0; return(*status = MEMORY_ALLOCATION); } slen = strlen(url) + 1; slen = maxvalue(slen, 32); /* reserve at least 32 chars */ ((*fptr)->Fptr)->filename = (char *) malloc(slen); /* mem for file name */ if ( !(((*fptr)->Fptr)->filename) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for filename: (ffinit)"); ffpmsg(url); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = FILE_NOT_CREATED); } /* mem for headstart array */ ((*fptr)->Fptr)->headstart = (LONGLONG *) calloc(1001, sizeof(LONGLONG)); if ( !(((*fptr)->Fptr)->headstart) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for headstart array: (ffinit)"); ffpmsg(url); free( ((*fptr)->Fptr)->filename); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* mem for file I/O buffers */ ((*fptr)->Fptr)->iobuffer = (char *) calloc(NIOBUF, IOBUFLEN); if ( !(((*fptr)->Fptr)->iobuffer) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for iobuffer array: (ffinit)"); ffpmsg(url); free( ((*fptr)->Fptr)->headstart); /* free memory for headstart array */ free( ((*fptr)->Fptr)->filename); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* initialize the ageindex array (relative age of the I/O buffers) */ /* and initialize the bufrecnum array as being empty */ for (ii = 0; ii < NIOBUF; ii++) { ((*fptr)->Fptr)->ageindex[ii] = ii; ((*fptr)->Fptr)->bufrecnum[ii] = -1; } /* store the parameters describing the file */ ((*fptr)->Fptr)->MAXHDU = 1000; /* initial size of headstart */ ((*fptr)->Fptr)->filehandle = handle; /* store the file pointer */ ((*fptr)->Fptr)->driver = driver; /* driver number */ strcpy(((*fptr)->Fptr)->filename, url); /* full input filename */ ((*fptr)->Fptr)->filesize = 0; /* physical file size */ ((*fptr)->Fptr)->logfilesize = 0; /* logical file size */ ((*fptr)->Fptr)->writemode = 1; /* read-write mode */ ((*fptr)->Fptr)->datastart = DATA_UNDEFINED; /* unknown start of data */ ((*fptr)->Fptr)->curbuf = -1; /* undefined current IO buffer */ ((*fptr)->Fptr)->open_count = 1; /* structure is currently used once */ ((*fptr)->Fptr)->validcode = VALIDSTRUC; /* flag denoting valid structure */ ffldrc(*fptr, 0, IGNORE_EOF, status); /* initialize first record */ fits_store_Fptr( (*fptr)->Fptr, status); /* store Fptr address */ /* if template file was given, use it to define structure of new file */ if (tmplfile[0]) ffoptplt(*fptr, tmplfile, status); /* parse and save image compression specification, if given */ if (compspec[0]) ffparsecompspec(*fptr, compspec, status); return(*status); /* successful return */ } /*--------------------------------------------------------------------------*/ /* ffimem == fits_create_memfile */ int ffimem(fitsfile **fptr, /* O - FITS file pointer */ void **buffptr, /* I - address of memory pointer */ size_t *buffsize, /* I - size of buffer, in bytes */ size_t deltasize, /* I - increment for future realloc's */ void *(*mem_realloc)(void *p, size_t newsize), /* function */ int *status) /* IO - error status */ /* Create and initialize a new FITS file in memory */ { int ii, driver, slen; char urltype[MAX_PREFIX_LEN]; int handle; if (*status > 0) return(*status); *fptr = 0; /* initialize null file pointer */ if (need_to_initialize) { /* this is called only once */ *status = fits_init_cfitsio(); } if (*status > 0) return(*status); strcpy(urltype, "memkeep://"); /* URL type for pre-existing memory file */ *status = urltype2driver(urltype, &driver); if (*status > 0) { ffpmsg("could not find driver for pre-existing memory file: (ffimem)"); return(*status); } /* call driver routine to "open" the memory file */ FFLOCK; /* lock this while searching for vacant handle */ *status = mem_openmem( buffptr, buffsize, deltasize, mem_realloc, &handle); FFUNLOCK; if (*status > 0) { ffpmsg("failed to open pre-existing memory file: (ffimem)"); return(*status); } /* allocate fitsfile structure and initialize = 0 */ *fptr = (fitsfile *) calloc(1, sizeof(fitsfile)); if (!(*fptr)) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate structure for memory file: (ffimem)"); return(*status = MEMORY_ALLOCATION); } /* allocate FITSfile structure and initialize = 0 */ (*fptr)->Fptr = (FITSfile *) calloc(1, sizeof(FITSfile)); if (!((*fptr)->Fptr)) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate structure for memory file: (ffimem)"); free(*fptr); *fptr = 0; return(*status = MEMORY_ALLOCATION); } slen = 32; /* reserve at least 32 chars */ ((*fptr)->Fptr)->filename = (char *) malloc(slen); /* mem for file name */ if ( !(((*fptr)->Fptr)->filename) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for filename: (ffimem)"); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* mem for headstart array */ ((*fptr)->Fptr)->headstart = (LONGLONG *) calloc(1001, sizeof(LONGLONG)); if ( !(((*fptr)->Fptr)->headstart) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for headstart array: (ffimem)"); free( ((*fptr)->Fptr)->filename); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* mem for file I/O buffers */ ((*fptr)->Fptr)->iobuffer = (char *) calloc(NIOBUF, IOBUFLEN); if ( !(((*fptr)->Fptr)->iobuffer) ) { (*driverTable[driver].close)(handle); /* close the file */ ffpmsg("failed to allocate memory for iobuffer array: (ffimem)"); free( ((*fptr)->Fptr)->headstart); /* free memory for headstart array */ free( ((*fptr)->Fptr)->filename); free((*fptr)->Fptr); free(*fptr); *fptr = 0; /* return null file pointer */ return(*status = MEMORY_ALLOCATION); } /* initialize the ageindex array (relative age of the I/O buffers) */ /* and initialize the bufrecnum array as being empty */ for (ii = 0; ii < NIOBUF; ii++) { ((*fptr)->Fptr)->ageindex[ii] = ii; ((*fptr)->Fptr)->bufrecnum[ii] = -1; } /* store the parameters describing the file */ ((*fptr)->Fptr)->MAXHDU = 1000; /* initial size of headstart */ ((*fptr)->Fptr)->filehandle = handle; /* file handle */ ((*fptr)->Fptr)->driver = driver; /* driver number */ strcpy(((*fptr)->Fptr)->filename, "memfile"); /* dummy filename */ ((*fptr)->Fptr)->filesize = *buffsize; /* physical file size */ ((*fptr)->Fptr)->logfilesize = *buffsize; /* logical file size */ ((*fptr)->Fptr)->writemode = 1; /* read-write mode */ ((*fptr)->Fptr)->datastart = DATA_UNDEFINED; /* unknown start of data */ ((*fptr)->Fptr)->curbuf = -1; /* undefined current IO buffer */ ((*fptr)->Fptr)->open_count = 1; /* structure is currently used once */ ((*fptr)->Fptr)->validcode = VALIDSTRUC; /* flag denoting valid structure */ ffldrc(*fptr, 0, IGNORE_EOF, status); /* initialize first record */ fits_store_Fptr( (*fptr)->Fptr, status); /* store Fptr address */ return(*status); } /*--------------------------------------------------------------------------*/ int fits_init_cfitsio(void) /* initialize anything that is required before using the CFITSIO routines */ { int status; union u_tag { short ival; char cval[2]; } u; fitsio_init_lock(); FFLOCK; /* lockout other threads while executing this critical */ /* section of code */ if (need_to_initialize == 0) { /* already initialized? */ FFUNLOCK; return(0); } /* test for correct byteswapping. */ u.ival = 1; if ((BYTESWAPPED && u.cval[0] != 1) || (BYTESWAPPED == FALSE && u.cval[1] != 1) ) { printf ("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); printf(" Byteswapping is not being done correctly on this system.\n"); printf(" Check the MACHINE and BYTESWAPPED definitions in fitsio2.h\n"); printf(" Please report this problem to the CFITSIO developers.\n"); printf( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); FFUNLOCK; return(1); } /* test that LONGLONG is an 8 byte integer */ if (sizeof(LONGLONG) != 8) { printf ("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); printf(" CFITSIO did not find an 8-byte long integer data type.\n"); printf(" sizeof(LONGLONG) = %d\n",(int)sizeof(LONGLONG)); printf(" Please report this problem to the CFITSIO developers.\n"); printf( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); FFUNLOCK; return(1); } /* register the standard I/O drivers that are always available */ /* 1--------------------disk file driver-----------------------*/ status = fits_register_driver("file://", file_init, file_shutdown, file_setoptions, file_getoptions, file_getversion, file_checkfile, file_open, file_create, #ifdef HAVE_FTRUNCATE file_truncate, #else NULL, /* no file truncate function */ #endif file_close, file_remove, file_size, file_flush, file_seek, file_read, file_write); if (status) { ffpmsg("failed to register the file:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 2------------ output temporary memory file driver ----------------*/ status = fits_register_driver("mem://", mem_init, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ NULL, /* open function not allowed */ mem_create, mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the mem:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 3--------------input pre-existing memory file driver----------------*/ status = fits_register_driver("memkeep://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ NULL, /* file open driver function is not used */ NULL, /* create function not allowed */ mem_truncate, mem_close_keep, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the memkeep:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 4-------------------stdin stream driver----------------------*/ /* the stdin stream is copied to memory then opened in memory */ status = fits_register_driver("stdin://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, stdin_checkfile, stdin_open, NULL, /* create function not allowed */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the stdin:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 5-------------------stdin file stream driver----------------------*/ /* the stdin stream is copied to a disk file then the disk file is opened */ status = fits_register_driver("stdinfile://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ stdin_open, NULL, /* create function not allowed */ #ifdef HAVE_FTRUNCATE file_truncate, #else NULL, /* no file truncate function */ #endif file_close, file_remove, file_size, file_flush, file_seek, file_read, file_write); if (status) { ffpmsg("failed to register the stdinfile:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 6-----------------------stdout stream driver------------------*/ status = fits_register_driver("stdout://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ NULL, /* open function not required */ mem_create, mem_truncate, stdout_close, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the stdout:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 7------------------iraf disk file to memory driver -----------*/ status = fits_register_driver("irafmem://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ mem_iraf_open, NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the irafmem:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 8------------------raw binary file to memory driver -----------*/ status = fits_register_driver("rawfile://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ mem_rawfile_open, NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the rawfile:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 9------------------compressed disk file to memory driver -----------*/ status = fits_register_driver("compress://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ mem_compress_open, NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the compress:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 10------------------compressed disk file to memory driver -----------*/ /* Identical to compress://, except it allows READWRITE access */ status = fits_register_driver("compressmem://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ mem_compress_openrw, NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the compressmem:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 11------------------compressed disk file to disk file driver -------*/ status = fits_register_driver("compressfile://", NULL, file_shutdown, file_setoptions, file_getoptions, file_getversion, NULL, /* checkfile not needed */ file_compress_open, file_create, #ifdef HAVE_FTRUNCATE file_truncate, #else NULL, /* no file truncate function */ #endif file_close, file_remove, file_size, file_flush, file_seek, file_read, file_write); if (status) { ffpmsg("failed to register the compressfile:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 12---create file in memory, then compress it to disk file on close--*/ status = fits_register_driver("compressoutfile://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ NULL, /* open function not allowed */ mem_create_comp, mem_truncate, mem_close_comp, file_remove, /* delete existing compressed disk file */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg( "failed to register the compressoutfile:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* Register Optional drivers */ #ifdef HAVE_NET_SERVICES /* 13--------------------root driver-----------------------*/ status = fits_register_driver("root://", root_init, root_shutdown, root_setoptions, root_getoptions, root_getversion, NULL, /* checkfile not needed */ root_open, root_create, NULL, /* No truncate possible */ root_close, NULL, /* No remove possible */ root_size, /* no size possible */ root_flush, root_seek, /* Though will always succeed */ root_read, root_write); if (status) { ffpmsg("failed to register the root:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 14--------------------http driver-----------------------*/ status = fits_register_driver("http://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, http_checkfile, http_open, NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the http:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 15--------------------http file driver-----------------------*/ status = fits_register_driver("httpfile://", NULL, file_shutdown, file_setoptions, file_getoptions, file_getversion, NULL, /* checkfile not needed */ http_file_open, file_create, #ifdef HAVE_FTRUNCATE file_truncate, #else NULL, /* no file truncate function */ #endif file_close, file_remove, file_size, file_flush, file_seek, file_read, file_write); if (status) { ffpmsg("failed to register the httpfile:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 16--------------------http memory driver-----------------------*/ /* same as http:// driver, except memory file can be opened READWRITE */ status = fits_register_driver("httpmem://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, http_checkfile, http_file_open, /* this will simply call http_open */ NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the httpmem:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 17--------------------httpcompress file driver-----------------------*/ status = fits_register_driver("httpcompress://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ http_compress_open, NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the httpcompress:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 18--------------------ftp driver-----------------------*/ status = fits_register_driver("ftp://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, ftp_checkfile, ftp_open, NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the ftp:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 19--------------------ftp file driver-----------------------*/ status = fits_register_driver("ftpfile://", NULL, file_shutdown, file_setoptions, file_getoptions, file_getversion, NULL, /* checkfile not needed */ ftp_file_open, file_create, #ifdef HAVE_FTRUNCATE file_truncate, #else NULL, /* no file truncate function */ #endif file_close, file_remove, file_size, file_flush, file_seek, file_read, file_write); if (status) { ffpmsg("failed to register the ftpfile:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 20--------------------ftp mem driver-----------------------*/ /* same as ftp:// driver, except memory file can be opened READWRITE */ status = fits_register_driver("ftpmem://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, ftp_checkfile, ftp_file_open, /* this will simply call ftp_open */ NULL, /* create function not required */ mem_truncate, mem_close_free, NULL, /* remove function not required */ mem_size, NULL, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the ftpmem:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* 21--------------------ftp compressed file driver------------------*/ status = fits_register_driver("ftpcompress://", NULL, mem_shutdown, mem_setoptions, mem_getoptions, mem_getversion, NULL, /* checkfile not needed */ ftp_compress_open, 0, /* create function not required */ mem_truncate, mem_close_free, 0, /* remove function not required */ mem_size, 0, /* flush function not required */ mem_seek, mem_read, mem_write); if (status) { ffpmsg("failed to register the ftpcompress:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* === End of net drivers section === */ #endif /* ==================== SHARED MEMORY DRIVER SECTION ======================= */ #ifdef HAVE_SHMEM_SERVICES /* 22--------------------shared memory driver-----------------------*/ status = fits_register_driver("shmem://", smem_init, smem_shutdown, smem_setoptions, smem_getoptions, smem_getversion, NULL, /* checkfile not needed */ smem_open, smem_create, NULL, /* truncate file not supported yet */ smem_close, smem_remove, smem_size, smem_flush, smem_seek, smem_read, smem_write ); if (status) { ffpmsg("failed to register the shmem:// driver (init_cfitsio)"); FFUNLOCK; return(status); } #endif /* ==================== END OF SHARED MEMORY DRIVER SECTION ================ */ #ifdef HAVE_GSIFTP /* 23--------------------gsiftp driver-----------------------*/ status = fits_register_driver("gsiftp://", gsiftp_init, gsiftp_shutdown, gsiftp_setoptions, gsiftp_getoptions, gsiftp_getversion, gsiftp_checkfile, gsiftp_open, gsiftp_create, #ifdef HAVE_FTRUNCATE gsiftp_truncate, #else NULL, #endif gsiftp_close, NULL, /* remove function not yet implemented */ gsiftp_size, gsiftp_flush, gsiftp_seek, gsiftp_read, gsiftp_write); if (status) { ffpmsg("failed to register the gsiftp:// driver (init_cfitsio)"); FFUNLOCK; return(status); } #endif /* 24---------------stdin and stdout stream driver-------------------*/ status = fits_register_driver("stream://", NULL, NULL, NULL, NULL, NULL, NULL, stream_open, stream_create, NULL, /* no stream truncate function */ stream_close, NULL, /* no stream remove */ stream_size, stream_flush, stream_seek, stream_read, stream_write); if (status) { ffpmsg("failed to register the stream:// driver (init_cfitsio)"); FFUNLOCK; return(status); } /* reset flag. Any other threads will now not need to call this routine */ need_to_initialize = 0; FFUNLOCK; return(status); } /*--------------------------------------------------------------------------*/ int fits_register_driver(char *prefix, int (*init)(void), int (*shutdown)(void), int (*setoptions)(int option), int (*getoptions)(int *options), int (*getversion)(int *version), int (*checkfile) (char *urltype, char *infile, char *outfile), int (*open)(char *filename, int rwmode, int *driverhandle), int (*create)(char *filename, int *driverhandle), int (*truncate)(int driverhandle, LONGLONG filesize), int (*close)(int driverhandle), int (*fremove)(char *filename), int (*size)(int driverhandle, LONGLONG *size), int (*flush)(int driverhandle), int (*seek)(int driverhandle, LONGLONG offset), int (*read) (int driverhandle, void *buffer, long nbytes), int (*write)(int driverhandle, void *buffer, long nbytes) ) /* register all the functions needed to support an I/O driver */ { int status; if (no_of_drivers < 0 ) { /* This is bad. looks like memory has been corrupted. */ ffpmsg("Vital CFITSIO parameters held in memory have been corrupted!!"); ffpmsg("Fatal condition detected in fits_register_driver."); return(TOO_MANY_DRIVERS); } if (no_of_drivers + 1 > MAX_DRIVERS) return(TOO_MANY_DRIVERS); if (prefix == NULL) return(BAD_URL_PREFIX); if (init != NULL) { status = (*init)(); /* initialize the driver */ if (status) return(status); } /* fill in data in table */ strncpy(driverTable[no_of_drivers].prefix, prefix, MAX_PREFIX_LEN); driverTable[no_of_drivers].prefix[MAX_PREFIX_LEN - 1] = 0; driverTable[no_of_drivers].init = init; driverTable[no_of_drivers].shutdown = shutdown; driverTable[no_of_drivers].setoptions = setoptions; driverTable[no_of_drivers].getoptions = getoptions; driverTable[no_of_drivers].getversion = getversion; driverTable[no_of_drivers].checkfile = checkfile; driverTable[no_of_drivers].open = open; driverTable[no_of_drivers].create = create; driverTable[no_of_drivers].truncate = truncate; driverTable[no_of_drivers].close = close; driverTable[no_of_drivers].remove = fremove; driverTable[no_of_drivers].size = size; driverTable[no_of_drivers].flush = flush; driverTable[no_of_drivers].seek = seek; driverTable[no_of_drivers].read = read; driverTable[no_of_drivers].write = write; no_of_drivers++; /* increment the number of drivers */ return(0); } /*--------------------------------------------------------------------------*/ /* fits_parse_input_url */ int ffiurl(char *url, /* input filename */ char *urltype, /* e.g., 'file://', 'http://', 'mem://' */ char *infilex, /* root filename (may be complete path) */ char *outfile, /* optional output file name */ char *extspec, /* extension spec: +n or [extname, extver] */ char *rowfilterx, /* boolean row filter expression */ char *binspec, /* histogram binning specifier */ char *colspec, /* column or keyword modifier expression */ int *status) /* parse the input URL into its basic components. This routine does not support the pixfilter or compspec components. */ { return ffifile2(url, urltype, infilex, outfile, extspec, rowfilterx, binspec, colspec, 0, 0, status); } /*--------------------------------------------------------------------------*/ /* fits_parse_input_file */ int ffifile(char *url, /* input filename */ char *urltype, /* e.g., 'file://', 'http://', 'mem://' */ char *infilex, /* root filename (may be complete path) */ char *outfile, /* optional output file name */ char *extspec, /* extension spec: +n or [extname, extver] */ char *rowfilterx, /* boolean row filter expression */ char *binspec, /* histogram binning specifier */ char *colspec, /* column or keyword modifier expression */ char *pixfilter, /* pixel filter expression */ int *status) /* fits_parse_input_filename parse the input URL into its basic components. This routine does not support the compspec component. */ { return ffifile2(url, urltype, infilex, outfile, extspec, rowfilterx, binspec, colspec, pixfilter, 0, status); } /*--------------------------------------------------------------------------*/ int ffifile2(char *url, /* input filename */ char *urltype, /* e.g., 'file://', 'http://', 'mem://' */ char *infilex, /* root filename (may be complete path) */ char *outfile, /* optional output file name */ char *extspec, /* extension spec: +n or [extname, extver] */ char *rowfilterx, /* boolean row filter expression */ char *binspec, /* histogram binning specifier */ char *colspec, /* column or keyword modifier expression */ char *pixfilter, /* pixel filter expression */ char *compspec, /* image compression specification */ int *status) /* fits_parse_input_filename parse the input URL into its basic components. This routine is big and ugly and should be redesigned someday! */ { int ii, jj, slen, infilelen, plus_ext = 0, collen; char *ptr1, *ptr2, *ptr3, *ptr4, *tmptr; int hasAt, hasDot, hasOper, followingOper, spaceTerm, rowFilter; int colStart, binStart, pixStart, compStart; /* must have temporary variable for these, in case inputs are NULL */ char *infile; char *rowfilter; char *tmpstr; if (*status > 0) return(*status); /* Initialize null strings */ if (infilex) *infilex = '\0'; if (urltype) *urltype = '\0'; if (outfile) *outfile = '\0'; if (extspec) *extspec = '\0'; if (binspec) *binspec = '\0'; if (colspec) *colspec = '\0'; if (rowfilterx) *rowfilterx = '\0'; if (pixfilter) *pixfilter = '\0'; if (compspec) *compspec = '\0'; slen = strlen(url); if (slen == 0) /* blank filename ?? */ return(*status); /* allocate memory for 3 strings, each as long as the input url */ infile = (char *) calloc(3, slen + 1); if (!infile) return(*status = MEMORY_ALLOCATION); rowfilter = &infile[slen + 1]; tmpstr = &rowfilter[slen + 1]; ptr1 = url; /* -------------------------------------------------------- */ /* get urltype (e.g., file://, ftp://, http://, etc.) */ /* --------------------------------------------------------- */ if (*ptr1 == '-' && ( *(ptr1 +1) == 0 || *(ptr1 +1) == ' ' || *(ptr1 +1) == '[' || *(ptr1 +1) == '(' ) ) { /* "-" means read file from stdin. Also support "- ", */ /* "-[extname]" and '-(outfile.fits)" but exclude disk file */ /* names that begin with a minus sign, e.g., "-55d33m.fits" */ if (urltype) strcat(urltype, "stdin://"); ptr1++; } else if (!strncasecmp(ptr1, "stdin", 5)) { if (urltype) strcat(urltype, "stdin://"); ptr1 = ptr1 + 5; } else { ptr2 = strstr(ptr1, "://"); ptr3 = strstr(ptr1, "(" ); if (ptr3 && (ptr3 < ptr2) ) { /* the urltype follows a '(' character, so it must apply */ /* to the output file, and is not the urltype of the input file */ ptr2 = 0; /* so reset pointer to zero */ } if (ptr2) /* copy the explicit urltype string */ { if (urltype) strncat(urltype, ptr1, ptr2 - ptr1 + 3); ptr1 = ptr2 + 3; } else if (!strncmp(ptr1, "ftp:", 4) ) { /* the 2 //'s are optional */ if (urltype) strcat(urltype, "ftp://"); ptr1 += 4; } else if (!strncmp(ptr1, "gsiftp:", 7) ) { /* the 2 //'s are optional */ if (urltype) strcat(urltype, "gsiftp://"); ptr1 += 7; } else if (!strncmp(ptr1, "http:", 5) ) { /* the 2 //'s are optional */ if (urltype) strcat(urltype, "http://"); ptr1 += 5; } else if (!strncmp(ptr1, "mem:", 4) ) { /* the 2 //'s are optional */ if (urltype) strcat(urltype, "mem://"); ptr1 += 4; } else if (!strncmp(ptr1, "shmem:", 6) ) { /* the 2 //'s are optional */ if (urltype) strcat(urltype, "shmem://"); ptr1 += 6; } else if (!strncmp(ptr1, "file:", 5) ) { /* the 2 //'s are optional */ if (urltype) strcat(urltype, "file://"); ptr1 += 5; } else /* assume file driver */ { if (urltype) strcat(urltype, "file://"); } } /* ---------------------------------------------------------- If this is a http:// type file, then the cgi file name could include the '[' character, which should not be interpreted as part of CFITSIO's Extended File Name Syntax. Test for this case by seeing if the last character is a ']' or ')'. If it is not, then just treat the whole input string as the file name and do not attempt to interprete the name using the extended filename syntax. ----------------------------------------------------------- */ if (urltype && !strncmp(urltype, "http://", 7) ) { /* test for opening parenthesis or bracket in the file name */ if( strchr(ptr1, '(' ) || strchr(ptr1, '[' ) ) { slen = strlen(ptr1); ptr3 = ptr1 + slen - 1; while (*ptr3 == ' ') /* ignore trailing blanks */ ptr3--; if (*ptr3 != ']' && *ptr3 != ')' ) { /* name doesn't end with a ']' or ')' so don't try */ /* to parse this unusual string (may be cgi string) */ if (infilex) { if (strlen(ptr1) > FLEN_FILENAME - 1) { ffpmsg("Name of file is too long."); return(*status = URL_PARSE_ERROR); } strcpy(infilex, ptr1); } free(infile); return(*status); } } } /* ---------------------------------------------------------- Look for VMS style filenames like: disk:[directory.subdirectory]filename.ext, or [directory.subdirectory]filename.ext Check if the first character is a '[' and urltype != stdin or if there is a ':[' string in the remaining url string. If so, then need to move past this bracket character before search for the opening bracket of a filter specification. ----------------------------------------------------------- */ tmptr = ptr1; if (*ptr1 == '[') { if (*url != '-') tmptr = ptr1 + 1; /* this bracket encloses a VMS directory name */ } else { tmptr = strstr(ptr1, ":["); if (tmptr) /* these 2 chars are part of the VMS disk and directory */ tmptr += 2; else tmptr = ptr1; } /* ------------------------ */ /* get the input file name */ /* ------------------------ */ ptr2 = strchr(tmptr, '('); /* search for opening parenthesis ( */ ptr3 = strchr(tmptr, '['); /* search for opening bracket [ */ if (ptr2 == ptr3) /* simple case: no [ or ( in the file name */ { strcat(infile, ptr1); } else if (!ptr3 || /* no bracket, so () enclose output file name */ (ptr2 && (ptr2 < ptr3)) ) /* () enclose output name before bracket */ { strncat(infile, ptr1, ptr2 - ptr1); ptr2++; ptr1 = strchr(ptr2, ')' ); /* search for closing ) */ if (!ptr1) { free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ) */ } if (outfile) { if (ptr1 - ptr2 > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strncat(outfile, ptr2, ptr1 - ptr2); } /* the opening [ could have been part of output name, */ /* e.g., file(out[compress])[3][#row > 5] */ /* so search again for opening bracket following the closing ) */ ptr3 = strchr(ptr1, '['); } else /* bracket comes first, so there is no output name */ { strncat(infile, ptr1, ptr3 - ptr1); } /* strip off any trailing blanks in the names */ slen = strlen(infile); while ( (--slen) > 0 && infile[slen] == ' ') infile[slen] = '\0'; if (outfile) { slen = strlen(outfile); while ( (--slen) > 0 && outfile[slen] == ' ') outfile[slen] = '\0'; } /* --------------------------------------------- */ /* check if this is an IRAF file (.imh extension */ /* --------------------------------------------- */ ptr4 = strstr(infile, ".imh"); /* did the infile name end with ".imh" ? */ if (ptr4 && (*(ptr4 + 4) == '\0')) { if (urltype) strcpy(urltype, "irafmem://"); } /* --------------------------------------------- */ /* check if the 'filename+n' convention has been */ /* used to specifiy which HDU number to open */ /* --------------------------------------------- */ jj = strlen(infile); for (ii = jj - 1; ii >= 0; ii--) { if (infile[ii] == '+') /* search backwards for '+' sign */ break; } if (ii > 0 && (jj - ii) < 7) /* limit extension numbers to 5 digits */ { infilelen = ii; ii++; ptr1 = infile+ii; /* pointer to start of sequence */ for (; ii < jj; ii++) { if (!isdigit((int) infile[ii] ) ) /* are all the chars digits? */ break; } if (ii == jj) { /* yes, the '+n' convention was used. Copy */ /* the digits to the output extspec string. */ plus_ext = 1; if (extspec) { if (jj - infilelen > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strncpy(extspec, ptr1, jj - infilelen); } infile[infilelen] = '\0'; /* delete the extension number */ } } /* -------------------------------------------------------------------- */ /* if '*' was given for the output name expand it to the root file name */ /* -------------------------------------------------------------------- */ if (outfile && outfile[0] == '*') { /* scan input name backwards to the first '/' character */ for (ii = jj - 1; ii >= 0; ii--) { if (infile[ii] == '/' || ii == 0) { if (strlen(&infile[ii + 1]) > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strcpy(outfile, &infile[ii + 1]); break; } } } /* ------------------------------------------ */ /* copy strings from local copy to the output */ /* ------------------------------------------ */ if (infilex) { if (strlen(infile) > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strcpy(infilex, infile); } /* ---------------------------------------------------------- */ /* if no '[' character in the input string, then we are done. */ /* ---------------------------------------------------------- */ if (!ptr3) { free(infile); return(*status); } /* ------------------------------------------- */ /* see if [ extension specification ] is given */ /* ------------------------------------------- */ if (!plus_ext) /* extension no. not already specified? Then */ /* first brackets must enclose extension name or # */ /* or it encloses a image subsection specification */ /* or a raw binary image specifier */ /* or a image compression specifier */ /* Or, the extension specification may have been */ /* omitted and we have to guess what the user intended */ { ptr1 = ptr3 + 1; /* pointer to first char after the [ */ ptr2 = strchr(ptr1, ']' ); /* search for closing ] */ if (!ptr2) { ffpmsg("input file URL is missing closing bracket ']'"); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } /* ---------------------------------------------- */ /* First, test if this is a rawfile specifier */ /* which looks something like: '[ib512,512:2880]' */ /* Test if first character is b,i,j,d,r,f, or u, */ /* and optional second character is b or l, */ /* followed by one or more digits, */ /* finally followed by a ',', ':', or ']' */ /* ---------------------------------------------- */ if (*ptr1 == 'b' || *ptr1 == 'B' || *ptr1 == 'i' || *ptr1 == 'I' || *ptr1 == 'j' || *ptr1 == 'J' || *ptr1 == 'd' || *ptr1 == 'D' || *ptr1 == 'r' || *ptr1 == 'R' || *ptr1 == 'f' || *ptr1 == 'F' || *ptr1 == 'u' || *ptr1 == 'U') { /* next optional character may be a b or l (for Big or Little) */ ptr1++; if (*ptr1 == 'b' || *ptr1 == 'B' || *ptr1 == 'l' || *ptr1 == 'L') ptr1++; if (isdigit((int) *ptr1)) /* must have at least 1 digit */ { while (isdigit((int) *ptr1)) ptr1++; /* skip over digits */ if (*ptr1 == ',' || *ptr1 == ':' || *ptr1 == ']' ) { /* OK, this looks like a rawfile specifier */ if (urltype) { if (strstr(urltype, "stdin") ) strcpy(urltype, "rawstdin://"); else strcpy(urltype, "rawfile://"); } /* append the raw array specifier to infilex */ if (infilex) { if (strlen(infilex) + strlen(ptr3) > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strcat(infilex, ptr3); ptr1 = strchr(infilex, ']'); /* find the closing ] char */ if (ptr1) *(ptr1 + 1) = '\0'; /* terminate string after the ] */ } if (extspec) strcpy(extspec, "0"); /* the 0 ext number is implicit */ tmptr = strchr(ptr2 + 1, '[' ); /* search for another [ char */ /* copy any remaining characters into rowfilterx */ if (tmptr && rowfilterx) { if (strlen(rowfilterx) + strlen(tmptr + 1) > FLEN_FILENAME -1) { free(infile); return(*status = URL_PARSE_ERROR); } strcat(rowfilterx, tmptr + 1); tmptr = strchr(rowfilterx, ']' ); /* search for closing ] */ if (tmptr) *tmptr = '\0'; /* overwrite the ] with null terminator */ } free(infile); /* finished parsing, so return */ return(*status); } } } /* end of rawfile specifier test */ /* -------------------------------------------------------- */ /* Not a rawfile, so next, test if this is an image section */ /* i.e., an integer followed by a ':' or a '*' or '-*' */ /* -------------------------------------------------------- */ ptr1 = ptr3 + 1; /* reset pointer to first char after the [ */ tmptr = ptr1; while (*tmptr == ' ') tmptr++; /* skip leading blanks */ while (isdigit((int) *tmptr)) tmptr++; /* skip over leading digits */ if (*tmptr == ':' || *tmptr == '*' || *tmptr == '-') { /* this is an image section specifier */ strcat(rowfilter, ptr3); /* don't want to assume 0 extension any more; may imply an image extension. if (extspec) strcpy(extspec, "0"); */ } else { /* ----------------------------------------------------------------- Not an image section or rawfile spec so may be an extension spec. Examples of valid extension specifiers: [3] - 3rd extension; 0 = primary array [events] - events extension [events, 2] - events extension, with EXTVER = 2 [events,2] - spaces are optional [events, 3, b] - same as above, plus XTENSION = 'BINTABLE' [PICS; colName(12)] - an image in row 12 of the colName column in the PICS table extension [PICS; colName(exposure > 1000)] - as above, but find image in first row with with exposure column value > 1000. [Rate Table] - extension name can contain spaces! [Rate Table;colName(exposure>1000)] Examples of other types of specifiers (Not extension specifiers) [bin] !!! this is ambiguous, and can't be distinguished from a valid extension specifier [bini X=1:512:16] (also binb, binj, binr, and bind are allowed) [binr (X,Y) = 5] [bin @binfilter.txt] [col Time;rate] [col PI=PHA * 1.1] [col -Time; status] [X > 5] [X>5] [@filter.txt] [StatusCol] !!! this is ambiguous, and can't be distinguished from a valid extension specifier [StatusCol==0] [StatusCol || x>6] [gtifilter()] [regfilter("region.reg")] [compress Rice] There will always be some ambiguity between an extension name and a boolean row filtering expression, (as in a couple of the above examples). If there is any doubt, the expression should be treated as an extension specification; The user can always add an explicit expression specifier to override this interpretation. The following decision logic will be used: 1) locate the first token, terminated with a space, comma, semi-colon, or closing bracket. 2) the token is not part of an extension specifier if any of the following is true: - if the token begins with '@' and contains a '.' - if the token contains an operator: = > < || && - if the token begins with "gtifilter(" or "regfilter(" - if the token is terminated by a space and is followed by additional characters (not a ']') AND any of the following: - the token is 'col' - the token is 3 or 4 chars long and begins with 'bin' - the second token begins with an operator: ! = < > | & + - * / % 3) otherwise, the string is assumed to be an extension specifier ----------------------------------------------------------------- */ tmptr = ptr1; while(*tmptr == ' ') tmptr++; hasAt = 0; hasDot = 0; hasOper = 0; followingOper = 0; spaceTerm = 0; rowFilter = 0; colStart = 0; binStart = 0; pixStart = 0; compStart = 0; if (*tmptr == '@') /* test for leading @ symbol */ hasAt = 1; if ( !strncasecmp(tmptr, "col ", 4) ) colStart = 1; if ( !strncasecmp(tmptr, "bin", 3) ) binStart = 1; if ( !strncasecmp(tmptr, "pix", 3) ) pixStart = 1; if ( !strncasecmp(tmptr, "compress ", 9) || !strncasecmp(tmptr, "compress]", 9) ) compStart = 1; if ( !strncasecmp(tmptr, "gtifilter(", 10) || !strncasecmp(tmptr, "regfilter(", 10) ) { rowFilter = 1; } else { /* parse the first token of the expression */ for (ii = 0; ii < ptr2 - ptr1 + 1; ii++, tmptr++) { if (*tmptr == '.') hasDot = 1; else if (*tmptr == '=' || *tmptr == '>' || *tmptr == '<' || (*tmptr == '|' && *(tmptr+1) == '|') || (*tmptr == '&' && *(tmptr+1) == '&') ) hasOper = 1; else if (*tmptr == ',' || *tmptr == ';' || *tmptr == ']') { break; } else if (*tmptr == ' ') /* a space char? */ { while(*tmptr == ' ') /* skip spaces */ tmptr++; if (*tmptr == ']') /* is this the end? */ break; spaceTerm = 1; /* 1st token is terminated by space */ /* test if this is a column or binning specifier */ if (colStart || (ii <= 4 && (binStart || pixStart)) ) rowFilter = 1; else { /* check if next character is an operator */ if (*tmptr == '=' || *tmptr == '>' || *tmptr == '<' || *tmptr == '|' || *tmptr == '&' || *tmptr == '!' || *tmptr == '+' || *tmptr == '-' || *tmptr == '*' || *tmptr == '/' || *tmptr == '%') followingOper = 1; } break; } } } /* test if this is NOT an extension specifier */ if ( rowFilter || (pixStart && spaceTerm) || (hasAt && hasDot) || hasOper || compStart || (spaceTerm && followingOper) ) { /* this is (probably) not an extension specifier */ /* so copy all chars to filter spec string */ strcat(rowfilter, ptr3); } else { /* this appears to be a legit extension specifier */ /* copy the extension specification */ if (extspec) { if (ptr2 - ptr1 > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strncat(extspec, ptr1, ptr2 - ptr1); } /* copy any remaining chars to filter spec string */ strcat(rowfilter, ptr2 + 1); } } } /* end of if (!plus_ext) */ else { /* ------------------------------------------------------------------ */ /* already have extension, so this must be a filter spec of some sort */ /* ------------------------------------------------------------------ */ strcat(rowfilter, ptr3); } /* strip off any trailing blanks from filter */ slen = strlen(rowfilter); while ( (--slen) >= 0 && rowfilter[slen] == ' ') rowfilter[slen] = '\0'; if (!rowfilter[0]) { free(infile); return(*status); /* nothing left to parse */ } /* ------------------------------------------------ */ /* does the filter contain a binning specification? */ /* ------------------------------------------------ */ ptr1 = strstr(rowfilter, "[bin"); /* search for "[bin" */ if (!ptr1) ptr1 = strstr(rowfilter, "[BIN"); /* search for "[BIN" */ if (!ptr1) ptr1 = strstr(rowfilter, "[Bin"); /* search for "[Bin" */ if (ptr1) { ptr2 = ptr1 + 4; /* end of the '[bin' string */ if (*ptr2 == 'b' || *ptr2 == 'i' || *ptr2 == 'j' || *ptr2 == 'r' || *ptr2 == 'd') ptr2++; /* skip the datatype code letter */ if ( *ptr2 != ' ' && *ptr2 != ']') ptr1 = NULL; /* bin string must be followed by space or ] */ } if (ptr1) { /* found the binning string */ if (binspec) { if (strlen(ptr1 +1) > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strcpy(binspec, ptr1 + 1); ptr2 = strchr(binspec, ']'); if (ptr2) /* terminate the binning filter */ { *ptr2 = '\0'; if ( *(--ptr2) == ' ') /* delete trailing spaces */ *ptr2 = '\0'; } else { ffpmsg("input file URL is missing closing bracket ']'"); ffpmsg(rowfilter); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } } /* delete the binning spec from the row filter string */ ptr2 = strchr(ptr1, ']'); strcpy(tmpstr, ptr2+1); /* copy any chars after the binspec */ strcpy(ptr1, tmpstr); /* overwrite binspec */ } /* --------------------------------------------------------- */ /* does the filter contain a column selection specification? */ /* --------------------------------------------------------- */ ptr1 = strstr(rowfilter, "[col "); if (!ptr1) { ptr1 = strstr(rowfilter, "[COL "); if (!ptr1) ptr1 = strstr(rowfilter, "[Col "); } if (ptr1) { /* find the end of the column specifier */ ptr2 = ptr1 + 5; while (*ptr2 != ']') { if (*ptr2 == '\0') { ffpmsg("input file URL is missing closing bracket ']'"); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } if (*ptr2 == '\'') /* start of a literal string */ { ptr2 = strchr(ptr2 + 1, '\''); /* find closing quote */ if (!ptr2) { ffpmsg ("literal string in input file URL is missing closing single quote"); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } } if (*ptr2 == '[') /* set of nested square brackets */ { ptr2 = strchr(ptr2 + 1, ']'); /* find closing bracket */ if (!ptr2) { ffpmsg ("nested brackets in input file URL is missing closing bracket"); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } } ptr2++; /* continue search for the closing bracket character */ } collen = ptr2 - ptr1 - 1; if (colspec) /* copy the column specifier to output string */ { if (collen > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strncpy(colspec, ptr1 + 1, collen); colspec[collen] = '\0'; while (colspec[--collen] == ' ') colspec[collen] = '\0'; /* strip trailing blanks */ } /* delete the column selection spec from the row filter string */ strcpy(tmpstr, ptr2 + 1); /* copy any chars after the colspec */ strcpy(ptr1, tmpstr); /* overwrite binspec */ } /* --------------------------------------------------------- */ /* does the filter contain a pixel filter specification? */ /* --------------------------------------------------------- */ ptr1 = strstr(rowfilter, "[pix"); if (!ptr1) { ptr1 = strstr(rowfilter, "[PIX"); if (!ptr1) ptr1 = strstr(rowfilter, "[Pix"); } if (ptr1) { ptr2 = ptr1 + 4; /* end of the '[pix' string */ if (*ptr2 == 'b' || *ptr2 == 'i' || *ptr2 == 'j' || *ptr2 == 'B' || *ptr2 == 'I' || *ptr2 == 'J' || *ptr2 == 'r' || *ptr2 == 'd' || *ptr2 == 'R' || *ptr2 == 'D') ptr2++; /* skip the datatype code letter */ if (*ptr2 == '1') ptr2++; /* skip the single HDU indicator */ if ( *ptr2 != ' ') ptr1 = NULL; /* pix string must be followed by space */ } if (ptr1) { /* find the end of the pixel filter */ while (*ptr2 != ']') { if (*ptr2 == '\0') { ffpmsg("input file URL is missing closing bracket ']'"); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } if (*ptr2 == '\'') /* start of a literal string */ { ptr2 = strchr(ptr2 + 1, '\''); /* find closing quote */ if (!ptr2) { ffpmsg ("literal string in input file URL is missing closing single quote"); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } } if (*ptr2 == '[') /* set of nested square brackets */ { ptr2 = strchr(ptr2 + 1, ']'); /* find closing bracket */ if (!ptr2) { ffpmsg ("nested brackets in input file URL is missing closing bracket"); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } } ptr2++; /* continue search for the closing bracket character */ } collen = ptr2 - ptr1 - 1; if (pixfilter) /* copy the column specifier to output string */ { if (collen > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strncpy(pixfilter, ptr1 + 1, collen); pixfilter[collen] = '\0'; while (pixfilter[--collen] == ' ') pixfilter[collen] = '\0'; /* strip trailing blanks */ } /* delete the pixel filter from the row filter string */ strcpy(tmpstr, ptr2 + 1); /* copy any chars after the pixel filter */ strcpy(ptr1, tmpstr); /* overwrite binspec */ } /* ------------------------------------------------------------ */ /* does the filter contain an image compression specification? */ /* ------------------------------------------------------------ */ ptr1 = strstr(rowfilter, "[compress"); if (ptr1) { ptr2 = ptr1 + 9; /* end of the '[compress' string */ if ( *ptr2 != ' ' && *ptr2 != ']') ptr1 = NULL; /* compress string must be followed by space or ] */ } if (ptr1) { /* found the compress string */ if (compspec) { if (strlen(ptr1 +1) > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strcpy(compspec, ptr1 + 1); ptr2 = strchr(compspec, ']'); if (ptr2) /* terminate the binning filter */ { *ptr2 = '\0'; if ( *(--ptr2) == ' ') /* delete trailing spaces */ *ptr2 = '\0'; } else { ffpmsg("input file URL is missing closing bracket ']'"); ffpmsg(rowfilter); free(infile); return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } } /* delete the compression spec from the row filter string */ ptr2 = strchr(ptr1, ']'); strcpy(tmpstr, ptr2+1); /* copy any chars after the binspec */ strcpy(ptr1, tmpstr); /* overwrite binspec */ } /* copy the remaining string to the rowfilter output... should only */ /* contain a rowfilter expression of the form "[expr]" */ if (rowfilterx && rowfilter[0]) { ptr2 = rowfilter + strlen(rowfilter) - 1; if( rowfilter[0]=='[' && *ptr2==']' ) { *ptr2 = '\0'; if (strlen(rowfilter + 1) > FLEN_FILENAME - 1) { free(infile); return(*status = URL_PARSE_ERROR); } strcpy(rowfilterx, rowfilter+1); } else { ffpmsg("input file URL lacks valid row filter expression"); *status = URL_PARSE_ERROR; } } free(infile); return(*status); } /*--------------------------------------------------------------------------*/ int ffexist(const char *infile, /* I - input filename or URL */ int *exists, /* O - 2 = a compressed version of file exists */ /* 1 = yes, disk file exists */ /* 0 = no, disk file could not be found */ /* -1 = infile is not a disk file (could */ /* be a http, ftp, gsiftp, smem, or stdin file) */ int *status) /* I/O status */ /* test if the input file specifier is an existing file on disk If the specified file can't be found, it then searches for a compressed version of the file. */ { FILE *diskfile; char rootname[FLEN_FILENAME]; char *ptr1; if (*status > 0) return(*status); /* strip off any extname or filters from the name */ ffrtnm( (char *)infile, rootname, status); ptr1 = strstr(rootname, "://"); if (ptr1 || *rootname == '-') { if (!strncmp(rootname, "file", 4) ) { ptr1 = ptr1 + 3; /* pointer to start of the disk file name */ } else { *exists = -1; /* this is not a disk file */ return (*status); } } else { ptr1 = rootname; } /* see if the disk file exists */ if (file_openfile(ptr1, 0, &diskfile)) { /* no, couldn't open file, so see if there is a compressed version */ if (file_is_compressed(ptr1) ) { *exists = 2; /* a compressed version of the file exists */ } else { *exists = 0; /* neither file nor compressed version exist */ } } else { /* yes, file exists */ *exists = 1; fclose(diskfile); } return(*status); } /*--------------------------------------------------------------------------*/ int ffrtnm(char *url, char *rootname, int *status) /* parse the input URL, returning the root name (filetype://basename). */ { int ii, jj, slen, infilelen; char *ptr1, *ptr2, *ptr3; char urltype[MAX_PREFIX_LEN]; char infile[FLEN_FILENAME]; if (*status > 0) return(*status); ptr1 = url; *rootname = '\0'; *urltype = '\0'; *infile = '\0'; /* get urltype (e.g., file://, ftp://, http://, etc.) */ if (*ptr1 == '-') /* "-" means read file from stdin */ { strcat(urltype, "-"); ptr1++; } else if (!strncmp(ptr1, "stdin", 5) || !strncmp(ptr1, "STDIN", 5)) { strcat(urltype, "-"); ptr1 = ptr1 + 5; } else { ptr2 = strstr(ptr1, "://"); ptr3 = strstr(ptr1, "(" ); if (ptr3 && (ptr3 < ptr2) ) { /* the urltype follows a '(' character, so it must apply */ /* to the output file, and is not the urltype of the input file */ ptr2 = 0; /* so reset pointer to zero */ } if (ptr2) /* copy the explicit urltype string */ { if (ptr2 - ptr1 + 3 > MAX_PREFIX_LEN - 1) { return(*status = URL_PARSE_ERROR); } strncat(urltype, ptr1, ptr2 - ptr1 + 3); ptr1 = ptr2 + 3; } else if (!strncmp(ptr1, "ftp:", 4) ) { /* the 2 //'s are optional */ strcat(urltype, "ftp://"); ptr1 += 4; } else if (!strncmp(ptr1, "gsiftp:", 7) ) { /* the 2 //'s are optional */ strcat(urltype, "gsiftp://"); ptr1 += 7; } else if (!strncmp(ptr1, "http:", 5) ) { /* the 2 //'s are optional */ strcat(urltype, "http://"); ptr1 += 5; } else if (!strncmp(ptr1, "mem:", 4) ) { /* the 2 //'s are optional */ strcat(urltype, "mem://"); ptr1 += 4; } else if (!strncmp(ptr1, "shmem:", 6) ) { /* the 2 //'s are optional */ strcat(urltype, "shmem://"); ptr1 += 6; } else if (!strncmp(ptr1, "file:", 5) ) { /* the 2 //'s are optional */ ptr1 += 5; } /* else assume file driver */ } /* get the input file name */ ptr2 = strchr(ptr1, '('); /* search for opening parenthesis ( */ ptr3 = strchr(ptr1, '['); /* search for opening bracket [ */ if (ptr2 == ptr3) /* simple case: no [ or ( in the file name */ { if (strlen(ptr1) > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strcat(infile, ptr1); } else if (!ptr3) /* no bracket, so () enclose output file name */ { if (ptr2 - ptr1 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(infile, ptr1, ptr2 - ptr1); ptr2++; ptr1 = strchr(ptr2, ')' ); /* search for closing ) */ if (!ptr1) return(*status = URL_PARSE_ERROR); /* error, no closing ) */ } else if (ptr2 && (ptr2 < ptr3)) /* () enclose output name before bracket */ { if (ptr2 - ptr1 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(infile, ptr1, ptr2 - ptr1); ptr2++; ptr1 = strchr(ptr2, ')' ); /* search for closing ) */ if (!ptr1) return(*status = URL_PARSE_ERROR); /* error, no closing ) */ } else /* bracket comes first, so there is no output name */ { if (ptr3 - ptr1 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(infile, ptr1, ptr3 - ptr1); } /* strip off any trailing blanks in the names */ slen = strlen(infile); for (ii = slen - 1; ii > 0; ii--) { if (infile[ii] == ' ') infile[ii] = '\0'; else break; } /* --------------------------------------------- */ /* check if the 'filename+n' convention has been */ /* used to specifiy which HDU number to open */ /* --------------------------------------------- */ jj = strlen(infile); for (ii = jj - 1; ii >= 0; ii--) { if (infile[ii] == '+') /* search backwards for '+' sign */ break; } if (ii > 0 && (jj - ii) < 5) /* limit extension numbers to 4 digits */ { infilelen = ii; ii++; for (; ii < jj; ii++) { if (!isdigit((int) infile[ii] ) ) /* are all the chars digits? */ break; } if (ii == jj) { /* yes, the '+n' convention was used. */ infile[infilelen] = '\0'; /* delete the extension number */ } } if (strlen(urltype) + strlen(infile) > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strcat(rootname, urltype); /* construct the root name */ strcat(rootname, infile); return(*status); } /*--------------------------------------------------------------------------*/ int ffourl(char *url, /* I - full input URL */ char *urltype, /* O - url type */ char *outfile, /* O - base file name */ char *tpltfile, /* O - template file name, if any */ char *compspec, /* O - compression specification, if any */ int *status) /* parse the output URL into its basic components. */ { char *ptr1, *ptr2, *ptr3; if (*status > 0) return(*status); if (urltype) *urltype = '\0'; if (outfile) *outfile = '\0'; if (tpltfile) *tpltfile = '\0'; if (compspec) *compspec = '\0'; ptr1 = url; while (*ptr1 == ' ') /* ignore leading blanks */ ptr1++; if ( ( (*ptr1 == '-') && ( *(ptr1 +1) == 0 || *(ptr1 +1) == ' ' ) ) || !strcmp(ptr1, "stdout") || !strcmp(ptr1, "STDOUT")) /* "-" means write to stdout; also support "- " */ /* but exclude disk file names that begin with a minus sign */ /* e.g., "-55d33m.fits" */ { if (urltype) strcpy(urltype, "stdout://"); } else { /* not writing to stdout */ /* get urltype (e.g., file://, ftp://, http://, etc.) */ ptr2 = strstr(ptr1, "://"); if (ptr2) /* copy the explicit urltype string */ { if (urltype) { if (ptr2 - ptr1 + 3 > MAX_PREFIX_LEN - 1) { return(*status = URL_PARSE_ERROR); } strncat(urltype, ptr1, ptr2 - ptr1 + 3); } ptr1 = ptr2 + 3; } else /* assume file driver */ { if (urltype) strcat(urltype, "file://"); } /* look for template file name, enclosed in parenthesis */ ptr2 = strchr(ptr1, '('); /* look for image compression parameters, enclosed in sq. brackets */ ptr3 = strchr(ptr1, '['); if (outfile) { if (ptr2) { /* template file was specified */ if (ptr2 - ptr1 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(outfile, ptr1, ptr2 - ptr1); } else if (ptr3) { /* compression was specified */ if (ptr3 - ptr1 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(outfile, ptr1, ptr3 - ptr1); } else { /* no template file or compression */ if (strlen(ptr1) > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strcpy(outfile, ptr1); } } if (ptr2) /* template file was specified */ { ptr2++; ptr1 = strchr(ptr2, ')' ); /* search for closing ) */ if (!ptr1) { return(*status = URL_PARSE_ERROR); /* error, no closing ) */ } if (tpltfile) { if (ptr1 - ptr2 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(tpltfile, ptr2, ptr1 - ptr2); } } if (ptr3) /* compression was specified */ { ptr3++; ptr1 = strchr(ptr3, ']' ); /* search for closing ] */ if (!ptr1) { return(*status = URL_PARSE_ERROR); /* error, no closing ] */ } if (compspec) { if (ptr1 - ptr3 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(compspec, ptr3, ptr1 - ptr3); } } /* check if a .gz compressed output file is to be created */ /* by seeing if the filename ends in '.gz' */ if (urltype && outfile) { if (!strcmp(urltype, "file://") ) { ptr1 = strstr(outfile, ".gz"); if (ptr1) { /* make sure the ".gz" is at the end of the file name */ ptr1 += 3; if (*ptr1 == 0 || *ptr1 == ' ' ) strcpy(urltype, "compressoutfile://"); } } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffexts(char *extspec, int *extnum, char *extname, int *extvers, int *hdutype, char *imagecolname, char *rowexpress, int *status) { /* Parse the input extension specification string, returning either the extension number or the values of the EXTNAME, EXTVERS, and XTENSION keywords in desired extension. Also return the name of the column containing an image, and an expression to be used to determine which row to use, if present. */ char *ptr1, *ptr2; int slen, nvals; int notint = 1; /* initially assume specified extname is not an integer */ char tmpname[FLEN_VALUE], *loc; *extnum = 0; *extname = '\0'; *extvers = 0; *hdutype = ANY_HDU; *imagecolname = '\0'; *rowexpress = '\0'; if (*status > 0) return(*status); ptr1 = extspec; /* pointer to first char */ while (*ptr1 == ' ') /* skip over any leading blanks */ ptr1++; if (isdigit((int) *ptr1)) /* is the extension specification a number? */ { notint = 0; /* looks like extname may actually be the ext. number */ errno = 0; /* reset this prior to calling strtol */ *extnum = strtol(ptr1, &loc, 10); /* read the string as an integer */ while (*loc == ' ') /* skip over trailing blanks */ loc++; /* check for read error, or junk following the integer */ if ((*loc != '\0' && *loc != ';' ) || (errno == ERANGE) ) { *extnum = 0; notint = 1; /* no, extname was not a simple integer after all */ errno = 0; /* reset error condition flag if it was set */ } if ( *extnum < 0 || *extnum > 99999) { *extnum = 0; /* this is not a reasonable extension number */ ffpmsg("specified extension number is out of range:"); ffpmsg(extspec); return(*status = URL_PARSE_ERROR); } } /* This logic was too simple, and failed on extnames like '1000TEMP' where it would try to move to the 1000th extension if (isdigit((int) *ptr1)) { sscanf(ptr1, "%d", extnum); if (*extnum < 0 || *extnum > 9999) { *extnum = 0; ffpmsg("specified extension number is out of range:"); ffpmsg(extspec); return(*status = URL_PARSE_ERROR); } } */ if (notint) { /* not a number, so EXTNAME must be specified, followed by */ /* optional EXTVERS and XTENSION values */ /* don't use space char as end indicator, because there */ /* may be imbedded spaces in the EXTNAME value */ slen = strcspn(ptr1, ",:;"); /* length of EXTNAME */ if (slen > FLEN_VALUE - 1) { return(*status = URL_PARSE_ERROR); } strncat(extname, ptr1, slen); /* EXTNAME value */ /* now remove any trailing blanks */ while (slen > 0 && *(extname + slen -1) == ' ') { *(extname + slen -1) = '\0'; slen--; } ptr1 += slen; slen = strspn(ptr1, " ,:"); /* skip delimiter characters */ ptr1 += slen; slen = strcspn(ptr1, " ,:;"); /* length of EXTVERS */ if (slen) { nvals = sscanf(ptr1, "%d", extvers); /* EXTVERS value */ if (nvals != 1) { ffpmsg("illegal EXTVER value in input URL:"); ffpmsg(extspec); return(*status = URL_PARSE_ERROR); } ptr1 += slen; slen = strspn(ptr1, " ,:"); /* skip delimiter characters */ ptr1 += slen; slen = strcspn(ptr1, ";"); /* length of HDUTYPE */ if (slen) { if (*ptr1 == 'b' || *ptr1 == 'B') *hdutype = BINARY_TBL; else if (*ptr1 == 't' || *ptr1 == 'T' || *ptr1 == 'a' || *ptr1 == 'A') *hdutype = ASCII_TBL; else if (*ptr1 == 'i' || *ptr1 == 'I') *hdutype = IMAGE_HDU; else { ffpmsg("unknown type of HDU in input URL:"); ffpmsg(extspec); return(*status = URL_PARSE_ERROR); } } } else { strcpy(tmpname, extname); ffupch(tmpname); if (!strcmp(tmpname, "PRIMARY") || !strcmp(tmpname, "P") ) *extname = '\0'; /* return extnum = 0 */ } } ptr1 = strchr(ptr1, ';'); if (ptr1) { /* an image is to be opened; the image is contained in a single */ /* cell of a binary table. A column name and an expression to */ /* determine which row to use has been entered. */ ptr1++; /* skip over the ';' delimiter */ while (*ptr1 == ' ') /* skip over any leading blanks */ ptr1++; ptr2 = strchr(ptr1, '('); if (!ptr2) { ffpmsg("illegal specification of image in table cell in input URL:"); ffpmsg(" did not find a row expression enclosed in ( )"); ffpmsg(extspec); return(*status = URL_PARSE_ERROR); } if (ptr2 - ptr1 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(imagecolname, ptr1, ptr2 - ptr1); /* copy column name */ ptr2++; /* skip over the '(' delimiter */ while (*ptr2 == ' ') /* skip over any leading blanks */ ptr2++; ptr1 = strchr(ptr2, ')'); if (!ptr2) { ffpmsg("illegal specification of image in table cell in input URL:"); ffpmsg(" missing closing ')' character in row expression"); ffpmsg(extspec); return(*status = URL_PARSE_ERROR); } if (ptr1 - ptr2 > FLEN_FILENAME - 1) { return(*status = URL_PARSE_ERROR); } strncat(rowexpress, ptr2, ptr1 - ptr2); /* row expression */ } return(*status); } /*--------------------------------------------------------------------------*/ int ffextn(char *url, /* I - input filename/URL */ int *extension_num, /* O - returned extension number */ int *status) { /* Parse the input url string and return the number of the extension that CFITSIO would automatically move to if CFITSIO were to open this input URL. The extension numbers are one's based, so 1 = the primary array, 2 = the first extension, etc. The extension number that gets returned is determined by the following algorithm: 1. If the input URL includes a binning specification (e.g. 'myfile.fits[3][bin X,Y]') then the returned extension number will always = 1, since CFITSIO would create a temporary primary image on the fly in this case. The same is true if an image within a single cell of a binary table is opened. 2. Else if the input URL specifies an extension number (e.g., 'myfile.fits[3]' or 'myfile.fits+3') then the specified extension number (+ 1) is returned. 3. Else if the extension name is specified in brackets (e.g., this 'myfile.fits[EVENTS]') then the file will be opened and searched for the extension number. If the input URL is '-' (reading from the stdin file stream) this is not possible and an error will be returned. 4. Else if the URL does not specify an extension (e.g. 'myfile.fits') then a special extension number = -99 will be returned to signal that no extension was specified. This feature is mainly for compatibility with existing FTOOLS software. CFITSIO would open the primary array by default (extension_num = 1) in this case. */ fitsfile *fptr; char urltype[20]; char infile[FLEN_FILENAME]; char outfile[FLEN_FILENAME]; char extspec[FLEN_FILENAME]; char extname[FLEN_FILENAME]; char rowfilter[FLEN_FILENAME]; char binspec[FLEN_FILENAME]; char colspec[FLEN_FILENAME]; char imagecolname[FLEN_VALUE], rowexpress[FLEN_FILENAME]; char *cptr; int extnum, extvers, hdutype, tstatus = 0; if (*status > 0) return(*status); /* parse the input URL into its basic components */ fits_parse_input_url(url, urltype, infile, outfile, extspec, rowfilter,binspec, colspec, status); if (*status > 0) return(*status); if (*binspec) /* is there a binning specification? */ { *extension_num = 1; /* a temporary primary array image is created */ return(*status); } if (*extspec) /* is an extension specified? */ { ffexts(extspec, &extnum, extname, &extvers, &hdutype, imagecolname, rowexpress, status); if (*status > 0) return(*status); if (*imagecolname) /* is an image within a table cell being opened? */ { *extension_num = 1; /* a temporary primary array image is created */ return(*status); } if (*extname) { /* have to open the file to search for the extension name (curses!) */ if (!strcmp(urltype, "stdin://")) /* opening stdin would destroying it! */ return(*status = URL_PARSE_ERROR); /* First, strip off any filtering specification */ infile[0] = '\0'; strncat(infile, url, FLEN_FILENAME -1); cptr = strchr(infile, ']'); /* locate the closing bracket */ if (!cptr) { return(*status = URL_PARSE_ERROR); } else { cptr++; *cptr = '\0'; /* terminate URl after the extension spec */ } if (ffopen(&fptr, infile, READONLY, status) > 0) /* open the file */ { ffclos(fptr, &tstatus); return(*status); } ffghdn(fptr, &extnum); /* where am I in the file? */ *extension_num = extnum; ffclos(fptr, status); return(*status); } else { *extension_num = extnum + 1; /* return the specified number (+ 1) */ return(*status); } } else { *extension_num = -99; /* no specific extension was specified */ /* defaults to primary array */ return(*status); } } /*--------------------------------------------------------------------------*/ int ffurlt(fitsfile *fptr, char *urlType, int *status) /* return the prefix string associated with the driver in use by the fitsfile pointer fptr */ { strcpy(urlType, driverTable[fptr->Fptr->driver].prefix); return(*status); } /*--------------------------------------------------------------------------*/ int ffimport_file( char *filename, /* Text file to read */ char **contents, /* Pointer to pointer to hold file */ int *status ) /* CFITSIO error code */ /* Read and concatenate all the lines from the given text file. User must free the pointer returned in contents. Pointer is guaranteed to hold 2 characters more than the length of the text... allows the calling routine to append (or prepend) a newline (or quotes?) without reallocating memory. */ { int allocLen, totalLen, llen, eoline = 1; char *lines,line[256]; FILE *aFile; if( *status > 0 ) return( *status ); totalLen = 0; allocLen = 1024; lines = (char *)malloc( allocLen * sizeof(char) ); if( !lines ) { ffpmsg("Couldn't allocate memory to hold ASCII file contents."); return(*status = MEMORY_ALLOCATION ); } lines[0] = '\0'; if( (aFile = fopen( filename, "r" ))==NULL ) { sprintf(line,"Could not open ASCII file %s.",filename); ffpmsg(line); free( lines ); return(*status = FILE_NOT_OPENED); } while( fgets(line,256,aFile)!=NULL ) { llen = strlen(line); if ( eoline && (llen > 1) && (line[0] == '/' && line[1] == '/')) continue; /* skip comment lines begging with // */ eoline = 0; /* replace CR and newline chars at end of line with nulls */ if ((llen > 0) && (line[llen-1]=='\n' || line[llen-1] == '\r')) { line[--llen] = '\0'; eoline = 1; /* found an end of line character */ if ((llen > 0) && (line[llen-1]=='\n' || line[llen-1] == '\r')) { line[--llen] = '\0'; } } if( totalLen + llen + 3 >= allocLen ) { allocLen += 256; lines = (char *)realloc(lines, allocLen * sizeof(char) ); if( ! lines ) { ffpmsg("Couldn't allocate memory to hold ASCII file contents."); *status = MEMORY_ALLOCATION; break; } } strcpy( lines+totalLen, line ); totalLen += llen; if (eoline) { strcpy( lines+totalLen, " "); /* add a space between lines */ totalLen += 1; } } fclose(aFile); *contents = lines; return( *status ); } /*--------------------------------------------------------------------------*/ int fits_get_token(char **ptr, char *delimiter, char *token, int *isanumber) /* O - is this token a number? */ /* parse off the next token, delimited by a character in 'delimiter', from the input ptr string; increment *ptr to the end of the token. Returns the length of the token, not including the delimiter char; */ { char *loc, tval[73]; int slen; double dval; *token = '\0'; while (**ptr == ' ') /* skip over leading blanks */ (*ptr)++; slen = strcspn(*ptr, delimiter); /* length of next token */ if (slen) { strncat(token, *ptr, slen); /* copy token */ (*ptr) += slen; /* skip over the token */ if (isanumber) /* check if token is a number */ { *isanumber = 1; if (strchr(token, 'D')) { strncpy(tval, token, 72); tval[72] = '\0'; /* The C language does not support a 'D'; replace with 'E' */ if ((loc = strchr(tval, 'D'))) *loc = 'E'; dval = strtod(tval, &loc); } else { dval = strtod(token, &loc); } /* check for read error, or junk following the value */ if (*loc != '\0' && *loc != ' ' ) *isanumber = 0; if (errno == ERANGE) *isanumber = 0; } } return(slen); } /*--------------------------------------------------------------------------*/ int fits_get_token2(char **ptr, char *delimiter, char **token, int *isanumber, /* O - is this token a number? */ int *status) /* parse off the next token, delimited by a character in 'delimiter', from the input ptr string; increment *ptr to the end of the token. Returns the length of the token, not including the delimiter char; This routine allocates the *token string; the calling routine must free it */ { char *loc, tval[73]; int slen; double dval; if (*status) return(0); while (**ptr == ' ') /* skip over leading blanks */ (*ptr)++; slen = strcspn(*ptr, delimiter); /* length of next token */ if (slen) { *token = (char *) calloc(slen + 1, 1); if (!(*token)) { ffpmsg("Couldn't allocate memory to hold token string (fits_get_token2)."); *status = MEMORY_ALLOCATION ; return(0); } strncat(*token, *ptr, slen); /* copy token */ (*ptr) += slen; /* skip over the token */ if (isanumber) /* check if token is a number */ { *isanumber = 1; if (strchr(*token, 'D')) { strncpy(tval, *token, 72); tval[72] = '\0'; /* The C language does not support a 'D'; replace with 'E' */ if ((loc = strchr(tval, 'D'))) *loc = 'E'; dval = strtod(tval, &loc); } else { dval = strtod(*token, &loc); } /* check for read error, or junk following the value */ if (*loc != '\0' && *loc != ' ' ) *isanumber = 0; if (errno == ERANGE) *isanumber = 0; } } return(slen); } /*---------------------------------------------------------------------------*/ char *fits_split_names( char *list) /* I - input list of names */ { /* A sequence of calls to fits_split_names will split the input string into name tokens. The string typically contains a list of file or column names. The names must be delimited by a comma and/or spaces. This routine ignores spaces and commas that occur within parentheses, brackets, or curly brackets. It also strips any leading and trailing blanks from the returned name. This routine is similar to the ANSI C 'strtok' function: The first call to fits_split_names has a non-null input string. It finds the first name in the string and terminates it by overwriting the next character of the string with a '\0' and returns a pointer to the name. Each subsequent call, indicated by a NULL value of the input string, returns the next name, searching from just past the end of the previous name. It returns NULL when no further names are found. The following line illustrates how a string would be split into 3 names: myfile[1][bin (x,y)=4], file2.fits file3.fits ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ 1st name 2nd name 3rd name NOTE: This routine is not thread-safe. This routine is simply provided as a utility routine for other external software. It is not used by any CFITSIO routine. */ int depth = 0; char *start; static char *ptr; if (list) /* reset ptr if a string is given */ ptr = list; while (*ptr == ' ')ptr++; /* skip leading white space */ if (*ptr == '\0')return(0); /* no remaining file names */ start = ptr; while (*ptr != '\0') { if ((*ptr == '[') || (*ptr == '(') || (*ptr == '{')) depth ++; else if ((*ptr == '}') || (*ptr == ')') || (*ptr == ']')) depth --; else if ((depth == 0) && (*ptr == ',' || *ptr == ' ')) { *ptr = '\0'; /* terminate the filename here */ ptr++; /* save pointer to start of next filename */ break; } ptr++; } return(start); } /*--------------------------------------------------------------------------*/ int urltype2driver(char *urltype, int *driver) /* compare input URL with list of known drivers, returning the matching driver numberL. */ { int ii; /* find matching driver; search most recent drivers first */ for (ii=no_of_drivers - 1; ii >= 0; ii--) { if (0 == strcmp(driverTable[ii].prefix, urltype)) { *driver = ii; return(0); } } return(NO_MATCHING_DRIVER); } /*--------------------------------------------------------------------------*/ int ffclos(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* close the FITS file by completing the current HDU, flushing it to disk, then calling the system dependent routine to physically close the FITS file */ { int tstatus = NO_CLOSE_ERROR, zerostatus = 0; if (!fptr) return(*status = NULL_INPUT_PTR); else if ((fptr->Fptr)->validcode != VALIDSTRUC) /* check for magic value */ return(*status = BAD_FILEPTR); /* close and flush the current HDU */ if (*status > 0) ffchdu(fptr, &tstatus); /* turn off the error message from ffchdu */ else ffchdu(fptr, status); ((fptr->Fptr)->open_count)--; /* decrement usage counter */ if ((fptr->Fptr)->open_count == 0) /* if no other files use structure */ { ffflsh(fptr, TRUE, status); /* flush and disassociate IO buffers */ /* call driver function to actually close the file */ if ((*driverTable[(fptr->Fptr)->driver].close)((fptr->Fptr)->filehandle)) { if (*status <= 0) { *status = FILE_NOT_CLOSED; /* report if no previous error */ ffpmsg("failed to close the following file: (ffclos)"); ffpmsg((fptr->Fptr)->filename); } } fits_clear_Fptr( fptr->Fptr, status); /* clear Fptr address */ free((fptr->Fptr)->iobuffer); /* free memory for I/O buffers */ free((fptr->Fptr)->headstart); /* free memory for headstart array */ free((fptr->Fptr)->filename); /* free memory for the filename */ (fptr->Fptr)->filename = 0; (fptr->Fptr)->validcode = 0; /* magic value to indicate invalid fptr */ free(fptr->Fptr); /* free memory for the FITS file structure */ free(fptr); /* free memory for the FITS file structure */ } else { /* to minimize the fallout from any previous error (e.g., trying to open a non-existent extension in a already opened file), always call ffflsh with status = 0. */ /* just flush the buffers, don't disassociate them */ if (*status > 0) ffflsh(fptr, FALSE, &zerostatus); else ffflsh(fptr, FALSE, status); free(fptr); /* free memory for the FITS file structure */ } return(*status); } /*--------------------------------------------------------------------------*/ int ffdelt(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* close and DELETE the FITS file. */ { char *basename; int slen, tstatus = NO_CLOSE_ERROR, zerostatus = 0; if (!fptr) return(*status = NULL_INPUT_PTR); else if ((fptr->Fptr)->validcode != VALIDSTRUC) /* check for magic value */ return(*status = BAD_FILEPTR); if (*status > 0) ffchdu(fptr, &tstatus); /* turn off the error message from ffchdu */ else ffchdu(fptr, status); ffflsh(fptr, TRUE, status); /* flush and disassociate IO buffers */ /* call driver function to actually close the file */ if ( (*driverTable[(fptr->Fptr)->driver].close)((fptr->Fptr)->filehandle) ) { if (*status <= 0) { *status = FILE_NOT_CLOSED; /* report error if no previous error */ ffpmsg("failed to close the following file: (ffdelt)"); ffpmsg((fptr->Fptr)->filename); } } /* call driver function to actually delete the file */ if ( (driverTable[(fptr->Fptr)->driver].remove) ) { /* parse the input URL to get the base filename */ slen = strlen((fptr->Fptr)->filename); basename = (char *) malloc(slen +1); if (!basename) return(*status = MEMORY_ALLOCATION); fits_parse_input_url((fptr->Fptr)->filename, NULL, basename, NULL, NULL, NULL, NULL, NULL, &zerostatus); if ((*driverTable[(fptr->Fptr)->driver].remove)(basename)) { ffpmsg("failed to delete the following file: (ffdelt)"); ffpmsg((fptr->Fptr)->filename); if (!(*status)) *status = FILE_NOT_CLOSED; } free(basename); } fits_clear_Fptr( fptr->Fptr, status); /* clear Fptr address */ free((fptr->Fptr)->iobuffer); /* free memory for I/O buffers */ free((fptr->Fptr)->headstart); /* free memory for headstart array */ free((fptr->Fptr)->filename); /* free memory for the filename */ (fptr->Fptr)->filename = 0; (fptr->Fptr)->validcode = 0; /* magic value to indicate invalid fptr */ free(fptr->Fptr); /* free memory for the FITS file structure */ free(fptr); /* free memory for the FITS file structure */ return(*status); } /*--------------------------------------------------------------------------*/ int fftrun( fitsfile *fptr, /* I - FITS file pointer */ LONGLONG filesize, /* I - size to truncate the file */ int *status) /* O - error status */ /* low level routine to truncate a file to a new smaller size. */ { if (driverTable[(fptr->Fptr)->driver].truncate) { ffflsh(fptr, FALSE, status); /* flush all the buffers first */ (fptr->Fptr)->filesize = filesize; (fptr->Fptr)->io_pos = filesize; (fptr->Fptr)->logfilesize = filesize; (fptr->Fptr)->bytepos = filesize; ffbfeof(fptr, status); /* eliminate any buffers beyond current EOF */ return (*status = (*driverTable[(fptr->Fptr)->driver].truncate)((fptr->Fptr)->filehandle, filesize) ); } else return(*status); } /*--------------------------------------------------------------------------*/ int ffflushx( FITSfile *fptr) /* I - FITS file pointer */ /* low level routine to flush internal file buffers to the file. */ { if (driverTable[fptr->driver].flush) return ( (*driverTable[fptr->driver].flush)(fptr->filehandle) ); else return(0); /* no flush function defined for this driver */ } /*--------------------------------------------------------------------------*/ int ffseek( FITSfile *fptr, /* I - FITS file pointer */ LONGLONG position) /* I - byte position to seek to */ /* low level routine to seek to a position in a file. */ { return( (*driverTable[fptr->driver].seek)(fptr->filehandle, position) ); } /*--------------------------------------------------------------------------*/ int ffwrite( FITSfile *fptr, /* I - FITS file pointer */ long nbytes, /* I - number of bytes to write */ void *buffer, /* I - buffer to write */ int *status) /* O - error status */ /* low level routine to write bytes to a file. */ { if ( (*driverTable[fptr->driver].write)(fptr->filehandle, buffer, nbytes) ) { ffpmsg("Error writing data buffer to file:"); ffpmsg(fptr->filename); *status = WRITE_ERROR; } return(*status); } /*--------------------------------------------------------------------------*/ int ffread( FITSfile *fptr, /* I - FITS file pointer */ long nbytes, /* I - number of bytes to read */ void *buffer, /* O - buffer to read into */ int *status) /* O - error status */ /* low level routine to read bytes from a file. */ { int readstatus; readstatus = (*driverTable[fptr->driver].read)(fptr->filehandle, buffer, nbytes); if (readstatus == END_OF_FILE) *status = END_OF_FILE; else if (readstatus > 0) { ffpmsg("Error reading data buffer from file:"); ffpmsg(fptr->filename); *status = READ_ERROR; } return(*status); } /*--------------------------------------------------------------------------*/ int fftplt(fitsfile **fptr, /* O - FITS file pointer */ const char *filename, /* I - name of file to create */ const char *tempname, /* I - name of template file */ int *status) /* IO - error status */ /* Create and initialize a new FITS file based on a template file. Uses C fopen and fgets functions. */ { if (*status > 0) return(*status); if ( ffinit(fptr, filename, status) ) /* create empty file */ return(*status); ffoptplt(*fptr, tempname, status); /* open and use template */ return(*status); } /*--------------------------------------------------------------------------*/ int ffoptplt(fitsfile *fptr, /* O - FITS file pointer */ const char *tempname, /* I - name of template file */ int *status) /* IO - error status */ /* open template file and use it to create new file */ { fitsfile *tptr; int tstatus = 0, nkeys, nadd, ii; char card[FLEN_CARD]; if (*status > 0) return(*status); if (tempname == NULL || *tempname == '\0') /* no template file? */ return(*status); /* try opening template */ ffopen(&tptr, (char *) tempname, READONLY, &tstatus); if (tstatus) /* not a FITS file, so treat it as an ASCII template */ { ffxmsg(2, card); /* clear the error message */ fits_execute_template(fptr, (char *) tempname, status); ffmahd(fptr, 1, 0, status); /* move back to the primary array */ return(*status); } else /* template is a valid FITS file */ { ffmahd(tptr, 1, NULL, status); /* make sure we are at the beginning */ while (*status <= 0) { ffghsp(tptr, &nkeys, &nadd, status); /* get no. of keywords */ for (ii = 1; ii <= nkeys; ii++) /* copy keywords */ { ffgrec(tptr, ii, card, status); /* must reset the PCOUNT keyword to zero in the new output file */ if (strncmp(card, "PCOUNT ",8) == 0) { /* the PCOUNT keyword? */ if (strncmp(card+25, " 0", 5)) { /* non-zero value? */ strncpy(card, "PCOUNT = 0", 30); } } ffprec(fptr, card, status); } ffmrhd(tptr, 1, 0, status); /* move to next HDU until error */ ffcrhd(fptr, status); /* create empty new HDU in output file */ } if (*status == END_OF_FILE) { *status = 0; /* expected error condition */ } ffclos(tptr, status); /* close the template file */ } ffmahd(fptr, 1, 0, status); /* move to the primary array */ return(*status); } /*--------------------------------------------------------------------------*/ void ffrprt( FILE *stream, int status) /* Print out report of cfitsio error status and messages on the error stack. Uses C FILE stream. */ { char status_str[FLEN_STATUS], errmsg[FLEN_ERRMSG]; if (status) { fits_get_errstatus(status, status_str); /* get the error description */ fprintf(stream, "\nFITSIO status = %d: %s\n", status, status_str); while ( fits_read_errmsg(errmsg) ) /* get error stack messages */ fprintf(stream, "%s\n", errmsg); } return; } /*--------------------------------------------------------------------------*/ int pixel_filter_helper( fitsfile **fptr, /* IO - pointer to input image; on output it */ /* points to the new image */ char *outfile, /* I - name for output file */ char *expr, /* I - Image filter expression */ int *status) { PixelFilter filter = { 0 }; char * DEFAULT_TAG = "X"; int ii, hdunum; int singleHDU = 0; filter.count = 1; filter.ifptr = fptr; filter.tag = &DEFAULT_TAG; /* create new empty file for result */ if (ffinit(&filter.ofptr, outfile, status) > 0) { ffpmsg("failed to create output file for pixel filter:"); ffpmsg(outfile); return(*status); } fits_get_hdu_num(*fptr, &hdunum); /* current HDU number in input file */ expr += 3; /* skip 'pix' */ switch (expr[0]) { case 'b': case 'B': filter.bitpix = BYTE_IMG; break; case 'i': case 'I': filter.bitpix = SHORT_IMG; break; case 'j': case 'J': filter.bitpix = LONG_IMG; break; case 'r': case 'R': filter.bitpix = FLOAT_IMG; break; case 'd': case 'D': filter.bitpix = DOUBLE_IMG; break; } if (filter.bitpix) /* skip bitpix indicator */ ++expr; if (*expr == '1') { ++expr; singleHDU = 1; } if (((*fptr)->Fptr)->only_one) singleHDU = 1; if (*expr != ' ') { ffpmsg("pixel filtering expression not space separated:"); ffpmsg(expr); } while (*expr == ' ') ++expr; /* copy all preceding extensions to the output file */ for (ii = 1; !singleHDU && ii < hdunum; ii++) { fits_movabs_hdu(*fptr, ii, NULL, status); if (fits_copy_hdu(*fptr, filter.ofptr, 0, status) > 0) { ffclos(filter.ofptr, status); return(*status); } } /* move back to the original HDU position */ fits_movabs_hdu(*fptr, hdunum, NULL, status); filter.expression = expr; if (fits_pixel_filter(&filter, status)) { ffpmsg("failed to execute image filter:"); ffpmsg(expr); ffclos(filter.ofptr, status); return(*status); } /* copy any remaining HDUs to the output file */ for (ii = hdunum + 1; !singleHDU; ii++) { if (fits_movabs_hdu(*fptr, ii, NULL, status) > 0) break; fits_copy_hdu(*fptr, filter.ofptr, 0, status); } if (*status == END_OF_FILE) *status = 0; /* got the expected EOF error; reset = 0 */ else if (*status > 0) { ffclos(filter.ofptr, status); return(*status); } /* close the original file and return ptr to the new image */ ffclos(*fptr, status); *fptr = filter.ofptr; /* reset the pointer to the new table */ /* move back to the image subsection */ if (ii - 1 != hdunum) fits_movabs_hdu(*fptr, hdunum, NULL, status); return(*status); } healpy-1.10.3/cfitsio/cfitsio.pc.in0000664000175000017500000000040113010375004017343 0ustar zoncazonca00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: cfitsio Description: FITS File Subroutine Library Version: @CFITSIO_MAJOR@.@CFITSIO_MINOR@ Libs: -L${libdir} -lcfitsio @LIBS@ Libs.private: -lm Cflags: -I${includedir} healpy-1.10.3/cfitsio/cfitsio_mac.sit.hqx0000664000175000017500000005550613010375004020572 0ustar zoncazonca00000000000000(This file must be converted with BinHex 4.0) :$f0QDA4cD@pIE@&M,R0TG!"6594%8dP8)3#3"%11!*!%4HY6593K!!%!!%11FNa KG3*6!*!$&ZlZ)#!,BfCTG(0TEepYB@-!N"AR#BB"&J!9!U)"eJ#3!`-!N!q'!!! $([q3"!2JYCR`K,@Cp[N!N!8"mK%!N!C$#2r`rrJ!!-0!!!"0Y`!0$N0'DA4cD@p 38%-ZE@0`!*!4Da3*KJ#3$aB!!$i$!*!$&[q3"%e08(*$9dP&!3#[H%fHYCRfmJ# 3"3(U0!#3"Md0!!"9XJ#3"[8H"[LUJEpCRC+&h2,Qp5XR2!PhHq4S2H%,ApKQqmJ LNkpp8AlddNfr[1A)MP#1Tai![I"-haEmadlZiRN5eLh2&pPQYb@hMpc#pMQahU[ MjF@A)`YEb',mbF)EN!#&l)[`r)9RmFZHm#-lbAEK#qr)l6MKLpjbR($&#Ur-Vr0 fK0r#Ma`RA-)l22Q&,13AFTY-&L1cK5jN"9K($6SEG(C1mZ4R0R4JEhDp%a[NjC! $GhCHIV6,b@DM((4ffHR#LbqH!ph[phRj4[C&&ShX)r[YiRdmbHkebmMq[(KN$cV cFa#2l)[X86b,,-plB#b!Vl2VCAikk,fqbH,(bq[*l53meJ,!&[`"jhIkI5f1'd% 3,!Q#dUUJp-!lJY+$p5"BH5ma(bKeP6LDVcDZZdeKNN4a8UiQm9CAbqCLA5QIqP[ XPi0Jl8H#i"hHrpUqXi,J3lqkj2T6Yh"H2r[XNdTd(rB03A$L`5"Bk[dc2RMIZPh "b@rE'34[ackdki2h"FF(`H@c#NqI)P4GS[!F,Pp*9ei&5TqF6!e5'Z+9D"fM`h3 SKb"@J#a`!MD',FIf`[E'9Q$lB2YLqf(lBdr#RS`GJ$d&1a!l&(XDGKKf1,B5HcV f$1`)l*RBNGLcX'GMcm'HKld!Hb&f0$D-(B3GV&F8@iSYXeH9XJm!'S'I``l"RSX p(cX+1aCEK4f((@pf`QYP)SqYmP[j5"8[%qfa(pAKIHX%hY3A6jljZ2T8+l$Y9P+ 9ZSABJ5Ud2KH'fm*+)da6PhC[$C1M&eJq8#d2EIU0kPcTFK1[N!#9EL'@!Z3P+,c -9icR6L[c8`j9I`iR[I25%D#SDkA4H$YaNp&-Gc1XG32c$IHfjC@#kiCLM)K%k9U d0C!!+Y"B$PJ09iKRp+T'ImNm&#%J!p"afpL5RV[@,,R`mrF[ZH#ElqrD[qq5V[h AhHR6KErIYIm6PcaA6"*I""A*,da(Ij9Gqfr-+elX!'`CYKcE#pX2#j!!mKDmMrF f[!P[`aGVCh(5hqLkFX8[lETZ[FY'fki@68BZ'4rrPF(qU1%Ur52RpBmU,(M&e-r [ZMjp9qrk4M`40Y,amE22fMMRMCjalUk29a)ACUirLCZM'DkYiq-#6)e-2)$BNji $[H19,-l5)CG-ZI*`jkGdGbVIp'Te-(q&F1rJqXfekDJZ"VeXY&TjXIkPJR"+B'p X,f`j0LE!&GXAfcq[XZ"cN!$HrL9`cYkY)A1@E%VP'l5+hlRcbk0[mTDf2KX`YaX e[DrL-$5@ED`1G2ZkcR%$Fa@`J+rA8&Ll`)9ePk4(B5"I%%P5e4$j5bD8ZL99"C' %"%)')C`36FJTK2"&@%JPj,)HqlYBb1JU,136iJN"K@"#6L'VI1!b4*@kJP$@BGG L4Gh4a",#Z4rl8L`BHMX@BVS-#r0EJEd4Za,lHpJef*Z`P0R0f&Z`eGL*@0jl&aD -K&[`XMABGGK*f-RBLl$)*TGJT`JBa8l$6XI1`0CLRiqGLGf"[3%,JGq$I3N@rVF HHkYa$AMM[GJAB+r&3Z`KlK"pb2NXib@3!(k)1%)!K2[P15X)"&GM)IQ)!4"pq!T #!&`#-@!$&R5![%2Qlm4HJpf%I4lfaGM0@05cV9J)r6EXE1`Fl+ABZGKjf-Z`ml% ,X*GM&f,"JLZ`,m3ZaYiPU$4)UGRfhGJP@0',!Vq$[4Ul&,YDF#,f+Zc[B+r%hS0 YCr+j6bUTE-2`KTkK[Zkqc5UCjSmUeDA%`6[rejF4)l,TiR`brVA3*Hm,%a+b-,* 3m2Vmm)Grm!5eR`CPMk%khMkK4`-Vr9'@4R'j@Uf8aebD5H$HN!#%3R@q1)AA(!- ,*PeY!S[6i&1kHG`*(+DSEhGqHe)rN3YqQb2j1!RK3Fcr%)dV5eHAPR@*'(UI%,* )f"hrVb$680&UjfB4V1HqC*df[aL&i!5iCF2hhkV$Xr!4rp,Nc`R6Uq!!q&D2TeQ B,2,38L0LY!''CqYC[k2Ei6&eaif6jJX[#J$6`Cm+2mfIND*raNQlmN!cYD6qDhR iehPEAiE`T##&'[YlPQU9DGfVFiN+aG3d"p9Cr"U,Il(jejT5GAfZ@k+UQ[MRfAQ c2FC,l,`Pec"4*3dBEV-mfqdq1r+cj1VIXf&dS&`T9q*@'MGFZEpRl,pCY8HMYE" hS,I"43%j5H+E+PXTX"5C[L@5"*hjT*ck(p+-T'pPA6eAME"lC``ZA"'DN9&,k4l 3V35k$q"r4B!'5-[V2ffqh+G,[2'9A[C+-mQ4Hce6diRfMY3c"p(TcH-lB&51Ndq [$2IfR9iq[EGRV)IMSS(+Q"TA(#UI-kB[e`fL%R@hP1SR6VjaNXdRhjpH,Bp,dX- 85VFXPH*+Ve+iDrm(e&0&Ve"NH8pG[9G[aNDV88Xp2hqKFUUVaZSTqNGXbG"!4Xq 8bTZ'GimiHUU8),CXb,ASJe,U*bV2S1[LSrHS&biT)+AqS0jakVLrZJPI4G4Sb2F KI(e'Ym6dEDP[iqYl396Ar5"4rBELEIL#kKRV6eqQj!ZUEqNNA2)f3I8iREc$9HK &#UVhD8!MdYX%2iA[&-[h-AbRCT8ahLri(A`$XmE&p*Q&T$F-LPS9hLDN(V6"PDa ",eG)Z[q3!%E()H'(e&meY,&XP$Z&e&pfQ[Lcq2i3hl$H*#3qp(Pm`mH5N!#qYG" Am9@Z)&"m2m3RI@k)kQ(eJCh4UMYU+kbqY4'4VK%i6Ve5CrSqeV#8FGk"12VGk!r $pa!(5f(#AqC!2adqDY(fiN@NcG"I4`Pc2VpVrar!jb2U@EXJ1+&1r868mdCr(MR S4k1h$YmIF"MYm5$bjrM'H$b)2)"[V-H$b02iUM`H409R0XlM395pGH-p(N69qcA "id&8Me[Ym5#UrVf*(JqLYq#VmAJ3r5+q54i2SUV,b4i2BY+4,[*i%"0ZAHca)#E "i"+2"c(edNhap4h6@dleH"$6@dlcH"#l(Crdl9&rXDrMQf(jrN8BD2#J4$ed-cd HP+JAF*E(Ja,9j@b2"bAUmC[MmD"%IAQAHM`S89h1pAK3mL9mmc`HP$b+lc+2"k8 5$HCl2#K92b5pGG,69kSq3hVXj+e,e50*Vaep[26@JFY5ck9-Cp#pGb+2P0l"'5b @[X(5KcR6FbFpJDA2F1DY"&r+K$(df8Q2AjNN#RV[D)AQE[4,#T%S8lI3e4Hj5kR 4-Y@Pp!U'`BNbeHAbJ@DEZLN6hUqSELU$ifArJ1rDLi,cHEpb[HA+4PY[@*lhGPD [8FYJZIM%kNEj21URA2fAer@A"lKRZCT**#re9hiG[M8HrmVr'YpDMhrPUX[Vam+ %ZLNAaXM!MNTk+hZT6h$pU-Y)dNYeZD'-8hc8aNBh'X*EHUQ2%8iL$6Qpe)F)&i" Z[)8$[!2I"cR3qiM[#3kf@kUh-'EEijG)[ZNYE"A9X6Fb@1qmVr06Tk9I`3FhZQ& UEINqI25GlR`m&i&k#f0f5C38hr[`lHETjEkpralI(QT,F+Zh4QcFL'STp95KZVa THQd2H&#KZYbl*48Z93J,ETDL+6lHlKDAPDRV#YAPmrhp+X4ME[AhUp#dNaHdfa( [A[(2q&iS495S%lfKYjhILAMR2Z*aq`+5L`pFS2F5HJ@hi!haJ@(dkq*l0`GkGI( "AH"Sq,l,!Ei$(D-h&@k)MjjFqPcaJ5P`,RcdfG)ELZr9(+K(I1!@ICriU(AH&Kr FL$jKB)aq9[J12VJ42Dri`$,H#Kq#*Afdq(kI!p0,m,fI`rhQq`+(9jM[D3k[p,l qkUGpPIRJ%16(4mm`Ei@2IPfCQ+*pVqG!MH0$#RfYq6l2!4c$pkmFb!-9T5rh!I2 "Ym"Y69(PS&[6a8H0[G&m$h*iNrR!@VJN[Up`J"FE1!m%0jZ2AQ[i1$kDcmL2Mcj TX!iIp3b'ib2[@mhh%3j[-aqm"$b"*S0rEcFII2%GjU-Iq*hQJr[#FI"4jqmb(hF $0r"pQ!1F%4riqV$hR5)qqKlc`6RIDcl`'mc%4rr`RjL2HRl%I0bCZXEhF3l`1(` #[`(K#45(RZX2Q)qHG$J&2[UBVAapUM$ecmd(VX%&m&&,F(Cme"rk!ckd"pj6[S' 5T)R&"pHKM["4hr"@I1!([!mI[%dQlfJIZ)$QJ)qhi`haJAr`GhcJabHmEj!!qVi rD6l`$jc("liqEMjkh)@(D"pi*ra%qkM$6jX2[Jk'ii0,`8IN'b`"L9Kmp,6rMIR SdIjEmr&qi"Xqm)Lh`NHGJ+[ii)*Ip,iK`Sm[Q3m0!Nk+$rjNCh)-%Ik"DILS[kq D$hcL,[LS5HS1hcFiJ#(b$C@fK#D!$r`!Zr$4RdiHI25pIp0mF",d%(aJ)PL"MjV mP[QHj2"YlcY0'XChc%G0`hI``5HrCcii#6`,(aJRlGRDalYc&rQ'5926ij6%"ip mbRa`EMJ12ZB4r,2ji#(8*Mk`$#d#(l8"*XJhA'm2VmG(EF&Pm-(RIQ3qCK[)j#E YJdZBKS2!,i06RZ3hR$VaY-&+HR)BCD0pdVR!U!cY%rk[V(HP%TkZE,j&*4LJV21 m%La6[PFR8+BfY1iRhqQ3!"5PZ32iC,k#XZ&"Ti-V5[L-6rLRm[e$J90d*p-E&$K &8kUBJB#21m%aj6Z$'+8q&(`bld'*fq)6,UM8RB42hPjTlJ3qiA)U*d[L%kaAiT, i"&18Y"hj4R"rTEN(q%6c8MD$B!6m@`N(m%R6K4)1ia0m9H+-q)5V+"0J4i#$5V- Em%QY+XePN!$[61+91#!qi@G+I!fID"h+jPbF#6iTm3Km`Tq8G#eme"ED*Ml"%@A khdMH9jRq0e,eD[@rNHKH-J(0q!5cPI!"Rf#U-[e[*&a#L42K%ka4QVdKheR5)Uh qGaEDJM,plbcTY,U[4Ac#GC8d"(c#Se6HkL)q`@@Pq4[bRDekdYd[iT2l+'N#q%5 I8MB)kQc9+0SJ2Z($5[-hm)&2k$Ri")Z9jQl)G`ieVc4r!jr-he$5ar#*0UE`Dap B`P`1I033A!DIm#*Pc86RJ*8UEp!@D96U5QPZ"ci4UT4`(KmD0CS92Z(j5T`&Rr! pC6hIjm)IP'CNb(FH'+5N1H160e,Lb2L%IfZY'jr`HbAZL8riZC)`KSpDK,2J%`k JT2R)GciiSU6riC2l+r%&I05LkB31R)NHSD6ri411UU6ri42HSU6rbAH"-"KHJ%p U3%Nc`3IfS2rK%ae(L8[L%be!5DI&*aa5D9B)2[#-H4hbA3Jf+Fe9`3G1S,AL%`e 'LI2L%ae%5EI%*aa4L8[L!hIYh+C4F!1PH5li`(+d3Aab0bAY!Kpe3lm"2Y%[P$J M2Z'd5[UEI+-e$3JY!TpJNl*T1+1&$I!eI+*Y+G2r4ZXH9[mE$3G@T[q0d6fXrMG '2!$p%"mD-9S%2UN6C3eBBlL2N[D,$fjN1pI(L"m`4`DID!R+QN2'S%FScB("ar[ "fI%*MeALJ2L%[bPV[KX,$e(LFIJ%aj8d0(b#IFSDmmH#"8VD&$jk)Y#kmFPE+-e N`5HkQa*ra`GqfbEqX@J$b[5rX@J0b[5rXA"eCIVI@''`eIr'`L&eMiCm9A!YCIT I&Ca%QIjA*IbcqPq9"K0BrDq+qP5Qre@T&Uhq9i@ZSdcrUd,E8UEr9D'c+02rUX4 6VIih6K1BV2ih$JkM62mETlYDr@mFpDa-raY(,QAkhcLpYpAraSN6@2e[($aFQIi h(XkQ62mE,jjKpEra`L5VrifRaT6TIq24pC6TIq24UT6TIq24!*6TIq09deErQb# 1CI@r#F*1Urp08(eBr@q#kX2UIa1)9kEr64"rYIVI"(36CITIYDCH@[f['JkT62q VKQmSdrqUK3G@rkY@69MpVaTG6jRq9bd-X2TIY6LheImQ`Vf9kAm6iA[+p,q*F!p PqYp%m@1Vrde869[pEb*kRc,pEk,iK0Ar*UVQV2jA)kjMpEmDiBI9rfVJ)FVd[aV a4D[reBMh@2f[4M9YpEmD0#aPqPm01SXbr@q5F06UIj2%JDcq0dPFfHTrNm"LCIV I*1'heImQkAj@rjXNc,$khb6d(@Akhf6a2k[r6BDl+Y2r*N[RX2VIC$#DbCY1Q3r PUGI)m,#a8r0&eSpX0(SE@2U'3ph*@k+**%a%KDVl"`Elb$c1cZ2Y2-(1ARb0R6I Cq@)lAf,R+ADHDZGTGTjZjaPfVVAc6$[2X[0X1mqamk9fRQ[RHADqc-lclEc!cTI EHD'G&pQjbXjAf(Q*RCIDq8SlAfARCADqfXlAf(QjR9IBq9SlVl6c+MZ[Y[0eGUk cmaSlVlAcHMY[X20'R4QRD2eEl,c9cY[X[(fKRS1[ca[ejqI&[%PGB)%ZZdBr1rG I5+G1BX"G+P[)XT6EZCHGbaDbPLe9`a@6MlL#66"J)8(jm[PHGbm&F`R9mMIP+G6 199HAPTr8cMVT@ppq8Y6+bT16mQpH03NBV@I5Bq8CNqdX16B3XA9FTSpccS'T%Dd 6a6TlfeeId-ZiA,F#p%CIKPll'2SfFYB3,HI`iJ#3!-`NXe%!81m40qN5ekU4Bcd c8mf`B!e[$H-fRA!IC'YVU"C)YdX4Y03&l6V*83$Z@a"ea3aSG0B-SN-(%cXH1`& EMDh"EX*HM,d%1`A,hJ(6X01a-l#ef*PBV@1*RB1p&$XA1`pl'ABqGJ(fFZa#l#* X&IB+l",X8Zb9f+Z`bl"ABkr",XHZ`&k,ABPGK9f0[3jEKef$ABYGMpf!hBMG)U! AZ`flAB43E"!E`SDa6F``*bPZAcaQVT!!#f(B[NrMM8l@TEAGAJP@lE`m1'lANU" mmEU6ejkQMR$h,Iph+Fb86idDE*i)l`JB3"QDfphM1@``eKN`"GY&mECQP3(DCC& 5D)qPlCDf@YTMDBZP(CD''0TZDBHPcC!!pN,D#QQ*T4@@&PKDAfPjTG@9&PGD@fP TTC@9'U$eN!#@3eS0D6'N$C2f5pSZDEHNMC-f6GSYDE1N[C)f6pSiDDpNE!MM3KJ 63SXPVC@d90*+53XPVC1d60)U5BXNVC'dJc*+K"%LM!jKC!JYXE6#dJ*,kbXYYE6 -d[T+bbZYVV6FdP*,UbXYN!#d2Y,b5,XVEDkdYp,@5MXVEDbdVp+f5VXUEDUdjY) @56XNEC!!M$pTfN(&@aQ#m3@-,@"F!@-6')[!Z!*[0aA'%M#1J$%%6EZQ-&l!@qH "-3+-9fKDhB(fFpV1D6HRcCcfGGV6D61R[CbfFYVED9rheQI`eQ9)VXS!2D)Yh&[ c)ENq"'h`Y(V6iZfY'q'Y%m+S$'3e2BP8V,GALaf*%Grki0Lq,ibZB'3&SbVS&'0 -"H-T["eJ[,8N''-!@$-@JE%(b48I'*X!BKpDpB%a!i`AS(Z-F3+-%8#@C)3!S`- B'F#S!-E)b2JBhHl2k"K'aL!m-'U'N6'-LQ&8#Qh"Y-VbCV6MmfkdS20fM)TK4)b -2p(M0'3X$+-dp!J0aX)`GS*DCK3-)f!BrF,)&aReSXF2b,JE4Q``@S14'S`BB*` 'Bc4S#kFGR$C`fVpTqkEPR*CbfVjTpkE0QjCd@XYT+DIeR(C[fVaTlkDYQhCZfVK ThkCYQhCY@YTT@DGGQcCYfV0TbkBGQcCXfU0TLkBGQMCSfTpT[DDeQ[CRfTjTGkB eQaCV@UYT`DEYQACRfTaTEkDYQACQfTKTAkCYQGCZ@VGT@kCGQ6CPfT0T5kBGQI% XM'9K(!)M@4M&`SJA4VJ`LS84,)aHB33-ia-BmD&l4aM43#XiidBBad(E-f-!"(F CYm*S$dCk-'k&-5Z-@'$%#U09'+R#+"9'U$#HJ6%bM2aJe!FM2KM"`(J2aRS`KS2 a'icGB0`')cdBfF'i$FCX-&k$N4q-lQ#X"b-f'+h"5!e'D6"#Jp%CM-aJ9!BM-KL 0`8J-4Q%`!S24&ibmB03&Bd)BFm&i#mCD--j#Ml&Jc)q-pp%M*aMY`dJI4J8a#SL 42ScbBB32Sd!BT`'2BI3'A)C4([!B4[N``SIa'A!D'G[$'"BpIS@a2B`'J'm`USI a#Y!#16#+4ir!B2b#m"l'XM#1K6%AM',4)eJB9F#S%PVA'Bh*q!hDj)@6-)U#F4' -L@!m"+-X'%R"+!T'9M!QJ[%3M)@JCB!a%)arB1`$iaiBmm!S$%CG-1D"m3k-G@# F!f-F[2%0MS)2rM2k16(CU!5M$ZalURYfpJNEUH*SqmBHf[c'ai8a"rBp!lkHEL0 b('hI1*(94Pbiim#q*lma1hZhM8&cXRdZXadr4,pU@[Y"cm$pfHF%DFjdKFb`pkU MH5Upr4`8A5*Lk$Uid6E,1l"-95+9lNcSbD1l&hVbk!k(RMad39aEj+&,BQq4Kmk *L88H1JPULMad)H`UmS#TZiXmG#rX+I,3q6#Tb%2Aa13L$jd9&a9jk,kiZ-K$KmB P44kk0kB8HHM`Q&VNS3YN@T%(pA9kNBFZNKP&(MT0DSXmG+2-,2,3XA*VNBHZPPP &(P6&'iSmG-IX,2,33I1#)JmG0V1,2(6Kc#Rbd+PcDC'(ETkj44kkIHB9HHJ)ZUc )3pI3r#)2R88,LMadF&eHj+(lDf'4Kik3!%9&(VU1VLMbd('fZ-K$pp4Y44kkS*B 8HHKkfeINSIYNDC'(lT8VLcaddYeHj+(ElUSL$aej0aGjk0DlXmK$4ppG44kkrZi ZmY!CH-qL!Zpp1)m$k(2,,8VMVYR"bUf`E&rk5br5U1BQAcTK2PdCMSIkG-p8)c- bjAMD2(-r@##5KrlrB88HCJ--,r)`,f$S5hRL%'TA(kdXmM"[B0P,#N3b$l-)4QR 2S)C)rGPamcS2X`Xb(45qdkcjSdUeC*C2I2eV58KIXPRcCmI5+Mh3CXfIG41G+4C b[90jDUXa2G"QcCrYH@Z,@I1RVUd9AS,IiES$rAh-QMm,`MCeDYEmf65c$(ABV2Q M5P&UpaiDCXY4qmfD2lZA9EAbMelcCdCBQfDjd-H8Cee@4CN+D6C"T4YC6aG"Q+H 1VrNcJRZIiHm6*PE2Zj!![[Z`9$lQBB$'c"SC5CjbZcGpj9,cBFhaJ)",$hjBXaA S,qpI+KhhY1@4qSbSpTLE)HH)HX6T-jHHqmJ'lR1"ca04Qa4c0)3$4$5MK(NDV!M %h)l4j)RCIHbD$a(09V"V2N4jUm!j0,a('5GjTZ8KMQi%ZqC$9!SMA5Tb[qK[Fjp URbHUf5,-jC!![[@SjT6B04qLQJNa5H9[lc0jZU3kL!QrQ0NKq@*kViZe"T(N'6C rlfEFNf92jAh#c,[XUcc"rGH[mrH4&GGNKGLeE[N'YhepVpX@eIapYZIe,HjebeN Kad5Z@miU30C9ASNEF9)UYHV+)b[Ul$dRMbJID'ec#@X,LDpda)80bl-Z8jkkLBC EXE&GCmhA4G'-d'9"11d'aK4AbXT%UK6QH(Cp[4)hfkrMjV@0b,@bJGi961rDcCS lXeTCFZQ+8LPeqEh&bIX3*50jBqrUl8X5(N&#PV'5d2C5+9QQ2(YQF1[Vl-iI41T K%I8!CkJ-6JM[,j@@hZTakR+Rp`rZrkMLi5M%rq@K(LQTXbYmrEbalHXRF+IU4ee @ZTcYa9E6ec4HGj-mebQ2HNrT[F69-4,[qHCESac1JPY&JL9[U'JJYpPhNLR"68K !2ekU*mqK32Y5YrCiYEF%U01"(lX%aMBjLp4R*pNh`(30PeNVqUmqGdeMJ92P@c! kd,GbS*@jT-95Al0QfNK(khkiq@VR0pIjY+2FM'e&iecl[[c1GCd,"mD#ffkfMC) 8qiia14*5-KdCH0SC+frl@([P,BpFP8rm(FSSViUK[JdE%D*Z'4dE1CAckk[9@0, C"dHLZPUX2a%kl@SAH)KiE[AerSCfPJXm-6DN84Q"JpSQ9'jBK[Dj#ch[&,@&LAp 8lm!Bm@TYlq#`KV60MQSCpe)M[8QX)@+VMP[B86XFjF-0p8j!iDhj!%1plia#STD MhRp+aTd0+G[H4M,q6-4ZZbr22Se8X$[8l-[($EJS0[6dR@N*mTQ&,ZeH9@khca( )&Fh1,rU-*iM1(j,2lY6PJ2X!"6TZG2q(E"AUT-1&a'E9UmHM9T4&B52Dm6pXmMR GI[8iC(KVe++jcK&4)rqjDh-kU20,l1cUU&J&S'Y,NL-pCA4+Z`+kd`k[e@4fDY9 ITCT'6b33P,D5rpVVblAb49JC)0Qc[@[,$lZfDCD3!,"d,lF$i6[3TY'FiaGhFXj -3XQ0Gfhph#C5KrYfp4Uhh"3qedCcjh-AFYaqhLL9%`q%m4Q2IYS@bTEa'BrqK4E I&CmGRr(S*br4q)bcY1f$Zf4m4T!!@BP#V3bj!PPGCT!!Gq6EQ'AYYDYAEf9)bDL ddqUZaFh9l55ZGfTCZRTVIAVefGeRVkl(YA4ef)jX-A$(b'IQ*0#r`jb%dNAZjL3 X'"eF'fahbA4D(Xh#9Me-kVBjlFf+VD`Q$[cF`Gl!ejF[F'(G*BZ83BQ2#c'2#h@ eiG(bD+IGC[bdbidpq,J3@V4ZVNU*HP30AC!!YQJKMpZQIk*PZd!rIc#!hJ0EG*2 Y8dQSV9aF+Cp66Q28RiZLlr8DKK8Xakl!ASYGL9f&ABfp$PZ(AB0GLef2hB$GL0f #hBVGKQ8VRZkEHTY!R)JJp2SpXXefX*0H[dFZCqX5[pI[NI6HP6Gmqm'hD'GDPhU [RkYQ9T[$p3X1Imhf(T*pJ4CqDpeKIK!F[PGl8l[-2KI[,#Dhh+5q30IVmj9XcI3 $@9+,N!$C!i0p$0,SBqHqkdFfDP012R856DqTE#(,8QlRAREZ[C!!Y@bTfJ2T$Z3 +*'!e06p"qI,4YQ2B!QQm&(+(@&qL8E$KhlIcAIlX[F@*"-,iGaGYLdh6jh`Crfl feVCEDbrS0,)Sk)m54KiXF9009J!-V2AA&'@NFU#Tm8'bfrCP`9"edf(hM,$4L1- @-k@fY)1K6HA+kXUCCrT%bmV9-+f&MGblf1d)URhpKe1R(S#eZH81@q*0FG+SGpH J,22,P@lb92D(Umk0aYI8hpV08qLiaCe@&M8G`5DN,Y[#1CjVp1&FmK`YYf$1L9l AMaa,"SBhEPB@(CYk&aN%%9Kl0++T,NJ5Ih[VY'q29qcdY"PXVJchca@!MN[8Jdj UAiX,aPm[lY@#`2U`jKCH2&N-bDcQ2Ef)KZH63Y22P`UDh6-@V"ebbC3V$a2EN!" 4JJpNE,f'9aT0"4N[1hZa908hKc5PS6UD3jV5m)V0)C12EQMSqldCDC*NpNZ62l) M39)TIE%[QG!2@p1CR+3$9k"Yl54Mf$E&mQadYHQddm5eVKjPYEKKRShe$KiZXPB UcYTJbPQdFDbCmi#9aT0)XfR1ml`jcqBj6q)@2)Eal*P2ZFGbERDAiYJDeleM4mF H`$Ki!12K!Bb("c!HEQ-mA-CiH!$M5Gb#"c!HRYYk%XRe8iM,[!"iZUf6Cpqe2@c $AGILZUQ@GV*)3EZT-JRDJ+ZTiRHT$,R,MYT032r5@U--6QT)mV*Hf!ae(BENlA5 T(LBp#kQfNfCaXhb4Zh4lR066S+G@)j-JrHiYD6!@JTk3!+IG@G5D5Z&5d#Tj*Zf GdBNDGE5mh8QB"VhD%(5$5mSqCm$c"KD`P*ab6HeH&LBYIj'P9Dkic6@#JC(bF"Z XPh9hGJE',q*CV6qHPRHVMHYZ[@[P[TP4UN@rYV,iT54,2#SZ)5,Q[$2HbXUAPV$ B@`Yc5pab3a*hfX+(RHd`59dLZ,SaE)a2(R*S!-0"a@k-+"KG90ZR*l$LZMlCPJM qV'ZV%rEK%Dh6HREj))Y'*0f8K*1UD(&Yi8SEQ9qB`!J5l(468BbN%E$F!JUl1S+ SJeLmYPCl'EhhcXc-KrVS[56Z*$9A(NXF,3,a!VEF5aI2R%Bm33%Q+R46F`&-GM5 L@'jahG!*bAU,5Q!RLhhDU'@p[B1$clrAaM"apHITLeP@T#',af*p)XK9#+'9Ifl ,!MAF5E+YFEB`rm660dl+P3VcbCUSJ59,KYkYPRh@1`ehlEr`9XkX64S*MKr@-Y1 X@LS,C1L2*F'paJ9@5#eTD#eUXk5dV-L[2`4X6`9Kr9E@M1@l&mZJ8li(X$*QS%6 $%Gk,VE#iMf,l((`NU(2q'VE[a&Dj!XpLq`9[r$Xp)rGRK9KmJr,he-0EP0C326R 1%bVT)U`25`i@+QIe9h`XhbdM$A3q9RJG'2bH4LbShm)hU*dV,@SA"ePK9IYHcQ' )q@4PRm#E'r"bmE(dh'RXc5ip)HTfI-0q0MLCqP*I`$GF1l'+lh-F+VQS[*&kc0H DZYV@Lch$"#-'3Bm)lRJ,F8(G8eCFr3&E!J@erLUV`C+$qM[,Vd`De*,KCr[pMi* kVA1#%fqLI64i&Ejc[4i8[)EcHGVi6AbmdrPqilIJjr"GB(Ik,!G@A-A(ficLIP* 6`Ar$0pSM48Je1FDV6b&KJeh*0D5&jKP2MBmPbPNi(jrFd9[*0E5$`i5HUXC5K+l %9leqFideB%-I%,B)S5I(UcR8j*X3"CCSa-3NeB[ihXlC6UB+#4XZ#Zii$8`+I4E IaG5(e&Y)Up8bAS)FRq%`KIH6@JSpM'qUAi3PT(I9qTMiRZ6!Zq%$5eL&&VJ$5r4 VL!p-B@PkI&,EHM&kI+a$5`hL3beP$9amV"2,%[2iZ!q,bZ160pI,b10MZA8@MXF (AK+,$qaKFAKm9"M,`H0l)3I`#KmeEAZ-`X*1&RR(pcS1LmhhS'%b[SFiX*`l2M# *"GcaIB3$li!2!'@4GRaIi-#bl2LqaB&Da[F$$Lbp$J@J2X!FI'!Sq)N2hX##k[M !!TC3adFGk0%KiZ-GHA0ma,!`1Mj'V0Q&Db,##4BrahFA"`hfiJ-EE$Y,4'r-dZI ihX@"2LamImV"$Lk*h-2"-*(!mF)!kJZI`%)!h0'qTcR!Ck!c[+XGp4CP[9h0Ar# "`CBb4B9jGP1qU0E,K52J!hGXNdj8p8mM'6lUdfUe8G@2V!QXIEb['Bm51%&[FC2 jL,'E@dA&NfifhpdFU!YmVq"JPGbS10UYjRXV"pEfaFGUZq!'2M$b0[0pR)-G2K- 94YT9L+1UHcJ1[LFi[-Kmm"+`@VkBq-mGjQ0GAeB3aXGk[#mf(eJ'4Z'MYPRY&aq e4#hMidej6hcFl4lc`32fQimhVMFIY8iX2YB2&PkNIAr&!5k'MbfU`%0m2q4`RrF j,MkNqG%LL(i%[P%(pMh926[lK(%(4pXh&M'Q#4I'(0Mh$$cXG1-@MVC[($*'%bl FF@$INpqBREhli+*ZZ2#bI*ZR"Pai+AcKEE1cepkjL"XU1'G(HTYQ'HI+jjiEkHf H(c9C0fRp@$*UXSl4cmP4NhA@`Z8dqDaZ1NVVVGSb5(kf2dVRS6*HhM@h3'YUXmC i9XP$i,e&([TrlL[bX*lKX0IbR&K4I!kBmI41ZB(6hQJX2F"TmT(KA6CSpT!!"Ki DTqR(0-2fc)3Y%jFFf*@)5)hY5S5PKddP3QfACb+!k9kqemliLNFN*RfCN!$8[#m 6XLaUMHKa8N&lejahj,f)Q$96Fcb+M0p,ABV3YMFM029Q"(L[j$EkJX'*'q,@XI( 3DQLSZJK!ac$MPQ6`90fV$FMpr&bSiaq0,02EEC[RFr`HYF2[YaP"Z8rQI2+`(6P U'qQ2jR8FZXHmVFPN0rECGf@`f)*0&CYRGE`q&Sq1f)bXirGBfVGjV(YLBGHFjLm eCEEYdrIBQ$ArVrMe2CL5r&bpkRX8X*1TZ-9[q8"9Drhm&Mp!i194fqD9(ApA'4& YCeJGVrZGD@)c[SlIJfp8V3&,2[kZqKjk*YlaHaKqcqcE0VScC2%*TV0JD0!Qhq@ qaLR3"epqdH#2%1E`2C`"$'AKq4Iq'$NEaPQhISi+TP2!cY3SlSjlR(rQBJ(hk(b 3!*rHS`1!Ihk2)T)IZBFXd["rY@qBkI&kKERVHa4HSf(UH[ipGM#)f"&`Ml@[[Qc aA4P&k0fM(BPqHSmGVl,6iV['lq%%B1lk(VZF6DEmcHHHB0`bK,KVL%VMV2r@EeI @@56J(RbM+**Rhj@4UVibIc"*E2%*jZkSB+C1!14d+b$9SDpVKTEl3p14Tfelq@F dRG`ph#DUmc%Y*PXG[p"LZZja9)[TZXG4,DEl(NHdQ1)ph!YD60Ylr%U,b6hX-eT -m4j(YCLfDra5LqQkac%YjZ"&A!4D6'F1ZkG(amF5(m@lTKIpD2kF(jT1&SKqSHR N%GmCS1N8aelfV`aZY&Rj[rRSVh&2G&'i!lSIA#IG"PZ1-5rTHU@c+0(lf[$&'BT lSQ[KHUemHI`cpcL1`('QA'$FrriHlT[ZKpf,!Bb'PfE[FHH8&lUbddAp(ia!,Y* 4dFFB3GFpMM+#VRXF4I,ZHaa"mZ)pMQP9EIIiP9D9Hj!!Cj!!XhL2SmMCGSeI)QI A2BjT93F[%Vp(3Bk4HqKT#Zdjc$hd+R,CMdZX5ifmjr1i!638IBr#i'4INFJMQYa $9R&T[mI#LDdr[SGlGUTjFY&!GmVRSTYUIZ)10-f'lCG9[M0B%1@PC('jb4BXPb0 V62mNAeJj##l)8YH6JqdZQ8l,SeRBUSG*rG!+km6+hLakRf`4GkkRdD1ZlT*&bU$ %ai@Sa`AGdV@NdaEAF,Qa"amA3MNZ10b3!+$Kmh%KY[MXp$`VRlK@#Z#%Gf%R@2M !#@E#BUNR[K(kL&kLA$-LGK9hc(d+@0JD4Uh&RUT3aS[%1&ic[d9m5Vq)1b921FH ZEH-PLVNP`iXm[6QH9Z6T`h&SNBFK3*9&R[iFVhiT6hbVHiNkLH10Vp@&5$kIi6# S9'V9e8NY[X&C0@3D6@JP[L%0laZV0icJ8k8P'j3(Rm3a*@EBdVk'DkB-[5*SmhR ,H[XUSkA5H@[bqlcZQT-ICjPLh[BRXrrbR[RhNErXZlH@5YIZprF1RM`lqp4Q3Xr %MX5HK@AKBZEMMH$jcV(h18re+IB-,$1&,X"HL"f&(8fH-CDR#MX11ail!FZFQSR B'ZcTj*PNH5l#ASaP`#*,)c""4pifm'lXD[*iGF'XYKAB99LQK6-CD41@'YK-RLf @"dD`(FXXTaZ`G+%c*BJ"3#[*XmIbh)6GLi9C#Xr81&CLY4NQ6kRP!EGX5@YX!RF UX1"+Ar,dXcc81h8f!(X+pP6X308f45jj"PZHSF)YXFa"C-)4%hpRBDGJTj0RYZ@ j&(X*PL%YFl(cX-`eBi,b![*S("!I`iHZ`#l'-U0a+IC+l&ABUH4CCRQZ`5iAAL5 "5*Vf`cNJbDXE[(MYRH!&G6!02"J[j%TZ0a,2drMa5)(JjV1#kkkrPraPj"'mN6a 5%HSA5mHVU'kE9I`$`L2UMI[GAb*4iMl[2QFbrfl$Ip[Xi92LI4iiDal2IR$l[q2 C!ffl$r([1aS[q9qQr2(h14$r6VZIi1*69j)RD(Pi3M#!HZ(p)PerqYAbrqZ"pN0 acXqHR,jKG!#&EPXD0eajU02)SV@96TV&cI*&lY,YF9*2AdJa[9Cc+(Z,`Qc,Lr& ,3rS!GjG(ACC&VDNA8ma'%U`F#Y[YPa2-k%50HVP[*NYJcFha6!QSMHYZ[@Zp($i c5K%Jec8RT$kfjE"#69[dSL6HkQVCLf@LUA&Fh-aQ@"BQVCIIZ,Cr5+T8Fq6FNI* `1iZDdBlrZ*ZH#E1`Nl8l,ck1$XmrRSkrDZL&8,q68`TmQfZmN!$%m[RfelFTfTq ITX"m#40H,''rVl!Y@MSQXU'j!M(p,,N#N!#qQBlAed*&4`C8`[cMqb*L@l6hH[C FQ52Ur)LpV9-*UpG-(i0d%Z3!RHJ11#G"(X`*cd%jd9NJpi*c'1"PD#N8,lDeb(9 4j!%m%Am3[h4m-hJ6Pi0ZSV2!(3r12PJVD"0BJ'a5G!#fRb$hh&Q`pS)lbc3$e&j X'UEMJCPbb%%dd6Q!*VSGRSR2JV-AR(R+*$#RJZ@e1Q'B"$NB*VS$KNQ3!)GK`R- `6(3@KVhJA(el'9U+`S[0&88HKK2a"h&*acI$-(%j'#Bk#m2ai1b$YF)`J38B*N8 ($2X*FXqGK@%[Z,0--c$XaDCK1"kB+BFF$"1GJf'Lff'Bq#`-Hm'CTmc#m1bHX@- `6))F$"2G!F-Nb--`i6NB*MS,`ej`VVkp$#e&iFAQLL)2`iRiJlLNijYKQ,JF$"1 GKH&iF2E"@Q'B`!)-Nk)$K[d%ZHI1`V!Ah&QQ'4MfBY-`(!r-P%-1KSR1`6$4l6" -I"D'[H$-8ak!i4jCULK-p8K6AH*88CiU#&5(*+T1NDSJ8h8,9Ge598kX+XT9Km@ P(RQT4f!U5%b(4+C1Q5N[0"@NTU,B9*5EHU5IS[M6)rpd#8"&#DJJ!Kf5J6U&S)) 8e#d'GFY"18'S+!NG&R"k**`H%DFJia`5FMUPR,bB8j!!FiU#6P(5kC&ALJ*,Mm6 5*E)8CCD#d(*)DZN8@`Tb5lIJdLfjj%5ASZab@#6TN8PkK*+#9(*),1Q85r+#58% b+BSQ4GQNd-a4E1I)0h4d0bJ8@K3kQa3+E3S&GEbSMqF9mQl&Yk$jGUUq"Gfh)$F @"FHmj0JYS49%Y%iC,5ZN0DmEPqCF,6P5T+XP342VDXR43,YD-U4i9dZ#*2(+a+F )35D*,CG-H%Hp0*!!Veb+1,&T6@(S9dYSLRqe*%K#86Dqp3RR,L33-'T*IS$GY@4 *%V0-I&FKqY3X%`ihbmEQLc6&cPS5T1KC-X&5Pc)IDfFmPB609l%aP5J,N!#T,1d SQ8U8JmT8QLaHTV*N3$1G*&Z`k8c09C[1d9+H$F@9!p,Q2+eSfT!!j`#NTZ+cZ*V +NJ(A!dQk(VJ&CP-*1V%fP5S$Z1NN4iUi$AV61CV`pd##BK&NN6L9*3[(5pU1$@, *e3('ITSX&2XjfS(B6j1$B6p*&S6p("N)ENb4VGh'2-f9fjLKT5b6TC5$hR5@9Z" 0CMN!Zhjd&R6p("R)E8T4H03@Z2A$1m(@6j5"fXB8KiUe$@BE-c5"E&0ijl0R!GE 2NB9AM`l2G"1GU5QAP$dbYZDB29CpK9$VkTXIYUBk)A1m-aPQaV9M[,e40XlRk*! !9aSeYCB859%Y%cpVTZC!,e(6mLr[bfqCm#k@e&jrU83(Lr!!l@bYa(5D6$Nf-,K m6EBNkQEUqHT-jFQ8D$T*4jfQXa@*EkCLI8"YVpFNJ@bYeLE1dPUVM8NbPCSN![N k2C!!TNMVmMAUCmP8D'1+M[TXc0A*PlTVFffYpTp5!CPke!,5("%-b(4)-b"2Mfa !QL0!3kCZMF(,dX0F[93GaHJPkDR(3hT$)P%"Qh5LGY9"ef%"HXR4)dk3!1B35-I cG1JBm5cG*A-%p-Pd60JJea'1i'IU+F9Z[F6,FK4iZP36,dP11)PRk+UH([Q%0$d #*@N1XbB5G4-R,mY4lZ5PkbUFBMr3NVL6e&aj,('-`Zc3LKCh@S$R3E%(AM#R%8m !)Ch0,2J1*q,G1K+P1(cf&3r+,Le2QHjSq1RYZaieV6GdC22jErCG@m5*PPGY&)U 2hE[V44XjHMVAXYlH`F(RRmq%0(&e%jALj5DNLB1EU!DqE@*5h0U%T'ZL-Fc5Da1 9T0+*L"4l5B5e[E62RK-"(ZlDPfpJaFQJ11fb3BEY'ZF"[QILNM`X%G(mDUfeR!K 0[CT(Xha[kJe6p-Q%T+L5#@QN45BS5B%5%@QkN`KYHc1Ip53#@SRIaM"ap9FJe-4 hL%FQ48ie-[%GFT&*NGH*6)+F3'6L1e'q-8H,HQ45C'@M4(L1YLGbG(+$4*i@HTU )cPGYZi58c("3X,!CQN8M%eR38%b5V0#4##q@5MH05Z6*P8UVpZ'(jUSSThDBq*c -BH,Ep3f6)5YX*-)l&Be%RN1&NT%m%Y%(Ud(QDVF6!F)lH3!CmM5!m%i@3)Cf%N" mRJ-3AU!!U45Y$)!-13,J4HG"c8Y4+&8[6@ZPHX'j3Zh!rN5#0ZMA#9U3!*r!)[# 6)iIlAR5K3RT3hdZ6VC!!JjJIMmc@6Kla#Fm$2Z%GH%q#(0ald3@dpp,de%F@kle JV`UF5CqkYUj&(,HQfC&Y*BDcbH-T1iPVh+PS2PXTaK6AZ)1R@XAK(1,BcY(r2[A (@Lc4h#rdMr0aRbG1hd2ZPi`V[B`P"HcpNR'Vf1kap-&QPZpiP0bNmX-FRLD1R3r mZ0$6(#UE@ASNRp*D"[DGN[IVp4AZFN'cR4k*@r)P&MqFhmbQMVa6@&XqpZAH[,G r[jRD&Z,6cDc"HbAM*[`CprZckL$cQ82Iiqhe0TAb$IiDKe(YK+e$3RGp"KpE9FT h$aZaK!Gmh2YlP-2Q1eHA0h%2[4IID"phhkFiR1RMIU)FGLAr)GTUXFc(rGd`2MD [*0rM(1l0im,R2S52E5cPZeml,mccq4l8FMKX)mQ9EeqS*hq,K'dIeM+9YLlpZ-M 0(2CCAITaBH'%9cGqA&5EC`keZ[(MpYdbAamIdhD6GSZ2I3r1emFfE9eTGiLkij6 jqRMdER`,I0aGfJV5eXG,@IBaS+dhLI[#I(eFYaiI'e-5pr@jqJMYH4)I@e6+GlH fac6e%4j66E+GTP6kcSmXe)'r(QL81SlAJ4mArZK#25AcIA#K2[bi'2H,eiFI0dL EE*Vk#&qKQVEiqe%``pC(q'HZ*X$Z$R'UDXM84rJbl49P0h9mA*KNkL0mP6E*[0& i!29UkL0mm4I`X8%RqIjk(Mp'DKm0kJ+mCpF*@aq[%TEFl12k#*pUmVLq2a$'[F4 `p`dFH[Zi4l3Tk*hfVYqIbpG[ac*m$rLiJF*eQqq*hIM),eqrlmlIljZ2iRZ2MqZ [c8C0[RklKB[[pA&pYEQRHHr!pi9re"h[)AK[hcY`81rdQ)ql6(R0H`Iq4MjUJAZ `SjTjlm"REX)((`'R(jkrhkHI`XHpL101jRiUqD3+eF60qrVmrCl8Qhl-lXe@4HC qUNGepR'lamUjq`9M[4re5(f$8qCq`6F+Ym!%q9CqFqjq`HekXdrjZ$fU$h1ri)l 2iK-HT2%*(Q0`)R,5,q$lQ[%RkRb`MhZ0DSLkNqq2`0Q5YSm,kLfqlH2HIJHBGV+ 2Up,Z(YraeiL#0j9rjH0@LdYqeqjh,cEQmH16fZ6dHmEcK'F%l"jVK5AJ!h(ic(Y (hUQY8rr*iUM4#Rq2KiAh6eUp2U6,QlK(YENV03,ZISR$&"rhT,C#IFTi*29XlK' jm6&m2c4FNHeFe8-qVYHr%N#0JarJE#prMbm+qm!Vm!Rq8HAcVEJ0(cRPZi8kL&4 ph$4aPAme(JchXMMp0['-Ic-H`#DTDqcHi-(6aVHNEVckZ&YFlNIfIY5cVBpc2SE [aclZC'fiqL&r[fq)GpUY5%qqKhFGk11qqNrc&,C#m3rkHfb$0hLVcFD%XjCrI"q I-ZifK)e6JeB(Ei&2H#[6KS9h&PGQ82G+'#*IL6BZ+S1AJcXq[jQ+$K%U+epXpkr aCNVEbI*dXMeV++qRf1i9TjVq!-6GKkq[MkZ(@bYK[RbIH"rjq[ZiNm!QTBeQ`8Z iKHB0XGhh8@2+0Q)j9CaEmiEBqjk&HbPY2-XlNIF-Rkm5,&$'ef2S&UEqBVY[)*F b[PkLYp4i'G[p1Ef0jHX$a&%d(XGfGm(2e&NqVPceq6`Ipa%`5)%cZQlJ*b90pLT ,e)Cq*p&[!KpUKNGhAbX4(cEhVYr-9VNUhrK9q,&XH4YHjq1Q28#FfE&CR3l[-$J GfhX&@mFUEE[+m`S1'Cb1lAN%A&6#4[P1S`i-6XIfDQPETHeKjCXcAkreer2f#Vp q$lQIVBrkc@b4Ue4he-dr(-+Rf0irr#*aXTbXcJIqDGb0lGd%cLREb(B''mmDr)l Y$H"-5Y[CNNq`bZ"hE1m0ZJFEfa)(cl6hH#Am4QQ,@qLmE'aVm$Zfjbkp"j[Gb[F DX0$L5[e[`Qf8YYQ&(m#A0*l&pYccF@'-LGXXc$"i8lm6V85*Ji$Im(jlMhI`4SS Dj(XGA-6JI@c2RGmLMXf#jAX6ZSc&TrSEU3QPlAQTErL$a[[BRZpG54akMRbRL0F Ch0Vr-&LSE11AQ2L*`DhpGi%T5TbD1RMPI2fK"5MHAlp6R0r(p[kPhS-YGZ8E*Yc 4r##fG`IF58PMNDm@hF6`JpMH')kUT)2"ekN6c3pLHem(Pe2DJ"IHrm3KIL$i)4L Pa#APfiM@B[L"h%0d,28QidrS$JCIpcm+*e$D(*JiH*jp[dAS@1TYaZGiAiYc`IZ *XlVA32&JJkreTm+TP1PHmm!2Lkre[`kI8kClKD89fAZ-q50mFKGJlA,UfI$Df0j 2#!2Bh&MLVJ)$,&lZ[d[Da'Gph%e`"3m[[k)D%icPQi9qjZ(PD186rBV[IYl9`m[ TUPIi(Hq"eQMIqir&rG!*LB2[fATpC!mqZ$rm$lbf1,G!R"`p3Ei9UN@,Pkq(f`@ NGj%2($&iZIpCm$)JIB!ikX2HBk5`!&iXheid#3m[2kbDrRXIYdFkVF@jkQ[*`CE $8$MZBqYl`+IaIGR(E8AImI"bJIL0h8`iV$UhpbMrAAaImA%28cm@,qY6m@2"+,l h``-p[(`[R&qCRMTEqT("brTedP$J&q#Ik+mHAMi'Pe@fi9G)R0lJCAdGV89*2k3 1@1h-eTr@@RKciQK0X2AhQ',3#H@l9RU"`F[pMdQMK0m"0E)KQBHA&G*DV)Dm5hU (aFYDD3bm!lL1CQ$`X[l0dNVJ0I+pkX[cH$Ri6`K!db$IQqIamR%d+D80RAQR""q Y[dEB)abCEr!#AXj%Te&k%rPZ%kjB[0`RIX`fd2!Ep%',Pj23m*9d@RJ'HN1*jrF 2`1(9Z)rl!,JFbHXlF0a"Z*Db4@0,a31Y(V!6M&#f#QaIEE&XiL)R`&'9l8Sd8"K QimD+hjKGM03PB*9h[he`"LAq+mGedS00A138DPMC)T,$a5[X[GmRhQ#hqjUR,C* Yh2IJR-TfcC`R,,4a6iQAQ&fE9%6GH[Hq(Crb1U[DaqE0hVfMD!E+G0D9iZ[fr5k rN6LVXki8cl$hqaal-bRMlCY9ccEZafJJbVDT'b3F2kNC(qfV#1FiC2@5Z&lqr`d !"8PMEfi0D@p38%-ZE@0`!*!4H$-*KJ#3$iB!!$q)!*!$&J#3"'PMEfj038063!# eQI#%YCR`K!!!!HB!N!B"&3#3""F@!*!)JE)4!!JF[-XKL%Vqkr)IQ(qRr&[Nla6 hDYcMFCFjq"YaTmHeLN[2GdpFcRaEjcXYAk0m21qMq8VPh6[[,ARVj-h+FeLHar* XRZHi20im2E`Aj5RJ6I0HR2Y9EqIFjhU,j8l,I9eZP$XeGilF20HCZF[QV*!!Frm F0q9-c,&GMVGcP-Pa@1aj14V(GSQp1qE4f25BR@-hL'NEFkrRVTMdQ%GLYiSj-,D qXmMT%0kG+6`p!r+B3c"H,b-CF*54$%p[fY"-D$T(Emh-i#$Rk@eK'$HR8'ZQ(!T cYqY-%A+HIQQ%K@(XR2`ZdLmbcpr'-b3U-8II58AYQIfMclTCrUa,aK5GkLJ8DZY dYLC!(J4+k5cqV!ZZX3#3!`d0$&*&384045j0B@028f0`!*!4KZB*KJ#3$Mi$!!" $(J#3!aErN!4849K8G(4iG!%!VZP",E@CpXm!!!'X!!!%5`#3!md!!!*C*YQfB3# 3"M&!%3!)(1ad#')JLFI%1Rb*Jij4$SQpPB0bK,62fc8T)G'Ij216P-l"P'KkQ)V "9!65Xe)GTD5H!!J3)B2Y3fARKLIIKp0[UTHYN!"1TZXCRhC&(mcFBpDR'HL$*'B bTRkDJEjBKM3rJcd9[(l15!U(i9GF#&#aYR)HIf+0dbT$lV2bl"JXUUC$EZHE"al 2iakBaArh`'Q21'8UXp'm)bLH6D%Jj*ZT4*peCGa0ec5-ImP4+,3"j!m%ZqTYqZ6 3G)IlBUBS06Yib'K"cmeeX!8+SJ#!)!1BM"JC-!+`$L,X(*!!!I2)5Sk5@mQapmK 4)jc-'!()lfAi9c`$q#LHiJRk%3`%F23LI'9'RJd))mKJ"$&X*HX$!2R!j-"86Di hP&T,(j5qZD143lS3BL2ThP2PI'XI5AP$NipTUQ[5Y8[4mDG"DGPqH44E5H18D(G GRYhHlZ5J4h+q)$f2NA("kX4KNAR[25[cBc!alGMBre3)MJ2G"UBhKAa3RC@#L!k YLdqqiJYGlkUJ`N*eRJ92AV,"NXVII@4++M3fa6*3F@STdf5#C'1L-A!6e&"Bmk- i@SYrMNqP%#KPLKKmkB3@RNJV6mT!k,10E!"'#$la2"5TmcHT!P5IN3-mIH58Q96 #$lKPhbr8+NLf&J("!%4ND4QlQ0dA*j@UqNA-l&mPQMPd'+DhCae+d4&89pQj2k, C$*%#4#&Sih`6FaYB&mlVIM,@B(82mSImU#!"I(BSTA4f0&K[0Bhpe#"`31l*&!Q GjeQd21Fj9$,cK*Z5-6*A$6f@S"H0)mXXp68BV-T,`8&6,QpI3ZUC1dK"1cN)G&H &59X*!0YIFKAPj&eMT@k&q-$'e8kVj0K(+E'e@DqffpAjf3A41$Y%i#mMa'&E0V( @dUZSC--2ZAjm2YUCDYGEa'#3!%!*lImdGq`IE-J"rMa-*q8HPC2dkekJ#P#K3!U 6KaS80)bpFKkS&H0D+KTFM!Makqek*cDEeIVmVlaVp`MSlqK9EiHF[1p`(jN120# 90cC%kk9BRkifTk[eqXJhZ,jECVAm"V`IMITMrqNXlklhKl[p$@hPqZ48LRmK)3Y MCQPdFfP[AfeKB`#3&JQ'!4B!&3+L!GB!N!-"!!!rL!#3"aB!N!1'!!!$([q3"!2 JYCR`K,@Cp[N!N!8"mK%!N!C#Q2r`rrJ!!-0!!!!3DBZi!!!: healpy-1.10.3/cfitsio/cfortran.h0000664000175000017500000040757213010375004016765 0ustar zoncazonca00000000000000/* cfortran.h 4.4 */ /* http://www-zeus.desy.de/~burow/cfortran/ */ /* Burkhard Burow burow@desy.de 1990 - 2002. */ #ifndef __CFORTRAN_LOADED #define __CFORTRAN_LOADED /* THIS FILE IS PROPERTY OF BURKHARD BUROW. IF YOU ARE USING THIS FILE YOU SHOULD ALSO HAVE ACCESS TO CFORTRAN.DOC WHICH PROVIDES TERMS FOR USING, MODIFYING, COPYING AND DISTRIBUTING THE CFORTRAN.H PACKAGE. */ /* The following modifications were made by the authors of CFITSIO or by me. * They are flagged below with CFITSIO, the author's initials, or KMCCARTY. * PDW = Peter Wilson * DM = Doug Mink * LEB = Lee E Brotzman * MR = Martin Reinecke * WDP = William D Pence * -- Kevin McCarty, for Debian (19 Dec. 2005) */ /******* Modifications: Oct 1997: Changed symbol name extname to appendus (PDW/HSTX) (Conflicted with a common variable name in FTOOLS) Nov 1997: If g77Fortran defined, also define f2cFortran (PDW/HSTX) Feb 1998: Let VMS see the NUM_ELEMS code. Lets programs treat single strings as vectors with single elements Nov 1999: If macintoxh defined, also define f2cfortran (for Mac OS-X) Apr 2000: If WIN32 defined, also define PowerStationFortran and VISUAL_CPLUSPLUS (Visual C++) Jun 2000: If __GNUC__ and linux defined, also define f2cFortran (linux/gcc environment detection) Apr 2002: If __CYGWIN__ is defined, also define f2cFortran Nov 2002: If __APPLE__ defined, also define f2cfortran (for Mac OS-X) Nov 2003: If __INTEL_COMPILER or INTEL_COMPILER defined, also define f2cFortran (KMCCARTY) Dec 2005: If f2cFortran is defined, enforce REAL functions in FORTRAN returning "double" in C. This was one of the items on Burkhard's TODO list. (KMCCARTY) Dec 2005: Modifications to support 8-byte integers. (MR) USE AT YOUR OWN RISK! Feb 2006 Added logic to typedef the symbol 'LONGLONG' to an appropriate intrinsic 8-byte integer datatype (WDP) Apr 2006: Modifications to support gfortran (and g77 with -fno-f2c flag) since by default it returns "float" for FORTRAN REAL function. (KMCCARTY) May 2008: Revert commenting out of "extern" in COMMON_BLOCK_DEF macro. Add braces around do-nothing ";" in 3 empty while blocks to get rid of compiler warnings. Thanks to ROOT developers Jacek Holeczek and Rene Brun for these suggestions. (KMCCARTY) Dec 2008 Added typedef for LONGLONG to support Borland compiler (WDP) *******/ /* Avoid symbols already used by compilers and system *.h: __ - OSF1 zukal06 V3.0 347 alpha, cc -c -std1 cfortest.c */ /* Determine what 8-byte integer data type is available. 'long long' is now supported by most compilers, but older MS Visual C++ compilers before V7.0 use '__int64' instead. (WDP) */ #ifndef LONGLONG_TYPE /* this may have been previously defined */ #if defined(_MSC_VER) /* Microsoft Visual C++ */ #if (_MSC_VER < 1300) /* versions earlier than V7.0 do not have 'long long' */ typedef __int64 LONGLONG; #else /* newer versions do support 'long long' */ typedef long long LONGLONG; #endif #elif defined( __BORLANDC__) /* (WDP) for the free Borland compiler, in particular */ typedef __int64 LONGLONG; #else typedef long long LONGLONG; #endif #define LONGLONG_TYPE #endif /* First prepare for the C compiler. */ #ifndef ANSI_C_preprocessor /* i.e. user can override. */ #ifdef __CF__KnR #define ANSI_C_preprocessor 0 #else #ifdef __STDC__ #define ANSI_C_preprocessor 1 #else #define _cfleft 1 #define _cfright #define _cfleft_cfright 0 #define ANSI_C_preprocessor _cfleft/**/_cfright #endif #endif #endif #if ANSI_C_preprocessor #define _0(A,B) A##B #define _(A,B) _0(A,B) /* see cat,xcat of K&R ANSI C p. 231 */ #define _2(A,B) A##B /* K&R ANSI C p.230: .. identifier is not replaced */ #define _3(A,B,C) _(A,_(B,C)) #else /* if it turns up again during rescanning. */ #define _(A,B) A/**/B #define _2(A,B) A/**/B #define _3(A,B,C) A/**/B/**/C #endif #if (defined(vax)&&defined(unix)) || (defined(__vax__)&&defined(__unix__)) #define VAXUltrix #endif #include /* NULL [in all machines stdio.h] */ #include /* strlen, memset, memcpy, memchr. */ #if !( defined(VAXUltrix) || defined(sun) || (defined(apollo)&&!defined(__STDCPP__)) ) #include /* malloc,free */ #else #include /* Had to be removed for DomainOS h105 10.4 sys5.3 425t*/ #ifdef apollo #define __CF__APOLLO67 /* __STDCPP__ is in Apollo 6.8 (i.e. ANSI) and onwards */ #endif #endif #if !defined(__GNUC__) && !defined(__sun) && (defined(sun)||defined(VAXUltrix)||defined(lynx)) #define __CF__KnR /* Sun, LynxOS and VAX Ultrix cc only supports K&R. */ /* Manually define __CF__KnR for HP if desired/required.*/ #endif /* i.e. We will generate Kernighan and Ritchie C. */ /* Note that you may define __CF__KnR before #include cfortran.h, in order to generate K&R C instead of the default ANSI C. The differences are mainly in the function prototypes and declarations. All machines, except the Apollo, work with either style. The Apollo's argument promotion rules require ANSI or use of the obsolete std_$call which we have not implemented here. Hence on the Apollo, only C calling FORTRAN subroutines will work using K&R style.*/ /* Remainder of cfortran.h depends on the Fortran compiler. */ /* 11/29/2003 (KMCCARTY): add *INTEL_COMPILER symbols here */ /* 04/05/2006 (KMCCARTY): add gFortran symbol here */ #if defined(CLIPPERFortran) || defined(pgiFortran) || defined(__INTEL_COMPILER) || defined(INTEL_COMPILER) || defined(gFortran) #define f2cFortran #endif /* VAX/VMS does not let us \-split long #if lines. */ /* Split #if into 2 because some HP-UX can't handle long #if */ #if !(defined(NAGf90Fortran)||defined(f2cFortran)||defined(hpuxFortran)||defined(apolloFortran)||defined(sunFortran)||defined(IBMR2Fortran)||defined(CRAYFortran)) #if !(defined(mipsFortran)||defined(DECFortran)||defined(vmsFortran)||defined(CONVEXFortran)||defined(PowerStationFortran)||defined(AbsoftUNIXFortran)||defined(AbsoftProFortran)||defined(SXFortran)) /* If no Fortran compiler is given, we choose one for the machines we know. */ #if defined(lynx) || defined(VAXUltrix) #define f2cFortran /* Lynx: Only support f2c at the moment. VAXUltrix: f77 behaves like f2c. Support f2c or f77 with gcc, vcc with f2c. f77 with vcc works, missing link magic for f77 I/O.*/ #endif /* 04/13/00 DM (CFITSIO): Add these lines for NT */ /* with PowerStationFortran and and Visual C++ */ #if defined(WIN32) && !defined(__CYGWIN__) #define PowerStationFortran #define VISUAL_CPLUSPLUS #endif #if defined(g77Fortran) /* 11/03/97 PDW (CFITSIO) */ #define f2cFortran #endif #if defined(__CYGWIN__) /* 04/11/02 LEB (CFITSIO) */ #define f2cFortran #endif #if defined(__GNUC__) && defined(linux) /* 06/21/00 PDW (CFITSIO) */ #define f2cFortran #endif #if defined(macintosh) /* 11/1999 (CFITSIO) */ #define f2cFortran #endif #if defined(__APPLE__) /* 11/2002 (CFITSIO) */ #define f2cFortran #endif #if defined(__hpux) /* 921107: Use __hpux instead of __hp9000s300 */ #define hpuxFortran /* Should also allow hp9000s7/800 use.*/ #endif #if defined(apollo) #define apolloFortran /* __CF__APOLLO67 also defines some behavior. */ #endif #if defined(sun) || defined(__sun) #define sunFortran #endif #if defined(_IBMR2) #define IBMR2Fortran #endif #if defined(_CRAY) #define CRAYFortran /* _CRAYT3E also defines some behavior. */ #endif #if defined(_SX) #define SXFortran #endif #if defined(mips) || defined(__mips) #define mipsFortran #endif #if defined(vms) || defined(__vms) #define vmsFortran #endif #if defined(__alpha) && defined(__unix__) #define DECFortran #endif #if defined(__convex__) #define CONVEXFortran #endif #if defined(VISUAL_CPLUSPLUS) #define PowerStationFortran #endif #endif /* ...Fortran */ #endif /* ...Fortran */ /* Split #if into 2 because some HP-UX can't handle long #if */ #if !(defined(NAGf90Fortran)||defined(f2cFortran)||defined(hpuxFortran)||defined(apolloFortran)||defined(sunFortran)||defined(IBMR2Fortran)||defined(CRAYFortran)) #if !(defined(mipsFortran)||defined(DECFortran)||defined(vmsFortran)||defined(CONVEXFortran)||defined(PowerStationFortran)||defined(AbsoftUNIXFortran)||defined(AbsoftProFortran)||defined(SXFortran)) /* If your compiler barfs on ' #error', replace # with the trigraph for # */ #error "cfortran.h: Can't find your environment among:\ - GNU gcc (g77) on Linux. \ - MIPS cc and f77 2.0. (e.g. Silicon Graphics, DECstations, ...) \ - IBM AIX XL C and FORTRAN Compiler/6000 Version 01.01.0000.0000 \ - VAX VMS CC 3.1 and FORTRAN 5.4. \ - Alpha VMS DEC C 1.3 and DEC FORTRAN 6.0. \ - Alpha OSF DEC C and DEC Fortran for OSF/1 AXP Version 1.2 \ - Apollo DomainOS 10.2 (sys5.3) with f77 10.7 and cc 6.7. \ - CRAY \ - NEC SX-4 SUPER-UX \ - CONVEX \ - Sun \ - PowerStation Fortran with Visual C++ \ - HP9000s300/s700/s800 Latest test with: HP-UX A.08.07 A 9000/730 \ - LynxOS: cc or gcc with f2c. \ - VAXUltrix: vcc,cc or gcc with f2c. gcc or cc with f77. \ - f77 with vcc works; but missing link magic for f77 I/O. \ - NO fort. None of gcc, cc or vcc generate required names.\ - f2c/g77: Use #define f2cFortran, or cc -Df2cFortran \ - gfortran: Use #define gFortran, or cc -DgFortran \ (also necessary for g77 with -fno-f2c option) \ - NAG f90: Use #define NAGf90Fortran, or cc -DNAGf90Fortran \ - Absoft UNIX F77: Use #define AbsoftUNIXFortran or cc -DAbsoftUNIXFortran \ - Absoft Pro Fortran: Use #define AbsoftProFortran \ - Portland Group Fortran: Use #define pgiFortran \ - Intel Fortran: Use #define INTEL_COMPILER" /* Compiler must throw us out at this point! */ #endif #endif #if defined(VAXC) && !defined(__VAXC) #define OLD_VAXC #pragma nostandard /* Prevent %CC-I-PARAMNOTUSED. */ #endif /* Throughout cfortran.h we use: UN = Uppercase Name. LN = Lowercase Name. */ /* "extname" changed to "appendus" below (CFITSIO) */ #if defined(f2cFortran) || defined(NAGf90Fortran) || defined(DECFortran) || defined(mipsFortran) || defined(apolloFortran) || defined(sunFortran) || defined(CONVEXFortran) || defined(SXFortran) || defined(appendus) #define CFC_(UN,LN) _(LN,_) /* Lowercase FORTRAN symbols. */ #define orig_fcallsc(UN,LN) CFC_(UN,LN) #else #if defined(CRAYFortran) || defined(PowerStationFortran) || defined(AbsoftProFortran) #ifdef _CRAY /* (UN), not UN, circumvents CRAY preprocessor bug. */ #define CFC_(UN,LN) (UN) /* Uppercase FORTRAN symbols. */ #else /* At least VISUAL_CPLUSPLUS barfs on (UN), so need UN. */ #define CFC_(UN,LN) UN /* Uppercase FORTRAN symbols. */ #endif #define orig_fcallsc(UN,LN) CFC_(UN,LN) /* CRAY insists on arg.'s here. */ #else /* For following machines one may wish to change the fcallsc default. */ #define CF_SAME_NAMESPACE #ifdef vmsFortran #define CFC_(UN,LN) LN /* Either case FORTRAN symbols. */ /* BUT we usually use UN for C macro to FORTRAN routines, so use LN here,*/ /* because VAX/VMS doesn't do recursive macros. */ #define orig_fcallsc(UN,LN) UN #else /* HP-UX without +ppu or IBMR2 without -qextname. NOT reccomended. */ #define CFC_(UN,LN) LN /* Lowercase FORTRAN symbols. */ #define orig_fcallsc(UN,LN) CFC_(UN,LN) #endif /* vmsFortran */ #endif /* CRAYFortran PowerStationFortran */ #endif /* ....Fortran */ #define fcallsc(UN,LN) orig_fcallsc(UN,LN) #define preface_fcallsc(P,p,UN,LN) CFC_(_(P,UN),_(p,LN)) #define append_fcallsc(P,p,UN,LN) CFC_(_(UN,P),_(LN,p)) #define C_FUNCTION(UN,LN) fcallsc(UN,LN) #define FORTRAN_FUNCTION(UN,LN) CFC_(UN,LN) #ifndef COMMON_BLOCK #ifndef CONVEXFortran #ifndef CLIPPERFortran #if !(defined(AbsoftUNIXFortran)||defined(AbsoftProFortran)) #define COMMON_BLOCK(UN,LN) CFC_(UN,LN) #else #define COMMON_BLOCK(UN,LN) _(_C,LN) #endif /* AbsoftUNIXFortran or AbsoftProFortran */ #else #define COMMON_BLOCK(UN,LN) _(LN,__) #endif /* CLIPPERFortran */ #else #define COMMON_BLOCK(UN,LN) _3(_,LN,_) #endif /* CONVEXFortran */ #endif /* COMMON_BLOCK */ #ifndef DOUBLE_PRECISION #if defined(CRAYFortran) && !defined(_CRAYT3E) #define DOUBLE_PRECISION long double #else #define DOUBLE_PRECISION double #endif #endif #ifndef FORTRAN_REAL #if defined(CRAYFortran) && defined(_CRAYT3E) #define FORTRAN_REAL double #else #define FORTRAN_REAL float #endif #endif #ifdef CRAYFortran #ifdef _CRAY #include #else #include "fortran.h" /* i.e. if crosscompiling assume user has file. */ #endif #define FLOATVVVVVVV_cfPP (FORTRAN_REAL *) /* Used for C calls FORTRAN. */ /* CRAY's double==float but CRAY says pointers to doubles and floats are diff.*/ #define VOIDP (void *) /* When FORTRAN calls C, we don't know if C routine arg.'s have been declared float *, or double *. */ #else #define FLOATVVVVVVV_cfPP #define VOIDP #endif #ifdef vmsFortran #if defined(vms) || defined(__vms) #include #else #include "descrip.h" /* i.e. if crosscompiling assume user has file. */ #endif #endif #ifdef sunFortran #if defined(sun) || defined(__sun) #include /* Sun's FLOATFUNCTIONTYPE, ASSIGNFLOAT, RETURNFLOAT. */ #else #include "math.h" /* i.e. if crosscompiling assume user has file. */ #endif /* At least starting with the default C compiler SC3.0.1 of SunOS 5.3, * FLOATFUNCTIONTYPE, ASSIGNFLOAT, RETURNFLOAT are not required and not in * , since sun C no longer promotes C float return values to doubles. * Therefore, only use them if defined. * Even if gcc is being used, assume that it exhibits the Sun C compiler * behavior in order to be able to use *.o from the Sun C compiler. * i.e. If FLOATFUNCTIONTYPE, etc. are in math.h, they required by gcc. */ #endif #ifndef apolloFortran #define COMMON_BLOCK_DEF(DEFINITION, NAME) extern DEFINITION NAME #define CF_NULL_PROTO #else /* HP doesn't understand #elif. */ /* Without ANSI prototyping, Apollo promotes float functions to double. */ /* Note that VAX/VMS, IBM, Mips choke on 'type function(...);' prototypes. */ #define CF_NULL_PROTO ... #ifndef __CF__APOLLO67 #define COMMON_BLOCK_DEF(DEFINITION, NAME) \ DEFINITION NAME __attribute((__section(NAME))) #else #define COMMON_BLOCK_DEF(DEFINITION, NAME) \ DEFINITION NAME #attribute[section(NAME)] #endif #endif #ifdef __cplusplus #undef CF_NULL_PROTO #define CF_NULL_PROTO ... #endif #ifndef USE_NEW_DELETE #ifdef __cplusplus #define USE_NEW_DELETE 1 #else #define USE_NEW_DELETE 0 #endif #endif #if USE_NEW_DELETE #define _cf_malloc(N) new char[N] #define _cf_free(P) delete[] P #else #define _cf_malloc(N) (char *)malloc(N) #define _cf_free(P) free(P) #endif #ifdef mipsFortran #define CF_DECLARE_GETARG int f77argc; char **f77argv #define CF_SET_GETARG(ARGC,ARGV) f77argc = ARGC; f77argv = ARGV #else #define CF_DECLARE_GETARG #define CF_SET_GETARG(ARGC,ARGV) #endif #ifdef OLD_VAXC /* Allow %CC-I-PARAMNOTUSED. */ #pragma standard #endif #define AcfCOMMA , #define AcfCOLON ; /*-------------------------------------------------------------------------*/ /* UTILITIES USED WITHIN CFORTRAN.H */ #define _cfMIN(A,B) (As) { /* Need this to handle NULL string.*/ while (e>s && *--e==t) {;} /* Don't follow t's past beginning. */ e[*e==t?0:1] = '\0'; /* Handle s[0]=t correctly. */ } return s; } /* kill_trailingn(s,t,e) will kill the trailing t's in string s. e normally points to the terminating '\0' of s, but may actually point to anywhere in s. s's new '\0' will be placed at e or earlier in order to remove any trailing t's. If es) { /* Watch out for neg. length string.*/ while (e>s && *--e==t){;} /* Don't follow t's past beginning. */ e[*e==t?0:1] = '\0'; /* Handle s[0]=t correctly. */ } return s; } /* Note the following assumes that any element which has t's to be chopped off, does indeed fill the entire element. */ #ifndef __CF__KnR static char *vkill_trailing(char* cstr, int elem_len, int sizeofcstr, char t) #else static char *vkill_trailing( cstr, elem_len, sizeofcstr, t) char* cstr; int elem_len; int sizeofcstr; char t; #endif { int i; for (i=0; i= 4.3 gives message: zow35> cc -c -DDECFortran cfortest.c cfe: Fatal: Out of memory: cfortest.c zow35> Old __hpux had the problem, but new 'HP-UX A.09.03 A 9000/735' is fine if using -Aa, otherwise we have a problem. */ #ifndef MAX_PREPRO_ARGS #if !defined(__GNUC__) && (defined(VAXUltrix) || defined(__CF__APOLLO67) || (defined(sun)&&!defined(__sun)) || defined(_CRAY) || defined(__ultrix__) || (defined(__hpux)&&defined(__CF__KnR))) #define MAX_PREPRO_ARGS 31 #else #define MAX_PREPRO_ARGS 99 #endif #endif #if defined(AbsoftUNIXFortran) || defined(AbsoftProFortran) /* In addition to explicit Absoft stuff, only Absoft requires: - DEFAULT coming from _cfSTR. DEFAULT could have been called e.g. INT, but keep it for clarity. - M term in CFARGT14 and CFARGT14FS. */ #define ABSOFT_cf1(T0) _(T0,_cfSTR)(0,ABSOFT1,0,0,0,0,0) #define ABSOFT_cf2(T0) _(T0,_cfSTR)(0,ABSOFT2,0,0,0,0,0) #define ABSOFT_cf3(T0) _(T0,_cfSTR)(0,ABSOFT3,0,0,0,0,0) #define DEFAULT_cfABSOFT1 #define LOGICAL_cfABSOFT1 #define STRING_cfABSOFT1 ,MAX_LEN_FORTRAN_FUNCTION_STRING #define DEFAULT_cfABSOFT2 #define LOGICAL_cfABSOFT2 #define STRING_cfABSOFT2 ,unsigned D0 #define DEFAULT_cfABSOFT3 #define LOGICAL_cfABSOFT3 #define STRING_cfABSOFT3 ,D0 #else #define ABSOFT_cf1(T0) #define ABSOFT_cf2(T0) #define ABSOFT_cf3(T0) #endif /* _Z introduced to cicumvent IBM and HP silly preprocessor warning. e.g. "Macro CFARGT14 invoked with a null argument." */ #define _Z #define CFARGT14S(S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ S(T1,1) S(T2,2) S(T3,3) S(T4,4) S(T5,5) S(T6,6) S(T7,7) \ S(T8,8) S(T9,9) S(TA,10) S(TB,11) S(TC,12) S(TD,13) S(TE,14) #define CFARGT27S(S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ S(T1,1) S(T2,2) S(T3,3) S(T4,4) S(T5,5) S(T6,6) S(T7,7) \ S(T8,8) S(T9,9) S(TA,10) S(TB,11) S(TC,12) S(TD,13) S(TE,14) \ S(TF,15) S(TG,16) S(TH,17) S(TI,18) S(TJ,19) S(TK,20) S(TL,21) \ S(TM,22) S(TN,23) S(TO,24) S(TP,25) S(TQ,26) S(TR,27) #define CFARGT14FS(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ F(T1,1,0) F(T2,2,1) F(T3,3,1) F(T4,4,1) F(T5,5,1) F(T6,6,1) F(T7,7,1) \ F(T8,8,1) F(T9,9,1) F(TA,10,1) F(TB,11,1) F(TC,12,1) F(TD,13,1) F(TE,14,1) \ M CFARGT14S(S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) #define CFARGT27FS(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ F(T1,1,0) F(T2,2,1) F(T3,3,1) F(T4,4,1) F(T5,5,1) F(T6,6,1) F(T7,7,1) \ F(T8,8,1) F(T9,9,1) F(TA,10,1) F(TB,11,1) F(TC,12,1) F(TD,13,1) F(TE,14,1) \ F(TF,15,1) F(TG,16,1) F(TH,17,1) F(TI,18,1) F(TJ,19,1) F(TK,20,1) F(TL,21,1) \ F(TM,22,1) F(TN,23,1) F(TO,24,1) F(TP,25,1) F(TQ,26,1) F(TR,27,1) \ M CFARGT27S(S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) #if !(defined(PowerStationFortran)||defined(hpuxFortran800)) /* Old CFARGT14 -> CFARGT14FS as seen below, for Absoft cross-compile yields: SunOS> cc -c -Xa -DAbsoftUNIXFortran c.c "c.c", line 406: warning: argument mismatch Haven't checked if this is ANSI C or a SunOS bug. SunOS -Xs works ok. Behavior is most clearly seen in example: #define A 1 , 2 #define C(X,Y,Z) x=X. y=Y. z=Z. #define D(X,Y,Z) C(X,Y,Z) D(x,A,z) Output from preprocessor is: x = x . y = 1 . z = 2 . #define CFARGT14(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ CFARGT14FS(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) */ #define CFARGT14(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ F(T1,1,0) F(T2,2,1) F(T3,3,1) F(T4,4,1) F(T5,5,1) F(T6,6,1) F(T7,7,1) \ F(T8,8,1) F(T9,9,1) F(TA,10,1) F(TB,11,1) F(TC,12,1) F(TD,13,1) F(TE,14,1) \ M CFARGT14S(S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) #define CFARGT27(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ F(T1,1,0) F(T2,2,1) F(T3,3,1) F(T4,4,1) F(T5,5,1) F(T6,6,1) F(T7,7,1) \ F(T8,8,1) F(T9,9,1) F(TA,10,1) F(TB,11,1) F(TC,12,1) F(TD,13,1) F(TE,14,1) \ F(TF,15,1) F(TG,16,1) F(TH,17,1) F(TI,18,1) F(TJ,19,1) F(TK,20,1) F(TL,21,1) \ F(TM,22,1) F(TN,23,1) F(TO,24,1) F(TP,25,1) F(TQ,26,1) F(TR,27,1) \ M CFARGT27S(S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) #define CFARGT20(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) \ F(T1,1,0) F(T2,2,1) F(T3,3,1) F(T4,4,1) F(T5,5,1) F(T6,6,1) F(T7,7,1) \ F(T8,8,1) F(T9,9,1) F(TA,10,1) F(TB,11,1) F(TC,12,1) F(TD,13,1) F(TE,14,1) \ F(TF,15,1) F(TG,16,1) F(TH,17,1) F(TI,18,1) F(TJ,19,1) F(TK,20,1) \ S(T1,1) S(T2,2) S(T3,3) S(T4,4) S(T5,5) S(T6,6) S(T7,7) \ S(T8,8) S(T9,9) S(TA,10) S(TB,11) S(TC,12) S(TD,13) S(TE,14) \ S(TF,15) S(TG,16) S(TH,17) S(TI,18) S(TJ,19) S(TK,20) #define CFARGTA14(F,S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE) \ F(T1,A1,1,0) F(T2,A2,2,1) F(T3,A3,3,1) F(T4,A4,4,1) F(T5,A5,5,1) F(T6,A6,6,1) \ F(T7,A7,7,1) F(T8,A8,8,1) F(T9,A9,9,1) F(TA,AA,10,1) F(TB,AB,11,1) F(TC,AC,12,1) \ F(TD,AD,13,1) F(TE,AE,14,1) S(T1,1) S(T2,2) S(T3,3) S(T4,4) \ S(T5,5) S(T6,6) S(T7,7) S(T8,8) S(T9,9) S(TA,10) \ S(TB,11) S(TC,12) S(TD,13) S(TE,14) #if MAX_PREPRO_ARGS>31 #define CFARGTA20(F,S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK) \ F(T1,A1,1,0) F(T2,A2,2,1) F(T3,A3,3,1) F(T4,A4,4,1) F(T5,A5,5,1) F(T6,A6,6,1) \ F(T7,A7,7,1) F(T8,A8,8,1) F(T9,A9,9,1) F(TA,AA,10,1) F(TB,AB,11,1) F(TC,AC,12,1) \ F(TD,AD,13,1) F(TE,AE,14,1) F(TF,AF,15,1) F(TG,AG,16,1) F(TH,AH,17,1) F(TI,AI,18,1) \ F(TJ,AJ,19,1) F(TK,AK,20,1) S(T1,1) S(T2,2) S(T3,3) S(T4,4) \ S(T5,5) S(T6,6) S(T7,7) S(T8,8) S(T9,9) S(TA,10) \ S(TB,11) S(TC,12) S(TD,13) S(TE,14) S(TF,15) S(TG,16) \ S(TH,17) S(TI,18) S(TJ,19) S(TK,20) #define CFARGTA27(F,S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR) \ F(T1,A1,1,0) F(T2,A2,2,1) F(T3,A3,3,1) F(T4,A4,4,1) F(T5,A5,5,1) F(T6,A6,6,1) \ F(T7,A7,7,1) F(T8,A8,8,1) F(T9,A9,9,1) F(TA,AA,10,1) F(TB,AB,11,1) F(TC,AC,12,1) \ F(TD,AD,13,1) F(TE,AE,14,1) F(TF,AF,15,1) F(TG,AG,16,1) F(TH,AH,17,1) F(TI,AI,18,1) \ F(TJ,AJ,19,1) F(TK,AK,20,1) F(TL,AL,21,1) F(TM,AM,22,1) F(TN,AN,23,1) F(TO,AO,24,1) \ F(TP,AP,25,1) F(TQ,AQ,26,1) F(TR,AR,27,1) S(T1,1) S(T2,2) S(T3,3) \ S(T4,4) S(T5,5) S(T6,6) S(T7,7) S(T8,8) S(T9,9) \ S(TA,10) S(TB,11) S(TC,12) S(TD,13) S(TE,14) S(TF,15) \ S(TG,16) S(TH,17) S(TI,18) S(TJ,19) S(TK,20) S(TL,21) \ S(TM,22) S(TN,23) S(TO,24) S(TP,25) S(TQ,26) S(TR,27) #endif #else #define CFARGT14(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ F(T1,1,0) S(T1,1) F(T2,2,1) S(T2,2) F(T3,3,1) S(T3,3) F(T4,4,1) S(T4,4) \ F(T5,5,1) S(T5,5) F(T6,6,1) S(T6,6) F(T7,7,1) S(T7,7) F(T8,8,1) S(T8,8) \ F(T9,9,1) S(T9,9) F(TA,10,1) S(TA,10) F(TB,11,1) S(TB,11) F(TC,12,1) S(TC,12) \ F(TD,13,1) S(TD,13) F(TE,14,1) S(TE,14) #define CFARGT27(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ F(T1,1,0) S(T1,1) F(T2,2,1) S(T2,2) F(T3,3,1) S(T3,3) F(T4,4,1) S(T4,4) \ F(T5,5,1) S(T5,5) F(T6,6,1) S(T6,6) F(T7,7,1) S(T7,7) F(T8,8,1) S(T8,8) \ F(T9,9,1) S(T9,9) F(TA,10,1) S(TA,10) F(TB,11,1) S(TB,11) F(TC,12,1) S(TC,12) \ F(TD,13,1) S(TD,13) F(TE,14,1) S(TE,14) F(TF,15,1) S(TF,15) F(TG,16,1) S(TG,16) \ F(TH,17,1) S(TH,17) F(TI,18,1) S(TI,18) F(TJ,19,1) S(TJ,19) F(TK,20,1) S(TK,20) \ F(TL,21,1) S(TL,21) F(TM,22,1) S(TM,22) F(TN,23,1) S(TN,23) F(TO,24,1) S(TO,24) \ F(TP,25,1) S(TP,25) F(TQ,26,1) S(TQ,26) F(TR,27,1) S(TR,27) #define CFARGT20(F,S,M,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) \ F(T1,1,0) S(T1,1) F(T2,2,1) S(T2,2) F(T3,3,1) S(T3,3) F(T4,4,1) S(T4,4) \ F(T5,5,1) S(T5,5) F(T6,6,1) S(T6,6) F(T7,7,1) S(T7,7) F(T8,8,1) S(T8,8) \ F(T9,9,1) S(T9,9) F(TA,10,1) S(TA,10) F(TB,11,1) S(TB,11) F(TC,12,1) S(TC,12) \ F(TD,13,1) S(TD,13) F(TE,14,1) S(TE,14) F(TF,15,1) S(TF,15) F(TG,16,1) S(TG,16) \ F(TH,17,1) S(TH,17) F(TI,18,1) S(TI,18) F(TJ,19,1) S(TJ,19) F(TK,20,1) S(TK,20) #define CFARGTA14(F,S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE) \ F(T1,A1,1,0) S(T1,1) F(T2,A2,2,1) S(T2,2) F(T3,A3,3,1) S(T3,3) \ F(T4,A4,4,1) S(T4,4) F(T5,A5,5,1) S(T5,5) F(T6,A6,6,1) S(T6,6) \ F(T7,A7,7,1) S(T7,7) F(T8,A8,8,1) S(T8,8) F(T9,A9,9,1) S(T9,9) \ F(TA,AA,10,1) S(TA,10) F(TB,AB,11,1) S(TB,11) F(TC,AC,12,1) S(TC,12) \ F(TD,AD,13,1) S(TD,13) F(TE,AE,14,1) S(TE,14) #if MAX_PREPRO_ARGS>31 #define CFARGTA20(F,S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK) \ F(T1,A1,1,0) S(T1,1) F(T2,A2,2,1) S(T2,2) F(T3,A3,3,1) S(T3,3) \ F(T4,A4,4,1) S(T4,4) F(T5,A5,5,1) S(T5,5) F(T6,A6,6,1) S(T6,6) \ F(T7,A7,7,1) S(T7,7) F(T8,A8,8,1) S(T8,8) F(T9,A9,9,1) S(T9,9) \ F(TA,AA,10,1) S(TA,10) F(TB,AB,11,1) S(TB,11) F(TC,AC,12,1) S(TC,12) \ F(TD,AD,13,1) S(TD,13) F(TE,AE,14,1) S(TE,14) F(TF,AF,15,1) S(TF,15) \ F(TG,AG,16,1) S(TG,16) F(TH,AH,17,1) S(TH,17) F(TI,AI,18,1) S(TI,18) \ F(TJ,AJ,19,1) S(TJ,19) F(TK,AK,20,1) S(TK,20) #define CFARGTA27(F,S,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR) \ F(T1,A1,1,0) S(T1,1) F(T2,A2,2,1) S(T2,2) F(T3,A3,3,1) S(T3,3) \ F(T4,A4,4,1) S(T4,4) F(T5,A5,5,1) S(T5,5) F(T6,A6,6,1) S(T6,6) \ F(T7,A7,7,1) S(T7,7) F(T8,A8,8,1) S(T8,8) F(T9,A9,9,1) S(T9,9) \ F(TA,AA,10,1) S(TA,10) F(TB,AB,11,1) S(TB,11) F(TC,AC,12,1) S(TC,12) \ F(TD,AD,13,1) S(TD,13) F(TE,AE,14,1) S(TE,14) F(TF,AF,15,1) S(TF,15) \ F(TG,AG,16,1) S(TG,16) F(TH,AH,17,1) S(TH,17) F(TI,AI,18,1) S(TI,18) \ F(TJ,AJ,19,1) S(TJ,19) F(TK,AK,20,1) S(TK,20) F(TL,AL,21,1) S(TL,21) \ F(TM,AM,22,1) S(TM,22) F(TN,AN,23,1) S(TN,23) F(TO,AO,24,1) S(TO,24) \ F(TP,AP,25,1) S(TP,25) F(TQ,AQ,26,1) S(TQ,26) F(TR,AR,27,1) S(TR,27) #endif #endif #define PROTOCCALLSFSUB1( UN,LN,T1) \ PROTOCCALLSFSUB14(UN,LN,T1,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB2( UN,LN,T1,T2) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB3( UN,LN,T1,T2,T3) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB4( UN,LN,T1,T2,T3,T4) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB5( UN,LN,T1,T2,T3,T4,T5) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB6( UN,LN,T1,T2,T3,T4,T5,T6) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB7( UN,LN,T1,T2,T3,T4,T5,T6,T7) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB8( UN,LN,T1,T2,T3,T4,T5,T6,T7,T8) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB9( UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB10(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB11(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB12(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,CF_0,CF_0) #define PROTOCCALLSFSUB13(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,CF_0) #define PROTOCCALLSFSUB15(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF) \ PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB16(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG) \ PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB17(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH) \ PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB18(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI) \ PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,CF_0,CF_0) #define PROTOCCALLSFSUB19(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ) \ PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,CF_0) #define PROTOCCALLSFSUB21(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL) \ PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB22(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM) \ PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB23(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN) \ PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB24(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO) \ PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,CF_0,CF_0,CF_0) #define PROTOCCALLSFSUB25(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP) \ PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,CF_0,CF_0) #define PROTOCCALLSFSUB26(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ) \ PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,CF_0) #ifndef FCALLSC_QUALIFIER #ifdef VISUAL_CPLUSPLUS #define FCALLSC_QUALIFIER __stdcall #else #define FCALLSC_QUALIFIER #endif #endif #ifdef __cplusplus #define CFextern extern "C" #else #define CFextern extern #endif #ifdef CFSUBASFUN #define PROTOCCALLSFSUB0(UN,LN) \ PROTOCCALLSFFUN0( VOID,UN,LN) #define PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ PROTOCCALLSFFUN14(VOID,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) #define PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK)\ PROTOCCALLSFFUN20(VOID,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) #define PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR)\ PROTOCCALLSFFUN27(VOID,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) #else /* Note: Prevent compiler warnings, null #define PROTOCCALLSFSUB14/20 after #include-ing cfortran.h if calling the FORTRAN wrapper within the same source code where the wrapper is created. */ #define PROTOCCALLSFSUB0(UN,LN) _(VOID,_cfPU)(CFC_(UN,LN))(); #ifndef __CF__KnR #define PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ _(VOID,_cfPU)(CFC_(UN,LN))( CFARGT14(NCF,KCF,_Z,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) ); #define PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK)\ _(VOID,_cfPU)(CFC_(UN,LN))( CFARGT20(NCF,KCF,_Z,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) ); #define PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR)\ _(VOID,_cfPU)(CFC_(UN,LN))( CFARGT27(NCF,KCF,_Z,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) ); #else #define PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ PROTOCCALLSFSUB0(UN,LN) #define PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) \ PROTOCCALLSFSUB0(UN,LN) #define PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ PROTOCCALLSFSUB0(UN,LN) #endif #endif #ifdef OLD_VAXC /* Allow %CC-I-PARAMNOTUSED. */ #pragma standard #endif #define CCALLSFSUB1( UN,LN,T1, A1) \ CCALLSFSUB5 (UN,LN,T1,CF_0,CF_0,CF_0,CF_0,A1,0,0,0,0) #define CCALLSFSUB2( UN,LN,T1,T2, A1,A2) \ CCALLSFSUB5 (UN,LN,T1,T2,CF_0,CF_0,CF_0,A1,A2,0,0,0) #define CCALLSFSUB3( UN,LN,T1,T2,T3, A1,A2,A3) \ CCALLSFSUB5 (UN,LN,T1,T2,T3,CF_0,CF_0,A1,A2,A3,0,0) #define CCALLSFSUB4( UN,LN,T1,T2,T3,T4, A1,A2,A3,A4)\ CCALLSFSUB5 (UN,LN,T1,T2,T3,T4,CF_0,A1,A2,A3,A4,0) #define CCALLSFSUB5( UN,LN,T1,T2,T3,T4,T5, A1,A2,A3,A4,A5) \ CCALLSFSUB10(UN,LN,T1,T2,T3,T4,T5,CF_0,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,0,0,0,0,0) #define CCALLSFSUB6( UN,LN,T1,T2,T3,T4,T5,T6, A1,A2,A3,A4,A5,A6) \ CCALLSFSUB10(UN,LN,T1,T2,T3,T4,T5,T6,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,0,0,0,0) #define CCALLSFSUB7( UN,LN,T1,T2,T3,T4,T5,T6,T7, A1,A2,A3,A4,A5,A6,A7) \ CCALLSFSUB10(UN,LN,T1,T2,T3,T4,T5,T6,T7,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,0,0,0) #define CCALLSFSUB8( UN,LN,T1,T2,T3,T4,T5,T6,T7,T8, A1,A2,A3,A4,A5,A6,A7,A8) \ CCALLSFSUB10(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,0,0) #define CCALLSFSUB9( UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,A1,A2,A3,A4,A5,A6,A7,A8,A9)\ CCALLSFSUB10(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,0) #define CCALLSFSUB10(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA)\ CCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,0,0,0,0) #define CCALLSFSUB11(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB)\ CCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,0,0,0) #define CCALLSFSUB12(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC)\ CCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,0,0) #define CCALLSFSUB13(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD)\ CCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,0) #ifdef __cplusplus #define CPPPROTOCLSFSUB0( UN,LN) #define CPPPROTOCLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) #define CPPPROTOCLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) #define CPPPROTOCLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) #else #define CPPPROTOCLSFSUB0(UN,LN) \ PROTOCCALLSFSUB0(UN,LN) #define CPPPROTOCLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ PROTOCCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) #define CPPPROTOCLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) \ PROTOCCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) #define CPPPROTOCLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ PROTOCCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) #endif #ifdef CFSUBASFUN #define CCALLSFSUB0(UN,LN) CCALLSFFUN0(UN,LN) #define CCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE)\ CCALLSFFUN14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE) #else /* do{...}while(0) allows if(a==b) FORT(); else BORT(); */ #define CCALLSFSUB0( UN,LN) do{CPPPROTOCLSFSUB0(UN,LN) CFC_(UN,LN)();}while(0) #define CCALLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE)\ do{VVCF(T1,A1,B1) VVCF(T2,A2,B2) VVCF(T3,A3,B3) VVCF(T4,A4,B4) VVCF(T5,A5,B5) \ VVCF(T6,A6,B6) VVCF(T7,A7,B7) VVCF(T8,A8,B8) VVCF(T9,A9,B9) VVCF(TA,AA,B10) \ VVCF(TB,AB,B11) VVCF(TC,AC,B12) VVCF(TD,AD,B13) VVCF(TE,AE,B14) \ CPPPROTOCLSFSUB14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ ACF(LN,T1,A1,1) ACF(LN,T2,A2,2) ACF(LN,T3,A3,3) \ ACF(LN,T4,A4,4) ACF(LN,T5,A5,5) ACF(LN,T6,A6,6) ACF(LN,T7,A7,7) \ ACF(LN,T8,A8,8) ACF(LN,T9,A9,9) ACF(LN,TA,AA,10) ACF(LN,TB,AB,11) \ ACF(LN,TC,AC,12) ACF(LN,TD,AD,13) ACF(LN,TE,AE,14) \ CFC_(UN,LN)( CFARGTA14(AACF,JCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE) );\ WCF(T1,A1,1) WCF(T2,A2,2) WCF(T3,A3,3) WCF(T4,A4,4) WCF(T5,A5,5) \ WCF(T6,A6,6) WCF(T7,A7,7) WCF(T8,A8,8) WCF(T9,A9,9) WCF(TA,AA,10) \ WCF(TB,AB,11) WCF(TC,AC,12) WCF(TD,AD,13) WCF(TE,AE,14) }while(0) #endif #if MAX_PREPRO_ARGS>31 #define CCALLSFSUB15(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF)\ CCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,CF_0,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,0,0,0,0,0) #define CCALLSFSUB16(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG)\ CCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,0,0,0,0) #define CCALLSFSUB17(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH)\ CCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,0,0,0) #define CCALLSFSUB18(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI)\ CCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,0,0) #define CCALLSFSUB19(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ)\ CCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,0) #ifdef CFSUBASFUN #define CCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH, \ TI,TJ,TK, A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK) \ CCALLSFFUN20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH, \ TI,TJ,TK, A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK) #else #define CCALLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH, \ TI,TJ,TK, A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK) \ do{VVCF(T1,A1,B1) VVCF(T2,A2,B2) VVCF(T3,A3,B3) VVCF(T4,A4,B4) VVCF(T5,A5,B5) \ VVCF(T6,A6,B6) VVCF(T7,A7,B7) VVCF(T8,A8,B8) VVCF(T9,A9,B9) VVCF(TA,AA,B10) \ VVCF(TB,AB,B11) VVCF(TC,AC,B12) VVCF(TD,AD,B13) VVCF(TE,AE,B14) VVCF(TF,AF,B15) \ VVCF(TG,AG,B16) VVCF(TH,AH,B17) VVCF(TI,AI,B18) VVCF(TJ,AJ,B19) VVCF(TK,AK,B20) \ CPPPROTOCLSFSUB20(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) \ ACF(LN,T1,A1,1) ACF(LN,T2,A2,2) ACF(LN,T3,A3,3) ACF(LN,T4,A4,4) \ ACF(LN,T5,A5,5) ACF(LN,T6,A6,6) ACF(LN,T7,A7,7) ACF(LN,T8,A8,8) \ ACF(LN,T9,A9,9) ACF(LN,TA,AA,10) ACF(LN,TB,AB,11) ACF(LN,TC,AC,12) \ ACF(LN,TD,AD,13) ACF(LN,TE,AE,14) ACF(LN,TF,AF,15) ACF(LN,TG,AG,16) \ ACF(LN,TH,AH,17) ACF(LN,TI,AI,18) ACF(LN,TJ,AJ,19) ACF(LN,TK,AK,20) \ CFC_(UN,LN)( CFARGTA20(AACF,JCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK) ); \ WCF(T1,A1,1) WCF(T2,A2,2) WCF(T3,A3,3) WCF(T4,A4,4) WCF(T5,A5,5) WCF(T6,A6,6) \ WCF(T7,A7,7) WCF(T8,A8,8) WCF(T9,A9,9) WCF(TA,AA,10) WCF(TB,AB,11) WCF(TC,AC,12) \ WCF(TD,AD,13) WCF(TE,AE,14) WCF(TF,AF,15) WCF(TG,AG,16) WCF(TH,AH,17) WCF(TI,AI,18) \ WCF(TJ,AJ,19) WCF(TK,AK,20) }while(0) #endif #endif /* MAX_PREPRO_ARGS */ #if MAX_PREPRO_ARGS>31 #define CCALLSFSUB21(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL)\ CCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,0,0,0,0,0,0) #define CCALLSFSUB22(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM)\ CCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,CF_0,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,0,0,0,0,0) #define CCALLSFSUB23(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN)\ CCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,0,0,0,0) #define CCALLSFSUB24(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO)\ CCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,0,0,0) #define CCALLSFSUB25(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP)\ CCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,0,0) #define CCALLSFSUB26(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ)\ CCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,0) #ifdef CFSUBASFUN #define CCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR, \ A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR) \ CCALLSFFUN27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR, \ A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR) #else #define CCALLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR, \ A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR) \ do{VVCF(T1,A1,B1) VVCF(T2,A2,B2) VVCF(T3,A3,B3) VVCF(T4,A4,B4) VVCF(T5,A5,B5) \ VVCF(T6,A6,B6) VVCF(T7,A7,B7) VVCF(T8,A8,B8) VVCF(T9,A9,B9) VVCF(TA,AA,B10) \ VVCF(TB,AB,B11) VVCF(TC,AC,B12) VVCF(TD,AD,B13) VVCF(TE,AE,B14) VVCF(TF,AF,B15) \ VVCF(TG,AG,B16) VVCF(TH,AH,B17) VVCF(TI,AI,B18) VVCF(TJ,AJ,B19) VVCF(TK,AK,B20) \ VVCF(TL,AL,B21) VVCF(TM,AM,B22) VVCF(TN,AN,B23) VVCF(TO,AO,B24) VVCF(TP,AP,B25) \ VVCF(TQ,AQ,B26) VVCF(TR,AR,B27) \ CPPPROTOCLSFSUB27(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ ACF(LN,T1,A1,1) ACF(LN,T2,A2,2) ACF(LN,T3,A3,3) ACF(LN,T4,A4,4) \ ACF(LN,T5,A5,5) ACF(LN,T6,A6,6) ACF(LN,T7,A7,7) ACF(LN,T8,A8,8) \ ACF(LN,T9,A9,9) ACF(LN,TA,AA,10) ACF(LN,TB,AB,11) ACF(LN,TC,AC,12) \ ACF(LN,TD,AD,13) ACF(LN,TE,AE,14) ACF(LN,TF,AF,15) ACF(LN,TG,AG,16) \ ACF(LN,TH,AH,17) ACF(LN,TI,AI,18) ACF(LN,TJ,AJ,19) ACF(LN,TK,AK,20) \ ACF(LN,TL,AL,21) ACF(LN,TM,AM,22) ACF(LN,TN,AN,23) ACF(LN,TO,AO,24) \ ACF(LN,TP,AP,25) ACF(LN,TQ,AQ,26) ACF(LN,TR,AR,27) \ CFC_(UN,LN)( CFARGTA27(AACF,JCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR,\ A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR) ); \ WCF(T1,A1,1) WCF(T2,A2,2) WCF(T3,A3,3) WCF(T4,A4,4) WCF(T5,A5,5) WCF(T6,A6,6) \ WCF(T7,A7,7) WCF(T8,A8,8) WCF(T9,A9,9) WCF(TA,AA,10) WCF(TB,AB,11) WCF(TC,AC,12) \ WCF(TD,AD,13) WCF(TE,AE,14) WCF(TF,AF,15) WCF(TG,AG,16) WCF(TH,AH,17) WCF(TI,AI,18) \ WCF(TJ,AJ,19) WCF(TK,AK,20) WCF(TL,AL,21) WCF(TM,AM,22) WCF(TN,AN,23) WCF(TO,AO,24) \ WCF(TP,AP,25) WCF(TQ,AQ,26) WCF(TR,AR,27) }while(0) #endif #endif /* MAX_PREPRO_ARGS */ /*-------------------------------------------------------------------------*/ /* UTILITIES FOR C TO CALL FORTRAN FUNCTIONS */ /*N.B. PROTOCCALLSFFUNn(..) generates code, whether or not the FORTRAN function is called. Therefore, especially for creator's of C header files for large FORTRAN libraries which include many functions, to reduce compile time and object code size, it may be desirable to create preprocessor directives to allow users to create code for only those functions which they use. */ /* The following defines the maximum length string that a function can return. Of course it may be undefine-d and re-define-d before individual PROTOCCALLSFFUNn(..) as required. It would also be nice to have this derived from the individual machines' limits. */ #define MAX_LEN_FORTRAN_FUNCTION_STRING 0x4FE /* The following defines a character used by CFORTRAN.H to flag the end of a string coming out of a FORTRAN routine. */ #define CFORTRAN_NON_CHAR 0x7F #ifdef OLD_VAXC /* Prevent %CC-I-PARAMNOTUSED. */ #pragma nostandard #endif #define _SEP_(TN,C,cfCOMMA) _(__SEP_,C)(TN,cfCOMMA) #define __SEP_0(TN,cfCOMMA) #define __SEP_1(TN,cfCOMMA) _Icf(2,SEP,TN,cfCOMMA,0) #define INT_cfSEP(T,B) _(A,B) #define INTV_cfSEP(T,B) INT_cfSEP(T,B) #define INTVV_cfSEP(T,B) INT_cfSEP(T,B) #define INTVVV_cfSEP(T,B) INT_cfSEP(T,B) #define INTVVVV_cfSEP(T,B) INT_cfSEP(T,B) #define INTVVVVV_cfSEP(T,B) INT_cfSEP(T,B) #define INTVVVVVV_cfSEP(T,B) INT_cfSEP(T,B) #define INTVVVVVVV_cfSEP(T,B) INT_cfSEP(T,B) #define PINT_cfSEP(T,B) INT_cfSEP(T,B) #define PVOID_cfSEP(T,B) INT_cfSEP(T,B) #define ROUTINE_cfSEP(T,B) INT_cfSEP(T,B) #define SIMPLE_cfSEP(T,B) INT_cfSEP(T,B) #define VOID_cfSEP(T,B) INT_cfSEP(T,B) /* For FORTRAN calls C subr.s.*/ #define STRING_cfSEP(T,B) INT_cfSEP(T,B) #define STRINGV_cfSEP(T,B) INT_cfSEP(T,B) #define PSTRING_cfSEP(T,B) INT_cfSEP(T,B) #define PSTRINGV_cfSEP(T,B) INT_cfSEP(T,B) #define PNSTRING_cfSEP(T,B) INT_cfSEP(T,B) #define PPSTRING_cfSEP(T,B) INT_cfSEP(T,B) #define ZTRINGV_cfSEP(T,B) INT_cfSEP(T,B) #define PZTRINGV_cfSEP(T,B) INT_cfSEP(T,B) #if defined(SIGNED_BYTE) || !defined(UNSIGNED_BYTE) #ifdef OLD_VAXC #define INTEGER_BYTE char /* Old VAXC barfs on 'signed char' */ #else #define INTEGER_BYTE signed char /* default */ #endif #else #define INTEGER_BYTE unsigned char #endif #define BYTEVVVVVVV_cfTYPE INTEGER_BYTE #define DOUBLEVVVVVVV_cfTYPE DOUBLE_PRECISION #define FLOATVVVVVVV_cfTYPE FORTRAN_REAL #define INTVVVVVVV_cfTYPE int #define LOGICALVVVVVVV_cfTYPE int #define LONGVVVVVVV_cfTYPE long #define LONGLONGVVVVVVV_cfTYPE LONGLONG /* added by MR December 2005 */ #define SHORTVVVVVVV_cfTYPE short #define PBYTE_cfTYPE INTEGER_BYTE #define PDOUBLE_cfTYPE DOUBLE_PRECISION #define PFLOAT_cfTYPE FORTRAN_REAL #define PINT_cfTYPE int #define PLOGICAL_cfTYPE int #define PLONG_cfTYPE long #define PLONGLONG_cfTYPE LONGLONG /* added by MR December 2005 */ #define PSHORT_cfTYPE short #define CFARGS0(A,T,V,W,X,Y,Z) _3(T,_cf,A) #define CFARGS1(A,T,V,W,X,Y,Z) _3(T,_cf,A)(V) #define CFARGS2(A,T,V,W,X,Y,Z) _3(T,_cf,A)(V,W) #define CFARGS3(A,T,V,W,X,Y,Z) _3(T,_cf,A)(V,W,X) #define CFARGS4(A,T,V,W,X,Y,Z) _3(T,_cf,A)(V,W,X,Y) #define CFARGS5(A,T,V,W,X,Y,Z) _3(T,_cf,A)(V,W,X,Y,Z) #define _Icf(N,T,I,X,Y) _(I,_cfINT)(N,T,I,X,Y,0) #define _Icf4(N,T,I,X,Y,Z) _(I,_cfINT)(N,T,I,X,Y,Z) #define BYTE_cfINT(N,A,B,X,Y,Z) DOUBLE_cfINT(N,A,B,X,Y,Z) #define DOUBLE_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,INT,B,X,Y,Z,0) #define FLOAT_cfINT(N,A,B,X,Y,Z) DOUBLE_cfINT(N,A,B,X,Y,Z) #define INT_cfINT(N,A,B,X,Y,Z) DOUBLE_cfINT(N,A,B,X,Y,Z) #define LOGICAL_cfINT(N,A,B,X,Y,Z) DOUBLE_cfINT(N,A,B,X,Y,Z) #define LONG_cfINT(N,A,B,X,Y,Z) DOUBLE_cfINT(N,A,B,X,Y,Z) #define LONGLONG_cfINT(N,A,B,X,Y,Z) DOUBLE_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define SHORT_cfINT(N,A,B,X,Y,Z) DOUBLE_cfINT(N,A,B,X,Y,Z) #define PBYTE_cfINT(N,A,B,X,Y,Z) PDOUBLE_cfINT(N,A,B,X,Y,Z) #define PDOUBLE_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,PINT,B,X,Y,Z,0) #define PFLOAT_cfINT(N,A,B,X,Y,Z) PDOUBLE_cfINT(N,A,B,X,Y,Z) #define PINT_cfINT(N,A,B,X,Y,Z) PDOUBLE_cfINT(N,A,B,X,Y,Z) #define PLOGICAL_cfINT(N,A,B,X,Y,Z) PDOUBLE_cfINT(N,A,B,X,Y,Z) #define PLONG_cfINT(N,A,B,X,Y,Z) PDOUBLE_cfINT(N,A,B,X,Y,Z) #define PLONGLONG_cfINT(N,A,B,X,Y,Z) PDOUBLE_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define PSHORT_cfINT(N,A,B,X,Y,Z) PDOUBLE_cfINT(N,A,B,X,Y,Z) #define BYTEV_cfINT(N,A,B,X,Y,Z) DOUBLEV_cfINT(N,A,B,X,Y,Z) #define BYTEVV_cfINT(N,A,B,X,Y,Z) DOUBLEVV_cfINT(N,A,B,X,Y,Z) #define BYTEVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVV_cfINT(N,A,B,X,Y,Z) #define BYTEVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVV_cfINT(N,A,B,X,Y,Z) #define BYTEVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVV_cfINT(N,A,B,X,Y,Z) #define BYTEVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVV_cfINT(N,A,B,X,Y,Z) #define BYTEVVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVVV_cfINT(N,A,B,X,Y,Z) #define DOUBLEV_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,INTV,B,X,Y,Z,0) #define DOUBLEVV_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,INTVV,B,X,Y,Z,0) #define DOUBLEVVV_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,INTVVV,B,X,Y,Z,0) #define DOUBLEVVVV_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,INTVVVV,B,X,Y,Z,0) #define DOUBLEVVVVV_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,INTVVVVV,B,X,Y,Z,0) #define DOUBLEVVVVVV_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,INTVVVVVV,B,X,Y,Z,0) #define DOUBLEVVVVVVV_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,INTVVVVVVV,B,X,Y,Z,0) #define FLOATV_cfINT(N,A,B,X,Y,Z) DOUBLEV_cfINT(N,A,B,X,Y,Z) #define FLOATVV_cfINT(N,A,B,X,Y,Z) DOUBLEVV_cfINT(N,A,B,X,Y,Z) #define FLOATVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVV_cfINT(N,A,B,X,Y,Z) #define FLOATVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVV_cfINT(N,A,B,X,Y,Z) #define FLOATVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVV_cfINT(N,A,B,X,Y,Z) #define FLOATVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVV_cfINT(N,A,B,X,Y,Z) #define FLOATVVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVVV_cfINT(N,A,B,X,Y,Z) #define INTV_cfINT(N,A,B,X,Y,Z) DOUBLEV_cfINT(N,A,B,X,Y,Z) #define INTVV_cfINT(N,A,B,X,Y,Z) DOUBLEVV_cfINT(N,A,B,X,Y,Z) #define INTVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVV_cfINT(N,A,B,X,Y,Z) #define INTVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVV_cfINT(N,A,B,X,Y,Z) #define INTVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVV_cfINT(N,A,B,X,Y,Z) #define INTVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVV_cfINT(N,A,B,X,Y,Z) #define INTVVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVVV_cfINT(N,A,B,X,Y,Z) #define LOGICALV_cfINT(N,A,B,X,Y,Z) DOUBLEV_cfINT(N,A,B,X,Y,Z) #define LOGICALVV_cfINT(N,A,B,X,Y,Z) DOUBLEVV_cfINT(N,A,B,X,Y,Z) #define LOGICALVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVV_cfINT(N,A,B,X,Y,Z) #define LOGICALVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVV_cfINT(N,A,B,X,Y,Z) #define LOGICALVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVV_cfINT(N,A,B,X,Y,Z) #define LOGICALVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVV_cfINT(N,A,B,X,Y,Z) #define LOGICALVVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVVV_cfINT(N,A,B,X,Y,Z) #define LONGV_cfINT(N,A,B,X,Y,Z) DOUBLEV_cfINT(N,A,B,X,Y,Z) #define LONGVV_cfINT(N,A,B,X,Y,Z) DOUBLEVV_cfINT(N,A,B,X,Y,Z) #define LONGVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVV_cfINT(N,A,B,X,Y,Z) #define LONGVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVV_cfINT(N,A,B,X,Y,Z) #define LONGVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVV_cfINT(N,A,B,X,Y,Z) #define LONGVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVV_cfINT(N,A,B,X,Y,Z) #define LONGVVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVVV_cfINT(N,A,B,X,Y,Z) #define LONGLONGV_cfINT(N,A,B,X,Y,Z) DOUBLEV_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define LONGLONGVV_cfINT(N,A,B,X,Y,Z) DOUBLEVV_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define LONGLONGVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVV_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define LONGLONGVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVV_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define LONGLONGVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVV_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define LONGLONGVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVV_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define LONGLONGVVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVVV_cfINT(N,A,B,X,Y,Z) /* added by MR December 2005 */ #define SHORTV_cfINT(N,A,B,X,Y,Z) DOUBLEV_cfINT(N,A,B,X,Y,Z) #define SHORTVV_cfINT(N,A,B,X,Y,Z) DOUBLEVV_cfINT(N,A,B,X,Y,Z) #define SHORTVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVV_cfINT(N,A,B,X,Y,Z) #define SHORTVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVV_cfINT(N,A,B,X,Y,Z) #define SHORTVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVV_cfINT(N,A,B,X,Y,Z) #define SHORTVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVV_cfINT(N,A,B,X,Y,Z) #define SHORTVVVVVVV_cfINT(N,A,B,X,Y,Z) DOUBLEVVVVVVV_cfINT(N,A,B,X,Y,Z) #define PVOID_cfINT(N,A,B,X,Y,Z) _(CFARGS,N)(A,B,B,X,Y,Z,0) #define ROUTINE_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) /*CRAY coughs on the first, i.e. the usual trouble of not being able to define macros to macros with arguments. New ultrix is worse, it coughs on all such uses. */ /*#define SIMPLE_cfINT PVOID_cfINT*/ #define SIMPLE_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define VOID_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define STRING_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define STRINGV_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define PSTRING_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define PSTRINGV_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define PNSTRING_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define PPSTRING_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define ZTRINGV_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define PZTRINGV_cfINT(N,A,B,X,Y,Z) PVOID_cfINT(N,A,B,X,Y,Z) #define CF_0_cfINT(N,A,B,X,Y,Z) #define UCF(TN,I,C) _SEP_(TN,C,cfCOMMA) _Icf(2,U,TN,_(A,I),0) #define UUCF(TN,I,C) _SEP_(TN,C,cfCOMMA) _SEP_(TN,1,I) #define UUUCF(TN,I,C) _SEP_(TN,C,cfCOLON) _Icf(2,U,TN,_(A,I),0) #define INT_cfU(T,A) _(T,VVVVVVV_cfTYPE) A #define INTV_cfU(T,A) _(T,VVVVVV_cfTYPE) * A #define INTVV_cfU(T,A) _(T,VVVVV_cfTYPE) * A #define INTVVV_cfU(T,A) _(T,VVVV_cfTYPE) * A #define INTVVVV_cfU(T,A) _(T,VVV_cfTYPE) * A #define INTVVVVV_cfU(T,A) _(T,VV_cfTYPE) * A #define INTVVVVVV_cfU(T,A) _(T,V_cfTYPE) * A #define INTVVVVVVV_cfU(T,A) _(T,_cfTYPE) * A #define PINT_cfU(T,A) _(T,_cfTYPE) * A #define PVOID_cfU(T,A) void *A #define ROUTINE_cfU(T,A) void (*A)(CF_NULL_PROTO) #define VOID_cfU(T,A) void A /* Needed for C calls FORTRAN sub.s. */ #define STRING_cfU(T,A) char *A /* via VOID and wrapper. */ #define STRINGV_cfU(T,A) char *A #define PSTRING_cfU(T,A) char *A #define PSTRINGV_cfU(T,A) char *A #define ZTRINGV_cfU(T,A) char *A #define PZTRINGV_cfU(T,A) char *A /* VOID breaks U into U and UU. */ #define INT_cfUU(T,A) _(T,VVVVVVV_cfTYPE) A #define VOID_cfUU(T,A) /* Needed for FORTRAN calls C sub.s. */ #define STRING_cfUU(T,A) char *A #define BYTE_cfPU(A) CFextern INTEGER_BYTE FCALLSC_QUALIFIER A #define DOUBLE_cfPU(A) CFextern DOUBLE_PRECISION FCALLSC_QUALIFIER A #if ! (defined(FLOATFUNCTIONTYPE)&&defined(ASSIGNFLOAT)&&defined(RETURNFLOAT)) #if defined (f2cFortran) && ! defined (gFortran) /* f2c/g77 return double from FORTRAN REAL functions. (KMCCARTY, 2005/12/09) */ #define FLOAT_cfPU(A) CFextern DOUBLE_PRECISION FCALLSC_QUALIFIER A #else #define FLOAT_cfPU(A) CFextern FORTRAN_REAL FCALLSC_QUALIFIER A #endif #else #define FLOAT_cfPU(A) CFextern FLOATFUNCTIONTYPE FCALLSC_QUALIFIER A #endif #define INT_cfPU(A) CFextern int FCALLSC_QUALIFIER A #define LOGICAL_cfPU(A) CFextern int FCALLSC_QUALIFIER A #define LONG_cfPU(A) CFextern long FCALLSC_QUALIFIER A #define SHORT_cfPU(A) CFextern short FCALLSC_QUALIFIER A #define STRING_cfPU(A) CFextern void FCALLSC_QUALIFIER A #define VOID_cfPU(A) CFextern void FCALLSC_QUALIFIER A #define BYTE_cfE INTEGER_BYTE A0; #define DOUBLE_cfE DOUBLE_PRECISION A0; #if ! (defined(FLOATFUNCTIONTYPE)&&defined(ASSIGNFLOAT)&&defined(RETURNFLOAT)) #define FLOAT_cfE FORTRAN_REAL A0; #else #define FLOAT_cfE FORTRAN_REAL AA0; FLOATFUNCTIONTYPE A0; #endif #define INT_cfE int A0; #define LOGICAL_cfE int A0; #define LONG_cfE long A0; #define SHORT_cfE short A0; #define VOID_cfE #ifdef vmsFortran #define STRING_cfE static char AA0[1+MAX_LEN_FORTRAN_FUNCTION_STRING]; \ static fstring A0 = \ {MAX_LEN_FORTRAN_FUNCTION_STRING,DSC$K_DTYPE_T,DSC$K_CLASS_S,AA0};\ memset(AA0, CFORTRAN_NON_CHAR, MAX_LEN_FORTRAN_FUNCTION_STRING);\ *(AA0+MAX_LEN_FORTRAN_FUNCTION_STRING)='\0'; #else #ifdef CRAYFortran #define STRING_cfE static char AA0[1+MAX_LEN_FORTRAN_FUNCTION_STRING]; \ static _fcd A0; *(AA0+MAX_LEN_FORTRAN_FUNCTION_STRING)='\0';\ memset(AA0,CFORTRAN_NON_CHAR, MAX_LEN_FORTRAN_FUNCTION_STRING);\ A0 = _cptofcd(AA0,MAX_LEN_FORTRAN_FUNCTION_STRING); #else /* 'cc: SC3.0.1 13 Jul 1994' barfs on char A0[0x4FE+1]; * char A0[0x4FE +1]; char A0[1+0x4FE]; are both OK. */ #define STRING_cfE static char A0[1+MAX_LEN_FORTRAN_FUNCTION_STRING]; \ memset(A0, CFORTRAN_NON_CHAR, \ MAX_LEN_FORTRAN_FUNCTION_STRING); \ *(A0+MAX_LEN_FORTRAN_FUNCTION_STRING)='\0'; #endif #endif /* ESTRING must use static char. array which is guaranteed to exist after function returns. */ /* N.B.i) The diff. for 0 (Zero) and >=1 arguments. ii)That the following create an unmatched bracket, i.e. '(', which must of course be matched in the call. iii)Commas must be handled very carefully */ #define INT_cfGZ(T,UN,LN) A0=CFC_(UN,LN)( #define VOID_cfGZ(T,UN,LN) CFC_(UN,LN)( #ifdef vmsFortran #define STRING_cfGZ(T,UN,LN) CFC_(UN,LN)(&A0 #else #if defined(CRAYFortran) || defined(AbsoftUNIXFortran) || defined(AbsoftProFortran) #define STRING_cfGZ(T,UN,LN) CFC_(UN,LN)( A0 #else #define STRING_cfGZ(T,UN,LN) CFC_(UN,LN)( A0,MAX_LEN_FORTRAN_FUNCTION_STRING #endif #endif #define INT_cfG(T,UN,LN) INT_cfGZ(T,UN,LN) #define VOID_cfG(T,UN,LN) VOID_cfGZ(T,UN,LN) #define STRING_cfG(T,UN,LN) STRING_cfGZ(T,UN,LN), /*, is only diff. from _cfG*/ #define BYTEVVVVVVV_cfPP #define INTVVVVVVV_cfPP /* These complement FLOATVVVVVVV_cfPP. */ #define DOUBLEVVVVVVV_cfPP #define LOGICALVVVVVVV_cfPP #define LONGVVVVVVV_cfPP #define SHORTVVVVVVV_cfPP #define PBYTE_cfPP #define PINT_cfPP #define PDOUBLE_cfPP #define PLOGICAL_cfPP #define PLONG_cfPP #define PSHORT_cfPP #define PFLOAT_cfPP FLOATVVVVVVV_cfPP #define BCF(TN,AN,C) _SEP_(TN,C,cfCOMMA) _Icf(2,B,TN,AN,0) #define INT_cfB(T,A) (_(T,VVVVVVV_cfTYPE)) A #define INTV_cfB(T,A) A #define INTVV_cfB(T,A) (A)[0] #define INTVVV_cfB(T,A) (A)[0][0] #define INTVVVV_cfB(T,A) (A)[0][0][0] #define INTVVVVV_cfB(T,A) (A)[0][0][0][0] #define INTVVVVVV_cfB(T,A) (A)[0][0][0][0][0] #define INTVVVVVVV_cfB(T,A) (A)[0][0][0][0][0][0] #define PINT_cfB(T,A) _(T,_cfPP)&A #define STRING_cfB(T,A) (char *) A #define STRINGV_cfB(T,A) (char *) A #define PSTRING_cfB(T,A) (char *) A #define PSTRINGV_cfB(T,A) (char *) A #define PVOID_cfB(T,A) (void *) A #define ROUTINE_cfB(T,A) (cfCAST_FUNCTION)A #define ZTRINGV_cfB(T,A) (char *) A #define PZTRINGV_cfB(T,A) (char *) A #define SCF(TN,NAME,I,A) _(TN,_cfSTR)(3,S,NAME,I,A,0,0) #define DEFAULT_cfS(M,I,A) #define LOGICAL_cfS(M,I,A) #define PLOGICAL_cfS(M,I,A) #define STRING_cfS(M,I,A) ,sizeof(A) #define STRINGV_cfS(M,I,A) ,( (unsigned)0xFFFF*firstindexlength(A) \ +secondindexlength(A)) #define PSTRING_cfS(M,I,A) ,sizeof(A) #define PSTRINGV_cfS(M,I,A) STRINGV_cfS(M,I,A) #define ZTRINGV_cfS(M,I,A) #define PZTRINGV_cfS(M,I,A) #define HCF(TN,I) _(TN,_cfSTR)(3,H,cfCOMMA, H,_(C,I),0,0) #define HHCF(TN,I) _(TN,_cfSTR)(3,H,cfCOMMA,HH,_(C,I),0,0) #define HHHCF(TN,I) _(TN,_cfSTR)(3,H,cfCOLON, H,_(C,I),0,0) #define H_CF_SPECIAL unsigned #define HH_CF_SPECIAL #define DEFAULT_cfH(M,I,A) #define LOGICAL_cfH(S,U,B) #define PLOGICAL_cfH(S,U,B) #define STRING_cfH(S,U,B) _(A,S) _(U,_CF_SPECIAL) B #define STRINGV_cfH(S,U,B) STRING_cfH(S,U,B) #define PSTRING_cfH(S,U,B) STRING_cfH(S,U,B) #define PSTRINGV_cfH(S,U,B) STRING_cfH(S,U,B) #define PNSTRING_cfH(S,U,B) STRING_cfH(S,U,B) #define PPSTRING_cfH(S,U,B) STRING_cfH(S,U,B) #define ZTRINGV_cfH(S,U,B) #define PZTRINGV_cfH(S,U,B) /* Need VOID_cfSTR because Absoft forced function types go through _cfSTR. */ /* No spaces inside expansion. They screws up macro catenation kludge. */ #define VOID_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define BYTE_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define DOUBLE_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define FLOAT_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define INT_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LOGICAL_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,LOGICAL,A,B,C,D,E) #define LONG_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGLONG_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define SHORT_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define BYTEV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define BYTEVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define BYTEVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define BYTEVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define BYTEVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define BYTEVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define BYTEVVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define DOUBLEV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define DOUBLEVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define DOUBLEVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define DOUBLEVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define DOUBLEVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define DOUBLEVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define DOUBLEVVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define FLOATV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define FLOATVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define FLOATVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define FLOATVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define FLOATVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define FLOATVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define FLOATVVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define INTV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define INTVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define INTVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define INTVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define INTVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define INTVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define INTVVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LOGICALV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LOGICALVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LOGICALVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LOGICALVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LOGICALVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LOGICALVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LOGICALVVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGVVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define LONGLONGV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define LONGLONGVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define LONGLONGVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define LONGLONGVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define LONGLONGVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define LONGLONGVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define LONGLONGVVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define SHORTV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define SHORTVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define SHORTVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define SHORTVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define SHORTVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define SHORTVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define SHORTVVVVVVV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define PBYTE_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define PDOUBLE_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define PFLOAT_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define PINT_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define PLOGICAL_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,PLOGICAL,A,B,C,D,E) #define PLONG_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define PLONGLONG_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) /* added by MR December 2005 */ #define PSHORT_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define STRING_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,STRING,A,B,C,D,E) #define PSTRING_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,PSTRING,A,B,C,D,E) #define STRINGV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,STRINGV,A,B,C,D,E) #define PSTRINGV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,PSTRINGV,A,B,C,D,E) #define PNSTRING_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,PNSTRING,A,B,C,D,E) #define PPSTRING_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,PPSTRING,A,B,C,D,E) #define PVOID_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define ROUTINE_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define SIMPLE_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,DEFAULT,A,B,C,D,E) #define ZTRINGV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,ZTRINGV,A,B,C,D,E) #define PZTRINGV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,PZTRINGV,A,B,C,D,E) #define CF_0_cfSTR(N,T,A,B,C,D,E) /* See ACF table comments, which explain why CCF was split into two. */ #define CCF(NAME,TN,I) _(TN,_cfSTR)(5,C,NAME,I,_(A,I),_(B,I),_(C,I)) #define DEFAULT_cfC(M,I,A,B,C) #define LOGICAL_cfC(M,I,A,B,C) A=C2FLOGICAL( A); #define PLOGICAL_cfC(M,I,A,B,C) *A=C2FLOGICAL(*A); #ifdef vmsFortran #define STRING_cfC(M,I,A,B,C) (B.clen=strlen(A),B.f.dsc$a_pointer=A, \ C==sizeof(char*)||C==(unsigned)(B.clen+1)?B.f.dsc$w_length=B.clen: \ (memset((A)+B.clen,' ',C-B.clen-1),A[B.f.dsc$w_length=C-1]='\0')); /* PSTRING_cfC to beware of array A which does not contain any \0. */ #define PSTRING_cfC(M,I,A,B,C) (B.dsc$a_pointer=A, C==sizeof(char*) ? \ B.dsc$w_length=strlen(A): (A[C-1]='\0',B.dsc$w_length=strlen(A), \ memset((A)+B.dsc$w_length,' ',C-B.dsc$w_length-1), B.dsc$w_length=C-1)); #else #define STRING_cfC(M,I,A,B,C) (B.nombre=A,B.clen=strlen(A), \ C==sizeof(char*)||C==(unsigned)(B.clen+1)?B.flen=B.clen: \ (memset(B.nombre+B.clen,' ',C-B.clen-1),B.nombre[B.flen=C-1]='\0')); #define PSTRING_cfC(M,I,A,B,C) (C==sizeof(char*)? B=strlen(A): \ (A[C-1]='\0',B=strlen(A),memset((A)+B,' ',C-B-1),B=C-1)); #endif /* For CRAYFortran for (P)STRINGV_cfC, B.fs is set, but irrelevant. */ #define STRINGV_cfC(M,I,A,B,C) \ AATRINGV_cfA( A,B,(C/0xFFFF)*(C%0xFFFF),C/0xFFFF,C%0xFFFF) #define PSTRINGV_cfC(M,I,A,B,C) \ APATRINGV_cfA( A,B,(C/0xFFFF)*(C%0xFFFF),C/0xFFFF,C%0xFFFF) #define ZTRINGV_cfC(M,I,A,B,C) \ AATRINGV_cfA( A,B, (_3(M,_ELEMS_,I))*((_3(M,_ELEMLEN_,I))+1), \ (_3(M,_ELEMS_,I)), (_3(M,_ELEMLEN_,I))+1 ) #define PZTRINGV_cfC(M,I,A,B,C) \ APATRINGV_cfA( A,B, (_3(M,_ELEMS_,I))*((_3(M,_ELEMLEN_,I))+1), \ (_3(M,_ELEMS_,I)), (_3(M,_ELEMLEN_,I))+1 ) #define BYTE_cfCCC(A,B) &A #define DOUBLE_cfCCC(A,B) &A #if !defined(__CF__KnR) #define FLOAT_cfCCC(A,B) &A /* Although the VAX doesn't, at least the */ #else /* HP and K&R mips promote float arg.'s of */ #define FLOAT_cfCCC(A,B) &B /* unprototyped functions to double. Cannot */ #endif /* use A here to pass the argument to FORTRAN. */ #define INT_cfCCC(A,B) &A #define LOGICAL_cfCCC(A,B) &A #define LONG_cfCCC(A,B) &A #define SHORT_cfCCC(A,B) &A #define PBYTE_cfCCC(A,B) A #define PDOUBLE_cfCCC(A,B) A #define PFLOAT_cfCCC(A,B) A #define PINT_cfCCC(A,B) A #define PLOGICAL_cfCCC(A,B) B=A /* B used to keep a common W table. */ #define PLONG_cfCCC(A,B) A #define PSHORT_cfCCC(A,B) A #define CCCF(TN,I,M) _SEP_(TN,M,cfCOMMA) _Icf(3,CC,TN,_(A,I),_(B,I)) #define INT_cfCC(T,A,B) _(T,_cfCCC)(A,B) #define INTV_cfCC(T,A,B) A #define INTVV_cfCC(T,A,B) A #define INTVVV_cfCC(T,A,B) A #define INTVVVV_cfCC(T,A,B) A #define INTVVVVV_cfCC(T,A,B) A #define INTVVVVVV_cfCC(T,A,B) A #define INTVVVVVVV_cfCC(T,A,B) A #define PINT_cfCC(T,A,B) _(T,_cfCCC)(A,B) #define PVOID_cfCC(T,A,B) A #if defined(apolloFortran) || defined(hpuxFortran800) || defined(AbsoftUNIXFortran) #define ROUTINE_cfCC(T,A,B) &A #else #define ROUTINE_cfCC(T,A,B) A #endif #define SIMPLE_cfCC(T,A,B) A #ifdef vmsFortran #define STRING_cfCC(T,A,B) &B.f #define STRINGV_cfCC(T,A,B) &B #define PSTRING_cfCC(T,A,B) &B #define PSTRINGV_cfCC(T,A,B) &B #else #ifdef CRAYFortran #define STRING_cfCC(T,A,B) _cptofcd(A,B.flen) #define STRINGV_cfCC(T,A,B) _cptofcd(B.s,B.flen) #define PSTRING_cfCC(T,A,B) _cptofcd(A,B) #define PSTRINGV_cfCC(T,A,B) _cptofcd(A,B.flen) #else #define STRING_cfCC(T,A,B) A #define STRINGV_cfCC(T,A,B) B.fs #define PSTRING_cfCC(T,A,B) A #define PSTRINGV_cfCC(T,A,B) B.fs #endif #endif #define ZTRINGV_cfCC(T,A,B) STRINGV_cfCC(T,A,B) #define PZTRINGV_cfCC(T,A,B) PSTRINGV_cfCC(T,A,B) #define BYTE_cfX return A0; #define DOUBLE_cfX return A0; #if ! (defined(FLOATFUNCTIONTYPE)&&defined(ASSIGNFLOAT)&&defined(RETURNFLOAT)) #define FLOAT_cfX return A0; #else #define FLOAT_cfX ASSIGNFLOAT(AA0,A0); return AA0; #endif #define INT_cfX return A0; #define LOGICAL_cfX return F2CLOGICAL(A0); #define LONG_cfX return A0; #define SHORT_cfX return A0; #define VOID_cfX return ; #if defined(vmsFortran) || defined(CRAYFortran) #define STRING_cfX return kill_trailing( \ kill_trailing(AA0,CFORTRAN_NON_CHAR),' '); #else #define STRING_cfX return kill_trailing( \ kill_trailing( A0,CFORTRAN_NON_CHAR),' '); #endif #define CFFUN(NAME) _(__cf__,NAME) /* Note that we don't use LN here, but we keep it for consistency. */ #define CCALLSFFUN0(UN,LN) CFFUN(UN)() #ifdef OLD_VAXC /* Allow %CC-I-PARAMNOTUSED. */ #pragma standard #endif #define CCALLSFFUN1( UN,LN,T1, A1) \ CCALLSFFUN5 (UN,LN,T1,CF_0,CF_0,CF_0,CF_0,A1,0,0,0,0) #define CCALLSFFUN2( UN,LN,T1,T2, A1,A2) \ CCALLSFFUN5 (UN,LN,T1,T2,CF_0,CF_0,CF_0,A1,A2,0,0,0) #define CCALLSFFUN3( UN,LN,T1,T2,T3, A1,A2,A3) \ CCALLSFFUN5 (UN,LN,T1,T2,T3,CF_0,CF_0,A1,A2,A3,0,0) #define CCALLSFFUN4( UN,LN,T1,T2,T3,T4, A1,A2,A3,A4)\ CCALLSFFUN5 (UN,LN,T1,T2,T3,T4,CF_0,A1,A2,A3,A4,0) #define CCALLSFFUN5( UN,LN,T1,T2,T3,T4,T5, A1,A2,A3,A4,A5) \ CCALLSFFUN10(UN,LN,T1,T2,T3,T4,T5,CF_0,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,0,0,0,0,0) #define CCALLSFFUN6( UN,LN,T1,T2,T3,T4,T5,T6, A1,A2,A3,A4,A5,A6) \ CCALLSFFUN10(UN,LN,T1,T2,T3,T4,T5,T6,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,0,0,0,0) #define CCALLSFFUN7( UN,LN,T1,T2,T3,T4,T5,T6,T7, A1,A2,A3,A4,A5,A6,A7) \ CCALLSFFUN10(UN,LN,T1,T2,T3,T4,T5,T6,T7,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,0,0,0) #define CCALLSFFUN8( UN,LN,T1,T2,T3,T4,T5,T6,T7,T8, A1,A2,A3,A4,A5,A6,A7,A8) \ CCALLSFFUN10(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,0,0) #define CCALLSFFUN9( UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,A1,A2,A3,A4,A5,A6,A7,A8,A9)\ CCALLSFFUN10(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,0) #define CCALLSFFUN10(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA)\ CCALLSFFUN14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,CF_0,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,0,0,0,0) #define CCALLSFFUN11(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB)\ CCALLSFFUN14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,CF_0,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,0,0,0) #define CCALLSFFUN12(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC)\ CCALLSFFUN14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,CF_0,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,0,0) #define CCALLSFFUN13(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD)\ CCALLSFFUN14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,CF_0,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,0) #define CCALLSFFUN14(UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,A1,A2,A3,A4,A5,A6,A7,A8,A9,AA,AB,AC,AD,AE)\ ((CFFUN(UN)( BCF(T1,A1,0) BCF(T2,A2,1) BCF(T3,A3,1) BCF(T4,A4,1) BCF(T5,A5,1) \ BCF(T6,A6,1) BCF(T7,A7,1) BCF(T8,A8,1) BCF(T9,A9,1) BCF(TA,AA,1) \ BCF(TB,AB,1) BCF(TC,AC,1) BCF(TD,AD,1) BCF(TE,AE,1) \ SCF(T1,LN,1,A1) SCF(T2,LN,2,A2) SCF(T3,LN,3,A3) SCF(T4,LN,4,A4) \ SCF(T5,LN,5,A5) SCF(T6,LN,6,A6) SCF(T7,LN,7,A7) SCF(T8,LN,8,A8) \ SCF(T9,LN,9,A9) SCF(TA,LN,10,AA) SCF(TB,LN,11,AB) SCF(TC,LN,12,AC) \ SCF(TD,LN,13,AD) SCF(TE,LN,14,AE)))) /* N.B. Create a separate function instead of using (call function, function value here) because in order to create the variables needed for the input arg.'s which may be const.'s one has to do the creation within {}, but these can never be placed within ()'s. Therefore one must create wrapper functions. gcc, on the other hand may be able to avoid the wrapper functions. */ /* Prototypes are needed to correctly handle the value returned correctly. N.B. Can only have prototype arg.'s with difficulty, a la G... table since FORTRAN functions returning strings have extra arg.'s. Don't bother, since this only causes a compiler warning to come up when one uses FCALLSCFUNn and CCALLSFFUNn for the same function in the same source code. Something done by the experts in debugging only.*/ #define PROTOCCALLSFFUN0(F,UN,LN) \ _(F,_cfPU)( CFC_(UN,LN))(CF_NULL_PROTO); \ static _Icf(2,U,F,CFFUN(UN),0)() {_(F,_cfE) _Icf(3,GZ,F,UN,LN) ABSOFT_cf1(F));_(F,_cfX)} #define PROTOCCALLSFFUN1( T0,UN,LN,T1) \ PROTOCCALLSFFUN5 (T0,UN,LN,T1,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFFUN2( T0,UN,LN,T1,T2) \ PROTOCCALLSFFUN5 (T0,UN,LN,T1,T2,CF_0,CF_0,CF_0) #define PROTOCCALLSFFUN3( T0,UN,LN,T1,T2,T3) \ PROTOCCALLSFFUN5 (T0,UN,LN,T1,T2,T3,CF_0,CF_0) #define PROTOCCALLSFFUN4( T0,UN,LN,T1,T2,T3,T4) \ PROTOCCALLSFFUN5 (T0,UN,LN,T1,T2,T3,T4,CF_0) #define PROTOCCALLSFFUN5( T0,UN,LN,T1,T2,T3,T4,T5) \ PROTOCCALLSFFUN10(T0,UN,LN,T1,T2,T3,T4,T5,CF_0,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFFUN6( T0,UN,LN,T1,T2,T3,T4,T5,T6) \ PROTOCCALLSFFUN10(T0,UN,LN,T1,T2,T3,T4,T5,T6,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFFUN7( T0,UN,LN,T1,T2,T3,T4,T5,T6,T7) \ PROTOCCALLSFFUN10(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,CF_0,CF_0,CF_0) #define PROTOCCALLSFFUN8( T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8) \ PROTOCCALLSFFUN10(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,CF_0,CF_0) #define PROTOCCALLSFFUN9( T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9) \ PROTOCCALLSFFUN10(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,CF_0) #define PROTOCCALLSFFUN10(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA) \ PROTOCCALLSFFUN14(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,CF_0,CF_0,CF_0,CF_0) #define PROTOCCALLSFFUN11(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB) \ PROTOCCALLSFFUN14(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,CF_0,CF_0,CF_0) #define PROTOCCALLSFFUN12(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC) \ PROTOCCALLSFFUN14(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,CF_0,CF_0) #define PROTOCCALLSFFUN13(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD) \ PROTOCCALLSFFUN14(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,CF_0) /* HP/UX 9.01 cc requires the blank between '_Icf(3,G,T0,UN,LN) CCCF(T1,1,0)' */ #ifndef __CF__KnR #define PROTOCCALLSFFUN14(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ _(T0,_cfPU)(CFC_(UN,LN))(CF_NULL_PROTO); static _Icf(2,U,T0,CFFUN(UN),0)( \ CFARGT14FS(UCF,HCF,_Z,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) ) \ { CFARGT14S(VCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) _(T0,_cfE) \ CCF(LN,T1,1) CCF(LN,T2,2) CCF(LN,T3,3) CCF(LN,T4,4) CCF(LN,T5,5) \ CCF(LN,T6,6) CCF(LN,T7,7) CCF(LN,T8,8) CCF(LN,T9,9) CCF(LN,TA,10) \ CCF(LN,TB,11) CCF(LN,TC,12) CCF(LN,TD,13) CCF(LN,TE,14) _Icf(3,G,T0,UN,LN) \ CFARGT14(CCCF,JCF,ABSOFT_cf1(T0),T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE)); \ WCF(T1,A1,1) WCF(T2,A2,2) WCF(T3,A3,3) WCF(T4,A4,4) WCF(T5,A5,5) \ WCF(T6,A6,6) WCF(T7,A7,7) WCF(T8,A8,8) WCF(T9,A9,9) WCF(TA,A10,10) \ WCF(TB,A11,11) WCF(TC,A12,12) WCF(TD,A13,13) WCF(TE,A14,14) _(T0,_cfX)} #else #define PROTOCCALLSFFUN14(T0,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ _(T0,_cfPU)(CFC_(UN,LN))(CF_NULL_PROTO); static _Icf(2,U,T0,CFFUN(UN),0)( \ CFARGT14FS(UUCF,HHCF,_Z,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) ) \ CFARGT14FS(UUUCF,HHHCF,_Z,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) ; \ { CFARGT14S(VCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) _(T0,_cfE) \ CCF(LN,T1,1) CCF(LN,T2,2) CCF(LN,T3,3) CCF(LN,T4,4) CCF(LN,T5,5) \ CCF(LN,T6,6) CCF(LN,T7,7) CCF(LN,T8,8) CCF(LN,T9,9) CCF(LN,TA,10) \ CCF(LN,TB,11) CCF(LN,TC,12) CCF(LN,TD,13) CCF(LN,TE,14) _Icf(3,G,T0,UN,LN) \ CFARGT14(CCCF,JCF,ABSOFT_cf1(T0),T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE)); \ WCF(T1,A1,1) WCF(T2,A2,2) WCF(T3,A3,3) WCF(T4,A4,4) WCF(T5,A5,5) \ WCF(T6,A6,6) WCF(T7,A7,7) WCF(T8,A8,8) WCF(T9,A9,9) WCF(TA,A10,10) \ WCF(TB,A11,11) WCF(TC,A12,12) WCF(TD,A13,13) WCF(TE,A14,14) _(T0,_cfX)} #endif /*-------------------------------------------------------------------------*/ /* UTILITIES FOR FORTRAN TO CALL C ROUTINES */ #ifdef OLD_VAXC /* Prevent %CC-I-PARAMNOTUSED. */ #pragma nostandard #endif #if defined(vmsFortran) || defined(CRAYFortran) #define DCF(TN,I) #define DDCF(TN,I) #define DDDCF(TN,I) #else #define DCF(TN,I) HCF(TN,I) #define DDCF(TN,I) HHCF(TN,I) #define DDDCF(TN,I) HHHCF(TN,I) #endif #define QCF(TN,I) _(TN,_cfSTR)(1,Q,_(B,I), 0,0,0,0) #define DEFAULT_cfQ(B) #define LOGICAL_cfQ(B) #define PLOGICAL_cfQ(B) #define STRINGV_cfQ(B) char *B; unsigned int _(B,N); #define STRING_cfQ(B) char *B=NULL; #define PSTRING_cfQ(B) char *B=NULL; #define PSTRINGV_cfQ(B) STRINGV_cfQ(B) #define PNSTRING_cfQ(B) char *B=NULL; #define PPSTRING_cfQ(B) #ifdef __sgi /* Else SGI gives warning 182 contrary to its C LRM A.17.7 */ #define ROUTINE_orig *(void**)& #else #define ROUTINE_orig (void *) #endif #define ROUTINE_1 ROUTINE_orig #define ROUTINE_2 ROUTINE_orig #define ROUTINE_3 ROUTINE_orig #define ROUTINE_4 ROUTINE_orig #define ROUTINE_5 ROUTINE_orig #define ROUTINE_6 ROUTINE_orig #define ROUTINE_7 ROUTINE_orig #define ROUTINE_8 ROUTINE_orig #define ROUTINE_9 ROUTINE_orig #define ROUTINE_10 ROUTINE_orig #define ROUTINE_11 ROUTINE_orig #define ROUTINE_12 ROUTINE_orig #define ROUTINE_13 ROUTINE_orig #define ROUTINE_14 ROUTINE_orig #define ROUTINE_15 ROUTINE_orig #define ROUTINE_16 ROUTINE_orig #define ROUTINE_17 ROUTINE_orig #define ROUTINE_18 ROUTINE_orig #define ROUTINE_19 ROUTINE_orig #define ROUTINE_20 ROUTINE_orig #define ROUTINE_21 ROUTINE_orig #define ROUTINE_22 ROUTINE_orig #define ROUTINE_23 ROUTINE_orig #define ROUTINE_24 ROUTINE_orig #define ROUTINE_25 ROUTINE_orig #define ROUTINE_26 ROUTINE_orig #define ROUTINE_27 ROUTINE_orig #define TCF(NAME,TN,I,M) _SEP_(TN,M,cfCOMMA) _(TN,_cfT)(NAME,I,_(A,I),_(B,I),_(C,I)) #define BYTE_cfT(M,I,A,B,D) *A #define DOUBLE_cfT(M,I,A,B,D) *A #define FLOAT_cfT(M,I,A,B,D) *A #define INT_cfT(M,I,A,B,D) *A #define LOGICAL_cfT(M,I,A,B,D) F2CLOGICAL(*A) #define LONG_cfT(M,I,A,B,D) *A #define LONGLONG_cfT(M,I,A,B,D) *A /* added by MR December 2005 */ #define SHORT_cfT(M,I,A,B,D) *A #define BYTEV_cfT(M,I,A,B,D) A #define DOUBLEV_cfT(M,I,A,B,D) A #define FLOATV_cfT(M,I,A,B,D) VOIDP A #define INTV_cfT(M,I,A,B,D) A #define LOGICALV_cfT(M,I,A,B,D) A #define LONGV_cfT(M,I,A,B,D) A #define LONGLONGV_cfT(M,I,A,B,D) A /* added by MR December 2005 */ #define SHORTV_cfT(M,I,A,B,D) A #define BYTEVV_cfT(M,I,A,B,D) (void *)A /* We have to cast to void *,*/ #define BYTEVVV_cfT(M,I,A,B,D) (void *)A /* since we don't know the */ #define BYTEVVVV_cfT(M,I,A,B,D) (void *)A /* dimensions of the array. */ #define BYTEVVVVV_cfT(M,I,A,B,D) (void *)A /* i.e. Unfortunately, can't */ #define BYTEVVVVVV_cfT(M,I,A,B,D) (void *)A /* check that the type */ #define BYTEVVVVVVV_cfT(M,I,A,B,D) (void *)A /* matches the prototype. */ #define DOUBLEVV_cfT(M,I,A,B,D) (void *)A #define DOUBLEVVV_cfT(M,I,A,B,D) (void *)A #define DOUBLEVVVV_cfT(M,I,A,B,D) (void *)A #define DOUBLEVVVVV_cfT(M,I,A,B,D) (void *)A #define DOUBLEVVVVVV_cfT(M,I,A,B,D) (void *)A #define DOUBLEVVVVVVV_cfT(M,I,A,B,D) (void *)A #define FLOATVV_cfT(M,I,A,B,D) (void *)A #define FLOATVVV_cfT(M,I,A,B,D) (void *)A #define FLOATVVVV_cfT(M,I,A,B,D) (void *)A #define FLOATVVVVV_cfT(M,I,A,B,D) (void *)A #define FLOATVVVVVV_cfT(M,I,A,B,D) (void *)A #define FLOATVVVVVVV_cfT(M,I,A,B,D) (void *)A #define INTVV_cfT(M,I,A,B,D) (void *)A #define INTVVV_cfT(M,I,A,B,D) (void *)A #define INTVVVV_cfT(M,I,A,B,D) (void *)A #define INTVVVVV_cfT(M,I,A,B,D) (void *)A #define INTVVVVVV_cfT(M,I,A,B,D) (void *)A #define INTVVVVVVV_cfT(M,I,A,B,D) (void *)A #define LOGICALVV_cfT(M,I,A,B,D) (void *)A #define LOGICALVVV_cfT(M,I,A,B,D) (void *)A #define LOGICALVVVV_cfT(M,I,A,B,D) (void *)A #define LOGICALVVVVV_cfT(M,I,A,B,D) (void *)A #define LOGICALVVVVVV_cfT(M,I,A,B,D) (void *)A #define LOGICALVVVVVVV_cfT(M,I,A,B,D) (void *)A #define LONGVV_cfT(M,I,A,B,D) (void *)A #define LONGVVV_cfT(M,I,A,B,D) (void *)A #define LONGVVVV_cfT(M,I,A,B,D) (void *)A #define LONGVVVVV_cfT(M,I,A,B,D) (void *)A #define LONGVVVVVV_cfT(M,I,A,B,D) (void *)A #define LONGVVVVVVV_cfT(M,I,A,B,D) (void *)A #define LONGLONGVV_cfT(M,I,A,B,D) (void *)A /* added by MR December 2005 */ #define LONGLONGVVV_cfT(M,I,A,B,D) (void *)A /* added by MR December 2005 */ #define LONGLONGVVVV_cfT(M,I,A,B,D) (void *)A /* added by MR December 2005 */ #define LONGLONGVVVVV_cfT(M,I,A,B,D) (void *)A /* added by MR December 2005 */ #define LONGLONGVVVVVV_cfT(M,I,A,B,D) (void *)A /* added by MR December 2005 */ #define LONGLONGVVVVVVV_cfT(M,I,A,B,D) (void *)A /* added by MR December 2005 */ #define SHORTVV_cfT(M,I,A,B,D) (void *)A #define SHORTVVV_cfT(M,I,A,B,D) (void *)A #define SHORTVVVV_cfT(M,I,A,B,D) (void *)A #define SHORTVVVVV_cfT(M,I,A,B,D) (void *)A #define SHORTVVVVVV_cfT(M,I,A,B,D) (void *)A #define SHORTVVVVVVV_cfT(M,I,A,B,D) (void *)A #define PBYTE_cfT(M,I,A,B,D) A #define PDOUBLE_cfT(M,I,A,B,D) A #define PFLOAT_cfT(M,I,A,B,D) VOIDP A #define PINT_cfT(M,I,A,B,D) A #define PLOGICAL_cfT(M,I,A,B,D) ((*A=F2CLOGICAL(*A)),A) #define PLONG_cfT(M,I,A,B,D) A #define PLONGLONG_cfT(M,I,A,B,D) A /* added by MR December 2005 */ #define PSHORT_cfT(M,I,A,B,D) A #define PVOID_cfT(M,I,A,B,D) A #if defined(apolloFortran) || defined(hpuxFortran800) || defined(AbsoftUNIXFortran) #define ROUTINE_cfT(M,I,A,B,D) _(ROUTINE_,I) (*A) #else #define ROUTINE_cfT(M,I,A,B,D) _(ROUTINE_,I) A #endif /* A == pointer to the characters D == length of the string, or of an element in an array of strings E == number of elements in an array of strings */ #define TTSTR( A,B,D) \ ((B=_cf_malloc(D+1))[D]='\0', memcpy(B,A,D), kill_trailing(B,' ')) #define TTTTSTR( A,B,D) (!(D<4||A[0]||A[1]||A[2]||A[3]))?NULL: \ memchr(A,'\0',D) ?A : TTSTR(A,B,D) #define TTTTSTRV( A,B,D,E) (_(B,N)=E,B=_cf_malloc(_(B,N)*(D+1)), (void *) \ vkill_trailing(f2cstrv(A,B,D+1, _(B,N)*(D+1)), D+1,_(B,N)*(D+1),' ')) #ifdef vmsFortran #define STRING_cfT(M,I,A,B,D) TTTTSTR( A->dsc$a_pointer,B,A->dsc$w_length) #define STRINGV_cfT(M,I,A,B,D) TTTTSTRV(A->dsc$a_pointer, B, \ A->dsc$w_length , A->dsc$l_m[0]) #define PSTRING_cfT(M,I,A,B,D) TTSTR( A->dsc$a_pointer,B,A->dsc$w_length) #define PPSTRING_cfT(M,I,A,B,D) A->dsc$a_pointer #else #ifdef CRAYFortran #define STRING_cfT(M,I,A,B,D) TTTTSTR( _fcdtocp(A),B,_fcdlen(A)) #define STRINGV_cfT(M,I,A,B,D) TTTTSTRV(_fcdtocp(A),B,_fcdlen(A), \ num_elem(_fcdtocp(A),_fcdlen(A),_3(M,_STRV_A,I))) #define PSTRING_cfT(M,I,A,B,D) TTSTR( _fcdtocp(A),B,_fcdlen(A)) #define PPSTRING_cfT(M,I,A,B,D) _fcdtocp(A) #else #define STRING_cfT(M,I,A,B,D) TTTTSTR( A,B,D) #define STRINGV_cfT(M,I,A,B,D) TTTTSTRV(A,B,D, num_elem(A,D,_3(M,_STRV_A,I))) #define PSTRING_cfT(M,I,A,B,D) TTSTR( A,B,D) #define PPSTRING_cfT(M,I,A,B,D) A #endif #endif #define PNSTRING_cfT(M,I,A,B,D) STRING_cfT(M,I,A,B,D) #define PSTRINGV_cfT(M,I,A,B,D) STRINGV_cfT(M,I,A,B,D) #define CF_0_cfT(M,I,A,B,D) #define RCF(TN,I) _(TN,_cfSTR)(3,R,_(A,I),_(B,I),_(C,I),0,0) #define DEFAULT_cfR(A,B,D) #define LOGICAL_cfR(A,B,D) #define PLOGICAL_cfR(A,B,D) *A=C2FLOGICAL(*A); #define STRING_cfR(A,B,D) if (B) _cf_free(B); #define STRINGV_cfR(A,B,D) _cf_free(B); /* A and D as defined above for TSTRING(V) */ #define RRRRPSTR( A,B,D) if (B) memcpy(A,B, _cfMIN(strlen(B),D)), \ (D>strlen(B)?memset(A+strlen(B),' ', D-strlen(B)):0), _cf_free(B); #define RRRRPSTRV(A,B,D) c2fstrv(B,A,D+1,(D+1)*_(B,N)), _cf_free(B); #ifdef vmsFortran #define PSTRING_cfR(A,B,D) RRRRPSTR( A->dsc$a_pointer,B,A->dsc$w_length) #define PSTRINGV_cfR(A,B,D) RRRRPSTRV(A->dsc$a_pointer,B,A->dsc$w_length) #else #ifdef CRAYFortran #define PSTRING_cfR(A,B,D) RRRRPSTR( _fcdtocp(A),B,_fcdlen(A)) #define PSTRINGV_cfR(A,B,D) RRRRPSTRV(_fcdtocp(A),B,_fcdlen(A)) #else #define PSTRING_cfR(A,B,D) RRRRPSTR( A,B,D) #define PSTRINGV_cfR(A,B,D) RRRRPSTRV(A,B,D) #endif #endif #define PNSTRING_cfR(A,B,D) PSTRING_cfR(A,B,D) #define PPSTRING_cfR(A,B,D) #define BYTE_cfFZ(UN,LN) INTEGER_BYTE FCALLSC_QUALIFIER fcallsc(UN,LN)( #define DOUBLE_cfFZ(UN,LN) DOUBLE_PRECISION FCALLSC_QUALIFIER fcallsc(UN,LN)( #define INT_cfFZ(UN,LN) int FCALLSC_QUALIFIER fcallsc(UN,LN)( #define LOGICAL_cfFZ(UN,LN) int FCALLSC_QUALIFIER fcallsc(UN,LN)( #define LONG_cfFZ(UN,LN) long FCALLSC_QUALIFIER fcallsc(UN,LN)( #define LONGLONG_cfFZ(UN,LN) LONGLONG FCALLSC_QUALIFIER fcallsc(UN,LN)( /* added by MR December 2005 */ #define SHORT_cfFZ(UN,LN) short FCALLSC_QUALIFIER fcallsc(UN,LN)( #define VOID_cfFZ(UN,LN) void FCALLSC_QUALIFIER fcallsc(UN,LN)( #ifndef __CF__KnR /* The void is req'd by the Apollo, to make this an ANSI function declaration. The Apollo promotes K&R float functions to double. */ #if defined (f2cFortran) && ! defined (gFortran) /* f2c/g77 return double from FORTRAN REAL functions. (KMCCARTY, 2005/12/09) */ #define FLOAT_cfFZ(UN,LN) DOUBLE_PRECISION FCALLSC_QUALIFIER fcallsc(UN,LN)(void #else #define FLOAT_cfFZ(UN,LN) FORTRAN_REAL FCALLSC_QUALIFIER fcallsc(UN,LN)(void #endif #ifdef vmsFortran #define STRING_cfFZ(UN,LN) void FCALLSC_QUALIFIER fcallsc(UN,LN)(fstring *AS #else #ifdef CRAYFortran #define STRING_cfFZ(UN,LN) void FCALLSC_QUALIFIER fcallsc(UN,LN)(_fcd AS #else #if defined(AbsoftUNIXFortran) || defined(AbsoftProFortran) #define STRING_cfFZ(UN,LN) void FCALLSC_QUALIFIER fcallsc(UN,LN)(char *AS #else #define STRING_cfFZ(UN,LN) void FCALLSC_QUALIFIER fcallsc(UN,LN)(char *AS, unsigned D0 #endif #endif #endif #else #if ! (defined(FLOATFUNCTIONTYPE)&&defined(ASSIGNFLOAT)&&defined(RETURNFLOAT)) #if defined (f2cFortran) && ! defined (gFortran) /* f2c/g77 return double from FORTRAN REAL functions. (KMCCARTY, 2005/12/09) */ #define FLOAT_cfFZ(UN,LN) DOUBLE_PRECISION FCALLSC_QUALIFIER fcallsc(UN,LN)( #else #define FLOAT_cfFZ(UN,LN) FORTRAN_REAL FCALLSC_QUALIFIER fcallsc(UN,LN)( #endif #else #define FLOAT_cfFZ(UN,LN) FLOATFUNCTIONTYPE FCALLSC_QUALIFIER fcallsc(UN,LN)( #endif #if defined(vmsFortran) || defined(CRAYFortran) || defined(AbsoftUNIXFortran) #define STRING_cfFZ(UN,LN) void FCALLSC_QUALIFIER fcallsc(UN,LN)(AS #else #define STRING_cfFZ(UN,LN) void FCALLSC_QUALIFIER fcallsc(UN,LN)(AS, D0 #endif #endif #define BYTE_cfF(UN,LN) BYTE_cfFZ(UN,LN) #define DOUBLE_cfF(UN,LN) DOUBLE_cfFZ(UN,LN) #ifndef __CF_KnR #if defined (f2cFortran) && ! defined (gFortran) /* f2c/g77 return double from FORTRAN REAL functions. (KMCCARTY, 2005/12/09) */ #define FLOAT_cfF(UN,LN) DOUBLE_PRECISION FCALLSC_QUALIFIER fcallsc(UN,LN)( #else #define FLOAT_cfF(UN,LN) FORTRAN_REAL FCALLSC_QUALIFIER fcallsc(UN,LN)( #endif #else #define FLOAT_cfF(UN,LN) FLOAT_cfFZ(UN,LN) #endif #define INT_cfF(UN,LN) INT_cfFZ(UN,LN) #define LOGICAL_cfF(UN,LN) LOGICAL_cfFZ(UN,LN) #define LONG_cfF(UN,LN) LONG_cfFZ(UN,LN) #define LONGLONG_cfF(UN,LN) LONGLONG_cfFZ(UN,LN) /* added by MR December 2005 */ #define SHORT_cfF(UN,LN) SHORT_cfFZ(UN,LN) #define VOID_cfF(UN,LN) VOID_cfFZ(UN,LN) #define STRING_cfF(UN,LN) STRING_cfFZ(UN,LN), #define INT_cfFF #define VOID_cfFF #ifdef vmsFortran #define STRING_cfFF fstring *AS; #else #ifdef CRAYFortran #define STRING_cfFF _fcd AS; #else #define STRING_cfFF char *AS; unsigned D0; #endif #endif #define INT_cfL A0= #define STRING_cfL A0= #define VOID_cfL #define INT_cfK #define VOID_cfK /* KSTRING copies the string into the position provided by the caller. */ #ifdef vmsFortran #define STRING_cfK \ memcpy(AS->dsc$a_pointer,A0,_cfMIN(AS->dsc$w_length,(A0==NULL?0:strlen(A0))));\ AS->dsc$w_length>(A0==NULL?0:strlen(A0))? \ memset(AS->dsc$a_pointer+(A0==NULL?0:strlen(A0)),' ', \ AS->dsc$w_length-(A0==NULL?0:strlen(A0))):0; #else #ifdef CRAYFortran #define STRING_cfK \ memcpy(_fcdtocp(AS),A0, _cfMIN(_fcdlen(AS),(A0==NULL?0:strlen(A0))) ); \ _fcdlen(AS)>(A0==NULL?0:strlen(A0))? \ memset(_fcdtocp(AS)+(A0==NULL?0:strlen(A0)),' ', \ _fcdlen(AS)-(A0==NULL?0:strlen(A0))):0; #else #define STRING_cfK memcpy(AS,A0, _cfMIN(D0,(A0==NULL?0:strlen(A0))) ); \ D0>(A0==NULL?0:strlen(A0))?memset(AS+(A0==NULL?0:strlen(A0)), \ ' ', D0-(A0==NULL?0:strlen(A0))):0; #endif #endif /* Note that K.. and I.. can't be combined since K.. has to access data before R.., in order for functions returning strings which are also passed in as arguments to work correctly. Note that R.. frees and hence may corrupt the string. */ #define BYTE_cfI return A0; #define DOUBLE_cfI return A0; #if ! (defined(FLOATFUNCTIONTYPE)&&defined(ASSIGNFLOAT)&&defined(RETURNFLOAT)) #define FLOAT_cfI return A0; #else #define FLOAT_cfI RETURNFLOAT(A0); #endif #define INT_cfI return A0; #ifdef hpuxFortran800 /* Incredibly, functions must return true as 1, elsewhere .true.==0x01000000. */ #define LOGICAL_cfI return ((A0)?1:0); #else #define LOGICAL_cfI return C2FLOGICAL(A0); #endif #define LONG_cfI return A0; #define LONGLONG_cfI return A0; /* added by MR December 2005 */ #define SHORT_cfI return A0; #define STRING_cfI return ; #define VOID_cfI return ; #ifdef OLD_VAXC /* Allow %CC-I-PARAMNOTUSED. */ #pragma standard #endif #define FCALLSCSUB0( CN,UN,LN) FCALLSCFUN0(VOID,CN,UN,LN) #define FCALLSCSUB1( CN,UN,LN,T1) FCALLSCFUN1(VOID,CN,UN,LN,T1) #define FCALLSCSUB2( CN,UN,LN,T1,T2) FCALLSCFUN2(VOID,CN,UN,LN,T1,T2) #define FCALLSCSUB3( CN,UN,LN,T1,T2,T3) FCALLSCFUN3(VOID,CN,UN,LN,T1,T2,T3) #define FCALLSCSUB4( CN,UN,LN,T1,T2,T3,T4) \ FCALLSCFUN4(VOID,CN,UN,LN,T1,T2,T3,T4) #define FCALLSCSUB5( CN,UN,LN,T1,T2,T3,T4,T5) \ FCALLSCFUN5(VOID,CN,UN,LN,T1,T2,T3,T4,T5) #define FCALLSCSUB6( CN,UN,LN,T1,T2,T3,T4,T5,T6) \ FCALLSCFUN6(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6) #define FCALLSCSUB7( CN,UN,LN,T1,T2,T3,T4,T5,T6,T7) \ FCALLSCFUN7(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7) #define FCALLSCSUB8( CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8) \ FCALLSCFUN8(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8) #define FCALLSCSUB9( CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9) \ FCALLSCFUN9(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9) #define FCALLSCSUB10(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA) \ FCALLSCFUN10(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA) #define FCALLSCSUB11(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB) \ FCALLSCFUN11(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB) #define FCALLSCSUB12(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC) \ FCALLSCFUN12(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC) #define FCALLSCSUB13(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD) \ FCALLSCFUN13(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD) #define FCALLSCSUB14(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ FCALLSCFUN14(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) #define FCALLSCSUB15(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF) \ FCALLSCFUN15(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF) #define FCALLSCSUB16(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG) \ FCALLSCFUN16(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG) #define FCALLSCSUB17(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH) \ FCALLSCFUN17(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH) #define FCALLSCSUB18(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI) \ FCALLSCFUN18(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI) #define FCALLSCSUB19(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ) \ FCALLSCFUN19(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ) #define FCALLSCSUB20(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) \ FCALLSCFUN20(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) #define FCALLSCSUB21(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL) \ FCALLSCFUN21(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL) #define FCALLSCSUB22(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM) \ FCALLSCFUN22(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM) #define FCALLSCSUB23(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN) \ FCALLSCFUN23(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN) #define FCALLSCSUB24(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO) \ FCALLSCFUN24(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO) #define FCALLSCSUB25(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP) \ FCALLSCFUN25(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP) #define FCALLSCSUB26(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ) \ FCALLSCFUN26(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ) #define FCALLSCSUB27(CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ FCALLSCFUN27(VOID,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) #define FCALLSCFUN1( T0,CN,UN,LN,T1) \ FCALLSCFUN5 (T0,CN,UN,LN,T1,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN2( T0,CN,UN,LN,T1,T2) \ FCALLSCFUN5 (T0,CN,UN,LN,T1,T2,CF_0,CF_0,CF_0) #define FCALLSCFUN3( T0,CN,UN,LN,T1,T2,T3) \ FCALLSCFUN5 (T0,CN,UN,LN,T1,T2,T3,CF_0,CF_0) #define FCALLSCFUN4( T0,CN,UN,LN,T1,T2,T3,T4) \ FCALLSCFUN5 (T0,CN,UN,LN,T1,T2,T3,T4,CF_0) #define FCALLSCFUN5( T0,CN,UN,LN,T1,T2,T3,T4,T5) \ FCALLSCFUN10(T0,CN,UN,LN,T1,T2,T3,T4,T5,CF_0,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN6( T0,CN,UN,LN,T1,T2,T3,T4,T5,T6) \ FCALLSCFUN10(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN7( T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7) \ FCALLSCFUN10(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,CF_0,CF_0,CF_0) #define FCALLSCFUN8( T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8) \ FCALLSCFUN10(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,CF_0,CF_0) #define FCALLSCFUN9( T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9) \ FCALLSCFUN10(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,CF_0) #define FCALLSCFUN10(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA) \ FCALLSCFUN14(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN11(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB) \ FCALLSCFUN14(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,CF_0,CF_0,CF_0) #define FCALLSCFUN12(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC) \ FCALLSCFUN14(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,CF_0,CF_0) #define FCALLSCFUN13(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD) \ FCALLSCFUN14(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,CF_0) #define FCALLSCFUN15(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF) \ FCALLSCFUN20(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,CF_0,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN16(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG) \ FCALLSCFUN20(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN17(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH) \ FCALLSCFUN20(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,CF_0,CF_0,CF_0) #define FCALLSCFUN18(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI) \ FCALLSCFUN20(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,CF_0,CF_0) #define FCALLSCFUN19(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ) \ FCALLSCFUN20(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,CF_0) #define FCALLSCFUN20(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK) \ FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN21(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL) \ FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,CF_0,CF_0,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN22(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM) \ FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,CF_0,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN23(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN) \ FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,CF_0,CF_0,CF_0,CF_0) #define FCALLSCFUN24(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO) \ FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,CF_0,CF_0,CF_0) #define FCALLSCFUN25(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP) \ FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,CF_0,CF_0) #define FCALLSCFUN26(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ) \ FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,CF_0) #ifndef __CF__KnR #define FCALLSCFUN0(T0,CN,UN,LN) CFextern _(T0,_cfFZ)(UN,LN) ABSOFT_cf2(T0)) \ {_Icf(2,UU,T0,A0,0); _Icf(0,L,T0,0,0) CN(); _Icf(0,K,T0,0,0) _(T0,_cfI)} #define FCALLSCFUN14(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ CFextern _(T0,_cfF)(UN,LN) \ CFARGT14(NCF,DCF,ABSOFT_cf2(T0),T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) ) \ { CFARGT14S(QCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ _Icf(2,UU,T0,A0,0); _Icf(0,L,T0,0,0) CN( TCF(LN,T1,1,0) TCF(LN,T2,2,1) \ TCF(LN,T3,3,1) TCF(LN,T4,4,1) TCF(LN,T5,5,1) TCF(LN,T6,6,1) TCF(LN,T7,7,1) \ TCF(LN,T8,8,1) TCF(LN,T9,9,1) TCF(LN,TA,10,1) TCF(LN,TB,11,1) TCF(LN,TC,12,1) \ TCF(LN,TD,13,1) TCF(LN,TE,14,1) ); _Icf(0,K,T0,0,0) \ CFARGT14S(RCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) _(T0,_cfI) } #define FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ CFextern _(T0,_cfF)(UN,LN) \ CFARGT27(NCF,DCF,ABSOFT_cf2(T0),T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) ) \ { CFARGT27S(QCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ _Icf(2,UU,T0,A0,0); _Icf(0,L,T0,0,0) CN( TCF(LN,T1,1,0) TCF(LN,T2,2,1) \ TCF(LN,T3,3,1) TCF(LN,T4,4,1) TCF(LN,T5,5,1) TCF(LN,T6,6,1) TCF(LN,T7,7,1) \ TCF(LN,T8,8,1) TCF(LN,T9,9,1) TCF(LN,TA,10,1) TCF(LN,TB,11,1) TCF(LN,TC,12,1) \ TCF(LN,TD,13,1) TCF(LN,TE,14,1) TCF(LN,TF,15,1) TCF(LN,TG,16,1) TCF(LN,TH,17,1) \ TCF(LN,TI,18,1) TCF(LN,TJ,19,1) TCF(LN,TK,20,1) TCF(LN,TL,21,1) TCF(LN,TM,22,1) \ TCF(LN,TN,23,1) TCF(LN,TO,24,1) TCF(LN,TP,25,1) TCF(LN,TQ,26,1) TCF(LN,TR,27,1) ); _Icf(0,K,T0,0,0) \ CFARGT27S(RCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) _(T0,_cfI) } #else #define FCALLSCFUN0(T0,CN,UN,LN) CFextern _(T0,_cfFZ)(UN,LN) ABSOFT_cf3(T0)) _Icf(0,FF,T0,0,0)\ {_Icf(2,UU,T0,A0,0); _Icf(0,L,T0,0,0) CN(); _Icf(0,K,T0,0,0) _(T0,_cfI)} #define FCALLSCFUN14(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ CFextern _(T0,_cfF)(UN,LN) \ CFARGT14(NNCF,DDCF,ABSOFT_cf3(T0),T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE)) _Icf(0,FF,T0,0,0) \ CFARGT14FS(NNNCF,DDDCF,_Z,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE); \ { CFARGT14S(QCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) \ _Icf(2,UU,T0,A0,0); _Icf(0,L,T0,0,0) CN( TCF(LN,T1,1,0) TCF(LN,T2,2,1) \ TCF(LN,T3,3,1) TCF(LN,T4,4,1) TCF(LN,T5,5,1) TCF(LN,T6,6,1) TCF(LN,T7,7,1) \ TCF(LN,T8,8,1) TCF(LN,T9,9,1) TCF(LN,TA,10,1) TCF(LN,TB,11,1) TCF(LN,TC,12,1) \ TCF(LN,TD,13,1) TCF(LN,TE,14,1) ); _Icf(0,K,T0,0,0) \ CFARGT14S(RCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE) _(T0,_cfI)} #define FCALLSCFUN27(T0,CN,UN,LN,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ CFextern _(T0,_cfF)(UN,LN) \ CFARGT27(NNCF,DDCF,ABSOFT_cf3(T0),T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR)) _Icf(0,FF,T0,0,0) \ CFARGT27FS(NNNCF,DDDCF,_Z,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR); \ { CFARGT27S(QCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) \ _Icf(2,UU,T0,A0,0); _Icf(0,L,T0,0,0) CN( TCF(LN,T1,1,0) TCF(LN,T2,2,1) \ TCF(LN,T3,3,1) TCF(LN,T4,4,1) TCF(LN,T5,5,1) TCF(LN,T6,6,1) TCF(LN,T7,7,1) \ TCF(LN,T8,8,1) TCF(LN,T9,9,1) TCF(LN,TA,10,1) TCF(LN,TB,11,1) TCF(LN,TC,12,1) \ TCF(LN,TD,13,1) TCF(LN,TE,14,1) TCF(LN,TF,15,1) TCF(LN,TG,16,1) TCF(LN,TH,17,1) \ TCF(LN,TI,18,1) TCF(LN,TJ,19,1) TCF(LN,TK,20,1) TCF(LN,TL,21,1) TCF(LN,TM,22,1) \ TCF(LN,TN,23,1) TCF(LN,TO,24,1) TCF(LN,TP,25,1) TCF(LN,TQ,26,1) TCF(LN,TR,27,1) ); _Icf(0,K,T0,0,0) \ CFARGT27S(RCF,T1,T2,T3,T4,T5,T6,T7,T8,T9,TA,TB,TC,TD,TE,TF,TG,TH,TI,TJ,TK,TL,TM,TN,TO,TP,TQ,TR) _(T0,_cfI)} #endif #endif /* __CFORTRAN_LOADED */ healpy-1.10.3/cfitsio/checksum.c0000664000175000017500000004226413010375004016735 0ustar zoncazonca00000000000000/* This file, checksum.c, contains the checksum-related routines in the */ /* FITSIO library. */ /* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ #include #include #include "fitsio2.h" /*------------------------------------------------------------------------*/ int ffcsum(fitsfile *fptr, /* I - FITS file pointer */ long nrec, /* I - number of 2880-byte blocks to sum */ unsigned long *sum, /* IO - accumulated checksum */ int *status) /* IO - error status */ /* Calculate a 32-bit 1's complement checksum of the FITS 2880-byte blocks. This routine is based on the C algorithm developed by Rob Seaman at NOAO that was presented at the 1994 ADASS conference, published in the Astronomical Society of the Pacific Conference Series. This uses a 32-bit 1's complement checksum in which the overflow bits are permuted back into the sum and therefore all bit positions are sampled evenly. */ { long ii, jj; unsigned short sbuf[1440]; unsigned long hi, lo, hicarry, locarry; if (*status > 0) return(*status); /* Sum the specified number of FITS 2880-byte records. This assumes that the FITSIO file pointer points to the start of the records to be summed. Read each FITS block as 1440 short values (do byte swapping if needed). */ for (jj = 0; jj < nrec; jj++) { ffgbyt(fptr, 2880, sbuf, status); #if BYTESWAPPED ffswap2( (short *)sbuf, 1440); /* reverse order of bytes in each value */ #endif hi = (*sum >> 16); lo = *sum & 0xFFFF; for (ii = 0; ii < 1440; ii += 2) { hi += sbuf[ii]; lo += sbuf[ii+1]; } hicarry = hi >> 16; /* fold carry bits in */ locarry = lo >> 16; while (hicarry | locarry) { hi = (hi & 0xFFFF) + locarry; lo = (lo & 0xFFFF) + hicarry; hicarry = hi >> 16; locarry = lo >> 16; } *sum = (hi << 16) + lo; } return(*status); } /*-------------------------------------------------------------------------*/ void ffesum(unsigned long sum, /* I - accumulated checksum */ int complm, /* I - = 1 to encode complement of the sum */ char *ascii) /* O - 16-char ASCII encoded checksum */ /* encode the 32 bit checksum by converting every 2 bits of each byte into an ASCII character (32 bit word encoded as 16 character string). Only ASCII letters and digits are used to encode the values (no ASCII punctuation characters). If complm=TRUE, then the complement of the sum will be encoded. This routine is based on the C algorithm developed by Rob Seaman at NOAO that was presented at the 1994 ADASS conference, published in the Astronomical Society of the Pacific Conference Series. */ { unsigned int exclude[13] = { 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60 }; unsigned long mask[4] = { 0xff000000, 0xff0000, 0xff00, 0xff }; int offset = 0x30; /* ASCII 0 (zero) */ unsigned long value; int byte, quotient, remainder, ch[4], check, ii, jj, kk; char asc[32]; if (complm) value = 0xFFFFFFFF - sum; /* complement each bit of the value */ else value = sum; for (ii = 0; ii < 4; ii++) { byte = (value & mask[ii]) >> (24 - (8 * ii)); quotient = byte / 4 + offset; remainder = byte % 4; for (jj = 0; jj < 4; jj++) ch[jj] = quotient; ch[0] += remainder; for (check = 1; check;) /* avoid ASCII punctuation */ for (check = 0, kk = 0; kk < 13; kk++) for (jj = 0; jj < 4; jj += 2) if ((unsigned char) ch[jj] == exclude[kk] || (unsigned char) ch[jj+1] == exclude[kk]) { ch[jj]++; ch[jj+1]--; check++; } for (jj = 0; jj < 4; jj++) /* assign the bytes */ asc[4*jj+ii] = ch[jj]; } for (ii = 0; ii < 16; ii++) /* shift the bytes 1 to the right */ ascii[ii] = asc[(ii+15)%16]; ascii[16] = '\0'; } /*-------------------------------------------------------------------------*/ unsigned long ffdsum(char *ascii, /* I - 16-char ASCII encoded checksum */ int complm, /* I - =1 to decode complement of the */ unsigned long *sum) /* O - 32-bit checksum */ /* decode the 16-char ASCII encoded checksum into an unsigned 32-bit long. If complm=TRUE, then the complement of the sum will be decoded. This routine is based on the C algorithm developed by Rob Seaman at NOAO that was presented at the 1994 ADASS conference, published in the Astronomical Society of the Pacific Conference Series. */ { char cbuf[16]; unsigned long hi = 0, lo = 0, hicarry, locarry; int ii; /* remove the permuted FITS byte alignment and the ASCII 0 offset */ for (ii = 0; ii < 16; ii++) { cbuf[ii] = ascii[(ii+1)%16]; cbuf[ii] -= 0x30; } for (ii = 0; ii < 16; ii += 4) { hi += (cbuf[ii] << 8) + cbuf[ii+1]; lo += (cbuf[ii+2] << 8) + cbuf[ii+3]; } hicarry = hi >> 16; locarry = lo >> 16; while (hicarry || locarry) { hi = (hi & 0xFFFF) + locarry; lo = (lo & 0xFFFF) + hicarry; hicarry = hi >> 16; locarry = lo >> 16; } *sum = (hi << 16) + lo; if (complm) *sum = 0xFFFFFFFF - *sum; /* complement each bit of the value */ return(*sum); } /*------------------------------------------------------------------------*/ int ffpcks(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* Create or update the checksum keywords in the CHDU. These keywords provide a checksum verification of the FITS HDU based on the ASCII coded 1's complement checksum algorithm developed by Rob Seaman at NOAO. */ { char datestr[20], checksum[FLEN_VALUE], datasum[FLEN_VALUE]; char comm[FLEN_COMMENT], chkcomm[FLEN_COMMENT], datacomm[FLEN_COMMENT]; int tstatus; long nrec; LONGLONG headstart, datastart, dataend; unsigned long dsum, olddsum, sum; double tdouble; if (*status > 0) /* inherit input status value if > 0 */ return(*status); /* generate current date string and construct the keyword comments */ ffgstm(datestr, NULL, status); strcpy(chkcomm, "HDU checksum updated "); strcat(chkcomm, datestr); strcpy(datacomm, "data unit checksum updated "); strcat(datacomm, datestr); /* write the CHECKSUM keyword if it does not exist */ tstatus = *status; if (ffgkys(fptr, "CHECKSUM", checksum, comm, status) == KEY_NO_EXIST) { *status = tstatus; strcpy(checksum, "0000000000000000"); ffpkys(fptr, "CHECKSUM", checksum, chkcomm, status); } /* write the DATASUM keyword if it does not exist */ tstatus = *status; if (ffgkys(fptr, "DATASUM", datasum, comm, status) == KEY_NO_EXIST) { *status = tstatus; olddsum = 0; ffpkys(fptr, "DATASUM", " 0", datacomm, status); /* set the CHECKSUM keyword as undefined, if it isn't already */ if (strcmp(checksum, "0000000000000000") ) { strcpy(checksum, "0000000000000000"); ffmkys(fptr, "CHECKSUM", checksum, chkcomm, status); } } else { /* decode the datasum into an unsigned long variable */ /* olddsum = strtoul(datasum, 0, 10); doesn't work on SUN OS */ tdouble = atof(datasum); olddsum = (unsigned long) tdouble; } /* close header: rewrite END keyword and following blank fill */ /* and re-read the required keywords to determine the structure */ if (ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->heapsize > 0) ffuptf(fptr, status); /* update the variable length TFORM values */ /* write the correct data fill values, if they are not already correct */ if (ffpdfl(fptr, status) > 0) return(*status); /* calc size of data unit, in FITS 2880-byte blocks */ if (ffghadll(fptr, &headstart, &datastart, &dataend, status) > 0) return(*status); nrec = (long) ((dataend - datastart) / 2880); dsum = 0; if (nrec > 0) { /* accumulate the 32-bit 1's complement checksum */ ffmbyt(fptr, datastart, REPORT_EOF, status); if (ffcsum(fptr, nrec, &dsum, status) > 0) return(*status); } if (dsum != olddsum) { /* update the DATASUM keyword with the correct value */ sprintf(datasum, "%lu", dsum); ffmkys(fptr, "DATASUM", datasum, datacomm, status); /* set the CHECKSUM keyword as undefined, if it isn't already */ if (strcmp(checksum, "0000000000000000") ) { strcpy(checksum, "0000000000000000"); ffmkys(fptr, "CHECKSUM", checksum, chkcomm, status); } } if (strcmp(checksum, "0000000000000000") ) { /* check if CHECKSUM is still OK; move to the start of the header */ ffmbyt(fptr, headstart, REPORT_EOF, status); /* accumulate the header checksum into the previous data checksum */ nrec = (long) ((datastart - headstart) / 2880); sum = dsum; if (ffcsum(fptr, nrec, &sum, status) > 0) return(*status); if (sum == 0 || sum == 0xFFFFFFFF) return(*status); /* CHECKSUM is correct */ /* Zero the CHECKSUM and recompute the new value */ ffmkys(fptr, "CHECKSUM", "0000000000000000", chkcomm, status); } /* move to the start of the header */ ffmbyt(fptr, headstart, REPORT_EOF, status); /* accumulate the header checksum into the previous data checksum */ nrec = (long) ((datastart - headstart) / 2880); sum = dsum; if (ffcsum(fptr, nrec, &sum, status) > 0) return(*status); /* encode the COMPLEMENT of the checksum into a 16-character string */ ffesum(sum, TRUE, checksum); /* update the CHECKSUM keyword value with the new string */ ffmkys(fptr, "CHECKSUM", checksum, "&", status); return(*status); } /*------------------------------------------------------------------------*/ int ffupck(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* Update the CHECKSUM keyword value. This assumes that the DATASUM keyword exists and has the correct value. */ { char datestr[20], chkcomm[FLEN_COMMENT], comm[FLEN_COMMENT]; char checksum[FLEN_VALUE], datasum[FLEN_VALUE]; int tstatus; long nrec; LONGLONG headstart, datastart, dataend; unsigned long sum, dsum; double tdouble; if (*status > 0) /* inherit input status value if > 0 */ return(*status); /* generate current date string and construct the keyword comments */ ffgstm(datestr, NULL, status); strcpy(chkcomm, "HDU checksum updated "); strcat(chkcomm, datestr); /* get the DATASUM keyword and convert it to a unsigned long */ if (ffgkys(fptr, "DATASUM", datasum, comm, status) == KEY_NO_EXIST) { ffpmsg("DATASUM keyword not found (ffupck"); return(*status); } tdouble = atof(datasum); /* read as a double as a workaround */ dsum = (unsigned long) tdouble; /* get size of the HDU */ if (ffghadll(fptr, &headstart, &datastart, &dataend, status) > 0) return(*status); /* get the checksum keyword, if it exists */ tstatus = *status; if (ffgkys(fptr, "CHECKSUM", checksum, comm, status) == KEY_NO_EXIST) { *status = tstatus; strcpy(checksum, "0000000000000000"); ffpkys(fptr, "CHECKSUM", checksum, chkcomm, status); } else { /* check if CHECKSUM is still OK */ /* rewrite END keyword and following blank fill */ if (ffwend(fptr, status) > 0) return(*status); /* move to the start of the header */ ffmbyt(fptr, headstart, REPORT_EOF, status); /* accumulate the header checksum into the previous data checksum */ nrec = (long) ((datastart - headstart) / 2880); sum = dsum; if (ffcsum(fptr, nrec, &sum, status) > 0) return(*status); if (sum == 0 || sum == 0xFFFFFFFF) return(*status); /* CHECKSUM is already correct */ /* Zero the CHECKSUM and recompute the new value */ ffmkys(fptr, "CHECKSUM", "0000000000000000", chkcomm, status); } /* move to the start of the header */ ffmbyt(fptr, headstart, REPORT_EOF, status); /* accumulate the header checksum into the previous data checksum */ nrec = (long) ((datastart - headstart) / 2880); sum = dsum; if (ffcsum(fptr, nrec, &sum, status) > 0) return(*status); /* encode the COMPLEMENT of the checksum into a 16-character string */ ffesum(sum, TRUE, checksum); /* update the CHECKSUM keyword value with the new string */ ffmkys(fptr, "CHECKSUM", checksum, "&", status); return(*status); } /*------------------------------------------------------------------------*/ int ffvcks(fitsfile *fptr, /* I - FITS file pointer */ int *datastatus, /* O - data checksum status */ int *hdustatus, /* O - hdu checksum status */ /* 1 verification is correct */ /* 0 checksum keyword is not present */ /* -1 verification not correct */ int *status) /* IO - error status */ /* Verify the HDU by comparing the value of the computed checksums against the values of the DATASUM and CHECKSUM keywords if they are present. */ { int tstatus; double tdouble; unsigned long datasum, hdusum, olddatasum; char chksum[FLEN_VALUE], comm[FLEN_COMMENT]; if (*status > 0) /* inherit input status value if > 0 */ return(*status); *datastatus = -1; *hdustatus = -1; tstatus = *status; if (ffgkys(fptr, "CHECKSUM", chksum, comm, status) == KEY_NO_EXIST) { *hdustatus = 0; /* CHECKSUM keyword does not exist */ *status = tstatus; } if (chksum[0] == '\0') *hdustatus = 0; /* all blank checksum means it is undefined */ if (ffgkys(fptr, "DATASUM", chksum, comm, status) == KEY_NO_EXIST) { *datastatus = 0; /* DATASUM keyword does not exist */ *status = tstatus; } if (chksum[0] == '\0') *datastatus = 0; /* all blank checksum means it is undefined */ if ( *status > 0 || (!(*hdustatus) && !(*datastatus)) ) return(*status); /* return if neither keywords exist */ /* convert string to unsigned long */ /* olddatasum = strtoul(chksum, 0, 10); doesn't work w/ gcc on SUN OS */ /* sscanf(chksum, "%u", &olddatasum); doesn't work w/ cc on VAX/VMS */ tdouble = atof(chksum); /* read as a double as a workaround */ olddatasum = (unsigned long) tdouble; /* calculate the data checksum and the HDU checksum */ if (ffgcks(fptr, &datasum, &hdusum, status) > 0) return(*status); if (*datastatus) if (datasum == olddatasum) *datastatus = 1; if (*hdustatus) if (hdusum == 0 || hdusum == 0xFFFFFFFF) *hdustatus = 1; return(*status); } /*------------------------------------------------------------------------*/ int ffgcks(fitsfile *fptr, /* I - FITS file pointer */ unsigned long *datasum, /* O - data checksum */ unsigned long *hdusum, /* O - hdu checksum */ int *status) /* IO - error status */ /* calculate the checksums of the data unit and the total HDU */ { long nrec; LONGLONG headstart, datastart, dataend; if (*status > 0) /* inherit input status value if > 0 */ return(*status); /* get size of the HDU */ if (ffghadll(fptr, &headstart, &datastart, &dataend, status) > 0) return(*status); nrec = (long) ((dataend - datastart) / 2880); *datasum = 0; if (nrec > 0) { /* accumulate the 32-bit 1's complement checksum */ ffmbyt(fptr, datastart, REPORT_EOF, status); if (ffcsum(fptr, nrec, datasum, status) > 0) return(*status); } /* move to the start of the header and calc. size of header */ ffmbyt(fptr, headstart, REPORT_EOF, status); nrec = (long) ((datastart - headstart) / 2880); /* accumulate the header checksum into the previous data checksum */ *hdusum = *datasum; ffcsum(fptr, nrec, hdusum, status); return(*status); } healpy-1.10.3/cfitsio/config.guess0000775000175000017500000012776412761067627017345 0ustar zoncazonca00000000000000#! /bin/sh # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 # Free Software Foundation, Inc. timestamp='2010-08-21' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Originally written by Per Bothner. Please send patches (context # diff format) to and include a ChangeLog # entry. # # This script attempts to guess a canonical system name similar to # config.sub. If it succeeds, it prints the system name on stdout, and # exits with 0. Otherwise, it exits with 1. # # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi trap 'exit 1' HUP INT TERM # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. set_cc_for_build=' trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" HUP INT PIPE TERM ; : ${TMPDIR=/tmp} ; { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; dummy=$tmp/dummy ; tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; case $CC_FOR_BUILD,$HOST_CC,$CC in ,,) echo "int x;" > $dummy.c ; for c in cc gcc c89 c99 ; do if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then CC_FOR_BUILD="$c"; break ; fi ; done ; if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found ; fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac ; set_cc_for_build= ;' # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown # Note: order is significant - the case branches are not exclusive. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ /usr/sbin/$sysctl 2>/dev/null || echo unknown)` case "${UNAME_MACHINE_ARCH}" in armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; *) machine=${UNAME_MACHINE_ARCH}-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently, or will in the future. case "${UNAME_MACHINE_ARCH}" in arm*|i386|m68k|ns32k|sh3*|sparc|vax) eval $set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case "${UNAME_VERSION}" in Debian*) release='-gnu' ;; *) release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. echo "${machine}-${os}${release}" exit ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} exit ;; *:ekkoBSD:*:*) echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} exit ;; *:SolidBSD:*:*) echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} exit ;; macppc:MirBSD:*:*) echo powerpc-unknown-mirbsd${UNAME_RELEASE} exit ;; *:MirBSD:*:*) echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} exit ;; alpha:OSF1:*:*) case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case "$ALPHA_CPU_TYPE" in "EV4 (21064)") UNAME_MACHINE="alpha" ;; "EV4.5 (21064)") UNAME_MACHINE="alpha" ;; "LCA4 (21066/21068)") UNAME_MACHINE="alpha" ;; "EV5 (21164)") UNAME_MACHINE="alphaev5" ;; "EV5.6 (21164A)") UNAME_MACHINE="alphaev56" ;; "EV5.6 (21164PC)") UNAME_MACHINE="alphapca56" ;; "EV5.7 (21164PC)") UNAME_MACHINE="alphapca57" ;; "EV6 (21264)") UNAME_MACHINE="alphaev6" ;; "EV6.7 (21264A)") UNAME_MACHINE="alphaev67" ;; "EV6.8CB (21264C)") UNAME_MACHINE="alphaev68" ;; "EV6.8AL (21264B)") UNAME_MACHINE="alphaev68" ;; "EV6.8CX (21264D)") UNAME_MACHINE="alphaev68" ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE="alphaev69" ;; "EV7 (21364)") UNAME_MACHINE="alphaev7" ;; "EV7.9 (21364A)") UNAME_MACHINE="alphaev79" ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` exit ;; Alpha\ *:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # Should we change UNAME_MACHINE based on the output of uname instead # of the specific Alpha model? echo alpha-pc-interix exit ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit ;; arm:riscos:*:*|arm:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; s390x:SunOS:*:*) echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux${UNAME_RELEASE} exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) eval $set_cc_for_build SUN_ARCH="i386" # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH="x86_64" fi fi echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos${UNAME_RELEASE} ;; sun4) echo sparc-sun-sunos${UNAME_RELEASE} ;; esac exit ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint${UNAME_RELEASE} exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint${UNAME_RELEASE} exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint${UNAME_RELEASE} exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`$dummy $dummyarg` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos${UNAME_RELEASE} exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ [ ${TARGET_BINARY_INTERFACE}x = x ] then echo m88k-dg-dgux${UNAME_RELEASE} else echo m88k-dg-dguxbcs${UNAME_RELEASE} fi else echo i586-dg-dgux${UNAME_RELEASE} fi exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; ia64:AIX:*:*) if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${IBM_ARCH}-ibm-aix${IBM_REV} exit ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; 9000/[34]?? ) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case "${sc_cpu_version}" in 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case "${sc_kernel_bits}" in 32) HP_ARCH="hppa2.0n" ;; 64) HP_ARCH="hppa2.0w" ;; '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 esac ;; esac fi if [ "${HP_ARCH}" = "" ]; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ ${HP_ARCH} = "hppa2.0w" ] then eval $set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH="hppa2.0w" else HP_ARCH="hppa64" fi fi echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux${HPUX_REV} exit ;; 3050*:HI-UX:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*[A-Z]90:*:*:*) echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi${UNAME_RELEASE} exit ;; *:BSD/OS:*:*) echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit ;; *:FreeBSD:*:*) case ${UNAME_MACHINE} in pc98) echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; amd64) echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; *) echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; esac exit ;; i*:CYGWIN*:*) echo ${UNAME_MACHINE}-pc-cygwin exit ;; *:MINGW*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:windows32*:*) # uname -m includes "-pc" on this system. echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; *:Interix*:*) case ${UNAME_MACHINE} in x86) echo i586-pc-interix${UNAME_RELEASE} exit ;; authenticamd | genuineintel | EM64T) echo x86_64-unknown-interix${UNAME_RELEASE} exit ;; IA64) echo ia64-unknown-interix${UNAME_RELEASE} exit ;; esac ;; [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) echo i${UNAME_MACHINE}-pc-mks exit ;; 8664:Windows_NT:*) echo x86_64-pc-mks exit ;; i*:Windows_NT*:* | Pentium*:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we # UNAME_MACHINE based on the output of uname instead of i386? echo i586-pc-interix exit ;; i*:UWIN*:*) echo ${UNAME_MACHINE}-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; *:GNU:*:*) # the GNU system echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu exit ;; i*86:Minix:*:*) echo ${UNAME_MACHINE}-pc-minix exit ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} exit ;; arm*:Linux:*:*) eval $set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo ${UNAME_MACHINE}-unknown-linux-gnu else echo ${UNAME_MACHINE}-unknown-linux-gnueabi fi exit ;; avr32*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; cris:Linux:*:*) echo cris-axis-linux-gnu exit ;; crisv32:Linux:*:*) echo crisv32-axis-linux-gnu exit ;; frv:Linux:*:*) echo frv-unknown-linux-gnu exit ;; i*86:Linux:*:*) LIBC=gnu eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __dietlibc__ LIBC=dietlibc #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'` echo "${UNAME_MACHINE}-pc-linux-${LIBC}" exit ;; ia64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m32r*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m68*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; mips:Linux:*:* | mips64:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=${UNAME_MACHINE}el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=${UNAME_MACHINE} #else CPU= #endif #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } ;; or32:Linux:*:*) echo or32-unknown-linux-gnu exit ;; padre:Linux:*:*) echo sparc-unknown-linux-gnu exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-gnu exit ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) echo hppa1.1-unknown-linux-gnu ;; PA8*) echo hppa2.0-unknown-linux-gnu ;; *) echo hppa-unknown-linux-gnu ;; esac exit ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-gnu exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-gnu exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo ${UNAME_MACHINE}-ibm-linux exit ;; sh64*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; tile*:Linux:*:*) echo ${UNAME_MACHINE}-tilera-linux-gnu exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-gnu exit ;; x86_64:Linux:*:*) echo x86_64-unknown-linux-gnu exit ;; xtensa*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. echo ${UNAME_MACHINE}-pc-os2-emx exit ;; i*86:XTS-300:*:STOP) echo ${UNAME_MACHINE}-unknown-stop exit ;; i*86:atheos:*:*) echo ${UNAME_MACHINE}-unknown-atheos exit ;; i*86:syllable:*:*) echo ${UNAME_MACHINE}-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit ;; i*86:*DOS:*:*) echo ${UNAME_MACHINE}-pc-msdosdjgpp exit ;; i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} else echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} fi exit ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} exit ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 echo ${UNAME_MACHINE}-pc-sco$UNAME_REL else echo ${UNAME_MACHINE}-pc-sysv32 fi exit ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configury will decide that # this is a cross-build. echo i586-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 fi exit ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) echo powerpc-unknown-lynxos${UNAME_RELEASE} exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo ${UNAME_MACHINE}-sni-sysv4 else echo ns32k-sni-sysv fi exit ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo ${UNAME_MACHINE}-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv${UNAME_RELEASE} else echo mips-unknown-sysv${UNAME_RELEASE} fi exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. echo i586-pc-haiku exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux${UNAME_RELEASE} exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux${UNAME_RELEASE} exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux${UNAME_RELEASE} exit ;; SX-7:SUPER-UX:*:*) echo sx7-nec-superux${UNAME_RELEASE} exit ;; SX-8:SUPER-UX:*:*) echo sx8-nec-superux${UNAME_RELEASE} exit ;; SX-8R:SUPER-UX:*:*) echo sx8r-nec-superux${UNAME_RELEASE} exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody${UNAME_RELEASE} exit ;; *:Rhapsody:*:*) echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown case $UNAME_PROCESSOR in i386) eval $set_cc_for_build if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then UNAME_PROCESSOR="x86_64" fi fi ;; unknown) UNAME_PROCESSOR=powerpc ;; esac echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} exit ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = "x86"; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} exit ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NSE-?:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; NSR-?:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk${UNAME_RELEASE} exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "$cputype" = "386"; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi echo ${UNAME_MACHINE}-unknown-plan9 exit ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' exit ;; i*86:rdos:*:*) echo ${UNAME_MACHINE}-pc-rdos exit ;; i*86:AROS:*:*) echo ${UNAME_MACHINE}-pc-aros exit ;; esac #echo '(No uname command or uname output not recognized.)' 1>&2 #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 eval $set_cc_for_build cat >$dummy.c < # include #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (__arm) && defined (__acorn) && defined (__unix) printf ("arm-acorn-riscix\n"); exit (0); #endif #if defined (hp300) && !defined (hpux) printf ("m68k-hp-bsd\n"); exit (0); #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; if (version < 4) printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); else printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) # if !defined (ultrix) # include # if defined (BSD) # if BSD == 43 printf ("vax-dec-bsd4.3\n"); exit (0); # else # if BSD == 199006 printf ("vax-dec-bsd4.3reno\n"); exit (0); # else printf ("vax-dec-bsd\n"); exit (0); # endif # endif # else printf ("vax-dec-bsd\n"); exit (0); # endif # else printf ("vax-dec-ultrix\n"); exit (0); # endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } # Convex versions that predate uname can use getsysinfo(1) if [ -x /usr/convex/getsysinfo ] then case `getsysinfo -f cpu_type` in c1*) echo c1-convex-bsd exit ;; c2*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; c34*) echo c34-convex-bsd exit ;; c38*) echo c38-convex-bsd exit ;; c4*) echo c4-convex-bsd exit ;; esac fi cat >&2 < in order to provide the needed information to handle your system. config.guess timestamp = $timestamp uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = ${UNAME_MACHINE} UNAME_RELEASE = ${UNAME_RELEASE} UNAME_SYSTEM = ${UNAME_SYSTEM} UNAME_VERSION = ${UNAME_VERSION} EOF exit 1 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: healpy-1.10.3/cfitsio/config.sub0000775000175000017500000010437612761067627017002 0ustar zoncazonca00000000000000#! /bin/sh # Configuration validation subroutine script. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 # Free Software Foundation, Inc. timestamp='2010-09-11' # This file is (in principle) common to ALL GNU software. # The presence of a machine in this file suggests that SOME GNU software # can handle that machine. It does not imply ALL GNU software can. # # This file is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Please send patches to . Submit a context # diff and a properly formatted GNU ChangeLog entry. # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS $0 [OPTION] ALIAS Canonicalize a configuration name. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" exit 1 ;; *local*) # First pass through any local machine types. echo $1 exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ knetbsd*-gnu* | netbsd*-gnu* | \ kopensolaris*-gnu* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; *) basic_machine=`echo $1 | sed 's/-[^-]*$//'` if [ $basic_machine != $1 ] then os=`echo $1 | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple | -axis | -knuth | -cray | -microblaze) os= basic_machine=$1 ;; -bluegene*) os=-cnk ;; -sim | -cisco | -oki | -wec | -winbond) os= basic_machine=$1 ;; -scout) ;; -wrs) os=-vxworks basic_machine=$1 ;; -chorusos*) os=-chorusos basic_machine=$1 ;; -chorusrdb) os=-chorusrdb basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco6) os=-sco5v6 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5) os=-sco3.2v5 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5v6*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -udk*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` ;; -windowsnt*) os=`echo $os | sed -e 's/windowsnt/winnt/'` ;; -psos*) os=-psos ;; -mint | -mint[0-9]*) basic_machine=m68k-atari os=-mint ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. 1750a | 580 \ | a29k \ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ | am33_2.0 \ | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \ | bfin \ | c4x | clipper \ | d10v | d30v | dlx | dsp16xx \ | fido | fr30 | frv \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | i370 | i860 | i960 | ia64 \ | ip2k | iq2000 \ | lm32 \ | m32c | m32r | m32rle | m68000 | m68k | m88k \ | maxq | mb | microblaze | mcore | mep | metag \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64octeon | mips64octeonel \ | mips64orion | mips64orionel \ | mips64r5900 | mips64r5900el \ | mips64vr | mips64vrel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nds32 | nds32le | nds32be \ | nios | nios2 \ | ns16k | ns32k \ | or32 \ | pdp10 | pdp11 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ | pyramid \ | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ | spu | strongarm \ | tahoe | thumb | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ | ubicom32 \ | v850 | v850e \ | we32k \ | x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; c54x) basic_machine=tic54x-unknown ;; c55x) basic_machine=tic55x-unknown ;; c6x) basic_machine=tic6x-unknown ;; m6811 | m68hc11 | m6812 | m68hc12 | picochip) # Motorola 68HC11/12. basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) ;; ms1) basic_machine=mt-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i*86 | x86_64) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. 580-* \ | a29k-* \ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* | avr32-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* \ | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | i*86-* | i860-* | i960-* | ia64-* \ | ip2k-* | iq2000-* \ | lm32-* \ | m32c-* | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64octeon-* | mips64octeonel-* \ | mips64orion-* | mips64orionel-* \ | mips64r5900-* | mips64r5900el-* \ | mips64vr-* | mips64vrel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nds32-* | nds32le-* | nds32be-* \ | nios-* | nios2-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ | pyramid-* \ | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \ | tahoe-* | thumb-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tile-* | tilegx-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | vax-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) ;; # Recognize the basic CPU types without company name, with glob match. xtensa*) basic_machine=$basic_machine-unknown ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 386bsd) basic_machine=i386-unknown os=-bsd ;; 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; a29khif) basic_machine=a29k-amd os=-udi ;; abacus) basic_machine=abacus-unknown ;; adobe68k) basic_machine=m68010-adobe os=-scout ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amd64) basic_machine=x86_64-pc ;; amd64-*) basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-unknown ;; amigaos | amigados) basic_machine=m68k-unknown os=-amigaos ;; amigaunix | amix) basic_machine=m68k-unknown os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; apollo68bsd) basic_machine=m68k-apollo os=-bsd ;; aros) basic_machine=i386-pc os=-aros ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; blackfin) basic_machine=bfin-unknown os=-linux ;; blackfin-*) basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; bluegene*) basic_machine=powerpc-ibm os=-cnk ;; c54x-*) basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c55x-*) basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c6x-*) basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c90) basic_machine=c90-cray os=-unicos ;; cegcc) basic_machine=arm-unknown os=-cegcc ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | j90) basic_machine=j90-cray os=-unicos ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16) basic_machine=cr16-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; cris | cris-* | etrax*) basic_machine=cris-axis ;; crx) basic_machine=crx-unknown os=-elf ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; decsystem10* | dec10*) basic_machine=pdp10-dec os=-tops10 ;; decsystem20* | dec20*) basic_machine=pdp10-dec os=-tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; dicos) basic_machine=i686-pc os=-dicos ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2* | dpx2*-bull) basic_machine=m68k-bull os=-sysv3 ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson os=-ose ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; go32) basic_machine=i386-pc os=-go32 ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; h8300xray) basic_machine=h8300-hitachi os=-xray ;; h8500hms) basic_machine=h8500-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) basic_machine=hppa1.1-hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppa-next) os=-nextstep3 ;; hppaosf) basic_machine=hppa1.1-hp os=-osf ;; hppro) basic_machine=hppa1.1-hp os=-proelf ;; i370-ibm* | ibm*) basic_machine=i370-ibm ;; # I'm not sure what "Sysv32" means. Should this be sysv3.2? i*86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i*86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i*86v) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv ;; i*86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; i386mach) basic_machine=i386-mach os=-mach ;; i386-vsta | vsta) basic_machine=i386-unknown os=-vsta ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; microblaze) basic_machine=microblaze-xilinx ;; mingw32) basic_machine=i386-pc os=-mingw32 ;; mingw32ce) basic_machine=arm-unknown os=-mingw32ce ;; miniframe) basic_machine=m68000-convergent ;; *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) basic_machine=m68k-atari os=-mint ;; mips3*-*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` ;; mvs) basic_machine=i370-ibm os=-mvs ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; netbsd386) basic_machine=i386-unknown os=-netbsd ;; netwinder) basic_machine=armv4l-rebel os=-linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; necv70) basic_machine=v70-nec os=-sysv ;; next | m*-next ) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; mon960) basic_machine=i960-intel os=-mon960 ;; nonstopux) basic_machine=mips-compaq os=-nonstopux ;; np1) basic_machine=np1-gould ;; neo-tandem) basic_machine=neo-tandem ;; nse-tandem) basic_machine=nse-tandem ;; nsr-tandem) basic_machine=nsr-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; os400) basic_machine=powerpc-ibm os=-os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson os=-ose ;; os68k) basic_machine=m68k-none os=-os68k ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; parisc) basic_machine=hppa-unknown os=-linux ;; parisc-*) basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium | p5 | k5 | k6 | nexgen | viac3) basic_machine=i586-pc ;; pentiumpro | p6 | 6x86 | athlon | athlon_*) basic_machine=i686-pc ;; pentiumii | pentium2 | pentiumiii | pentium3) basic_machine=i686-pc ;; pentium4) basic_machine=i786-pc ;; pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-* | 6x86-* | athlon-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium4-*) basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pn) basic_machine=pn-gould ;; power) basic_machine=power-ibm ;; ppc) basic_machine=powerpc-unknown ;; ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64) basic_machine=powerpc64-unknown ;; ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64le | powerpc64little | ppc64-le | powerpc64-little) basic_machine=powerpc64le-unknown ;; ppc64le-* | powerpc64little-*) basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; pw32) basic_machine=i586-unknown os=-pw32 ;; rdos) basic_machine=i386-pc os=-rdos ;; rom68k) basic_machine=m68k-rom68k os=-coff ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; s390 | s390-*) basic_machine=s390-ibm ;; s390x | s390x-*) basic_machine=s390x-ibm ;; sa29200) basic_machine=a29k-amd os=-udi ;; sb1) basic_machine=mipsisa64sb1-unknown ;; sb1el) basic_machine=mipsisa64sb1el-unknown ;; sde) basic_machine=mipsisa32-sde os=-elf ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sh5el) basic_machine=sh5le-unknown ;; sh64) basic_machine=sh64-unknown ;; sparclite-wrs | simso-wrs) basic_machine=sparclite-wrs os=-vxworks ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; st2000) basic_machine=m68k-tandem ;; stratus) basic_machine=i860-stratus os=-sysv4 ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; sv1) basic_machine=sv1-cray os=-unicos ;; symmetry) basic_machine=i386-sequent os=-dynix ;; t3e) basic_machine=alphaev5-cray os=-unicos ;; t90) basic_machine=t90-cray os=-unicos ;; # This must be matched before tile*. tilegx*) basic_machine=tilegx-unknown os=-linux-gnu ;; tile*) basic_machine=tile-unknown os=-linux-gnu ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; toad1) basic_machine=pdp10-xkl os=-tops20 ;; tower | tower-32) basic_machine=m68k-ncr ;; tpf) basic_machine=s390x-ibm os=-tpf ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; v810 | necv810) basic_machine=v810-nec os=-none ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; w65*) basic_machine=w65-wdc os=-none ;; w89k-*) basic_machine=hppa1.1-winbond os=-proelf ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; ymp) basic_machine=ymp-cray os=-unicos ;; z8k-*-coff) basic_machine=z8k-unknown os=-sim ;; z80-*-coff) basic_machine=z80-unknown os=-sim ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) basic_machine=hppa1.1-winbond ;; op50n) basic_machine=hppa1.1-oki ;; op60c) basic_machine=hppa1.1-oki ;; romp) basic_machine=romp-ibm ;; mmix) basic_machine=mmix-knuth ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp10) # there are many clones, so DEC is not a safe bet basic_machine=pdp10-unknown ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) basic_machine=sparc-sun ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; mac | mpw | mac-mpw) basic_machine=m68k-apple ;; pmac | pmac-mpw) basic_machine=powerpc-apple ;; *-unknown) # Make sure to match an already-canonicalized machine name. ;; *) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. -auroraux) os=-auroraux ;; -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -svr4*) os=-sysv4 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # First accept the basic system types. # The portable systems comes first. # Each alternative MUST END IN A *, to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ | -sym* | -kopensolaris* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ | -openbsd* | -solidbsd* \ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* | -cegcc* \ | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -linux-gnu* | -linux-android* \ | -linux-newlib* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*) # Remember, each alternative MUST END IN *, to match a version number. ;; -qnx*) case $basic_machine in x86-* | i*86-*) ;; *) os=-nto$os ;; esac ;; -nto-qnx*) ;; -nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ;; -mac*) os=`echo $os | sed -e 's|mac|macos|'` ;; -linux-dietlibc) os=-linux-dietlibc ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo $os | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo $os | sed -e 's|sunos6|solaris3|'` ;; -opened*) os=-openedition ;; -os400*) os=-os400 ;; -wince*) os=-wince ;; -osfrose*) os=-osfrose ;; -osf*) os=-osf ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -atheos*) os=-atheos ;; -syllable*) os=-syllable ;; -386bsd) os=-bsd ;; -ctix* | -uts*) os=-sysv ;; -nova*) os=-rtmk-nova ;; -ns2 ) os=-nextstep2 ;; -nsk*) os=-nsk ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -tpf*) os=-tpf ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -ose*) os=-ose ;; -es1800*) os=-ose ;; -xenix) os=-xenix ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -aros*) os=-aros ;; -kaos*) os=-kaos ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -nacl*) ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in score-*) os=-elf ;; spu-*) os=-elf ;; *-acorn) os=-riscix1.2 ;; arm*-rebel) os=-linux ;; arm*-semi) os=-aout ;; c4x-* | tic4x-*) os=-coff ;; tic54x-*) os=-coff ;; tic55x-*) os=-coff ;; tic6x-*) os=-coff ;; # This must come before the *-dec entry. pdp10-*) os=-tops20 ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 # This also exists in the configure program, but was not the # default. # os=-sunos4 ;; m68*-cisco) os=-aout ;; mep-*) os=-elf ;; mips*-cisco) os=-elf ;; mips*-*) os=-elf ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; *-be) os=-beos ;; *-haiku) os=-haiku ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-wec) os=-proelf ;; *-winbond) os=-proelf ;; *-oki) os=-proelf ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next ) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-next) os=-nextstep3 ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f30[01]-fujitsu | f700-fujitsu) os=-uxpv ;; *-rom68k) os=-coff ;; *-*bug) os=-coff ;; *-apple) os=-macos ;; *-atari*) os=-mint ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -cnk*|-aix*) vendor=ibm ;; -beos*) vendor=be ;; -hpux*) vendor=hp ;; -mpeix*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs* | -opened*) vendor=ibm ;; -os400*) vendor=ibm ;; -ptx*) vendor=sequent ;; -tpf*) vendor=ibm ;; -vxsim* | -vxworks* | -windiss*) vendor=wrs ;; -aux*) vendor=apple ;; -hms*) vendor=hitachi ;; -mpw* | -macos*) vendor=apple ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) vendor=atari ;; -vos*) vendor=stratus ;; esac basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` ;; esac echo $basic_machine$os exit # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: healpy-1.10.3/cfitsio/configure0000775000175000017500000060057712761067627016732 0ustar zoncazonca00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.68. # # # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, # 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software # Foundation, Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV export CONFIG_SHELL case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"} fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, $0: including any error possibly output before this $0: message. Then install a modern shell, or manually run $0: the script under such a shell if you do have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME= PACKAGE_TARNAME= PACKAGE_VERSION= PACKAGE_STRING= PACKAGE_BUGREPORT= PACKAGE_URL= ac_unique_file="fitscore.c" ac_default_prefix=`pwd` # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif #ifdef HAVE_STRING_H # if !defined STDC_HEADERS && defined HAVE_MEMORY_H # include # endif # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_subst_vars='LTLIBOBJS LIBOBJS my_shmem F77_WRAPPERS CFITSIO_SHLIB_SONAME CFITSIO_SHLIB SHLIB_SUFFIX SHLIB_LD LIBPRE ARCH GCCVERSION SSE_FLAGS EGREP GREP CPP RANLIB ARCHIVE AR FC OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC INSTALL_ROOT CFITSIO_SONAME CFITSIO_MINOR CFITSIO_MAJOR target_os target_vendor target_cpu target host_os host_vendor host_cpu host build_os build_vendor build_cpu build target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking enable_reentrant enable_sse2 enable_ssse3 enable_hera with_gsiftp_flavour with_gsiftp ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host. If a cross compiler is detected then cross compile mode will be used" >&2 elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF \`configure' configures this package to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/PACKAGE] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF System types: --build=BUILD configure for building on BUILD [guessed] --host=HOST cross-compile to build programs to run on HOST [BUILD] --target=TARGET configure for building compilers for TARGET [HOST] _ACEOF fi if test -n "$ac_init_help"; then cat <<\_ACEOF Optional Features: --disable-option-checking ignore unrecognized --enable/--with options --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) --enable-FEATURE[=ARG] include FEATURE [ARG=yes] --enable-reentrant Enable reentrant multithreading --enable-sse2 Enable use of instructions in the SSE2 extended instruction set --enable-ssse3 Enable use of instructions in the SSSE3 extended instruction set --enable-hera Build for HERA (ASD use only) Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-gsiftp-flavour[=PATH] Enable Globus Toolkit gsiftp protocol support --with-gsiftp[=PATH] Enable Globus Toolkit gsiftp protocol support Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to the package provider. _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested configure. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF configure generated by GNU Autoconf 2.68 Copyright (C) 2010 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists, giving a warning if it cannot be compiled using # the include files in INCLUDES and setting the cache variable VAR # accordingly. ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval \${$3+:} false; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || $as_test_x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by $as_me, which was generated by GNU Autoconf 2.68. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_aux_dir= for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do if test -f "$ac_dir/install-sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f "$ac_dir/install.sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break elif test -f "$ac_dir/shtool"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/shtool install -c" break fi done if test -z "$ac_aux_dir"; then as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5 fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } if ${ac_cv_build+:} false; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: build_os=$* IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } if ${ac_cv_host+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: host_os=$* IFS=$ac_save_IFS case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5 $as_echo_n "checking target system type... " >&6; } if ${ac_cv_target+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$target_alias" = x; then ac_cv_target=$ac_cv_host else ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5 $as_echo "$ac_cv_target" >&6; } case $ac_cv_target in *-*-*) ;; *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;; esac target=$ac_cv_target ac_save_IFS=$IFS; IFS='-' set x $ac_cv_target shift target_cpu=$1 target_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: target_os=$* IFS=$ac_save_IFS case $target_os in *\ *) target_os=`echo "$target_os" | sed 's/ /-/g'`;; esac # The aliases save the names the user supplied, while $host etc. # will get canonicalized. test -n "$target_alias" && test "$program_prefix$program_suffix$program_transform_name" = \ NONENONEs,x,x, && program_prefix=${target_alias}- #-------------------------------------------------------------------- # CFITSIO Version Numbers: #-------------------------------------------------------------------- CFITSIO_MAJOR=3 CFITSIO_MINOR=36 # Increment soname each time the interface changes: CFITSIO_SONAME=2 #-------------------------------------------------------------------- # Command options #-------------------------------------------------------------------- # Check whether --enable-reentrant was given. if test "${enable_reentrant+set}" = set; then : enableval=$enable_reentrant; if test $enableval = yes; then BUILD_REENTRANT=yes; fi fi SSE_FLAGS="" # Check whether --enable-sse2 was given. if test "${enable_sse2+set}" = set; then : enableval=$enable_sse2; if test $enableval = yes; then SSE_FLAGS="-msse2"; fi fi # Check whether --enable-ssse3 was given. if test "${enable_ssse3+set}" = set; then : enableval=$enable_ssse3; if test $enableval = yes; then SSE_FLAGS="$SSE_FLAGS -mssse3"; fi fi # Define BUILD_HERA when building for HERA project to activate code in # drvrfile.c (by way of fitsio2.h): # Check whether --enable-hera was given. if test "${enable_hera+set}" = set; then : enableval=$enable_hera; if test $enableval = yes; then BUILD_HERA=yes; fi fi if test "x$BUILD_HERA" = xyes; then $as_echo "#define BUILD_HERA 1" >>confdefs.h fi # Check whether --with-gsiftp-flavour was given. if test "${with_gsiftp_flavour+set}" = set; then : withval=$with_gsiftp_flavour; if test "x$withval" != "xno"; then if test "x$withval" != "xyes" ; then GSIFTP_FLAVOUR=${withval} fi $as_echo "#define GSIFTP_FLAVOUR 1" >>confdefs.h fi fi # Check whether --with-gsiftp was given. if test "${with_gsiftp+set}" = set; then : withval=$with_gsiftp; if test "x$withval" != "xno"; then if test "x$withval" != "xyes" ; then CFLAGS="$CFLAGS -I${withval}/include/${GSIFTP_FLAVOUR}" LDFLAGS="$LDFLAGS -L${withval}/lib -lglobus_ftp_client_${GSIFTP_FLAVOUR}" HAVE_GSIFTP=yes fi $as_echo "#define HAVE_GSIFTP 1" >>confdefs.h fi fi #-------------------------------------------------------------------- # Check for install location prefix #-------------------------------------------------------------------- # make will complain about duplicate targets for the install directories # if prefix == exec_prefix INSTALL_ROOT='${prefix}' test "$exec_prefix" != NONE -a "$prefix" != "$exec_prefix" \ && INSTALL_ROOT="$INSTALL_ROOT "'${exec_prefix}' #-------------------------------------------------------------------- # System type #-------------------------------------------------------------------- case $host in *pc-cygwin*) ARCH="cygwin" EXT="cygwin" ;; *apple-darwin*) # Darwin can be powerpc, i386, or x86_64 ARCH=`uname -p` EXT="darwin" ;; *freebsd*) ARCH="linux" EXT="lnx" ;; *hpux*) ARCH="hp" EXT="hpu" ;; *irix*) ARCH="sgi" EXT="sgi" ;; *linux*) ARCH="linux" EXT="lnx" ;; *mingw32*) #ARCH="" EXT="mingw32" ;; *osf1*) ARCH="alpha" EXT="osf" ;; *solaris*) ARCH="solaris" EXT="sol" ;; *ultrix*) ARCH="dec" EXT="dec" ;; *) echo "cfitsio: == Don't know what do do with $host" ;; esac # Try first to find a proprietary C compiler, then gcc if test "x$EXT" != xcygwin && test "x$EXT" != xdarwin && test "x$EXT" != xlnx && test "x$EXT" != xmingw32; then if test "x$CC" = x; then for ac_prog in cc do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test "x$FC" = "xnone" ; then { $as_echo "$as_me:${as_lineno-$LINENO}: cfitsio: == Fortran compiler search has been overridden" >&5 $as_echo "$as_me: cfitsio: == Fortran compiler search has been overridden" >&6;} { $as_echo "$as_me:${as_lineno-$LINENO}: cfitsio: == Cfitsio will be built without Fortran wrapper support" >&5 $as_echo "$as_me: cfitsio: == Cfitsio will be built without Fortran wrapper support" >&6;} FC= F77_WRAPPERS= else for ac_prog in gfortran g95 g77 f77 ifort f95 f90 xlf cf77 gf77 af77 ncf f2c do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_FC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$FC"; then ac_cv_prog_FC="$FC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_FC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi FC=$ac_cv_prog_FC if test -n "$FC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5 $as_echo "$FC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$FC" && break done test -n "$FC" || FC="notfound" if test $FC = 'notfound' ; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cfitsio: == No acceptable Fortran compiler found in \$PATH" >&5 $as_echo "$as_me: WARNING: cfitsio: == No acceptable Fortran compiler found in \$PATH" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: cfitsio: == Adding wrapper support for GNU Fortran by default" >&5 $as_echo "$as_me: cfitsio: == Adding wrapper support for GNU Fortran by default" >&6;} CFORTRANFLAGS="-Dg77Fortran" F77_WRAPPERS="\${FITSIO_SRC}" else CFORTRANFLAGS= F77_WRAPPERS="\${FITSIO_SRC}" echo $ac_n "checking whether we are using GNU Fortran""... $ac_c" 1>&6 if test `$FC --version -c < /dev/null 2> /dev/null | grep -c GNU` -gt 0 -o \ `$FC --version -c < /dev/null 2> /dev/null | grep -ic egcs` -gt 0 then echo "$ac_t""yes" 1>&6 echo $ac_n "cfitsio: == Adding wrapper support for GNU Fortran""... $ac_c" 1>&6 CFORTRANFLAGS="-Dg77Fortran" echo "$ac_t"" done" 1>&6 else echo "$ac_t""no" 1>&6 if test $FC = 'f2c' ; then echo $ac_n "cfitsio: == Adding wrapper support for f2c""... $ac_c" 1>&6 CFORTRANFLAGS="-Df2cFortran" echo "$ac_t"" done" 1>&6 fi fi fi fi # ar & ranlib required #--------------------- # Extract the first word of "ar", so it can be a program name with args. set dummy ar; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_AR+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$AR"; then ac_cv_prog_AR="$AR" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_AR="ar" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="noar" fi fi AR=$ac_cv_prog_AR if test -n "$AR"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 $as_echo "$AR" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test $AR = noar; then as_fn_error $? "ar not found in your \$PATH. See your sysdamin." "$LINENO" 5 fi ARCHIVE="$AR rv" if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. set dummy ${ac_tool_prefix}ranlib; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_RANLIB+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$RANLIB"; then ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi RANLIB=$ac_cv_prog_RANLIB if test -n "$RANLIB"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 $as_echo "$RANLIB" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_RANLIB"; then ac_ct_RANLIB=$RANLIB # Extract the first word of "ranlib", so it can be a program name with args. set dummy ranlib; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_RANLIB+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_RANLIB"; then ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ac_cv_prog_ac_ct_RANLIB="ranlib" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB if test -n "$ac_ct_RANLIB"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 $as_echo "$ac_ct_RANLIB" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_RANLIB" = x; then RANLIB=":" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac RANLIB=$ac_ct_RANLIB fi else RANLIB="$ac_cv_prog_RANLIB" fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 $as_echo "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 $as_echo "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "memchr" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "free" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then : : else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if ((' ' & 0x0FF) == 0x020) # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #else # define ISLOWER(c) \ (('a' <= (c) && (c) <= 'i') \ || ('j' <= (c) && (c) <= 'r') \ || ('s' <= (c) && (c) <= 'z')) # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) #endif #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi # On IRIX 5.3, sys/types and inttypes.h are conflicting. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ inttypes.h stdint.h unistd.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in stdlib.h string.h math.h limits.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF ANSI_HEADER=yes else ANSI_HEADER=no fi done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { void d( int , double) ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : PROTO=yes else PROTO=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ANSI_HEADER = no -o $PROTO = no; then echo " *********** WARNING: CFITSIO CONFIGURE FAILURE ************ " echo "cfitsio: ANSI C environment NOT found. Aborting cfitsio configure." if test $ANSI_HEADER = no; then echo "cfitsio: You're missing a needed ANSI header file." fi if test $PROTO = no; then echo "cfitsio: Your compiler can't do ANSI function prototypes." fi echo "cfitsio: You need an ANSI C compiler and all ANSI trappings" echo "cfitsio: to build cfitsio. " echo " ******************************************************* " exit 0; fi if test "x$SSE_FLAGS" != x; then SAVE_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS $SSE_FLAGS" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts $SSE_FLAGS" >&5 $as_echo_n "checking whether $CC accepts $SSE_FLAGS... " >&6; } ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : c_has_option=yes else c_has_option=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $c_has_option" >&5 $as_echo "$c_has_option" >&6; } ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test "$c_has_option" = no; then SSE_FLAGS=""; fi CFLAGS="$SAVE_CFLAGS" fi CFLAGS="$CFLAGS" LIBPRE="" case $host in *pc-cygwin*) CFLAGS="$CFLAGS -DHAVE_POSIX_SIGNALS" ;; *apple-darwin*) # Build for i386 & x86_64 architectures on Darwin 10.x or newer: case $host in *darwin[56789]*) ;; *) # Test to see whether the C compiler accepts the "-arch" # flags for building "universal" binaries (Apple XCode only): SAVE_CFLAGS="$CFLAGS" C_UNIV_SWITCH="-arch i386 -arch x86_64" CFLAGS="$CFLAGS $C_UNIV_SWITCH" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts $C_UNIV_SWITCH" >&5 $as_echo_n "checking whether $CC accepts $C_UNIV_SWITCH... " >&6; } ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : c_has_option=yes else c_has_option=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $c_has_option" >&5 $as_echo "$c_has_option" >&6; } ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu # Value of C_UNIV_SWITCH will be needed later for SHLIB_LD: if test "$c_has_option" = no; then C_UNIV_SWITCH=""; fi CFLAGS="$SAVE_CFLAGS $C_UNIV_SWITCH" ;; esac # For large file support (but may break Absoft compilers): $as_echo "#define _LARGEFILE_SOURCE 1" >>confdefs.h $as_echo "#define _FILE_OFFSET_BITS 64" >>confdefs.h ;; *hpux*) if test "x$CFORTRANFLAGS" = x ; then CFORTRANFLAGS="-Dappendus" fi CFLAGS="$CFLAGS -DPG_PPU" LIBPRE="-Wl," ;; *irix*) CFLAGS="$CFLAGS -DHAVE_POSIX_SIGNALS" RANLIB="touch" ;; *linux*) # For large file support: $as_echo "#define _LARGEFILE_SOURCE 1" >>confdefs.h $as_echo "#define _FILE_OFFSET_BITS 64" >>confdefs.h ;; *mingw32*) { $as_echo "$as_me:${as_lineno-$LINENO}: checking for large file support" >&5 $as_echo_n "checking for large file support... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { _FILE_OFFSET_BITS_SET_FSEEKO ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : $as_echo "#define _LARGEFILE_SOURCE 1" >>confdefs.h $as_echo "#define _FILE_OFFSET_BITS 64" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ;; *solaris*) if test "x$CFORTRANFLAGS" = x ; then CFORTRANFLAGS="-Dsolaris" fi # We need libm on Solaris: { $as_echo "$as_me:${as_lineno-$LINENO}: checking for frexp in -lm" >&5 $as_echo_n "checking for frexp in -lm... " >&6; } if ${ac_cv_lib_m_frexp+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lm $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char frexp (); int main () { return frexp (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_m_frexp=yes else ac_cv_lib_m_frexp=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_frexp" >&5 $as_echo "$ac_cv_lib_m_frexp" >&6; } if test "x$ac_cv_lib_m_frexp" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBM 1 _ACEOF LIBS="-lm $LIBS" fi # For large file support: $as_echo "#define _LARGEFILE_SOURCE 1" >>confdefs.h $as_echo "#define _FILE_OFFSET_BITS 64" >>confdefs.h ;; *) echo "cfitsio: == Don't know what do do with $host" ;; esac CFLAGS="$CFLAGS $CFORTRANFLAGS" case $GCC in yes) GCCVERSION="`$CC -dumpversion 2>&1`" echo "cfitsio: == Using gcc version $GCCVERSION" gcc_test=`echo $GCCVERSION | grep -c '2\.[45678]'` if test $gcc_test -gt 0 then CFLAGS=`echo $CFLAGS | sed 's:-O[^ ]* *::'` { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This gcc is pretty old. Disabling optimization to be safe." >&5 $as_echo "$as_me: WARNING: This gcc is pretty old. Disabling optimization to be safe." >&2;} fi ;; no) echo "cfitsio: Old CFLAGS is $CFLAGS" CFLAGS=`echo $CFLAGS | sed -e "s/-g/-O/"` case $host in *solaris*) if test `echo $CFLAGS | grep -c fast` -gt 0 then echo "cfitsio: Replacing -fast with -O3" CFLAGS=`echo $CFLAGS | sed 's:-fast:-O3:'` fi CFLAGS="$CFLAGS -DHAVE_ALLOCA_H -DHAVE_POSIX_SIGNALS" ;; *) echo "== No special changes for $host" ;; esac echo "New CFLAGS is $CFLAGS" ;; *) # Don't do anything now ;; esac # Shared library section #------------------------------------------------------------------------------- SHLIB_LD=: SHLIB_SUFFIX=".so" CFITSIO_SHLIB="" CFITSIO_SHLIB_SONAME="" lhea_shlib_cflags= case $EXT in cygwin) SHLIB_LD="$CC -shared" SHLIB_SUFFIX=".dll" ;; darwin) SHLIB_SUFFIX=".dylib" CFITSIO_SHLIB="libcfitsio.\${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}\${SHLIB_SUFFIX}" CFITSIO_SHLIB_SONAME="libcfitsio.\${CFITSIO_SONAME}\${SHLIB_SUFFIX}" case $host in *darwin[56789]*) SHLIB_LD="$CC -dynamiclib -install_name libcfitsio.\${CFITSIO_SONAME}\${SHLIB_SUFFIX} -compatibility_version \${CFITSIO_SONAME} -current_version \${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}" ;; *) # Build for i386 & x86_64 architectures on Darwin 10.x or newer: SHLIB_LD="$CC -dynamiclib $C_UNIV_SWITCH -install_name libcfitsio.\${CFITSIO_SONAME}\${SHLIB_SUFFIX} -compatibility_version \${CFITSIO_SONAME} -current_version \${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}" ;; esac lhea_shlib_cflags="-fPIC -fno-common" ;; hpu) SHLIB_LD="ld -b" SHLIB_SUFFIX=".sl" ;; lnx) SHLIB_LD=":" CFITSIO_SHLIB="libcfitsio\${SHLIB_SUFFIX}.\${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}" CFITSIO_SHLIB_SONAME="libcfitsio\${SHLIB_SUFFIX}.\${CFITSIO_SONAME}" ;; osf) SHLIB_LD="ld -shared -expect_unresolved '*'" LD_FLAGS="-taso" ;; sol) SHLIB_LD="/usr/ccs/bin/ld -G" lhea_shlib_cflags="-KPIC" ;; sgi) SHLIB_LD="ld -shared -rdata_shared" ;; *) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to determine how to make a shared library" >&5 $as_echo "$as_me: WARNING: Unable to determine how to make a shared library" >&2;} ;; esac # Darwin uses gcc (=cc), but needs different flags (see above) if test "x$EXT" != xdarwin && test "x$EXT" != xcygwin && test "x$EXT" != xmingw32; then if test "x$GCC" = xyes; then SHLIB_LD="$CC -shared -Wl,-soname,libcfitsio\${SHLIB_SUFFIX}.\${CFITSIO_SONAME}" lhea_shlib_cflags='-fPIC' fi fi if test "x$lhea_shlib_cflags" != x; then CFLAGS="$CFLAGS $lhea_shlib_cflags" fi # Set shared library name for cases in which we aren't setting a 'soname': if test "x$CFITSIO_SHLIB" = x; then CFITSIO_SHLIB="libcfitsio\${SHLIB_SUFFIX}"; fi # ================= test for the unix ftruncate function ================ { $as_echo "$as_me:${as_lineno-$LINENO}: checking \"whether ftruncate works\"" >&5 $as_echo_n "checking \"whether ftruncate works\"... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { ftruncate(0, 0); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : $as_echo "#define HAVE_FTRUNCATE 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"yes\"" >&5 $as_echo "\"yes\"" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"no\"" >&5 $as_echo "\"no\"" >&6; } fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext # --------------------------------------------------------- # some systems define long long for 64-bit ints # --------------------------------------------------------- { $as_echo "$as_me:${as_lineno-$LINENO}: checking \"whether long long is defined\"" >&5 $as_echo_n "checking \"whether long long is defined\"... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { long long filler; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : $as_echo "#define HAVE_LONGLONG 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"yes\"" >&5 $as_echo "\"yes\"" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"no\"" >&5 $as_echo "\"no\"" >&6; } fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext # ==================== SHARED MEMORY DRIVER SECTION ======================= # # 09-Mar-98 : modified by JB/ISDC # 3 checks added to support autoconfiguration of shared memory # driver. First generic check is made whether shared memory is supported # at all, then 2 more specific checks are made (architecture dependent). # Currently tested on : sparc-solaris, intel-linux, sgi-irix, dec-alpha-osf # ------------------------------------------------------------------------- # check is System V IPC is supported on this machine # ------------------------------------------------------------------------- { $as_echo "$as_me:${as_lineno-$LINENO}: checking \"whether system V style IPC services are supported\"" >&5 $as_echo_n "checking \"whether system V style IPC services are supported\"... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include int main () { shmat(0, 0, 0); shmdt(0); shmget(0, 0, 0); semget(0, 0, 0); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : $as_echo "#define HAVE_SHMEM_SERVICES 1" >>confdefs.h my_shmem=\${SOURCES_SHMEM} { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"yes\"" >&5 $as_echo "\"yes\"" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"no\"" >&5 $as_echo "\"no\"" >&6; } fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext # ------------------------------------------------------------------------- # some systems define flock_t, for others we have to define it ourselves # ------------------------------------------------------------------------- { $as_echo "$as_me:${as_lineno-$LINENO}: checking \"do we have flock_t defined in sys/fcntl.h\"" >&5 $as_echo_n "checking \"do we have flock_t defined in sys/fcntl.h\"... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { flock_t filler; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : $as_echo "#define HAVE_FLOCK_T 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"yes\"" >&5 $as_echo "\"yes\"" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"no\"" >&5 $as_echo "\"no\"" >&6; } fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test "$HAVE_FLOCK_T" != 1; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking \"do we have flock_t defined in sys/flock.h\"" >&5 $as_echo_n "checking \"do we have flock_t defined in sys/flock.h\"... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { flock_t filler; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : $as_echo "#define HAVE_FLOCK_T 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"yes\"" >&5 $as_echo "\"yes\"" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"no\"" >&5 $as_echo "\"no\"" >&6; } fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi # ------------------------------------------------------------------------- # there are some idiosyncrasies with semun defs (used in semxxx). Solaris # does not define it at all # ------------------------------------------------------------------------- { $as_echo "$as_me:${as_lineno-$LINENO}: checking \"do we have union semun defined\"" >&5 $as_echo_n "checking \"do we have union semun defined\"... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include int main () { union semun filler; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : $as_echo "#define HAVE_UNION_SEMUN 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"yes\"" >&5 $as_echo "\"yes\"" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: \"no\"" >&5 $as_echo "\"no\"" >&6; } fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext # ==================== END OF SHARED MEMORY DRIVER SECTION ================ # ================= test for the unix networking functions ================ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing gethostbyname" >&5 $as_echo_n "checking for library containing gethostbyname... " >&6; } if ${ac_cv_search_gethostbyname+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char gethostbyname (); int main () { return gethostbyname (); ; return 0; } _ACEOF for ac_lib in '' nsl; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_gethostbyname=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_gethostbyname+:} false; then : break fi done if ${ac_cv_search_gethostbyname+:} false; then : else ac_cv_search_gethostbyname=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_gethostbyname" >&5 $as_echo "$ac_cv_search_gethostbyname" >&6; } ac_res=$ac_cv_search_gethostbyname if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" cfitsio_have_nsl=1 else cfitsio_have_nsl=0 fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing connect" >&5 $as_echo_n "checking for library containing connect... " >&6; } if ${ac_cv_search_connect+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char connect (); int main () { return connect (); ; return 0; } _ACEOF for ac_lib in '' socket; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib -lnsl $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_connect=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_connect+:} false; then : break fi done if ${ac_cv_search_connect+:} false; then : else ac_cv_search_connect=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_connect" >&5 $as_echo "$ac_cv_search_connect" >&6; } ac_res=$ac_cv_search_connect if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" cfitsio_have_socket=1 else cfitsio_have_socket=0 fi if test "$cfitsio_have_nsl" = 1 -a "$cfitsio_have_socket" = 1; then $as_echo "#define HAVE_NET_SERVICES 1" >>confdefs.h fi # ==================== END OF unix networking SECTION ================ # ------------------------------------------------------------------------------ # Define _REENTRANT & add -lpthread to LIBS if reentrant multithreading enabled: # ------------------------------------------------------------------------------ if test "x$BUILD_REENTRANT" = xyes; then $as_echo "#define _REENTRANT 1" >>confdefs.h { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lpthread" >&5 $as_echo_n "checking for main in -lpthread... " >&6; } if ${ac_cv_lib_pthread_main+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lpthread $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { return main (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_pthread_main=yes else ac_cv_lib_pthread_main=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_main" >&5 $as_echo "$ac_cv_lib_pthread_main" >&6; } if test "x$ac_cv_lib_pthread_main" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBPTHREAD 1 _ACEOF LIBS="-lpthread $LIBS" else as_fn_error $? "Unable to locate pthread library needed when enabling reentrant multithreading" "$LINENO" 5 fi fi # ------------------------------------------------------------------------------ ac_config_files="$ac_config_files Makefile" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' # Transform confdefs.h into DEFS. # Protect against shell expansion while executing Makefile rules. # Protect against Makefile macro expansion. # # If the first sed substitution is executed (which looks for macros that # take arguments), then branch to the quote section. Otherwise, # look for a macro that doesn't take arguments. ac_script=' :mline /\\$/{ N s,\\\n,, b mline } t clear :clear s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g t quote s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g t quote b any :quote s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g s/\[/\\&/g s/\]/\\&/g s/\$/$$/g H :any ${ g s/^\n// s/\n/ /g p } ' DEFS=`sed -n "$ac_script" confdefs.h` ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by $as_me, which was generated by GNU Autoconf 2.68. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE Configuration files: $config_files Report bugs to the package provider." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ config.status configured by $0, generated by GNU Autoconf 2.68, with options \\"\$ac_cs_config\\" Copyright (C) 2010 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --he | --h | --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" eval set X " :F $CONFIG_FILES " shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi ac_config_files="$ac_config_files cfitsio.pc" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' # Transform confdefs.h into DEFS. # Protect against shell expansion while executing Makefile rules. # Protect against Makefile macro expansion. # # If the first sed substitution is executed (which looks for macros that # take arguments), then branch to the quote section. Otherwise, # look for a macro that doesn't take arguments. ac_script=' :mline /\\$/{ N s,\\\n,, b mline } t clear :clear s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g t quote s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g t quote b any :quote s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g s/\[/\\&/g s/\]/\\&/g s/\$/$$/g H :any ${ g s/^\n// s/\n/ /g p } ' DEFS=`sed -n "$ac_script" confdefs.h` ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -p'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -p' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -p' fi else as_ln_s='cp -p' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi if test -x / >/dev/null 2>&1; then as_test_x='test -x' else if ls -dL / >/dev/null 2>&1; then as_ls_L_option=L else as_ls_L_option= fi as_test_x=' eval sh -c '\'' if test -d "$1"; then test -d "$1/."; else case $1 in #( -*)set "./$1";; esac; case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #(( ???[sx]*):;;*)false;;esac;fi '\'' sh ' fi as_executable_p=$as_test_x # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by $as_me, which was generated by GNU Autoconf 2.68. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE Configuration files: $config_files Report bugs to the package provider." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ config.status configured by $0, generated by GNU Autoconf 2.68, with options \\"\$ac_cs_config\\" Copyright (C) 2010 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --he | --h | --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; "cfitsio.pc") CONFIG_FILES="$CONFIG_FILES cfitsio.pc" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" eval set X " :F $CONFIG_FILES " shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: " >&5 $as_echo "" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: Congratulations, Makefile update was successful." >&5 $as_echo " Congratulations, Makefile update was successful." >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: You may want to run \"make\" now." >&5 $as_echo " You may want to run \"make\" now." >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: " >&5 $as_echo "" >&6; } healpy-1.10.3/cfitsio/configure.in0000664000175000017500000004067413010375004017303 0ustar zoncazonca00000000000000# # configure.in for cfitsio # # /redshift/sgi6/lheavc/ftools/cfitsio/configure.in,v 3.4 1996/07/26 20:27:53 pence Exp # # copied from host and modified # dnl Process this file with autoconf to produce a configure script. AC_INIT AC_CONFIG_SRCDIR([fitscore.c]) AC_CANONICAL_TARGET([]) #-------------------------------------------------------------------- # CFITSIO Version Numbers: #-------------------------------------------------------------------- AC_SUBST(CFITSIO_MAJOR,3) AC_SUBST(CFITSIO_MINOR,36) # Increment soname each time the interface changes: AC_SUBST(CFITSIO_SONAME,2) #-------------------------------------------------------------------- # Command options #-------------------------------------------------------------------- AC_ARG_ENABLE( reentrant, [AS_HELP_STRING([--enable-reentrant],[Enable reentrant multithreading])], [ if test $enableval = yes; then BUILD_REENTRANT=yes; fi ] ) SSE_FLAGS="" AC_ARG_ENABLE( sse2, [AS_HELP_STRING([--enable-sse2],[Enable use of instructions in the SSE2 extended instruction set])], [ if test $enableval = yes; then SSE_FLAGS="-msse2"; fi ] ) AC_ARG_ENABLE( ssse3, [AS_HELP_STRING([--enable-ssse3],[Enable use of instructions in the SSSE3 extended instruction set])], [ if test $enableval = yes; then SSE_FLAGS="$SSE_FLAGS -mssse3"; fi ] ) # Define BUILD_HERA when building for HERA project to activate code in # drvrfile.c (by way of fitsio2.h): AC_ARG_ENABLE( hera, [AS_HELP_STRING([--enable-hera],[Build for HERA (ASD use only)])], [ if test $enableval = yes; then BUILD_HERA=yes; fi ] ) if test "x$BUILD_HERA" = xyes; then AC_DEFINE(BUILD_HERA) fi AC_ARG_WITH( gsiftp-flavour, [AS_HELP_STRING([--with-gsiftp-flavour[[=PATH]]],[Enable Globus Toolkit gsiftp protocol support])], [ if test "x$withval" != "xno"; then if test "x$withval" != "xyes" ; then GSIFTP_FLAVOUR=${withval} fi AC_DEFINE(GSIFTP_FLAVOUR,1,[Define Globus Toolkit architecture]) fi ] ) AC_ARG_WITH( gsiftp, [AS_HELP_STRING([--with-gsiftp[[=PATH]]],[Enable Globus Toolkit gsiftp protocol support])], [ if test "x$withval" != "xno"; then if test "x$withval" != "xyes" ; then CFLAGS="$CFLAGS -I${withval}/include/${GSIFTP_FLAVOUR}" LDFLAGS="$LDFLAGS -L${withval}/lib -lglobus_ftp_client_${GSIFTP_FLAVOUR}" HAVE_GSIFTP=yes fi AC_DEFINE(HAVE_GSIFTP,1,[Define if you want Globus Toolkit gsiftp protocol support]) fi ] ) #-------------------------------------------------------------------- # Check for install location prefix #-------------------------------------------------------------------- AC_PREFIX_DEFAULT(`pwd`) # make will complain about duplicate targets for the install directories # if prefix == exec_prefix AC_SUBST(INSTALL_ROOT,'${prefix}') test "$exec_prefix" != NONE -a "$prefix" != "$exec_prefix" \ && INSTALL_ROOT="$INSTALL_ROOT "'${exec_prefix}' #-------------------------------------------------------------------- # System type #-------------------------------------------------------------------- case $host in *pc-cygwin*) ARCH="cygwin" EXT="cygwin" ;; *apple-darwin*) # Darwin can be powerpc, i386, or x86_64 ARCH=`uname -p` EXT="darwin" ;; *freebsd*) ARCH="linux" EXT="lnx" ;; *hpux*) ARCH="hp" EXT="hpu" ;; *irix*) ARCH="sgi" EXT="sgi" ;; *linux*) ARCH="linux" EXT="lnx" ;; *mingw32*) #ARCH="" EXT="mingw32" ;; *osf1*) ARCH="alpha" EXT="osf" ;; *solaris*) ARCH="solaris" EXT="sol" ;; *ultrix*) ARCH="dec" EXT="dec" ;; *) echo "cfitsio: == Don't know what do do with $host" ;; esac dnl Checks for programs. # Try first to find a proprietary C compiler, then gcc if test "x$EXT" != xcygwin && test "x$EXT" != xdarwin && test "x$EXT" != xlnx && test "x$EXT" != xmingw32; then if test "x$CC" = x; then AC_CHECK_PROGS(CC, cc) fi fi AC_PROG_CC if test "x$FC" = "xnone" ; then AC_MSG_NOTICE(cfitsio: == Fortran compiler search has been overridden) AC_MSG_NOTICE(cfitsio: == Cfitsio will be built without Fortran wrapper support) FC= F77_WRAPPERS= else AC_CHECK_PROGS(FC, gfortran g95 g77 f77 ifort f95 f90 xlf cf77 gf77 af77 ncf f2c, notfound) if test $FC = 'notfound' ; then AC_MSG_WARN(cfitsio: == No acceptable Fortran compiler found in \$PATH) AC_MSG_NOTICE(cfitsio: == Adding wrapper support for GNU Fortran by default) CFORTRANFLAGS="-Dg77Fortran" F77_WRAPPERS="\${FITSIO_SRC}" else CFORTRANFLAGS= F77_WRAPPERS="\${FITSIO_SRC}" echo $ac_n "checking whether we are using GNU Fortran""... $ac_c" 1>&6 if test `$FC --version -c < /dev/null 2> /dev/null | grep -c GNU` -gt 0 -o \ `$FC --version -c < /dev/null 2> /dev/null | grep -ic egcs` -gt 0 then echo "$ac_t""yes" 1>&6 echo $ac_n "cfitsio: == Adding wrapper support for GNU Fortran""... $ac_c" 1>&6 CFORTRANFLAGS="-Dg77Fortran" echo "$ac_t"" done" 1>&6 else echo "$ac_t""no" 1>&6 if test $FC = 'f2c' ; then echo $ac_n "cfitsio: == Adding wrapper support for f2c""... $ac_c" 1>&6 CFORTRANFLAGS="-Df2cFortran" echo "$ac_t"" done" 1>&6 fi fi fi fi # ar & ranlib required #--------------------- AC_CHECK_PROG(AR, ar, ar, noar) if test $AR = noar; then AC_MSG_ERROR(ar not found in your \$PATH. See your sysdamin.) fi ARCHIVE="$AR rv" AC_SUBST(ARCHIVE) AC_PROG_RANLIB dnl Checks for ANSI stdlib.h. AC_CHECK_HEADERS(stdlib.h string.h math.h limits.h ,ANSI_HEADER=yes,ANSI_HEADER=no)dnl dnl Check if prototyping is allowed. AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[void d( int , double) ]])],[PROTO=yes],[PROTO=no])dnl if test $ANSI_HEADER = no -o $PROTO = no; then echo " *********** WARNING: CFITSIO CONFIGURE FAILURE ************ " echo "cfitsio: ANSI C environment NOT found. Aborting cfitsio configure." if test $ANSI_HEADER = no; then echo "cfitsio: You're missing a needed ANSI header file." fi if test $PROTO = no; then echo "cfitsio: Your compiler can't do ANSI function prototypes." fi echo "cfitsio: You need an ANSI C compiler and all ANSI trappings" echo "cfitsio: to build cfitsio. " echo " ******************************************************* " exit 0; fi dnl Check if C compiler supports sse extended instruction flags. if test "x$SSE_FLAGS" != x; then SAVE_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS $SSE_FLAGS" AC_MSG_CHECKING([whether $CC accepts $SSE_FLAGS]) AC_LANG_PUSH([C]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([])],[c_has_option=yes],[c_has_option=no]) AC_MSG_RESULT($c_has_option) AC_LANG_POP([]) if test "$c_has_option" = no; then SSE_FLAGS=""; fi CFLAGS="$SAVE_CFLAGS" fi AC_SUBST(SSE_FLAGS) CFLAGS="$CFLAGS" LIBPRE="" case $host in *pc-cygwin*) CFLAGS="$CFLAGS -DHAVE_POSIX_SIGNALS" ;; *apple-darwin*) # Build for i386 & x86_64 architectures on Darwin 10.x or newer: changequote(,) case $host in *darwin[56789]*) ;; *) changequote([,]) # Test to see whether the C compiler accepts the "-arch" # flags for building "universal" binaries (Apple XCode only): SAVE_CFLAGS="$CFLAGS" C_UNIV_SWITCH="-arch i386 -arch x86_64" CFLAGS="$CFLAGS $C_UNIV_SWITCH" AC_MSG_CHECKING([whether $CC accepts $C_UNIV_SWITCH]) AC_LANG_PUSH([C]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([])],[c_has_option=yes],[c_has_option=no]) AC_MSG_RESULT($c_has_option) AC_LANG_POP([]) # Value of C_UNIV_SWITCH will be needed later for SHLIB_LD: if test "$c_has_option" = no; then C_UNIV_SWITCH=""; fi CFLAGS="$SAVE_CFLAGS $C_UNIV_SWITCH" ;; esac # For large file support (but may break Absoft compilers): AC_DEFINE(_LARGEFILE_SOURCE) AC_DEFINE(_FILE_OFFSET_BITS,64) ;; *hpux*) if test "x$CFORTRANFLAGS" = x ; then CFORTRANFLAGS="-Dappendus" fi CFLAGS="$CFLAGS -DPG_PPU" LIBPRE="-Wl," ;; *irix*) CFLAGS="$CFLAGS -DHAVE_POSIX_SIGNALS" RANLIB="touch" ;; *linux*) # For large file support: AC_DEFINE(_LARGEFILE_SOURCE) AC_DEFINE(_FILE_OFFSET_BITS,64) ;; *mingw32*) AC_MSG_CHECKING([for large file support]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include ], [_FILE_OFFSET_BITS_SET_FSEEKO])],[ AC_DEFINE(_LARGEFILE_SOURCE) AC_DEFINE(_FILE_OFFSET_BITS,64) AC_MSG_RESULT(yes) ],[AC_MSG_RESULT(no)]) ;; *solaris*) if test "x$CFORTRANFLAGS" = x ; then CFORTRANFLAGS="-Dsolaris" fi # We need libm on Solaris: AC_CHECK_LIB(m, frexp) # For large file support: AC_DEFINE(_LARGEFILE_SOURCE) AC_DEFINE(_FILE_OFFSET_BITS,64) ;; *) echo "cfitsio: == Don't know what do do with $host" ;; esac CFLAGS="$CFLAGS $CFORTRANFLAGS" case $GCC in yes) GCCVERSION="`$CC -dumpversion 2>&1`" echo "cfitsio: == Using gcc version $GCCVERSION" AC_SUBST(GCCVERSION) changequote(,) gcc_test=`echo $GCCVERSION | grep -c '2\.[45678]'` changequote([,]) if test $gcc_test -gt 0 then changequote(,) CFLAGS=`echo $CFLAGS | sed 's:-O[^ ]* *::'` changequote([,]) AC_MSG_WARN(This gcc is pretty old. Disabling optimization to be safe.) fi ;; no) echo "cfitsio: Old CFLAGS is $CFLAGS" CFLAGS=`echo $CFLAGS | sed -e "s/-g/-O/"` case $host in *solaris*) changequote(,) if test `echo $CFLAGS | grep -c fast` -gt 0 then echo "cfitsio: Replacing -fast with -O3" CFLAGS=`echo $CFLAGS | sed 's:-fast:-O3:'` fi changequote([,]) CFLAGS="$CFLAGS -DHAVE_ALLOCA_H -DHAVE_POSIX_SIGNALS" ;; *) echo "== No special changes for $host" ;; esac echo "New CFLAGS is $CFLAGS" ;; *) # Don't do anything now ;; esac # Shared library section #------------------------------------------------------------------------------- SHLIB_LD=: SHLIB_SUFFIX=".so" CFITSIO_SHLIB="" CFITSIO_SHLIB_SONAME="" lhea_shlib_cflags= case $EXT in cygwin) SHLIB_LD="$CC -shared" SHLIB_SUFFIX=".dll" ;; darwin) changequote(,) SHLIB_SUFFIX=".dylib" CFITSIO_SHLIB="libcfitsio.\${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}\${SHLIB_SUFFIX}" CFITSIO_SHLIB_SONAME="libcfitsio.\${CFITSIO_SONAME}\${SHLIB_SUFFIX}" case $host in *darwin[56789]*) SHLIB_LD="$CC -dynamiclib -install_name libcfitsio.\${CFITSIO_SONAME}\${SHLIB_SUFFIX} -compatibility_version \${CFITSIO_SONAME} -current_version \${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}" ;; *) # Build for i386 & x86_64 architectures on Darwin 10.x or newer: SHLIB_LD="$CC -dynamiclib $C_UNIV_SWITCH -install_name libcfitsio.\${CFITSIO_SONAME}\${SHLIB_SUFFIX} -compatibility_version \${CFITSIO_SONAME} -current_version \${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}" ;; esac changequote([,]) lhea_shlib_cflags="-fPIC -fno-common" ;; hpu) SHLIB_LD="ld -b" SHLIB_SUFFIX=".sl" ;; lnx) SHLIB_LD=":" CFITSIO_SHLIB="libcfitsio\${SHLIB_SUFFIX}.\${CFITSIO_SONAME}.\${CFITSIO_MAJOR}.\${CFITSIO_MINOR}" CFITSIO_SHLIB_SONAME="libcfitsio\${SHLIB_SUFFIX}.\${CFITSIO_SONAME}" ;; osf) SHLIB_LD="ld -shared -expect_unresolved '*'" LD_FLAGS="-taso" ;; sol) SHLIB_LD="/usr/ccs/bin/ld -G" lhea_shlib_cflags="-KPIC" ;; sgi) SHLIB_LD="ld -shared -rdata_shared" ;; *) AC_MSG_WARN(Unable to determine how to make a shared library) ;; esac # Darwin uses gcc (=cc), but needs different flags (see above) if test "x$EXT" != xdarwin && test "x$EXT" != xcygwin && test "x$EXT" != xmingw32; then if test "x$GCC" = xyes; then SHLIB_LD="$CC -shared -Wl,-soname,libcfitsio\${SHLIB_SUFFIX}.\${CFITSIO_SONAME}" lhea_shlib_cflags='-fPIC' fi fi if test "x$lhea_shlib_cflags" != x; then CFLAGS="$CFLAGS $lhea_shlib_cflags" fi # Set shared library name for cases in which we aren't setting a 'soname': if test "x$CFITSIO_SHLIB" = x; then CFITSIO_SHLIB="libcfitsio\${SHLIB_SUFFIX}"; fi AC_SUBST(ARCH)dnl AC_SUBST(CFLAGS)dnl AC_SUBST(CC)dnl AC_SUBST(FC)dnl AC_SUBST(LIBPRE)dnl AC_SUBST(SHLIB_LD)dnl AC_SUBST(SHLIB_SUFFIX)dnl AC_SUBST(CFITSIO_SHLIB)dnl AC_SUBST(CFITSIO_SHLIB_SONAME)dnl AC_SUBST(F77_WRAPPERS) # ================= test for the unix ftruncate function ================ AC_MSG_CHECKING("whether ftruncate works") AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ ftruncate(0, 0); ]])],[ AC_DEFINE(HAVE_FTRUNCATE) AC_MSG_RESULT("yes") ],[AC_MSG_RESULT("no") ]) # --------------------------------------------------------- # some systems define long long for 64-bit ints # --------------------------------------------------------- AC_MSG_CHECKING("whether long long is defined") AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ long long filler; ]])],[ AC_DEFINE(HAVE_LONGLONG) AC_MSG_RESULT("yes") ],[AC_MSG_RESULT("no") ]) # ==================== SHARED MEMORY DRIVER SECTION ======================= # # 09-Mar-98 : modified by JB/ISDC # 3 checks added to support autoconfiguration of shared memory # driver. First generic check is made whether shared memory is supported # at all, then 2 more specific checks are made (architecture dependent). # Currently tested on : sparc-solaris, intel-linux, sgi-irix, dec-alpha-osf # ------------------------------------------------------------------------- # check is System V IPC is supported on this machine # ------------------------------------------------------------------------- AC_MSG_CHECKING("whether system V style IPC services are supported") AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include #include #include ]], [[ shmat(0, 0, 0); shmdt(0); shmget(0, 0, 0); semget(0, 0, 0); ]])],[ AC_DEFINE(HAVE_SHMEM_SERVICES) my_shmem=\${SOURCES_SHMEM} AC_MSG_RESULT("yes") ],[AC_MSG_RESULT("no") ]) AC_SUBST(my_shmem) # ------------------------------------------------------------------------- # some systems define flock_t, for others we have to define it ourselves # ------------------------------------------------------------------------- AC_MSG_CHECKING("do we have flock_t defined in sys/fcntl.h") AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ flock_t filler; ]])],[ AC_DEFINE(HAVE_FLOCK_T) AC_MSG_RESULT("yes") ],[AC_MSG_RESULT("no") ]) if test "$HAVE_FLOCK_T" != 1; then AC_MSG_CHECKING("do we have flock_t defined in sys/flock.h") AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ flock_t filler; ]])],[ AC_DEFINE(HAVE_FLOCK_T) AC_MSG_RESULT("yes") ],[AC_MSG_RESULT("no") ]) fi # ------------------------------------------------------------------------- # there are some idiosyncrasies with semun defs (used in semxxx). Solaris # does not define it at all # ------------------------------------------------------------------------- AC_MSG_CHECKING("do we have union semun defined") AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include #include #include ]], [[ union semun filler; ]])],[ AC_DEFINE(HAVE_UNION_SEMUN) AC_MSG_RESULT("yes") ],[AC_MSG_RESULT("no") ]) # ==================== END OF SHARED MEMORY DRIVER SECTION ================ # ================= test for the unix networking functions ================ AC_SEARCH_LIBS([gethostbyname], [nsl], cfitsio_have_nsl=1, cfitsio_have_nsl=0) AC_SEARCH_LIBS([connect], [socket], cfitsio_have_socket=1, cfitsio_have_socket=0, [-lnsl]) if test "$cfitsio_have_nsl" = 1 -a "$cfitsio_have_socket" = 1; then AC_DEFINE(HAVE_NET_SERVICES) fi # ==================== END OF unix networking SECTION ================ # ------------------------------------------------------------------------------ # Define _REENTRANT & add -lpthread to LIBS if reentrant multithreading enabled: # ------------------------------------------------------------------------------ if test "x$BUILD_REENTRANT" = xyes; then AC_DEFINE(_REENTRANT) AC_CHECK_LIB([pthread],[main],[],[AC_MSG_ERROR(Unable to locate pthread library needed when enabling reentrant multithreading)]) fi # ------------------------------------------------------------------------------ AC_CONFIG_FILES([Makefile]) AC_OUTPUT AC_CONFIG_FILES([cfitsio.pc]) AC_OUTPUT AC_MSG_RESULT([]) AC_MSG_RESULT([ Congratulations, Makefile update was successful.]) AC_MSG_RESULT([ You may want to run \"make\" now.]) AC_MSG_RESULT([]) healpy-1.10.3/cfitsio/cookbook.c0000664000175000017500000005254213010375004016741 0ustar zoncazonca00000000000000#include #include #include /* Every program which uses the CFITSIO interface must include the the fitsio.h header file. This contains the prototypes for all the routines and defines the error status values and other symbolic constants used in the interface. */ #include "fitsio.h" int main( void ); void writeimage( void ); void writeascii( void ); void writebintable( void ); void copyhdu( void ); void selectrows( void ); void readheader( void ); void readimage( void ); void readtable( void ); void printerror( int status); int main() { /************************************************************************* This is a simple main program that calls the following routines: writeimage - write a FITS primary array image writeascii - write a FITS ASCII table extension writebintable - write a FITS binary table extension copyhdu - copy a header/data unit from one FITS file to another selectrows - copy selected row from one HDU to another readheader - read and print the header keywords in every extension readimage - read a FITS image and compute the min and max value readtable - read columns of data from ASCII and binary tables **************************************************************************/ writeimage(); writeascii(); writebintable(); copyhdu(); selectrows(); readheader(); readimage(); readtable(); printf("\nAll the cfitsio cookbook routines ran successfully.\n"); return(0); } /*--------------------------------------------------------------------------*/ void writeimage( void ) /******************************************************/ /* Create a FITS primary array containing a 2-D image */ /******************************************************/ { fitsfile *fptr; /* pointer to the FITS file, defined in fitsio.h */ int status, ii, jj; long fpixel, nelements, exposure; unsigned short *array[200]; /* initialize FITS image parameters */ char filename[] = "atestfil.fit"; /* name for new FITS file */ int bitpix = USHORT_IMG; /* 16-bit unsigned short pixel values */ long naxis = 2; /* 2-dimensional image */ long naxes[2] = { 300, 200 }; /* image is 300 pixels wide by 200 rows */ /* allocate memory for the whole image */ array[0] = (unsigned short *)malloc( naxes[0] * naxes[1] * sizeof( unsigned short ) ); /* initialize pointers to the start of each row of the image */ for( ii=1; ii 0) { nbuffer = npixels; if (npixels > buffsize) nbuffer = buffsize; /* read as many pixels as will fit in buffer */ /* Note that even though the FITS images contains unsigned integer */ /* pixel values (or more accurately, signed integer pixels with */ /* a bias of 32768), this routine is reading the values into a */ /* float array. Cfitsio automatically performs the datatype */ /* conversion in cases like this. */ if ( fits_read_img(fptr, TFLOAT, fpixel, nbuffer, &nullval, buffer, &anynull, &status) ) printerror( status ); for (ii = 0; ii < nbuffer; ii++) { if ( buffer[ii] < datamin ) datamin = buffer[ii]; if ( buffer[ii] > datamax ) datamax = buffer[ii]; } npixels -= nbuffer; /* increment remaining number of pixels */ fpixel += nbuffer; /* next pixel to be read in image */ } printf("\nMin and max image pixels = %.0f, %.0f\n", datamin, datamax); if ( fits_close_file(fptr, &status) ) printerror( status ); return; } /*--------------------------------------------------------------------------*/ void readtable( void ) /************************************************************/ /* read and print data values from an ASCII or binary table */ /************************************************************/ { fitsfile *fptr; /* pointer to the FITS file, defined in fitsio.h */ int status, hdunum, hdutype, nfound, anynull, ii; long frow, felem, nelem, longnull, dia[6]; float floatnull, den[6]; char strnull[10], *name[6], *ttype[3]; char filename[] = "atestfil.fit"; /* name of existing FITS file */ status = 0; if ( fits_open_file(&fptr, filename, READONLY, &status) ) printerror( status ); for (ii = 0; ii < 3; ii++) /* allocate space for the column labels */ ttype[ii] = (char *) malloc(FLEN_VALUE); /* max label length = 69 */ for (ii = 0; ii < 6; ii++) /* allocate space for string column value */ name[ii] = (char *) malloc(10); for (hdunum = 2; hdunum <= 3; hdunum++) /*read ASCII, then binary table */ { /* move to the HDU */ if ( fits_movabs_hdu(fptr, hdunum, &hdutype, &status) ) printerror( status ); if (hdutype == ASCII_TBL) printf("\nReading ASCII table in HDU %d:\n", hdunum); else if (hdutype == BINARY_TBL) printf("\nReading binary table in HDU %d:\n", hdunum); else { printf("Error: this HDU is not an ASCII or binary table\n"); printerror( status ); } /* read the column names from the TTYPEn keywords */ fits_read_keys_str(fptr, "TTYPE", 1, 3, ttype, &nfound, &status); printf(" Row %10s %10s %10s\n", ttype[0], ttype[1], ttype[2]); frow = 1; felem = 1; nelem = 6; strcpy(strnull, " "); longnull = 0; floatnull = 0.; /* read the columns */ fits_read_col(fptr, TSTRING, 1, frow, felem, nelem, strnull, name, &anynull, &status); fits_read_col(fptr, TLONG, 2, frow, felem, nelem, &longnull, dia, &anynull, &status); fits_read_col(fptr, TFLOAT, 3, frow, felem, nelem, &floatnull, den, &anynull, &status); for (ii = 0; ii < 6; ii++) printf("%5d %10s %10ld %10.2f\n", ii + 1, name[ii], dia[ii], den[ii]); } for (ii = 0; ii < 3; ii++) /* free the memory for the column labels */ free( ttype[ii] ); for (ii = 0; ii < 6; ii++) /* free the memory for the string column */ free( name[ii] ); if ( fits_close_file(fptr, &status) ) printerror( status ); return; } /*--------------------------------------------------------------------------*/ void printerror( int status) { /*****************************************************/ /* Print out cfitsio error messages and exit program */ /*****************************************************/ if (status) { fits_report_error(stderr, status); /* print error report */ exit( status ); /* terminate the program, returning error status */ } return; } healpy-1.10.3/cfitsio/cookbook.f0000664000175000017500000007277313010375004016754 0ustar zoncazonca00000000000000 program main C This is the FITSIO cookbook program that contains an annotated listing of C various computer programs that read and write files in FITS format C using the FITSIO subroutine interface. These examples are C working programs which users may adapt and modify for their own C purposes. This Cookbook serves as a companion to the FITSIO User's C Guide that provides more complete documentation on all the C available FITSIO subroutines. C Call each subroutine in turn: call writeimage call writeascii call writebintable call copyhdu call selectrows call readheader call readimage call readtable print * print *,"All the fitsio cookbook routines ran successfully." end C ************************************************************************* subroutine writeimage C Create a FITS primary array containing a 2-D image integer status,unit,blocksize,bitpix,naxis,naxes(2) integer i,j,group,fpixel,nelements,array(300,200) character filename*80 logical simple,extend C The STATUS parameter must be initialized before using FITSIO. A C positive value of STATUS is returned whenever a serious error occurs. C FITSIO uses an `inherited status' convention, which means that if a C subroutine is called with a positive input value of STATUS, then the C subroutine will exit immediately, preserving the status value. For C simplicity, this program only checks the status value at the end of C the program, but it is usually better practice to check the status C value more frequently. status=0 C Name of the FITS file to be created: filename='ATESTFILEZ.FITS' C Delete the file if it already exists, so we can then recreate it. C The deletefile subroutine is listed at the end of this file. call deletefile(filename,status) C Get an unused Logical Unit Number to use to open the FITS file. C This routine is not required; programmers can choose any unused C unit number to open the file. call ftgiou(unit,status) C Create the new empty FITS file. The blocksize parameter is a C historical artifact and the value is ignored by FITSIO. blocksize=1 call ftinit(unit,filename,blocksize,status) C Initialize parameters about the FITS image. C BITPIX = 16 means that the image pixels will consist of 16-bit C integers. The size of the image is given by the NAXES values. C The EXTEND = TRUE parameter indicates that the FITS file C may contain extensions following the primary array. simple=.true. bitpix=16 naxis=2 naxes(1)=300 naxes(2)=200 extend=.true. C Write the required header keywords to the file call ftphpr(unit,simple,bitpix,naxis,naxes,0,1,extend,status) C Initialize the values in the image with a linear ramp function do j=1,naxes(2) do i=1,naxes(1) array(i,j)=i - 1 +j - 1 end do end do C Write the array to the FITS file. C The last letter of the subroutine name defines the datatype of the C array argument; in this case the 'J' indicates that the array has an C integer*4 datatype. ('I' = I*2, 'E' = Real*4, 'D' = Real*8). C The 2D array is treated as a single 1-D array with NAXIS1 * NAXIS2 C total number of pixels. GROUP is seldom used parameter that should C almost always be set = 1. group=1 fpixel=1 nelements=naxes(1)*naxes(2) call ftpprj(unit,group,fpixel,nelements,array,status) C Write another optional keyword to the header C The keyword record will look like this in the FITS file: C C EXPOSURE= 1500 / Total Exposure Time C call ftpkyj(unit,'EXPOSURE',1500,'Total Exposure Time',status) C The FITS file must always be closed before exiting the program. C Any unit numbers allocated with FTGIOU must be freed with FTFIOU. call ftclos(unit, status) call ftfiou(unit, status) C Check for any errors, and if so print out error messages. C The PRINTERROR subroutine is listed near the end of this file. if (status .gt. 0)call printerror(status) end C ************************************************************************* subroutine writeascii C Create an ASCII table containing 3 columns and 6 rows. For convenience, C the ASCII table extension is appended to the FITS image file created C previously by the WRITEIMAGE subroutine. integer status,unit,readwrite,blocksize,tfields,nrows,rowlen integer nspace,tbcol(3),diameter(6), colnum,frow,felem real density(6) character filename*40,extname*16 character*16 ttype(3),tform(3),tunit(3),name(6) data ttype/'Planet','Diameter','Density'/ data tform/'A8','I6','F4.2'/ data tunit/' ','km','g/cm'/ data name/'Mercury','Venus','Earth','Mars','Jupiter','Saturn'/ data diameter/4880,12112,12742,6800,143000,121000/ data density/5.1,5.3,5.52,3.94,1.33,0.69/ C The STATUS parameter must always be initialized. status=0 C Name of the FITS file to append the ASCII table to: filename='ATESTFILEZ.FITS' C Get an unused Logical Unit Number to use to open the FITS file. call ftgiou(unit,status) C Open the FITS file with write access. C (readwrite = 0 would open the file with readonly access). readwrite=1 call ftopen(unit,filename,readwrite,blocksize,status) C FTCRHD creates a new empty FITS extension following the current C extension and moves to it. In this case, FITSIO was initially C positioned on the primary array when the FITS file was first opened, so C FTCRHD appends an empty extension and moves to it. All future FITSIO C calls then operate on the new extension (which will be an ASCII C table). call ftcrhd(unit,status) C define parameters for the ASCII table (see the above data statements) tfields=3 nrows=6 extname='PLANETS_ASCII' C FTGABC is a convenient subroutine for calculating the total width of C the table and the starting position of each column in an ASCII table. C Any number of blank spaces (including zero) may be inserted between C each column of the table, as specified by the NSPACE parameter. nspace=1 call ftgabc(tfields,tform,nspace,rowlen,tbcol,status) C FTPHTB writes all the required header keywords which define the C structure of the ASCII table. NROWS and TFIELDS give the number of C rows and columns in the table, and the TTYPE, TBCOL, TFORM, and TUNIT C arrays give the column name, starting position, format, and units, C respectively of each column. The values of the ROWLEN and TBCOL parameters C were previously calculated by the FTGABC routine. call ftphtb(unit,rowlen,nrows,tfields,ttype,tbcol,tform,tunit, & extname,status) C Write names to the first column, diameters to 2nd col., and density to 3rd C FTPCLS writes the string values to the NAME column (column 1) of the C table. The FTPCLJ and FTPCLE routines write the diameter (integer) and C density (real) value to the 2nd and 3rd columns. The FITSIO routines C are column oriented, so it is usually easier to read or write data in a C table in a column by column order rather than row by row. frow=1 felem=1 colnum=1 call ftpcls(unit,colnum,frow,felem,nrows,name,status) colnum=2 call ftpclj(unit,colnum,frow,felem,nrows,diameter,status) colnum=3 call ftpcle(unit,colnum,frow,felem,nrows,density,status) C The FITS file must always be closed before exiting the program. C Any unit numbers allocated with FTGIOU must be freed with FTFIOU. call ftclos(unit, status) call ftfiou(unit, status) C Check for any error, and if so print out error messages. C The PRINTERROR subroutine is listed near the end of this file. if (status .gt. 0)call printerror(status) end C ************************************************************************* subroutine writebintable C This routine creates a FITS binary table, or BINTABLE, containing C 3 columns and 6 rows. This routine is nearly identical to the C previous WRITEASCII routine, except that the call to FTGABC is not C needed, and FTPHBN is called rather than FTPHTB to write the C required header keywords. integer status,unit,readwrite,blocksize,hdutype,tfields,nrows integer varidat,diameter(6), colnum,frow,felem real density(6) character filename*40,extname*16 character*16 ttype(3),tform(3),tunit(3),name(6) data ttype/'Planet','Diameter','Density'/ data tform/'8A','1J','1E'/ data tunit/' ','km','g/cm'/ data name/'Mercury','Venus','Earth','Mars','Jupiter','Saturn'/ data diameter/4880,12112,12742,6800,143000,121000/ data density/5.1,5.3,5.52,3.94,1.33,0.69/ C The STATUS parameter must always be initialized. status=0 C Name of the FITS file to append the ASCII table to: filename='ATESTFILEZ.FITS' C Get an unused Logical Unit Number to use to open the FITS file. call ftgiou(unit,status) C Open the FITS file, with write access. readwrite=1 call ftopen(unit,filename,readwrite,blocksize,status) C Move to the last (2nd) HDU in the file (the ASCII table). call ftmahd(unit,2,hdutype,status) C Append/create a new empty HDU onto the end of the file and move to it. call ftcrhd(unit,status) C Define parameters for the binary table (see the above data statements) tfields=3 nrows=6 extname='PLANETS_BINARY' varidat=0 C FTPHBN writes all the required header keywords which define the C structure of the binary table. NROWS and TFIELDS gives the number of C rows and columns in the table, and the TTYPE, TFORM, and TUNIT arrays C give the column name, format, and units, respectively of each column. call ftphbn(unit,nrows,tfields,ttype,tform,tunit, & extname,varidat,status) C Write names to the first column, diameters to 2nd col., and density to 3rd C FTPCLS writes the string values to the NAME column (column 1) of the C table. The FTPCLJ and FTPCLE routines write the diameter (integer) and C density (real) value to the 2nd and 3rd columns. The FITSIO routines C are column oriented, so it is usually easier to read or write data in a C table in a column by column order rather than row by row. Note that C the identical subroutine calls are used to write to either ASCII or C binary FITS tables. frow=1 felem=1 colnum=1 call ftpcls(unit,colnum,frow,felem,nrows,name,status) colnum=2 call ftpclj(unit,colnum,frow,felem,nrows,diameter,status) colnum=3 call ftpcle(unit,colnum,frow,felem,nrows,density,status) C The FITS file must always be closed before exiting the program. C Any unit numbers allocated with FTGIOU must be freed with FTFIOU. call ftclos(unit, status) call ftfiou(unit, status) C Check for any error, and if so print out error messages. C The PRINTERROR subroutine is listed near the end of this file. if (status .gt. 0)call printerror(status) end C ************************************************************************* subroutine copyhdu C Copy the 1st and 3rd HDUs from the input file to a new FITS file integer status,inunit,outunit,readwrite,blocksize,morekeys,hdutype character infilename*40,outfilename*40 C The STATUS parameter must always be initialized. status=0 C Name of the FITS files: infilename='ATESTFILEZ.FITS' outfilename='BTESTFILEZ.FITS' C Delete the file if it already exists, so we can then recreate it C The deletefile subroutine is listed at the end of this file. call deletefile(outfilename,status) C Get unused Logical Unit Numbers to use to open the FITS files. call ftgiou(inunit,status) call ftgiou(outunit,status) C Open the input FITS file, with readonly access readwrite=0 call ftopen(inunit,infilename,readwrite,blocksize,status) C Create the new empty FITS file (value of blocksize is ignored) blocksize=1 call ftinit(outunit,outfilename,blocksize,status) C FTCOPY copies the current HDU from the input FITS file to the output C file. The MOREKEY parameter allows one to reserve space for additional C header keywords when the HDU is created. FITSIO will automatically C insert more header space if required, so programmers do not have to C reserve space ahead of time, although it is more efficient to do so if C it is known that more keywords will be appended to the header. morekeys=0 call ftcopy(inunit,outunit,morekeys,status) C Append/create a new empty extension on the end of the output file call ftcrhd(outunit,status) C Skip to the 3rd extension in the input file which in this case C is the binary table created by the previous WRITEBINARY routine. call ftmahd(inunit,3,hdutype,status) C FTCOPY now copies the binary table from the input FITS file C to the output file. call ftcopy(inunit,outunit,morekeys,status) C The FITS files must always be closed before exiting the program. C Any unit numbers allocated with FTGIOU must be freed with FTFIOU. C Giving -1 for the value of the first argument causes all previously C allocated unit numbers to be released. call ftclos(inunit, status) call ftclos(outunit, status) call ftfiou(-1, status) C Check for any error, and if so print out error messages. C The PRINTERROR subroutine is listed near the end of this file. if (status .gt. 0)call printerror(status) end C ************************************************************************* subroutine selectrows C This routine copies selected rows from an input table into a new output C FITS table. In this example all the rows in the input table that have C a value of the DENSITY column less that 3.0 are copied to the output C table. This program illustrates several generally useful techniques, C including: C how to locate the end of a FITS file C how to create a table when the total number of rows in the table C is not known until the table is completed C how to efficiently copy entire rows from one table to another. integer status,inunit,outunit,readwrite,blocksize,hdutype integer nkeys,nspace,naxes(2),nfound,colnum,frow,felem integer noutrows,irow,temp(100),i real nullval,density(6) character infilename*40,outfilename*40,record*80 logical exact,anynulls C The STATUS parameter must always be initialized. status=0 C Names of the FITS files: infilename='ATESTFILEZ.FITS' outfilename='BTESTFILEZ.FITS' C Get unused Logical Unit Numbers to use to open the FITS files. call ftgiou(inunit,status) call ftgiou(outunit,status) C The input FITS file is opened with READONLY access, and the output C FITS file is opened with WRITE access. readwrite=0 call ftopen(inunit,infilename,readwrite,blocksize,status) readwrite=1 call ftopen(outunit,outfilename,readwrite,blocksize,status) C move to the 3rd HDU in the input file (a binary table in this case) call ftmahd(inunit,3,hdutype,status) C This do-loop illustrates how to move to the last extension in any FITS C file. The call to FTMRHD moves one extension at a time through the C FITS file until an `End-of-file' status value (= 107) is returned. do while (status .eq. 0) call ftmrhd(outunit,1,hdutype,status) end do C After locating the end of the FITS file, it is necessary to reset the C status value to zero and also clear the internal error message stack C in FITSIO. The previous `End-of-file' error will have produced C an unimportant message on the error stack which can be cleared with C the call to the FTCMSG routine (which has no arguments). if (status .eq. 107)then status=0 call ftcmsg end if C Create a new empty extension in the output file. call ftcrhd(outunit,status) C Find the number of keywords in the input table header. call ftghsp(inunit,nkeys,nspace,status) C This do-loop of calls to FTGREC and FTPREC copies all the keywords from C the input to the output FITS file. Notice that the specified number C of rows in the output table, as given by the NAXIS2 keyword, will be C incorrect. This value will be modified later after it is known how many C rows will be in the table, so it does not matter how many rows are specified C initially. do i=1,nkeys call ftgrec(inunit,i,record,status) call ftprec(outunit,record,status) end do C FTGKNJ is used to get the value of the NAXIS1 and NAXIS2 keywords, C which define the width of the table in bytes, and the number of C rows in the table. call ftgknj(inunit,'NAXIS',1,2,naxes,nfound,status) C FTGCNO gets the column number of the `DENSITY' column; the column C number is needed when reading the data in the column. The EXACT C parameter determines whether or not the match to the column names C will be case sensitive. exact=.false. call ftgcno(inunit,exact,'DENSITY',colnum,status) C FTGCVE reads all 6 rows of data in the `DENSITY' column. The number C of rows in the table is given by NAXES(2). Any null values in the C table will be returned with the corresponding value set to -99 C (= the value of NULLVAL). The ANYNULLS parameter will be set to TRUE C if any null values were found while reading the data values in the table. frow=1 felem=1 nullval=-99. call ftgcve(inunit,colnum,frow,felem,naxes(2),nullval, & density,anynulls,status) C If the density is less than 3.0, copy the row to the output table. C FTGTBB and FTPTBB are low-level routines to read and write, respectively, C a specified number of bytes in the table, starting at the specified C row number and beginning byte within the row. These routines do C not do any interpretation of the bytes, and simply pass them to or C from the FITS file without any modification. This is a faster C way of transferring large chunks of data from one FITS file to another, C than reading and then writing each column of data individually. C In this case an entire row of bytes (the row length is specified C by the naxes(1) parameter) is transferred. The datatype of the C buffer array (TEMP in this case) is immaterial so long as it is C declared large enough to hold the required number of bytes. noutrows=0 do irow=1,naxes(2) if (density(irow) .lt. 3.0)then noutrows=noutrows+1 call ftgtbb(inunit,irow,1,naxes(1),temp,status) call ftptbb(outunit,noutrows,1,naxes(1),temp,status) end if end do C Update the NAXIS2 keyword with the correct no. of rows in the output file. C After all the rows have been written to the output table, the C FTMKYJ routine is used to overwrite the NAXIS2 keyword value with C the correct number of rows. Specifying `\&' for the comment string C tells FITSIO to keep the current comment string in the keyword and C only modify the value. Because the total number of rows in the table C was unknown when the table was first created, any value (including 0) C could have been used for the initial NAXIS2 keyword value. call ftmkyj(outunit,'NAXIS2',noutrows,'&',status) C The FITS files must always be closed before exiting the program. C Any unit numbers allocated with FTGIOU must be freed with FTFIOU. call ftclos(inunit, status) call ftclos(outunit, status) call ftfiou(-1, status) C Check for any error, and if so print out error messages. C The PRINTERROR subroutine is listed near the end of this file. if (status .gt. 0)call printerror(status) end C ************************************************************************* subroutine readheader C Print out all the header keywords in all extensions of a FITS file integer status,unit,readwrite,blocksize,nkeys,nspace,hdutype,i,j character filename*80,record*80 C The STATUS parameter must always be initialized. status=0 C Get an unused Logical Unit Number to use to open the FITS file. call ftgiou(unit,status) C name of FITS file filename='ATESTFILEZ.FITS' C open the FITS file, with read-only access. The returned BLOCKSIZE C parameter is obsolete and should be ignored. readwrite=0 call ftopen(unit,filename,readwrite,blocksize,status) j = 0 100 continue j = j + 1 print *,'Header listing for HDU', j C The FTGHSP subroutine returns the number of existing keywords in the C current header data unit (CHDU), not counting the required END keyword, call ftghsp(unit,nkeys,nspace,status) C Read each 80-character keyword record, and print it out. do i = 1, nkeys call ftgrec(unit,i,record,status) print *,record end do C Print out an END record, and a blank line to mark the end of the header. if (status .eq. 0)then print *,'END' print *,' ' end if C Try moving to the next extension in the FITS file, if it exists. C The FTMRHD subroutine attempts to move to the next HDU, as specified by C the second parameter. This subroutine moves by a relative number of C HDUs from the current HDU. The related FTMAHD routine may be used to C move to an absolute HDU number in the FITS file. If the end-of-file is C encountered when trying to move to the specified extension, then a C status = 107 is returned. call ftmrhd(unit,1,hdutype,status) if (status .eq. 0)then C success, so jump back and print out keywords in this extension go to 100 else if (status .eq. 107)then C hit end of file, so quit status=0 end if C The FITS file must always be closed before exiting the program. C Any unit numbers allocated with FTGIOU must be freed with FTFIOU. call ftclos(unit, status) call ftfiou(unit, status) C Check for any error, and if so print out error messages. C The PRINTERROR subroutine is listed near the end of this file. if (status .gt. 0)call printerror(status) end C ************************************************************************* subroutine readimage C Read a FITS image and determine the minimum and maximum pixel value. C Rather than reading the entire image in C at once (which could require a very large array), the image is read C in pieces, 100 pixels at a time. integer status,unit,readwrite,blocksize,naxes(2),nfound integer group,firstpix,nbuffer,npixels,i real datamin,datamax,nullval,buffer(100) logical anynull character filename*80 C The STATUS parameter must always be initialized. status=0 C Get an unused Logical Unit Number to use to open the FITS file. call ftgiou(unit,status) C Open the FITS file previously created by WRITEIMAGE filename='ATESTFILEZ.FITS' readwrite=0 call ftopen(unit,filename,readwrite,blocksize,status) C Determine the size of the image. call ftgknj(unit,'NAXIS',1,2,naxes,nfound,status) C Check that it found both NAXIS1 and NAXIS2 keywords. if (nfound .ne. 2)then print *,'READIMAGE failed to read the NAXISn keywords.' return end if C Initialize variables npixels=naxes(1)*naxes(2) group=1 firstpix=1 nullval=-999 datamin=1.0E30 datamax=-1.0E30 do while (npixels .gt. 0) C read up to 100 pixels at a time nbuffer=min(100,npixels) call ftgpve(unit,group,firstpix,nbuffer,nullval, & buffer,anynull,status) C find the min and max values do i=1,nbuffer datamin=min(datamin,buffer(i)) datamax=max(datamax,buffer(i)) end do C increment pointers and loop back to read the next group of pixels npixels=npixels-nbuffer firstpix=firstpix+nbuffer end do print * print *,'Min and max image pixels = ',datamin,datamax C The FITS file must always be closed before exiting the program. C Any unit numbers allocated with FTGIOU must be freed with FTFIOU. call ftclos(unit, status) call ftfiou(unit, status) C Check for any error, and if so print out error messages. C The PRINTERROR subroutine is listed near the end of this file. if (status .gt. 0)call printerror(status) end C ************************************************************************* subroutine readtable C Read and print data values from an ASCII or binary table C This example reads and prints out all the data in the ASCII and C the binary tables that were previously created by WRITEASCII and C WRITEBINTABLE. Note that the exact same FITSIO routines are C used to read both types of tables. integer status,unit,readwrite,blocksize,hdutype,ntable integer felem,nelems,nullj,diameter,nfound,irow,colnum real nulle,density character filename*40,nullstr*1,name*8,ttype(3)*10 logical anynull C The STATUS parameter must always be initialized. status=0 C Get an unused Logical Unit Number to use to open the FITS file. call ftgiou(unit,status) C Open the FITS file previously created by WRITEIMAGE filename='ATESTFILEZ.FITS' readwrite=0 call ftopen(unit,filename,readwrite,blocksize,status) C Loop twice, first reading the ASCII table, then the binary table do ntable=2,3 C Move to the next extension call ftmahd(unit,ntable,hdutype,status) print *,' ' if (hdutype .eq. 1)then print *,'Reading ASCII table in HDU ',ntable else if (hdutype .eq. 2)then print *,'Reading binary table in HDU ',ntable end if C Read the TTYPEn keywords, which give the names of the columns call ftgkns(unit,'TTYPE',1,3,ttype,nfound,status) write(*,2000)ttype 2000 format(2x,"Row ",3a10) C Read the data, one row at a time, and print them out felem=1 nelems=1 nullstr=' ' nullj=0 nulle=0. do irow=1,6 C FTGCVS reads the NAMES from the first column of the table. colnum=1 call ftgcvs(unit,colnum,irow,felem,nelems,nullstr,name, & anynull,status) C FTGCVJ reads the DIAMETER values from the second column. colnum=2 call ftgcvj(unit,colnum,irow,felem,nelems,nullj,diameter, & anynull,status) C FTGCVE reads the DENSITY values from the third column. colnum=3 call ftgcve(unit,colnum,irow,felem,nelems,nulle,density, & anynull,status) write(*,2001)irow,name,diameter,density 2001 format(i5,a10,i10,f10.2) end do end do C The FITS file must always be closed before exiting the program. C Any unit numbers allocated with FTGIOU must be freed with FTFIOU. call ftclos(unit, status) call ftfiou(unit, status) C Check for any error, and if so print out error messages. C The PRINTERROR subroutine is listed near the end of this file. if (status .gt. 0)call printerror(status) end C ************************************************************************* subroutine printerror(status) C This subroutine prints out the descriptive text corresponding to the C error status value and prints out the contents of the internal C error message stack generated by FITSIO whenever an error occurs. integer status character errtext*30,errmessage*80 C Check if status is OK (no error); if so, simply return if (status .le. 0)return C The FTGERR subroutine returns a descriptive 30-character text string that C corresponds to the integer error status number. A complete list of all C the error numbers can be found in the back of the FITSIO User's Guide. call ftgerr(status,errtext) print *,'FITSIO Error Status =',status,': ',errtext C FITSIO usually generates an internal stack of error messages whenever C an error occurs. These messages provide much more information on the C cause of the problem than can be provided by the single integer error C status value. The FTGMSG subroutine retrieves the oldest message from C the stack and shifts any remaining messages on the stack down one C position. FTGMSG is called repeatedly until a blank message is C returned, which indicates that the stack is empty. Each error message C may be up to 80 characters in length. Another subroutine, called C FTCMSG, is available to simply clear the whole error message stack in C cases where one is not interested in the contents. call ftgmsg(errmessage) do while (errmessage .ne. ' ') print *,errmessage call ftgmsg(errmessage) end do end C ************************************************************************* subroutine deletefile(filename,status) C A simple little routine to delete a FITS file integer status,unit,blocksize character*(*) filename C Simply return if status is greater than zero if (status .gt. 0)return C Get an unused Logical Unit Number to use to open the FITS file call ftgiou(unit,status) C Try to open the file, to see if it exists call ftopen(unit,filename,1,blocksize,status) if (status .eq. 0)then C file was opened; so now delete it call ftdelt(unit,status) else if (status .eq. 103)then C file doesn't exist, so just reset status to zero and clear errors status=0 call ftcmsg else C there was some other error opening the file; delete the file anyway status=0 call ftcmsg call ftdelt(unit,status) end if C Free the unit number for later reuse call ftfiou(unit, status) end healpy-1.10.3/cfitsio/drvrfile.c0000664000175000017500000006700013010375004016743 0ustar zoncazonca00000000000000/* This file, drvrfile.c contains driver routines for disk files. */ /* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ #include #include #include "fitsio2.h" #include "group.h" /* needed for fits_get_cwd in file_create */ #if defined(unix) || defined(__unix__) || defined(__unix) #include /* needed in file_openfile */ #ifdef REPLACE_LINKS #include #include #endif #endif #ifdef HAVE_FTRUNCATE #if defined(unix) || defined(__unix__) || defined(__unix) #include /* needed for getcwd prototype on unix machines */ #endif #endif #define IO_SEEK 0 /* last file I/O operation was a seek */ #define IO_READ 1 /* last file I/O operation was a read */ #define IO_WRITE 2 /* last file I/O operation was a write */ static char file_outfile[FLEN_FILENAME]; typedef struct /* structure containing disk file structure */ { FILE *fileptr; LONGLONG currentpos; int last_io_op; } diskdriver; static diskdriver handleTable[NMAXFILES]; /* allocate diskfile handle tables */ /*--------------------------------------------------------------------------*/ int file_init(void) { int ii; for (ii = 0; ii < NMAXFILES; ii++) /* initialize all empty slots in table */ { handleTable[ii].fileptr = 0; } return(0); } /*--------------------------------------------------------------------------*/ int file_setoptions(int options) { /* do something with the options argument, to stop compiler warning */ options = 0; return(options); } /*--------------------------------------------------------------------------*/ int file_getoptions(int *options) { *options = 0; return(0); } /*--------------------------------------------------------------------------*/ int file_getversion(int *version) { *version = 10; return(0); } /*--------------------------------------------------------------------------*/ int file_shutdown(void) { return(0); } /*--------------------------------------------------------------------------*/ int file_open(char *filename, int rwmode, int *handle) { FILE *diskfile; int copyhandle, ii, status; char recbuf[2880]; size_t nread; /* if an output filename has been specified as part of the input file, as in "inputfile.fits(outputfile.fit)" then we have to create the output file, copy the input to it, then reopen the the new copy. */ if (*file_outfile) { /* open the original file, with readonly access */ status = file_openfile(filename, READONLY, &diskfile); if (status) { file_outfile[0] = '\0'; return(status); } /* create the output file */ status = file_create(file_outfile,handle); if (status) { ffpmsg("Unable to create output file for copy of input file:"); ffpmsg(file_outfile); file_outfile[0] = '\0'; return(status); } /* copy the file from input to output */ while(0 != (nread = fread(recbuf,1,2880, diskfile))) { status = file_write(*handle, recbuf, nread); if (status) { file_outfile[0] = '\0'; return(status); } } /* close both files */ fclose(diskfile); copyhandle = *handle; file_close(*handle); *handle = copyhandle; /* reuse the old file handle */ /* reopen the new copy, with correct rwmode */ status = file_openfile(file_outfile, rwmode, &diskfile); file_outfile[0] = '\0'; } else { *handle = -1; for (ii = 0; ii < NMAXFILES; ii++) /* find empty slot in table */ { if (handleTable[ii].fileptr == 0) { *handle = ii; break; } } if (*handle == -1) return(TOO_MANY_FILES); /* too many files opened */ /*open the file */ status = file_openfile(filename, rwmode, &diskfile); } handleTable[*handle].fileptr = diskfile; handleTable[*handle].currentpos = 0; handleTable[*handle].last_io_op = IO_SEEK; return(status); } /*--------------------------------------------------------------------------*/ int file_openfile(char *filename, int rwmode, FILE **diskfile) /* lowest level routine to physically open a disk file */ { char mode[4]; #if defined(unix) || defined(__unix__) || defined(__unix) char tempname[1024], *cptr, user[80]; struct passwd *pwd; int ii = 0; #if defined(REPLACE_LINKS) struct stat stbuf; int success = 0; size_t n; FILE *f1, *f2; char buf[BUFSIZ]; #endif #endif if (rwmode == READWRITE) { strcpy(mode, "r+b"); /* open existing file with read-write */ } else { strcpy(mode, "rb"); /* open existing file readonly */ } #if MACHINE == ALPHAVMS || MACHINE == VAXVMS /* specify VMS record structure: fixed format, 2880 byte records */ /* but force stream mode access to enable random I/O access */ *diskfile = fopen(filename, mode, "rfm=fix", "mrs=2880", "ctx=stm"); #elif defined(unix) || defined(__unix__) || defined(__unix) /* support the ~user/file.fits or ~/file.fits filenames in UNIX */ if (*filename == '~') { if (filename[1] == '/') { cptr = getenv("HOME"); if (cptr) { if (strlen(cptr) + strlen(filename+1) > 1023) return(FILE_NOT_OPENED); strcpy(tempname, cptr); strcat(tempname, filename+1); } else { if (strlen(filename) > 1023) return(FILE_NOT_OPENED); strcpy(tempname, filename); } } else { /* copy user name */ cptr = filename+1; while (*cptr && (*cptr != '/')) { user[ii] = *cptr; cptr++; ii++; } user[ii] = '\0'; /* get structure that includes name of user's home directory */ pwd = getpwnam(user); /* copy user's home directory */ if (strlen(pwd->pw_dir) + strlen(cptr) > 1023) return(FILE_NOT_OPENED); strcpy(tempname, pwd->pw_dir); strcat(tempname, cptr); } *diskfile = fopen(tempname, mode); } else { /* don't need to expand the input file name */ *diskfile = fopen(filename, mode); #if defined(REPLACE_LINKS) if (!(*diskfile) && (rwmode == READWRITE)) { /* failed to open file with READWRITE privilege. Test if */ /* the file we are trying to open is a soft link to a file that */ /* doesn't have write privilege. */ lstat(filename, &stbuf); if ((stbuf.st_mode & S_IFMT) == S_IFLNK) /* is this a soft link? */ { if ((f1 = fopen(filename, "rb")) != 0) /* try opening READONLY */ { if (strlen(filename) + 7 > 1023) return(FILE_NOT_OPENED); strcpy(tempname, filename); strcat(tempname, ".TmxFil"); if ((f2 = fopen(tempname, "wb")) != 0) /* create temp file */ { success = 1; while ((n = fread(buf, 1, BUFSIZ, f1)) > 0) { /* copy linked file to local temporary file */ if (fwrite(buf, 1, n, f2) != n) { success = 0; break; } } fclose(f2); } fclose(f1); if (success) { /* delete link and rename temp file to previous link name */ remove(filename); rename(tempname, filename); /* try once again to open the file with write access */ *diskfile = fopen(filename, mode); } else remove(tempname); /* clean up the failed copy */ } } } #endif } #else /* other non-UNIX machines */ *diskfile = fopen(filename, mode); #endif if (!(*diskfile)) /* couldn't open file */ { return(FILE_NOT_OPENED); } return(0); } /*--------------------------------------------------------------------------*/ int file_create(char *filename, int *handle) { FILE *diskfile; int ii; char mode[4]; int status = 0, rootlen, rootlen2, slen; char *cptr, *cpos; char cwd[FLEN_FILENAME], absURL[FLEN_FILENAME]; char rootstring[256], rootstring2[256]; char username[FLEN_FILENAME], userroot[FLEN_FILENAME], userroot2[FLEN_FILENAME]; cptr = getenv("HERA_DATA_DIRECTORY"); if (cptr) { /* This environment variable is defined in the Hera data analysis environment. */ /* It specifies the root directory path to the users data directories. */ /* CFITSIO will verify that the path to the file that is to be created */ /* is within this root directory + the user's home directory name. */ /* printf("env = %s\n",cptr); */ if (strlen(cptr) > 200) /* guard against possible string overflows */ return(FILE_NOT_CREATED); /* environment variable has the form "path/one/;/path/two/" where the */ /* second path is optional */ strcpy(rootstring, cptr); cpos = strchr(rootstring, ';'); if (cpos) { *cpos = '\0'; cpos++; strcpy(rootstring2, cpos); } else { *rootstring2 = '\0'; } /* printf("%s, %s\n", rootstring, rootstring2); printf("CWD = %s\n", cwd); printf("rootstring=%s, cwd=%s.\n", rootstring, cwd); */ /* Get the current working directory */ fits_get_cwd(cwd, &status); slen = strlen(cwd); if (cwd[slen-1] != '/') strcat(cwd,"/"); /* make sure the CWD ends with slash */ /* check that CWD string matches the rootstring */ rootlen = strlen(rootstring); if (strncmp(rootstring, cwd, rootlen)) { ffpmsg("invalid CWD: does not match root data directory"); return(FILE_NOT_CREATED); } else { /* get the user name from CWD (it follows the root string) */ strncpy(username, cwd+rootlen, 50); /* limit length of user name */ cpos=strchr(username, '/'); if (!cpos) { ffpmsg("invalid CWD: not equal to root data directory + username"); return(FILE_NOT_CREATED); } else { *(cpos+1) = '\0'; /* truncate user name string */ /* construct full user root name */ strcpy(userroot, rootstring); strcat(userroot, username); rootlen = strlen(userroot); /* construct alternate full user root name */ strcpy(userroot2, rootstring2); strcat(userroot2, username); rootlen2 = strlen(userroot2); /* convert the input filename to absolute path relative to the CWD */ fits_relurl2url(cwd, filename, absURL, &status); /* printf("username = %s\n", username); printf("userroot = %s\n", userroot); printf("userroot2 = %s\n", userroot2); printf("filename = %s\n", filename); printf("ABS = %s\n", absURL); */ /* check that CWD string matches the rootstring or alternate root string */ if ( strncmp(userroot, absURL, rootlen) && strncmp(userroot2, absURL, rootlen2) ) { ffpmsg("invalid filename: path not within user directory"); return(FILE_NOT_CREATED); } } } /* if we got here, then the input filename appears to be valid */ } *handle = -1; for (ii = 0; ii < NMAXFILES; ii++) /* find empty slot in table */ { if (handleTable[ii].fileptr == 0) { *handle = ii; break; } } if (*handle == -1) return(TOO_MANY_FILES); /* too many files opened */ strcpy(mode, "w+b"); /* create new file with read-write */ diskfile = fopen(filename, "r"); /* does file already exist? */ if (diskfile) { fclose(diskfile); /* close file and exit with error */ return(FILE_NOT_CREATED); } #if MACHINE == ALPHAVMS || MACHINE == VAXVMS /* specify VMS record structure: fixed format, 2880 byte records */ /* but force stream mode access to enable random I/O access */ diskfile = fopen(filename, mode, "rfm=fix", "mrs=2880", "ctx=stm"); #else diskfile = fopen(filename, mode); #endif if (!(diskfile)) /* couldn't create file */ { return(FILE_NOT_CREATED); } handleTable[ii].fileptr = diskfile; handleTable[ii].currentpos = 0; handleTable[ii].last_io_op = IO_SEEK; return(0); } /*--------------------------------------------------------------------------*/ int file_truncate(int handle, LONGLONG filesize) /* truncate the diskfile to a new smaller size */ { #ifdef HAVE_FTRUNCATE int fdesc; fdesc = fileno(handleTable[handle].fileptr); ftruncate(fdesc, (OFF_T) filesize); file_seek(handle, filesize); handleTable[handle].currentpos = filesize; handleTable[handle].last_io_op = IO_SEEK; #endif return(0); } /*--------------------------------------------------------------------------*/ int file_size(int handle, LONGLONG *filesize) /* return the size of the file in bytes */ { OFF_T position1,position2; FILE *diskfile; diskfile = handleTable[handle].fileptr; #if defined(_MSC_VER) && (_MSC_VER >= 1400) /* call the VISUAL C++ version of the routines which support */ /* Large Files (> 2GB) if they are supported (since VC 8.0) */ position1 = _ftelli64(diskfile); /* save current postion */ if (position1 < 0) return(SEEK_ERROR); if (_fseeki64(diskfile, 0, 2) != 0) /* seek to end of file */ return(SEEK_ERROR); position2 = _ftelli64(diskfile); /* get file size */ if (position2 < 0) return(SEEK_ERROR); if (_fseeki64(diskfile, position1, 0) != 0) /* seek back to original pos */ return(SEEK_ERROR); #elif _FILE_OFFSET_BITS - 0 == 64 /* call the newer ftello and fseeko routines , which support */ /* Large Files (> 2GB) if they are supported. */ position1 = ftello(diskfile); /* save current postion */ if (position1 < 0) return(SEEK_ERROR); if (fseeko(diskfile, 0, 2) != 0) /* seek to end of file */ return(SEEK_ERROR); position2 = ftello(diskfile); /* get file size */ if (position2 < 0) return(SEEK_ERROR); if (fseeko(diskfile, position1, 0) != 0) /* seek back to original pos */ return(SEEK_ERROR); #else position1 = ftell(diskfile); /* save current postion */ if (position1 < 0) return(SEEK_ERROR); if (fseek(diskfile, 0, 2) != 0) /* seek to end of file */ return(SEEK_ERROR); position2 = ftell(diskfile); /* get file size */ if (position2 < 0) return(SEEK_ERROR); if (fseek(diskfile, position1, 0) != 0) /* seek back to original pos */ return(SEEK_ERROR); #endif *filesize = (LONGLONG) position2; return(0); } /*--------------------------------------------------------------------------*/ int file_close(int handle) /* close the file */ { if (fclose(handleTable[handle].fileptr) ) return(FILE_NOT_CLOSED); handleTable[handle].fileptr = 0; return(0); } /*--------------------------------------------------------------------------*/ int file_remove(char *filename) /* delete the file from disk */ { remove(filename); return(0); } /*--------------------------------------------------------------------------*/ int file_flush(int handle) /* flush the file */ { if (fflush(handleTable[handle].fileptr) ) return(WRITE_ERROR); /* The flush operation is not supposed to move the internal */ /* file pointer, but it does on some Windows-95 compilers and */ /* perhaps others, so seek to original position to be sure. */ /* This seek will do no harm on other systems. */ #if MACHINE == IBMPC if (file_seek(handle, handleTable[handle].currentpos)) return(SEEK_ERROR); #endif return(0); } /*--------------------------------------------------------------------------*/ int file_seek(int handle, LONGLONG offset) /* seek to position relative to start of the file */ { #if defined(_MSC_VER) && (_MSC_VER >= 1400) /* Microsoft visual studio C++ */ /* _fseeki64 supported beginning with version 8.0 */ if (_fseeki64(handleTable[handle].fileptr, (OFF_T) offset, 0) != 0) return(SEEK_ERROR); #elif _FILE_OFFSET_BITS - 0 == 64 if (fseeko(handleTable[handle].fileptr, (OFF_T) offset, 0) != 0) return(SEEK_ERROR); #else if (fseek(handleTable[handle].fileptr, (OFF_T) offset, 0) != 0) return(SEEK_ERROR); #endif handleTable[handle].currentpos = offset; return(0); } /*--------------------------------------------------------------------------*/ int file_read(int hdl, void *buffer, long nbytes) /* read bytes from the current position in the file */ { long nread; char *cptr; if (handleTable[hdl].last_io_op == IO_WRITE) { if (file_seek(hdl, handleTable[hdl].currentpos)) return(SEEK_ERROR); } nread = (long) fread(buffer, 1, nbytes, handleTable[hdl].fileptr); if (nread == 1) { cptr = (char *) buffer; /* some editors will add a single end-of-file character to a file */ /* Ignore it if the character is a zero, 10, or 32 */ if (*cptr == 0 || *cptr == 10 || *cptr == 32) return(END_OF_FILE); else return(READ_ERROR); } else if (nread != nbytes) { return(READ_ERROR); } handleTable[hdl].currentpos += nbytes; handleTable[hdl].last_io_op = IO_READ; return(0); } /*--------------------------------------------------------------------------*/ int file_write(int hdl, void *buffer, long nbytes) /* write bytes at the current position in the file */ { if (handleTable[hdl].last_io_op == IO_READ) { if (file_seek(hdl, handleTable[hdl].currentpos)) return(SEEK_ERROR); } if((long) fwrite(buffer, 1, nbytes, handleTable[hdl].fileptr) != nbytes) return(WRITE_ERROR); handleTable[hdl].currentpos += nbytes; handleTable[hdl].last_io_op = IO_WRITE; return(0); } /*--------------------------------------------------------------------------*/ int file_compress_open(char *filename, int rwmode, int *hdl) /* This routine opens the compressed diskfile by creating a new uncompressed file then opening it. The input file name (the name of the compressed file) gets replaced with the name of the uncompressed file, which is initially stored in the global file_outfile string. file_outfile then gets set to a null string. */ { FILE *indiskfile, *outdiskfile; int status; char *cptr; /* open the compressed disk file */ status = file_openfile(filename, READONLY, &indiskfile); if (status) { ffpmsg("failed to open compressed disk file (file_compress_open)"); ffpmsg(filename); return(status); } /* name of the output uncompressed file is stored in the */ /* global variable called 'file_outfile'. */ cptr = file_outfile; if (*cptr == '!') { /* clobber any existing file with the same name */ cptr++; remove(cptr); } else { outdiskfile = fopen(file_outfile, "r"); /* does file already exist? */ if (outdiskfile) { ffpmsg("uncompressed file already exists: (file_compress_open)"); ffpmsg(file_outfile); fclose(outdiskfile); /* close file and exit with error */ file_outfile[0] = '\0'; return(FILE_NOT_CREATED); } } outdiskfile = fopen(cptr, "w+b"); /* create new file */ if (!outdiskfile) { ffpmsg("could not create uncompressed file: (file_compress_open)"); ffpmsg(file_outfile); file_outfile[0] = '\0'; return(FILE_NOT_CREATED); } /* uncompress file into another file */ uncompress2file(filename, indiskfile, outdiskfile, &status); fclose(indiskfile); fclose(outdiskfile); if (status) { ffpmsg("error in file_compress_open: failed to uncompressed file:"); ffpmsg(filename); ffpmsg(" into new output file:"); ffpmsg(file_outfile); file_outfile[0] = '\0'; return(status); } strcpy(filename, cptr); /* switch the names */ file_outfile[0] = '\0'; status = file_open(filename, rwmode, hdl); return(status); } /*--------------------------------------------------------------------------*/ int file_is_compressed(char *filename) /* I - FITS file name */ /* Test if the disk file is compressed. Returns 1 if compressed, 0 if not. This may modify the filename string by appending a compression suffex. */ { FILE *diskfile; unsigned char buffer[2]; char tmpfilename[FLEN_FILENAME]; /* Open file. Try various suffix combinations */ if (file_openfile(filename, 0, &diskfile)) { if (strlen(filename) > FLEN_FILENAME - 1) return(0); strcpy(tmpfilename,filename); strcat(filename,".gz"); if (file_openfile(filename, 0, &diskfile)) { strcpy(filename, tmpfilename); strcat(filename,".Z"); if (file_openfile(filename, 0, &diskfile)) { strcpy(filename, tmpfilename); strcat(filename,".z"); /* it's often lower case on CDROMs */ if (file_openfile(filename, 0, &diskfile)) { strcpy(filename, tmpfilename); strcat(filename,".zip"); if (file_openfile(filename, 0, &diskfile)) { strcpy(filename, tmpfilename); strcat(filename,"-z"); /* VMS suffix */ if (file_openfile(filename, 0, &diskfile)) { strcpy(filename, tmpfilename); strcat(filename,"-gz"); /* VMS suffix */ if (file_openfile(filename, 0, &diskfile)) { strcpy(filename,tmpfilename); /* restore original name */ return(0); /* file not found */ } } } } } } } if (fread(buffer, 1, 2, diskfile) != 2) /* read 2 bytes */ { fclose(diskfile); /* error reading file so just return */ return(0); } fclose(diskfile); /* see if the 2 bytes have the magic values for a compressed file */ if ( (memcmp(buffer, "\037\213", 2) == 0) || /* GZIP */ (memcmp(buffer, "\120\113", 2) == 0) || /* PKZIP */ (memcmp(buffer, "\037\036", 2) == 0) || /* PACK */ (memcmp(buffer, "\037\235", 2) == 0) || /* LZW */ (memcmp(buffer, "\037\240", 2) == 0) ) /* LZH */ { return(1); /* this is a compressed file */ } else { return(0); /* not a compressed file */ } } /*--------------------------------------------------------------------------*/ int file_checkfile (char *urltype, char *infile, char *outfile) { /* special case: if file:// driver, check if the file is compressed */ if ( file_is_compressed(infile) ) { /* if output file has been specified, save the name for future use: */ /* This is the name of the uncompressed file to be created on disk. */ if (strlen(outfile)) { if (!strncmp(outfile, "mem:", 4) ) { /* uncompress the file in memory, with READ and WRITE access */ strcpy(urltype, "compressmem://"); /* use special driver */ *file_outfile = '\0'; } else { strcpy(urltype, "compressfile://"); /* use special driver */ /* don't copy the "file://" prefix, if present. */ if (!strncmp(outfile, "file://", 7) ) strcpy(file_outfile,outfile+7); else strcpy(file_outfile,outfile); } } else { /* uncompress the file in memory */ strcpy(urltype, "compress://"); /* use special driver */ *file_outfile = '\0'; /* no output file was specified */ } } else /* an ordinary, uncompressed FITS file on disk */ { /* save the output file name for later use when opening the file. */ /* In this case, the file to be opened will be opened READONLY, */ /* and copied to this newly created output file. The original file */ /* will be closed, and the copy will be opened by CFITSIO for */ /* subsequent processing (possibly with READWRITE access). */ if (strlen(outfile)) { file_outfile[0] = '\0'; strncat(file_outfile,outfile,FLEN_FILENAME-1); } } return 0; } /**********************************************************************/ /**********************************************************************/ /**********************************************************************/ /**** driver routines for stream//: device (stdin or stdout) ********/ /*--------------------------------------------------------------------------*/ int stream_open(char *filename, int rwmode, int *handle) { /* read from stdin */ if (filename) rwmode = 1; /* dummy statement to suppress unused parameter compiler warning */ *handle = 1; /* 1 = stdin */ return(0); } /*--------------------------------------------------------------------------*/ int stream_create(char *filename, int *handle) { /* write to stdout */ if (filename) /* dummy statement to suppress unused parameter compiler warning */ *handle = 2; else *handle = 2; /* 2 = stdout */ return(0); } /*--------------------------------------------------------------------------*/ int stream_size(int handle, LONGLONG *filesize) /* return the size of the file in bytes */ { handle = 0; /* suppress unused parameter compiler warning */ /* this operation is not supported in a stream; return large value */ *filesize = LONG_MAX; return(0); } /*--------------------------------------------------------------------------*/ int stream_close(int handle) /* don't have to close stdin or stdout */ { handle = 0; /* suppress unused parameter compiler warning */ return(0); } /*--------------------------------------------------------------------------*/ int stream_flush(int handle) /* flush the file */ { if (handle == 2) fflush(stdout); return(0); } /*--------------------------------------------------------------------------*/ int stream_seek(int handle, LONGLONG offset) /* seeking is not allowed in a stream */ { offset = handle; /* suppress unused parameter compiler warning */ return(1); } /*--------------------------------------------------------------------------*/ int stream_read(int hdl, void *buffer, long nbytes) /* reading from stdin stream */ { long nread; if (hdl != 1) return(1); /* can only read from stdin */ nread = (long) fread(buffer, 1, nbytes, stdin); if (nread != nbytes) { /* return(READ_ERROR); */ return(END_OF_FILE); } return(0); } /*--------------------------------------------------------------------------*/ int stream_write(int hdl, void *buffer, long nbytes) /* write bytes at the current position in the file */ { if (hdl != 2) return(1); /* can only write to stdout */ if((long) fwrite(buffer, 1, nbytes, stdout) != nbytes) return(WRITE_ERROR); return(0); } healpy-1.10.3/cfitsio/drvrgsiftp.c0000664000175000017500000003241613010375004017323 0ustar zoncazonca00000000000000 /* This file, drvrgsiftp.c contains driver routines for gsiftp files. */ /* Andrea Barisani */ /* Taffoni Giuliano */ #ifdef HAVE_NET_SERVICES #ifdef HAVE_GSIFTP #include #include #include #include #include #include "fitsio2.h" #include #define MAXLEN 1200 #define NETTIMEOUT 80 #define MAX_BUFFER_SIZE_R 1024 #define MAX_BUFFER_SIZE_W (64*1024) static int gsiftpopen = 0; static int global_offset = 0; static int gsiftp_get(char *filename, FILE **gsiftpfile, int num_streams); static globus_mutex_t lock; static globus_cond_t cond; static globus_bool_t done; static char *gsiftp_tmpfile; static char *gsiftpurl = NULL; static char gsiftp_tmpdir[MAXLEN]; static jmp_buf env; /* holds the jump buffer for setjmp/longjmp pairs */ static void signal_handler(int sig); int gsiftp_init(void) { if (getenv("GSIFTP_TMPFILE")) { gsiftp_tmpfile = getenv("GSIFTP_TMPFILE"); } else { strncpy(gsiftp_tmpdir, "/tmp/gsiftp_XXXXXX", sizeof gsiftp_tmpdir); if (mkdtemp(gsiftp_tmpdir) == NULL) { ffpmsg("Cannot create temporary directory!"); return (FILE_NOT_OPENED); } gsiftp_tmpfile = malloc(strlen(gsiftp_tmpdir) + strlen("/gsiftp_buffer.tmp")); strcat(gsiftp_tmpfile, gsiftp_tmpdir); strcat(gsiftp_tmpfile, "/gsiftp_buffer.tmp"); } return file_init(); } int gsiftp_shutdown(void) { free(gsiftpurl); free(gsiftp_tmpfile); free(gsiftp_tmpdir); return file_shutdown(); } int gsiftp_setoptions(int options) { return file_setoptions(options); } int gsiftp_getoptions(int *options) { return file_getoptions(options); } int gsiftp_getversion(int *version) { return file_getversion(version); } int gsiftp_checkfile(char *urltype, char *infile, char *outfile) { return file_checkfile(urltype, infile, outfile); } int gsiftp_open(char *filename, int rwmode, int *handle) { FILE *gsiftpfile; int num_streams; if (getenv("GSIFTP_STREAMS")) { num_streams = (int)getenv("GSIFTP_STREAMS"); } else { num_streams = 1; } if (rwmode) { gsiftpopen = 2; } else { gsiftpopen = 1; } if (gsiftpurl) free(gsiftpurl); gsiftpurl = strdup(filename); if (setjmp(env) != 0) { ffpmsg("Timeout (gsiftp_open)"); goto error; } signal(SIGALRM, signal_handler); alarm(NETTIMEOUT); if (gsiftp_get(filename,&gsiftpfile,num_streams)) { alarm(0); ffpmsg("Unable to open gsiftp file (gsiftp_open)"); ffpmsg(filename); goto error; } fclose(gsiftpfile); signal(SIGALRM, SIG_DFL); alarm(0); return file_open(gsiftp_tmpfile, rwmode, handle); error: alarm(0); signal(SIGALRM, SIG_DFL); return (FILE_NOT_OPENED); } int gsiftp_create(char *filename, int *handle) { if (gsiftpurl) free(gsiftpurl); gsiftpurl = strdup(filename); return file_create(gsiftp_tmpfile, handle); } int gsiftp_truncate(int handle, LONGLONG filesize) { return file_truncate(handle, filesize); } int gsiftp_size(int handle, LONGLONG *filesize) { return file_size(handle, filesize); } int gsiftp_flush(int handle) { FILE *gsiftpfile; int num_streams; if (getenv("GSIFTP_STREAMS")) { num_streams = (int)getenv("GSIFTP_STREAMS"); } else { num_streams = 1; } int rc = file_flush(handle); if (gsiftpopen != 1) { if (setjmp(env) != 0) { ffpmsg("Timeout (gsiftp_write)"); goto error; } signal(SIGALRM, signal_handler); alarm(NETTIMEOUT); if (gsiftp_put(gsiftpurl,&gsiftpfile,num_streams)) { alarm(0); ffpmsg("Unable to open gsiftp file (gsiftp_flush)"); ffpmsg(gsiftpurl); goto error; } fclose(gsiftpfile); signal(SIGALRM, SIG_DFL); alarm(0); } return rc; error: alarm(0); signal(SIGALRM, SIG_DFL); return (FILE_NOT_OPENED); } int gsiftp_seek(int handle, LONGLONG offset) { return file_seek(handle, offset); } int gsiftp_read(int hdl, void *buffer, long nbytes) { return file_read(hdl, buffer, nbytes); } int gsiftp_write(int hdl, void *buffer, long nbytes) { return file_write(hdl, buffer, nbytes); } int gsiftp_close(int handle) { unlink(gsiftp_tmpfile); if (gsiftp_tmpdir) rmdir(gsiftp_tmpdir); return file_close(handle); } static void done_cb( void * user_arg, globus_ftp_client_handle_t * handle, globus_object_t * err) { if(err){ fprintf(stderr, "%s", globus_object_printable_to_string(err)); } globus_mutex_lock(&lock); done = GLOBUS_TRUE; globus_cond_signal(&cond); globus_mutex_unlock(&lock); return; } static void data_cb_read( void * user_arg, globus_ftp_client_handle_t * handle, globus_object_t * err, globus_byte_t * buffer, globus_size_t length, globus_off_t offset, globus_bool_t eof) { if(err) { fprintf(stderr, "%s", globus_object_printable_to_string(err)); } else { FILE* fd = (FILE*) user_arg; int rc = fwrite(buffer, 1, length, fd); if (ferror(fd)) { printf("Read error in function data_cb_read; errno = %d\n", errno); return; } if (!eof) { globus_ftp_client_register_read(handle, buffer, MAX_BUFFER_SIZE_R, data_cb_read, (void*) fd); } } return; } static void data_cb_write( void * user_arg, globus_ftp_client_handle_t * handle, globus_object_t * err, globus_byte_t * buffer, globus_size_t length, globus_off_t offset, globus_bool_t eof) { int curr_offset; if(err) { fprintf(stderr, "%s", globus_object_printable_to_string(err)); } else { if (!eof) { FILE* fd = (FILE*) user_arg; int rc; globus_mutex_lock(&lock); curr_offset = global_offset; rc = fread(buffer, 1, MAX_BUFFER_SIZE_W, fd); global_offset += rc; globus_mutex_unlock(&lock); if (ferror(fd)) { printf("Read error in function data_cb_write; errno = %d\n", errno); return; } globus_ftp_client_register_write(handle, buffer, rc, curr_offset, feof(fd) != 0, data_cb_write, (void*) fd); } else { globus_libc_free(buffer); } } return; } int gsiftp_get(char *filename, FILE **gsiftpfile, int num_streams) { char gsiurl[MAXLEN]; globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_ftp_client_handleattr_t handle_attr; globus_ftp_control_parallelism_t parallelism; globus_ftp_control_layout_t layout; globus_byte_t buffer[MAX_BUFFER_SIZE_R]; globus_size_t buffer_length = sizeof(buffer); globus_result_t result; globus_ftp_client_restart_marker_t restart; globus_ftp_control_type_t filetype; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_handle_init(&handle, GLOBUS_NULL); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); layout.mode = GLOBUS_FTP_CONTROL_STRIPING_NONE; globus_ftp_client_restart_marker_init(&restart); globus_ftp_client_operationattr_set_mode( &attr, GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK); if (num_streams >= 1) { parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED; parallelism.fixed.size = num_streams; globus_ftp_client_operationattr_set_parallelism( &attr, ¶llelism); } globus_ftp_client_operationattr_set_layout(&attr, &layout); filetype = GLOBUS_FTP_CONTROL_TYPE_IMAGE; globus_ftp_client_operationattr_set_type (&attr, filetype); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; strcpy(gsiurl,"gsiftp://"); strcat(gsiurl,filename); *gsiftpfile = fopen(gsiftp_tmpfile,"w+"); if (!*gsiftpfile) { ffpmsg("Unable to open temporary file!"); return (FILE_NOT_OPENED); } result = globus_ftp_client_get(&handle, gsiurl, &attr, &restart, done_cb, 0); if(result != GLOBUS_SUCCESS) { globus_object_t * err; err = globus_error_get(result); fprintf(stderr, "%s", globus_object_printable_to_string(err)); done = GLOBUS_TRUE; } else { globus_ftp_client_register_read(&handle, buffer, buffer_length, data_cb_read, (void*) *gsiftpfile); } globus_mutex_lock(&lock); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); return 0; } int gsiftp_put(char *filename, FILE **gsiftpfile, int num_streams) { int i; char gsiurl[MAXLEN]; globus_ftp_client_handle_t handle; globus_ftp_client_operationattr_t attr; globus_ftp_client_handleattr_t handle_attr; globus_ftp_control_parallelism_t parallelism; globus_ftp_control_layout_t layout; globus_byte_t * buffer; globus_size_t buffer_length = sizeof(buffer); globus_result_t result; globus_ftp_client_restart_marker_t restart; globus_ftp_control_type_t filetype; globus_module_activate(GLOBUS_FTP_CLIENT_MODULE); globus_mutex_init(&lock, GLOBUS_NULL); globus_cond_init(&cond, GLOBUS_NULL); globus_ftp_client_handle_init(&handle, GLOBUS_NULL); globus_ftp_client_handleattr_init(&handle_attr); globus_ftp_client_operationattr_init(&attr); layout.mode = GLOBUS_FTP_CONTROL_STRIPING_NONE; globus_ftp_client_restart_marker_init(&restart); globus_ftp_client_operationattr_set_mode( &attr, GLOBUS_FTP_CONTROL_MODE_EXTENDED_BLOCK); if (num_streams >= 1) { parallelism.mode = GLOBUS_FTP_CONTROL_PARALLELISM_FIXED; parallelism.fixed.size = num_streams; globus_ftp_client_operationattr_set_parallelism( &attr, ¶llelism); } globus_ftp_client_operationattr_set_layout(&attr, &layout); filetype = GLOBUS_FTP_CONTROL_TYPE_IMAGE; globus_ftp_client_operationattr_set_type (&attr, filetype); globus_ftp_client_handle_init(&handle, &handle_attr); done = GLOBUS_FALSE; strcpy(gsiurl,"gsiftp://"); strcat(gsiurl,filename); *gsiftpfile = fopen(gsiftp_tmpfile,"r"); if (!*gsiftpfile) { ffpmsg("Unable to open temporary file!"); return (FILE_NOT_OPENED); } result = globus_ftp_client_put(&handle, gsiurl, &attr, &restart, done_cb, 0); if(result != GLOBUS_SUCCESS) { globus_object_t * err; err = globus_error_get(result); fprintf(stderr, "%s", globus_object_printable_to_string(err)); done = GLOBUS_TRUE; } else { int rc; int curr_offset; for (i = 0; i< 2 * num_streams && feof(*gsiftpfile) == 0; i++) { buffer = malloc(MAX_BUFFER_SIZE_W); globus_mutex_lock(&lock); curr_offset = global_offset; rc = fread(buffer, 1, MAX_BUFFER_SIZE_W, *gsiftpfile); global_offset += rc; globus_mutex_unlock(&lock); globus_ftp_client_register_write( &handle, buffer, rc, curr_offset, feof(*gsiftpfile) != 0, data_cb_write, (void*) *gsiftpfile); } } globus_mutex_lock(&lock); while(!done) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_ftp_client_handle_destroy(&handle); globus_module_deactivate_all(); return 0; } static void signal_handler(int sig) { switch (sig) { case SIGALRM: /* process for alarm */ longjmp(env,sig); default: { /* Hmm, shouldn't have happend */ exit(sig); } } } #endif #endif healpy-1.10.3/cfitsio/drvrgsiftp.h0000664000175000017500000000142313010375004017322 0ustar zoncazonca00000000000000#ifndef _GSIFTP_H #define _GSIFTP_H int gsiftp_init(void); int gsiftp_setoptions(int options); int gsiftp_getoptions(int *options); int gsiftp_getversion(int *version); int gsiftp_shutdown(void); int gsiftp_checkfile(char *urltype, char *infile, char *outfile); int gsiftp_open(char *filename, int rwmode, int *driverhandle); int gsiftp_create(char *filename, int *driverhandle); int gsiftp_truncate(int driverhandle, LONGLONG filesize); int gsiftp_size(int driverhandle, LONGLONG *filesize); int gsiftp_close(int driverhandle); int gsiftp_remove(char *filename); int gsiftp_flush(int driverhandle); int gsiftp_seek(int driverhandle, LONGLONG offset); int gsiftp_read (int driverhandle, void *buffer, long nbytes); int gsiftp_write(int driverhandle, void *buffer, long nbytes); #endif healpy-1.10.3/cfitsio/drvrmem.c0000664000175000017500000010772113010375004016607 0ustar zoncazonca00000000000000/* This file, drvrmem.c, contains driver routines for memory files. */ /* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ #include #include #include /* apparently needed to define size_t */ #include "fitsio2.h" /* prototype for .Z file uncompression function in zuncompress.c */ int zuncompress2mem(char *filename, FILE *diskfile, char **buffptr, size_t *buffsize, void *(*mem_realloc)(void *p, size_t newsize), size_t *filesize, int *status); #define RECBUFLEN 1000 static char stdin_outfile[FLEN_FILENAME]; typedef struct /* structure containing mem file structure */ { char **memaddrptr; /* Pointer to memory address pointer; */ /* This may or may not point to memaddr. */ char *memaddr; /* Pointer to starting memory address; may */ /* not always be used, so use *memaddrptr instead */ size_t *memsizeptr; /* Pointer to the size of the memory allocation. */ /* This may or may not point to memsize. */ size_t memsize; /* Size of the memory allocation; this may not */ /* always be used, so use *memsizeptr instead. */ size_t deltasize; /* Suggested increment for reallocating memory */ void *(*mem_realloc)(void *p, size_t newsize); /* realloc function */ LONGLONG currentpos; /* current file position, relative to start */ LONGLONG fitsfilesize; /* size of the FITS file (always <= *memsizeptr) */ FILE *fileptr; /* pointer to compressed output disk file */ } memdriver; static memdriver memTable[NMAXFILES]; /* allocate mem file handle tables */ /*--------------------------------------------------------------------------*/ int mem_init(void) { int ii; for (ii = 0; ii < NMAXFILES; ii++) /* initialize all empty slots in table */ { memTable[ii].memaddrptr = 0; memTable[ii].memaddr = 0; } return(0); } /*--------------------------------------------------------------------------*/ int mem_setoptions(int options) { /* do something with the options argument, to stop compiler warning */ options = 0; return(options); } /*--------------------------------------------------------------------------*/ int mem_getoptions(int *options) { *options = 0; return(0); } /*--------------------------------------------------------------------------*/ int mem_getversion(int *version) { *version = 10; return(0); } /*--------------------------------------------------------------------------*/ int mem_shutdown(void) { return(0); } /*--------------------------------------------------------------------------*/ int mem_create(char *filename, int *handle) /* Create a new empty memory file for subsequent writes. The file name is ignored in this case. */ { int status; /* initially allocate 1 FITS block = 2880 bytes */ status = mem_createmem(2880L, handle); if (status) { ffpmsg("failed to create empty memory file (mem_create)"); return(status); } return(0); } /*--------------------------------------------------------------------------*/ int mem_create_comp(char *filename, int *handle) /* Create a new empty memory file for subsequent writes. Also create an empty compressed .gz file. The memory file will be compressed and written to the disk file when the file is closed. */ { FILE *diskfile; char mode[4]; int status; /* first, create disk file for the compressed output */ if ( !strcmp(filename, "-.gz") || !strcmp(filename, "stdout.gz") || !strcmp(filename, "STDOUT.gz") ) { /* special case: create uncompressed FITS file in memory, then compress it an write it out to 'stdout' when it is closed. */ diskfile = stdout; } else { /* normal case: create disk file for the compressed output */ strcpy(mode, "w+b"); /* create file with read-write */ diskfile = fopen(filename, "r"); /* does file already exist? */ if (diskfile) { fclose(diskfile); /* close file and exit with error */ return(FILE_NOT_CREATED); } #if MACHINE == ALPHAVMS || MACHINE == VAXVMS /* specify VMS record structure: fixed format, 2880 byte records */ /* but force stream mode access to enable random I/O access */ diskfile = fopen(filename, mode, "rfm=fix", "mrs=2880", "ctx=stm"); #else diskfile = fopen(filename, mode); #endif if (!(diskfile)) /* couldn't create file */ { return(FILE_NOT_CREATED); } } /* now create temporary memory file */ /* initially allocate 1 FITS block = 2880 bytes */ status = mem_createmem(2880L, handle); if (status) { ffpmsg("failed to create empty memory file (mem_create_comp)"); return(status); } memTable[*handle].fileptr = diskfile; return(0); } /*--------------------------------------------------------------------------*/ int mem_openmem(void **buffptr, /* I - address of memory pointer */ size_t *buffsize, /* I - size of buffer, in bytes */ size_t deltasize, /* I - increment for future realloc's */ void *(*memrealloc)(void *p, size_t newsize), /* function */ int *handle) /* lowest level routine to open a pre-existing memory file. */ { int ii; *handle = -1; for (ii = 0; ii < NMAXFILES; ii++) /* find empty slot in handle table */ { if (memTable[ii].memaddrptr == 0) { *handle = ii; break; } } if (*handle == -1) return(TOO_MANY_FILES); /* too many files opened */ memTable[ii].memaddrptr = (char **) buffptr; /* pointer to start addres */ memTable[ii].memsizeptr = buffsize; /* allocated size of memory */ memTable[ii].deltasize = deltasize; /* suggested realloc increment */ memTable[ii].fitsfilesize = *buffsize; /* size of FITS file (upper limit) */ memTable[ii].currentpos = 0; /* at beginning of the file */ memTable[ii].mem_realloc = memrealloc; /* memory realloc function */ return(0); } /*--------------------------------------------------------------------------*/ int mem_createmem(size_t msize, int *handle) /* lowest level routine to allocate a memory file. */ { int ii; *handle = -1; for (ii = 0; ii < NMAXFILES; ii++) /* find empty slot in handle table */ { if (memTable[ii].memaddrptr == 0) { *handle = ii; break; } } if (*handle == -1) return(TOO_MANY_FILES); /* too many files opened */ /* use the internally allocated memaddr and memsize variables */ memTable[ii].memaddrptr = &memTable[ii].memaddr; memTable[ii].memsizeptr = &memTable[ii].memsize; /* allocate initial block of memory for the file */ if (msize > 0) { memTable[ii].memaddr = (char *) malloc(msize); if ( !(memTable[ii].memaddr) ) { ffpmsg("malloc of initial memory failed (mem_createmem)"); return(FILE_NOT_OPENED); } } /* set initial state of the file */ memTable[ii].memsize = msize; memTable[ii].deltasize = 2880; memTable[ii].fitsfilesize = 0; memTable[ii].currentpos = 0; memTable[ii].mem_realloc = realloc; return(0); } /*--------------------------------------------------------------------------*/ int mem_truncate(int handle, LONGLONG filesize) /* truncate the file to a new size */ { char *ptr; /* call the memory reallocation function, if defined */ if ( memTable[handle].mem_realloc ) { /* explicit LONGLONG->size_t cast */ ptr = (memTable[handle].mem_realloc)( *(memTable[handle].memaddrptr), (size_t) filesize); if (!ptr) { ffpmsg("Failed to reallocate memory (mem_truncate)"); return(MEMORY_ALLOCATION); } /* if allocated more memory, initialize it to zero */ if ( filesize > *(memTable[handle].memsizeptr) ) { memset(ptr + *(memTable[handle].memsizeptr), 0, ((size_t) filesize) - *(memTable[handle].memsizeptr) ); } *(memTable[handle].memaddrptr) = ptr; *(memTable[handle].memsizeptr) = (size_t) (filesize); } memTable[handle].currentpos = filesize; memTable[handle].fitsfilesize = filesize; return(0); } /*--------------------------------------------------------------------------*/ int stdin_checkfile(char *urltype, char *infile, char *outfile) /* do any special case checking when opening a file on the stdin stream */ { if (strlen(outfile)) { stdin_outfile[0] = '\0'; strncat(stdin_outfile,outfile,FLEN_FILENAME-1); /* an output file is specified */ strcpy(urltype,"stdinfile://"); } else *stdin_outfile = '\0'; /* no output file was specified */ return(0); } /*--------------------------------------------------------------------------*/ int stdin_open(char *filename, int rwmode, int *handle) /* open a FITS file from the stdin file stream by copying it into memory The file name is ignored in this case. */ { int status; char cbuff; if (*stdin_outfile) { /* copy the stdin stream to the specified disk file then open the file */ /* Create the output file */ status = file_create(stdin_outfile,handle); if (status) { ffpmsg("Unable to create output file to copy stdin (stdin_open):"); ffpmsg(stdin_outfile); return(status); } /* copy the whole stdin stream to the file */ status = stdin2file(*handle); file_close(*handle); if (status) { ffpmsg("failed to copy stdin to file (stdin_open)"); ffpmsg(stdin_outfile); return(status); } /* reopen file with proper rwmode attribute */ status = file_open(stdin_outfile, rwmode, handle); } else { /* get the first character, then put it back */ cbuff = fgetc(stdin); ungetc(cbuff, stdin); /* compressed files begin with 037 or 'P' */ if (cbuff == 31 || cbuff == 75) { /* looks like the input stream is compressed */ status = mem_compress_stdin_open(filename, rwmode, handle); } else { /* copy the stdin stream into memory then open file in memory */ if (rwmode != READONLY) { ffpmsg("cannot open stdin with WRITE access"); return(READONLY_FILE); } status = mem_createmem(2880L, handle); if (status) { ffpmsg("failed to create empty memory file (stdin_open)"); return(status); } /* copy the whole stdin stream into memory */ status = stdin2mem(*handle); if (status) { ffpmsg("failed to copy stdin into memory (stdin_open)"); free(memTable[*handle].memaddr); } } } return(status); } /*--------------------------------------------------------------------------*/ int stdin2mem(int hd) /* handle number */ /* Copy the stdin stream into memory. Fill whatever amount of memory has already been allocated, then realloc more memory if necessary. */ { size_t nread, memsize, delta; LONGLONG filesize; char *memptr; char simple[] = "SIMPLE"; int c, ii, jj; memptr = *memTable[hd].memaddrptr; memsize = *memTable[hd].memsizeptr; delta = memTable[hd].deltasize; filesize = 0; ii = 0; for(jj = 0; (c = fgetc(stdin)) != EOF && jj < 2000; jj++) { /* Skip over any garbage at the beginning of the stdin stream by */ /* reading 1 char at a time, looking for 'S', 'I', 'M', 'P', 'L', 'E' */ /* Give up if not found in the first 2000 characters */ if (c == simple[ii]) { ii++; if (ii == 6) /* found the complete string? */ { memcpy(memptr, simple, 6); /* copy "SIMPLE" to buffer */ filesize = 6; break; } } else ii = 0; /* reset search to beginning of the string */ } if (filesize == 0) { ffpmsg("Couldn't find the string 'SIMPLE' in the stdin stream."); ffpmsg("This does not look like a FITS file."); return(FILE_NOT_OPENED); } /* fill up the remainder of the initial memory allocation */ nread = fread(memptr + 6, 1, memsize - 6, stdin); nread += 6; /* add in the 6 characters in 'SIMPLE' */ if (nread < memsize) /* reached the end? */ { memTable[hd].fitsfilesize = nread; return(0); } filesize = nread; while (1) { /* allocate memory for another FITS block */ memptr = realloc(memptr, memsize + delta); if (!memptr) { ffpmsg("realloc failed while copying stdin (stdin2mem)"); return(MEMORY_ALLOCATION); } memsize += delta; /* read another FITS block */ nread = fread(memptr + filesize, 1, delta, stdin); filesize += nread; if (nread < delta) /* reached the end? */ break; } memTable[hd].fitsfilesize = filesize; *memTable[hd].memaddrptr = memptr; *memTable[hd].memsizeptr = memsize; return(0); } /*--------------------------------------------------------------------------*/ int stdin2file(int handle) /* handle number */ /* Copy the stdin stream to a file. . */ { size_t nread; char simple[] = "SIMPLE"; int c, ii, jj, status; char recbuf[RECBUFLEN]; ii = 0; for(jj = 0; (c = fgetc(stdin)) != EOF && jj < 2000; jj++) { /* Skip over any garbage at the beginning of the stdin stream by */ /* reading 1 char at a time, looking for 'S', 'I', 'M', 'P', 'L', 'E' */ /* Give up if not found in the first 2000 characters */ if (c == simple[ii]) { ii++; if (ii == 6) /* found the complete string? */ { memcpy(recbuf, simple, 6); /* copy "SIMPLE" to buffer */ break; } } else ii = 0; /* reset search to beginning of the string */ } if (ii != 6) { ffpmsg("Couldn't find the string 'SIMPLE' in the stdin stream"); return(FILE_NOT_OPENED); } /* fill up the remainder of the buffer */ nread = fread(recbuf + 6, 1, RECBUFLEN - 6, stdin); nread += 6; /* add in the 6 characters in 'SIMPLE' */ status = file_write(handle, recbuf, nread); if (status) return(status); /* copy the rest of stdin stream */ while(0 != (nread = fread(recbuf,1,RECBUFLEN, stdin))) { status = file_write(handle, recbuf, nread); if (status) return(status); } return(status); } /*--------------------------------------------------------------------------*/ int stdout_close(int handle) /* copy the memory file to stdout, then free the memory */ { int status = 0; /* copy from memory to standard out. explicit LONGLONG->size_t cast */ if(fwrite(memTable[handle].memaddr, 1, ((size_t) memTable[handle].fitsfilesize), stdout) != (size_t) memTable[handle].fitsfilesize ) { ffpmsg("failed to copy memory file to stdout (stdout_close)"); status = WRITE_ERROR; } free( memTable[handle].memaddr ); /* free the memory */ memTable[handle].memaddrptr = 0; memTable[handle].memaddr = 0; return(status); } /*--------------------------------------------------------------------------*/ int mem_compress_openrw(char *filename, int rwmode, int *hdl) /* This routine opens the compressed diskfile and creates an empty memory buffer with an appropriate size, then calls mem_uncompress2mem. It allows the memory 'file' to be opened with READWRITE access. */ { return(mem_compress_open(filename, READONLY, hdl)); } /*--------------------------------------------------------------------------*/ int mem_compress_open(char *filename, int rwmode, int *hdl) /* This routine opens the compressed diskfile and creates an empty memory buffer with an appropriate size, then calls mem_uncompress2mem. */ { FILE *diskfile; int status, estimated = 1; unsigned char buffer[4]; size_t finalsize, filesize; LONGLONG llsize = 0; unsigned int modulosize; char *ptr; if (rwmode != READONLY) { ffpmsg( "cannot open compressed file with WRITE access (mem_compress_open)"); ffpmsg(filename); return(READONLY_FILE); } /* open the compressed disk file */ status = file_openfile(filename, READONLY, &diskfile); if (status) { ffpmsg("failed to open compressed disk file (compress_open)"); ffpmsg(filename); return(status); } if (fread(buffer, 1, 2, diskfile) != 2) /* read 2 bytes */ { fclose(diskfile); return(READ_ERROR); } if (memcmp(buffer, "\037\213", 2) == 0) /* GZIP */ { /* the uncompressed file size is give at the end */ /* of the file in the ISIZE field (modulo 2^32) */ fseek(diskfile, 0, 2); /* move to end of file */ filesize = ftell(diskfile); /* position = size of file */ fseek(diskfile, -4L, 1); /* move back 4 bytes */ fread(buffer, 1, 4L, diskfile); /* read 4 bytes */ /* have to worry about integer byte order */ modulosize = buffer[0]; modulosize |= buffer[1] << 8; modulosize |= buffer[2] << 16; modulosize |= buffer[3] << 24; /* the field ISIZE in the gzipped file header only stores 4 bytes and contains the uncompressed file size modulo 2^32. If the uncompressed file size is less than the compressed file size (filesize), then one probably needs to add 2^32 = 4294967296 to the uncompressed file size, assuming that the gzip produces a compressed file that is smaller than the original file. But one must allow for the case of very small files, where the gzipped file may actually be larger then the original uncompressed file. Therefore, only perform the modulo 2^32 correction test if the compressed file is greater than 10,000 bytes in size. (Note: this threhold would fail only if the original file was greater than 2^32 bytes in size AND gzip was able to compress it by more than a factor of 400,000 (!) which seems highly unlikely.) Also, obviously, this 2^32 modulo correction cannot be performed if the finalsize variable is only 32-bits long. Typically, the 'size_t' integer type must be 8 bytes or larger in size to support data files that are greater than 2 GB (2^31 bytes) in size. */ finalsize = modulosize; if (sizeof(size_t) > 4 && filesize > 10000) { llsize = (LONGLONG) finalsize; /* use LONGLONG variable to suppress compiler warning */ while (llsize < (LONGLONG) filesize) llsize += 4294967296; finalsize = (size_t) llsize; } estimated = 0; /* file size is known, not estimated */ } else if (memcmp(buffer, "\120\113", 2) == 0) /* PKZIP */ { /* the uncompressed file size is give at byte 22 the file */ fseek(diskfile, 22L, 0); /* move to byte 22 */ fread(buffer, 1, 4L, diskfile); /* read 4 bytes */ /* have to worry about integer byte order */ modulosize = buffer[0]; modulosize |= buffer[1] << 8; modulosize |= buffer[2] << 16; modulosize |= buffer[3] << 24; finalsize = modulosize; estimated = 0; /* file size is known, not estimated */ } else if (memcmp(buffer, "\037\036", 2) == 0) /* PACK */ finalsize = 0; /* for most methods we can't determine final size */ else if (memcmp(buffer, "\037\235", 2) == 0) /* LZW */ finalsize = 0; /* for most methods we can't determine final size */ else if (memcmp(buffer, "\037\240", 2) == 0) /* LZH */ finalsize = 0; /* for most methods we can't determine final size */ else { /* not a compressed file; this should never happen */ fclose(diskfile); return(1); } if (finalsize == 0) /* estimate uncompressed file size */ { fseek(diskfile, 0, 2); /* move to end of the compressed file */ finalsize = ftell(diskfile); /* position = size of file */ finalsize = finalsize * 3; /* assume factor of 3 compression */ } fseek(diskfile, 0, 0); /* move back to beginning of file */ /* create a memory file big enough (hopefully) for the uncompressed file */ status = mem_createmem(finalsize, hdl); if (status && estimated) { /* memory allocation failed, so try a smaller estimated size */ finalsize = finalsize / 3; status = mem_createmem(finalsize, hdl); } if (status) { fclose(diskfile); ffpmsg("failed to create empty memory file (compress_open)"); return(status); } /* uncompress file into memory */ status = mem_uncompress2mem(filename, diskfile, *hdl); fclose(diskfile); if (status) { mem_close_free(*hdl); /* free up the memory */ ffpmsg("failed to uncompress file into memory (compress_open)"); return(status); } /* if we allocated too much memory initially, then free it */ if (*(memTable[*hdl].memsizeptr) > (( (size_t) memTable[*hdl].fitsfilesize) + 256L) ) { ptr = realloc(*(memTable[*hdl].memaddrptr), ((size_t) memTable[*hdl].fitsfilesize) ); if (!ptr) { ffpmsg("Failed to reduce size of allocated memory (compress_open)"); return(MEMORY_ALLOCATION); } *(memTable[*hdl].memaddrptr) = ptr; *(memTable[*hdl].memsizeptr) = (size_t) (memTable[*hdl].fitsfilesize); } return(0); } /*--------------------------------------------------------------------------*/ int mem_compress_stdin_open(char *filename, int rwmode, int *hdl) /* This routine reads the compressed input stream and creates an empty memory buffer, then calls mem_uncompress2mem. */ { int status; char *ptr; if (rwmode != READONLY) { ffpmsg( "cannot open compressed input stream with WRITE access (mem_compress_stdin_open)"); return(READONLY_FILE); } /* create a memory file for the uncompressed file */ status = mem_createmem(28800, hdl); if (status) { ffpmsg("failed to create empty memory file (compress_stdin_open)"); return(status); } /* uncompress file into memory */ status = mem_uncompress2mem(filename, stdin, *hdl); if (status) { mem_close_free(*hdl); /* free up the memory */ ffpmsg("failed to uncompress stdin into memory (compress_stdin_open)"); return(status); } /* if we allocated too much memory initially, then free it */ if (*(memTable[*hdl].memsizeptr) > (( (size_t) memTable[*hdl].fitsfilesize) + 256L) ) { ptr = realloc(*(memTable[*hdl].memaddrptr), ((size_t) memTable[*hdl].fitsfilesize) ); if (!ptr) { ffpmsg("Failed to reduce size of allocated memory (compress_stdin_open)"); return(MEMORY_ALLOCATION); } *(memTable[*hdl].memaddrptr) = ptr; *(memTable[*hdl].memsizeptr) = (size_t) (memTable[*hdl].fitsfilesize); } return(0); } /*--------------------------------------------------------------------------*/ int mem_iraf_open(char *filename, int rwmode, int *hdl) /* This routine creates an empty memory buffer, then calls iraf2mem to open the IRAF disk file and convert it to a FITS file in memeory. */ { int status; size_t filesize = 0; /* create a memory file with size = 0 for the FITS converted IRAF file */ status = mem_createmem(filesize, hdl); if (status) { ffpmsg("failed to create empty memory file (mem_iraf_open)"); return(status); } /* convert the iraf file into a FITS file in memory */ status = iraf2mem(filename, memTable[*hdl].memaddrptr, memTable[*hdl].memsizeptr, &filesize, &status); if (status) { mem_close_free(*hdl); /* free up the memory */ ffpmsg("failed to convert IRAF file into memory (mem_iraf_open)"); return(status); } memTable[*hdl].currentpos = 0; /* save starting position */ memTable[*hdl].fitsfilesize=filesize; /* and initial file size */ return(0); } /*--------------------------------------------------------------------------*/ int mem_rawfile_open(char *filename, int rwmode, int *hdl) /* This routine creates an empty memory buffer, writes a minimal image header, then copies the image data from the raw file into memory. It will byteswap the pixel values if the raw array is in little endian byte order. */ { FILE *diskfile; fitsfile *fptr; short *sptr; int status, endian, datatype, bytePerPix, naxis; long dim[5] = {1,1,1,1,1}, ii, nvals, offset = 0; size_t filesize = 0, datasize; char rootfile[FLEN_FILENAME], *cptr = 0, *cptr2 = 0; void *ptr; if (rwmode != READONLY) { ffpmsg( "cannot open raw binary file with WRITE access (mem_rawfile_open)"); ffpmsg(filename); return(READONLY_FILE); } cptr = strchr(filename, '['); /* search for opening bracket [ */ if (!cptr) { ffpmsg("binary file name missing '[' character (mem_rawfile_open)"); ffpmsg(filename); return(URL_PARSE_ERROR); } *rootfile = '\0'; strncat(rootfile, filename, cptr - filename); /* store the rootname */ cptr++; while (*cptr == ' ') cptr++; /* skip leading blanks */ /* Get the Data Type of the Image */ if (*cptr == 'b' || *cptr == 'B') { datatype = BYTE_IMG; bytePerPix = 1; } else if (*cptr == 'i' || *cptr == 'I') { datatype = SHORT_IMG; bytePerPix = 2; } else if (*cptr == 'u' || *cptr == 'U') { datatype = USHORT_IMG; bytePerPix = 2; } else if (*cptr == 'j' || *cptr == 'J') { datatype = LONG_IMG; bytePerPix = 4; } else if (*cptr == 'r' || *cptr == 'R' || *cptr == 'f' || *cptr == 'F') { datatype = FLOAT_IMG; bytePerPix = 4; } else if (*cptr == 'd' || *cptr == 'D') { datatype = DOUBLE_IMG; bytePerPix = 8; } else { ffpmsg("error in raw binary file datatype (mem_rawfile_open)"); ffpmsg(filename); return(URL_PARSE_ERROR); } cptr++; /* get Endian: Big or Little; default is same as the local machine */ if (*cptr == 'b' || *cptr == 'B') { endian = 0; cptr++; } else if (*cptr == 'l' || *cptr == 'L') { endian = 1; cptr++; } else endian = BYTESWAPPED; /* byteswapped machines are little endian */ /* read each dimension (up to 5) */ naxis = 1; dim[0] = strtol(cptr, &cptr2, 10); if (cptr2 && *cptr2 == ',') { naxis = 2; dim[1] = strtol(cptr2+1, &cptr, 10); if (cptr && *cptr == ',') { naxis = 3; dim[2] = strtol(cptr+1, &cptr2, 10); if (cptr2 && *cptr2 == ',') { naxis = 4; dim[3] = strtol(cptr2+1, &cptr, 10); if (cptr && *cptr == ',') naxis = 5; dim[4] = strtol(cptr+1, &cptr2, 10); } } } cptr = maxvalue(cptr, cptr2); if (*cptr == ':') /* read starting offset value */ offset = strtol(cptr+1, 0, 10); nvals = dim[0] * dim[1] * dim[2] * dim[3] * dim[4]; datasize = nvals * bytePerPix; filesize = nvals * bytePerPix + 2880; filesize = ((filesize - 1) / 2880 + 1) * 2880; /* open the raw binary disk file */ status = file_openfile(rootfile, READONLY, &diskfile); if (status) { ffpmsg("failed to open raw binary file (mem_rawfile_open)"); ffpmsg(rootfile); return(status); } /* create a memory file with corrct size for the FITS converted raw file */ status = mem_createmem(filesize, hdl); if (status) { ffpmsg("failed to create memory file (mem_rawfile_open)"); fclose(diskfile); return(status); } /* open this piece of memory as a new FITS file */ ffimem(&fptr, (void **) memTable[*hdl].memaddrptr, &filesize, 0, 0, &status); /* write the required header keywords */ ffcrim(fptr, datatype, naxis, dim, &status); /* close the FITS file, but keep the memory allocated */ ffclos(fptr, &status); if (status > 0) { ffpmsg("failed to write basic image header (mem_rawfile_open)"); fclose(diskfile); mem_close_free(*hdl); /* free up the memory */ return(status); } if (offset > 0) fseek(diskfile, offset, 0); /* offset to start of the data */ /* read the raw data into memory */ ptr = *memTable[*hdl].memaddrptr + 2880; if (fread((char *) ptr, 1, datasize, diskfile) != datasize) status = READ_ERROR; fclose(diskfile); /* close the raw binary disk file */ if (status) { mem_close_free(*hdl); /* free up the memory */ ffpmsg("failed to copy raw file data into memory (mem_rawfile_open)"); return(status); } if (datatype == USHORT_IMG) /* have to subtract 32768 from each unsigned */ { /* value to conform to FITS convention. More */ /* efficient way to do this is to just flip */ /* the most significant bit. */ sptr = (short *) ptr; if (endian == BYTESWAPPED) /* working with native format */ { for (ii = 0; ii < nvals; ii++, sptr++) { *sptr = ( *sptr ) ^ 0x8000; } } else /* pixels are byteswapped WRT the native format */ { for (ii = 0; ii < nvals; ii++, sptr++) { *sptr = ( *sptr ) ^ 0x80; } } } if (endian) /* swap the bytes if array is in little endian byte order */ { if (datatype == SHORT_IMG || datatype == USHORT_IMG) { ffswap2( (short *) ptr, nvals); } else if (datatype == LONG_IMG || datatype == FLOAT_IMG) { ffswap4( (INT32BIT *) ptr, nvals); } else if (datatype == DOUBLE_IMG) { ffswap8( (double *) ptr, nvals); } } memTable[*hdl].currentpos = 0; /* save starting position */ memTable[*hdl].fitsfilesize=filesize; /* and initial file size */ return(0); } /*--------------------------------------------------------------------------*/ int mem_uncompress2mem(char *filename, FILE *diskfile, int hdl) { /* lower level routine to uncompress a file into memory. The file has already been opened and the memory buffer has been allocated. */ size_t finalsize; int status; /* uncompress file into memory */ status = 0; if (strstr(filename, ".Z")) { zuncompress2mem(filename, diskfile, memTable[hdl].memaddrptr, /* pointer to memory address */ memTable[hdl].memsizeptr, /* pointer to size of memory */ realloc, /* reallocation function */ &finalsize, &status); /* returned file size nd status*/ } else { uncompress2mem(filename, diskfile, memTable[hdl].memaddrptr, /* pointer to memory address */ memTable[hdl].memsizeptr, /* pointer to size of memory */ realloc, /* reallocation function */ &finalsize, &status); /* returned file size nd status*/ } memTable[hdl].currentpos = 0; /* save starting position */ memTable[hdl].fitsfilesize=finalsize; /* and initial file size */ return status; } /*--------------------------------------------------------------------------*/ int mem_size(int handle, LONGLONG *filesize) /* return the size of the file; only called when the file is first opened */ { *filesize = memTable[handle].fitsfilesize; return(0); } /*--------------------------------------------------------------------------*/ int mem_close_free(int handle) /* close the file and free the memory. */ { free( *(memTable[handle].memaddrptr) ); memTable[handle].memaddrptr = 0; memTable[handle].memaddr = 0; return(0); } /*--------------------------------------------------------------------------*/ int mem_close_keep(int handle) /* close the memory file but do not free the memory. */ { memTable[handle].memaddrptr = 0; memTable[handle].memaddr = 0; return(0); } /*--------------------------------------------------------------------------*/ int mem_close_comp(int handle) /* compress the memory file, writing it out to the fileptr (which might be stdout) */ { int status = 0; size_t compsize; /* compress file in memory to a .gz disk file */ if(compress2file_from_mem(memTable[handle].memaddr, (size_t) (memTable[handle].fitsfilesize), memTable[handle].fileptr, &compsize, &status ) ) { ffpmsg("failed to copy memory file to file (mem_close_comp)"); status = WRITE_ERROR; } free( memTable[handle].memaddr ); /* free the memory */ memTable[handle].memaddrptr = 0; memTable[handle].memaddr = 0; /* close the compressed disk file (except if it is 'stdout' */ if (memTable[handle].fileptr != stdout) fclose(memTable[handle].fileptr); return(status); } /*--------------------------------------------------------------------------*/ int mem_seek(int handle, LONGLONG offset) /* seek to position relative to start of the file. */ { if (offset > memTable[handle].fitsfilesize ) return(END_OF_FILE); memTable[handle].currentpos = offset; return(0); } /*--------------------------------------------------------------------------*/ int mem_read(int hdl, void *buffer, long nbytes) /* read bytes from the current position in the file */ { if (memTable[hdl].currentpos + nbytes > memTable[hdl].fitsfilesize) return(END_OF_FILE); memcpy(buffer, *(memTable[hdl].memaddrptr) + memTable[hdl].currentpos, nbytes); memTable[hdl].currentpos += nbytes; return(0); } /*--------------------------------------------------------------------------*/ int mem_write(int hdl, void *buffer, long nbytes) /* write bytes at the current position in the file */ { size_t newsize; char *ptr; if ((size_t) (memTable[hdl].currentpos + nbytes) > *(memTable[hdl].memsizeptr) ) { if (!(memTable[hdl].mem_realloc)) { ffpmsg("realloc function not defined (mem_write)"); return(WRITE_ERROR); } /* Attempt to reallocate additional memory: the memory buffer size is incremented by the larger of: 1 FITS block (2880 bytes) or the defined 'deltasize' parameter */ newsize = maxvalue( (size_t) (((memTable[hdl].currentpos + nbytes - 1) / 2880) + 1) * 2880, *(memTable[hdl].memsizeptr) + memTable[hdl].deltasize); /* call the realloc function */ ptr = (memTable[hdl].mem_realloc)( *(memTable[hdl].memaddrptr), newsize); if (!ptr) { ffpmsg("Failed to reallocate memory (mem_write)"); return(MEMORY_ALLOCATION); } *(memTable[hdl].memaddrptr) = ptr; *(memTable[hdl].memsizeptr) = newsize; } /* now copy the bytes from the buffer into memory */ memcpy( *(memTable[hdl].memaddrptr) + memTable[hdl].currentpos, buffer, nbytes); memTable[hdl].currentpos += nbytes; memTable[hdl].fitsfilesize = maxvalue(memTable[hdl].fitsfilesize, memTable[hdl].currentpos); return(0); } healpy-1.10.3/cfitsio/drvrnet.c0000664000175000017500000021322713010375004016616 0ustar zoncazonca00000000000000/* This file, drvrhttp.c contains driver routines for http, ftp and root files. */ /* This file was written by Bruce O'Neel at the ISDC, Switzerland */ /* The FITSIO software is maintained by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ /* Notes on the drivers: The ftp driver uses passive mode exclusivly. If your remote system can't deal with passive mode then it'll fail. Since Netscape Navigator uses passive mode as well there shouldn't be too many ftp servers which have problems. The http driver works properly with 301 and 302 redirects. For many more gory details see http://www.w3c.org/Protocols/rfc2068/rfc2068. The only catch to the 301/302 redirects is that they have to redirect to another http:// url. If not, things would have to change a lot in cfitsio and this was thought to be too difficult. Redirects look like 301 Moved Permanently

Moved Permanently

The document has moved here.

This redirect was from apache 1.2.5 but most of the other servers produce something very similiar. The parser for the redirects finds the first anchor tag in the body and goes there. If that wasn't what was intended by the remote system then hopefully the error stack, which includes notes about the redirect will help the user fix the problem. Root protocal doesn't have any real docs, so, the emperical docs are as follows. First, you must use a slightly modified rootd server. The modifications include implimentation of the stat command which returns the size of the remote file. Without that it's impossible for cfitsio to work properly since fitsfiles don't include any information about the size of the files in the headers. The rootd server closes the connections on any errors, including reading beyond the end of the file or seeking beyond the end of the file. The rootd:// driver doesn't reopen a closed connection, if the connection is closed you're pretty much done. The messages are of the form All binary information is transfered in network format, so use htonl and ntohl to convert back and forth. :== 4 byte length, in network format, the len doesn't include the length of :== one of the message opcodes below, 4 bytes, network format :== depends on opcode The response is of the same form with the same opcode sent. Success is indicated by being 0. Root is a NFSish protocol where each read/write includes the byte offset to read or write to. As a result, seeks will always succeed in the driver even if they would cause a fatal error when you try to read because you're beyond the end of the file. There is file locking on the host such that you need to possibly create /usr/tmp/rootdtab on the host system. There is one file per socket connection, though the rootd daemon can support multiple files open at once. The messages are sent in the following order: ROOTD_USER - user name, is the user name, trailing null is sent though it's not required it seems. A ROOTD_AUTH message is returned with any sort of error meaning that the user name is wrong. ROOTD_PASS - password, ones complemented, stored in . Once again the trailing null is sent. Once again a ROOTD_AUTH message is returned ROOTD_OPEN - includes filename and one of {create|update|read} as the file mode. ~ seems to be dealt with as the username's login directory. A ROOTD_OPEN message is returned. Once the file is opened any of the following can be sent: ROOTD_STAT - file status and size returns a message where is the file length in bytes ROOTD_FLUSH - flushes the file, not sure this has any real effect on the daemon since the daemon uses open/read/write/close rather than the buffered fopen/fread/fwrite/fclose. ROOTD_GET - on send includes a text message of offset and length to get. Return is a status message first with a status value, then, the raw bytes for the length that you requested. It's an error to seek or read past the end of the file, and, the rootd daemon exits and won't respond anymore. Ie, don't do this. ROOTD_PUT - on send includes a text message of offset and length to put. Then send the raw bytes you want to write. Then recieve a status message When you are finished then you send the message: ROOTD_CLOSE - closes the file Once the file is closed then the socket is closed. Revision 1.56 2000/01/04 11:58:31 oneel Updates so that compressed network files are dealt with regardless of their file names and/or mime types. Revision 1.55 2000/01/04 10:52:40 oneel cfitsio 2.034 Revision 1.51 1999/08/10 12:13:40 oneel Make the http code a bit less picky about the types of files it uncompresses. Now it also uncompresses files which end in .Z or .gz. Revision 1.50 1999/08/04 12:38:46 oneel Don's 2.0.32 patch with dal 1.3 Revision 1.39 1998/12/02 15:31:33 oneel Updates to drvrnet.c so that less compiler warnings would be generated. Fixes the signal handling. Revision 1.38 1998/11/23 10:03:24 oneel Added in a useragent string, as suggested by: Tim Kimball Data Systems Division kimball@stsci.edu 410-338-4417 Space Telescope Science Institute http://www.stsci.edu/~kimball/ 3700 San Martin Drive http://archive.stsci.edu/ Baltimore MD 21218 USA http://faxafloi.stsci.edu:4547/ */ #ifdef HAVE_NET_SERVICES #include #include #include #include #include #include #include #include #include #include #include #if defined(unix) || defined(__unix__) || defined(__unix) #include #endif #include #include #include "fitsio2.h" static jmp_buf env; /* holds the jump buffer for setjmp/longjmp pairs */ static void signal_handler(int sig); /* Network routine error codes */ #define NET_OK 0 #define NOT_INET_ADDRESS -1000 #define UNKNOWN_INET_HOST -1001 #define CONNECTION_ERROR -1002 /* Network routine constants */ #define NET_DEFAULT 0 #define NET_OOB 1 #define NET_PEEK 2 #define NETTIMEOUT 180 /* in secs */ /* local defines and variables */ #define MAXLEN 1200 #define SHORTLEN 100 static char netoutfile[MAXLEN]; #define ROOTD_USER 2000 /*user id follows */ #define ROOTD_PASS 2001 /*passwd follows */ #define ROOTD_AUTH 2002 /*authorization status (to client) */ #define ROOTD_FSTAT 2003 /*filename follows */ #define ROOTD_OPEN 2004 /*filename follows + mode */ #define ROOTD_PUT 2005 /*offset, number of bytes and buffer */ #define ROOTD_GET 2006 /*offset, number of bytes */ #define ROOTD_FLUSH 2007 /*flush file */ #define ROOTD_CLOSE 2008 /*close file */ #define ROOTD_STAT 2009 /*return rootd statistics */ #define ROOTD_ACK 2010 /*acknowledgement (all OK) */ #define ROOTD_ERR 2011 /*error code and message follow */ typedef struct /* structure containing disk file structure */ { int sock; LONGLONG currentpos; } rootdriver; static rootdriver handleTable[NMAXFILES]; /* allocate diskfile handle tables */ /* static prototypes */ static int NET_TcpConnect(char *hostname, int port); static int NET_SendRaw(int sock, const void *buf, int length, int opt); static int NET_RecvRaw(int sock, void *buffer, int length); static int NET_ParseUrl(const char *url, char *proto, char *host, int *port, char *fn); static int CreateSocketAddress(struct sockaddr_in *sockaddrPtr, char *host,int port); static int ftp_status(FILE *ftp, char *statusstr); static int http_open_network(char *url, FILE **httpfile, char *contentencoding, int *contentlength); static int ftp_open_network(char *url, FILE **ftpfile, FILE **command, int *sock); static int root_send_buffer(int sock, int op, char *buffer, int buflen); static int root_recv_buffer(int sock, int *op, char *buffer,int buflen); static int root_openfile(char *filename, char *rwmode, int *sock); static int encode64(unsigned s_len, char *src, unsigned d_len, char *dst); /***************************/ /* Static variables */ static int closehttpfile; static int closememfile; static int closefdiskfile; static int closediskfile; static int closefile; static int closeoutfile; static int closecommandfile; static int closeftpfile; static FILE *diskfile; static FILE *outfile; /*--------------------------------------------------------------------------*/ /* This creates a memory file handle with a copy of the URL in filename. The file is uncompressed if necessary */ int http_open(char *filename, int rwmode, int *handle) { FILE *httpfile; char contentencoding[SHORTLEN]; char newfilename[MAXLEN]; char errorstr[MAXLEN]; char recbuf[MAXLEN]; long len; int contentlength; int status; char firstchar; closehttpfile = 0; closememfile = 0; /* don't do r/w files */ if (rwmode != 0) { ffpmsg("Can't open http:// type file with READWRITE access"); ffpmsg(" Specify an outfile for r/w access (http_open)"); goto error; } /* do the signal handler bits */ if (setjmp(env) != 0) { /* feels like the second time */ /* this means something bad happened */ ffpmsg("Timeout (http_open)"); goto error; } (void) signal(SIGALRM, signal_handler); /* Open the network connection */ /* Does the file have a .Z or .gz in it */ /* Also, if file has a '?' in it (probably cgi script) */ if (strstr(filename,".Z") || strstr(filename,".gz") || strstr(filename,"?")) { alarm(NETTIMEOUT); if (http_open_network(filename,&httpfile,contentencoding, &contentlength)) { alarm(0); ffpmsg("Unable to open http file (http_open):"); ffpmsg(filename); goto error; } } else { if (strlen(filename) >= MAXLEN - 4) { ffpmsg("http file name is too long (http_open)"); ffpmsg(filename); goto error; } alarm(NETTIMEOUT); /* Try the .gz one */ strcpy(newfilename,filename); strcat(newfilename,".gz"); if (http_open_network(newfilename,&httpfile,contentencoding, &contentlength)) { alarm(0); /* Now the .Z one */ strcpy(newfilename,filename); strcat(newfilename,".Z"); alarm(NETTIMEOUT); if (http_open_network(newfilename,&httpfile,contentencoding, &contentlength)) { alarm(0); alarm(NETTIMEOUT); if (http_open_network(filename,&httpfile,contentencoding, &contentlength)) { alarm(0); ffpmsg("Unable to open http file (http_open)"); ffpmsg(filename); goto error; } } } } closehttpfile++; /* Create the memory file */ if ((status = mem_create(filename,handle))) { ffpmsg("Unable to create memory file (http_open)"); goto error; } closememfile++; /* Now, what do we do with the file */ /* Check to see what the first character is */ firstchar = fgetc(httpfile); ungetc(firstchar,httpfile); if (!strcmp(contentencoding,"x-gzip") || !strcmp(contentencoding,"x-compress") || strstr(filename,".gz") || strstr(filename,".Z") || ('\037' == firstchar)) { /* do the compress dance, which is the same as the gzip dance */ /* Using the cfitsio routine */ status = 0; /* Ok, this is a tough case, let's be arbritary and say 10*NETTIMEOUT, Given the choices for nettimeout above they'll probaby ^C before, but it's always worth a shot*/ alarm(NETTIMEOUT*10); status = mem_uncompress2mem(filename, httpfile, *handle); alarm(0); if (status) { ffpmsg("Error writing compressed memory file (http_open)"); ffpmsg(filename); goto error; } } else { /* It's not compressed, bad choice, but we'll copy it anyway */ if (contentlength % 2880) { sprintf(errorstr,"Content-Length not a multiple of 2880 (http_open) %d", contentlength); ffpmsg(errorstr); } /* write a memory file */ alarm(NETTIMEOUT); while(0 != (len = fread(recbuf,1,MAXLEN,httpfile))) { alarm(0); /* cancel alarm */ status = mem_write(*handle,recbuf,len); if (status) { ffpmsg("Error copying http file into memory (http_open)"); ffpmsg(filename); goto error; } alarm(NETTIMEOUT); /* rearm the alarm */ } } fclose(httpfile); signal(SIGALRM, SIG_DFL); alarm(0); return mem_seek(*handle,0); error: alarm(0); /* clear it */ if (closehttpfile) { fclose(httpfile); } if (closememfile) { mem_close_free(*handle); } signal(SIGALRM, SIG_DFL); return (FILE_NOT_OPENED); } /*--------------------------------------------------------------------------*/ /* This creates a memory file handle with a copy of the URL in filename. The file must be compressed and is copied (still compressed) to disk first. The compressed disk file is then uncompressed into memory (READONLY). */ int http_compress_open(char *url, int rwmode, int *handle) { FILE *httpfile; char contentencoding[SHORTLEN]; char recbuf[MAXLEN]; long len; int contentlength; int ii, flen, status; char firstchar; closehttpfile = 0; closediskfile = 0; closefdiskfile = 0; closememfile = 0; /* cfileio made a mistake, should set the netoufile first otherwise we don't know where to write the output file */ flen = strlen(netoutfile); if (!flen) { ffpmsg ("Output file not set, shouldn't have happened (http_compress_open)"); goto error; } if (rwmode != 0) { ffpmsg("Can't open compressed http:// type file with READWRITE access"); ffpmsg(" Specify an UNCOMPRESSED outfile (http_compress_open)"); goto error; } /* do the signal handler bits */ if (setjmp(env) != 0) { /* feels like the second time */ /* this means something bad happened */ ffpmsg("Timeout (http_open)"); goto error; } signal(SIGALRM, signal_handler); /* Open the http connectin */ alarm(NETTIMEOUT); if ((status = http_open_network(url,&httpfile,contentencoding, &contentlength))) { alarm(0); ffpmsg("Unable to open http file (http_compress_open)"); ffpmsg(url); goto error; } closehttpfile++; /* Better be compressed */ firstchar = fgetc(httpfile); ungetc(firstchar,httpfile); if (!strcmp(contentencoding,"x-gzip") || !strcmp(contentencoding,"x-compress") || ('\037' == firstchar)) { if (*netoutfile == '!') { /* user wants to clobber file, if it already exists */ for (ii = 0; ii < flen; ii++) netoutfile[ii] = netoutfile[ii + 1]; /* remove '!' */ status = file_remove(netoutfile); } /* Create the new file */ if ((status = file_create(netoutfile,handle))) { ffpmsg("Unable to create output disk file (http_compress_open):"); ffpmsg(netoutfile); goto error; } closediskfile++; /* write a file */ alarm(NETTIMEOUT); while(0 != (len = fread(recbuf,1,MAXLEN,httpfile))) { alarm(0); status = file_write(*handle,recbuf,len); if (status) { ffpmsg("Error writing disk file (http_compres_open)"); ffpmsg(netoutfile); goto error; } alarm(NETTIMEOUT); } file_close(*handle); fclose(httpfile); closehttpfile--; closediskfile--; /* File is on disk, let's uncompress it into memory */ if (NULL == (diskfile = fopen(netoutfile,"r"))) { ffpmsg("Unable to reopen disk file (http_compress_open)"); ffpmsg(netoutfile); goto error; } closefdiskfile++; /* Create the memory handle to hold it */ if ((status = mem_create(url,handle))) { ffpmsg("Unable to create memory file (http_compress_open)"); goto error; } closememfile++; /* Uncompress it */ status = 0; status = mem_uncompress2mem(url,diskfile,*handle); fclose(diskfile); closefdiskfile--; if (status) { ffpmsg("Error uncompressing disk file to memory (http_compress_open)"); ffpmsg(netoutfile); goto error; } } else { /* Opps, this should not have happened */ ffpmsg("Can only have compressed files here (http_compress_open)"); goto error; } signal(SIGALRM, SIG_DFL); alarm(0); return mem_seek(*handle,0); error: alarm(0); /* clear it */ if (closehttpfile) { fclose(httpfile); } if (closefdiskfile) { fclose(diskfile); } if (closememfile) { mem_close_free(*handle); } if (closediskfile) { file_close(*handle); } signal(SIGALRM, SIG_DFL); return (FILE_NOT_OPENED); } /*--------------------------------------------------------------------------*/ /* This creates a file handle with a copy of the URL in filename. The http file is copied to disk first. If it's compressed then it is uncompressed when copying to the disk */ int http_file_open(char *url, int rwmode, int *handle) { FILE *httpfile; char contentencoding[SHORTLEN]; char errorstr[MAXLEN]; char recbuf[MAXLEN]; long len; int contentlength; int ii, flen, status; char firstchar; /* Check if output file is actually a memory file */ if (!strncmp(netoutfile, "mem:", 4) ) { /* allow the memory file to be opened with write access */ return( http_open(url, READONLY, handle) ); } closehttpfile = 0; closefile = 0; closeoutfile = 0; /* cfileio made a mistake, we need to know where to write the file */ flen = strlen(netoutfile); if (!flen) { ffpmsg("Output file not set, shouldn't have happened (http_file_open)"); return (FILE_NOT_OPENED); } /* do the signal handler bits */ if (setjmp(env) != 0) { /* feels like the second time */ /* this means something bad happened */ ffpmsg("Timeout (http_open)"); goto error; } signal(SIGALRM, signal_handler); /* Open the network connection */ alarm(NETTIMEOUT); if ((status = http_open_network(url,&httpfile,contentencoding, &contentlength))) { alarm(0); ffpmsg("Unable to open http file (http_file_open)"); ffpmsg(url); goto error; } closehttpfile++; if (*netoutfile == '!') { /* user wants to clobber disk file, if it already exists */ for (ii = 0; ii < flen; ii++) netoutfile[ii] = netoutfile[ii + 1]; /* remove '!' */ status = file_remove(netoutfile); } firstchar = fgetc(httpfile); ungetc(firstchar,httpfile); if (!strcmp(contentencoding,"x-gzip") || !strcmp(contentencoding,"x-compress") || ('\037' == firstchar)) { /* to make this more cfitsioish we use the file driver calls to create the disk file */ /* Create the output file */ if ((status = file_create(netoutfile,handle))) { ffpmsg("Unable to create output file (http_file_open)"); ffpmsg(netoutfile); goto error; } file_close(*handle); if (NULL == (outfile = fopen(netoutfile,"w"))) { ffpmsg("Unable to reopen the output file (http_file_open)"); ffpmsg(netoutfile); goto error; } closeoutfile++; status = 0; /* Ok, this is a tough case, let's be arbritary and say 10*NETTIMEOUT, Given the choices for nettimeout above they'll probaby ^C before, but it's always worth a shot*/ alarm(NETTIMEOUT*10); status = uncompress2file(url,httpfile,outfile,&status); alarm(0); if (status) { ffpmsg("Error uncompressing http file to disk file (http_file_open)"); ffpmsg(url); ffpmsg(netoutfile); goto error; } fclose(outfile); closeoutfile--; } else { /* Create the output file */ if ((status = file_create(netoutfile,handle))) { ffpmsg("Unable to create output file (http_file_open)"); ffpmsg(netoutfile); goto error; } /* Give a warning message. This could just be bad padding at the end so don't treat it like an error. */ closefile++; if (contentlength % 2880) { sprintf(errorstr, "Content-Length not a multiple of 2880 (http_file_open) %d", contentlength); ffpmsg(errorstr); } /* write a file */ alarm(NETTIMEOUT); while(0 != (len = fread(recbuf,1,MAXLEN,httpfile))) { alarm(0); status = file_write(*handle,recbuf,len); if (status) { ffpmsg("Error copying http file to disk file (http_file_open)"); ffpmsg(url); ffpmsg(netoutfile); goto error; } } file_close(*handle); closefile--; } fclose(httpfile); closehttpfile--; signal(SIGALRM, SIG_DFL); alarm(0); return file_open(netoutfile,rwmode,handle); error: alarm(0); /* clear it */ if (closehttpfile) { fclose(httpfile); } if (closeoutfile) { fclose(outfile); } if (closefile) { file_close(*handle); } signal(SIGALRM, SIG_DFL); return (FILE_NOT_OPENED); } /*--------------------------------------------------------------------------*/ /* This is the guts of the code to get a file via http. url is the input url httpfile is set to be the file connected to the socket which you can read the file from contentencoding is the mime type of the file, returned if the http server returns it contentlength is the lenght of the file, returned if the http server returns it */ static int http_open_network(char *url, FILE **httpfile, char *contentencoding, int *contentlength) { int status; int sock; int tmpint; char recbuf[MAXLEN]; char tmpstr[MAXLEN]; char tmpstr1[SHORTLEN]; char tmpstr2[MAXLEN]; char errorstr[MAXLEN]; char proto[SHORTLEN]; char host[SHORTLEN]; char userpass[MAXLEN]; char fn[MAXLEN]; char turl[MAXLEN]; char *scratchstr; int port; float version; char pproto[SHORTLEN]; char phost[SHORTLEN]; /* address of the proxy server */ int pport; /* port number of the proxy server */ char pfn[MAXLEN]; char *proxy; /* URL of the proxy server */ /* Parse the URL apart again */ strcpy(turl,"http://"); strncat(turl,url,MAXLEN - 8); if (NET_ParseUrl(turl,proto,host,&port,fn)) { sprintf(errorstr,"URL Parse Error (http_open) %s",url); ffpmsg(errorstr); return (FILE_NOT_OPENED); } /* Do we have a user:password combo ? */ strcpy(userpass, url); if ((scratchstr = strchr(userpass, '@')) != NULL) { *scratchstr = '\0'; } else strcpy(userpass, ""); /* Ph. Prugniel 2003/04/03 Are we using a proxy? We use a proxy if the environment variable "http_proxy" is set to an address, eg. http://wwwcache.nottingham.ac.uk:3128 ("http_proxy" is also used by wget) */ proxy = getenv("http_proxy"); /* Connect to the remote host */ if (proxy) { if (NET_ParseUrl(proxy,pproto,phost,&pport,pfn)) { sprintf(errorstr,"URL Parse Error (http_open) %s",proxy); ffpmsg(errorstr); return (FILE_NOT_OPENED); } sock = NET_TcpConnect(phost,pport); } else sock = NET_TcpConnect(host,port); if (sock < 0) { if (proxy) { ffpmsg("Couldn't connect to host via proxy server (http_open_network)"); ffpmsg(proxy); } return (FILE_NOT_OPENED); } /* Make the socket a stdio file */ if (NULL == (*httpfile = fdopen(sock,"r"))) { ffpmsg ("fdopen failed to convert socket to file (http_open_network)"); close(sock); return (FILE_NOT_OPENED); } /* Send the GET request to the remote server */ /* Ph. Prugniel 2003/04/03 One must add the Host: command because of HTTP 1.1 servers (ie. virtual hosts) */ if (proxy) sprintf(tmpstr,"GET http://%s:%-d%s HTTP/1.0\r\n",host,port,fn); else sprintf(tmpstr,"GET %s HTTP/1.0\r\n",fn); if (strcmp(userpass, "")) { encode64(strlen(userpass), userpass, MAXLEN, tmpstr2); sprintf(tmpstr1, "Authorization: Basic %s\r\n", tmpstr2); if (strlen(tmpstr) + strlen(tmpstr1) > MAXLEN - 1) return (FILE_NOT_OPENED); strcat(tmpstr,tmpstr1); } sprintf(tmpstr1,"User-Agent: HEASARC/CFITSIO/%-8.3f\r\n",ffvers(&version)); if (strlen(tmpstr) + strlen(tmpstr1) > MAXLEN - 1) return (FILE_NOT_OPENED); strcat(tmpstr,tmpstr1); /* HTTP 1.1 servers require the following 'Host: ' string */ sprintf(tmpstr1,"Host: %s:%-d\r\n\r\n",host,port); if (strlen(tmpstr) + strlen(tmpstr1) > MAXLEN - 1) return (FILE_NOT_OPENED); strcat(tmpstr,tmpstr1); status = NET_SendRaw(sock,tmpstr,strlen(tmpstr),NET_DEFAULT); /* read the header */ if (!(fgets(recbuf,MAXLEN,*httpfile))) { sprintf (errorstr,"http header short (http_open_network) %s",recbuf); ffpmsg(errorstr); fclose(*httpfile); return (FILE_NOT_OPENED); } *contentlength = 0; contentencoding[0] = '\0'; /* Our choices are 200, ok, 301, temporary redirect, or 302 perm redirect */ sscanf(recbuf,"%s %d",tmpstr,&status); if (status != 200){ if (status == 301 || status == 302) { /* got a redirect */ if (status == 301) { ffpmsg("Note: Web server replied with a temporary redirect from"); } else { ffpmsg("Note: Web server replied with a redirect from"); } ffpmsg(turl); /* now, let's not write the most sophisticated parser here */ while (fgets(recbuf,MAXLEN,*httpfile)) { scratchstr = strstr(recbuf," 3) { recbuf[strlen(recbuf)-1] = '\0'; recbuf[strlen(recbuf)-1] = '\0'; } sscanf(recbuf,"%s %d",tmpstr,&tmpint); /* Did we get a content-length header ? */ if (!strcmp(tmpstr,"Content-Length:")) { *contentlength = tmpint; } /* Did we get the content-encoding header ? */ if (!strcmp(tmpstr,"Content-Encoding:")) { if (NULL != (scratchstr = strstr(recbuf,":"))) { /* Found the : */ scratchstr++; /* skip the : */ scratchstr++; /* skip the extra space */ strcpy(contentencoding,scratchstr); } } } /* we're done, so return */ return 0; } /*--------------------------------------------------------------------------*/ /* This creates a memory file handle with a copy of the URL in filename. The file is uncompressed if necessary */ int ftp_open(char *filename, int rwmode, int *handle) { FILE *ftpfile; FILE *command; int sock; char newfilename[MAXLEN]; char recbuf[MAXLEN]; long len; int status; char firstchar; closememfile = 0; closecommandfile = 0; closeftpfile = 0; /* don't do r/w files */ if (rwmode != 0) { ffpmsg("Can't open ftp:// type file with READWRITE access"); ffpmsg("Specify an outfile for r/w access (ftp_open)"); return (FILE_NOT_OPENED); } /* do the signal handler bits */ if (setjmp(env) != 0) { /* feels like the second time */ /* this means something bad happened */ ffpmsg("Timeout (http_open)"); goto error; } signal(SIGALRM, signal_handler); /* Open the ftp connetion. ftpfile is connected to the file port, command is connected to port 21. sock is the socket on port 21 */ if (strlen(filename) > MAXLEN - 4) { ffpmsg("filename too long (ftp_open)"); ffpmsg(filename); goto error; } alarm(NETTIMEOUT); strcpy(newfilename,filename); /* Does the file have a .Z or .gz in it */ if (strstr(newfilename,".Z") || strstr(newfilename,".gz")) { alarm(NETTIMEOUT); if (ftp_open_network(filename,&ftpfile,&command,&sock)) { alarm(0); ffpmsg("Unable to open ftp file (ftp_open)"); ffpmsg(filename); goto error; } } else { /* Try the .gz one */ strcpy(newfilename,filename); strcat(newfilename,".gz"); alarm(NETTIMEOUT); if (ftp_open_network(newfilename,&ftpfile,&command,&sock)) { alarm(0); strcpy(newfilename,filename); strcat(newfilename,".Z"); alarm(NETTIMEOUT); if (ftp_open_network(newfilename,&ftpfile,&command,&sock)) { /* Now as given */ alarm(0); strcpy(newfilename,filename); alarm(NETTIMEOUT); if (ftp_open_network(newfilename,&ftpfile,&command,&sock)) { alarm(0); ffpmsg("Unable to open ftp file (ftp_open)"); ffpmsg(newfilename); goto error; } } } } closeftpfile++; closecommandfile++; /* create the memory file */ if ((status = mem_create(filename,handle))) { ffpmsg ("Could not create memory file to passive port (ftp_open)"); ffpmsg(filename); goto error; } closememfile++; /* This isn't quite right, it'll fail if the file has .gzabc at the end for instance */ /* Decide if the file is compressed */ firstchar = fgetc(ftpfile); ungetc(firstchar,ftpfile); if (strstr(newfilename,".gz") || strstr(newfilename,".Z") || ('\037' == firstchar)) { status = 0; /* A bit arbritary really, the user will probably hit ^C */ alarm(NETTIMEOUT*10); status = mem_uncompress2mem(filename, ftpfile, *handle); alarm(0); if (status) { ffpmsg("Error writing compressed memory file (ftp_open)"); ffpmsg(filename); goto error; } } else { /* write a memory file */ alarm(NETTIMEOUT); while(0 != (len = fread(recbuf,1,MAXLEN,ftpfile))) { alarm(0); status = mem_write(*handle,recbuf,len); if (status) { ffpmsg("Error writing memory file (http_open)"); ffpmsg(filename); goto error; } alarm(NETTIMEOUT); } } /* close and clean up */ fclose(ftpfile); closeftpfile--; NET_SendRaw(sock,"QUIT\n",5,NET_DEFAULT); fclose(command); closecommandfile--; signal(SIGALRM, SIG_DFL); alarm(0); return mem_seek(*handle,0); error: alarm(0); /* clear it */ if (closecommandfile) { fclose(command); } if (closeftpfile) { fclose(ftpfile); } if (closememfile) { mem_close_free(*handle); } signal(SIGALRM, SIG_DFL); return (FILE_NOT_OPENED); } /*--------------------------------------------------------------------------*/ /* This creates a file handle with a copy of the URL in filename. The file must be uncompressed and is copied to disk first */ int ftp_file_open(char *url, int rwmode, int *handle) { FILE *ftpfile; FILE *command; char recbuf[MAXLEN]; long len; int sock; int ii, flen, status; char firstchar; /* Check if output file is actually a memory file */ if (!strncmp(netoutfile, "mem:", 4) ) { /* allow the memory file to be opened with write access */ return( ftp_open(url, READONLY, handle) ); } closeftpfile = 0; closecommandfile = 0; closefile = 0; closeoutfile = 0; /* cfileio made a mistake, need to know where to write the output file */ flen = strlen(netoutfile); if (!flen) { ffpmsg("Output file not set, shouldn't have happened (ftp_file_open)"); return (FILE_NOT_OPENED); } /* do the signal handler bits */ if (setjmp(env) != 0) { /* feels like the second time */ /* this means something bad happened */ ffpmsg("Timeout (http_open)"); goto error; } signal(SIGALRM, signal_handler); /* open the network connection to url. ftpfile holds the connection to the input file, command holds the connection to port 21, and sock is the socket connected to port 21 */ alarm(NETTIMEOUT); if ((status = ftp_open_network(url,&ftpfile,&command,&sock))) { alarm(0); ffpmsg("Unable to open http file (ftp_file_open)"); ffpmsg(url); goto error; } closeftpfile++; closecommandfile++; if (*netoutfile == '!') { /* user wants to clobber file, if it already exists */ for (ii = 0; ii < flen; ii++) netoutfile[ii] = netoutfile[ii + 1]; /* remove '!' */ status = file_remove(netoutfile); } /* Now, what do we do with the file */ firstchar = fgetc(ftpfile); ungetc(firstchar,ftpfile); if (strstr(url,".gz") || strstr(url,".Z") || ('\037' == firstchar)) { /* to make this more cfitsioish we use the file driver calls to create the file */ /* Create the output file */ if ((status = file_create(netoutfile,handle))) { ffpmsg("Unable to create output file (ftp_file_open)"); ffpmsg(netoutfile); goto error; } file_close(*handle); if (NULL == (outfile = fopen(netoutfile,"w"))) { ffpmsg("Unable to reopen the output file (ftp_file_open)"); ffpmsg(netoutfile); goto error; } closeoutfile++; status = 0; /* Ok, this is a tough case, let's be arbritary and say 10*NETTIMEOUT, Given the choices for nettimeout above they'll probaby ^C before, but it's always worth a shot*/ alarm(NETTIMEOUT*10); status = uncompress2file(url,ftpfile,outfile,&status); alarm(0); if (status) { ffpmsg("Unable to uncompress the output file (ftp_file_open)"); ffpmsg(url); ffpmsg(netoutfile); goto error; } fclose(outfile); closeoutfile--; } else { /* Create the output file */ if ((status = file_create(netoutfile,handle))) { ffpmsg("Unable to create output file (ftp_file_open)"); ffpmsg(netoutfile); goto error; } closefile++; /* write a file */ alarm(NETTIMEOUT); while(0 != (len = fread(recbuf,1,MAXLEN,ftpfile))) { alarm(0); status = file_write(*handle,recbuf,len); if (status) { ffpmsg("Error writing file (ftp_file_open)"); ffpmsg(url); ffpmsg(netoutfile); goto error; } alarm(NETTIMEOUT); } file_close(*handle); } fclose(ftpfile); closeftpfile--; NET_SendRaw(sock,"QUIT\n",5,NET_DEFAULT); fclose(command); closecommandfile--; signal(SIGALRM, SIG_DFL); alarm(0); return file_open(netoutfile,rwmode,handle); error: alarm(0); /* clear it */ if (closeftpfile) { fclose(ftpfile); } if (closecommandfile) { fclose(command); } if (closeoutfile) { fclose(outfile); } if (closefile) { file_close(*handle); } signal(SIGALRM, SIG_DFL); return (FILE_NOT_OPENED); } /*--------------------------------------------------------------------------*/ /* This creates a memory handle with a copy of the URL in filename. The file must be compressed and is copied to disk first */ int ftp_compress_open(char *url, int rwmode, int *handle) { FILE *ftpfile; FILE *command; char recbuf[MAXLEN]; long len; int ii, flen, status; int sock; char firstchar; closeftpfile = 0; closecommandfile = 0; closememfile = 0; closefdiskfile = 0; closediskfile = 0; /* don't do r/w files */ if (rwmode != 0) { ffpmsg("Compressed files must be r/o"); return (FILE_NOT_OPENED); } /* Need to know where to write the output file */ flen = strlen(netoutfile); if (!flen) { ffpmsg( "Output file not set, shouldn't have happened (ftp_compress_open)"); return (FILE_NOT_OPENED); } /* do the signal handler bits */ if (setjmp(env) != 0) { /* feels like the second time */ /* this means something bad happened */ ffpmsg("Timeout (http_open)"); goto error; } signal(SIGALRM, signal_handler); /* Open the network connection to url, ftpfile is connected to the file port, command is connected to port 21. sock is for writing to port 21 */ alarm(NETTIMEOUT); if ((status = ftp_open_network(url,&ftpfile,&command,&sock))) { alarm(0); ffpmsg("Unable to open ftp file (ftp_compress_open)"); ffpmsg(url); goto error; } closeftpfile++; closecommandfile++; /* Now, what do we do with the file */ firstchar = fgetc(ftpfile); ungetc(firstchar,ftpfile); if (strstr(url,".gz") || strstr(url,".Z") || ('\037' == firstchar)) { if (*netoutfile == '!') { /* user wants to clobber file, if it already exists */ for (ii = 0; ii < flen; ii++) netoutfile[ii] = netoutfile[ii + 1]; /* remove '!' */ status = file_remove(netoutfile); } /* Create the output file */ if ((status = file_create(netoutfile,handle))) { ffpmsg("Unable to create output file (ftp_compress_open)"); ffpmsg(netoutfile); goto error; } closediskfile++; /* write a file */ alarm(NETTIMEOUT); while(0 != (len = fread(recbuf,1,MAXLEN,ftpfile))) { alarm(0); status = file_write(*handle,recbuf,len); if (status) { ffpmsg("Error writing file (ftp_compres_open)"); ffpmsg(url); ffpmsg(netoutfile); goto error; } alarm(NETTIMEOUT); } file_close(*handle); closediskfile--; fclose(ftpfile); closeftpfile--; /* Close down the ftp connection */ NET_SendRaw(sock,"QUIT\n",5,NET_DEFAULT); fclose(command); closecommandfile--; /* File is on disk, let's uncompress it into memory */ if (NULL == (diskfile = fopen(netoutfile,"r"))) { ffpmsg("Unable to reopen disk file (ftp_compress_open)"); ffpmsg(netoutfile); return (FILE_NOT_OPENED); } closefdiskfile++; if ((status = mem_create(url,handle))) { ffpmsg("Unable to create memory file (ftp_compress_open)"); ffpmsg(url); goto error; } closememfile++; status = 0; status = mem_uncompress2mem(url,diskfile,*handle); fclose(diskfile); closefdiskfile--; if (status) { ffpmsg("Error writing compressed memory file (ftp_compress_open)"); goto error; } } else { /* Opps, this should not have happened */ ffpmsg("Can only compressed files here (ftp_compress_open)"); goto error; } signal(SIGALRM, SIG_DFL); alarm(0); return mem_seek(*handle,0); error: alarm(0); /* clear it */ if (closeftpfile) { fclose(ftpfile); } if (closecommandfile) { fclose(command); } if (closefdiskfile) { fclose(diskfile); } if (closememfile) { mem_close_free(*handle); } if (closediskfile) { file_close(*handle); } signal(SIGALRM, SIG_DFL); return (FILE_NOT_OPENED); } /*--------------------------------------------------------------------------*/ /* Open a ftp connection to filename (really a URL), return ftpfile set to the file connection, and command set to the control connection, with sock also set to the control connection */ int ftp_open_network(char *filename, FILE **ftpfile, FILE **command, int *sock) { int status; int sock1; int tmpint; char recbuf[MAXLEN]; char errorstr[MAXLEN]; char tmpstr[MAXLEN]; char proto[SHORTLEN]; char host[SHORTLEN]; char *newhost; char *username; char *password; char fn[MAXLEN]; char *newfn; char *passive; char *tstr; char ip[SHORTLEN]; char turl[MAXLEN]; int port; /* parse the URL */ if (strlen(filename) > MAXLEN - 7) { ffpmsg("ftp filename is too long (ftp_open)"); return (FILE_NOT_OPENED); } strcpy(turl,"ftp://"); strcat(turl,filename); if (NET_ParseUrl(turl,proto,host,&port,fn)) { sprintf(errorstr,"URL Parse Error (ftp_open) %s",filename); ffpmsg(errorstr); return (FILE_NOT_OPENED); } #ifdef DEBUG printf ("proto, %s, host, %s, port %d, fn %s\n",proto,host,port,fn); #endif port = 21; /* we might have a user name */ username = "anonymous"; password = "user@host.com"; /* is there an @ sign */ if (NULL != (newhost = strrchr(host,'@'))) { *newhost = '\0'; /* make it a null, */ newhost++; /* Now newhost points to the host name and host points to the user name, password combo */ username = host; /* is there a : for a password */ if (NULL != strchr(username,':')) { password = strchr(username,':'); *password = '\0'; password++; } } else { newhost = host; } #ifdef DEBUG printf("User %s pass %s\n",username,password); #endif /* Connect to the host on the required port */ *sock = NET_TcpConnect(newhost,port); /* convert it to a stdio file */ if (NULL == (*command = fdopen(*sock,"r"))) { ffpmsg ("fdopen failed to convert socket to stdio file (ftp_open)"); return (FILE_NOT_OPENED); } /* Wait for the 220 response */ if (ftp_status(*command,"220 ")) { ffpmsg ("error connecting to remote server, no 220 seen (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } /* Send the user name and wait for the right response */ sprintf(tmpstr,"USER %s\n",username); status = NET_SendRaw(*sock,tmpstr,strlen(tmpstr),NET_DEFAULT); if (ftp_status(*command,"331 ")) { ffpmsg ("USER error no 331 seen (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } /* Send the password and wait for the right response */ sprintf(tmpstr,"PASS %s\n",password); status = NET_SendRaw(*sock,tmpstr,strlen(tmpstr),NET_DEFAULT); if (ftp_status(*command,"230 ")) { ffpmsg ("PASS error, no 230 seen (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } /* now do the cwd command */ newfn = strrchr(fn,'/'); if (newfn == NULL) { strcpy(tmpstr,"CWD /\n"); newfn = fn; } else { *newfn = '\0'; newfn++; if (strlen(fn) == 0) { strcpy(tmpstr,"CWD /\n"); } else { /* remove the leading slash */ if (fn[0] == '/') { sprintf(tmpstr,"CWD %s\n",&fn[1]); } else { sprintf(tmpstr,"CWD %s\n",fn); } } } #ifdef DEBUG printf("CWD command is %s\n",tmpstr); #endif status = NET_SendRaw(*sock,tmpstr,strlen(tmpstr),NET_DEFAULT); if (ftp_status(*command,"250 ")) { ffpmsg ("CWD error, no 250 seen (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } if (!strlen(newfn)) { ffpmsg("Null file name (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } /* Always use binary mode */ sprintf(tmpstr,"TYPE I\n"); status = NET_SendRaw(*sock,tmpstr,strlen(tmpstr),NET_DEFAULT); if (ftp_status(*command,"200 ")) { ffpmsg ("TYPE I error, 200 not seen (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } status = NET_SendRaw(*sock,"PASV\n",5,NET_DEFAULT); if (!(fgets(recbuf,MAXLEN,*command))) { ffpmsg ("PASV error (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } /* Passive mode response looks like 227 Entering Passive Mode (129,194,67,8,210,80) */ if (recbuf[0] == '2' && recbuf[1] == '2' && recbuf[2] == '7') { /* got a good passive mode response, find the opening ( */ if (!(passive = strchr(recbuf,'('))) { ffpmsg ("PASV error (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } *passive = '\0'; passive++; ip[0] = '\0'; /* Messy parsing of response from PASV *command */ if (!(tstr = strtok(passive,",)"))) { ffpmsg ("PASV error (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } strcpy(ip,tstr); strcat(ip,"."); if (!(tstr = strtok(NULL,",)"))) { ffpmsg ("PASV error (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } strcat(ip,tstr); strcat(ip,"."); if (!(tstr = strtok(NULL,",)"))) { ffpmsg ("PASV error (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } strcat(ip,tstr); strcat(ip,"."); if (!(tstr = strtok(NULL,",)"))) { ffpmsg ("PASV error (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } strcat(ip,tstr); /* Done the ip number, now do the port # */ if (!(tstr = strtok(NULL,",)"))) { ffpmsg ("PASV error (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } sscanf(tstr,"%d",&port); port *= 256; if (!(tstr = strtok(NULL,",)"))) { ffpmsg ("PASV error (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } sscanf(tstr,"%d",&tmpint); port += tmpint; if (!strlen(newfn)) { ffpmsg("Null file name (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } #ifdef DEBUG puts("connection to passive port"); #endif /* COnnect to the data port */ sock1 = NET_TcpConnect(ip,port); if (NULL == (*ftpfile = fdopen(sock1,"r"))) { ffpmsg ("Could not connect to passive port (ftp_open)"); fclose(*command); return (FILE_NOT_OPENED); } /* now we return */ /* Send the retrieve command */ sprintf(tmpstr,"RETR %s\n",newfn); status = NET_SendRaw(*sock,tmpstr,strlen(tmpstr),NET_DEFAULT); #ifdef DEBUG puts("Sent RETR command"); #endif if (ftp_status(*command,"150 ")) { /* ffpmsg ("RETR error, most likely file is not there (ftp_open)"); */ fclose(*command); #ifdef DEBUG puts("File not there"); #endif return (FILE_NOT_OPENED); } return 0; } /* no passive mode */ NET_SendRaw(*sock,"QUIT\n",5,NET_DEFAULT); fclose(*command); return (FILE_NOT_OPENED); } /*--------------------------------------------------------------------------*/ /* return a socket which results from connection to hostname on port port */ static int NET_TcpConnect(char *hostname, int port) { /* Connect to hostname on port */ struct sockaddr_in sockaddr; int sock; int stat; int val = 1; CreateSocketAddress(&sockaddr,hostname,port); /* Create socket */ if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { ffpmsg("Can't create socket"); return CONNECTION_ERROR; } if ((stat = connect(sock, (struct sockaddr*) &sockaddr, sizeof(sockaddr))) < 0) { close(sock); /* perror("NET_Tcpconnect - Connection error"); ffpmsg("Can't connect to host, connection error"); */ return CONNECTION_ERROR; } setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val)); setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *)&val, sizeof(val)); val = 65536; setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&val, sizeof(val)); setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&val, sizeof(val)); return sock; } /*--------------------------------------------------------------------------*/ /* Write len bytes from buffer to socket sock */ static int NET_SendRaw(int sock, const void *buffer, int length, int opt) { char * buf = (char *) buffer; int flag; int n, nsent = 0; switch (opt) { case NET_DEFAULT: flag = 0; break; case NET_OOB: flag = MSG_OOB; break; case NET_PEEK: default: flag = 0; break; } if (sock < 0) return -1; for (n = 0; n < length; n += nsent) { if ((nsent = send(sock, buf+n, length-n, flag)) <= 0) { return nsent; } #ifdef DEBUG printf ("send raw, sent %d bytes\n",nsent); #endif } #ifdef DEBUG printf ("send raw end, sent %d bytes\n",n); #endif return n; } /*--------------------------------------------------------------------------*/ static int NET_RecvRaw(int sock, void *buffer, int length) { /* Receive exactly length bytes into buffer. Returns number of bytes */ /* received. Returns -1 in case of error. */ int nrecv, n; char *buf = (char *)buffer; if (sock < 0) return -1; for (n = 0; n < length; n += nrecv) { while ((nrecv = recv(sock, buf+n, length-n, 0)) == -1 && errno == EINTR) errno = 0; /* probably a SIGCLD that was caught */ if (nrecv < 0) return nrecv; else if (nrecv == 0) break; /*/ EOF */ } return n; } /*--------------------------------------------------------------------------*/ /* Yet Another URL Parser url - input url proto - input protocol host - output host port - output port fn - output filename */ static int NET_ParseUrl(const char *url, char *proto, char *host, int *port, char *fn) { /* parses urls into their bits */ /* returns 1 if error, else 0 */ char *urlcopy, *urlcopyorig; char *ptrstr; char *thost; int isftp = 0; /* figure out if there is a http: or ftp: */ urlcopyorig = urlcopy = (char *) malloc(strlen(url)+1); strcpy(urlcopy,url); /* set some defaults */ *port = 80; strcpy(proto,"http:"); strcpy(host,"localhost"); strcpy(fn,"/"); ptrstr = strstr(urlcopy,"http:"); if (ptrstr == NULL) { /* Nope, not http: */ ptrstr = strstr(urlcopy,"root:"); if (ptrstr == NULL) { /* Nope, not root either */ ptrstr = strstr(urlcopy,"ftp:"); if (ptrstr != NULL) { if (ptrstr == urlcopy) { strcpy(proto,"ftp:"); *port = 21; isftp++; urlcopy += 4; /* move past ftp: */ } else { /* not at the beginning, bad url */ free(urlcopyorig); return 1; } } } else { if (ptrstr == urlcopy) { urlcopy += 5; /* move past root: */ } else { /* not at the beginning, bad url */ free(urlcopyorig); return 1; } } } else { if (ptrstr == urlcopy) { urlcopy += 5; /* move past http: */ } else { free(urlcopyorig); return 1; } } /* got the protocol */ /* get the hostname */ if (urlcopy[0] == '/' && urlcopy[1] == '/') { /* we have a hostname */ urlcopy += 2; /* move past the // */ } /* do this only if http */ if (!strcmp(proto,"http:")) { /* Move past any user:password */ if ((thost = strchr(urlcopy, '@')) != NULL) urlcopy = thost+1; strcpy(host,urlcopy); thost = host; while (*urlcopy != '/' && *urlcopy != ':' && *urlcopy) { thost++; urlcopy++; } /* we should either be at the end of the string, have a /, or have a : */ *thost = '\0'; if (*urlcopy == ':') { /* follows a port number */ urlcopy++; sscanf(urlcopy,"%d",port); while (*urlcopy != '/' && *urlcopy) urlcopy++; /* step to the */ } } else { /* do this for ftp */ strcpy(host,urlcopy); thost = host; while (*urlcopy != '/' && *urlcopy) { thost++; urlcopy++; } *thost = '\0'; /* Now, we should either be at the end of the string, or have a / */ } /* Now the rest is a fn */ if (*urlcopy) { strcpy(fn,urlcopy); } free(urlcopyorig); return 0; } /*--------------------------------------------------------------------------*/ /* Small helper functions to set the netoutfile static string */ /* Called by cfileio after parsing the output file off of the input file url */ int http_checkfile (char *urltype, char *infile, char *outfile1) { char newinfile[MAXLEN]; FILE *httpfile; char contentencoding[MAXLEN]; int contentlength; /* default to http:// if there is no output file */ strcpy(urltype,"http://"); if (strlen(outfile1)) { /* there is an output file */ /* don't copy the "file://" prefix, if present. */ if (!strncmp(outfile1, "file://", 7) ) strcpy(netoutfile,outfile1+7); else strcpy(netoutfile,outfile1); if (!strncmp(outfile1, "mem:", 4) ) { /* copy the file to memory, with READ and WRITE access In this case, it makes no difference whether the http file and or the output file are compressed or not. */ strcpy(urltype, "httpmem://"); /* use special driver */ return 0; } if (strstr(infile, "?")) { /* file name contains a '?' so probably a cgi string; don't open it */ strcpy(urltype,"httpfile://"); return 0; } if (!http_open_network(infile,&httpfile,contentencoding,&contentlength)) { fclose(httpfile); /* It's there, we're happy */ if (strstr(infile,".gz") || (strstr(infile,".Z"))) { /* It's compressed */ if (strstr(outfile1,".gz") || (strstr(outfile1,".Z"))) { strcpy(urltype,"httpcompress://"); } else { strcpy(urltype,"httpfile://"); } } else { strcpy(urltype,"httpfile://"); } return 0; } /* Ok, let's try the .gz one */ strcpy(newinfile,infile); strcat(newinfile,".gz"); if (!http_open_network(newinfile,&httpfile,contentencoding, &contentlength)) { fclose(httpfile); strcpy(infile,newinfile); /* It's there, we're happy, and, it's compressed */ /* It's compressed */ if (strstr(outfile1,".gz") || (strstr(outfile1,".Z"))) { strcpy(urltype,"httpcompress://"); } else { strcpy(urltype,"httpfile://"); } return 0; } /* Ok, let's try the .Z one */ strcpy(newinfile,infile); strcat(newinfile,".Z"); if (!http_open_network(newinfile,&httpfile,contentencoding, &contentlength)) { fclose(httpfile); strcpy(infile,newinfile); /* It's there, we're happy, and, it's compressed */ if (strstr(outfile1,".gz") || (strstr(outfile1,".Z"))) { strcpy(urltype,"httpcompress://"); } else { strcpy(urltype,"httpfile://"); } return 0; } } return 0; } /*--------------------------------------------------------------------------*/ int ftp_checkfile (char *urltype, char *infile, char *outfile1) { char newinfile[MAXLEN]; FILE *ftpfile; FILE *command; int sock; /* default to ftp:// */ strcpy(urltype,"ftp://"); if (strlen(outfile1)) { /* there is an output file */ /* don't copy the "file://" prefix, if present. */ if (!strncmp(outfile1, "file://", 7) ) strcpy(netoutfile,outfile1+7); else strcpy(netoutfile,outfile1); if (!strncmp(outfile1, "mem:", 4) ) { /* copy the file to memory, with READ and WRITE access In this case, it makes no difference whether the ftp file and or the output file are compressed or not. */ strcpy(urltype, "ftpmem://"); /* use special driver */ return 0; } if (!ftp_open_network(infile,&ftpfile,&command,&sock)) { fclose(ftpfile); fclose(command); /* It's there, we're happy */ if (strstr(infile,".gz") || (strstr(infile,".Z"))) { /* It's compressed */ if (strstr(outfile1,".gz") || (strstr(outfile1,".Z"))) { strcpy(urltype,"ftpcompress://"); } else { strcpy(urltype,"ftpfile://"); } } else { strcpy(urltype,"ftpfile://"); } return 0; } /* Ok, let's try the .gz one */ strcpy(newinfile,infile); strcat(newinfile,".gz"); if (!ftp_open_network(newinfile,&ftpfile,&command,&sock)) { fclose(ftpfile); fclose(command); strcpy(infile,newinfile); /* It's there, we're happy, and, it's compressed */ if (strstr(outfile1,".gz") || (strstr(outfile1,".Z"))) { strcpy(urltype,"ftpcompress://"); } else { strcpy(urltype,"ftpfile://"); } return 0; } /* Ok, let's try the .Z one */ strcpy(newinfile,infile); strcat(newinfile,".Z"); if (!ftp_open_network(newinfile,&ftpfile,&command,&sock)) { fclose(ftpfile); fclose(command); strcpy(infile,newinfile); if (strstr(outfile1,".gz") || (strstr(outfile1,".Z"))) { strcpy(urltype,"ftpcompress://"); } else { strcpy(urltype,"ftpfile://"); } return 0; } } return 0; } /*--------------------------------------------------------------------------*/ /* A small helper function to wait for a particular status on the ftp connectino */ static int ftp_status(FILE *ftp, char *statusstr) { /* read through until we find a string beginning with statusstr */ /* This needs a timeout */ char recbuf[MAXLEN]; int len; len = strlen(statusstr); while (1) { if (!(fgets(recbuf,MAXLEN,ftp))) { #ifdef DEBUG puts("error reading response in ftp_status"); #endif return 1; /* error reading */ } #ifdef DEBUG printf("ftp_status, return string was %s\n",recbuf); #endif recbuf[len] = '\0'; /* make it short */ if (!strcmp(recbuf,statusstr)) { return 0; /* we're ok */ } if (recbuf[0] > '3') { /* oh well, some sort of error */ return 1; } } } /* *---------------------------------------------------------------------- * * CreateSocketAddress -- * * This function initializes a sockaddr structure for a host and port. * * Results: * 1 if the host was valid, 0 if the host could not be converted to * an IP address. * * Side effects: * Fills in the *sockaddrPtr structure. * *---------------------------------------------------------------------- */ static int CreateSocketAddress( struct sockaddr_in *sockaddrPtr, /* Socket address */ char *host, /* Host. NULL implies INADDR_ANY */ int port) /* Port number */ { struct hostent *hostent; /* Host database entry */ struct in_addr addr; /* For 64/32 bit madness */ char localhost[MAXLEN]; strcpy(localhost,host); memset((void *) sockaddrPtr, '\0', sizeof(struct sockaddr_in)); sockaddrPtr->sin_family = AF_INET; sockaddrPtr->sin_port = htons((unsigned short) (port & 0xFFFF)); if (host == NULL) { addr.s_addr = INADDR_ANY; } else { addr.s_addr = inet_addr(localhost); if (addr.s_addr == 0xFFFFFFFF) { hostent = gethostbyname(localhost); if (hostent != NULL) { memcpy((void *) &addr, (void *) hostent->h_addr_list[0], (size_t) hostent->h_length); } else { #ifdef EHOSTUNREACH errno = EHOSTUNREACH; #else #ifdef ENXIO errno = ENXIO; #endif #endif return 0; /* error */ } } } /* * NOTE: On 64 bit machines the assignment below is rumored to not * do the right thing. Please report errors related to this if you * observe incorrect behavior on 64 bit machines such as DEC Alphas. * Should we modify this code to do an explicit memcpy? */ sockaddrPtr->sin_addr.s_addr = addr.s_addr; return 1; /* Success. */ } /* Signal handler for timeouts */ static void signal_handler(int sig) { switch (sig) { case SIGALRM: /* process for alarm */ longjmp(env,sig); default: { /* Hmm, shouldn't have happend */ exit(sig); } } } /**************************************************************/ /* Root driver */ /*--------------------------------------------------------------------------*/ int root_init(void) { int ii; for (ii = 0; ii < NMAXFILES; ii++) /* initialize all empty slots in table */ { handleTable[ii].sock = 0; handleTable[ii].currentpos = 0; } return(0); } /*--------------------------------------------------------------------------*/ int root_setoptions(int options) { /* do something with the options argument, to stop compiler warning */ options = 0; return(options); } /*--------------------------------------------------------------------------*/ int root_getoptions(int *options) { *options = 0; return(0); } /*--------------------------------------------------------------------------*/ int root_getversion(int *version) { *version = 10; return(0); } /*--------------------------------------------------------------------------*/ int root_shutdown(void) { return(0); } /*--------------------------------------------------------------------------*/ int root_open(char *url, int rwmode, int *handle) { int ii, status; int sock; *handle = -1; for (ii = 0; ii < NMAXFILES; ii++) /* find empty slot in table */ { if (handleTable[ii].sock == 0) { *handle = ii; break; } } if (*handle == -1) return(TOO_MANY_FILES); /* too many files opened */ /*open the file */ if (rwmode) { status = root_openfile(url, "update", &sock); } else { status = root_openfile(url, "read", &sock); } if (status) return(status); handleTable[ii].sock = sock; handleTable[ii].currentpos = 0; return(0); } /*--------------------------------------------------------------------------*/ int root_create(char *filename, int *handle) { int ii, status; int sock; *handle = -1; for (ii = 0; ii < NMAXFILES; ii++) /* find empty slot in table */ { if (handleTable[ii].sock == 0) { *handle = ii; break; } } if (*handle == -1) return(TOO_MANY_FILES); /* too many files opened */ /*open the file */ status = root_openfile(filename, "create", &sock); if (status) { ffpmsg("Unable to create file"); return(status); } handleTable[ii].sock = sock; handleTable[ii].currentpos = 0; return(0); } /*--------------------------------------------------------------------------*/ int root_size(int handle, LONGLONG *filesize) /* return the size of the file in bytes */ { int sock; int offset; int status; int op; sock = handleTable[handle].sock; status = root_send_buffer(sock,ROOTD_STAT,NULL,0); status = root_recv_buffer(sock,&op,(char *)&offset, 4); *filesize = (LONGLONG) ntohl(offset); return(0); } /*--------------------------------------------------------------------------*/ int root_close(int handle) /* close the file */ { int status; int sock; sock = handleTable[handle].sock; status = root_send_buffer(sock,ROOTD_CLOSE,NULL,0); close(sock); handleTable[handle].sock = 0; return(0); } /*--------------------------------------------------------------------------*/ int root_flush(int handle) /* flush the file */ { int status; int sock; sock = handleTable[handle].sock; status = root_send_buffer(sock,ROOTD_FLUSH,NULL,0); return(0); } /*--------------------------------------------------------------------------*/ int root_seek(int handle, LONGLONG offset) /* seek to position relative to start of the file */ { handleTable[handle].currentpos = offset; return(0); } /*--------------------------------------------------------------------------*/ int root_read(int hdl, void *buffer, long nbytes) /* read bytes from the current position in the file */ { char msg[SHORTLEN]; int op; int status; int astat; /* we presume here that the file position will never be > 2**31 = 2.1GB */ sprintf(msg,"%ld %ld ",(long) handleTable[hdl].currentpos,nbytes); status = root_send_buffer(handleTable[hdl].sock,ROOTD_GET,msg,strlen(msg)); if ((unsigned) status != strlen(msg)) { return (READ_ERROR); } astat = 0; status = root_recv_buffer(handleTable[hdl].sock,&op,(char *) &astat,4); if (astat != 0) { return (READ_ERROR); } #ifdef DEBUG printf("root_read, op %d astat %d\n",op,astat); #endif status = NET_RecvRaw(handleTable[hdl].sock,buffer,nbytes); if (status != nbytes) { return (READ_ERROR); } handleTable[hdl].currentpos += nbytes; return(0); } /*--------------------------------------------------------------------------*/ int root_write(int hdl, void *buffer, long nbytes) /* write bytes at the current position in the file */ { char msg[SHORTLEN]; int len; int sock; int status; int astat; int op; sock = handleTable[hdl].sock; /* we presume here that the file position will never be > 2**31 = 2.1GB */ sprintf(msg,"%ld %ld ",(long) handleTable[hdl].currentpos,nbytes); len = strlen(msg); status = root_send_buffer(sock,ROOTD_PUT,msg,len+1); if (status != len+1) { return (WRITE_ERROR); } status = NET_SendRaw(sock,buffer,nbytes,NET_DEFAULT); if (status != nbytes) { return (WRITE_ERROR); } astat = 0; status = root_recv_buffer(handleTable[hdl].sock,&op,(char *) &astat,4); #ifdef DEBUG printf("root_read, op %d astat %d\n",op,astat); #endif if (astat != 0) { return (WRITE_ERROR); } handleTable[hdl].currentpos += nbytes; return(0); } /*--------------------------------------------------------------------------*/ int root_openfile(char *url, char *rwmode, int *sock) /* lowest level routine to physically open a root file */ { int status; char recbuf[MAXLEN]; char errorstr[MAXLEN]; char proto[SHORTLEN]; char host[SHORTLEN]; char fn[MAXLEN]; char turl[MAXLEN]; int port; int op; int ii; int authstat; /* Parse the URL apart again */ strcpy(turl,"root://"); strcat(turl,url); if (NET_ParseUrl(turl,proto,host,&port,fn)) { sprintf(errorstr,"URL Parse Error (root_open) %s",url); ffpmsg(errorstr); return (FILE_NOT_OPENED); } #ifdef DEBUG printf("Connecting to %s on port %d\n",host,port); #endif /* Connect to the remote host */ *sock = NET_TcpConnect(host,port); if (*sock < 0) { ffpmsg("Couldn't connect to host (http_open_network)"); return (FILE_NOT_OPENED); } /* get the username */ if (NULL != getenv("ROOTUSERNAME")) { strcpy(recbuf,getenv("ROOTUSERNAME")); } else { printf("Username: "); fgets(recbuf,MAXLEN,stdin); recbuf[strlen(recbuf)-1] = '\0'; } status = root_send_buffer(*sock, ROOTD_USER, recbuf,strlen(recbuf)); if (status < 0) { ffpmsg("error talking to remote system on username "); return (FILE_NOT_OPENED); } status = root_recv_buffer(*sock,&op,(char *)&authstat,4); if (!status) { ffpmsg("error talking to remote system on username"); return (FILE_NOT_OPENED); } #ifdef DEBUG printf("op is %d and authstat is %d\n",op,authstat); #endif if (op != ROOTD_AUTH) { ffpmsg("ERROR on ROOTD_USER"); ffpmsg(recbuf); return (FILE_NOT_OPENED); } /* now the password */ if (NULL != getenv("ROOTPASSWORD")) { strcpy(recbuf,getenv("ROOTPASSWORD")); } else { printf("Password: "); fgets(recbuf,MAXLEN,stdin); recbuf[strlen(recbuf)-1] = '\0'; } /* ones complement the password */ for (ii=0;(unsigned) ii includes the 4 bytes for the op, the length bytes (4) are implicit if buffer is null don't send it, not everything needs something sent */ int len; int status; int hdr[2]; len = 4; if (buffer != NULL) { len += buflen; } hdr[0] = htonl(len); #ifdef DEBUG printf("len sent is %x\n",hdr[0]); #endif hdr[1] = htonl(op); #ifdef DEBUG printf("op sent is %x\n",hdr[1]); #endif #ifdef DEBUG printf("Sending op %d and length of %d\n",op,len); #endif status = NET_SendRaw(sock,hdr,sizeof(hdr),NET_DEFAULT); if (status < 0) { return status; } if (buffer != NULL) { status = NET_SendRaw(sock,buffer,buflen,NET_DEFAULT); } return status; } static int root_recv_buffer(int sock, int *op, char *buffer, int buflen) { /* recv a buffer, the form is */ int recv1 = 0; int len; int status; char recbuf[MAXLEN]; status = NET_RecvRaw(sock,&len,4); #ifdef DEBUG printf("Recv: status from rec is %d\n",status); #endif if (status < 0) { return status; } recv1 += status; len = ntohl(len); #ifdef DEBUG printf ("Recv: length is %d\n",len); #endif /* ok, have the length, recive the operation */ len -= 4; status = NET_RecvRaw(sock,op,4); if (status < 0) { return status; } recv1 += status; *op = ntohl(*op); #ifdef DEBUG printf ("Recv: Operation is %d\n",*op); #endif if (len > MAXLEN) { len = MAXLEN; } if (len > 0) { /* Get the rest of the message */ status = NET_RecvRaw(sock,recbuf,len); if (len > buflen) { len = buflen; } memcpy(buffer,recbuf,len); if (status < 0) { return status; } } recv1 += status; return recv1; } /*****************************************************************************/ /* Encode a string into MIME Base64 format string */ static int encode64(unsigned s_len, char *src, unsigned d_len, char *dst) { static char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz" "0123456789" "+/"; unsigned triad; for (triad = 0; triad < s_len; triad += 3) { unsigned long int sr; unsigned byte; for (byte = 0; (byte<3) && (triad+byte #include #include #include #include #include #include #if defined(unix) || defined(__unix__) || defined(__unix) #include #endif static int shared_kbase = 0; /* base for shared memory handles */ static int shared_maxseg = 0; /* max number of shared memory blocks */ static int shared_range = 0; /* max number of tried entries */ static int shared_fd = SHARED_INVALID; /* handle of global access lock file */ static int shared_gt_h = SHARED_INVALID; /* handle of global table segment */ static SHARED_LTAB *shared_lt = NULL; /* local table pointer */ static SHARED_GTAB *shared_gt = NULL; /* global table pointer */ static int shared_create_mode = 0666; /* permission flags for created objects */ static int shared_debug = 1; /* simple debugging tool, set to 0 to disable messages */ static int shared_init_called = 0; /* flag whether shared_init() has been called, used for delayed init */ /* static support routines prototypes */ static int shared_clear_entry(int idx); /* unconditionally clear entry */ static int shared_destroy_entry(int idx); /* unconditionally destroy sema & shseg and clear entry */ static int shared_mux(int idx, int mode); /* obtain exclusive access to specified segment */ static int shared_demux(int idx, int mode); /* free exclusive access to specified segment */ static int shared_process_count(int sem); /* valid only for time of invocation */ static int shared_delta_process(int sem, int delta); /* change number of processes hanging on segment */ static int shared_attach_process(int sem); static int shared_detach_process(int sem); static int shared_get_free_entry(int newhandle); /* get free entry in shared_key, or -1, entry is set rw locked */ static int shared_get_hash(long size, int idx);/* return hash value for malloc */ static long shared_adjust_size(long size); /* size must be >= 0 !!! */ static int shared_check_locked_index(int idx); /* verify that given idx is valid */ static int shared_map(int idx); /* map all tables for given idx, check for validity */ static int shared_validate(int idx, int mode); /* use intrnally inside crit.sect !!! */ /* support routines - initialization */ static int shared_clear_entry(int idx) /* unconditionally clear entry */ { if ((idx < 0) || (idx >= shared_maxseg)) return(SHARED_BADARG); shared_gt[idx].key = SHARED_INVALID; /* clear entries in global table */ shared_gt[idx].handle = SHARED_INVALID; shared_gt[idx].sem = SHARED_INVALID; shared_gt[idx].semkey = SHARED_INVALID; shared_gt[idx].nprocdebug = 0; shared_gt[idx].size = 0; shared_gt[idx].attr = 0; return(SHARED_OK); } static int shared_destroy_entry(int idx) /* unconditionally destroy sema & shseg and clear entry */ { int r, r2; union semun filler; if ((idx < 0) || (idx >= shared_maxseg)) return(SHARED_BADARG); r2 = r = SHARED_OK; filler.val = 0; /* this is to make cc happy (warning otherwise) */ if (SHARED_INVALID != shared_gt[idx].sem) r = semctl(shared_gt[idx].sem, 0, IPC_RMID, filler); /* destroy semaphore */ if (SHARED_INVALID != shared_gt[idx].handle) r2 = shmctl(shared_gt[idx].handle, IPC_RMID, 0); /* destroy shared memory segment */ if (SHARED_OK == r) r = r2; /* accumulate error code in r, free r2 */ r2 = shared_clear_entry(idx); return((SHARED_OK == r) ? r2 : r); } void shared_cleanup(void) /* this must (should) be called during exit/abort */ { int i, j, r, oktodelete, filelocked, segmentspresent; flock_t flk; struct shmid_ds ds; if (shared_debug) printf("shared_cleanup:"); if (NULL != shared_lt) { if (shared_debug) printf(" deleting segments:"); for (i=0; i>\n"); return; } int shared_init(int debug_msgs) /* initialize shared memory stuff, you have to call this routine once */ { int i; char buf[1000], *p; mode_t oldumask; shared_init_called = 1; /* tell everybody no need to call us for the 2nd time */ shared_debug = debug_msgs; /* set required debug mode */ if (shared_debug) printf("shared_init:"); shared_kbase = 0; /* adapt to current env. settings */ if (NULL != (p = getenv(SHARED_ENV_KEYBASE))) shared_kbase = atoi(p); if (0 == shared_kbase) shared_kbase = SHARED_KEYBASE; if (shared_debug) printf(" keybase=%d", shared_kbase); shared_maxseg = 0; if (NULL != (p = getenv(SHARED_ENV_MAXSEG))) shared_maxseg = atoi(p); if (0 == shared_maxseg) shared_maxseg = SHARED_MAXSEG; if (shared_debug) printf(" maxseg=%d", shared_maxseg); shared_range = 3 * shared_maxseg; if (SHARED_INVALID == shared_fd) /* create rw locking file (this file is never deleted) */ { if (shared_debug) printf(" lockfileinit="); sprintf(buf, "%s.%d.%d", SHARED_FDNAME, shared_kbase, shared_maxseg); oldumask = umask(0); shared_fd = open(buf, O_TRUNC | O_EXCL | O_CREAT | O_RDWR, shared_create_mode); umask(oldumask); if (SHARED_INVALID == shared_fd) /* or just open rw locking file, in case it already exists */ { shared_fd = open(buf, O_TRUNC | O_RDWR, shared_create_mode); if (SHARED_INVALID == shared_fd) return(SHARED_NOFILE); if (shared_debug) printf("slave"); } else { if (shared_debug) printf("master"); } } if (SHARED_INVALID == shared_gt_h) /* global table not attached, try to create it in shared memory */ { if (shared_debug) printf(" globalsharedtableinit="); shared_gt_h = shmget(shared_kbase, shared_maxseg * sizeof(SHARED_GTAB), IPC_CREAT | IPC_EXCL | shared_create_mode); /* try open as a master */ if (SHARED_INVALID == shared_gt_h) /* if failed, try to open as a slave */ { shared_gt_h = shmget(shared_kbase, shared_maxseg * sizeof(SHARED_GTAB), shared_create_mode); if (SHARED_INVALID == shared_gt_h) return(SHARED_IPCERR); /* means deleted ID residing in system, shared mem unusable ... */ shared_gt = (SHARED_GTAB *)shmat(shared_gt_h, 0, 0); /* attach segment */ if (((SHARED_GTAB *)SHARED_INVALID) == shared_gt) return(SHARED_IPCERR); if (shared_debug) printf("slave"); } else { shared_gt = (SHARED_GTAB *)shmat(shared_gt_h, 0, 0); /* attach segment */ if (((SHARED_GTAB *)SHARED_INVALID) == shared_gt) return(SHARED_IPCERR); for (i=0; i>\n"); return(SHARED_OK); } int shared_recover(int id) /* try to recover dormant segments after applic crash */ { int i, r, r2; if (NULL == shared_gt) return(SHARED_NOTINIT); /* not initialized */ if (NULL == shared_lt) return(SHARED_NOTINIT); /* not initialized */ r = SHARED_OK; for (i=0; i r2) || (0 == r2)) { if (shared_debug) printf("Bogus handle=%d nproc=%d sema=%d:", i, shared_gt[i].nprocdebug, r2); r = shared_destroy_entry(i); if (shared_debug) { printf("%s", r ? "error couldn't clear handle" : "handle cleared"); } } shared_demux(i, SHARED_RDWRITE); } return(r); /* table full */ } /* API routines - mutexes and locking */ static int shared_mux(int idx, int mode) /* obtain exclusive access to specified segment */ { flock_t flk; int r; if (0 == shared_init_called) /* delayed initialization */ { if (SHARED_OK != (r = shared_init(0))) return(r); } if (SHARED_INVALID == shared_fd) return(SHARED_NOTINIT); if ((idx < 0) || (idx >= shared_maxseg)) return(SHARED_BADARG); flk.l_type = ((mode & SHARED_RDWRITE) ? F_WRLCK : F_RDLCK); flk.l_whence = 0; flk.l_start = idx; flk.l_len = 1; if (shared_debug) printf(" [mux (%d): ", idx); if (-1 == fcntl(shared_fd, ((mode & SHARED_NOWAIT) ? F_SETLK : F_SETLKW), &flk)) { switch (errno) { case EAGAIN: ; case EACCES: if (shared_debug) printf("again]"); return(SHARED_AGAIN); default: if (shared_debug) printf("err]"); return(SHARED_IPCERR); } } if (shared_debug) printf("ok]"); return(SHARED_OK); } static int shared_demux(int idx, int mode) /* free exclusive access to specified segment */ { flock_t flk; if (SHARED_INVALID == shared_fd) return(SHARED_NOTINIT); if ((idx < 0) || (idx >= shared_maxseg)) return(SHARED_BADARG); flk.l_type = F_UNLCK; flk.l_whence = 0; flk.l_start = idx; flk.l_len = 1; if (shared_debug) printf(" [demux (%d): ", idx); if (-1 == fcntl(shared_fd, F_SETLKW, &flk)) { switch (errno) { case EAGAIN: ; case EACCES: if (shared_debug) printf("again]"); return(SHARED_AGAIN); default: if (shared_debug) printf("err]"); return(SHARED_IPCERR); } } if (shared_debug) printf("mode=%d ok]", mode); return(SHARED_OK); } static int shared_process_count(int sem) /* valid only for time of invocation */ { union semun su; su.val = 0; /* to force compiler not to give warning messages */ return(semctl(sem, 0, GETVAL, su)); /* su is unused here */ } static int shared_delta_process(int sem, int delta) /* change number of processes hanging on segment */ { struct sembuf sb; if (SHARED_INVALID == sem) return(SHARED_BADARG); /* semaphore not attached */ sb.sem_num = 0; sb.sem_op = delta; sb.sem_flg = SEM_UNDO; return((-1 == semop(sem, &sb, 1)) ? SHARED_IPCERR : SHARED_OK); } static int shared_attach_process(int sem) { if (shared_debug) printf(" [attach process]"); return(shared_delta_process(sem, 1)); } static int shared_detach_process(int sem) { if (shared_debug) printf(" [detach process]"); return(shared_delta_process(sem, -1)); } /* API routines - hashing and searching */ static int shared_get_free_entry(int newhandle) /* get newhandle, or -1, entry is set rw locked */ { if (NULL == shared_gt) return(-1); /* not initialized */ if (NULL == shared_lt) return(-1); /* not initialized */ if (newhandle < 0) return(-1); if (newhandle >= shared_maxseg) return(-1); if (shared_lt[newhandle].tcnt) return(-1); /* somebody (we) is using it */ if (shared_mux(newhandle, SHARED_NOWAIT | SHARED_RDWRITE)) return(-1); /* used by others */ if (SHARED_INVALID == shared_gt[newhandle].key) return(newhandle); /* we have found free slot, lock it and return index */ shared_demux(newhandle, SHARED_RDWRITE); if (shared_debug) printf("[free_entry - ERROR - entry unusable]"); return(-1); /* table full */ } static int shared_get_hash(long size, int idx) /* return hash value for malloc */ { static int counter = 0; int hash; hash = (counter + size * idx) % shared_range; counter = (counter + 1) % shared_range; return(hash); } static long shared_adjust_size(long size) /* size must be >= 0 !!! */ { return(((size + sizeof(BLKHEAD) + SHARED_GRANUL - 1) / SHARED_GRANUL) * SHARED_GRANUL); } /* API routines - core : malloc/realloc/free/attach/detach/lock/unlock */ int shared_malloc(long size, int mode, int newhandle) /* return idx or SHARED_INVALID */ { int h, i, r, idx, key; union semun filler; BLKHEAD *bp; if (0 == shared_init_called) /* delayed initialization */ { if (SHARED_OK != (r = shared_init(0))) return(r); } if (shared_debug) printf("malloc (size = %ld, mode = %d):", size, mode); if (size < 0) return(SHARED_INVALID); if (-1 == (idx = shared_get_free_entry(newhandle))) return(SHARED_INVALID); if (shared_debug) printf(" idx=%d", idx); for (i = 0; ; i++) { if (i >= shared_range) /* table full, signal error & exit */ { shared_demux(idx, SHARED_RDWRITE); return(SHARED_INVALID); } key = shared_kbase + ((i + shared_get_hash(size, idx)) % shared_range); if (shared_debug) printf(" key=%d", key); h = shmget(key, shared_adjust_size(size), IPC_CREAT | IPC_EXCL | shared_create_mode); if (shared_debug) printf(" handle=%d", h); if (SHARED_INVALID == h) continue; /* segment already accupied */ bp = (BLKHEAD *)shmat(h, 0, 0); /* try attach */ if (shared_debug) printf(" p=%p", bp); if (((BLKHEAD *)SHARED_INVALID) == bp) /* cannot attach, delete segment, try with another key */ { shmctl(h, IPC_RMID, 0); continue; } /* now create semaphor counting number of processes attached */ if (SHARED_INVALID == (shared_gt[idx].sem = semget(key, 1, IPC_CREAT | IPC_EXCL | shared_create_mode))) { shmdt((void *)bp); /* cannot create segment, delete everything */ shmctl(h, IPC_RMID, 0); continue; /* try with another key */ } if (shared_debug) printf(" sem=%d", shared_gt[idx].sem); if (shared_attach_process(shared_gt[idx].sem)) /* try attach process */ { semctl(shared_gt[idx].sem, 0, IPC_RMID, filler); /* destroy semaphore */ shmdt((char *)bp); /* detach shared mem segment */ shmctl(h, IPC_RMID, 0); /* destroy shared mem segment */ continue; /* try with another key */ } bp->s.tflag = BLOCK_SHARED; /* fill in data in segment's header (this is really not necessary) */ bp->s.ID[0] = SHARED_ID_0; bp->s.ID[1] = SHARED_ID_1; bp->s.handle = idx; /* used in yorick */ if (mode & SHARED_RESIZE) { if (shmdt((char *)bp)) r = SHARED_IPCERR; /* if segment is resizable, then detach segment */ shared_lt[idx].p = NULL; } else { shared_lt[idx].p = bp; } shared_lt[idx].tcnt = 1; /* one thread using segment */ shared_lt[idx].lkcnt = 0; /* no locks at the moment */ shared_lt[idx].seekpos = 0L; /* r/w pointer positioned at beg of block */ shared_gt[idx].handle = h; /* fill in data in global table */ shared_gt[idx].size = size; shared_gt[idx].attr = mode; shared_gt[idx].semkey = key; shared_gt[idx].key = key; shared_gt[idx].nprocdebug = 0; break; } shared_demux(idx, SHARED_RDWRITE); /* hope this will not fail */ return(idx); } int shared_attach(int idx) { int r, r2; if (SHARED_OK != (r = shared_mux(idx, SHARED_RDWRITE | SHARED_WAIT))) return(r); if (SHARED_OK != (r = shared_map(idx))) { shared_demux(idx, SHARED_RDWRITE); return(r); } if (shared_attach_process(shared_gt[idx].sem)) /* try attach process */ { shmdt((char *)(shared_lt[idx].p)); /* cannot attach process, detach everything */ shared_lt[idx].p = NULL; shared_demux(idx, SHARED_RDWRITE); return(SHARED_BADARG); } shared_lt[idx].tcnt++; /* one more thread is using segment */ if (shared_gt[idx].attr & SHARED_RESIZE) /* if resizeable, detach and return special pointer */ { if (shmdt((char *)(shared_lt[idx].p))) r = SHARED_IPCERR; /* if segment is resizable, then detach segment */ shared_lt[idx].p = NULL; } shared_lt[idx].seekpos = 0L; /* r/w pointer positioned at beg of block */ r2 = shared_demux(idx, SHARED_RDWRITE); return(r ? r : r2); } static int shared_check_locked_index(int idx) /* verify that given idx is valid */ { int r; if (0 == shared_init_called) /* delayed initialization */ { if (SHARED_OK != (r = shared_init(0))) return(r); } if ((idx < 0) || (idx >= shared_maxseg)) return(SHARED_BADARG); if (NULL == shared_lt[idx].p) return(SHARED_BADARG); /* NULL pointer, not attached ?? */ if (0 == shared_lt[idx].lkcnt) return(SHARED_BADARG); /* not locked ?? */ if ((SHARED_ID_0 != (shared_lt[idx].p)->s.ID[0]) || (SHARED_ID_1 != (shared_lt[idx].p)->s.ID[1]) || (BLOCK_SHARED != (shared_lt[idx].p)->s.tflag)) /* invalid data in segment */ return(SHARED_BADARG); return(SHARED_OK); } static int shared_map(int idx) /* map all tables for given idx, check for validity */ { int h; /* have to obtain excl. access before calling shared_map */ BLKHEAD *bp; if ((idx < 0) || (idx >= shared_maxseg)) return(SHARED_BADARG); if (SHARED_INVALID == shared_gt[idx].key) return(SHARED_BADARG); if (SHARED_INVALID == (h = shmget(shared_gt[idx].key, 1, shared_create_mode))) return(SHARED_BADARG); if (((BLKHEAD *)SHARED_INVALID) == (bp = (BLKHEAD *)shmat(h, 0, 0))) return(SHARED_BADARG); if ((SHARED_ID_0 != bp->s.ID[0]) || (SHARED_ID_1 != bp->s.ID[1]) || (BLOCK_SHARED != bp->s.tflag) || (h != shared_gt[idx].handle)) { shmdt((char *)bp); /* invalid segment, detach everything */ return(SHARED_BADARG); } if (shared_gt[idx].sem != semget(shared_gt[idx].semkey, 1, shared_create_mode)) /* check if sema is still there */ { shmdt((char *)bp); /* cannot attach semaphore, detach everything */ return(SHARED_BADARG); } shared_lt[idx].p = bp; /* store pointer to shmem data */ return(SHARED_OK); } static int shared_validate(int idx, int mode) /* use intrnally inside crit.sect !!! */ { int r; if (SHARED_OK != (r = shared_mux(idx, mode))) return(r); /* idx checked by shared_mux */ if (NULL == shared_lt[idx].p) if (SHARED_OK != (r = shared_map(idx))) { shared_demux(idx, mode); return(r); } if ((SHARED_ID_0 != (shared_lt[idx].p)->s.ID[0]) || (SHARED_ID_1 != (shared_lt[idx].p)->s.ID[1]) || (BLOCK_SHARED != (shared_lt[idx].p)->s.tflag)) { shared_demux(idx, mode); return(r); } return(SHARED_OK); } SHARED_P shared_realloc(int idx, long newsize) /* realloc shared memory segment */ { int h, key, i, r; BLKHEAD *bp; long transfersize; r = SHARED_OK; if (newsize < 0) return(NULL); if (shared_check_locked_index(idx)) return(NULL); if (0 == (shared_gt[idx].attr & SHARED_RESIZE)) return(NULL); if (-1 != shared_lt[idx].lkcnt) return(NULL); /* check for RW lock */ if (shared_adjust_size(shared_gt[idx].size) == shared_adjust_size(newsize)) { shared_gt[idx].size = newsize; return((SHARED_P)((shared_lt[idx].p) + 1)); } for (i = 0; ; i++) { if (i >= shared_range) return(NULL); /* table full, signal error & exit */ key = shared_kbase + ((i + shared_get_hash(newsize, idx)) % shared_range); h = shmget(key, shared_adjust_size(newsize), IPC_CREAT | IPC_EXCL | shared_create_mode); if (SHARED_INVALID == h) continue; /* segment already accupied */ bp = (BLKHEAD *)shmat(h, 0, 0); /* try attach */ if (((BLKHEAD *)SHARED_INVALID) == bp) /* cannot attach, delete segment, try with another key */ { shmctl(h, IPC_RMID, 0); continue; } *bp = *(shared_lt[idx].p); /* copy header, then data */ transfersize = ((newsize < shared_gt[idx].size) ? newsize : shared_gt[idx].size); if (transfersize > 0) memcpy((void *)(bp + 1), (void *)((shared_lt[idx].p) + 1), transfersize); if (shmdt((char *)(shared_lt[idx].p))) r = SHARED_IPCERR; /* try to detach old segment */ if (shmctl(shared_gt[idx].handle, IPC_RMID, 0)) if (SHARED_OK == r) r = SHARED_IPCERR; /* destroy old shared memory segment */ shared_gt[idx].size = newsize; /* signal new size */ shared_gt[idx].handle = h; /* signal new handle */ shared_gt[idx].key = key; /* signal new key */ shared_lt[idx].p = bp; break; } return((SHARED_P)(bp + 1)); } int shared_free(int idx) /* detach segment, if last process & !PERSIST, destroy segment */ { int cnt, r, r2; if (SHARED_OK != (r = shared_validate(idx, SHARED_RDWRITE | SHARED_WAIT))) return(r); if (SHARED_OK != (r = shared_detach_process(shared_gt[idx].sem))) /* update number of processes using segment */ { shared_demux(idx, SHARED_RDWRITE); return(r); } shared_lt[idx].tcnt--; /* update number of threads using segment */ if (shared_lt[idx].tcnt > 0) return(shared_demux(idx, SHARED_RDWRITE)); /* if more threads are using segment we are done */ if (shmdt((char *)(shared_lt[idx].p))) /* if, we are the last thread, try to detach segment */ { shared_demux(idx, SHARED_RDWRITE); return(SHARED_IPCERR); } shared_lt[idx].p = NULL; /* clear entry in local table */ shared_lt[idx].seekpos = 0L; /* r/w pointer positioned at beg of block */ if (-1 == (cnt = shared_process_count(shared_gt[idx].sem))) /* get number of processes hanging on segment */ { shared_demux(idx, SHARED_RDWRITE); return(SHARED_IPCERR); } if ((0 == cnt) && (0 == (shared_gt[idx].attr & SHARED_PERSIST))) r = shared_destroy_entry(idx); /* no procs on seg, destroy it */ r2 = shared_demux(idx, SHARED_RDWRITE); return(r ? r : r2); } SHARED_P shared_lock(int idx, int mode) /* lock given segment for exclusive access */ { int r; if (shared_mux(idx, mode)) return(NULL); /* idx checked by shared_mux */ if (0 != shared_lt[idx].lkcnt) /* are we already locked ?? */ if (SHARED_OK != (r = shared_map(idx))) { shared_demux(idx, mode); return(NULL); } if (NULL == shared_lt[idx].p) /* stupid pointer ?? */ if (SHARED_OK != (r = shared_map(idx))) { shared_demux(idx, mode); return(NULL); } if ((SHARED_ID_0 != (shared_lt[idx].p)->s.ID[0]) || (SHARED_ID_1 != (shared_lt[idx].p)->s.ID[1]) || (BLOCK_SHARED != (shared_lt[idx].p)->s.tflag)) { shared_demux(idx, mode); return(NULL); } if (mode & SHARED_RDWRITE) { shared_lt[idx].lkcnt = -1; shared_gt[idx].nprocdebug++; } else shared_lt[idx].lkcnt++; shared_lt[idx].seekpos = 0L; /* r/w pointer positioned at beg of block */ return((SHARED_P)((shared_lt[idx].p) + 1)); } int shared_unlock(int idx) /* unlock given segment, assumes seg is locked !! */ { int r, r2, mode; if (SHARED_OK != (r = shared_check_locked_index(idx))) return(r); if (shared_lt[idx].lkcnt > 0) { shared_lt[idx].lkcnt--; /* unlock read lock */ mode = SHARED_RDONLY; } else { shared_lt[idx].lkcnt = 0; /* unlock write lock */ shared_gt[idx].nprocdebug--; mode = SHARED_RDWRITE; } if (0 == shared_lt[idx].lkcnt) if (shared_gt[idx].attr & SHARED_RESIZE) { if (shmdt((char *)(shared_lt[idx].p))) r = SHARED_IPCERR; /* segment is resizable, then detach segment */ shared_lt[idx].p = NULL; /* signal detachment in local table */ } r2 = shared_demux(idx, mode); /* unlock segment, rest is only parameter checking */ return(r ? r : r2); } /* API routines - support and info routines */ int shared_attr(int idx) /* get the attributes of the shared memory segment */ { int r; if (shared_check_locked_index(idx)) return(SHARED_INVALID); r = shared_gt[idx].attr; return(r); } int shared_set_attr(int idx, int newattr) /* get the attributes of the shared memory segment */ { int r; if (shared_check_locked_index(idx)) return(SHARED_INVALID); if (-1 != shared_lt[idx].lkcnt) return(SHARED_INVALID); /* ADDED - check for RW lock */ r = shared_gt[idx].attr; shared_gt[idx].attr = newattr; return(r); } int shared_set_debug(int mode) /* set/reset debug mode */ { int r = shared_debug; shared_debug = mode; return(r); } int shared_set_createmode(int mode) /* set/reset debug mode */ { int r = shared_create_mode; shared_create_mode = mode; return(r); } int shared_list(int id) { int i, r; if (NULL == shared_gt) return(SHARED_NOTINIT); /* not initialized */ if (NULL == shared_lt) return(SHARED_NOTINIT); /* not initialized */ if (shared_debug) printf("shared_list:"); r = SHARED_OK; printf(" Idx Key Nproc Size Flags\n"); printf("==============================================\n"); for (i=0; i= SHARED_ERRBASE) { printf(" cannot clear PERSIST attribute"); } if (shared_free(i)) { printf(" delete failed\n"); } else { printf(" deleted\n"); } } if (shared_debug) printf(" done\n"); return(r); /* table full */ } /************************* CFITSIO DRIVER FUNCTIONS ***************************/ int smem_init(void) { return(0); } int smem_shutdown(void) { if (shared_init_called) shared_cleanup(); return(0); } int smem_setoptions(int option) { option = 0; return(0); } int smem_getoptions(int *options) { if (NULL == options) return(SHARED_NULPTR); *options = 0; return(0); } int smem_getversion(int *version) { if (NULL == version) return(SHARED_NULPTR); *version = 10; return(0); } int smem_open(char *filename, int rwmode, int *driverhandle) { int h, nitems, r; DAL_SHM_SEGHEAD *sp; if (NULL == filename) return(SHARED_NULPTR); if (NULL == driverhandle) return(SHARED_NULPTR); nitems = sscanf(filename, "h%d", &h); if (1 != nitems) return(SHARED_BADARG); if (SHARED_OK != (r = shared_attach(h))) return(r); if (NULL == (sp = (DAL_SHM_SEGHEAD *)shared_lock(h, ((READWRITE == rwmode) ? SHARED_RDWRITE : SHARED_RDONLY)))) { shared_free(h); return(SHARED_BADARG); } if ((h != sp->h) || (DAL_SHM_SEGHEAD_ID != sp->ID)) { shared_unlock(h); shared_free(h); return(SHARED_BADARG); } *driverhandle = h; return(0); } int smem_create(char *filename, int *driverhandle) { DAL_SHM_SEGHEAD *sp; int h, sz, nitems; if (NULL == filename) return(SHARED_NULPTR); /* currently ignored */ if (NULL == driverhandle) return(SHARED_NULPTR); nitems = sscanf(filename, "h%d", &h); if (1 != nitems) return(SHARED_BADARG); if (SHARED_INVALID == (h = shared_malloc(sz = 2880 + sizeof(DAL_SHM_SEGHEAD), SHARED_RESIZE | SHARED_PERSIST, h))) return(SHARED_NOMEM); if (NULL == (sp = (DAL_SHM_SEGHEAD *)shared_lock(h, SHARED_RDWRITE))) { shared_free(h); return(SHARED_BADARG); } sp->ID = DAL_SHM_SEGHEAD_ID; sp->h = h; sp->size = sz; sp->nodeidx = -1; *driverhandle = h; return(0); } int smem_close(int driverhandle) { int r; if (SHARED_OK != (r = shared_unlock(driverhandle))) return(r); return(shared_free(driverhandle)); } int smem_remove(char *filename) { int nitems, h, r; if (NULL == filename) return(SHARED_NULPTR); nitems = sscanf(filename, "h%d", &h); if (1 != nitems) return(SHARED_BADARG); if (0 == shared_check_locked_index(h)) /* are we locked ? */ { if (-1 != shared_lt[h].lkcnt) /* are we locked RO ? */ { if (SHARED_OK != (r = shared_unlock(h))) return(r); /* yes, so relock in RW */ if (NULL == shared_lock(h, SHARED_RDWRITE)) return(SHARED_BADARG); } } else /* not locked */ { if (SHARED_OK != (r = smem_open(filename, READWRITE, &h))) return(r); /* so open in RW mode */ } shared_set_attr(h, SHARED_RESIZE); /* delete PERSIST attribute */ return(smem_close(h)); /* detach segment (this will delete it) */ } int smem_size(int driverhandle, LONGLONG *size) { if (NULL == size) return(SHARED_NULPTR); if (shared_check_locked_index(driverhandle)) return(SHARED_INVALID); *size = (LONGLONG) (shared_gt[driverhandle].size - sizeof(DAL_SHM_SEGHEAD)); return(0); } int smem_flush(int driverhandle) { if (shared_check_locked_index(driverhandle)) return(SHARED_INVALID); return(0); } int smem_seek(int driverhandle, LONGLONG offset) { if (offset < 0) return(SHARED_BADARG); if (shared_check_locked_index(driverhandle)) return(SHARED_INVALID); shared_lt[driverhandle].seekpos = offset; return(0); } int smem_read(int driverhandle, void *buffer, long nbytes) { if (NULL == buffer) return(SHARED_NULPTR); if (shared_check_locked_index(driverhandle)) return(SHARED_INVALID); if (nbytes < 0) return(SHARED_BADARG); if ((shared_lt[driverhandle].seekpos + nbytes) > shared_gt[driverhandle].size) return(SHARED_BADARG); /* read beyond EOF */ memcpy(buffer, ((char *)(((DAL_SHM_SEGHEAD *)(shared_lt[driverhandle].p + 1)) + 1)) + shared_lt[driverhandle].seekpos, nbytes); shared_lt[driverhandle].seekpos += nbytes; return(0); } int smem_write(int driverhandle, void *buffer, long nbytes) { if (NULL == buffer) return(SHARED_NULPTR); if (shared_check_locked_index(driverhandle)) return(SHARED_INVALID); if (-1 != shared_lt[driverhandle].lkcnt) return(SHARED_INVALID); /* are we locked RW ? */ if (nbytes < 0) return(SHARED_BADARG); if ((unsigned long)(shared_lt[driverhandle].seekpos + nbytes) > (unsigned long)(shared_gt[driverhandle].size - sizeof(DAL_SHM_SEGHEAD))) { /* need to realloc shmem */ if (NULL == shared_realloc(driverhandle, shared_lt[driverhandle].seekpos + nbytes + sizeof(DAL_SHM_SEGHEAD))) return(SHARED_NOMEM); } memcpy(((char *)(((DAL_SHM_SEGHEAD *)(shared_lt[driverhandle].p + 1)) + 1)) + shared_lt[driverhandle].seekpos, buffer, nbytes); shared_lt[driverhandle].seekpos += nbytes; return(0); } #endif healpy-1.10.3/cfitsio/drvrsmem.h0000664000175000017500000001461013010375004016771 0ustar zoncazonca00000000000000/* S H A R E D M E M O R Y D R I V E R ======================================= by Jerzy.Borkowski@obs.unige.ch 09-Mar-98 : initial version 1.0 released 23-Mar-98 : shared_malloc now accepts new handle as an argument */ #include /* this is necessary for Solaris/Linux */ #include #include #ifdef _AIX #include #else #include #endif /* configuration parameters */ #define SHARED_MAXSEG (16) /* maximum number of shared memory blocks */ #define SHARED_KEYBASE (14011963) /* base for shared memory keys, may be overriden by getenv */ #define SHARED_FDNAME ("/tmp/.shmem-lockfile") /* template for lock file name */ #define SHARED_ENV_KEYBASE ("SHMEM_LIB_KEYBASE") /* name of environment variable */ #define SHARED_ENV_MAXSEG ("SHMEM_LIB_MAXSEG") /* name of environment variable */ /* useful constants */ #define SHARED_RDONLY (0) /* flag for shared_(un)lock, lock for read */ #define SHARED_RDWRITE (1) /* flag for shared_(un)lock, lock for write */ #define SHARED_WAIT (0) /* flag for shared_lock, block if cannot lock immediate */ #define SHARED_NOWAIT (2) /* flag for shared_lock, fail if cannot lock immediate */ #define SHARED_NOLOCK (0x100) /* flag for shared_validate function */ #define SHARED_RESIZE (4) /* flag for shared_malloc, object is resizeable */ #define SHARED_PERSIST (8) /* flag for shared_malloc, object is not deleted after last proc detaches */ #define SHARED_INVALID (-1) /* invalid handle for semaphore/shared memory */ #define SHARED_EMPTY (0) /* entries for shared_used table */ #define SHARED_USED (1) #define SHARED_GRANUL (16384) /* granularity of shared_malloc allocation = phys page size, system dependent */ /* checkpoints in shared memory segments - might be omitted */ #define SHARED_ID_0 ('J') /* first byte of identifier in BLKHEAD */ #define SHARED_ID_1 ('B') /* second byte of identifier in BLKHEAD */ #define BLOCK_REG (0) /* value for tflag member of BLKHEAD */ #define BLOCK_SHARED (1) /* value for tflag member of BLKHEAD */ /* generic error codes */ #define SHARED_OK (0) #define SHARED_ERR_MIN_IDX SHARED_BADARG #define SHARED_ERR_MAX_IDX SHARED_NORESIZE #define DAL_SHM_FREE (0) #define DAL_SHM_USED (1) #define DAL_SHM_ID0 ('D') #define DAL_SHM_ID1 ('S') #define DAL_SHM_ID2 ('M') #define DAL_SHM_SEGHEAD_ID (0x19630114) /* data types */ /* BLKHEAD object is placed at the beginning of every memory segment (both shared and regular) to allow automatic recognition of segments type */ typedef union { struct BLKHEADstruct { char ID[2]; /* ID = 'JB', just as a checkpoint */ char tflag; /* is it shared memory or regular one ? */ int handle; /* this is not necessary, used only for non-resizeable objects via ptr */ } s; double d; /* for proper alignment on every machine */ } BLKHEAD; typedef void *SHARED_P; /* generic type of shared memory pointer */ typedef struct SHARED_GTABstruct /* data type used in global table */ { int sem; /* access semaphore (1 field): process count */ int semkey; /* key value used to generate semaphore handle */ int key; /* key value used to generate shared memory handle (realloc changes it) */ int handle; /* handle of shared memory segment */ int size; /* size of shared memory segment */ int nprocdebug; /* attached proc counter, helps remove zombie segments */ char attr; /* attributes of shared memory object */ } SHARED_GTAB; typedef struct SHARED_LTABstruct /* data type used in local table */ { BLKHEAD *p; /* pointer to segment (may be null) */ int tcnt; /* number of threads in this process attached to segment */ int lkcnt; /* >=0 <- number of read locks, -1 - write lock */ long seekpos; /* current pointer position, read/write/seek operations change it */ } SHARED_LTAB; /* system dependent definitions */ #ifndef HAVE_FLOCK_T typedef struct flock flock_t; #define HAVE_FLOCK_T #endif #ifndef HAVE_UNION_SEMUN union semun { int val; struct semid_ds *buf; unsigned short *array; }; #define HAVE_UNION_SEMUN #endif typedef struct DAL_SHM_SEGHEAD_STRUCT DAL_SHM_SEGHEAD; struct DAL_SHM_SEGHEAD_STRUCT { int ID; /* ID for debugging */ int h; /* handle of sh. mem */ int size; /* size of data area */ int nodeidx; /* offset of root object (node struct typically) */ }; /* API routines */ #ifdef __cplusplus extern "C" { #endif void shared_cleanup(void); /* must be called at exit/abort */ int shared_init(int debug_msgs); /* must be called before any other shared memory routine */ int shared_recover(int id); /* try to recover dormant segment(s) after applic crash */ int shared_malloc(long size, int mode, int newhandle); /* allocate n-bytes of shared memory */ int shared_attach(int idx); /* attach to segment given index to table */ int shared_free(int idx); /* release shared memory */ SHARED_P shared_lock(int idx, int mode); /* lock segment for reading */ SHARED_P shared_realloc(int idx, long newsize); /* reallocate n-bytes of shared memory (ON LOCKED SEGMENT ONLY) */ int shared_size(int idx); /* get size of attached shared memory segment (ON LOCKED SEGMENT ONLY) */ int shared_attr(int idx); /* get attributes of attached shared memory segment (ON LOCKED SEGMENT ONLY) */ int shared_set_attr(int idx, int newattr); /* set attributes of attached shared memory segment (ON LOCKED SEGMENT ONLY) */ int shared_unlock(int idx); /* unlock segment (ON LOCKED SEGMENT ONLY) */ int shared_set_debug(int debug_msgs); /* set/reset debug mode */ int shared_set_createmode(int mode); /* set/reset debug mode */ int shared_list(int id); /* list segment(s) */ int shared_uncond_delete(int id); /* uncondintionally delete (NOWAIT operation) segment(s) */ int shared_getaddr(int id, char **address); /* get starting address of FITS file in segment */ int smem_init(void); int smem_shutdown(void); int smem_setoptions(int options); int smem_getoptions(int *options); int smem_getversion(int *version); int smem_open(char *filename, int rwmode, int *driverhandle); int smem_create(char *filename, int *driverhandle); int smem_close(int driverhandle); int smem_remove(char *filename); int smem_size(int driverhandle, LONGLONG *size); int smem_flush(int driverhandle); int smem_seek(int driverhandle, LONGLONG offset); int smem_read(int driverhandle, void *buffer, long nbytes); int smem_write(int driverhandle, void *buffer, long nbytes); #ifdef __cplusplus } #endif healpy-1.10.3/cfitsio/editcol.c0000664000175000017500000024527113010375004016561 0ustar zoncazonca00000000000000/* This file, editcol.c, contains the set of FITSIO routines that */ /* insert or delete rows or columns in a table or resize an image */ /* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ #include #include #include #include "fitsio2.h" /*--------------------------------------------------------------------------*/ int ffrsim(fitsfile *fptr, /* I - FITS file pointer */ int bitpix, /* I - bits per pixel */ int naxis, /* I - number of axes in the array */ long *naxes, /* I - size of each axis */ int *status) /* IO - error status */ /* resize an existing primary array or IMAGE extension. */ { LONGLONG tnaxes[99]; int ii; if (*status > 0) return(*status); for (ii = 0; (ii < naxis) && (ii < 99); ii++) tnaxes[ii] = naxes[ii]; ffrsimll(fptr, bitpix, naxis, tnaxes, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffrsimll(fitsfile *fptr, /* I - FITS file pointer */ int bitpix, /* I - bits per pixel */ int naxis, /* I - number of axes in the array */ LONGLONG *naxes, /* I - size of each axis */ int *status) /* IO - error status */ /* resize an existing primary array or IMAGE extension. */ { int ii, simple, obitpix, onaxis, extend, nmodify; long nblocks, longval; long pcount, gcount, longbitpix; LONGLONG onaxes[99], newsize, oldsize; char comment[FLEN_COMMENT], keyname[FLEN_KEYWORD], message[FLEN_ERRMSG]; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } /* rescan header if data structure is undefined */ else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); /* get current image size parameters */ if (ffghprll(fptr, 99, &simple, &obitpix, &onaxis, onaxes, &pcount, &gcount, &extend, status) > 0) return(*status); longbitpix = bitpix; /* test for the 2 special cases that represent unsigned integers */ if (longbitpix == USHORT_IMG) longbitpix = SHORT_IMG; else if (longbitpix == ULONG_IMG) longbitpix = LONG_IMG; /* test that the new values are legal */ if (longbitpix != BYTE_IMG && longbitpix != SHORT_IMG && longbitpix != LONG_IMG && longbitpix != LONGLONG_IMG && longbitpix != FLOAT_IMG && longbitpix != DOUBLE_IMG) { sprintf(message, "Illegal value for BITPIX keyword: %d", bitpix); ffpmsg(message); return(*status = BAD_BITPIX); } if (naxis < 0 || naxis > 999) { sprintf(message, "Illegal value for NAXIS keyword: %d", naxis); ffpmsg(message); return(*status = BAD_NAXIS); } if (naxis == 0) newsize = 0; else newsize = 1; for (ii = 0; ii < naxis; ii++) { if (naxes[ii] < 0) { sprintf(message, "Illegal value for NAXIS%d keyword: %.0f", ii + 1, (double) (naxes[ii])); ffpmsg(message); return(*status = BAD_NAXES); } newsize *= naxes[ii]; /* compute new image size, in pixels */ } /* compute size of old image, in bytes */ if (onaxis == 0) oldsize = 0; else { oldsize = 1; for (ii = 0; ii < onaxis; ii++) oldsize *= onaxes[ii]; oldsize = (oldsize + pcount) * gcount * (abs(obitpix) / 8); } oldsize = (oldsize + 2879) / 2880; /* old size, in blocks */ newsize = (newsize + pcount) * gcount * (abs(longbitpix) / 8); newsize = (newsize + 2879) / 2880; /* new size, in blocks */ if (newsize > oldsize) /* have to insert new blocks for image */ { nblocks = (long) (newsize - oldsize); if (ffiblk(fptr, nblocks, 1, status) > 0) return(*status); } else if (oldsize > newsize) /* have to delete blocks from image */ { nblocks = (long) (oldsize - newsize); if (ffdblk(fptr, nblocks, status) > 0) return(*status); } /* now update the header keywords */ strcpy(comment,"&"); /* special value to leave comments unchanged */ if (longbitpix != obitpix) { /* update BITPIX value */ ffmkyj(fptr, "BITPIX", longbitpix, comment, status); } if (naxis != onaxis) { /* update NAXIS value */ longval = naxis; ffmkyj(fptr, "NAXIS", longval, comment, status); } /* modify the existing NAXISn keywords */ nmodify = minvalue(naxis, onaxis); for (ii = 0; ii < nmodify; ii++) { ffkeyn("NAXIS", ii+1, keyname, status); ffmkyj(fptr, keyname, naxes[ii], comment, status); } if (naxis > onaxis) /* insert additional NAXISn keywords */ { strcpy(comment,"length of data axis"); for (ii = onaxis; ii < naxis; ii++) { ffkeyn("NAXIS", ii+1, keyname, status); ffikyj(fptr, keyname, naxes[ii], comment, status); } } else if (onaxis > naxis) /* delete old NAXISn keywords */ { for (ii = naxis; ii < onaxis; ii++) { ffkeyn("NAXIS", ii+1, keyname, status); ffdkey(fptr, keyname, status); } } /* Update the BSCALE and BZERO keywords, if an unsigned integer image */ if (bitpix == USHORT_IMG) { strcpy(comment, "offset data range to that of unsigned short"); ffukyg(fptr, "BZERO", 32768., 0, comment, status); strcpy(comment, "default scaling factor"); ffukyg(fptr, "BSCALE", 1.0, 0, comment, status); } else if (bitpix == ULONG_IMG) { strcpy(comment, "offset data range to that of unsigned long"); ffukyg(fptr, "BZERO", 2147483648., 0, comment, status); strcpy(comment, "default scaling factor"); ffukyg(fptr, "BSCALE", 1.0, 0, comment, status); } /* re-read the header, to make sure structures are updated */ ffrdef(fptr, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffirow(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG firstrow, /* I - insert space AFTER this row */ /* 0 = insert space at beginning of table */ LONGLONG nrows, /* I - number of rows to insert */ int *status) /* IO - error status */ /* insert NROWS blank rows immediated after row firstrow (1 = first row). Set firstrow = 0 to insert space at the beginning of the table. */ { int tstatus; LONGLONG naxis1, naxis2; LONGLONG datasize, firstbyte, nshift, nbytes; LONGLONG freespace; long nblock; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } /* rescan header if data structure is undefined */ else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg("Can only add rows to TABLE or BINTABLE extension (ffirow)"); return(*status = NOT_TABLE); } if (nrows < 0 ) return(*status = NEG_BYTES); else if (nrows == 0) return(*status); /* no op, so just return */ /* get the current size of the table */ /* use internal structure since NAXIS2 keyword may not be up to date */ naxis1 = (fptr->Fptr)->rowlength; naxis2 = (fptr->Fptr)->numrows; if (firstrow > naxis2) { ffpmsg( "Insert position greater than the number of rows in the table (ffirow)"); return(*status = BAD_ROW_NUM); } else if (firstrow < 0) { ffpmsg("Insert position is less than 0 (ffirow)"); return(*status = BAD_ROW_NUM); } /* current data size */ datasize = (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; freespace = ( ( (datasize + 2879) / 2880) * 2880) - datasize; nshift = naxis1 * nrows; /* no. of bytes to add to table */ if ( (freespace - nshift) < 0) /* not enough existing space? */ { nblock = (long) ((nshift - freespace + 2879) / 2880); /* number of blocks */ ffiblk(fptr, nblock, 1, status); /* insert the blocks */ } firstbyte = naxis1 * firstrow; /* relative insert position */ nbytes = datasize - firstbyte; /* no. of bytes to shift down */ firstbyte += ((fptr->Fptr)->datastart); /* absolute insert position */ ffshft(fptr, firstbyte, nbytes, nshift, status); /* shift rows and heap */ /* update the heap starting address */ (fptr->Fptr)->heapstart += nshift; /* update the THEAP keyword if it exists */ tstatus = 0; ffmkyj(fptr, "THEAP", (fptr->Fptr)->heapstart, "&", &tstatus); /* update the NAXIS2 keyword */ ffmkyj(fptr, "NAXIS2", naxis2 + nrows, "&", status); ((fptr->Fptr)->numrows) += nrows; ((fptr->Fptr)->origrows) += nrows; return(*status); } /*--------------------------------------------------------------------------*/ int ffdrow(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG firstrow, /* I - first row to delete (1 = first) */ LONGLONG nrows, /* I - number of rows to delete */ int *status) /* IO - error status */ /* delete NROWS rows from table starting with firstrow (1 = first row of table). */ { int tstatus; LONGLONG naxis1, naxis2; LONGLONG datasize, firstbyte, nbytes, nshift; LONGLONG freespace; long nblock; char comm[FLEN_COMMENT]; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } /* rescan header if data structure is undefined */ else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg("Can only delete rows in TABLE or BINTABLE extension (ffdrow)"); return(*status = NOT_TABLE); } if (nrows < 0 ) return(*status = NEG_BYTES); else if (nrows == 0) return(*status); /* no op, so just return */ ffgkyjj(fptr, "NAXIS1", &naxis1, comm, status); /* get the current */ /* ffgkyj(fptr, "NAXIS2", &naxis2, comm, status);*/ /* size of the table */ /* the NAXIS2 keyword may not be up to date, so use the structure value */ naxis2 = (fptr->Fptr)->numrows; if (firstrow > naxis2) { ffpmsg( "Delete position greater than the number of rows in the table (ffdrow)"); return(*status = BAD_ROW_NUM); } else if (firstrow < 1) { ffpmsg("Delete position is less than 1 (ffdrow)"); return(*status = BAD_ROW_NUM); } else if (firstrow + nrows - 1 > naxis2) { ffpmsg("No. of rows to delete exceeds size of table (ffdrow)"); return(*status = BAD_ROW_NUM); } nshift = naxis1 * nrows; /* no. of bytes to delete from table */ /* cur size of data */ datasize = (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; firstbyte = naxis1 * (firstrow + nrows - 1); /* relative del pos */ nbytes = datasize - firstbyte; /* no. of bytes to shift up */ firstbyte += ((fptr->Fptr)->datastart); /* absolute delete position */ ffshft(fptr, firstbyte, nbytes, nshift * (-1), status); /* shift data */ freespace = ( ( (datasize + 2879) / 2880) * 2880) - datasize; nblock = (long) ((nshift + freespace) / 2880); /* number of blocks */ /* delete integral number blocks */ if (nblock > 0) ffdblk(fptr, nblock, status); /* update the heap starting address */ (fptr->Fptr)->heapstart -= nshift; /* update the THEAP keyword if it exists */ tstatus = 0; ffmkyj(fptr, "THEAP", (long)(fptr->Fptr)->heapstart, "&", &tstatus); /* update the NAXIS2 keyword */ ffmkyj(fptr, "NAXIS2", naxis2 - nrows, "&", status); ((fptr->Fptr)->numrows) -= nrows; ((fptr->Fptr)->origrows) -= nrows; /* Update the heap data, if any. This will remove any orphaned data */ /* that was only pointed to by the rows that have been deleted */ ffcmph(fptr, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffdrrg(fitsfile *fptr, /* I - FITS file pointer to table */ char *ranges, /* I - ranges of rows to delete (1 = first) */ int *status) /* IO - error status */ /* delete the ranges of rows from the table (1 = first row of table). The 'ranges' parameter typically looks like: '10-20, 30 - 40, 55' or '50-' and gives a list of rows or row ranges separated by commas. */ { char *cptr; int nranges, nranges2, ii; long *minrow, *maxrow, nrows, *rowarray, jj, kk; LONGLONG naxis2; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } /* rescan header if data structure is undefined */ else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg("Can only delete rows in TABLE or BINTABLE extension (ffdrrg)"); return(*status = NOT_TABLE); } /* the NAXIS2 keyword may not be up to date, so use the structure value */ naxis2 = (fptr->Fptr)->numrows; /* find how many ranges were specified ( = no. of commas in string + 1) */ cptr = ranges; for (nranges = 1; (cptr = strchr(cptr, ',')); nranges++) cptr++; minrow = calloc(nranges, sizeof(long)); maxrow = calloc(nranges, sizeof(long)); if (!minrow || !maxrow) { *status = MEMORY_ALLOCATION; ffpmsg("failed to allocate memory for row ranges (ffdrrg)"); if (maxrow) free(maxrow); if (minrow) free(minrow); return(*status); } /* parse range list into array of range min and max values */ ffrwrg(ranges, naxis2, nranges, &nranges2, minrow, maxrow, status); if (*status > 0 || nranges2 == 0) { free(maxrow); free(minrow); return(*status); } /* determine total number or rows to delete */ nrows = 0; for (ii = 0; ii < nranges2; ii++) { nrows = nrows + maxrow[ii] - minrow[ii] + 1; } rowarray = calloc(nrows, sizeof(long)); if (!rowarray) { *status = MEMORY_ALLOCATION; ffpmsg("failed to allocate memory for row array (ffdrrg)"); return(*status); } for (kk = 0, ii = 0; ii < nranges2; ii++) { for (jj = minrow[ii]; jj <= maxrow[ii]; jj++) { rowarray[kk] = jj; kk++; } } /* delete the rows */ ffdrws(fptr, rowarray, nrows, status); free(rowarray); free(maxrow); free(minrow); return(*status); } /*--------------------------------------------------------------------------*/ int ffdrws(fitsfile *fptr, /* I - FITS file pointer */ long *rownum, /* I - list of rows to delete (1 = first) */ long nrows, /* I - number of rows to delete */ int *status) /* IO - error status */ /* delete the list of rows from the table (1 = first row of table). */ { LONGLONG naxis1, naxis2, insertpos, nextrowpos; long ii, nextrow; char comm[FLEN_COMMENT]; unsigned char *buffer; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); /* rescan header if data structure is undefined */ if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg("Can only delete rows in TABLE or BINTABLE extension (ffdrws)"); return(*status = NOT_TABLE); } if (nrows < 0 ) return(*status = NEG_BYTES); else if (nrows == 0) return(*status); /* no op, so just return */ ffgkyjj(fptr, "NAXIS1", &naxis1, comm, status); /* row width */ ffgkyjj(fptr, "NAXIS2", &naxis2, comm, status); /* number of rows */ /* check that input row list is in ascending order */ for (ii = 1; ii < nrows; ii++) { if (rownum[ii - 1] >= rownum[ii]) { ffpmsg("row numbers are not in increasing order (ffdrws)"); return(*status = BAD_ROW_NUM); } } if (rownum[0] < 1) { ffpmsg("first row to delete is less than 1 (ffdrws)"); return(*status = BAD_ROW_NUM); } else if (rownum[nrows - 1] > naxis2) { ffpmsg("last row to delete exceeds size of table (ffdrws)"); return(*status = BAD_ROW_NUM); } buffer = (unsigned char *) malloc( (size_t) naxis1); /* buffer for one row */ if (!buffer) { ffpmsg("malloc failed (ffdrws)"); return(*status = MEMORY_ALLOCATION); } /* byte location to start of first row to delete, and the next row */ insertpos = (fptr->Fptr)->datastart + ((rownum[0] - 1) * naxis1); nextrowpos = insertpos + naxis1; nextrow = rownum[0] + 1; /* work through the list of rows to delete */ for (ii = 1; ii < nrows; nextrow++, nextrowpos += naxis1) { if (nextrow < rownum[ii]) { /* keep this row, so copy it to the new position */ ffmbyt(fptr, nextrowpos, REPORT_EOF, status); ffgbyt(fptr, naxis1, buffer, status); /* read the bytes */ ffmbyt(fptr, insertpos, IGNORE_EOF, status); ffpbyt(fptr, naxis1, buffer, status); /* write the bytes */ if (*status > 0) { ffpmsg("error while copying good rows in table (ffdrws)"); free(buffer); return(*status); } insertpos += naxis1; } else { /* skip over this row since it is in the list */ ii++; } } /* finished with all the rows to delete; copy remaining rows */ while(nextrow <= naxis2) { ffmbyt(fptr, nextrowpos, REPORT_EOF, status); ffgbyt(fptr, naxis1, buffer, status); /* read the bytes */ ffmbyt(fptr, insertpos, IGNORE_EOF, status); ffpbyt(fptr, naxis1, buffer, status); /* write the bytes */ if (*status > 0) { ffpmsg("failed to copy remaining rows in table (ffdrws)"); free(buffer); return(*status); } insertpos += naxis1; nextrowpos += naxis1; nextrow++; } free(buffer); /* now delete the empty rows at the end of the table */ ffdrow(fptr, naxis2 - nrows + 1, nrows, status); /* Update the heap data, if any. This will remove any orphaned data */ /* that was only pointed to by the rows that have been deleted */ ffcmph(fptr, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffdrwsll(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG *rownum, /* I - list of rows to delete (1 = first) */ LONGLONG nrows, /* I - number of rows to delete */ int *status) /* IO - error status */ /* delete the list of rows from the table (1 = first row of table). */ { LONGLONG insertpos, nextrowpos; LONGLONG naxis1, naxis2, ii, nextrow; char comm[FLEN_COMMENT]; unsigned char *buffer; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); /* rescan header if data structure is undefined */ if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg("Can only delete rows in TABLE or BINTABLE extension (ffdrws)"); return(*status = NOT_TABLE); } if (nrows < 0 ) return(*status = NEG_BYTES); else if (nrows == 0) return(*status); /* no op, so just return */ ffgkyjj(fptr, "NAXIS1", &naxis1, comm, status); /* row width */ ffgkyjj(fptr, "NAXIS2", &naxis2, comm, status); /* number of rows */ /* check that input row list is in ascending order */ for (ii = 1; ii < nrows; ii++) { if (rownum[ii - 1] >= rownum[ii]) { ffpmsg("row numbers are not in increasing order (ffdrws)"); return(*status = BAD_ROW_NUM); } } if (rownum[0] < 1) { ffpmsg("first row to delete is less than 1 (ffdrws)"); return(*status = BAD_ROW_NUM); } else if (rownum[nrows - 1] > naxis2) { ffpmsg("last row to delete exceeds size of table (ffdrws)"); return(*status = BAD_ROW_NUM); } buffer = (unsigned char *) malloc( (size_t) naxis1); /* buffer for one row */ if (!buffer) { ffpmsg("malloc failed (ffdrwsll)"); return(*status = MEMORY_ALLOCATION); } /* byte location to start of first row to delete, and the next row */ insertpos = (fptr->Fptr)->datastart + ((rownum[0] - 1) * naxis1); nextrowpos = insertpos + naxis1; nextrow = rownum[0] + 1; /* work through the list of rows to delete */ for (ii = 1; ii < nrows; nextrow++, nextrowpos += naxis1) { if (nextrow < rownum[ii]) { /* keep this row, so copy it to the new position */ ffmbyt(fptr, nextrowpos, REPORT_EOF, status); ffgbyt(fptr, naxis1, buffer, status); /* read the bytes */ ffmbyt(fptr, insertpos, IGNORE_EOF, status); ffpbyt(fptr, naxis1, buffer, status); /* write the bytes */ if (*status > 0) { ffpmsg("error while copying good rows in table (ffdrws)"); free(buffer); return(*status); } insertpos += naxis1; } else { /* skip over this row since it is in the list */ ii++; } } /* finished with all the rows to delete; copy remaining rows */ while(nextrow <= naxis2) { ffmbyt(fptr, nextrowpos, REPORT_EOF, status); ffgbyt(fptr, naxis1, buffer, status); /* read the bytes */ ffmbyt(fptr, insertpos, IGNORE_EOF, status); ffpbyt(fptr, naxis1, buffer, status); /* write the bytes */ if (*status > 0) { ffpmsg("failed to copy remaining rows in table (ffdrws)"); free(buffer); return(*status); } insertpos += naxis1; nextrowpos += naxis1; nextrow++; } free(buffer); /* now delete the empty rows at the end of the table */ ffdrow(fptr, naxis2 - nrows + 1, nrows, status); /* Update the heap data, if any. This will remove any orphaned data */ /* that was only pointed to by the rows that have been deleted */ ffcmph(fptr, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffrwrg( char *rowlist, /* I - list of rows and row ranges */ LONGLONG maxrows, /* I - number of rows in the table */ int maxranges, /* I - max number of ranges to be returned */ int *numranges, /* O - number ranges returned */ long *minrow, /* O - first row in each range */ long *maxrow, /* O - last row in each range */ int *status) /* IO - status value */ { /* parse the input list of row ranges, returning the number of ranges, and the min and max row value in each range. The only characters allowed in the input rowlist are decimal digits, minus sign, and comma (and non-significant spaces) Example: list = "10-20, 30-35,50" would return numranges = 3, minrow[] = {10, 30, 50}, maxrow[] = {20, 35, 50} error is returned if min value of range is > max value of range or if the ranges are not monotonically increasing. */ char *next; long minval, maxval; if (*status > 0) return(*status); if (maxrows <= 0 ) { *status = RANGE_PARSE_ERROR; ffpmsg("Input maximum range value is <= 0 (fits_parse_ranges)"); return(*status); } next = rowlist; *numranges = 0; while (*next == ' ')next++; /* skip spaces */ while (*next != '\0') { /* find min value of next range; *next must be '-' or a digit */ if (*next == '-') { minval = 1; /* implied minrow value = 1 */ } else if ( isdigit((int) *next) ) { minval = strtol(next, &next, 10); } else { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list:"); ffpmsg(rowlist); return(*status); } while (*next == ' ')next++; /* skip spaces */ /* find max value of next range; *next must be '-', or ',' */ if (*next == '-') { next++; while (*next == ' ')next++; /* skip spaces */ if ( isdigit((int) *next) ) { maxval = strtol(next, &next, 10); } else if (*next == ',' || *next == '\0') { maxval = (long) maxrows; /* implied max value */ } else { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list:"); ffpmsg(rowlist); return(*status); } } else if (*next == ',' || *next == '\0') { maxval = minval; /* only a single integer in this range */ } else { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list:"); ffpmsg(rowlist); return(*status); } if (*numranges + 1 > maxranges) { *status = RANGE_PARSE_ERROR; ffpmsg("Overflowed maximum number of ranges (fits_parse_ranges)"); return(*status); } if (minval < 1 ) { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list: row number < 1"); ffpmsg(rowlist); return(*status); } if (maxval < minval) { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list: min > max"); ffpmsg(rowlist); return(*status); } if (*numranges > 0) { if (minval <= maxrow[(*numranges) - 1]) { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list. Range minimum is"); ffpmsg(" less than or equal to previous range maximum"); ffpmsg(rowlist); return(*status); } } if (minval <= maxrows) { /* ignore range if greater than maxrows */ if (maxval > maxrows) maxval = (long) maxrows; minrow[*numranges] = minval; maxrow[*numranges] = maxval; (*numranges)++; } while (*next == ' ')next++; /* skip spaces */ if (*next == ',') { next++; while (*next == ' ')next++; /* skip more spaces */ } } if (*numranges == 0) { /* a null string was entered */ minrow[0] = 1; maxrow[0] = (long) maxrows; *numranges = 1; } return(*status); } /*--------------------------------------------------------------------------*/ int ffrwrgll( char *rowlist, /* I - list of rows and row ranges */ LONGLONG maxrows, /* I - number of rows in the list */ int maxranges, /* I - max number of ranges to be returned */ int *numranges, /* O - number ranges returned */ LONGLONG *minrow, /* O - first row in each range */ LONGLONG *maxrow, /* O - last row in each range */ int *status) /* IO - status value */ { /* parse the input list of row ranges, returning the number of ranges, and the min and max row value in each range. The only characters allowed in the input rowlist are decimal digits, minus sign, and comma (and non-significant spaces) Example: list = "10-20, 30-35,50" would return numranges = 3, minrow[] = {10, 30, 50}, maxrow[] = {20, 35, 50} error is returned if min value of range is > max value of range or if the ranges are not monotonically increasing. */ char *next; LONGLONG minval, maxval; double dvalue; if (*status > 0) return(*status); if (maxrows <= 0 ) { *status = RANGE_PARSE_ERROR; ffpmsg("Input maximum range value is <= 0 (fits_parse_ranges)"); return(*status); } next = rowlist; *numranges = 0; while (*next == ' ')next++; /* skip spaces */ while (*next != '\0') { /* find min value of next range; *next must be '-' or a digit */ if (*next == '-') { minval = 1; /* implied minrow value = 1 */ } else if ( isdigit((int) *next) ) { /* read as a double, because the string to LONGLONG function */ /* is platform dependent (strtoll, strtol, _atoI64) */ dvalue = strtod(next, &next); minval = (LONGLONG) (dvalue + 0.1); } else { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list:"); ffpmsg(rowlist); return(*status); } while (*next == ' ')next++; /* skip spaces */ /* find max value of next range; *next must be '-', or ',' */ if (*next == '-') { next++; while (*next == ' ')next++; /* skip spaces */ if ( isdigit((int) *next) ) { /* read as a double, because the string to LONGLONG function */ /* is platform dependent (strtoll, strtol, _atoI64) */ dvalue = strtod(next, &next); maxval = (LONGLONG) (dvalue + 0.1); } else if (*next == ',' || *next == '\0') { maxval = maxrows; /* implied max value */ } else { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list:"); ffpmsg(rowlist); return(*status); } } else if (*next == ',' || *next == '\0') { maxval = minval; /* only a single integer in this range */ } else { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list:"); ffpmsg(rowlist); return(*status); } if (*numranges + 1 > maxranges) { *status = RANGE_PARSE_ERROR; ffpmsg("Overflowed maximum number of ranges (fits_parse_ranges)"); return(*status); } if (minval < 1 ) { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list: row number < 1"); ffpmsg(rowlist); return(*status); } if (maxval < minval) { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list: min > max"); ffpmsg(rowlist); return(*status); } if (*numranges > 0) { if (minval <= maxrow[(*numranges) - 1]) { *status = RANGE_PARSE_ERROR; ffpmsg("Syntax error in this row range list. Range minimum is"); ffpmsg(" less than or equal to previous range maximum"); ffpmsg(rowlist); return(*status); } } if (minval <= maxrows) { /* ignore range if greater than maxrows */ if (maxval > maxrows) maxval = maxrows; minrow[*numranges] = minval; maxrow[*numranges] = maxval; (*numranges)++; } while (*next == ' ')next++; /* skip spaces */ if (*next == ',') { next++; while (*next == ' ')next++; /* skip more spaces */ } } if (*numranges == 0) { /* a null string was entered */ minrow[0] = 1; maxrow[0] = maxrows; *numranges = 1; } return(*status); } /*--------------------------------------------------------------------------*/ int fficol(fitsfile *fptr, /* I - FITS file pointer */ int numcol, /* I - position for new col. (1 = 1st) */ char *ttype, /* I - name of column (TTYPE keyword) */ char *tform, /* I - format of column (TFORM keyword) */ int *status) /* IO - error status */ /* Insert a new column into an existing table at position numcol. If numcol is greater than the number of existing columns in the table then the new column will be appended as the last column in the table. */ { char *name, *format; name = ttype; format = tform; fficls(fptr, numcol, 1, &name, &format, status); return(*status); } /*--------------------------------------------------------------------------*/ int fficls(fitsfile *fptr, /* I - FITS file pointer */ int fstcol, /* I - position for first new col. (1 = 1st) */ int ncols, /* I - number of columns to insert */ char **ttype, /* I - array of column names(TTYPE keywords) */ char **tform, /* I - array of formats of column (TFORM) */ int *status) /* IO - error status */ /* Insert 1 or more new columns into an existing table at position numcol. If fstcol is greater than the number of existing columns in the table then the new column will be appended as the last column in the table. */ { int colnum, datacode, decims, tfields, tstatus, ii; LONGLONG datasize, firstbyte, nbytes, nadd, naxis1, naxis2, freespace; LONGLONG tbcol, firstcol, delbyte; long nblock, width, repeat; char tfm[FLEN_VALUE], keyname[FLEN_KEYWORD], comm[FLEN_COMMENT], *cptr; tcolumn *colptr; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } /* rescan header if data structure is undefined */ else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg("Can only add columns to TABLE or BINTABLE extension (fficol)"); return(*status = NOT_TABLE); } /* is the column number valid? */ tfields = (fptr->Fptr)->tfield; if (fstcol < 1 ) return(*status = BAD_COL_NUM); else if (fstcol > tfields) colnum = tfields + 1; /* append as last column */ else colnum = fstcol; /* parse the tform value and calc number of bytes to add to each row */ delbyte = 0; for (ii = 0; ii < ncols; ii++) { strcpy(tfm, tform[ii]); ffupch(tfm); /* make sure format is in upper case */ if ((fptr->Fptr)->hdutype == ASCII_TBL) { ffasfm(tfm, &datacode, &width, &decims, status); delbyte += width + 1; /* add one space between the columns */ } else { ffbnfm(tfm, &datacode, &repeat, &width, status); if (datacode < 0) { /* variable length array column */ if (strchr(tfm, 'Q')) delbyte += 16; else delbyte += 8; } else if (datacode == 1) /* bit column; round up */ delbyte += (repeat + 7) / 8; /* to multiple of 8 bits */ else if (datacode == 16) /* ASCII string column */ delbyte += repeat; else /* numerical data type */ delbyte += (datacode / 10) * repeat; } } if (*status > 0) return(*status); /* get the current size of the table */ /* use internal structure since NAXIS2 keyword may not be up to date */ naxis1 = (fptr->Fptr)->rowlength; naxis2 = (fptr->Fptr)->numrows; /* current size of data */ datasize = (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; freespace = ( ( (datasize + 2879) / 2880) * 2880) - datasize; nadd = delbyte * naxis2; /* no. of bytes to add to table */ if ( (freespace - nadd) < 0) /* not enough existing space? */ { nblock = (long) ((nadd - freespace + 2879) / 2880); /* number of blocks */ if (ffiblk(fptr, nblock, 1, status) > 0) /* insert the blocks */ return(*status); } /* shift heap down (if it exists) */ if ((fptr->Fptr)->heapsize > 0) { nbytes = (fptr->Fptr)->heapsize; /* no. of bytes to shift down */ /* absolute heap pos */ firstbyte = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart; if (ffshft(fptr, firstbyte, nbytes, nadd, status) > 0) /* move heap */ return(*status); } /* update the heap starting address */ (fptr->Fptr)->heapstart += nadd; /* update the THEAP keyword if it exists */ tstatus = 0; ffmkyj(fptr, "THEAP", (fptr->Fptr)->heapstart, "&", &tstatus); /* calculate byte position in the row where to insert the new column */ if (colnum > tfields) firstcol = naxis1; else { colptr = (fptr->Fptr)->tableptr; colptr += (colnum - 1); firstcol = colptr->tbcol; } /* insert delbyte bytes in every row, at byte position firstcol */ ffcins(fptr, naxis1, naxis2, delbyte, firstcol, status); if ((fptr->Fptr)->hdutype == ASCII_TBL) { /* adjust the TBCOL values of the existing columns */ for(ii = 0; ii < tfields; ii++) { ffkeyn("TBCOL", ii + 1, keyname, status); ffgkyjj(fptr, keyname, &tbcol, comm, status); if (tbcol > firstcol) { tbcol += delbyte; ffmkyj(fptr, keyname, tbcol, "&", status); } } } /* update the mandatory keywords */ ffmkyj(fptr, "TFIELDS", tfields + ncols, "&", status); ffmkyj(fptr, "NAXIS1", naxis1 + delbyte, "&", status); /* increment the index value on any existing column keywords */ if(colnum <= tfields) ffkshf(fptr, colnum, tfields, ncols, status); /* add the required keywords for the new columns */ for (ii = 0; ii < ncols; ii++, colnum++) { strcpy(comm, "label for field"); ffkeyn("TTYPE", colnum, keyname, status); ffpkys(fptr, keyname, ttype[ii], comm, status); strcpy(comm, "format of field"); strcpy(tfm, tform[ii]); ffupch(tfm); /* make sure format is in upper case */ ffkeyn("TFORM", colnum, keyname, status); if (abs(datacode) == TSBYTE) { /* Replace the 'S' with an 'B' in the TFORMn code */ cptr = tfm; while (*cptr != 'S') cptr++; *cptr = 'B'; ffpkys(fptr, keyname, tfm, comm, status); /* write the TZEROn and TSCALn keywords */ ffkeyn("TZERO", colnum, keyname, status); strcpy(comm, "offset for signed bytes"); ffpkyg(fptr, keyname, -128., 0, comm, status); ffkeyn("TSCAL", colnum, keyname, status); strcpy(comm, "data are not scaled"); ffpkyg(fptr, keyname, 1., 0, comm, status); } else if (abs(datacode) == TUSHORT) { /* Replace the 'U' with an 'I' in the TFORMn code */ cptr = tfm; while (*cptr != 'U') cptr++; *cptr = 'I'; ffpkys(fptr, keyname, tfm, comm, status); /* write the TZEROn and TSCALn keywords */ ffkeyn("TZERO", colnum, keyname, status); strcpy(comm, "offset for unsigned integers"); ffpkyg(fptr, keyname, 32768., 0, comm, status); ffkeyn("TSCAL", colnum, keyname, status); strcpy(comm, "data are not scaled"); ffpkyg(fptr, keyname, 1., 0, comm, status); } else if (abs(datacode) == TULONG) { /* Replace the 'V' with an 'J' in the TFORMn code */ cptr = tfm; while (*cptr != 'V') cptr++; *cptr = 'J'; ffpkys(fptr, keyname, tfm, comm, status); /* write the TZEROn and TSCALn keywords */ ffkeyn("TZERO", colnum, keyname, status); strcpy(comm, "offset for unsigned integers"); ffpkyg(fptr, keyname, 2147483648., 0, comm, status); ffkeyn("TSCAL", colnum, keyname, status); strcpy(comm, "data are not scaled"); ffpkyg(fptr, keyname, 1., 0, comm, status); } else { ffpkys(fptr, keyname, tfm, comm, status); } if ((fptr->Fptr)->hdutype == ASCII_TBL) /* write the TBCOL keyword */ { if (colnum == tfields + 1) tbcol = firstcol + 2; /* allow space between preceding col */ else tbcol = firstcol + 1; strcpy(comm, "beginning column of field"); ffkeyn("TBCOL", colnum, keyname, status); ffpkyj(fptr, keyname, tbcol, comm, status); /* increment the column starting position for the next column */ ffasfm(tfm, &datacode, &width, &decims, status); firstcol += width + 1; /* add one space between the columns */ } } ffrdef(fptr, status); /* initialize the new table structure */ return(*status); } /*--------------------------------------------------------------------------*/ int ffmvec(fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - position of col to be modified */ LONGLONG newveclen, /* I - new vector length of column (TFORM) */ int *status) /* IO - error status */ /* Modify the vector length of a column in a binary table, larger or smaller. E.g., change a column from TFORMn = '1E' to '20E'. */ { int datacode, tfields, tstatus; LONGLONG datasize, size, firstbyte, nbytes, nadd, ndelete; LONGLONG naxis1, naxis2, firstcol, freespace; LONGLONG width, delbyte, repeat; long nblock; char tfm[FLEN_VALUE], keyname[FLEN_KEYWORD], tcode[2]; tcolumn *colptr; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } /* rescan header if data structure is undefined */ else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->hdutype != BINARY_TBL) { ffpmsg( "Can only change vector length of a column in BINTABLE extension (ffmvec)"); return(*status = NOT_TABLE); } /* is the column number valid? */ tfields = (fptr->Fptr)->tfield; if (colnum < 1 || colnum > tfields) return(*status = BAD_COL_NUM); /* look up the current vector length and element width */ colptr = (fptr->Fptr)->tableptr; colptr += (colnum - 1); datacode = colptr->tdatatype; /* datatype of the column */ repeat = colptr->trepeat; /* field repeat count */ width = colptr->twidth; /* width of a single element in chars */ if (datacode < 0) { ffpmsg( "Can't modify vector length of variable length column (ffmvec)"); return(*status = BAD_TFORM); } if (repeat == newveclen) return(*status); /* column already has the desired vector length */ if (datacode == TSTRING) width = 1; /* width was equal to width of unit string */ naxis1 = (fptr->Fptr)->rowlength; /* current width of the table */ naxis2 = (fptr->Fptr)->numrows; delbyte = (newveclen - repeat) * width; /* no. of bytes to insert */ if (datacode == TBIT) /* BIT column is a special case */ delbyte = ((newveclen + 7) / 8) - ((repeat + 7) / 8); if (delbyte > 0) /* insert space for more elements */ { /* current size of data */ datasize = (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; freespace = ( ( (datasize + 2879) / 2880) * 2880) - datasize; nadd = (LONGLONG)delbyte * naxis2; /* no. of bytes to add to table */ if ( (freespace - nadd) < 0) /* not enough existing space? */ { nblock = (long) ((nadd - freespace + 2879) / 2880); /* number of blocks */ if (ffiblk(fptr, nblock, 1, status) > 0) /* insert the blocks */ return(*status); } /* shift heap down (if it exists) */ if ((fptr->Fptr)->heapsize > 0) { nbytes = (fptr->Fptr)->heapsize; /* no. of bytes to shift down */ /* absolute heap pos */ firstbyte = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart; if (ffshft(fptr, firstbyte, nbytes, nadd, status) > 0) /* move heap */ return(*status); } /* update the heap starting address */ (fptr->Fptr)->heapstart += nadd; /* update the THEAP keyword if it exists */ tstatus = 0; ffmkyj(fptr, "THEAP", (fptr->Fptr)->heapstart, "&", &tstatus); firstcol = colptr->tbcol + (repeat * width); /* insert position */ /* insert delbyte bytes in every row, at byte position firstcol */ ffcins(fptr, naxis1, naxis2, delbyte, firstcol, status); } else if (delbyte < 0) { /* current size of table */ size = (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; freespace = ((size + 2879) / 2880) * 2880 - size - ((LONGLONG)delbyte * naxis2); nblock = (long) (freespace / 2880); /* number of empty blocks to delete */ firstcol = colptr->tbcol + (newveclen * width); /* delete position */ /* delete elements from the vector */ ffcdel(fptr, naxis1, naxis2, -delbyte, firstcol, status); /* abs heap pos */ firstbyte = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart; ndelete = (LONGLONG)delbyte * naxis2; /* size of shift (negative) */ /* shift heap up (if it exists) */ if ((fptr->Fptr)->heapsize > 0) { nbytes = (fptr->Fptr)->heapsize; /* no. of bytes to shift up */ if (ffshft(fptr, firstbyte, nbytes, ndelete, status) > 0) return(*status); } /* delete the empty blocks at the end of the HDU */ if (nblock > 0) ffdblk(fptr, nblock, status); /* update the heap starting address */ (fptr->Fptr)->heapstart += ndelete; /* ndelete is negative */ /* update the THEAP keyword if it exists */ tstatus = 0; ffmkyj(fptr, "THEAP", (fptr->Fptr)->heapstart, "&", &tstatus); } /* construct the new TFORM keyword for the column */ if (datacode == TBIT) strcpy(tcode,"X"); else if (datacode == TBYTE) strcpy(tcode,"B"); else if (datacode == TLOGICAL) strcpy(tcode,"L"); else if (datacode == TSTRING) strcpy(tcode,"A"); else if (datacode == TSHORT) strcpy(tcode,"I"); else if (datacode == TLONG) strcpy(tcode,"J"); else if (datacode == TLONGLONG) strcpy(tcode,"K"); else if (datacode == TFLOAT) strcpy(tcode,"E"); else if (datacode == TDOUBLE) strcpy(tcode,"D"); else if (datacode == TCOMPLEX) strcpy(tcode,"C"); else if (datacode == TDBLCOMPLEX) strcpy(tcode,"M"); /* write as a double value because the LONGLONG conversion */ /* character in sprintf is platform dependent ( %lld, %ld, %I64d ) */ sprintf(tfm,"%.0f%s",(double) newveclen, tcode); ffkeyn("TFORM", colnum, keyname, status); /* Keyword name */ ffmkys(fptr, keyname, tfm, "&", status); /* modify TFORM keyword */ ffmkyj(fptr, "NAXIS1", naxis1 + delbyte, "&", status); /* modify NAXIS1 */ ffrdef(fptr, status); /* reinitialize the new table structure */ return(*status); } /*--------------------------------------------------------------------------*/ int ffcpcl(fitsfile *infptr, /* I - FITS file pointer to input file */ fitsfile *outfptr, /* I - FITS file pointer to output file */ int incol, /* I - number of input column */ int outcol, /* I - number for output column */ int create_col, /* I - create new col if TRUE, else overwrite */ int *status) /* IO - error status */ /* copy a column from infptr and insert it in the outfptr table. */ { int tstatus, colnum, typecode, anynull; long tfields, repeat, width, nrows, outrows; long inloop, outloop, maxloop, ndone, ntodo, npixels; long firstrow, firstelem, ii; char keyname[FLEN_KEYWORD], ttype[FLEN_VALUE], tform[FLEN_VALUE]; char ttype_comm[FLEN_COMMENT],tform_comm[FLEN_COMMENT]; char *lvalues = 0, nullflag, **strarray = 0; char nulstr[] = {'\5', '\0'}; /* unique null string value */ double dnull = 0.l, *dvalues = 0; float fnull = 0., *fvalues = 0; if (*status > 0) return(*status); if (infptr->HDUposition != (infptr->Fptr)->curhdu) { ffmahd(infptr, (infptr->HDUposition) + 1, NULL, status); } else if ((infptr->Fptr)->datastart == DATA_UNDEFINED) ffrdef(infptr, status); /* rescan header */ if (outfptr->HDUposition != (outfptr->Fptr)->curhdu) { ffmahd(outfptr, (outfptr->HDUposition) + 1, NULL, status); } else if ((outfptr->Fptr)->datastart == DATA_UNDEFINED) ffrdef(outfptr, status); /* rescan header */ if (*status > 0) return(*status); if ((infptr->Fptr)->hdutype == IMAGE_HDU || (outfptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg ("Can not copy columns to or from IMAGE HDUs (ffcpcl)"); return(*status = NOT_TABLE); } if ( (infptr->Fptr)->hdutype == BINARY_TBL && (outfptr->Fptr)->hdutype == ASCII_TBL) { ffpmsg ("Copying from Binary table to ASCII table is not supported (ffcpcl)"); return(*status = NOT_BTABLE); } /* get the datatype and vector repeat length of the column */ ffgtcl(infptr, incol, &typecode, &repeat, &width, status); if (typecode < 0) { ffpmsg("Variable-length columns are not supported (ffcpcl)"); return(*status = BAD_TFORM); } if (create_col) /* insert new column in output table? */ { tstatus = 0; ffkeyn("TTYPE", incol, keyname, &tstatus); ffgkys(infptr, keyname, ttype, ttype_comm, &tstatus); ffkeyn("TFORM", incol, keyname, &tstatus); if (ffgkys(infptr, keyname, tform, tform_comm, &tstatus) ) { ffpmsg ("Could not find TTYPE and TFORM keywords in input table (ffcpcl)"); return(*status = NO_TFORM); } if ((infptr->Fptr)->hdutype == ASCII_TBL && (outfptr->Fptr)->hdutype == BINARY_TBL) { /* convert from ASCII table to BINARY table format string */ if (typecode == TSTRING) ffnkey(width, "A", tform, status); else if (typecode == TLONG) strcpy(tform, "1J"); else if (typecode == TSHORT) strcpy(tform, "1I"); else if (typecode == TFLOAT) strcpy(tform,"1E"); else if (typecode == TDOUBLE) strcpy(tform,"1D"); } if (ffgkyj(outfptr, "TFIELDS", &tfields, 0, &tstatus)) { ffpmsg ("Could not read TFIELDS keyword in output table (ffcpcl)"); return(*status = NO_TFIELDS); } colnum = minvalue((int) tfields + 1, outcol); /* output col. number */ /* create the empty column */ if (fficol(outfptr, colnum, ttype, tform, status) > 0) { ffpmsg ("Could not append new column to output file (ffcpcl)"); return(*status); } /* copy the comment strings from the input file for TTYPE and TFORM */ tstatus = 0; ffkeyn("TTYPE", colnum, keyname, &tstatus); ffmcom(outfptr, keyname, ttype_comm, &tstatus); ffkeyn("TFORM", colnum, keyname, &tstatus); ffmcom(outfptr, keyname, tform_comm, &tstatus); /* copy other column-related keywords if they exist */ ffcpky(infptr, outfptr, incol, colnum, "TUNIT", status); ffcpky(infptr, outfptr, incol, colnum, "TSCAL", status); ffcpky(infptr, outfptr, incol, colnum, "TZERO", status); ffcpky(infptr, outfptr, incol, colnum, "TDISP", status); ffcpky(infptr, outfptr, incol, colnum, "TLMIN", status); ffcpky(infptr, outfptr, incol, colnum, "TLMAX", status); ffcpky(infptr, outfptr, incol, colnum, "TDIM", status); /* WCS keywords */ ffcpky(infptr, outfptr, incol, colnum, "TCTYP", status); ffcpky(infptr, outfptr, incol, colnum, "TCUNI", status); ffcpky(infptr, outfptr, incol, colnum, "TCRVL", status); ffcpky(infptr, outfptr, incol, colnum, "TCRPX", status); ffcpky(infptr, outfptr, incol, colnum, "TCDLT", status); ffcpky(infptr, outfptr, incol, colnum, "TCROT", status); if ((infptr->Fptr)->hdutype == ASCII_TBL && (outfptr->Fptr)->hdutype == BINARY_TBL) { /* binary tables only have TNULLn keyword for integer columns */ if (typecode == TLONG || typecode == TSHORT) { /* check if null string is defined; replace with integer */ ffkeyn("TNULL", incol, keyname, &tstatus); if (ffgkys(infptr, keyname, ttype, 0, &tstatus) <= 0) { ffkeyn("TNULL", colnum, keyname, &tstatus); if (typecode == TLONG) ffpkyj(outfptr, keyname, -9999999L, "Null value", status); else ffpkyj(outfptr, keyname, -32768L, "Null value", status); } } } else { ffcpky(infptr, outfptr, incol, colnum, "TNULL", status); } /* rescan header to recognize the new keywords */ if (ffrdef(outfptr, status) ) return(*status); } else { colnum = outcol; } ffgkyj(infptr, "NAXIS2", &nrows, 0, status); /* no. of input rows */ ffgkyj(outfptr, "NAXIS2", &outrows, 0, status); /* no. of output rows */ nrows = minvalue(nrows, outrows); if (typecode == TBIT) repeat = (repeat + 7) / 8; /* convert from bits to bytes */ else if (typecode == TSTRING && (infptr->Fptr)->hdutype == BINARY_TBL) repeat = repeat / width; /* convert from chars to unit strings */ /* get optimum number of rows to copy at one time */ ffgrsz(infptr, &inloop, status); ffgrsz(outfptr, &outloop, status); /* adjust optimum number, since 2 tables are open at once */ maxloop = minvalue(inloop, outloop); /* smallest of the 2 tables */ maxloop = maxvalue(1, maxloop / 2); /* at least 1 row */ maxloop = minvalue(maxloop, nrows); /* max = nrows to be copied */ maxloop *= repeat; /* mult by no of elements in a row */ /* allocate memory for arrays */ if (typecode == TLOGICAL) { lvalues = (char *) calloc(maxloop, sizeof(char) ); if (!lvalues) { ffpmsg ("malloc failed to get memory for logicals (ffcpcl)"); return(*status = ARRAY_TOO_BIG); } } else if (typecode == TSTRING) { /* allocate array of pointers */ strarray = (char **) calloc(maxloop, sizeof(strarray)); /* allocate space for each string */ for (ii = 0; ii < maxloop; ii++) strarray[ii] = (char *) calloc(width+1, sizeof(char)); } else if (typecode == TCOMPLEX) { fvalues = (float *) calloc(maxloop * 2, sizeof(float) ); if (!fvalues) { ffpmsg ("malloc failed to get memory for complex (ffcpcl)"); return(*status = ARRAY_TOO_BIG); } fnull = 0.; } else if (typecode == TDBLCOMPLEX) { dvalues = (double *) calloc(maxloop * 2, sizeof(double) ); if (!dvalues) { ffpmsg ("malloc failed to get memory for dbl complex (ffcpcl)"); return(*status = ARRAY_TOO_BIG); } dnull = 0.; } else /* numerical datatype; read them all as doubles */ { dvalues = (double *) calloc(maxloop, sizeof(double) ); if (!dvalues) { ffpmsg ("malloc failed to get memory for doubles (ffcpcl)"); return(*status = ARRAY_TOO_BIG); } dnull = -9.99991999E31; /* use an unlikely value for nulls */ } npixels = nrows * repeat; /* total no. of pixels to copy */ ntodo = minvalue(npixels, maxloop); /* no. to copy per iteration */ ndone = 0; /* total no. of pixels that have been copied */ while (ntodo) /* iterate through the table */ { firstrow = ndone / repeat + 1; firstelem = ndone - ((firstrow - 1) * repeat) + 1; /* read from input table */ if (typecode == TLOGICAL) ffgcl(infptr, incol, firstrow, firstelem, ntodo, lvalues, status); else if (typecode == TSTRING) ffgcvs(infptr, incol, firstrow, firstelem, ntodo, nulstr, strarray, &anynull, status); else if (typecode == TCOMPLEX) ffgcvc(infptr, incol, firstrow, firstelem, ntodo, fnull, fvalues, &anynull, status); else if (typecode == TDBLCOMPLEX) ffgcvm(infptr, incol, firstrow, firstelem, ntodo, dnull, dvalues, &anynull, status); else /* all numerical types */ ffgcvd(infptr, incol, firstrow, firstelem, ntodo, dnull, dvalues, &anynull, status); if (*status > 0) { ffpmsg("Error reading input copy of column (ffcpcl)"); break; } /* write to output table */ if (typecode == TLOGICAL) { nullflag = 2; ffpcnl(outfptr, colnum, firstrow, firstelem, ntodo, lvalues, nullflag, status); } else if (typecode == TSTRING) { if (anynull) ffpcns(outfptr, colnum, firstrow, firstelem, ntodo, strarray, nulstr, status); else ffpcls(outfptr, colnum, firstrow, firstelem, ntodo, strarray, status); } else if (typecode == TCOMPLEX) { /* doesn't support writing nulls */ ffpclc(outfptr, colnum, firstrow, firstelem, ntodo, fvalues, status); } else if (typecode == TDBLCOMPLEX) { /* doesn't support writing nulls */ ffpclm(outfptr, colnum, firstrow, firstelem, ntodo, dvalues, status); } else /* all other numerical types */ { if (anynull) ffpcnd(outfptr, colnum, firstrow, firstelem, ntodo, dvalues, dnull, status); else ffpcld(outfptr, colnum, firstrow, firstelem, ntodo, dvalues, status); } if (*status > 0) { ffpmsg("Error writing output copy of column (ffcpcl)"); break; } npixels -= ntodo; ndone += ntodo; ntodo = minvalue(npixels, maxloop); } /* free the previously allocated memory */ if (typecode == TLOGICAL) { free(lvalues); } else if (typecode == TSTRING) { for (ii = 0; ii < maxloop; ii++) free(strarray[ii]); free(strarray); } else { free(dvalues); } return(*status); } /*--------------------------------------------------------------------------*/ int ffcprw(fitsfile *infptr, /* I - FITS file pointer to input file */ fitsfile *outfptr, /* I - FITS file pointer to output file */ LONGLONG firstrow, /* I - number of first row to copy (1 based) */ LONGLONG nrows, /* I - number of rows to copy */ int *status) /* IO - error status */ /* copy consecutive set of rows from infptr and append it in the outfptr table. */ { LONGLONG innaxis1, innaxis2, outnaxis1, outnaxis2, ii, jj; unsigned char *buffer; if (*status > 0) return(*status); if (infptr->HDUposition != (infptr->Fptr)->curhdu) { ffmahd(infptr, (infptr->HDUposition) + 1, NULL, status); } else if ((infptr->Fptr)->datastart == DATA_UNDEFINED) ffrdef(infptr, status); /* rescan header */ if (outfptr->HDUposition != (outfptr->Fptr)->curhdu) { ffmahd(outfptr, (outfptr->HDUposition) + 1, NULL, status); } else if ((outfptr->Fptr)->datastart == DATA_UNDEFINED) ffrdef(outfptr, status); /* rescan header */ if (*status > 0) return(*status); if ((infptr->Fptr)->hdutype == IMAGE_HDU || (outfptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg ("Can not copy rows to or from IMAGE HDUs (ffcprw)"); return(*status = NOT_TABLE); } if ( ((infptr->Fptr)->hdutype == BINARY_TBL && (outfptr->Fptr)->hdutype == ASCII_TBL) || ((infptr->Fptr)->hdutype == ASCII_TBL && (outfptr->Fptr)->hdutype == BINARY_TBL) ) { ffpmsg ("Copying rows between Binary and ASCII tables is not supported (ffcprw)"); return(*status = NOT_BTABLE); } ffgkyjj(infptr, "NAXIS1", &innaxis1, 0, status); /* width of input rows */ ffgkyjj(infptr, "NAXIS2", &innaxis2, 0, status); /* no. of input rows */ ffgkyjj(outfptr, "NAXIS1", &outnaxis1, 0, status); /* width of output rows */ ffgkyjj(outfptr, "NAXIS2", &outnaxis2, 0, status); /* no. of output rows */ if (*status > 0) return(*status); if (outnaxis1 > innaxis1) { ffpmsg ("Input and output tables do not have same width (ffcprw)"); return(*status = BAD_ROW_WIDTH); } if (firstrow + nrows - 1 > innaxis2) { ffpmsg ("Not enough rows in input table to copy (ffcprw)"); return(*status = BAD_ROW_NUM); } /* allocate buffer to hold 1 row of data */ buffer = malloc( (size_t) innaxis1); if (!buffer) { ffpmsg ("Unable to allocate memory (ffcprw)"); return(*status = MEMORY_ALLOCATION); } /* copy the rows, 1 at a time */ jj = outnaxis2 + 1; for (ii = firstrow; ii < firstrow + nrows; ii++) { fits_read_tblbytes (infptr, ii, 1, innaxis1, buffer, status); fits_write_tblbytes(outfptr, jj, 1, innaxis1, buffer, status); jj++; } outnaxis2 += nrows; fits_update_key(outfptr, TLONGLONG, "NAXIS2", &outnaxis2, 0, status); free(buffer); return(*status); } /*--------------------------------------------------------------------------*/ int ffcpky(fitsfile *infptr, /* I - FITS file pointer to input file */ fitsfile *outfptr, /* I - FITS file pointer to output file */ int incol, /* I - input index number */ int outcol, /* I - output index number */ char *rootname, /* I - root name of the keyword to be copied */ int *status) /* IO - error status */ /* copy an indexed keyword from infptr to outfptr. */ { int tstatus = 0; char keyname[FLEN_KEYWORD]; char value[FLEN_VALUE], comment[FLEN_COMMENT], card[FLEN_CARD]; ffkeyn(rootname, incol, keyname, &tstatus); if (ffgkey(infptr, keyname, value, comment, &tstatus) <= 0) { ffkeyn(rootname, outcol, keyname, &tstatus); ffmkky(keyname, value, comment, card, status); ffprec(outfptr, card, status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffdcol(fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column to delete (1 = 1st) */ int *status) /* IO - error status */ /* Delete a column from a table. */ { int ii, tstatus; LONGLONG firstbyte, size, ndelete, nbytes, naxis1, naxis2, firstcol, delbyte, freespace; LONGLONG tbcol; long nblock, nspace; char keyname[FLEN_KEYWORD], comm[FLEN_COMMENT]; tcolumn *colptr, *nextcol; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } /* rescan header if data structure is undefined */ else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffpmsg ("Can only delete column from TABLE or BINTABLE extension (ffdcol)"); return(*status = NOT_TABLE); } if (colnum < 1 || colnum > (fptr->Fptr)->tfield ) return(*status = BAD_COL_NUM); colptr = (fptr->Fptr)->tableptr; colptr += (colnum - 1); firstcol = colptr->tbcol; /* starting byte position of the column */ /* use column width to determine how many bytes to delete in each row */ if ((fptr->Fptr)->hdutype == ASCII_TBL) { delbyte = colptr->twidth; /* width of ASCII column */ if (colnum < (fptr->Fptr)->tfield) /* check for space between next column */ { nextcol = colptr + 1; nspace = (long) ((nextcol->tbcol) - (colptr->tbcol) - delbyte); if (nspace > 0) delbyte++; } else if (colnum > 1) /* check for space between last 2 columns */ { nextcol = colptr - 1; nspace = (long) ((colptr->tbcol) - (nextcol->tbcol) - (nextcol->twidth)); if (nspace > 0) { delbyte++; firstcol--; /* delete the leading space */ } } } else /* a binary table */ { if (colnum < (fptr->Fptr)->tfield) { nextcol = colptr + 1; delbyte = (nextcol->tbcol) - (colptr->tbcol); } else { delbyte = ((fptr->Fptr)->rowlength) - (colptr->tbcol); } } naxis1 = (fptr->Fptr)->rowlength; /* current width of the table */ naxis2 = (fptr->Fptr)->numrows; /* current size of table */ size = (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; freespace = ((LONGLONG)delbyte * naxis2) + ((size + 2879) / 2880) * 2880 - size; nblock = (long) (freespace / 2880); /* number of empty blocks to delete */ ffcdel(fptr, naxis1, naxis2, delbyte, firstcol, status); /* delete col */ /* absolute heap position */ firstbyte = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart; ndelete = (LONGLONG)delbyte * naxis2; /* size of shift */ /* shift heap up (if it exists) */ if ((fptr->Fptr)->heapsize > 0) { nbytes = (fptr->Fptr)->heapsize; /* no. of bytes to shift up */ if (ffshft(fptr, firstbyte, nbytes, -ndelete, status) > 0) /* mv heap */ return(*status); } /* delete the empty blocks at the end of the HDU */ if (nblock > 0) ffdblk(fptr, nblock, status); /* update the heap starting address */ (fptr->Fptr)->heapstart -= ndelete; /* update the THEAP keyword if it exists */ tstatus = 0; ffmkyj(fptr, "THEAP", (long)(fptr->Fptr)->heapstart, "&", &tstatus); if ((fptr->Fptr)->hdutype == ASCII_TBL) { /* adjust the TBCOL values of the remaining columns */ for (ii = 1; ii <= (fptr->Fptr)->tfield; ii++) { ffkeyn("TBCOL", ii, keyname, status); ffgkyjj(fptr, keyname, &tbcol, comm, status); if (tbcol > firstcol) { tbcol = tbcol - delbyte; ffmkyj(fptr, keyname, tbcol, "&", status); } } } /* update the mandatory keywords */ ffmkyj(fptr, "TFIELDS", ((fptr->Fptr)->tfield) - 1, "&", status); ffmkyj(fptr, "NAXIS1", naxis1 - delbyte, "&", status); /* delete the index keywords starting with 'T' associated with the deleted column and subtract 1 from index of all higher keywords */ ffkshf(fptr, colnum, (fptr->Fptr)->tfield, -1, status); ffrdef(fptr, status); /* initialize the new table structure */ return(*status); } /*--------------------------------------------------------------------------*/ int ffcins(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG naxis1, /* I - width of the table, in bytes */ LONGLONG naxis2, /* I - number of rows in the table */ LONGLONG ninsert, /* I - number of bytes to insert in each row */ LONGLONG bytepos, /* I - rel. position in row to insert bytes */ int *status) /* IO - error status */ /* Insert 'ninsert' bytes into each row of the table at position 'bytepos'. */ { unsigned char buffer[10000], cfill; LONGLONG newlen, fbyte, nbytes, irow, nseg, ii; if (*status > 0) return(*status); if (naxis2 == 0) return(*status); /* just return if there are 0 rows in the table */ /* select appropriate fill value */ if ((fptr->Fptr)->hdutype == ASCII_TBL) cfill = 32; /* ASCII tables use blank fill */ else cfill = 0; /* primary array and binary tables use zero fill */ newlen = naxis1 + ninsert; if (newlen <= 10000) { /******************************************************************* CASE #1: optimal case where whole new row fits in the work buffer *******************************************************************/ for (ii = 0; ii < ninsert; ii++) buffer[ii] = cfill; /* initialize buffer with fill value */ /* first move the trailing bytes (if any) in the last row */ fbyte = bytepos + 1; nbytes = naxis1 - bytepos; ffgtbb(fptr, naxis2, fbyte, nbytes, &buffer[ninsert], status); (fptr->Fptr)->rowlength = newlen; /* new row length */ /* write the row (with leading fill bytes) in the new place */ nbytes += ninsert; ffptbb(fptr, naxis2, fbyte, nbytes, buffer, status); (fptr->Fptr)->rowlength = naxis1; /* reset to orig. value */ /* now move the rest of the rows */ for (irow = naxis2 - 1; irow > 0; irow--) { /* read the row to be shifted (work backwards thru the table) */ ffgtbb(fptr, irow, fbyte, naxis1, &buffer[ninsert], status); (fptr->Fptr)->rowlength = newlen; /* new row length */ /* write the row (with the leading fill bytes) in the new place */ ffptbb(fptr, irow, fbyte, newlen, buffer, status); (fptr->Fptr)->rowlength = naxis1; /* reset to orig value */ } } else { /***************************************************************** CASE #2: whole row doesn't fit in work buffer; move row in pieces ****************************************************************** first copy the data, then go back and write fill into the new column start by copying the trailing bytes (if any) in the last row. */ nbytes = naxis1 - bytepos; nseg = (nbytes + 9999) / 10000; fbyte = (nseg - 1) * 10000 + bytepos + 1; nbytes = naxis1 - fbyte + 1; for (ii = 0; ii < nseg; ii++) { ffgtbb(fptr, naxis2, fbyte, nbytes, buffer, status); (fptr->Fptr)->rowlength = newlen; /* new row length */ ffptbb(fptr, naxis2, fbyte + ninsert, nbytes, buffer, status); (fptr->Fptr)->rowlength = naxis1; /* reset to orig value */ fbyte -= 10000; nbytes = 10000; } /* now move the rest of the rows */ nseg = (naxis1 + 9999) / 10000; for (irow = naxis2 - 1; irow > 0; irow--) { fbyte = (nseg - 1) * 10000 + bytepos + 1; nbytes = naxis1 - (nseg - 1) * 10000; for (ii = 0; ii < nseg; ii++) { /* read the row to be shifted (work backwards thru the table) */ ffgtbb(fptr, irow, fbyte, nbytes, buffer, status); (fptr->Fptr)->rowlength = newlen; /* new row length */ /* write the row in the new place */ ffptbb(fptr, irow, fbyte + ninsert, nbytes, buffer, status); (fptr->Fptr)->rowlength = naxis1; /* reset to orig value */ fbyte -= 10000; nbytes = 10000; } } /* now write the fill values into the new column */ nbytes = minvalue(ninsert, 10000); memset(buffer, cfill, (size_t) nbytes); /* initialize with fill value */ nseg = (ninsert + 9999) / 10000; (fptr->Fptr)->rowlength = newlen; /* new row length */ for (irow = 1; irow <= naxis2; irow++) { fbyte = bytepos + 1; nbytes = ninsert - ((nseg - 1) * 10000); for (ii = 0; ii < nseg; ii++) { ffptbb(fptr, irow, fbyte, nbytes, buffer, status); fbyte += nbytes; nbytes = 10000; } } (fptr->Fptr)->rowlength = naxis1; /* reset to orig value */ } return(*status); } /*--------------------------------------------------------------------------*/ int ffcdel(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG naxis1, /* I - width of the table, in bytes */ LONGLONG naxis2, /* I - number of rows in the table */ LONGLONG ndelete, /* I - number of bytes to delete in each row */ LONGLONG bytepos, /* I - rel. position in row to delete bytes */ int *status) /* IO - error status */ /* delete 'ndelete' bytes from each row of the table at position 'bytepos'. */ { unsigned char buffer[10000]; LONGLONG i1, i2, ii, irow, nseg; LONGLONG newlen, remain, nbytes; if (*status > 0) return(*status); if (naxis2 == 0) return(*status); /* just return if there are 0 rows in the table */ newlen = naxis1 - ndelete; if (newlen <= 10000) { /******************************************************************* CASE #1: optimal case where whole new row fits in the work buffer *******************************************************************/ i1 = bytepos + 1; i2 = i1 + ndelete; for (irow = 1; irow < naxis2; irow++) { ffgtbb(fptr, irow, i2, newlen, buffer, status); /* read row */ (fptr->Fptr)->rowlength = newlen; /* new row length */ ffptbb(fptr, irow, i1, newlen, buffer, status); /* write row */ (fptr->Fptr)->rowlength = naxis1; /* reset to orig value */ } /* now do the last row */ remain = naxis1 - (bytepos + ndelete); if (remain > 0) { ffgtbb(fptr, naxis2, i2, remain, buffer, status); /* read row */ (fptr->Fptr)->rowlength = newlen; /* new row length */ ffptbb(fptr, naxis2, i1, remain, buffer, status); /* write row */ (fptr->Fptr)->rowlength = naxis1; /* reset to orig value */ } } else { /***************************************************************** CASE #2: whole row doesn't fit in work buffer; move row in pieces ******************************************************************/ nseg = (newlen + 9999) / 10000; for (irow = 1; irow < naxis2; irow++) { i1 = bytepos + 1; i2 = i1 + ndelete; nbytes = newlen - (nseg - 1) * 10000; for (ii = 0; ii < nseg; ii++) { ffgtbb(fptr, irow, i2, nbytes, buffer, status); /* read bytes */ (fptr->Fptr)->rowlength = newlen; /* new row length */ ffptbb(fptr, irow, i1, nbytes, buffer, status); /* rewrite bytes */ (fptr->Fptr)->rowlength = naxis1; /* reset to orig value */ i1 += nbytes; i2 += nbytes; nbytes = 10000; } } /* now do the last row */ remain = naxis1 - (bytepos + ndelete); if (remain > 0) { nseg = (remain + 9999) / 10000; i1 = bytepos + 1; i2 = i1 + ndelete; nbytes = remain - (nseg - 1) * 10000; for (ii = 0; ii < nseg; ii++) { ffgtbb(fptr, naxis2, i2, nbytes, buffer, status); (fptr->Fptr)->rowlength = newlen; /* new row length */ ffptbb(fptr, naxis2, i1, nbytes, buffer, status); /* write row */ (fptr->Fptr)->rowlength = naxis1; /* reset to orig value */ i1 += nbytes; i2 += nbytes; nbytes = 10000; } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffkshf(fitsfile *fptr, /* I - FITS file pointer */ int colmin, /* I - starting col. to be incremented; 1 = 1st */ int colmax, /* I - last column to be incremented */ int incre, /* I - shift index number by this amount */ int *status) /* IO - error status */ /* shift the index value on any existing column keywords This routine will modify the name of any keyword that begins with 'T' and has an index number in the range COLMIN - COLMAX, inclusive. if incre is positive, then the index values will be incremented. if incre is negative, then the kewords with index = COLMIN will be deleted and the index of higher numbered keywords will be decremented. */ { int nkeys, nmore, nrec, tstatus, i1; long ivalue; char rec[FLEN_CARD], q[FLEN_KEYWORD], newkey[FLEN_KEYWORD]; ffghsp(fptr, &nkeys, &nmore, status); /* get number of keywords */ /* go thru header starting with the 9th keyword looking for 'TxxxxNNN' */ for (nrec = 9; nrec <= nkeys; nrec++) { ffgrec(fptr, nrec, rec, status); if (rec[0] == 'T') { i1 = 0; strncpy(q, &rec[1], 4); if (!strncmp(q, "BCOL", 4) || !strncmp(q, "FORM", 4) || !strncmp(q, "TYPE", 4) || !strncmp(q, "SCAL", 4) || !strncmp(q, "UNIT", 4) || !strncmp(q, "NULL", 4) || !strncmp(q, "ZERO", 4) || !strncmp(q, "DISP", 4) || !strncmp(q, "LMIN", 4) || !strncmp(q, "LMAX", 4) || !strncmp(q, "DMIN", 4) || !strncmp(q, "DMAX", 4) || !strncmp(q, "CTYP", 4) || !strncmp(q, "CRPX", 4) || !strncmp(q, "CRVL", 4) || !strncmp(q, "CDLT", 4) || !strncmp(q, "CROT", 4) || !strncmp(q, "CUNI", 4) ) i1 = 5; else if (!strncmp(rec, "TDIM", 4) ) i1 = 4; if (i1) { /* try reading the index number suffix */ q[0] = '\0'; strncat(q, &rec[i1], 8 - i1); tstatus = 0; ffc2ii(q, &ivalue, &tstatus); if (tstatus == 0 && ivalue >= colmin && ivalue <= colmax) { if (incre <= 0 && ivalue == colmin) { ffdrec(fptr, nrec, status); /* delete keyword */ nkeys = nkeys - 1; nrec = nrec - 1; } else { ivalue = ivalue + incre; q[0] = '\0'; strncat(q, rec, i1); ffkeyn(q, ivalue, newkey, status); strncpy(rec, " ", 8); /* erase old keyword name */ i1 = strlen(newkey); strncpy(rec, newkey, i1); /* overwrite new keyword name */ ffmrec(fptr, nrec, rec, status); /* modify the record */ } } } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffshft(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG firstbyte, /* I - position of first byte in block to shift */ LONGLONG nbytes, /* I - size of block of bytes to shift */ LONGLONG nshift, /* I - size of shift in bytes (+ or -) */ int *status) /* IO - error status */ /* Shift block of bytes by nshift bytes (positive or negative). A positive nshift value moves the block down further in the file, while a negative value shifts the block towards the beginning of the file. */ { #define shftbuffsize 100000 long ntomov; LONGLONG ptr, ntodo; char buffer[shftbuffsize]; if (*status > 0) return(*status); ntodo = nbytes; /* total number of bytes to shift */ if (nshift > 0) /* start at the end of the block and work backwards */ ptr = firstbyte + nbytes; else /* start at the beginning of the block working forwards */ ptr = firstbyte; while (ntodo) { /* number of bytes to move at one time */ ntomov = (long) (minvalue(ntodo, shftbuffsize)); if (nshift > 0) /* if moving block down ... */ ptr -= ntomov; /* move to position and read the bytes to be moved */ ffmbyt(fptr, ptr, REPORT_EOF, status); ffgbyt(fptr, ntomov, buffer, status); /* move by shift amount and write the bytes */ ffmbyt(fptr, ptr + nshift, IGNORE_EOF, status); if (ffpbyt(fptr, ntomov, buffer, status) > 0) { ffpmsg("Error while shifting block (ffshft)"); return(*status); } ntodo -= ntomov; if (nshift < 0) /* if moving block up ... */ ptr += ntomov; } /* now overwrite the old data with fill */ if ((fptr->Fptr)->hdutype == ASCII_TBL) memset(buffer, 32, shftbuffsize); /* fill ASCII tables with spaces */ else memset(buffer, 0, shftbuffsize); /* fill other HDUs with zeros */ if (nshift < 0) { ntodo = -nshift; /* point to the end of the shifted block */ ptr = firstbyte + nbytes + nshift; } else { ntodo = nshift; /* point to original beginning of the block */ ptr = firstbyte; } ffmbyt(fptr, ptr, REPORT_EOF, status); while (ntodo) { ntomov = (long) (minvalue(ntodo, shftbuffsize)); ffpbyt(fptr, ntomov, buffer, status); ntodo -= ntomov; } return(*status); } healpy-1.10.3/cfitsio/edithdu.c0000664000175000017500000007472713010375005016573 0ustar zoncazonca00000000000000/* This file, edithdu.c, contains the FITSIO routines related to */ /* copying, inserting, or deleting HDUs in a FITS file */ /* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ #include #include #include "fitsio2.h" /*--------------------------------------------------------------------------*/ int ffcopy(fitsfile *infptr, /* I - FITS file pointer to input file */ fitsfile *outfptr, /* I - FITS file pointer to output file */ int morekeys, /* I - reserve space in output header */ int *status) /* IO - error status */ /* copy the CHDU from infptr to the CHDU of outfptr. This will also allocate space in the output header for MOREKY keywords */ { int nspace; if (*status > 0) return(*status); if (infptr == outfptr) return(*status = SAME_FILE); if (ffcphd(infptr, outfptr, status) ) /* copy the header keywords */ return(*status); if (morekeys > 0) { ffhdef(outfptr, morekeys, status); /* reserve space for more keywords */ } else { if (ffghsp(infptr, NULL, &nspace, status) > 0) /* get existing space */ return(*status); if (nspace > 0) { ffhdef(outfptr, nspace, status); /* preserve same amount of space */ if (nspace >= 35) { /* There is at least 1 full empty FITS block in the header. */ /* Physically write the END keyword at the beginning of the */ /* last block to preserve this extra space now rather than */ /* later. This is needed by the stream: driver which cannot */ /* seek back to the header to write the END keyword later. */ ffwend(outfptr, status); } } } ffcpdt(infptr, outfptr, status); /* now copy the data unit */ return(*status); } /*--------------------------------------------------------------------------*/ int ffcpfl(fitsfile *infptr, /* I - FITS file pointer to input file */ fitsfile *outfptr, /* I - FITS file pointer to output file */ int previous, /* I - copy any previous HDUs? */ int current, /* I - copy the current HDU? */ int following, /* I - copy any following HDUs? */ int *status) /* IO - error status */ /* copy all or part of the input file to the output file. */ { int hdunum, ii; if (*status > 0) return(*status); if (infptr == outfptr) return(*status = SAME_FILE); ffghdn(infptr, &hdunum); if (previous) { /* copy any previous HDUs */ for (ii=1; ii < hdunum; ii++) { ffmahd(infptr, ii, NULL, status); ffcopy(infptr, outfptr, 0, status); } } if (current && (*status <= 0) ) { /* copy current HDU */ ffmahd(infptr, hdunum, NULL, status); ffcopy(infptr, outfptr, 0, status); } if (following && (*status <= 0) ) { /* copy any remaining HDUs */ ii = hdunum + 1; while (1) { if (ffmahd(infptr, ii, NULL, status) ) { /* reset expected end of file status */ if (*status == END_OF_FILE) *status = 0; break; } if (ffcopy(infptr, outfptr, 0, status)) break; /* quit on unexpected error */ ii++; } } ffmahd(infptr, hdunum, NULL, status); /* restore initial position */ return(*status); } /*--------------------------------------------------------------------------*/ int ffcphd(fitsfile *infptr, /* I - FITS file pointer to input file */ fitsfile *outfptr, /* I - FITS file pointer to output file */ int *status) /* IO - error status */ /* copy the header keywords from infptr to outfptr. */ { int nkeys, ii, inPrim = 0, outPrim = 0; long naxis, naxes[1]; char *card, comm[FLEN_COMMENT]; char *tmpbuff; if (*status > 0) return(*status); if (infptr == outfptr) return(*status = SAME_FILE); /* set the input pointer to the correct HDU */ if (infptr->HDUposition != (infptr->Fptr)->curhdu) ffmahd(infptr, (infptr->HDUposition) + 1, NULL, status); if (ffghsp(infptr, &nkeys, NULL, status) > 0) /* get no. of keywords */ return(*status); /* create a memory buffer to hold the header records */ tmpbuff = (char*) malloc(nkeys*FLEN_CARD*sizeof(char)); if (!tmpbuff) return(*status = MEMORY_ALLOCATION); /* read all of the header records in the input HDU */ for (ii = 0; ii < nkeys; ii++) ffgrec(infptr, ii+1, tmpbuff + (ii * FLEN_CARD), status); if (infptr->HDUposition == 0) /* set flag if this is the Primary HDU */ inPrim = 1; /* if input is an image hdu, get the number of axes */ naxis = -1; /* negative if HDU is a table */ if ((infptr->Fptr)->hdutype == IMAGE_HDU) ffgkyj(infptr, "NAXIS", &naxis, NULL, status); /* set the output pointer to the correct HDU */ if (outfptr->HDUposition != (outfptr->Fptr)->curhdu) ffmahd(outfptr, (outfptr->HDUposition) + 1, NULL, status); /* check if output header is empty; if not create new empty HDU */ if ((outfptr->Fptr)->headend != (outfptr->Fptr)->headstart[(outfptr->Fptr)->curhdu] ) ffcrhd(outfptr, status); if (outfptr->HDUposition == 0) { if (naxis < 0) { /* the input HDU is a table, so we have to create */ /* a dummy Primary array before copying it to the output */ ffcrim(outfptr, 8, 0, naxes, status); ffcrhd(outfptr, status); /* create new empty HDU */ } else { /* set flag that this is the Primary HDU */ outPrim = 1; } } if (*status > 0) /* check for errors before proceeding */ { free(tmpbuff); return(*status); } if ( inPrim == 1 && outPrim == 0 ) { /* copying from primary array to image extension */ strcpy(comm, "IMAGE extension"); ffpkys(outfptr, "XTENSION", "IMAGE", comm, status); /* copy BITPIX through NAXISn keywords */ for (ii = 1; ii < 3 + naxis; ii++) { card = tmpbuff + (ii * FLEN_CARD); ffprec(outfptr, card, status); } strcpy(comm, "number of random group parameters"); ffpkyj(outfptr, "PCOUNT", 0, comm, status); strcpy(comm, "number of random groups"); ffpkyj(outfptr, "GCOUNT", 1, comm, status); /* copy remaining keywords, excluding EXTEND, and reference COMMENT keywords */ for (ii = 3 + naxis ; ii < nkeys; ii++) { card = tmpbuff+(ii * FLEN_CARD); if (FSTRNCMP(card, "EXTEND ", 8) && FSTRNCMP(card, "COMMENT FITS (Flexible Image Transport System) format is", 58) && FSTRNCMP(card, "COMMENT and Astrophysics', volume 376, page 3", 47) ) { ffprec(outfptr, card, status); } } } else if ( inPrim == 0 && outPrim == 1 ) { /* copying between image extension and primary array */ strcpy(comm, "file does conform to FITS standard"); ffpkyl(outfptr, "SIMPLE", TRUE, comm, status); /* copy BITPIX through NAXISn keywords */ for (ii = 1; ii < 3 + naxis; ii++) { card = tmpbuff + (ii * FLEN_CARD); ffprec(outfptr, card, status); } /* add the EXTEND keyword */ strcpy(comm, "FITS dataset may contain extensions"); ffpkyl(outfptr, "EXTEND", TRUE, comm, status); /* write standard block of self-documentating comments */ ffprec(outfptr, "COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy", status); ffprec(outfptr, "COMMENT and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H", status); /* copy remaining keywords, excluding pcount, gcount */ for (ii = 3 + naxis; ii < nkeys; ii++) { card = tmpbuff+(ii * FLEN_CARD); if (FSTRNCMP(card, "PCOUNT ", 8) && FSTRNCMP(card, "GCOUNT ", 8)) { ffprec(outfptr, card, status); } } } else { /* input and output HDUs are same type; simply copy all keywords */ for (ii = 0; ii < nkeys; ii++) { card = tmpbuff+(ii * FLEN_CARD); ffprec(outfptr, card, status); } } free(tmpbuff); return(*status); } /*--------------------------------------------------------------------------*/ int ffcpdt(fitsfile *infptr, /* I - FITS file pointer to input file */ fitsfile *outfptr, /* I - FITS file pointer to output file */ int *status) /* IO - error status */ { /* copy the data unit from the CHDU of infptr to the CHDU of outfptr. This will overwrite any data already in the outfptr CHDU. */ long nb, ii; LONGLONG indatastart, indataend, outdatastart; char buffer[2880]; if (*status > 0) return(*status); if (infptr == outfptr) return(*status = SAME_FILE); ffghadll(infptr, NULL, &indatastart, &indataend, status); ffghadll(outfptr, NULL, &outdatastart, NULL, status); /* Calculate the number of blocks to be copied */ nb = (long) ((indataend - indatastart) / 2880); if (nb > 0) { if (infptr->Fptr == outfptr->Fptr) { /* copying between 2 HDUs in the SAME file */ for (ii = 0; ii < nb; ii++) { ffmbyt(infptr, indatastart, REPORT_EOF, status); ffgbyt(infptr, 2880L, buffer, status); /* read input block */ ffmbyt(outfptr, outdatastart, IGNORE_EOF, status); ffpbyt(outfptr, 2880L, buffer, status); /* write output block */ indatastart += 2880; /* move address */ outdatastart += 2880; /* move address */ } } else { /* copying between HDUs in separate files */ /* move to the initial copy position in each of the files */ ffmbyt(infptr, indatastart, REPORT_EOF, status); ffmbyt(outfptr, outdatastart, IGNORE_EOF, status); for (ii = 0; ii < nb; ii++) { ffgbyt(infptr, 2880L, buffer, status); /* read input block */ ffpbyt(outfptr, 2880L, buffer, status); /* write output block */ } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffwrhdu(fitsfile *infptr, /* I - FITS file pointer to input file */ FILE *outstream, /* I - stream to write HDU to */ int *status) /* IO - error status */ { /* write the data unit from the CHDU of infptr to the output file stream */ long nb, ii; LONGLONG hdustart, hduend; char buffer[2880]; if (*status > 0) return(*status); ffghadll(infptr, &hdustart, NULL, &hduend, status); nb = (long) ((hduend - hdustart) / 2880); /* number of blocks to copy */ if (nb > 0) { /* move to the start of the HDU */ ffmbyt(infptr, hdustart, REPORT_EOF, status); for (ii = 0; ii < nb; ii++) { ffgbyt(infptr, 2880L, buffer, status); /* read input block */ fwrite(buffer, 1, 2880, outstream ); /* write to output stream */ } } return(*status); } /*--------------------------------------------------------------------------*/ int ffiimg(fitsfile *fptr, /* I - FITS file pointer */ int bitpix, /* I - bits per pixel */ int naxis, /* I - number of axes in the array */ long *naxes, /* I - size of each axis */ int *status) /* IO - error status */ /* insert an IMAGE extension following the current HDU */ { LONGLONG tnaxes[99]; int ii; if (*status > 0) return(*status); if (naxis > 99) { ffpmsg("NAXIS value is too large (>99) (ffiimg)"); return(*status = 212); } for (ii = 0; (ii < naxis); ii++) tnaxes[ii] = naxes[ii]; ffiimgll(fptr, bitpix, naxis, tnaxes, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffiimgll(fitsfile *fptr, /* I - FITS file pointer */ int bitpix, /* I - bits per pixel */ int naxis, /* I - number of axes in the array */ LONGLONG *naxes, /* I - size of each axis */ int *status) /* IO - error status */ /* insert an IMAGE extension following the current HDU */ { int bytlen, nexthdu, maxhdu, ii, onaxis; long nblocks; LONGLONG npixels, newstart, datasize; char errmsg[FLEN_ERRMSG], card[FLEN_CARD], naxiskey[FLEN_KEYWORD]; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); maxhdu = (fptr->Fptr)->maxhdu; if (*status != PREPEND_PRIMARY) { /* if the current header is completely empty ... */ if (( (fptr->Fptr)->headend == (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu]) /* or, if we are at the end of the file, ... */ || ( (((fptr->Fptr)->curhdu) == maxhdu ) && ((fptr->Fptr)->headstart[maxhdu + 1] >= (fptr->Fptr)->logfilesize ) ) ) { /* then simply append new image extension */ ffcrimll(fptr, bitpix, naxis, naxes, status); return(*status); } } if (bitpix == 8) bytlen = 1; else if (bitpix == 16) bytlen = 2; else if (bitpix == 32 || bitpix == -32) bytlen = 4; else if (bitpix == 64 || bitpix == -64) bytlen = 8; else { sprintf(errmsg, "Illegal value for BITPIX keyword: %d", bitpix); ffpmsg(errmsg); return(*status = BAD_BITPIX); /* illegal bitpix value */ } if (naxis < 0 || naxis > 999) { sprintf(errmsg, "Illegal value for NAXIS keyword: %d", naxis); ffpmsg(errmsg); return(*status = BAD_NAXIS); } for (ii = 0; ii < naxis; ii++) { if (naxes[ii] < 0) { sprintf(errmsg, "Illegal value for NAXIS%d keyword: %ld", ii + 1, (long) naxes[ii]); ffpmsg(errmsg); return(*status = BAD_NAXES); } } /* calculate number of pixels in the image */ if (naxis == 0) npixels = 0; else npixels = naxes[0]; for (ii = 1; ii < naxis; ii++) npixels = npixels * naxes[ii]; datasize = npixels * bytlen; /* size of image in bytes */ nblocks = (long) (((datasize + 2879) / 2880) + 1); /* +1 for the header */ if ((fptr->Fptr)->writemode == READWRITE) /* must have write access */ { /* close the CHDU */ ffrdef(fptr, status); /* scan header to redefine structure */ ffpdfl(fptr, status); /* insure correct data file values */ } else return(*status = READONLY_FILE); if (*status == PREPEND_PRIMARY) { /* inserting a new primary array; the current primary */ /* array must be transformed into an image extension. */ *status = 0; ffmahd(fptr, 1, NULL, status); /* move to the primary array */ ffgidm(fptr, &onaxis, status); if (onaxis > 0) ffkeyn("NAXIS",onaxis, naxiskey, status); else strcpy(naxiskey, "NAXIS"); ffgcrd(fptr, naxiskey, card, status); /* read last NAXIS keyword */ ffikyj(fptr, "PCOUNT", 0, "required keyword", status); /* add PCOUNT and */ ffikyj(fptr, "GCOUNT", 1, "required keyword", status); /* GCOUNT keywords */ if (*status > 0) return(*status); if (ffdkey(fptr, "EXTEND", status) ) /* delete the EXTEND keyword */ *status = 0; /* redefine internal structure for this HDU */ ffrdef(fptr, status); /* insert space for the primary array */ if (ffiblk(fptr, nblocks, -1, status) > 0) /* insert the blocks */ return(*status); nexthdu = 0; /* number of the new hdu */ newstart = 0; /* starting addr of HDU */ } else { nexthdu = ((fptr->Fptr)->curhdu) + 1; /* number of the next (new) hdu */ newstart = (fptr->Fptr)->headstart[nexthdu]; /* save starting addr of HDU */ (fptr->Fptr)->hdutype = IMAGE_HDU; /* so that correct fill value is used */ /* ffiblk also increments headstart for all following HDUs */ if (ffiblk(fptr, nblocks, 1, status) > 0) /* insert the blocks */ return(*status); } ((fptr->Fptr)->maxhdu)++; /* increment known number of HDUs in the file */ for (ii = (fptr->Fptr)->maxhdu; ii > (fptr->Fptr)->curhdu; ii--) (fptr->Fptr)->headstart[ii + 1] = (fptr->Fptr)->headstart[ii]; /* incre start addr */ if (nexthdu == 0) (fptr->Fptr)->headstart[1] = nblocks * 2880; /* start of the old Primary array */ (fptr->Fptr)->headstart[nexthdu] = newstart; /* set starting addr of HDU */ /* set default parameters for this new empty HDU */ (fptr->Fptr)->curhdu = nexthdu; /* we are now located at the next HDU */ fptr->HDUposition = nexthdu; /* we are now located at the next HDU */ (fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[nexthdu]; (fptr->Fptr)->headend = (fptr->Fptr)->headstart[nexthdu]; (fptr->Fptr)->datastart = ((fptr->Fptr)->headstart[nexthdu]) + 2880; (fptr->Fptr)->hdutype = IMAGE_HDU; /* might need to be reset... */ /* write the required header keywords */ ffphprll(fptr, TRUE, bitpix, naxis, naxes, 0, 1, TRUE, status); /* redefine internal structure for this HDU */ ffrdef(fptr, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffitab(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG naxis1, /* I - width of row in the table */ LONGLONG naxis2, /* I - number of rows in the table */ int tfields, /* I - number of columns in the table */ char **ttype, /* I - name of each column */ long *tbcol, /* I - byte offset in row to each column */ char **tform, /* I - value of TFORMn keyword for each column */ char **tunit, /* I - value of TUNITn keyword for each column */ const char *extnmx, /* I - value of EXTNAME keyword, if any */ int *status) /* IO - error status */ /* insert an ASCII table extension following the current HDU */ { int nexthdu, maxhdu, ii, nunit, nhead, ncols, gotmem = 0; long nblocks, rowlen; LONGLONG datasize, newstart; char errmsg[81], extnm[FLEN_VALUE]; if (*status > 0) return(*status); extnm[0] = '\0'; if (extnmx) strncat(extnm, extnmx, FLEN_VALUE-1); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); maxhdu = (fptr->Fptr)->maxhdu; /* if the current header is completely empty ... */ if (( (fptr->Fptr)->headend == (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] ) /* or, if we are at the end of the file, ... */ || ( (((fptr->Fptr)->curhdu) == maxhdu ) && ((fptr->Fptr)->headstart[maxhdu + 1] >= (fptr->Fptr)->logfilesize ) ) ) { /* then simply append new image extension */ ffcrtb(fptr, ASCII_TBL, naxis2, tfields, ttype, tform, tunit, extnm, status); return(*status); } if (naxis1 < 0) return(*status = NEG_WIDTH); else if (naxis2 < 0) return(*status = NEG_ROWS); else if (tfields < 0 || tfields > 999) { sprintf(errmsg, "Illegal value for TFIELDS keyword: %d", tfields); ffpmsg(errmsg); return(*status = BAD_TFIELDS); } /* count number of optional TUNIT keywords to be written */ nunit = 0; for (ii = 0; ii < tfields; ii++) { if (tunit && *tunit && *tunit[ii]) nunit++; } if (*extnm) nunit++; /* add one for the EXTNAME keyword */ rowlen = (long) naxis1; if (!tbcol || !tbcol[0] || (!naxis1 && tfields)) /* spacing not defined? */ { /* allocate mem for tbcol; malloc may have problems allocating small */ /* arrays, so allocate at least 20 bytes */ ncols = maxvalue(5, tfields); tbcol = (long *) calloc(ncols, sizeof(long)); if (tbcol) { gotmem = 1; /* calculate width of a row and starting position of each column. */ /* Each column will be separated by 1 blank space */ ffgabc(tfields, tform, 1, &rowlen, tbcol, status); } } nhead = (9 + (3 * tfields) + nunit + 35) / 36; /* no. of header blocks */ datasize = (LONGLONG)rowlen * naxis2; /* size of table in bytes */ nblocks = (long) (((datasize + 2879) / 2880) + nhead); /* size of HDU */ if ((fptr->Fptr)->writemode == READWRITE) /* must have write access */ { /* close the CHDU */ ffrdef(fptr, status); /* scan header to redefine structure */ ffpdfl(fptr, status); /* insure correct data file values */ } else return(*status = READONLY_FILE); nexthdu = ((fptr->Fptr)->curhdu) + 1; /* number of the next (new) hdu */ newstart = (fptr->Fptr)->headstart[nexthdu]; /* save starting addr of HDU */ (fptr->Fptr)->hdutype = ASCII_TBL; /* so that correct fill value is used */ /* ffiblk also increments headstart for all following HDUs */ if (ffiblk(fptr, nblocks, 1, status) > 0) /* insert the blocks */ { if (gotmem) free(tbcol); return(*status); } ((fptr->Fptr)->maxhdu)++; /* increment known number of HDUs in the file */ for (ii = (fptr->Fptr)->maxhdu; ii > (fptr->Fptr)->curhdu; ii--) (fptr->Fptr)->headstart[ii + 1] = (fptr->Fptr)->headstart[ii]; /* incre start addr */ (fptr->Fptr)->headstart[nexthdu] = newstart; /* set starting addr of HDU */ /* set default parameters for this new empty HDU */ (fptr->Fptr)->curhdu = nexthdu; /* we are now located at the next HDU */ fptr->HDUposition = nexthdu; /* we are now located at the next HDU */ (fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[nexthdu]; (fptr->Fptr)->headend = (fptr->Fptr)->headstart[nexthdu]; (fptr->Fptr)->datastart = ((fptr->Fptr)->headstart[nexthdu]) + (nhead * 2880); (fptr->Fptr)->hdutype = ASCII_TBL; /* might need to be reset... */ /* write the required header keywords */ ffphtb(fptr, rowlen, naxis2, tfields, ttype, tbcol, tform, tunit, extnm, status); if (gotmem) free(tbcol); /* redefine internal structure for this HDU */ ffrdef(fptr, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffibin(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG naxis2, /* I - number of rows in the table */ int tfields, /* I - number of columns in the table */ char **ttype, /* I - name of each column */ char **tform, /* I - value of TFORMn keyword for each column */ char **tunit, /* I - value of TUNITn keyword for each column */ const char *extnmx, /* I - value of EXTNAME keyword, if any */ LONGLONG pcount, /* I - size of special data area (heap) */ int *status) /* IO - error status */ /* insert a Binary table extension following the current HDU */ { int nexthdu, maxhdu, ii, nunit, nhead, datacode; LONGLONG naxis1; long nblocks, repeat, width; LONGLONG datasize, newstart; char errmsg[81], extnm[FLEN_VALUE]; if (*status > 0) return(*status); extnm[0] = '\0'; if (extnmx) strncat(extnm, extnmx, FLEN_VALUE-1); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); maxhdu = (fptr->Fptr)->maxhdu; /* if the current header is completely empty ... */ if (( (fptr->Fptr)->headend == (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] ) /* or, if we are at the end of the file, ... */ || ( (((fptr->Fptr)->curhdu) == maxhdu ) && ((fptr->Fptr)->headstart[maxhdu + 1] >= (fptr->Fptr)->logfilesize ) ) ) { /* then simply append new image extension */ ffcrtb(fptr, BINARY_TBL, naxis2, tfields, ttype, tform, tunit, extnm, status); return(*status); } if (naxis2 < 0) return(*status = NEG_ROWS); else if (tfields < 0 || tfields > 999) { sprintf(errmsg, "Illegal value for TFIELDS keyword: %d", tfields); ffpmsg(errmsg); return(*status = BAD_TFIELDS); } /* count number of optional TUNIT keywords to be written */ nunit = 0; for (ii = 0; ii < tfields; ii++) { if (tunit && *tunit && *tunit[ii]) nunit++; } if (*extnm) nunit++; /* add one for the EXTNAME keyword */ nhead = (9 + (2 * tfields) + nunit + 35) / 36; /* no. of header blocks */ /* calculate total width of the table */ naxis1 = 0; for (ii = 0; ii < tfields; ii++) { ffbnfm(tform[ii], &datacode, &repeat, &width, status); if (datacode == TBIT) naxis1 = naxis1 + ((repeat + 7) / 8); else if (datacode == TSTRING) naxis1 += repeat; else naxis1 = naxis1 + (repeat * width); } datasize = ((LONGLONG)naxis1 * naxis2) + pcount; /* size of table in bytes */ nblocks = (long) ((datasize + 2879) / 2880) + nhead; /* size of HDU */ if ((fptr->Fptr)->writemode == READWRITE) /* must have write access */ { /* close the CHDU */ ffrdef(fptr, status); /* scan header to redefine structure */ ffpdfl(fptr, status); /* insure correct data file values */ } else return(*status = READONLY_FILE); nexthdu = ((fptr->Fptr)->curhdu) + 1; /* number of the next (new) hdu */ newstart = (fptr->Fptr)->headstart[nexthdu]; /* save starting addr of HDU */ (fptr->Fptr)->hdutype = BINARY_TBL; /* so that correct fill value is used */ /* ffiblk also increments headstart for all following HDUs */ if (ffiblk(fptr, nblocks, 1, status) > 0) /* insert the blocks */ return(*status); ((fptr->Fptr)->maxhdu)++; /* increment known number of HDUs in the file */ for (ii = (fptr->Fptr)->maxhdu; ii > (fptr->Fptr)->curhdu; ii--) (fptr->Fptr)->headstart[ii + 1] = (fptr->Fptr)->headstart[ii]; /* incre start addr */ (fptr->Fptr)->headstart[nexthdu] = newstart; /* set starting addr of HDU */ /* set default parameters for this new empty HDU */ (fptr->Fptr)->curhdu = nexthdu; /* we are now located at the next HDU */ fptr->HDUposition = nexthdu; /* we are now located at the next HDU */ (fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[nexthdu]; (fptr->Fptr)->headend = (fptr->Fptr)->headstart[nexthdu]; (fptr->Fptr)->datastart = ((fptr->Fptr)->headstart[nexthdu]) + (nhead * 2880); (fptr->Fptr)->hdutype = BINARY_TBL; /* might need to be reset... */ /* write the required header keywords. This will write PCOUNT = 0 */ /* so that the variable length data will be written at the right place */ ffphbn(fptr, naxis2, tfields, ttype, tform, tunit, extnm, pcount, status); /* redefine internal structure for this HDU (with PCOUNT = 0) */ ffrdef(fptr, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffdhdu(fitsfile *fptr, /* I - FITS file pointer */ int *hdutype, /* O - type of the new CHDU after deletion */ int *status) /* IO - error status */ /* Delete the CHDU. If the CHDU is the primary array, then replace the HDU with an empty primary array with no data. Return the type of the new CHDU after the old CHDU is deleted. */ { int tmptype = 0; long nblocks, ii, naxes[1]; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); if ((fptr->Fptr)->curhdu == 0) /* replace primary array with null image */ { /* ignore any existing keywords */ (fptr->Fptr)->headend = 0; (fptr->Fptr)->nextkey = 0; /* write default primary array header */ ffphpr(fptr,1,8,0,naxes,0,1,1,status); /* calc number of blocks to delete (leave just 1 block) */ nblocks = (long) (( (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu + 1] - 2880 ) / 2880); /* ffdblk also updates the starting address of all following HDUs */ if (nblocks > 0) { if (ffdblk(fptr, nblocks, status) > 0) /* delete the HDU */ return(*status); } /* this might not be necessary, but is doesn't hurt */ (fptr->Fptr)->datastart = DATA_UNDEFINED; ffrdef(fptr, status); /* reinitialize the primary array */ } else { /* calc number of blocks to delete */ nblocks = (long) (( (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu + 1] - (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] ) / 2880); /* ffdblk also updates the starting address of all following HDUs */ if (ffdblk(fptr, nblocks, status) > 0) /* delete the HDU */ return(*status); /* delete the CHDU from the list of HDUs */ for (ii = (fptr->Fptr)->curhdu + 1; ii <= (fptr->Fptr)->maxhdu; ii++) (fptr->Fptr)->headstart[ii] = (fptr->Fptr)->headstart[ii + 1]; (fptr->Fptr)->headstart[(fptr->Fptr)->maxhdu + 1] = 0; ((fptr->Fptr)->maxhdu)--; /* decrement the known number of HDUs */ if (ffrhdu(fptr, &tmptype, status) > 0) /* initialize next HDU */ { /* failed (end of file?), so move back one HDU */ *status = 0; ffcmsg(); /* clear extraneous error messages */ ffgext(fptr, ((fptr->Fptr)->curhdu) - 1, &tmptype, status); } } if (hdutype) *hdutype = tmptype; return(*status); } healpy-1.10.3/cfitsio/eval.l0000664000175000017500000003743013010375005016073 0ustar zoncazonca00000000000000%{ /************************************************************************/ /* */ /* CFITSIO Lexical Parser */ /* */ /* This file is one of 3 files containing code which parses an */ /* arithmetic expression and evaluates it in the context of an input */ /* FITS file table extension. The CFITSIO lexical parser is divided */ /* into the following 3 parts/files: the CFITSIO "front-end", */ /* eval_f.c, contains the interface between the user/CFITSIO and the */ /* real core of the parser; the FLEX interpreter, eval_l.c, takes the */ /* input string and parses it into tokens and identifies the FITS */ /* information required to evaluate the expression (ie, keywords and */ /* columns); and, the BISON grammar and evaluation routines, eval_y.c, */ /* receives the FLEX output and determines and performs the actual */ /* operations. The files eval_l.c and eval_y.c are produced from */ /* running flex and bison on the files eval.l and eval.y, respectively. */ /* (flex and bison are available from any GNU archive: see www.gnu.org) */ /* */ /* The grammar rules, rather than evaluating the expression in situ, */ /* builds a tree, or Nodal, structure mapping out the order of */ /* operations and expression dependencies. This "compilation" process */ /* allows for much faster processing of multiple rows. This technique */ /* was developed by Uwe Lammers of the XMM Science Analysis System, */ /* although the CFITSIO implementation is entirely code original. */ /* */ /* */ /* Modification History: */ /* */ /* Kent Blackburn c1992 Original parser code developed for the */ /* FTOOLS software package, in particular, */ /* the fselect task. */ /* Kent Blackburn c1995 BIT column support added */ /* Peter D Wilson Feb 1998 Vector column support added */ /* Peter D Wilson May 1998 Ported to CFITSIO library. User */ /* interface routines written, in essence */ /* making fselect, fcalc, and maketime */ /* capabilities available to all tools */ /* via single function calls. */ /* Peter D Wilson Jun 1998 Major rewrite of parser core, so as to */ /* create a run-time evaluation tree, */ /* inspired by the work of Uwe Lammers, */ /* resulting in a speed increase of */ /* 10-100 times. */ /* Peter D Wilson Jul 1998 gtifilter(a,b,c,d) function added */ /* Peter D Wilson Aug 1998 regfilter(a,b,c,d) function added */ /* Peter D Wilson Jul 1999 Make parser fitsfile-independent, */ /* allowing a purely vector-based usage */ /* */ /************************************************************************/ #include #include #include #ifdef sparc #include #else #include #endif #include "eval_defs.h" ParseData gParse; /* Global structure holding all parser information */ /***** Internal functions *****/ int yyGetVariable( char *varName, YYSTYPE *varVal ); static int find_variable( char *varName ); static int expr_read( char *buf, int nbytes ); /***** Definitions *****/ #define YY_NO_UNPUT /* Don't include YYUNPUT function */ #define YY_NEVER_INTERACTIVE 1 #define MAXCHR 256 #define MAXBIT 128 #define OCT_0 "000" #define OCT_1 "001" #define OCT_2 "010" #define OCT_3 "011" #define OCT_4 "100" #define OCT_5 "101" #define OCT_6 "110" #define OCT_7 "111" #define OCT_X "xxx" #define HEX_0 "0000" #define HEX_1 "0001" #define HEX_2 "0010" #define HEX_3 "0011" #define HEX_4 "0100" #define HEX_5 "0101" #define HEX_6 "0110" #define HEX_7 "0111" #define HEX_8 "1000" #define HEX_9 "1001" #define HEX_A "1010" #define HEX_B "1011" #define HEX_C "1100" #define HEX_D "1101" #define HEX_E "1110" #define HEX_F "1111" #define HEX_X "xxxx" /* MJT - 13 June 1996 read from buffer instead of stdin (as per old ftools.skel) */ #undef YY_INPUT #define YY_INPUT(buf,result,max_size) \ if ( (result = expr_read( (char *) buf, max_size )) < 0 ) \ YY_FATAL_ERROR( "read() in flex scanner failed" ); %} bit ([bB][01xX]+) oct ([oO][01234567xX]+) hex ([hH][0123456789aAbBcCdDeEfFxX]+) integer [0-9]+ boolean (t|f|T|F) real ([0-9]*"."[0-9]+)|([0-9]*"."*[0-9]+[eEdD][+-]?[0-9]+)|([0-9]*".") constant ("#"[a-zA-Z0-9_]+)|("#""$"[^\n]*"$") string ([\"][^\"\n]*[\"])|([\'][^\'\n]*[\']) variable ([a-zA-Z_][a-zA-Z0-9_]*)|("$"[^$\n]*"$") function [a-zA-Z][a-zA-Z0-9]+"(" intcast ("(int)"|"(INT)") fltcast ("(float)"|"(FLOAT)"|"(double)"|"(DOUBLE)") power ("^"|"**") not ("!"|".not."|".NOT."|"not."|"NOT.") or ("||"|".or."|".OR."|"or."|"OR.") and ("&&"|".and."|".AND."|"and."|"AND.") equal ("=="|".eq."|".EQ."|"eq."|"EQ.") not_equal ("!="|".ne."|".NE."|"ne."|"NE.") greater (">"|".gt."|".GT."|"gt."|"GT.") lesser ("<"|".lt."|".LT."|"lt."|"LT.") greater_eq (">="|"=>"|".ge."|".GE."|"ge."|"GE.") lesser_eq ("<="|"=<"|".le."|".LE."|"le."|"LE.") nl \n %% [ \t]+ ; {bit} { int len; len = strlen(yytext); while (yytext[len] == ' ') len--; len = len - 1; strncpy(yylval.str,&yytext[1],len); yylval.str[len] = '\0'; return( BITSTR ); } {oct} { int len; char tmpstring[256]; char bitstring[256]; len = strlen(yytext); if (len >= 256) { char errMsg[100]; gParse.status = PARSE_SYNTAX_ERR; strcpy (errMsg,"Bit string exceeds maximum length: '"); strncat(errMsg, &(yytext[0]), 20); strcat (errMsg,"...'"); ffpmsg (errMsg); len = 0; } else { while (yytext[len] == ' ') len--; len = len - 1; strncpy(tmpstring,&yytext[1],len); } tmpstring[len] = '\0'; bitstring[0] = '\0'; len = 0; while ( tmpstring[len] != '\0') { switch ( tmpstring[len] ) { case '0': strcat(bitstring,OCT_0); break; case '1': strcat(bitstring,OCT_1); break; case '2': strcat(bitstring,OCT_2); break; case '3': strcat(bitstring,OCT_3); break; case '4': strcat(bitstring,OCT_4); break; case '5': strcat(bitstring,OCT_5); break; case '6': strcat(bitstring,OCT_6); break; case '7': strcat(bitstring,OCT_7); break; case 'x': case 'X': strcat(bitstring,OCT_X); break; } len++; } strcpy( yylval.str, bitstring ); return( BITSTR ); } {hex} { int len; char tmpstring[256]; char bitstring[256]; len = strlen(yytext); if (len >= 256) { char errMsg[100]; gParse.status = PARSE_SYNTAX_ERR; strcpy (errMsg,"Hex string exceeds maximum length: '"); strncat(errMsg, &(yytext[0]), 20); strcat (errMsg,"...'"); ffpmsg (errMsg); len = 0; } else { while (yytext[len] == ' ') len--; len = len - 1; strncpy(tmpstring,&yytext[1],len); } tmpstring[len] = '\0'; bitstring[0] = '\0'; len = 0; while ( tmpstring[len] != '\0') { switch ( tmpstring[len] ) { case '0': strcat(bitstring,HEX_0); break; case '1': strcat(bitstring,HEX_1); break; case '2': strcat(bitstring,HEX_2); break; case '3': strcat(bitstring,HEX_3); break; case '4': strcat(bitstring,HEX_4); break; case '5': strcat(bitstring,HEX_5); break; case '6': strcat(bitstring,HEX_6); break; case '7': strcat(bitstring,HEX_7); break; case '8': strcat(bitstring,HEX_8); break; case '9': strcat(bitstring,HEX_9); break; case 'a': case 'A': strcat(bitstring,HEX_A); break; case 'b': case 'B': strcat(bitstring,HEX_B); break; case 'c': case 'C': strcat(bitstring,HEX_C); break; case 'd': case 'D': strcat(bitstring,HEX_D); break; case 'e': case 'E': strcat(bitstring,HEX_E); break; case 'f': case 'F': strcat(bitstring,HEX_F); break; case 'x': case 'X': strcat(bitstring,HEX_X); break; } len++; } strcpy( yylval.str, bitstring ); return( BITSTR ); } {integer} { yylval.lng = atol(yytext); return( LONG ); } {boolean} { if ((yytext[0] == 't') || (yytext[0] == 'T')) yylval.log = 1; else yylval.log = 0; return( BOOLEAN ); } {real} { yylval.dbl = atof(yytext); return( DOUBLE ); } {constant} { if( !strcasecmp(yytext,"#PI") ) { yylval.dbl = (double)(4) * atan((double)(1)); return( DOUBLE ); } else if( !strcasecmp(yytext,"#E") ) { yylval.dbl = exp((double)(1)); return( DOUBLE ); } else if( !strcasecmp(yytext,"#DEG") ) { yylval.dbl = ((double)4)*atan((double)1)/((double)180); return( DOUBLE ); } else if( !strcasecmp(yytext,"#ROW") ) { return( ROWREF ); } else if( !strcasecmp(yytext,"#NULL") ) { return( NULLREF ); } else if( !strcasecmp(yytext,"#SNULL") ) { return( SNULLREF ); } else { int len; if (yytext[1] == '$') { len = strlen(yytext) - 3; yylval.str[0] = '#'; strncpy(yylval.str+1,&yytext[2],len); yylval.str[len+1] = '\0'; yytext = yylval.str; } return( (*gParse.getData)(yytext, &yylval) ); } } {string} { int len; len = strlen(yytext) - 2; if (len >= MAX_STRLEN) { char errMsg[100]; gParse.status = PARSE_SYNTAX_ERR; strcpy (errMsg,"String exceeds maximum length: '"); strncat(errMsg, &(yytext[1]), 20); strcat (errMsg,"...'"); ffpmsg (errMsg); len = 0; } else { strncpy(yylval.str,&yytext[1],len); } yylval.str[len] = '\0'; return( STRING ); } {variable} { int len,type; if (yytext[0] == '$') { len = strlen(yytext) - 2; strncpy(yylval.str,&yytext[1],len); yylval.str[len] = '\0'; yytext = yylval.str; } type = yyGetVariable(yytext, &yylval); return( type ); } {function} { char *fname; int len=0; fname = &yylval.str[0]; while( (fname[len]=toupper(yytext[len])) ) len++; if( FSTRCMP(fname,"BOX(")==0 || FSTRCMP(fname,"CIRCLE(")==0 || FSTRCMP(fname,"ELLIPSE(")==0 || FSTRCMP(fname,"NEAR(")==0 || FSTRCMP(fname,"ISNULL(")==0 ) /* Return type is always boolean */ return( BFUNCTION ); else if( FSTRCMP(fname,"GTIFILTER(")==0 ) return( GTIFILTER ); else if( FSTRCMP(fname,"REGFILTER(")==0 ) return( REGFILTER ); else if( FSTRCMP(fname,"STRSTR(")==0 ) return( IFUNCTION ); /* Returns integer */ else return( FUNCTION ); } {intcast} { return( INTCAST ); } {fltcast} { return( FLTCAST ); } {power} { return( POWER ); } {not} { return( NOT ); } {or} { return( OR ); } {and} { return( AND ); } {equal} { return( EQ ); } {not_equal} { return( NE ); } {greater} { return( GT ); } {lesser} { return( LT ); } {greater_eq} { return( GTE ); } {lesser_eq} { return( LTE ); } {nl} { return( '\n' ); } . { return( yytext[0] ); } %% int yywrap() { /* MJT -- 13 June 1996 Supplied for compatibility with pre-2.5.1 versions of flex which do not recognize %option noyywrap */ return(1); } /* expr_read is lifted from old ftools.skel. Now we can use any version of flex with no .skel file necessary! MJT - 13 June 1996 keep a memory of how many bytes have been read previously, so that an unlimited-sized buffer can be supported. PDW - 28 Feb 1998 */ static int expr_read(char *buf, int nbytes) { int n; n = 0; if( !gParse.is_eobuf ) { do { buf[n++] = gParse.expr[gParse.index++]; } while ((nlng = varNum; } return( type ); } static int find_variable(char *varName) { int i; if( gParse.nCols ) for( i=0; i c2) return(1); if (c1 == 0) return(0); s1++; s2++; } } int strncasecmp(const char *s1, const char *s2, size_t n) { char c1, c2; for (; n-- ;) { c1 = toupper( *s1 ); c2 = toupper( *s2 ); if (c1 < c2) return(-1); if (c1 > c2) return(1); if (c1 == 0) return(0); s1++; s2++; } return(0); } #endif healpy-1.10.3/cfitsio/eval.y0000664000175000017500000053305013010375005016107 0ustar zoncazonca00000000000000%{ /************************************************************************/ /* */ /* CFITSIO Lexical Parser */ /* */ /* This file is one of 3 files containing code which parses an */ /* arithmetic expression and evaluates it in the context of an input */ /* FITS file table extension. The CFITSIO lexical parser is divided */ /* into the following 3 parts/files: the CFITSIO "front-end", */ /* eval_f.c, contains the interface between the user/CFITSIO and the */ /* real core of the parser; the FLEX interpreter, eval_l.c, takes the */ /* input string and parses it into tokens and identifies the FITS */ /* information required to evaluate the expression (ie, keywords and */ /* columns); and, the BISON grammar and evaluation routines, eval_y.c, */ /* receives the FLEX output and determines and performs the actual */ /* operations. The files eval_l.c and eval_y.c are produced from */ /* running flex and bison on the files eval.l and eval.y, respectively. */ /* (flex and bison are available from any GNU archive: see www.gnu.org) */ /* */ /* The grammar rules, rather than evaluating the expression in situ, */ /* builds a tree, or Nodal, structure mapping out the order of */ /* operations and expression dependencies. This "compilation" process */ /* allows for much faster processing of multiple rows. This technique */ /* was developed by Uwe Lammers of the XMM Science Analysis System, */ /* although the CFITSIO implementation is entirely code original. */ /* */ /* */ /* Modification History: */ /* */ /* Kent Blackburn c1992 Original parser code developed for the */ /* FTOOLS software package, in particular, */ /* the fselect task. */ /* Kent Blackburn c1995 BIT column support added */ /* Peter D Wilson Feb 1998 Vector column support added */ /* Peter D Wilson May 1998 Ported to CFITSIO library. User */ /* interface routines written, in essence */ /* making fselect, fcalc, and maketime */ /* capabilities available to all tools */ /* via single function calls. */ /* Peter D Wilson Jun 1998 Major rewrite of parser core, so as to */ /* create a run-time evaluation tree, */ /* inspired by the work of Uwe Lammers, */ /* resulting in a speed increase of */ /* 10-100 times. */ /* Peter D Wilson Jul 1998 gtifilter(a,b,c,d) function added */ /* Peter D Wilson Aug 1998 regfilter(a,b,c,d) function added */ /* Peter D Wilson Jul 1999 Make parser fitsfile-independent, */ /* allowing a purely vector-based usage */ /* Craig B Markwardt Jun 2004 Add MEDIAN() function */ /* Craig B Markwardt Jun 2004 Add SUM(), and MIN/MAX() for bit arrays */ /* Craig B Markwardt Jun 2004 Allow subscripting of nX bit arrays */ /* Craig B Markwardt Jun 2004 Implement statistical functions */ /* NVALID(), AVERAGE(), and STDDEV() */ /* for integer and floating point vectors */ /* Craig B Markwardt Jun 2004 Use NULL values for range errors instead*/ /* of throwing a parse error */ /* Craig B Markwardt Oct 2004 Add ACCUM() and SEQDIFF() functions */ /* Craig B Markwardt Feb 2005 Add ANGSEP() function */ /* Craig B Markwardt Aug 2005 CIRCLE, BOX, ELLIPSE, NEAR and REGFILTER*/ /* functions now accept vector arguments */ /* Craig B Markwardt Sum 2006 Add RANDOMN() and RANDOMP() functions */ /* Craig B Markwardt Mar 2007 Allow arguments to RANDOM and RANDOMN to*/ /* determine the output dimensions */ /* Craig B Markwardt Aug 2009 Add substring STRMID() and string search*/ /* STRSTR() functions; more overflow checks*/ /* */ /************************************************************************/ #define APPROX 1.0e-7 #include "eval_defs.h" #include "region.h" #include #include #ifndef alloca #define alloca malloc #endif /* Shrink the initial stack depth to keep local data <32K (mac limit) */ /* yacc will allocate more space if needed, though. */ #define YYINITDEPTH 100 /***************************************************************/ /* Replace Bison's BACKUP macro with one that fixes a bug -- */ /* must update state after popping the stack -- and allows */ /* popping multiple terms at one time. */ /***************************************************************/ #define YYNEWBACKUP(token, value) \ do \ if (yychar == YYEMPTY ) \ { yychar = (token); \ memcpy( &yylval, &(value), sizeof(value) ); \ yychar1 = YYTRANSLATE (yychar); \ while (yylen--) YYPOPSTACK; \ yystate = *yyssp; \ goto yybackup; \ } \ else \ { yyerror ("syntax error: cannot back up"); YYERROR; } \ while (0) /***************************************************************/ /* Useful macros for accessing/testing Nodes */ /***************************************************************/ #define TEST(a) if( (a)<0 ) YYERROR #define SIZE(a) gParse.Nodes[ a ].value.nelem #define TYPE(a) gParse.Nodes[ a ].type #define OPER(a) gParse.Nodes[ a ].operation #define PROMOTE(a,b) if( TYPE(a) > TYPE(b) ) \ b = New_Unary( TYPE(a), 0, b ); \ else if( TYPE(a) < TYPE(b) ) \ a = New_Unary( TYPE(b), 0, a ); /***** Internal functions *****/ #ifdef __cplusplus extern "C" { #endif static int Alloc_Node ( void ); static void Free_Last_Node( void ); static void Evaluate_Node ( int thisNode ); static int New_Const ( int returnType, void *value, long len ); static int New_Column( int ColNum ); static int New_Offset( int ColNum, int offset ); static int New_Unary ( int returnType, int Op, int Node1 ); static int New_BinOp ( int returnType, int Node1, int Op, int Node2 ); static int New_Func ( int returnType, funcOp Op, int nNodes, int Node1, int Node2, int Node3, int Node4, int Node5, int Node6, int Node7 ); static int New_FuncSize( int returnType, funcOp Op, int nNodes, int Node1, int Node2, int Node3, int Node4, int Node5, int Node6, int Node7, int Size); static int New_Deref ( int Var, int nDim, int Dim1, int Dim2, int Dim3, int Dim4, int Dim5 ); static int New_GTI ( char *fname, int Node1, char *start, char *stop ); static int New_REG ( char *fname, int NodeX, int NodeY, char *colNames ); static int New_Vector( int subNode ); static int Close_Vec ( int vecNode ); static int Locate_Col( Node *this ); static int Test_Dims ( int Node1, int Node2 ); static void Copy_Dims ( int Node1, int Node2 ); static void Allocate_Ptrs( Node *this ); static void Do_Unary ( Node *this ); static void Do_Offset ( Node *this ); static void Do_BinOp_bit ( Node *this ); static void Do_BinOp_str ( Node *this ); static void Do_BinOp_log ( Node *this ); static void Do_BinOp_lng ( Node *this ); static void Do_BinOp_dbl ( Node *this ); static void Do_Func ( Node *this ); static void Do_Deref ( Node *this ); static void Do_GTI ( Node *this ); static void Do_REG ( Node *this ); static void Do_Vector ( Node *this ); static long Search_GTI ( double evtTime, long nGTI, double *start, double *stop, int ordered ); static char saobox (double xcen, double ycen, double xwid, double ywid, double rot, double xcol, double ycol); static char ellipse(double xcen, double ycen, double xrad, double yrad, double rot, double xcol, double ycol); static char circle (double xcen, double ycen, double rad, double xcol, double ycol); static char bnear (double x, double y, double tolerance); static char bitcmp (char *bitstrm1, char *bitstrm2); static char bitlgte(char *bits1, int oper, char *bits2); static void bitand(char *result, char *bitstrm1, char *bitstrm2); static void bitor (char *result, char *bitstrm1, char *bitstrm2); static void bitnot(char *result, char *bits); static int cstrmid(char *dest_str, int dest_len, char *src_str, int src_len, int pos); static void yyerror(char *msg); #ifdef __cplusplus } #endif %} %union { int Node; /* Index of Node */ double dbl; /* real value */ long lng; /* integer value */ char log; /* logical value */ char str[MAX_STRLEN]; /* string value */ } %token BOOLEAN /* First 3 must be in order of */ %token LONG /* increasing promotion for later use */ %token DOUBLE %token STRING %token BITSTR %token FUNCTION %token BFUNCTION /* Bit function */ %token IFUNCTION /* Integer function */ %token GTIFILTER %token REGFILTER %token COLUMN %token BCOLUMN %token SCOLUMN %token BITCOL %token ROWREF %token NULLREF %token SNULLREF %type expr %type bexpr %type sexpr %type bits %type vector %type bvector %left ',' '=' ':' '{' '}' %right '?' %left OR %left AND %left EQ NE '~' %left GT LT LTE GTE %left '+' '-' '%' %left '*' '/' %left '|' '&' %right POWER %left NOT %left INTCAST FLTCAST %left UMINUS %left '[' %right ACCUM DIFF %% lines: /* nothing ; was | lines line */ | lines line ; line: '\n' {} | expr '\n' { if( $1<0 ) { yyerror("Couldn't build node structure: out of memory?"); YYERROR; } gParse.resultNode = $1; } | bexpr '\n' { if( $1<0 ) { yyerror("Couldn't build node structure: out of memory?"); YYERROR; } gParse.resultNode = $1; } | sexpr '\n' { if( $1<0 ) { yyerror("Couldn't build node structure: out of memory?"); YYERROR; } gParse.resultNode = $1; } | bits '\n' { if( $1<0 ) { yyerror("Couldn't build node structure: out of memory?"); YYERROR; } gParse.resultNode = $1; } | error '\n' { yyerrok; } ; bvector: '{' bexpr { $$ = New_Vector( $2 ); TEST($$); } | bvector ',' bexpr { if( gParse.Nodes[$1].nSubNodes >= MAXSUBS ) { $1 = Close_Vec( $1 ); TEST($1); $$ = New_Vector( $1 ); TEST($$); } else { $$ = $1; } gParse.Nodes[$$].SubNodes[ gParse.Nodes[$$].nSubNodes++ ] = $3; } ; vector: '{' expr { $$ = New_Vector( $2 ); TEST($$); } | vector ',' expr { if( TYPE($1) < TYPE($3) ) TYPE($1) = TYPE($3); if( gParse.Nodes[$1].nSubNodes >= MAXSUBS ) { $1 = Close_Vec( $1 ); TEST($1); $$ = New_Vector( $1 ); TEST($$); } else { $$ = $1; } gParse.Nodes[$$].SubNodes[ gParse.Nodes[$$].nSubNodes++ ] = $3; } | vector ',' bexpr { if( gParse.Nodes[$1].nSubNodes >= MAXSUBS ) { $1 = Close_Vec( $1 ); TEST($1); $$ = New_Vector( $1 ); TEST($$); } else { $$ = $1; } gParse.Nodes[$$].SubNodes[ gParse.Nodes[$$].nSubNodes++ ] = $3; } | bvector ',' expr { TYPE($1) = TYPE($3); if( gParse.Nodes[$1].nSubNodes >= MAXSUBS ) { $1 = Close_Vec( $1 ); TEST($1); $$ = New_Vector( $1 ); TEST($$); } else { $$ = $1; } gParse.Nodes[$$].SubNodes[ gParse.Nodes[$$].nSubNodes++ ] = $3; } ; expr: vector '}' { $$ = Close_Vec( $1 ); TEST($$); } ; bexpr: bvector '}' { $$ = Close_Vec( $1 ); TEST($$); } ; bits: BITSTR { $$ = New_Const( BITSTR, $1, strlen($1)+1 ); TEST($$); SIZE($$) = strlen($1); } | BITCOL { $$ = New_Column( $1 ); TEST($$); } | BITCOL '{' expr '}' { if( TYPE($3) != LONG || OPER($3) != CONST_OP ) { yyerror("Offset argument must be a constant integer"); YYERROR; } $$ = New_Offset( $1, $3 ); TEST($$); } | bits '&' bits { $$ = New_BinOp( BITSTR, $1, '&', $3 ); TEST($$); SIZE($$) = ( SIZE($1)>SIZE($3) ? SIZE($1) : SIZE($3) ); } | bits '|' bits { $$ = New_BinOp( BITSTR, $1, '|', $3 ); TEST($$); SIZE($$) = ( SIZE($1)>SIZE($3) ? SIZE($1) : SIZE($3) ); } | bits '+' bits { if (SIZE($1)+SIZE($3) >= MAX_STRLEN) { yyerror("Combined bit string size exceeds " MAX_STRLEN_S " bits"); YYERROR; } $$ = New_BinOp( BITSTR, $1, '+', $3 ); TEST($$); SIZE($$) = SIZE($1) + SIZE($3); } | bits '[' expr ']' { $$ = New_Deref( $1, 1, $3, 0, 0, 0, 0 ); TEST($$); } | bits '[' expr ',' expr ']' { $$ = New_Deref( $1, 2, $3, $5, 0, 0, 0 ); TEST($$); } | bits '[' expr ',' expr ',' expr ']' { $$ = New_Deref( $1, 3, $3, $5, $7, 0, 0 ); TEST($$); } | bits '[' expr ',' expr ',' expr ',' expr ']' { $$ = New_Deref( $1, 4, $3, $5, $7, $9, 0 ); TEST($$); } | bits '[' expr ',' expr ',' expr ',' expr ',' expr ']' { $$ = New_Deref( $1, 5, $3, $5, $7, $9, $11 ); TEST($$); } | NOT bits { $$ = New_Unary( BITSTR, NOT, $2 ); TEST($$); } | '(' bits ')' { $$ = $2; } ; expr: LONG { $$ = New_Const( LONG, &($1), sizeof(long) ); TEST($$); } | DOUBLE { $$ = New_Const( DOUBLE, &($1), sizeof(double) ); TEST($$); } | COLUMN { $$ = New_Column( $1 ); TEST($$); } | COLUMN '{' expr '}' { if( TYPE($3) != LONG || OPER($3) != CONST_OP ) { yyerror("Offset argument must be a constant integer"); YYERROR; } $$ = New_Offset( $1, $3 ); TEST($$); } | ROWREF { $$ = New_Func( LONG, row_fct, 0, 0, 0, 0, 0, 0, 0, 0 ); } | NULLREF { $$ = New_Func( LONG, null_fct, 0, 0, 0, 0, 0, 0, 0, 0 ); } | expr '%' expr { PROMOTE($1,$3); $$ = New_BinOp( TYPE($1), $1, '%', $3 ); TEST($$); } | expr '+' expr { PROMOTE($1,$3); $$ = New_BinOp( TYPE($1), $1, '+', $3 ); TEST($$); } | expr '-' expr { PROMOTE($1,$3); $$ = New_BinOp( TYPE($1), $1, '-', $3 ); TEST($$); } | expr '*' expr { PROMOTE($1,$3); $$ = New_BinOp( TYPE($1), $1, '*', $3 ); TEST($$); } | expr '/' expr { PROMOTE($1,$3); $$ = New_BinOp( TYPE($1), $1, '/', $3 ); TEST($$); } | expr POWER expr { PROMOTE($1,$3); $$ = New_BinOp( TYPE($1), $1, POWER, $3 ); TEST($$); } | '+' expr %prec UMINUS { $$ = $2; } | '-' expr %prec UMINUS { $$ = New_Unary( TYPE($2), UMINUS, $2 ); TEST($$); } | '(' expr ')' { $$ = $2; } | expr '*' bexpr { $3 = New_Unary( TYPE($1), 0, $3 ); $$ = New_BinOp( TYPE($1), $1, '*', $3 ); TEST($$); } | bexpr '*' expr { $1 = New_Unary( TYPE($3), 0, $1 ); $$ = New_BinOp( TYPE($3), $1, '*', $3 ); TEST($$); } | bexpr '?' expr ':' expr { PROMOTE($3,$5); if( ! Test_Dims($3,$5) ) { yyerror("Incompatible dimensions in '?:' arguments"); YYERROR; } $$ = New_Func( 0, ifthenelse_fct, 3, $3, $5, $1, 0, 0, 0, 0 ); TEST($$); if( SIZE($3)=SIZE($4) && Test_Dims( $2, $4 ) ) { PROMOTE($2,$4); $$ = New_Func( 0, defnull_fct, 2, $2, $4, 0, 0, 0, 0, 0 ); TEST($$); } else { yyerror("Dimensions of DEFNULL arguments " "are not compatible"); YYERROR; } } else if (FSTRCMP($1,"ARCTAN2(") == 0) { if( TYPE($2) != DOUBLE ) $2 = New_Unary( DOUBLE, 0, $2 ); if( TYPE($4) != DOUBLE ) $4 = New_Unary( DOUBLE, 0, $4 ); if( Test_Dims( $2, $4 ) ) { $$ = New_Func( 0, atan2_fct, 2, $2, $4, 0, 0, 0, 0, 0 ); TEST($$); if( SIZE($2)=SIZE($4) && Test_Dims( $2, $4 ) ) { $$ = New_Func( 0, defnull_fct, 2, $2, $4, 0, 0, 0, 0, 0 ); TEST($$); } else { yyerror("Dimensions of DEFNULL arguments are not compatible"); YYERROR; } } else { yyerror("Boolean Function(expr,expr) not supported"); YYERROR; } } | BFUNCTION expr ',' expr ',' expr ')' { if( TYPE($2) != DOUBLE ) $2 = New_Unary( DOUBLE, 0, $2 ); if( TYPE($4) != DOUBLE ) $4 = New_Unary( DOUBLE, 0, $4 ); if( TYPE($6) != DOUBLE ) $6 = New_Unary( DOUBLE, 0, $6 ); if( ! (Test_Dims( $2, $4 ) && Test_Dims( $4, $6 ) ) ) { yyerror("Dimensions of NEAR arguments " "are not compatible"); YYERROR; } else { if (FSTRCMP($1,"NEAR(") == 0) { $$ = New_Func( BOOLEAN, near_fct, 3, $2, $4, $6, 0, 0, 0, 0 ); } else { yyerror("Boolean Function not supported"); YYERROR; } TEST($$); if( SIZE($$)= MAX_STRLEN) { yyerror("Combined string size exceeds " MAX_STRLEN_S " characters"); YYERROR; } $$ = New_BinOp( STRING, $1, '+', $3 ); TEST($$); SIZE($$) = SIZE($1) + SIZE($3); } | bexpr '?' sexpr ':' sexpr { int outSize; if( SIZE($1)!=1 ) { yyerror("Cannot have a vector string column"); YYERROR; } /* Since the output can be calculated now, as a constant scalar, we must precalculate the output size, in order to avoid an overflow. */ outSize = SIZE($3); if (SIZE($5) > outSize) outSize = SIZE($5); $$ = New_FuncSize( 0, ifthenelse_fct, 3, $3, $5, $1, 0, 0, 0, 0, outSize); TEST($$); if( SIZE($3) outSize) outSize = SIZE($4); $$ = New_FuncSize( 0, defnull_fct, 2, $2, $4, 0, 0, 0, 0, 0, outSize ); TEST($$); if( SIZE($4)>SIZE($2) ) SIZE($$) = SIZE($4); } else { yyerror("Function(string,string) not supported"); YYERROR; } } | FUNCTION sexpr ',' expr ',' expr ')' { if (FSTRCMP($1,"STRMID(") == 0) { int len; if( TYPE($4) != LONG || SIZE($4) != 1 || TYPE($6) != LONG || SIZE($6) != 1) { yyerror("When using STRMID(S,P,N), P and N must be integers (and not vector columns)"); YYERROR; } if (OPER($6) == CONST_OP) { /* Constant value: use that directly */ len = (gParse.Nodes[$6].value.data.lng); } else { /* Variable value: use the maximum possible (from $2) */ len = SIZE($2); } if (len <= 0 || len >= MAX_STRLEN) { yyerror("STRMID(S,P,N), N must be 1-" MAX_STRLEN_S); YYERROR; } $$ = New_FuncSize( 0, strmid_fct, 3, $2, $4,$6,0,0,0,0,len); TEST($$); } else { yyerror("Function(string,expr,expr) not supported"); YYERROR; } } ; %% /*************************************************************************/ /* Start of "New" routines which build the expression Nodal structure */ /*************************************************************************/ static int Alloc_Node( void ) { /* Use this for allocation to guarantee *Nodes */ Node *newNodePtr; /* survives on failure, making it still valid */ /* while working our way out of this error */ if( gParse.nNodes == gParse.nNodesAlloc ) { if( gParse.Nodes ) { gParse.nNodesAlloc += gParse.nNodesAlloc; newNodePtr = (Node *)realloc( gParse.Nodes, sizeof(Node)*gParse.nNodesAlloc ); } else { gParse.nNodesAlloc = 100; newNodePtr = (Node *)malloc ( sizeof(Node)*gParse.nNodesAlloc ); } if( newNodePtr ) { gParse.Nodes = newNodePtr; } else { gParse.status = MEMORY_ALLOCATION; return( -1 ); } } return ( gParse.nNodes++ ); } static void Free_Last_Node( void ) { if( gParse.nNodes ) gParse.nNodes--; } static int New_Const( int returnType, void *value, long len ) { Node *this; int n; n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = CONST_OP; /* Flag a constant */ this->DoOp = NULL; this->nSubNodes = 0; this->type = returnType; memcpy( &(this->value.data), value, len ); this->value.undef = NULL; this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; } return(n); } static int New_Column( int ColNum ) { Node *this; int n, i; n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = -ColNum; this->DoOp = NULL; this->nSubNodes = 0; this->type = gParse.varData[ColNum].type; this->value.nelem = gParse.varData[ColNum].nelem; this->value.naxis = gParse.varData[ColNum].naxis; for( i=0; ivalue.naxes[i] = gParse.varData[ColNum].naxes[i]; } return(n); } static int New_Offset( int ColNum, int offsetNode ) { Node *this; int n, i, colNode; colNode = New_Column( ColNum ); if( colNode<0 ) return(-1); n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = '{'; this->DoOp = Do_Offset; this->nSubNodes = 2; this->SubNodes[0] = colNode; this->SubNodes[1] = offsetNode; this->type = gParse.varData[ColNum].type; this->value.nelem = gParse.varData[ColNum].nelem; this->value.naxis = gParse.varData[ColNum].naxis; for( i=0; ivalue.naxes[i] = gParse.varData[ColNum].naxes[i]; } return(n); } static int New_Unary( int returnType, int Op, int Node1 ) { Node *this, *that; int i,n; if( Node1<0 ) return(-1); that = gParse.Nodes + Node1; if( !Op ) Op = returnType; if( (Op==DOUBLE || Op==FLTCAST) && that->type==DOUBLE ) return( Node1 ); if( (Op==LONG || Op==INTCAST) && that->type==LONG ) return( Node1 ); if( (Op==BOOLEAN ) && that->type==BOOLEAN ) return( Node1 ); n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = Op; this->DoOp = Do_Unary; this->nSubNodes = 1; this->SubNodes[0] = Node1; this->type = returnType; that = gParse.Nodes + Node1; /* Reset in case .Nodes mv'd */ this->value.nelem = that->value.nelem; this->value.naxis = that->value.naxis; for( i=0; ivalue.naxis; i++ ) this->value.naxes[i] = that->value.naxes[i]; if( that->operation==CONST_OP ) this->DoOp( this ); } return( n ); } static int New_BinOp( int returnType, int Node1, int Op, int Node2 ) { Node *this,*that1,*that2; int n,i,constant; if( Node1<0 || Node2<0 ) return(-1); n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = Op; this->nSubNodes = 2; this->SubNodes[0]= Node1; this->SubNodes[1]= Node2; this->type = returnType; that1 = gParse.Nodes + Node1; that2 = gParse.Nodes + Node2; constant = (that1->operation==CONST_OP && that2->operation==CONST_OP); if( that1->type!=STRING && that1->type!=BITSTR ) if( !Test_Dims( Node1, Node2 ) ) { Free_Last_Node(); yyerror("Array sizes/dims do not match for binary operator"); return(-1); } if( that1->value.nelem == 1 ) that1 = that2; this->value.nelem = that1->value.nelem; this->value.naxis = that1->value.naxis; for( i=0; ivalue.naxis; i++ ) this->value.naxes[i] = that1->value.naxes[i]; if ( Op == ACCUM && that1->type == BITSTR ) { /* ACCUM is rank-reducing on bit strings */ this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; } /* Both subnodes should be of same time */ switch( that1->type ) { case BITSTR: this->DoOp = Do_BinOp_bit; break; case STRING: this->DoOp = Do_BinOp_str; break; case BOOLEAN: this->DoOp = Do_BinOp_log; break; case LONG: this->DoOp = Do_BinOp_lng; break; case DOUBLE: this->DoOp = Do_BinOp_dbl; break; } if( constant ) this->DoOp( this ); } return( n ); } static int New_Func( int returnType, funcOp Op, int nNodes, int Node1, int Node2, int Node3, int Node4, int Node5, int Node6, int Node7 ) { return New_FuncSize(returnType, Op, nNodes, Node1, Node2, Node3, Node4, Node5, Node6, Node7, 0); } static int New_FuncSize( int returnType, funcOp Op, int nNodes, int Node1, int Node2, int Node3, int Node4, int Node5, int Node6, int Node7, int Size ) /* If returnType==0 , use Node1's type and vector sizes as returnType, */ /* else return a single value of type returnType */ { Node *this, *that; int i,n,constant; if( Node1<0 || Node2<0 || Node3<0 || Node4<0 || Node5<0 || Node6<0 || Node7<0 ) return(-1); n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = (int)Op; this->DoOp = Do_Func; this->nSubNodes = nNodes; this->SubNodes[0] = Node1; this->SubNodes[1] = Node2; this->SubNodes[2] = Node3; this->SubNodes[3] = Node4; this->SubNodes[4] = Node5; this->SubNodes[5] = Node6; this->SubNodes[6] = Node7; i = constant = nNodes; /* Functions with zero params are not const */ if (Op == poirnd_fct) constant = 0; /* Nor is Poisson deviate */ while( i-- ) constant = ( constant && OPER(this->SubNodes[i]) == CONST_OP ); if( returnType ) { this->type = returnType; this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; } else { that = gParse.Nodes + Node1; this->type = that->type; this->value.nelem = that->value.nelem; this->value.naxis = that->value.naxis; for( i=0; ivalue.naxis; i++ ) this->value.naxes[i] = that->value.naxes[i]; } /* Force explicit size before evaluating */ if (Size > 0) this->value.nelem = Size; if( constant ) this->DoOp( this ); } return( n ); } static int New_Deref( int Var, int nDim, int Dim1, int Dim2, int Dim3, int Dim4, int Dim5 ) { int n, idx, constant; long elem=0; Node *this, *theVar, *theDim[MAXDIMS]; if( Var<0 || Dim1<0 || Dim2<0 || Dim3<0 || Dim4<0 || Dim5<0 ) return(-1); theVar = gParse.Nodes + Var; if( theVar->operation==CONST_OP || theVar->value.nelem==1 ) { yyerror("Cannot index a scalar value"); return(-1); } n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->nSubNodes = nDim+1; theVar = gParse.Nodes + (this->SubNodes[0]=Var); theDim[0] = gParse.Nodes + (this->SubNodes[1]=Dim1); theDim[1] = gParse.Nodes + (this->SubNodes[2]=Dim2); theDim[2] = gParse.Nodes + (this->SubNodes[3]=Dim3); theDim[3] = gParse.Nodes + (this->SubNodes[4]=Dim4); theDim[4] = gParse.Nodes + (this->SubNodes[5]=Dim5); constant = theVar->operation==CONST_OP; for( idx=0; idxoperation==CONST_OP); for( idx=0; idxvalue.nelem>1 ) { Free_Last_Node(); yyerror("Cannot use an array as an index value"); return(-1); } else if( theDim[idx]->type!=LONG ) { Free_Last_Node(); yyerror("Index value must be an integer type"); return(-1); } this->operation = '['; this->DoOp = Do_Deref; this->type = theVar->type; if( theVar->value.naxis == nDim ) { /* All dimensions specified */ this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; } else if( nDim==1 ) { /* Dereference only one dimension */ elem=1; this->value.naxis = theVar->value.naxis-1; for( idx=0; idxvalue.naxis; idx++ ) { elem *= ( this->value.naxes[idx] = theVar->value.naxes[idx] ); } this->value.nelem = elem; } else { Free_Last_Node(); yyerror("Must specify just one or all indices for vector"); return(-1); } if( constant ) this->DoOp( this ); } return(n); } extern int yyGetVariable( char *varName, YYSTYPE *varVal ); static int New_GTI( char *fname, int Node1, char *start, char *stop ) { fitsfile *fptr; Node *this, *that0, *that1; int type,i,n, startCol, stopCol, Node0; int hdutype, hdunum, evthdu, samefile, extvers, movetotype, tstat; char extname[100]; long nrows; double timeZeroI[2], timeZeroF[2], dt, timeSpan; char xcol[20], xexpr[20]; YYSTYPE colVal; if( Node1==-99 ) { type = yyGetVariable( "TIME", &colVal ); if( type==COLUMN ) { Node1 = New_Column( (int)colVal.lng ); } else { yyerror("Could not build TIME column for GTIFILTER"); return(-1); } } Node1 = New_Unary( DOUBLE, 0, Node1 ); Node0 = Alloc_Node(); /* This will hold the START/STOP times */ if( Node1<0 || Node0<0 ) return(-1); /* Record current HDU number in case we need to move within this file */ fptr = gParse.def_fptr; ffghdn( fptr, &evthdu ); /* Look for TIMEZERO keywords in current extension */ tstat = 0; if( ffgkyd( fptr, "TIMEZERO", timeZeroI, NULL, &tstat ) ) { tstat = 0; if( ffgkyd( fptr, "TIMEZERI", timeZeroI, NULL, &tstat ) ) { timeZeroI[0] = timeZeroF[0] = 0.0; } else if( ffgkyd( fptr, "TIMEZERF", timeZeroF, NULL, &tstat ) ) { timeZeroF[0] = 0.0; } } else { timeZeroF[0] = 0.0; } /* Resolve filename parameter */ switch( fname[0] ) { case '\0': samefile = 1; hdunum = 1; break; case '[': samefile = 1; i = 1; while( fname[i] != '\0' && fname[i] != ']' ) i++; if( fname[i] ) { fname[i] = '\0'; fname++; ffexts( fname, &hdunum, extname, &extvers, &movetotype, xcol, xexpr, &gParse.status ); if( *extname ) { ffmnhd( fptr, movetotype, extname, extvers, &gParse.status ); ffghdn( fptr, &hdunum ); } else if( hdunum ) { ffmahd( fptr, ++hdunum, &hdutype, &gParse.status ); } else if( !gParse.status ) { yyerror("Cannot use primary array for GTI filter"); return( -1 ); } } else { yyerror("File extension specifier lacks closing ']'"); return( -1 ); } break; case '+': samefile = 1; hdunum = atoi( fname ) + 1; if( hdunum>1 ) ffmahd( fptr, hdunum, &hdutype, &gParse.status ); else { yyerror("Cannot use primary array for GTI filter"); return( -1 ); } break; default: samefile = 0; if( ! ffopen( &fptr, fname, READONLY, &gParse.status ) ) ffghdn( fptr, &hdunum ); break; } if( gParse.status ) return(-1); /* If at primary, search for GTI extension */ if( hdunum==1 ) { while( 1 ) { hdunum++; if( ffmahd( fptr, hdunum, &hdutype, &gParse.status ) ) break; if( hdutype==IMAGE_HDU ) continue; tstat = 0; if( ffgkys( fptr, "EXTNAME", extname, NULL, &tstat ) ) continue; ffupch( extname ); if( strstr( extname, "GTI" ) ) break; } if( gParse.status ) { if( gParse.status==END_OF_FILE ) yyerror("GTI extension not found in this file"); return(-1); } } /* Locate START/STOP Columns */ ffgcno( fptr, CASEINSEN, start, &startCol, &gParse.status ); ffgcno( fptr, CASEINSEN, stop, &stopCol, &gParse.status ); if( gParse.status ) return(-1); /* Look for TIMEZERO keywords in GTI extension */ tstat = 0; if( ffgkyd( fptr, "TIMEZERO", timeZeroI+1, NULL, &tstat ) ) { tstat = 0; if( ffgkyd( fptr, "TIMEZERI", timeZeroI+1, NULL, &tstat ) ) { timeZeroI[1] = timeZeroF[1] = 0.0; } else if( ffgkyd( fptr, "TIMEZERF", timeZeroF+1, NULL, &tstat ) ) { timeZeroF[1] = 0.0; } } else { timeZeroF[1] = 0.0; } n = Alloc_Node(); if( n >= 0 ) { this = gParse.Nodes + n; this->nSubNodes = 2; this->SubNodes[1] = Node1; this->operation = (int)gtifilt_fct; this->DoOp = Do_GTI; this->type = BOOLEAN; that1 = gParse.Nodes + Node1; this->value.nelem = that1->value.nelem; this->value.naxis = that1->value.naxis; for( i=0; i < that1->value.naxis; i++ ) this->value.naxes[i] = that1->value.naxes[i]; /* Init START/STOP node to be treated as a "constant" */ this->SubNodes[0] = Node0; that0 = gParse.Nodes + Node0; that0->operation = CONST_OP; that0->DoOp = NULL; that0->value.data.ptr= NULL; /* Read in START/STOP times */ if( ffgkyj( fptr, "NAXIS2", &nrows, NULL, &gParse.status ) ) return(-1); that0->value.nelem = nrows; if( nrows ) { that0->value.data.dblptr = (double*)malloc( 2*nrows*sizeof(double) ); if( !that0->value.data.dblptr ) { gParse.status = MEMORY_ALLOCATION; return(-1); } ffgcvd( fptr, startCol, 1L, 1L, nrows, 0.0, that0->value.data.dblptr, &i, &gParse.status ); ffgcvd( fptr, stopCol, 1L, 1L, nrows, 0.0, that0->value.data.dblptr+nrows, &i, &gParse.status ); if( gParse.status ) { free( that0->value.data.dblptr ); return(-1); } /* Test for fully time-ordered GTI... both START && STOP */ that0->type = 1; /* Assume yes */ i = nrows; while( --i ) if( that0->value.data.dblptr[i-1] >= that0->value.data.dblptr[i] || that0->value.data.dblptr[i-1+nrows] >= that0->value.data.dblptr[i+nrows] ) { that0->type = 0; break; } /* Handle TIMEZERO offset, if any */ dt = (timeZeroI[1] - timeZeroI[0]) + (timeZeroF[1] - timeZeroF[0]); timeSpan = that0->value.data.dblptr[nrows+nrows-1] - that0->value.data.dblptr[0]; if( fabs( dt / timeSpan ) > 1e-12 ) { for( i=0; i<(nrows+nrows); i++ ) that0->value.data.dblptr[i] += dt; } } if( OPER(Node1)==CONST_OP ) this->DoOp( this ); } if( samefile ) ffmahd( fptr, evthdu, &hdutype, &gParse.status ); else ffclos( fptr, &gParse.status ); return( n ); } static int New_REG( char *fname, int NodeX, int NodeY, char *colNames ) { Node *this, *that0; int type, n, Node0; int Xcol, Ycol, tstat; WCSdata wcs; SAORegion *Rgn; char *cX, *cY; YYSTYPE colVal; if( NodeX==-99 ) { type = yyGetVariable( "X", &colVal ); if( type==COLUMN ) { NodeX = New_Column( (int)colVal.lng ); } else { yyerror("Could not build X column for REGFILTER"); return(-1); } } if( NodeY==-99 ) { type = yyGetVariable( "Y", &colVal ); if( type==COLUMN ) { NodeY = New_Column( (int)colVal.lng ); } else { yyerror("Could not build Y column for REGFILTER"); return(-1); } } NodeX = New_Unary( DOUBLE, 0, NodeX ); NodeY = New_Unary( DOUBLE, 0, NodeY ); Node0 = Alloc_Node(); /* This will hold the Region Data */ if( NodeX<0 || NodeY<0 || Node0<0 ) return(-1); if( ! (Test_Dims( NodeX, NodeY ) ) ) { yyerror("Dimensions of REGFILTER arguments are not compatible"); return (-1); } n = Alloc_Node(); if( n >= 0 ) { this = gParse.Nodes + n; this->nSubNodes = 3; this->SubNodes[0] = Node0; this->SubNodes[1] = NodeX; this->SubNodes[2] = NodeY; this->operation = (int)regfilt_fct; this->DoOp = Do_REG; this->type = BOOLEAN; this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; Copy_Dims(n, NodeX); if( SIZE(NodeX)operation = CONST_OP; that0->DoOp = NULL; /* Identify what columns to use for WCS information */ Xcol = Ycol = 0; if( *colNames ) { /* Use the column names in this string for WCS info */ while( *colNames==' ' ) colNames++; cX = cY = colNames; while( *cY && *cY!=' ' && *cY!=',' ) cY++; if( *cY ) *(cY++) = '\0'; while( *cY==' ' ) cY++; if( !*cY ) { yyerror("Could not extract valid pair of column names from REGFILTER"); Free_Last_Node(); return( -1 ); } fits_get_colnum( gParse.def_fptr, CASEINSEN, cX, &Xcol, &gParse.status ); fits_get_colnum( gParse.def_fptr, CASEINSEN, cY, &Ycol, &gParse.status ); if( gParse.status ) { yyerror("Could not locate columns indicated for WCS info"); Free_Last_Node(); return( -1 ); } } else { /* Try to find columns used in X/Y expressions */ Xcol = Locate_Col( gParse.Nodes + NodeX ); Ycol = Locate_Col( gParse.Nodes + NodeY ); if( Xcol<0 || Ycol<0 ) { yyerror("Found multiple X/Y column references in REGFILTER"); Free_Last_Node(); return( -1 ); } } /* Now, get the WCS info, if it exists, from the indicated columns */ wcs.exists = 0; if( Xcol>0 && Ycol>0 ) { tstat = 0; ffgtcs( gParse.def_fptr, Xcol, Ycol, &wcs.xrefval, &wcs.yrefval, &wcs.xrefpix, &wcs.yrefpix, &wcs.xinc, &wcs.yinc, &wcs.rot, wcs.type, &tstat ); if( tstat==NO_WCS_KEY ) { wcs.exists = 0; } else if( tstat ) { gParse.status = tstat; Free_Last_Node(); return( -1 ); } else { wcs.exists = 1; } } /* Read in Region file */ fits_read_rgnfile( fname, &wcs, &Rgn, &gParse.status ); if( gParse.status ) { Free_Last_Node(); return( -1 ); } that0->value.data.ptr = Rgn; if( OPER(NodeX)==CONST_OP && OPER(NodeY)==CONST_OP ) this->DoOp( this ); } return( n ); } static int New_Vector( int subNode ) { Node *this, *that; int n; n = Alloc_Node(); if( n >= 0 ) { this = gParse.Nodes + n; that = gParse.Nodes + subNode; this->type = that->type; this->nSubNodes = 1; this->SubNodes[0] = subNode; this->operation = '{'; this->DoOp = Do_Vector; } return( n ); } static int Close_Vec( int vecNode ) { Node *this; int n, nelem=0; this = gParse.Nodes + vecNode; for( n=0; n < this->nSubNodes; n++ ) { if( TYPE( this->SubNodes[n] ) != this->type ) { this->SubNodes[n] = New_Unary( this->type, 0, this->SubNodes[n] ); if( this->SubNodes[n]<0 ) return(-1); } nelem += SIZE(this->SubNodes[n]); } this->value.naxis = 1; this->value.nelem = nelem; this->value.naxes[0] = nelem; return( vecNode ); } static int Locate_Col( Node *this ) /* Locate the TABLE column number of any columns in "this" calculation. */ /* Return ZERO if none found, or negative if more than 1 found. */ { Node *that; int i, col=0, newCol, nfound=0; if( this->nSubNodes==0 && this->operation<=0 && this->operation!=CONST_OP ) return gParse.colData[ - this->operation].colnum; for( i=0; inSubNodes; i++ ) { that = gParse.Nodes + this->SubNodes[i]; if( that->operation>0 ) { newCol = Locate_Col( that ); if( newCol<=0 ) { nfound += -newCol; } else { if( !nfound ) { col = newCol; nfound++; } else if( col != newCol ) { nfound++; } } } else if( that->operation!=CONST_OP ) { /* Found a Column */ newCol = gParse.colData[- that->operation].colnum; if( !nfound ) { col = newCol; nfound++; } else if( col != newCol ) { nfound++; } } } if( nfound!=1 ) return( - nfound ); else return( col ); } static int Test_Dims( int Node1, int Node2 ) { Node *that1, *that2; int valid, i; if( Node1<0 || Node2<0 ) return(0); that1 = gParse.Nodes + Node1; that2 = gParse.Nodes + Node2; if( that1->value.nelem==1 || that2->value.nelem==1 ) valid = 1; else if( that1->type==that2->type && that1->value.nelem==that2->value.nelem && that1->value.naxis==that2->value.naxis ) { valid = 1; for( i=0; ivalue.naxis; i++ ) { if( that1->value.naxes[i]!=that2->value.naxes[i] ) valid = 0; } } else valid = 0; return( valid ); } static void Copy_Dims( int Node1, int Node2 ) { Node *that1, *that2; int i; if( Node1<0 || Node2<0 ) return; that1 = gParse.Nodes + Node1; that2 = gParse.Nodes + Node2; that1->value.nelem = that2->value.nelem; that1->value.naxis = that2->value.naxis; for( i=0; ivalue.naxis; i++ ) that1->value.naxes[i] = that2->value.naxes[i]; } /********************************************************************/ /* Routines for actually evaluating the expression start here */ /********************************************************************/ void Evaluate_Parser( long firstRow, long nRows ) /***********************************************************************/ /* Reset the parser for processing another batch of data... */ /* firstRow: Row number of the first element to evaluate */ /* nRows: Number of rows to be processed */ /* Initialize each COLUMN node so that its UNDEF and DATA pointers */ /* point to the appropriate column arrays. */ /* Finally, call Evaluate_Node for final node. */ /***********************************************************************/ { int i, column; long offset, rowOffset; gParse.firstRow = firstRow; gParse.nRows = nRows; /* Reset Column Nodes' pointers to point to right data and UNDEF arrays */ rowOffset = firstRow - gParse.firstDataRow; for( i=0; i 0 || OPER(i) == CONST_OP ) continue; column = -OPER(i); offset = gParse.varData[column].nelem * rowOffset; gParse.Nodes[i].value.undef = gParse.varData[column].undef + offset; switch( gParse.Nodes[i].type ) { case BITSTR: gParse.Nodes[i].value.data.strptr = (char**)gParse.varData[column].data + rowOffset; gParse.Nodes[i].value.undef = NULL; break; case STRING: gParse.Nodes[i].value.data.strptr = (char**)gParse.varData[column].data + rowOffset; gParse.Nodes[i].value.undef = gParse.varData[column].undef + rowOffset; break; case BOOLEAN: gParse.Nodes[i].value.data.logptr = (char*)gParse.varData[column].data + offset; break; case LONG: gParse.Nodes[i].value.data.lngptr = (long*)gParse.varData[column].data + offset; break; case DOUBLE: gParse.Nodes[i].value.data.dblptr = (double*)gParse.varData[column].data + offset; break; } } Evaluate_Node( gParse.resultNode ); } static void Evaluate_Node( int thisNode ) /**********************************************************************/ /* Recursively evaluate thisNode's subNodes, then call one of the */ /* Do_ functions pointed to by thisNode's DoOp element. */ /**********************************************************************/ { Node *this; int i; if( gParse.status ) return; this = gParse.Nodes + thisNode; if( this->operation>0 ) { /* <=0 indicate constants and columns */ i = this->nSubNodes; while( i-- ) { Evaluate_Node( this->SubNodes[i] ); if( gParse.status ) return; } this->DoOp( this ); } } static void Allocate_Ptrs( Node *this ) { long elem, row, size; if( this->type==BITSTR || this->type==STRING ) { this->value.data.strptr = (char**)malloc( gParse.nRows * sizeof(char*) ); if( this->value.data.strptr ) { this->value.data.strptr[0] = (char*)malloc( gParse.nRows * (this->value.nelem+2) * sizeof(char) ); if( this->value.data.strptr[0] ) { row = 0; while( (++row)value.data.strptr[row] = this->value.data.strptr[row-1] + this->value.nelem+1; } if( this->type==STRING ) { this->value.undef = this->value.data.strptr[row-1] + this->value.nelem+1; } else { this->value.undef = NULL; /* BITSTRs don't use undef array */ } } else { gParse.status = MEMORY_ALLOCATION; free( this->value.data.strptr ); } } else { gParse.status = MEMORY_ALLOCATION; } } else { elem = this->value.nelem * gParse.nRows; switch( this->type ) { case DOUBLE: size = sizeof( double ); break; case LONG: size = sizeof( long ); break; case BOOLEAN: size = sizeof( char ); break; default: size = 1; break; } this->value.data.ptr = calloc(size+1, elem); if( this->value.data.ptr==NULL ) { gParse.status = MEMORY_ALLOCATION; } else { this->value.undef = (char *)this->value.data.ptr + elem*size; } } } static void Do_Unary( Node *this ) { Node *that; long elem; that = gParse.Nodes + this->SubNodes[0]; if( that->operation==CONST_OP ) { /* Operating on a constant! */ switch( this->operation ) { case DOUBLE: case FLTCAST: if( that->type==LONG ) this->value.data.dbl = (double)that->value.data.lng; else if( that->type==BOOLEAN ) this->value.data.dbl = ( that->value.data.log ? 1.0 : 0.0 ); break; case LONG: case INTCAST: if( that->type==DOUBLE ) this->value.data.lng = (long)that->value.data.dbl; else if( that->type==BOOLEAN ) this->value.data.lng = ( that->value.data.log ? 1L : 0L ); break; case BOOLEAN: if( that->type==DOUBLE ) this->value.data.log = ( that->value.data.dbl != 0.0 ); else if( that->type==LONG ) this->value.data.log = ( that->value.data.lng != 0L ); break; case UMINUS: if( that->type==DOUBLE ) this->value.data.dbl = - that->value.data.dbl; else if( that->type==LONG ) this->value.data.lng = - that->value.data.lng; break; case NOT: if( that->type==BOOLEAN ) this->value.data.log = ( ! that->value.data.log ); else if( that->type==BITSTR ) bitnot( this->value.data.str, that->value.data.str ); break; } this->operation = CONST_OP; } else { Allocate_Ptrs( this ); if( !gParse.status ) { if( this->type!=BITSTR ) { elem = gParse.nRows; if( this->type!=STRING ) elem *= this->value.nelem; while( elem-- ) this->value.undef[elem] = that->value.undef[elem]; } elem = gParse.nRows * this->value.nelem; switch( this->operation ) { case BOOLEAN: if( that->type==DOUBLE ) while( elem-- ) this->value.data.logptr[elem] = ( that->value.data.dblptr[elem] != 0.0 ); else if( that->type==LONG ) while( elem-- ) this->value.data.logptr[elem] = ( that->value.data.lngptr[elem] != 0L ); break; case DOUBLE: case FLTCAST: if( that->type==LONG ) while( elem-- ) this->value.data.dblptr[elem] = (double)that->value.data.lngptr[elem]; else if( that->type==BOOLEAN ) while( elem-- ) this->value.data.dblptr[elem] = ( that->value.data.logptr[elem] ? 1.0 : 0.0 ); break; case LONG: case INTCAST: if( that->type==DOUBLE ) while( elem-- ) this->value.data.lngptr[elem] = (long)that->value.data.dblptr[elem]; else if( that->type==BOOLEAN ) while( elem-- ) this->value.data.lngptr[elem] = ( that->value.data.logptr[elem] ? 1L : 0L ); break; case UMINUS: if( that->type==DOUBLE ) { while( elem-- ) this->value.data.dblptr[elem] = - that->value.data.dblptr[elem]; } else if( that->type==LONG ) { while( elem-- ) this->value.data.lngptr[elem] = - that->value.data.lngptr[elem]; } break; case NOT: if( that->type==BOOLEAN ) { while( elem-- ) this->value.data.logptr[elem] = ( ! that->value.data.logptr[elem] ); } else if( that->type==BITSTR ) { elem = gParse.nRows; while( elem-- ) bitnot( this->value.data.strptr[elem], that->value.data.strptr[elem] ); } break; } } } if( that->operation>0 ) { free( that->value.data.ptr ); } } static void Do_Offset( Node *this ) { Node *col; long fRow, nRowOverlap, nRowReload, rowOffset; long nelem, elem, offset, nRealElem; int status; col = gParse.Nodes + this->SubNodes[0]; rowOffset = gParse.Nodes[ this->SubNodes[1] ].value.data.lng; Allocate_Ptrs( this ); fRow = gParse.firstRow + rowOffset; if( this->type==STRING || this->type==BITSTR ) nRealElem = 1; else nRealElem = this->value.nelem; nelem = nRealElem; if( fRow < gParse.firstDataRow ) { /* Must fill in data at start of array */ nRowReload = gParse.firstDataRow - fRow; if( nRowReload > gParse.nRows ) nRowReload = gParse.nRows; nRowOverlap = gParse.nRows - nRowReload; offset = 0; /* NULLify any values falling out of bounds */ while( fRow<1 && nRowReload>0 ) { if( this->type == BITSTR ) { nelem = this->value.nelem; this->value.data.strptr[offset][ nelem ] = '\0'; while( nelem-- ) this->value.data.strptr[offset][nelem] = '0'; offset++; } else { while( nelem-- ) this->value.undef[offset++] = 1; } nelem = nRealElem; fRow++; nRowReload--; } } else if( fRow + gParse.nRows > gParse.firstDataRow + gParse.nDataRows ) { /* Must fill in data at end of array */ nRowReload = (fRow+gParse.nRows) - (gParse.firstDataRow+gParse.nDataRows); if( nRowReload>gParse.nRows ) { nRowReload = gParse.nRows; } else { fRow = gParse.firstDataRow + gParse.nDataRows; } nRowOverlap = gParse.nRows - nRowReload; offset = nRowOverlap * nelem; /* NULLify any values falling out of bounds */ elem = gParse.nRows * nelem; while( fRow+nRowReload>gParse.totalRows && nRowReload>0 ) { if( this->type == BITSTR ) { nelem = this->value.nelem; elem--; this->value.data.strptr[elem][ nelem ] = '\0'; while( nelem-- ) this->value.data.strptr[elem][nelem] = '0'; } else { while( nelem-- ) this->value.undef[--elem] = 1; } nelem = nRealElem; nRowReload--; } } else { nRowReload = 0; nRowOverlap = gParse.nRows; offset = 0; } if( nRowReload>0 ) { switch( this->type ) { case BITSTR: case STRING: status = (*gParse.loadData)( -col->operation, fRow, nRowReload, this->value.data.strptr+offset, this->value.undef+offset ); break; case BOOLEAN: status = (*gParse.loadData)( -col->operation, fRow, nRowReload, this->value.data.logptr+offset, this->value.undef+offset ); break; case LONG: status = (*gParse.loadData)( -col->operation, fRow, nRowReload, this->value.data.lngptr+offset, this->value.undef+offset ); break; case DOUBLE: status = (*gParse.loadData)( -col->operation, fRow, nRowReload, this->value.data.dblptr+offset, this->value.undef+offset ); break; } } /* Now copy over the overlapping region, if any */ if( nRowOverlap <= 0 ) return; if( rowOffset>0 ) elem = nRowOverlap * nelem; else elem = gParse.nRows * nelem; offset = nelem * rowOffset; while( nRowOverlap-- && !gParse.status ) { while( nelem-- && !gParse.status ) { elem--; if( this->type != BITSTR ) this->value.undef[elem] = col->value.undef[elem+offset]; switch( this->type ) { case BITSTR: strcpy( this->value.data.strptr[elem ], col->value.data.strptr[elem+offset] ); break; case STRING: strcpy( this->value.data.strptr[elem ], col->value.data.strptr[elem+offset] ); break; case BOOLEAN: this->value.data.logptr[elem] = col->value.data.logptr[elem+offset]; break; case LONG: this->value.data.lngptr[elem] = col->value.data.lngptr[elem+offset]; break; case DOUBLE: this->value.data.dblptr[elem] = col->value.data.dblptr[elem+offset]; break; } } nelem = nRealElem; } } static void Do_BinOp_bit( Node *this ) { Node *that1, *that2; char *sptr1=NULL, *sptr2=NULL; int const1, const2; long rows; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; const1 = ( that1->operation==CONST_OP ); const2 = ( that2->operation==CONST_OP ); sptr1 = ( const1 ? that1->value.data.str : NULL ); sptr2 = ( const2 ? that2->value.data.str : NULL ); if( const1 && const2 ) { switch( this->operation ) { case NE: this->value.data.log = !bitcmp( sptr1, sptr2 ); break; case EQ: this->value.data.log = bitcmp( sptr1, sptr2 ); break; case GT: case LT: case LTE: case GTE: this->value.data.log = bitlgte( sptr1, this->operation, sptr2 ); break; case '|': bitor( this->value.data.str, sptr1, sptr2 ); break; case '&': bitand( this->value.data.str, sptr1, sptr2 ); break; case '+': strcpy( this->value.data.str, sptr1 ); strcat( this->value.data.str, sptr2 ); break; case ACCUM: this->value.data.lng = 0; while( *sptr1 ) { if ( *sptr1 == '1' ) this->value.data.lng ++; sptr1 ++; } break; } this->operation = CONST_OP; } else { Allocate_Ptrs( this ); if( !gParse.status ) { rows = gParse.nRows; switch( this->operation ) { /* BITSTR comparisons */ case NE: case EQ: case GT: case LT: case LTE: case GTE: while( rows-- ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; switch( this->operation ) { case NE: this->value.data.logptr[rows] = !bitcmp( sptr1, sptr2 ); break; case EQ: this->value.data.logptr[rows] = bitcmp( sptr1, sptr2 ); break; case GT: case LT: case LTE: case GTE: this->value.data.logptr[rows] = bitlgte( sptr1, this->operation, sptr2 ); break; } this->value.undef[rows] = 0; } break; /* BITSTR AND/ORs ... no UNDEFS in or out */ case '|': case '&': case '+': while( rows-- ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; if( this->operation=='|' ) bitor( this->value.data.strptr[rows], sptr1, sptr2 ); else if( this->operation=='&' ) bitand( this->value.data.strptr[rows], sptr1, sptr2 ); else { strcpy( this->value.data.strptr[rows], sptr1 ); strcat( this->value.data.strptr[rows], sptr2 ); } } break; /* Accumulate 1 bits */ case ACCUM: { long i, previous, curr; previous = that2->value.data.lng; /* Cumulative sum of this chunk */ for (i=0; ivalue.data.strptr[i]; for (curr = 0; *sptr1; sptr1 ++) { if ( *sptr1 == '1' ) curr ++; } previous += curr; this->value.data.lngptr[i] = previous; this->value.undef[i] = 0; } /* Store final cumulant for next pass */ that2->value.data.lng = previous; } } } } if( that1->operation>0 ) { free( that1->value.data.strptr[0] ); free( that1->value.data.strptr ); } if( that2->operation>0 ) { free( that2->value.data.strptr[0] ); free( that2->value.data.strptr ); } } static void Do_BinOp_str( Node *this ) { Node *that1, *that2; char *sptr1, *sptr2, null1=0, null2=0; int const1, const2, val; long rows; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; const1 = ( that1->operation==CONST_OP ); const2 = ( that2->operation==CONST_OP ); sptr1 = ( const1 ? that1->value.data.str : NULL ); sptr2 = ( const2 ? that2->value.data.str : NULL ); if( const1 && const2 ) { /* Result is a constant */ switch( this->operation ) { /* Compare Strings */ case NE: case EQ: val = ( FSTRCMP( sptr1, sptr2 ) == 0 ); this->value.data.log = ( this->operation==EQ ? val : !val ); break; case GT: this->value.data.log = ( FSTRCMP( sptr1, sptr2 ) > 0 ); break; case LT: this->value.data.log = ( FSTRCMP( sptr1, sptr2 ) < 0 ); break; case GTE: this->value.data.log = ( FSTRCMP( sptr1, sptr2 ) >= 0 ); break; case LTE: this->value.data.log = ( FSTRCMP( sptr1, sptr2 ) <= 0 ); break; /* Concat Strings */ case '+': strcpy( this->value.data.str, sptr1 ); strcat( this->value.data.str, sptr2 ); break; } this->operation = CONST_OP; } else { /* Not a constant */ Allocate_Ptrs( this ); if( !gParse.status ) { rows = gParse.nRows; switch( this->operation ) { /* Compare Strings */ case NE: case EQ: while( rows-- ) { if( !const1 ) null1 = that1->value.undef[rows]; if( !const2 ) null2 = that2->value.undef[rows]; this->value.undef[rows] = (null1 || null2); if( ! this->value.undef[rows] ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; val = ( FSTRCMP( sptr1, sptr2 ) == 0 ); this->value.data.logptr[rows] = ( this->operation==EQ ? val : !val ); } } break; case GT: case LT: while( rows-- ) { if( !const1 ) null1 = that1->value.undef[rows]; if( !const2 ) null2 = that2->value.undef[rows]; this->value.undef[rows] = (null1 || null2); if( ! this->value.undef[rows] ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; val = ( FSTRCMP( sptr1, sptr2 ) ); this->value.data.logptr[rows] = ( this->operation==GT ? val>0 : val<0 ); } } break; case GTE: case LTE: while( rows-- ) { if( !const1 ) null1 = that1->value.undef[rows]; if( !const2 ) null2 = that2->value.undef[rows]; this->value.undef[rows] = (null1 || null2); if( ! this->value.undef[rows] ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; val = ( FSTRCMP( sptr1, sptr2 ) ); this->value.data.logptr[rows] = ( this->operation==GTE ? val>=0 : val<=0 ); } } break; /* Concat Strings */ case '+': while( rows-- ) { if( !const1 ) null1 = that1->value.undef[rows]; if( !const2 ) null2 = that2->value.undef[rows]; this->value.undef[rows] = (null1 || null2); if( ! this->value.undef[rows] ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; strcpy( this->value.data.strptr[rows], sptr1 ); strcat( this->value.data.strptr[rows], sptr2 ); } } break; } } } if( that1->operation>0 ) { free( that1->value.data.strptr[0] ); free( that1->value.data.strptr ); } if( that2->operation>0 ) { free( that2->value.data.strptr[0] ); free( that2->value.data.strptr ); } } static void Do_BinOp_log( Node *this ) { Node *that1, *that2; int vector1, vector2; char val1=0, val2=0, null1=0, null2=0; long rows, nelem, elem; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; vector1 = ( that1->operation!=CONST_OP ); if( vector1 ) vector1 = that1->value.nelem; else { val1 = that1->value.data.log; } vector2 = ( that2->operation!=CONST_OP ); if( vector2 ) vector2 = that2->value.nelem; else { val2 = that2->value.data.log; } if( !vector1 && !vector2 ) { /* Result is a constant */ switch( this->operation ) { case OR: this->value.data.log = (val1 || val2); break; case AND: this->value.data.log = (val1 && val2); break; case EQ: this->value.data.log = ( (val1 && val2) || (!val1 && !val2) ); break; case NE: this->value.data.log = ( (val1 && !val2) || (!val1 && val2) ); break; case ACCUM: this->value.data.lng = val1; break; } this->operation=CONST_OP; } else if (this->operation == ACCUM) { long i, previous, curr; rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); if( !gParse.status ) { previous = that2->value.data.lng; /* Cumulative sum of this chunk */ for (i=0; ivalue.undef[i]) { curr = that1->value.data.logptr[i]; previous += curr; } this->value.data.lngptr[i] = previous; this->value.undef[i] = 0; } /* Store final cumulant for next pass */ that2->value.data.lng = previous; } } else { rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); if( !gParse.status ) { if (this->operation == ACCUM) { long i, previous, curr; previous = that2->value.data.lng; /* Cumulative sum of this chunk */ for (i=0; ivalue.undef[i]) { curr = that1->value.data.logptr[i]; previous += curr; } this->value.data.lngptr[i] = previous; this->value.undef[i] = 0; } /* Store final cumulant for next pass */ that2->value.data.lng = previous; } while( rows-- ) { while( nelem-- ) { elem--; if( vector1>1 ) { val1 = that1->value.data.logptr[elem]; null1 = that1->value.undef[elem]; } else if( vector1 ) { val1 = that1->value.data.logptr[rows]; null1 = that1->value.undef[rows]; } if( vector2>1 ) { val2 = that2->value.data.logptr[elem]; null2 = that2->value.undef[elem]; } else if( vector2 ) { val2 = that2->value.data.logptr[rows]; null2 = that2->value.undef[rows]; } this->value.undef[elem] = (null1 || null2); switch( this->operation ) { case OR: /* This is more complicated than others to suppress UNDEFs */ /* in those cases where the other argument is DEF && TRUE */ if( !null1 && !null2 ) { this->value.data.logptr[elem] = (val1 || val2); } else if( (null1 && !null2 && val2) || ( !null1 && null2 && val1 ) ) { this->value.data.logptr[elem] = 1; this->value.undef[elem] = 0; } break; case AND: /* This is more complicated than others to suppress UNDEFs */ /* in those cases where the other argument is DEF && FALSE */ if( !null1 && !null2 ) { this->value.data.logptr[elem] = (val1 && val2); } else if( (null1 && !null2 && !val2) || ( !null1 && null2 && !val1 ) ) { this->value.data.logptr[elem] = 0; this->value.undef[elem] = 0; } break; case EQ: this->value.data.logptr[elem] = ( (val1 && val2) || (!val1 && !val2) ); break; case NE: this->value.data.logptr[elem] = ( (val1 && !val2) || (!val1 && val2) ); break; } } nelem = this->value.nelem; } } } if( that1->operation>0 ) { free( that1->value.data.ptr ); } if( that2->operation>0 ) { free( that2->value.data.ptr ); } } static void Do_BinOp_lng( Node *this ) { Node *that1, *that2; int vector1, vector2; long val1=0, val2=0; char null1=0, null2=0; long rows, nelem, elem; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; vector1 = ( that1->operation!=CONST_OP ); if( vector1 ) vector1 = that1->value.nelem; else { val1 = that1->value.data.lng; } vector2 = ( that2->operation!=CONST_OP ); if( vector2 ) vector2 = that2->value.nelem; else { val2 = that2->value.data.lng; } if( !vector1 && !vector2 ) { /* Result is a constant */ switch( this->operation ) { case '~': /* Treat as == for LONGS */ case EQ: this->value.data.log = (val1 == val2); break; case NE: this->value.data.log = (val1 != val2); break; case GT: this->value.data.log = (val1 > val2); break; case LT: this->value.data.log = (val1 < val2); break; case LTE: this->value.data.log = (val1 <= val2); break; case GTE: this->value.data.log = (val1 >= val2); break; case '+': this->value.data.lng = (val1 + val2); break; case '-': this->value.data.lng = (val1 - val2); break; case '*': this->value.data.lng = (val1 * val2); break; case '%': if( val2 ) this->value.data.lng = (val1 % val2); else yyerror("Divide by Zero"); break; case '/': if( val2 ) this->value.data.lng = (val1 / val2); else yyerror("Divide by Zero"); break; case POWER: this->value.data.lng = (long)pow((double)val1,(double)val2); break; case ACCUM: this->value.data.lng = val1; break; case DIFF: this->value.data.lng = 0; break; } this->operation=CONST_OP; } else if ((this->operation == ACCUM) || (this->operation == DIFF)) { long i, previous, curr; long undef; rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); if( !gParse.status ) { previous = that2->value.data.lng; undef = (long) that2->value.undef; if (this->operation == ACCUM) { /* Cumulative sum of this chunk */ for (i=0; ivalue.undef[i]) { curr = that1->value.data.lngptr[i]; previous += curr; } this->value.data.lngptr[i] = previous; this->value.undef[i] = 0; } } else { /* Sequential difference for this chunk */ for (i=0; ivalue.data.lngptr[i]; if (that1->value.undef[i] || undef) { /* Either this, or previous, value was undefined */ this->value.data.lngptr[i] = 0; this->value.undef[i] = 1; } else { /* Both defined, we are okay! */ this->value.data.lngptr[i] = curr - previous; this->value.undef[i] = 0; } previous = curr; undef = that1->value.undef[i]; } } /* Store final cumulant for next pass */ that2->value.data.lng = previous; that2->value.undef = (char *) undef; /* XXX evil, but no harm here */ } } else { rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); while( rows-- && !gParse.status ) { while( nelem-- && !gParse.status ) { elem--; if( vector1>1 ) { val1 = that1->value.data.lngptr[elem]; null1 = that1->value.undef[elem]; } else if( vector1 ) { val1 = that1->value.data.lngptr[rows]; null1 = that1->value.undef[rows]; } if( vector2>1 ) { val2 = that2->value.data.lngptr[elem]; null2 = that2->value.undef[elem]; } else if( vector2 ) { val2 = that2->value.data.lngptr[rows]; null2 = that2->value.undef[rows]; } this->value.undef[elem] = (null1 || null2); switch( this->operation ) { case '~': /* Treat as == for LONGS */ case EQ: this->value.data.logptr[elem] = (val1 == val2); break; case NE: this->value.data.logptr[elem] = (val1 != val2); break; case GT: this->value.data.logptr[elem] = (val1 > val2); break; case LT: this->value.data.logptr[elem] = (val1 < val2); break; case LTE: this->value.data.logptr[elem] = (val1 <= val2); break; case GTE: this->value.data.logptr[elem] = (val1 >= val2); break; case '+': this->value.data.lngptr[elem] = (val1 + val2); break; case '-': this->value.data.lngptr[elem] = (val1 - val2); break; case '*': this->value.data.lngptr[elem] = (val1 * val2); break; case '%': if( val2 ) this->value.data.lngptr[elem] = (val1 % val2); else { this->value.data.lngptr[elem] = 0; this->value.undef[elem] = 1; } break; case '/': if( val2 ) this->value.data.lngptr[elem] = (val1 / val2); else { this->value.data.lngptr[elem] = 0; this->value.undef[elem] = 1; } break; case POWER: this->value.data.lngptr[elem] = (long)pow((double)val1,(double)val2); break; } } nelem = this->value.nelem; } } if( that1->operation>0 ) { free( that1->value.data.ptr ); } if( that2->operation>0 ) { free( that2->value.data.ptr ); } } static void Do_BinOp_dbl( Node *this ) { Node *that1, *that2; int vector1, vector2; double val1=0.0, val2=0.0; char null1=0, null2=0; long rows, nelem, elem; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; vector1 = ( that1->operation!=CONST_OP ); if( vector1 ) vector1 = that1->value.nelem; else { val1 = that1->value.data.dbl; } vector2 = ( that2->operation!=CONST_OP ); if( vector2 ) vector2 = that2->value.nelem; else { val2 = that2->value.data.dbl; } if( !vector1 && !vector2 ) { /* Result is a constant */ switch( this->operation ) { case '~': this->value.data.log = ( fabs(val1-val2) < APPROX ); break; case EQ: this->value.data.log = (val1 == val2); break; case NE: this->value.data.log = (val1 != val2); break; case GT: this->value.data.log = (val1 > val2); break; case LT: this->value.data.log = (val1 < val2); break; case LTE: this->value.data.log = (val1 <= val2); break; case GTE: this->value.data.log = (val1 >= val2); break; case '+': this->value.data.dbl = (val1 + val2); break; case '-': this->value.data.dbl = (val1 - val2); break; case '*': this->value.data.dbl = (val1 * val2); break; case '%': if( val2 ) this->value.data.dbl = val1 - val2*((int)(val1/val2)); else yyerror("Divide by Zero"); break; case '/': if( val2 ) this->value.data.dbl = (val1 / val2); else yyerror("Divide by Zero"); break; case POWER: this->value.data.dbl = (double)pow(val1,val2); break; case ACCUM: this->value.data.dbl = val1; break; case DIFF: this->value.data.dbl = 0; break; } this->operation=CONST_OP; } else if ((this->operation == ACCUM) || (this->operation == DIFF)) { long i; long undef; double previous, curr; rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); if( !gParse.status ) { previous = that2->value.data.dbl; undef = (long) that2->value.undef; if (this->operation == ACCUM) { /* Cumulative sum of this chunk */ for (i=0; ivalue.undef[i]) { curr = that1->value.data.dblptr[i]; previous += curr; } this->value.data.dblptr[i] = previous; this->value.undef[i] = 0; } } else { /* Sequential difference for this chunk */ for (i=0; ivalue.data.dblptr[i]; if (that1->value.undef[i] || undef) { /* Either this, or previous, value was undefined */ this->value.data.dblptr[i] = 0; this->value.undef[i] = 1; } else { /* Both defined, we are okay! */ this->value.data.dblptr[i] = curr - previous; this->value.undef[i] = 0; } previous = curr; undef = that1->value.undef[i]; } } /* Store final cumulant for next pass */ that2->value.data.dbl = previous; that2->value.undef = (char *) undef; /* XXX evil, but no harm here */ } } else { rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); while( rows-- && !gParse.status ) { while( nelem-- && !gParse.status ) { elem--; if( vector1>1 ) { val1 = that1->value.data.dblptr[elem]; null1 = that1->value.undef[elem]; } else if( vector1 ) { val1 = that1->value.data.dblptr[rows]; null1 = that1->value.undef[rows]; } if( vector2>1 ) { val2 = that2->value.data.dblptr[elem]; null2 = that2->value.undef[elem]; } else if( vector2 ) { val2 = that2->value.data.dblptr[rows]; null2 = that2->value.undef[rows]; } this->value.undef[elem] = (null1 || null2); switch( this->operation ) { case '~': this->value.data.logptr[elem] = ( fabs(val1-val2) < APPROX ); break; case EQ: this->value.data.logptr[elem] = (val1 == val2); break; case NE: this->value.data.logptr[elem] = (val1 != val2); break; case GT: this->value.data.logptr[elem] = (val1 > val2); break; case LT: this->value.data.logptr[elem] = (val1 < val2); break; case LTE: this->value.data.logptr[elem] = (val1 <= val2); break; case GTE: this->value.data.logptr[elem] = (val1 >= val2); break; case '+': this->value.data.dblptr[elem] = (val1 + val2); break; case '-': this->value.data.dblptr[elem] = (val1 - val2); break; case '*': this->value.data.dblptr[elem] = (val1 * val2); break; case '%': if( val2 ) this->value.data.dblptr[elem] = val1 - val2*((int)(val1/val2)); else { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } break; case '/': if( val2 ) this->value.data.dblptr[elem] = (val1 / val2); else { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } break; case POWER: this->value.data.dblptr[elem] = (double)pow(val1,val2); break; } } nelem = this->value.nelem; } } if( that1->operation>0 ) { free( that1->value.data.ptr ); } if( that2->operation>0 ) { free( that2->value.data.ptr ); } } /* * This Quickselect routine is based on the algorithm described in * "Numerical recipes in C", Second Edition, * Cambridge University Press, 1992, Section 8.5, ISBN 0-521-43108-5 * This code by Nicolas Devillard - 1998. Public domain. * http://ndevilla.free.fr/median/median/src/quickselect.c */ #define ELEM_SWAP(a,b) { register long t=(a);(a)=(b);(b)=t; } /* * qselect_median_lng - select the median value of a long array * * This routine selects the median value of the long integer array * arr[]. If there are an even number of elements, the "lower median" * is selected. * * The array arr[] is scrambled, so users must operate on a scratch * array if they wish the values to be preserved. * * long arr[] - array of values * int n - number of elements in arr * * RETURNS: the lower median value of arr[] * */ long qselect_median_lng(long arr[], int n) { int low, high ; int median; int middle, ll, hh; low = 0 ; high = n-1 ; median = (low + high) / 2; for (;;) { if (high <= low) { /* One element only */ return arr[median]; } if (high == low + 1) { /* Two elements only */ if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ; return arr[median]; } /* Find median of low, middle and high items; swap into position low */ middle = (low + high) / 2; if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ; if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ; if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ; /* Swap low item (now in position middle) into position (low+1) */ ELEM_SWAP(arr[middle], arr[low+1]) ; /* Nibble from each end towards middle, swapping items when stuck */ ll = low + 1; hh = high; for (;;) { do ll++; while (arr[low] > arr[ll]) ; do hh--; while (arr[hh] > arr[low]) ; if (hh < ll) break; ELEM_SWAP(arr[ll], arr[hh]) ; } /* Swap middle item (in position low) back into correct position */ ELEM_SWAP(arr[low], arr[hh]) ; /* Re-set active partition */ if (hh <= median) low = ll; if (hh >= median) high = hh - 1; } } #undef ELEM_SWAP #define ELEM_SWAP(a,b) { register double t=(a);(a)=(b);(b)=t; } /* * qselect_median_dbl - select the median value of a double array * * This routine selects the median value of the double array * arr[]. If there are an even number of elements, the "lower median" * is selected. * * The array arr[] is scrambled, so users must operate on a scratch * array if they wish the values to be preserved. * * double arr[] - array of values * int n - number of elements in arr * * RETURNS: the lower median value of arr[] * */ double qselect_median_dbl(double arr[], int n) { int low, high ; int median; int middle, ll, hh; low = 0 ; high = n-1 ; median = (low + high) / 2; for (;;) { if (high <= low) { /* One element only */ return arr[median] ; } if (high == low + 1) { /* Two elements only */ if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ; return arr[median] ; } /* Find median of low, middle and high items; swap into position low */ middle = (low + high) / 2; if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ; if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ; if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ; /* Swap low item (now in position middle) into position (low+1) */ ELEM_SWAP(arr[middle], arr[low+1]) ; /* Nibble from each end towards middle, swapping items when stuck */ ll = low + 1; hh = high; for (;;) { do ll++; while (arr[low] > arr[ll]) ; do hh--; while (arr[hh] > arr[low]) ; if (hh < ll) break; ELEM_SWAP(arr[ll], arr[hh]) ; } /* Swap middle item (in position low) back into correct position */ ELEM_SWAP(arr[low], arr[hh]) ; /* Re-set active partition */ if (hh <= median) low = ll; if (hh >= median) high = hh - 1; } } #undef ELEM_SWAP /* * angsep_calc - compute angular separation between celestial coordinates * * This routine computes the angular separation between to coordinates * on the celestial sphere (i.e. RA and Dec). Note that all units are * in DEGREES, unlike the other trig functions in the calculator. * * double ra1, dec1 - RA and Dec of the first position in degrees * double ra2, dec2 - RA and Dec of the second position in degrees * * RETURNS: (double) angular separation in degrees * */ double angsep_calc(double ra1, double dec1, double ra2, double dec2) { /* double cd; */ static double deg = 0; double a, sdec, sra; if (deg == 0) deg = ((double)4)*atan((double)1)/((double)180); /* deg = 1.0; **** UNCOMMENT IF YOU WANT RADIANS */ /* This (commented out) algorithm uses the Low of Cosines, which becomes unstable for angles less than 0.1 arcsec. cd = sin(dec1*deg)*sin(dec2*deg) + cos(dec1*deg)*cos(dec2*deg)*cos((ra1-ra2)*deg); if (cd < (-1)) cd = -1; if (cd > (+1)) cd = +1; return acos(cd)/deg; */ /* The algorithm is the law of Haversines. This algorithm is stable even when the points are close together. The normal Law of Cosines fails for angles around 0.1 arcsec. */ sra = sin( (ra2 - ra1)*deg / 2 ); sdec = sin( (dec2 - dec1)*deg / 2); a = sdec*sdec + cos(dec1*deg)*cos(dec2*deg)*sra*sra; /* Sanity checking to avoid a range error in the sqrt()'s below */ if (a < 0) { a = 0; } if (a > 1) { a = 1; } return 2.0*atan2(sqrt(a), sqrt(1.0 - a)) / deg; } static double ran1() { static double dval = 0.0; double rndVal; if (dval == 0.0) { if( rand()<32768 && rand()<32768 ) dval = 32768.0; else dval = 2147483648.0; } rndVal = (double)rand(); while( rndVal > dval ) dval *= 2.0; return rndVal/dval; } /* Gaussian deviate routine from Numerical Recipes */ static double gasdev() { static int iset = 0; static double gset; double fac, rsq, v1, v2; if (iset == 0) { do { v1 = 2.0*ran1()-1.0; v2 = 2.0*ran1()-1.0; rsq = v1*v1 + v2*v2; } while (rsq >= 1.0 || rsq == 0.0); fac = sqrt(-2.0*log(rsq)/rsq); gset = v1*fac; iset = 1; return v2*fac; } else { iset = 0; return gset; } } /* lgamma function - from Numerical Recipes */ float gammaln(float xx) /* Returns the value ln Gamma[(xx)] for xx > 0. */ { /* Internal arithmetic will be done in double precision, a nicety that you can omit if five-figure accuracy is good enough. */ double x,y,tmp,ser; static double cof[6]={76.18009172947146,-86.50532032941677, 24.01409824083091,-1.231739572450155, 0.1208650973866179e-2,-0.5395239384953e-5}; int j; y=x=xx; tmp=x+5.5; tmp -= (x+0.5)*log(tmp); ser=1.000000000190015; for (j=0;j<=5;j++) ser += cof[j]/++y; return (float) (-tmp+log(2.5066282746310005*ser/x)); } /* Poisson deviate - derived from Numerical Recipes */ static long poidev(double xm) { static double sq, alxm, g, oldm = -1.0; static double pi = 0; double em, t, y; if (pi == 0) pi = ((double)4)*atan((double)1); if (xm < 20.0) { if (xm != oldm) { oldm = xm; g = exp(-xm); } em = -1; t = 1.0; do { em += 1; t *= ran1(); } while (t > g); } else { if (xm != oldm) { oldm = xm; sq = sqrt(2.0*xm); alxm = log(xm); g = xm*alxm-gammaln( (float) (xm+1.0)); } do { do { y = tan(pi*ran1()); em = sq*y+xm; } while (em < 0.0); em = floor(em); t = 0.9*(1.0+y*y)*exp(em*alxm-gammaln( (float) (em+1.0) )-g); } while (ran1() > t); } /* Return integer version */ return (long int) floor(em+0.5); } static void Do_Func( Node *this ) { Node *theParams[MAXSUBS]; int vector[MAXSUBS], allConst; lval pVals[MAXSUBS]; char pNull[MAXSUBS]; long ival; double dval; int i, valInit; long row, elem, nelem; i = this->nSubNodes; allConst = 1; while( i-- ) { theParams[i] = gParse.Nodes + this->SubNodes[i]; vector[i] = ( theParams[i]->operation!=CONST_OP ); if( vector[i] ) { allConst = 0; vector[i] = theParams[i]->value.nelem; } else { if( theParams[i]->type==DOUBLE ) { pVals[i].data.dbl = theParams[i]->value.data.dbl; } else if( theParams[i]->type==LONG ) { pVals[i].data.lng = theParams[i]->value.data.lng; } else if( theParams[i]->type==BOOLEAN ) { pVals[i].data.log = theParams[i]->value.data.log; } else strcpy(pVals[i].data.str, theParams[i]->value.data.str); pNull[i] = 0; } } if( this->nSubNodes==0 ) allConst = 0; /* These do produce scalars */ /* Random numbers are *never* constant !! */ if( this->operation == poirnd_fct ) allConst = 0; if( this->operation == gasrnd_fct ) allConst = 0; if( this->operation == rnd_fct ) allConst = 0; if( allConst ) { switch( this->operation ) { /* Non-Trig single-argument functions */ case sum_fct: if( theParams[0]->type==BOOLEAN ) this->value.data.lng = ( pVals[0].data.log ? 1 : 0 ); else if( theParams[0]->type==LONG ) this->value.data.lng = pVals[0].data.lng; else if( theParams[0]->type==DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; else if( theParams[0]->type==BITSTR ) strcpy(this->value.data.str, pVals[0].data.str); break; case average_fct: if( theParams[0]->type==LONG ) this->value.data.dbl = pVals[0].data.lng; else if( theParams[0]->type==DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; break; case stddev_fct: this->value.data.dbl = 0; /* Standard deviation of a constant = 0 */ break; case median_fct: if( theParams[0]->type==BOOLEAN ) this->value.data.lng = ( pVals[0].data.log ? 1 : 0 ); else if( theParams[0]->type==LONG ) this->value.data.lng = pVals[0].data.lng; else this->value.data.dbl = pVals[0].data.dbl; break; case poirnd_fct: if( theParams[0]->type==DOUBLE ) this->value.data.lng = poidev(pVals[0].data.dbl); else this->value.data.lng = poidev(pVals[0].data.lng); break; case abs_fct: if( theParams[0]->type==DOUBLE ) { dval = pVals[0].data.dbl; this->value.data.dbl = (dval>0.0 ? dval : -dval); } else { ival = pVals[0].data.lng; this->value.data.lng = (ival> 0 ? ival : -ival); } break; /* Special Null-Handling Functions */ case nonnull_fct: this->value.data.lng = 1; /* Constants are always 1-element and defined */ break; case isnull_fct: /* Constants are always defined */ this->value.data.log = 0; break; case defnull_fct: if( this->type==BOOLEAN ) this->value.data.log = pVals[0].data.log; else if( this->type==LONG ) this->value.data.lng = pVals[0].data.lng; else if( this->type==DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; else if( this->type==STRING ) strcpy(this->value.data.str,pVals[0].data.str); break; /* Math functions with 1 double argument */ case sin_fct: this->value.data.dbl = sin( pVals[0].data.dbl ); break; case cos_fct: this->value.data.dbl = cos( pVals[0].data.dbl ); break; case tan_fct: this->value.data.dbl = tan( pVals[0].data.dbl ); break; case asin_fct: dval = pVals[0].data.dbl; if( dval<-1.0 || dval>1.0 ) yyerror("Out of range argument to arcsin"); else this->value.data.dbl = asin( dval ); break; case acos_fct: dval = pVals[0].data.dbl; if( dval<-1.0 || dval>1.0 ) yyerror("Out of range argument to arccos"); else this->value.data.dbl = acos( dval ); break; case atan_fct: this->value.data.dbl = atan( pVals[0].data.dbl ); break; case sinh_fct: this->value.data.dbl = sinh( pVals[0].data.dbl ); break; case cosh_fct: this->value.data.dbl = cosh( pVals[0].data.dbl ); break; case tanh_fct: this->value.data.dbl = tanh( pVals[0].data.dbl ); break; case exp_fct: this->value.data.dbl = exp( pVals[0].data.dbl ); break; case log_fct: dval = pVals[0].data.dbl; if( dval<=0.0 ) yyerror("Out of range argument to log"); else this->value.data.dbl = log( dval ); break; case log10_fct: dval = pVals[0].data.dbl; if( dval<=0.0 ) yyerror("Out of range argument to log10"); else this->value.data.dbl = log10( dval ); break; case sqrt_fct: dval = pVals[0].data.dbl; if( dval<0.0 ) yyerror("Out of range argument to sqrt"); else this->value.data.dbl = sqrt( dval ); break; case ceil_fct: this->value.data.dbl = ceil( pVals[0].data.dbl ); break; case floor_fct: this->value.data.dbl = floor( pVals[0].data.dbl ); break; case round_fct: this->value.data.dbl = floor( pVals[0].data.dbl + 0.5 ); break; /* Two-argument Trig Functions */ case atan2_fct: this->value.data.dbl = atan2( pVals[0].data.dbl, pVals[1].data.dbl ); break; /* Four-argument ANGSEP function */ case angsep_fct: this->value.data.dbl = angsep_calc(pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl); /* Min/Max functions taking 1 or 2 arguments */ case min1_fct: /* No constant vectors! */ if( this->type == DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; else if( this->type == LONG ) this->value.data.lng = pVals[0].data.lng; else if( this->type == BITSTR ) strcpy(this->value.data.str, pVals[0].data.str); break; case min2_fct: if( this->type == DOUBLE ) this->value.data.dbl = minvalue( pVals[0].data.dbl, pVals[1].data.dbl ); else if( this->type == LONG ) this->value.data.lng = minvalue( pVals[0].data.lng, pVals[1].data.lng ); break; case max1_fct: /* No constant vectors! */ if( this->type == DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; else if( this->type == LONG ) this->value.data.lng = pVals[0].data.lng; else if( this->type == BITSTR ) strcpy(this->value.data.str, pVals[0].data.str); break; case max2_fct: if( this->type == DOUBLE ) this->value.data.dbl = maxvalue( pVals[0].data.dbl, pVals[1].data.dbl ); else if( this->type == LONG ) this->value.data.lng = maxvalue( pVals[0].data.lng, pVals[1].data.lng ); break; /* Boolean SAO region Functions... scalar or vector dbls */ case near_fct: this->value.data.log = bnear( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl ); break; case circle_fct: this->value.data.log = circle( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl ); break; case box_fct: this->value.data.log = saobox( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl, pVals[5].data.dbl, pVals[6].data.dbl ); break; case elps_fct: this->value.data.log = ellipse( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl, pVals[5].data.dbl, pVals[6].data.dbl ); break; /* C Conditional expression: bool ? expr : expr */ case ifthenelse_fct: switch( this->type ) { case BOOLEAN: this->value.data.log = ( pVals[2].data.log ? pVals[0].data.log : pVals[1].data.log ); break; case LONG: this->value.data.lng = ( pVals[2].data.log ? pVals[0].data.lng : pVals[1].data.lng ); break; case DOUBLE: this->value.data.dbl = ( pVals[2].data.log ? pVals[0].data.dbl : pVals[1].data.dbl ); break; case STRING: strcpy(this->value.data.str, ( pVals[2].data.log ? pVals[0].data.str : pVals[1].data.str ) ); break; } break; /* String functions */ case strmid_fct: cstrmid(this->value.data.str, this->value.nelem, pVals[0].data.str, pVals[0].nelem, pVals[1].data.lng); break; case strpos_fct: { char *res = strstr(pVals[0].data.str, pVals[1].data.str); if (res == NULL) { this->value.data.lng = 0; } else { this->value.data.lng = (res - pVals[0].data.str) + 1; } break; } } this->operation = CONST_OP; } else { Allocate_Ptrs( this ); row = gParse.nRows; elem = row * this->value.nelem; if( !gParse.status ) { switch( this->operation ) { /* Special functions with no arguments */ case row_fct: while( row-- ) { this->value.data.lngptr[row] = gParse.firstRow + row; this->value.undef[row] = 0; } break; case null_fct: if( this->type==LONG ) { while( row-- ) { this->value.data.lngptr[row] = 0; this->value.undef[row] = 1; } } else if( this->type==STRING ) { while( row-- ) { this->value.data.strptr[row][0] = '\0'; this->value.undef[row] = 1; } } break; case rnd_fct: while( elem-- ) { this->value.data.dblptr[elem] = ran1(); this->value.undef[elem] = 0; } break; case gasrnd_fct: while( elem-- ) { this->value.data.dblptr[elem] = gasdev(); this->value.undef[elem] = 0; } break; case poirnd_fct: if( theParams[0]->type==DOUBLE ) { if (theParams[0]->operation == CONST_OP) { while( elem-- ) { this->value.undef[elem] = (pVals[0].data.dbl < 0); if (! this->value.undef[elem]) { this->value.data.lngptr[elem] = poidev(pVals[0].data.dbl); } } } else { while( elem-- ) { this->value.undef[elem] = theParams[0]->value.undef[elem]; if (theParams[0]->value.data.dblptr[elem] < 0) this->value.undef[elem] = 1; if (! this->value.undef[elem]) { this->value.data.lngptr[elem] = poidev(theParams[0]->value.data.dblptr[elem]); } } /* while */ } /* ! CONST_OP */ } else { /* LONG */ if (theParams[0]->operation == CONST_OP) { while( elem-- ) { this->value.undef[elem] = (pVals[0].data.lng < 0); if (! this->value.undef[elem]) { this->value.data.lngptr[elem] = poidev(pVals[0].data.lng); } } } else { while( elem-- ) { this->value.undef[elem] = theParams[0]->value.undef[elem]; if (theParams[0]->value.data.lngptr[elem] < 0) this->value.undef[elem] = 1; if (! this->value.undef[elem]) { this->value.data.lngptr[elem] = poidev(theParams[0]->value.data.lngptr[elem]); } } /* while */ } /* ! CONST_OP */ } /* END LONG */ break; /* Non-Trig single-argument functions */ case sum_fct: elem = row * theParams[0]->value.nelem; if( theParams[0]->type==BOOLEAN ) { while( row-- ) { this->value.data.lngptr[row] = 0; /* Default is UNDEF until a defined value is found */ this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( ! theParams[0]->value.undef[elem] ) { this->value.data.lngptr[row] += ( theParams[0]->value.data.logptr[elem] ? 1 : 0 ); this->value.undef[row] = 0; } } } } else if( theParams[0]->type==LONG ) { while( row-- ) { this->value.data.lngptr[row] = 0; /* Default is UNDEF until a defined value is found */ this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( ! theParams[0]->value.undef[elem] ) { this->value.data.lngptr[row] += theParams[0]->value.data.lngptr[elem]; this->value.undef[row] = 0; } } } } else if( theParams[0]->type==DOUBLE ){ while( row-- ) { this->value.data.dblptr[row] = 0.0; /* Default is UNDEF until a defined value is found */ this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( ! theParams[0]->value.undef[elem] ) { this->value.data.dblptr[row] += theParams[0]->value.data.dblptr[elem]; this->value.undef[row] = 0; } } } } else { /* BITSTR */ nelem = theParams[0]->value.nelem; while( row-- ) { char *sptr1 = theParams[0]->value.data.strptr[row]; this->value.data.lngptr[row] = 0; this->value.undef[row] = 0; while (*sptr1) { if (*sptr1 == '1') this->value.data.lngptr[row] ++; sptr1++; } } } break; case average_fct: elem = row * theParams[0]->value.nelem; if( theParams[0]->type==LONG ) { while( row-- ) { int count = 0; this->value.data.dblptr[row] = 0; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { this->value.data.dblptr[row] += theParams[0]->value.data.lngptr[elem]; count ++; } } if (count == 0) { this->value.undef[row] = 1; } else { this->value.undef[row] = 0; this->value.data.dblptr[row] /= count; } } } else if( theParams[0]->type==DOUBLE ){ while( row-- ) { int count = 0; this->value.data.dblptr[row] = 0; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { this->value.data.dblptr[row] += theParams[0]->value.data.dblptr[elem]; count ++; } } if (count == 0) { this->value.undef[row] = 1; } else { this->value.undef[row] = 0; this->value.data.dblptr[row] /= count; } } } break; case stddev_fct: elem = row * theParams[0]->value.nelem; if( theParams[0]->type==LONG ) { /* Compute the mean value */ while( row-- ) { int count = 0; double sum = 0, sum2 = 0; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { sum += theParams[0]->value.data.lngptr[elem]; count ++; } } if (count > 1) { sum /= count; /* Compute the sum of squared deviations */ nelem = theParams[0]->value.nelem; elem += nelem; /* Reset elem for second pass */ while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { double dx = (theParams[0]->value.data.lngptr[elem] - sum); sum2 += (dx*dx); } } sum2 /= (double)count-1; this->value.undef[row] = 0; this->value.data.dblptr[row] = sqrt(sum2); } else { this->value.undef[row] = 0; /* STDDEV => 0 */ this->value.data.dblptr[row] = 0; } } } else if( theParams[0]->type==DOUBLE ){ /* Compute the mean value */ while( row-- ) { int count = 0; double sum = 0, sum2 = 0; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { sum += theParams[0]->value.data.dblptr[elem]; count ++; } } if (count > 1) { sum /= count; /* Compute the sum of squared deviations */ nelem = theParams[0]->value.nelem; elem += nelem; /* Reset elem for second pass */ while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { double dx = (theParams[0]->value.data.dblptr[elem] - sum); sum2 += (dx*dx); } } sum2 /= (double)count-1; this->value.undef[row] = 0; this->value.data.dblptr[row] = sqrt(sum2); } else { this->value.undef[row] = 0; /* STDDEV => 0 */ this->value.data.dblptr[row] = 0; } } } break; case median_fct: elem = row * theParams[0]->value.nelem; nelem = theParams[0]->value.nelem; if( theParams[0]->type==LONG ) { long *dptr = theParams[0]->value.data.lngptr; char *uptr = theParams[0]->value.undef; long *mptr = (long *) malloc(sizeof(long)*nelem); int irow; /* Allocate temporary storage for this row, since the quickselect function will scramble the contents */ if (mptr == 0) { yyerror("Could not allocate temporary memory in median function"); free( this->value.data.ptr ); break; } for (irow=0; irow 0) { this->value.undef[irow] = 0; this->value.data.lngptr[irow] = qselect_median_lng(mptr, nelem1); } else { this->value.undef[irow] = 1; this->value.data.lngptr[irow] = 0; } } free(mptr); } else { double *dptr = theParams[0]->value.data.dblptr; char *uptr = theParams[0]->value.undef; double *mptr = (double *) malloc(sizeof(double)*nelem); int irow; /* Allocate temporary storage for this row, since the quickselect function will scramble the contents */ if (mptr == 0) { yyerror("Could not allocate temporary memory in median function"); free( this->value.data.ptr ); break; } for (irow=0; irow 0) { this->value.undef[irow] = 0; this->value.data.dblptr[irow] = qselect_median_dbl(mptr, nelem1); } else { this->value.undef[irow] = 1; this->value.data.dblptr[irow] = 0; } } free(mptr); } break; case abs_fct: if( theParams[0]->type==DOUBLE ) while( elem-- ) { dval = theParams[0]->value.data.dblptr[elem]; this->value.data.dblptr[elem] = (dval>0.0 ? dval : -dval); this->value.undef[elem] = theParams[0]->value.undef[elem]; } else while( elem-- ) { ival = theParams[0]->value.data.lngptr[elem]; this->value.data.lngptr[elem] = (ival> 0 ? ival : -ival); this->value.undef[elem] = theParams[0]->value.undef[elem]; } break; /* Special Null-Handling Functions */ case nonnull_fct: nelem = theParams[0]->value.nelem; if ( theParams[0]->type==STRING ) nelem = 1; elem = row * nelem; while( row-- ) { int nelem1 = nelem; this->value.undef[row] = 0; /* Initialize to 0 (defined) */ this->value.data.lngptr[row] = 0; while( nelem1-- ) { elem --; if ( theParams[0]->value.undef[elem] == 0 ) this->value.data.lngptr[row] ++; } } break; case isnull_fct: if( theParams[0]->type==STRING ) elem = row; while( elem-- ) { this->value.data.logptr[elem] = theParams[0]->value.undef[elem]; this->value.undef[elem] = 0; } break; case defnull_fct: switch( this->type ) { case BOOLEAN: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pNull[i] = theParams[i]->value.undef[elem]; pVals[i].data.log = theParams[i]->value.data.logptr[elem]; } else if( vector[i] ) { pNull[i] = theParams[i]->value.undef[row]; pVals[i].data.log = theParams[i]->value.data.logptr[row]; } if( pNull[0] ) { this->value.undef[elem] = pNull[1]; this->value.data.logptr[elem] = pVals[1].data.log; } else { this->value.undef[elem] = 0; this->value.data.logptr[elem] = pVals[0].data.log; } } } break; case LONG: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pNull[i] = theParams[i]->value.undef[elem]; pVals[i].data.lng = theParams[i]->value.data.lngptr[elem]; } else if( vector[i] ) { pNull[i] = theParams[i]->value.undef[row]; pVals[i].data.lng = theParams[i]->value.data.lngptr[row]; } if( pNull[0] ) { this->value.undef[elem] = pNull[1]; this->value.data.lngptr[elem] = pVals[1].data.lng; } else { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[0].data.lng; } } } break; case DOUBLE: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pNull[i] = theParams[i]->value.undef[elem]; pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; } else if( vector[i] ) { pNull[i] = theParams[i]->value.undef[row]; pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; } if( pNull[0] ) { this->value.undef[elem] = pNull[1]; this->value.data.dblptr[elem] = pVals[1].data.dbl; } else { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[0].data.dbl; } } } break; case STRING: while( row-- ) { i=2; while( i-- ) if( vector[i] ) { pNull[i] = theParams[i]->value.undef[row]; strcpy(pVals[i].data.str, theParams[i]->value.data.strptr[row]); } if( pNull[0] ) { this->value.undef[row] = pNull[1]; strcpy(this->value.data.strptr[row],pVals[1].data.str); } else { this->value.undef[elem] = 0; strcpy(this->value.data.strptr[row],pVals[0].data.str); } } } break; /* Math functions with 1 double argument */ case sin_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = sin( theParams[0]->value.data.dblptr[elem] ); } break; case cos_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = cos( theParams[0]->value.data.dblptr[elem] ); } break; case tan_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = tan( theParams[0]->value.data.dblptr[elem] ); } break; case asin_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<-1.0 || dval>1.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = asin( dval ); } break; case acos_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<-1.0 || dval>1.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = acos( dval ); } break; case atan_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; this->value.data.dblptr[elem] = atan( dval ); } break; case sinh_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = sinh( theParams[0]->value.data.dblptr[elem] ); } break; case cosh_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = cosh( theParams[0]->value.data.dblptr[elem] ); } break; case tanh_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = tanh( theParams[0]->value.data.dblptr[elem] ); } break; case exp_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; this->value.data.dblptr[elem] = exp( dval ); } break; case log_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<=0.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = log( dval ); } break; case log10_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<=0.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = log10( dval ); } break; case sqrt_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<0.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = sqrt( dval ); } break; case ceil_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = ceil( theParams[0]->value.data.dblptr[elem] ); } break; case floor_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = floor( theParams[0]->value.data.dblptr[elem] ); } break; case round_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = floor( theParams[0]->value.data.dblptr[elem] + 0.5); } break; /* Two-argument Trig Functions */ case atan2_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1]) ) ) this->value.data.dblptr[elem] = atan2( pVals[0].data.dbl, pVals[1].data.dbl ); } } break; /* Four-argument ANGSEP Function */ case angsep_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=4; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2] || pNull[3]) ) ) this->value.data.dblptr[elem] = angsep_calc(pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl); } } break; /* Min/Max functions taking 1 or 2 arguments */ case min1_fct: elem = row * theParams[0]->value.nelem; if( this->type==LONG ) { long minVal=0; while( row-- ) { valInit = 1; this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( !theParams[0]->value.undef[elem] ) { if ( valInit ) { valInit = 0; minVal = theParams[0]->value.data.lngptr[elem]; } else { minVal = minvalue( minVal, theParams[0]->value.data.lngptr[elem] ); } this->value.undef[row] = 0; } } this->value.data.lngptr[row] = minVal; } } else if( this->type==DOUBLE ) { double minVal=0.0; while( row-- ) { valInit = 1; this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( !theParams[0]->value.undef[elem] ) { if ( valInit ) { valInit = 0; minVal = theParams[0]->value.data.dblptr[elem]; } else { minVal = minvalue( minVal, theParams[0]->value.data.dblptr[elem] ); } this->value.undef[row] = 0; } } this->value.data.dblptr[row] = minVal; } } else if( this->type==BITSTR ) { char minVal; while( row-- ) { char *sptr1 = theParams[0]->value.data.strptr[row]; minVal = '1'; while (*sptr1) { if (*sptr1 == '0') minVal = '0'; sptr1++; } this->value.data.strptr[row][0] = minVal; this->value.data.strptr[row][1] = 0; /* Null terminate */ } } break; case min2_fct: if( this->type==LONG ) { while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( pNull[0] && pNull[1] ) { this->value.undef[elem] = 1; this->value.data.lngptr[elem] = 0; } else if (pNull[0]) { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[1].data.lng; } else if (pNull[1]) { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[0].data.lng; } else { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = minvalue( pVals[0].data.lng, pVals[1].data.lng ); } } } } else if( this->type==DOUBLE ) { while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( pNull[0] && pNull[1] ) { this->value.undef[elem] = 1; this->value.data.dblptr[elem] = 0; } else if (pNull[0]) { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[1].data.dbl; } else if (pNull[1]) { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[0].data.dbl; } else { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = minvalue( pVals[0].data.dbl, pVals[1].data.dbl ); } } } } break; case max1_fct: elem = row * theParams[0]->value.nelem; if( this->type==LONG ) { long maxVal=0; while( row-- ) { valInit = 1; this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( !theParams[0]->value.undef[elem] ) { if ( valInit ) { valInit = 0; maxVal = theParams[0]->value.data.lngptr[elem]; } else { maxVal = maxvalue( maxVal, theParams[0]->value.data.lngptr[elem] ); } this->value.undef[row] = 0; } } this->value.data.lngptr[row] = maxVal; } } else if( this->type==DOUBLE ) { double maxVal=0.0; while( row-- ) { valInit = 1; this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( !theParams[0]->value.undef[elem] ) { if ( valInit ) { valInit = 0; maxVal = theParams[0]->value.data.dblptr[elem]; } else { maxVal = maxvalue( maxVal, theParams[0]->value.data.dblptr[elem] ); } this->value.undef[row] = 0; } } this->value.data.dblptr[row] = maxVal; } } else if( this->type==BITSTR ) { char maxVal; while( row-- ) { char *sptr1 = theParams[0]->value.data.strptr[row]; maxVal = '0'; while (*sptr1) { if (*sptr1 == '1') maxVal = '1'; sptr1++; } this->value.data.strptr[row][0] = maxVal; this->value.data.strptr[row][1] = 0; /* Null terminate */ } } break; case max2_fct: if( this->type==LONG ) { while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( pNull[0] && pNull[1] ) { this->value.undef[elem] = 1; this->value.data.lngptr[elem] = 0; } else if (pNull[0]) { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[1].data.lng; } else if (pNull[1]) { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[0].data.lng; } else { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = maxvalue( pVals[0].data.lng, pVals[1].data.lng ); } } } } else if( this->type==DOUBLE ) { while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( pNull[0] && pNull[1] ) { this->value.undef[elem] = 1; this->value.data.dblptr[elem] = 0; } else if (pNull[0]) { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[1].data.dbl; } else if (pNull[1]) { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[0].data.dbl; } else { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = maxvalue( pVals[0].data.dbl, pVals[1].data.dbl ); } } } } break; /* Boolean SAO region Functions... scalar or vector dbls */ case near_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=3; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2]) ) ) this->value.data.logptr[elem] = bnear( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl ); } } break; case circle_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=5; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2] || pNull[3] || pNull[4]) ) ) this->value.data.logptr[elem] = circle( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl ); } } break; case box_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=7; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2] || pNull[3] || pNull[4] || pNull[5] || pNull[6] ) ) ) this->value.data.logptr[elem] = saobox( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl, pVals[5].data.dbl, pVals[6].data.dbl ); } } break; case elps_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=7; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2] || pNull[3] || pNull[4] || pNull[5] || pNull[6] ) ) ) this->value.data.logptr[elem] = ellipse( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl, pVals[5].data.dbl, pVals[6].data.dbl ); } } break; /* C Conditional expression: bool ? expr : expr */ case ifthenelse_fct: switch( this->type ) { case BOOLEAN: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; if( vector[2]>1 ) { pVals[2].data.log = theParams[2]->value.data.logptr[elem]; pNull[2] = theParams[2]->value.undef[elem]; } else if( vector[2] ) { pVals[2].data.log = theParams[2]->value.data.logptr[row]; pNull[2] = theParams[2]->value.undef[row]; } i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.log = theParams[i]->value.data.logptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.log = theParams[i]->value.data.logptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = pNull[2]) ) { if( pVals[2].data.log ) { this->value.data.logptr[elem] = pVals[0].data.log; this->value.undef[elem] = pNull[0]; } else { this->value.data.logptr[elem] = pVals[1].data.log; this->value.undef[elem] = pNull[1]; } } } } break; case LONG: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; if( vector[2]>1 ) { pVals[2].data.log = theParams[2]->value.data.logptr[elem]; pNull[2] = theParams[2]->value.undef[elem]; } else if( vector[2] ) { pVals[2].data.log = theParams[2]->value.data.logptr[row]; pNull[2] = theParams[2]->value.undef[row]; } i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = pNull[2]) ) { if( pVals[2].data.log ) { this->value.data.lngptr[elem] = pVals[0].data.lng; this->value.undef[elem] = pNull[0]; } else { this->value.data.lngptr[elem] = pVals[1].data.lng; this->value.undef[elem] = pNull[1]; } } } } break; case DOUBLE: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; if( vector[2]>1 ) { pVals[2].data.log = theParams[2]->value.data.logptr[elem]; pNull[2] = theParams[2]->value.undef[elem]; } else if( vector[2] ) { pVals[2].data.log = theParams[2]->value.data.logptr[row]; pNull[2] = theParams[2]->value.undef[row]; } i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = pNull[2]) ) { if( pVals[2].data.log ) { this->value.data.dblptr[elem] = pVals[0].data.dbl; this->value.undef[elem] = pNull[0]; } else { this->value.data.dblptr[elem] = pVals[1].data.dbl; this->value.undef[elem] = pNull[1]; } } } } break; case STRING: while( row-- ) { if( vector[2] ) { pVals[2].data.log = theParams[2]->value.data.logptr[row]; pNull[2] = theParams[2]->value.undef[row]; } i=2; while( i-- ) if( vector[i] ) { strcpy( pVals[i].data.str, theParams[i]->value.data.strptr[row] ); pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[row] = pNull[2]) ) { if( pVals[2].data.log ) { strcpy( this->value.data.strptr[row], pVals[0].data.str ); this->value.undef[row] = pNull[0]; } else { strcpy( this->value.data.strptr[row], pVals[1].data.str ); this->value.undef[row] = pNull[1]; } } else { this->value.data.strptr[row][0] = '\0'; } } break; } break; /* String functions */ case strmid_fct: { int strconst = theParams[0]->operation == CONST_OP; int posconst = theParams[1]->operation == CONST_OP; int lenconst = theParams[2]->operation == CONST_OP; int dest_len = this->value.nelem; int src_len = theParams[0]->value.nelem; while (row--) { int pos; int len; char *str; int undef = 0; if (posconst) { pos = theParams[1]->value.data.lng; } else { pos = theParams[1]->value.data.lngptr[row]; if (theParams[1]->value.undef[row]) undef = 1; } if (strconst) { str = theParams[0]->value.data.str; if (src_len == 0) src_len = strlen(str); } else { str = theParams[0]->value.data.strptr[row]; if (theParams[0]->value.undef[row]) undef = 1; } if (lenconst) { len = dest_len; } else { len = theParams[2]->value.data.lngptr[row]; if (theParams[2]->value.undef[row]) undef = 1; } this->value.data.strptr[row][0] = '\0'; if (pos == 0) undef = 1; if (! undef ) { if (cstrmid(this->value.data.strptr[row], len, str, src_len, pos) < 0) break; } this->value.undef[row] = undef; } } break; /* String functions */ case strpos_fct: { int const1 = theParams[0]->operation == CONST_OP; int const2 = theParams[1]->operation == CONST_OP; while (row--) { char *str1, *str2; int undef = 0; if (const1) { str1 = theParams[0]->value.data.str; } else { str1 = theParams[0]->value.data.strptr[row]; if (theParams[0]->value.undef[row]) undef = 1; } if (const2) { str2 = theParams[1]->value.data.str; } else { str2 = theParams[1]->value.data.strptr[row]; if (theParams[1]->value.undef[row]) undef = 1; } this->value.data.lngptr[row] = 0; if (! undef ) { char *res = strstr(str1, str2); if (res == NULL) { undef = 1; this->value.data.lngptr[row] = 0; } else { this->value.data.lngptr[row] = (res - str1) + 1; } } this->value.undef[row] = undef; } } break; } /* End switch(this->operation) */ } /* End if (!gParse.status) */ } /* End non-constant operations */ i = this->nSubNodes; while( i-- ) { if( theParams[i]->operation>0 ) { /* Currently only numeric params allowed */ free( theParams[i]->value.data.ptr ); } } } static void Do_Deref( Node *this ) { Node *theVar, *theDims[MAXDIMS]; int isConst[MAXDIMS], allConst; long dimVals[MAXDIMS]; int i, nDims; long row, elem, dsize; theVar = gParse.Nodes + this->SubNodes[0]; i = nDims = this->nSubNodes-1; allConst = 1; while( i-- ) { theDims[i] = gParse.Nodes + this->SubNodes[i+1]; isConst[i] = ( theDims[i]->operation==CONST_OP ); if( isConst[i] ) dimVals[i] = theDims[i]->value.data.lng; else allConst = 0; } if( this->type==DOUBLE ) { dsize = sizeof( double ); } else if( this->type==LONG ) { dsize = sizeof( long ); } else if( this->type==BOOLEAN ) { dsize = sizeof( char ); } else dsize = 0; Allocate_Ptrs( this ); if( !gParse.status ) { if( allConst && theVar->value.naxis==nDims ) { /* Dereference completely using constant indices */ elem = 0; i = nDims; while( i-- ) { if( dimVals[i]<1 || dimVals[i]>theVar->value.naxes[i] ) break; elem = theVar->value.naxes[i]*elem + dimVals[i]-1; } if( i<0 ) { for( row=0; rowtype==STRING ) this->value.undef[row] = theVar->value.undef[row]; else if( this->type==BITSTR ) this->value.undef; /* Dummy - BITSTRs do not have undefs */ else this->value.undef[row] = theVar->value.undef[elem]; if( this->type==DOUBLE ) this->value.data.dblptr[row] = theVar->value.data.dblptr[elem]; else if( this->type==LONG ) this->value.data.lngptr[row] = theVar->value.data.lngptr[elem]; else if( this->type==BOOLEAN ) this->value.data.logptr[row] = theVar->value.data.logptr[elem]; else { /* XXX Note, the below expression uses knowledge of the layout of the string format, namely (nelem+1) characters per string, followed by (nelem+1) "undef" values. */ this->value.data.strptr[row][0] = theVar->value.data.strptr[0][elem+row]; this->value.data.strptr[row][1] = 0; /* Null terminate */ } elem += theVar->value.nelem; } } else { yyerror("Index out of range"); free( this->value.data.ptr ); } } else if( allConst && nDims==1 ) { /* Reduce dimensions by 1, using a constant index */ if( dimVals[0] < 1 || dimVals[0] > theVar->value.naxes[ theVar->value.naxis-1 ] ) { yyerror("Index out of range"); free( this->value.data.ptr ); } else if ( this->type == BITSTR || this->type == STRING ) { elem = this->value.nelem * (dimVals[0]-1); for( row=0; rowvalue.undef) this->value.undef[row] = theVar->value.undef[row]; memcpy( (char*)this->value.data.strptr[0] + row*sizeof(char)*(this->value.nelem+1), (char*)theVar->value.data.strptr[0] + elem*sizeof(char), this->value.nelem * sizeof(char) ); /* Null terminate */ this->value.data.strptr[row][this->value.nelem] = 0; elem += theVar->value.nelem+1; } } else { elem = this->value.nelem * (dimVals[0]-1); for( row=0; rowvalue.undef + row*this->value.nelem, theVar->value.undef + elem, this->value.nelem * sizeof(char) ); memcpy( (char*)this->value.data.ptr + row*dsize*this->value.nelem, (char*)theVar->value.data.ptr + elem*dsize, this->value.nelem * dsize ); elem += theVar->value.nelem; } } } else if( theVar->value.naxis==nDims ) { /* Dereference completely using an expression for the indices */ for( row=0; rowvalue.undef[row] ) { yyerror("Null encountered as vector index"); free( this->value.data.ptr ); break; } else dimVals[i] = theDims[i]->value.data.lngptr[row]; } } if( gParse.status ) break; elem = 0; i = nDims; while( i-- ) { if( dimVals[i]<1 || dimVals[i]>theVar->value.naxes[i] ) break; elem = theVar->value.naxes[i]*elem + dimVals[i]-1; } if( i<0 ) { elem += row*theVar->value.nelem; if( this->type==STRING ) this->value.undef[row] = theVar->value.undef[row]; else if( this->type==BITSTR ) this->value.undef; /* Dummy - BITSTRs do not have undefs */ else this->value.undef[row] = theVar->value.undef[elem]; if( this->type==DOUBLE ) this->value.data.dblptr[row] = theVar->value.data.dblptr[elem]; else if( this->type==LONG ) this->value.data.lngptr[row] = theVar->value.data.lngptr[elem]; else if( this->type==BOOLEAN ) this->value.data.logptr[row] = theVar->value.data.logptr[elem]; else { /* XXX Note, the below expression uses knowledge of the layout of the string format, namely (nelem+1) characters per string, followed by (nelem+1) "undef" values. */ this->value.data.strptr[row][0] = theVar->value.data.strptr[0][elem+row]; this->value.data.strptr[row][1] = 0; /* Null terminate */ } } else { yyerror("Index out of range"); free( this->value.data.ptr ); } } } else { /* Reduce dimensions by 1, using a nonconstant expression */ for( row=0; rowvalue.undef[row] ) { yyerror("Null encountered as vector index"); free( this->value.data.ptr ); break; } else dimVals[0] = theDims[0]->value.data.lngptr[row]; if( dimVals[0] < 1 || dimVals[0] > theVar->value.naxes[ theVar->value.naxis-1 ] ) { yyerror("Index out of range"); free( this->value.data.ptr ); } else if ( this->type == BITSTR || this->type == STRING ) { elem = this->value.nelem * (dimVals[0]-1); elem += row*(theVar->value.nelem+1); if (this->value.undef) this->value.undef[row] = theVar->value.undef[row]; memcpy( (char*)this->value.data.strptr[0] + row*sizeof(char)*(this->value.nelem+1), (char*)theVar->value.data.strptr[0] + elem*sizeof(char), this->value.nelem * sizeof(char) ); /* Null terminate */ this->value.data.strptr[row][this->value.nelem] = 0; } else { elem = this->value.nelem * (dimVals[0]-1); elem += row*theVar->value.nelem; memcpy( this->value.undef + row*this->value.nelem, theVar->value.undef + elem, this->value.nelem * sizeof(char) ); memcpy( (char*)this->value.data.ptr + row*dsize*this->value.nelem, (char*)theVar->value.data.ptr + elem*dsize, this->value.nelem * dsize ); } } } } if( theVar->operation>0 ) { if (theVar->type == STRING || theVar->type == BITSTR) free(theVar->value.data.strptr[0] ); else free( theVar->value.data.ptr ); } for( i=0; ioperation>0 ) { free( theDims[i]->value.data.ptr ); } } static void Do_GTI( Node *this ) { Node *theExpr, *theTimes; double *start, *stop, *times; long elem, nGTI, gti; int ordered; theTimes = gParse.Nodes + this->SubNodes[0]; theExpr = gParse.Nodes + this->SubNodes[1]; nGTI = theTimes->value.nelem; start = theTimes->value.data.dblptr; stop = theTimes->value.data.dblptr + nGTI; ordered = theTimes->type; if( theExpr->operation==CONST_OP ) { this->value.data.log = (Search_GTI( theExpr->value.data.dbl, nGTI, start, stop, ordered )>=0); this->operation = CONST_OP; } else { Allocate_Ptrs( this ); times = theExpr->value.data.dblptr; if( !gParse.status ) { elem = gParse.nRows * this->value.nelem; if( nGTI ) { gti = -1; while( elem-- ) { if( (this->value.undef[elem] = theExpr->value.undef[elem]) ) continue; /* Before searching entire GTI, check the GTI found last time */ if( gti<0 || times[elem]stop[gti] ) { gti = Search_GTI( times[elem], nGTI, start, stop, ordered ); } this->value.data.logptr[elem] = ( gti>=0 ); } } else while( elem-- ) { this->value.data.logptr[elem] = 0; this->value.undef[elem] = 0; } } } if( theExpr->operation>0 ) free( theExpr->value.data.ptr ); } static long Search_GTI( double evtTime, long nGTI, double *start, double *stop, int ordered ) { long gti, step; if( ordered && nGTI>15 ) { /* If time-ordered and lots of GTIs, */ /* use "FAST" Binary search algorithm */ if( evtTime>=start[0] && evtTime<=stop[nGTI-1] ) { gti = step = (nGTI >> 1); while(1) { if( step>1L ) step >>= 1; if( evtTime>stop[gti] ) { if( evtTime>=start[gti+1] ) gti += step; else { gti = -1L; break; } } else if( evtTime=start[gti] && evtTime<=stop[gti] ) break; } return( gti ); } static void Do_REG( Node *this ) { Node *theRegion, *theX, *theY; double Xval=0.0, Yval=0.0; char Xnull=0, Ynull=0; int Xvector, Yvector; long nelem, elem, rows; theRegion = gParse.Nodes + this->SubNodes[0]; theX = gParse.Nodes + this->SubNodes[1]; theY = gParse.Nodes + this->SubNodes[2]; Xvector = ( theX->operation!=CONST_OP ); if( Xvector ) Xvector = theX->value.nelem; else { Xval = theX->value.data.dbl; } Yvector = ( theY->operation!=CONST_OP ); if( Yvector ) Yvector = theY->value.nelem; else { Yval = theY->value.data.dbl; } if( !Xvector && !Yvector ) { this->value.data.log = ( fits_in_region( Xval, Yval, (SAORegion *)theRegion->value.data.ptr ) != 0 ); this->operation = CONST_OP; } else { Allocate_Ptrs( this ); if( !gParse.status ) { rows = gParse.nRows; nelem = this->value.nelem; elem = rows*nelem; while( rows-- ) { while( nelem-- ) { elem--; if( Xvector>1 ) { Xval = theX->value.data.dblptr[elem]; Xnull = theX->value.undef[elem]; } else if( Xvector ) { Xval = theX->value.data.dblptr[rows]; Xnull = theX->value.undef[rows]; } if( Yvector>1 ) { Yval = theY->value.data.dblptr[elem]; Ynull = theY->value.undef[elem]; } else if( Yvector ) { Yval = theY->value.data.dblptr[rows]; Ynull = theY->value.undef[rows]; } this->value.undef[elem] = ( Xnull || Ynull ); if( this->value.undef[elem] ) continue; this->value.data.logptr[elem] = ( fits_in_region( Xval, Yval, (SAORegion *)theRegion->value.data.ptr ) != 0 ); } nelem = this->value.nelem; } } } if( theX->operation>0 ) free( theX->value.data.ptr ); if( theY->operation>0 ) free( theY->value.data.ptr ); } static void Do_Vector( Node *this ) { Node *that; long row, elem, idx, jdx, offset=0; int node; Allocate_Ptrs( this ); if( !gParse.status ) { for( node=0; nodenSubNodes; node++ ) { that = gParse.Nodes + this->SubNodes[node]; if( that->operation == CONST_OP ) { idx = gParse.nRows*this->value.nelem + offset; while( (idx-=this->value.nelem)>=0 ) { this->value.undef[idx] = 0; switch( this->type ) { case BOOLEAN: this->value.data.logptr[idx] = that->value.data.log; break; case LONG: this->value.data.lngptr[idx] = that->value.data.lng; break; case DOUBLE: this->value.data.dblptr[idx] = that->value.data.dbl; break; } } } else { row = gParse.nRows; idx = row * that->value.nelem; while( row-- ) { elem = that->value.nelem; jdx = row*this->value.nelem + offset; while( elem-- ) { this->value.undef[jdx+elem] = that->value.undef[--idx]; switch( this->type ) { case BOOLEAN: this->value.data.logptr[jdx+elem] = that->value.data.logptr[idx]; break; case LONG: this->value.data.lngptr[jdx+elem] = that->value.data.lngptr[idx]; break; case DOUBLE: this->value.data.dblptr[jdx+elem] = that->value.data.dblptr[idx]; break; } } } } offset += that->value.nelem; } } for( node=0; node < this->nSubNodes; node++ ) if( OPER(this->SubNodes[node])>0 ) free( gParse.Nodes[this->SubNodes[node]].value.data.ptr ); } /*****************************************************************************/ /* Utility routines which perform the calculations on bits and SAO regions */ /*****************************************************************************/ static char bitlgte(char *bits1, int oper, char *bits2) { int val1, val2, nextbit; char result; int i, l1, l2, length, ldiff; char stream[256]; char chr1, chr2; l1 = strlen(bits1); l2 = strlen(bits2); if (l1 < l2) { length = l2; ldiff = l2 - l1; i=0; while( ldiff-- ) stream[i++] = '0'; while( l1-- ) stream[i++] = *(bits1++); stream[i] = '\0'; bits1 = stream; } else if (l2 < l1) { length = l1; ldiff = l1 - l2; i=0; while( ldiff-- ) stream[i++] = '0'; while( l2-- ) stream[i++] = *(bits2++); stream[i] = '\0'; bits2 = stream; } else length = l1; val1 = val2 = 0; nextbit = 1; while( length-- ) { chr1 = bits1[length]; chr2 = bits2[length]; if ((chr1 != 'x')&&(chr1 != 'X')&&(chr2 != 'x')&&(chr2 != 'X')) { if (chr1 == '1') val1 += nextbit; if (chr2 == '1') val2 += nextbit; nextbit *= 2; } } result = 0; switch (oper) { case LT: if (val1 < val2) result = 1; break; case LTE: if (val1 <= val2) result = 1; break; case GT: if (val1 > val2) result = 1; break; case GTE: if (val1 >= val2) result = 1; break; } return (result); } static void bitand(char *result,char *bitstrm1,char *bitstrm2) { int i, l1, l2, ldiff; char stream[256]; char chr1, chr2; l1 = strlen(bitstrm1); l2 = strlen(bitstrm2); if (l1 < l2) { ldiff = l2 - l1; i=0; while( ldiff-- ) stream[i++] = '0'; while( l1-- ) stream[i++] = *(bitstrm1++); stream[i] = '\0'; bitstrm1 = stream; } else if (l2 < l1) { ldiff = l1 - l2; i=0; while( ldiff-- ) stream[i++] = '0'; while( l2-- ) stream[i++] = *(bitstrm2++); stream[i] = '\0'; bitstrm2 = stream; } while ( (chr1 = *(bitstrm1++)) ) { chr2 = *(bitstrm2++); if ((chr1 == 'x') || (chr2 == 'x')) *result = 'x'; else if ((chr1 == '1') && (chr2 == '1')) *result = '1'; else *result = '0'; result++; } *result = '\0'; } static void bitor(char *result,char *bitstrm1,char *bitstrm2) { int i, l1, l2, ldiff; char stream[256]; char chr1, chr2; l1 = strlen(bitstrm1); l2 = strlen(bitstrm2); if (l1 < l2) { ldiff = l2 - l1; i=0; while( ldiff-- ) stream[i++] = '0'; while( l1-- ) stream[i++] = *(bitstrm1++); stream[i] = '\0'; bitstrm1 = stream; } else if (l2 < l1) { ldiff = l1 - l2; i=0; while( ldiff-- ) stream[i++] = '0'; while( l2-- ) stream[i++] = *(bitstrm2++); stream[i] = '\0'; bitstrm2 = stream; } while ( (chr1 = *(bitstrm1++)) ) { chr2 = *(bitstrm2++); if ((chr1 == '1') || (chr2 == '1')) *result = '1'; else if ((chr1 == '0') || (chr2 == '0')) *result = '0'; else *result = 'x'; result++; } *result = '\0'; } static void bitnot(char *result,char *bits) { int length; char chr; length = strlen(bits); while( length-- ) { chr = *(bits++); *(result++) = ( chr=='1' ? '0' : ( chr=='0' ? '1' : chr ) ); } *result = '\0'; } static char bitcmp(char *bitstrm1, char *bitstrm2) { int i, l1, l2, ldiff; char stream[256]; char chr1, chr2; l1 = strlen(bitstrm1); l2 = strlen(bitstrm2); if (l1 < l2) { ldiff = l2 - l1; i=0; while( ldiff-- ) stream[i++] = '0'; while( l1-- ) stream[i++] = *(bitstrm1++); stream[i] = '\0'; bitstrm1 = stream; } else if (l2 < l1) { ldiff = l1 - l2; i=0; while( ldiff-- ) stream[i++] = '0'; while( l2-- ) stream[i++] = *(bitstrm2++); stream[i] = '\0'; bitstrm2 = stream; } while( (chr1 = *(bitstrm1++)) ) { chr2 = *(bitstrm2++); if ( ((chr1 == '0') && (chr2 == '1')) || ((chr1 == '1') && (chr2 == '0')) ) return( 0 ); } return( 1 ); } static char bnear(double x, double y, double tolerance) { if (fabs(x - y) < tolerance) return ( 1 ); else return ( 0 ); } static char saobox(double xcen, double ycen, double xwid, double ywid, double rot, double xcol, double ycol) { double x,y,xprime,yprime,xmin,xmax,ymin,ymax,theta; theta = (rot / 180.0) * myPI; xprime = xcol - xcen; yprime = ycol - ycen; x = xprime * cos(theta) + yprime * sin(theta); y = -xprime * sin(theta) + yprime * cos(theta); xmin = - 0.5 * xwid; xmax = 0.5 * xwid; ymin = - 0.5 * ywid; ymax = 0.5 * ywid; if ((x >= xmin) && (x <= xmax) && (y >= ymin) && (y <= ymax)) return ( 1 ); else return ( 0 ); } static char circle(double xcen, double ycen, double rad, double xcol, double ycol) { double r2,dx,dy,dlen; dx = xcol - xcen; dy = ycol - ycen; dx *= dx; dy *= dy; dlen = dx + dy; r2 = rad * rad; if (dlen <= r2) return ( 1 ); else return ( 0 ); } static char ellipse(double xcen, double ycen, double xrad, double yrad, double rot, double xcol, double ycol) { double x,y,xprime,yprime,dx,dy,dlen,theta; theta = (rot / 180.0) * myPI; xprime = xcol - xcen; yprime = ycol - ycen; x = xprime * cos(theta) + yprime * sin(theta); y = -xprime * sin(theta) + yprime * cos(theta); dx = x / xrad; dy = y / yrad; dx *= dx; dy *= dy; dlen = dx + dy; if (dlen <= 1.0) return ( 1 ); else return ( 0 ); } /* * Extract substring */ int cstrmid(char *dest_str, int dest_len, char *src_str, int src_len, int pos) { /* char fill_char = ' '; */ char fill_char = '\0'; if (src_len == 0) { src_len = strlen(src_str); } /* .. if constant */ /* Fill destination with blanks */ if (pos < 0) { yyerror("STRMID(S,P,N) P must be 0 or greater"); return -1; } if (pos > src_len || pos == 0) { /* pos==0: blank string requested */ memset(dest_str, fill_char, dest_len); } else if (pos+dest_len > src_len) { /* Copy a subset */ int nsub = src_len-pos+1; int npad = dest_len - nsub; memcpy(dest_str, src_str+pos-1, nsub); /* Fill remaining string with blanks */ memset(dest_str+nsub, fill_char, npad); } else { /* Full string copy */ memcpy(dest_str, src_str+pos-1, dest_len); } dest_str[dest_len] = '\0'; /* Null-terminate */ return 0; } static void yyerror(char *s) { char msg[80]; if( !gParse.status ) gParse.status = PARSE_SYNTAX_ERR; strncpy(msg, s, 80); msg[79] = '\0'; ffpmsg(msg); } healpy-1.10.3/cfitsio/eval_defs.h0000664000175000017500000001023613010375005017063 0ustar zoncazonca00000000000000#include #include #include #include #if defined(__sgi) || defined(__hpux) #include #endif #ifdef sparc #include #endif #include "fitsio2.h" #define MAXDIMS 5 #define MAXSUBS 10 #define MAXVARNAME 80 #define CONST_OP -1000 #define pERROR -1 #define MAX_STRLEN 256 #define MAX_STRLEN_S "255" #ifndef FFBISON #include "eval_tab.h" #endif typedef struct { char name[MAXVARNAME+1]; int type; long nelem; int naxis; long naxes[MAXDIMS]; char *undef; void *data; } DataInfo; typedef struct { long nelem; int naxis; long naxes[MAXDIMS]; char *undef; union { double dbl; long lng; char log; char str[MAX_STRLEN]; double *dblptr; long *lngptr; char *logptr; char **strptr; void *ptr; } data; } lval; typedef struct Node { int operation; void (*DoOp)(struct Node *this); int nSubNodes; int SubNodes[MAXSUBS]; int type; lval value; } Node; typedef struct { fitsfile *def_fptr; int (*getData)( char *dataName, void *dataValue ); int (*loadData)( int varNum, long fRow, long nRows, void *data, char *undef ); int compressed; int timeCol; int parCol; int valCol; char *expr; int index; int is_eobuf; Node *Nodes; int nNodes; int nNodesAlloc; int resultNode; long firstRow; long nRows; int nCols; iteratorCol *colData; DataInfo *varData; PixelFilter *pixFilter; long firstDataRow; long nDataRows; long totalRows; int datatype; int hdutype; int status; } ParseData; typedef enum { rnd_fct = 1001, sum_fct, nelem_fct, sin_fct, cos_fct, tan_fct, asin_fct, acos_fct, atan_fct, sinh_fct, cosh_fct, tanh_fct, exp_fct, log_fct, log10_fct, sqrt_fct, abs_fct, atan2_fct, ceil_fct, floor_fct, round_fct, min1_fct, min2_fct, max1_fct, max2_fct, near_fct, circle_fct, box_fct, elps_fct, isnull_fct, defnull_fct, gtifilt_fct, regfilt_fct, ifthenelse_fct, row_fct, null_fct, median_fct, average_fct, stddev_fct, nonnull_fct, angsep_fct, gasrnd_fct, poirnd_fct, strmid_fct, strpos_fct } funcOp; extern ParseData gParse; #ifdef __cplusplus extern "C" { #endif int ffparse(void); int fflex(void); void ffrestart(FILE*); void Evaluate_Parser( long firstRow, long nRows ); #ifdef __cplusplus } #endif healpy-1.10.3/cfitsio/eval_f.c0000664000175000017500000030057713010375005016374 0ustar zoncazonca00000000000000/************************************************************************/ /* */ /* CFITSIO Lexical Parser */ /* */ /* This file is one of 3 files containing code which parses an */ /* arithmetic expression and evaluates it in the context of an input */ /* FITS file table extension. The CFITSIO lexical parser is divided */ /* into the following 3 parts/files: the CFITSIO "front-end", */ /* eval_f.c, contains the interface between the user/CFITSIO and the */ /* real core of the parser; the FLEX interpreter, eval_l.c, takes the */ /* input string and parses it into tokens and identifies the FITS */ /* information required to evaluate the expression (ie, keywords and */ /* columns); and, the BISON grammar and evaluation routines, eval_y.c, */ /* receives the FLEX output and determines and performs the actual */ /* operations. The files eval_l.c and eval_y.c are produced from */ /* running flex and bison on the files eval.l and eval.y, respectively. */ /* (flex and bison are available from any GNU archive: see www.gnu.org) */ /* */ /* The grammar rules, rather than evaluating the expression in situ, */ /* builds a tree, or Nodal, structure mapping out the order of */ /* operations and expression dependencies. This "compilation" process */ /* allows for much faster processing of multiple rows. This technique */ /* was developed by Uwe Lammers of the XMM Science Analysis System, */ /* although the CFITSIO implementation is entirely code original. */ /* */ /* */ /* Modification History: */ /* */ /* Kent Blackburn c1992 Original parser code developed for the */ /* FTOOLS software package, in particular, */ /* the fselect task. */ /* Kent Blackburn c1995 BIT column support added */ /* Peter D Wilson Feb 1998 Vector column support added */ /* Peter D Wilson May 1998 Ported to CFITSIO library. User */ /* interface routines written, in essence */ /* making fselect, fcalc, and maketime */ /* capabilities available to all tools */ /* via single function calls. */ /* Peter D Wilson Jun 1998 Major rewrite of parser core, so as to */ /* create a run-time evaluation tree, */ /* inspired by the work of Uwe Lammers, */ /* resulting in a speed increase of */ /* 10-100 times. */ /* Peter D Wilson Jul 1998 gtifilter(a,b,c,d) function added */ /* Peter D Wilson Aug 1998 regfilter(a,b,c,d) function added */ /* Peter D Wilson Jul 1999 Make parser fitsfile-independent, */ /* allowing a purely vector-based usage */ /* Peter D Wilson Aug 1999 Add row-offset capability */ /* Peter D Wilson Sep 1999 Add row-range capability to ffcalc_rng */ /* */ /************************************************************************/ #include #include #include "eval_defs.h" #include "region.h" typedef struct { int datatype; /* Data type to cast parse results into for user */ void *dataPtr; /* Pointer to array of results, NULL if to use iterCol */ void *nullPtr; /* Pointer to nulval, use zero if NULL */ long maxRows; /* Max No. of rows to process, -1=all, 0=1 iteration */ int anyNull; /* Flag indicating at least 1 undef value encountered */ } parseInfo; /* Internal routines needed to allow the evaluator to operate on FITS data */ static void Setup_DataArrays( int nCols, iteratorCol *cols, long fRow, long nRows ); static int find_column( char *colName, void *itslval ); static int find_keywd ( char *key, void *itslval ); static int allocateCol( int nCol, int *status ); static int load_column( int varNum, long fRow, long nRows, void *data, char *undef ); static int DEBUG_PIXFILTER; #define FREE(x) { if (x) free(x); else printf("invalid free(" #x ") at %s:%d\n", __FILE__, __LINE__); } /*---------------------------------------------------------------------------*/ int fffrow( fitsfile *fptr, /* I - Input FITS file */ char *expr, /* I - Boolean expression */ long firstrow, /* I - First row of table to eval */ long nrows, /* I - Number of rows to evaluate */ long *n_good_rows, /* O - Number of rows eval to True */ char *row_status, /* O - Array of boolean results */ int *status ) /* O - Error status */ /* */ /* Evaluate a boolean expression using the indicated rows, returning an */ /* array of flags indicating which rows evaluated to TRUE/FALSE */ /*---------------------------------------------------------------------------*/ { parseInfo Info; int naxis, constant; long nelem, naxes[MAXDIMS], elem; char result; if( *status ) return( *status ); FFLOCK; if( ffiprs( fptr, 0, expr, MAXDIMS, &Info.datatype, &nelem, &naxis, naxes, status ) ) { ffcprs(); FFUNLOCK; return( *status ); } if( nelem<0 ) { constant = 1; nelem = -nelem; } else constant = 0; if( Info.datatype!=TLOGICAL || nelem!=1 ) { ffcprs(); ffpmsg("Expression does not evaluate to a logical scalar."); FFUNLOCK; return( *status = PARSE_BAD_TYPE ); } if( constant ) { /* No need to call parser... have result from ffiprs */ result = gParse.Nodes[gParse.resultNode].value.data.log; *n_good_rows = nrows; for( elem=0; elem1 ? firstrow : 1); Info.dataPtr = row_status; Info.nullPtr = NULL; Info.maxRows = nrows; if( ffiter( gParse.nCols, gParse.colData, firstrow-1, 0, parse_data, (void*)&Info, status ) == -1 ) *status = 0; /* -1 indicates exitted without error before end... OK */ if( *status ) { /***********************/ /* Error... Do nothing */ /***********************/ } else { /***********************************/ /* Count number of good rows found */ /***********************************/ *n_good_rows = 0L; for( elem=0; elemHDUposition != (infptr->Fptr)->curhdu ) ffmahd( infptr, (infptr->HDUposition) + 1, NULL, status ); if( *status ) { ffcprs(); FFUNLOCK; return( *status ); } inExt.rowLength = (long) (infptr->Fptr)->rowlength; inExt.numRows = (infptr->Fptr)->numrows; inExt.heapSize = (infptr->Fptr)->heapsize; if( inExt.numRows == 0 ) { /* Nothing to copy */ ffcprs(); FFUNLOCK; return( *status ); } if( outfptr->HDUposition != (outfptr->Fptr)->curhdu ) ffmahd( outfptr, (outfptr->HDUposition) + 1, NULL, status ); if( (outfptr->Fptr)->datastart < 0 ) ffrdef( outfptr, status ); if( *status ) { ffcprs(); FFUNLOCK; return( *status ); } outExt.rowLength = (long) (outfptr->Fptr)->rowlength; outExt.numRows = (outfptr->Fptr)->numrows; if( !outExt.numRows ) (outfptr->Fptr)->heapsize = 0L; outExt.heapSize = (outfptr->Fptr)->heapsize; if( inExt.rowLength != outExt.rowLength ) { ffpmsg("Output table has different row length from input"); ffcprs(); FFUNLOCK; return( *status = PARSE_BAD_OUTPUT ); } /***********************************/ /* Fill out Info data for parser */ /***********************************/ Info.dataPtr = (char *)malloc( (size_t) ((inExt.numRows + 1) * sizeof(char)) ); Info.nullPtr = NULL; Info.maxRows = (long) inExt.numRows; if( !Info.dataPtr ) { ffpmsg("Unable to allocate memory for row selection"); ffcprs(); FFUNLOCK; return( *status = MEMORY_ALLOCATION ); } /* make sure array is zero terminated */ ((char*)Info.dataPtr)[inExt.numRows] = 0; if( constant ) { /* Set all rows to the same value from constant result */ result = gParse.Nodes[gParse.resultNode].value.data.log; for( ntodo = 0; ntodo 1) ffirow( outfptr, outExt.numRows, nGood, status ); } do { if( ((char*)Info.dataPtr)[inloc-1] ) { ffgtbb( infptr, inloc, 1L, rdlen, buffer+rdlen*nbuff, status ); nbuff++; if( nbuff==maxrows ) { ffptbb( outfptr, outloc, 1L, rdlen*nbuff, buffer, status ); outloc += nbuff; nbuff = 0; } } inloc++; } while( !*status && inloc<=inExt.numRows ); if( nbuff ) { ffptbb( outfptr, outloc, 1L, rdlen*nbuff, buffer, status ); outloc += nbuff; } if( infptr==outfptr ) { if( outloc<=inExt.numRows ) ffdrow( infptr, outloc, inExt.numRows-outloc+1, status ); } else if( inExt.heapSize && nGood ) { /* Copy heap, if it exists and at least one row copied */ /********************************************************/ /* Get location information from the output extension */ /********************************************************/ if( outfptr->HDUposition != (outfptr->Fptr)->curhdu ) ffmahd( outfptr, (outfptr->HDUposition) + 1, NULL, status ); outExt.dataStart = (outfptr->Fptr)->datastart; outExt.heapStart = (outfptr->Fptr)->heapstart; /*************************************************/ /* Insert more space into outfptr if necessary */ /*************************************************/ hsize = outExt.heapStart + outExt.heapSize; freespace = (long) (( ( (hsize + 2879) / 2880) * 2880) - hsize); ntodo = inExt.heapSize; if ( (freespace - ntodo) < 0) { /* not enough existing space? */ ntodo = (ntodo - freespace + 2879) / 2880; /* number of blocks */ ffiblk(outfptr, (long) ntodo, 1, status); /* insert the blocks */ } ffukyj( outfptr, "PCOUNT", inExt.heapSize+outExt.heapSize, NULL, status ); /*******************************************************/ /* Get location information from the input extension */ /*******************************************************/ if( infptr->HDUposition != (infptr->Fptr)->curhdu ) ffmahd( infptr, (infptr->HDUposition) + 1, NULL, status ); inExt.dataStart = (infptr->Fptr)->datastart; inExt.heapStart = (infptr->Fptr)->heapstart; /**********************************/ /* Finally copy heap to outfptr */ /**********************************/ ntodo = inExt.heapSize; inbyteloc = inExt.heapStart + inExt.dataStart; outbyteloc = outExt.heapStart + outExt.dataStart + outExt.heapSize; while ( ntodo && !*status ) { rdlen = (long) minvalue(ntodo,500000); ffmbyt( infptr, inbyteloc, REPORT_EOF, status ); ffgbyt( infptr, rdlen, buffer, status ); ffmbyt( outfptr, outbyteloc, IGNORE_EOF, status ); ffpbyt( outfptr, rdlen, buffer, status ); inbyteloc += rdlen; outbyteloc += rdlen; ntodo -= rdlen; } /***********************************************************/ /* But must update DES if data is being appended to a */ /* pre-existing heap space. Edit each new entry in file */ /***********************************************************/ if( outExt.heapSize ) { LONGLONG repeat, offset, j; int i; for( i=1; i<=(outfptr->Fptr)->tfield; i++ ) { if( (outfptr->Fptr)->tableptr[i-1].tdatatype<0 ) { for( j=outExt.numRows+1; j<=outExt.numRows+nGood; j++ ) { ffgdesll( outfptr, i, j, &repeat, &offset, status ); offset += outExt.heapSize; ffpdes( outfptr, i, j, repeat, offset, status ); } } } } } /* End of HEAP copy */ FREE(buffer); } FREE(Info.dataPtr); ffcprs(); ffcmph(outfptr, status); /* compress heap, deleting any orphaned data */ FFUNLOCK; return(*status); } /*---------------------------------------------------------------------------*/ int ffcrow( fitsfile *fptr, /* I - Input FITS file */ int datatype, /* I - Datatype to return results as */ char *expr, /* I - Arithmetic expression */ long firstrow, /* I - First row to evaluate */ long nelements, /* I - Number of elements to return */ void *nulval, /* I - Ptr to value to use as UNDEF */ void *array, /* O - Array of results */ int *anynul, /* O - Were any UNDEFs encountered? */ int *status ) /* O - Error status */ /* */ /* Calculate an expression for the indicated rows of a table, returning */ /* the results, cast as datatype (TSHORT, TDOUBLE, etc), in array. If */ /* nulval==NULL, UNDEFs will be zeroed out. For vector results, the number */ /* of elements returned may be less than nelements if nelements is not an */ /* even multiple of the result dimension. Call fftexp to obtain the */ /* dimensions of the results. */ /*---------------------------------------------------------------------------*/ { parseInfo Info; int naxis; long nelem1, naxes[MAXDIMS]; if( *status ) return( *status ); FFLOCK; if( ffiprs( fptr, 0, expr, MAXDIMS, &Info.datatype, &nelem1, &naxis, naxes, status ) ) { ffcprs(); FFUNLOCK; return( *status ); } if( nelem1<0 ) nelem1 = - nelem1; if( nelements1 ? firstrow : 1); if( datatype ) Info.datatype = datatype; Info.dataPtr = array; Info.nullPtr = nulval; Info.maxRows = nelements / nelem1; if( ffiter( gParse.nCols, gParse.colData, firstrow-1, 0, parse_data, (void*)&Info, status ) == -1 ) *status=0; /* -1 indicates exitted without error before end... OK */ *anynul = Info.anyNull; ffcprs(); FFUNLOCK; return( *status ); } /*--------------------------------------------------------------------------*/ int ffcalc( fitsfile *infptr, /* I - Input FITS file */ char *expr, /* I - Arithmetic expression */ fitsfile *outfptr, /* I - Output fits file */ char *parName, /* I - Name of output parameter */ char *parInfo, /* I - Extra information on parameter */ int *status ) /* O - Error status */ /* */ /* Evaluate an expression for all rows of a table. Call ffcalc_rng with */ /* a row range of 1-MAX. */ { long start=1, end=LONG_MAX; return ffcalc_rng( infptr, expr, outfptr, parName, parInfo, 1, &start, &end, status ); } /*--------------------------------------------------------------------------*/ int ffcalc_rng( fitsfile *infptr, /* I - Input FITS file */ char *expr, /* I - Arithmetic expression */ fitsfile *outfptr, /* I - Output fits file */ char *parName, /* I - Name of output parameter */ char *parInfo, /* I - Extra information on parameter */ int nRngs, /* I - Row range info */ long *start, /* I - Row range info */ long *end, /* I - Row range info */ int *status ) /* O - Error status */ /* */ /* Evaluate an expression using the data in the input FITS file and place */ /* the results into either a column or keyword in the output fits file, */ /* depending on the value of parName (keywords normally prefixed with '#') */ /* and whether the expression evaluates to a constant or a table column. */ /* The logic is as follows: */ /* (1) If a column exists with name, parName, put results there. */ /* (2) If parName starts with '#', as in #NAXIS, put result there, */ /* with parInfo used as the comment. If expression does not evaluate */ /* to a constant, flag an error. */ /* (3) If a keyword exists with name, parName, and expression is a */ /* constant, put result there, using parInfo as the new comment. */ /* (4) Else, create a new column with name parName and TFORM parInfo. */ /* If parInfo is NULL, use a default data type for the column. */ /*--------------------------------------------------------------------------*/ { parseInfo Info; int naxis, constant, typecode, newNullKwd=0; long nelem, naxes[MAXDIMS], repeat, width; int col_cnt, colNo; Node *result; char card[81], tform[16], nullKwd[9], tdimKwd[9]; if( *status ) return( *status ); FFLOCK; if( ffiprs( infptr, 0, expr, MAXDIMS, &Info.datatype, &nelem, &naxis, naxes, status ) ) { ffcprs(); FFUNLOCK; return( *status ); } if( nelem<0 ) { constant = 1; nelem = -nelem; } else constant = 0; /* Case (1): If column exists put it there */ colNo = 0; if( ffgcno( outfptr, CASEINSEN, parName, &colNo, status )==COL_NOT_FOUND ) { /* Output column doesn't exist. Test for keyword. */ /* Case (2): Does parName indicate result should be put into keyword */ *status = 0; if( parName[0]=='#' ) { if( ! constant ) { ffcprs(); ffpmsg( "Cannot put tabular result into keyword (ffcalc)" ); FFUNLOCK; return( *status = PARSE_BAD_TYPE ); } parName++; /* Advance past '#' */ if ( (strcasecmp(parName,"HISTORY") == 0 || strcasecmp(parName,"COMMENT") == 0) && Info.datatype != TSTRING ) { ffcprs(); ffpmsg( "HISTORY and COMMENT values must be strings (ffcalc)" ); FFUNLOCK; return( *status = PARSE_BAD_TYPE ); } } else if( constant ) { /* Case (3): Does a keyword named parName already exist */ if( ffgcrd( outfptr, parName, card, status )==KEY_NO_EXIST ) { colNo = -1; } else if( *status ) { ffcprs(); FFUNLOCK; return( *status ); } } else colNo = -1; if( colNo<0 ) { /* Case (4): Create new column */ *status = 0; ffgncl( outfptr, &colNo, status ); colNo++; if( parInfo==NULL || *parInfo=='\0' ) { /* Figure out best default column type */ if( gParse.hdutype==BINARY_TBL ) { sprintf(tform,"%ld",nelem); switch( Info.datatype ) { case TLOGICAL: strcat(tform,"L"); break; case TLONG: strcat(tform,"J"); break; case TDOUBLE: strcat(tform,"D"); break; case TSTRING: strcat(tform,"A"); break; case TBIT: strcat(tform,"X"); break; case TLONGLONG: strcat(tform,"K"); break; } } else { switch( Info.datatype ) { case TLOGICAL: ffcprs(); ffpmsg("Cannot create LOGICAL column in ASCII table"); FFUNLOCK; return( *status = NOT_BTABLE ); case TLONG: strcpy(tform,"I11"); break; case TDOUBLE: strcpy(tform,"D23.15"); break; case TSTRING: case TBIT: sprintf(tform,"A%ld",nelem); break; } } parInfo = tform; } else if( !(isdigit((int) *parInfo)) && gParse.hdutype==BINARY_TBL ) { if( Info.datatype==TBIT && *parInfo=='B' ) nelem = (nelem+7)/8; sprintf(tform,"%ld%s",nelem,parInfo); parInfo = tform; } fficol( outfptr, colNo, parName, parInfo, status ); if( naxis>1 ) ffptdm( outfptr, colNo, naxis, naxes, status ); /* Setup TNULLn keyword in case NULLs are encountered */ ffkeyn("TNULL", colNo, nullKwd, status); if( ffgcrd( outfptr, nullKwd, card, status )==KEY_NO_EXIST ) { *status = 0; if( gParse.hdutype==BINARY_TBL ) { LONGLONG nullVal=0; fits_binary_tform( parInfo, &typecode, &repeat, &width, status ); if( typecode==TBYTE ) nullVal = UCHAR_MAX; else if( typecode==TSHORT ) nullVal = SHRT_MIN; else if( typecode==TINT ) nullVal = INT_MIN; else if( typecode==TLONG ) nullVal = LONG_MIN; else if( typecode==TLONGLONG ) nullVal = LONGLONG_MIN; if( nullVal ) { ffpkyj( outfptr, nullKwd, nullVal, "Null value", status ); fits_set_btblnull( outfptr, colNo, nullVal, status ); newNullKwd = 1; } } else if( gParse.hdutype==ASCII_TBL ) { ffpkys( outfptr, nullKwd, "NULL", "Null value string", status ); fits_set_atblnull( outfptr, colNo, "NULL", status ); newNullKwd = 1; } } } } else if( *status ) { ffcprs(); FFUNLOCK; return( *status ); } else { /********************************************************/ /* Check if a TDIM keyword should be written/updated. */ /********************************************************/ ffkeyn("TDIM", colNo, tdimKwd, status); ffgcrd( outfptr, tdimKwd, card, status ); if( *status==0 ) { /* TDIM exists, so update it with result's dimension */ ffptdm( outfptr, colNo, naxis, naxes, status ); } else if( *status==KEY_NO_EXIST ) { /* TDIM does not exist, so clear error stack and */ /* write a TDIM only if result is multi-dimensional */ *status = 0; ffcmsg(); if( naxis>1 ) ffptdm( outfptr, colNo, naxis, naxes, status ); } if( *status ) { /* Either some other error happened in ffgcrd */ /* or one happened in ffptdm */ ffcprs(); FFUNLOCK; return( *status ); } } if( colNo>0 ) { /* Output column exists (now)... put results into it */ int anyNull = 0; int nPerLp, i; long totaln; ffgkyj(infptr, "NAXIS2", &totaln, 0, status); /*************************************/ /* Create new iterator Output Column */ /*************************************/ col_cnt = gParse.nCols; if( allocateCol( col_cnt, status ) ) { ffcprs(); FFUNLOCK; return( *status ); } fits_iter_set_by_num( gParse.colData+col_cnt, outfptr, colNo, 0, OutputCol ); gParse.nCols++; for( i=0; i= 10) && (nRngs == 1) && (start[0] == 1) && (end[0] == totaln)) nPerLp = 0; else nPerLp = Info.maxRows; if( ffiter( gParse.nCols, gParse.colData, start[i]-1, nPerLp, parse_data, (void*)&Info, status ) == -1 ) *status = 0; else if( *status ) { ffcprs(); FFUNLOCK; return( *status ); } if( Info.anyNull ) anyNull = 1; } if( newNullKwd && !anyNull ) { ffdkey( outfptr, nullKwd, status ); } } else { /* Put constant result into keyword */ result = gParse.Nodes + gParse.resultNode; switch( Info.datatype ) { case TDOUBLE: ffukyd( outfptr, parName, result->value.data.dbl, 15, parInfo, status ); break; case TLONG: ffukyj( outfptr, parName, result->value.data.lng, parInfo, status ); break; case TLOGICAL: ffukyl( outfptr, parName, result->value.data.log, parInfo, status ); break; case TBIT: case TSTRING: if (strcasecmp(parName,"HISTORY") == 0) { ffphis( outfptr, result->value.data.str, status); } else if (strcasecmp(parName,"COMMENT") == 0) { ffpcom( outfptr, result->value.data.str, status); } else { ffukys( outfptr, parName, result->value.data.str, parInfo, status ); } break; } } ffcprs(); FFUNLOCK; return( *status ); } /*--------------------------------------------------------------------------*/ int fftexp( fitsfile *fptr, /* I - Input FITS file */ char *expr, /* I - Arithmetic expression */ int maxdim, /* I - Max Dimension of naxes */ int *datatype, /* O - Data type of result */ long *nelem, /* O - Vector length of result */ int *naxis, /* O - # of dimensions of result */ long *naxes, /* O - Size of each dimension */ int *status ) /* O - Error status */ /* */ /* Evaluate the given expression and return information on the result. */ /*--------------------------------------------------------------------------*/ { FFLOCK; ffiprs( fptr, 0, expr, maxdim, datatype, nelem, naxis, naxes, status ); ffcprs(); FFUNLOCK; return( *status ); } /*--------------------------------------------------------------------------*/ int ffiprs( fitsfile *fptr, /* I - Input FITS file */ int compressed, /* I - Is FITS file hkunexpanded? */ char *expr, /* I - Arithmetic expression */ int maxdim, /* I - Max Dimension of naxes */ int *datatype, /* O - Data type of result */ long *nelem, /* O - Vector length of result */ int *naxis, /* O - # of dimensions of result */ long *naxes, /* O - Size of each dimension */ int *status ) /* O - Error status */ /* */ /* Initialize the parser and determine what type of result the expression */ /* produces. */ /*--------------------------------------------------------------------------*/ { Node *result; int i,lexpr, tstatus = 0; int xaxis, bitpix; long xaxes[9]; static iteratorCol dmyCol; if( *status ) return( *status ); /* make sure all internal structures for this HDU are current */ if ( ffrdef(fptr, status) ) return(*status); /* Initialize the Parser structure */ gParse.def_fptr = fptr; gParse.compressed = compressed; gParse.nCols = 0; gParse.colData = NULL; gParse.varData = NULL; gParse.getData = find_column; gParse.loadData = load_column; gParse.Nodes = NULL; gParse.nNodesAlloc= 0; gParse.nNodes = 0; gParse.hdutype = 0; gParse.status = 0; fits_get_hdu_type(fptr, &gParse.hdutype, status ); if (gParse.hdutype == IMAGE_HDU) { fits_get_img_param(fptr, 9, &bitpix, &xaxis, xaxes, status); if (*status) { ffpmsg("ffiprs: unable to get image dimensions"); return( *status ); } gParse.totalRows = xaxis > 0 ? 1 : 0; for (i = 0; i < xaxis; ++i) gParse.totalRows *= xaxes[i]; if (DEBUG_PIXFILTER) printf("naxis=%d, gParse.totalRows=%ld\n", xaxis, gParse.totalRows); } else if( ffgkyj(fptr, "NAXIS2", &gParse.totalRows, 0, &tstatus) ) { /* this might be a 1D or null image with no NAXIS2 keyword */ gParse.totalRows = 0; } /* Copy expression into parser... read from file if necessary */ if( expr[0]=='@' ) { if( ffimport_file( expr+1, &gParse.expr, status ) ) return( *status ); lexpr = strlen(gParse.expr); } else { lexpr = strlen(expr); gParse.expr = (char*)malloc( (2+lexpr)*sizeof(char)); strcpy(gParse.expr,expr); } strcat(gParse.expr + lexpr,"\n"); gParse.index = 0; gParse.is_eobuf = 0; /* Parse the expression, building the Nodes and determing */ /* which columns are needed and what data type is returned */ ffrestart(NULL); if( ffparse() ) { return( *status = PARSE_SYNTAX_ERR ); } /* Check results */ *status = gParse.status; if( *status ) return(*status); if( !gParse.nNodes ) { ffpmsg("Blank expression"); return( *status = PARSE_SYNTAX_ERR ); } if( !gParse.nCols ) { dmyCol.fptr = fptr; /* This allows iterator to know value of */ gParse.colData = &dmyCol; /* fptr when no columns are referenced */ } result = gParse.Nodes + gParse.resultNode; *naxis = result->value.naxis; *nelem = result->value.nelem; for( i=0; i<*naxis && ivalue.naxes[i]; switch( result->type ) { case BOOLEAN: *datatype = TLOGICAL; break; case LONG: *datatype = TLONG; break; case DOUBLE: *datatype = TDOUBLE; break; case BITSTR: *datatype = TBIT; break; case STRING: *datatype = TSTRING; break; default: *datatype = 0; ffpmsg("Bad return data type"); *status = gParse.status = PARSE_BAD_TYPE; break; } gParse.datatype = *datatype; FREE(gParse.expr); if( result->operation==CONST_OP ) *nelem = - *nelem; return(*status); } /*--------------------------------------------------------------------------*/ void ffcprs( void ) /* No parameters */ /* */ /* Clear the parser, making it ready to accept a new expression. */ /*--------------------------------------------------------------------------*/ { int col, node, i; if( gParse.nCols > 0 ) { FREE( gParse.colData ); for( col=0; col 0 ) { node = gParse.nNodes; while( node-- ) { if( gParse.Nodes[node].operation==gtifilt_fct ) { i = gParse.Nodes[node].SubNodes[0]; if (gParse.Nodes[ i ].value.data.ptr) FREE( gParse.Nodes[ i ].value.data.ptr ); } else if( gParse.Nodes[node].operation==regfilt_fct ) { i = gParse.Nodes[node].SubNodes[0]; fits_free_region( (SAORegion *)gParse.Nodes[ i ].value.data.ptr ); } } gParse.nNodes = 0; } if( gParse.Nodes ) free( gParse.Nodes ); gParse.Nodes = NULL; gParse.hdutype = ANY_HDU; gParse.pixFilter = 0; } /*---------------------------------------------------------------------------*/ int parse_data( long totalrows, /* I - Total rows to be processed */ long offset, /* I - Number of rows skipped at start*/ long firstrow, /* I - First row of this iteration */ long nrows, /* I - Number of rows in this iter */ int nCols, /* I - Number of columns in use */ iteratorCol *colData, /* IO- Column information/data */ void *userPtr ) /* I - Data handling instructions */ /* */ /* Iterator work function which calls the parser and copies the results */ /* into either an OutputCol or a data pointer supplied in the userPtr */ /* structure. */ /*---------------------------------------------------------------------------*/ { int status, constant=0, anyNullThisTime=0; long jj, kk, idx, remain, ntodo; Node *result; iteratorCol * outcol; /* declare variables static to preserve their values between calls */ static void *Data, *Null; static int datasize; static long lastRow, repeat, resDataSize; static LONGLONG jnull; static parseInfo *userInfo; static long zeros[4] = {0,0,0,0}; if (DEBUG_PIXFILTER) printf("parse_data(total=%ld, offset=%ld, first=%ld, rows=%ld, cols=%d)\n", totalrows, offset, firstrow, nrows, nCols); /*--------------------------------------------------------*/ /* Initialization procedures: execute on the first call */ /*--------------------------------------------------------*/ outcol = colData + (nCols - 1); if (firstrow == offset+1) { userInfo = (parseInfo*)userPtr; userInfo->anyNull = 0; if( userInfo->maxRows>0 ) userInfo->maxRows = minvalue(totalrows,userInfo->maxRows); else if( userInfo->maxRows<0 ) userInfo->maxRows = totalrows; else userInfo->maxRows = nrows; lastRow = firstrow + userInfo->maxRows - 1; if( userInfo->dataPtr==NULL ) { if( outcol->iotype == InputCol ) { ffpmsg("Output column for parser results not found!"); return( PARSE_NO_OUTPUT ); } /* Data gets set later */ Null = outcol->array; userInfo->datatype = outcol->datatype; /* Check for a TNULL/BLANK keyword for output column/image */ status = 0; jnull = 0; if (gParse.hdutype == IMAGE_HDU) { if (gParse.pixFilter->blank) jnull = (LONGLONG) gParse.pixFilter->blank; } else { ffgknjj( outcol->fptr, "TNULL", outcol->colnum, 1, &jnull, (int*)&jj, &status ); if( status==BAD_INTKEY ) { /* Probably ASCII table with text TNULL keyword */ switch( userInfo->datatype ) { case TSHORT: jnull = (LONGLONG) SHRT_MIN; break; case TINT: jnull = (LONGLONG) INT_MIN; break; case TLONG: jnull = (LONGLONG) LONG_MIN; break; } } } repeat = outcol->repeat; /* if (DEBUG_PIXFILTER) printf("parse_data: using null value %ld\n", jnull); */ } else { Data = userInfo->dataPtr; Null = (userInfo->nullPtr ? userInfo->nullPtr : zeros); repeat = gParse.Nodes[gParse.resultNode].value.nelem; } /* Determine the size of each element of the returned result */ switch( userInfo->datatype ) { case TBIT: /* Fall through to TBYTE */ case TLOGICAL: /* Fall through to TBYTE */ case TBYTE: datasize = sizeof(char); break; case TSHORT: datasize = sizeof(short); break; case TINT: datasize = sizeof(int); break; case TLONG: datasize = sizeof(long); break; case TLONGLONG: datasize = sizeof(LONGLONG); break; case TFLOAT: datasize = sizeof(float); break; case TDOUBLE: datasize = sizeof(double); break; case TSTRING: datasize = sizeof(char*); break; } /* Determine the size of each element of the calculated result */ /* (only matters for numeric/logical data) */ switch( gParse.Nodes[gParse.resultNode].type ) { case BOOLEAN: resDataSize = sizeof(char); break; case LONG: resDataSize = sizeof(long); break; case DOUBLE: resDataSize = sizeof(double); break; } } /*-------------------------------------------*/ /* Main loop: process all the rows of data */ /*-------------------------------------------*/ /* If writing to output column, set first element to appropriate */ /* null value. If no NULLs encounter, zero out before returning. */ /* if (DEBUG_PIXFILTER) printf("parse_data: using null value %ld\n", jnull); */ if( userInfo->dataPtr == NULL ) { /* First, reset Data pointer to start of output array */ Data = (char*) outcol->array + datasize; switch( userInfo->datatype ) { case TLOGICAL: *(char *)Null = 'U'; break; case TBYTE: *(char *)Null = (char )jnull; break; case TSHORT: *(short *)Null = (short)jnull; break; case TINT: *(int *)Null = (int )jnull; break; case TLONG: *(long *)Null = (long )jnull; break; case TLONGLONG: *(LONGLONG *)Null = (LONGLONG )jnull; break; case TFLOAT: *(float *)Null = FLOATNULLVALUE; break; case TDOUBLE: *(double*)Null = DOUBLENULLVALUE; break; case TSTRING: (*(char **)Null)[0] = '\1'; (*(char **)Null)[1] = '\0'; break; } } /* Alter nrows in case calling routine didn't want to do all rows */ nrows = minvalue(nrows,lastRow-firstrow+1); Setup_DataArrays( nCols, colData, firstrow, nrows ); /* Parser allocates arrays for each column and calculation it performs. */ /* Limit number of rows processed during each pass to reduce memory */ /* requirements... In most cases, iterator will limit rows to less */ /* than 2500 rows per iteration, so this is really only relevant for */ /* hk-compressed files which must be decompressed in memory and sent */ /* whole to parse_data in a single iteration. */ remain = nrows; while( remain ) { ntodo = minvalue(remain,2500); Evaluate_Parser ( firstrow, ntodo ); if( gParse.status ) break; firstrow += ntodo; remain -= ntodo; /* Copy results into data array */ result = gParse.Nodes + gParse.resultNode; if( result->operation==CONST_OP ) constant = 1; switch( result->type ) { case BOOLEAN: case LONG: case DOUBLE: if( constant ) { char undef=0; for( kk=0; kkvalue.data), &undef, result->value.nelem /* 1 */, userInfo->datatype, Null, (char*)Data + (kk*repeat+jj)*datasize, &anyNullThisTime, &gParse.status ); } else { if ( repeat == result->value.nelem ) { ffcvtn( gParse.datatype, result->value.data.ptr, result->value.undef, result->value.nelem*ntodo, userInfo->datatype, Null, Data, &anyNullThisTime, &gParse.status ); } else if( result->value.nelem == 1 ) { for( kk=0; kkvalue.data.ptr + kk*resDataSize, (char*)result->value.undef + kk, 1, userInfo->datatype, Null, (char*)Data + (kk*repeat+jj)*datasize, &anyNullThisTime, &gParse.status ); } } else { int nCopy; nCopy = minvalue( repeat, result->value.nelem ); for( kk=0; kkvalue.data.ptr + kk*result->value.nelem*resDataSize, (char*)result->value.undef + kk*result->value.nelem, nCopy, userInfo->datatype, Null, (char*)Data + (kk*repeat)*datasize, &anyNullThisTime, &gParse.status ); if( nCopy < repeat ) { memset( (char*)Data + (kk*repeat+nCopy)*datasize, 0, (repeat-nCopy)*datasize); } } } if( result->operation>0 ) { FREE( result->value.data.ptr ); } } if( gParse.status==OVERFLOW_ERR ) { gParse.status = NUM_OVERFLOW; ffpmsg("Numerical overflow while converting expression to necessary datatype"); } break; case BITSTR: switch( userInfo->datatype ) { case TBYTE: idx = -1; for( kk=0; kkvalue.nelem; jj++ ) { if( jj%8 == 0 ) ((char*)Data)[++idx] = 0; if( constant ) { if( result->value.data.str[jj]=='1' ) ((char*)Data)[idx] |= 128>>(jj%8); } else { if( result->value.data.strptr[kk][jj]=='1' ) ((char*)Data)[idx] |= 128>>(jj%8); } } } break; case TBIT: case TLOGICAL: if( constant ) { for( kk=0; kkvalue.nelem; jj++ ) { ((char*)Data)[ jj+kk*result->value.nelem ] = ( result->value.data.str[jj]=='1' ); } } else { for( kk=0; kkvalue.nelem; jj++ ) { ((char*)Data)[ jj+kk*result->value.nelem ] = ( result->value.data.strptr[kk][jj]=='1' ); } } break; case TSTRING: if( constant ) { for( jj=0; jjvalue.data.str ); } } else { for( jj=0; jjvalue.data.strptr[jj] ); } } break; default: ffpmsg("Cannot convert bit expression to desired type."); gParse.status = PARSE_BAD_TYPE; break; } if( result->operation>0 ) { FREE( result->value.data.strptr[0] ); FREE( result->value.data.strptr ); } break; case STRING: if( userInfo->datatype==TSTRING ) { if( constant ) { for( jj=0; jjvalue.data.str ); } else { for( jj=0; jjvalue.undef[jj] ) { anyNullThisTime = 1; strcpy( ((char**)Data)[jj], *(char **)Null ); } else { strcpy( ((char**)Data)[jj], result->value.data.strptr[jj] ); } } } else { ffpmsg("Cannot convert string expression to desired type."); gParse.status = PARSE_BAD_TYPE; } if( result->operation>0 ) { FREE( result->value.data.strptr[0] ); FREE( result->value.data.strptr ); } break; } if( gParse.status ) break; /* Increment Data to point to where the next block should go */ if( result->type==BITSTR && userInfo->datatype==TBYTE ) Data = (char*)Data + datasize * ( (result->value.nelem+7)/8 ) * ntodo; else if( result->type==STRING ) Data = (char*)Data + datasize * ntodo; else Data = (char*)Data + datasize * ntodo * repeat; } /* If no NULLs encountered during this pass, set Null value to */ /* zero to make the writing of the output column data faster */ if( anyNullThisTime ) userInfo->anyNull = 1; else if( userInfo->dataPtr == NULL ) { if( userInfo->datatype == TSTRING ) memcpy( *(char **)Null, zeros, 2 ); else memcpy( Null, zeros, datasize ); } /*-------------------------------------------------------*/ /* Clean up procedures: after processing all the rows */ /*-------------------------------------------------------*/ /* if the calling routine specified that only a limited number */ /* of rows in the table should be processed, return a value of -1 */ /* once all the rows have been done, if no other error occurred. */ if (gParse.hdutype != IMAGE_HDU && firstrow - 1 == lastRow) { if (!gParse.status && userInfo->maxRowsiotype == OutputCol ) continue; nelem = varData->nelem; len = nelem * nRows; switch ( varData->type ) { case BITSTR: /* No need for UNDEF array, but must make string DATA array */ len = (nelem+1)*nRows; /* Count '\0' */ bitStrs = (char**)varData->data; if( bitStrs ) FREE( bitStrs[0] ); free( bitStrs ); bitStrs = (char**)malloc( nRows*sizeof(char*) ); if( bitStrs==NULL ) { varData->data = varData->undef = NULL; gParse.status = MEMORY_ALLOCATION; break; } bitStrs[0] = (char*)malloc( len*sizeof(char) ); if( bitStrs[0]==NULL ) { free( bitStrs ); varData->data = varData->undef = NULL; gParse.status = MEMORY_ALLOCATION; break; } for( row=0; rowarray)[idx] & (1<<(7-len%8)) ) bitStrs[row][len] = '1'; else bitStrs[row][len] = '0'; if( len%8==7 ) idx++; } bitStrs[row][len] = '\0'; } varData->undef = (char*)bitStrs; varData->data = (char*)bitStrs; break; case STRING: sptr = (char**)icol->array; if (varData->undef) free( varData->undef ); varData->undef = (char*)malloc( nRows*sizeof(char) ); if( varData->undef==NULL ) { gParse.status = MEMORY_ALLOCATION; break; } row = nRows; while( row-- ) varData->undef[row] = ( **sptr != '\0' && FSTRCMP( sptr[0], sptr[row+1] )==0 ); varData->data = sptr + 1; break; case BOOLEAN: barray = (char*)icol->array; if (varData->undef) free( varData->undef ); varData->undef = (char*)malloc( len*sizeof(char) ); if( varData->undef==NULL ) { gParse.status = MEMORY_ALLOCATION; break; } while( len-- ) { varData->undef[len] = ( barray[0]!=0 && barray[0]==barray[len+1] ); } varData->data = barray + 1; break; case LONG: iarray = (long*)icol->array; if (varData->undef) free( varData->undef ); varData->undef = (char*)malloc( len*sizeof(char) ); if( varData->undef==NULL ) { gParse.status = MEMORY_ALLOCATION; break; } while( len-- ) { varData->undef[len] = ( iarray[0]!=0L && iarray[0]==iarray[len+1] ); } varData->data = iarray + 1; break; case DOUBLE: rarray = (double*)icol->array; if (varData->undef) free( varData->undef ); varData->undef = (char*)malloc( len*sizeof(char) ); if( varData->undef==NULL ) { gParse.status = MEMORY_ALLOCATION; break; } while( len-- ) { varData->undef[len] = ( rarray[0]!=0.0 && rarray[0]==rarray[len+1]); } varData->data = rarray + 1; break; default: sprintf(msg, "SetupDataArrays, unhandled type %d\n", varData->type); ffpmsg(msg); } if( gParse.status ) { /* Deallocate NULL arrays of previous columns */ while( i-- ) { varData = gParse.varData + i; if( varData->type==BITSTR ) FREE( ((char**)varData->data)[0] ); FREE( varData->undef ); varData->undef = NULL; } return; } } } /*--------------------------------------------------------------------------*/ int ffcvtn( int inputType, /* I - Data type of input array */ void *input, /* I - Input array of type inputType */ char *undef, /* I - Array of flags indicating UNDEF elems */ long ntodo, /* I - Number of elements to process */ int outputType, /* I - Data type of output array */ void *nulval, /* I - Ptr to value to use for UNDEF elements */ void *output, /* O - Output array of type outputType */ int *anynull, /* O - Any nulls flagged? */ int *status ) /* O - Error status */ /* */ /* Convert an array of any input data type to an array of any output */ /* data type, using an array of UNDEF flags to assign nulvals to */ /*--------------------------------------------------------------------------*/ { long i; switch( outputType ) { case TLOGICAL: switch( inputType ) { case TLOGICAL: case TBYTE: for( i=0; i UCHAR_MAX ) { *status = OVERFLOW_ERR; ((unsigned char*)output)[i] = UCHAR_MAX; } else ((unsigned char*)output)[i] = (unsigned char) ((long*)input)[i]; } } return( *status ); case TFLOAT: fffr4i1((float*)input,ntodo,1.,0.,0,0,NULL,NULL, (unsigned char*)output,status); break; case TDOUBLE: fffr8i1((double*)input,ntodo,1.,0.,0,0,NULL,NULL, (unsigned char*)output,status); break; default: *status = BAD_DATATYPE; break; } for(i=0;i SHRT_MAX ) { *status = OVERFLOW_ERR; ((short*)output)[i] = SHRT_MAX; } else ((short*)output)[i] = (short) ((long*)input)[i]; } } return( *status ); case TFLOAT: fffr4i2((float*)input,ntodo,1.,0.,0,0,NULL,NULL, (short*)output,status); break; case TDOUBLE: fffr8i2((double*)input,ntodo,1.,0.,0,0,NULL,NULL, (short*)output,status); break; default: *status = BAD_DATATYPE; break; } for(i=0;i=0 ) { found[parNo] = 1; /* Flag this parameter as found */ switch( gParse.colData[parNo].datatype ) { case TLONG: ffgcvj( fptr, gParse.valCol, row, 1L, 1L, ((long*)gParse.colData[parNo].array)[0], ((long*)gParse.colData[parNo].array)+currelem, &anynul, status ); break; case TDOUBLE: ffgcvd( fptr, gParse.valCol, row, 1L, 1L, ((double*)gParse.colData[parNo].array)[0], ((double*)gParse.colData[parNo].array)+currelem, &anynul, status ); break; case TSTRING: ffgcvs( fptr, gParse.valCol, row, 1L, 1L, ((char**)gParse.colData[parNo].array)[0], ((char**)gParse.colData[parNo].array)+currelem, &anynul, status ); break; } if( *status ) return( *status ); } } if( currelemoperation==CONST_OP ) { if( result->value.data.log ) { *(long*)userPtr = firstrow; return( -1 ); } } else { for( idx=0; idxvalue.data.logptr[idx] && !result->value.undef[idx] ) { *(long*)userPtr = firstrow + idx; return( -1 ); } } } return( gParse.status ); } static int set_image_col_types (fitsfile * fptr, const char * name, int bitpix, DataInfo * varInfo, iteratorCol *colIter) { int istatus; double tscale, tzero; char temp[80]; switch (bitpix) { case BYTE_IMG: case SHORT_IMG: case LONG_IMG: istatus = 0; if (fits_read_key(fptr, TDOUBLE, "BZERO", &tzero, NULL, &istatus)) tzero = 0.0; istatus = 0; if (fits_read_key(fptr, TDOUBLE, "BSCALE", &tscale, NULL, &istatus)) tscale = 1.0; if (tscale == 1.0 && (tzero == 0.0 || tzero == 32768.0 )) { varInfo->type = LONG; colIter->datatype = TLONG; } else { varInfo->type = DOUBLE; colIter->datatype = TDOUBLE; if (DEBUG_PIXFILTER) printf("use DOUBLE for %s with BSCALE=%g/BZERO=%g\n", name, tscale, tzero); } break; case LONGLONG_IMG: case FLOAT_IMG: case DOUBLE_IMG: varInfo->type = DOUBLE; colIter->datatype = TDOUBLE; break; default: sprintf(temp, "set_image_col_types: unrecognized image bitpix [%d]\n", bitpix); ffpmsg(temp); return gParse.status = PARSE_BAD_TYPE; } return 0; } /************************************************************************* Functions used by the evaluator to access FITS data (find_column, find_keywd, allocateCol, load_column) *************************************************************************/ static int find_column( char *colName, void *itslval ) { FFSTYPE *thelval = (FFSTYPE*)itslval; int col_cnt, status; int colnum, typecode, type; long repeat, width; fitsfile *fptr; char temp[80]; double tzero,tscale; int istatus; DataInfo *varInfo; iteratorCol *colIter; if (DEBUG_PIXFILTER) printf("find_column(%s)\n", colName); if( *colName == '#' ) return( find_keywd( colName + 1, itslval ) ); fptr = gParse.def_fptr; status = 0; col_cnt = gParse.nCols; if (gParse.hdutype == IMAGE_HDU) { int i; if (!gParse.pixFilter) { gParse.status = COL_NOT_FOUND; ffpmsg("find_column: IMAGE_HDU but no PixelFilter"); return pERROR; } colnum = -1; for (i = 0; i < gParse.pixFilter->count; ++i) { if (!strcasecmp(colName, gParse.pixFilter->tag[i])) colnum = i; } if (colnum < 0) { sprintf(temp, "find_column: PixelFilter tag %s not found", colName); ffpmsg(temp); gParse.status = COL_NOT_FOUND; return pERROR; } if( allocateCol( col_cnt, &gParse.status ) ) return pERROR; varInfo = gParse.varData + col_cnt; colIter = gParse.colData + col_cnt; fptr = gParse.pixFilter->ifptr[colnum]; fits_get_img_param(fptr, MAXDIMS, &typecode, /* actually bitpix */ &varInfo->naxis, &varInfo->naxes[0], &status); varInfo->nelem = 1; type = COLUMN; if (set_image_col_types(fptr, colName, typecode, varInfo, colIter)) return pERROR; colIter->fptr = fptr; colIter->iotype = InputCol; } else { /* HDU holds a table */ if( gParse.compressed ) colnum = gParse.valCol; else if( fits_get_colnum( fptr, CASEINSEN, colName, &colnum, &status ) ) { if( status == COL_NOT_FOUND ) { type = find_keywd( colName, itslval ); if( type != pERROR ) ffcmsg(); return( type ); } gParse.status = status; return pERROR; } if( fits_get_coltype( fptr, colnum, &typecode, &repeat, &width, &status ) ) { gParse.status = status; return pERROR; } if( allocateCol( col_cnt, &gParse.status ) ) return pERROR; varInfo = gParse.varData + col_cnt; colIter = gParse.colData + col_cnt; fits_iter_set_by_num( colIter, fptr, colnum, 0, InputCol ); } /* Make sure we don't overflow variable name array */ strncpy(varInfo->name,colName,MAXVARNAME); varInfo->name[MAXVARNAME] = '\0'; if (gParse.hdutype != IMAGE_HDU) { switch( typecode ) { case TBIT: varInfo->type = BITSTR; colIter->datatype = TBYTE; type = BITCOL; break; case TBYTE: case TSHORT: case TLONG: /* The datatype of column with TZERO and TSCALE keywords might be float or double. */ sprintf(temp,"TZERO%d",colnum); istatus = 0; if(fits_read_key(fptr,TDOUBLE,temp,&tzero,NULL,&istatus)) { tzero = 0.0; } sprintf(temp,"TSCAL%d",colnum); istatus = 0; if(fits_read_key(fptr,TDOUBLE,temp,&tscale,NULL,&istatus)) { tscale = 1.0; } if (tscale == 1.0 && (tzero == 0.0 || tzero == 32768.0 )) { varInfo->type = LONG; colIter->datatype = TLONG; /* Reading an unsigned long column as a long can cause overflow errors. Treat the column as a double instead. } else if (tscale == 1.0 && tzero == 2147483648.0 ) { varInfo->type = LONG; colIter->datatype = TULONG; */ } else { varInfo->type = DOUBLE; colIter->datatype = TDOUBLE; } type = COLUMN; break; /* For now, treat 8-byte integer columns as type double. This can lose precision, so the better long term solution will be to add support for TLONGLONG as a separate datatype. */ case TLONGLONG: case TFLOAT: case TDOUBLE: varInfo->type = DOUBLE; colIter->datatype = TDOUBLE; type = COLUMN; break; case TLOGICAL: varInfo->type = BOOLEAN; colIter->datatype = TLOGICAL; type = BCOLUMN; break; case TSTRING: varInfo->type = STRING; colIter->datatype = TSTRING; type = SCOLUMN; if ( width >= MAX_STRLEN ) { sprintf(temp, "column %d is wider than maximum %d characters", colnum, MAX_STRLEN-1); ffpmsg(temp); gParse.status = PARSE_LRG_VECTOR; return pERROR; } if( gParse.hdutype == ASCII_TBL ) repeat = width; break; default: if (typecode < 0) { sprintf(temp, "variable-length array columns are not supported. typecode = %d", typecode); ffpmsg(temp); } gParse.status = PARSE_BAD_TYPE; return pERROR; } varInfo->nelem = repeat; if( repeat>1 && typecode!=TSTRING ) { if( fits_read_tdim( fptr, colnum, MAXDIMS, &varInfo->naxis, &varInfo->naxes[0], &status ) ) { gParse.status = status; return pERROR; } } else { varInfo->naxis = 1; varInfo->naxes[0] = 1; } } gParse.nCols++; thelval->lng = col_cnt; return( type ); } static int find_keywd(char *keyname, void *itslval ) { FFSTYPE *thelval = (FFSTYPE*)itslval; int status, type; char keyvalue[FLEN_VALUE], dtype; fitsfile *fptr; double rval; int bval; long ival; status = 0; fptr = gParse.def_fptr; if( fits_read_keyword( fptr, keyname, keyvalue, NULL, &status ) ) { if( status == KEY_NO_EXIST ) { /* Do this since ffgkey doesn't put an error message on stack */ sprintf(keyvalue, "ffgkey could not find keyword: %s",keyname); ffpmsg(keyvalue); } gParse.status = status; return( pERROR ); } if( fits_get_keytype( keyvalue, &dtype, &status ) ) { gParse.status = status; return( pERROR ); } switch( dtype ) { case 'C': fits_read_key_str( fptr, keyname, keyvalue, NULL, &status ); type = STRING; strcpy( thelval->str , keyvalue ); break; case 'L': fits_read_key_log( fptr, keyname, &bval, NULL, &status ); type = BOOLEAN; thelval->log = bval; break; case 'I': fits_read_key_lng( fptr, keyname, &ival, NULL, &status ); type = LONG; thelval->lng = ival; break; case 'F': fits_read_key_dbl( fptr, keyname, &rval, NULL, &status ); type = DOUBLE; thelval->dbl = rval; break; default: type = pERROR; break; } if( status ) { gParse.status=status; return pERROR; } return( type ); } static int allocateCol( int nCol, int *status ) { if( (nCol%25)==0 ) { if( nCol ) { gParse.colData = (iteratorCol*) realloc( gParse.colData, (nCol+25)*sizeof(iteratorCol) ); gParse.varData = (DataInfo *) realloc( gParse.varData, (nCol+25)*sizeof(DataInfo) ); } else { gParse.colData = (iteratorCol*) malloc( 25*sizeof(iteratorCol) ); gParse.varData = (DataInfo *) malloc( 25*sizeof(DataInfo) ); } if( gParse.colData == NULL || gParse.varData == NULL ) { if( gParse.colData ) free(gParse.colData); if( gParse.varData ) free(gParse.varData); gParse.colData = NULL; gParse.varData = NULL; return( *status = MEMORY_ALLOCATION ); } } gParse.varData[nCol].data = NULL; gParse.varData[nCol].undef = NULL; return 0; } static int load_column( int varNum, long fRow, long nRows, void *data, char *undef ) { iteratorCol *var = gParse.colData+varNum; long nelem,nbytes,row,len,idx; char **bitStrs, msg[80]; unsigned char *bytes; int status = 0, anynul; if (gParse.hdutype == IMAGE_HDU) { /* This test would need to be on a per varNum basis to support * cross HDU operations */ fits_read_imgnull(var->fptr, var->datatype, fRow, nRows, data, undef, &anynul, &status); if (DEBUG_PIXFILTER) printf("load_column: IMAGE_HDU fRow=%ld, nRows=%ld => %d\n", fRow, nRows, status); } else { nelem = nRows * var->repeat; switch( var->datatype ) { case TBYTE: nbytes = ((var->repeat+7)/8) * nRows; bytes = (unsigned char *)malloc( nbytes * sizeof(char) ); ffgcvb(var->fptr, var->colnum, fRow, 1L, nbytes, 0, bytes, &anynul, &status); nelem = var->repeat; bitStrs = (char **)data; for( row=0; rowfptr, var->colnum, fRow, 1L, nRows, (char **)data, undef, &anynul, &status); break; case TLOGICAL: ffgcfl(var->fptr, var->colnum, fRow, 1L, nelem, (char *)data, undef, &anynul, &status); break; case TLONG: ffgcfj(var->fptr, var->colnum, fRow, 1L, nelem, (long *)data, undef, &anynul, &status); break; case TDOUBLE: ffgcfd(var->fptr, var->colnum, fRow, 1L, nelem, (double *)data, undef, &anynul, &status); break; default: sprintf(msg,"load_column: unexpected datatype %d", var->datatype); ffpmsg(msg); } } if( status ) { gParse.status = status; return pERROR; } return 0; } /*--------------------------------------------------------------------------*/ int fits_pixel_filter (PixelFilter * filter, int * status) /* Evaluate an expression using the data in the input FITS file(s) */ /*--------------------------------------------------------------------------*/ { parseInfo Info = { 0 }; int naxis, bitpix; long nelem, naxes[MAXDIMS]; int col_cnt; Node *result; int datatype; fitsfile * infptr; fitsfile * outfptr; char * DEFAULT_TAGS[] = { "X" }; char msg[256]; int writeBlankKwd = 0; /* write BLANK if any output nulls? */ DEBUG_PIXFILTER = getenv("DEBUG_PIXFILTER") ? 1 : 0; if (*status) return (*status); FFLOCK; if (!filter->tag || !filter->tag[0] || !filter->tag[0][0]) { filter->tag = DEFAULT_TAGS; if (DEBUG_PIXFILTER) printf("using default tag '%s'\n", filter->tag[0]); } infptr = filter->ifptr[0]; outfptr = filter->ofptr; gParse.pixFilter = filter; if (ffiprs(infptr, 0, filter->expression, MAXDIMS, &Info.datatype, &nelem, &naxis, naxes, status)) { goto CLEANUP; } if (nelem < 0) { nelem = -nelem; } { /* validate result type */ const char * type = 0; switch (Info.datatype) { case TLOGICAL: type = "LOGICAL"; break; case TLONG: type = "LONG"; break; case TDOUBLE: type = "DOUBLE"; break; case TSTRING: type = "STRING"; *status = pERROR; ffpmsg("pixel_filter: cannot have string image"); case TBIT: type = "BIT"; if (DEBUG_PIXFILTER) printf("hmm, image from bits?\n"); break; default: type = "UNKNOWN?!"; *status = pERROR; ffpmsg("pixel_filter: unexpected result datatype"); } if (DEBUG_PIXFILTER) printf("result type is %s [%d]\n", type, Info.datatype); if (*status) goto CLEANUP; } if (fits_get_img_param(infptr, MAXDIMS, &bitpix, &naxis, &naxes[0], status)) { ffpmsg("pixel_filter: unable to read input image parameters"); goto CLEANUP; } if (DEBUG_PIXFILTER) printf("input bitpix %d\n", bitpix); if (Info.datatype == TDOUBLE) { /* for floating point expressions, set the default output image to bitpix = -32 (float) unless the default is already a double */ if (bitpix != DOUBLE_IMG) bitpix = FLOAT_IMG; } /* override output image bitpix if specified by caller */ if (filter->bitpix) bitpix = filter->bitpix; if (DEBUG_PIXFILTER) printf("output bitpix %d\n", bitpix); if (fits_create_img(outfptr, bitpix, naxis, naxes, status)) { ffpmsg("pixel_filter: unable to create output image"); goto CLEANUP; } /* transfer keycards */ { int i, ncards, more; if (fits_get_hdrspace(infptr, &ncards, &more, status)) { ffpmsg("pixel_filter: unable to determine number of keycards"); goto CLEANUP; } for (i = 1; i <= ncards; ++i) { int keyclass; char card[FLEN_CARD]; if (fits_read_record(infptr, i, card, status)) { sprintf(msg, "pixel_filter: unable to read keycard %d", i); ffpmsg(msg); goto CLEANUP; } keyclass = fits_get_keyclass(card); if (keyclass == TYP_STRUC_KEY) { /* output structure defined by fits_create_img */ } else if (keyclass == TYP_COMM_KEY && i < 12) { /* assume this is one of the FITS standard comments */ } else if (keyclass == TYP_NULL_KEY && bitpix < 0) { /* do not transfer BLANK to real output image */ } else if (keyclass == TYP_SCAL_KEY && bitpix < 0) { /* do not transfer BZERO, BSCALE to real output image */ } else if (fits_write_record(outfptr, card, status)) { sprintf(msg, "pixel_filter: unable to write keycard '%s' [%d]\n", card, *status); ffpmsg(msg); goto CLEANUP; } } } switch (bitpix) { case BYTE_IMG: datatype = TLONG; Info.datatype = TBYTE; break; case SHORT_IMG: datatype = TLONG; Info.datatype = TSHORT; break; case LONG_IMG: datatype = TLONG; Info.datatype = TLONG; break; case FLOAT_IMG: datatype = TDOUBLE; Info.datatype = TFLOAT; break; case DOUBLE_IMG: datatype = TDOUBLE; Info.datatype = TDOUBLE; break; default: sprintf(msg, "pixel_filter: unexpected output bitpix %d\n", bitpix); ffpmsg(msg); *status = pERROR; goto CLEANUP; } if (bitpix > 0) { /* arrange for NULLs in output */ long nullVal = filter->blank; if (!filter->blank) { int tstatus = 0; if (fits_read_key_lng(infptr, "BLANK", &nullVal, 0, &tstatus)) { writeBlankKwd = 1; if (bitpix == BYTE_IMG) nullVal = UCHAR_MAX; else if (bitpix == SHORT_IMG) nullVal = SHRT_MIN; else if (bitpix == LONG_IMG) nullVal = LONG_MIN; else printf("unhandled positive output BITPIX %d\n", bitpix); } filter->blank = nullVal; } fits_set_imgnull(outfptr, filter->blank, status); if (DEBUG_PIXFILTER) printf("using blank %ld\n", nullVal); } if (!filter->keyword[0]) { iteratorCol * colIter; DataInfo * varInfo; /*************************************/ /* Create new iterator Output Column */ /*************************************/ col_cnt = gParse.nCols; if (allocateCol(col_cnt, status)) goto CLEANUP; gParse.nCols++; colIter = &gParse.colData[col_cnt]; colIter->fptr = filter->ofptr; colIter->iotype = OutputCol; varInfo = &gParse.varData[col_cnt]; set_image_col_types(colIter->fptr, "CREATED", bitpix, varInfo, colIter); Info.maxRows = -1; if (ffiter(gParse.nCols, gParse.colData, 0, 0, parse_data, &Info, status) == -1) *status = 0; else if (*status) goto CLEANUP; if (Info.anyNull) { if (writeBlankKwd) { fits_update_key_lng(outfptr, "BLANK", filter->blank, "NULL pixel value", status); if (*status) ffpmsg("pixel_filter: unable to write BLANK keyword"); if (DEBUG_PIXFILTER) { printf("output has NULLs\n"); printf("wrote blank [%d]\n", *status); } } } else if (bitpix > 0) /* never used a null */ if (fits_set_imgnull(outfptr, -1234554321, status)) ffpmsg("pixel_filter: unable to reset imgnull"); } else { /* Put constant result into keyword */ char * parName = filter->keyword; char * parInfo = filter->comment; result = gParse.Nodes + gParse.resultNode; switch (Info.datatype) { case TDOUBLE: ffukyd(outfptr, parName, result->value.data.dbl, 15, parInfo, status); break; case TLONG: ffukyj(outfptr, parName, result->value.data.lng, parInfo, status); break; case TLOGICAL: ffukyl(outfptr, parName, result->value.data.log, parInfo, status); break; case TBIT: case TSTRING: ffukys(outfptr, parName, result->value.data.str, parInfo, status); break; default: sprintf(msg, "pixel_filter: unexpected constant result type [%d]\n", Info.datatype); ffpmsg(msg); } } CLEANUP: ffcprs(); FFUNLOCK; return (*status); } healpy-1.10.3/cfitsio/eval_l.c0000664000175000017500000016627313010375005016405 0ustar zoncazonca00000000000000/* A lexical scanner generated by flex */ /* Scanner skeleton version: * $Header: /software/lheasoft/lheavc/hip/cfitsio/eval_l.c,v 3.47 2009/09/04 18:35:05 pence Exp $ */ #define FLEX_SCANNER #define FF_FLEX_MAJOR_VERSION 2 #define FF_FLEX_MINOR_VERSION 5 #include /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ #ifdef c_plusplus #ifndef __cplusplus #define __cplusplus #endif #endif #ifdef __cplusplus #include #include /* Use prototypes in function declarations. */ #define FF_USE_PROTOS /* The "const" storage-class-modifier is valid. */ #define FF_USE_CONST #else /* ! __cplusplus */ #if __STDC__ #define FF_USE_PROTOS #define FF_USE_CONST #endif /* __STDC__ */ #endif /* ! __cplusplus */ #ifdef __TURBOC__ #pragma warn -rch #pragma warn -use #include #include #define FF_USE_CONST #define FF_USE_PROTOS #endif #ifdef FF_USE_CONST #define ffconst const #else #define ffconst #endif #ifdef FF_USE_PROTOS #define FF_PROTO(proto) proto #else #define FF_PROTO(proto) () #endif /* Returned upon end-of-file. */ #define FF_NULL 0 /* Promotes a possibly negative, possibly signed char to an unsigned * integer for use as an array index. If the signed char is negative, * we want to instead treat it as an 8-bit unsigned char, hence the * double cast. */ #define FF_SC_TO_UI(c) ((unsigned int) (unsigned char) c) /* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */ #define BEGIN ff_start = 1 + 2 * /* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The FFSTATE alias is for lex * compatibility. */ #define FF_START ((ff_start - 1) / 2) #define FFSTATE FF_START /* Action number for EOF rule of a given start state. */ #define FF_STATE_EOF(state) (FF_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ #define FF_NEW_FILE ffrestart( ffin ) #define FF_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ #define FF_BUF_SIZE 16384 typedef struct ff_buffer_state *FF_BUFFER_STATE; extern int ffleng; extern FILE *ffin, *ffout; #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 /* The funky do-while in the following #define is used to turn the definition * int a single C statement (which needs a semi-colon terminator). This * avoids problems with code like: * * if ( condition_holds ) * ffless( 5 ); * else * do_something_else(); * * Prior to using the do-while the compiler would get upset at the * "else" because it interpreted the "if" statement as being all * done when it reached the ';' after the ffless() call. */ /* Return all but the first 'n' matched characters back to the input stream. */ #define ffless(n) \ do \ { \ /* Undo effects of setting up fftext. */ \ *ff_cp = ff_hold_char; \ FF_RESTORE_FF_MORE_OFFSET \ ff_c_buf_p = ff_cp = ff_bp + n - FF_MORE_ADJ; \ FF_DO_BEFORE_ACTION; /* set up fftext again */ \ } \ while ( 0 ) #define unput(c) ffunput( c, fftext_ptr ) /* The following is because we cannot portably get our hands on size_t * (without autoconf's help, which isn't available because we want * flex-generated scanners to compile on their own). */ typedef unsigned int ff_size_t; struct ff_buffer_state { FILE *ff_input_file; char *ff_ch_buf; /* input buffer */ char *ff_buf_pos; /* current position in input buffer */ /* Size of input buffer in bytes, not including room for EOB * characters. */ ff_size_t ff_buf_size; /* Number of characters read into ff_ch_buf, not including EOB * characters. */ int ff_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to * delete it. */ int ff_is_our_buffer; /* Whether this is an "interactive" input source; if so, and * if we're using stdio for input, then we want to use getc() * instead of fread(), to make sure we stop fetching input after * each newline. */ int ff_is_interactive; /* Whether we're considered to be at the beginning of a line. * If so, '^' rules will be active on the next match, otherwise * not. */ int ff_at_bol; /* Whether to try to fill the input buffer when we reach the * end of it. */ int ff_fill_buffer; int ff_buffer_status; #define FF_BUFFER_NEW 0 #define FF_BUFFER_NORMAL 1 /* When an EOF's been seen but there's still some text to process * then we mark the buffer as FF_EOF_PENDING, to indicate that we * shouldn't try reading from the input source any more. We might * still have a bunch of tokens to match, though, because of * possible backing-up. * * When we actually see the EOF, we change the status to "new" * (via ffrestart()), so that the user can continue scanning by * just pointing ffin at a new input file. */ #define FF_BUFFER_EOF_PENDING 2 }; static FF_BUFFER_STATE ff_current_buffer = 0; /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". */ #define FF_CURRENT_BUFFER ff_current_buffer /* ff_hold_char holds the character lost when fftext is formed. */ static char ff_hold_char; static int ff_n_chars; /* number of characters read into ff_ch_buf */ int ffleng; /* Points to current character in buffer. */ static char *ff_c_buf_p = (char *) 0; static int ff_init = 1; /* whether we need to initialize */ static int ff_start = 0; /* start state number */ /* Flag which is used to allow ffwrap()'s to do buffer switches * instead of setting up a fresh ffin. A bit of a hack ... */ static int ff_did_buffer_switch_on_eof; void ffrestart FF_PROTO(( FILE *input_file )); void ff_switch_to_buffer FF_PROTO(( FF_BUFFER_STATE new_buffer )); void ff_load_buffer_state FF_PROTO(( void )); FF_BUFFER_STATE ff_create_buffer FF_PROTO(( FILE *file, int size )); void ff_delete_buffer FF_PROTO(( FF_BUFFER_STATE b )); void ff_init_buffer FF_PROTO(( FF_BUFFER_STATE b, FILE *file )); void ff_flush_buffer FF_PROTO(( FF_BUFFER_STATE b )); #define FF_FLUSH_BUFFER ff_flush_buffer( ff_current_buffer ) FF_BUFFER_STATE ff_scan_buffer FF_PROTO(( char *base, ff_size_t size )); FF_BUFFER_STATE ff_scan_string FF_PROTO(( ffconst char *ff_str )); FF_BUFFER_STATE ff_scan_bytes FF_PROTO(( ffconst char *bytes, int len )); static void *ff_flex_alloc FF_PROTO(( ff_size_t )); static void *ff_flex_realloc FF_PROTO(( void *, ff_size_t )); static void ff_flex_free FF_PROTO(( void * )); #define ff_new_buffer ff_create_buffer #define ff_set_interactive(is_interactive) \ { \ if ( ! ff_current_buffer ) \ ff_current_buffer = ff_create_buffer( ffin, FF_BUF_SIZE ); \ ff_current_buffer->ff_is_interactive = is_interactive; \ } #define ff_set_bol(at_bol) \ { \ if ( ! ff_current_buffer ) \ ff_current_buffer = ff_create_buffer( ffin, FF_BUF_SIZE ); \ ff_current_buffer->ff_at_bol = at_bol; \ } #define FF_AT_BOL() (ff_current_buffer->ff_at_bol) typedef unsigned char FF_CHAR; FILE *ffin = (FILE *) 0, *ffout = (FILE *) 0; typedef int ff_state_type; extern char *fftext; #define fftext_ptr fftext static ff_state_type ff_get_previous_state FF_PROTO(( void )); static ff_state_type ff_try_NUL_trans FF_PROTO(( ff_state_type current_state )); static int ff_get_next_buffer FF_PROTO(( void )); static void ff_fatal_error FF_PROTO(( ffconst char msg[] )); /* Done after the current pattern has been matched and before the * corresponding action - sets up fftext. */ #define FF_DO_BEFORE_ACTION \ fftext_ptr = ff_bp; \ ffleng = (int) (ff_cp - ff_bp); \ ff_hold_char = *ff_cp; \ *ff_cp = '\0'; \ ff_c_buf_p = ff_cp; #define FF_NUM_RULES 26 #define FF_END_OF_BUFFER 27 static ffconst short int ff_accept[160] = { 0, 0, 0, 27, 25, 1, 24, 15, 25, 25, 25, 25, 25, 25, 25, 7, 5, 21, 25, 20, 10, 10, 10, 10, 6, 10, 10, 10, 10, 10, 14, 10, 10, 10, 10, 10, 10, 10, 25, 1, 19, 0, 9, 0, 8, 0, 10, 17, 0, 0, 0, 0, 0, 0, 0, 14, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 5, 0, 23, 18, 22, 10, 10, 10, 2, 10, 10, 10, 4, 10, 10, 10, 10, 3, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 16, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 11, 10, 20, 21, 10, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0 } ; static ffconst int ff_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 5, 6, 7, 1, 8, 9, 10, 11, 12, 13, 1, 13, 14, 1, 15, 15, 16, 16, 16, 16, 16, 16, 17, 17, 1, 1, 18, 19, 20, 1, 1, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 30, 31, 30, 32, 33, 30, 34, 35, 30, 36, 37, 30, 30, 38, 30, 30, 1, 1, 1, 39, 40, 1, 41, 42, 23, 43, 44, 45, 46, 28, 47, 30, 30, 48, 30, 49, 50, 30, 51, 52, 30, 53, 54, 30, 30, 38, 30, 30, 1, 55, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ; static ffconst int ff_meta[56] = { 0, 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 1, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1 } ; static ffconst short int ff_base[167] = { 0, 0, 0, 367, 368, 364, 368, 346, 359, 356, 355, 353, 351, 32, 347, 66, 103, 339, 44, 338, 25, 52, 316, 26, 315, 34, 133, 48, 61, 125, 368, 0, 29, 45, 60, 81, 82, 93, 299, 351, 368, 347, 368, 344, 343, 342, 368, 368, 339, 314, 315, 313, 294, 295, 293, 368, 121, 164, 307, 301, 70, 117, 43, 296, 276, 271, 58, 86, 79, 269, 152, 168, 181, 368, 368, 368, 151, 162, 0, 180, 189, 190, 191, 309, 196, 199, 205, 204, 211, 214, 207, 223, 224, 232, 238, 243, 245, 222, 246, 368, 311, 310, 279, 282, 278, 259, 262, 258, 252, 286, 295, 294, 293, 292, 291, 290, 267, 288, 258, 285, 284, 278, 270, 268, 259, 218, 252, 264, 272, 368, 251, 368, 368, 260, 280, 283, 236, 222, 230, 193, 184, 212, 208, 202, 173, 156, 368, 133, 126, 368, 104, 98, 119, 132, 80, 94, 92, 368, 78, 368, 323, 325, 329, 333, 68, 67, 337 } ; static ffconst short int ff_def[167] = { 0, 159, 1, 159, 159, 159, 159, 159, 160, 161, 162, 159, 163, 159, 159, 159, 159, 159, 159, 159, 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, 159, 165, 164, 164, 164, 164, 164, 164, 159, 159, 159, 160, 159, 166, 161, 162, 159, 159, 163, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 164, 164, 165, 164, 164, 164, 164, 26, 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, 164, 159, 166, 166, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 164, 159, 159, 164, 164, 164, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 0, 159, 159, 159, 159, 159, 159, 159 } ; static ffconst short int ff_nxt[424] = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 4, 14, 4, 15, 16, 16, 16, 17, 18, 19, 20, 21, 22, 22, 23, 24, 25, 26, 22, 22, 27, 28, 29, 22, 22, 24, 22, 22, 30, 31, 32, 21, 22, 33, 24, 34, 22, 35, 36, 37, 22, 22, 24, 22, 38, 49, 77, 50, 81, 80, 51, 73, 74, 75, 78, 78, 79, 115, 78, 82, 78, 76, 84, 78, 52, 116, 53, 90, 54, 56, 57, 57, 57, 85, 78, 86, 58, 78, 157, 79, 59, 78, 60, 87, 111, 91, 61, 62, 63, 78, 78, 120, 157, 92, 157, 112, 64, 88, 88, 65, 121, 66, 93, 67, 68, 69, 70, 71, 71, 71, 78, 78, 124, 158, 94, 96, 72, 72, 125, 122, 88, 97, 78, 95, 56, 108, 108, 108, 123, 88, 88, 113, 157, 156, 98, 72, 72, 83, 83, 83, 155, 154, 114, 83, 83, 83, 83, 83, 83, 89, 129, 153, 88, 152, 78, 56, 57, 57, 57, 146, 83, 129, 78, 83, 83, 83, 83, 83, 57, 57, 57, 70, 71, 71, 71, 130, 47, 72, 72, 129, 78, 72, 72, 127, 79, 128, 128, 128, 129, 129, 129, 78, 74, 75, 131, 129, 72, 72, 129, 73, 72, 72, 132, 129, 129, 146, 129, 79, 40, 78, 129, 47, 149, 129, 151, 88, 88, 99, 78, 78, 78, 129, 129, 129, 150, 78, 74, 75, 78, 133, 149, 129, 148, 78, 78, 131, 78, 129, 88, 134, 78, 73, 129, 78, 129, 129, 132, 147, 40, 99, 129, 78, 78, 78, 47, 99, 108, 108, 108, 129, 145, 78, 40, 146, 135, 72, 72, 78, 128, 128, 128, 132, 78, 73, 78, 78, 128, 128, 128, 129, 78, 131, 129, 47, 72, 72, 146, 75, 74, 78, 144, 99, 143, 40, 132, 73, 131, 75, 74, 142, 141, 140, 139, 138, 137, 136, 101, 101, 129, 78, 126, 119, 78, 41, 118, 41, 41, 44, 44, 45, 117, 45, 45, 48, 110, 48, 48, 100, 109, 100, 100, 107, 106, 105, 104, 103, 102, 42, 46, 159, 101, 42, 39, 99, 78, 78, 75, 73, 55, 42, 47, 46, 43, 42, 40, 39, 159, 3, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159 } ; static ffconst short int ff_chk[424] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 13, 20, 13, 25, 23, 13, 18, 18, 18, 20, 23, 21, 62, 32, 25, 165, 164, 27, 25, 13, 62, 13, 32, 13, 15, 15, 15, 15, 27, 33, 28, 15, 27, 158, 21, 15, 21, 15, 28, 60, 33, 15, 15, 15, 34, 28, 66, 156, 34, 155, 60, 15, 37, 37, 15, 66, 15, 34, 15, 15, 15, 16, 16, 16, 16, 35, 36, 68, 154, 35, 36, 16, 16, 68, 67, 37, 36, 37, 35, 56, 56, 56, 56, 67, 29, 29, 61, 153, 152, 37, 16, 16, 26, 26, 26, 151, 150, 61, 26, 26, 26, 26, 26, 26, 29, 76, 148, 29, 147, 29, 70, 70, 70, 70, 145, 26, 77, 26, 26, 26, 26, 26, 26, 57, 57, 57, 71, 71, 71, 71, 77, 144, 57, 57, 79, 76, 71, 71, 72, 79, 72, 72, 72, 80, 81, 82, 77, 80, 81, 82, 84, 57, 57, 85, 84, 71, 71, 85, 87, 86, 143, 90, 79, 86, 79, 88, 142, 141, 89, 140, 88, 88, 89, 80, 81, 82, 97, 91, 92, 139, 84, 91, 92, 85, 87, 138, 93, 137, 87, 86, 93, 90, 94, 88, 90, 88, 94, 95, 89, 96, 98, 95, 136, 96, 98, 130, 97, 91, 92, 130, 126, 108, 108, 108, 133, 125, 93, 124, 133, 97, 108, 108, 94, 127, 127, 127, 123, 95, 122, 96, 98, 128, 128, 128, 134, 130, 121, 135, 134, 108, 108, 135, 120, 119, 133, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 107, 106, 105, 104, 103, 102, 101, 100, 83, 134, 69, 65, 135, 160, 64, 160, 160, 161, 161, 162, 63, 162, 162, 163, 59, 163, 163, 166, 58, 166, 166, 54, 53, 52, 51, 50, 49, 48, 45, 44, 43, 41, 39, 38, 24, 22, 19, 17, 14, 12, 11, 10, 9, 8, 7, 5, 3, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, 159 } ; static ff_state_type ff_last_accepting_state; static char *ff_last_accepting_cpos; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */ #define REJECT reject_used_but_not_detected #define ffmore() ffmore_used_but_not_detected #define FF_MORE_ADJ 0 #define FF_RESTORE_FF_MORE_OFFSET char *fftext; #line 1 "eval.l" #define INITIAL 0 #line 2 "eval.l" /************************************************************************/ /* */ /* CFITSIO Lexical Parser */ /* */ /* This file is one of 3 files containing code which parses an */ /* arithmetic expression and evaluates it in the context of an input */ /* FITS file table extension. The CFITSIO lexical parser is divided */ /* into the following 3 parts/files: the CFITSIO "front-end", */ /* eval_f.c, contains the interface between the user/CFITSIO and the */ /* real core of the parser; the FLEX interpreter, eval_l.c, takes the */ /* input string and parses it into tokens and identifies the FITS */ /* information required to evaluate the expression (ie, keywords and */ /* columns); and, the BISON grammar and evaluation routines, eval_y.c, */ /* receives the FLEX output and determines and performs the actual */ /* operations. The files eval_l.c and eval_y.c are produced from */ /* running flex and bison on the files eval.l and eval.y, respectively. */ /* (flex and bison are available from any GNU archive: see www.gnu.org) */ /* */ /* The grammar rules, rather than evaluating the expression in situ, */ /* builds a tree, or Nodal, structure mapping out the order of */ /* operations and expression dependencies. This "compilation" process */ /* allows for much faster processing of multiple rows. This technique */ /* was developed by Uwe Lammers of the XMM Science Analysis System, */ /* although the CFITSIO implementation is entirely code original. */ /* */ /* */ /* Modification History: */ /* */ /* Kent Blackburn c1992 Original parser code developed for the */ /* FTOOLS software package, in particular, */ /* the fselect task. */ /* Kent Blackburn c1995 BIT column support added */ /* Peter D Wilson Feb 1998 Vector column support added */ /* Peter D Wilson May 1998 Ported to CFITSIO library. User */ /* interface routines written, in essence */ /* making fselect, fcalc, and maketime */ /* capabilities available to all tools */ /* via single function calls. */ /* Peter D Wilson Jun 1998 Major rewrite of parser core, so as to */ /* create a run-time evaluation tree, */ /* inspired by the work of Uwe Lammers, */ /* resulting in a speed increase of */ /* 10-100 times. */ /* Peter D Wilson Jul 1998 gtifilter(a,b,c,d) function added */ /* Peter D Wilson Aug 1998 regfilter(a,b,c,d) function added */ /* Peter D Wilson Jul 1999 Make parser fitsfile-independent, */ /* allowing a purely vector-based usage */ /* */ /************************************************************************/ #include #include #include #ifdef sparc #include #else #include #endif #include "eval_defs.h" ParseData gParse; /* Global structure holding all parser information */ /***** Internal functions *****/ int ffGetVariable( char *varName, FFSTYPE *varVal ); static int find_variable( char *varName ); static int expr_read( char *buf, int nbytes ); /***** Definitions *****/ #define FF_NO_UNPUT /* Don't include FFUNPUT function */ #define FF_NEVER_INTERACTIVE 1 #define MAXCHR 256 #define MAXBIT 128 #define OCT_0 "000" #define OCT_1 "001" #define OCT_2 "010" #define OCT_3 "011" #define OCT_4 "100" #define OCT_5 "101" #define OCT_6 "110" #define OCT_7 "111" #define OCT_X "xxx" #define HEX_0 "0000" #define HEX_1 "0001" #define HEX_2 "0010" #define HEX_3 "0011" #define HEX_4 "0100" #define HEX_5 "0101" #define HEX_6 "0110" #define HEX_7 "0111" #define HEX_8 "1000" #define HEX_9 "1001" #define HEX_A "1010" #define HEX_B "1011" #define HEX_C "1100" #define HEX_D "1101" #define HEX_E "1110" #define HEX_F "1111" #define HEX_X "xxxx" /* MJT - 13 June 1996 read from buffer instead of stdin (as per old ftools.skel) */ #undef FF_INPUT #define FF_INPUT(buf,result,max_size) \ if ( (result = expr_read( (char *) buf, max_size )) < 0 ) \ FF_FATAL_ERROR( "read() in flex scanner failed" ); /* Macros after this point can all be overridden by user definitions in * section 1. */ #ifndef FF_SKIP_FFWRAP #ifdef __cplusplus extern "C" int ffwrap FF_PROTO(( void )); #else extern int ffwrap FF_PROTO(( void )); #endif #endif #ifndef FF_NO_UNPUT static void ffunput FF_PROTO(( int c, char *buf_ptr )); #endif #ifndef fftext_ptr static void ff_flex_strncpy FF_PROTO(( char *, ffconst char *, int )); #endif #ifdef FF_NEED_STRLEN static int ff_flex_strlen FF_PROTO(( ffconst char * )); #endif #ifndef FF_NO_INPUT #ifdef __cplusplus static int ffinput FF_PROTO(( void )); #else static int input FF_PROTO(( void )); #endif #endif #if FF_STACK_USED static int ff_start_stack_ptr = 0; static int ff_start_stack_depth = 0; static int *ff_start_stack = 0; #ifndef FF_NO_PUSH_STATE static void ff_push_state FF_PROTO(( int new_state )); #endif #ifndef FF_NO_POP_STATE static void ff_pop_state FF_PROTO(( void )); #endif #ifndef FF_NO_TOP_STATE static int ff_top_state FF_PROTO(( void )); #endif #else #define FF_NO_PUSH_STATE 1 #define FF_NO_POP_STATE 1 #define FF_NO_TOP_STATE 1 #endif #ifdef FF_MALLOC_DECL FF_MALLOC_DECL #else #if __STDC__ #ifndef __cplusplus #include #endif #else /* Just try to get by without declaring the routines. This will fail * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) * or sizeof(void*) != sizeof(int). */ #endif #endif /* Amount of stuff to slurp up with each read. */ #ifndef FF_READ_BUF_SIZE #define FF_READ_BUF_SIZE 8192 #endif /* Copy whatever the last rule matched to the standard output. */ #ifndef ECHO /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ #define ECHO (void) fwrite( fftext, ffleng, 1, ffout ) #endif /* Gets input and stuffs it into "buf". number of characters read, or FF_NULL, * is returned in "result". */ #ifndef FF_INPUT #define FF_INPUT(buf,result,max_size) \ if ( ff_current_buffer->ff_is_interactive ) \ { \ int c = '*', n; \ for ( n = 0; n < max_size && \ (c = getc( ffin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ if ( c == EOF && ferror( ffin ) ) \ FF_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else if ( ((result = fread( buf, 1, max_size, ffin )) == 0) \ && ferror( ffin ) ) \ FF_FATAL_ERROR( "input in flex scanner failed" ); #endif /* No semi-colon after return; correct usage is to write "ffterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */ #ifndef ffterminate #define ffterminate() return FF_NULL #endif /* Number of entries by which start-condition stack grows. */ #ifndef FF_START_STACK_INCR #define FF_START_STACK_INCR 25 #endif /* Report a fatal error. */ #ifndef FF_FATAL_ERROR #define FF_FATAL_ERROR(msg) ff_fatal_error( msg ) #endif /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef FF_DECL #define FF_DECL int fflex FF_PROTO(( void )) #endif /* Code executed at the beginning of each rule, after fftext and ffleng * have been set up. */ #ifndef FF_USER_ACTION #define FF_USER_ACTION #endif /* Code executed at the end of each rule. */ #ifndef FF_BREAK #define FF_BREAK break; #endif #define FF_RULE_SETUP \ FF_USER_ACTION FF_DECL { register ff_state_type ff_current_state; register char *ff_cp, *ff_bp; register int ff_act; #line 142 "eval.l" if ( ff_init ) { ff_init = 0; #ifdef FF_USER_INIT FF_USER_INIT; #endif if ( ! ff_start ) ff_start = 1; /* first start state */ if ( ! ffin ) ffin = stdin; if ( ! ffout ) ffout = stdout; if ( ! ff_current_buffer ) ff_current_buffer = ff_create_buffer( ffin, FF_BUF_SIZE ); ff_load_buffer_state(); } while ( 1 ) /* loops until end-of-file is reached */ { ff_cp = ff_c_buf_p; /* Support of fftext. */ *ff_cp = ff_hold_char; /* ff_bp points to the position in ff_ch_buf of the start of * the current run. */ ff_bp = ff_cp; ff_current_state = ff_start; ff_match: do { register FF_CHAR ff_c = ff_ec[FF_SC_TO_UI(*ff_cp)]; if ( ff_accept[ff_current_state] ) { ff_last_accepting_state = ff_current_state; ff_last_accepting_cpos = ff_cp; } while ( ff_chk[ff_base[ff_current_state] + ff_c] != ff_current_state ) { ff_current_state = (int) ff_def[ff_current_state]; if ( ff_current_state >= 160 ) ff_c = ff_meta[(unsigned int) ff_c]; } ff_current_state = ff_nxt[ff_base[ff_current_state] + (unsigned int) ff_c]; ++ff_cp; } while ( ff_base[ff_current_state] != 368 ); ff_find_action: ff_act = ff_accept[ff_current_state]; if ( ff_act == 0 ) { /* have to back up */ ff_cp = ff_last_accepting_cpos; ff_current_state = ff_last_accepting_state; ff_act = ff_accept[ff_current_state]; } FF_DO_BEFORE_ACTION; do_action: /* This label is used only to access EOF actions. */ switch ( ff_act ) { /* beginning of action switch */ case 0: /* must back up */ /* undo the effects of FF_DO_BEFORE_ACTION */ *ff_cp = ff_hold_char; ff_cp = ff_last_accepting_cpos; ff_current_state = ff_last_accepting_state; goto ff_find_action; case 1: FF_RULE_SETUP #line 144 "eval.l" ; FF_BREAK case 2: FF_RULE_SETUP #line 145 "eval.l" { int len; len = strlen(fftext); while (fftext[len] == ' ') len--; len = len - 1; strncpy(fflval.str,&fftext[1],len); fflval.str[len] = '\0'; return( BITSTR ); } FF_BREAK case 3: FF_RULE_SETUP #line 155 "eval.l" { int len; char tmpstring[256]; char bitstring[256]; len = strlen(fftext); if (len >= 256) { char errMsg[100]; gParse.status = PARSE_SYNTAX_ERR; strcpy (errMsg,"Bit string exceeds maximum length: '"); strncat(errMsg, &(fftext[0]), 20); strcat (errMsg,"...'"); ffpmsg (errMsg); len = 0; } else { while (fftext[len] == ' ') len--; len = len - 1; strncpy(tmpstring,&fftext[1],len); } tmpstring[len] = '\0'; bitstring[0] = '\0'; len = 0; while ( tmpstring[len] != '\0') { switch ( tmpstring[len] ) { case '0': strcat(bitstring,OCT_0); break; case '1': strcat(bitstring,OCT_1); break; case '2': strcat(bitstring,OCT_2); break; case '3': strcat(bitstring,OCT_3); break; case '4': strcat(bitstring,OCT_4); break; case '5': strcat(bitstring,OCT_5); break; case '6': strcat(bitstring,OCT_6); break; case '7': strcat(bitstring,OCT_7); break; case 'x': case 'X': strcat(bitstring,OCT_X); break; } len++; } strcpy( fflval.str, bitstring ); return( BITSTR ); } FF_BREAK case 4: FF_RULE_SETUP #line 215 "eval.l" { int len; char tmpstring[256]; char bitstring[256]; len = strlen(fftext); if (len >= 256) { char errMsg[100]; gParse.status = PARSE_SYNTAX_ERR; strcpy (errMsg,"Hex string exceeds maximum length: '"); strncat(errMsg, &(fftext[0]), 20); strcat (errMsg,"...'"); ffpmsg (errMsg); len = 0; } else { while (fftext[len] == ' ') len--; len = len - 1; strncpy(tmpstring,&fftext[1],len); } tmpstring[len] = '\0'; bitstring[0] = '\0'; len = 0; while ( tmpstring[len] != '\0') { switch ( tmpstring[len] ) { case '0': strcat(bitstring,HEX_0); break; case '1': strcat(bitstring,HEX_1); break; case '2': strcat(bitstring,HEX_2); break; case '3': strcat(bitstring,HEX_3); break; case '4': strcat(bitstring,HEX_4); break; case '5': strcat(bitstring,HEX_5); break; case '6': strcat(bitstring,HEX_6); break; case '7': strcat(bitstring,HEX_7); break; case '8': strcat(bitstring,HEX_8); break; case '9': strcat(bitstring,HEX_9); break; case 'a': case 'A': strcat(bitstring,HEX_A); break; case 'b': case 'B': strcat(bitstring,HEX_B); break; case 'c': case 'C': strcat(bitstring,HEX_C); break; case 'd': case 'D': strcat(bitstring,HEX_D); break; case 'e': case 'E': strcat(bitstring,HEX_E); break; case 'f': case 'F': strcat(bitstring,HEX_F); break; case 'x': case 'X': strcat(bitstring,HEX_X); break; } len++; } strcpy( fflval.str, bitstring ); return( BITSTR ); } FF_BREAK case 5: FF_RULE_SETUP #line 306 "eval.l" { fflval.lng = atol(fftext); return( LONG ); } FF_BREAK case 6: FF_RULE_SETUP #line 310 "eval.l" { if ((fftext[0] == 't') || (fftext[0] == 'T')) fflval.log = 1; else fflval.log = 0; return( BOOLEAN ); } FF_BREAK case 7: FF_RULE_SETUP #line 317 "eval.l" { fflval.dbl = atof(fftext); return( DOUBLE ); } FF_BREAK case 8: FF_RULE_SETUP #line 321 "eval.l" { if( !strcasecmp(fftext,"#PI") ) { fflval.dbl = (double)(4) * atan((double)(1)); return( DOUBLE ); } else if( !strcasecmp(fftext,"#E") ) { fflval.dbl = exp((double)(1)); return( DOUBLE ); } else if( !strcasecmp(fftext,"#DEG") ) { fflval.dbl = ((double)4)*atan((double)1)/((double)180); return( DOUBLE ); } else if( !strcasecmp(fftext,"#ROW") ) { return( ROWREF ); } else if( !strcasecmp(fftext,"#NULL") ) { return( NULLREF ); } else if( !strcasecmp(fftext,"#SNULL") ) { return( SNULLREF ); } else { int len; if (fftext[1] == '$') { len = strlen(fftext) - 3; fflval.str[0] = '#'; strncpy(fflval.str+1,&fftext[2],len); fflval.str[len+1] = '\0'; fftext = fflval.str; } return( (*gParse.getData)(fftext, &fflval) ); } } FF_BREAK case 9: FF_RULE_SETUP #line 349 "eval.l" { int len; len = strlen(fftext) - 2; if (len >= MAX_STRLEN) { char errMsg[100]; gParse.status = PARSE_SYNTAX_ERR; strcpy (errMsg,"String exceeds maximum length: '"); strncat(errMsg, &(fftext[1]), 20); strcat (errMsg,"...'"); ffpmsg (errMsg); len = 0; } else { strncpy(fflval.str,&fftext[1],len); } fflval.str[len] = '\0'; return( STRING ); } FF_BREAK case 10: FF_RULE_SETUP #line 366 "eval.l" { int len,type; if (fftext[0] == '$') { len = strlen(fftext) - 2; strncpy(fflval.str,&fftext[1],len); fflval.str[len] = '\0'; fftext = fflval.str; } type = ffGetVariable(fftext, &fflval); return( type ); } FF_BREAK case 11: FF_RULE_SETUP #line 378 "eval.l" { char *fname; int len=0; fname = &fflval.str[0]; while( (fname[len]=toupper(fftext[len])) ) len++; if( FSTRCMP(fname,"BOX(")==0 || FSTRCMP(fname,"CIRCLE(")==0 || FSTRCMP(fname,"ELLIPSE(")==0 || FSTRCMP(fname,"NEAR(")==0 || FSTRCMP(fname,"ISNULL(")==0 ) /* Return type is always boolean */ return( BFUNCTION ); else if( FSTRCMP(fname,"GTIFILTER(")==0 ) return( GTIFILTER ); else if( FSTRCMP(fname,"REGFILTER(")==0 ) return( REGFILTER ); else if( FSTRCMP(fname,"STRSTR(")==0 ) return( IFUNCTION ); /* Returns integer */ else return( FUNCTION ); } FF_BREAK case 12: FF_RULE_SETUP #line 405 "eval.l" { return( INTCAST ); } FF_BREAK case 13: FF_RULE_SETUP #line 406 "eval.l" { return( FLTCAST ); } FF_BREAK case 14: FF_RULE_SETUP #line 407 "eval.l" { return( POWER ); } FF_BREAK case 15: FF_RULE_SETUP #line 408 "eval.l" { return( NOT ); } FF_BREAK case 16: FF_RULE_SETUP #line 409 "eval.l" { return( OR ); } FF_BREAK case 17: FF_RULE_SETUP #line 410 "eval.l" { return( AND ); } FF_BREAK case 18: FF_RULE_SETUP #line 411 "eval.l" { return( EQ ); } FF_BREAK case 19: FF_RULE_SETUP #line 412 "eval.l" { return( NE ); } FF_BREAK case 20: FF_RULE_SETUP #line 413 "eval.l" { return( GT ); } FF_BREAK case 21: FF_RULE_SETUP #line 414 "eval.l" { return( LT ); } FF_BREAK case 22: FF_RULE_SETUP #line 415 "eval.l" { return( GTE ); } FF_BREAK case 23: FF_RULE_SETUP #line 416 "eval.l" { return( LTE ); } FF_BREAK case 24: FF_RULE_SETUP #line 417 "eval.l" { return( '\n' ); } FF_BREAK case 25: FF_RULE_SETUP #line 418 "eval.l" { return( fftext[0] ); } FF_BREAK case 26: FF_RULE_SETUP #line 419 "eval.l" ECHO; FF_BREAK case FF_STATE_EOF(INITIAL): ffterminate(); case FF_END_OF_BUFFER: { /* Amount of text matched not including the EOB char. */ int ff_amount_of_matched_text = (int) (ff_cp - fftext_ptr) - 1; /* Undo the effects of FF_DO_BEFORE_ACTION. */ *ff_cp = ff_hold_char; FF_RESTORE_FF_MORE_OFFSET if ( ff_current_buffer->ff_buffer_status == FF_BUFFER_NEW ) { /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed ffin at a new source and called * fflex(). If so, then we have to assure * consistency between ff_current_buffer and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source. */ ff_n_chars = ff_current_buffer->ff_n_chars; ff_current_buffer->ff_input_file = ffin; ff_current_buffer->ff_buffer_status = FF_BUFFER_NORMAL; } /* Note that here we test for ff_c_buf_p "<=" to the position * of the first EOB in the buffer, since ff_c_buf_p will * already have been incremented past the NUL character * (since all states make transitions on EOB to the * end-of-buffer state). Contrast this with the test * in input(). */ if ( ff_c_buf_p <= &ff_current_buffer->ff_ch_buf[ff_n_chars] ) { /* This was really a NUL. */ ff_state_type ff_next_state; ff_c_buf_p = fftext_ptr + ff_amount_of_matched_text; ff_current_state = ff_get_previous_state(); /* Okay, we're now positioned to make the NUL * transition. We couldn't have * ff_get_previous_state() go ahead and do it * for us because it doesn't know how to deal * with the possibility of jamming (and we don't * want to build jamming into it because then it * will run more slowly). */ ff_next_state = ff_try_NUL_trans( ff_current_state ); ff_bp = fftext_ptr + FF_MORE_ADJ; if ( ff_next_state ) { /* Consume the NUL. */ ff_cp = ++ff_c_buf_p; ff_current_state = ff_next_state; goto ff_match; } else { ff_cp = ff_c_buf_p; goto ff_find_action; } } else switch ( ff_get_next_buffer() ) { case EOB_ACT_END_OF_FILE: { ff_did_buffer_switch_on_eof = 0; if ( ffwrap() ) { /* Note: because we've taken care in * ff_get_next_buffer() to have set up * fftext, we can now set up * ff_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the * FF_NULL, it'll still work - another * FF_NULL will get returned. */ ff_c_buf_p = fftext_ptr + FF_MORE_ADJ; ff_act = FF_STATE_EOF(FF_START); goto do_action; } else { if ( ! ff_did_buffer_switch_on_eof ) FF_NEW_FILE; } break; } case EOB_ACT_CONTINUE_SCAN: ff_c_buf_p = fftext_ptr + ff_amount_of_matched_text; ff_current_state = ff_get_previous_state(); ff_cp = ff_c_buf_p; ff_bp = fftext_ptr + FF_MORE_ADJ; goto ff_match; case EOB_ACT_LAST_MATCH: ff_c_buf_p = &ff_current_buffer->ff_ch_buf[ff_n_chars]; ff_current_state = ff_get_previous_state(); ff_cp = ff_c_buf_p; ff_bp = fftext_ptr + FF_MORE_ADJ; goto ff_find_action; } break; } default: FF_FATAL_ERROR( "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ } /* end of fflex */ /* ff_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: * EOB_ACT_LAST_MATCH - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file */ static int ff_get_next_buffer() { register char *dest = ff_current_buffer->ff_ch_buf; register char *source = fftext_ptr; register int number_to_move, i; int ret_val; if ( ff_c_buf_p > &ff_current_buffer->ff_ch_buf[ff_n_chars + 1] ) FF_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" ); if ( ff_current_buffer->ff_fill_buffer == 0 ) { /* Don't try to fill the buffer, so this is an EOF. */ if ( ff_c_buf_p - fftext_ptr - FF_MORE_ADJ == 1 ) { /* We matched a single character, the EOB, so * treat this as a final EOF. */ return EOB_ACT_END_OF_FILE; } else { /* We matched some text prior to the EOB, first * process it. */ return EOB_ACT_LAST_MATCH; } } /* Try to read more data. */ /* First move last chars to start of buffer. */ number_to_move = (int) (ff_c_buf_p - fftext_ptr) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); if ( ff_current_buffer->ff_buffer_status == FF_BUFFER_EOF_PENDING ) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF */ ff_current_buffer->ff_n_chars = ff_n_chars = 0; else { int num_to_read = ff_current_buffer->ff_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ #ifdef FF_USES_REJECT FF_FATAL_ERROR( "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); #else /* just a shorter name for the current buffer */ FF_BUFFER_STATE b = ff_current_buffer; int ff_c_buf_p_offset = (int) (ff_c_buf_p - b->ff_ch_buf); if ( b->ff_is_our_buffer ) { int new_size = b->ff_buf_size * 2; if ( new_size <= 0 ) b->ff_buf_size += b->ff_buf_size / 8; else b->ff_buf_size *= 2; b->ff_ch_buf = (char *) /* Include room in for 2 EOB chars. */ ff_flex_realloc( (void *) b->ff_ch_buf, b->ff_buf_size + 2 ); } else /* Can't grow it, we don't own it. */ b->ff_ch_buf = 0; if ( ! b->ff_ch_buf ) FF_FATAL_ERROR( "fatal error - scanner input buffer overflow" ); ff_c_buf_p = &b->ff_ch_buf[ff_c_buf_p_offset]; num_to_read = ff_current_buffer->ff_buf_size - number_to_move - 1; #endif } if ( num_to_read > FF_READ_BUF_SIZE ) num_to_read = FF_READ_BUF_SIZE; /* Read in more data. */ FF_INPUT( (&ff_current_buffer->ff_ch_buf[number_to_move]), ff_n_chars, num_to_read ); ff_current_buffer->ff_n_chars = ff_n_chars; } if ( ff_n_chars == 0 ) { if ( number_to_move == FF_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; ffrestart( ffin ); } else { ret_val = EOB_ACT_LAST_MATCH; ff_current_buffer->ff_buffer_status = FF_BUFFER_EOF_PENDING; } } else ret_val = EOB_ACT_CONTINUE_SCAN; ff_n_chars += number_to_move; ff_current_buffer->ff_ch_buf[ff_n_chars] = FF_END_OF_BUFFER_CHAR; ff_current_buffer->ff_ch_buf[ff_n_chars + 1] = FF_END_OF_BUFFER_CHAR; fftext_ptr = &ff_current_buffer->ff_ch_buf[0]; return ret_val; } /* ff_get_previous_state - get the state just before the EOB char was reached */ static ff_state_type ff_get_previous_state() { register ff_state_type ff_current_state; register char *ff_cp; ff_current_state = ff_start; for ( ff_cp = fftext_ptr + FF_MORE_ADJ; ff_cp < ff_c_buf_p; ++ff_cp ) { register FF_CHAR ff_c = (*ff_cp ? ff_ec[FF_SC_TO_UI(*ff_cp)] : 1); if ( ff_accept[ff_current_state] ) { ff_last_accepting_state = ff_current_state; ff_last_accepting_cpos = ff_cp; } while ( ff_chk[ff_base[ff_current_state] + ff_c] != ff_current_state ) { ff_current_state = (int) ff_def[ff_current_state]; if ( ff_current_state >= 160 ) ff_c = ff_meta[(unsigned int) ff_c]; } ff_current_state = ff_nxt[ff_base[ff_current_state] + (unsigned int) ff_c]; } return ff_current_state; } /* ff_try_NUL_trans - try to make a transition on the NUL character * * synopsis * next_state = ff_try_NUL_trans( current_state ); */ #ifdef FF_USE_PROTOS static ff_state_type ff_try_NUL_trans( ff_state_type ff_current_state ) #else static ff_state_type ff_try_NUL_trans( ff_current_state ) ff_state_type ff_current_state; #endif { register int ff_is_jam; register char *ff_cp = ff_c_buf_p; register FF_CHAR ff_c = 1; if ( ff_accept[ff_current_state] ) { ff_last_accepting_state = ff_current_state; ff_last_accepting_cpos = ff_cp; } while ( ff_chk[ff_base[ff_current_state] + ff_c] != ff_current_state ) { ff_current_state = (int) ff_def[ff_current_state]; if ( ff_current_state >= 160 ) ff_c = ff_meta[(unsigned int) ff_c]; } ff_current_state = ff_nxt[ff_base[ff_current_state] + (unsigned int) ff_c]; ff_is_jam = (ff_current_state == 159); return ff_is_jam ? 0 : ff_current_state; } #ifndef FF_NO_UNPUT #ifdef FF_USE_PROTOS static void ffunput( int c, register char *ff_bp ) #else static void ffunput( c, ff_bp ) int c; register char *ff_bp; #endif { register char *ff_cp = ff_c_buf_p; /* undo effects of setting up fftext */ *ff_cp = ff_hold_char; if ( ff_cp < ff_current_buffer->ff_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ register int number_to_move = ff_n_chars + 2; register char *dest = &ff_current_buffer->ff_ch_buf[ ff_current_buffer->ff_buf_size + 2]; register char *source = &ff_current_buffer->ff_ch_buf[number_to_move]; while ( source > ff_current_buffer->ff_ch_buf ) *--dest = *--source; ff_cp += (int) (dest - source); ff_bp += (int) (dest - source); ff_current_buffer->ff_n_chars = ff_n_chars = ff_current_buffer->ff_buf_size; if ( ff_cp < ff_current_buffer->ff_ch_buf + 2 ) FF_FATAL_ERROR( "flex scanner push-back overflow" ); } *--ff_cp = (char) c; fftext_ptr = ff_bp; ff_hold_char = *ff_cp; ff_c_buf_p = ff_cp; } #endif /* ifndef FF_NO_UNPUT */ #ifdef __cplusplus static int ffinput() #else static int input() #endif { int c; *ff_c_buf_p = ff_hold_char; if ( *ff_c_buf_p == FF_END_OF_BUFFER_CHAR ) { /* ff_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer. */ if ( ff_c_buf_p < &ff_current_buffer->ff_ch_buf[ff_n_chars] ) /* This was really a NUL. */ *ff_c_buf_p = '\0'; else { /* need more input */ int offset = ff_c_buf_p - fftext_ptr; ++ff_c_buf_p; switch ( ff_get_next_buffer() ) { case EOB_ACT_LAST_MATCH: /* This happens because ff_g_n_b() * sees that we've accumulated a * token and flags that we need to * try matching the token before * proceeding. But for input(), * there's no matching to consider. * So convert the EOB_ACT_LAST_MATCH * to EOB_ACT_END_OF_FILE. */ /* Reset buffer status. */ ffrestart( ffin ); /* fall through */ case EOB_ACT_END_OF_FILE: { if ( ffwrap() ) return EOF; if ( ! ff_did_buffer_switch_on_eof ) FF_NEW_FILE; #ifdef __cplusplus return ffinput(); #else return input(); #endif } case EOB_ACT_CONTINUE_SCAN: ff_c_buf_p = fftext_ptr + offset; break; } } } c = *(unsigned char *) ff_c_buf_p; /* cast for 8-bit char's */ *ff_c_buf_p = '\0'; /* preserve fftext */ ff_hold_char = *++ff_c_buf_p; return c; } #ifdef FF_USE_PROTOS void ffrestart( FILE *input_file ) #else void ffrestart( input_file ) FILE *input_file; #endif { if ( ! ff_current_buffer ) ff_current_buffer = ff_create_buffer( ffin, FF_BUF_SIZE ); ff_init_buffer( ff_current_buffer, input_file ); ff_load_buffer_state(); } #ifdef FF_USE_PROTOS void ff_switch_to_buffer( FF_BUFFER_STATE new_buffer ) #else void ff_switch_to_buffer( new_buffer ) FF_BUFFER_STATE new_buffer; #endif { if ( ff_current_buffer == new_buffer ) return; if ( ff_current_buffer ) { /* Flush out information for old buffer. */ *ff_c_buf_p = ff_hold_char; ff_current_buffer->ff_buf_pos = ff_c_buf_p; ff_current_buffer->ff_n_chars = ff_n_chars; } ff_current_buffer = new_buffer; ff_load_buffer_state(); /* We don't actually know whether we did this switch during * EOF (ffwrap()) processing, but the only time this flag * is looked at is after ffwrap() is called, so it's safe * to go ahead and always set it. */ ff_did_buffer_switch_on_eof = 1; } #ifdef FF_USE_PROTOS void ff_load_buffer_state( void ) #else void ff_load_buffer_state() #endif { ff_n_chars = ff_current_buffer->ff_n_chars; fftext_ptr = ff_c_buf_p = ff_current_buffer->ff_buf_pos; ffin = ff_current_buffer->ff_input_file; ff_hold_char = *ff_c_buf_p; } #ifdef FF_USE_PROTOS FF_BUFFER_STATE ff_create_buffer( FILE *file, int size ) #else FF_BUFFER_STATE ff_create_buffer( file, size ) FILE *file; int size; #endif { FF_BUFFER_STATE b; b = (FF_BUFFER_STATE) ff_flex_alloc( sizeof( struct ff_buffer_state ) ); if ( ! b ) FF_FATAL_ERROR( "out of dynamic memory in ff_create_buffer()" ); b->ff_buf_size = size; /* ff_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ b->ff_ch_buf = (char *) ff_flex_alloc( b->ff_buf_size + 2 ); if ( ! b->ff_ch_buf ) FF_FATAL_ERROR( "out of dynamic memory in ff_create_buffer()" ); b->ff_is_our_buffer = 1; ff_init_buffer( b, file ); return b; } #ifdef FF_USE_PROTOS void ff_delete_buffer( FF_BUFFER_STATE b ) #else void ff_delete_buffer( b ) FF_BUFFER_STATE b; #endif { if ( ! b ) return; if ( b == ff_current_buffer ) ff_current_buffer = (FF_BUFFER_STATE) 0; if ( b->ff_is_our_buffer ) ff_flex_free( (void *) b->ff_ch_buf ); ff_flex_free( (void *) b ); } #ifndef FF_ALWAYS_INTERACTIVE #ifndef FF_NEVER_INTERACTIVE extern int isatty FF_PROTO(( int )); #endif #endif #ifdef FF_USE_PROTOS void ff_init_buffer( FF_BUFFER_STATE b, FILE *file ) #else void ff_init_buffer( b, file ) FF_BUFFER_STATE b; FILE *file; #endif { ff_flush_buffer( b ); b->ff_input_file = file; b->ff_fill_buffer = 1; #if FF_ALWAYS_INTERACTIVE b->ff_is_interactive = 1; #else #if FF_NEVER_INTERACTIVE b->ff_is_interactive = 0; #else b->ff_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; #endif #endif } #ifdef FF_USE_PROTOS void ff_flush_buffer( FF_BUFFER_STATE b ) #else void ff_flush_buffer( b ) FF_BUFFER_STATE b; #endif { if ( ! b ) return; b->ff_n_chars = 0; /* We always need two end-of-buffer characters. The first causes * a transition to the end-of-buffer state. The second causes * a jam in that state. */ b->ff_ch_buf[0] = FF_END_OF_BUFFER_CHAR; b->ff_ch_buf[1] = FF_END_OF_BUFFER_CHAR; b->ff_buf_pos = &b->ff_ch_buf[0]; b->ff_at_bol = 1; b->ff_buffer_status = FF_BUFFER_NEW; if ( b == ff_current_buffer ) ff_load_buffer_state(); } #ifndef FF_NO_SCAN_BUFFER #ifdef FF_USE_PROTOS FF_BUFFER_STATE ff_scan_buffer( char *base, ff_size_t size ) #else FF_BUFFER_STATE ff_scan_buffer( base, size ) char *base; ff_size_t size; #endif { FF_BUFFER_STATE b; if ( size < 2 || base[size-2] != FF_END_OF_BUFFER_CHAR || base[size-1] != FF_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ return 0; b = (FF_BUFFER_STATE) ff_flex_alloc( sizeof( struct ff_buffer_state ) ); if ( ! b ) FF_FATAL_ERROR( "out of dynamic memory in ff_scan_buffer()" ); b->ff_buf_size = size - 2; /* "- 2" to take care of EOB's */ b->ff_buf_pos = b->ff_ch_buf = base; b->ff_is_our_buffer = 0; b->ff_input_file = 0; b->ff_n_chars = b->ff_buf_size; b->ff_is_interactive = 0; b->ff_at_bol = 1; b->ff_fill_buffer = 0; b->ff_buffer_status = FF_BUFFER_NEW; ff_switch_to_buffer( b ); return b; } #endif #ifndef FF_NO_SCAN_STRING #ifdef FF_USE_PROTOS FF_BUFFER_STATE ff_scan_string( ffconst char *ff_str ) #else FF_BUFFER_STATE ff_scan_string( ff_str ) ffconst char *ff_str; #endif { int len; for ( len = 0; ff_str[len]; ++len ) ; return ff_scan_bytes( ff_str, len ); } #endif #ifndef FF_NO_SCAN_BYTES #ifdef FF_USE_PROTOS FF_BUFFER_STATE ff_scan_bytes( ffconst char *bytes, int len ) #else FF_BUFFER_STATE ff_scan_bytes( bytes, len ) ffconst char *bytes; int len; #endif { FF_BUFFER_STATE b; char *buf; ff_size_t n; int i; /* Get memory for full buffer, including space for trailing EOB's. */ n = len + 2; buf = (char *) ff_flex_alloc( n ); if ( ! buf ) FF_FATAL_ERROR( "out of dynamic memory in ff_scan_bytes()" ); for ( i = 0; i < len; ++i ) buf[i] = bytes[i]; buf[len] = buf[len+1] = FF_END_OF_BUFFER_CHAR; b = ff_scan_buffer( buf, n ); if ( ! b ) FF_FATAL_ERROR( "bad buffer in ff_scan_bytes()" ); /* It's okay to grow etc. this buffer, and we should throw it * away when we're done. */ b->ff_is_our_buffer = 1; return b; } #endif #ifndef FF_NO_PUSH_STATE #ifdef FF_USE_PROTOS static void ff_push_state( int new_state ) #else static void ff_push_state( new_state ) int new_state; #endif { if ( ff_start_stack_ptr >= ff_start_stack_depth ) { ff_size_t new_size; ff_start_stack_depth += FF_START_STACK_INCR; new_size = ff_start_stack_depth * sizeof( int ); if ( ! ff_start_stack ) ff_start_stack = (int *) ff_flex_alloc( new_size ); else ff_start_stack = (int *) ff_flex_realloc( (void *) ff_start_stack, new_size ); if ( ! ff_start_stack ) FF_FATAL_ERROR( "out of memory expanding start-condition stack" ); } ff_start_stack[ff_start_stack_ptr++] = FF_START; BEGIN(new_state); } #endif #ifndef FF_NO_POP_STATE static void ff_pop_state() { if ( --ff_start_stack_ptr < 0 ) FF_FATAL_ERROR( "start-condition stack underflow" ); BEGIN(ff_start_stack[ff_start_stack_ptr]); } #endif #ifndef FF_NO_TOP_STATE static int ff_top_state() { return ff_start_stack[ff_start_stack_ptr - 1]; } #endif #ifndef FF_EXIT_FAILURE #define FF_EXIT_FAILURE 2 #endif #ifdef FF_USE_PROTOS static void ff_fatal_error( ffconst char msg[] ) #else static void ff_fatal_error( msg ) char msg[]; #endif { (void) fprintf( stderr, "%s\n", msg ); exit( FF_EXIT_FAILURE ); } /* Redefine ffless() so it works in section 3 code. */ #undef ffless #define ffless(n) \ do \ { \ /* Undo effects of setting up fftext. */ \ fftext[ffleng] = ff_hold_char; \ ff_c_buf_p = fftext + n; \ ff_hold_char = *ff_c_buf_p; \ *ff_c_buf_p = '\0'; \ ffleng = n; \ } \ while ( 0 ) /* Internal utility routines. */ #ifndef fftext_ptr #ifdef FF_USE_PROTOS static void ff_flex_strncpy( char *s1, ffconst char *s2, int n ) #else static void ff_flex_strncpy( s1, s2, n ) char *s1; ffconst char *s2; int n; #endif { register int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i]; } #endif #ifdef FF_NEED_STRLEN #ifdef FF_USE_PROTOS static int ff_flex_strlen( ffconst char *s ) #else static int ff_flex_strlen( s ) ffconst char *s; #endif { register int n; for ( n = 0; s[n]; ++n ) ; return n; } #endif #ifdef FF_USE_PROTOS static void *ff_flex_alloc( ff_size_t size ) #else static void *ff_flex_alloc( size ) ff_size_t size; #endif { return (void *) malloc( size ); } #ifdef FF_USE_PROTOS static void *ff_flex_realloc( void *ptr, ff_size_t size ) #else static void *ff_flex_realloc( ptr, size ) void *ptr; ff_size_t size; #endif { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ return (void *) realloc( (char *) ptr, size ); } #ifdef FF_USE_PROTOS static void ff_flex_free( void *ptr ) #else static void ff_flex_free( ptr ) void *ptr; #endif { free( ptr ); } #if FF_MAIN int main() { fflex(); return 0; } #endif #line 419 "eval.l" int ffwrap() { /* MJT -- 13 June 1996 Supplied for compatibility with pre-2.5.1 versions of flex which do not recognize %option noffwrap */ return(1); } /* expr_read is lifted from old ftools.skel. Now we can use any version of flex with no .skel file necessary! MJT - 13 June 1996 keep a memory of how many bytes have been read previously, so that an unlimited-sized buffer can be supported. PDW - 28 Feb 1998 */ static int expr_read(char *buf, int nbytes) { int n; n = 0; if( !gParse.is_eobuf ) { do { buf[n++] = gParse.expr[gParse.index++]; } while ((nlng = varNum; } return( type ); } static int find_variable(char *varName) { int i; if( gParse.nCols ) for( i=0; i c2) return(1); if (c1 == 0) return(0); s1++; s2++; } } int strncasecmp(const char *s1, const char *s2, size_t n) { char c1, c2; for (; n-- ;) { c1 = toupper( *s1 ); c2 = toupper( *s2 ); if (c1 < c2) return(-1); if (c1 > c2) return(1); if (c1 == 0) return(0); s1++; s2++; } return(0); } #endif healpy-1.10.3/cfitsio/eval_tab.h0000664000175000017500000000154713010375005016715 0ustar zoncazonca00000000000000typedef union { int Node; /* Index of Node */ double dbl; /* real value */ long lng; /* integer value */ char log; /* logical value */ char str[MAX_STRLEN]; /* string value */ } FFSTYPE; #define BOOLEAN 258 #define LONG 259 #define DOUBLE 260 #define STRING 261 #define BITSTR 262 #define FUNCTION 263 #define BFUNCTION 264 #define IFUNCTION 265 #define GTIFILTER 266 #define REGFILTER 267 #define COLUMN 268 #define BCOLUMN 269 #define SCOLUMN 270 #define BITCOL 271 #define ROWREF 272 #define NULLREF 273 #define SNULLREF 274 #define OR 275 #define AND 276 #define EQ 277 #define NE 278 #define GT 279 #define LT 280 #define LTE 281 #define GTE 282 #define POWER 283 #define NOT 284 #define INTCAST 285 #define FLTCAST 286 #define UMINUS 287 #define ACCUM 288 #define DIFF 289 extern FFSTYPE fflval; healpy-1.10.3/cfitsio/eval_y.c0000664000175000017500000073314713010375005016422 0ustar zoncazonca00000000000000 /* A Bison parser, made from eval.y by GNU Bison version 1.25 */ #define FFBISON 1 /* Identify Bison output. */ #define BOOLEAN 258 #define LONG 259 #define DOUBLE 260 #define STRING 261 #define BITSTR 262 #define FUNCTION 263 #define BFUNCTION 264 #define IFUNCTION 265 #define GTIFILTER 266 #define REGFILTER 267 #define COLUMN 268 #define BCOLUMN 269 #define SCOLUMN 270 #define BITCOL 271 #define ROWREF 272 #define NULLREF 273 #define SNULLREF 274 #define OR 275 #define AND 276 #define EQ 277 #define NE 278 #define GT 279 #define LT 280 #define LTE 281 #define GTE 282 #define POWER 283 #define NOT 284 #define INTCAST 285 #define FLTCAST 286 #define UMINUS 287 #define ACCUM 288 #define DIFF 289 #line 1 "eval.y" /************************************************************************/ /* */ /* CFITSIO Lexical Parser */ /* */ /* This file is one of 3 files containing code which parses an */ /* arithmetic expression and evaluates it in the context of an input */ /* FITS file table extension. The CFITSIO lexical parser is divided */ /* into the following 3 parts/files: the CFITSIO "front-end", */ /* eval_f.c, contains the interface between the user/CFITSIO and the */ /* real core of the parser; the FLEX interpreter, eval_l.c, takes the */ /* input string and parses it into tokens and identifies the FITS */ /* information required to evaluate the expression (ie, keywords and */ /* columns); and, the BISON grammar and evaluation routines, eval_y.c, */ /* receives the FLEX output and determines and performs the actual */ /* operations. The files eval_l.c and eval_y.c are produced from */ /* running flex and bison on the files eval.l and eval.y, respectively. */ /* (flex and bison are available from any GNU archive: see www.gnu.org) */ /* */ /* The grammar rules, rather than evaluating the expression in situ, */ /* builds a tree, or Nodal, structure mapping out the order of */ /* operations and expression dependencies. This "compilation" process */ /* allows for much faster processing of multiple rows. This technique */ /* was developed by Uwe Lammers of the XMM Science Analysis System, */ /* although the CFITSIO implementation is entirely code original. */ /* */ /* */ /* Modification History: */ /* */ /* Kent Blackburn c1992 Original parser code developed for the */ /* FTOOLS software package, in particular, */ /* the fselect task. */ /* Kent Blackburn c1995 BIT column support added */ /* Peter D Wilson Feb 1998 Vector column support added */ /* Peter D Wilson May 1998 Ported to CFITSIO library. User */ /* interface routines written, in essence */ /* making fselect, fcalc, and maketime */ /* capabilities available to all tools */ /* via single function calls. */ /* Peter D Wilson Jun 1998 Major rewrite of parser core, so as to */ /* create a run-time evaluation tree, */ /* inspired by the work of Uwe Lammers, */ /* resulting in a speed increase of */ /* 10-100 times. */ /* Peter D Wilson Jul 1998 gtifilter(a,b,c,d) function added */ /* Peter D Wilson Aug 1998 regfilter(a,b,c,d) function added */ /* Peter D Wilson Jul 1999 Make parser fitsfile-independent, */ /* allowing a purely vector-based usage */ /* Craig B Markwardt Jun 2004 Add MEDIAN() function */ /* Craig B Markwardt Jun 2004 Add SUM(), and MIN/MAX() for bit arrays */ /* Craig B Markwardt Jun 2004 Allow subscripting of nX bit arrays */ /* Craig B Markwardt Jun 2004 Implement statistical functions */ /* NVALID(), AVERAGE(), and STDDEV() */ /* for integer and floating point vectors */ /* Craig B Markwardt Jun 2004 Use NULL values for range errors instead*/ /* of throwing a parse error */ /* Craig B Markwardt Oct 2004 Add ACCUM() and SEQDIFF() functions */ /* Craig B Markwardt Feb 2005 Add ANGSEP() function */ /* Craig B Markwardt Aug 2005 CIRCLE, BOX, ELLIPSE, NEAR and REGFILTER*/ /* functions now accept vector arguments */ /* Craig B Markwardt Sum 2006 Add RANDOMN() and RANDOMP() functions */ /* Craig B Markwardt Mar 2007 Allow arguments to RANDOM and RANDOMN to*/ /* determine the output dimensions */ /* Craig B Markwardt Aug 2009 Add substring STRMID() and string search*/ /* STRSTR() functions; more overflow checks*/ /* */ /************************************************************************/ #define APPROX 1.0e-7 #include "eval_defs.h" #include "region.h" #include #include #ifndef alloca #define alloca malloc #endif /* Shrink the initial stack depth to keep local data <32K (mac limit) */ /* yacc will allocate more space if needed, though. */ #define FFINITDEPTH 100 /***************************************************************/ /* Replace Bison's BACKUP macro with one that fixes a bug -- */ /* must update state after popping the stack -- and allows */ /* popping multiple terms at one time. */ /***************************************************************/ #define FFNEWBACKUP(token, value) \ do \ if (ffchar == FFEMPTY ) \ { ffchar = (token); \ memcpy( &fflval, &(value), sizeof(value) ); \ ffchar1 = FFTRANSLATE (ffchar); \ while (fflen--) FFPOPSTACK; \ ffstate = *ffssp; \ goto ffbackup; \ } \ else \ { fferror ("syntax error: cannot back up"); FFERROR; } \ while (0) /***************************************************************/ /* Useful macros for accessing/testing Nodes */ /***************************************************************/ #define TEST(a) if( (a)<0 ) FFERROR #define SIZE(a) gParse.Nodes[ a ].value.nelem #define TYPE(a) gParse.Nodes[ a ].type #define OPER(a) gParse.Nodes[ a ].operation #define PROMOTE(a,b) if( TYPE(a) > TYPE(b) ) \ b = New_Unary( TYPE(a), 0, b ); \ else if( TYPE(a) < TYPE(b) ) \ a = New_Unary( TYPE(b), 0, a ); /***** Internal functions *****/ #ifdef __cplusplus extern "C" { #endif static int Alloc_Node ( void ); static void Free_Last_Node( void ); static void Evaluate_Node ( int thisNode ); static int New_Const ( int returnType, void *value, long len ); static int New_Column( int ColNum ); static int New_Offset( int ColNum, int offset ); static int New_Unary ( int returnType, int Op, int Node1 ); static int New_BinOp ( int returnType, int Node1, int Op, int Node2 ); static int New_Func ( int returnType, funcOp Op, int nNodes, int Node1, int Node2, int Node3, int Node4, int Node5, int Node6, int Node7 ); static int New_FuncSize( int returnType, funcOp Op, int nNodes, int Node1, int Node2, int Node3, int Node4, int Node5, int Node6, int Node7, int Size); static int New_Deref ( int Var, int nDim, int Dim1, int Dim2, int Dim3, int Dim4, int Dim5 ); static int New_GTI ( char *fname, int Node1, char *start, char *stop ); static int New_REG ( char *fname, int NodeX, int NodeY, char *colNames ); static int New_Vector( int subNode ); static int Close_Vec ( int vecNode ); static int Locate_Col( Node *this ); static int Test_Dims ( int Node1, int Node2 ); static void Copy_Dims ( int Node1, int Node2 ); static void Allocate_Ptrs( Node *this ); static void Do_Unary ( Node *this ); static void Do_Offset ( Node *this ); static void Do_BinOp_bit ( Node *this ); static void Do_BinOp_str ( Node *this ); static void Do_BinOp_log ( Node *this ); static void Do_BinOp_lng ( Node *this ); static void Do_BinOp_dbl ( Node *this ); static void Do_Func ( Node *this ); static void Do_Deref ( Node *this ); static void Do_GTI ( Node *this ); static void Do_REG ( Node *this ); static void Do_Vector ( Node *this ); static long Search_GTI ( double evtTime, long nGTI, double *start, double *stop, int ordered ); static char saobox (double xcen, double ycen, double xwid, double ywid, double rot, double xcol, double ycol); static char ellipse(double xcen, double ycen, double xrad, double yrad, double rot, double xcol, double ycol); static char circle (double xcen, double ycen, double rad, double xcol, double ycol); static char bnear (double x, double y, double tolerance); static char bitcmp (char *bitstrm1, char *bitstrm2); static char bitlgte(char *bits1, int oper, char *bits2); static void bitand(char *result, char *bitstrm1, char *bitstrm2); static void bitor (char *result, char *bitstrm1, char *bitstrm2); static void bitnot(char *result, char *bits); static int cstrmid(char *dest_str, int dest_len, char *src_str, int src_len, int pos); static void fferror(char *msg); #ifdef __cplusplus } #endif #line 189 "eval.y" typedef union { int Node; /* Index of Node */ double dbl; /* real value */ long lng; /* integer value */ char log; /* logical value */ char str[MAX_STRLEN]; /* string value */ } FFSTYPE; #include #ifndef __cplusplus #ifndef __STDC__ #define const #endif #endif #define FFFINAL 290 #define FFFLAG -32768 #define FFNTBASE 54 #define FFTRANSLATE(x) ((unsigned)(x) <= 289 ? fftranslate[x] : 62) static const char fftranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 50, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 37, 41, 2, 52, 53, 38, 35, 20, 36, 2, 39, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 22, 2, 2, 21, 2, 25, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 47, 2, 51, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 23, 40, 24, 30, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 26, 27, 28, 29, 31, 32, 33, 34, 42, 43, 44, 45, 46, 48, 49 }; #if FFDEBUG != 0 static const short ffprhs[] = { 0, 0, 1, 4, 6, 9, 12, 15, 18, 21, 24, 28, 31, 35, 39, 43, 46, 49, 51, 53, 58, 62, 66, 70, 75, 82, 91, 102, 115, 118, 122, 124, 126, 128, 133, 135, 137, 141, 145, 149, 153, 157, 161, 164, 167, 171, 175, 179, 185, 191, 197, 200, 204, 208, 212, 216, 222, 228, 238, 243, 250, 259, 270, 283, 286, 289, 292, 295, 297, 299, 304, 308, 312, 316, 320, 324, 328, 332, 336, 340, 344, 348, 352, 356, 360, 364, 368, 372, 376, 380, 384, 388, 392, 396, 402, 408, 412, 416, 420, 426, 434, 446, 462, 465, 469, 475, 485, 489, 497, 507, 512, 519, 528, 539, 552, 555, 559, 561, 563, 568, 570, 574, 578, 584, 590 }; static const short ffrhs[] = { -1, 54, 55, 0, 50, 0, 58, 50, 0, 59, 50, 0, 61, 50, 0, 60, 50, 0, 1, 50, 0, 23, 59, 0, 56, 20, 59, 0, 23, 58, 0, 57, 20, 58, 0, 57, 20, 59, 0, 56, 20, 58, 0, 57, 24, 0, 56, 24, 0, 7, 0, 16, 0, 16, 23, 58, 24, 0, 60, 41, 60, 0, 60, 40, 60, 0, 60, 35, 60, 0, 60, 47, 58, 51, 0, 60, 47, 58, 20, 58, 51, 0, 60, 47, 58, 20, 58, 20, 58, 51, 0, 60, 47, 58, 20, 58, 20, 58, 20, 58, 51, 0, 60, 47, 58, 20, 58, 20, 58, 20, 58, 20, 58, 51, 0, 43, 60, 0, 52, 60, 53, 0, 4, 0, 5, 0, 13, 0, 13, 23, 58, 24, 0, 17, 0, 18, 0, 58, 37, 58, 0, 58, 35, 58, 0, 58, 36, 58, 0, 58, 38, 58, 0, 58, 39, 58, 0, 58, 42, 58, 0, 35, 58, 0, 36, 58, 0, 52, 58, 53, 0, 58, 38, 59, 0, 59, 38, 58, 0, 59, 25, 58, 22, 58, 0, 59, 25, 59, 22, 58, 0, 59, 25, 58, 22, 59, 0, 8, 53, 0, 8, 59, 53, 0, 8, 61, 53, 0, 8, 60, 53, 0, 8, 58, 53, 0, 10, 61, 20, 61, 53, 0, 8, 58, 20, 58, 53, 0, 8, 58, 20, 58, 20, 58, 20, 58, 53, 0, 58, 47, 58, 51, 0, 58, 47, 58, 20, 58, 51, 0, 58, 47, 58, 20, 58, 20, 58, 51, 0, 58, 47, 58, 20, 58, 20, 58, 20, 58, 51, 0, 58, 47, 58, 20, 58, 20, 58, 20, 58, 20, 58, 51, 0, 44, 58, 0, 44, 59, 0, 45, 58, 0, 45, 59, 0, 3, 0, 14, 0, 14, 23, 58, 24, 0, 60, 28, 60, 0, 60, 29, 60, 0, 60, 32, 60, 0, 60, 33, 60, 0, 60, 31, 60, 0, 60, 34, 60, 0, 58, 31, 58, 0, 58, 32, 58, 0, 58, 34, 58, 0, 58, 33, 58, 0, 58, 30, 58, 0, 58, 28, 58, 0, 58, 29, 58, 0, 61, 28, 61, 0, 61, 29, 61, 0, 61, 31, 61, 0, 61, 34, 61, 0, 61, 32, 61, 0, 61, 33, 61, 0, 59, 27, 59, 0, 59, 26, 59, 0, 59, 28, 59, 0, 59, 29, 59, 0, 58, 21, 58, 22, 58, 0, 59, 25, 59, 22, 59, 0, 9, 58, 53, 0, 9, 59, 53, 0, 9, 61, 53, 0, 8, 59, 20, 59, 53, 0, 9, 58, 20, 58, 20, 58, 53, 0, 9, 58, 20, 58, 20, 58, 20, 58, 20, 58, 53, 0, 9, 58, 20, 58, 20, 58, 20, 58, 20, 58, 20, 58, 20, 58, 53, 0, 11, 53, 0, 11, 6, 53, 0, 11, 6, 20, 58, 53, 0, 11, 6, 20, 58, 20, 6, 20, 6, 53, 0, 12, 6, 53, 0, 12, 6, 20, 58, 20, 58, 53, 0, 12, 6, 20, 58, 20, 58, 20, 6, 53, 0, 59, 47, 58, 51, 0, 59, 47, 58, 20, 58, 51, 0, 59, 47, 58, 20, 58, 20, 58, 51, 0, 59, 47, 58, 20, 58, 20, 58, 20, 58, 51, 0, 59, 47, 58, 20, 58, 20, 58, 20, 58, 20, 58, 51, 0, 43, 59, 0, 52, 59, 53, 0, 6, 0, 15, 0, 15, 23, 58, 24, 0, 19, 0, 52, 61, 53, 0, 61, 35, 61, 0, 59, 25, 61, 22, 61, 0, 8, 61, 20, 61, 53, 0, 8, 61, 20, 58, 20, 58, 53, 0 }; #endif #if FFDEBUG != 0 static const short ffrline[] = { 0, 241, 242, 245, 246, 252, 258, 264, 270, 273, 275, 288, 290, 303, 314, 328, 332, 336, 340, 342, 351, 354, 357, 366, 368, 370, 372, 374, 376, 379, 383, 385, 387, 389, 398, 400, 402, 405, 408, 411, 414, 417, 420, 422, 424, 426, 430, 434, 453, 472, 491, 504, 518, 530, 561, 659, 667, 729, 753, 755, 757, 759, 761, 763, 765, 767, 769, 773, 775, 777, 786, 789, 792, 795, 798, 801, 804, 807, 810, 813, 816, 819, 822, 825, 828, 831, 834, 837, 840, 843, 845, 847, 849, 852, 859, 876, 889, 902, 913, 929, 953, 981, 1018, 1022, 1026, 1029, 1033, 1037, 1040, 1044, 1046, 1048, 1050, 1052, 1054, 1056, 1060, 1063, 1065, 1074, 1076, 1078, 1087, 1106, 1125 }; #endif #if FFDEBUG != 0 || defined (FFERROR_VERBOSE) static const char * const fftname[] = { "$","error","$undefined.","BOOLEAN", "LONG","DOUBLE","STRING","BITSTR","FUNCTION","BFUNCTION","IFUNCTION","GTIFILTER", "REGFILTER","COLUMN","BCOLUMN","SCOLUMN","BITCOL","ROWREF","NULLREF","SNULLREF", "','","'='","':'","'{'","'}'","'?'","OR","AND","EQ","NE","'~'","GT","LT","LTE", "GTE","'+'","'-'","'%'","'*'","'/'","'|'","'&'","POWER","NOT","INTCAST","FLTCAST", "UMINUS","'['","ACCUM","DIFF","'\\n'","']'","'('","')'","lines","line","bvector", "vector","expr","bexpr","bits","sexpr", NULL }; #endif static const short ffr1[] = { 0, 54, 54, 55, 55, 55, 55, 55, 55, 56, 56, 57, 57, 57, 57, 58, 59, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 61, 61, 61, 61, 61, 61, 61, 61, 61 }; static const short ffr2[] = { 0, 0, 2, 1, 2, 2, 2, 2, 2, 2, 3, 2, 3, 3, 3, 2, 2, 1, 1, 4, 3, 3, 3, 4, 6, 8, 10, 12, 2, 3, 1, 1, 1, 4, 1, 1, 3, 3, 3, 3, 3, 3, 2, 2, 3, 3, 3, 5, 5, 5, 2, 3, 3, 3, 3, 5, 5, 9, 4, 6, 8, 10, 12, 2, 2, 2, 2, 1, 1, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 5, 3, 3, 3, 5, 7, 11, 15, 2, 3, 5, 9, 3, 7, 9, 4, 6, 8, 10, 12, 2, 3, 1, 1, 4, 1, 3, 3, 5, 5, 7 }; static const short ffdefact[] = { 1, 0, 0, 67, 30, 31, 116, 17, 0, 0, 0, 0, 0, 32, 68, 117, 18, 34, 35, 119, 0, 0, 0, 0, 0, 0, 3, 0, 2, 0, 0, 0, 0, 0, 0, 8, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 102, 0, 0, 0, 0, 0, 11, 9, 0, 42, 43, 114, 28, 63, 64, 65, 66, 0, 0, 0, 0, 0, 16, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 6, 0, 54, 0, 51, 53, 0, 52, 0, 95, 96, 97, 0, 0, 103, 0, 106, 0, 0, 0, 0, 44, 115, 29, 120, 14, 10, 12, 13, 0, 81, 82, 80, 76, 77, 79, 78, 37, 38, 36, 39, 45, 40, 41, 0, 0, 0, 0, 90, 89, 91, 92, 46, 0, 0, 0, 70, 71, 74, 72, 73, 75, 22, 21, 20, 0, 83, 84, 85, 87, 88, 86, 121, 0, 0, 0, 0, 0, 0, 0, 0, 33, 69, 118, 19, 0, 0, 58, 0, 0, 0, 0, 109, 28, 0, 0, 23, 0, 56, 98, 0, 123, 0, 55, 0, 104, 0, 93, 0, 47, 49, 48, 94, 122, 0, 0, 0, 0, 0, 0, 0, 0, 59, 0, 110, 0, 24, 0, 124, 0, 99, 0, 0, 107, 0, 0, 0, 0, 0, 0, 0, 0, 60, 0, 111, 0, 25, 57, 0, 105, 108, 0, 0, 0, 0, 0, 61, 0, 112, 0, 26, 0, 100, 0, 0, 0, 0, 62, 113, 27, 0, 0, 101, 0, 0 }; static const short ffdefgoto[] = { 1, 28, 29, 30, 45, 46, 43, 57 }; static const short ffpact[] = {-32768, 301, -41,-32768,-32768,-32768,-32768,-32768, 351, 402, 402, -5, 12, 8, 33, 34, 41,-32768,-32768,-32768, 402, 402, 402, 402, 402, 402,-32768, 402,-32768, -18, 9, 1092, 403, 1438, 79,-32768,-32768, 428, 143, 294, 10, 456, 224, 1478, 125, 1390, 1436, 1523, -6,-32768, 2, 402, 402, 402, 402, 1390, 1436, 1129, 19, 19, 20, 21, 19, 20, 19, 20, 623, 240, 344, 1120, 402, -32768, 402,-32768, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402,-32768, 402, 402, 402, 402, 402, 402, 402,-32768, -3, -3, -3, -3, -3, -3, -3, -3, -3, 402,-32768, 402, 402, 402, 402, 402, 402, 402,-32768, 402,-32768, 402,-32768, -32768, 402,-32768, 402,-32768,-32768,-32768, 402, 402,-32768, 402,-32768, 1266, 1286, 1306, 1326,-32768,-32768,-32768,-32768, 1390, 1436, 1390, 1436, 1348, 1503, 1503, 1503, 23, 23, 23, 23, 160, 160, 160, -15, 20, -15, -15, 732, 1370, 1413, 1531, 146, -13, -35, -35, -15, 756, -3, -3, -30, -30, -30, -30, -30, -30, 50, 21, 21, 780, 67, 67, 11, 11, 11, 11,-32768, 484, 1118, 1146, 1415, 1166, 1424, 512, 1186,-32768,-32768,-32768,-32768, 402, 402,-32768, 402, 402, 402, 402,-32768, 21, 1480, 402,-32768, 402,-32768,-32768, 402,-32768, 402,-32768, 66, -32768, 402, 1461, 804, 1461, 1436, 1461, 1436, 1129, 828, 852, 1206, 650, 540, 68, 568, 402,-32768, 402,-32768, 402,-32768, 402,-32768, 402,-32768, 86, 87,-32768, 876, 900, 924, 677, 1226, 52, 56, 402,-32768, 402,-32768, 402,-32768,-32768, 402,-32768,-32768, 948, 972, 996, 596, 402,-32768, 402,-32768, 402,-32768, 402,-32768, 1020, 1044, 1068, 1246,-32768,-32768,-32768, 402, 704,-32768, 126,-32768 }; static const short ffpgoto[] = {-32768, -32768,-32768,-32768, -1, 95, 124, 27 }; #define FFLAST 1566 static const short fftable[] = { 31, 48, 70, 95, 7, 104, 71, 37, 41, 35, 105, 106, 96, 16, 129, 93, 94, 107, 50, 55, 58, 59, 131, 62, 64, 95, 66, 87, 34, 72, 122, 51, 88, 73, 96, 40, 44, 47, 109, 110, 170, 111, 112, 113, 114, 115, 115, 130, 49, 171, 133, 134, 135, 136, 69, 132, 52, 53, 82, 83, 84, 85, 86, 123, 54, 87, 88, 96, 107, 141, 88, 143, 235, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 158, 159, 160, 247, 161, 105, 106, 255, 256, 168, 169, 32, 107, 111, 112, 113, 114, 115, 38, 42, 265, 181, 109, 110, 266, 111, 112, 113, 114, 115, 56, 189, 163, 60, 63, 65, 191, 67, 193, 0, 33, 290, 0, 195, 116, 196, 0, 39, 0, 0, 0, 182, 183, 184, 185, 186, 187, 188, 0, 0, 0, 0, 61, 0, 192, 0, 68, 0, 109, 110, 194, 111, 112, 113, 114, 115, 0, 0, 119, 0, 142, 0, 144, 90, 91, 92, 93, 94, 92, 93, 94, 0, 0, 127, 0, 157, 95, 0, 0, 95, 162, 164, 165, 166, 167, 96, 0, 0, 96, 0, 0, 120, 0, 85, 86, 223, 224, 87, 225, 227, 0, 230, 88, 0, 0, 231, 0, 232, 0, 190, 233, 0, 234, 0, 0, 0, 236, 172, 173, 174, 175, 176, 177, 178, 179, 180, 0, 0, 229, 0, 0, 250, 0, 251, 0, 252, 0, 253, 0, 254, 0, 0, 0, 0, 90, 91, 92, 93, 94, 0, 0, 267, 0, 268, 0, 269, 0, 95, 270, 0, 90, 91, 92, 93, 94, 279, 96, 280, 0, 281, 0, 282, 126, 95, 0, 0, 0, 0, 0, 0, 287, 0, 96, 0, 0, 0, 0, 0, 138, 209, 210, 0, 0, 0, 226, 228, 289, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 98, 99, 20, 100, 101, 102, 103, 104, 0, 0, 0, 0, 105, 106, 21, 22, 0, 0, 0, 107, 0, 0, 23, 24, 25, 121, 0, 0, 0, 26, 0, 27, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 98, 99, 20, 100, 101, 102, 103, 104, 0, 0, 0, 0, 105, 106, 21, 22, 0, 0, 0, 107, 0, 0, 23, 24, 25, 139, 0, 0, 0, 0, 0, 27, 36, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 0, 0, 0, 20, 0, 0, 90, 91, 92, 93, 94, 0, 0, 0, 0, 21, 22, 0, 0, 95, 0, 0, 0, 23, 24, 25, 117, 74, 96, 0, 0, 97, 27, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 124, 74, 0, 0, 0, 118, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 213, 74, 0, 0, 0, 125, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 220, 74, 0, 0, 0, 214, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 245, 74, 0, 0, 0, 221, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 248, 74, 0, 0, 0, 246, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 277, 74, 0, 0, 0, 249, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 74, 0, 0, 0, 0, 278, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 74, 0, 0, 0, 0, 137, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 74, 0, 0, 0, 0, 244, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 74, 0, 0, 0, 0, 263, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 202, 74, 0, 0, 0, 288, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 207, 74, 0, 88, 0, 0, 0, 203, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 211, 74, 0, 88, 0, 0, 0, 208, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 237, 74, 0, 88, 0, 0, 0, 212, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 239, 74, 0, 88, 0, 0, 0, 238, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 241, 74, 0, 88, 0, 0, 0, 240, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 257, 74, 0, 88, 0, 0, 0, 242, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 259, 74, 0, 88, 0, 0, 0, 258, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 261, 74, 0, 88, 0, 0, 0, 260, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 271, 74, 0, 88, 0, 0, 0, 262, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 273, 74, 0, 88, 0, 0, 0, 272, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 275, 74, 0, 88, 0, 0, 0, 274, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 74, 0, 88, 0, 0, 0, 276, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 74, 0, 88, 0, 0, 0, 283, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 74, 0, 88, 0, 0, 0, 284, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 74, 0, 88, 0, 0, 0, 285, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 0, 0, 88, 0, 0, 89, 90, 91, 92, 93, 94, 109, 110, 0, 111, 112, 113, 114, 115, 95, 109, 110, 0, 111, 112, 113, 114, 115, 96, 216, 74, 0, 0, 0, 215, 0, 140, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 218, 74, 87, 0, 0, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 222, 74, 87, 0, 0, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 243, 74, 87, 0, 0, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 264, 74, 87, 0, 0, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 286, 74, 87, 0, 0, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 74, 87, 0, 197, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 74, 87, 0, 198, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 74, 87, 0, 199, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 74, 87, 0, 200, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 74, 201, 0, 0, 88, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 74, 204, 0, 0, 88, 0, 0, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 74, 87, 0, 0, 0, 0, 88, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 205, 0, 88, 90, 91, 92, 93, 94, 109, 110, 0, 111, 112, 113, 114, 115, 95, 109, 110, 0, 111, 112, 113, 114, 115, 96, 90, 91, 92, 93, 94, 98, 99, 217, 100, 101, 102, 103, 104, 95, 0, 0, 219, 105, 106, 0, 0, 0, 96, 0, 107, 0, 0, 108, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 0, 0, 87, 0, 0, 98, 99, 88, 100, 101, 102, 103, 104, 0, 104, 0, 0, 105, 106, 105, 106, 0, 0, 0, 107, 0, 107, 0, 0, 0, 0, 0, 139, 78, 79, 80, 81, 82, 83, 84, 85, 86, 128, 0, 87, 0, 0, 0, 0, 88, 109, 110, 206, 111, 112, 113, 114, 115, 109, 110, 0, 111, 112, 113, 114, 115 }; static const short ffcheck[] = { 1, 6, 20, 38, 7, 35, 24, 8, 9, 50, 40, 41, 47, 16, 20, 28, 29, 47, 6, 20, 21, 22, 20, 24, 25, 38, 27, 42, 1, 20, 20, 23, 47, 24, 47, 8, 9, 10, 28, 29, 43, 31, 32, 33, 34, 35, 35, 53, 53, 52, 51, 52, 53, 54, 27, 53, 23, 23, 35, 36, 37, 38, 39, 53, 23, 42, 47, 47, 47, 70, 47, 72, 6, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 20, 90, 40, 41, 6, 6, 95, 96, 1, 47, 31, 32, 33, 34, 35, 8, 9, 53, 107, 28, 29, 53, 31, 32, 33, 34, 35, 20, 117, 90, 23, 24, 25, 122, 27, 124, -1, 1, 0, -1, 129, 50, 131, -1, 8, -1, -1, -1, 109, 110, 111, 112, 113, 114, 115, -1, -1, -1, -1, 23, -1, 122, -1, 27, -1, 28, 29, 128, 31, 32, 33, 34, 35, -1, -1, 20, -1, 70, -1, 72, 25, 26, 27, 28, 29, 27, 28, 29, -1, -1, 53, -1, 85, 38, -1, -1, 38, 90, 91, 92, 93, 94, 47, -1, -1, 47, -1, -1, 53, -1, 38, 39, 201, 202, 42, 204, 205, -1, 207, 47, -1, -1, 211, -1, 213, -1, 119, 216, -1, 218, -1, -1, -1, 222, 98, 99, 100, 101, 102, 103, 104, 105, 106, -1, -1, 206, -1, -1, 237, -1, 239, -1, 241, -1, 243, -1, 245, -1, -1, -1, -1, 25, 26, 27, 28, 29, -1, -1, 257, -1, 259, -1, 261, -1, 38, 264, -1, 25, 26, 27, 28, 29, 271, 47, 273, -1, 275, -1, 277, 53, 38, -1, -1, -1, -1, -1, -1, 286, -1, 47, -1, -1, -1, -1, -1, 53, 170, 171, -1, -1, -1, 204, 205, 0, 1, -1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, 28, 29, 23, 31, 32, 33, 34, 35, -1, -1, -1, -1, 40, 41, 35, 36, -1, -1, -1, 47, -1, -1, 43, 44, 45, 53, -1, -1, -1, 50, -1, 52, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, 28, 29, 23, 31, 32, 33, 34, 35, -1, -1, -1, -1, 40, 41, 35, 36, -1, -1, -1, 47, -1, -1, 43, 44, 45, 53, -1, -1, -1, -1, -1, 52, 53, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, -1, -1, 23, -1, -1, 25, 26, 27, 28, 29, -1, -1, -1, -1, 35, 36, -1, -1, 38, -1, -1, -1, 43, 44, 45, 20, 21, 47, -1, -1, 50, 52, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 20, 21, -1, -1, -1, 53, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 20, 21, -1, -1, -1, 53, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 20, 21, -1, -1, -1, 53, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 20, 21, -1, -1, -1, 53, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 20, 21, -1, -1, -1, 53, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 20, 21, -1, -1, -1, 53, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 21, -1, -1, -1, -1, 53, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 21, -1, -1, -1, -1, 53, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 21, -1, -1, -1, -1, 53, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 21, -1, -1, -1, -1, 53, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, 20, 21, -1, -1, -1, 53, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, 20, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, 21, -1, 47, -1, -1, -1, 51, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, -1, -1, 47, -1, -1, 50, 25, 26, 27, 28, 29, 28, 29, -1, 31, 32, 33, 34, 35, 38, 28, 29, -1, 31, 32, 33, 34, 35, 47, 20, 21, -1, -1, -1, 53, -1, 53, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 20, 21, 42, -1, -1, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 20, 21, 42, -1, -1, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 20, 21, 42, -1, -1, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 20, 21, 42, -1, -1, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 20, 21, 42, -1, -1, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, 21, 42, -1, 24, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, 21, 42, -1, 24, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, 21, 42, -1, 24, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, 21, 42, -1, 24, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, 21, 22, -1, -1, 47, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, 21, 22, -1, -1, 47, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, 21, 42, -1, -1, -1, -1, 47, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, 22, -1, 47, 25, 26, 27, 28, 29, 28, 29, -1, 31, 32, 33, 34, 35, 38, 28, 29, -1, 31, 32, 33, 34, 35, 47, 25, 26, 27, 28, 29, 28, 29, 53, 31, 32, 33, 34, 35, 38, -1, -1, 53, 40, 41, -1, -1, -1, 47, -1, 47, -1, -1, 50, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1, 42, -1, -1, 28, 29, 47, 31, 32, 33, 34, 35, -1, 35, -1, -1, 40, 41, 40, 41, -1, -1, -1, 47, -1, 47, -1, -1, -1, -1, -1, 53, 31, 32, 33, 34, 35, 36, 37, 38, 39, 20, -1, 42, -1, -1, -1, -1, 47, 28, 29, 22, 31, 32, 33, 34, 35, 28, 29, -1, 31, 32, 33, 34, 35 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ #line 3 "/usr1/local/share/bison.simple" /* Skeleton output parser for bison, Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. This special exception was added by the Free Software Foundation in version 1.24 of Bison. */ #ifndef alloca #ifdef __GNUC__ #define alloca __builtin_alloca #else /* not GNU C. */ #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) #include #else /* not sparc */ #if defined (MSDOS) && !defined (__TURBOC__) #include #else /* not MSDOS, or __TURBOC__ */ #if defined(_AIX) #include #pragma alloca #else /* not MSDOS, __TURBOC__, or _AIX */ #ifdef __hpux #ifdef __cplusplus extern "C" { void *alloca (unsigned int); }; #else /* not __cplusplus */ void *alloca (); #endif /* not __cplusplus */ #endif /* __hpux */ #endif /* not _AIX */ #endif /* not MSDOS, or __TURBOC__ */ #endif /* not sparc. */ #endif /* not GNU C. */ #endif /* alloca not defined. */ /* This is the parser code that is written into each bison parser when the %semantic_parser declaration is not specified in the grammar. It was written by Richard Stallman by simplifying the hairy parser used when %semantic_parser is specified. */ /* Note: there must be only one dollar sign in this file. It is replaced by the list of actions, each action as one case of the switch. */ #define fferrok (fferrstatus = 0) #define ffclearin (ffchar = FFEMPTY) #define FFEMPTY -2 #define FFEOF 0 #define FFACCEPT return(0) #define FFABORT return(1) #define FFERROR goto fferrlab1 /* Like FFERROR except do call fferror. This remains here temporarily to ease the transition to the new meaning of FFERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define FFFAIL goto fferrlab #define FFRECOVERING() (!!fferrstatus) #define FFBACKUP(token, value) \ do \ if (ffchar == FFEMPTY && fflen == 1) \ { ffchar = (token), fflval = (value); \ ffchar1 = FFTRANSLATE (ffchar); \ FFPOPSTACK; \ goto ffbackup; \ } \ else \ { fferror ("syntax error: cannot back up"); FFERROR; } \ while (0) #define FFTERROR 1 #define FFERRCODE 256 #ifndef FFPURE #define FFLEX fflex() #endif #ifdef FFPURE #ifdef FFLSP_NEEDED #ifdef FFLEX_PARAM #define FFLEX fflex(&fflval, &fflloc, FFLEX_PARAM) #else #define FFLEX fflex(&fflval, &fflloc) #endif #else /* not FFLSP_NEEDED */ #ifdef FFLEX_PARAM #define FFLEX fflex(&fflval, FFLEX_PARAM) #else #define FFLEX fflex(&fflval) #endif #endif /* not FFLSP_NEEDED */ #endif /* If nonreentrant, generate the variables here */ #ifndef FFPURE int ffchar; /* the lookahead symbol */ FFSTYPE fflval; /* the semantic value of the */ /* lookahead symbol */ #ifdef FFLSP_NEEDED FFLTYPE fflloc; /* location data for the lookahead */ /* symbol */ #endif int ffnerrs; /* number of parse errors so far */ #endif /* not FFPURE */ #if FFDEBUG != 0 int ffdebug; /* nonzero means print parse trace */ /* Since this is uninitialized, it does not stop multiple parsers from coexisting. */ #endif /* FFINITDEPTH indicates the initial size of the parser's stacks */ #ifndef FFINITDEPTH #define FFINITDEPTH 200 #endif /* FFMAXDEPTH is the maximum size the stacks can grow to (effective only if the built-in stack extension method is used). */ #if FFMAXDEPTH == 0 #undef FFMAXDEPTH #endif #ifndef FFMAXDEPTH #define FFMAXDEPTH 10000 #endif /* Prevent warning if -Wstrict-prototypes. */ #ifdef __GNUC__ int ffparse (void); #endif #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ #define __ff_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) #else /* not GNU C or C++ */ #ifndef __cplusplus /* This is the most reliable way to avoid incompatibilities in available built-in functions on various systems. */ static void __ff_memcpy (to, from, count) char *to; char *from; int count; { register char *f = from; register char *t = to; register int i = count; while (i-- > 0) *t++ = *f++; } #else /* __cplusplus */ /* This is the most reliable way to avoid incompatibilities in available built-in functions on various systems. */ static void __ff_memcpy (char *to, char *from, int count) { register char *f = from; register char *t = to; register int i = count; while (i-- > 0) *t++ = *f++; } #endif #endif #line 196 "/usr1/local/share/bison.simple" /* The user can define FFPARSE_PARAM as the name of an argument to be passed into ffparse. The argument should have type void *. It should actually point to an object. Grammar actions can access the variable by casting it to the proper pointer type. */ #ifdef FFPARSE_PARAM #ifdef __cplusplus #define FFPARSE_PARAM_ARG void *FFPARSE_PARAM #define FFPARSE_PARAM_DECL #else /* not __cplusplus */ #define FFPARSE_PARAM_ARG FFPARSE_PARAM #define FFPARSE_PARAM_DECL void *FFPARSE_PARAM; #endif /* not __cplusplus */ #else /* not FFPARSE_PARAM */ #define FFPARSE_PARAM_ARG #define FFPARSE_PARAM_DECL #endif /* not FFPARSE_PARAM */ int ffparse(FFPARSE_PARAM_ARG) FFPARSE_PARAM_DECL { register int ffstate; register int ffn; register short *ffssp; register FFSTYPE *ffvsp; int fferrstatus; /* number of tokens to shift before error messages enabled */ int ffchar1 = 0; /* lookahead token as an internal (translated) token number */ short ffssa[FFINITDEPTH]; /* the state stack */ FFSTYPE ffvsa[FFINITDEPTH]; /* the semantic value stack */ short *ffss = ffssa; /* refer to the stacks thru separate pointers */ FFSTYPE *ffvs = ffvsa; /* to allow ffoverflow to reallocate them elsewhere */ #ifdef FFLSP_NEEDED FFLTYPE fflsa[FFINITDEPTH]; /* the location stack */ FFLTYPE *ffls = fflsa; FFLTYPE *fflsp; #define FFPOPSTACK (ffvsp--, ffssp--, fflsp--) #else #define FFPOPSTACK (ffvsp--, ffssp--) #endif int ffstacksize = FFINITDEPTH; #ifdef FFPURE int ffchar; FFSTYPE fflval; int ffnerrs; #ifdef FFLSP_NEEDED FFLTYPE fflloc; #endif #endif FFSTYPE ffval; /* the variable used to return */ /* semantic values from the action */ /* routines */ int fflen; #if FFDEBUG != 0 if (ffdebug) fprintf(stderr, "Starting parse\n"); #endif ffstate = 0; fferrstatus = 0; ffnerrs = 0; ffchar = FFEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ ffssp = ffss - 1; ffvsp = ffvs; #ifdef FFLSP_NEEDED fflsp = ffls; #endif /* Push a new state, which is found in ffstate . */ /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ ffnewstate: *++ffssp = ffstate; if (ffssp >= ffss + ffstacksize - 1) { /* Give user a chance to reallocate the stack */ /* Use copies of these so that the &'s don't force the real ones into memory. */ FFSTYPE *ffvs1 = ffvs; short *ffss1 = ffss; #ifdef FFLSP_NEEDED FFLTYPE *ffls1 = ffls; #endif /* Get the current used size of the three stacks, in elements. */ int size = ffssp - ffss + 1; #ifdef ffoverflow /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. */ #ifdef FFLSP_NEEDED /* This used to be a conditional around just the two extra args, but that might be undefined if ffoverflow is a macro. */ ffoverflow("parser stack overflow", &ffss1, size * sizeof (*ffssp), &ffvs1, size * sizeof (*ffvsp), &ffls1, size * sizeof (*fflsp), &ffstacksize); #else ffoverflow("parser stack overflow", &ffss1, size * sizeof (*ffssp), &ffvs1, size * sizeof (*ffvsp), &ffstacksize); #endif ffss = ffss1; ffvs = ffvs1; #ifdef FFLSP_NEEDED ffls = ffls1; #endif #else /* no ffoverflow */ /* Extend the stack our own way. */ if (ffstacksize >= FFMAXDEPTH) { fferror("parser stack overflow"); return 2; } ffstacksize *= 2; if (ffstacksize > FFMAXDEPTH) ffstacksize = FFMAXDEPTH; ffss = (short *) alloca (ffstacksize * sizeof (*ffssp)); __ff_memcpy ((char *)ffss, (char *)ffss1, size * sizeof (*ffssp)); ffvs = (FFSTYPE *) alloca (ffstacksize * sizeof (*ffvsp)); __ff_memcpy ((char *)ffvs, (char *)ffvs1, size * sizeof (*ffvsp)); #ifdef FFLSP_NEEDED ffls = (FFLTYPE *) alloca (ffstacksize * sizeof (*fflsp)); __ff_memcpy ((char *)ffls, (char *)ffls1, size * sizeof (*fflsp)); #endif #endif /* no ffoverflow */ ffssp = ffss + size - 1; ffvsp = ffvs + size - 1; #ifdef FFLSP_NEEDED fflsp = ffls + size - 1; #endif #if FFDEBUG != 0 if (ffdebug) fprintf(stderr, "Stack size increased to %d\n", ffstacksize); #endif if (ffssp >= ffss + ffstacksize - 1) FFABORT; } #if FFDEBUG != 0 if (ffdebug) fprintf(stderr, "Entering state %d\n", ffstate); #endif goto ffbackup; ffbackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ /* ffresume: */ /* First try to decide what to do without reference to lookahead token. */ ffn = ffpact[ffstate]; if (ffn == FFFLAG) goto ffdefault; /* Not known => get a lookahead token if don't already have one. */ /* ffchar is either FFEMPTY or FFEOF or a valid token in external form. */ if (ffchar == FFEMPTY) { #if FFDEBUG != 0 if (ffdebug) fprintf(stderr, "Reading a token: "); #endif ffchar = FFLEX; } /* Convert token to internal form (in ffchar1) for indexing tables with */ if (ffchar <= 0) /* This means end of input. */ { ffchar1 = 0; ffchar = FFEOF; /* Don't call FFLEX any more */ #if FFDEBUG != 0 if (ffdebug) fprintf(stderr, "Now at end of input.\n"); #endif } else { ffchar1 = FFTRANSLATE(ffchar); #if FFDEBUG != 0 if (ffdebug) { fprintf (stderr, "Next token is %d (%s", ffchar, fftname[ffchar1]); /* Give the individual parser a way to print the precise meaning of a token, for further debugging info. */ #ifdef FFPRINT FFPRINT (stderr, ffchar, fflval); #endif fprintf (stderr, ")\n"); } #endif } ffn += ffchar1; if (ffn < 0 || ffn > FFLAST || ffcheck[ffn] != ffchar1) goto ffdefault; ffn = fftable[ffn]; /* ffn is what to do for this token type in this state. Negative => reduce, -ffn is rule number. Positive => shift, ffn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (ffn < 0) { if (ffn == FFFLAG) goto fferrlab; ffn = -ffn; goto ffreduce; } else if (ffn == 0) goto fferrlab; if (ffn == FFFINAL) FFACCEPT; /* Shift the lookahead token. */ #if FFDEBUG != 0 if (ffdebug) fprintf(stderr, "Shifting token %d (%s), ", ffchar, fftname[ffchar1]); #endif /* Discard the token being shifted unless it is eof. */ if (ffchar != FFEOF) ffchar = FFEMPTY; *++ffvsp = fflval; #ifdef FFLSP_NEEDED *++fflsp = fflloc; #endif /* count tokens shifted since error; after three, turn off error status. */ if (fferrstatus) fferrstatus--; ffstate = ffn; goto ffnewstate; /* Do the default action for the current state. */ ffdefault: ffn = ffdefact[ffstate]; if (ffn == 0) goto fferrlab; /* Do a reduction. ffn is the number of a rule to reduce with. */ ffreduce: fflen = ffr2[ffn]; if (fflen > 0) ffval = ffvsp[1-fflen]; /* implement default value of the action */ #if FFDEBUG != 0 if (ffdebug) { int i; fprintf (stderr, "Reducing via rule %d (line %d), ", ffn, ffrline[ffn]); /* Print the symbols being reduced, and their result. */ for (i = ffprhs[ffn]; ffrhs[i] > 0; i++) fprintf (stderr, "%s ", fftname[ffrhs[i]]); fprintf (stderr, " -> %s\n", fftname[ffr1[ffn]]); } #endif switch (ffn) { case 3: #line 245 "eval.y" {; break;} case 4: #line 247 "eval.y" { if( ffvsp[-1].Node<0 ) { fferror("Couldn't build node structure: out of memory?"); FFERROR; } gParse.resultNode = ffvsp[-1].Node; ; break;} case 5: #line 253 "eval.y" { if( ffvsp[-1].Node<0 ) { fferror("Couldn't build node structure: out of memory?"); FFERROR; } gParse.resultNode = ffvsp[-1].Node; ; break;} case 6: #line 259 "eval.y" { if( ffvsp[-1].Node<0 ) { fferror("Couldn't build node structure: out of memory?"); FFERROR; } gParse.resultNode = ffvsp[-1].Node; ; break;} case 7: #line 265 "eval.y" { if( ffvsp[-1].Node<0 ) { fferror("Couldn't build node structure: out of memory?"); FFERROR; } gParse.resultNode = ffvsp[-1].Node; ; break;} case 8: #line 270 "eval.y" { fferrok; ; break;} case 9: #line 274 "eval.y" { ffval.Node = New_Vector( ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 10: #line 276 "eval.y" { if( gParse.Nodes[ffvsp[-2].Node].nSubNodes >= MAXSUBS ) { ffvsp[-2].Node = Close_Vec( ffvsp[-2].Node ); TEST(ffvsp[-2].Node); ffval.Node = New_Vector( ffvsp[-2].Node ); TEST(ffval.Node); } else { ffval.Node = ffvsp[-2].Node; } gParse.Nodes[ffval.Node].SubNodes[ gParse.Nodes[ffval.Node].nSubNodes++ ] = ffvsp[0].Node; ; break;} case 11: #line 289 "eval.y" { ffval.Node = New_Vector( ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 12: #line 291 "eval.y" { if( TYPE(ffvsp[-2].Node) < TYPE(ffvsp[0].Node) ) TYPE(ffvsp[-2].Node) = TYPE(ffvsp[0].Node); if( gParse.Nodes[ffvsp[-2].Node].nSubNodes >= MAXSUBS ) { ffvsp[-2].Node = Close_Vec( ffvsp[-2].Node ); TEST(ffvsp[-2].Node); ffval.Node = New_Vector( ffvsp[-2].Node ); TEST(ffval.Node); } else { ffval.Node = ffvsp[-2].Node; } gParse.Nodes[ffval.Node].SubNodes[ gParse.Nodes[ffval.Node].nSubNodes++ ] = ffvsp[0].Node; ; break;} case 13: #line 304 "eval.y" { if( gParse.Nodes[ffvsp[-2].Node].nSubNodes >= MAXSUBS ) { ffvsp[-2].Node = Close_Vec( ffvsp[-2].Node ); TEST(ffvsp[-2].Node); ffval.Node = New_Vector( ffvsp[-2].Node ); TEST(ffval.Node); } else { ffval.Node = ffvsp[-2].Node; } gParse.Nodes[ffval.Node].SubNodes[ gParse.Nodes[ffval.Node].nSubNodes++ ] = ffvsp[0].Node; ; break;} case 14: #line 315 "eval.y" { TYPE(ffvsp[-2].Node) = TYPE(ffvsp[0].Node); if( gParse.Nodes[ffvsp[-2].Node].nSubNodes >= MAXSUBS ) { ffvsp[-2].Node = Close_Vec( ffvsp[-2].Node ); TEST(ffvsp[-2].Node); ffval.Node = New_Vector( ffvsp[-2].Node ); TEST(ffval.Node); } else { ffval.Node = ffvsp[-2].Node; } gParse.Nodes[ffval.Node].SubNodes[ gParse.Nodes[ffval.Node].nSubNodes++ ] = ffvsp[0].Node; ; break;} case 15: #line 329 "eval.y" { ffval.Node = Close_Vec( ffvsp[-1].Node ); TEST(ffval.Node); ; break;} case 16: #line 333 "eval.y" { ffval.Node = Close_Vec( ffvsp[-1].Node ); TEST(ffval.Node); ; break;} case 17: #line 337 "eval.y" { ffval.Node = New_Const( BITSTR, ffvsp[0].str, strlen(ffvsp[0].str)+1 ); TEST(ffval.Node); SIZE(ffval.Node) = strlen(ffvsp[0].str); ; break;} case 18: #line 341 "eval.y" { ffval.Node = New_Column( ffvsp[0].lng ); TEST(ffval.Node); ; break;} case 19: #line 343 "eval.y" { if( TYPE(ffvsp[-1].Node) != LONG || OPER(ffvsp[-1].Node) != CONST_OP ) { fferror("Offset argument must be a constant integer"); FFERROR; } ffval.Node = New_Offset( ffvsp[-3].lng, ffvsp[-1].Node ); TEST(ffval.Node); ; break;} case 20: #line 352 "eval.y" { ffval.Node = New_BinOp( BITSTR, ffvsp[-2].Node, '&', ffvsp[0].Node ); TEST(ffval.Node); SIZE(ffval.Node) = ( SIZE(ffvsp[-2].Node)>SIZE(ffvsp[0].Node) ? SIZE(ffvsp[-2].Node) : SIZE(ffvsp[0].Node) ); ; break;} case 21: #line 355 "eval.y" { ffval.Node = New_BinOp( BITSTR, ffvsp[-2].Node, '|', ffvsp[0].Node ); TEST(ffval.Node); SIZE(ffval.Node) = ( SIZE(ffvsp[-2].Node)>SIZE(ffvsp[0].Node) ? SIZE(ffvsp[-2].Node) : SIZE(ffvsp[0].Node) ); ; break;} case 22: #line 358 "eval.y" { if (SIZE(ffvsp[-2].Node)+SIZE(ffvsp[0].Node) >= MAX_STRLEN) { fferror("Combined bit string size exceeds " MAX_STRLEN_S " bits"); FFERROR; } ffval.Node = New_BinOp( BITSTR, ffvsp[-2].Node, '+', ffvsp[0].Node ); TEST(ffval.Node); SIZE(ffval.Node) = SIZE(ffvsp[-2].Node) + SIZE(ffvsp[0].Node); ; break;} case 23: #line 367 "eval.y" { ffval.Node = New_Deref( ffvsp[-3].Node, 1, ffvsp[-1].Node, 0, 0, 0, 0 ); TEST(ffval.Node); ; break;} case 24: #line 369 "eval.y" { ffval.Node = New_Deref( ffvsp[-5].Node, 2, ffvsp[-3].Node, ffvsp[-1].Node, 0, 0, 0 ); TEST(ffval.Node); ; break;} case 25: #line 371 "eval.y" { ffval.Node = New_Deref( ffvsp[-7].Node, 3, ffvsp[-5].Node, ffvsp[-3].Node, ffvsp[-1].Node, 0, 0 ); TEST(ffval.Node); ; break;} case 26: #line 373 "eval.y" { ffval.Node = New_Deref( ffvsp[-9].Node, 4, ffvsp[-7].Node, ffvsp[-5].Node, ffvsp[-3].Node, ffvsp[-1].Node, 0 ); TEST(ffval.Node); ; break;} case 27: #line 375 "eval.y" { ffval.Node = New_Deref( ffvsp[-11].Node, 5, ffvsp[-9].Node, ffvsp[-7].Node, ffvsp[-5].Node, ffvsp[-3].Node, ffvsp[-1].Node ); TEST(ffval.Node); ; break;} case 28: #line 377 "eval.y" { ffval.Node = New_Unary( BITSTR, NOT, ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 29: #line 380 "eval.y" { ffval.Node = ffvsp[-1].Node; ; break;} case 30: #line 384 "eval.y" { ffval.Node = New_Const( LONG, &(ffvsp[0].lng), sizeof(long) ); TEST(ffval.Node); ; break;} case 31: #line 386 "eval.y" { ffval.Node = New_Const( DOUBLE, &(ffvsp[0].dbl), sizeof(double) ); TEST(ffval.Node); ; break;} case 32: #line 388 "eval.y" { ffval.Node = New_Column( ffvsp[0].lng ); TEST(ffval.Node); ; break;} case 33: #line 390 "eval.y" { if( TYPE(ffvsp[-1].Node) != LONG || OPER(ffvsp[-1].Node) != CONST_OP ) { fferror("Offset argument must be a constant integer"); FFERROR; } ffval.Node = New_Offset( ffvsp[-3].lng, ffvsp[-1].Node ); TEST(ffval.Node); ; break;} case 34: #line 399 "eval.y" { ffval.Node = New_Func( LONG, row_fct, 0, 0, 0, 0, 0, 0, 0, 0 ); ; break;} case 35: #line 401 "eval.y" { ffval.Node = New_Func( LONG, null_fct, 0, 0, 0, 0, 0, 0, 0, 0 ); ; break;} case 36: #line 403 "eval.y" { PROMOTE(ffvsp[-2].Node,ffvsp[0].Node); ffval.Node = New_BinOp( TYPE(ffvsp[-2].Node), ffvsp[-2].Node, '%', ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 37: #line 406 "eval.y" { PROMOTE(ffvsp[-2].Node,ffvsp[0].Node); ffval.Node = New_BinOp( TYPE(ffvsp[-2].Node), ffvsp[-2].Node, '+', ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 38: #line 409 "eval.y" { PROMOTE(ffvsp[-2].Node,ffvsp[0].Node); ffval.Node = New_BinOp( TYPE(ffvsp[-2].Node), ffvsp[-2].Node, '-', ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 39: #line 412 "eval.y" { PROMOTE(ffvsp[-2].Node,ffvsp[0].Node); ffval.Node = New_BinOp( TYPE(ffvsp[-2].Node), ffvsp[-2].Node, '*', ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 40: #line 415 "eval.y" { PROMOTE(ffvsp[-2].Node,ffvsp[0].Node); ffval.Node = New_BinOp( TYPE(ffvsp[-2].Node), ffvsp[-2].Node, '/', ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 41: #line 418 "eval.y" { PROMOTE(ffvsp[-2].Node,ffvsp[0].Node); ffval.Node = New_BinOp( TYPE(ffvsp[-2].Node), ffvsp[-2].Node, POWER, ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 42: #line 421 "eval.y" { ffval.Node = ffvsp[0].Node; ; break;} case 43: #line 423 "eval.y" { ffval.Node = New_Unary( TYPE(ffvsp[0].Node), UMINUS, ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 44: #line 425 "eval.y" { ffval.Node = ffvsp[-1].Node; ; break;} case 45: #line 427 "eval.y" { ffvsp[0].Node = New_Unary( TYPE(ffvsp[-2].Node), 0, ffvsp[0].Node ); ffval.Node = New_BinOp( TYPE(ffvsp[-2].Node), ffvsp[-2].Node, '*', ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 46: #line 431 "eval.y" { ffvsp[-2].Node = New_Unary( TYPE(ffvsp[0].Node), 0, ffvsp[-2].Node ); ffval.Node = New_BinOp( TYPE(ffvsp[0].Node), ffvsp[-2].Node, '*', ffvsp[0].Node ); TEST(ffval.Node); ; break;} case 47: #line 435 "eval.y" { PROMOTE(ffvsp[-2].Node,ffvsp[0].Node); if( ! Test_Dims(ffvsp[-2].Node,ffvsp[0].Node) ) { fferror("Incompatible dimensions in '?:' arguments"); FFERROR; } ffval.Node = New_Func( 0, ifthenelse_fct, 3, ffvsp[-2].Node, ffvsp[0].Node, ffvsp[-4].Node, 0, 0, 0, 0 ); TEST(ffval.Node); if( SIZE(ffvsp[-2].Node)=SIZE(ffvsp[-1].Node) && Test_Dims( ffvsp[-3].Node, ffvsp[-1].Node ) ) { PROMOTE(ffvsp[-3].Node,ffvsp[-1].Node); ffval.Node = New_Func( 0, defnull_fct, 2, ffvsp[-3].Node, ffvsp[-1].Node, 0, 0, 0, 0, 0 ); TEST(ffval.Node); } else { fferror("Dimensions of DEFNULL arguments " "are not compatible"); FFERROR; } } else if (FSTRCMP(ffvsp[-4].str,"ARCTAN2(") == 0) { if( TYPE(ffvsp[-3].Node) != DOUBLE ) ffvsp[-3].Node = New_Unary( DOUBLE, 0, ffvsp[-3].Node ); if( TYPE(ffvsp[-1].Node) != DOUBLE ) ffvsp[-1].Node = New_Unary( DOUBLE, 0, ffvsp[-1].Node ); if( Test_Dims( ffvsp[-3].Node, ffvsp[-1].Node ) ) { ffval.Node = New_Func( 0, atan2_fct, 2, ffvsp[-3].Node, ffvsp[-1].Node, 0, 0, 0, 0, 0 ); TEST(ffval.Node); if( SIZE(ffvsp[-3].Node)=SIZE(ffvsp[-1].Node) && Test_Dims( ffvsp[-3].Node, ffvsp[-1].Node ) ) { ffval.Node = New_Func( 0, defnull_fct, 2, ffvsp[-3].Node, ffvsp[-1].Node, 0, 0, 0, 0, 0 ); TEST(ffval.Node); } else { fferror("Dimensions of DEFNULL arguments are not compatible"); FFERROR; } } else { fferror("Boolean Function(expr,expr) not supported"); FFERROR; } ; break;} case 99: #line 930 "eval.y" { if( TYPE(ffvsp[-5].Node) != DOUBLE ) ffvsp[-5].Node = New_Unary( DOUBLE, 0, ffvsp[-5].Node ); if( TYPE(ffvsp[-3].Node) != DOUBLE ) ffvsp[-3].Node = New_Unary( DOUBLE, 0, ffvsp[-3].Node ); if( TYPE(ffvsp[-1].Node) != DOUBLE ) ffvsp[-1].Node = New_Unary( DOUBLE, 0, ffvsp[-1].Node ); if( ! (Test_Dims( ffvsp[-5].Node, ffvsp[-3].Node ) && Test_Dims( ffvsp[-3].Node, ffvsp[-1].Node ) ) ) { fferror("Dimensions of NEAR arguments " "are not compatible"); FFERROR; } else { if (FSTRCMP(ffvsp[-6].str,"NEAR(") == 0) { ffval.Node = New_Func( BOOLEAN, near_fct, 3, ffvsp[-5].Node, ffvsp[-3].Node, ffvsp[-1].Node, 0, 0, 0, 0 ); } else { fferror("Boolean Function not supported"); FFERROR; } TEST(ffval.Node); if( SIZE(ffval.Node)= MAX_STRLEN) { fferror("Combined string size exceeds " MAX_STRLEN_S " characters"); FFERROR; } ffval.Node = New_BinOp( STRING, ffvsp[-2].Node, '+', ffvsp[0].Node ); TEST(ffval.Node); SIZE(ffval.Node) = SIZE(ffvsp[-2].Node) + SIZE(ffvsp[0].Node); ; break;} case 122: #line 1088 "eval.y" { int outSize; if( SIZE(ffvsp[-4].Node)!=1 ) { fferror("Cannot have a vector string column"); FFERROR; } /* Since the output can be calculated now, as a constant scalar, we must precalculate the output size, in order to avoid an overflow. */ outSize = SIZE(ffvsp[-2].Node); if (SIZE(ffvsp[0].Node) > outSize) outSize = SIZE(ffvsp[0].Node); ffval.Node = New_FuncSize( 0, ifthenelse_fct, 3, ffvsp[-2].Node, ffvsp[0].Node, ffvsp[-4].Node, 0, 0, 0, 0, outSize); TEST(ffval.Node); if( SIZE(ffvsp[-2].Node) outSize) outSize = SIZE(ffvsp[-1].Node); ffval.Node = New_FuncSize( 0, defnull_fct, 2, ffvsp[-3].Node, ffvsp[-1].Node, 0, 0, 0, 0, 0, outSize ); TEST(ffval.Node); if( SIZE(ffvsp[-1].Node)>SIZE(ffvsp[-3].Node) ) SIZE(ffval.Node) = SIZE(ffvsp[-1].Node); } else { fferror("Function(string,string) not supported"); FFERROR; } ; break;} case 124: #line 1126 "eval.y" { if (FSTRCMP(ffvsp[-6].str,"STRMID(") == 0) { int len; if( TYPE(ffvsp[-3].Node) != LONG || SIZE(ffvsp[-3].Node) != 1 || TYPE(ffvsp[-1].Node) != LONG || SIZE(ffvsp[-1].Node) != 1) { fferror("When using STRMID(S,P,N), P and N must be integers (and not vector columns)"); FFERROR; } if (OPER(ffvsp[-1].Node) == CONST_OP) { /* Constant value: use that directly */ len = (gParse.Nodes[ffvsp[-1].Node].value.data.lng); } else { /* Variable value: use the maximum possible (from $2) */ len = SIZE(ffvsp[-5].Node); } if (len <= 0 || len >= MAX_STRLEN) { fferror("STRMID(S,P,N), N must be 1-" MAX_STRLEN_S); FFERROR; } ffval.Node = New_FuncSize( 0, strmid_fct, 3, ffvsp[-5].Node, ffvsp[-3].Node,ffvsp[-1].Node,0,0,0,0,len); TEST(ffval.Node); } else { fferror("Function(string,expr,expr) not supported"); FFERROR; } ; break;} } /* the action file gets copied in in place of this dollarsign */ #line 498 "/usr1/local/share/bison.simple" ffvsp -= fflen; ffssp -= fflen; #ifdef FFLSP_NEEDED fflsp -= fflen; #endif #if FFDEBUG != 0 if (ffdebug) { short *ssp1 = ffss - 1; fprintf (stderr, "state stack now"); while (ssp1 != ffssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif *++ffvsp = ffval; #ifdef FFLSP_NEEDED fflsp++; if (fflen == 0) { fflsp->first_line = fflloc.first_line; fflsp->first_column = fflloc.first_column; fflsp->last_line = (fflsp-1)->last_line; fflsp->last_column = (fflsp-1)->last_column; fflsp->text = 0; } else { fflsp->last_line = (fflsp+fflen-1)->last_line; fflsp->last_column = (fflsp+fflen-1)->last_column; } #endif /* Now "shift" the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ ffn = ffr1[ffn]; ffstate = ffpgoto[ffn - FFNTBASE] + *ffssp; if (ffstate >= 0 && ffstate <= FFLAST && ffcheck[ffstate] == *ffssp) ffstate = fftable[ffstate]; else ffstate = ffdefgoto[ffn - FFNTBASE]; goto ffnewstate; fferrlab: /* here on detecting error */ if (! fferrstatus) /* If not already recovering from an error, report this error. */ { ++ffnerrs; #ifdef FFERROR_VERBOSE ffn = ffpact[ffstate]; if (ffn > FFFLAG && ffn < FFLAST) { int size = 0; char *msg; int x, count; count = 0; /* Start X at -ffn if nec to avoid negative indexes in ffcheck. */ for (x = (ffn < 0 ? -ffn : 0); x < (sizeof(fftname) / sizeof(char *)); x++) if (ffcheck[x + ffn] == x) size += strlen(fftname[x]) + 15, count++; msg = (char *) malloc(size + 15); if (msg != 0) { strcpy(msg, "parse error"); if (count < 5) { count = 0; for (x = (ffn < 0 ? -ffn : 0); x < (sizeof(fftname) / sizeof(char *)); x++) if (ffcheck[x + ffn] == x) { strcat(msg, count == 0 ? ", expecting `" : " or `"); strcat(msg, fftname[x]); strcat(msg, "'"); count++; } } fferror(msg); free(msg); } else fferror ("parse error; also virtual memory exceeded"); } else #endif /* FFERROR_VERBOSE */ fferror("parse error"); } goto fferrlab1; fferrlab1: /* here on error raised explicitly by an action */ if (fferrstatus == 3) { /* if just tried and failed to reuse lookahead token after an error, discard it. */ /* return failure if at end of input */ if (ffchar == FFEOF) FFABORT; #if FFDEBUG != 0 if (ffdebug) fprintf(stderr, "Discarding token %d (%s).\n", ffchar, fftname[ffchar1]); #endif ffchar = FFEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ fferrstatus = 3; /* Each real token shifted decrements this */ goto fferrhandle; fferrdefault: /* current state does not do anything special for the error token. */ #if 0 /* This is wrong; only states that explicitly want error tokens should shift them. */ ffn = ffdefact[ffstate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ if (ffn) goto ffdefault; #endif fferrpop: /* pop the current state because it cannot handle the error token */ if (ffssp == ffss) FFABORT; ffvsp--; ffstate = *--ffssp; #ifdef FFLSP_NEEDED fflsp--; #endif #if FFDEBUG != 0 if (ffdebug) { short *ssp1 = ffss - 1; fprintf (stderr, "Error: state stack now"); while (ssp1 != ffssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif fferrhandle: ffn = ffpact[ffstate]; if (ffn == FFFLAG) goto fferrdefault; ffn += FFTERROR; if (ffn < 0 || ffn > FFLAST || ffcheck[ffn] != FFTERROR) goto fferrdefault; ffn = fftable[ffn]; if (ffn < 0) { if (ffn == FFFLAG) goto fferrpop; ffn = -ffn; goto ffreduce; } else if (ffn == 0) goto fferrpop; if (ffn == FFFINAL) FFACCEPT; #if FFDEBUG != 0 if (ffdebug) fprintf(stderr, "Shifting error token, "); #endif *++ffvsp = fflval; #ifdef FFLSP_NEEDED *++fflsp = fflloc; #endif ffstate = ffn; goto ffnewstate; } #line 1155 "eval.y" /*************************************************************************/ /* Start of "New" routines which build the expression Nodal structure */ /*************************************************************************/ static int Alloc_Node( void ) { /* Use this for allocation to guarantee *Nodes */ Node *newNodePtr; /* survives on failure, making it still valid */ /* while working our way out of this error */ if( gParse.nNodes == gParse.nNodesAlloc ) { if( gParse.Nodes ) { gParse.nNodesAlloc += gParse.nNodesAlloc; newNodePtr = (Node *)realloc( gParse.Nodes, sizeof(Node)*gParse.nNodesAlloc ); } else { gParse.nNodesAlloc = 100; newNodePtr = (Node *)malloc ( sizeof(Node)*gParse.nNodesAlloc ); } if( newNodePtr ) { gParse.Nodes = newNodePtr; } else { gParse.status = MEMORY_ALLOCATION; return( -1 ); } } return ( gParse.nNodes++ ); } static void Free_Last_Node( void ) { if( gParse.nNodes ) gParse.nNodes--; } static int New_Const( int returnType, void *value, long len ) { Node *this; int n; n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = CONST_OP; /* Flag a constant */ this->DoOp = NULL; this->nSubNodes = 0; this->type = returnType; memcpy( &(this->value.data), value, len ); this->value.undef = NULL; this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; } return(n); } static int New_Column( int ColNum ) { Node *this; int n, i; n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = -ColNum; this->DoOp = NULL; this->nSubNodes = 0; this->type = gParse.varData[ColNum].type; this->value.nelem = gParse.varData[ColNum].nelem; this->value.naxis = gParse.varData[ColNum].naxis; for( i=0; ivalue.naxes[i] = gParse.varData[ColNum].naxes[i]; } return(n); } static int New_Offset( int ColNum, int offsetNode ) { Node *this; int n, i, colNode; colNode = New_Column( ColNum ); if( colNode<0 ) return(-1); n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = '{'; this->DoOp = Do_Offset; this->nSubNodes = 2; this->SubNodes[0] = colNode; this->SubNodes[1] = offsetNode; this->type = gParse.varData[ColNum].type; this->value.nelem = gParse.varData[ColNum].nelem; this->value.naxis = gParse.varData[ColNum].naxis; for( i=0; ivalue.naxes[i] = gParse.varData[ColNum].naxes[i]; } return(n); } static int New_Unary( int returnType, int Op, int Node1 ) { Node *this, *that; int i,n; if( Node1<0 ) return(-1); that = gParse.Nodes + Node1; if( !Op ) Op = returnType; if( (Op==DOUBLE || Op==FLTCAST) && that->type==DOUBLE ) return( Node1 ); if( (Op==LONG || Op==INTCAST) && that->type==LONG ) return( Node1 ); if( (Op==BOOLEAN ) && that->type==BOOLEAN ) return( Node1 ); n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = Op; this->DoOp = Do_Unary; this->nSubNodes = 1; this->SubNodes[0] = Node1; this->type = returnType; that = gParse.Nodes + Node1; /* Reset in case .Nodes mv'd */ this->value.nelem = that->value.nelem; this->value.naxis = that->value.naxis; for( i=0; ivalue.naxis; i++ ) this->value.naxes[i] = that->value.naxes[i]; if( that->operation==CONST_OP ) this->DoOp( this ); } return( n ); } static int New_BinOp( int returnType, int Node1, int Op, int Node2 ) { Node *this,*that1,*that2; int n,i,constant; if( Node1<0 || Node2<0 ) return(-1); n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = Op; this->nSubNodes = 2; this->SubNodes[0]= Node1; this->SubNodes[1]= Node2; this->type = returnType; that1 = gParse.Nodes + Node1; that2 = gParse.Nodes + Node2; constant = (that1->operation==CONST_OP && that2->operation==CONST_OP); if( that1->type!=STRING && that1->type!=BITSTR ) if( !Test_Dims( Node1, Node2 ) ) { Free_Last_Node(); fferror("Array sizes/dims do not match for binary operator"); return(-1); } if( that1->value.nelem == 1 ) that1 = that2; this->value.nelem = that1->value.nelem; this->value.naxis = that1->value.naxis; for( i=0; ivalue.naxis; i++ ) this->value.naxes[i] = that1->value.naxes[i]; if ( Op == ACCUM && that1->type == BITSTR ) { /* ACCUM is rank-reducing on bit strings */ this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; } /* Both subnodes should be of same time */ switch( that1->type ) { case BITSTR: this->DoOp = Do_BinOp_bit; break; case STRING: this->DoOp = Do_BinOp_str; break; case BOOLEAN: this->DoOp = Do_BinOp_log; break; case LONG: this->DoOp = Do_BinOp_lng; break; case DOUBLE: this->DoOp = Do_BinOp_dbl; break; } if( constant ) this->DoOp( this ); } return( n ); } static int New_Func( int returnType, funcOp Op, int nNodes, int Node1, int Node2, int Node3, int Node4, int Node5, int Node6, int Node7 ) { return New_FuncSize(returnType, Op, nNodes, Node1, Node2, Node3, Node4, Node5, Node6, Node7, 0); } static int New_FuncSize( int returnType, funcOp Op, int nNodes, int Node1, int Node2, int Node3, int Node4, int Node5, int Node6, int Node7, int Size ) /* If returnType==0 , use Node1's type and vector sizes as returnType, */ /* else return a single value of type returnType */ { Node *this, *that; int i,n,constant; if( Node1<0 || Node2<0 || Node3<0 || Node4<0 || Node5<0 || Node6<0 || Node7<0 ) return(-1); n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->operation = (int)Op; this->DoOp = Do_Func; this->nSubNodes = nNodes; this->SubNodes[0] = Node1; this->SubNodes[1] = Node2; this->SubNodes[2] = Node3; this->SubNodes[3] = Node4; this->SubNodes[4] = Node5; this->SubNodes[5] = Node6; this->SubNodes[6] = Node7; i = constant = nNodes; /* Functions with zero params are not const */ if (Op == poirnd_fct) constant = 0; /* Nor is Poisson deviate */ while( i-- ) constant = ( constant && OPER(this->SubNodes[i]) == CONST_OP ); if( returnType ) { this->type = returnType; this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; } else { that = gParse.Nodes + Node1; this->type = that->type; this->value.nelem = that->value.nelem; this->value.naxis = that->value.naxis; for( i=0; ivalue.naxis; i++ ) this->value.naxes[i] = that->value.naxes[i]; } /* Force explicit size before evaluating */ if (Size > 0) this->value.nelem = Size; if( constant ) this->DoOp( this ); } return( n ); } static int New_Deref( int Var, int nDim, int Dim1, int Dim2, int Dim3, int Dim4, int Dim5 ) { int n, idx, constant; long elem=0; Node *this, *theVar, *theDim[MAXDIMS]; if( Var<0 || Dim1<0 || Dim2<0 || Dim3<0 || Dim4<0 || Dim5<0 ) return(-1); theVar = gParse.Nodes + Var; if( theVar->operation==CONST_OP || theVar->value.nelem==1 ) { fferror("Cannot index a scalar value"); return(-1); } n = Alloc_Node(); if( n>=0 ) { this = gParse.Nodes + n; this->nSubNodes = nDim+1; theVar = gParse.Nodes + (this->SubNodes[0]=Var); theDim[0] = gParse.Nodes + (this->SubNodes[1]=Dim1); theDim[1] = gParse.Nodes + (this->SubNodes[2]=Dim2); theDim[2] = gParse.Nodes + (this->SubNodes[3]=Dim3); theDim[3] = gParse.Nodes + (this->SubNodes[4]=Dim4); theDim[4] = gParse.Nodes + (this->SubNodes[5]=Dim5); constant = theVar->operation==CONST_OP; for( idx=0; idxoperation==CONST_OP); for( idx=0; idxvalue.nelem>1 ) { Free_Last_Node(); fferror("Cannot use an array as an index value"); return(-1); } else if( theDim[idx]->type!=LONG ) { Free_Last_Node(); fferror("Index value must be an integer type"); return(-1); } this->operation = '['; this->DoOp = Do_Deref; this->type = theVar->type; if( theVar->value.naxis == nDim ) { /* All dimensions specified */ this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; } else if( nDim==1 ) { /* Dereference only one dimension */ elem=1; this->value.naxis = theVar->value.naxis-1; for( idx=0; idxvalue.naxis; idx++ ) { elem *= ( this->value.naxes[idx] = theVar->value.naxes[idx] ); } this->value.nelem = elem; } else { Free_Last_Node(); fferror("Must specify just one or all indices for vector"); return(-1); } if( constant ) this->DoOp( this ); } return(n); } extern int ffGetVariable( char *varName, FFSTYPE *varVal ); static int New_GTI( char *fname, int Node1, char *start, char *stop ) { fitsfile *fptr; Node *this, *that0, *that1; int type,i,n, startCol, stopCol, Node0; int hdutype, hdunum, evthdu, samefile, extvers, movetotype, tstat; char extname[100]; long nrows; double timeZeroI[2], timeZeroF[2], dt, timeSpan; char xcol[20], xexpr[20]; FFSTYPE colVal; if( Node1==-99 ) { type = ffGetVariable( "TIME", &colVal ); if( type==COLUMN ) { Node1 = New_Column( (int)colVal.lng ); } else { fferror("Could not build TIME column for GTIFILTER"); return(-1); } } Node1 = New_Unary( DOUBLE, 0, Node1 ); Node0 = Alloc_Node(); /* This will hold the START/STOP times */ if( Node1<0 || Node0<0 ) return(-1); /* Record current HDU number in case we need to move within this file */ fptr = gParse.def_fptr; ffghdn( fptr, &evthdu ); /* Look for TIMEZERO keywords in current extension */ tstat = 0; if( ffgkyd( fptr, "TIMEZERO", timeZeroI, NULL, &tstat ) ) { tstat = 0; if( ffgkyd( fptr, "TIMEZERI", timeZeroI, NULL, &tstat ) ) { timeZeroI[0] = timeZeroF[0] = 0.0; } else if( ffgkyd( fptr, "TIMEZERF", timeZeroF, NULL, &tstat ) ) { timeZeroF[0] = 0.0; } } else { timeZeroF[0] = 0.0; } /* Resolve filename parameter */ switch( fname[0] ) { case '\0': samefile = 1; hdunum = 1; break; case '[': samefile = 1; i = 1; while( fname[i] != '\0' && fname[i] != ']' ) i++; if( fname[i] ) { fname[i] = '\0'; fname++; ffexts( fname, &hdunum, extname, &extvers, &movetotype, xcol, xexpr, &gParse.status ); if( *extname ) { ffmnhd( fptr, movetotype, extname, extvers, &gParse.status ); ffghdn( fptr, &hdunum ); } else if( hdunum ) { ffmahd( fptr, ++hdunum, &hdutype, &gParse.status ); } else if( !gParse.status ) { fferror("Cannot use primary array for GTI filter"); return( -1 ); } } else { fferror("File extension specifier lacks closing ']'"); return( -1 ); } break; case '+': samefile = 1; hdunum = atoi( fname ) + 1; if( hdunum>1 ) ffmahd( fptr, hdunum, &hdutype, &gParse.status ); else { fferror("Cannot use primary array for GTI filter"); return( -1 ); } break; default: samefile = 0; if( ! ffopen( &fptr, fname, READONLY, &gParse.status ) ) ffghdn( fptr, &hdunum ); break; } if( gParse.status ) return(-1); /* If at primary, search for GTI extension */ if( hdunum==1 ) { while( 1 ) { hdunum++; if( ffmahd( fptr, hdunum, &hdutype, &gParse.status ) ) break; if( hdutype==IMAGE_HDU ) continue; tstat = 0; if( ffgkys( fptr, "EXTNAME", extname, NULL, &tstat ) ) continue; ffupch( extname ); if( strstr( extname, "GTI" ) ) break; } if( gParse.status ) { if( gParse.status==END_OF_FILE ) fferror("GTI extension not found in this file"); return(-1); } } /* Locate START/STOP Columns */ ffgcno( fptr, CASEINSEN, start, &startCol, &gParse.status ); ffgcno( fptr, CASEINSEN, stop, &stopCol, &gParse.status ); if( gParse.status ) return(-1); /* Look for TIMEZERO keywords in GTI extension */ tstat = 0; if( ffgkyd( fptr, "TIMEZERO", timeZeroI+1, NULL, &tstat ) ) { tstat = 0; if( ffgkyd( fptr, "TIMEZERI", timeZeroI+1, NULL, &tstat ) ) { timeZeroI[1] = timeZeroF[1] = 0.0; } else if( ffgkyd( fptr, "TIMEZERF", timeZeroF+1, NULL, &tstat ) ) { timeZeroF[1] = 0.0; } } else { timeZeroF[1] = 0.0; } n = Alloc_Node(); if( n >= 0 ) { this = gParse.Nodes + n; this->nSubNodes = 2; this->SubNodes[1] = Node1; this->operation = (int)gtifilt_fct; this->DoOp = Do_GTI; this->type = BOOLEAN; that1 = gParse.Nodes + Node1; this->value.nelem = that1->value.nelem; this->value.naxis = that1->value.naxis; for( i=0; i < that1->value.naxis; i++ ) this->value.naxes[i] = that1->value.naxes[i]; /* Init START/STOP node to be treated as a "constant" */ this->SubNodes[0] = Node0; that0 = gParse.Nodes + Node0; that0->operation = CONST_OP; that0->DoOp = NULL; that0->value.data.ptr= NULL; /* Read in START/STOP times */ if( ffgkyj( fptr, "NAXIS2", &nrows, NULL, &gParse.status ) ) return(-1); that0->value.nelem = nrows; if( nrows ) { that0->value.data.dblptr = (double*)malloc( 2*nrows*sizeof(double) ); if( !that0->value.data.dblptr ) { gParse.status = MEMORY_ALLOCATION; return(-1); } ffgcvd( fptr, startCol, 1L, 1L, nrows, 0.0, that0->value.data.dblptr, &i, &gParse.status ); ffgcvd( fptr, stopCol, 1L, 1L, nrows, 0.0, that0->value.data.dblptr+nrows, &i, &gParse.status ); if( gParse.status ) { free( that0->value.data.dblptr ); return(-1); } /* Test for fully time-ordered GTI... both START && STOP */ that0->type = 1; /* Assume yes */ i = nrows; while( --i ) if( that0->value.data.dblptr[i-1] >= that0->value.data.dblptr[i] || that0->value.data.dblptr[i-1+nrows] >= that0->value.data.dblptr[i+nrows] ) { that0->type = 0; break; } /* Handle TIMEZERO offset, if any */ dt = (timeZeroI[1] - timeZeroI[0]) + (timeZeroF[1] - timeZeroF[0]); timeSpan = that0->value.data.dblptr[nrows+nrows-1] - that0->value.data.dblptr[0]; if( fabs( dt / timeSpan ) > 1e-12 ) { for( i=0; i<(nrows+nrows); i++ ) that0->value.data.dblptr[i] += dt; } } if( OPER(Node1)==CONST_OP ) this->DoOp( this ); } if( samefile ) ffmahd( fptr, evthdu, &hdutype, &gParse.status ); else ffclos( fptr, &gParse.status ); return( n ); } static int New_REG( char *fname, int NodeX, int NodeY, char *colNames ) { Node *this, *that0; int type, n, Node0; int Xcol, Ycol, tstat; WCSdata wcs; SAORegion *Rgn; char *cX, *cY; FFSTYPE colVal; if( NodeX==-99 ) { type = ffGetVariable( "X", &colVal ); if( type==COLUMN ) { NodeX = New_Column( (int)colVal.lng ); } else { fferror("Could not build X column for REGFILTER"); return(-1); } } if( NodeY==-99 ) { type = ffGetVariable( "Y", &colVal ); if( type==COLUMN ) { NodeY = New_Column( (int)colVal.lng ); } else { fferror("Could not build Y column for REGFILTER"); return(-1); } } NodeX = New_Unary( DOUBLE, 0, NodeX ); NodeY = New_Unary( DOUBLE, 0, NodeY ); Node0 = Alloc_Node(); /* This will hold the Region Data */ if( NodeX<0 || NodeY<0 || Node0<0 ) return(-1); if( ! (Test_Dims( NodeX, NodeY ) ) ) { fferror("Dimensions of REGFILTER arguments are not compatible"); return (-1); } n = Alloc_Node(); if( n >= 0 ) { this = gParse.Nodes + n; this->nSubNodes = 3; this->SubNodes[0] = Node0; this->SubNodes[1] = NodeX; this->SubNodes[2] = NodeY; this->operation = (int)regfilt_fct; this->DoOp = Do_REG; this->type = BOOLEAN; this->value.nelem = 1; this->value.naxis = 1; this->value.naxes[0] = 1; Copy_Dims(n, NodeX); if( SIZE(NodeX)operation = CONST_OP; that0->DoOp = NULL; /* Identify what columns to use for WCS information */ Xcol = Ycol = 0; if( *colNames ) { /* Use the column names in this string for WCS info */ while( *colNames==' ' ) colNames++; cX = cY = colNames; while( *cY && *cY!=' ' && *cY!=',' ) cY++; if( *cY ) *(cY++) = '\0'; while( *cY==' ' ) cY++; if( !*cY ) { fferror("Could not extract valid pair of column names from REGFILTER"); Free_Last_Node(); return( -1 ); } fits_get_colnum( gParse.def_fptr, CASEINSEN, cX, &Xcol, &gParse.status ); fits_get_colnum( gParse.def_fptr, CASEINSEN, cY, &Ycol, &gParse.status ); if( gParse.status ) { fferror("Could not locate columns indicated for WCS info"); Free_Last_Node(); return( -1 ); } } else { /* Try to find columns used in X/Y expressions */ Xcol = Locate_Col( gParse.Nodes + NodeX ); Ycol = Locate_Col( gParse.Nodes + NodeY ); if( Xcol<0 || Ycol<0 ) { fferror("Found multiple X/Y column references in REGFILTER"); Free_Last_Node(); return( -1 ); } } /* Now, get the WCS info, if it exists, from the indicated columns */ wcs.exists = 0; if( Xcol>0 && Ycol>0 ) { tstat = 0; ffgtcs( gParse.def_fptr, Xcol, Ycol, &wcs.xrefval, &wcs.yrefval, &wcs.xrefpix, &wcs.yrefpix, &wcs.xinc, &wcs.yinc, &wcs.rot, wcs.type, &tstat ); if( tstat==NO_WCS_KEY ) { wcs.exists = 0; } else if( tstat ) { gParse.status = tstat; Free_Last_Node(); return( -1 ); } else { wcs.exists = 1; } } /* Read in Region file */ fits_read_rgnfile( fname, &wcs, &Rgn, &gParse.status ); if( gParse.status ) { Free_Last_Node(); return( -1 ); } that0->value.data.ptr = Rgn; if( OPER(NodeX)==CONST_OP && OPER(NodeY)==CONST_OP ) this->DoOp( this ); } return( n ); } static int New_Vector( int subNode ) { Node *this, *that; int n; n = Alloc_Node(); if( n >= 0 ) { this = gParse.Nodes + n; that = gParse.Nodes + subNode; this->type = that->type; this->nSubNodes = 1; this->SubNodes[0] = subNode; this->operation = '{'; this->DoOp = Do_Vector; } return( n ); } static int Close_Vec( int vecNode ) { Node *this; int n, nelem=0; this = gParse.Nodes + vecNode; for( n=0; n < this->nSubNodes; n++ ) { if( TYPE( this->SubNodes[n] ) != this->type ) { this->SubNodes[n] = New_Unary( this->type, 0, this->SubNodes[n] ); if( this->SubNodes[n]<0 ) return(-1); } nelem += SIZE(this->SubNodes[n]); } this->value.naxis = 1; this->value.nelem = nelem; this->value.naxes[0] = nelem; return( vecNode ); } static int Locate_Col( Node *this ) /* Locate the TABLE column number of any columns in "this" calculation. */ /* Return ZERO if none found, or negative if more than 1 found. */ { Node *that; int i, col=0, newCol, nfound=0; if( this->nSubNodes==0 && this->operation<=0 && this->operation!=CONST_OP ) return gParse.colData[ - this->operation].colnum; for( i=0; inSubNodes; i++ ) { that = gParse.Nodes + this->SubNodes[i]; if( that->operation>0 ) { newCol = Locate_Col( that ); if( newCol<=0 ) { nfound += -newCol; } else { if( !nfound ) { col = newCol; nfound++; } else if( col != newCol ) { nfound++; } } } else if( that->operation!=CONST_OP ) { /* Found a Column */ newCol = gParse.colData[- that->operation].colnum; if( !nfound ) { col = newCol; nfound++; } else if( col != newCol ) { nfound++; } } } if( nfound!=1 ) return( - nfound ); else return( col ); } static int Test_Dims( int Node1, int Node2 ) { Node *that1, *that2; int valid, i; if( Node1<0 || Node2<0 ) return(0); that1 = gParse.Nodes + Node1; that2 = gParse.Nodes + Node2; if( that1->value.nelem==1 || that2->value.nelem==1 ) valid = 1; else if( that1->type==that2->type && that1->value.nelem==that2->value.nelem && that1->value.naxis==that2->value.naxis ) { valid = 1; for( i=0; ivalue.naxis; i++ ) { if( that1->value.naxes[i]!=that2->value.naxes[i] ) valid = 0; } } else valid = 0; return( valid ); } static void Copy_Dims( int Node1, int Node2 ) { Node *that1, *that2; int i; if( Node1<0 || Node2<0 ) return; that1 = gParse.Nodes + Node1; that2 = gParse.Nodes + Node2; that1->value.nelem = that2->value.nelem; that1->value.naxis = that2->value.naxis; for( i=0; ivalue.naxis; i++ ) that1->value.naxes[i] = that2->value.naxes[i]; } /********************************************************************/ /* Routines for actually evaluating the expression start here */ /********************************************************************/ void Evaluate_Parser( long firstRow, long nRows ) /***********************************************************************/ /* Reset the parser for processing another batch of data... */ /* firstRow: Row number of the first element to evaluate */ /* nRows: Number of rows to be processed */ /* Initialize each COLUMN node so that its UNDEF and DATA pointers */ /* point to the appropriate column arrays. */ /* Finally, call Evaluate_Node for final node. */ /***********************************************************************/ { int i, column; long offset, rowOffset; gParse.firstRow = firstRow; gParse.nRows = nRows; /* Reset Column Nodes' pointers to point to right data and UNDEF arrays */ rowOffset = firstRow - gParse.firstDataRow; for( i=0; i 0 || OPER(i) == CONST_OP ) continue; column = -OPER(i); offset = gParse.varData[column].nelem * rowOffset; gParse.Nodes[i].value.undef = gParse.varData[column].undef + offset; switch( gParse.Nodes[i].type ) { case BITSTR: gParse.Nodes[i].value.data.strptr = (char**)gParse.varData[column].data + rowOffset; gParse.Nodes[i].value.undef = NULL; break; case STRING: gParse.Nodes[i].value.data.strptr = (char**)gParse.varData[column].data + rowOffset; gParse.Nodes[i].value.undef = gParse.varData[column].undef + rowOffset; break; case BOOLEAN: gParse.Nodes[i].value.data.logptr = (char*)gParse.varData[column].data + offset; break; case LONG: gParse.Nodes[i].value.data.lngptr = (long*)gParse.varData[column].data + offset; break; case DOUBLE: gParse.Nodes[i].value.data.dblptr = (double*)gParse.varData[column].data + offset; break; } } Evaluate_Node( gParse.resultNode ); } static void Evaluate_Node( int thisNode ) /**********************************************************************/ /* Recursively evaluate thisNode's subNodes, then call one of the */ /* Do_ functions pointed to by thisNode's DoOp element. */ /**********************************************************************/ { Node *this; int i; if( gParse.status ) return; this = gParse.Nodes + thisNode; if( this->operation>0 ) { /* <=0 indicate constants and columns */ i = this->nSubNodes; while( i-- ) { Evaluate_Node( this->SubNodes[i] ); if( gParse.status ) return; } this->DoOp( this ); } } static void Allocate_Ptrs( Node *this ) { long elem, row, size; if( this->type==BITSTR || this->type==STRING ) { this->value.data.strptr = (char**)malloc( gParse.nRows * sizeof(char*) ); if( this->value.data.strptr ) { this->value.data.strptr[0] = (char*)malloc( gParse.nRows * (this->value.nelem+2) * sizeof(char) ); if( this->value.data.strptr[0] ) { row = 0; while( (++row)value.data.strptr[row] = this->value.data.strptr[row-1] + this->value.nelem+1; } if( this->type==STRING ) { this->value.undef = this->value.data.strptr[row-1] + this->value.nelem+1; } else { this->value.undef = NULL; /* BITSTRs don't use undef array */ } } else { gParse.status = MEMORY_ALLOCATION; free( this->value.data.strptr ); } } else { gParse.status = MEMORY_ALLOCATION; } } else { elem = this->value.nelem * gParse.nRows; switch( this->type ) { case DOUBLE: size = sizeof( double ); break; case LONG: size = sizeof( long ); break; case BOOLEAN: size = sizeof( char ); break; default: size = 1; break; } this->value.data.ptr = calloc(size+1, elem); if( this->value.data.ptr==NULL ) { gParse.status = MEMORY_ALLOCATION; } else { this->value.undef = (char *)this->value.data.ptr + elem*size; } } } static void Do_Unary( Node *this ) { Node *that; long elem; that = gParse.Nodes + this->SubNodes[0]; if( that->operation==CONST_OP ) { /* Operating on a constant! */ switch( this->operation ) { case DOUBLE: case FLTCAST: if( that->type==LONG ) this->value.data.dbl = (double)that->value.data.lng; else if( that->type==BOOLEAN ) this->value.data.dbl = ( that->value.data.log ? 1.0 : 0.0 ); break; case LONG: case INTCAST: if( that->type==DOUBLE ) this->value.data.lng = (long)that->value.data.dbl; else if( that->type==BOOLEAN ) this->value.data.lng = ( that->value.data.log ? 1L : 0L ); break; case BOOLEAN: if( that->type==DOUBLE ) this->value.data.log = ( that->value.data.dbl != 0.0 ); else if( that->type==LONG ) this->value.data.log = ( that->value.data.lng != 0L ); break; case UMINUS: if( that->type==DOUBLE ) this->value.data.dbl = - that->value.data.dbl; else if( that->type==LONG ) this->value.data.lng = - that->value.data.lng; break; case NOT: if( that->type==BOOLEAN ) this->value.data.log = ( ! that->value.data.log ); else if( that->type==BITSTR ) bitnot( this->value.data.str, that->value.data.str ); break; } this->operation = CONST_OP; } else { Allocate_Ptrs( this ); if( !gParse.status ) { if( this->type!=BITSTR ) { elem = gParse.nRows; if( this->type!=STRING ) elem *= this->value.nelem; while( elem-- ) this->value.undef[elem] = that->value.undef[elem]; } elem = gParse.nRows * this->value.nelem; switch( this->operation ) { case BOOLEAN: if( that->type==DOUBLE ) while( elem-- ) this->value.data.logptr[elem] = ( that->value.data.dblptr[elem] != 0.0 ); else if( that->type==LONG ) while( elem-- ) this->value.data.logptr[elem] = ( that->value.data.lngptr[elem] != 0L ); break; case DOUBLE: case FLTCAST: if( that->type==LONG ) while( elem-- ) this->value.data.dblptr[elem] = (double)that->value.data.lngptr[elem]; else if( that->type==BOOLEAN ) while( elem-- ) this->value.data.dblptr[elem] = ( that->value.data.logptr[elem] ? 1.0 : 0.0 ); break; case LONG: case INTCAST: if( that->type==DOUBLE ) while( elem-- ) this->value.data.lngptr[elem] = (long)that->value.data.dblptr[elem]; else if( that->type==BOOLEAN ) while( elem-- ) this->value.data.lngptr[elem] = ( that->value.data.logptr[elem] ? 1L : 0L ); break; case UMINUS: if( that->type==DOUBLE ) { while( elem-- ) this->value.data.dblptr[elem] = - that->value.data.dblptr[elem]; } else if( that->type==LONG ) { while( elem-- ) this->value.data.lngptr[elem] = - that->value.data.lngptr[elem]; } break; case NOT: if( that->type==BOOLEAN ) { while( elem-- ) this->value.data.logptr[elem] = ( ! that->value.data.logptr[elem] ); } else if( that->type==BITSTR ) { elem = gParse.nRows; while( elem-- ) bitnot( this->value.data.strptr[elem], that->value.data.strptr[elem] ); } break; } } } if( that->operation>0 ) { free( that->value.data.ptr ); } } static void Do_Offset( Node *this ) { Node *col; long fRow, nRowOverlap, nRowReload, rowOffset; long nelem, elem, offset, nRealElem; int status; col = gParse.Nodes + this->SubNodes[0]; rowOffset = gParse.Nodes[ this->SubNodes[1] ].value.data.lng; Allocate_Ptrs( this ); fRow = gParse.firstRow + rowOffset; if( this->type==STRING || this->type==BITSTR ) nRealElem = 1; else nRealElem = this->value.nelem; nelem = nRealElem; if( fRow < gParse.firstDataRow ) { /* Must fill in data at start of array */ nRowReload = gParse.firstDataRow - fRow; if( nRowReload > gParse.nRows ) nRowReload = gParse.nRows; nRowOverlap = gParse.nRows - nRowReload; offset = 0; /* NULLify any values falling out of bounds */ while( fRow<1 && nRowReload>0 ) { if( this->type == BITSTR ) { nelem = this->value.nelem; this->value.data.strptr[offset][ nelem ] = '\0'; while( nelem-- ) this->value.data.strptr[offset][nelem] = '0'; offset++; } else { while( nelem-- ) this->value.undef[offset++] = 1; } nelem = nRealElem; fRow++; nRowReload--; } } else if( fRow + gParse.nRows > gParse.firstDataRow + gParse.nDataRows ) { /* Must fill in data at end of array */ nRowReload = (fRow+gParse.nRows) - (gParse.firstDataRow+gParse.nDataRows); if( nRowReload>gParse.nRows ) { nRowReload = gParse.nRows; } else { fRow = gParse.firstDataRow + gParse.nDataRows; } nRowOverlap = gParse.nRows - nRowReload; offset = nRowOverlap * nelem; /* NULLify any values falling out of bounds */ elem = gParse.nRows * nelem; while( fRow+nRowReload>gParse.totalRows && nRowReload>0 ) { if( this->type == BITSTR ) { nelem = this->value.nelem; elem--; this->value.data.strptr[elem][ nelem ] = '\0'; while( nelem-- ) this->value.data.strptr[elem][nelem] = '0'; } else { while( nelem-- ) this->value.undef[--elem] = 1; } nelem = nRealElem; nRowReload--; } } else { nRowReload = 0; nRowOverlap = gParse.nRows; offset = 0; } if( nRowReload>0 ) { switch( this->type ) { case BITSTR: case STRING: status = (*gParse.loadData)( -col->operation, fRow, nRowReload, this->value.data.strptr+offset, this->value.undef+offset ); break; case BOOLEAN: status = (*gParse.loadData)( -col->operation, fRow, nRowReload, this->value.data.logptr+offset, this->value.undef+offset ); break; case LONG: status = (*gParse.loadData)( -col->operation, fRow, nRowReload, this->value.data.lngptr+offset, this->value.undef+offset ); break; case DOUBLE: status = (*gParse.loadData)( -col->operation, fRow, nRowReload, this->value.data.dblptr+offset, this->value.undef+offset ); break; } } /* Now copy over the overlapping region, if any */ if( nRowOverlap <= 0 ) return; if( rowOffset>0 ) elem = nRowOverlap * nelem; else elem = gParse.nRows * nelem; offset = nelem * rowOffset; while( nRowOverlap-- && !gParse.status ) { while( nelem-- && !gParse.status ) { elem--; if( this->type != BITSTR ) this->value.undef[elem] = col->value.undef[elem+offset]; switch( this->type ) { case BITSTR: strcpy( this->value.data.strptr[elem ], col->value.data.strptr[elem+offset] ); break; case STRING: strcpy( this->value.data.strptr[elem ], col->value.data.strptr[elem+offset] ); break; case BOOLEAN: this->value.data.logptr[elem] = col->value.data.logptr[elem+offset]; break; case LONG: this->value.data.lngptr[elem] = col->value.data.lngptr[elem+offset]; break; case DOUBLE: this->value.data.dblptr[elem] = col->value.data.dblptr[elem+offset]; break; } } nelem = nRealElem; } } static void Do_BinOp_bit( Node *this ) { Node *that1, *that2; char *sptr1=NULL, *sptr2=NULL; int const1, const2; long rows; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; const1 = ( that1->operation==CONST_OP ); const2 = ( that2->operation==CONST_OP ); sptr1 = ( const1 ? that1->value.data.str : NULL ); sptr2 = ( const2 ? that2->value.data.str : NULL ); if( const1 && const2 ) { switch( this->operation ) { case NE: this->value.data.log = !bitcmp( sptr1, sptr2 ); break; case EQ: this->value.data.log = bitcmp( sptr1, sptr2 ); break; case GT: case LT: case LTE: case GTE: this->value.data.log = bitlgte( sptr1, this->operation, sptr2 ); break; case '|': bitor( this->value.data.str, sptr1, sptr2 ); break; case '&': bitand( this->value.data.str, sptr1, sptr2 ); break; case '+': strcpy( this->value.data.str, sptr1 ); strcat( this->value.data.str, sptr2 ); break; case ACCUM: this->value.data.lng = 0; while( *sptr1 ) { if ( *sptr1 == '1' ) this->value.data.lng ++; sptr1 ++; } break; } this->operation = CONST_OP; } else { Allocate_Ptrs( this ); if( !gParse.status ) { rows = gParse.nRows; switch( this->operation ) { /* BITSTR comparisons */ case NE: case EQ: case GT: case LT: case LTE: case GTE: while( rows-- ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; switch( this->operation ) { case NE: this->value.data.logptr[rows] = !bitcmp( sptr1, sptr2 ); break; case EQ: this->value.data.logptr[rows] = bitcmp( sptr1, sptr2 ); break; case GT: case LT: case LTE: case GTE: this->value.data.logptr[rows] = bitlgte( sptr1, this->operation, sptr2 ); break; } this->value.undef[rows] = 0; } break; /* BITSTR AND/ORs ... no UNDEFS in or out */ case '|': case '&': case '+': while( rows-- ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; if( this->operation=='|' ) bitor( this->value.data.strptr[rows], sptr1, sptr2 ); else if( this->operation=='&' ) bitand( this->value.data.strptr[rows], sptr1, sptr2 ); else { strcpy( this->value.data.strptr[rows], sptr1 ); strcat( this->value.data.strptr[rows], sptr2 ); } } break; /* Accumulate 1 bits */ case ACCUM: { long i, previous, curr; previous = that2->value.data.lng; /* Cumulative sum of this chunk */ for (i=0; ivalue.data.strptr[i]; for (curr = 0; *sptr1; sptr1 ++) { if ( *sptr1 == '1' ) curr ++; } previous += curr; this->value.data.lngptr[i] = previous; this->value.undef[i] = 0; } /* Store final cumulant for next pass */ that2->value.data.lng = previous; } } } } if( that1->operation>0 ) { free( that1->value.data.strptr[0] ); free( that1->value.data.strptr ); } if( that2->operation>0 ) { free( that2->value.data.strptr[0] ); free( that2->value.data.strptr ); } } static void Do_BinOp_str( Node *this ) { Node *that1, *that2; char *sptr1, *sptr2, null1=0, null2=0; int const1, const2, val; long rows; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; const1 = ( that1->operation==CONST_OP ); const2 = ( that2->operation==CONST_OP ); sptr1 = ( const1 ? that1->value.data.str : NULL ); sptr2 = ( const2 ? that2->value.data.str : NULL ); if( const1 && const2 ) { /* Result is a constant */ switch( this->operation ) { /* Compare Strings */ case NE: case EQ: val = ( FSTRCMP( sptr1, sptr2 ) == 0 ); this->value.data.log = ( this->operation==EQ ? val : !val ); break; case GT: this->value.data.log = ( FSTRCMP( sptr1, sptr2 ) > 0 ); break; case LT: this->value.data.log = ( FSTRCMP( sptr1, sptr2 ) < 0 ); break; case GTE: this->value.data.log = ( FSTRCMP( sptr1, sptr2 ) >= 0 ); break; case LTE: this->value.data.log = ( FSTRCMP( sptr1, sptr2 ) <= 0 ); break; /* Concat Strings */ case '+': strcpy( this->value.data.str, sptr1 ); strcat( this->value.data.str, sptr2 ); break; } this->operation = CONST_OP; } else { /* Not a constant */ Allocate_Ptrs( this ); if( !gParse.status ) { rows = gParse.nRows; switch( this->operation ) { /* Compare Strings */ case NE: case EQ: while( rows-- ) { if( !const1 ) null1 = that1->value.undef[rows]; if( !const2 ) null2 = that2->value.undef[rows]; this->value.undef[rows] = (null1 || null2); if( ! this->value.undef[rows] ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; val = ( FSTRCMP( sptr1, sptr2 ) == 0 ); this->value.data.logptr[rows] = ( this->operation==EQ ? val : !val ); } } break; case GT: case LT: while( rows-- ) { if( !const1 ) null1 = that1->value.undef[rows]; if( !const2 ) null2 = that2->value.undef[rows]; this->value.undef[rows] = (null1 || null2); if( ! this->value.undef[rows] ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; val = ( FSTRCMP( sptr1, sptr2 ) ); this->value.data.logptr[rows] = ( this->operation==GT ? val>0 : val<0 ); } } break; case GTE: case LTE: while( rows-- ) { if( !const1 ) null1 = that1->value.undef[rows]; if( !const2 ) null2 = that2->value.undef[rows]; this->value.undef[rows] = (null1 || null2); if( ! this->value.undef[rows] ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; val = ( FSTRCMP( sptr1, sptr2 ) ); this->value.data.logptr[rows] = ( this->operation==GTE ? val>=0 : val<=0 ); } } break; /* Concat Strings */ case '+': while( rows-- ) { if( !const1 ) null1 = that1->value.undef[rows]; if( !const2 ) null2 = that2->value.undef[rows]; this->value.undef[rows] = (null1 || null2); if( ! this->value.undef[rows] ) { if( !const1 ) sptr1 = that1->value.data.strptr[rows]; if( !const2 ) sptr2 = that2->value.data.strptr[rows]; strcpy( this->value.data.strptr[rows], sptr1 ); strcat( this->value.data.strptr[rows], sptr2 ); } } break; } } } if( that1->operation>0 ) { free( that1->value.data.strptr[0] ); free( that1->value.data.strptr ); } if( that2->operation>0 ) { free( that2->value.data.strptr[0] ); free( that2->value.data.strptr ); } } static void Do_BinOp_log( Node *this ) { Node *that1, *that2; int vector1, vector2; char val1=0, val2=0, null1=0, null2=0; long rows, nelem, elem; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; vector1 = ( that1->operation!=CONST_OP ); if( vector1 ) vector1 = that1->value.nelem; else { val1 = that1->value.data.log; } vector2 = ( that2->operation!=CONST_OP ); if( vector2 ) vector2 = that2->value.nelem; else { val2 = that2->value.data.log; } if( !vector1 && !vector2 ) { /* Result is a constant */ switch( this->operation ) { case OR: this->value.data.log = (val1 || val2); break; case AND: this->value.data.log = (val1 && val2); break; case EQ: this->value.data.log = ( (val1 && val2) || (!val1 && !val2) ); break; case NE: this->value.data.log = ( (val1 && !val2) || (!val1 && val2) ); break; case ACCUM: this->value.data.lng = val1; break; } this->operation=CONST_OP; } else if (this->operation == ACCUM) { long i, previous, curr; rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); if( !gParse.status ) { previous = that2->value.data.lng; /* Cumulative sum of this chunk */ for (i=0; ivalue.undef[i]) { curr = that1->value.data.logptr[i]; previous += curr; } this->value.data.lngptr[i] = previous; this->value.undef[i] = 0; } /* Store final cumulant for next pass */ that2->value.data.lng = previous; } } else { rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); if( !gParse.status ) { if (this->operation == ACCUM) { long i, previous, curr; previous = that2->value.data.lng; /* Cumulative sum of this chunk */ for (i=0; ivalue.undef[i]) { curr = that1->value.data.logptr[i]; previous += curr; } this->value.data.lngptr[i] = previous; this->value.undef[i] = 0; } /* Store final cumulant for next pass */ that2->value.data.lng = previous; } while( rows-- ) { while( nelem-- ) { elem--; if( vector1>1 ) { val1 = that1->value.data.logptr[elem]; null1 = that1->value.undef[elem]; } else if( vector1 ) { val1 = that1->value.data.logptr[rows]; null1 = that1->value.undef[rows]; } if( vector2>1 ) { val2 = that2->value.data.logptr[elem]; null2 = that2->value.undef[elem]; } else if( vector2 ) { val2 = that2->value.data.logptr[rows]; null2 = that2->value.undef[rows]; } this->value.undef[elem] = (null1 || null2); switch( this->operation ) { case OR: /* This is more complicated than others to suppress UNDEFs */ /* in those cases where the other argument is DEF && TRUE */ if( !null1 && !null2 ) { this->value.data.logptr[elem] = (val1 || val2); } else if( (null1 && !null2 && val2) || ( !null1 && null2 && val1 ) ) { this->value.data.logptr[elem] = 1; this->value.undef[elem] = 0; } break; case AND: /* This is more complicated than others to suppress UNDEFs */ /* in those cases where the other argument is DEF && FALSE */ if( !null1 && !null2 ) { this->value.data.logptr[elem] = (val1 && val2); } else if( (null1 && !null2 && !val2) || ( !null1 && null2 && !val1 ) ) { this->value.data.logptr[elem] = 0; this->value.undef[elem] = 0; } break; case EQ: this->value.data.logptr[elem] = ( (val1 && val2) || (!val1 && !val2) ); break; case NE: this->value.data.logptr[elem] = ( (val1 && !val2) || (!val1 && val2) ); break; } } nelem = this->value.nelem; } } } if( that1->operation>0 ) { free( that1->value.data.ptr ); } if( that2->operation>0 ) { free( that2->value.data.ptr ); } } static void Do_BinOp_lng( Node *this ) { Node *that1, *that2; int vector1, vector2; long val1=0, val2=0; char null1=0, null2=0; long rows, nelem, elem; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; vector1 = ( that1->operation!=CONST_OP ); if( vector1 ) vector1 = that1->value.nelem; else { val1 = that1->value.data.lng; } vector2 = ( that2->operation!=CONST_OP ); if( vector2 ) vector2 = that2->value.nelem; else { val2 = that2->value.data.lng; } if( !vector1 && !vector2 ) { /* Result is a constant */ switch( this->operation ) { case '~': /* Treat as == for LONGS */ case EQ: this->value.data.log = (val1 == val2); break; case NE: this->value.data.log = (val1 != val2); break; case GT: this->value.data.log = (val1 > val2); break; case LT: this->value.data.log = (val1 < val2); break; case LTE: this->value.data.log = (val1 <= val2); break; case GTE: this->value.data.log = (val1 >= val2); break; case '+': this->value.data.lng = (val1 + val2); break; case '-': this->value.data.lng = (val1 - val2); break; case '*': this->value.data.lng = (val1 * val2); break; case '%': if( val2 ) this->value.data.lng = (val1 % val2); else fferror("Divide by Zero"); break; case '/': if( val2 ) this->value.data.lng = (val1 / val2); else fferror("Divide by Zero"); break; case POWER: this->value.data.lng = (long)pow((double)val1,(double)val2); break; case ACCUM: this->value.data.lng = val1; break; case DIFF: this->value.data.lng = 0; break; } this->operation=CONST_OP; } else if ((this->operation == ACCUM) || (this->operation == DIFF)) { long i, previous, curr; long undef; rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); if( !gParse.status ) { previous = that2->value.data.lng; undef = (long) that2->value.undef; if (this->operation == ACCUM) { /* Cumulative sum of this chunk */ for (i=0; ivalue.undef[i]) { curr = that1->value.data.lngptr[i]; previous += curr; } this->value.data.lngptr[i] = previous; this->value.undef[i] = 0; } } else { /* Sequential difference for this chunk */ for (i=0; ivalue.data.lngptr[i]; if (that1->value.undef[i] || undef) { /* Either this, or previous, value was undefined */ this->value.data.lngptr[i] = 0; this->value.undef[i] = 1; } else { /* Both defined, we are okay! */ this->value.data.lngptr[i] = curr - previous; this->value.undef[i] = 0; } previous = curr; undef = that1->value.undef[i]; } } /* Store final cumulant for next pass */ that2->value.data.lng = previous; that2->value.undef = (char *) undef; /* XXX evil, but no harm here */ } } else { rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); while( rows-- && !gParse.status ) { while( nelem-- && !gParse.status ) { elem--; if( vector1>1 ) { val1 = that1->value.data.lngptr[elem]; null1 = that1->value.undef[elem]; } else if( vector1 ) { val1 = that1->value.data.lngptr[rows]; null1 = that1->value.undef[rows]; } if( vector2>1 ) { val2 = that2->value.data.lngptr[elem]; null2 = that2->value.undef[elem]; } else if( vector2 ) { val2 = that2->value.data.lngptr[rows]; null2 = that2->value.undef[rows]; } this->value.undef[elem] = (null1 || null2); switch( this->operation ) { case '~': /* Treat as == for LONGS */ case EQ: this->value.data.logptr[elem] = (val1 == val2); break; case NE: this->value.data.logptr[elem] = (val1 != val2); break; case GT: this->value.data.logptr[elem] = (val1 > val2); break; case LT: this->value.data.logptr[elem] = (val1 < val2); break; case LTE: this->value.data.logptr[elem] = (val1 <= val2); break; case GTE: this->value.data.logptr[elem] = (val1 >= val2); break; case '+': this->value.data.lngptr[elem] = (val1 + val2); break; case '-': this->value.data.lngptr[elem] = (val1 - val2); break; case '*': this->value.data.lngptr[elem] = (val1 * val2); break; case '%': if( val2 ) this->value.data.lngptr[elem] = (val1 % val2); else { this->value.data.lngptr[elem] = 0; this->value.undef[elem] = 1; } break; case '/': if( val2 ) this->value.data.lngptr[elem] = (val1 / val2); else { this->value.data.lngptr[elem] = 0; this->value.undef[elem] = 1; } break; case POWER: this->value.data.lngptr[elem] = (long)pow((double)val1,(double)val2); break; } } nelem = this->value.nelem; } } if( that1->operation>0 ) { free( that1->value.data.ptr ); } if( that2->operation>0 ) { free( that2->value.data.ptr ); } } static void Do_BinOp_dbl( Node *this ) { Node *that1, *that2; int vector1, vector2; double val1=0.0, val2=0.0; char null1=0, null2=0; long rows, nelem, elem; that1 = gParse.Nodes + this->SubNodes[0]; that2 = gParse.Nodes + this->SubNodes[1]; vector1 = ( that1->operation!=CONST_OP ); if( vector1 ) vector1 = that1->value.nelem; else { val1 = that1->value.data.dbl; } vector2 = ( that2->operation!=CONST_OP ); if( vector2 ) vector2 = that2->value.nelem; else { val2 = that2->value.data.dbl; } if( !vector1 && !vector2 ) { /* Result is a constant */ switch( this->operation ) { case '~': this->value.data.log = ( fabs(val1-val2) < APPROX ); break; case EQ: this->value.data.log = (val1 == val2); break; case NE: this->value.data.log = (val1 != val2); break; case GT: this->value.data.log = (val1 > val2); break; case LT: this->value.data.log = (val1 < val2); break; case LTE: this->value.data.log = (val1 <= val2); break; case GTE: this->value.data.log = (val1 >= val2); break; case '+': this->value.data.dbl = (val1 + val2); break; case '-': this->value.data.dbl = (val1 - val2); break; case '*': this->value.data.dbl = (val1 * val2); break; case '%': if( val2 ) this->value.data.dbl = val1 - val2*((int)(val1/val2)); else fferror("Divide by Zero"); break; case '/': if( val2 ) this->value.data.dbl = (val1 / val2); else fferror("Divide by Zero"); break; case POWER: this->value.data.dbl = (double)pow(val1,val2); break; case ACCUM: this->value.data.dbl = val1; break; case DIFF: this->value.data.dbl = 0; break; } this->operation=CONST_OP; } else if ((this->operation == ACCUM) || (this->operation == DIFF)) { long i; long undef; double previous, curr; rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); if( !gParse.status ) { previous = that2->value.data.dbl; undef = (long) that2->value.undef; if (this->operation == ACCUM) { /* Cumulative sum of this chunk */ for (i=0; ivalue.undef[i]) { curr = that1->value.data.dblptr[i]; previous += curr; } this->value.data.dblptr[i] = previous; this->value.undef[i] = 0; } } else { /* Sequential difference for this chunk */ for (i=0; ivalue.data.dblptr[i]; if (that1->value.undef[i] || undef) { /* Either this, or previous, value was undefined */ this->value.data.dblptr[i] = 0; this->value.undef[i] = 1; } else { /* Both defined, we are okay! */ this->value.data.dblptr[i] = curr - previous; this->value.undef[i] = 0; } previous = curr; undef = that1->value.undef[i]; } } /* Store final cumulant for next pass */ that2->value.data.dbl = previous; that2->value.undef = (char *) undef; /* XXX evil, but no harm here */ } } else { rows = gParse.nRows; nelem = this->value.nelem; elem = this->value.nelem * rows; Allocate_Ptrs( this ); while( rows-- && !gParse.status ) { while( nelem-- && !gParse.status ) { elem--; if( vector1>1 ) { val1 = that1->value.data.dblptr[elem]; null1 = that1->value.undef[elem]; } else if( vector1 ) { val1 = that1->value.data.dblptr[rows]; null1 = that1->value.undef[rows]; } if( vector2>1 ) { val2 = that2->value.data.dblptr[elem]; null2 = that2->value.undef[elem]; } else if( vector2 ) { val2 = that2->value.data.dblptr[rows]; null2 = that2->value.undef[rows]; } this->value.undef[elem] = (null1 || null2); switch( this->operation ) { case '~': this->value.data.logptr[elem] = ( fabs(val1-val2) < APPROX ); break; case EQ: this->value.data.logptr[elem] = (val1 == val2); break; case NE: this->value.data.logptr[elem] = (val1 != val2); break; case GT: this->value.data.logptr[elem] = (val1 > val2); break; case LT: this->value.data.logptr[elem] = (val1 < val2); break; case LTE: this->value.data.logptr[elem] = (val1 <= val2); break; case GTE: this->value.data.logptr[elem] = (val1 >= val2); break; case '+': this->value.data.dblptr[elem] = (val1 + val2); break; case '-': this->value.data.dblptr[elem] = (val1 - val2); break; case '*': this->value.data.dblptr[elem] = (val1 * val2); break; case '%': if( val2 ) this->value.data.dblptr[elem] = val1 - val2*((int)(val1/val2)); else { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } break; case '/': if( val2 ) this->value.data.dblptr[elem] = (val1 / val2); else { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } break; case POWER: this->value.data.dblptr[elem] = (double)pow(val1,val2); break; } } nelem = this->value.nelem; } } if( that1->operation>0 ) { free( that1->value.data.ptr ); } if( that2->operation>0 ) { free( that2->value.data.ptr ); } } /* * This Quickselect routine is based on the algorithm described in * "Numerical recipes in C", Second Edition, * Cambridge University Press, 1992, Section 8.5, ISBN 0-521-43108-5 * This code by Nicolas Devillard - 1998. Public domain. * http://ndevilla.free.fr/median/median/src/quickselect.c */ #define ELEM_SWAP(a,b) { register long t=(a);(a)=(b);(b)=t; } /* * qselect_median_lng - select the median value of a long array * * This routine selects the median value of the long integer array * arr[]. If there are an even number of elements, the "lower median" * is selected. * * The array arr[] is scrambled, so users must operate on a scratch * array if they wish the values to be preserved. * * long arr[] - array of values * int n - number of elements in arr * * RETURNS: the lower median value of arr[] * */ long qselect_median_lng(long arr[], int n) { int low, high ; int median; int middle, ll, hh; low = 0 ; high = n-1 ; median = (low + high) / 2; for (;;) { if (high <= low) { /* One element only */ return arr[median]; } if (high == low + 1) { /* Two elements only */ if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ; return arr[median]; } /* Find median of low, middle and high items; swap into position low */ middle = (low + high) / 2; if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ; if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ; if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ; /* Swap low item (now in position middle) into position (low+1) */ ELEM_SWAP(arr[middle], arr[low+1]) ; /* Nibble from each end towards middle, swapping items when stuck */ ll = low + 1; hh = high; for (;;) { do ll++; while (arr[low] > arr[ll]) ; do hh--; while (arr[hh] > arr[low]) ; if (hh < ll) break; ELEM_SWAP(arr[ll], arr[hh]) ; } /* Swap middle item (in position low) back into correct position */ ELEM_SWAP(arr[low], arr[hh]) ; /* Re-set active partition */ if (hh <= median) low = ll; if (hh >= median) high = hh - 1; } } #undef ELEM_SWAP #define ELEM_SWAP(a,b) { register double t=(a);(a)=(b);(b)=t; } /* * qselect_median_dbl - select the median value of a double array * * This routine selects the median value of the double array * arr[]. If there are an even number of elements, the "lower median" * is selected. * * The array arr[] is scrambled, so users must operate on a scratch * array if they wish the values to be preserved. * * double arr[] - array of values * int n - number of elements in arr * * RETURNS: the lower median value of arr[] * */ double qselect_median_dbl(double arr[], int n) { int low, high ; int median; int middle, ll, hh; low = 0 ; high = n-1 ; median = (low + high) / 2; for (;;) { if (high <= low) { /* One element only */ return arr[median] ; } if (high == low + 1) { /* Two elements only */ if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ; return arr[median] ; } /* Find median of low, middle and high items; swap into position low */ middle = (low + high) / 2; if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ; if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ; if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ; /* Swap low item (now in position middle) into position (low+1) */ ELEM_SWAP(arr[middle], arr[low+1]) ; /* Nibble from each end towards middle, swapping items when stuck */ ll = low + 1; hh = high; for (;;) { do ll++; while (arr[low] > arr[ll]) ; do hh--; while (arr[hh] > arr[low]) ; if (hh < ll) break; ELEM_SWAP(arr[ll], arr[hh]) ; } /* Swap middle item (in position low) back into correct position */ ELEM_SWAP(arr[low], arr[hh]) ; /* Re-set active partition */ if (hh <= median) low = ll; if (hh >= median) high = hh - 1; } } #undef ELEM_SWAP /* * angsep_calc - compute angular separation between celestial coordinates * * This routine computes the angular separation between to coordinates * on the celestial sphere (i.e. RA and Dec). Note that all units are * in DEGREES, unlike the other trig functions in the calculator. * * double ra1, dec1 - RA and Dec of the first position in degrees * double ra2, dec2 - RA and Dec of the second position in degrees * * RETURNS: (double) angular separation in degrees * */ double angsep_calc(double ra1, double dec1, double ra2, double dec2) { double cd; static double deg = 0; double a, sdec, sra; if (deg == 0) deg = ((double)4)*atan((double)1)/((double)180); /* deg = 1.0; **** UNCOMMENT IF YOU WANT RADIANS */ /* This (commented out) algorithm uses the Low of Cosines, which becomes unstable for angles less than 0.1 arcsec. cd = sin(dec1*deg)*sin(dec2*deg) + cos(dec1*deg)*cos(dec2*deg)*cos((ra1-ra2)*deg); if (cd < (-1)) cd = -1; if (cd > (+1)) cd = +1; return acos(cd)/deg; */ /* The algorithm is the law of Haversines. This algorithm is stable even when the points are close together. The normal Law of Cosines fails for angles around 0.1 arcsec. */ sra = sin( (ra2 - ra1)*deg / 2 ); sdec = sin( (dec2 - dec1)*deg / 2); a = sdec*sdec + cos(dec1*deg)*cos(dec2*deg)*sra*sra; /* Sanity checking to avoid a range error in the sqrt()'s below */ if (a < 0) { a = 0; } if (a > 1) { a = 1; } return 2.0*atan2(sqrt(a), sqrt(1.0 - a)) / deg; } static double ran1() { static double dval = 0.0; double rndVal; if (dval == 0.0) { if( rand()<32768 && rand()<32768 ) dval = 32768.0; else dval = 2147483648.0; } rndVal = (double)rand(); while( rndVal > dval ) dval *= 2.0; return rndVal/dval; } /* Gaussian deviate routine from Numerical Recipes */ static double gasdev() { static int iset = 0; static double gset; double fac, rsq, v1, v2; if (iset == 0) { do { v1 = 2.0*ran1()-1.0; v2 = 2.0*ran1()-1.0; rsq = v1*v1 + v2*v2; } while (rsq >= 1.0 || rsq == 0.0); fac = sqrt(-2.0*log(rsq)/rsq); gset = v1*fac; iset = 1; return v2*fac; } else { iset = 0; return gset; } } /* lgamma function - from Numerical Recipes */ float gammaln(float xx) /* Returns the value ln Gamma[(xx)] for xx > 0. */ { /* Internal arithmetic will be done in double precision, a nicety that you can omit if five-figure accuracy is good enough. */ double x,y,tmp,ser; static double cof[6]={76.18009172947146,-86.50532032941677, 24.01409824083091,-1.231739572450155, 0.1208650973866179e-2,-0.5395239384953e-5}; int j; y=x=xx; tmp=x+5.5; tmp -= (x+0.5)*log(tmp); ser=1.000000000190015; for (j=0;j<=5;j++) ser += cof[j]/++y; return (float) -tmp+log(2.5066282746310005*ser/x); } /* Poisson deviate - derived from Numerical Recipes */ static long poidev(double xm) { static double sq, alxm, g, oldm = -1.0; static double pi = 0; double em, t, y; if (pi == 0) pi = ((double)4)*atan((double)1); if (xm < 20.0) { if (xm != oldm) { oldm = xm; g = exp(-xm); } em = -1; t = 1.0; do { em += 1; t *= ran1(); } while (t > g); } else { if (xm != oldm) { oldm = xm; sq = sqrt(2.0*xm); alxm = log(xm); g = xm*alxm-gammaln( (float) (xm+1.0)); } do { do { y = tan(pi*ran1()); em = sq*y+xm; } while (em < 0.0); em = floor(em); t = 0.9*(1.0+y*y)*exp(em*alxm-gammaln( (float) (em+1.0) )-g); } while (ran1() > t); } /* Return integer version */ return (long int) floor(em+0.5); } static void Do_Func( Node *this ) { Node *theParams[MAXSUBS]; int vector[MAXSUBS], allConst; lval pVals[MAXSUBS]; char pNull[MAXSUBS]; long ival; double dval; int i, valInit; long row, elem, nelem; i = this->nSubNodes; allConst = 1; while( i-- ) { theParams[i] = gParse.Nodes + this->SubNodes[i]; vector[i] = ( theParams[i]->operation!=CONST_OP ); if( vector[i] ) { allConst = 0; vector[i] = theParams[i]->value.nelem; } else { if( theParams[i]->type==DOUBLE ) { pVals[i].data.dbl = theParams[i]->value.data.dbl; } else if( theParams[i]->type==LONG ) { pVals[i].data.lng = theParams[i]->value.data.lng; } else if( theParams[i]->type==BOOLEAN ) { pVals[i].data.log = theParams[i]->value.data.log; } else strcpy(pVals[i].data.str, theParams[i]->value.data.str); pNull[i] = 0; } } if( this->nSubNodes==0 ) allConst = 0; /* These do produce scalars */ /* Random numbers are *never* constant !! */ if( this->operation == poirnd_fct ) allConst = 0; if( this->operation == gasrnd_fct ) allConst = 0; if( this->operation == rnd_fct ) allConst = 0; if( allConst ) { switch( this->operation ) { /* Non-Trig single-argument functions */ case sum_fct: if( theParams[0]->type==BOOLEAN ) this->value.data.lng = ( pVals[0].data.log ? 1 : 0 ); else if( theParams[0]->type==LONG ) this->value.data.lng = pVals[0].data.lng; else if( theParams[0]->type==DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; else if( theParams[0]->type==BITSTR ) strcpy(this->value.data.str, pVals[0].data.str); break; case average_fct: if( theParams[0]->type==LONG ) this->value.data.dbl = pVals[0].data.lng; else if( theParams[0]->type==DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; break; case stddev_fct: this->value.data.dbl = 0; /* Standard deviation of a constant = 0 */ break; case median_fct: if( theParams[0]->type==BOOLEAN ) this->value.data.lng = ( pVals[0].data.log ? 1 : 0 ); else if( theParams[0]->type==LONG ) this->value.data.lng = pVals[0].data.lng; else this->value.data.dbl = pVals[0].data.dbl; break; case poirnd_fct: if( theParams[0]->type==DOUBLE ) this->value.data.lng = poidev(pVals[0].data.dbl); else this->value.data.lng = poidev(pVals[0].data.lng); break; case abs_fct: if( theParams[0]->type==DOUBLE ) { dval = pVals[0].data.dbl; this->value.data.dbl = (dval>0.0 ? dval : -dval); } else { ival = pVals[0].data.lng; this->value.data.lng = (ival> 0 ? ival : -ival); } break; /* Special Null-Handling Functions */ case nonnull_fct: this->value.data.lng = 1; /* Constants are always 1-element and defined */ break; case isnull_fct: /* Constants are always defined */ this->value.data.log = 0; break; case defnull_fct: if( this->type==BOOLEAN ) this->value.data.log = pVals[0].data.log; else if( this->type==LONG ) this->value.data.lng = pVals[0].data.lng; else if( this->type==DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; else if( this->type==STRING ) strcpy(this->value.data.str,pVals[0].data.str); break; /* Math functions with 1 double argument */ case sin_fct: this->value.data.dbl = sin( pVals[0].data.dbl ); break; case cos_fct: this->value.data.dbl = cos( pVals[0].data.dbl ); break; case tan_fct: this->value.data.dbl = tan( pVals[0].data.dbl ); break; case asin_fct: dval = pVals[0].data.dbl; if( dval<-1.0 || dval>1.0 ) fferror("Out of range argument to arcsin"); else this->value.data.dbl = asin( dval ); break; case acos_fct: dval = pVals[0].data.dbl; if( dval<-1.0 || dval>1.0 ) fferror("Out of range argument to arccos"); else this->value.data.dbl = acos( dval ); break; case atan_fct: this->value.data.dbl = atan( pVals[0].data.dbl ); break; case sinh_fct: this->value.data.dbl = sinh( pVals[0].data.dbl ); break; case cosh_fct: this->value.data.dbl = cosh( pVals[0].data.dbl ); break; case tanh_fct: this->value.data.dbl = tanh( pVals[0].data.dbl ); break; case exp_fct: this->value.data.dbl = exp( pVals[0].data.dbl ); break; case log_fct: dval = pVals[0].data.dbl; if( dval<=0.0 ) fferror("Out of range argument to log"); else this->value.data.dbl = log( dval ); break; case log10_fct: dval = pVals[0].data.dbl; if( dval<=0.0 ) fferror("Out of range argument to log10"); else this->value.data.dbl = log10( dval ); break; case sqrt_fct: dval = pVals[0].data.dbl; if( dval<0.0 ) fferror("Out of range argument to sqrt"); else this->value.data.dbl = sqrt( dval ); break; case ceil_fct: this->value.data.dbl = ceil( pVals[0].data.dbl ); break; case floor_fct: this->value.data.dbl = floor( pVals[0].data.dbl ); break; case round_fct: this->value.data.dbl = floor( pVals[0].data.dbl + 0.5 ); break; /* Two-argument Trig Functions */ case atan2_fct: this->value.data.dbl = atan2( pVals[0].data.dbl, pVals[1].data.dbl ); break; /* Four-argument ANGSEP function */ case angsep_fct: this->value.data.dbl = angsep_calc(pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl); /* Min/Max functions taking 1 or 2 arguments */ case min1_fct: /* No constant vectors! */ if( this->type == DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; else if( this->type == LONG ) this->value.data.lng = pVals[0].data.lng; else if( this->type == BITSTR ) strcpy(this->value.data.str, pVals[0].data.str); break; case min2_fct: if( this->type == DOUBLE ) this->value.data.dbl = minvalue( pVals[0].data.dbl, pVals[1].data.dbl ); else if( this->type == LONG ) this->value.data.lng = minvalue( pVals[0].data.lng, pVals[1].data.lng ); break; case max1_fct: /* No constant vectors! */ if( this->type == DOUBLE ) this->value.data.dbl = pVals[0].data.dbl; else if( this->type == LONG ) this->value.data.lng = pVals[0].data.lng; else if( this->type == BITSTR ) strcpy(this->value.data.str, pVals[0].data.str); break; case max2_fct: if( this->type == DOUBLE ) this->value.data.dbl = maxvalue( pVals[0].data.dbl, pVals[1].data.dbl ); else if( this->type == LONG ) this->value.data.lng = maxvalue( pVals[0].data.lng, pVals[1].data.lng ); break; /* Boolean SAO region Functions... scalar or vector dbls */ case near_fct: this->value.data.log = bnear( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl ); break; case circle_fct: this->value.data.log = circle( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl ); break; case box_fct: this->value.data.log = saobox( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl, pVals[5].data.dbl, pVals[6].data.dbl ); break; case elps_fct: this->value.data.log = ellipse( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl, pVals[5].data.dbl, pVals[6].data.dbl ); break; /* C Conditional expression: bool ? expr : expr */ case ifthenelse_fct: switch( this->type ) { case BOOLEAN: this->value.data.log = ( pVals[2].data.log ? pVals[0].data.log : pVals[1].data.log ); break; case LONG: this->value.data.lng = ( pVals[2].data.log ? pVals[0].data.lng : pVals[1].data.lng ); break; case DOUBLE: this->value.data.dbl = ( pVals[2].data.log ? pVals[0].data.dbl : pVals[1].data.dbl ); break; case STRING: strcpy(this->value.data.str, ( pVals[2].data.log ? pVals[0].data.str : pVals[1].data.str ) ); break; } break; /* String functions */ case strmid_fct: cstrmid(this->value.data.str, this->value.nelem, pVals[0].data.str, pVals[0].nelem, pVals[1].data.lng); break; case strpos_fct: { char *res = strstr(pVals[0].data.str, pVals[1].data.str); if (res == NULL) { this->value.data.lng = 0; } else { this->value.data.lng = (res - pVals[0].data.str) + 1; } break; } } this->operation = CONST_OP; } else { Allocate_Ptrs( this ); row = gParse.nRows; elem = row * this->value.nelem; if( !gParse.status ) { switch( this->operation ) { /* Special functions with no arguments */ case row_fct: while( row-- ) { this->value.data.lngptr[row] = gParse.firstRow + row; this->value.undef[row] = 0; } break; case null_fct: if( this->type==LONG ) { while( row-- ) { this->value.data.lngptr[row] = 0; this->value.undef[row] = 1; } } else if( this->type==STRING ) { while( row-- ) { this->value.data.strptr[row][0] = '\0'; this->value.undef[row] = 1; } } break; case rnd_fct: while( elem-- ) { this->value.data.dblptr[elem] = ran1(); this->value.undef[elem] = 0; } break; case gasrnd_fct: while( elem-- ) { this->value.data.dblptr[elem] = gasdev(); this->value.undef[elem] = 0; } break; case poirnd_fct: if( theParams[0]->type==DOUBLE ) { if (theParams[0]->operation == CONST_OP) { while( elem-- ) { this->value.undef[elem] = (pVals[0].data.dbl < 0); if (! this->value.undef[elem]) { this->value.data.lngptr[elem] = poidev(pVals[0].data.dbl); } } } else { while( elem-- ) { this->value.undef[elem] = theParams[0]->value.undef[elem]; if (theParams[0]->value.data.dblptr[elem] < 0) this->value.undef[elem] = 1; if (! this->value.undef[elem]) { this->value.data.lngptr[elem] = poidev(theParams[0]->value.data.dblptr[elem]); } } /* while */ } /* ! CONST_OP */ } else { /* LONG */ if (theParams[0]->operation == CONST_OP) { while( elem-- ) { this->value.undef[elem] = (pVals[0].data.lng < 0); if (! this->value.undef[elem]) { this->value.data.lngptr[elem] = poidev(pVals[0].data.lng); } } } else { while( elem-- ) { this->value.undef[elem] = theParams[0]->value.undef[elem]; if (theParams[0]->value.data.lngptr[elem] < 0) this->value.undef[elem] = 1; if (! this->value.undef[elem]) { this->value.data.lngptr[elem] = poidev(theParams[0]->value.data.lngptr[elem]); } } /* while */ } /* ! CONST_OP */ } /* END LONG */ break; /* Non-Trig single-argument functions */ case sum_fct: elem = row * theParams[0]->value.nelem; if( theParams[0]->type==BOOLEAN ) { while( row-- ) { this->value.data.lngptr[row] = 0; /* Default is UNDEF until a defined value is found */ this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( ! theParams[0]->value.undef[elem] ) { this->value.data.lngptr[row] += ( theParams[0]->value.data.logptr[elem] ? 1 : 0 ); this->value.undef[row] = 0; } } } } else if( theParams[0]->type==LONG ) { while( row-- ) { this->value.data.lngptr[row] = 0; /* Default is UNDEF until a defined value is found */ this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( ! theParams[0]->value.undef[elem] ) { this->value.data.lngptr[row] += theParams[0]->value.data.lngptr[elem]; this->value.undef[row] = 0; } } } } else if( theParams[0]->type==DOUBLE ){ while( row-- ) { this->value.data.dblptr[row] = 0.0; /* Default is UNDEF until a defined value is found */ this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( ! theParams[0]->value.undef[elem] ) { this->value.data.dblptr[row] += theParams[0]->value.data.dblptr[elem]; this->value.undef[row] = 0; } } } } else { /* BITSTR */ nelem = theParams[0]->value.nelem; while( row-- ) { char *sptr1 = theParams[0]->value.data.strptr[row]; this->value.data.lngptr[row] = 0; this->value.undef[row] = 0; while (*sptr1) { if (*sptr1 == '1') this->value.data.lngptr[row] ++; sptr1++; } } } break; case average_fct: elem = row * theParams[0]->value.nelem; if( theParams[0]->type==LONG ) { while( row-- ) { int count = 0; this->value.data.dblptr[row] = 0; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { this->value.data.dblptr[row] += theParams[0]->value.data.lngptr[elem]; count ++; } } if (count == 0) { this->value.undef[row] = 1; } else { this->value.undef[row] = 0; this->value.data.dblptr[row] /= count; } } } else if( theParams[0]->type==DOUBLE ){ while( row-- ) { int count = 0; this->value.data.dblptr[row] = 0; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { this->value.data.dblptr[row] += theParams[0]->value.data.dblptr[elem]; count ++; } } if (count == 0) { this->value.undef[row] = 1; } else { this->value.undef[row] = 0; this->value.data.dblptr[row] /= count; } } } break; case stddev_fct: elem = row * theParams[0]->value.nelem; if( theParams[0]->type==LONG ) { /* Compute the mean value */ while( row-- ) { int count = 0; double sum = 0, sum2 = 0; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { sum += theParams[0]->value.data.lngptr[elem]; count ++; } } if (count > 1) { sum /= count; /* Compute the sum of squared deviations */ nelem = theParams[0]->value.nelem; elem += nelem; /* Reset elem for second pass */ while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { double dx = (theParams[0]->value.data.lngptr[elem] - sum); sum2 += (dx*dx); } } sum2 /= (double)count-1; this->value.undef[row] = 0; this->value.data.dblptr[row] = sqrt(sum2); } else { this->value.undef[row] = 0; /* STDDEV => 0 */ this->value.data.dblptr[row] = 0; } } } else if( theParams[0]->type==DOUBLE ){ /* Compute the mean value */ while( row-- ) { int count = 0; double sum = 0, sum2 = 0; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { sum += theParams[0]->value.data.dblptr[elem]; count ++; } } if (count > 1) { sum /= count; /* Compute the sum of squared deviations */ nelem = theParams[0]->value.nelem; elem += nelem; /* Reset elem for second pass */ while( nelem-- ) { elem--; if (theParams[0]->value.undef[elem] == 0) { double dx = (theParams[0]->value.data.dblptr[elem] - sum); sum2 += (dx*dx); } } sum2 /= (double)count-1; this->value.undef[row] = 0; this->value.data.dblptr[row] = sqrt(sum2); } else { this->value.undef[row] = 0; /* STDDEV => 0 */ this->value.data.dblptr[row] = 0; } } } break; case median_fct: elem = row * theParams[0]->value.nelem; nelem = theParams[0]->value.nelem; if( theParams[0]->type==LONG ) { long *dptr = theParams[0]->value.data.lngptr; char *uptr = theParams[0]->value.undef; long *mptr = (long *) malloc(sizeof(long)*nelem); int irow; /* Allocate temporary storage for this row, since the quickselect function will scramble the contents */ if (mptr == 0) { fferror("Could not allocate temporary memory in median function"); free( this->value.data.ptr ); break; } for (irow=0; irow 0) { this->value.undef[irow] = 0; this->value.data.lngptr[irow] = qselect_median_lng(mptr, nelem1); } else { this->value.undef[irow] = 1; this->value.data.lngptr[irow] = 0; } } free(mptr); } else { double *dptr = theParams[0]->value.data.dblptr; char *uptr = theParams[0]->value.undef; double *mptr = (double *) malloc(sizeof(double)*nelem); int irow; /* Allocate temporary storage for this row, since the quickselect function will scramble the contents */ if (mptr == 0) { fferror("Could not allocate temporary memory in median function"); free( this->value.data.ptr ); break; } for (irow=0; irow 0) { this->value.undef[irow] = 0; this->value.data.dblptr[irow] = qselect_median_dbl(mptr, nelem1); } else { this->value.undef[irow] = 1; this->value.data.dblptr[irow] = 0; } } free(mptr); } break; case abs_fct: if( theParams[0]->type==DOUBLE ) while( elem-- ) { dval = theParams[0]->value.data.dblptr[elem]; this->value.data.dblptr[elem] = (dval>0.0 ? dval : -dval); this->value.undef[elem] = theParams[0]->value.undef[elem]; } else while( elem-- ) { ival = theParams[0]->value.data.lngptr[elem]; this->value.data.lngptr[elem] = (ival> 0 ? ival : -ival); this->value.undef[elem] = theParams[0]->value.undef[elem]; } break; /* Special Null-Handling Functions */ case nonnull_fct: nelem = theParams[0]->value.nelem; if ( theParams[0]->type==STRING ) nelem = 1; elem = row * nelem; while( row-- ) { int nelem1 = nelem; this->value.undef[row] = 0; /* Initialize to 0 (defined) */ this->value.data.lngptr[row] = 0; while( nelem1-- ) { elem --; if ( theParams[0]->value.undef[elem] == 0 ) this->value.data.lngptr[row] ++; } } break; case isnull_fct: if( theParams[0]->type==STRING ) elem = row; while( elem-- ) { this->value.data.logptr[elem] = theParams[0]->value.undef[elem]; this->value.undef[elem] = 0; } break; case defnull_fct: switch( this->type ) { case BOOLEAN: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pNull[i] = theParams[i]->value.undef[elem]; pVals[i].data.log = theParams[i]->value.data.logptr[elem]; } else if( vector[i] ) { pNull[i] = theParams[i]->value.undef[row]; pVals[i].data.log = theParams[i]->value.data.logptr[row]; } if( pNull[0] ) { this->value.undef[elem] = pNull[1]; this->value.data.logptr[elem] = pVals[1].data.log; } else { this->value.undef[elem] = 0; this->value.data.logptr[elem] = pVals[0].data.log; } } } break; case LONG: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pNull[i] = theParams[i]->value.undef[elem]; pVals[i].data.lng = theParams[i]->value.data.lngptr[elem]; } else if( vector[i] ) { pNull[i] = theParams[i]->value.undef[row]; pVals[i].data.lng = theParams[i]->value.data.lngptr[row]; } if( pNull[0] ) { this->value.undef[elem] = pNull[1]; this->value.data.lngptr[elem] = pVals[1].data.lng; } else { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[0].data.lng; } } } break; case DOUBLE: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pNull[i] = theParams[i]->value.undef[elem]; pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; } else if( vector[i] ) { pNull[i] = theParams[i]->value.undef[row]; pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; } if( pNull[0] ) { this->value.undef[elem] = pNull[1]; this->value.data.dblptr[elem] = pVals[1].data.dbl; } else { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[0].data.dbl; } } } break; case STRING: while( row-- ) { i=2; while( i-- ) if( vector[i] ) { pNull[i] = theParams[i]->value.undef[row]; strcpy(pVals[i].data.str, theParams[i]->value.data.strptr[row]); } if( pNull[0] ) { this->value.undef[row] = pNull[1]; strcpy(this->value.data.strptr[row],pVals[1].data.str); } else { this->value.undef[elem] = 0; strcpy(this->value.data.strptr[row],pVals[0].data.str); } } } break; /* Math functions with 1 double argument */ case sin_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = sin( theParams[0]->value.data.dblptr[elem] ); } break; case cos_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = cos( theParams[0]->value.data.dblptr[elem] ); } break; case tan_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = tan( theParams[0]->value.data.dblptr[elem] ); } break; case asin_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<-1.0 || dval>1.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = asin( dval ); } break; case acos_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<-1.0 || dval>1.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = acos( dval ); } break; case atan_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; this->value.data.dblptr[elem] = atan( dval ); } break; case sinh_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = sinh( theParams[0]->value.data.dblptr[elem] ); } break; case cosh_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = cosh( theParams[0]->value.data.dblptr[elem] ); } break; case tanh_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = tanh( theParams[0]->value.data.dblptr[elem] ); } break; case exp_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; this->value.data.dblptr[elem] = exp( dval ); } break; case log_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<=0.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = log( dval ); } break; case log10_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<=0.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = log10( dval ); } break; case sqrt_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { dval = theParams[0]->value.data.dblptr[elem]; if( dval<0.0 ) { this->value.data.dblptr[elem] = 0.0; this->value.undef[elem] = 1; } else this->value.data.dblptr[elem] = sqrt( dval ); } break; case ceil_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = ceil( theParams[0]->value.data.dblptr[elem] ); } break; case floor_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = floor( theParams[0]->value.data.dblptr[elem] ); } break; case round_fct: while( elem-- ) if( !(this->value.undef[elem] = theParams[0]->value.undef[elem]) ) { this->value.data.dblptr[elem] = floor( theParams[0]->value.data.dblptr[elem] + 0.5); } break; /* Two-argument Trig Functions */ case atan2_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1]) ) ) this->value.data.dblptr[elem] = atan2( pVals[0].data.dbl, pVals[1].data.dbl ); } } break; /* Four-argument ANGSEP Function */ case angsep_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=4; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2] || pNull[3]) ) ) this->value.data.dblptr[elem] = angsep_calc(pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl); } } break; /* Min/Max functions taking 1 or 2 arguments */ case min1_fct: elem = row * theParams[0]->value.nelem; if( this->type==LONG ) { long minVal=0; while( row-- ) { valInit = 1; this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( !theParams[0]->value.undef[elem] ) { if ( valInit ) { valInit = 0; minVal = theParams[0]->value.data.lngptr[elem]; } else { minVal = minvalue( minVal, theParams[0]->value.data.lngptr[elem] ); } this->value.undef[row] = 0; } } this->value.data.lngptr[row] = minVal; } } else if( this->type==DOUBLE ) { double minVal=0.0; while( row-- ) { valInit = 1; this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( !theParams[0]->value.undef[elem] ) { if ( valInit ) { valInit = 0; minVal = theParams[0]->value.data.dblptr[elem]; } else { minVal = minvalue( minVal, theParams[0]->value.data.dblptr[elem] ); } this->value.undef[row] = 0; } } this->value.data.dblptr[row] = minVal; } } else if( this->type==BITSTR ) { char minVal; while( row-- ) { char *sptr1 = theParams[0]->value.data.strptr[row]; minVal = '1'; while (*sptr1) { if (*sptr1 == '0') minVal = '0'; sptr1++; } this->value.data.strptr[row][0] = minVal; this->value.data.strptr[row][1] = 0; /* Null terminate */ } } break; case min2_fct: if( this->type==LONG ) { while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( pNull[0] && pNull[1] ) { this->value.undef[elem] = 1; this->value.data.lngptr[elem] = 0; } else if (pNull[0]) { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[1].data.lng; } else if (pNull[1]) { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[0].data.lng; } else { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = minvalue( pVals[0].data.lng, pVals[1].data.lng ); } } } } else if( this->type==DOUBLE ) { while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( pNull[0] && pNull[1] ) { this->value.undef[elem] = 1; this->value.data.dblptr[elem] = 0; } else if (pNull[0]) { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[1].data.dbl; } else if (pNull[1]) { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[0].data.dbl; } else { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = minvalue( pVals[0].data.dbl, pVals[1].data.dbl ); } } } } break; case max1_fct: elem = row * theParams[0]->value.nelem; if( this->type==LONG ) { long maxVal=0; while( row-- ) { valInit = 1; this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( !theParams[0]->value.undef[elem] ) { if ( valInit ) { valInit = 0; maxVal = theParams[0]->value.data.lngptr[elem]; } else { maxVal = maxvalue( maxVal, theParams[0]->value.data.lngptr[elem] ); } this->value.undef[row] = 0; } } this->value.data.lngptr[row] = maxVal; } } else if( this->type==DOUBLE ) { double maxVal=0.0; while( row-- ) { valInit = 1; this->value.undef[row] = 1; nelem = theParams[0]->value.nelem; while( nelem-- ) { elem--; if ( !theParams[0]->value.undef[elem] ) { if ( valInit ) { valInit = 0; maxVal = theParams[0]->value.data.dblptr[elem]; } else { maxVal = maxvalue( maxVal, theParams[0]->value.data.dblptr[elem] ); } this->value.undef[row] = 0; } } this->value.data.dblptr[row] = maxVal; } } else if( this->type==BITSTR ) { char maxVal; while( row-- ) { char *sptr1 = theParams[0]->value.data.strptr[row]; maxVal = '0'; while (*sptr1) { if (*sptr1 == '1') maxVal = '1'; sptr1++; } this->value.data.strptr[row][0] = maxVal; this->value.data.strptr[row][1] = 0; /* Null terminate */ } } break; case max2_fct: if( this->type==LONG ) { while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( pNull[0] && pNull[1] ) { this->value.undef[elem] = 1; this->value.data.lngptr[elem] = 0; } else if (pNull[0]) { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[1].data.lng; } else if (pNull[1]) { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = pVals[0].data.lng; } else { this->value.undef[elem] = 0; this->value.data.lngptr[elem] = maxvalue( pVals[0].data.lng, pVals[1].data.lng ); } } } } else if( this->type==DOUBLE ) { while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( pNull[0] && pNull[1] ) { this->value.undef[elem] = 1; this->value.data.dblptr[elem] = 0; } else if (pNull[0]) { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[1].data.dbl; } else if (pNull[1]) { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = pVals[0].data.dbl; } else { this->value.undef[elem] = 0; this->value.data.dblptr[elem] = maxvalue( pVals[0].data.dbl, pVals[1].data.dbl ); } } } } break; /* Boolean SAO region Functions... scalar or vector dbls */ case near_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=3; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2]) ) ) this->value.data.logptr[elem] = bnear( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl ); } } break; case circle_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=5; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2] || pNull[3] || pNull[4]) ) ) this->value.data.logptr[elem] = circle( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl ); } } break; case box_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=7; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2] || pNull[3] || pNull[4] || pNull[5] || pNull[6] ) ) ) this->value.data.logptr[elem] = saobox( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl, pVals[5].data.dbl, pVals[6].data.dbl ); } } break; case elps_fct: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; i=7; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = (pNull[0] || pNull[1] || pNull[2] || pNull[3] || pNull[4] || pNull[5] || pNull[6] ) ) ) this->value.data.logptr[elem] = ellipse( pVals[0].data.dbl, pVals[1].data.dbl, pVals[2].data.dbl, pVals[3].data.dbl, pVals[4].data.dbl, pVals[5].data.dbl, pVals[6].data.dbl ); } } break; /* C Conditional expression: bool ? expr : expr */ case ifthenelse_fct: switch( this->type ) { case BOOLEAN: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; if( vector[2]>1 ) { pVals[2].data.log = theParams[2]->value.data.logptr[elem]; pNull[2] = theParams[2]->value.undef[elem]; } else if( vector[2] ) { pVals[2].data.log = theParams[2]->value.data.logptr[row]; pNull[2] = theParams[2]->value.undef[row]; } i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.log = theParams[i]->value.data.logptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.log = theParams[i]->value.data.logptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = pNull[2]) ) { if( pVals[2].data.log ) { this->value.data.logptr[elem] = pVals[0].data.log; this->value.undef[elem] = pNull[0]; } else { this->value.data.logptr[elem] = pVals[1].data.log; this->value.undef[elem] = pNull[1]; } } } } break; case LONG: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; if( vector[2]>1 ) { pVals[2].data.log = theParams[2]->value.data.logptr[elem]; pNull[2] = theParams[2]->value.undef[elem]; } else if( vector[2] ) { pVals[2].data.log = theParams[2]->value.data.logptr[row]; pNull[2] = theParams[2]->value.undef[row]; } i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.lng = theParams[i]->value.data.lngptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = pNull[2]) ) { if( pVals[2].data.log ) { this->value.data.lngptr[elem] = pVals[0].data.lng; this->value.undef[elem] = pNull[0]; } else { this->value.data.lngptr[elem] = pVals[1].data.lng; this->value.undef[elem] = pNull[1]; } } } } break; case DOUBLE: while( row-- ) { nelem = this->value.nelem; while( nelem-- ) { elem--; if( vector[2]>1 ) { pVals[2].data.log = theParams[2]->value.data.logptr[elem]; pNull[2] = theParams[2]->value.undef[elem]; } else if( vector[2] ) { pVals[2].data.log = theParams[2]->value.data.logptr[row]; pNull[2] = theParams[2]->value.undef[row]; } i=2; while( i-- ) if( vector[i]>1 ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[elem]; pNull[i] = theParams[i]->value.undef[elem]; } else if( vector[i] ) { pVals[i].data.dbl = theParams[i]->value.data.dblptr[row]; pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[elem] = pNull[2]) ) { if( pVals[2].data.log ) { this->value.data.dblptr[elem] = pVals[0].data.dbl; this->value.undef[elem] = pNull[0]; } else { this->value.data.dblptr[elem] = pVals[1].data.dbl; this->value.undef[elem] = pNull[1]; } } } } break; case STRING: while( row-- ) { if( vector[2] ) { pVals[2].data.log = theParams[2]->value.data.logptr[row]; pNull[2] = theParams[2]->value.undef[row]; } i=2; while( i-- ) if( vector[i] ) { strcpy( pVals[i].data.str, theParams[i]->value.data.strptr[row] ); pNull[i] = theParams[i]->value.undef[row]; } if( !(this->value.undef[row] = pNull[2]) ) { if( pVals[2].data.log ) { strcpy( this->value.data.strptr[row], pVals[0].data.str ); this->value.undef[row] = pNull[0]; } else { strcpy( this->value.data.strptr[row], pVals[1].data.str ); this->value.undef[row] = pNull[1]; } } else { this->value.data.strptr[row][0] = '\0'; } } break; } break; /* String functions */ case strmid_fct: { int strconst = theParams[0]->operation == CONST_OP; int posconst = theParams[1]->operation == CONST_OP; int lenconst = theParams[2]->operation == CONST_OP; int dest_len = this->value.nelem; int src_len = theParams[0]->value.nelem; while (row--) { int pos; int len; char *str; int undef = 0; if (posconst) { pos = theParams[1]->value.data.lng; } else { pos = theParams[1]->value.data.lngptr[row]; if (theParams[1]->value.undef[row]) undef = 1; } if (strconst) { str = theParams[0]->value.data.str; if (src_len == 0) src_len = strlen(str); } else { str = theParams[0]->value.data.strptr[row]; if (theParams[0]->value.undef[row]) undef = 1; } if (lenconst) { len = dest_len; } else { len = theParams[2]->value.data.lngptr[row]; if (theParams[2]->value.undef[row]) undef = 1; } this->value.data.strptr[row][0] = '\0'; if (pos == 0) undef = 1; if (! undef ) { if (cstrmid(this->value.data.strptr[row], len, str, src_len, pos) < 0) break; } this->value.undef[row] = undef; } } break; /* String functions */ case strpos_fct: { int const1 = theParams[0]->operation == CONST_OP; int const2 = theParams[1]->operation == CONST_OP; while (row--) { char *str1, *str2; int undef = 0; if (const1) { str1 = theParams[0]->value.data.str; } else { str1 = theParams[0]->value.data.strptr[row]; if (theParams[0]->value.undef[row]) undef = 1; } if (const2) { str2 = theParams[1]->value.data.str; } else { str2 = theParams[1]->value.data.strptr[row]; if (theParams[1]->value.undef[row]) undef = 1; } this->value.data.lngptr[row] = 0; if (! undef ) { char *res = strstr(str1, str2); if (res == NULL) { undef = 1; this->value.data.lngptr[row] = 0; } else { this->value.data.lngptr[row] = (res - str1) + 1; } } this->value.undef[row] = undef; } } break; } /* End switch(this->operation) */ } /* End if (!gParse.status) */ } /* End non-constant operations */ i = this->nSubNodes; while( i-- ) { if( theParams[i]->operation>0 ) { /* Currently only numeric params allowed */ free( theParams[i]->value.data.ptr ); } } } static void Do_Deref( Node *this ) { Node *theVar, *theDims[MAXDIMS]; int isConst[MAXDIMS], allConst; long dimVals[MAXDIMS]; int i, nDims; long row, elem, dsize; theVar = gParse.Nodes + this->SubNodes[0]; i = nDims = this->nSubNodes-1; allConst = 1; while( i-- ) { theDims[i] = gParse.Nodes + this->SubNodes[i+1]; isConst[i] = ( theDims[i]->operation==CONST_OP ); if( isConst[i] ) dimVals[i] = theDims[i]->value.data.lng; else allConst = 0; } if( this->type==DOUBLE ) { dsize = sizeof( double ); } else if( this->type==LONG ) { dsize = sizeof( long ); } else if( this->type==BOOLEAN ) { dsize = sizeof( char ); } else dsize = 0; Allocate_Ptrs( this ); if( !gParse.status ) { if( allConst && theVar->value.naxis==nDims ) { /* Dereference completely using constant indices */ elem = 0; i = nDims; while( i-- ) { if( dimVals[i]<1 || dimVals[i]>theVar->value.naxes[i] ) break; elem = theVar->value.naxes[i]*elem + dimVals[i]-1; } if( i<0 ) { for( row=0; rowtype==STRING ) this->value.undef[row] = theVar->value.undef[row]; else if( this->type==BITSTR ) this->value.undef; /* Dummy - BITSTRs do not have undefs */ else this->value.undef[row] = theVar->value.undef[elem]; if( this->type==DOUBLE ) this->value.data.dblptr[row] = theVar->value.data.dblptr[elem]; else if( this->type==LONG ) this->value.data.lngptr[row] = theVar->value.data.lngptr[elem]; else if( this->type==BOOLEAN ) this->value.data.logptr[row] = theVar->value.data.logptr[elem]; else { /* XXX Note, the below expression uses knowledge of the layout of the string format, namely (nelem+1) characters per string, followed by (nelem+1) "undef" values. */ this->value.data.strptr[row][0] = theVar->value.data.strptr[0][elem+row]; this->value.data.strptr[row][1] = 0; /* Null terminate */ } elem += theVar->value.nelem; } } else { fferror("Index out of range"); free( this->value.data.ptr ); } } else if( allConst && nDims==1 ) { /* Reduce dimensions by 1, using a constant index */ if( dimVals[0] < 1 || dimVals[0] > theVar->value.naxes[ theVar->value.naxis-1 ] ) { fferror("Index out of range"); free( this->value.data.ptr ); } else if ( this->type == BITSTR || this->type == STRING ) { elem = this->value.nelem * (dimVals[0]-1); for( row=0; rowvalue.undef) this->value.undef[row] = theVar->value.undef[row]; memcpy( (char*)this->value.data.strptr[0] + row*sizeof(char)*(this->value.nelem+1), (char*)theVar->value.data.strptr[0] + elem*sizeof(char), this->value.nelem * sizeof(char) ); /* Null terminate */ this->value.data.strptr[row][this->value.nelem] = 0; elem += theVar->value.nelem+1; } } else { elem = this->value.nelem * (dimVals[0]-1); for( row=0; rowvalue.undef + row*this->value.nelem, theVar->value.undef + elem, this->value.nelem * sizeof(char) ); memcpy( (char*)this->value.data.ptr + row*dsize*this->value.nelem, (char*)theVar->value.data.ptr + elem*dsize, this->value.nelem * dsize ); elem += theVar->value.nelem; } } } else if( theVar->value.naxis==nDims ) { /* Dereference completely using an expression for the indices */ for( row=0; rowvalue.undef[row] ) { fferror("Null encountered as vector index"); free( this->value.data.ptr ); break; } else dimVals[i] = theDims[i]->value.data.lngptr[row]; } } if( gParse.status ) break; elem = 0; i = nDims; while( i-- ) { if( dimVals[i]<1 || dimVals[i]>theVar->value.naxes[i] ) break; elem = theVar->value.naxes[i]*elem + dimVals[i]-1; } if( i<0 ) { elem += row*theVar->value.nelem; if( this->type==STRING ) this->value.undef[row] = theVar->value.undef[row]; else if( this->type==BITSTR ) this->value.undef; /* Dummy - BITSTRs do not have undefs */ else this->value.undef[row] = theVar->value.undef[elem]; if( this->type==DOUBLE ) this->value.data.dblptr[row] = theVar->value.data.dblptr[elem]; else if( this->type==LONG ) this->value.data.lngptr[row] = theVar->value.data.lngptr[elem]; else if( this->type==BOOLEAN ) this->value.data.logptr[row] = theVar->value.data.logptr[elem]; else { /* XXX Note, the below expression uses knowledge of the layout of the string format, namely (nelem+1) characters per string, followed by (nelem+1) "undef" values. */ this->value.data.strptr[row][0] = theVar->value.data.strptr[0][elem+row]; this->value.data.strptr[row][1] = 0; /* Null terminate */ } } else { fferror("Index out of range"); free( this->value.data.ptr ); } } } else { /* Reduce dimensions by 1, using a nonconstant expression */ for( row=0; rowvalue.undef[row] ) { fferror("Null encountered as vector index"); free( this->value.data.ptr ); break; } else dimVals[0] = theDims[0]->value.data.lngptr[row]; if( dimVals[0] < 1 || dimVals[0] > theVar->value.naxes[ theVar->value.naxis-1 ] ) { fferror("Index out of range"); free( this->value.data.ptr ); } else if ( this->type == BITSTR || this->type == STRING ) { elem = this->value.nelem * (dimVals[0]-1); elem += row*(theVar->value.nelem+1); if (this->value.undef) this->value.undef[row] = theVar->value.undef[row]; memcpy( (char*)this->value.data.strptr[0] + row*sizeof(char)*(this->value.nelem+1), (char*)theVar->value.data.strptr[0] + elem*sizeof(char), this->value.nelem * sizeof(char) ); /* Null terminate */ this->value.data.strptr[row][this->value.nelem] = 0; } else { elem = this->value.nelem * (dimVals[0]-1); elem += row*theVar->value.nelem; memcpy( this->value.undef + row*this->value.nelem, theVar->value.undef + elem, this->value.nelem * sizeof(char) ); memcpy( (char*)this->value.data.ptr + row*dsize*this->value.nelem, (char*)theVar->value.data.ptr + elem*dsize, this->value.nelem * dsize ); } } } } if( theVar->operation>0 ) { if (theVar->type == STRING || theVar->type == BITSTR) free(theVar->value.data.strptr[0] ); else free( theVar->value.data.ptr ); } for( i=0; ioperation>0 ) { free( theDims[i]->value.data.ptr ); } } static void Do_GTI( Node *this ) { Node *theExpr, *theTimes; double *start, *stop, *times; long elem, nGTI, gti; int ordered; theTimes = gParse.Nodes + this->SubNodes[0]; theExpr = gParse.Nodes + this->SubNodes[1]; nGTI = theTimes->value.nelem; start = theTimes->value.data.dblptr; stop = theTimes->value.data.dblptr + nGTI; ordered = theTimes->type; if( theExpr->operation==CONST_OP ) { this->value.data.log = (Search_GTI( theExpr->value.data.dbl, nGTI, start, stop, ordered )>=0); this->operation = CONST_OP; } else { Allocate_Ptrs( this ); times = theExpr->value.data.dblptr; if( !gParse.status ) { elem = gParse.nRows * this->value.nelem; if( nGTI ) { gti = -1; while( elem-- ) { if( (this->value.undef[elem] = theExpr->value.undef[elem]) ) continue; /* Before searching entire GTI, check the GTI found last time */ if( gti<0 || times[elem]stop[gti] ) { gti = Search_GTI( times[elem], nGTI, start, stop, ordered ); } this->value.data.logptr[elem] = ( gti>=0 ); } } else while( elem-- ) { this->value.data.logptr[elem] = 0; this->value.undef[elem] = 0; } } } if( theExpr->operation>0 ) free( theExpr->value.data.ptr ); } static long Search_GTI( double evtTime, long nGTI, double *start, double *stop, int ordered ) { long gti, step; if( ordered && nGTI>15 ) { /* If time-ordered and lots of GTIs, */ /* use "FAST" Binary search algorithm */ if( evtTime>=start[0] && evtTime<=stop[nGTI-1] ) { gti = step = (nGTI >> 1); while(1) { if( step>1L ) step >>= 1; if( evtTime>stop[gti] ) { if( evtTime>=start[gti+1] ) gti += step; else { gti = -1L; break; } } else if( evtTime=start[gti] && evtTime<=stop[gti] ) break; } return( gti ); } static void Do_REG( Node *this ) { Node *theRegion, *theX, *theY; double Xval=0.0, Yval=0.0; char Xnull=0, Ynull=0; int Xvector, Yvector; long nelem, elem, rows; theRegion = gParse.Nodes + this->SubNodes[0]; theX = gParse.Nodes + this->SubNodes[1]; theY = gParse.Nodes + this->SubNodes[2]; Xvector = ( theX->operation!=CONST_OP ); if( Xvector ) Xvector = theX->value.nelem; else { Xval = theX->value.data.dbl; } Yvector = ( theY->operation!=CONST_OP ); if( Yvector ) Yvector = theY->value.nelem; else { Yval = theY->value.data.dbl; } if( !Xvector && !Yvector ) { this->value.data.log = ( fits_in_region( Xval, Yval, (SAORegion *)theRegion->value.data.ptr ) != 0 ); this->operation = CONST_OP; } else { Allocate_Ptrs( this ); if( !gParse.status ) { rows = gParse.nRows; nelem = this->value.nelem; elem = rows*nelem; while( rows-- ) { while( nelem-- ) { elem--; if( Xvector>1 ) { Xval = theX->value.data.dblptr[elem]; Xnull = theX->value.undef[elem]; } else if( Xvector ) { Xval = theX->value.data.dblptr[rows]; Xnull = theX->value.undef[rows]; } if( Yvector>1 ) { Yval = theY->value.data.dblptr[elem]; Ynull = theY->value.undef[elem]; } else if( Yvector ) { Yval = theY->value.data.dblptr[rows]; Ynull = theY->value.undef[rows]; } this->value.undef[elem] = ( Xnull || Ynull ); if( this->value.undef[elem] ) continue; this->value.data.logptr[elem] = ( fits_in_region( Xval, Yval, (SAORegion *)theRegion->value.data.ptr ) != 0 ); } nelem = this->value.nelem; } } } if( theX->operation>0 ) free( theX->value.data.ptr ); if( theY->operation>0 ) free( theY->value.data.ptr ); } static void Do_Vector( Node *this ) { Node *that; long row, elem, idx, jdx, offset=0; int node; Allocate_Ptrs( this ); if( !gParse.status ) { for( node=0; nodenSubNodes; node++ ) { that = gParse.Nodes + this->SubNodes[node]; if( that->operation == CONST_OP ) { idx = gParse.nRows*this->value.nelem + offset; while( (idx-=this->value.nelem)>=0 ) { this->value.undef[idx] = 0; switch( this->type ) { case BOOLEAN: this->value.data.logptr[idx] = that->value.data.log; break; case LONG: this->value.data.lngptr[idx] = that->value.data.lng; break; case DOUBLE: this->value.data.dblptr[idx] = that->value.data.dbl; break; } } } else { row = gParse.nRows; idx = row * that->value.nelem; while( row-- ) { elem = that->value.nelem; jdx = row*this->value.nelem + offset; while( elem-- ) { this->value.undef[jdx+elem] = that->value.undef[--idx]; switch( this->type ) { case BOOLEAN: this->value.data.logptr[jdx+elem] = that->value.data.logptr[idx]; break; case LONG: this->value.data.lngptr[jdx+elem] = that->value.data.lngptr[idx]; break; case DOUBLE: this->value.data.dblptr[jdx+elem] = that->value.data.dblptr[idx]; break; } } } } offset += that->value.nelem; } } for( node=0; node < this->nSubNodes; node++ ) if( OPER(this->SubNodes[node])>0 ) free( gParse.Nodes[this->SubNodes[node]].value.data.ptr ); } /*****************************************************************************/ /* Utility routines which perform the calculations on bits and SAO regions */ /*****************************************************************************/ static char bitlgte(char *bits1, int oper, char *bits2) { int val1, val2, nextbit; char result; int i, l1, l2, length, ldiff; char stream[256]; char chr1, chr2; l1 = strlen(bits1); l2 = strlen(bits2); if (l1 < l2) { length = l2; ldiff = l2 - l1; i=0; while( ldiff-- ) stream[i++] = '0'; while( l1-- ) stream[i++] = *(bits1++); stream[i] = '\0'; bits1 = stream; } else if (l2 < l1) { length = l1; ldiff = l1 - l2; i=0; while( ldiff-- ) stream[i++] = '0'; while( l2-- ) stream[i++] = *(bits2++); stream[i] = '\0'; bits2 = stream; } else length = l1; val1 = val2 = 0; nextbit = 1; while( length-- ) { chr1 = bits1[length]; chr2 = bits2[length]; if ((chr1 != 'x')&&(chr1 != 'X')&&(chr2 != 'x')&&(chr2 != 'X')) { if (chr1 == '1') val1 += nextbit; if (chr2 == '1') val2 += nextbit; nextbit *= 2; } } result = 0; switch (oper) { case LT: if (val1 < val2) result = 1; break; case LTE: if (val1 <= val2) result = 1; break; case GT: if (val1 > val2) result = 1; break; case GTE: if (val1 >= val2) result = 1; break; } return (result); } static void bitand(char *result,char *bitstrm1,char *bitstrm2) { int i, l1, l2, ldiff; char stream[256]; char chr1, chr2; l1 = strlen(bitstrm1); l2 = strlen(bitstrm2); if (l1 < l2) { ldiff = l2 - l1; i=0; while( ldiff-- ) stream[i++] = '0'; while( l1-- ) stream[i++] = *(bitstrm1++); stream[i] = '\0'; bitstrm1 = stream; } else if (l2 < l1) { ldiff = l1 - l2; i=0; while( ldiff-- ) stream[i++] = '0'; while( l2-- ) stream[i++] = *(bitstrm2++); stream[i] = '\0'; bitstrm2 = stream; } while ( (chr1 = *(bitstrm1++)) ) { chr2 = *(bitstrm2++); if ((chr1 == 'x') || (chr2 == 'x')) *result = 'x'; else if ((chr1 == '1') && (chr2 == '1')) *result = '1'; else *result = '0'; result++; } *result = '\0'; } static void bitor(char *result,char *bitstrm1,char *bitstrm2) { int i, l1, l2, ldiff; char stream[256]; char chr1, chr2; l1 = strlen(bitstrm1); l2 = strlen(bitstrm2); if (l1 < l2) { ldiff = l2 - l1; i=0; while( ldiff-- ) stream[i++] = '0'; while( l1-- ) stream[i++] = *(bitstrm1++); stream[i] = '\0'; bitstrm1 = stream; } else if (l2 < l1) { ldiff = l1 - l2; i=0; while( ldiff-- ) stream[i++] = '0'; while( l2-- ) stream[i++] = *(bitstrm2++); stream[i] = '\0'; bitstrm2 = stream; } while ( (chr1 = *(bitstrm1++)) ) { chr2 = *(bitstrm2++); if ((chr1 == '1') || (chr2 == '1')) *result = '1'; else if ((chr1 == '0') || (chr2 == '0')) *result = '0'; else *result = 'x'; result++; } *result = '\0'; } static void bitnot(char *result,char *bits) { int length; char chr; length = strlen(bits); while( length-- ) { chr = *(bits++); *(result++) = ( chr=='1' ? '0' : ( chr=='0' ? '1' : chr ) ); } *result = '\0'; } static char bitcmp(char *bitstrm1, char *bitstrm2) { int i, l1, l2, ldiff; char stream[256]; char chr1, chr2; l1 = strlen(bitstrm1); l2 = strlen(bitstrm2); if (l1 < l2) { ldiff = l2 - l1; i=0; while( ldiff-- ) stream[i++] = '0'; while( l1-- ) stream[i++] = *(bitstrm1++); stream[i] = '\0'; bitstrm1 = stream; } else if (l2 < l1) { ldiff = l1 - l2; i=0; while( ldiff-- ) stream[i++] = '0'; while( l2-- ) stream[i++] = *(bitstrm2++); stream[i] = '\0'; bitstrm2 = stream; } while( (chr1 = *(bitstrm1++)) ) { chr2 = *(bitstrm2++); if ( ((chr1 == '0') && (chr2 == '1')) || ((chr1 == '1') && (chr2 == '0')) ) return( 0 ); } return( 1 ); } static char bnear(double x, double y, double tolerance) { if (fabs(x - y) < tolerance) return ( 1 ); else return ( 0 ); } static char saobox(double xcen, double ycen, double xwid, double ywid, double rot, double xcol, double ycol) { double x,y,xprime,yprime,xmin,xmax,ymin,ymax,theta; theta = (rot / 180.0) * myPI; xprime = xcol - xcen; yprime = ycol - ycen; x = xprime * cos(theta) + yprime * sin(theta); y = -xprime * sin(theta) + yprime * cos(theta); xmin = - 0.5 * xwid; xmax = 0.5 * xwid; ymin = - 0.5 * ywid; ymax = 0.5 * ywid; if ((x >= xmin) && (x <= xmax) && (y >= ymin) && (y <= ymax)) return ( 1 ); else return ( 0 ); } static char circle(double xcen, double ycen, double rad, double xcol, double ycol) { double r2,dx,dy,dlen; dx = xcol - xcen; dy = ycol - ycen; dx *= dx; dy *= dy; dlen = dx + dy; r2 = rad * rad; if (dlen <= r2) return ( 1 ); else return ( 0 ); } static char ellipse(double xcen, double ycen, double xrad, double yrad, double rot, double xcol, double ycol) { double x,y,xprime,yprime,dx,dy,dlen,theta; theta = (rot / 180.0) * myPI; xprime = xcol - xcen; yprime = ycol - ycen; x = xprime * cos(theta) + yprime * sin(theta); y = -xprime * sin(theta) + yprime * cos(theta); dx = x / xrad; dy = y / yrad; dx *= dx; dy *= dy; dlen = dx + dy; if (dlen <= 1.0) return ( 1 ); else return ( 0 ); } /* * Extract substring */ int cstrmid(char *dest_str, int dest_len, char *src_str, int src_len, int pos) { /* char fill_char = ' '; */ char fill_char = '\0'; if (src_len == 0) { src_len = strlen(src_str); } /* .. if constant */ /* Fill destination with blanks */ if (pos < 0) { fferror("STRMID(S,P,N) P must be 0 or greater"); return -1; } if (pos > src_len || pos == 0) { /* pos==0: blank string requested */ memset(dest_str, fill_char, dest_len); } else if (pos+dest_len > src_len) { /* Copy a subset */ int nsub = src_len-pos+1; int npad = dest_len - nsub; memcpy(dest_str, src_str+pos-1, nsub); /* Fill remaining string with blanks */ memset(dest_str+nsub, fill_char, npad); } else { /* Full string copy */ memcpy(dest_str, src_str+pos-1, dest_len); } dest_str[dest_len] = '\0'; /* Null-terminate */ return 0; } static void fferror(char *s) { char msg[80]; if( !gParse.status ) gParse.status = PARSE_SYNTAX_ERR; strncpy(msg, s, 80); msg[79] = '\0'; ffpmsg(msg); } healpy-1.10.3/cfitsio/f77.inc0000664000175000017500000000152513010375005016061 0ustar zoncazonca00000000000000C Codes for FITS extension types integer IMAGE_HDU, ASCII_TBL, BINARY_TBL parameter ( & IMAGE_HDU = 0, & ASCII_TBL = 1, & BINARY_TBL = 2 ) C Codes for FITS table data types integer TBIT,TBYTE,TLOGICAL,TSTRING,TSHORT,TINT integer TFLOAT,TDOUBLE,TCOMPLEX,TDBLCOMPLEX parameter ( & TBIT = 1, & TBYTE = 11, & TLOGICAL = 14, & TSTRING = 16, & TSHORT = 21, & TINT = 31, & TFLOAT = 42, & TDOUBLE = 82, & TCOMPLEX = 83, & TDBLCOMPLEX = 163 ) C Codes for iterator column types integer InputCol, InputOutputCol, OutputCol parameter ( & InputCol = 0, & InputOutputCol = 1, & OutputCol = 2 ) healpy-1.10.3/cfitsio/f77_wrap.h0000664000175000017500000002427613010375005016600 0ustar zoncazonca00000000000000#define UNSIGNED_BYTE #include "cfortran.h" /************************************************************************ Some platforms creates longs as 8-byte integers. On other machines, ints and longs are both 4-bytes, so both are compatible with Fortrans default integer which is 4-bytes. To support 8-byte longs, we must redefine LONGs and convert them to 8-bytes when going to C, and restore them to 4-bytes when returning to Fortran. Ugh!!! *************************************************************************/ #if defined(DECFortran) || (defined(__alpha) && defined(g77Fortran)) \ || (defined(mipsFortran) && _MIPS_SZLONG==64) \ || (defined(IBMR2Fortran) && defined(__64BIT__)) \ || defined(__ia64__) \ || defined (__sparcv9) || (defined(__sparc__) && defined(__arch64__)) \ || defined (__x86_64__) \ || defined (_SX) \ || defined (__powerpc64__)\ || defined (__s390x__) #define LONG8BYTES_INT4BYTES #undef LONGV_cfSTR #undef PLONG_cfSTR #undef LONGVVVVVVV_cfTYPE #undef PLONG_cfTYPE #undef LONGV_cfT #undef PLONG_cfT #define LONGV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,LONGV,A,B,C,D,E) #define PLONG_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,PLONG,A,B,C,D,E) #define LONGVVVVVVV_cfTYPE int #define PLONG_cfTYPE int #define LONGV_cfQ(B) long *B, _(B,N); #define PLONG_cfQ(B) long B; #define LONGV_cfT(M,I,A,B,D) ( (_(B,N) = * _3(M,_LONGV_A,I)), \ B = F2Clongv(_(B,N),A) ) #define PLONG_cfT(M,I,A,B,D) ((B=*A),&B) #define LONGV_cfR(A,B,D) C2Flongv(_(B,N),A,B); #define PLONG_cfR(A,B,D) *A=B; #define LONGV_cfH(S,U,B) #define PLONG_cfH(S,U,B) static long *F2Clongv(long size, int *A) { long i; long *B; B=(long *)malloc( size*sizeof(long) ); for(i=0;idsc$a_pointer /* We want single strings to be equivalent to string vectors with */ /* a single element, so ignore the number of elements info in the */ /* vector structure, and rely on the NUM_ELEM definitions. */ #undef STRINGV_cfT #define STRINGV_cfT(M,I,A,B,D) TTTTSTRV(A->dsc$a_pointer, B, \ A->dsc$w_length, \ num_elem(A->dsc$a_pointer, \ A->dsc$w_length, \ _3(M,_STRV_A,I) ) ) #else #ifdef CRAYFortran #define PPSTRING_cfT(M,I,A,B,D) (unsigned char*)_fcdtocp(A) #else #define PPSTRING_cfT(M,I,A,B,D) (unsigned char*)A #endif #endif #define _cfMAX(A,B) ( (A>B) ? A : B ) #define STRINGV_cfQ(B) char **B; unsigned int _(B,N), _(B,M); #define STRINGV_cfR(A,B,D) free(B[0]); free(B); #define TTSTR( A,B,D) \ ((B=(char*)malloc(_cfMAX(D,gMinStrLen)+1))[D]='\0',memcpy(B,A,D), \ kill_trailing(B,' ')) #define TTTTSTRV( A,B,D,E) ( \ _(B,N)=_cfMAX(E,1), \ _(B,M)=_cfMAX(D,gMinStrLen)+1, \ B=(char**)malloc(_(B,N)*sizeof(char*)), \ B[0]=(char*)malloc(_(B,N)*_(B,M)), \ vindex(B,_(B,M),_(B,N),f2cstrv2(A,B[0],D,_(B,M),_(B,N))) \ ) #define RRRRPSTRV(A,B,D) \ c2fstrv2(B[0],A,_(B,M),D,_(B,N)), \ free(B[0]), \ free(B); static char **vindex(char **B, int elem_len, int nelem, char *B0) { int i; if( nelem ) for( i=0;idsc$a_pointer)[0]) #define BYTEV_cfT(M,I,A,B,D) (INTEGER_BYTE*)A->dsc$a_pointer #else #ifdef CRAYFortran #define BYTE_cfN(T,A) _fcd A #define BYTEV_cfN(T,A) _fcd A #define BYTE_cfT(M,I,A,B,D) (INTEGER_BYTE)((_fcdtocp(A))[0]) #define BYTEV_cfT(M,I,A,B,D) (INTEGER_BYTE*)_fcdtocp(A) #else #define BYTE_cfN(T,A) INTEGER_BYTE * A #define BYTEV_cfN(T,A) INTEGER_BYTE * A #define BYTE_cfT(M,I,A,B,D) A[0] #define BYTEV_cfT(M,I,A,B,D) A #endif #endif /************************************************************************ The following definitions and functions handle conversions between C and Fortran arrays of LOGICALS. Individually, LOGICALS are treated as int's but as char's when in an array. cfortran defines (F2C/C2F)LOGICALV but never uses them, so these routines also handle TRUE/FALSE conversions. *************************************************************************/ #undef LOGICALV_cfSTR #undef LOGICALV_cfT #define LOGICALV_cfSTR(N,T,A,B,C,D,E) _(CFARGS,N)(T,LOGICALV,A,B,C,D,E) #define LOGICALV_cfQ(B) char *B; unsigned int _(B,N); #define LOGICALV_cfT(M,I,A,B,D) (_(B,N)= * _3(M,_LOGV_A,I), \ B=F2CcopyLogVect(_(B,N),A)) #define LOGICALV_cfR(A,B,D) C2FcopyLogVect(_(B,N),A,B); #define LOGICALV_cfH(S,U,B) static char *F2CcopyLogVect(long size, int *A) { long i; char *B; B=(char *)malloc(size*sizeof(char)); for( i=0; i0 ) return; for( i=50;i0 ) return; if( unit == -1 ) { int i; for( i=50; i=NMAXFILES ) { *status = BAD_FILEPTR; ffpmsg("Cfffiou was sent an unacceptable unit number."); } else gFitsFiles[unit]=NULL; } FCALLSCSUB2(Cfffiou,FTFIOU,ftfiou,INT,PINT) int CFITS2Unit( fitsfile *fptr ) /* Utility routine to convert a fitspointer to a Fortran unit number */ /* for use when a C program is calling a Fortran routine which could */ /* in turn call CFITSIO... Modelled after code by Ning Gan. */ { static fitsfile *last_fptr = (fitsfile *)NULL; /* Remember last fptr */ static int last_unit = 0; /* Remember last unit */ int status = 0; /* Test whether we are repeating the last lookup */ if( last_unit && fptr==gFitsFiles[last_unit] ) return( last_unit ); /* Check if gFitsFiles has an entry for this fptr. */ /* Allows Fortran to call C to call Fortran to */ /* call CFITSIO... OUCH!!! */ last_fptr = fptr; for( last_unit=1; last_unit=NMAXFILES ) return(0); return(gFitsFiles[unit]); } /**************************************************/ /* Start of wrappers for routines in fitsio.h */ /**************************************************/ /*---------------- FITS file URL parsing routines -------------*/ FCALLSCSUB9(ffiurl,FTIURL,ftiurl,STRING,PSTRING,PSTRING,PSTRING,PSTRING,PSTRING,PSTRING,PSTRING,PINT) FCALLSCSUB3(ffrtnm,FTRTNM,ftrtnm,STRING,PSTRING,PINT) FCALLSCSUB3(ffexist,FTEXIST,ftexist,STRING,PINT,PINT) FCALLSCSUB3(ffextn,FTEXTN,ftextn,STRING,PINT,PINT) FCALLSCSUB7(ffrwrg,FTRWRG,ftrwrg,STRING,LONG,INT,PINT,PLONG,PLONG,PINT) /*---------------- FITS file I/O routines ---------------*/ void Cffopen( fitsfile **fptr, const char *filename, int iomode, int *blocksize, int *status ); void Cffopen( fitsfile **fptr, const char *filename, int iomode, int *blocksize, int *status ) { int hdutype; if( *fptr==NULL || *fptr==(fitsfile*)1 ) { ffopen( fptr, filename, iomode, status ); ffmahd( *fptr, 1, &hdutype, status ); *blocksize = 1; } else { *status = FILE_NOT_OPENED; ffpmsg("Cffopen tried to use an already opened unit."); } } FCALLSCSUB5(Cffopen,FTOPEN,ftopen,PFITSUNIT,STRING,INT,PINT,PINT) void Cffdkopn( fitsfile **fptr, const char *filename, int iomode, int *blocksize, int *status ); void Cffdkopn( fitsfile **fptr, const char *filename, int iomode, int *blocksize, int *status ) { int hdutype; if( *fptr==NULL || *fptr==(fitsfile*)1 ) { ffdkopn( fptr, filename, iomode, status ); ffmahd( *fptr, 1, &hdutype, status ); *blocksize = 1; } else { *status = FILE_NOT_OPENED; ffpmsg("Cffdkopn tried to use an already opened unit."); } } FCALLSCSUB5(Cffdkopn,FTDKOPN,ftdkopn,PFITSUNIT,STRING,INT,PINT,PINT) void Cffnopn( fitsfile **fptr, const char *filename, int iomode, int *status ); void Cffnopn( fitsfile **fptr, const char *filename, int iomode, int *status ) { if( *fptr==NULL || *fptr==(fitsfile*)1 ) { ffopen( fptr, filename, iomode, status ); } else { *status = FILE_NOT_OPENED; ffpmsg("Cffnopn tried to use an already opened unit."); } } FCALLSCSUB4(Cffnopn,FTNOPN,ftnopn,PFITSUNIT,STRING,INT,PINT) void Cffdopn( fitsfile **fptr, const char *filename, int iomode, int *status ); void Cffdopn( fitsfile **fptr, const char *filename, int iomode, int *status ) { if( *fptr==NULL || *fptr==(fitsfile*)1 ) { ffdopn( fptr, filename, iomode, status ); } else { *status = FILE_NOT_OPENED; ffpmsg("Cffdopn tried to use an already opened unit."); } } FCALLSCSUB4(Cffdopn,FTDOPN,ftdopn,PFITSUNIT,STRING,INT,PINT) void Cfftopn( fitsfile **fptr, const char *filename, int iomode, int *status ); void Cfftopn( fitsfile **fptr, const char *filename, int iomode, int *status ) { if( *fptr==NULL || *fptr==(fitsfile*)1 ) { fftopn( fptr, filename, iomode, status ); } else { *status = FILE_NOT_OPENED; ffpmsg("Cfftopn tried to use an already opened unit."); } } FCALLSCSUB4(Cfftopn,FTTOPN,fttopn,PFITSUNIT,STRING,INT,PINT) void Cffiopn( fitsfile **fptr, const char *filename, int iomode, int *status ); void Cffiopn( fitsfile **fptr, const char *filename, int iomode, int *status ) { if( *fptr==NULL || *fptr==(fitsfile*)1 ) { ffiopn( fptr, filename, iomode, status ); } else { *status = FILE_NOT_OPENED; ffpmsg("Cffiopn tried to use an already opened unit."); } } FCALLSCSUB4(Cffiopn,FTIOPN,ftiopn,PFITSUNIT,STRING,INT,PINT) void Cffreopen( fitsfile *openfptr, fitsfile **newfptr, int *status ); void Cffreopen( fitsfile *openfptr, fitsfile **newfptr, int *status ) { if( *newfptr==NULL || *newfptr==(fitsfile*)1 ) { ffreopen( openfptr, newfptr, status ); } else { *status = FILE_NOT_OPENED; ffpmsg("Cffreopen tried to use an already opened unit."); } } FCALLSCSUB3(Cffreopen,FTREOPEN,ftreopen,FITSUNIT,PFITSUNIT,PINT) void Cffinit( fitsfile **fptr, const char *filename, int blocksize, int *status ); void Cffinit( fitsfile **fptr, const char *filename, int blocksize, int *status ) { if( *fptr==NULL || *fptr==(fitsfile*)1 ) { ffinit( fptr, filename, status ); } else { *status = FILE_NOT_CREATED; ffpmsg("Cffinit tried to use an already opened unit."); } } FCALLSCSUB4(Cffinit,FTINIT,ftinit,PFITSUNIT,STRING,INT,PINT) void Cffdkinit( fitsfile **fptr, const char *filename, int blocksize, int *status ); void Cffdkinit( fitsfile **fptr, const char *filename, int blocksize, int *status ) { if( *fptr==NULL || *fptr==(fitsfile*)1 ) { ffdkinit( fptr, filename, status ); } else { *status = FILE_NOT_CREATED; ffpmsg("Cffdkinit tried to use an already opened unit."); } } FCALLSCSUB4(Cffdkinit,FTDKINIT,ftdkinit,PFITSUNIT,STRING,INT,PINT) void Cfftplt( fitsfile **fptr, const char *filename, const char *tempname, int *status ); void Cfftplt( fitsfile **fptr, const char *filename, const char *tempname, int *status ) { if( *fptr==NULL || *fptr==(fitsfile*)1 ) { fftplt( fptr, filename, tempname, status ); } else { *status = FILE_NOT_CREATED; ffpmsg("Cfftplt tried to use an already opened unit."); } } FCALLSCSUB4(Cfftplt,FTTPLT,fttplt,PFITSUNIT,STRING,STRING,PINT) FCALLSCSUB2(ffflus,FTFLUS,ftflus,FITSUNIT,PINT) FCALLSCSUB3(ffflsh,FTFLSH,ftflsh,FITSUNIT, INT, PINT) void Cffclos( int unit, int *status ); void Cffclos( int unit, int *status ) { if( gFitsFiles[unit]!=NULL && gFitsFiles[unit]!=(void*)1 ) { ffclos( gFitsFiles[unit], status ); /* Flag unit number as unavailable */ gFitsFiles[unit]=(fitsfile*)1; /* in case want to reuse it */ } } FCALLSCSUB2(Cffclos,FTCLOS,ftclos,INT,PINT) void Cffdelt( int unit, int *status ); void Cffdelt( int unit, int *status ) { if( gFitsFiles[unit]!=NULL && gFitsFiles[unit]!=(void*)1 ) { ffdelt( gFitsFiles[unit], status ); /* Flag unit number as unavailable */ gFitsFiles[unit]=(fitsfile*)1; /* in case want to reuse it */ } } FCALLSCSUB2(Cffdelt,FTDELT,ftdelt,INT,PINT) FCALLSCSUB3(ffflnm,FTFLNM,ftflnm,FITSUNIT,PSTRING,PINT) FCALLSCSUB3(ffflmd,FTFLMD,ftflmd,FITSUNIT,PINT,PINT) /*--------------- utility routines ---------------*/ FCALLSCSUB1(ffvers,FTVERS,ftvers,PFLOAT) FCALLSCSUB1(ffupch,FTUPCH,ftupch,PSTRING) FCALLSCSUB2(ffgerr,FTGERR,ftgerr,INT,PSTRING) FCALLSCSUB1(ffpmsg,FTPMSG,ftpmsg,STRING) FCALLSCSUB1(ffgmsg,FTGMSG,ftgmsg,PSTRING) FCALLSCSUB0(ffcmsg,FTCMSG,ftcmsg) FCALLSCSUB0(ffpmrk,FTPMRK,ftpmrk) FCALLSCSUB0(ffcmrk,FTCMRK,ftcmrk) void Cffrprt( char *fname, int status ); void Cffrprt( char *fname, int status ) { if( !strcmp(fname,"STDOUT") || !strcmp(fname,"stdout") ) ffrprt( stdout, status ); else if( !strcmp(fname,"STDERR") || !strcmp(fname,"stderr") ) ffrprt( stderr, status ); else { FILE *fptr; fptr = fopen(fname, "a"); if (fptr==NULL) printf("file pointer is null.\n"); else { ffrprt(fptr,status); fclose(fptr); } } } FCALLSCSUB2(Cffrprt,FTRPRT,ftrprt,STRING,INT) FCALLSCSUB5(ffcmps,FTCMPS,ftcmps,STRING,STRING,LOGICAL,PLOGICAL,PLOGICAL) FCALLSCSUB2(fftkey,FTTKEY,fttkey,STRING,PINT) FCALLSCSUB2(fftrec,FTTREC,fttrec,STRING,PINT) FCALLSCSUB2(ffnchk,FTNCHK,ftnchk,FITSUNIT,PINT) FCALLSCSUB4(ffkeyn,FTKEYN,ftkeyn,STRING,INT,PSTRING,PINT) FCALLSCSUB4(ffgknm,FTGKNM,ftgknm,STRING,PSTRING, PINT, PINT) FCALLSCSUB4(ffnkey,FTNKEY,ftnkey,INT,STRING,PSTRING,PINT) FCALLSCSUB3(ffdtyp,FTDTYP,ftdtyp,STRING,PSTRING,PINT) FCALLSCFUN1(INT,ffgkcl,FTGKCL,ftgkcl,STRING) FCALLSCSUB5(ffmkky,FTMKKY,ftmkky,STRING,STRING,STRING,PSTRING,PINT) FCALLSCSUB4(ffpsvc,FTPSVC,ftpsvc,STRING,PSTRING,PSTRING,PINT) FCALLSCSUB4(ffgthd,FTGTHD,ftgthd,STRING,PSTRING,PINT,PINT) FCALLSCSUB5(ffasfm,FTASFM,ftasfm,STRING,PINT,PLONG,PINT,PINT) FCALLSCSUB5(ffbnfm,FTBNFM,ftbnfm,STRING,PINT,PLONG,PLONG,PINT) #define ftgabc_STRV_A2 NUM_ELEM_ARG(1) #define ftgabc_LONGV_A5 A1 FCALLSCSUB6(ffgabc,FTGABC,ftgabc,INT,STRINGV,INT,PLONG,LONGV,PINT) healpy-1.10.3/cfitsio/f77_wrap2.c0000664000175000017500000007720113010375005016651 0ustar zoncazonca00000000000000/************************************************************************ f77_wrap1.c and f77_wrap2.c have now been split into 4 files to prevent compile-time memory errors (from expansion of compiler commands). f77_wrap1.c was split into f77_wrap1.c and f77_wrap3.c, and f77_wrap2.c was split into f77_wrap2.c and f77_wrap4.c: f77_wrap1.c contains routines operating on whole files and some utility routines. f77_wrap2.c contains routines operating on primary array, image, or column elements. f77_wrap3.c contains routines operating on headers & keywords. f77_wrap4.c contains miscellaneous routines. Peter's original comments: Together, f77_wrap1.c and f77_wrap2.c contain C wrappers for all the CFITSIO routines prototyped in fitsio.h, except for the generic datatype routines and features not supported in fortran (eg, unsigned integers), a few routines prototyped in fitsio2.h, which only a handful of FTOOLS use, plus a few obsolete FITSIO routines not present in CFITSIO. This file allows Fortran code to use the CFITSIO library instead of the FITSIO library without modification. It also gives access to new routines not present in FITSIO. Fortran FTOOLS must continue using the old routine names from FITSIO (ie, ftxxxx), but most of the C-wrappers simply redirect those calls to the corresponding CFITSIO routines (ie, ffxxxx), with appropriate parameter massaging where necessary. The main exception are read/write routines ending in j (ie, long data) which get redirected to C routines ending in k (ie, int data). This is more consistent with the default integer type in Fortran. f77_wrap1.c primarily holds routines operating on whole files and extension headers. f77_wrap2.c handle routines which read and write the data portion, plus miscellaneous extra routines. File created by Peter Wilson (HSTX), Oct-Dec. 1997 ************************************************************************/ #include "fitsio2.h" #include "f77_wrap.h" FCALLSCSUB5(ffgextn,FTGEXTN,ftgextn,FITSUNIT,LONG,LONG,BYTEV,PINT) FCALLSCSUB5(ffpextn,FTPEXTN,ftpextn,FITSUNIT,LONG,LONG,BYTEV,PINT) /*------------ read primary array or image elements -------------*/ FCALLSCSUB8(ffgpvb,FTGPVB,ftgpvb,FITSUNIT,LONG,LONG,LONG,BYTE,BYTEV,PLOGICAL,PINT) FCALLSCSUB8(ffgpvi,FTGPVI,ftgpvi,FITSUNIT,LONG,LONG,LONG,SHORT,SHORTV,PLOGICAL,PINT) FCALLSCSUB8(ffgpvk,FTGPVJ,ftgpvj,FITSUNIT,LONG,LONG,LONG,INT,INTV,PLOGICAL,PINT) FCALLSCSUB8(ffgpvjj,FTGPVK,ftgpvk,FITSUNIT,LONG,LONG,LONG,LONGLONG,LONGLONGV,PLOGICAL,PINT) FCALLSCSUB8(ffgpve,FTGPVE,ftgpve,FITSUNIT,LONG,LONG,LONG,FLOAT,FLOATV,PLOGICAL,PINT) FCALLSCSUB8(ffgpvd,FTGPVD,ftgpvd,FITSUNIT,LONG,LONG,LONG,DOUBLE,DOUBLEV,PLOGICAL,PINT) #define ftgpfb_LOGV_A6 A4 FCALLSCSUB8(ffgpfb,FTGPFB,ftgpfb,FITSUNIT,LONG,LONG,LONG,BYTEV,LOGICALV,PLOGICAL,PINT) #define ftgpfi_LOGV_A6 A4 FCALLSCSUB8(ffgpfi,FTGPFI,ftgpfi,FITSUNIT,LONG,LONG,LONG,SHORTV,LOGICALV,PLOGICAL,PINT) #define ftgpfj_LOGV_A6 A4 FCALLSCSUB8(ffgpfk,FTGPFJ,ftgpfj,FITSUNIT,LONG,LONG,LONG,INTV,LOGICALV,PLOGICAL,PINT) #define ftgpfk_LOGV_A6 A4 FCALLSCSUB8(ffgpfjj,FTGPFK,ftgpfk,FITSUNIT,LONG,LONG,LONG,LONGLONGV,LOGICALV,PLOGICAL,PINT) #define ftgpfe_LOGV_A6 A4 FCALLSCSUB8(ffgpfe,FTGPFE,ftgpfe,FITSUNIT,LONG,LONG,LONG,FLOATV,LOGICALV,PLOGICAL,PINT) #define ftgpfd_LOGV_A6 A4 FCALLSCSUB8(ffgpfd,FTGPFD,ftgpfd,FITSUNIT,LONG,LONG,LONG,DOUBLEV,LOGICALV,PLOGICAL,PINT) FCALLSCSUB9(ffg2db,FTG2DB,ftg2db,FITSUNIT,LONG,BYTE,LONG,LONG,LONG,BYTEV,PLOGICAL,PINT) FCALLSCSUB9(ffg2di,FTG2DI,ftg2di,FITSUNIT,LONG,SHORT,LONG,LONG,LONG,SHORTV,PLOGICAL,PINT) FCALLSCSUB9(ffg2dk,FTG2DJ,ftg2dj,FITSUNIT,LONG,INT,LONG,LONG,LONG,INTV,PLOGICAL,PINT) FCALLSCSUB9(ffg2djj,FTG2DK,ftg2dk,FITSUNIT,LONG,LONGLONG,LONG,LONG,LONG,LONGLONGV,PLOGICAL,PINT) FCALLSCSUB9(ffg2de,FTG2DE,ftg2de,FITSUNIT,LONG,FLOAT,LONG,LONG,LONG,FLOATV,PLOGICAL,PINT) FCALLSCSUB9(ffg2dd,FTG2DD,ftg2dd,FITSUNIT,LONG,DOUBLE,LONG,LONG,LONG,DOUBLEV,PLOGICAL,PINT) FCALLSCSUB11(ffg3db,FTG3DB,ftg3db,FITSUNIT,LONG,BYTE,LONG,LONG,LONG,LONG,LONG,BYTEV,PLOGICAL,PINT) FCALLSCSUB11(ffg3di,FTG3DI,ftg3di,FITSUNIT,LONG,SHORT,LONG,LONG,LONG,LONG,LONG,SHORTV,PLOGICAL,PINT) FCALLSCSUB11(ffg3dk,FTG3DJ,ftg3dj,FITSUNIT,LONG,INT,LONG,LONG,LONG,LONG,LONG,INTV,PLOGICAL,PINT) FCALLSCSUB11(ffg3djj,FTG3DK,ftg3dk,FITSUNIT,LONG,LONGLONG,LONG,LONG,LONG,LONG,LONG,LONGLONGV,PLOGICAL,PINT) FCALLSCSUB11(ffg3de,FTG3DE,ftg3de,FITSUNIT,LONG,FLOAT,LONG,LONG,LONG,LONG,LONG,FLOATV,PLOGICAL,PINT) FCALLSCSUB11(ffg3dd,FTG3DD,ftg3dd,FITSUNIT,LONG,DOUBLE,LONG,LONG,LONG,LONG,LONG,DOUBLEV,PLOGICAL,PINT) /* The follow LONGV definitions have +1 appended because the */ /* routines use of NAXIS+1 elements of the long vectors. */ #define ftgsvb_LONGV_A4 A3+1 #define ftgsvb_LONGV_A5 A3+1 #define ftgsvb_LONGV_A6 A3+1 #define ftgsvb_LONGV_A7 A3+1 FCALLSCSUB11(ffgsvb,FTGSVB,ftgsvb,FITSUNIT,INT,INT,LONGV,LONGV,LONGV,LONGV,BYTE,BYTEV,PLOGICAL,PINT) #define ftgsvi_LONGV_A4 A3+1 #define ftgsvi_LONGV_A5 A3+1 #define ftgsvi_LONGV_A6 A3+1 #define ftgsvi_LONGV_A7 A3+1 FCALLSCSUB11(ffgsvi,FTGSVI,ftgsvi,FITSUNIT,INT,INT,LONGV,LONGV,LONGV,LONGV,SHORT,SHORTV,PLOGICAL,PINT) #define ftgsvj_LONGV_A4 A3+1 #define ftgsvj_LONGV_A5 A3+1 #define ftgsvj_LONGV_A6 A3+1 #define ftgsvj_LONGV_A7 A3+1 FCALLSCSUB11(ffgsvk,FTGSVJ,ftgsvj,FITSUNIT,INT,INT,LONGV,LONGV,LONGV,LONGV,INT,INTV,PLOGICAL,PINT) #define ftgsvk_LONGV_A4 A3+1 #define ftgsvk_LONGV_A5 A3+1 #define ftgsvk_LONGV_A6 A3+1 #define ftgsvk_LONGV_A7 A3+1 FCALLSCSUB11(ffgsvjj,FTGSVK,ftgsvk,FITSUNIT,INT,INT,LONGV,LONGV,LONGV,LONGV,LONGLONG,LONGLONGV,PLOGICAL,PINT) #define ftgsve_LONGV_A4 A3+1 #define ftgsve_LONGV_A5 A3+1 #define ftgsve_LONGV_A6 A3+1 #define ftgsve_LONGV_A7 A3+1 FCALLSCSUB11(ffgsve,FTGSVE,ftgsve,FITSUNIT,INT,INT,LONGV,LONGV,LONGV,LONGV,FLOAT,FLOATV,PLOGICAL,PINT) #define ftgsvd_LONGV_A4 A3+1 #define ftgsvd_LONGV_A5 A3+1 #define ftgsvd_LONGV_A6 A3+1 #define ftgsvd_LONGV_A7 A3+1 FCALLSCSUB11(ffgsvd,FTGSVD,ftgsvd,FITSUNIT,INT,INT,LONGV,LONGV,LONGV,LONGV,DOUBLE,DOUBLEV,PLOGICAL,PINT) /* Must handle LOGICALV conversion manually */ void Cffgsfb( fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned char *array, int *flagval, int *anynul, int *status ); void Cffgsfb( fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned char *array, int *flagval, int *anynul, int *status ) { char *Cflagval; long nflagval; int i; for( nflagval=1, i=0; iFwork_fn(&a1,&a2,&a3,&a4,&n_cols,units,colnum,datatype, iotype,repeat,&status,f->userData, ptrs[ 0], ptrs[ 1], ptrs[ 2], ptrs[ 3], ptrs[ 4], ptrs[ 5], ptrs[ 6], ptrs[ 7], ptrs[ 8], ptrs[ 9], ptrs[10], ptrs[11], ptrs[12], ptrs[13], ptrs[14], ptrs[15], ptrs[16], ptrs[17], ptrs[18], ptrs[19], ptrs[20], ptrs[21], ptrs[22], ptrs[23], ptrs[24] ); } /* Check whether there are any LOGICAL or STRING columns being outputted */ nstr=0; for( i=0;i #include #include #include #include "fitsio2.h" static long noutchar; static long noutmax; static int htrans(int a[],int nx,int ny); static void digitize(int a[], int nx, int ny, int scale); static int encode(char *outfile, long *nlen, int a[], int nx, int ny, int scale); static void shuffle(int a[], int n, int n2, int tmp[]); static int htrans64(LONGLONG a[],int nx,int ny); static void digitize64(LONGLONG a[], int nx, int ny, int scale); static int encode64(char *outfile, long *nlen, LONGLONG a[], int nx, int ny, int scale); static void shuffle64(LONGLONG a[], int n, int n2, LONGLONG tmp[]); static void writeint(char *outfile, int a); static void writelonglong(char *outfile, LONGLONG a); static int doencode(char *outfile, int a[], int nx, int ny, unsigned char nbitplanes[3]); static int doencode64(char *outfile, LONGLONG a[], int nx, int ny, unsigned char nbitplanes[3]); static int qwrite(char *file, char buffer[], int n); static int qtree_encode(char *outfile, int a[], int n, int nqx, int nqy, int nbitplanes); static int qtree_encode64(char *outfile, LONGLONG a[], int n, int nqx, int nqy, int nbitplanes); static void start_outputing_bits(void); static void done_outputing_bits(char *outfile); static void output_nbits(char *outfile, int bits, int n); static void qtree_onebit(int a[], int n, int nx, int ny, unsigned char b[], int bit); static void qtree_onebit64(LONGLONG a[], int n, int nx, int ny, unsigned char b[], int bit); static void qtree_reduce(unsigned char a[], int n, int nx, int ny, unsigned char b[]); static int bufcopy(unsigned char a[], int n, unsigned char buffer[], int *b, int bmax); static void write_bdirect(char *outfile, int a[], int n,int nqx, int nqy, unsigned char scratch[], int bit); static void write_bdirect64(char *outfile, LONGLONG a[], int n,int nqx, int nqy, unsigned char scratch[], int bit); /* #define output_nybble(outfile,c) output_nbits(outfile,c,4) */ static void output_nybble(char *outfile, int bits); static void output_nnybble(char *outfile, int n, unsigned char array[]); #define output_huffman(outfile,c) output_nbits(outfile,code[c],ncode[c]) /* ---------------------------------------------------------------------- */ int fits_hcompress(int *a, int ny, int nx, int scale, char *output, long *nbytes, int *status) { /* compress the input image using the H-compress algorithm a - input image array nx - size of X axis of image ny - size of Y axis of image scale - quantization scale factor. Larger values results in more (lossy) compression scale = 0 does lossless compression output - pre-allocated array to hold the output compressed stream of bytes nbyts - input value = size of the output buffer; returned value = size of the compressed byte stream, in bytes NOTE: the nx and ny dimensions as defined within this code are reversed from the usual FITS notation. ny is the fastest varying dimension, which is usually considered the X axis in the FITS image display */ int stat; if (*status > 0) return(*status); /* H-transform */ stat = htrans(a, nx, ny); if (stat) { *status = stat; return(*status); } /* digitize */ digitize(a, nx, ny, scale); /* encode and write to output array */ FFLOCK; noutmax = *nbytes; /* input value is the allocated size of the array */ *nbytes = 0; /* reset */ stat = encode(output, nbytes, a, nx, ny, scale); FFUNLOCK; *status = stat; return(*status); } /* ---------------------------------------------------------------------- */ int fits_hcompress64(LONGLONG *a, int ny, int nx, int scale, char *output, long *nbytes, int *status) { /* compress the input image using the H-compress algorithm a - input image array nx - size of X axis of image ny - size of Y axis of image scale - quantization scale factor. Larger values results in more (lossy) compression scale = 0 does lossless compression output - pre-allocated array to hold the output compressed stream of bytes nbyts - size of the compressed byte stream, in bytes NOTE: the nx and ny dimensions as defined within this code are reversed from the usual FITS notation. ny is the fastest varying dimension, which is usually considered the X axis in the FITS image display */ int stat; if (*status > 0) return(*status); /* H-transform */ stat = htrans64(a, nx, ny); if (stat) { *status = stat; return(*status); } /* digitize */ digitize64(a, nx, ny, scale); /* encode and write to output array */ FFLOCK; noutmax = *nbytes; /* input value is the allocated size of the array */ *nbytes = 0; /* reset */ stat = encode64(output, nbytes, a, nx, ny, scale); FFUNLOCK; *status = stat; return(*status); } /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* htrans.c H-transform of NX x NY integer image * * Programmer: R. White Date: 11 May 1992 */ /* ######################################################################### */ static int htrans(int a[],int nx,int ny) { int nmax, log2n, h0, hx, hy, hc, nxtop, nytop, i, j, k; int oddx, oddy; int shift, mask, mask2, prnd, prnd2, nrnd2; int s10, s00; int *tmp; /* * log2n is log2 of max(nx,ny) rounded up to next power of 2 */ nmax = (nx>ny) ? nx : ny; log2n = (int) (log((float) nmax)/log(2.0)+0.5); if ( nmax > (1<> shift; hx = (a[s10+1] + a[s10] - a[s00+1] - a[s00]) >> shift; hy = (a[s10+1] - a[s10] + a[s00+1] - a[s00]) >> shift; hc = (a[s10+1] - a[s10] - a[s00+1] + a[s00]) >> shift; /* * Throw away the 2 bottom bits of h0, bottom bit of hx,hy. * To get rounding to be same for positive and negative * numbers, nrnd2 = prnd2 - 1. */ a[s10+1] = hc; a[s10 ] = ( (hx>=0) ? (hx+prnd) : hx ) & mask ; a[s00+1] = ( (hy>=0) ? (hy+prnd) : hy ) & mask ; a[s00 ] = ( (h0>=0) ? (h0+prnd2) : (h0+nrnd2) ) & mask2; s00 += 2; s10 += 2; } if (oddy) { /* * do last element in row if row length is odd * s00+1, s10+1 are off edge */ h0 = (a[s10] + a[s00]) << (1-shift); hx = (a[s10] - a[s00]) << (1-shift); a[s10 ] = ( (hx>=0) ? (hx+prnd) : hx ) & mask ; a[s00 ] = ( (h0>=0) ? (h0+prnd2) : (h0+nrnd2) ) & mask2; s00 += 1; s10 += 1; } } if (oddx) { /* * do last row if column length is odd * s10, s10+1 are off edge */ s00 = i*ny; for (j = 0; j=0) ? (hy+prnd) : hy ) & mask ; a[s00 ] = ( (h0>=0) ? (h0+prnd2) : (h0+nrnd2) ) & mask2; s00 += 2; } if (oddy) { /* * do corner element if both row and column lengths are odd * s00+1, s10, s10+1 are off edge */ h0 = a[s00] << (2-shift); a[s00 ] = ( (h0>=0) ? (h0+prnd2) : (h0+nrnd2) ) & mask2; } } /* * now shuffle in each dimension to group coefficients by order */ for (i = 0; i>1; nytop = (nytop+1)>>1; /* * divisor doubles after first reduction */ shift = 1; /* * masks, rounding values double after each iteration */ mask = mask2; prnd = prnd2; mask2 = mask2 << 1; prnd2 = prnd2 << 1; nrnd2 = prnd2 - 1; } free(tmp); return(0); } /* ######################################################################### */ static int htrans64(LONGLONG a[],int nx,int ny) { int nmax, log2n, nxtop, nytop, i, j, k; int oddx, oddy; int shift; int s10, s00; LONGLONG h0, hx, hy, hc, prnd, prnd2, nrnd2, mask, mask2; LONGLONG *tmp; /* * log2n is log2 of max(nx,ny) rounded up to next power of 2 */ nmax = (nx>ny) ? nx : ny; log2n = (int) (log((float) nmax)/log(2.0)+0.5); if ( nmax > (1<> shift; hx = (a[s10+1] + a[s10] - a[s00+1] - a[s00]) >> shift; hy = (a[s10+1] - a[s10] + a[s00+1] - a[s00]) >> shift; hc = (a[s10+1] - a[s10] - a[s00+1] + a[s00]) >> shift; /* * Throw away the 2 bottom bits of h0, bottom bit of hx,hy. * To get rounding to be same for positive and negative * numbers, nrnd2 = prnd2 - 1. */ a[s10+1] = hc; a[s10 ] = ( (hx>=0) ? (hx+prnd) : hx ) & mask ; a[s00+1] = ( (hy>=0) ? (hy+prnd) : hy ) & mask ; a[s00 ] = ( (h0>=0) ? (h0+prnd2) : (h0+nrnd2) ) & mask2; s00 += 2; s10 += 2; } if (oddy) { /* * do last element in row if row length is odd * s00+1, s10+1 are off edge */ h0 = (a[s10] + a[s00]) << (1-shift); hx = (a[s10] - a[s00]) << (1-shift); a[s10 ] = ( (hx>=0) ? (hx+prnd) : hx ) & mask ; a[s00 ] = ( (h0>=0) ? (h0+prnd2) : (h0+nrnd2) ) & mask2; s00 += 1; s10 += 1; } } if (oddx) { /* * do last row if column length is odd * s10, s10+1 are off edge */ s00 = i*ny; for (j = 0; j=0) ? (hy+prnd) : hy ) & mask ; a[s00 ] = ( (h0>=0) ? (h0+prnd2) : (h0+nrnd2) ) & mask2; s00 += 2; } if (oddy) { /* * do corner element if both row and column lengths are odd * s00+1, s10, s10+1 are off edge */ h0 = a[s00] << (2-shift); a[s00 ] = ( (h0>=0) ? (h0+prnd2) : (h0+nrnd2) ) & mask2; } } /* * now shuffle in each dimension to group coefficients by order */ for (i = 0; i>1; nytop = (nytop+1)>>1; /* * divisor doubles after first reduction */ shift = 1; /* * masks, rounding values double after each iteration */ mask = mask2; prnd = prnd2; mask2 = mask2 << 1; prnd2 = prnd2 << 1; nrnd2 = prnd2 - 1; } free(tmp); return(0); } /* ######################################################################### */ static void shuffle(int a[], int n, int n2, int tmp[]) { /* int a[]; array to shuffle int n; number of elements to shuffle int n2; second dimension int tmp[]; scratch storage */ int i; int *p1, *p2, *pt; /* * copy odd elements to tmp */ pt = tmp; p1 = &a[n2]; for (i=1; i < n; i += 2) { *pt = *p1; pt += 1; p1 += (n2+n2); } /* * compress even elements into first half of A */ p1 = &a[n2]; p2 = &a[n2+n2]; for (i=2; i0) ? (*p+d) : (*p-d))/scale; } /* ######################################################################### */ static void digitize64(LONGLONG a[], int nx, int ny, int scale) { LONGLONG d, *p, scale64; /* * round to multiple of scale */ if (scale <= 1) return; d=(scale+1)/2-1; scale64 = scale; /* use a 64-bit int for efficiency in the big loop */ for (p=a; p <= &a[nx*ny-1]; p++) *p = ((*p>0) ? (*p+d) : (*p-d))/scale64; } /* ######################################################################### */ /* ######################################################################### */ /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* encode.c encode H-transform and write to outfile * * Programmer: R. White Date: 2 February 1994 */ static char code_magic[2] = { (char)0xDD, (char)0x99 }; /* ######################################################################### */ static int encode(char *outfile, long *nlength, int a[], int nx, int ny, int scale) { /* FILE *outfile; - change outfile to a char array */ /* long * nlength returned length (in bytes) of the encoded array) int a[]; input H-transform array (nx,ny) int nx,ny; size of H-transform array int scale; scale factor for digitization */ int nel, nx2, ny2, i, j, k, q, vmax[3], nsign, bits_to_go; unsigned char nbitplanes[3]; unsigned char *signbits; int stat; noutchar = 0; /* initialize the number of compressed bytes that have been written */ nel = nx*ny; /* * write magic value */ qwrite(outfile, code_magic, sizeof(code_magic)); writeint(outfile, nx); /* size of image */ writeint(outfile, ny); writeint(outfile, scale); /* scale factor for digitization */ /* * write first value of A (sum of all pixels -- the only value * which does not compress well) */ writelonglong(outfile, (LONGLONG) a[0]); a[0] = 0; /* * allocate array for sign bits and save values, 8 per byte */ signbits = (unsigned char *) malloc((nel+7)/8); if (signbits == (unsigned char *) NULL) { ffpmsg("encode: insufficient memory"); return(DATA_COMPRESSION_ERR); } nsign = 0; bits_to_go = 8; signbits[0] = 0; for (i=0; i 0) { /* * positive element, put zero at end of buffer */ signbits[nsign] <<= 1; bits_to_go -= 1; } else if (a[i] < 0) { /* * negative element, shift in a one */ signbits[nsign] <<= 1; signbits[nsign] |= 1; bits_to_go -= 1; /* * replace a by absolute value */ a[i] = -a[i]; } if (bits_to_go == 0) { /* * filled up this byte, go to the next one */ bits_to_go = 8; nsign += 1; signbits[nsign] = 0; } } if (bits_to_go != 8) { /* * some bits in last element * move bits in last byte to bottom and increment nsign */ signbits[nsign] <<= bits_to_go; nsign += 1; } /* * calculate number of bit planes for 3 quadrants * * quadrant 0=bottom left, 1=bottom right or top left, 2=top right, */ for (q=0; q<3; q++) { vmax[q] = 0; } /* * get maximum absolute value in each quadrant */ nx2 = (nx+1)/2; ny2 = (ny+1)/2; j=0; /* column counter */ k=0; /* row counter */ for (i=0; i=ny2) + (k>=nx2); if (vmax[q] < a[i]) vmax[q] = a[i]; if (++j >= ny) { j = 0; k += 1; } } /* * now calculate number of bits for each quadrant */ /* this is a more efficient way to do this, */ for (q = 0; q < 3; q++) { for (nbitplanes[q] = 0; vmax[q]>0; vmax[q] = vmax[q]>>1, nbitplanes[q]++) ; } /* for (q = 0; q < 3; q++) { nbitplanes[q] = (int) (log((float) (vmax[q]+1))/log(2.0)+0.5); if ( (vmax[q]+1) > (1< 0) { if ( 0 == qwrite(outfile, (char *) signbits, nsign)) { free(signbits); *nlength = noutchar; ffpmsg("encode: output buffer too small"); return(DATA_COMPRESSION_ERR); } } free(signbits); *nlength = noutchar; if (noutchar >= noutmax) { ffpmsg("encode: output buffer too small"); return(DATA_COMPRESSION_ERR); } return(stat); } /* ######################################################################### */ static int encode64(char *outfile, long *nlength, LONGLONG a[], int nx, int ny, int scale) { /* FILE *outfile; - change outfile to a char array */ /* long * nlength returned length (in bytes) of the encoded array) LONGLONG a[]; input H-transform array (nx,ny) int nx,ny; size of H-transform array int scale; scale factor for digitization */ int nel, nx2, ny2, i, j, k, q, nsign, bits_to_go; LONGLONG vmax[3]; unsigned char nbitplanes[3]; unsigned char *signbits; int stat; noutchar = 0; /* initialize the number of compressed bytes that have been written */ nel = nx*ny; /* * write magic value */ qwrite(outfile, code_magic, sizeof(code_magic)); writeint(outfile, nx); /* size of image */ writeint(outfile, ny); writeint(outfile, scale); /* scale factor for digitization */ /* * write first value of A (sum of all pixels -- the only value * which does not compress well) */ writelonglong(outfile, a[0]); a[0] = 0; /* * allocate array for sign bits and save values, 8 per byte */ signbits = (unsigned char *) malloc((nel+7)/8); if (signbits == (unsigned char *) NULL) { ffpmsg("encode64: insufficient memory"); return(DATA_COMPRESSION_ERR); } nsign = 0; bits_to_go = 8; signbits[0] = 0; for (i=0; i 0) { /* * positive element, put zero at end of buffer */ signbits[nsign] <<= 1; bits_to_go -= 1; } else if (a[i] < 0) { /* * negative element, shift in a one */ signbits[nsign] <<= 1; signbits[nsign] |= 1; bits_to_go -= 1; /* * replace a by absolute value */ a[i] = -a[i]; } if (bits_to_go == 0) { /* * filled up this byte, go to the next one */ bits_to_go = 8; nsign += 1; signbits[nsign] = 0; } } if (bits_to_go != 8) { /* * some bits in last element * move bits in last byte to bottom and increment nsign */ signbits[nsign] <<= bits_to_go; nsign += 1; } /* * calculate number of bit planes for 3 quadrants * * quadrant 0=bottom left, 1=bottom right or top left, 2=top right, */ for (q=0; q<3; q++) { vmax[q] = 0; } /* * get maximum absolute value in each quadrant */ nx2 = (nx+1)/2; ny2 = (ny+1)/2; j=0; /* column counter */ k=0; /* row counter */ for (i=0; i=ny2) + (k>=nx2); if (vmax[q] < a[i]) vmax[q] = a[i]; if (++j >= ny) { j = 0; k += 1; } } /* * now calculate number of bits for each quadrant */ /* this is a more efficient way to do this, */ for (q = 0; q < 3; q++) { for (nbitplanes[q] = 0; vmax[q]>0; vmax[q] = vmax[q]>>1, nbitplanes[q]++) ; } /* for (q = 0; q < 3; q++) { nbitplanes[q] = log((float) (vmax[q]+1))/log(2.0)+0.5; if ( (vmax[q]+1) > (((LONGLONG) 1)< 0) { if ( 0 == qwrite(outfile, (char *) signbits, nsign)) { free(signbits); *nlength = noutchar; ffpmsg("encode: output buffer too small"); return(DATA_COMPRESSION_ERR); } } free(signbits); *nlength = noutchar; if (noutchar >= noutmax) { ffpmsg("encode64: output buffer too small"); return(DATA_COMPRESSION_ERR); } return(stat); } /* ######################################################################### */ /* ######################################################################### */ /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* qwrite.c Write binary data * * Programmer: R. White Date: 11 March 1991 */ /* ######################################################################### */ static void writeint(char *outfile, int a) { int i; unsigned char b[4]; /* Write integer A one byte at a time to outfile. * * This is portable from Vax to Sun since it eliminates the * need for byte-swapping. */ for (i=3; i>=0; i--) { b[i] = a & 0x000000ff; a >>= 8; } for (i=0; i<4; i++) qwrite(outfile, (char *) &b[i],1); } /* ######################################################################### */ static void writelonglong(char *outfile, LONGLONG a) { int i; unsigned char b[8]; /* Write integer A one byte at a time to outfile. * * This is portable from Vax to Sun since it eliminates the * need for byte-swapping. */ for (i=7; i>=0; i--) { b[i] = (unsigned char) (a & 0x000000ff); a >>= 8; } for (i=0; i<8; i++) qwrite(outfile, (char *) &b[i],1); } /* ######################################################################### */ static int qwrite(char *file, char buffer[], int n){ /* * write n bytes from buffer into file * returns number of bytes read (=n) if successful, <=0 if not */ if (noutchar + n > noutmax) return(0); /* buffer overflow */ memcpy(&file[noutchar], buffer, n); noutchar += n; return(n); } /* ######################################################################### */ /* ######################################################################### */ /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* doencode.c Encode 2-D array and write stream of characters on outfile * * This version assumes that A is positive. * * Programmer: R. White Date: 7 May 1991 */ /* ######################################################################### */ static int doencode(char *outfile, int a[], int nx, int ny, unsigned char nbitplanes[3]) { /* char *outfile; output data stream int a[]; Array of values to encode int nx,ny; Array dimensions [nx][ny] unsigned char nbitplanes[3]; Number of bit planes in quadrants */ int nx2, ny2, stat; nx2 = (nx+1)/2; ny2 = (ny+1)/2; /* * Initialize bit output */ start_outputing_bits(); /* * write out the bit planes for each quadrant */ stat = qtree_encode(outfile, &a[0], ny, nx2, ny2, nbitplanes[0]); if (!stat) stat = qtree_encode(outfile, &a[ny2], ny, nx2, ny/2, nbitplanes[1]); if (!stat) stat = qtree_encode(outfile, &a[ny*nx2], ny, nx/2, ny2, nbitplanes[1]); if (!stat) stat = qtree_encode(outfile, &a[ny*nx2+ny2], ny, nx/2, ny/2, nbitplanes[2]); /* * Add zero as an EOF symbol */ output_nybble(outfile, 0); done_outputing_bits(outfile); return(stat); } /* ######################################################################### */ static int doencode64(char *outfile, LONGLONG a[], int nx, int ny, unsigned char nbitplanes[3]) { /* char *outfile; output data stream LONGLONG a[]; Array of values to encode int nx,ny; Array dimensions [nx][ny] unsigned char nbitplanes[3]; Number of bit planes in quadrants */ int nx2, ny2, stat; nx2 = (nx+1)/2; ny2 = (ny+1)/2; /* * Initialize bit output */ start_outputing_bits(); /* * write out the bit planes for each quadrant */ stat = qtree_encode64(outfile, &a[0], ny, nx2, ny2, nbitplanes[0]); if (!stat) stat = qtree_encode64(outfile, &a[ny2], ny, nx2, ny/2, nbitplanes[1]); if (!stat) stat = qtree_encode64(outfile, &a[ny*nx2], ny, nx/2, ny2, nbitplanes[1]); if (!stat) stat = qtree_encode64(outfile, &a[ny*nx2+ny2], ny, nx/2, ny/2, nbitplanes[2]); /* * Add zero as an EOF symbol */ output_nybble(outfile, 0); done_outputing_bits(outfile); return(stat); } /* ######################################################################### */ /* ######################################################################### */ /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* BIT OUTPUT ROUTINES */ static LONGLONG bitcount; /* THE BIT BUFFER */ static int buffer2; /* Bits buffered for output */ static int bits_to_go2; /* Number of bits free in buffer */ /* ######################################################################### */ /* INITIALIZE FOR BIT OUTPUT */ static void start_outputing_bits(void) { buffer2 = 0; /* Buffer is empty to start */ bits_to_go2 = 8; /* with */ bitcount = 0; } /* ######################################################################### */ /* OUTPUT N BITS (N must be <= 8) */ static void output_nbits(char *outfile, int bits, int n) { /* AND mask for the right-most n bits */ static int mask[9] = {0, 1, 3, 7, 15, 31, 63, 127, 255}; /* * insert bits at end of buffer */ buffer2 <<= n; /* buffer2 |= ( bits & ((1<>(-bits_to_go2)) & 0xff); if (noutchar < noutmax) noutchar++; bits_to_go2 += 8; } bitcount += n; } /* ######################################################################### */ /* OUTPUT a 4 bit nybble */ static void output_nybble(char *outfile, int bits) { /* * insert 4 bits at end of buffer */ buffer2 = (buffer2<<4) | ( bits & 15 ); bits_to_go2 -= 4; if (bits_to_go2 <= 0) { /* * buffer2 full, put out top 8 bits */ outfile[noutchar] = ((buffer2>>(-bits_to_go2)) & 0xff); if (noutchar < noutmax) noutchar++; bits_to_go2 += 8; } bitcount += 4; } /* ############################################################################ */ /* OUTPUT array of 4 BITS */ static void output_nnybble(char *outfile, int n, unsigned char array[]) { /* pack the 4 lower bits in each element of the array into the outfile array */ int ii, jj, kk = 0, shift; if (n == 1) { output_nybble(outfile, (int) array[0]); return; } /* forcing byte alignment doesn;t help, and even makes it go slightly slower if (bits_to_go2 != 8) output_nbits(outfile, kk, bits_to_go2); */ if (bits_to_go2 <= 4) { /* just room for 1 nybble; write it out separately */ output_nybble(outfile, array[0]); kk++; /* index to next array element */ if (n == 2) /* only 1 more nybble to write out */ { output_nybble(outfile, (int) array[1]); return; } } /* bits_to_go2 is now in the range 5 - 8 */ shift = 8 - bits_to_go2; /* now write out pairs of nybbles; this does not affect value of bits_to_go2 */ jj = (n - kk) / 2; if (bits_to_go2 == 8) { /* special case if nybbles are aligned on byte boundary */ /* this actually seems to make very little differnece in speed */ buffer2 = 0; for (ii = 0; ii < jj; ii++) { outfile[noutchar] = ((array[kk] & 15)<<4) | (array[kk+1] & 15); kk += 2; noutchar++; } } else { for (ii = 0; ii < jj; ii++) { buffer2 = (buffer2<<8) | ((array[kk] & 15)<<4) | (array[kk+1] & 15); kk += 2; /* buffer2 full, put out top 8 bits */ outfile[noutchar] = ((buffer2>>shift) & 0xff); noutchar++; } } bitcount += (8 * (ii - 1)); /* write out last odd nybble, if present */ if (kk != n) output_nybble(outfile, (int) array[n - 1]); return; } /* ######################################################################### */ /* FLUSH OUT THE LAST BITS */ static void done_outputing_bits(char *outfile) { if(bits_to_go2 < 8) { /* putc(buffer2<nqy) ? nqx : nqy; log2n = (int) (log((float) nqmax)/log(2.0)+0.5); if (nqmax > (1<= 0; bit--) { /* * initial bit buffer */ b = 0; bitbuffer = 0; bits_to_go3 = 0; /* * on first pass copy A to scratch array */ qtree_onebit(a,n,nqx,nqy,scratch,bit); nx = (nqx+1)>>1; ny = (nqy+1)>>1; /* * copy non-zero values to output buffer, which will be written * in reverse order */ if (bufcopy(scratch,nx*ny,buffer,&b,bmax)) { /* * quadtree is expanding data, * change warning code and just fill buffer with bit-map */ write_bdirect(outfile,a,n,nqx,nqy,scratch,bit); goto bitplane_done; } /* * do log2n reductions */ for (k = 1; k>1; ny = (ny+1)>>1; if (bufcopy(scratch,nx*ny,buffer,&b,bmax)) { write_bdirect(outfile,a,n,nqx,nqy,scratch,bit); goto bitplane_done; } } /* * OK, we've got the code in buffer * Write quadtree warning code, then write buffer in reverse order */ output_nybble(outfile,0xF); if (b==0) { if (bits_to_go3>0) { /* * put out the last few bits */ output_nbits(outfile, bitbuffer & ((1<0) { /* * put out the last few bits */ output_nbits(outfile, bitbuffer & ((1<=0; i--) { output_nbits(outfile,buffer[i],8); } } bitplane_done: ; } free(buffer); free(scratch); return(0); } /* ######################################################################### */ static int qtree_encode64(char *outfile, LONGLONG a[], int n, int nqx, int nqy, int nbitplanes) { /* LONGLONG a[]; int n; physical dimension of row in a int nqx; length of row int nqy; length of column (<=n) int nbitplanes; number of bit planes to output */ int log2n, i, k, bit, b, nqmax, nqx2, nqy2, nx, ny; int bmax; /* this potentially needs to be made a 64-bit int to support large arrays */ unsigned char *scratch, *buffer; /* * log2n is log2 of max(nqx,nqy) rounded up to next power of 2 */ nqmax = (nqx>nqy) ? nqx : nqy; log2n = (int) (log((float) nqmax)/log(2.0)+0.5); if (nqmax > (1<= 0; bit--) { /* * initial bit buffer */ b = 0; bitbuffer = 0; bits_to_go3 = 0; /* * on first pass copy A to scratch array */ qtree_onebit64(a,n,nqx,nqy,scratch,bit); nx = (nqx+1)>>1; ny = (nqy+1)>>1; /* * copy non-zero values to output buffer, which will be written * in reverse order */ if (bufcopy(scratch,nx*ny,buffer,&b,bmax)) { /* * quadtree is expanding data, * change warning code and just fill buffer with bit-map */ write_bdirect64(outfile,a,n,nqx,nqy,scratch,bit); goto bitplane_done; } /* * do log2n reductions */ for (k = 1; k>1; ny = (ny+1)>>1; if (bufcopy(scratch,nx*ny,buffer,&b,bmax)) { write_bdirect64(outfile,a,n,nqx,nqy,scratch,bit); goto bitplane_done; } } /* * OK, we've got the code in buffer * Write quadtree warning code, then write buffer in reverse order */ output_nybble(outfile,0xF); if (b==0) { if (bits_to_go3>0) { /* * put out the last few bits */ output_nbits(outfile, bitbuffer & ((1<0) { /* * put out the last few bits */ output_nbits(outfile, bitbuffer & ((1<=0; i--) { output_nbits(outfile,buffer[i],8); } } bitplane_done: ; } free(buffer); free(scratch); return(0); } /* ######################################################################### */ /* * copy non-zero codes from array to buffer */ static int bufcopy(unsigned char a[], int n, unsigned char buffer[], int *b, int bmax) { int i; for (i = 0; i < n; i++) { if (a[i] != 0) { /* * add Huffman code for a[i] to buffer */ bitbuffer |= code[a[i]] << bits_to_go3; bits_to_go3 += ncode[a[i]]; if (bits_to_go3 >= 8) { buffer[*b] = bitbuffer & 0xFF; *b += 1; /* * return warning code if we fill buffer */ if (*b >= bmax) return(1); bitbuffer >>= 8; bits_to_go3 -= 8; } } } return(0); } /* ######################################################################### */ /* * Do first quadtree reduction step on bit BIT of array A. * Results put into B. * */ static void qtree_onebit(int a[], int n, int nx, int ny, unsigned char b[], int bit) { int i, j, k; int b0, b1, b2, b3; int s10, s00; /* * use selected bit to get amount to shift */ b0 = 1<> bit; k += 1; s00 += 2; s10 += 2; } if (j < ny) { /* * row size is odd, do last element in row * s00+1,s10+1 are off edge */ b[k] = ( ((a[s10 ]<<1) & b1) | ((a[s00 ]<<3) & b3) ) >> bit; k += 1; } } if (i < nx) { /* * column size is odd, do last row * s10,s10+1 are off edge */ s00 = n*i; for (j = 0; j> bit; k += 1; s00 += 2; } if (j < ny) { /* * both row and column size are odd, do corner element * s00+1, s10, s10+1 are off edge */ b[k] = ( ((a[s00 ]<<3) & b3) ) >> bit; k += 1; } } } /* ######################################################################### */ /* * Do first quadtree reduction step on bit BIT of array A. * Results put into B. * */ static void qtree_onebit64(LONGLONG a[], int n, int nx, int ny, unsigned char b[], int bit) { int i, j, k; LONGLONG b0, b1, b2, b3; int s10, s00; /* * use selected bit to get amount to shift */ b0 = ((LONGLONG) 1)<> bit); k += 1; s00 += 2; s10 += 2; } if (j < ny) { /* * row size is odd, do last element in row * s00+1,s10+1 are off edge */ b[k] = (unsigned char) (( ((a[s10 ]<<1) & b1) | ((a[s00 ]<<3) & b3) ) >> bit); k += 1; } } if (i < nx) { /* * column size is odd, do last row * s10,s10+1 are off edge */ s00 = n*i; for (j = 0; j> bit); k += 1; s00 += 2; } if (j < ny) { /* * both row and column size are odd, do corner element * s00+1, s10, s10+1 are off edge */ b[k] = (unsigned char) (( ((a[s00 ]<<3) & b3) ) >> bit); k += 1; } } } /* ######################################################################### */ /* * do one quadtree reduction step on array a * results put into b (which may be the same as a) */ static void qtree_reduce(unsigned char a[], int n, int nx, int ny, unsigned char b[]) { int i, j, k; int s10, s00; k = 0; /* k is index of b[i/2,j/2] */ for (i = 0; i #include #include #include #include "fitsio2.h" /* WDP added test to see if min and max are already defined */ #ifndef min #define min(a,b) (((a)<(b))?(a):(b)) #endif #ifndef max #define max(a,b) (((a)>(b))?(a):(b)) #endif static long nextchar; static int decode(unsigned char *infile, int *a, int *nx, int *ny, int *scale); static int decode64(unsigned char *infile, LONGLONG *a, int *nx, int *ny, int *scale); static int hinv(int a[], int nx, int ny, int smooth ,int scale); static int hinv64(LONGLONG a[], int nx, int ny, int smooth ,int scale); static void undigitize(int a[], int nx, int ny, int scale); static void undigitize64(LONGLONG a[], int nx, int ny, int scale); static void unshuffle(int a[], int n, int n2, int tmp[]); static void unshuffle64(LONGLONG a[], int n, int n2, LONGLONG tmp[]); static void hsmooth(int a[], int nxtop, int nytop, int ny, int scale); static void hsmooth64(LONGLONG a[], int nxtop, int nytop, int ny, int scale); static void qread(unsigned char *infile,char *a, int n); static int readint(unsigned char *infile); static LONGLONG readlonglong(unsigned char *infile); static int dodecode(unsigned char *infile, int a[], int nx, int ny, unsigned char nbitplanes[3]); static int dodecode64(unsigned char *infile, LONGLONG a[], int nx, int ny, unsigned char nbitplanes[3]); static int qtree_decode(unsigned char *infile, int a[], int n, int nqx, int nqy, int nbitplanes); static int qtree_decode64(unsigned char *infile, LONGLONG a[], int n, int nqx, int nqy, int nbitplanes); static void start_inputing_bits(void); static int input_bit(unsigned char *infile); static int input_nbits(unsigned char *infile, int n); /* make input_nybble a separate routine, for added effiency */ /* #define input_nybble(infile) input_nbits(infile,4) */ static int input_nybble(unsigned char *infile); static int input_nnybble(unsigned char *infile, int n, unsigned char *array); static void qtree_expand(unsigned char *infile, unsigned char a[], int nx, int ny, unsigned char b[]); static void qtree_bitins(unsigned char a[], int nx, int ny, int b[], int n, int bit); static void qtree_bitins64(unsigned char a[], int nx, int ny, LONGLONG b[], int n, int bit); static void qtree_copy(unsigned char a[], int nx, int ny, unsigned char b[], int n); static void read_bdirect(unsigned char *infile, int a[], int n, int nqx, int nqy, unsigned char scratch[], int bit); static void read_bdirect64(unsigned char *infile, LONGLONG a[], int n, int nqx, int nqy, unsigned char scratch[], int bit); static int input_huffman(unsigned char *infile); /* ---------------------------------------------------------------------- */ int fits_hdecompress(unsigned char *input, int smooth, int *a, int *ny, int *nx, int *scale, int *status) { /* decompress the input byte stream using the H-compress algorithm input - input array of compressed bytes a - pre-allocated array to hold the output uncompressed image nx - returned X axis size ny - returned Y axis size NOTE: the nx and ny dimensions as defined within this code are reversed from the usual FITS notation. ny is the fastest varying dimension, which is usually considered the X axis in the FITS image display */ int stat; if (*status > 0) return(*status); /* decode the input array */ FFLOCK; /* decode uses the nextchar global variable */ stat = decode(input, a, nx, ny, scale); FFUNLOCK; *status = stat; if (stat) return(*status); /* * Un-Digitize */ undigitize(a, *nx, *ny, *scale); /* * Inverse H-transform */ stat = hinv(a, *nx, *ny, smooth, *scale); *status = stat; return(*status); } /* ---------------------------------------------------------------------- */ int fits_hdecompress64(unsigned char *input, int smooth, LONGLONG *a, int *ny, int *nx, int *scale, int *status) { /* decompress the input byte stream using the H-compress algorithm input - input array of compressed bytes a - pre-allocated array to hold the output uncompressed image nx - returned X axis size ny - returned Y axis size NOTE: the nx and ny dimensions as defined within this code are reversed from the usual FITS notation. ny is the fastest varying dimension, which is usually considered the X axis in the FITS image display */ int stat, *iarray, ii, nval; if (*status > 0) return(*status); /* decode the input array */ FFLOCK; /* decode uses the nextchar global variable */ stat = decode64(input, a, nx, ny, scale); FFUNLOCK; *status = stat; if (stat) return(*status); /* * Un-Digitize */ undigitize64(a, *nx, *ny, *scale); /* * Inverse H-transform */ stat = hinv64(a, *nx, *ny, smooth, *scale); *status = stat; /* pack the I*8 values back into an I*4 array */ iarray = (int *) a; nval = (*nx) * (*ny); for (ii = 0; ii < nval; ii++) iarray[ii] = (int) a[ii]; return(*status); } /* ############################################################################ */ /* ############################################################################ */ /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* hinv.c Inverse H-transform of NX x NY integer image * * Programmer: R. White Date: 23 July 1993 */ /* ############################################################################ */ static int hinv(int a[], int nx, int ny, int smooth ,int scale) /* int smooth; 0 for no smoothing, else smooth during inversion int scale; used if smoothing is specified */ { int nmax, log2n, i, j, k; int nxtop,nytop,nxf,nyf,c; int oddx,oddy; int shift, bit0, bit1, bit2, mask0, mask1, mask2, prnd0, prnd1, prnd2, nrnd0, nrnd1, nrnd2, lowbit0, lowbit1; int h0, hx, hy, hc; int s10, s00; int *tmp; /* * log2n is log2 of max(nx,ny) rounded up to next power of 2 */ nmax = (nx>ny) ? nx : ny; log2n = (int) (log((float) nmax)/log(2.0)+0.5); if ( nmax > (1<> 1; prnd1 = bit1 >> 1; prnd2 = bit2 >> 1; nrnd0 = prnd0 - 1; nrnd1 = prnd1 - 1; nrnd2 = prnd2 - 1; /* * round h0 to multiple of bit2 */ a[0] = (a[0] + ((a[0] >= 0) ? prnd2 : nrnd2)) & mask2; /* * do log2n expansions * * We're indexing a as a 2-D array with dimensions (nx,ny). */ nxtop = 1; nytop = 1; nxf = nx; nyf = ny; c = 1<=0; k--) { /* * this somewhat cryptic code generates the sequence * ntop[k-1] = (ntop[k]+1)/2, where ntop[log2n] = n */ c = c>>1; nxtop = nxtop<<1; nytop = nytop<<1; if (nxf <= c) { nxtop -= 1; } else { nxf -= c; } if (nyf <= c) { nytop -= 1; } else { nyf -= c; } /* * double shift and fix nrnd0 (because prnd0=0) on last pass */ if (k == 0) { nrnd0 = 0; shift = 2; } /* * unshuffle in each dimension to interleave coefficients */ for (i = 0; i= 0) ? prnd1 : nrnd1)) & mask1; hy = (hy + ((hy >= 0) ? prnd1 : nrnd1)) & mask1; hc = (hc + ((hc >= 0) ? prnd0 : nrnd0)) & mask0; /* * propagate bit0 of hc to hx,hy */ lowbit0 = hc & bit0; hx = (hx >= 0) ? (hx - lowbit0) : (hx + lowbit0); hy = (hy >= 0) ? (hy - lowbit0) : (hy + lowbit0); /* * Propagate bits 0 and 1 of hc,hx,hy to h0. * This could be simplified if we assume h0>0, but then * the inversion would not be lossless for images with * negative pixels. */ lowbit1 = (hc ^ hx ^ hy) & bit1; h0 = (h0 >= 0) ? (h0 + lowbit0 - lowbit1) : (h0 + ((lowbit0 == 0) ? lowbit1 : (lowbit0-lowbit1))); /* * Divide sums by 2 (4 last time) */ a[s10+1] = (h0 + hx + hy + hc) >> shift; a[s10 ] = (h0 + hx - hy - hc) >> shift; a[s00+1] = (h0 - hx + hy - hc) >> shift; a[s00 ] = (h0 - hx - hy + hc) >> shift; s00 += 2; s10 += 2; } if (oddy) { /* * do last element in row if row length is odd * s00+1, s10+1 are off edge */ h0 = a[s00 ]; hx = a[s10 ]; hx = ((hx >= 0) ? (hx+prnd1) : (hx+nrnd1)) & mask1; lowbit1 = hx & bit1; h0 = (h0 >= 0) ? (h0 - lowbit1) : (h0 + lowbit1); a[s10 ] = (h0 + hx) >> shift; a[s00 ] = (h0 - hx) >> shift; } } if (oddx) { /* * do last row if column length is odd * s10, s10+1 are off edge */ s00 = ny*i; for (j = 0; j= 0) ? (hy+prnd1) : (hy+nrnd1)) & mask1; lowbit1 = hy & bit1; h0 = (h0 >= 0) ? (h0 - lowbit1) : (h0 + lowbit1); a[s00+1] = (h0 + hy) >> shift; a[s00 ] = (h0 - hy) >> shift; s00 += 2; } if (oddy) { /* * do corner element if both row and column lengths are odd * s00+1, s10, s10+1 are off edge */ h0 = a[s00 ]; a[s00 ] = h0 >> shift; } } /* * divide all the masks and rounding values by 2 */ bit2 = bit1; bit1 = bit0; bit0 = bit0 >> 1; mask1 = mask0; mask0 = mask0 >> 1; prnd1 = prnd0; prnd0 = prnd0 >> 1; nrnd1 = nrnd0; nrnd0 = prnd0 - 1; } free(tmp); return(0); } /* ############################################################################ */ static int hinv64(LONGLONG a[], int nx, int ny, int smooth ,int scale) /* int smooth; 0 for no smoothing, else smooth during inversion int scale; used if smoothing is specified */ { int nmax, log2n, i, j, k; int nxtop,nytop,nxf,nyf,c; int oddx,oddy; int shift; LONGLONG mask0, mask1, mask2, prnd0, prnd1, prnd2, bit0, bit1, bit2; LONGLONG nrnd0, nrnd1, nrnd2, lowbit0, lowbit1; LONGLONG h0, hx, hy, hc; int s10, s00; LONGLONG *tmp; /* * log2n is log2 of max(nx,ny) rounded up to next power of 2 */ nmax = (nx>ny) ? nx : ny; log2n = (int) (log((float) nmax)/log(2.0)+0.5); if ( nmax > (1<> 1; prnd1 = bit1 >> 1; prnd2 = bit2 >> 1; nrnd0 = prnd0 - 1; nrnd1 = prnd1 - 1; nrnd2 = prnd2 - 1; /* * round h0 to multiple of bit2 */ a[0] = (a[0] + ((a[0] >= 0) ? prnd2 : nrnd2)) & mask2; /* * do log2n expansions * * We're indexing a as a 2-D array with dimensions (nx,ny). */ nxtop = 1; nytop = 1; nxf = nx; nyf = ny; c = 1<=0; k--) { /* * this somewhat cryptic code generates the sequence * ntop[k-1] = (ntop[k]+1)/2, where ntop[log2n] = n */ c = c>>1; nxtop = nxtop<<1; nytop = nytop<<1; if (nxf <= c) { nxtop -= 1; } else { nxf -= c; } if (nyf <= c) { nytop -= 1; } else { nyf -= c; } /* * double shift and fix nrnd0 (because prnd0=0) on last pass */ if (k == 0) { nrnd0 = 0; shift = 2; } /* * unshuffle in each dimension to interleave coefficients */ for (i = 0; i= 0) ? prnd1 : nrnd1)) & mask1; hy = (hy + ((hy >= 0) ? prnd1 : nrnd1)) & mask1; hc = (hc + ((hc >= 0) ? prnd0 : nrnd0)) & mask0; /* * propagate bit0 of hc to hx,hy */ lowbit0 = hc & bit0; hx = (hx >= 0) ? (hx - lowbit0) : (hx + lowbit0); hy = (hy >= 0) ? (hy - lowbit0) : (hy + lowbit0); /* * Propagate bits 0 and 1 of hc,hx,hy to h0. * This could be simplified if we assume h0>0, but then * the inversion would not be lossless for images with * negative pixels. */ lowbit1 = (hc ^ hx ^ hy) & bit1; h0 = (h0 >= 0) ? (h0 + lowbit0 - lowbit1) : (h0 + ((lowbit0 == 0) ? lowbit1 : (lowbit0-lowbit1))); /* * Divide sums by 2 (4 last time) */ a[s10+1] = (h0 + hx + hy + hc) >> shift; a[s10 ] = (h0 + hx - hy - hc) >> shift; a[s00+1] = (h0 - hx + hy - hc) >> shift; a[s00 ] = (h0 - hx - hy + hc) >> shift; s00 += 2; s10 += 2; } if (oddy) { /* * do last element in row if row length is odd * s00+1, s10+1 are off edge */ h0 = a[s00 ]; hx = a[s10 ]; hx = ((hx >= 0) ? (hx+prnd1) : (hx+nrnd1)) & mask1; lowbit1 = hx & bit1; h0 = (h0 >= 0) ? (h0 - lowbit1) : (h0 + lowbit1); a[s10 ] = (h0 + hx) >> shift; a[s00 ] = (h0 - hx) >> shift; } } if (oddx) { /* * do last row if column length is odd * s10, s10+1 are off edge */ s00 = ny*i; for (j = 0; j= 0) ? (hy+prnd1) : (hy+nrnd1)) & mask1; lowbit1 = hy & bit1; h0 = (h0 >= 0) ? (h0 - lowbit1) : (h0 + lowbit1); a[s00+1] = (h0 + hy) >> shift; a[s00 ] = (h0 - hy) >> shift; s00 += 2; } if (oddy) { /* * do corner element if both row and column lengths are odd * s00+1, s10, s10+1 are off edge */ h0 = a[s00 ]; a[s00 ] = h0 >> shift; } } /* * divide all the masks and rounding values by 2 */ bit2 = bit1; bit1 = bit0; bit0 = bit0 >> 1; mask1 = mask0; mask0 = mask0 >> 1; prnd1 = prnd0; prnd0 = prnd0 >> 1; nrnd1 = nrnd0; nrnd0 = prnd0 - 1; } free(tmp); return(0); } /* ############################################################################ */ static void unshuffle(int a[], int n, int n2, int tmp[]) /* int a[]; array to shuffle int n; number of elements to shuffle int n2; second dimension int tmp[]; scratch storage */ { int i; int nhalf; int *p1, *p2, *pt; /* * copy 2nd half of array to tmp */ nhalf = (n+1)>>1; pt = tmp; p1 = &a[n2*nhalf]; /* pointer to a[i] */ for (i=nhalf; i= 0; i--) { *p1 = *p2; p2 -= n2; p1 -= (n2+n2); } /* * now distribute 2nd half of array (in tmp) to odd elements */ pt = tmp; p1 = &a[n2]; /* pointer to a[i] */ for (i=1; i>1; pt = tmp; p1 = &a[n2*nhalf]; /* pointer to a[i] */ for (i=nhalf; i= 0; i--) { *p1 = *p2; p2 -= n2; p1 -= (n2+n2); } /* * now distribute 2nd half of array (in tmp) to odd elements */ pt = tmp; p1 = &a[n2]; /* pointer to a[i] */ for (i=1; i> 1); if (smax <= 0) return; ny2 = ny << 1; /* * We're indexing a as a 2-D array with dimensions (nxtop,ny) of which * only (nxtop,nytop) are used. The coefficients on the edge of the * array are not adjusted (which is why the loops below start at 2 * instead of 0 and end at nxtop-2 instead of nxtop.) */ /* * Adjust x difference hx */ for (i = 2; i=0, dmin<=0. */ if (dmin < dmax) { diff = max( min(diff, dmax), dmin); /* * Compute change in slope limited to range +/- smax. * Careful with rounding negative numbers when using * shift for divide by 8. */ s = diff-(a[s10]<<3); s = (s>=0) ? (s>>3) : ((s+7)>>3) ; s = max( min(s, smax), -smax); a[s10] = a[s10]+s; } s00 += 2; s10 += 2; } } /* * Adjust y difference hy */ for (i = 0; i=0) ? (s>>3) : ((s+7)>>3) ; s = max( min(s, smax), -smax); a[s00+1] = a[s00+1]+s; } s00 += 2; s10 += 2; } } /* * Adjust curvature difference hc */ for (i = 2; i=0, dmin<=0. */ if (dmin < dmax) { diff = max( min(diff, dmax), dmin); /* * Compute change in slope limited to range +/- smax. * Careful with rounding negative numbers when using * shift for divide by 64. */ s = diff-(a[s10+1]<<6); s = (s>=0) ? (s>>6) : ((s+63)>>6) ; s = max( min(s, smax), -smax); a[s10+1] = a[s10+1]+s; } s00 += 2; s10 += 2; } } } /* ############################################################################ */ static void hsmooth64(LONGLONG a[], int nxtop, int nytop, int ny, int scale) /* LONGLONG a[]; array of H-transform coefficients int nxtop,nytop; size of coefficient block to use int ny; actual 1st dimension of array int scale; truncation scale factor that was used */ { int i, j; int ny2, s10, s00; LONGLONG hm, h0, hp, hmm, hpm, hmp, hpp, hx2, hy2, diff, dmax, dmin, s, smax, m1, m2; /* * Maximum change in coefficients is determined by scale factor. * Since we rounded during division (see digitize.c), the biggest * permitted change is scale/2. */ smax = (scale >> 1); if (smax <= 0) return; ny2 = ny << 1; /* * We're indexing a as a 2-D array with dimensions (nxtop,ny) of which * only (nxtop,nytop) are used. The coefficients on the edge of the * array are not adjusted (which is why the loops below start at 2 * instead of 0 and end at nxtop-2 instead of nxtop.) */ /* * Adjust x difference hx */ for (i = 2; i=0, dmin<=0. */ if (dmin < dmax) { diff = max( min(diff, dmax), dmin); /* * Compute change in slope limited to range +/- smax. * Careful with rounding negative numbers when using * shift for divide by 8. */ s = diff-(a[s10]<<3); s = (s>=0) ? (s>>3) : ((s+7)>>3) ; s = max( min(s, smax), -smax); a[s10] = a[s10]+s; } s00 += 2; s10 += 2; } } /* * Adjust y difference hy */ for (i = 0; i=0) ? (s>>3) : ((s+7)>>3) ; s = max( min(s, smax), -smax); a[s00+1] = a[s00+1]+s; } s00 += 2; s10 += 2; } } /* * Adjust curvature difference hc */ for (i = 2; i=0, dmin<=0. */ if (dmin < dmax) { diff = max( min(diff, dmax), dmin); /* * Compute change in slope limited to range +/- smax. * Careful with rounding negative numbers when using * shift for divide by 64. */ s = diff-(a[s10+1]<<6); s = (s>=0) ? (s>>6) : ((s+63)>>6) ; s = max( min(s, smax), -smax); a[s10+1] = a[s10+1]+s; } s00 += 2; s10 += 2; } } } /* ############################################################################ */ /* ############################################################################ */ /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* undigitize.c undigitize H-transform * * Programmer: R. White Date: 9 May 1991 */ /* ############################################################################ */ static void undigitize(int a[], int nx, int ny, int scale) { int *p; /* * multiply by scale */ if (scale <= 1) return; for (p=a; p <= &a[nx*ny-1]; p++) *p = (*p)*scale; } /* ############################################################################ */ static void undigitize64(LONGLONG a[], int nx, int ny, int scale) { LONGLONG *p, scale64; /* * multiply by scale */ if (scale <= 1) return; scale64 = (LONGLONG) scale; /* use a 64-bit int for efficiency in the big loop */ for (p=a; p <= &a[nx*ny-1]; p++) *p = (*p)*scale64; } /* ############################################################################ */ /* ############################################################################ */ /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* decode.c read codes from infile and construct array * * Programmer: R. White Date: 2 February 1994 */ static char code_magic[2] = { (char)0xDD, (char)0x99 }; /* ############################################################################ */ static int decode(unsigned char *infile, int *a, int *nx, int *ny, int *scale) /* char *infile; input file int *a; address of output array [nx][ny] int *nx,*ny; size of output array int *scale; scale factor for digitization */ { LONGLONG sumall; int nel, stat; unsigned char nbitplanes[3]; char tmagic[2]; /* initialize the byte read position to the beginning of the array */; nextchar = 0; /* * File starts either with special 2-byte magic code or with * FITS keyword "SIMPLE =" */ qread(infile, tmagic, sizeof(tmagic)); /* * check for correct magic code value */ if (memcmp(tmagic,code_magic,sizeof(code_magic)) != 0) { ffpmsg("bad file format"); return(DATA_DECOMPRESSION_ERR); } *nx =readint(infile); /* x size of image */ *ny =readint(infile); /* y size of image */ *scale=readint(infile); /* scale factor for digitization */ nel = (*nx) * (*ny); /* sum of all pixels */ sumall=readlonglong(infile); /* # bits in quadrants */ qread(infile, (char *) nbitplanes, sizeof(nbitplanes)); stat = dodecode(infile, a, *nx, *ny, nbitplanes); /* * put sum of all pixels back into pixel 0 */ a[0] = (int) sumall; return(stat); } /* ############################################################################ */ static int decode64(unsigned char *infile, LONGLONG *a, int *nx, int *ny, int *scale) /* char *infile; input file LONGLONG *a; address of output array [nx][ny] int *nx,*ny; size of output array int *scale; scale factor for digitization */ { int nel, stat; LONGLONG sumall; unsigned char nbitplanes[3]; char tmagic[2]; /* initialize the byte read position to the beginning of the array */; nextchar = 0; /* * File starts either with special 2-byte magic code or with * FITS keyword "SIMPLE =" */ qread(infile, tmagic, sizeof(tmagic)); /* * check for correct magic code value */ if (memcmp(tmagic,code_magic,sizeof(code_magic)) != 0) { ffpmsg("bad file format"); return(DATA_DECOMPRESSION_ERR); } *nx =readint(infile); /* x size of image */ *ny =readint(infile); /* y size of image */ *scale=readint(infile); /* scale factor for digitization */ nel = (*nx) * (*ny); /* sum of all pixels */ sumall=readlonglong(infile); /* # bits in quadrants */ qread(infile, (char *) nbitplanes, sizeof(nbitplanes)); stat = dodecode64(infile, a, *nx, *ny, nbitplanes); /* * put sum of all pixels back into pixel 0 */ a[0] = sumall; return(stat); } /* ############################################################################ */ /* ############################################################################ */ /* Copyright (c) 1993 Association of Universities for Research * in Astronomy. All rights reserved. Produced under National * Aeronautics and Space Administration Contract No. NAS5-26555. */ /* dodecode.c Decode stream of characters on infile and return array * * This version encodes the different quadrants separately * * Programmer: R. White Date: 9 May 1991 */ /* ############################################################################ */ static int dodecode(unsigned char *infile, int a[], int nx, int ny, unsigned char nbitplanes[3]) /* int a[]; int nx,ny; Array dimensions are [nx][ny] unsigned char nbitplanes[3]; Number of bit planes in quadrants */ { int i, nel, nx2, ny2, stat; nel = nx*ny; nx2 = (nx+1)/2; ny2 = (ny+1)/2; /* * initialize a to zero */ for (i=0; inqy) ? nqx : nqy; log2n = (int) (log((float) nqmax)/log(2.0)+0.5); if (nqmax > (1<= 0; bit--) { /* * Was bitplane was quadtree-coded or written directly? */ b = input_nybble(infile); if(b == 0) { /* * bit map was written directly */ read_bdirect(infile,a,n,nqx,nqy,scratch,bit); } else if (b != 0xf) { ffpmsg("qtree_decode: bad format code"); return(DATA_DECOMPRESSION_ERR); } else { /* * bitmap was quadtree-coded, do log2n expansions * * read first code */ scratch[0] = input_huffman(infile); /* * now do log2n expansions, reading codes from file as necessary */ nx = 1; ny = 1; nfx = nqx; nfy = nqy; c = 1<>1; nx = nx<<1; ny = ny<<1; if (nfx <= c) { nx -= 1; } else { nfx -= c; } if (nfy <= c) { ny -= 1; } else { nfy -= c; } qtree_expand(infile,scratch,nx,ny,scratch); } /* * now copy last set of 4-bit codes to bitplane bit of array a */ qtree_bitins(scratch,nqx,nqy,a,n,bit); } } free(scratch); return(0); } /* ############################################################################ */ static int qtree_decode64(unsigned char *infile, LONGLONG a[], int n, int nqx, int nqy, int nbitplanes) /* char *infile; LONGLONG a[]; a is 2-D array with dimensions (n,n) int n; length of full row in a int nqx; partial length of row to decode int nqy; partial length of column (<=n) int nbitplanes; number of bitplanes to decode */ { int log2n, k, bit, b, nqmax; int nx,ny,nfx,nfy,c; int nqx2, nqy2; unsigned char *scratch; /* * log2n is log2 of max(nqx,nqy) rounded up to next power of 2 */ nqmax = (nqx>nqy) ? nqx : nqy; log2n = (int) (log((float) nqmax)/log(2.0)+0.5); if (nqmax > (1<= 0; bit--) { /* * Was bitplane was quadtree-coded or written directly? */ b = input_nybble(infile); if(b == 0) { /* * bit map was written directly */ read_bdirect64(infile,a,n,nqx,nqy,scratch,bit); } else if (b != 0xf) { ffpmsg("qtree_decode64: bad format code"); return(DATA_DECOMPRESSION_ERR); } else { /* * bitmap was quadtree-coded, do log2n expansions * * read first code */ scratch[0] = input_huffman(infile); /* * now do log2n expansions, reading codes from file as necessary */ nx = 1; ny = 1; nfx = nqx; nfy = nqy; c = 1<>1; nx = nx<<1; ny = ny<<1; if (nfx <= c) { nx -= 1; } else { nfx -= c; } if (nfy <= c) { ny -= 1; } else { nfy -= c; } qtree_expand(infile,scratch,nx,ny,scratch); } /* * now copy last set of 4-bit codes to bitplane bit of array a */ qtree_bitins64(scratch,nqx,nqy,a,n,bit); } } free(scratch); return(0); } /* ############################################################################ */ /* * do one quadtree expansion step on array a[(nqx+1)/2,(nqy+1)/2] * results put into b[nqx,nqy] (which may be the same as a) */ static void qtree_expand(unsigned char *infile, unsigned char a[], int nx, int ny, unsigned char b[]) { int i; /* * first copy a to b, expanding each 4-bit value */ qtree_copy(a,nx,ny,b,ny); /* * now read new 4-bit values into b for each non-zero element */ for (i = nx*ny-1; i >= 0; i--) { if (b[i]) b[i] = input_huffman(infile); } } /* ############################################################################ */ /* * copy 4-bit values from a[(nx+1)/2,(ny+1)/2] to b[nx,ny], expanding * each value to 2x2 pixels * a,b may be same array */ static void qtree_copy(unsigned char a[], int nx, int ny, unsigned char b[], int n) /* int n; declared y dimension of b */ { int i, j, k, nx2, ny2; int s00, s10; /* * first copy 4-bit values to b * start at end in case a,b are same array */ nx2 = (nx+1)/2; ny2 = (ny+1)/2; k = ny2*(nx2-1)+ny2-1; /* k is index of a[i,j] */ for (i = nx2-1; i >= 0; i--) { s00 = 2*(n*i+ny2-1); /* s00 is index of b[2*i,2*j] */ for (j = ny2-1; j >= 0; j--) { b[s00] = a[k]; k -= 1; s00 -= 2; } } /* * now expand each 2x2 block */ for (i = 0; i>1) & 1; b[s00+1] = (b[s00]>>2) & 1; b[s00 ] = (b[s00]>>3) & 1; */ s00 += 2; s10 += 2; } if (j < ny) { /* * row size is odd, do last element in row * s00+1, s10+1 are off edge */ /* not worth converting this to use 16 case statements */ b[s10 ] = (b[s00]>>1) & 1; b[s00 ] = (b[s00]>>3) & 1; } } if (i < nx) { /* * column size is odd, do last row * s10, s10+1 are off edge */ s00 = n*i; for (j = 0; j>2) & 1; b[s00 ] = (b[s00]>>3) & 1; s00 += 2; } if (j < ny) { /* * both row and column size are odd, do corner element * s00+1, s10, s10+1 are off edge */ /* not worth converting this to use 16 case statements */ b[s00 ] = (b[s00]>>3) & 1; } } } /* ############################################################################ */ /* * Copy 4-bit values from a[(nx+1)/2,(ny+1)/2] to b[nx,ny], expanding * each value to 2x2 pixels and inserting into bitplane BIT of B. * A,B may NOT be same array (it wouldn't make sense to be inserting * bits into the same array anyway.) */ static void qtree_bitins(unsigned char a[], int nx, int ny, int b[], int n, int bit) /* int n; declared y dimension of b */ { int i, j, k; int s00; int plane_val; plane_val = 1 << bit; /* * expand each 2x2 block */ k = 0; /* k is index of a[i/2,j/2] */ for (i = 0; i>1) & 1) << bit; b[s00+1] |= ((a[k]>>2) & 1) << bit; b[s00 ] |= ((a[k]>>3) & 1) << bit; */ s00 += 2; /* s10 += 2; */ k += 1; } if (j < ny) { /* * row size is odd, do last element in row * s00+1, s10+1 are off edge */ switch (a[k]) { case(0): break; case(1): break; case(2): b[s00+n ] |= plane_val; break; case(3): b[s00+n ] |= plane_val; break; case(4): break; case(5): break; case(6): b[s00+n ] |= plane_val; break; case(7): b[s00+n ] |= plane_val; break; case(8): b[s00 ] |= plane_val; break; case(9): b[s00 ] |= plane_val; break; case(10): b[s00+n ] |= plane_val; b[s00 ] |= plane_val; break; case(11): b[s00+n ] |= plane_val; b[s00 ] |= plane_val; break; case(12): b[s00 ] |= plane_val; break; case(13): b[s00 ] |= plane_val; break; case(14): b[s00+n ] |= plane_val; b[s00 ] |= plane_val; break; case(15): b[s00+n ] |= plane_val; b[s00 ] |= plane_val; break; } /* b[s10 ] |= ((a[k]>>1) & 1) << bit; b[s00 ] |= ((a[k]>>3) & 1) << bit; */ k += 1; } } if (i < nx) { /* * column size is odd, do last row * s10, s10+1 are off edge */ s00 = n*i; for (j = 0; j>2) & 1) << bit; b[s00 ] |= ((a[k]>>3) & 1) << bit; */ s00 += 2; k += 1; } if (j < ny) { /* * both row and column size are odd, do corner element * s00+1, s10, s10+1 are off edge */ switch (a[k]) { case(0): break; case(1): break; case(2): break; case(3): break; case(4): break; case(5): break; case(6): break; case(7): break; case(8): b[s00 ] |= plane_val; break; case(9): b[s00 ] |= plane_val; break; case(10): b[s00 ] |= plane_val; break; case(11): b[s00 ] |= plane_val; break; case(12): b[s00 ] |= plane_val; break; case(13): b[s00 ] |= plane_val; break; case(14): b[s00 ] |= plane_val; break; case(15): b[s00 ] |= plane_val; break; } /* b[s00 ] |= ((a[k]>>3) & 1) << bit; */ k += 1; } } } /* ############################################################################ */ /* * Copy 4-bit values from a[(nx+1)/2,(ny+1)/2] to b[nx,ny], expanding * each value to 2x2 pixels and inserting into bitplane BIT of B. * A,B may NOT be same array (it wouldn't make sense to be inserting * bits into the same array anyway.) */ static void qtree_bitins64(unsigned char a[], int nx, int ny, LONGLONG b[], int n, int bit) /* int n; declared y dimension of b */ { int i, j, k; int s00; int plane_val; plane_val = 1 << bit; /* * expand each 2x2 block */ k = 0; /* k is index of a[i/2,j/2] */ for (i = 0; i>1) & 1) << bit; b[s00+1] |= ((((LONGLONG)a[k])>>2) & 1) << bit; b[s00 ] |= ((((LONGLONG)a[k])>>3) & 1) << bit; */ s00 += 2; /* s10 += 2; */ k += 1; } if (j < ny) { /* * row size is odd, do last element in row * s00+1, s10+1 are off edge */ switch (a[k]) { case(0): break; case(1): break; case(2): b[s00+n ] |= plane_val; break; case(3): b[s00+n ] |= plane_val; break; case(4): break; case(5): break; case(6): b[s00+n ] |= plane_val; break; case(7): b[s00+n ] |= plane_val; break; case(8): b[s00 ] |= plane_val; break; case(9): b[s00 ] |= plane_val; break; case(10): b[s00+n ] |= plane_val; b[s00 ] |= plane_val; break; case(11): b[s00+n ] |= plane_val; b[s00 ] |= plane_val; break; case(12): b[s00 ] |= plane_val; break; case(13): b[s00 ] |= plane_val; break; case(14): b[s00+n ] |= plane_val; b[s00 ] |= plane_val; break; case(15): b[s00+n ] |= plane_val; b[s00 ] |= plane_val; break; } /* b[s10 ] |= ((((LONGLONG)a[k])>>1) & 1) << bit; b[s00 ] |= ((((LONGLONG)a[k])>>3) & 1) << bit; */ k += 1; } } if (i < nx) { /* * column size is odd, do last row * s10, s10+1 are off edge */ s00 = n*i; for (j = 0; j>2) & 1) << bit; b[s00 ] |= ((((LONGLONG)a[k])>>3) & 1) << bit; */ s00 += 2; k += 1; } if (j < ny) { /* * both row and column size are odd, do corner element * s00+1, s10, s10+1 are off edge */ switch (a[k]) { case(0): break; case(1): break; case(2): break; case(3): break; case(4): break; case(5): break; case(6): break; case(7): break; case(8): b[s00 ] |= plane_val; break; case(9): b[s00 ] |= plane_val; break; case(10): b[s00 ] |= plane_val; break; case(11): b[s00 ] |= plane_val; break; case(12): b[s00 ] |= plane_val; break; case(13): b[s00 ] |= plane_val; break; case(14): b[s00 ] |= plane_val; break; case(15): b[s00 ] |= plane_val; break; } /* b[s00 ] |= ((((LONGLONG)a[k])>>3) & 1) << bit; */ k += 1; } } } /* ############################################################################ */ static void read_bdirect(unsigned char *infile, int a[], int n, int nqx, int nqy, unsigned char scratch[], int bit) { /* * read bit image packed 4 pixels/nybble */ /* int i; for (i = 0; i < ((nqx+1)/2) * ((nqy+1)/2); i++) { scratch[i] = input_nybble(infile); } */ input_nnybble(infile, ((nqx+1)/2) * ((nqy+1)/2), scratch); /* * insert in bitplane BIT of image A */ qtree_bitins(scratch,nqx,nqy,a,n,bit); } /* ############################################################################ */ static void read_bdirect64(unsigned char *infile, LONGLONG a[], int n, int nqx, int nqy, unsigned char scratch[], int bit) { /* * read bit image packed 4 pixels/nybble */ /* int i; for (i = 0; i < ((nqx+1)/2) * ((nqy+1)/2); i++) { scratch[i] = input_nybble(infile); } */ input_nnybble(infile, ((nqx+1)/2) * ((nqy+1)/2), scratch); /* * insert in bitplane BIT of image A */ qtree_bitins64(scratch,nqx,nqy,a,n,bit); } /* ############################################################################ */ /* * Huffman decoding for fixed codes * * Coded values range from 0-15 * * Huffman code values (hex): * * 3e, 00, 01, 08, 02, 09, 1a, 1b, * 03, 1c, 0a, 1d, 0b, 1e, 3f, 0c * * and number of bits in each code: * * 6, 3, 3, 4, 3, 4, 5, 5, * 3, 5, 4, 5, 4, 5, 6, 4 */ static int input_huffman(unsigned char *infile) { int c; /* * get first 3 bits to start */ c = input_nbits(infile,3); if (c < 4) { /* * this is all we need * return 1,2,4,8 for c=0,1,2,3 */ return(1<>bits_to_go) & 1); } /* ############################################################################ */ /* INPUT N BITS (N must be <= 8) */ static int input_nbits(unsigned char *infile, int n) { /* AND mask for retreiving the right-most n bits */ static int mask[9] = {0, 1, 3, 7, 15, 31, 63, 127, 255}; if (bits_to_go < n) { /* * need another byte's worth of bits */ buffer2 = (buffer2<<8) | (int) infile[nextchar]; nextchar++; bits_to_go += 8; } /* * now pick off the first n bits */ bits_to_go -= n; /* there was a slight gain in speed by replacing the following line */ /* return( (buffer2>>bits_to_go) & ((1<>bits_to_go) & (*(mask+n)) ); } /* ############################################################################ */ /* INPUT 4 BITS */ static int input_nybble(unsigned char *infile) { if (bits_to_go < 4) { /* * need another byte's worth of bits */ buffer2 = (buffer2<<8) | (int) infile[nextchar]; nextchar++; bits_to_go += 8; } /* * now pick off the first 4 bits */ bits_to_go -= 4; return( (buffer2>>bits_to_go) & 15 ); } /* ############################################################################ */ /* INPUT array of 4 BITS */ static int input_nnybble(unsigned char *infile, int n, unsigned char array[]) { /* copy n 4-bit nybbles from infile to the lower 4 bits of array */ int ii, kk, shift1, shift2; /* forcing byte alignment doesn;t help, and even makes it go slightly slower if (bits_to_go != 8) input_nbits(infile, bits_to_go); */ if (n == 1) { array[0] = input_nybble(infile); return(0); } if (bits_to_go == 8) { /* already have 2 full nybbles in buffer2, so backspace the infile array to reuse last char */ nextchar--; bits_to_go = 0; } /* bits_to_go now has a value in the range 0 - 7. After adding */ /* another byte, bits_to_go effectively will be in range 8 - 15 */ shift1 = bits_to_go + 4; /* shift1 will be in range 4 - 11 */ shift2 = bits_to_go; /* shift2 will be in range 0 - 7 */ kk = 0; /* special case */ if (bits_to_go == 0) { for (ii = 0; ii < n/2; ii++) { /* * refill the buffer with next byte */ buffer2 = (buffer2<<8) | (int) infile[nextchar]; nextchar++; array[kk] = (int) ((buffer2>>4) & 15); array[kk + 1] = (int) ((buffer2) & 15); /* no shift required */ kk += 2; } } else { for (ii = 0; ii < n/2; ii++) { /* * refill the buffer with next byte */ buffer2 = (buffer2<<8) | (int) infile[nextchar]; nextchar++; array[kk] = (int) ((buffer2>>shift1) & 15); array[kk + 1] = (int) ((buffer2>>shift2) & 15); kk += 2; } } if (ii * 2 != n) { /* have to read last odd byte */ array[n-1] = input_nybble(infile); } return( (buffer2>>bits_to_go) & 15 ); } healpy-1.10.3/cfitsio/fitscopy.c0000664000175000017500000000512213010375005016764 0ustar zoncazonca00000000000000#include #include "fitsio.h" int main(int argc, char *argv[]) { fitsfile *infptr, *outfptr; /* FITS file pointers defined in fitsio.h */ int status = 0; /* status must always be initialized = 0 */ if (argc != 3) { printf("Usage: fitscopy inputfile outputfile\n"); printf("\n"); printf("Copy an input file to an output file, optionally filtering\n"); printf("the file in the process. This seemingly simple program can\n"); printf("apply powerful filters which transform the input file as\n"); printf("it is being copied. Filters may be used to extract a\n"); printf("subimage from a larger image, select rows from a table,\n"); printf("filter a table with a GTI time extension or a SAO region file,\n"); printf("create or delete columns in a table, create an image by\n"); printf("binning (histogramming) 2 table columns, and convert IRAF\n"); printf("format *.imh or raw binary data files into FITS images.\n"); printf("See the CFITSIO User's Guide for a complete description of\n"); printf("the Extended File Name filtering syntax.\n"); printf("\n"); printf("Examples:\n"); printf("\n"); printf("fitscopy in.fit out.fit (simple file copy)\n"); printf("fitscopy - - (stdin to stdout)\n"); printf("fitscopy in.fit[11:50,21:60] out.fit (copy a subimage)\n"); printf("fitscopy iniraf.imh out.fit (IRAF image to FITS)\n"); printf("fitscopy in.dat[i512,512] out.fit (raw array to FITS)\n"); printf("fitscopy in.fit[events][pi>35] out.fit (copy rows with pi>35)\n"); printf("fitscopy in.fit[events][bin X,Y] out.fit (bin an image) \n"); printf("fitscopy in.fit[events][col x=.9*y] out.fit (new x column)\n"); printf("fitscopy in.fit[events][gtifilter()] out.fit (time filter)\n"); printf("fitscopy in.fit[2][regfilter(\"pow.reg\")] out.fit (spatial filter)\n"); printf("\n"); printf("Note that it may be necessary to enclose the input file name\n"); printf("in single quote characters on the Unix command line.\n"); return(0); } /* Open the input file */ if ( !fits_open_file(&infptr, argv[1], READONLY, &status) ) { /* Create the output file */ if ( !fits_create_file(&outfptr, argv[2], &status) ) { /* copy the previous, current, and following HDUs */ fits_copy_file(infptr, outfptr, 1, 1, 1, &status); fits_close_file(outfptr, &status); } fits_close_file(infptr, &status); } /* if error occured, print out error message */ if (status) fits_report_error(stderr, status); return(status); } healpy-1.10.3/cfitsio/fitscore.c0000664000175000017500000112222013010375005016742 0ustar zoncazonca00000000000000/* This file, fitscore.c, contains the core set of FITSIO routines. */ /* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ /* Copyright (Unpublished--all rights reserved under the copyright laws of the United States), U.S. Government as represented by the Administrator of the National Aeronautics and Space Administration. No copyright is claimed in the United States under Title 17, U.S. Code. Permission to freely use, copy, modify, and distribute this software and its documentation without fee is hereby granted, provided that this copyright notice and disclaimer of warranty appears in all copies. DISCLAIMER: THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND FREEDOM FROM INFRINGEMENT, AND ANY WARRANTY THAT THE DOCUMENTATION WILL CONFORM TO THE SOFTWARE, OR ANY WARRANTY THAT THE SOFTWARE WILL BE ERROR FREE. IN NO EVENT SHALL NASA BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM, OR IN ANY WAY CONNECTED WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY, CONTRACT, TORT , OR OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM, OR AROSE OUT OF THE RESULTS OF, OR USE OF, THE SOFTWARE OR SERVICES PROVIDED HEREUNDER." */ #include #include #include #include #include #include /* stddef.h is apparently needed to define size_t with some compilers ?? */ #include #include #include "fitsio2.h" #define errmsgsiz 25 #define ESMARKER 27 /* Escape character is used as error stack marker */ #define DelAll 1 /* delete all messages on the error stack */ #define DelMark 2 /* delete newest messages back to and including marker */ #define DelNewest 3 /* delete the newest message from the stack */ #define GetMesg 4 /* pop and return oldest message, ignoring marks */ #define PutMesg 5 /* add a new message to the stack */ #define PutMark 6 /* add a marker to the stack */ #ifdef _REENTRANT /* Fitsio_Lock and Fitsio_Pthread_Status are declared in fitsio2.h. */ pthread_mutex_t Fitsio_Lock; int Fitsio_Pthread_Status = 0; #endif int STREAM_DRIVER = 0; struct lconv *lcxxx; /*--------------------------------------------------------------------------*/ float ffvers(float *version) /* IO - version number */ /* return the current version number of the FITSIO software */ { *version = (float) 3.36; /* 6 Dec 2013 Previous releases: *version = 3.35 23 May 2013 *version = 3.34 20 Mar 2013 *version = 3.33 14 Feb 2013 *version = 3.32 Oct 2012 *version = 3.31 18 Jul 2012 *version = 3.30 11 Apr 2012 *version = 3.29 22 Sep 2011 *version = 3.28 12 May 2011 *version = 3.27 3 Mar 2011 *version = 3.26 30 Dec 2010 *version = 3.25 9 June 2010 *version = 3.24 26 Jan 2010 *version = 3.23 7 Jan 2010 *version = 3.22 28 Oct 2009 *version = 3.21 24 Sep 2009 *version = 3.20 31 Aug 2009 *version = 3.18 12 May 2009 (beta version) *version = 3.14 18 Mar 2009 *version = 3.13 5 Jan 2009 *version = 3.12 8 Oct 2008 *version = 3.11 19 Sep 2008 *version = 3.10 20 Aug 2008 *version = 3.09 3 Jun 2008 *version = 3.08 15 Apr 2007 (internal release) *version = 3.07 5 Nov 2007 (internal release) *version = 3.06 27 Aug 2007 *version = 3.05 12 Jul 2007 (internal release) *version = 3.03 11 Dec 2006 *version = 3.02 18 Sep 2006 *version = 3.01 May 2006 included in FTOOLS 6.1 release *version = 3.006 20 Feb 2006 *version = 3.005 20 Dec 2005 (beta, in heasoft swift release *version = 3.004 16 Sep 2005 (beta, in heasoft swift release *version = 3.003 28 Jul 2005 (beta, in heasoft swift release *version = 3.002 15 Apr 2005 (beta) *version = 3.001 15 Mar 2005 (beta) released with heasoft 6.0 *version = 3.000 1 Mar 2005 (internal release only) *version = 2.51 2 Dec 2004 *version = 2.50 28 Jul 2004 *version = 2.49 11 Feb 2004 *version = 2.48 28 Jan 2004 *version = 2.470 18 Aug 2003 *version = 2.460 20 May 2003 *version = 2.450 30 Apr 2003 (internal release only) *version = 2.440 8 Jan 2003 *version = 2.430; 4 Nov 2002 *version = 2.420; 19 Jul 2002 *version = 2.410; 22 Apr 2002 used in ftools v5.2 *version = 2.401; 28 Jan 2002 *version = 2.400; 18 Jan 2002 *version = 2.301; 7 Dec 2001 *version = 2.300; 23 Oct 2001 *version = 2.204; 26 Jul 2001 *version = 2.203; 19 Jul 2001 used in ftools v5.1 *version = 2.202; 22 May 2001 *version = 2.201; 15 Mar 2001 *version = 2.200; 26 Jan 2001 *version = 2.100; 26 Sep 2000 *version = 2.037; 6 Jul 2000 *version = 2.036; 1 Feb 2000 *version = 2.035; 7 Dec 1999 (internal release only) *version = 2.034; 23 Nov 1999 *version = 2.033; 17 Sep 1999 *version = 2.032; 25 May 1999 *version = 2.031; 31 Mar 1999 *version = 2.030; 24 Feb 1999 *version = 2.029; 11 Feb 1999 *version = 2.028; 26 Jan 1999 *version = 2.027; 12 Jan 1999 *version = 2.026; 23 Dec 1998 *version = 2.025; 1 Dec 1998 *version = 2.024; 9 Nov 1998 *version = 2.023; 1 Nov 1998 first full release of V2.0 *version = 1.42; 30 Apr 1998 *version = 1.40; 6 Feb 1998 *version = 1.33; 16 Dec 1997 (internal release only) *version = 1.32; 21 Nov 1997 (internal release only) *version = 1.31; 4 Nov 1997 (internal release only) *version = 1.30; 11 Sep 1997 *version = 1.27; 3 Sep 1997 (internal release only) *version = 1.25; 2 Jul 1997 *version = 1.24; 2 May 1997 *version = 1.23; 24 Apr 1997 *version = 1.22; 18 Apr 1997 *version = 1.21; 26 Mar 1997 *version = 1.2; 29 Jan 1997 *version = 1.11; 04 Dec 1996 *version = 1.101; 13 Nov 1996 *version = 1.1; 6 Nov 1996 *version = 1.04; 17 Sep 1996 *version = 1.03; 20 Aug 1996 *version = 1.02; 15 Aug 1996 *version = 1.01; 12 Aug 1996 */ return(*version); } /*--------------------------------------------------------------------------*/ int ffflnm(fitsfile *fptr, /* I - FITS file pointer */ char *filename, /* O - name of the file */ int *status) /* IO - error status */ /* return the name of the FITS file */ { strcpy(filename,(fptr->Fptr)->filename); return(*status); } /*--------------------------------------------------------------------------*/ int ffflmd(fitsfile *fptr, /* I - FITS file pointer */ int *filemode, /* O - open mode of the file */ int *status) /* IO - error status */ /* return the access mode of the FITS file */ { *filemode = (fptr->Fptr)->writemode; return(*status); } /*--------------------------------------------------------------------------*/ void ffgerr(int status, /* I - error status value */ char *errtext) /* O - error message (max 30 char long + null) */ /* Return a short descriptive error message that corresponds to the input error status value. The message may be up to 30 characters long, plus the terminating null character. */ { errtext[0] = '\0'; if (status >= 0 && status < 300) { switch (status) { case 0: strcpy(errtext, "OK - no error"); break; case 1: strcpy(errtext, "non-CFITSIO program error"); break; case 101: strcpy(errtext, "same input and output files"); break; case 103: strcpy(errtext, "attempt to open too many files"); break; case 104: strcpy(errtext, "could not open the named file"); break; case 105: strcpy(errtext, "couldn't create the named file"); break; case 106: strcpy(errtext, "error writing to FITS file"); break; case 107: strcpy(errtext, "tried to move past end of file"); break; case 108: strcpy(errtext, "error reading from FITS file"); break; case 110: strcpy(errtext, "could not close the file"); break; case 111: strcpy(errtext, "array dimensions too big"); break; case 112: strcpy(errtext, "cannot write to readonly file"); break; case 113: strcpy(errtext, "could not allocate memory"); break; case 114: strcpy(errtext, "invalid fitsfile pointer"); break; case 115: strcpy(errtext, "NULL input pointer"); break; case 116: strcpy(errtext, "error seeking file position"); break; case 121: strcpy(errtext, "invalid URL prefix"); break; case 122: strcpy(errtext, "too many I/O drivers"); break; case 123: strcpy(errtext, "I/O driver init failed"); break; case 124: strcpy(errtext, "no I/O driver for this URLtype"); break; case 125: strcpy(errtext, "parse error in input file URL"); break; case 126: strcpy(errtext, "parse error in range list"); break; case 151: strcpy(errtext, "bad argument (shared mem drvr)"); break; case 152: strcpy(errtext, "null ptr arg (shared mem drvr)"); break; case 153: strcpy(errtext, "no free shared memory handles"); break; case 154: strcpy(errtext, "share mem drvr not initialized"); break; case 155: strcpy(errtext, "IPC system error (shared mem)"); break; case 156: strcpy(errtext, "no memory (shared mem drvr)"); break; case 157: strcpy(errtext, "share mem resource deadlock"); break; case 158: strcpy(errtext, "lock file open/create failed"); break; case 159: strcpy(errtext, "can't resize share mem block"); break; case 201: strcpy(errtext, "header already has keywords"); break; case 202: strcpy(errtext, "keyword not found in header"); break; case 203: strcpy(errtext, "keyword number out of bounds"); break; case 204: strcpy(errtext, "keyword value is undefined"); break; case 205: strcpy(errtext, "string missing closing quote"); break; case 206: strcpy(errtext, "error in indexed keyword name"); break; case 207: strcpy(errtext, "illegal character in keyword"); break; case 208: strcpy(errtext, "required keywords out of order"); break; case 209: strcpy(errtext, "keyword value not positive int"); break; case 210: strcpy(errtext, "END keyword not found"); break; case 211: strcpy(errtext, "illegal BITPIX keyword value"); break; case 212: strcpy(errtext, "illegal NAXIS keyword value"); break; case 213: strcpy(errtext, "illegal NAXISn keyword value"); break; case 214: strcpy(errtext, "illegal PCOUNT keyword value"); break; case 215: strcpy(errtext, "illegal GCOUNT keyword value"); break; case 216: strcpy(errtext, "illegal TFIELDS keyword value"); break; case 217: strcpy(errtext, "negative table row size"); break; case 218: strcpy(errtext, "negative number of rows"); break; case 219: strcpy(errtext, "named column not found"); break; case 220: strcpy(errtext, "illegal SIMPLE keyword value"); break; case 221: strcpy(errtext, "first keyword not SIMPLE"); break; case 222: strcpy(errtext, "second keyword not BITPIX"); break; case 223: strcpy(errtext, "third keyword not NAXIS"); break; case 224: strcpy(errtext, "missing NAXISn keywords"); break; case 225: strcpy(errtext, "first keyword not XTENSION"); break; case 226: strcpy(errtext, "CHDU not an ASCII table"); break; case 227: strcpy(errtext, "CHDU not a binary table"); break; case 228: strcpy(errtext, "PCOUNT keyword not found"); break; case 229: strcpy(errtext, "GCOUNT keyword not found"); break; case 230: strcpy(errtext, "TFIELDS keyword not found"); break; case 231: strcpy(errtext, "missing TBCOLn keyword"); break; case 232: strcpy(errtext, "missing TFORMn keyword"); break; case 233: strcpy(errtext, "CHDU not an IMAGE extension"); break; case 234: strcpy(errtext, "illegal TBCOLn keyword value"); break; case 235: strcpy(errtext, "CHDU not a table extension"); break; case 236: strcpy(errtext, "column exceeds width of table"); break; case 237: strcpy(errtext, "more than 1 matching col. name"); break; case 241: strcpy(errtext, "row width not = field widths"); break; case 251: strcpy(errtext, "unknown FITS extension type"); break; case 252: strcpy(errtext, "1st key not SIMPLE or XTENSION"); break; case 253: strcpy(errtext, "END keyword is not blank"); break; case 254: strcpy(errtext, "Header fill area not blank"); break; case 255: strcpy(errtext, "Data fill area invalid"); break; case 261: strcpy(errtext, "illegal TFORM format code"); break; case 262: strcpy(errtext, "unknown TFORM datatype code"); break; case 263: strcpy(errtext, "illegal TDIMn keyword value"); break; case 264: strcpy(errtext, "invalid BINTABLE heap pointer"); break; default: strcpy(errtext, "unknown error status"); break; } } else if (status < 600) { switch(status) { case 301: strcpy(errtext, "illegal HDU number"); break; case 302: strcpy(errtext, "column number < 1 or > tfields"); break; case 304: strcpy(errtext, "negative byte address"); break; case 306: strcpy(errtext, "negative number of elements"); break; case 307: strcpy(errtext, "bad first row number"); break; case 308: strcpy(errtext, "bad first element number"); break; case 309: strcpy(errtext, "not an ASCII (A) column"); break; case 310: strcpy(errtext, "not a logical (L) column"); break; case 311: strcpy(errtext, "bad ASCII table datatype"); break; case 312: strcpy(errtext, "bad binary table datatype"); break; case 314: strcpy(errtext, "null value not defined"); break; case 317: strcpy(errtext, "not a variable length column"); break; case 320: strcpy(errtext, "illegal number of dimensions"); break; case 321: strcpy(errtext, "1st pixel no. > last pixel no."); break; case 322: strcpy(errtext, "BSCALE or TSCALn = 0."); break; case 323: strcpy(errtext, "illegal axis length < 1"); break; case 340: strcpy(errtext, "not group table"); break; case 341: strcpy(errtext, "HDU already member of group"); break; case 342: strcpy(errtext, "group member not found"); break; case 343: strcpy(errtext, "group not found"); break; case 344: strcpy(errtext, "bad group id"); break; case 345: strcpy(errtext, "too many HDUs tracked"); break; case 346: strcpy(errtext, "HDU alread tracked"); break; case 347: strcpy(errtext, "bad Grouping option"); break; case 348: strcpy(errtext, "identical pointers (groups)"); break; case 360: strcpy(errtext, "malloc failed in parser"); break; case 361: strcpy(errtext, "file read error in parser"); break; case 362: strcpy(errtext, "null pointer arg (parser)"); break; case 363: strcpy(errtext, "empty line (parser)"); break; case 364: strcpy(errtext, "cannot unread > 1 line"); break; case 365: strcpy(errtext, "parser too deeply nested"); break; case 366: strcpy(errtext, "file open failed (parser)"); break; case 367: strcpy(errtext, "hit EOF (parser)"); break; case 368: strcpy(errtext, "bad argument (parser)"); break; case 369: strcpy(errtext, "unexpected token (parser)"); break; case 401: strcpy(errtext, "bad int to string conversion"); break; case 402: strcpy(errtext, "bad float to string conversion"); break; case 403: strcpy(errtext, "keyword value not integer"); break; case 404: strcpy(errtext, "keyword value not logical"); break; case 405: strcpy(errtext, "keyword value not floating pt"); break; case 406: strcpy(errtext, "keyword value not double"); break; case 407: strcpy(errtext, "bad string to int conversion"); break; case 408: strcpy(errtext, "bad string to float conversion"); break; case 409: strcpy(errtext, "bad string to double convert"); break; case 410: strcpy(errtext, "illegal datatype code value"); break; case 411: strcpy(errtext, "illegal no. of decimals"); break; case 412: strcpy(errtext, "datatype conversion overflow"); break; case 413: strcpy(errtext, "error compressing image"); break; case 414: strcpy(errtext, "error uncompressing image"); break; case 420: strcpy(errtext, "bad date or time conversion"); break; case 431: strcpy(errtext, "syntax error in expression"); break; case 432: strcpy(errtext, "expression result wrong type"); break; case 433: strcpy(errtext, "vector result too large"); break; case 434: strcpy(errtext, "missing output column"); break; case 435: strcpy(errtext, "bad data in parsed column"); break; case 436: strcpy(errtext, "output extension of wrong type"); break; case 501: strcpy(errtext, "WCS angle too large"); break; case 502: strcpy(errtext, "bad WCS coordinate"); break; case 503: strcpy(errtext, "error in WCS calculation"); break; case 504: strcpy(errtext, "bad WCS projection type"); break; case 505: strcpy(errtext, "WCS keywords not found"); break; default: strcpy(errtext, "unknown error status"); break; } } else { strcpy(errtext, "unknown error status"); } return; } /*--------------------------------------------------------------------------*/ void ffpmsg(const char *err_message) /* put message on to error stack */ { ffxmsg(PutMesg, (char *)err_message); return; } /*--------------------------------------------------------------------------*/ void ffpmrk(void) /* write a marker to the stack. It is then possible to pop only those messages following the marker off of the stack, leaving the previous messages unaffected. The marker is ignored by the ffgmsg routine. */ { char *dummy = 0; ffxmsg(PutMark, dummy); return; } /*--------------------------------------------------------------------------*/ int ffgmsg(char *err_message) /* get oldest message from error stack, ignoring markers */ { ffxmsg(GetMesg, err_message); return(*err_message); } /*--------------------------------------------------------------------------*/ void ffcmsg(void) /* erase all messages in the error stack */ { char *dummy = 0; ffxmsg(DelAll, dummy); return; } /*--------------------------------------------------------------------------*/ void ffcmrk(void) /* erase newest messages in the error stack, stopping if a marker is found. The marker is also erased in this case. */ { char *dummy = 0; ffxmsg(DelMark, dummy); return; } /*--------------------------------------------------------------------------*/ void ffxmsg( int action, char *errmsg) /* general routine to get, put, or clear the error message stack. Use a static array rather than allocating memory as needed for the error messages because it is likely to be more efficient and simpler to implement. Action Code: DelAll 1 delete all messages on the error stack DelMark 2 delete messages back to and including the 1st marker DelNewest 3 delete the newest message from the stack GetMesg 4 pop and return oldest message, ignoring marks PutMesg 5 add a new message to the stack PutMark 6 add a marker to the stack */ { int ii; char markflag; static char *txtbuff[errmsgsiz], *tmpbuff, *msgptr; static char errbuff[errmsgsiz][81]; /* initialize all = \0 */ static int nummsg = 0; FFLOCK; if (action == DelAll) /* clear the whole message stack */ { for (ii = 0; ii < nummsg; ii ++) *txtbuff[ii] = '\0'; nummsg = 0; } else if (action == DelMark) /* clear up to and including first marker */ { while (nummsg > 0) { nummsg--; markflag = *txtbuff[nummsg]; /* store possible marker character */ *txtbuff[nummsg] = '\0'; /* clear the buffer for this msg */ if (markflag == ESMARKER) break; /* found a marker, so quit */ } } else if (action == DelNewest) /* remove newest message from stack */ { if (nummsg > 0) { nummsg--; *txtbuff[nummsg] = '\0'; /* clear the buffer for this msg */ } } else if (action == GetMesg) /* pop and return oldest message from stack */ { /* ignoring markers */ while (nummsg > 0) { strcpy(errmsg, txtbuff[0]); /* copy oldest message to output */ *txtbuff[0] = '\0'; /* clear the buffer for this msg */ nummsg--; for (ii = 0; ii < nummsg; ii++) txtbuff[ii] = txtbuff[ii + 1]; /* shift remaining pointers */ if (errmsg[0] != ESMARKER) { /* quit if this is not a marker */ FFUNLOCK; return; } } errmsg[0] = '\0'; /* no messages in the stack */ } else if (action == PutMesg) /* add new message to stack */ { msgptr = errmsg; while (strlen(msgptr)) { if (nummsg == errmsgsiz) { tmpbuff = txtbuff[0]; /* buffers full; reuse oldest buffer */ *txtbuff[0] = '\0'; /* clear the buffer for this msg */ nummsg--; for (ii = 0; ii < nummsg; ii++) txtbuff[ii] = txtbuff[ii + 1]; /* shift remaining pointers */ txtbuff[nummsg] = tmpbuff; /* set pointer for the new message */ } else { for (ii = 0; ii < errmsgsiz; ii++) { if (*errbuff[ii] == '\0') /* find first empty buffer */ { txtbuff[nummsg] = errbuff[ii]; break; } } } strncat(txtbuff[nummsg], msgptr, 80); nummsg++; msgptr += minvalue(80, strlen(msgptr)); } } else if (action == PutMark) /* put a marker on the stack */ { if (nummsg == errmsgsiz) { tmpbuff = txtbuff[0]; /* buffers full; reuse oldest buffer */ *txtbuff[0] = '\0'; /* clear the buffer for this msg */ nummsg--; for (ii = 0; ii < nummsg; ii++) txtbuff[ii] = txtbuff[ii + 1]; /* shift remaining pointers */ txtbuff[nummsg] = tmpbuff; /* set pointer for the new message */ } else { for (ii = 0; ii < errmsgsiz; ii++) { if (*errbuff[ii] == '\0') /* find first empty buffer */ { txtbuff[nummsg] = errbuff[ii]; break; } } } *txtbuff[nummsg] = ESMARKER; /* write the marker */ *(txtbuff[nummsg] + 1) = '\0'; nummsg++; } FFUNLOCK; return; } /*--------------------------------------------------------------------------*/ int ffpxsz(int datatype) /* return the number of bytes per pixel associated with the datatype */ { if (datatype == TBYTE) return(sizeof(char)); else if (datatype == TUSHORT) return(sizeof(short)); else if (datatype == TSHORT) return(sizeof(short)); else if (datatype == TULONG) return(sizeof(long)); else if (datatype == TLONG) return(sizeof(long)); else if (datatype == TINT) return(sizeof(int)); else if (datatype == TUINT) return(sizeof(int)); else if (datatype == TFLOAT) return(sizeof(float)); else if (datatype == TDOUBLE) return(sizeof(double)); else if (datatype == TLOGICAL) return(sizeof(char)); else return(0); } /*--------------------------------------------------------------------------*/ int fftkey(const char *keyword, /* I - keyword name */ int *status) /* IO - error status */ /* Test that the keyword name conforms to the FITS standard. Must contain only capital letters, digits, minus or underscore chars. Trailing spaces are allowed. If the input status value is less than zero, then the test is modified so that upper or lower case letters are allowed, and no error messages are printed if the keyword is not legal. */ { size_t maxchr, ii; int spaces=0; char msg[81], testchar; if (*status > 0) /* inherit input status value if > 0 */ return(*status); maxchr=strlen(keyword); if (maxchr > 8) maxchr = 8; for (ii = 0; ii < maxchr; ii++) { if (*status == 0) testchar = keyword[ii]; else testchar = toupper(keyword[ii]); if ( (testchar >= 'A' && testchar <= 'Z') || (testchar >= '0' && testchar <= '9') || testchar == '-' || testchar == '_' ) { if (spaces) { if (*status == 0) { /* don't print error message if status < 0 */ sprintf(msg, "Keyword name contains embedded space(s): %.8s", keyword); ffpmsg(msg); } return(*status = BAD_KEYCHAR); } } else if (keyword[ii] == ' ') spaces = 1; else { if (*status == 0) { /* don't print error message if status < 0 */ sprintf(msg, "Character %d in this keyword is illegal: %.8s", (int) (ii+1), keyword); ffpmsg(msg); /* explicitly flag the 2 most common cases */ if (keyword[ii] == 0) ffpmsg(" (This a NULL (0) character)."); else if (keyword[ii] == 9) ffpmsg(" (This an ASCII TAB (9) character)."); } return(*status = BAD_KEYCHAR); } } return(*status); } /*--------------------------------------------------------------------------*/ int fftrec(char *card, /* I - keyword card to test */ int *status) /* IO - error status */ /* Test that the keyword card conforms to the FITS standard. Must contain only printable ASCII characters; */ { size_t ii, maxchr; char msg[81]; if (*status > 0) /* inherit input status value if > 0 */ return(*status); maxchr = strlen(card); for (ii = 8; ii < maxchr; ii++) { if (card[ii] < 32 || card[ii] > 126) { sprintf(msg, "Character %d in this keyword is illegal. Hex Value = %X", (int) (ii+1), (int) card[ii] ); if (card[ii] == 0) strcat(msg, " (NULL char.)"); else if (card[ii] == 9) strcat(msg, " (TAB char.)"); else if (card[ii] == 10) strcat(msg, " (Line Feed char.)"); else if (card[ii] == 11) strcat(msg, " (Vertical Tab)"); else if (card[ii] == 12) strcat(msg, " (Form Feed char.)"); else if (card[ii] == 13) strcat(msg, " (Carriage Return)"); else if (card[ii] == 27) strcat(msg, " (Escape char.)"); else if (card[ii] == 127) strcat(msg, " (Delete char.)"); ffpmsg(msg); strncpy(msg, card, 80); msg[80] = '\0'; ffpmsg(msg); return(*status = BAD_KEYCHAR); } } return(*status); } /*--------------------------------------------------------------------------*/ void ffupch(char *string) /* convert string to upper case, in place. */ { size_t len, ii; len = strlen(string); for (ii = 0; ii < len; ii++) string[ii] = toupper(string[ii]); return; } /*--------------------------------------------------------------------------*/ int ffmkky(const char *keyname, /* I - keyword name */ char *value, /* I - keyword value */ const char *comm, /* I - keyword comment */ char *card, /* O - constructed keyword card */ int *status) /* IO - status value */ /* Make a complete FITS 80-byte keyword card from the input name, value and comment strings. Output card is null terminated without any trailing blanks. */ { size_t namelen, len, ii; char tmpname[FLEN_KEYWORD], *cptr; int tstatus = -1, nblank = 0; if (*status > 0) return(*status); *tmpname = '\0'; *card = '\0'; while(*(keyname + nblank) == ' ') /* skip leading blanks in the name */ nblank++; strncat(tmpname, keyname + nblank, FLEN_KEYWORD - 1); len = strlen(value); namelen = strlen(tmpname); if (namelen) { cptr = tmpname + namelen - 1; while(*cptr == ' ') /* skip trailing blanks */ { *cptr = '\0'; cptr--; } namelen = cptr - tmpname + 1; } if (namelen <= 8 && (fftkey(keyname, &tstatus) <= 0) ) { /* a normal FITS keyword */ strcat(card, tmpname); /* copy keyword name to buffer */ for (ii = namelen; ii < 8; ii++) card[ii] = ' '; /* pad keyword name with spaces */ card[8] = '='; /* append '= ' in columns 9-10 */ card[9] = ' '; card[10] = '\0'; /* terminate the partial string */ namelen = 10; } else { /* use the ESO HIERARCH convention for longer keyword names */ /* check that the name does not contain an '=' (equals sign) */ if (strchr(tmpname, '=') ) { ffpmsg("Illegal keyword name; contains an equals sign (=)"); ffpmsg(tmpname); return(*status = BAD_KEYCHAR); } /* Don't repeat HIERARCH if the keyword already contains it */ if (FSTRNCMP(tmpname, "HIERARCH ", 9) && FSTRNCMP(tmpname, "hierarch ", 9)) strcat(card, "HIERARCH "); else namelen -= 9; /* deleted the string 'HIERARCH ' */ strcat(card, tmpname); if (namelen + 12 + len > 80) { /* save 1 char by not putting a space before the equals sign */ strcat(card, "= "); namelen += 11; } else { strcat(card, " = "); namelen += 12; } } if (len > 0) { if (value[0] == '\'') /* is this a quoted string value? */ { if (namelen > 77) { ffpmsg( "The following keyword + value is too long to fit on a card:"); ffpmsg(keyname); ffpmsg(value); return(*status = BAD_KEYCHAR); } strncat(card, value, 80 - namelen); /* append the value string */ len = minvalue(80, namelen + len); /* restore the closing quote if it got truncated */ if (len == 80) { card[79] = '\''; } if (comm) { if (comm[0] != 0) { if (len < 30) { for (ii = len; ii < 30; ii++) card[ii] = ' '; /* fill with spaces to col 30 */ card[30] = '\0'; len = 30; } } } } else { if (namelen + len > 80) { ffpmsg( "The following keyword + value is too long to fit on a card:"); ffpmsg(keyname); ffpmsg(value); return(*status = BAD_KEYCHAR); } else if (namelen + len < 30) { /* add spaces so field ends at least in col 30 */ strncat(card, " ", 30 - (namelen + len)); } strncat(card, value, 80 - namelen); /* append the value string */ len = minvalue(80, namelen + len); len = maxvalue(30, len); } if (comm) { if ((len < 77) && ( strlen(comm) > 0) ) /* room for a comment? */ { strcat(card, " / "); /* append comment separator */ strncat(card, comm, 77 - len); /* append comment (what fits) */ } } } else { if (namelen == 10) /* This case applies to normal keywords only */ { card[8] = ' '; /* keywords with no value have no '=' */ if (comm) { strncat(card, comm, 80 - namelen); /* append comment (what fits) */ } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffmkey(fitsfile *fptr, /* I - FITS file pointer */ const char *card, /* I - card string value */ int *status) /* IO - error status */ /* replace the previously read card (i.e. starting 80 bytes before the (fptr->Fptr)->nextkey position) with the contents of the input card. */ { char tcard[81]; size_t len, ii; /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); strncpy(tcard,card,80); tcard[80] = '\0'; len = strlen(tcard); /* silently replace any illegal characters with a space */ for (ii=0; ii < len; ii++) if (tcard[ii] < ' ' || tcard[ii] > 126) tcard[ii] = ' '; for (ii=len; ii < 80; ii++) /* fill card with spaces if necessary */ tcard[ii] = ' '; for (ii=0; ii < 8; ii++) /* make sure keyword name is uppercase */ tcard[ii] = toupper(tcard[ii]); fftkey(tcard, status); /* test keyword name contains legal chars */ /* no need to do this any more, since any illegal characters have been removed fftrec(tcard, status); */ /* test rest of keyword for legal chars */ /* move position of keyword to be over written */ ffmbyt(fptr, ((fptr->Fptr)->nextkey) - 80, REPORT_EOF, status); ffpbyt(fptr, 80, tcard, status); /* write the 80 byte card */ return(*status); } /*--------------------------------------------------------------------------*/ int ffkeyn(const char *keyroot, /* I - root string for keyword name */ int value, /* I - index number to be appended to root name */ char *keyname, /* O - output root + index keyword name */ int *status) /* IO - error status */ /* Construct a keyword name string by appending the index number to the root. e.g., if root = "TTYPE" and value = 12 then keyname = "TTYPE12". */ { char suffix[16]; size_t rootlen; keyname[0] = '\0'; /* initialize output name to null */ rootlen = strlen(keyroot); if (rootlen == 0 || rootlen > 7 || value < 0 ) return(*status = 206); sprintf(suffix, "%d", value); /* construct keyword suffix */ if ( strlen(suffix) + rootlen > 8) return(*status = 206); strcpy(keyname, keyroot); /* copy root string to name string */ strcat(keyname, suffix); /* append suffix to the root */ return(*status); } /*--------------------------------------------------------------------------*/ int ffnkey(int value, /* I - index number to be appended to root name */ const char *keyroot, /* I - root string for keyword name */ char *keyname, /* O - output root + index keyword name */ int *status) /* IO - error status */ /* Construct a keyword name string by appending the root string to the index number. e.g., if root = "TTYPE" and value = 12 then keyname = "12TTYPE". */ { size_t rootlen; keyname[0] = '\0'; /* initialize output name to null */ rootlen = strlen(keyroot); if (rootlen == 0 || rootlen > 7 || value < 0 ) return(*status = 206); sprintf(keyname, "%d", value); /* construct keyword prefix */ if (rootlen + strlen(keyname) > 8) return(*status = 206); strcat(keyname, keyroot); /* append root to the prefix */ return(*status); } /*--------------------------------------------------------------------------*/ int ffpsvc(char *card, /* I - FITS header card (nominally 80 bytes long) */ char *value, /* O - value string parsed from the card */ char *comm, /* O - comment string parsed from the card */ int *status) /* IO - error status */ /* ParSe the Value and Comment strings from the input header card string. If the card contains a quoted string value, the returned value string includes the enclosing quote characters. If comm = NULL, don't return the comment string. */ { int jj; size_t ii, cardlen, nblank, valpos; if (*status > 0) return(*status); value[0] = '\0'; if (comm) comm[0] = '\0'; cardlen = strlen(card); /* support for ESO HIERARCH keywords; find the '=' */ if (FSTRNCMP(card, "HIERARCH ", 9) == 0) { valpos = strcspn(card, "="); if (valpos == cardlen) /* no value indicator ??? */ { if (comm != NULL) { if (cardlen > 8) { strcpy(comm, &card[8]); jj=cardlen - 8; for (jj--; jj >= 0; jj--) /* replace trailing blanks with nulls */ { if (comm[jj] == ' ') comm[jj] = '\0'; else break; } } } return(*status); /* no value indicator */ } valpos++; /* point to the position after the '=' */ } else if (cardlen < 9 || FSTRNCMP(card, "COMMENT ", 8) == 0 || /* keywords with no value */ FSTRNCMP(card, "HISTORY ", 8) == 0 || FSTRNCMP(card, "END ", 8) == 0 || FSTRNCMP(card, " ", 8) == 0 || FSTRNCMP(&card[8], "= ", 2) != 0 ) /* no '= ' in cols 9-10 */ { /* no value, so the comment extends from cols 9 - 80 */ if (comm != NULL) { if (cardlen > 8) { strcpy(comm, &card[8]); jj=cardlen - 8; for (jj--; jj >= 0; jj--) /* replace trailing blanks with nulls */ { if (comm[jj] == ' ') comm[jj] = '\0'; else break; } } } return(*status); } else { valpos = 10; /* starting position of the value field */ } nblank = strspn(&card[valpos], " "); /* find number of leading blanks */ if (nblank + valpos == cardlen) { /* the absence of a value string is legal, and simply indicates that the keyword value is undefined. Don't write an error message in this case. */ return(*status); } ii = valpos + nblank; if (card[ii] == '/' ) /* slash indicates start of the comment */ { ii++; } else if (card[ii] == '\'' ) /* is this a quoted string value? */ { value[0] = card[ii]; for (jj=1, ii++; ii < cardlen; ii++, jj++) { if (card[ii] == '\'') /* is this the closing quote? */ { if (card[ii+1] == '\'') /* 2 successive quotes? */ { value[jj] = card[ii]; ii++; jj++; } else { value[jj] = card[ii]; break; /* found the closing quote, so exit this loop */ } } value[jj] = card[ii]; /* copy the next character to the output */ } if (ii == cardlen) { jj = minvalue(jj, 69); /* don't exceed 70 char string length */ value[jj] = '\''; /* close the bad value string */ value[jj+1] = '\0'; /* terminate the bad value string */ ffpmsg("This keyword string value has no closing quote:"); ffpmsg(card); /* May 2008 - modified to not fail on this minor error */ /* return(*status = NO_QUOTE); */ } else { value[jj+1] = '\0'; /* terminate the good value string */ ii++; /* point to the character following the value */ } } else if (card[ii] == '(' ) /* is this a complex value? */ { nblank = strcspn(&card[ii], ")" ); /* find closing ) */ if (nblank == strlen( &card[ii] ) ) { ffpmsg("This complex keyword value has no closing ')':"); ffpmsg(card); return(*status = NO_QUOTE); } nblank++; strncpy(value, &card[ii], nblank); value[nblank] = '\0'; ii = ii + nblank; } else /* an integer, floating point, or logical FITS value string */ { nblank = strcspn(&card[ii], " /"); /* find the end of the token */ strncpy(value, &card[ii], nblank); value[nblank] = '\0'; ii = ii + nblank; } /* now find the comment string, if any */ if (comm) { nblank = strspn(&card[ii], " "); /* find next non-space character */ ii = ii + nblank; if (ii < 80) { if (card[ii] == '/') /* ignore the slash separator */ { ii++; if (card[ii] == ' ') /* also ignore the following space */ ii++; } strcat(comm, &card[ii]); /* copy the remaining characters */ jj=strlen(comm); for (jj--; jj >= 0; jj--) /* replace trailing blanks with nulls */ { if (comm[jj] == ' ') comm[jj] = '\0'; else break; } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffgthd(char *tmplt, /* I - input header template string */ char *card, /* O - returned FITS header record */ int *hdtype, /* O - how to interpreter the returned card string */ /* -2 = modify the name of a keyword; the old keyword name is returned starting at address chars[0]; the new name is returned starting at address char[40] (to be consistent with the Fortran version). Both names are null terminated. -1 = card contains the name of a keyword that is to be deleted 0 = append this keyword if it doesn't already exist, or modify the value if the keyword already exists. 1 = append this comment keyword ('HISTORY', 'COMMENT', or blank keyword name) 2 = this is the END keyword; do not write it to the header */ int *status) /* IO - error status */ /* 'Get Template HeaDer' parse a template header line and create a formated character string which is suitable for appending to a FITS header */ { char keyname[FLEN_KEYWORD], value[140], comment[140]; char *tok, *suffix, *loc, tvalue[140]; int len, vlen, more, tstatus; double dval; if (*status > 0) return(*status); card[0] = '\0'; *hdtype = 0; if (!FSTRNCMP(tmplt, " ", 8) ) { /* if first 8 chars of template are blank, then this is a comment */ strncat(card, tmplt, 80); *hdtype = 1; return(*status); } tok = tmplt; /* point to start of template string */ keyname[0] = '\0'; value[0] = '\0'; comment[0] = '\0'; len = strspn(tok, " "); /* no. of spaces before keyword */ tok += len; /* test for pecular case where token is a string of dashes */ if (strncmp(tok, "--------------------", 20) == 0) return(*status = BAD_KEYCHAR); if (tok[0] == '-') /* is there a leading minus sign? */ { /* first token is name of keyword to be deleted or renamed */ *hdtype = -1; tok++; len = strspn(tok, " "); /* no. of spaces before keyword */ tok += len; if (len < 8) /* not a blank name? */ { len = strcspn(tok, " ="); /* length of name */ if (len >= FLEN_KEYWORD) return(*status = BAD_KEYCHAR); strncat(card, tok, len); /* The HIERARCH convention supports non-standard characters in the keyword name, so don't always convert to upper case or abort if there are illegal characters in the name or if the name is greater than 8 characters long. */ if (len < 9) /* this is possibly a normal FITS keyword name */ { ffupch(card); tstatus = 0; if (fftkey(card, &tstatus) > 0) { /* name contained non-standard characters, so reset */ card[0] = '\0'; strncat(card, tok, len); } } tok += len; } /* second token, if present, is the new name for the keyword */ len = strspn(tok, " "); /* no. of spaces before next token */ tok += len; if (tok[0] == '\0' || tok[0] == '=') return(*status); /* no second token */ *hdtype = -2; len = strcspn(tok, " "); /* length of new name */ if (len > 40) /* name has to fit on columns 41-80 of card */ return(*status = BAD_KEYCHAR); /* copy the new name to card + 40; This is awkward, */ /* but is consistent with the way the Fortran FITSIO works */ strcat(card," "); strncpy(&card[40], tok, len+1); /* copy len+1 to get terminator */ /* The HIERARCH convention supports non-standard characters in the keyword name, so don't always convert to upper case or abort if there are illegal characters in the name or if the name is greater than 8 characters long. */ if (len < 9) /* this is possibly a normal FITS keyword name */ { ffupch(&card[40]); tstatus = 0; if (fftkey(&card[40], &tstatus) > 0) { /* name contained non-standard characters, so reset */ strncpy(&card[40], tok, len); } } } else /* no negative sign at beginning of template */ { /* get the keyword name token */ len = strcspn(tok, " ="); /* length of keyword name */ if (len >= FLEN_KEYWORD) return(*status = BAD_KEYCHAR); strncat(keyname, tok, len); /* The HIERARCH convention supports non-standard characters in the keyword name, so don't always convert to upper case or abort if there are illegal characters in the name or if the name is greater than 8 characters long. */ if (len < 9) /* this is possibly a normal FITS keyword name */ { ffupch(keyname); tstatus = 0; if (fftkey(keyname, &tstatus) > 0) { /* name contained non-standard characters, so reset */ keyname[0] = '\0'; strncat(keyname, tok, len); } } if (!FSTRCMP(keyname, "END") ) { strcpy(card, "END"); *hdtype = 2; return(*status); } tok += len; /* move token pointer to end of the keyword */ if (!FSTRCMP(keyname, "COMMENT") || !FSTRCMP(keyname, "HISTORY") || !FSTRCMP(keyname, "HIERARCH") ) { *hdtype = 1; /* simply append COMMENT and HISTORY keywords */ strcpy(card, keyname); strncat(card, tok, 73); return(*status); } /* look for the value token */ len = strspn(tok, " ="); /* spaces or = between name and value */ tok += len; if (*tok == '\'') /* is value enclosed in quotes? */ { more = TRUE; while (more) { tok++; /* temporarily move past the quote char */ len = strcspn(tok, "'"); /* length of quoted string */ tok--; strncat(value, tok, len + 2); tok += len + 1; if (tok[0] != '\'') /* check there is a closing quote */ return(*status = NO_QUOTE); tok++; if (tok[0] != '\'') /* 2 quote chars = literal quote */ more = FALSE; } } else if (*tok == '/' || *tok == '\0') /* There is no value */ { strcat(value, " "); } else /* not a quoted string value */ { len = strcspn(tok, " /"); /* length of value string */ strncat(value, tok, len); if (!( (tok[0] == 'T' || tok[0] == 'F') && (tok[1] == ' ' || tok[1] == '/' || tok[1] == '\0') )) { /* not a logical value */ dval = strtod(value, &suffix); /* try to read value as number */ if (*suffix != '\0' && *suffix != ' ' && *suffix != '/') { /* value not recognized as a number; might be because it */ /* contains a 'd' or 'D' exponent character */ strcpy(tvalue, value); if ((loc = strchr(tvalue, 'D'))) { *loc = 'E'; /* replace D's with E's. */ dval = strtod(tvalue, &suffix); /* read value again */ } else if ((loc = strchr(tvalue, 'd'))) { *loc = 'E'; /* replace d's with E's. */ dval = strtod(tvalue, &suffix); /* read value again */ } else if ((loc = strchr(tvalue, '.'))) { *loc = ','; /* replace period with a comma */ dval = strtod(tvalue, &suffix); /* read value again */ } } if (*suffix != '\0' && *suffix != ' ' && *suffix != '/') { /* value is not a number; must enclose it in quotes */ strcpy(value, "'"); strncat(value, tok, len); strcat(value, "'"); /* the following useless statement stops the compiler warning */ /* that dval is not used anywhere */ if (dval == 0.) len += (int) dval; } else { /* value is a number; convert any 'e' to 'E', or 'd' to 'D' */ loc = strchr(value, 'e'); if (loc) { *loc = 'E'; } else { loc = strchr(value, 'd'); if (loc) { *loc = 'D'; } } } } tok += len; } len = strspn(tok, " /"); /* no. of spaces between value and comment */ tok += len; vlen = strlen(value); if (vlen > 0 && vlen < 10 && value[0] == '\'') { /* pad quoted string with blanks so it is at least 8 chars long */ value[vlen-1] = '\0'; strncat(value, " ", 10 - vlen); strcat(&value[9], "'"); } /* get the comment string */ strncat(comment, tok, 70); /* construct the complete FITS header card */ ffmkky(keyname, value, comment, card, status); } return(*status); } /*--------------------------------------------------------------------------*/ int fits_translate_keyword( char *inrec, /* I - input string */ char *outrec, /* O - output converted string, or */ /* a null string if input does not */ /* match any of the patterns */ char *patterns[][2],/* I - pointer to input / output string */ /* templates */ int npat, /* I - number of templates passed */ int n_value, /* I - base 'n' template value of interest */ int n_offset, /* I - offset to be applied to the 'n' */ /* value in the output string */ int n_range, /* I - controls range of 'n' template */ /* values of interest (-1,0, or +1) */ int *pat_num, /* O - matched pattern number (0 based) or -1 */ int *i, /* O - value of i, if any, else 0 */ int *j, /* O - value of j, if any, else 0 */ int *m, /* O - value of m, if any, else 0 */ int *n, /* O - value of n, if any, else 0 */ int *status) /* IO - error status */ /* Translate a keyword name to a new name, based on a set of patterns. The user passes an array of patterns to be matched. Input pattern number i is pattern[i][0], and output pattern number i is pattern[i][1]. Keywords are matched against the input patterns. If a match is found then the keyword is re-written according to the output pattern. Order is important. The first match is accepted. The fastest match will be made when templates with the same first character are grouped together. Several characters have special meanings: i,j - single digits, preserved in output template n - column number of one or more digits, preserved in output template m - generic number of one or more digits, preserved in output template a - coordinate designator, preserved in output template # - number of one or more digits ? - any character * - only allowed in first character position, to match all keywords; only useful as last pattern in the list i, j, n, and m are returned by the routine. For example, the input pattern "iCTYPn" will match "1CTYP5" (if n_value is 5); the output pattern "CTYPEi" will be re-written as "CTYPE1". Notice that "i" is preserved. The following output patterns are special Special output pattern characters: "-" - do not copy a keyword that matches the corresponding input pattern "+" - copy the input unchanged The inrec string could be just the 8-char keyword name, or the entire 80-char header record. Characters 9 = 80 in the input string simply get appended to the translated keyword name. If n_range = 0, then only keywords with 'n' equal to n_value will be considered as a pattern match. If n_range = +1, then all values of 'n' greater than or equal to n_value will be a match, and if -1, then values of 'n' less than or equal to n_value will match. This routine was written by Craig Markwardt, GSFC */ { int i1 = 0, j1 = 0, n1 = 0, m1 = 0; int fac; char a = ' '; char oldp; char c, s; int ip, ic, pat, pass = 0, firstfail; char *spat; if (*status > 0) return(*status); if ((inrec == 0) || (outrec == 0)) return (*status = NULL_INPUT_PTR); *outrec = '\0'; /* if (*inrec == '\0') return 0; */ if (*inrec == '\0') /* expand to full 8 char blank keyword name */ strcpy(inrec, " "); oldp = '\0'; firstfail = 0; /* ===== Pattern match stage */ for (pat=0; pat < npat; pat++) { spat = patterns[pat][0]; i1 = 0; j1 = 0; m1 = -1; n1 = -1; a = ' '; /* Initialize the place-holders */ pass = 0; /* Pass the wildcard pattern */ if (spat[0] == '*') { pass = 1; break; } /* Optimization: if we have seen this initial pattern character before, then it must have failed, and we can skip the pattern */ if (firstfail && spat[0] == oldp) continue; oldp = spat[0]; /* ip = index of pattern character being matched ic = index of keyname character being matched firstfail = 1 if we fail on the first characteor (0=not) */ for (ip=0, ic=0, firstfail=1; (spat[ip]) && (ic < 8); ip++, ic++, firstfail=0) { c = inrec[ic]; s = spat[ip]; if (s == 'i') { /* Special pattern: 'i' placeholder */ if (isdigit(c)) { i1 = c - '0'; pass = 1;} } else if (s == 'j') { /* Special pattern: 'j' placeholder */ if (isdigit(c)) { j1 = c - '0'; pass = 1;} } else if ((s == 'n')||(s == 'm')||(s == '#')) { /* Special patterns: multi-digit number */ int val = 0; pass = 0; if (isdigit(c)) { pass = 1; /* NOTE, could fail below */ /* Parse decimal number */ while (ic<8 && isdigit(c)) { val = val*10 + (c - '0'); ic++; c = inrec[ic]; } ic--; c = inrec[ic]; if (s == 'n') { /* Is it a column number? */ if ( val >= 1 && val <= 999 && /* Row range check */ (((n_range == 0) && (val == n_value)) || /* Strict equality */ ((n_range == -1) && (val <= n_value)) || /* n <= n_value */ ((n_range == +1) && (val >= n_value))) ) { /* n >= n_value */ n1 = val; } else { pass = 0; } } else if (s == 'm') { /* Generic number */ m1 = val; } } } else if (s == 'a') { /* Special pattern: coordinate designator */ if (isupper(c) || c == ' ') { a = c; pass = 1;} } else if (s == '?') { /* Match any individual character */ pass = 1; } else if (c == s) { /* Match a specific character */ pass = 1; } else { /* FAIL */ pass = 0; } if (!pass) break; } /* Must pass to the end of the keyword. No partial matches allowed */ if (pass && (ic >= 8 || inrec[ic] == ' ')) break; } /* Transfer the pattern-matched numbers to the output parameters */ if (i) { *i = i1; } if (j) { *j = j1; } if (n) { *n = n1; } if (m) { *m = m1; } if (pat_num) { *pat_num = pat; } /* ===== Keyword rewriting and output stage */ spat = patterns[pat][1]; /* Return case: no match, or explicit deletion pattern */ if (pass == 0 || spat[0] == '\0' || spat[0] == '-') return 0; /* A match: we start by copying the input record to the output */ strcpy(outrec, inrec); /* Return case: return the input record unchanged */ if (spat[0] == '+') return 0; /* Final case: a new output pattern */ for (ip=0, ic=0; spat[ip]; ip++, ic++) { s = spat[ip]; if (s == 'i') { outrec[ic] = (i1+'0'); } else if (s == 'j') { outrec[ic] = (j1+'0'); } else if (s == 'n') { if (n1 == -1) { n1 = n_value; } if (n1 > 0) { n1 += n_offset; for (fac = 1; (n1/fac) > 0; fac *= 10); fac /= 10; while(fac > 0) { outrec[ic] = ((n1/fac) % 10) + '0'; fac /= 10; ic ++; } ic--; } } else if (s == 'm' && m1 >= 0) { for (fac = 1; (m1/fac) > 0; fac *= 10); fac /= 10; while(fac > 0) { outrec[ic] = ((m1/fac) % 10) + '0'; fac /= 10; ic ++; } ic --; } else if (s == 'a') { outrec[ic] = a; } else { outrec[ic] = s; } } /* Pad the keyword name with spaces */ for ( ; ic<8; ic++) { outrec[ic] = ' '; } return(*status); } /*--------------------------------------------------------------------------*/ int fits_translate_keywords( fitsfile *infptr, /* I - pointer to input HDU */ fitsfile *outfptr, /* I - pointer to output HDU */ int firstkey, /* I - first HDU record number to start with */ char *patterns[][2],/* I - pointer to input / output keyword templates */ int npat, /* I - number of templates passed */ int n_value, /* I - base 'n' template value of interest */ int n_offset, /* I - offset to be applied to the 'n' */ /* value in the output string */ int n_range, /* I - controls range of 'n' template */ /* values of interest (-1,0, or +1) */ int *status) /* IO - error status */ /* Copy relevant keywords from the table header into the newly created primary array header. Convert names of keywords where appropriate. See fits_translate_keyword() for the definitions. Translation begins at header record number 'firstkey', and continues to the end of the header. This routine was written by Craig Markwardt, GSFC */ { int nrec, nkeys, nmore; char rec[FLEN_CARD]; int i = 0, j = 0, n = 0, m = 0; int pat_num = 0, maxchr, ii; char outrec[FLEN_CARD]; if (*status > 0) return(*status); ffghsp(infptr, &nkeys, &nmore, status); /* get number of keywords */ for (nrec = firstkey; nrec <= nkeys; nrec++) { outrec[0] = '\0'; ffgrec(infptr, nrec, rec, status); /* silently overlook any illegal ASCII characters in the value or */ /* comment fields of the record. It is usually not appropriate to */ /* abort the process because of this minor transgression of the FITS rules. */ /* Set the offending character to a blank */ maxchr = strlen(rec); for (ii = 8; ii < maxchr; ii++) { if (rec[ii] < 32 || rec[ii] > 126) rec[ii] = ' '; } fits_translate_keyword(rec, outrec, patterns, npat, n_value, n_offset, n_range, &pat_num, &i, &j, &m, &n, status); if (outrec[0]) { ffprec(outfptr, outrec, status); /* copy the keyword */ rec[8] = 0; outrec[8] = 0; } else { rec[8] = 0; outrec[8] = 0; } } return(*status); } /*--------------------------------------------------------------------------*/ int fits_copy_pixlist2image( fitsfile *infptr, /* I - pointer to input HDU */ fitsfile *outfptr, /* I - pointer to output HDU */ int firstkey, /* I - first HDU record number to start with */ int naxis, /* I - number of axes in the image */ int *colnum, /* I - numbers of the columns to be binned */ int *status) /* IO - error status */ /* Copy relevant keywords from the pixel list table header into a newly created primary array header. Convert names of keywords where appropriate. See fits_translate_pixkeyword() for the definitions. Translation begins at header record number 'firstkey', and continues to the end of the header. */ { int nrec, nkeys, nmore; char rec[FLEN_CARD], outrec[FLEN_CARD]; int pat_num = 0, npat; int iret, jret, nret, mret, lret; char *patterns[][2] = { {"TCTYPn", "CTYPEn" }, {"TCTYna", "CTYPEna" }, {"TCUNIn", "CUNITn" }, {"TCUNna", "CUNITna" }, {"TCRVLn", "CRVALn" }, {"TCRVna", "CRVALna" }, {"TCDLTn", "CDELTn" }, {"TCDEna", "CDELTna" }, {"TCRPXn", "CRPIXn" }, {"TCRPna", "CRPIXna" }, {"TCROTn", "CROTAn" }, {"TPn_ma", "PCn_ma" }, {"TPCn_m", "PCn_ma" }, {"TCn_ma", "CDn_ma" }, {"TCDn_m", "CDn_ma" }, {"TVn_la", "PVn_la" }, {"TPVn_l", "PVn_la" }, {"TSn_la", "PSn_la" }, {"TPSn_l", "PSn_la" }, {"TWCSna", "WCSNAMEa" }, {"TCNAna", "CNAMEna" }, {"TCRDna", "CRDERna" }, {"TCSYna", "CSYERna" }, {"LONPna", "LONPOLEa" }, {"LATPna", "LATPOLEa" }, {"EQUIna", "EQUINOXa" }, {"MJDOBn", "MJD-OBS" }, {"MJDAn", "MJD-AVG" }, {"DAVGn", "DATE-AVG" }, {"RADEna", "RADESYSa" }, {"RFRQna", "RESTFRQa" }, {"RWAVna", "RESTWAVa" }, {"SPECna", "SPECSYSa" }, {"SOBSna", "SSYSOBSa" }, {"SSRCna", "SSYSSRCa" }, /* preserve common keywords */ {"LONPOLEa", "+" }, {"LATPOLEa", "+" }, {"EQUINOXa", "+" }, {"EPOCH", "+" }, {"MJD-????", "+" }, {"DATE????", "+" }, {"TIME????", "+" }, {"RADESYSa", "+" }, {"RADECSYS", "+" }, {"TELESCOP", "+" }, {"INSTRUME", "+" }, {"OBSERVER", "+" }, {"OBJECT", "+" }, /* Delete general table column keywords */ {"XTENSION", "-" }, {"BITPIX", "-" }, {"NAXIS", "-" }, {"NAXISi", "-" }, {"PCOUNT", "-" }, {"GCOUNT", "-" }, {"TFIELDS", "-" }, {"TDIM#", "-" }, {"THEAP", "-" }, {"EXTNAME", "-" }, {"EXTVER", "-" }, {"EXTLEVEL","-" }, {"CHECKSUM","-" }, {"DATASUM", "-" }, {"NAXLEN", "-" }, {"AXLEN#", "-" }, {"CPREF", "-" }, /* Delete table keywords related to other columns */ {"T????#a", "-" }, {"TC??#a", "-" }, {"T??#_#", "-" }, {"TWCS#a", "-" }, {"LONP#a", "-" }, {"LATP#a", "-" }, {"EQUI#a", "-" }, {"MJDOB#", "-" }, {"MJDA#", "-" }, {"RADE#a", "-" }, {"DAVG#", "-" }, {"iCTYP#", "-" }, {"iCTY#a", "-" }, {"iCUNI#", "-" }, {"iCUN#a", "-" }, {"iCRVL#", "-" }, {"iCDLT#", "-" }, {"iCRPX#", "-" }, {"iCTY#a", "-" }, {"iCUN#a", "-" }, {"iCRV#a", "-" }, {"iCDE#a", "-" }, {"iCRP#a", "-" }, {"ijPC#a", "-" }, {"ijCD#a", "-" }, {"iV#_#a", "-" }, {"iS#_#a", "-" }, {"iCRD#a", "-" }, {"iCSY#a", "-" }, {"iCROT#", "-" }, {"WCAX#a", "-" }, {"WCSN#a", "-" }, {"iCNA#a", "-" }, {"*", "+" }}; /* copy all other keywords */ if (*status > 0) return(*status); npat = sizeof(patterns)/sizeof(patterns[0][0])/2; ffghsp(infptr, &nkeys, &nmore, status); /* get number of keywords */ for (nrec = firstkey; nrec <= nkeys; nrec++) { outrec[0] = '\0'; ffgrec(infptr, nrec, rec, status); fits_translate_pixkeyword(rec, outrec, patterns, npat, naxis, colnum, &pat_num, &iret, &jret, &nret, &mret, &lret, status); if (outrec[0]) { ffprec(outfptr, outrec, status); /* copy the keyword */ } rec[8] = 0; outrec[8] = 0; } return(*status); } /*--------------------------------------------------------------------------*/ int fits_translate_pixkeyword( char *inrec, /* I - input string */ char *outrec, /* O - output converted string, or */ /* a null string if input does not */ /* match any of the patterns */ char *patterns[][2],/* I - pointer to input / output string */ /* templates */ int npat, /* I - number of templates passed */ int naxis, /* I - number of columns to be binned */ int *colnum, /* I - numbers of the columns to be binned */ int *pat_num, /* O - matched pattern number (0 based) or -1 */ int *i, int *j, int *n, int *m, int *l, int *status) /* IO - error status */ /* Translate a keyword name to a new name, based on a set of patterns. The user passes an array of patterns to be matched. Input pattern number i is pattern[i][0], and output pattern number i is pattern[i][1]. Keywords are matched against the input patterns. If a match is found then the keyword is re-written according to the output pattern. Order is important. The first match is accepted. The fastest match will be made when templates with the same first character are grouped together. Several characters have special meanings: i,j - single digits, preserved in output template n, m - column number of one or more digits, preserved in output template k - generic number of one or more digits, preserved in output template a - coordinate designator, preserved in output template # - number of one or more digits ? - any character * - only allowed in first character position, to match all keywords; only useful as last pattern in the list i, j, n, and m are returned by the routine. For example, the input pattern "iCTYPn" will match "1CTYP5" (if n_value is 5); the output pattern "CTYPEi" will be re-written as "CTYPE1". Notice that "i" is preserved. The following output patterns are special Special output pattern characters: "-" - do not copy a keyword that matches the corresponding input pattern "+" - copy the input unchanged The inrec string could be just the 8-char keyword name, or the entire 80-char header record. Characters 9 = 80 in the input string simply get appended to the translated keyword name. If n_range = 0, then only keywords with 'n' equal to n_value will be considered as a pattern match. If n_range = +1, then all values of 'n' greater than or equal to n_value will be a match, and if -1, then values of 'n' less than or equal to n_value will match. */ { int i1 = 0, j1 = 0, val; int fac, nval = 0, mval = 0, lval = 0; char a = ' '; char oldp; char c, s; int ip, ic, pat, pass = 0, firstfail; char *spat; if (*status > 0) return(*status); if ((inrec == 0) || (outrec == 0)) return (*status = NULL_INPUT_PTR); *outrec = '\0'; if (*inrec == '\0') return 0; oldp = '\0'; firstfail = 0; /* ===== Pattern match stage */ for (pat=0; pat < npat; pat++) { spat = patterns[pat][0]; i1 = 0; j1 = 0; a = ' '; /* Initialize the place-holders */ pass = 0; /* Pass the wildcard pattern */ if (spat[0] == '*') { pass = 1; break; } /* Optimization: if we have seen this initial pattern character before, then it must have failed, and we can skip the pattern */ if (firstfail && spat[0] == oldp) continue; oldp = spat[0]; /* ip = index of pattern character being matched ic = index of keyname character being matched firstfail = 1 if we fail on the first characteor (0=not) */ for (ip=0, ic=0, firstfail=1; (spat[ip]) && (ic < 8); ip++, ic++, firstfail=0) { c = inrec[ic]; s = spat[ip]; if (s == 'i') { /* Special pattern: 'i' placeholder */ if (isdigit(c)) { i1 = c - '0'; pass = 1;} } else if (s == 'j') { /* Special pattern: 'j' placeholder */ if (isdigit(c)) { j1 = c - '0'; pass = 1;} } else if ((s == 'n')||(s == 'm')||(s == 'l')||(s == '#')) { /* Special patterns: multi-digit number */ val = 0; pass = 0; if (isdigit(c)) { pass = 1; /* NOTE, could fail below */ /* Parse decimal number */ while (ic<8 && isdigit(c)) { val = val*10 + (c - '0'); ic++; c = inrec[ic]; } ic--; c = inrec[ic]; if (s == 'n' || s == 'm') { /* Is it a column number? */ if ( val >= 1 && val <= 999) { if (val == colnum[0]) val = 1; else if (val == colnum[1]) val = 2; else if (val == colnum[2]) val = 3; else if (val == colnum[3]) val = 4; else { pass = 0; val = 0; } if (s == 'n') nval = val; else mval = val; } else { pass = 0; } } else if (s == 'l') { /* Generic number */ lval = val; } } } else if (s == 'a') { /* Special pattern: coordinate designator */ if (isupper(c) || c == ' ') { a = c; pass = 1;} } else if (s == '?') { /* Match any individual character */ pass = 1; } else if (c == s) { /* Match a specific character */ pass = 1; } else { /* FAIL */ pass = 0; } if (!pass) break; } /* Must pass to the end of the keyword. No partial matches allowed */ if (pass && (ic >= 8 || inrec[ic] == ' ')) break; } /* Transfer the pattern-matched numbers to the output parameters */ if (i) { *i = i1; } if (j) { *j = j1; } if (n) { *n = nval; } if (m) { *m = mval; } if (l) { *l = lval; } if (pat_num) { *pat_num = pat; } /* ===== Keyword rewriting and output stage */ spat = patterns[pat][1]; /* Return case: no match, or explicit deletion pattern */ if (pass == 0 || spat[0] == '\0' || spat[0] == '-') return 0; /* A match: we start by copying the input record to the output */ strcpy(outrec, inrec); /* Return case: return the input record unchanged */ if (spat[0] == '+') return 0; /* Final case: a new output pattern */ for (ip=0, ic=0; spat[ip]; ip++, ic++) { s = spat[ip]; if (s == 'i') { outrec[ic] = (i1+'0'); } else if (s == 'j') { outrec[ic] = (j1+'0'); } else if (s == 'n' && nval > 0) { for (fac = 1; (nval/fac) > 0; fac *= 10); fac /= 10; while(fac > 0) { outrec[ic] = ((nval/fac) % 10) + '0'; fac /= 10; ic ++; } ic--; } else if (s == 'm' && mval > 0) { for (fac = 1; (mval/fac) > 0; fac *= 10); fac /= 10; while(fac > 0) { outrec[ic] = ((mval/fac) % 10) + '0'; fac /= 10; ic ++; } ic--; } else if (s == 'l' && lval >= 0) { for (fac = 1; (lval/fac) > 0; fac *= 10); fac /= 10; while(fac > 0) { outrec[ic] = ((lval/fac) % 10) + '0'; fac /= 10; ic ++; } ic --; } else if (s == 'a') { outrec[ic] = a; } else { outrec[ic] = s; } } /* Pad the keyword name with spaces */ for ( ; ic<8; ic++) { outrec[ic] = ' '; } return(*status); } /*--------------------------------------------------------------------------*/ int ffasfm(char *tform, /* I - format code from the TFORMn keyword */ int *dtcode, /* O - numerical datatype code */ long *twidth, /* O - width of the field, in chars */ int *decimals, /* O - number of decimal places (F, E, D format) */ int *status) /* IO - error status */ { /* parse the ASCII table TFORM column format to determine the data type, the field width, and number of decimal places (if relevant) */ int ii, datacode; long longval, width; float fwidth; char *form, temp[FLEN_VALUE], message[FLEN_ERRMSG]; if (*status > 0) return(*status); if (dtcode) *dtcode = 0; if (twidth) *twidth = 0; if (decimals) *decimals = 0; ii = 0; while (tform[ii] != 0 && tform[ii] == ' ') /* find first non-blank char */ ii++; strcpy(temp, &tform[ii]); /* copy format string */ ffupch(temp); /* make sure it is in upper case */ form = temp; /* point to start of format string */ if (form[0] == 0) { ffpmsg("Error: ASCII table TFORM code is blank"); return(*status = BAD_TFORM); } /*-----------------------------------------------*/ /* determine default datatype code */ /*-----------------------------------------------*/ if (form[0] == 'A') datacode = TSTRING; else if (form[0] == 'I') datacode = TLONG; else if (form[0] == 'F') datacode = TFLOAT; else if (form[0] == 'E') datacode = TFLOAT; else if (form[0] == 'D') datacode = TDOUBLE; else { sprintf(message, "Illegal ASCII table TFORMn datatype: \'%s\'", tform); ffpmsg(message); return(*status = BAD_TFORM_DTYPE); } if (dtcode) *dtcode = datacode; form++; /* point to the start of field width */ if (datacode == TSTRING || datacode == TLONG) { /*-----------------------------------------------*/ /* A or I data formats: */ /*-----------------------------------------------*/ if (ffc2ii(form, &width, status) <= 0) /* read the width field */ { if (width <= 0) { width = 0; *status = BAD_TFORM; } else { /* set to shorter precision if I4 or less */ if (width <= 4 && datacode == TLONG) datacode = TSHORT; } } } else { /*-----------------------------------------------*/ /* F, E or D data formats: */ /*-----------------------------------------------*/ if (ffc2rr(form, &fwidth, status) <= 0) /* read ww.dd width field */ { if (fwidth <= 0.) *status = BAD_TFORM; else { width = (long) fwidth; /* convert from float to long */ if (width > 7 && *temp == 'F') datacode = TDOUBLE; /* type double if >7 digits */ if (width < 10) form = form + 1; /* skip 1 digit */ else form = form + 2; /* skip 2 digits */ if (form[0] == '.') /* should be a decimal point here */ { form++; /* point to start of decimals field */ if (ffc2ii(form, &longval, status) <= 0) /* read decimals */ { if (decimals) *decimals = longval; /* long to short convertion */ if (longval >= width) /* width < no. of decimals */ *status = BAD_TFORM; if (longval > 6 && *temp == 'E') datacode = TDOUBLE; /* type double if >6 digits */ } } } } } if (*status > 0) { *status = BAD_TFORM; sprintf(message,"Illegal ASCII table TFORMn code: \'%s\'", tform); ffpmsg(message); } if (dtcode) *dtcode = datacode; if (twidth) *twidth = width; return(*status); } /*--------------------------------------------------------------------------*/ int ffbnfm(char *tform, /* I - format code from the TFORMn keyword */ int *dtcode, /* O - numerical datatype code */ long *trepeat, /* O - repeat count of the field */ long *twidth, /* O - width of the field, in chars */ int *status) /* IO - error status */ { /* parse the binary table TFORM column format to determine the data type, repeat count, and the field width (if it is an ASCII (A) field) */ size_t ii, nchar; int datacode, variable, iread; long width, repeat; char *form, temp[FLEN_VALUE], message[FLEN_ERRMSG]; if (*status > 0) return(*status); if (dtcode) *dtcode = 0; if (trepeat) *trepeat = 0; if (twidth) *twidth = 0; nchar = strlen(tform); for (ii = 0; ii < nchar; ii++) { if (tform[ii] != ' ') /* find first non-space char */ break; } if (ii == nchar) { ffpmsg("Error: binary table TFORM code is blank (ffbnfm)."); return(*status = BAD_TFORM); } strcpy(temp, &tform[ii]); /* copy format string */ ffupch(temp); /* make sure it is in upper case */ form = temp; /* point to start of format string */ /*-----------------------------------------------*/ /* get the repeat count */ /*-----------------------------------------------*/ ii = 0; while(isdigit((int) form[ii])) ii++; /* look for leading digits in the field */ if (ii == 0) repeat = 1; /* no explicit repeat count */ else sscanf(form,"%ld", &repeat); /* read repeat count */ /*-----------------------------------------------*/ /* determine datatype code */ /*-----------------------------------------------*/ form = form + ii; /* skip over the repeat field */ if (form[0] == 'P' || form[0] == 'Q') { variable = 1; /* this is a variable length column */ /* repeat = 1; */ /* disregard any other repeat value */ form++; /* move to the next data type code char */ } else variable = 0; if (form[0] == 'U') /* internal code to signify unsigned integer */ { datacode = TUSHORT; width = 2; } else if (form[0] == 'I') { datacode = TSHORT; width = 2; } else if (form[0] == 'V') /* internal code to signify unsigned integer */ { datacode = TULONG; width = 4; } else if (form[0] == 'J') { datacode = TLONG; width = 4; } else if (form[0] == 'K') { datacode = TLONGLONG; width = 8; } else if (form[0] == 'E') { datacode = TFLOAT; width = 4; } else if (form[0] == 'D') { datacode = TDOUBLE; width = 8; } else if (form[0] == 'A') { datacode = TSTRING; /* the following code is used to support the non-standard datatype of the form rAw where r = total width of the field and w = width of fixed-length substrings within the field. */ iread = 0; if (form[1] != 0) { if (form[1] == '(' ) /* skip parenthesis around */ form++; /* variable length column width */ iread = sscanf(&form[1],"%ld", &width); } if (iread != 1 || (!variable && (width > repeat)) ) width = repeat; } else if (form[0] == 'L') { datacode = TLOGICAL; width = 1; } else if (form[0] == 'X') { datacode = TBIT; width = 1; } else if (form[0] == 'B') { datacode = TBYTE; width = 1; } else if (form[0] == 'S') /* internal code to signify signed byte */ { datacode = TSBYTE; width = 1; } else if (form[0] == 'C') { datacode = TCOMPLEX; width = 8; } else if (form[0] == 'M') { datacode = TDBLCOMPLEX; width = 16; } else { sprintf(message, "Illegal binary table TFORMn datatype: \'%s\' ", tform); ffpmsg(message); return(*status = BAD_TFORM_DTYPE); } if (variable) datacode = datacode * (-1); /* flag variable cols w/ neg type code */ if (dtcode) *dtcode = datacode; if (trepeat) *trepeat = repeat; if (twidth) *twidth = width; return(*status); } /*--------------------------------------------------------------------------*/ int ffbnfmll(char *tform, /* I - format code from the TFORMn keyword */ int *dtcode, /* O - numerical datatype code */ LONGLONG *trepeat, /* O - repeat count of the field */ long *twidth, /* O - width of the field, in chars */ int *status) /* IO - error status */ { /* parse the binary table TFORM column format to determine the data type, repeat count, and the field width (if it is an ASCII (A) field) */ size_t ii, nchar; int datacode, variable, iread; long width; LONGLONG repeat; char *form, temp[FLEN_VALUE], message[FLEN_ERRMSG]; double drepeat; if (*status > 0) return(*status); if (dtcode) *dtcode = 0; if (trepeat) *trepeat = 0; if (twidth) *twidth = 0; nchar = strlen(tform); for (ii = 0; ii < nchar; ii++) { if (tform[ii] != ' ') /* find first non-space char */ break; } if (ii == nchar) { ffpmsg("Error: binary table TFORM code is blank (ffbnfmll)."); return(*status = BAD_TFORM); } strcpy(temp, &tform[ii]); /* copy format string */ ffupch(temp); /* make sure it is in upper case */ form = temp; /* point to start of format string */ /*-----------------------------------------------*/ /* get the repeat count */ /*-----------------------------------------------*/ ii = 0; while(isdigit((int) form[ii])) ii++; /* look for leading digits in the field */ if (ii == 0) repeat = 1; /* no explicit repeat count */ else { /* read repeat count */ /* print as double, because the string-to-64-bit int conversion */ /* character is platform dependent (%lld, %ld, %I64d) */ sscanf(form,"%lf", &drepeat); repeat = (LONGLONG) (drepeat + 0.1); } /*-----------------------------------------------*/ /* determine datatype code */ /*-----------------------------------------------*/ form = form + ii; /* skip over the repeat field */ if (form[0] == 'P' || form[0] == 'Q') { variable = 1; /* this is a variable length column */ /* repeat = 1; */ /* disregard any other repeat value */ form++; /* move to the next data type code char */ } else variable = 0; if (form[0] == 'U') /* internal code to signify unsigned integer */ { datacode = TUSHORT; width = 2; } else if (form[0] == 'I') { datacode = TSHORT; width = 2; } else if (form[0] == 'V') /* internal code to signify unsigned integer */ { datacode = TULONG; width = 4; } else if (form[0] == 'J') { datacode = TLONG; width = 4; } else if (form[0] == 'K') { datacode = TLONGLONG; width = 8; } else if (form[0] == 'E') { datacode = TFLOAT; width = 4; } else if (form[0] == 'D') { datacode = TDOUBLE; width = 8; } else if (form[0] == 'A') { datacode = TSTRING; /* the following code is used to support the non-standard datatype of the form rAw where r = total width of the field and w = width of fixed-length substrings within the field. */ iread = 0; if (form[1] != 0) { if (form[1] == '(' ) /* skip parenthesis around */ form++; /* variable length column width */ iread = sscanf(&form[1],"%ld", &width); } if (iread != 1 || (!variable && (width > repeat)) ) width = (long) repeat; } else if (form[0] == 'L') { datacode = TLOGICAL; width = 1; } else if (form[0] == 'X') { datacode = TBIT; width = 1; } else if (form[0] == 'B') { datacode = TBYTE; width = 1; } else if (form[0] == 'S') /* internal code to signify signed byte */ { datacode = TSBYTE; width = 1; } else if (form[0] == 'C') { datacode = TCOMPLEX; width = 8; } else if (form[0] == 'M') { datacode = TDBLCOMPLEX; width = 16; } else { sprintf(message, "Illegal binary table TFORMn datatype: \'%s\' ", tform); ffpmsg(message); return(*status = BAD_TFORM_DTYPE); } if (variable) datacode = datacode * (-1); /* flag variable cols w/ neg type code */ if (dtcode) *dtcode = datacode; if (trepeat) *trepeat = repeat; if (twidth) *twidth = width; return(*status); } /*--------------------------------------------------------------------------*/ void ffcfmt(char *tform, /* value of an ASCII table TFORMn keyword */ char *cform) /* equivalent format code in C language syntax */ /* convert the FITS format string for an ASCII Table extension column into the equivalent C format string that can be used in a printf statement, after the values have been read as a double. */ { int ii; cform[0] = '\0'; ii = 0; while (tform[ii] != 0 && tform[ii] == ' ') /* find first non-blank char */ ii++; if (tform[ii] == 0) return; /* input format string was blank */ cform[0] = '%'; /* start the format string */ strcpy(&cform[1], &tform[ii + 1]); /* append the width and decimal code */ if (tform[ii] == 'A') strcat(cform, "s"); else if (tform[ii] == 'I') strcat(cform, ".0f"); /* 0 precision to suppress decimal point */ if (tform[ii] == 'F') strcat(cform, "f"); if (tform[ii] == 'E') strcat(cform, "E"); if (tform[ii] == 'D') strcat(cform, "E"); return; } /*--------------------------------------------------------------------------*/ void ffcdsp(char *tform, /* value of an ASCII table TFORMn keyword */ char *cform) /* equivalent format code in C language syntax */ /* convert the FITS TDISPn display format into the equivalent C format suitable for use in a printf statement. */ { int ii; cform[0] = '\0'; ii = 0; while (tform[ii] != 0 && tform[ii] == ' ') /* find first non-blank char */ ii++; if (tform[ii] == 0) { cform[0] = '\0'; return; /* input format string was blank */ } if (strchr(tform+ii, '%')) /* is there a % character in the string?? */ { cform[0] = '\0'; return; /* illegal TFORM string (possibly even harmful) */ } cform[0] = '%'; /* start the format string */ strcpy(&cform[1], &tform[ii + 1]); /* append the width and decimal code */ if (tform[ii] == 'A' || tform[ii] == 'a') strcat(cform, "s"); else if (tform[ii] == 'I' || tform[ii] == 'i') strcat(cform, "d"); else if (tform[ii] == 'O' || tform[ii] == 'o') strcat(cform, "o"); else if (tform[ii] == 'Z' || tform[ii] == 'z') strcat(cform, "X"); else if (tform[ii] == 'F' || tform[ii] == 'f') strcat(cform, "f"); else if (tform[ii] == 'E' || tform[ii] == 'e') strcat(cform, "E"); else if (tform[ii] == 'D' || tform[ii] == 'd') strcat(cform, "E"); else if (tform[ii] == 'G' || tform[ii] == 'g') strcat(cform, "G"); else cform[0] = '\0'; /* unrecognized tform code */ return; } /*--------------------------------------------------------------------------*/ int ffgcno( fitsfile *fptr, /* I - FITS file pionter */ int casesen, /* I - case sensitive string comparison? 0=no */ char *templt, /* I - input name of column (w/wildcards) */ int *colnum, /* O - number of the named column; 1=first col */ int *status) /* IO - error status */ /* Determine the column number corresponding to an input column name. The first column of the table = column 1; This supports the * and ? wild cards in the input template. */ { char colname[FLEN_VALUE]; /* temporary string to hold column name */ ffgcnn(fptr, casesen, templt, colname, colnum, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffgcnn( fitsfile *fptr, /* I - FITS file pointer */ int casesen, /* I - case sensitive string comparison? 0=no */ char *templt, /* I - input name of column (w/wildcards) */ char *colname, /* O - full column name up to 68 + 1 chars long*/ int *colnum, /* O - number of the named column; 1=first col */ int *status) /* IO - error status */ /* Return the full column name and column number of the next column whose TTYPEn keyword value matches the input template string. The template may contain the * and ? wildcards. Status = 237 is returned if the match is not unique. If so, one may call this routine again with input status=237 to get the next match. A status value of 219 is returned when there are no more matching columns. */ { char errmsg[FLEN_ERRMSG]; int tstatus, ii, founde, foundw, match, exact, unique; long ivalue; tcolumn *colptr; if (*status <= 0) { (fptr->Fptr)->startcol = 0; /* start search with first column */ tstatus = 0; } else if (*status == COL_NOT_UNIQUE) /* start search from previous spot */ { tstatus = COL_NOT_UNIQUE; *status = 0; } else return(*status); /* bad input status value */ colname[0] = 0; /* initialize null return */ *colnum = 0; /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header to get col struct */ return(*status); colptr = (fptr->Fptr)->tableptr; /* pointer to first column */ colptr += ((fptr->Fptr)->startcol); /* offset to starting column */ founde = FALSE; /* initialize 'found exact match' flag */ foundw = FALSE; /* initialize 'found wildcard match' flag */ unique = FALSE; for (ii = (fptr->Fptr)->startcol; ii < (fptr->Fptr)->tfield; ii++, colptr++) { ffcmps(templt, colptr->ttype, casesen, &match, &exact); if (match) { if (founde && exact) { /* warning: this is the second exact match we've found */ /*reset pointer to first match so next search starts there */ (fptr->Fptr)->startcol = *colnum; return(*status = COL_NOT_UNIQUE); } else if (founde) /* a wildcard match */ { /* already found exact match so ignore this non-exact match */ } else if (exact) { /* this is the first exact match we have found, so save it. */ strcpy(colname, colptr->ttype); *colnum = ii + 1; founde = TRUE; } else if (foundw) { /* we have already found a wild card match, so not unique */ /* continue searching for other matches */ unique = FALSE; } else { /* this is the first wild card match we've found. save it */ strcpy(colname, colptr->ttype); *colnum = ii + 1; (fptr->Fptr)->startcol = *colnum; foundw = TRUE; unique = TRUE; } } } /* OK, we've checked all the names now see if we got any matches */ if (founde) { if (tstatus == COL_NOT_UNIQUE) /* we did find 1 exact match but */ *status = COL_NOT_UNIQUE; /* there was a previous match too */ } else if (foundw) { /* found one or more wildcard matches; report error if not unique */ if (!unique || tstatus == COL_NOT_UNIQUE) *status = COL_NOT_UNIQUE; } else { /* didn't find a match; check if template is a positive integer */ ffc2ii(templt, &ivalue, &tstatus); if (tstatus == 0 && ivalue <= (fptr->Fptr)->tfield && ivalue > 0) { *colnum = ivalue; colptr = (fptr->Fptr)->tableptr; /* pointer to first column */ colptr += (ivalue - 1); /* offset to correct column */ strcpy(colname, colptr->ttype); } else { *status = COL_NOT_FOUND; if (tstatus != COL_NOT_UNIQUE) { sprintf(errmsg, "ffgcnn could not find column: %.45s", templt); ffpmsg(errmsg); } } } (fptr->Fptr)->startcol = *colnum; /* save pointer for next time */ return(*status); } /*--------------------------------------------------------------------------*/ void ffcmps(char *templt, /* I - input template (may have wildcards) */ char *colname, /* I - full column name up to 68 + 1 chars long */ int casesen, /* I - case sensitive string comparison? 1=yes */ int *match, /* O - do template and colname match? 1=yes */ int *exact) /* O - do strings exactly match, or wildcards */ /* compare the template to the string and test if they match. The strings are limited to 68 characters or less (the max. length of a FITS string keyword value. This routine reports whether the two strings match and whether the match is exact or involves wildcards. This algorithm is very similar to the way unix filename wildcards work except that this first treats a wild card as a literal character when looking for a match. If there is no literal match, then it interpretes it as a wild card. So the template 'AB*DE' is considered to be an exact rather than a wild card match to the string 'AB*DE'. The '#' wild card in the template string will match any consecutive string of decimal digits in the colname. */ { int ii, found, t1, s1, wildsearch = 0, tsave = 0, ssave = 0; char temp[FLEN_VALUE], col[FLEN_VALUE]; *match = FALSE; *exact = TRUE; strncpy(temp, templt, FLEN_VALUE); /* copy strings to work area */ strncpy(col, colname, FLEN_VALUE); temp[FLEN_VALUE - 1] = '\0'; /* make sure strings are terminated */ col[FLEN_VALUE - 1] = '\0'; /* truncate trailing non-significant blanks */ for (ii = strlen(temp) - 1; ii >= 0 && temp[ii] == ' '; ii--) temp[ii] = '\0'; for (ii = strlen(col) - 1; ii >= 0 && col[ii] == ' '; ii--) col[ii] = '\0'; if (!casesen) { /* convert both strings to uppercase before comparison */ ffupch(temp); ffupch(col); } if (!FSTRCMP(temp, col) ) { *match = TRUE; /* strings exactly match */ return; } *exact = FALSE; /* strings don't exactly match */ t1 = 0; /* start comparison with 1st char of each string */ s1 = 0; while(1) /* compare corresponding chars in each string */ { if (temp[t1] == '\0' && col[s1] == '\0') { /* completely scanned both strings so they match */ *match = TRUE; return; } else if (temp[t1] == '\0') { if (wildsearch) { /* the previous wildcard search may have been going down a blind alley. Backtrack, and resume the wildcard search with the next character in the string. */ t1 = tsave; s1 = ssave + 1; } else { /* reached end of template string so they don't match */ return; } } else if (col[s1] == '\0') { /* reached end of other string; they match if the next */ /* character in the template string is a '*' wild card */ if (temp[t1] == '*' && temp[t1 + 1] == '\0') { *match = TRUE; } return; } if (temp[t1] == col[s1] || (temp[t1] == '?') ) { s1++; /* corresponding chars in the 2 strings match */ t1++; /* increment both pointers and loop back again */ } else if (temp[t1] == '#' && isdigit((int) col[s1]) ) { s1++; /* corresponding chars in the 2 strings match */ t1++; /* increment both pointers */ /* find the end of the string of digits */ while (isdigit((int) col[s1]) ) s1++; } else if (temp[t1] == '*') { /* save current string locations, in case we need to restart */ wildsearch = 1; tsave = t1; ssave = s1; /* get next char from template and look for it in the col name */ t1++; if (temp[t1] == '\0' || temp[t1] == ' ') { /* reached end of template so strings match */ *match = TRUE; return; } found = FALSE; while (col[s1] && !found) { if (temp[t1] == col[s1]) { t1++; /* found matching characters; incre both pointers */ s1++; /* and loop back to compare next chars */ found = TRUE; } else s1++; /* increment the column name pointer and try again */ } if (!found) { return; /* hit end of column name and failed to find a match */ } } else { if (wildsearch) { /* the previous wildcard search may have been going down a blind alley. Backtrack, and resume the wildcard search with the next character in the string. */ t1 = tsave; s1 = ssave + 1; } else { return; /* strings don't match */ } } } } /*--------------------------------------------------------------------------*/ int ffgtcl( fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number */ int *typecode, /* O - datatype code (21 = short, etc) */ long *repeat, /* O - repeat count of field */ long *width, /* O - if ASCII, width of field or unit string */ int *status) /* IO - error status */ /* Get Type of table column. Returns the datatype code of the column, as well as the vector repeat count and (if it is an ASCII character column) the width of the field or a unit string within the field. This supports the TFORMn = 'rAw' syntax for specifying arrays of substrings, so if TFORMn = '60A12' then repeat = 60 and width = 12. */ { LONGLONG trepeat, twidth; ffgtclll(fptr, colnum, typecode, &trepeat, &twidth, status); if (*status > 0) return(*status); if (repeat) *repeat= (long) trepeat; if (width) *width = (long) twidth; return(*status); } /*--------------------------------------------------------------------------*/ int ffgtclll( fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number */ int *typecode, /* O - datatype code (21 = short, etc) */ LONGLONG *repeat, /* O - repeat count of field */ LONGLONG *width, /* O - if ASCII, width of field or unit string */ int *status) /* IO - error status */ /* Get Type of table column. Returns the datatype code of the column, as well as the vector repeat count and (if it is an ASCII character column) the width of the field or a unit string within the field. This supports the TFORMn = 'rAw' syntax for specifying arrays of substrings, so if TFORMn = '60A12' then repeat = 60 and width = 12. */ { tcolumn *colptr; int hdutype, decims; long tmpwidth; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if (colnum < 1 || colnum > (fptr->Fptr)->tfield) return(*status = BAD_COL_NUM); colptr = (fptr->Fptr)->tableptr; /* pointer to first column */ colptr += (colnum - 1); /* offset to correct column */ if (ffghdt(fptr, &hdutype, status) > 0) return(*status); if (hdutype == ASCII_TBL) { ffasfm(colptr->tform, typecode, &tmpwidth, &decims, status); *width = tmpwidth; if (repeat) *repeat = 1; } else { if (typecode) *typecode = colptr->tdatatype; if (width) *width = colptr->twidth; if (repeat) *repeat = colptr->trepeat; } return(*status); } /*--------------------------------------------------------------------------*/ int ffeqty( fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number */ int *typecode, /* O - datatype code (21 = short, etc) */ long *repeat, /* O - repeat count of field */ long *width, /* O - if ASCII, width of field or unit string */ int *status) /* IO - error status */ /* Get the 'equivalent' table column type. This routine is similar to the ffgtcl routine (which returns the physical datatype of the column, as stored in the FITS file) except that if the TSCALn and TZEROn keywords are defined for the column, then it returns the 'equivalent' datatype. Thus, if the column is defined as '1I' (short integer) this routine may return the type as 'TUSHORT' or as 'TFLOAT' depending on the TSCALn and TZEROn values. Returns the datatype code of the column, as well as the vector repeat count and (if it is an ASCII character column) the width of the field or a unit string within the field. This supports the TFORMn = 'rAw' syntax for specifying arrays of substrings, so if TFORMn = '60A12' then repeat = 60 and width = 12. */ { LONGLONG trepeat, twidth; ffeqtyll(fptr, colnum, typecode, &trepeat, &twidth, status); if (repeat) *repeat= (long) trepeat; if (width) *width = (long) twidth; return(*status); } /*--------------------------------------------------------------------------*/ int ffeqtyll( fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number */ int *typecode, /* O - datatype code (21 = short, etc) */ LONGLONG *repeat, /* O - repeat count of field */ LONGLONG *width, /* O - if ASCII, width of field or unit string */ int *status) /* IO - error status */ /* Get the 'equivalent' table column type. This routine is similar to the ffgtcl routine (which returns the physical datatype of the column, as stored in the FITS file) except that if the TSCALn and TZEROn keywords are defined for the column, then it returns the 'equivalent' datatype. Thus, if the column is defined as '1I' (short integer) this routine may return the type as 'TUSHORT' or as 'TFLOAT' depending on the TSCALn and TZEROn values. Returns the datatype code of the column, as well as the vector repeat count and (if it is an ASCII character column) the width of the field or a unit string within the field. This supports the TFORMn = 'rAw' syntax for specifying arrays of substrings, so if TFORMn = '60A12' then repeat = 60 and width = 12. */ { tcolumn *colptr; int hdutype, decims, tcode, effcode; double tscale, tzero, min_val, max_val; long lngscale, lngzero = 0, tmpwidth; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if (colnum < 1 || colnum > (fptr->Fptr)->tfield) return(*status = BAD_COL_NUM); colptr = (fptr->Fptr)->tableptr; /* pointer to first column */ colptr += (colnum - 1); /* offset to correct column */ if (ffghdt(fptr, &hdutype, status) > 0) return(*status); if (hdutype == ASCII_TBL) { ffasfm(colptr->tform, typecode, &tmpwidth, &decims, status); *width = tmpwidth; if (repeat) *repeat = 1; } else { if (typecode) *typecode = colptr->tdatatype; if (width) *width = colptr->twidth; if (repeat) *repeat = colptr->trepeat; } /* return if caller is not interested in the typecode value */ if (!typecode) return(*status); /* check if the tscale and tzero keywords are defined, which might change the effective datatype of the column */ tscale = colptr->tscale; tzero = colptr->tzero; if (tscale == 1.0 && tzero == 0.0) /* no scaling */ return(*status); tcode = abs(*typecode); switch (tcode) { case TBYTE: /* binary table 'rB' column */ min_val = 0.; max_val = 255.0; break; case TSHORT: min_val = -32768.0; max_val = 32767.0; break; case TLONG: min_val = -2147483648.0; max_val = 2147483647.0; break; default: /* don't have to deal with other data types */ return(*status); } if (tscale >= 0.) { min_val = tzero + tscale * min_val; max_val = tzero + tscale * max_val; } else { max_val = tzero + tscale * min_val; min_val = tzero + tscale * max_val; } if (tzero < 2147483648.) /* don't exceed range of 32-bit integer */ lngzero = (long) tzero; lngscale = (long) tscale; if ((tzero != 2147483648.) && /* special value that exceeds integer range */ (lngzero != tzero || lngscale != tscale)) { /* not integers? */ /* floating point scaled values; just decide on required precision */ if (tcode == TBYTE || tcode == TSHORT) effcode = TFLOAT; else effcode = TDOUBLE; /* In all the remaining cases, TSCALn and TZEROn are integers, and not equal to 1 and 0, respectively. */ } else if ((min_val == -128.) && (max_val == 127.)) { effcode = TSBYTE; } else if ((min_val >= -32768.0) && (max_val <= 32767.0)) { effcode = TSHORT; } else if ((min_val >= 0.0) && (max_val <= 65535.0)) { effcode = TUSHORT; } else if ((min_val >= -2147483648.0) && (max_val <= 2147483647.0)) { effcode = TLONG; } else if ((min_val >= 0.0) && (max_val < 4294967296.0)) { effcode = TULONG; } else { /* exceeds the range of a 32-bit integer */ effcode = TDOUBLE; } /* return the effective datatype code (negative if variable length col.) */ if (*typecode < 0) /* variable length array column */ *typecode = -effcode; else *typecode = effcode; return(*status); } /*--------------------------------------------------------------------------*/ int ffgncl( fitsfile *fptr, /* I - FITS file pointer */ int *ncols, /* O - number of columns in the table */ int *status) /* IO - error status */ /* Get the number of columns in the table (= TFIELDS keyword) */ { if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) return(*status = NOT_TABLE); *ncols = (fptr->Fptr)->tfield; return(*status); } /*--------------------------------------------------------------------------*/ int ffgnrw( fitsfile *fptr, /* I - FITS file pointer */ long *nrows, /* O - number of rows in the table */ int *status) /* IO - error status */ /* Get the number of rows in the table (= NAXIS2 keyword) */ { if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) return(*status = NOT_TABLE); /* the NAXIS2 keyword may not be up to date, so use the structure value */ *nrows = (long) (fptr->Fptr)->numrows; return(*status); } /*--------------------------------------------------------------------------*/ int ffgnrwll( fitsfile *fptr, /* I - FITS file pointer */ LONGLONG *nrows, /* O - number of rows in the table */ int *status) /* IO - error status */ /* Get the number of rows in the table (= NAXIS2 keyword) */ { if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) return(*status = NOT_TABLE); /* the NAXIS2 keyword may not be up to date, so use the structure value */ *nrows = (fptr->Fptr)->numrows; return(*status); } /*--------------------------------------------------------------------------*/ int ffgacl( fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number */ char *ttype, /* O - TTYPEn keyword value */ long *tbcol, /* O - TBCOLn keyword value */ char *tunit, /* O - TUNITn keyword value */ char *tform, /* O - TFORMn keyword value */ double *tscal, /* O - TSCALn keyword value */ double *tzero, /* O - TZEROn keyword value */ char *tnull, /* O - TNULLn keyword value */ char *tdisp, /* O - TDISPn keyword value */ int *status) /* IO - error status */ /* get ASCII column keyword values */ { char name[FLEN_KEYWORD], comm[FLEN_COMMENT]; tcolumn *colptr; int tstatus; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if (colnum < 1 || colnum > (fptr->Fptr)->tfield) return(*status = BAD_COL_NUM); /* get what we can from the column structure */ colptr = (fptr->Fptr)->tableptr; /* pointer to first column */ colptr += (colnum -1); /* offset to correct column */ if (ttype) strcpy(ttype, colptr->ttype); if (tbcol) *tbcol = (long) ((colptr->tbcol) + 1); /* first col is 1, not 0 */ if (tform) strcpy(tform, colptr->tform); if (tscal) *tscal = colptr->tscale; if (tzero) *tzero = colptr->tzero; if (tnull) strcpy(tnull, colptr->strnull); /* read keywords to get additional parameters */ if (tunit) { ffkeyn("TUNIT", colnum, name, status); tstatus = 0; *tunit = '\0'; ffgkys(fptr, name, tunit, comm, &tstatus); } if (tdisp) { ffkeyn("TDISP", colnum, name, status); tstatus = 0; *tdisp = '\0'; ffgkys(fptr, name, tdisp, comm, &tstatus); } return(*status); } /*--------------------------------------------------------------------------*/ int ffgbcl( fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number */ char *ttype, /* O - TTYPEn keyword value */ char *tunit, /* O - TUNITn keyword value */ char *dtype, /* O - datatype char: I, J, E, D, etc. */ long *repeat, /* O - vector column repeat count */ double *tscal, /* O - TSCALn keyword value */ double *tzero, /* O - TZEROn keyword value */ long *tnull, /* O - TNULLn keyword value integer cols only */ char *tdisp, /* O - TDISPn keyword value */ int *status) /* IO - error status */ /* get BINTABLE column keyword values */ { LONGLONG trepeat, ttnull; if (*status > 0) return(*status); ffgbclll(fptr, colnum, ttype, tunit, dtype, &trepeat, tscal, tzero, &ttnull, tdisp, status); if (repeat) *repeat = (long) trepeat; if (tnull) *tnull = (long) ttnull; return(*status); } /*--------------------------------------------------------------------------*/ int ffgbclll( fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number */ char *ttype, /* O - TTYPEn keyword value */ char *tunit, /* O - TUNITn keyword value */ char *dtype, /* O - datatype char: I, J, E, D, etc. */ LONGLONG *repeat, /* O - vector column repeat count */ double *tscal, /* O - TSCALn keyword value */ double *tzero, /* O - TZEROn keyword value */ LONGLONG *tnull, /* O - TNULLn keyword value integer cols only */ char *tdisp, /* O - TDISPn keyword value */ int *status) /* IO - error status */ /* get BINTABLE column keyword values */ { char name[FLEN_KEYWORD], comm[FLEN_COMMENT]; tcolumn *colptr; int tstatus; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if (colnum < 1 || colnum > (fptr->Fptr)->tfield) return(*status = BAD_COL_NUM); /* get what we can from the column structure */ colptr = (fptr->Fptr)->tableptr; /* pointer to first column */ colptr += (colnum -1); /* offset to correct column */ if (ttype) strcpy(ttype, colptr->ttype); if (dtype) { if (colptr->tdatatype < 0) /* add the "P" prefix for */ strcpy(dtype, "P"); /* variable length columns */ else dtype[0] = 0; if (abs(colptr->tdatatype) == TBIT) strcat(dtype, "X"); else if (abs(colptr->tdatatype) == TBYTE) strcat(dtype, "B"); else if (abs(colptr->tdatatype) == TLOGICAL) strcat(dtype, "L"); else if (abs(colptr->tdatatype) == TSTRING) strcat(dtype, "A"); else if (abs(colptr->tdatatype) == TSHORT) strcat(dtype, "I"); else if (abs(colptr->tdatatype) == TLONG) strcat(dtype, "J"); else if (abs(colptr->tdatatype) == TLONGLONG) strcat(dtype, "K"); else if (abs(colptr->tdatatype) == TFLOAT) strcat(dtype, "E"); else if (abs(colptr->tdatatype) == TDOUBLE) strcat(dtype, "D"); else if (abs(colptr->tdatatype) == TCOMPLEX) strcat(dtype, "C"); else if (abs(colptr->tdatatype) == TDBLCOMPLEX) strcat(dtype, "M"); } if (repeat) *repeat = colptr->trepeat; if (tscal) *tscal = colptr->tscale; if (tzero) *tzero = colptr->tzero; if (tnull) *tnull = colptr->tnull; /* read keywords to get additional parameters */ if (tunit) { ffkeyn("TUNIT", colnum, name, status); tstatus = 0; *tunit = '\0'; ffgkys(fptr, name, tunit, comm, &tstatus); } if (tdisp) { ffkeyn("TDISP", colnum, name, status); tstatus = 0; *tdisp = '\0'; ffgkys(fptr, name, tdisp, comm, &tstatus); } return(*status); } /*--------------------------------------------------------------------------*/ int ffghdn(fitsfile *fptr, /* I - FITS file pointer */ int *chdunum) /* O - number of the CHDU; 1 = primary array */ /* Return the number of the Current HDU in the FITS file. The primary array is HDU number 1. Note that this is one of the few cfitsio routines that does not return the error status value as the value of the function. */ { *chdunum = (fptr->HDUposition) + 1; return(*chdunum); } /*--------------------------------------------------------------------------*/ int ffghadll(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG *headstart, /* O - byte offset to beginning of CHDU */ LONGLONG *datastart, /* O - byte offset to beginning of next HDU */ LONGLONG *dataend, /* O - byte offset to beginning of next HDU */ int *status) /* IO - error status */ /* Return the address (= byte offset) in the FITS file to the beginning of the current HDU, the beginning of the data unit, and the end of the data unit. */ { if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { if (ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status) > 0) return(*status); } else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) { if (ffrdef(fptr, status) > 0) /* rescan header */ return(*status); } if (headstart) *headstart = (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu]; if (datastart) *datastart = (fptr->Fptr)->datastart; if (dataend) *dataend = (fptr->Fptr)->headstart[((fptr->Fptr)->curhdu) + 1]; return(*status); } /*--------------------------------------------------------------------------*/ int ffghof(fitsfile *fptr, /* I - FITS file pointer */ OFF_T *headstart, /* O - byte offset to beginning of CHDU */ OFF_T *datastart, /* O - byte offset to beginning of next HDU */ OFF_T *dataend, /* O - byte offset to beginning of next HDU */ int *status) /* IO - error status */ /* Return the address (= byte offset) in the FITS file to the beginning of the current HDU, the beginning of the data unit, and the end of the data unit. */ { if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { if (ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status) > 0) return(*status); } else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) { if (ffrdef(fptr, status) > 0) /* rescan header */ return(*status); } if (headstart) *headstart = (OFF_T) (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu]; if (datastart) *datastart = (OFF_T) (fptr->Fptr)->datastart; if (dataend) *dataend = (OFF_T) (fptr->Fptr)->headstart[((fptr->Fptr)->curhdu) + 1]; return(*status); } /*--------------------------------------------------------------------------*/ int ffghad(fitsfile *fptr, /* I - FITS file pointer */ long *headstart, /* O - byte offset to beginning of CHDU */ long *datastart, /* O - byte offset to beginning of next HDU */ long *dataend, /* O - byte offset to beginning of next HDU */ int *status) /* IO - error status */ /* Return the address (= byte offset) in the FITS file to the beginning of the current HDU, the beginning of the data unit, and the end of the data unit. */ { LONGLONG shead, sdata, edata; if (*status > 0) return(*status); ffghadll(fptr, &shead, &sdata, &edata, status); if (headstart) { if (shead > LONG_MAX) *status = NUM_OVERFLOW; else *headstart = (long) shead; } if (datastart) { if (sdata > LONG_MAX) *status = NUM_OVERFLOW; else *datastart = (long) sdata; } if (dataend) { if (edata > LONG_MAX) *status = NUM_OVERFLOW; else *dataend = (long) edata; } return(*status); } /*--------------------------------------------------------------------------*/ int ffrhdu(fitsfile *fptr, /* I - FITS file pointer */ int *hdutype, /* O - type of HDU */ int *status) /* IO - error status */ /* read the required keywords of the CHDU and initialize the corresponding structure elements that describe the format of the HDU */ { int ii, tstatus; char card[FLEN_CARD]; char name[FLEN_KEYWORD], value[FLEN_VALUE], comm[FLEN_COMMENT]; char xname[FLEN_VALUE], *xtension, urltype[20]; if (*status > 0) return(*status); if (ffgrec(fptr, 1, card, status) > 0 ) /* get the 80-byte card */ { ffpmsg("Cannot read first keyword in header (ffrhdu)."); return(*status); } strncpy(name,card,8); /* first 8 characters = the keyword name */ name[8] = '\0'; for (ii=7; ii >= 0; ii--) /* replace trailing blanks with nulls */ { if (name[ii] == ' ') name[ii] = '\0'; else break; } if (ffpsvc(card, value, comm, status) > 0) /* parse value and comment */ { ffpmsg("Cannot read value of first keyword in header (ffrhdu):"); ffpmsg(card); return(*status); } if (!strcmp(name, "SIMPLE")) /* this is the primary array */ { ffpinit(fptr, status); /* initialize the primary array */ if (hdutype != NULL) *hdutype = 0; } else if (!strcmp(name, "XTENSION")) /* this is an XTENSION keyword */ { if (ffc2s(value, xname, status) > 0) /* get the value string */ { ffpmsg("Bad value string for XTENSION keyword:"); ffpmsg(value); return(*status); } xtension = xname; while (*xtension == ' ') /* ignore any leading spaces in name */ xtension++; if (!strcmp(xtension, "TABLE")) { ffainit(fptr, status); /* initialize the ASCII table */ if (hdutype != NULL) *hdutype = 1; } else if (!strcmp(xtension, "BINTABLE") || !strcmp(xtension, "A3DTABLE") || !strcmp(xtension, "3DTABLE") ) { ffbinit(fptr, status); /* initialize the binary table */ if (hdutype != NULL) *hdutype = 2; } else { tstatus = 0; ffpinit(fptr, &tstatus); /* probably an IMAGE extension */ if (tstatus == UNKNOWN_EXT && hdutype != NULL) *hdutype = -1; /* don't recognize this extension type */ else { *status = tstatus; if (hdutype != NULL) *hdutype = 0; } } } else /* not the start of a new extension */ { if (card[0] == 0 || card[0] == 10) /* some editors append this character to EOF */ { *status = END_OF_FILE; } else { *status = UNKNOWN_REC; /* found unknown type of record */ ffpmsg ("Extension doesn't start with SIMPLE or XTENSION keyword. (ffrhdu)"); ffpmsg(card); } } /* compare the starting position of the next HDU (if any) with the size */ /* of the whole file to see if this is the last HDU in the file */ if ((fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1] < (fptr->Fptr)->logfilesize ) { (fptr->Fptr)->lasthdu = 0; /* no, not the last HDU */ } else { (fptr->Fptr)->lasthdu = 1; /* yes, this is the last HDU */ /* special code for mem:// type files (FITS file in memory) */ /* Allocate enough memory to hold the entire HDU. */ /* Without this code, CFITSIO would repeatedly realloc memory */ /* to incrementally increase the size of the file by 2880 bytes */ /* at a time, until it reached the final size */ ffurlt(fptr, urltype, status); if (!strcmp(urltype,"mem://") || !strcmp(urltype,"memkeep://")) { fftrun(fptr, (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1], status); } } return(*status); } /*--------------------------------------------------------------------------*/ int ffpinit(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* initialize the parameters defining the structure of the primary array or an Image extension */ { int groups, tstatus, simple, bitpix, naxis, extend, nspace; int ttype = 0, bytlen = 0, ii, ntilebins; long pcount, gcount; LONGLONG naxes[999], npix, blank; double bscale, bzero; char comm[FLEN_COMMENT]; tcolumn *colptr; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); (fptr->Fptr)->hdutype = IMAGE_HDU; /* primary array or IMAGE extension */ (fptr->Fptr)->headend = (fptr->Fptr)->logfilesize; /* set max size */ groups = 0; tstatus = *status; /* get all the descriptive info about this HDU */ ffgphd(fptr, 999, &simple, &bitpix, &naxis, naxes, &pcount, &gcount, &extend, &bscale, &bzero, &blank, &nspace, status); if (*status == NOT_IMAGE) *status = tstatus; /* ignore 'unknown extension type' error */ else if (*status > 0) return(*status); /* the logical end of the header is 80 bytes before the current position, minus any trailing blank keywords just before the END keyword. */ (fptr->Fptr)->headend = (fptr->Fptr)->nextkey - (80 * (nspace + 1)); /* the data unit begins at the beginning of the next logical block */ (fptr->Fptr)->datastart = (((fptr->Fptr)->nextkey - 80) / 2880 + 1) * 2880; if (naxis > 0 && naxes[0] == 0) /* test for 'random groups' */ { tstatus = 0; ffmaky(fptr, 2, status); /* reset to beginning of header */ if (ffgkyl(fptr, "GROUPS", &groups, comm, &tstatus)) groups = 0; /* GROUPS keyword not found */ } if (bitpix == BYTE_IMG) /* test bitpix and set the datatype code */ { ttype=TBYTE; bytlen=1; } else if (bitpix == SHORT_IMG) { ttype=TSHORT; bytlen=2; } else if (bitpix == LONG_IMG) { ttype=TLONG; bytlen=4; } else if (bitpix == LONGLONG_IMG) { ttype=TLONGLONG; bytlen=8; } else if (bitpix == FLOAT_IMG) { ttype=TFLOAT; bytlen=4; } else if (bitpix == DOUBLE_IMG) { ttype=TDOUBLE; bytlen=8; } /* calculate the size of the primary array */ (fptr->Fptr)->imgdim = naxis; if (naxis == 0) { npix = 0; } else { if (groups) { npix = 1; /* NAXIS1 = 0 is a special flag for 'random groups' */ } else { npix = naxes[0]; } (fptr->Fptr)->imgnaxis[0] = naxes[0]; for (ii=1; ii < naxis; ii++) { npix = npix*naxes[ii]; /* calc number of pixels in the array */ (fptr->Fptr)->imgnaxis[ii] = naxes[ii]; } } /* now we know everything about the array; just fill in the parameters: the next HDU begins in the next logical block after the data */ (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1] = (fptr->Fptr)->datastart + ( ((LONGLONG) pcount + npix) * bytlen * gcount + 2879) / 2880 * 2880; /* initialize the fictitious heap starting address (immediately following the array data) and a zero length heap. This is used to find the end of the data when checking the fill values in the last block. */ (fptr->Fptr)->heapstart = (npix + pcount) * bytlen * gcount; (fptr->Fptr)->heapsize = 0; (fptr->Fptr)->compressimg = 0; /* this is not a compressed image */ if (naxis == 0) { (fptr->Fptr)->rowlength = 0; /* rows have zero length */ (fptr->Fptr)->tfield = 0; /* table has no fields */ /* free the tile-compressed image cache, if it exists */ if ((fptr->Fptr)->tilerow) { ntilebins = (((fptr->Fptr)->znaxis[0] - 1) / ((fptr->Fptr)->tilesize[0])) + 1; for (ii = 0; ii < ntilebins; ii++) { if ((fptr->Fptr)->tiledata[ii]) { free((fptr->Fptr)->tiledata[ii]); } if ((fptr->Fptr)->tilenullarray[ii]) { free((fptr->Fptr)->tilenullarray[ii]); } } free((fptr->Fptr)->tileanynull); free((fptr->Fptr)->tiletype); free((fptr->Fptr)->tiledatasize); free((fptr->Fptr)->tilenullarray); free((fptr->Fptr)->tiledata); free((fptr->Fptr)->tilerow); (fptr->Fptr)->tileanynull = 0; (fptr->Fptr)->tiletype = 0; (fptr->Fptr)->tiledatasize = 0; (fptr->Fptr)->tilenullarray = 0; (fptr->Fptr)->tiledata = 0; (fptr->Fptr)->tilerow = 0; } if ((fptr->Fptr)->tableptr) free((fptr->Fptr)->tableptr); /* free memory for the old CHDU */ (fptr->Fptr)->tableptr = 0; /* set a null table structure pointer */ (fptr->Fptr)->numrows = 0; (fptr->Fptr)->origrows = 0; } else { /* The primary array is actually interpreted as a binary table. There are two columns: the first column contains the group parameters if any. The second column contains the primary array of data as a single vector column element. In the case of 'random grouped' format, each group is stored in a separate row of the table. */ /* the number of rows is equal to the number of groups */ (fptr->Fptr)->numrows = gcount; (fptr->Fptr)->origrows = gcount; (fptr->Fptr)->rowlength = (npix + pcount) * bytlen; /* total size */ (fptr->Fptr)->tfield = 2; /* 2 fields: group params and the image */ /* free the tile-compressed image cache, if it exists */ if ((fptr->Fptr)->tilerow) { ntilebins = (((fptr->Fptr)->znaxis[0] - 1) / ((fptr->Fptr)->tilesize[0])) + 1; for (ii = 0; ii < ntilebins; ii++) { if ((fptr->Fptr)->tiledata[ii]) { free((fptr->Fptr)->tiledata[ii]); } if ((fptr->Fptr)->tilenullarray[ii]) { free((fptr->Fptr)->tilenullarray[ii]); } } free((fptr->Fptr)->tileanynull); free((fptr->Fptr)->tiletype); free((fptr->Fptr)->tiledatasize); free((fptr->Fptr)->tilenullarray); free((fptr->Fptr)->tiledata); free((fptr->Fptr)->tilerow); (fptr->Fptr)->tileanynull = 0; (fptr->Fptr)->tiletype = 0; (fptr->Fptr)->tiledatasize = 0; (fptr->Fptr)->tilenullarray = 0; (fptr->Fptr)->tiledata = 0; (fptr->Fptr)->tilerow = 0; } if ((fptr->Fptr)->tableptr) free((fptr->Fptr)->tableptr); /* free memory for the old CHDU */ colptr = (tcolumn *) calloc(2, sizeof(tcolumn) ) ; if (!colptr) { ffpmsg ("malloc failed to get memory for FITS array descriptors (ffpinit)"); (fptr->Fptr)->tableptr = 0; /* set a null table structure pointer */ return(*status = ARRAY_TOO_BIG); } /* copy the table structure address to the fitsfile structure */ (fptr->Fptr)->tableptr = colptr; /* the first column represents the group parameters, if any */ colptr->tbcol = 0; colptr->tdatatype = ttype; colptr->twidth = bytlen; colptr->trepeat = (LONGLONG) pcount; colptr->tscale = 1.; colptr->tzero = 0.; colptr->tnull = blank; colptr++; /* increment pointer to the second column */ /* the second column represents the image array */ colptr->tbcol = pcount * bytlen; /* col starts after the group parms */ colptr->tdatatype = ttype; colptr->twidth = bytlen; colptr->trepeat = npix; colptr->tscale = bscale; colptr->tzero = bzero; colptr->tnull = blank; } /* reset next keyword pointer to the start of the header */ (fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu ]; return(*status); } /*--------------------------------------------------------------------------*/ int ffainit(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ { /* initialize the parameters defining the structure of an ASCII table */ int ii, nspace, ntilebins; long tfield; LONGLONG pcount, rowlen, nrows, tbcoln; tcolumn *colptr = 0; char name[FLEN_KEYWORD], value[FLEN_VALUE], comm[FLEN_COMMENT]; char message[FLEN_ERRMSG], errmsg[81]; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); (fptr->Fptr)->hdutype = ASCII_TBL; /* set that this is an ASCII table */ (fptr->Fptr)->headend = (fptr->Fptr)->logfilesize; /* set max size */ /* get table parameters and test that the header is a valid: */ if (ffgttb(fptr, &rowlen, &nrows, &pcount, &tfield, status) > 0) return(*status); if (pcount != 0) { ffpmsg("PCOUNT keyword not equal to 0 in ASCII table (ffainit)."); sprintf(errmsg, " PCOUNT = %ld", (long) pcount); ffpmsg(errmsg); return(*status = BAD_PCOUNT); } (fptr->Fptr)->rowlength = rowlen; /* store length of a row */ (fptr->Fptr)->tfield = tfield; /* store number of table fields in row */ /* free the tile-compressed image cache, if it exists */ if ((fptr->Fptr)->tilerow) { ntilebins = (((fptr->Fptr)->znaxis[0] - 1) / ((fptr->Fptr)->tilesize[0])) + 1; for (ii = 0; ii < ntilebins; ii++) { if ((fptr->Fptr)->tiledata[ii]) { free((fptr->Fptr)->tiledata[ii]); } if ((fptr->Fptr)->tilenullarray[ii]) { free((fptr->Fptr)->tilenullarray[ii]); } } free((fptr->Fptr)->tileanynull); free((fptr->Fptr)->tiletype); free((fptr->Fptr)->tiledatasize); free((fptr->Fptr)->tilenullarray); free((fptr->Fptr)->tiledata); free((fptr->Fptr)->tilerow); (fptr->Fptr)->tileanynull = 0; (fptr->Fptr)->tiletype = 0; (fptr->Fptr)->tiledatasize = 0; (fptr->Fptr)->tilenullarray = 0; (fptr->Fptr)->tiledata = 0; (fptr->Fptr)->tilerow = 0; } if ((fptr->Fptr)->tableptr) free((fptr->Fptr)->tableptr); /* free memory for the old CHDU */ /* mem for column structures ; space is initialized = 0 */ if (tfield > 0) { colptr = (tcolumn *) calloc(tfield, sizeof(tcolumn) ); if (!colptr) { ffpmsg ("malloc failed to get memory for FITS table descriptors (ffainit)"); (fptr->Fptr)->tableptr = 0; /* set a null table structure pointer */ return(*status = ARRAY_TOO_BIG); } } /* copy the table structure address to the fitsfile structure */ (fptr->Fptr)->tableptr = colptr; /* initialize the table field parameters */ for (ii = 0; ii < tfield; ii++, colptr++) { colptr->ttype[0] = '\0'; /* null column name */ colptr->tscale = 1.; colptr->tzero = 0.; colptr->strnull[0] = ASCII_NULL_UNDEFINED; /* null value undefined */ colptr->tbcol = -1; /* initialize to illegal value */ colptr->tdatatype = -9999; /* initialize to illegal value */ } /* Initialize the fictitious heap starting address (immediately following the table data) and a zero length heap. This is used to find the end of the table data when checking the fill values in the last block. There is no special data following an ASCII table. */ (fptr->Fptr)->numrows = nrows; (fptr->Fptr)->origrows = nrows; (fptr->Fptr)->heapstart = rowlen * nrows; (fptr->Fptr)->heapsize = 0; (fptr->Fptr)->compressimg = 0; /* this is not a compressed image */ /* now search for the table column keywords and the END keyword */ for (nspace = 0, ii = 8; 1; ii++) /* infinite loop */ { ffgkyn(fptr, ii, name, value, comm, status); /* try to ignore minor syntax errors */ if (*status == NO_QUOTE) { strcat(value, "'"); *status = 0; } else if (*status == BAD_KEYCHAR) { *status = 0; } if (*status == END_OF_FILE) { ffpmsg("END keyword not found in ASCII table header (ffainit)."); return(*status = NO_END); } else if (*status > 0) return(*status); else if (name[0] == 'T') /* keyword starts with 'T' ? */ ffgtbp(fptr, name, value, status); /* test if column keyword */ else if (!FSTRCMP(name, "END")) /* is this the END keyword? */ break; if (!name[0] && !value[0] && !comm[0]) /* a blank keyword? */ nspace++; else nspace = 0; } /* test that all required keywords were found and have legal values */ colptr = (fptr->Fptr)->tableptr; for (ii = 0; ii < tfield; ii++, colptr++) { tbcoln = colptr->tbcol; /* the starting column number (zero based) */ if (colptr->tdatatype == -9999) { ffkeyn("TFORM", ii+1, name, status); /* construct keyword name */ sprintf(message,"Required %s keyword not found (ffainit).", name); ffpmsg(message); return(*status = NO_TFORM); } else if (tbcoln == -1) { ffkeyn("TBCOL", ii+1, name, status); /* construct keyword name */ sprintf(message,"Required %s keyword not found (ffainit).", name); ffpmsg(message); return(*status = NO_TBCOL); } else if ((fptr->Fptr)->rowlength != 0 && (tbcoln < 0 || tbcoln >= (fptr->Fptr)->rowlength ) ) { ffkeyn("TBCOL", ii+1, name, status); /* construct keyword name */ sprintf(message,"Value of %s keyword out of range: %ld (ffainit).", name, (long) tbcoln); ffpmsg(message); return(*status = BAD_TBCOL); } else if ((fptr->Fptr)->rowlength != 0 && tbcoln + colptr->twidth > (fptr->Fptr)->rowlength ) { sprintf(message,"Column %d is too wide to fit in table (ffainit)", ii+1); ffpmsg(message); sprintf(message, " TFORM = %s and NAXIS1 = %ld", colptr->tform, (long) (fptr->Fptr)->rowlength); ffpmsg(message); return(*status = COL_TOO_WIDE); } } /* now we know everything about the table; just fill in the parameters: the 'END' record is 80 bytes before the current position, minus any trailing blank keywords just before the END keyword. */ (fptr->Fptr)->headend = (fptr->Fptr)->nextkey - (80 * (nspace + 1)); /* the data unit begins at the beginning of the next logical block */ (fptr->Fptr)->datastart = (((fptr->Fptr)->nextkey - 80) / 2880 + 1) * 2880; /* the next HDU begins in the next logical block after the data */ (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1] = (fptr->Fptr)->datastart + ( ((LONGLONG)rowlen * nrows + 2879) / 2880 * 2880 ); /* reset next keyword pointer to the start of the header */ (fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu ]; return(*status); } /*--------------------------------------------------------------------------*/ int ffbinit(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ { /* initialize the parameters defining the structure of a binary table */ int ii, nspace, ntilebins; long tfield; LONGLONG pcount, rowlen, nrows, totalwidth; tcolumn *colptr = 0; char name[FLEN_KEYWORD], value[FLEN_VALUE], comm[FLEN_COMMENT]; char message[FLEN_ERRMSG]; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); (fptr->Fptr)->hdutype = BINARY_TBL; /* set that this is a binary table */ (fptr->Fptr)->headend = (fptr->Fptr)->logfilesize; /* set max size */ /* get table parameters and test that the header is valid: */ if (ffgttb(fptr, &rowlen, &nrows, &pcount, &tfield, status) > 0) return(*status); (fptr->Fptr)->rowlength = rowlen; /* store length of a row */ (fptr->Fptr)->tfield = tfield; /* store number of table fields in row */ /* free the tile-compressed image cache, if it exists */ if ((fptr->Fptr)->tilerow) { ntilebins = (((fptr->Fptr)->znaxis[0] - 1) / ((fptr->Fptr)->tilesize[0])) + 1; for (ii = 0; ii < ntilebins; ii++) { if ((fptr->Fptr)->tiledata[ii]) { free((fptr->Fptr)->tiledata[ii]); } if ((fptr->Fptr)->tilenullarray[ii]) { free((fptr->Fptr)->tilenullarray[ii]); } } free((fptr->Fptr)->tileanynull); free((fptr->Fptr)->tiletype); free((fptr->Fptr)->tiledatasize); free((fptr->Fptr)->tilenullarray); free((fptr->Fptr)->tiledata); free((fptr->Fptr)->tilerow); (fptr->Fptr)->tileanynull = 0; (fptr->Fptr)->tiletype = 0; (fptr->Fptr)->tiledatasize = 0; (fptr->Fptr)->tilenullarray = 0; (fptr->Fptr)->tiledata = 0; (fptr->Fptr)->tilerow = 0; } if ((fptr->Fptr)->tableptr) free((fptr->Fptr)->tableptr); /* free memory for the old CHDU */ /* mem for column structures ; space is initialized = 0 */ if (tfield > 0) { colptr = (tcolumn *) calloc(tfield, sizeof(tcolumn) ); if (!colptr) { ffpmsg ("malloc failed to get memory for FITS table descriptors (ffbinit)"); (fptr->Fptr)->tableptr = 0; /* set a null table structure pointer */ return(*status = ARRAY_TOO_BIG); } } /* copy the table structure address to the fitsfile structure */ (fptr->Fptr)->tableptr = colptr; /* initialize the table field parameters */ for (ii = 0; ii < tfield; ii++, colptr++) { colptr->ttype[0] = '\0'; /* null column name */ colptr->tscale = 1.; colptr->tzero = 0.; colptr->tnull = NULL_UNDEFINED; /* (integer) null value undefined */ colptr->tdatatype = -9999; /* initialize to illegal value */ colptr->trepeat = 1; colptr->strnull[0] = '\0'; /* for ASCII string columns (TFORM = rA) */ } /* Initialize the heap starting address (immediately following the table data) and the size of the heap. This is used to find the end of the table data when checking the fill values in the last block. */ (fptr->Fptr)->numrows = nrows; (fptr->Fptr)->origrows = nrows; (fptr->Fptr)->heapstart = rowlen * nrows; (fptr->Fptr)->heapsize = pcount; (fptr->Fptr)->compressimg = 0; /* initialize as not a compressed image */ /* now search for the table column keywords and the END keyword */ for (nspace = 0, ii = 8; 1; ii++) /* infinite loop */ { ffgkyn(fptr, ii, name, value, comm, status); /* try to ignore minor syntax errors */ if (*status == NO_QUOTE) { strcat(value, "'"); *status = 0; } else if (*status == BAD_KEYCHAR) { *status = 0; } if (*status == END_OF_FILE) { ffpmsg("END keyword not found in binary table header (ffbinit)."); return(*status = NO_END); } else if (*status > 0) return(*status); else if (name[0] == 'T') /* keyword starts with 'T' ? */ ffgtbp(fptr, name, value, status); /* test if column keyword */ else if (!FSTRCMP(name, "ZIMAGE")) { if (value[0] == 'T') (fptr->Fptr)->compressimg = 1; /* this is a compressed image */ } else if (!FSTRCMP(name, "END")) /* is this the END keyword? */ break; if (!name[0] && !value[0] && !comm[0]) /* a blank keyword? */ nspace++; else nspace = 0; /* reset number of consecutive spaces before END */ } /* test that all the required keywords were found and have legal values */ colptr = (fptr->Fptr)->tableptr; /* set pointer to first column */ for (ii = 0; ii < tfield; ii++, colptr++) { if (colptr->tdatatype == -9999) { ffkeyn("TFORM", ii+1, name, status); /* construct keyword name */ sprintf(message,"Required %s keyword not found (ffbinit).", name); ffpmsg(message); return(*status = NO_TFORM); } } /* now we know everything about the table; just fill in the parameters: the 'END' record is 80 bytes before the current position, minus any trailing blank keywords just before the END keyword. */ (fptr->Fptr)->headend = (fptr->Fptr)->nextkey - (80 * (nspace + 1)); /* the data unit begins at the beginning of the next logical block */ (fptr->Fptr)->datastart = (((fptr->Fptr)->nextkey - 80) / 2880 + 1) * 2880; /* the next HDU begins in the next logical block after the data */ (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1] = (fptr->Fptr)->datastart + ( ((fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize + 2879) / 2880 * 2880 ); /* determine the byte offset to the beginning of each column */ ffgtbc(fptr, &totalwidth, status); if (totalwidth != rowlen) { sprintf(message, "NAXIS1 = %ld is not equal to the sum of column widths: %ld", (long) rowlen, (long) totalwidth); ffpmsg(message); *status = BAD_ROW_WIDTH; } /* reset next keyword pointer to the start of the header */ (fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu ]; if ( (fptr->Fptr)->compressimg == 1) /* Is this a compressed image */ imcomp_get_compressed_image_par(fptr, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffgabc(int tfields, /* I - number of columns in the table */ char **tform, /* I - value of TFORMn keyword for each column */ int space, /* I - number of spaces to leave between cols */ long *rowlen, /* O - total width of a table row */ long *tbcol, /* O - starting byte in row for each column */ int *status) /* IO - error status */ /* calculate the starting byte offset of each column of an ASCII table and the total length of a row, in bytes. The input space value determines how many blank spaces to leave between each column (1 is recommended). */ { int ii, datacode, decims; long width; if (*status > 0) return(*status); *rowlen=0; if (tfields <= 0) return(*status); tbcol[0] = 1; for (ii = 0; ii < tfields; ii++) { tbcol[ii] = *rowlen + 1; /* starting byte in row of column */ ffasfm(tform[ii], &datacode, &width, &decims, status); *rowlen += (width + space); /* total length of row */ } *rowlen -= space; /* don't add space after the last field */ return (*status); } /*--------------------------------------------------------------------------*/ int ffgtbc(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG *totalwidth, /* O - total width of a table row */ int *status) /* IO - error status */ { /* calculate the starting byte offset of each column of a binary table. Use the values of the datatype code and repeat counts in the column structure. Return the total length of a row, in bytes. */ int tfields, ii; LONGLONG nbytes; tcolumn *colptr; char message[FLEN_ERRMSG], *cptr; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); tfields = (fptr->Fptr)->tfield; colptr = (fptr->Fptr)->tableptr; /* point to first column structure */ *totalwidth = 0; for (ii = 0; ii < tfields; ii++, colptr++) { colptr->tbcol = *totalwidth; /* byte offset in row to this column */ if (colptr->tdatatype == TSTRING) { nbytes = colptr->trepeat; /* one byte per char */ } else if (colptr->tdatatype == TBIT) { nbytes = ( colptr->trepeat + 7) / 8; } else if (colptr->tdatatype > 0) { nbytes = colptr->trepeat * (colptr->tdatatype / 10); } else { cptr = colptr->tform; while (isdigit(*cptr)) cptr++; if (*cptr == 'P') /* this is a 'P' variable length descriptor (neg. tdatatype) */ nbytes = colptr->trepeat * 8; else if (*cptr == 'Q') /* this is a 'Q' variable length descriptor (neg. tdatatype) */ nbytes = colptr->trepeat * 16; else { sprintf(message, "unknown binary table column type: %s", colptr->tform); ffpmsg(message); *status = BAD_TFORM; return(*status); } } *totalwidth = *totalwidth + nbytes; } return(*status); } /*--------------------------------------------------------------------------*/ int ffgtbp(fitsfile *fptr, /* I - FITS file pointer */ char *name, /* I - name of the keyword */ char *value, /* I - value string of the keyword */ int *status) /* IO - error status */ { /* Get TaBle Parameter. The input keyword name begins with the letter T. Test if the keyword is one of the table column definition keywords of an ASCII or binary table. If so, decode it and update the value in the structure. */ int tstatus, datacode, decimals; long width, repeat, nfield, ivalue; LONGLONG jjvalue; double dvalue; char tvalue[FLEN_VALUE], *loc; char message[FLEN_ERRMSG]; tcolumn *colptr; if (*status > 0) return(*status); tstatus = 0; /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); if(!FSTRNCMP(name + 1, "TYPE", 4) ) { /* get the index number */ if( ffc2ii(name + 5, &nfield, &tstatus) > 0) /* read index no. */ return(*status); /* must not be an indexed keyword */ if (nfield < 1 || nfield > (fptr->Fptr)->tfield ) /* out of range */ return(*status); colptr = (fptr->Fptr)->tableptr; /* get pointer to columns */ colptr = colptr + nfield - 1; /* point to the correct column */ if (ffc2s(value, tvalue, &tstatus) > 0) /* remove quotes */ return(*status); strcpy(colptr->ttype, tvalue); /* copy col name to structure */ } else if(!FSTRNCMP(name + 1, "FORM", 4) ) { /* get the index number */ if( ffc2ii(name + 5, &nfield, &tstatus) > 0) /* read index no. */ return(*status); /* must not be an indexed keyword */ if (nfield < 1 || nfield > (fptr->Fptr)->tfield ) /* out of range */ return(*status); colptr = (fptr->Fptr)->tableptr; /* get pointer to columns */ colptr = colptr + nfield - 1; /* point to the correct column */ if (ffc2s(value, tvalue, &tstatus) > 0) /* remove quotes */ return(*status); strncpy(colptr->tform, tvalue, 9); /* copy TFORM to structure */ colptr->tform[9] = '\0'; /* make sure it is terminated */ if ((fptr->Fptr)->hdutype == ASCII_TBL) /* ASCII table */ { if (ffasfm(tvalue, &datacode, &width, &decimals, status) > 0) return(*status); /* bad format code */ colptr->tdatatype = TSTRING; /* store datatype code */ colptr->trepeat = 1; /* field repeat count == 1 */ colptr->twidth = width; /* the width of the field, in bytes */ } else /* binary table */ { if (ffbnfm(tvalue, &datacode, &repeat, &width, status) > 0) return(*status); /* bad format code */ colptr->tdatatype = datacode; /* store datatype code */ colptr->trepeat = (LONGLONG) repeat; /* field repeat count */ /* Don't overwrite the unit string width if it was previously */ /* set by a TDIMn keyword and has a legal value */ if (datacode == TSTRING) { if (colptr->twidth == 0 || colptr->twidth > repeat) colptr->twidth = width; /* width of a unit string */ } else { colptr->twidth = width; /* width of a unit value in chars */ } } } else if(!FSTRNCMP(name + 1, "BCOL", 4) ) { /* get the index number */ if( ffc2ii(name + 5, &nfield, &tstatus) > 0) /* read index no. */ return(*status); /* must not be an indexed keyword */ if (nfield < 1 || nfield > (fptr->Fptr)->tfield ) /* out of range */ return(*status); colptr = (fptr->Fptr)->tableptr; /* get pointer to columns */ colptr = colptr + nfield - 1; /* point to the correct column */ if ((fptr->Fptr)->hdutype == BINARY_TBL) return(*status); /* binary tables don't have TBCOL keywords */ if (ffc2ii(value, &ivalue, status) > 0) { sprintf(message, "Error reading value of %s as an integer: %s", name, value); ffpmsg(message); return(*status); } colptr->tbcol = ivalue - 1; /* convert to zero base */ } else if(!FSTRNCMP(name + 1, "SCAL", 4) ) { /* get the index number */ if( ffc2ii(name + 5, &nfield, &tstatus) > 0) /* read index no. */ return(*status); /* must not be an indexed keyword */ if (nfield < 1 || nfield > (fptr->Fptr)->tfield ) /* out of range */ return(*status); colptr = (fptr->Fptr)->tableptr; /* get pointer to columns */ colptr = colptr + nfield - 1; /* point to the correct column */ if (ffc2dd(value, &dvalue, &tstatus) > 0) { sprintf(message, "Error reading value of %s as a double: %s", name, value); ffpmsg(message); /* ignore this error, so don't return error status */ return(*status); } colptr->tscale = dvalue; } else if(!FSTRNCMP(name + 1, "ZERO", 4) ) { /* get the index number */ if( ffc2ii(name + 5, &nfield, &tstatus) > 0) /* read index no. */ return(*status); /* must not be an indexed keyword */ if (nfield < 1 || nfield > (fptr->Fptr)->tfield ) /* out of range */ return(*status); colptr = (fptr->Fptr)->tableptr; /* get pointer to columns */ colptr = colptr + nfield - 1; /* point to the correct column */ if (ffc2dd(value, &dvalue, &tstatus) > 0) { sprintf(message, "Error reading value of %s as a double: %s", name, value); ffpmsg(message); /* ignore this error, so don't return error status */ return(*status); } colptr->tzero = dvalue; } else if(!FSTRNCMP(name + 1, "NULL", 4) ) { /* get the index number */ if( ffc2ii(name + 5, &nfield, &tstatus) > 0) /* read index no. */ return(*status); /* must not be an indexed keyword */ if (nfield < 1 || nfield > (fptr->Fptr)->tfield ) /* out of range */ return(*status); colptr = (fptr->Fptr)->tableptr; /* get pointer to columns */ colptr = colptr + nfield - 1; /* point to the correct column */ if ((fptr->Fptr)->hdutype == ASCII_TBL) /* ASCII table */ { if (ffc2s(value, tvalue, &tstatus) > 0) /* remove quotes */ return(*status); strncpy(colptr->strnull, tvalue, 17); /* copy TNULL string */ colptr->strnull[17] = '\0'; /* terminate the strnull field */ } else /* binary table */ { if (ffc2jj(value, &jjvalue, &tstatus) > 0) { sprintf(message, "Error reading value of %s as an integer: %s", name, value); ffpmsg(message); /* ignore this error, so don't return error status */ return(*status); } colptr->tnull = jjvalue; /* null value for integer column */ } } else if(!FSTRNCMP(name + 1, "DIM", 3) ) { if ((fptr->Fptr)->hdutype == ASCII_TBL) /* ASCII table */ return(*status); /* ASCII tables don't support TDIMn keyword */ /* get the index number */ if( ffc2ii(name + 4, &nfield, &tstatus) > 0) /* read index no. */ return(*status); /* must not be an indexed keyword */ if (nfield < 1 || nfield > (fptr->Fptr)->tfield ) /* out of range */ return(*status); colptr = (fptr->Fptr)->tableptr; /* get pointer to columns */ colptr = colptr + nfield - 1; /* point to the correct column */ /* uninitialized columns have tdatatype set = -9999 */ if (colptr->tdatatype != -9999 && colptr->tdatatype != TSTRING) return(*status); /* this is not an ASCII string column */ loc = strchr(value, '(' ); /* find the opening parenthesis */ if (!loc) return(*status); /* not a proper TDIM keyword */ loc++; width = strtol(loc, &loc, 10); /* read size of first dimension */ if (colptr->trepeat != 1 && colptr->trepeat < width) return(*status); /* string length is greater than column width */ colptr->twidth = width; /* set width of a unit string in chars */ } else if (!FSTRNCMP(name + 1, "HEAP", 4) ) { if ((fptr->Fptr)->hdutype == ASCII_TBL) /* ASCII table */ return(*status); /* ASCII tables don't have a heap */ if (ffc2jj(value, &jjvalue, &tstatus) > 0) { sprintf(message, "Error reading value of %s as an integer: %s", name, value); ffpmsg(message); /* ignore this error, so don't return error status */ return(*status); } (fptr->Fptr)->heapstart = jjvalue; /* starting byte of the heap */ return(*status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffgcprll( fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number (1 = 1st column of table) */ LONGLONG firstrow, /* I - first row (1 = 1st row of table) */ LONGLONG firstelem, /* I - first element within vector (1 = 1st) */ LONGLONG nelem, /* I - number of elements to read or write */ int writemode, /* I - = 1 if writing data, = 0 if reading data */ /* If = 2, then writing data, but don't modify */ /* the returned values of repeat and incre. */ /* If = -1, then reading data in reverse */ /* direction. */ double *scale, /* O - FITS scaling factor (TSCALn keyword value) */ double *zero, /* O - FITS scaling zero pt (TZEROn keyword value) */ char *tform, /* O - ASCII column format: value of TFORMn keyword */ long *twidth, /* O - width of ASCII column (characters) */ int *tcode, /* O - column datatype code: I*4=41, R*4=42, etc */ int *maxelem, /* O - max number of elements that fit in buffer */ LONGLONG *startpos,/* O - offset in file to starting row & column */ LONGLONG *elemnum, /* O - starting element number ( 0 = 1st element) */ long *incre, /* O - byte offset between elements within a row */ LONGLONG *repeat, /* O - number of elements in a row (vector column) */ LONGLONG *rowlen, /* O - length of a row, in bytes */ int *hdutype, /* O - HDU type: 0, 1, 2 = primary, table, bintable */ LONGLONG *tnull, /* O - null value for integer columns */ char *snull, /* O - null value for ASCII table columns */ int *status) /* IO - error status */ /* Get Column PaRameters, and test starting row and element numbers for validity. This is a workhorse routine that is call by nearly every other routine that reads or writes to FITS files. */ { int nulpos, rangecheck = 1, tstatus = 0; LONGLONG datastart, endpos; long nblock; LONGLONG heapoffset, lrepeat, endrow, nrows, tbcol; char message[81]; tcolumn *colptr; if (fptr->HDUposition != (fptr->Fptr)->curhdu) { /* reset position to the correct HDU if necessary */ ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) { /* rescan header if data structure is undefined */ if ( ffrdef(fptr, status) > 0) return(*status); } else if (writemode > 0) { /* Only terminate the header with the END card if */ /* writing to the stdout stream (don't have random access). */ /* Initialize STREAM_DRIVER to be the device number for */ /* writing FITS files directly out to the stdout stream. */ /* This only needs to be done once and is thread safe. */ if (STREAM_DRIVER <= 0 || STREAM_DRIVER > 40) { urltype2driver("stream://", &STREAM_DRIVER); } if (((fptr->Fptr)->driver == STREAM_DRIVER)) { if ((fptr->Fptr)->ENDpos != maxvalue((fptr->Fptr)->headend , (fptr->Fptr)->datastart -2880)) { ffwend(fptr, status); } } } /* Do sanity check of input parameters */ if (firstrow < 1) { if ((fptr->Fptr)->hdutype == IMAGE_HDU) /* Primary Array or IMAGE */ { sprintf(message, "Image group number is less than 1: %.0f", (double) firstrow); ffpmsg(message); return(*status = BAD_ROW_NUM); } else { sprintf(message, "Starting row number is less than 1: %.0f", (double) firstrow); ffpmsg(message); return(*status = BAD_ROW_NUM); } } else if ((fptr->Fptr)->hdutype != ASCII_TBL && firstelem < 1) { sprintf(message, "Starting element number less than 1: %ld", (long) firstelem); ffpmsg(message); return(*status = BAD_ELEM_NUM); } else if (nelem < 0) { sprintf(message, "Tried to read or write less than 0 elements: %.0f", (double) nelem); ffpmsg(message); return(*status = NEG_BYTES); } else if (colnum < 1 || colnum > (fptr->Fptr)->tfield) { sprintf(message, "Specified column number is out of range: %d", colnum); ffpmsg(message); sprintf(message, " There are %d columns in this table.", (fptr->Fptr)->tfield ); ffpmsg(message); return(*status = BAD_COL_NUM); } /* copy relevant parameters from the structure */ *hdutype = (fptr->Fptr)->hdutype; /* image, ASCII table, or BINTABLE */ *rowlen = (fptr->Fptr)->rowlength; /* width of the table, in bytes */ datastart = (fptr->Fptr)->datastart; /* offset in file to start of table */ colptr = (fptr->Fptr)->tableptr; /* point to first column */ colptr += (colnum - 1); /* offset to correct column structure */ *scale = colptr->tscale; /* value scaling factor; default = 1.0 */ *zero = colptr->tzero; /* value scaling zeropoint; default = 0.0 */ *tnull = colptr->tnull; /* null value for integer columns */ tbcol = colptr->tbcol; /* offset to start of column within row */ *twidth = colptr->twidth; /* width of a single datum, in bytes */ *incre = colptr->twidth; /* increment between datums, in bytes */ *tcode = colptr->tdatatype; *repeat = colptr->trepeat; strcpy(tform, colptr->tform); /* value of TFORMn keyword */ strcpy(snull, colptr->strnull); /* null value for ASCII table columns */ if (*hdutype == ASCII_TBL && snull[0] == '\0') { /* In ASCII tables, a null value is equivalent to all spaces */ strcpy(snull, " "); /* maximum of 17 spaces */ nulpos = minvalue(17, *twidth); /* truncate to width of column */ snull[nulpos] = '\0'; } /* Special case: interpret writemode = -1 as reading data, but */ /* don't do error check for exceeding the range of pixels */ if (writemode == -1) { writemode = 0; rangecheck = 0; } /* Special case: interprete 'X' column as 'B' */ if (abs(*tcode) == TBIT) { *tcode = *tcode / TBIT * TBYTE; *repeat = (*repeat + 7) / 8; } /* Special case: support the 'rAw' format in BINTABLEs */ if (*hdutype == BINARY_TBL && *tcode == TSTRING) { *repeat = *repeat / *twidth; /* repeat = # of unit strings in field */ } else if (*hdutype == BINARY_TBL && *tcode == -TSTRING) { /* variable length string */ *incre = 1; *twidth = (long) nelem; } if (*hdutype == ASCII_TBL) *elemnum = 0; /* ASCII tables don't have vector elements */ else *elemnum = firstelem - 1; /* interprete complex and double complex as pairs of floats or doubles */ if (abs(*tcode) >= TCOMPLEX) { if (*tcode > 0) *tcode = (*tcode + 1) / 2; else *tcode = (*tcode - 1) / 2; *repeat = *repeat * 2; *twidth = *twidth / 2; *incre = *incre / 2; } /* calculate no. of pixels that fit in buffer */ /* allow for case where floats are 8 bytes long */ if (abs(*tcode) == TFLOAT) *maxelem = DBUFFSIZE / sizeof(float); else if (abs(*tcode) == TDOUBLE) *maxelem = DBUFFSIZE / sizeof(double); else if (abs(*tcode) == TSTRING) { *maxelem = (DBUFFSIZE - 1)/ *twidth; /* leave room for final \0 */ if (*maxelem == 0) { sprintf(message, "ASCII string column is too wide: %ld; max supported width is %d", *twidth, DBUFFSIZE - 1); ffpmsg(message); return(*status = COL_TOO_WIDE); } } else *maxelem = DBUFFSIZE / *twidth; /* calc starting byte position to 1st element of col */ /* (this does not apply to variable length columns) */ *startpos = datastart + ((LONGLONG)(firstrow - 1) * *rowlen) + tbcol; if (*hdutype == IMAGE_HDU && writemode) /* Primary Array or IMAGE */ { /* For primary arrays, set the repeat count greater than the total number of pixels to be written. This prevents an out-of-range error message in cases where the final image array size is not yet known or defined. */ if (*repeat < *elemnum + nelem) *repeat = *elemnum + nelem; } else if (*tcode > 0) /* Fixed length table column */ { if (*elemnum >= *repeat) { sprintf(message, "First element to write is too large: %ld; max allowed value is %ld", (long) ((*elemnum) + 1), (long) *repeat); ffpmsg(message); return(*status = BAD_ELEM_NUM); } /* last row number to be read or written */ endrow = ((*elemnum + nelem - 1) / *repeat) + firstrow; if (writemode) { /* check if we are writing beyond the current end of table */ if ((endrow > (fptr->Fptr)->numrows) && (nelem > 0) ) { /* if there are more HDUs following the current one, or */ /* if there is a data heap, then we must insert space */ /* for the new rows. */ if ( !((fptr->Fptr)->lasthdu) || (fptr->Fptr)->heapsize > 0) { nrows = endrow - ((fptr->Fptr)->numrows); if (ffirow(fptr, (fptr->Fptr)->numrows, nrows, status) > 0) { sprintf(message, "Failed to add space for %.0f new rows in table.", (double) nrows); ffpmsg(message); return(*status); } } else { /* update heap starting address */ (fptr->Fptr)->heapstart += ((LONGLONG)(endrow - (fptr->Fptr)->numrows) * (fptr->Fptr)->rowlength ); (fptr->Fptr)->numrows = endrow; /* update number of rows */ } } } else /* reading from the file */ { if ( endrow > (fptr->Fptr)->numrows && rangecheck) { if (*hdutype == IMAGE_HDU) /* Primary Array or IMAGE */ { if (firstrow > (fptr->Fptr)->numrows) { sprintf(message, "Attempted to read from group %ld of the HDU,", (long) firstrow); ffpmsg(message); sprintf(message, "however the HDU only contains %ld group(s).", (long) ((fptr->Fptr)->numrows) ); ffpmsg(message); } else { ffpmsg("Attempt to read past end of array:"); sprintf(message, " Image has %ld elements;", (long) *repeat); ffpmsg(message); sprintf(message, " Tried to read %ld elements starting at element %ld.", (long) nelem, (long) firstelem); ffpmsg(message); } } else { ffpmsg("Attempt to read past end of table:"); sprintf(message, " Table has %.0f rows with %.0f elements per row;", (double) ((fptr->Fptr)->numrows), (double) *repeat); ffpmsg(message); sprintf(message, " Tried to read %.0f elements starting at row %.0f, element %.0f.", (double) nelem, (double) firstrow, (double) ((*elemnum) + 1)); ffpmsg(message); } return(*status = BAD_ROW_NUM); } } if (*repeat == 1 && nelem > 1 && writemode != 2) { /* When accessing a scalar column, fool the calling routine into thinking that this is a vector column with very big elements. This allows multiple values (up to the maxelem number of elements that will fit in the buffer) to be read or written with a single routine call, which increases the efficiency. If writemode == 2, then the calling program does not want to have this efficiency trick applied. */ if (*rowlen <= LONG_MAX) { *incre = (long) *rowlen; *repeat = nelem; } } } else /* Variable length Binary Table column */ { *tcode *= (-1); if (writemode) /* return next empty heap address for writing */ { *repeat = nelem + *elemnum; /* total no. of elements in the field */ /* first, check if we are overwriting an existing row, and */ /* if so, if the existing space is big enough for the new vector */ if ( firstrow <= (fptr->Fptr)->numrows ) { ffgdesll(fptr, colnum, firstrow, &lrepeat, &heapoffset, &tstatus); if (!tstatus) { if (colptr->tdatatype <= -TCOMPLEX) lrepeat = lrepeat * 2; /* no. of float or double values */ else if (colptr->tdatatype == -TBIT) lrepeat = (lrepeat + 7) / 8; /* convert from bits to bytes */ if (lrepeat >= *repeat) /* enough existing space? */ { *startpos = datastart + heapoffset + (fptr->Fptr)->heapstart; /* write the descriptor into the fixed length part of table */ if (colptr->tdatatype <= -TCOMPLEX) { /* divide repeat count by 2 to get no. of complex values */ ffpdes(fptr, colnum, firstrow, *repeat / 2, heapoffset, status); } else { ffpdes(fptr, colnum, firstrow, *repeat, heapoffset, status); } return(*status); } } } /* Add more rows to the table, if writing beyond the end. */ /* It is necessary to shift the heap down in this case */ if ( firstrow > (fptr->Fptr)->numrows) { nrows = firstrow - ((fptr->Fptr)->numrows); if (ffirow(fptr, (fptr->Fptr)->numrows, nrows, status) > 0) { sprintf(message, "Failed to add space for %.0f new rows in table.", (double) nrows); ffpmsg(message); return(*status); } } /* calculate starting position (for writing new data) in the heap */ *startpos = datastart + (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; /* write the descriptor into the fixed length part of table */ if (colptr->tdatatype <= -TCOMPLEX) { /* divide repeat count by 2 to get no. of complex values */ ffpdes(fptr, colnum, firstrow, *repeat / 2, (fptr->Fptr)->heapsize, status); } else { ffpdes(fptr, colnum, firstrow, *repeat, (fptr->Fptr)->heapsize, status); } /* If this is not the last HDU in the file, then check if */ /* extending the heap would overwrite the following header. */ /* If so, then have to insert more blocks. */ if ( !((fptr->Fptr)->lasthdu) ) { endpos = datastart + (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize + ( *repeat * (*incre)); if (endpos > (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1]) { /* calc the number of blocks that need to be added */ nblock = (long) (((endpos - 1 - (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1] ) / 2880) + 1); if (ffiblk(fptr, nblock, 1, status) > 0) /* insert blocks */ { sprintf(message, "Failed to extend the size of the variable length heap by %ld blocks.", nblock); ffpmsg(message); return(*status); } } } /* increment the address to the next empty heap position */ (fptr->Fptr)->heapsize += ( *repeat * (*incre)); } else /* get the read start position in the heap */ { if ( firstrow > (fptr->Fptr)->numrows) { ffpmsg("Attempt to read past end of table"); sprintf(message, " Table has %.0f rows and tried to read row %.0f.", (double) ((fptr->Fptr)->numrows), (double) firstrow); ffpmsg(message); return(*status = BAD_ROW_NUM); } ffgdesll(fptr, colnum, firstrow, &lrepeat, &heapoffset, status); *repeat = lrepeat; if (colptr->tdatatype <= -TCOMPLEX) *repeat = *repeat * 2; /* no. of float or double values */ else if (colptr->tdatatype == -TBIT) *repeat = (*repeat + 7) / 8; /* convert from bits to bytes */ if (*elemnum >= *repeat) { sprintf(message, "Starting element to read in variable length column is too large: %ld", (long) firstelem); ffpmsg(message); sprintf(message, " This row only contains %ld elements", (long) *repeat); ffpmsg(message); return(*status = BAD_ELEM_NUM); } *startpos = datastart + heapoffset + (fptr->Fptr)->heapstart; } } return(*status); } /*---------------------------------------------------------------------------*/ int fftheap(fitsfile *fptr, /* I - FITS file pointer */ LONGLONG *heapsz, /* O - current size of the heap */ LONGLONG *unused, /* O - no. of unused bytes in the heap */ LONGLONG *overlap, /* O - no. of bytes shared by > 1 descriptors */ int *valid, /* O - are all the heap addresses valid? */ int *status) /* IO - error status */ /* Tests the contents of the binary table variable length array heap. Returns the number of bytes that are currently not pointed to by any of the descriptors, and also the number of bytes that are pointed to by more than one descriptor. It returns valid = FALSE if any of the descriptors point to addresses that are out of the bounds of the heap. */ { int jj, typecode, pixsize; long ii, kk, theapsz, nbytes; LONGLONG repeat, offset, tunused = 0, toverlap = 0; char *buffer, message[81]; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if ( fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); /* rescan header to make sure everything is up to date */ else if ( ffrdef(fptr, status) > 0) return(*status); if (valid) *valid = TRUE; if (heapsz) *heapsz = (fptr->Fptr)->heapsize; if (unused) *unused = 0; if (overlap) *overlap = 0; /* return if this is not a binary table HDU or if the heap is empty */ if ( (fptr->Fptr)->hdutype != BINARY_TBL || (fptr->Fptr)->heapsize == 0 ) return(*status); if ((fptr->Fptr)->heapsize > LONG_MAX) { ffpmsg("Heap is too big to test ( > 2**31 bytes). (fftheap)"); return(*status = MEMORY_ALLOCATION); } theapsz = (long) (fptr->Fptr)->heapsize; buffer = calloc(1, theapsz); /* allocate temp space */ if (!buffer ) { sprintf(message,"Failed to allocate buffer to test the heap"); ffpmsg(message); return(*status = MEMORY_ALLOCATION); } /* loop over all cols */ for (jj = 1; jj <= (fptr->Fptr)->tfield && *status <= 0; jj++) { ffgtcl(fptr, jj, &typecode, NULL, NULL, status); if (typecode > 0) continue; /* ignore fixed length columns */ pixsize = -typecode / 10; for (ii = 1; ii <= (fptr->Fptr)->numrows; ii++) { ffgdesll(fptr, jj, ii, &repeat, &offset, status); if (typecode == -TBIT) nbytes = (long) (repeat + 7) / 8; else nbytes = (long) repeat * pixsize; if (offset < 0 || offset + nbytes > theapsz) { if (valid) *valid = FALSE; /* address out of bounds */ sprintf(message, "Descriptor in row %ld, column %d has invalid heap address", ii, jj); ffpmsg(message); } else { for (kk = 0; kk < nbytes; kk++) buffer[kk + offset]++; /* increment every used byte */ } } } for (kk = 0; kk < theapsz; kk++) { if (buffer[kk] == 0) tunused++; else if (buffer[kk] > 1) toverlap++; } if (heapsz) *heapsz = theapsz; if (unused) *unused = tunused; if (overlap) *overlap = toverlap; free(buffer); return(*status); } /*--------------------------------------------------------------------------*/ int ffcmph(fitsfile *fptr, /* I -FITS file pointer */ int *status) /* IO - error status */ /* compress the binary table heap by reordering the contents heap and recovering any unused space */ { fitsfile *tptr; int jj, typecode, pixsize, valid; long ii, buffsize = 10000, nblock, nbytes; LONGLONG unused, overlap; LONGLONG repeat, offset; char *buffer, *tbuff, comm[FLEN_COMMENT]; char message[81]; LONGLONG pcount; LONGLONG readheapstart, writeheapstart, endpos, t1heapsize, t2heapsize; if (*status > 0) return(*status); /* get information about the current heap */ fftheap(fptr, NULL, &unused, &overlap, &valid, status); if (!valid) return(*status = BAD_HEAP_PTR); /* bad heap pointers */ /* return if this is not a binary table HDU or if the heap is OK as is */ if ( (fptr->Fptr)->hdutype != BINARY_TBL || (fptr->Fptr)->heapsize == 0 || (unused == 0 && overlap == 0) || *status > 0 ) return(*status); /* copy the current HDU to a temporary file in memory */ if (ffinit( &tptr, "mem://tempheapfile", status) ) { sprintf(message,"Failed to create temporary file for the heap"); ffpmsg(message); return(*status); } if ( ffcopy(fptr, tptr, 0, status) ) { sprintf(message,"Failed to create copy of the heap"); ffpmsg(message); ffclos(tptr, status); return(*status); } buffer = (char *) malloc(buffsize); /* allocate initial buffer */ if (!buffer) { sprintf(message,"Failed to allocate buffer to copy the heap"); ffpmsg(message); ffclos(tptr, status); return(*status = MEMORY_ALLOCATION); } readheapstart = (tptr->Fptr)->datastart + (tptr->Fptr)->heapstart; writeheapstart = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart; t1heapsize = (fptr->Fptr)->heapsize; /* save original heap size */ (fptr->Fptr)->heapsize = 0; /* reset heap to zero */ /* loop over all cols */ for (jj = 1; jj <= (fptr->Fptr)->tfield && *status <= 0; jj++) { ffgtcl(tptr, jj, &typecode, NULL, NULL, status); if (typecode > 0) continue; /* ignore fixed length columns */ pixsize = -typecode / 10; /* copy heap data, row by row */ for (ii = 1; ii <= (fptr->Fptr)->numrows; ii++) { ffgdesll(tptr, jj, ii, &repeat, &offset, status); if (typecode == -TBIT) nbytes = (long) (repeat + 7) / 8; else nbytes = (long) repeat * pixsize; /* increase size of buffer if necessary to read whole array */ if (nbytes > buffsize) { tbuff = realloc(buffer, nbytes); if (tbuff) { buffer = tbuff; buffsize = nbytes; } else *status = MEMORY_ALLOCATION; } /* If this is not the last HDU in the file, then check if */ /* extending the heap would overwrite the following header. */ /* If so, then have to insert more blocks. */ if ( !((fptr->Fptr)->lasthdu) ) { endpos = writeheapstart + (fptr->Fptr)->heapsize + nbytes; if (endpos > (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1]) { /* calc the number of blocks that need to be added */ nblock = (long) (((endpos - 1 - (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1] ) / 2880) + 1); if (ffiblk(fptr, nblock, 1, status) > 0) /* insert blocks */ { sprintf(message, "Failed to extend the size of the variable length heap by %ld blocks.", nblock); ffpmsg(message); } } } /* read arrray of bytes from temporary copy */ ffmbyt(tptr, readheapstart + offset, REPORT_EOF, status); ffgbyt(tptr, nbytes, buffer, status); /* write arrray of bytes back to original file */ ffmbyt(fptr, writeheapstart + (fptr->Fptr)->heapsize, IGNORE_EOF, status); ffpbyt(fptr, nbytes, buffer, status); /* write descriptor */ ffpdes(fptr, jj, ii, repeat, (fptr->Fptr)->heapsize, status); (fptr->Fptr)->heapsize += nbytes; /* update heapsize */ if (*status > 0) { free(buffer); ffclos(tptr, status); return(*status); } } } free(buffer); ffclos(tptr, status); /* delete any empty blocks at the end of the HDU */ nblock = (long) (( (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1] - (writeheapstart + (fptr->Fptr)->heapsize) ) / 2880); if (nblock > 0) { t2heapsize = (fptr->Fptr)->heapsize; /* save new heap size */ (fptr->Fptr)->heapsize = t1heapsize; /* restore original heap size */ ffdblk(fptr, nblock, status); (fptr->Fptr)->heapsize = t2heapsize; /* reset correct heap size */ } /* update the PCOUNT value (size of heap) */ ffmaky(fptr, 2, status); /* reset to beginning of header */ ffgkyjj(fptr, "PCOUNT", &pcount, comm, status); if ((fptr->Fptr)->heapsize != pcount) { ffmkyj(fptr, "PCOUNT", (fptr->Fptr)->heapsize, comm, status); } ffrdef(fptr, status); /* rescan new HDU structure */ return(*status); } /*--------------------------------------------------------------------------*/ int ffgdes(fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number (1 = 1st column of table) */ LONGLONG rownum, /* I - row number (1 = 1st row of table) */ long *length, /* O - number of elements in the row */ long *heapaddr, /* O - heap pointer to the data */ int *status) /* IO - error status */ /* get (read) the variable length vector descriptor from the table. */ { LONGLONG lengthjj, heapaddrjj; if (ffgdesll(fptr, colnum, rownum, &lengthjj, &heapaddrjj, status) > 0) return(*status); /* convert the temporary 8-byte values to 4-byte values */ /* check for overflow */ if (length) { if (lengthjj > LONG_MAX) *status = NUM_OVERFLOW; else *length = (long) lengthjj; } if (heapaddr) { if (heapaddrjj > LONG_MAX) *status = NUM_OVERFLOW; else *heapaddr = (long) heapaddrjj; } return(*status); } /*--------------------------------------------------------------------------*/ int ffgdesll(fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number (1 = 1st column of table) */ LONGLONG rownum, /* I - row number (1 = 1st row of table) */ LONGLONG *length, /* O - number of elements in the row */ LONGLONG *heapaddr, /* O - heap pointer to the data */ int *status) /* IO - error status */ /* get (read) the variable length vector descriptor from the binary table. This is similar to ffgdes, except it supports the full 8-byte range of the length and offset values in 'Q' columns, as well as 'P' columns. */ { LONGLONG bytepos; unsigned int descript4[2] = {0,0}; LONGLONG descript8[2] = {0,0}; tcolumn *colptr; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); colptr = (fptr->Fptr)->tableptr; /* point to first column structure */ colptr += (colnum - 1); /* offset to the correct column */ if (colptr->tdatatype >= 0) { *status = NOT_VARI_LEN; return(*status); } bytepos = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * (rownum - 1)) + colptr->tbcol; if (colptr->tform[0] == 'P' || colptr->tform[1] == 'P') { /* read 4-byte descriptor */ if (ffgi4b(fptr, bytepos, 2, 4, (INT32BIT *) descript4, status) <= 0) { if (length) *length = (LONGLONG) descript4[0]; /* 1st word is the length */ if (heapaddr) *heapaddr = (LONGLONG) descript4[1]; /* 2nd word is the address */ } } else /* this is for 'Q' columns */ { /* read 8 byte descriptor */ if (ffgi8b(fptr, bytepos, 2, 8, (long *) descript8, status) <= 0) { if (length) *length = descript8[0]; /* 1st word is the length */ if (heapaddr) *heapaddr = descript8[1]; /* 2nd word is the address */ } } return(*status); } /*--------------------------------------------------------------------------*/ int ffgdess(fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number (1 = 1st column of table) */ LONGLONG firstrow, /* I - first row (1 = 1st row of table) */ LONGLONG nrows, /* I - number or rows to read */ long *length, /* O - number of elements in the row */ long *heapaddr, /* O - heap pointer to the data */ int *status) /* IO - error status */ /* get (read) a range of variable length vector descriptors from the table. */ { LONGLONG rowsize, bytepos; long ii; INT32BIT descript4[2] = {0,0}; LONGLONG descript8[2] = {0,0}; tcolumn *colptr; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); colptr = (fptr->Fptr)->tableptr; /* point to first column structure */ colptr += (colnum - 1); /* offset to the correct column */ if (colptr->tdatatype >= 0) { *status = NOT_VARI_LEN; return(*status); } rowsize = (fptr->Fptr)->rowlength; bytepos = (fptr->Fptr)->datastart + (rowsize * (firstrow - 1)) + colptr->tbcol; if (colptr->tform[0] == 'P' || colptr->tform[1] == 'P') { /* read 4-byte descriptors */ for (ii = 0; ii < nrows; ii++) { /* read descriptors */ if (ffgi4b(fptr, bytepos, 2, 4, descript4, status) <= 0) { if (length) { *length = (long) descript4[0]; /* 1st word is the length */ length++; } if (heapaddr) { *heapaddr = (long) descript4[1]; /* 2nd word is the address */ heapaddr++; } bytepos += rowsize; } else return(*status); } } else /* this is for 'Q' columns */ { /* read 8-byte descriptors */ for (ii = 0; ii < nrows; ii++) { /* read descriptors */ if (ffgi8b(fptr, bytepos, 2, 8, (long *) descript8, status) <= 0) { if (length) { if (descript8[0] > LONG_MAX)*status = NUM_OVERFLOW; *length = (long) descript8[0]; /* 1st word is the length */ length++; } if (heapaddr) { if (descript8[1] > LONG_MAX)*status = NUM_OVERFLOW; *heapaddr = (long) descript8[1]; /* 2nd word is the address */ heapaddr++; } bytepos += rowsize; } else return(*status); } } return(*status); } /*--------------------------------------------------------------------------*/ int ffgdessll(fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number (1 = 1st column of table) */ LONGLONG firstrow, /* I - first row (1 = 1st row of table) */ LONGLONG nrows, /* I - number or rows to read */ LONGLONG *length, /* O - number of elements in the row */ LONGLONG *heapaddr, /* O - heap pointer to the data */ int *status) /* IO - error status */ /* get (read) a range of variable length vector descriptors from the table. */ { LONGLONG rowsize, bytepos; long ii; unsigned int descript4[2] = {0,0}; LONGLONG descript8[2] = {0,0}; tcolumn *colptr; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); colptr = (fptr->Fptr)->tableptr; /* point to first column structure */ colptr += (colnum - 1); /* offset to the correct column */ if (colptr->tdatatype >= 0) { *status = NOT_VARI_LEN; return(*status); } rowsize = (fptr->Fptr)->rowlength; bytepos = (fptr->Fptr)->datastart + (rowsize * (firstrow - 1)) + colptr->tbcol; if (colptr->tform[0] == 'P' || colptr->tform[1] == 'P') { /* read 4-byte descriptors */ for (ii = 0; ii < nrows; ii++) { /* read descriptors */ if (ffgi4b(fptr, bytepos, 2, 4, (INT32BIT *) descript4, status) <= 0) { if (length) { *length = (LONGLONG) descript4[0]; /* 1st word is the length */ length++; } if (heapaddr) { *heapaddr = (LONGLONG) descript4[1]; /* 2nd word is the address */ heapaddr++; } bytepos += rowsize; } else return(*status); } } else /* this is for 'Q' columns */ { /* read 8-byte descriptors */ for (ii = 0; ii < nrows; ii++) { /* read descriptors */ /* cast to type (long *) even though it is actually (LONGLONG *) */ if (ffgi8b(fptr, bytepos, 2, 8, (long *) descript8, status) <= 0) { if (length) { *length = descript8[0]; /* 1st word is the length */ length++; } if (heapaddr) { *heapaddr = descript8[1]; /* 2nd word is the address */ heapaddr++; } bytepos += rowsize; } else return(*status); } } return(*status); } /*--------------------------------------------------------------------------*/ int ffpdes(fitsfile *fptr, /* I - FITS file pointer */ int colnum, /* I - column number (1 = 1st column of table) */ LONGLONG rownum, /* I - row number (1 = 1st row of table) */ LONGLONG length, /* I - number of elements in the row */ LONGLONG heapaddr, /* I - heap pointer to the data */ int *status) /* IO - error status */ /* put (write) the variable length vector descriptor to the table. */ { LONGLONG bytepos; unsigned int descript4[2]; LONGLONG descript8[2]; tcolumn *colptr; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); colptr = (fptr->Fptr)->tableptr; /* point to first column structure */ colptr += (colnum - 1); /* offset to the correct column */ if (colptr->tdatatype >= 0) *status = NOT_VARI_LEN; bytepos = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * (rownum - 1)) + colptr->tbcol; ffmbyt(fptr, bytepos, IGNORE_EOF, status); /* move to element */ if (colptr->tform[0] == 'P' || colptr->tform[1] == 'P') { if (length > UINT_MAX || length < 0 || heapaddr > UINT_MAX || heapaddr < 0) { ffpmsg("P variable length column descriptor is out of range"); *status = NUM_OVERFLOW; return(*status); } descript4[0] = (unsigned int) length; /* 1st word is the length */ descript4[1] = (unsigned int) heapaddr; /* 2nd word is the address */ ffpi4b(fptr, 2, 4, (INT32BIT *) descript4, status); /* write the descriptor */ } else /* this is a 'Q' descriptor column */ { descript8[0] = length; /* 1st word is the length */ descript8[1] = heapaddr; /* 2nd word is the address */ ffpi8b(fptr, 2, 8, (long *) descript8, status); /* write the descriptor */ } return(*status); } /*--------------------------------------------------------------------------*/ int ffchdu(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ { /* close the current HDU. If we have write access to the file, then: - write the END keyword and pad header with blanks if necessary - check the data fill values, and rewrite them if not correct */ char message[FLEN_ERRMSG]; int ii, stdriver, ntilebins; /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); /* no need to do any further updating of the HDU */ } else if ((fptr->Fptr)->writemode == 1) { urltype2driver("stream://", &stdriver); /* don't rescan header in special case of writing to stdout */ if (((fptr->Fptr)->driver != stdriver)) ffrdef(fptr, status); if ((fptr->Fptr)->heapsize > 0) { ffuptf(fptr, status); /* update the variable length TFORM values */ } ffpdfl(fptr, status); /* insure correct data fill values */ } if ((fptr->Fptr)->open_count == 1) { /* free memory for the CHDU structure only if no other files are using it */ if ((fptr->Fptr)->tableptr) { free((fptr->Fptr)->tableptr); (fptr->Fptr)->tableptr = NULL; /* free the tile-compressed image cache, if it exists */ if ((fptr->Fptr)->tilerow) { ntilebins = (((fptr->Fptr)->znaxis[0] - 1) / ((fptr->Fptr)->tilesize[0])) + 1; for (ii = 0; ii < ntilebins; ii++) { if ((fptr->Fptr)->tiledata[ii]) { free((fptr->Fptr)->tiledata[ii]); } if ((fptr->Fptr)->tilenullarray[ii]) { free((fptr->Fptr)->tilenullarray[ii]); } } free((fptr->Fptr)->tileanynull); free((fptr->Fptr)->tiletype); free((fptr->Fptr)->tiledatasize); free((fptr->Fptr)->tilenullarray); free((fptr->Fptr)->tiledata); free((fptr->Fptr)->tilerow); (fptr->Fptr)->tileanynull = 0; (fptr->Fptr)->tiletype = 0; (fptr->Fptr)->tiledatasize = 0; (fptr->Fptr)->tilenullarray = 0; (fptr->Fptr)->tiledata = 0; (fptr->Fptr)->tilerow = 0; } } } if (*status > 0 && *status != NO_CLOSE_ERROR) { sprintf(message, "Error while closing HDU number %d (ffchdu).", (fptr->Fptr)->curhdu); ffpmsg(message); } return(*status); } /*--------------------------------------------------------------------------*/ int ffuptf(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* Update the value of the TFORM keywords for the variable length array columns to make sure they all have the form 1Px(len) or Px(len) where 'len' is the maximum length of the vector in the table (e.g., '1PE(400)') */ { int ii; long tflds; LONGLONG length, addr, maxlen, naxis2, jj; char comment[FLEN_COMMENT], keyname[FLEN_KEYWORD]; char tform[FLEN_VALUE], newform[FLEN_VALUE], lenval[40]; char card[FLEN_CARD]; char message[FLEN_ERRMSG]; char *tmp; ffmaky(fptr, 2, status); /* reset to beginning of header */ ffgkyjj(fptr, "NAXIS2", &naxis2, comment, status); ffgkyj(fptr, "TFIELDS", &tflds, comment, status); for (ii = 1; ii <= tflds; ii++) /* loop over all the columns */ { ffkeyn("TFORM", ii, keyname, status); /* construct name */ if (ffgkys(fptr, keyname, tform, comment, status) > 0) { sprintf(message, "Error while updating variable length vector TFORMn values (ffuptf)."); ffpmsg(message); return(*status); } /* is this a variable array length column ? */ if (tform[0] == 'P' || tform[1] == 'P' || tform[0] == 'Q' || tform[1] == 'Q') { /* get the max length */ maxlen = 0; for (jj=1; jj <= naxis2; jj++) { ffgdesll(fptr, ii, jj, &length, &addr, status); if (length > maxlen) maxlen = length; } /* construct the new keyword value */ strcpy(newform, "'"); tmp = strchr(tform, '('); /* truncate old length, if present */ if (tmp) *tmp = 0; strcat(newform, tform); /* print as double, because the string-to-64-bit */ /* conversion is platform dependent (%lld, %ld, %I64d) */ sprintf(lenval, "(%.0f)", (double) maxlen); strcat(newform,lenval); while(strlen(newform) < 9) strcat(newform," "); /* append spaces 'till length = 8 */ strcat(newform,"'" ); /* append closing parenthesis */ /* would be simpler to just call ffmkyj here, but this */ /* would force linking in all the modkey & putkey routines */ ffmkky(keyname, newform, comment, card, status); /* make new card */ ffmkey(fptr, card, status); /* replace last read keyword */ } } return(*status); } /*--------------------------------------------------------------------------*/ int ffrdef(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* ReDEFine the structure of a data unit. This routine re-reads the CHDU header keywords to determine the structure and length of the current data unit. This redefines the start of the next HDU. */ { int dummy, tstatus = 0; LONGLONG naxis2; LONGLONG pcount; char card[FLEN_CARD], comm[FLEN_COMMENT], valstring[FLEN_VALUE]; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } else if ((fptr->Fptr)->writemode == 1) /* write access to the file? */ { /* don't need to check NAXIS2 and PCOUNT if data hasn't been written */ if ((fptr->Fptr)->datastart != DATA_UNDEFINED) { /* update NAXIS2 keyword if more rows were written to the table */ /* and if the user has not explicitly reset the NAXIS2 value */ if ((fptr->Fptr)->hdutype != IMAGE_HDU) { ffmaky(fptr, 2, status); if (ffgkyjj(fptr, "NAXIS2", &naxis2, comm, &tstatus) > 0) { /* Couldn't read NAXIS2 (odd!); in certain circumstances */ /* this may be normal, so ignore the error. */ naxis2 = (fptr->Fptr)->numrows; } if ((fptr->Fptr)->numrows > naxis2 && (fptr->Fptr)->origrows == naxis2) /* if origrows is not equal to naxis2, then the user must */ /* have manually modified the NAXIS2 keyword value, and */ /* we will assume that the current value is correct. */ { /* would be simpler to just call ffmkyj here, but this */ /* would force linking in all the modkey & putkey routines */ /* print as double because the 64-bit int conversion */ /* is platform dependent (%lld, %ld, %I64 ) */ sprintf(valstring, "%.0f", (double) ((fptr->Fptr)->numrows)); ffmkky("NAXIS2", valstring, comm, card, status); ffmkey(fptr, card, status); } } /* if data has been written to variable length columns in a */ /* binary table, then we may need to update the PCOUNT value */ if ((fptr->Fptr)->heapsize > 0) { ffmaky(fptr, 2, status); ffgkyjj(fptr, "PCOUNT", &pcount, comm, status); if ((fptr->Fptr)->heapsize != pcount) { ffmkyj(fptr, "PCOUNT", (fptr->Fptr)->heapsize, comm, status); } } } if (ffwend(fptr, status) <= 0) /* rewrite END keyword and fill */ { ffrhdu(fptr, &dummy, status); /* re-scan the header keywords */ } } return(*status); } /*--------------------------------------------------------------------------*/ int ffhdef(fitsfile *fptr, /* I - FITS file pointer */ int morekeys, /* I - reserve space for this many keywords */ int *status) /* IO - error status */ /* based on the number of keywords which have already been written, plus the number of keywords to reserve space for, we then can define where the data unit should start (it must start at the beginning of a 2880-byte logical block). This routine will only have any effect if the starting location of the data unit following the header is not already defined. In any case, it is always possible to add more keywords to the header even if the data has already been written. It is just more efficient to reserve the space in advance. */ { LONGLONG delta; if (*status > 0 || morekeys < 1) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) { ffrdef(fptr, status); /* ffrdef defines the offset to datastart and the start of */ /* the next HDU based on the number of existing keywords. */ /* We need to increment both of these values based on */ /* the number of new keywords to be added. */ delta = (((fptr->Fptr)->headend + (morekeys * 80)) / 2880 + 1) * 2880 - (fptr->Fptr)->datastart; (fptr->Fptr)->datastart += delta; (fptr->Fptr)->headstart[ (fptr->Fptr)->curhdu + 1] += delta; } return(*status); } /*--------------------------------------------------------------------------*/ int ffwend(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* write the END card and following fill (space chars) in the current header */ { int ii, tstatus; LONGLONG endpos; long nspace; char blankkey[FLEN_CARD], endkey[FLEN_CARD], keyrec[FLEN_CARD] = ""; if (*status > 0) return(*status); endpos = (fptr->Fptr)->headend; /* we assume that the HDUposition == curhdu in all cases */ /* calc the data starting position if not currently defined */ if ((fptr->Fptr)->datastart == DATA_UNDEFINED) (fptr->Fptr)->datastart = ( endpos / 2880 + 1 ) * 2880; /* calculate the number of blank keyword slots in the header */ nspace = (long) (( (fptr->Fptr)->datastart - endpos ) / 80); /* construct a blank and END keyword (80 spaces ) */ strcpy(blankkey, " "); strcat(blankkey, " "); strcpy(endkey, "END "); strcat(endkey, " "); /* check if header is already correctly terminated with END and fill */ tstatus=0; ffmbyt(fptr, endpos, REPORT_EOF, &tstatus); /* move to header end */ for (ii=0; ii < nspace; ii++) { ffgbyt(fptr, 80, keyrec, &tstatus); /* get next keyword */ if (tstatus) break; if (strncmp(keyrec, blankkey, 80) && strncmp(keyrec, endkey, 80)) break; } if (ii == nspace && !tstatus) { /* check if the END keyword exists at the correct position */ endpos=maxvalue( endpos, ( (fptr->Fptr)->datastart - 2880 ) ); ffmbyt(fptr, endpos, REPORT_EOF, &tstatus); /* move to END position */ ffgbyt(fptr, 80, keyrec, &tstatus); /* read the END keyword */ if ( !strncmp(keyrec, endkey, 80) && !tstatus) { /* store this position, for later reference */ (fptr->Fptr)->ENDpos = endpos; return(*status); /* END card was already correct */ } } /* header was not correctly terminated, so write the END and blank fill */ endpos = (fptr->Fptr)->headend; ffmbyt(fptr, endpos, IGNORE_EOF, status); /* move to header end */ for (ii=0; ii < nspace; ii++) ffpbyt(fptr, 80, blankkey, status); /* write the blank keywords */ /* The END keyword must either be placed immediately after the last keyword that was written (as indicated by the headend value), or must be in the first 80 bytes of the 2880-byte FITS record immediately preceeding the data unit, whichever is further in the file. The latter will occur if space has been reserved for more header keywords which have not yet been written. */ endpos=maxvalue( endpos, ( (fptr->Fptr)->datastart - 2880 ) ); ffmbyt(fptr, endpos, REPORT_EOF, status); /* move to END position */ ffpbyt(fptr, 80, endkey, status); /* write the END keyword to header */ /* store this position, for later reference */ (fptr->Fptr)->ENDpos = endpos; if (*status > 0) ffpmsg("Error while writing END card (ffwend)."); return(*status); } /*--------------------------------------------------------------------------*/ int ffpdfl(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* Write the Data Unit Fill values if they are not already correct. The fill values are used to fill out the last 2880 byte block of the HDU. Fill the data unit with zeros or blanks depending on the type of HDU from the end of the data to the end of the current FITS 2880 byte block */ { char chfill, fill[2880]; LONGLONG fillstart; int nfill, tstatus, ii; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) return(*status); /* fill has already been correctly written */ if ((fptr->Fptr)->heapstart == 0) return(*status); /* null data unit, so there is no fill */ fillstart = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; nfill = (long) ((fillstart + 2879) / 2880 * 2880 - fillstart); if ((fptr->Fptr)->hdutype == ASCII_TBL) chfill = 32; /* ASCII tables are filled with spaces */ else chfill = 0; /* all other extensions are filled with zeros */ tstatus = 0; if (!nfill) /* no fill bytes; just check that entire table exists */ { fillstart--; nfill = 1; ffmbyt(fptr, fillstart, REPORT_EOF, &tstatus); /* move to last byte */ ffgbyt(fptr, nfill, fill, &tstatus); /* get the last byte */ if (tstatus == 0) return(*status); /* no EOF error, so everything is OK */ } else { ffmbyt(fptr, fillstart, REPORT_EOF, &tstatus); /* move to fill area */ ffgbyt(fptr, nfill, fill, &tstatus); /* get the fill bytes */ if (tstatus == 0) { for (ii = 0; ii < nfill; ii++) { if (fill[ii] != chfill) break; } if (ii == nfill) return(*status); /* all the fill values were correct */ } } /* fill values are incorrect or have not been written, so write them */ memset(fill, chfill, nfill); /* fill the buffer with the fill value */ ffmbyt(fptr, fillstart, IGNORE_EOF, status); /* move to fill area */ ffpbyt(fptr, nfill, fill, status); /* write the fill bytes */ if (*status > 0) ffpmsg("Error writing Data Unit fill bytes (ffpdfl)."); return(*status); } /********************************************************************** ffchfl : Check Header Fill values Check that the header unit is correctly filled with blanks from the END card to the end of the current FITS 2880-byte block Function parameters: fptr Fits file pointer status output error status Translated ftchfl into C by Peter Wilson, Oct. 1997 **********************************************************************/ int ffchfl( fitsfile *fptr, int *status) { int nblank,i,gotend; LONGLONG endpos; char rec[FLEN_CARD]; char *blanks=" "; /* 80 spaces */ if( *status > 0 ) return (*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); /* calculate the number of blank keyword slots in the header */ endpos=(fptr->Fptr)->headend; nblank=(long) (((fptr->Fptr)->datastart-endpos)/80); /* move the i/o pointer to the end of the header keywords */ ffmbyt(fptr,endpos,TRUE,status); /* find the END card (there may be blank keywords perceeding it) */ gotend=FALSE; for(i=0;i 0 ) { rec[FLEN_CARD - 1] = '\0'; /* make sure string is null terminated */ ffpmsg(rec); return( *status ); } } return( *status ); } /********************************************************************** ffcdfl : Check Data Unit Fill values Check that the data unit is correctly filled with zeros or blanks from the end of the data to the end of the current FITS 2880 byte block Function parameters: fptr Fits file pointer status output error status Translated ftcdfl into C by Peter Wilson, Oct. 1997 **********************************************************************/ int ffcdfl( fitsfile *fptr, int *status) { int nfill,i; LONGLONG filpos; char chfill,chbuff[2880]; if( *status > 0 ) return( *status ); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); /* check if the data unit is null */ if( (fptr->Fptr)->heapstart==0 ) return( *status ); /* calculate starting position of the fill bytes, if any */ filpos = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; /* calculate the number of fill bytes */ nfill = (long) ((filpos + 2879) / 2880 * 2880 - filpos); if( nfill == 0 ) return( *status ); /* move to the beginning of the fill bytes */ ffmbyt(fptr, filpos, FALSE, status); if( ffgbyt(fptr, nfill, chbuff, status) > 0) { ffpmsg("Error reading data unit fill bytes (ffcdfl)."); return( *status ); } if( (fptr->Fptr)->hdutype==ASCII_TBL ) chfill = 32; /* ASCII tables are filled with spaces */ else chfill = 0; /* all other extensions are filled with zeros */ /* check for all zeros or blanks */ for(i=0;iFptr)->hdutype==ASCII_TBL ) ffpmsg("Warning: remaining bytes following ASCII table data are not filled with blanks."); else ffpmsg("Warning: remaining bytes following data are not filled with zeros."); return( *status ); } } return( *status ); } /*--------------------------------------------------------------------------*/ int ffcrhd(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* CReate Header Data unit: Create, initialize, and move the i/o pointer to a new extension appended to the end of the FITS file. */ { int tstatus = 0; LONGLONG bytepos, *ptr; if (*status > 0) return(*status); if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); /* If the current header is empty, we don't have to do anything */ if ((fptr->Fptr)->headend == (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] ) return(*status); while (ffmrhd(fptr, 1, 0, &tstatus) == 0); /* move to end of file */ if ((fptr->Fptr)->maxhdu == (fptr->Fptr)->MAXHDU) { /* allocate more space for the headstart array */ ptr = (LONGLONG*) realloc( (fptr->Fptr)->headstart, ((fptr->Fptr)->MAXHDU + 1001) * sizeof(LONGLONG) ); if (ptr == NULL) return (*status = MEMORY_ALLOCATION); else { (fptr->Fptr)->MAXHDU = (fptr->Fptr)->MAXHDU + 1000; (fptr->Fptr)->headstart = ptr; } } if (ffchdu(fptr, status) <= 0) /* close the current HDU */ { bytepos = (fptr->Fptr)->headstart[(fptr->Fptr)->maxhdu + 1]; /* last */ ffmbyt(fptr, bytepos, IGNORE_EOF, status); /* move file ptr to it */ (fptr->Fptr)->maxhdu++; /* increment the known number of HDUs */ (fptr->Fptr)->curhdu = (fptr->Fptr)->maxhdu; /* set current HDU loc */ fptr->HDUposition = (fptr->Fptr)->maxhdu; /* set current HDU loc */ (fptr->Fptr)->nextkey = bytepos; /* next keyword = start of header */ (fptr->Fptr)->headend = bytepos; /* end of header */ (fptr->Fptr)->datastart = DATA_UNDEFINED; /* start data unit undefined */ /* any other needed resets */ /* reset the dithering offset that may have been calculated for the */ /* previous HDU back to the requested default value */ (fptr->Fptr)->dither_seed = (fptr->Fptr)->request_dither_seed; } return(*status); } /*--------------------------------------------------------------------------*/ int ffdblk(fitsfile *fptr, /* I - FITS file pointer */ long nblocks, /* I - number of 2880-byte blocks to delete */ int *status) /* IO - error status */ /* Delete the specified number of 2880-byte blocks from the end of the CHDU by shifting all following extensions up this number of blocks. */ { char buffer[2880]; int tstatus, ii; LONGLONG readpos, writepos; if (*status > 0 || nblocks <= 0) return(*status); tstatus = 0; /* pointers to the read and write positions */ readpos = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; readpos = ((readpos + 2879) / 2880) * 2880; /* start of block */ /* the following formula is wrong because the current data unit may have been extended without updating the headstart value of the following HDU. readpos = (fptr->Fptr)->headstart[((fptr->Fptr)->curhdu) + 1]; */ writepos = readpos - ((LONGLONG)nblocks * 2880); while ( !ffmbyt(fptr, readpos, REPORT_EOF, &tstatus) && !ffgbyt(fptr, 2880L, buffer, &tstatus) ) { ffmbyt(fptr, writepos, REPORT_EOF, status); ffpbyt(fptr, 2880L, buffer, status); if (*status > 0) { ffpmsg("Error deleting FITS blocks (ffdblk)"); return(*status); } readpos += 2880; /* increment to next block to transfer */ writepos += 2880; } /* now fill the last nblock blocks with zeros */ memset(buffer, 0, 2880); ffmbyt(fptr, writepos, REPORT_EOF, status); for (ii = 0; ii < nblocks; ii++) ffpbyt(fptr, 2880L, buffer, status); /* move back before the deleted blocks, since they may be deleted */ /* and we do not want to delete the current active buffer */ ffmbyt(fptr, writepos - 1, REPORT_EOF, status); /* truncate the file to the new size, if supported on this device */ fftrun(fptr, writepos, status); /* recalculate the starting location of all subsequent HDUs */ for (ii = (fptr->Fptr)->curhdu; ii <= (fptr->Fptr)->maxhdu; ii++) (fptr->Fptr)->headstart[ii + 1] -= ((LONGLONG)nblocks * 2880); return(*status); } /*--------------------------------------------------------------------------*/ int ffghdt(fitsfile *fptr, /* I - FITS file pointer */ int *exttype, /* O - type of extension, 0, 1, or 2 */ /* for IMAGE_HDU, ASCII_TBL, or BINARY_TBL */ int *status) /* IO - error status */ /* Return the type of the CHDU. This returns the 'logical' type of the HDU, not necessarily the physical type, so in the case of a compressed image stored in a binary table, this will return the type as an Image, not a binary table. */ { if (*status > 0) return(*status); if (fptr->HDUposition == 0 && (fptr->Fptr)->headend == 0) { /* empty primary array is alway an IMAGE_HDU */ *exttype = IMAGE_HDU; } else { /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) { /* rescan header if data structure is undefined */ if ( ffrdef(fptr, status) > 0) return(*status); } *exttype = (fptr->Fptr)->hdutype; /* return the type of HDU */ /* check if this is a compressed image */ if ((fptr->Fptr)->compressimg) *exttype = IMAGE_HDU; } return(*status); } /*--------------------------------------------------------------------------*/ int fits_is_reentrant(void) /* Was CFITSIO compiled with the -D_REENTRANT flag? 1 = yes, 0 = no. Note that specifying the -D_REENTRANT flag is required, but may not be sufficient, to ensure that CFITSIO can be safely used in a multi-threaded environoment. */ { #ifdef _REENTRANT return(1); #else return(0); #endif } /*--------------------------------------------------------------------------*/ int fits_is_compressed_image(fitsfile *fptr, /* I - FITS file pointer */ int *status) /* IO - error status */ /* Returns TRUE if the CHDU is a compressed image, else returns zero. */ { if (*status > 0) return(0); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) { ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); } else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) { /* rescan header if data structure is undefined */ if ( ffrdef(fptr, status) > 0) return(*status); } /* check if this is a compressed image */ if ((fptr->Fptr)->compressimg) return(1); return(0); } /*--------------------------------------------------------------------------*/ int ffgipr(fitsfile *infptr, /* I - FITS file pointer */ int maxaxis, /* I - max number of axes to return */ int *bitpix, /* O - image data type */ int *naxis, /* O - image dimension (NAXIS value) */ long *naxes, /* O - size of image dimensions */ int *status) /* IO - error status */ /* get the datatype and size of the input image */ { if (*status > 0) return(*status); /* don't return the parameter if a null pointer was given */ if (bitpix) fits_get_img_type(infptr, bitpix, status); /* get BITPIX value */ if (naxis) fits_get_img_dim(infptr, naxis, status); /* get NAXIS value */ if (naxes) fits_get_img_size(infptr, maxaxis, naxes, status); /* get NAXISn values */ return(*status); } /*--------------------------------------------------------------------------*/ int ffgiprll(fitsfile *infptr, /* I - FITS file pointer */ int maxaxis, /* I - max number of axes to return */ int *bitpix, /* O - image data type */ int *naxis, /* O - image dimension (NAXIS value) */ LONGLONG *naxes, /* O - size of image dimensions */ int *status) /* IO - error status */ /* get the datatype and size of the input image */ { if (*status > 0) return(*status); /* don't return the parameter if a null pointer was given */ if (bitpix) fits_get_img_type(infptr, bitpix, status); /* get BITPIX value */ if (naxis) fits_get_img_dim(infptr, naxis, status); /* get NAXIS value */ if (naxes) fits_get_img_sizell(infptr, maxaxis, naxes, status); /* get NAXISn values */ return(*status); } /*--------------------------------------------------------------------------*/ int ffgidt( fitsfile *fptr, /* I - FITS file pointer */ int *imgtype, /* O - image data type */ int *status) /* IO - error status */ /* Get the datatype of the image (= BITPIX keyword for normal image, or ZBITPIX for a compressed image) */ { if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); /* reset to beginning of header */ ffmaky(fptr, 1, status); /* simply move to beginning of header */ if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffgky(fptr, TINT, "BITPIX", imgtype, NULL, status); } else if ((fptr->Fptr)->compressimg) { /* this is a binary table containing a compressed image */ ffgky(fptr, TINT, "ZBITPIX", imgtype, NULL, status); } else { *status = NOT_IMAGE; } return(*status); } /*--------------------------------------------------------------------------*/ int ffgiet( fitsfile *fptr, /* I - FITS file pointer */ int *imgtype, /* O - image data type */ int *status) /* IO - error status */ /* Get the effective datatype of the image (= BITPIX keyword for normal image, or ZBITPIX for a compressed image) */ { int tstatus; long lngscale, lngzero = 0; double bscale, bzero, min_val, max_val; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); /* reset to beginning of header */ ffmaky(fptr, 2, status); /* simply move to beginning of header */ if ((fptr->Fptr)->hdutype == IMAGE_HDU) { ffgky(fptr, TINT, "BITPIX", imgtype, NULL, status); } else if ((fptr->Fptr)->compressimg) { /* this is a binary table containing a compressed image */ ffgky(fptr, TINT, "ZBITPIX", imgtype, NULL, status); } else { *status = NOT_IMAGE; return(*status); } /* check if the BSCALE and BZERO keywords are defined, which might change the effective datatype of the image */ tstatus = 0; ffgky(fptr, TDOUBLE, "BSCALE", &bscale, NULL, &tstatus); if (tstatus) bscale = 1.0; tstatus = 0; ffgky(fptr, TDOUBLE, "BZERO", &bzero, NULL, &tstatus); if (tstatus) bzero = 0.0; if (bscale == 1.0 && bzero == 0.0) /* no scaling */ return(*status); switch (*imgtype) { case BYTE_IMG: /* 8-bit image */ min_val = 0.; max_val = 255.0; break; case SHORT_IMG: min_val = -32768.0; max_val = 32767.0; break; case LONG_IMG: min_val = -2147483648.0; max_val = 2147483647.0; break; default: /* don't have to deal with other data types */ return(*status); } if (bscale >= 0.) { min_val = bzero + bscale * min_val; max_val = bzero + bscale * max_val; } else { max_val = bzero + bscale * min_val; min_val = bzero + bscale * max_val; } if (bzero < 2147483648.) /* don't exceed range of 32-bit integer */ lngzero = (long) bzero; lngscale = (long) bscale; if ((bzero != 2147483648.) && /* special value that exceeds integer range */ (lngzero != bzero || lngscale != bscale)) { /* not integers? */ /* floating point scaled values; just decide on required precision */ if (*imgtype == BYTE_IMG || *imgtype == SHORT_IMG) *imgtype = FLOAT_IMG; else *imgtype = DOUBLE_IMG; /* In all the remaining cases, BSCALE and BZERO are integers, and not equal to 1 and 0, respectively. */ } else if ((min_val == -128.) && (max_val == 127.)) { *imgtype = SBYTE_IMG; } else if ((min_val >= -32768.0) && (max_val <= 32767.0)) { *imgtype = SHORT_IMG; } else if ((min_val >= 0.0) && (max_val <= 65535.0)) { *imgtype = USHORT_IMG; } else if ((min_val >= -2147483648.0) && (max_val <= 2147483647.0)) { *imgtype = LONG_IMG; } else if ((min_val >= 0.0) && (max_val < 4294967296.0)) { *imgtype = ULONG_IMG; } else { /* exceeds the range of a 32-bit integer */ *imgtype = DOUBLE_IMG; } return(*status); } /*--------------------------------------------------------------------------*/ int ffgidm( fitsfile *fptr, /* I - FITS file pointer */ int *naxis , /* O - image dimension (NAXIS value) */ int *status) /* IO - error status */ /* Get the dimension of the image (= NAXIS keyword for normal image, or ZNAXIS for a compressed image) These values are cached for faster access. */ { if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { *naxis = (fptr->Fptr)->imgdim; } else if ((fptr->Fptr)->compressimg) { *naxis = (fptr->Fptr)->zndim; } else { *status = NOT_IMAGE; } return(*status); } /*--------------------------------------------------------------------------*/ int ffgisz( fitsfile *fptr, /* I - FITS file pointer */ int nlen, /* I - number of axes to return */ long *naxes, /* O - size of image dimensions */ int *status) /* IO - error status */ /* Get the size of the image dimensions (= NAXISn keywords for normal image, or ZNAXISn for a compressed image) These values are cached for faster access. */ { int ii, naxis; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { naxis = minvalue((fptr->Fptr)->imgdim, nlen); for (ii = 0; ii < naxis; ii++) { naxes[ii] = (long) (fptr->Fptr)->imgnaxis[ii]; } } else if ((fptr->Fptr)->compressimg) { naxis = minvalue( (fptr->Fptr)->zndim, nlen); for (ii = 0; ii < naxis; ii++) { naxes[ii] = (long) (fptr->Fptr)->znaxis[ii]; } } else { *status = NOT_IMAGE; } return(*status); } /*--------------------------------------------------------------------------*/ int ffgiszll( fitsfile *fptr, /* I - FITS file pointer */ int nlen, /* I - number of axes to return */ LONGLONG *naxes, /* O - size of image dimensions */ int *status) /* IO - error status */ /* Get the size of the image dimensions (= NAXISn keywords for normal image, or ZNAXISn for a compressed image) */ { int ii, naxis; if (*status > 0) return(*status); /* reset position to the correct HDU if necessary */ if (fptr->HDUposition != (fptr->Fptr)->curhdu) ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) if ( ffrdef(fptr, status) > 0) /* rescan header */ return(*status); if ((fptr->Fptr)->hdutype == IMAGE_HDU) { naxis = minvalue((fptr->Fptr)->imgdim, nlen); for (ii = 0; ii < naxis; ii++) { naxes[ii] = (fptr->Fptr)->imgnaxis[ii]; } } else if ((fptr->Fptr)->compressimg) { naxis = minvalue( (fptr->Fptr)->zndim, nlen); for (ii = 0; ii < naxis; ii++) { naxes[ii] = (fptr->Fptr)->znaxis[ii]; } } else { *status = NOT_IMAGE; } return(*status); }/*--------------------------------------------------------------------------*/ int ffmahd(fitsfile *fptr, /* I - FITS file pointer */ int hdunum, /* I - number of the HDU to move to */ int *exttype, /* O - type of extension, 0, 1, or 2 */ int *status) /* IO - error status */ /* Move to Absolute Header Data unit. Move to the specified HDU and read the header to initialize the table structure. Note that extnum is one based, so the primary array is extnum = 1. */ { int moveto, tstatus; char message[FLEN_ERRMSG]; LONGLONG *ptr; if (*status > 0) return(*status); else if (hdunum < 1 ) return(*status = BAD_HDU_NUM); else if (hdunum >= (fptr->Fptr)->MAXHDU ) { /* allocate more space for the headstart array */ ptr = (LONGLONG*) realloc( (fptr->Fptr)->headstart, (hdunum + 1001) * sizeof(LONGLONG) ); if (ptr == NULL) return (*status = MEMORY_ALLOCATION); else { (fptr->Fptr)->MAXHDU = hdunum + 1000; (fptr->Fptr)->headstart = ptr; } } /* set logical HDU position to the actual position, in case they differ */ fptr->HDUposition = (fptr->Fptr)->curhdu; while( ((fptr->Fptr)->curhdu) + 1 != hdunum) /* at the correct HDU? */ { /* move directly to the extension if we know that it exists, otherwise move to the highest known extension. */ moveto = minvalue(hdunum - 1, ((fptr->Fptr)->maxhdu) + 1); /* test if HDU exists */ if ((fptr->Fptr)->headstart[moveto] < (fptr->Fptr)->logfilesize ) { if (ffchdu(fptr, status) <= 0) /* close out the current HDU */ { if (ffgext(fptr, moveto, exttype, status) > 0) { /* failed to get the requested extension */ tstatus = 0; ffrhdu(fptr, exttype, &tstatus); /* restore the CHDU */ } } } else *status = END_OF_FILE; if (*status > 0) { if (*status != END_OF_FILE) { /* don't clutter up the message stack in the common case of */ /* simply hitting the end of file (often an expected error) */ sprintf(message, "Failed to move to HDU number %d (ffmahd).", hdunum); ffpmsg(message); } return(*status); } } /* return the type of HDU; tile compressed images which are stored */ /* in a binary table will return exttype = IMAGE_HDU, not BINARY_TBL */ if (exttype != NULL) ffghdt(fptr, exttype, status); return(*status); } /*--------------------------------------------------------------------------*/ int ffmrhd(fitsfile *fptr, /* I - FITS file pointer */ int hdumov, /* I - rel. no. of HDUs to move by (+ or -) */ int *exttype, /* O - type of extension, 0, 1, or 2 */ int *status) /* IO - error status */ /* Move a Relative number of Header Data units. Offset to the specified extension and read the header to initialize the HDU structure. */ { int extnum; if (*status > 0) return(*status); extnum = fptr->HDUposition + 1 + hdumov; /* the absolute HDU number */ ffmahd(fptr, extnum, exttype, status); /* move to the HDU */ return(*status); } /*--------------------------------------------------------------------------*/ int ffmnhd(fitsfile *fptr, /* I - FITS file pointer */ int exttype, /* I - desired extension type */ char *hduname, /* I - desired EXTNAME value for the HDU */ int hduver, /* I - desired EXTVERS value for the HDU */ int *status) /* IO - error status */ /* Move to the next HDU with a given extension type (IMAGE_HDU, ASCII_TBL, BINARY_TBL, or ANY_HDU), extension name (EXTNAME or HDUNAME keyword), and EXTVERS keyword values. If hduvers = 0, then move to the first HDU with the given type and name regardless of EXTVERS value. If no matching HDU is found in the file, then the current open HDU will remain unchanged. */ { char extname[FLEN_VALUE]; int ii, hdutype, alttype, extnum, tstatus, match, exact; int slen, putback = 0, chopped = 0; long extver; if (*status > 0) return(*status); extnum = fptr->HDUposition + 1; /* save the current HDU number */ /* This is a kludge to deal with a special case where the user specified a hduname that ended with a # character, which CFITSIO previously interpreted as a flag to mean "don't copy any other HDUs in the file into the virtual file in memory. If the remaining hduname does not end with a # character (meaning that the user originally entered a hduname ending in 2 # characters) then there is the possibility that the # character should be treated literally, if the actual EXTNAME also ends with a #. Setting putback = 1 means that we need to test for this case later on. */ if ((fptr->Fptr)->only_one) { /* if true, name orignally ended with a # */ slen = strlen(hduname); if (hduname[slen - 1] != '#') /* This will fail if real EXTNAME value */ putback = 1; /* ends with 2 # characters. */ } for (ii=1; 1; ii++) /* loop over all HDUs until EOF */ { tstatus = 0; if (ffmahd(fptr, ii, &hdutype, &tstatus)) /* move to next HDU */ { ffmahd(fptr, extnum, 0, status); /* restore original file position */ return(*status = BAD_HDU_NUM); /* couldn't find desired HDU */ } alttype = -1; if (fits_is_compressed_image(fptr, status)) alttype = BINARY_TBL; /* Does this HDU have a matching type? */ if (exttype == ANY_HDU || hdutype == exttype || hdutype == alttype) { ffmaky(fptr, 2, status); /* reset to the 2nd keyword in the header */ if (ffgkys(fptr, "EXTNAME", extname, 0, &tstatus) <= 0) /* get keyword */ { if (putback) { /* more of the kludge */ /* test if the EXTNAME value ends with a #; if so, chop it */ /* off before comparing the strings */ chopped = 0; slen = strlen(extname); if (extname[slen - 1] == '#') { extname[slen - 1] = '\0'; chopped = 1; } } /* see if the strings are an exact match */ ffcmps(extname, hduname, CASEINSEN, &match, &exact); } /* if EXTNAME keyword doesn't exist, or it does not match, then try HDUNAME */ if (tstatus || !exact) { tstatus = 0; if (ffgkys(fptr, "HDUNAME", extname, 0, &tstatus) <= 0) { if (putback) { /* more of the kludge */ chopped = 0; slen = strlen(extname); if (extname[slen - 1] == '#') { extname[slen - 1] = '\0'; /* chop off the # */ chopped = 1; } } /* see if the strings are an exact match */ ffcmps(extname, hduname, CASEINSEN, &match, &exact); } } if (!tstatus && exact) /* found a matching name */ { if (hduver) /* need to check if version numbers match? */ { if (ffgkyj(fptr, "EXTVER", &extver, 0, &tstatus) > 0) extver = 1; /* assume default EXTVER value */ if ( (int) extver == hduver) { if (chopped) { /* The # was literally part of the name, not a flag */ (fptr->Fptr)->only_one = 0; } return(*status); /* found matching name and vers */ } } else { if (chopped) { /* The # was literally part of the name, not a flag */ (fptr->Fptr)->only_one = 0; } return(*status); /* found matching name */ } } /* end of !tstatus && exact */ } /* end of matching HDU type */ } /* end of loop over HDUs */ } /*--------------------------------------------------------------------------*/ int ffthdu(fitsfile *fptr, /* I - FITS file pointer */ int *nhdu, /* O - number of HDUs in the file */ int *status) /* IO - error status */ /* Return the number of HDUs that currently exist in the file. */ { int ii, extnum, tstatus; if (*status > 0) return(*status); extnum = fptr->HDUposition + 1; /* save the current HDU number */ *nhdu = extnum - 1; /* if the CHDU is empty or not completely defined, just return */ if ((fptr->Fptr)->datastart == DATA_UNDEFINED) return(*status); tstatus = 0; /* loop until EOF */ for (ii=extnum; ffmahd(fptr, ii, 0, &tstatus) <= 0; ii++) { *nhdu = ii; } ffmahd(fptr, extnum, 0, status); /* restore orig file position */ return(*status); } /*--------------------------------------------------------------------------*/ int ffgext(fitsfile *fptr, /* I - FITS file pointer */ int hdunum, /* I - no. of HDU to move get (0 based) */ int *exttype, /* O - type of extension, 0, 1, or 2 */ int *status) /* IO - error status */ /* Get Extension. Move to the specified extension and initialize the HDU structure. */ { int xcurhdu, xmaxhdu; LONGLONG xheadend; if (*status > 0) return(*status); if (ffmbyt(fptr, (fptr->Fptr)->headstart[hdunum], REPORT_EOF, status) <= 0) { /* temporarily save current values, in case of error */ xcurhdu = (fptr->Fptr)->curhdu; xmaxhdu = (fptr->Fptr)->maxhdu; xheadend = (fptr->Fptr)->headend; /* set new parameter values */ (fptr->Fptr)->curhdu = hdunum; fptr->HDUposition = hdunum; (fptr->Fptr)->maxhdu = maxvalue((fptr->Fptr)->maxhdu, hdunum); (fptr->Fptr)->headend = (fptr->Fptr)->logfilesize; /* set max size */ if (ffrhdu(fptr, exttype, status) > 0) { /* failed to get the new HDU, so restore previous values */ (fptr->Fptr)->curhdu = xcurhdu; fptr->HDUposition = xcurhdu; (fptr->Fptr)->maxhdu = xmaxhdu; (fptr->Fptr)->headend = xheadend; } } return(*status); } /*--------------------------------------------------------------------------*/ int ffiblk(fitsfile *fptr, /* I - FITS file pointer */ long nblock, /* I - no. of blocks to insert */ int headdata, /* I - insert where? 0=header, 1=data */ /* -1=beginning of file */ int *status) /* IO - error status */ /* insert 2880-byte blocks at the end of the current header or data unit */ { int tstatus, savehdu, typhdu; LONGLONG insertpt, jpoint; long ii, nshift; char charfill; char buff1[2880], buff2[2880]; char *inbuff, *outbuff, *tmpbuff; char card[FLEN_CARD]; if (*status > 0 || nblock <= 0) return(*status); tstatus = *status; if (headdata == 0 || (fptr->Fptr)->hdutype == ASCII_TBL) charfill = 32; /* headers and ASCII tables have space (32) fill */ else charfill = 0; /* images and binary tables have zero fill */ if (headdata == 0) insertpt = (fptr->Fptr)->datastart; /* insert just before data, or */ else if (headdata == -1) { insertpt = 0; strcpy(card, "XTENSION= 'IMAGE ' / IMAGE extension"); } else /* at end of data, */ { insertpt = (fptr->Fptr)->datastart + (fptr->Fptr)->heapstart + (fptr->Fptr)->heapsize; insertpt = ((insertpt + 2879) / 2880) * 2880; /* start of block */ /* the following formula is wrong because the current data unit may have been extended without updating the headstart value of the following HDU. */ /* insertpt = (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu + 1]; */ } inbuff = buff1; /* set pointers to input and output buffers */ outbuff = buff2; memset(outbuff, charfill, 2880); /* initialize buffer with fill */ if (nblock == 1) /* insert one block */ { if (headdata == -1) ffmrec(fptr, 1, card, status); /* change SIMPLE -> XTENSION */ ffmbyt(fptr, insertpt, REPORT_EOF, status); /* move to 1st point */ ffgbyt(fptr, 2880, inbuff, status); /* read first block of bytes */ while (*status <= 0) { ffmbyt(fptr, insertpt, REPORT_EOF, status); /* insert point */ ffpbyt(fptr, 2880, outbuff, status); /* write the output buffer */ if (*status > 0) return(*status); tmpbuff = inbuff; /* swap input and output pointers */ inbuff = outbuff; outbuff = tmpbuff; insertpt += 2880; /* increment insert point by 1 block */ ffmbyt(fptr, insertpt, REPORT_EOF, status); /* move to next block */ ffgbyt(fptr, 2880, inbuff, status); /* read block of bytes */ } *status = tstatus; /* reset status value */ ffmbyt(fptr, insertpt, IGNORE_EOF, status); /* move back to insert pt */ ffpbyt(fptr, 2880, outbuff, status); /* write the final block */ } else /* inserting more than 1 block */ { savehdu = (fptr->Fptr)->curhdu; /* save the current HDU number */ tstatus = *status; while(*status <= 0) /* find the last HDU in file */ ffmrhd(fptr, 1, &typhdu, status); if (*status == END_OF_FILE) { *status = tstatus; } ffmahd(fptr, savehdu + 1, &typhdu, status); /* move back to CHDU */ if (headdata == -1) ffmrec(fptr, 1, card, status); /* NOW change SIMPLE -> XTENSION */ /* number of 2880-byte blocks that have to be shifted down */ nshift = (long) (((fptr->Fptr)->headstart[(fptr->Fptr)->maxhdu + 1] - insertpt) / 2880); /* position of last block in file to be shifted */ jpoint = (fptr->Fptr)->headstart[(fptr->Fptr)->maxhdu + 1] - 2880; /* move all the blocks starting at end of file working backwards */ for (ii = 0; ii < nshift; ii++) { /* move to the read start position */ if (ffmbyt(fptr, jpoint, REPORT_EOF, status) > 0) return(*status); ffgbyt(fptr, 2880, inbuff,status); /* read one record */ /* move forward to the write postion */ ffmbyt(fptr, jpoint + ((LONGLONG) nblock * 2880), IGNORE_EOF, status); ffpbyt(fptr, 2880, inbuff, status); /* write the record */ jpoint -= 2880; } /* move back to the write start postion (might be EOF) */ ffmbyt(fptr, insertpt, IGNORE_EOF, status); for (ii = 0; ii < nblock; ii++) /* insert correct fill value */ ffpbyt(fptr, 2880, outbuff, status); } if (headdata == 0) /* update data start address */ (fptr->Fptr)->datastart += ((LONGLONG) nblock * 2880); /* update following HDU addresses */ for (ii = (fptr->Fptr)->curhdu; ii <= (fptr->Fptr)->maxhdu; ii++) (fptr->Fptr)->headstart[ii + 1] += ((LONGLONG) nblock * 2880); return(*status); } /*--------------------------------------------------------------------------*/ int ffgkcl(char *tcard) /* Return the type classification of the input header record TYP_STRUC_KEY: SIMPLE, BITPIX, NAXIS, NAXISn, EXTEND, BLOCKED, GROUPS, PCOUNT, GCOUNT, END XTENSION, TFIELDS, TTYPEn, TBCOLn, TFORMn, THEAP, and the first 4 COMMENT keywords in the primary array that define the FITS format. TYP_CMPRS_KEY: The experimental keywords used in the compressed image format ZIMAGE, ZCMPTYPE, ZNAMEn, ZVALn, ZTILEn, ZBITPIX, ZNAXISn, ZSCALE, ZZERO, ZBLANK, EXTNAME = 'COMPRESSED_IMAGE' ZSIMPLE, ZTENSION, ZEXTEND, ZBLOCKED, ZPCOUNT, ZGCOUNT TYP_SCAL_KEY: BSCALE, BZERO, TSCALn, TZEROn TYP_NULL_KEY: BLANK, TNULLn TYP_DIM_KEY: TDIMn TYP_RANG_KEY: TLMINn, TLMAXn, TDMINn, TDMAXn, DATAMIN, DATAMAX TYP_UNIT_KEY: BUNIT, TUNITn TYP_DISP_KEY: TDISPn TYP_HDUID_KEY: EXTNAME, EXTVER, EXTLEVEL, HDUNAME, HDUVER, HDULEVEL TYP_CKSUM_KEY CHECKSUM, DATASUM TYP_WCS_KEY: Primary array: WCAXES, CTYPEn, CUNITn, CRVALn, CRPIXn, CROTAn, CDELTn CDj_is, PVj_ms, LONPOLEs, LATPOLEs Pixel list: TCTYPn, TCTYns, TCUNIn, TCUNns, TCRVLn, TCRVns, TCRPXn, TCRPks, TCDn_k, TCn_ks, TPVn_m, TPn_ms, TCDLTn, TCROTn Bintable vector: jCTYPn, jCTYns, jCUNIn, jCUNns, jCRVLn, jCRVns, iCRPXn, iCRPns, jiCDn, jiCDns, jPVn_m, jPn_ms, jCDLTn, jCROTn TYP_REFSYS_KEY: EQUINOXs, EPOCH, MJD-OBSs, RADECSYS, RADESYSs TYP_COMM_KEY: COMMENT, HISTORY, (blank keyword) TYP_CONT_KEY: CONTINUE TYP_USER_KEY: all other keywords */ { char card[20], *card1, *card5; card[0] = '\0'; strncat(card, tcard, 8); /* copy the keyword name */ strcat(card, " "); /* append blanks to make at least 8 chars long */ ffupch(card); /* make sure it is in upper case */ card1 = card + 1; /* pointer to 2nd character */ card5 = card + 5; /* pointer to 6th character */ /* the strncmp function is slow, so try to be more efficient */ if (*card == 'Z') { if (FSTRNCMP (card1, "IMAGE ", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "CMPTYPE", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "NAME", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_CMPRS_KEY); } else if (FSTRNCMP (card1, "VAL", 3) == 0) { if (*(card + 4) >= '0' && *(card + 4) <= '9') return (TYP_CMPRS_KEY); } else if (FSTRNCMP (card1, "TILE", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_CMPRS_KEY); } else if (FSTRNCMP (card1, "BITPIX ", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "NAXIS", 5) == 0) { if ( ( *(card + 6) >= '0' && *(card + 6) <= '9' ) || (*(card + 6) == ' ') ) return (TYP_CMPRS_KEY); } else if (FSTRNCMP (card1, "SCALE ", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "ZERO ", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "BLANK ", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "SIMPLE ", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "TENSION", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "EXTEND ", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "BLOCKED", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "PCOUNT ", 7) == 0) return (TYP_CMPRS_KEY); else if (FSTRNCMP (card1, "GCOUNT ", 7) == 0) return (TYP_CMPRS_KEY); } else if (*card == ' ') { return (TYP_COMM_KEY); } else if (*card == 'B') { if (FSTRNCMP (card1, "ITPIX ", 7) == 0) return (TYP_STRUC_KEY); if (FSTRNCMP (card1, "LOCKED ", 7) == 0) return (TYP_STRUC_KEY); if (FSTRNCMP (card1, "LANK ", 7) == 0) return (TYP_NULL_KEY); if (FSTRNCMP (card1, "SCALE ", 7) == 0) return (TYP_SCAL_KEY); if (FSTRNCMP (card1, "ZERO ", 7) == 0) return (TYP_SCAL_KEY); if (FSTRNCMP (card1, "UNIT ", 7) == 0) return (TYP_UNIT_KEY); } else if (*card == 'C') { if (FSTRNCMP (card1, "OMMENT",6) == 0) { /* new comment string starting Oct 2001 */ if (FSTRNCMP (tcard, "COMMENT and Astrophysics', volume 376, page 3", 47) == 0) return (TYP_STRUC_KEY); /* original COMMENT strings from 1993 - 2001 */ if (FSTRNCMP (tcard, "COMMENT FITS (Flexible Image Transport System", 47) == 0) return (TYP_STRUC_KEY); if (FSTRNCMP (tcard, "COMMENT Astrophysics Supplement Series v44/p3", 47) == 0) return (TYP_STRUC_KEY); if (FSTRNCMP (tcard, "COMMENT Contact the NASA Science Office of St", 47) == 0) return (TYP_STRUC_KEY); if (FSTRNCMP (tcard, "COMMENT FITS Definition document #100 and oth", 47) == 0) return (TYP_STRUC_KEY); if (*(card + 7) == ' ') return (TYP_COMM_KEY); else return (TYP_USER_KEY); } if (FSTRNCMP (card1, "HECKSUM", 7) == 0) return (TYP_CKSUM_KEY); if (FSTRNCMP (card1, "ONTINUE", 7) == 0) return (TYP_CONT_KEY); if (FSTRNCMP (card1, "TYPE",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "UNIT",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "RVAL",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "RPIX",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "ROTA",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "RDER",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "SYER",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "DELT",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (*card1 == 'D') { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } } else if (*card == 'D') { if (FSTRNCMP (card1, "ATASUM ", 7) == 0) return (TYP_CKSUM_KEY); if (FSTRNCMP (card1, "ATAMIN ", 7) == 0) return (TYP_RANG_KEY); if (FSTRNCMP (card1, "ATAMAX ", 7) == 0) return (TYP_RANG_KEY); if (FSTRNCMP (card1, "ATE-OBS", 7) == 0) return (TYP_REFSYS_KEY); } else if (*card == 'E') { if (FSTRNCMP (card1, "XTEND ", 7) == 0) return (TYP_STRUC_KEY); if (FSTRNCMP (card1, "ND ", 7) == 0) return (TYP_STRUC_KEY); if (FSTRNCMP (card1, "XTNAME ", 7) == 0) { /* check for special compressed image value */ if (FSTRNCMP(tcard, "EXTNAME = 'COMPRESSED_IMAGE'", 28) == 0) return (TYP_CMPRS_KEY); else return (TYP_HDUID_KEY); } if (FSTRNCMP (card1, "XTVER ", 7) == 0) return (TYP_HDUID_KEY); if (FSTRNCMP (card1, "XTLEVEL", 7) == 0) return (TYP_HDUID_KEY); if (FSTRNCMP (card1, "QUINOX", 6) == 0) return (TYP_REFSYS_KEY); if (FSTRNCMP (card1, "QUI",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_REFSYS_KEY); } if (FSTRNCMP (card1, "POCH ", 7) == 0) return (TYP_REFSYS_KEY); } else if (*card == 'G') { if (FSTRNCMP (card1, "COUNT ", 7) == 0) return (TYP_STRUC_KEY); if (FSTRNCMP (card1, "ROUPS ", 7) == 0) return (TYP_STRUC_KEY); } else if (*card == 'H') { if (FSTRNCMP (card1, "DUNAME ", 7) == 0) return (TYP_HDUID_KEY); if (FSTRNCMP (card1, "DUVER ", 7) == 0) return (TYP_HDUID_KEY); if (FSTRNCMP (card1, "DULEVEL", 7) == 0) return (TYP_HDUID_KEY); if (FSTRNCMP (card1, "ISTORY",6) == 0) { if (*(card + 7) == ' ') return (TYP_COMM_KEY); else return (TYP_USER_KEY); } } else if (*card == 'L') { if (FSTRNCMP (card1, "ONPOLE",6) == 0) return (TYP_WCS_KEY); if (FSTRNCMP (card1, "ATPOLE",6) == 0) return (TYP_WCS_KEY); if (FSTRNCMP (card1, "ONP",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "ATP",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } } else if (*card == 'M') { if (FSTRNCMP (card1, "JD-OBS ", 7) == 0) return (TYP_REFSYS_KEY); if (FSTRNCMP (card1, "JDOB",4) == 0) { if (*(card+5) >= '0' && *(card+5) <= '9') return (TYP_REFSYS_KEY); } } else if (*card == 'N') { if (FSTRNCMP (card1, "AXIS", 4) == 0) { if ((*card5 >= '0' && *card5 <= '9') || (*card5 == ' ')) return (TYP_STRUC_KEY); } } else if (*card == 'P') { if (FSTRNCMP (card1, "COUNT ", 7) == 0) return (TYP_STRUC_KEY); if (*card1 == 'C') { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } else if (*card1 == 'V') { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } else if (*card1 == 'S') { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } } else if (*card == 'R') { if (FSTRNCMP (card1, "ADECSYS", 7) == 0) return (TYP_REFSYS_KEY); if (FSTRNCMP (card1, "ADESYS", 6) == 0) return (TYP_REFSYS_KEY); if (FSTRNCMP (card1, "ADE",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_REFSYS_KEY); } } else if (*card == 'S') { if (FSTRNCMP (card1, "IMPLE ", 7) == 0) return (TYP_STRUC_KEY); } else if (*card == 'T') { if (FSTRNCMP (card1, "TYPE", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_STRUC_KEY); } else if (FSTRNCMP (card1, "FORM", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_STRUC_KEY); } else if (FSTRNCMP (card1, "BCOL", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_STRUC_KEY); } else if (FSTRNCMP (card1, "FIELDS ", 7) == 0) return (TYP_STRUC_KEY); else if (FSTRNCMP (card1, "HEAP ", 7) == 0) return (TYP_STRUC_KEY); else if (FSTRNCMP (card1, "NULL", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_NULL_KEY); } else if (FSTRNCMP (card1, "DIM", 3) == 0) { if (*(card + 4) >= '0' && *(card + 4) <= '9') return (TYP_DIM_KEY); } else if (FSTRNCMP (card1, "UNIT", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_UNIT_KEY); } else if (FSTRNCMP (card1, "DISP", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_DISP_KEY); } else if (FSTRNCMP (card1, "SCAL", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_SCAL_KEY); } else if (FSTRNCMP (card1, "ZERO", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_SCAL_KEY); } else if (FSTRNCMP (card1, "LMIN", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_RANG_KEY); } else if (FSTRNCMP (card1, "LMAX", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_RANG_KEY); } else if (FSTRNCMP (card1, "DMIN", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_RANG_KEY); } else if (FSTRNCMP (card1, "DMAX", 4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_RANG_KEY); } else if (FSTRNCMP (card1, "CTYP",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CTY",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CUNI",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CUN",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRVL",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRV",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRPX",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRP",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CROT",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CDLT",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CDE",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRD",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CSY",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "WCS",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "C",1) == 0) { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "P",1) == 0) { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "V",1) == 0) { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "S",1) == 0) { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } } else if (*card == 'X') { if (FSTRNCMP (card1, "TENSION", 7) == 0) return (TYP_STRUC_KEY); } else if (*card == 'W') { if (FSTRNCMP (card1, "CSAXES", 6) == 0) return (TYP_WCS_KEY); if (FSTRNCMP (card1, "CSNAME", 6) == 0) return (TYP_WCS_KEY); if (FSTRNCMP (card1, "CAX", 3) == 0) { if (*(card + 4) >= '0' && *(card + 4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CSN", 3) == 0) { if (*(card + 4) >= '0' && *(card + 4) <= '9') return (TYP_WCS_KEY); } } else if (*card >= '0' && *card <= '9') { if (*card1 == 'C') { if (FSTRNCMP (card1, "CTYP",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CTY",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CUNI",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CUN",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRVL",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRV",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRPX",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRP",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CROT",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CDLT",4) == 0) { if (*card5 >= '0' && *card5 <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CDE",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CRD",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "CSY",3) == 0) { if (*(card+4) >= '0' && *(card+4) <= '9') return (TYP_WCS_KEY); } } else if (FSTRNCMP (card1, "V",1) == 0) { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } else if (FSTRNCMP (card1, "S",1) == 0) { if (*(card + 2) >= '0' && *(card + 2) <= '9') return (TYP_WCS_KEY); } else if (*card1 >= '0' && *card1 <= '9') { /* 2 digits at beginning of keyword */ if ( (*(card + 2) == 'P') && (*(card + 3) == 'C') ) { if (*(card + 4) >= '0' && *(card + 4) <= '9') return (TYP_WCS_KEY); /* ijPCn keyword */ } else if ( (*(card + 2) == 'C') && (*(card + 3) == 'D') ) { if (*(card + 4) >= '0' && *(card + 4) <= '9') return (TYP_WCS_KEY); /* ijCDn keyword */ } } } return (TYP_USER_KEY); /* by default all others are user keywords */ } /*--------------------------------------------------------------------------*/ int ffdtyp(const char *cval, /* I - formatted string representation of the value */ char *dtype, /* O - datatype code: C, L, F, I, or X */ int *status) /* IO - error status */ /* determine implicit datatype of input string. This assumes that the string conforms to the FITS standard for keyword values, so may not detect all invalid formats. */ { if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (cval[0] == '\0') return(*status = VALUE_UNDEFINED); else if (cval[0] == '\'') *dtype = 'C'; /* character string starts with a quote */ else if (cval[0] == 'T' || cval[0] == 'F') *dtype = 'L'; /* logical = T or F character */ else if (cval[0] == '(') *dtype = 'X'; /* complex datatype "(1.2, -3.4)" */ else if (strchr(cval,'.')) *dtype = 'F'; /* float usualy contains a decimal point */ else if (strchr(cval,'E') || strchr(cval,'D') ) *dtype = 'F'; /* exponential contains a E or D */ else *dtype = 'I'; /* if none of the above assume it is integer */ return(*status); } /*--------------------------------------------------------------------------*/ int ffinttyp(char *cval, /* I - formatted string representation of the integer */ int *dtype, /* O - datatype code: TBYTE, TSHORT, TUSHORT, etc */ int *negative, /* O - is cval negative? */ int *status) /* IO - error status */ /* determine implicit datatype of input integer string. This assumes that the string conforms to the FITS standard for integer keyword value, so may not detect all invalid formats. */ { int ii, len; char *p; if (*status > 0) /* inherit input status value if > 0 */ return(*status); *dtype = 0; /* initialize to NULL */ p = cval; if (*p == '+') { p++; /* ignore leading + sign */ } else if (*p == '-') { p++; *negative = 1; /* this is a negative number */ } if (*p == '0') { while (*p == '0') p++; /* skip leading zeros */ if (*p == 0) { /* the value is a string of 1 or more zeros */ *dtype = TSBYTE; return(*status); } } len = strlen(p); for (ii = 0; ii < len; ii++) { if (!isdigit(*(p+ii))) { *status = BAD_INTKEY; return(*status); } } /* check for unambiguous cases, based on length of the string */ if (len == 0) { *status = VALUE_UNDEFINED; } else if (len < 3) { *dtype = TSBYTE; } else if (len == 4) { *dtype = TSHORT; } else if (len > 5 && len < 10) { *dtype = TINT; } else if (len > 10 && len < 19) { *dtype = TLONGLONG; } else if (len > 19) { *status = BAD_INTKEY; } else { if (!(*negative)) { /* positive integers */ if (len == 3) { if (strcmp(p,"127") <= 0 ) { *dtype = TSBYTE; } else if (strcmp(p,"255") <= 0 ) { *dtype = TBYTE; } else { *dtype = TSHORT; } } else if (len == 5) { if (strcmp(p,"32767") <= 0 ) { *dtype = TSHORT; } else if (strcmp(p,"65535") <= 0 ) { *dtype = TUSHORT; } else { *dtype = TINT; } } else if (len == 10) { if (strcmp(p,"2147483647") <= 0 ) { *dtype = TINT; } else if (strcmp(p,"4294967295") <= 0 ) { *dtype = TUINT; } else { *dtype = TLONGLONG; } } else if (len == 19) { if (strcmp(p,"9223372036854775807") <= 0 ) { *dtype = TLONGLONG; } else { *status = BAD_INTKEY; } } } else { /* negative integers */ if (len == 3) { if (strcmp(p,"128") <= 0 ) { *dtype = TSBYTE; } else { *dtype = TSHORT; } } else if (len == 5) { if (strcmp(p,"32768") <= 0 ) { *dtype = TSHORT; } else { *dtype = TINT; } } else if (len == 10) { if (strcmp(p,"2147483648") <= 0 ) { *dtype = TINT; } else { *dtype = TLONGLONG; } } else if (len == 19) { if (strcmp(p,"9223372036854775808") <= 0 ) { *dtype = TLONGLONG; } else { *status = BAD_INTKEY; } } } } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2x(const char *cval, /* I - formatted string representation of the value */ char *dtype, /* O - datatype code: C, L, F, I or X */ /* Only one of the following will be defined, depending on datatype */ long *ival, /* O - integer value */ int *lval, /* O - logical value */ char *sval, /* O - string value */ double *dval, /* O - double value */ int *status) /* IO - error status */ /* high level routine to convert formatted character string to its intrinsic data type */ { ffdtyp(cval, dtype, status); /* determine the datatype */ if (*dtype == 'I') ffc2ii(cval, ival, status); else if (*dtype == 'F') ffc2dd(cval, dval, status); else if (*dtype == 'L') ffc2ll(cval, lval, status); else ffc2s(cval, sval, status); /* C and X formats */ return(*status); } /*--------------------------------------------------------------------------*/ int ffc2xx(const char *cval, /* I - formatted string representation of the value */ char *dtype, /* O - datatype code: C, L, F, I or X */ /* Only one of the following will be defined, depending on datatype */ LONGLONG *ival, /* O - integer value */ int *lval, /* O - logical value */ char *sval, /* O - string value */ double *dval, /* O - double value */ int *status) /* IO - error status */ /* high level routine to convert formatted character string to its intrinsic data type */ { ffdtyp(cval, dtype, status); /* determine the datatype */ if (*dtype == 'I') ffc2jj(cval, ival, status); else if (*dtype == 'F') ffc2dd(cval, dval, status); else if (*dtype == 'L') ffc2ll(cval, lval, status); else ffc2s(cval, sval, status); /* C and X formats */ return(*status); } /*--------------------------------------------------------------------------*/ int ffc2i(const char *cval, /* I - string representation of the value */ long *ival, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert formatted string to an integer value, doing implicit datatype conversion if necessary. */ { char dtype, sval[81], msg[81]; int lval; double dval; if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (cval[0] == '\0') return(*status = VALUE_UNDEFINED); /* null value string */ /* convert the keyword to its native datatype */ ffc2x(cval, &dtype, ival, &lval, sval, &dval, status); if (dtype == 'X' ) { *status = BAD_INTKEY; } else if (dtype == 'C') { /* try reading the string as a number */ if (ffc2dd(sval, &dval, status) <= 0) { if (dval > (double) LONG_MAX || dval < (double) LONG_MIN) *status = NUM_OVERFLOW; else *ival = (long) dval; } } else if (dtype == 'F') { if (dval > (double) LONG_MAX || dval < (double) LONG_MIN) *status = NUM_OVERFLOW; else *ival = (long) dval; } else if (dtype == 'L') { *ival = (long) lval; } if (*status > 0) { *ival = 0; strcpy(msg,"Error in ffc2i evaluating string as an integer: "); strncat(msg,cval,30); ffpmsg(msg); return(*status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2j(const char *cval, /* I - string representation of the value */ LONGLONG *ival, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert formatted string to a LONGLONG integer value, doing implicit datatype conversion if necessary. */ { char dtype, sval[81], msg[81]; int lval; double dval; if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (cval[0] == '\0') return(*status = VALUE_UNDEFINED); /* null value string */ /* convert the keyword to its native datatype */ ffc2xx(cval, &dtype, ival, &lval, sval, &dval, status); if (dtype == 'X' ) { *status = BAD_INTKEY; } else if (dtype == 'C') { /* try reading the string as a number */ if (ffc2dd(sval, &dval, status) <= 0) { if (dval > (double) LONGLONG_MAX || dval < (double) LONGLONG_MIN) *status = NUM_OVERFLOW; else *ival = (LONGLONG) dval; } } else if (dtype == 'F') { if (dval > (double) LONGLONG_MAX || dval < (double) LONGLONG_MIN) *status = NUM_OVERFLOW; else *ival = (LONGLONG) dval; } else if (dtype == 'L') { *ival = (LONGLONG) lval; } if (*status > 0) { *ival = 0; strcpy(msg,"Error in ffc2j evaluating string as a long integer: "); strncat(msg,cval,30); ffpmsg(msg); return(*status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2l(const char *cval, /* I - string representation of the value */ int *lval, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert formatted string to a logical value, doing implicit datatype conversion if necessary */ { char dtype, sval[81], msg[81]; long ival; double dval; if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (cval[0] == '\0') return(*status = VALUE_UNDEFINED); /* null value string */ /* convert the keyword to its native datatype */ ffc2x(cval, &dtype, &ival, lval, sval, &dval, status); if (dtype == 'C' || dtype == 'X' ) *status = BAD_LOGICALKEY; if (*status > 0) { *lval = 0; strcpy(msg,"Error in ffc2l evaluating string as a logical: "); strncat(msg,cval,30); ffpmsg(msg); return(*status); } if (dtype == 'I') { if (ival) *lval = 1; else *lval = 0; } else if (dtype == 'F') { if (dval) *lval = 1; else *lval = 0; } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2r(const char *cval, /* I - string representation of the value */ float *fval, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert formatted string to a real float value, doing implicit datatype conversion if necessary */ { char dtype, sval[81], msg[81]; int lval; if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (cval[0] == '\0') return(*status = VALUE_UNDEFINED); /* null value string */ ffdtyp(cval, &dtype, status); /* determine the datatype */ if (dtype == 'I' || dtype == 'F') ffc2rr(cval, fval, status); else if (dtype == 'L') { ffc2ll(cval, &lval, status); *fval = (float) lval; } else if (dtype == 'C') { /* try reading the string as a number */ ffc2s(cval, sval, status); ffc2rr(sval, fval, status); } else *status = BAD_FLOATKEY; if (*status > 0) { *fval = 0.; strcpy(msg,"Error in ffc2r evaluating string as a float: "); strncat(msg,cval,30); ffpmsg(msg); return(*status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2d(const char *cval, /* I - string representation of the value */ double *dval, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert formatted string to a double value, doing implicit datatype conversion if necessary */ { char dtype, sval[81], msg[81]; int lval; if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (cval[0] == '\0') return(*status = VALUE_UNDEFINED); /* null value string */ ffdtyp(cval, &dtype, status); /* determine the datatype */ if (dtype == 'I' || dtype == 'F') ffc2dd(cval, dval, status); else if (dtype == 'L') { ffc2ll(cval, &lval, status); *dval = (double) lval; } else if (dtype == 'C') { /* try reading the string as a number */ ffc2s(cval, sval, status); ffc2dd(sval, dval, status); } else *status = BAD_DOUBLEKEY; if (*status > 0) { *dval = 0.; strcpy(msg,"Error in ffc2d evaluating string as a double: "); strncat(msg,cval,30); ffpmsg(msg); return(*status); } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2ii(const char *cval, /* I - string representation of the value */ long *ival, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert null-terminated formatted string to an integer value */ { char *loc, msg[81]; if (*status > 0) /* inherit input status value if > 0 */ return(*status); errno = 0; *ival = 0; *ival = strtol(cval, &loc, 10); /* read the string as an integer */ /* check for read error, or junk following the integer */ if (*loc != '\0' && *loc != ' ' ) *status = BAD_C2I; if (errno == ERANGE) { strcpy(msg,"Range Error in ffc2ii converting string to long int: "); strncat(msg,cval,25); ffpmsg(msg); *status = NUM_OVERFLOW; errno = 0; } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2jj(const char *cval, /* I - string representation of the value */ LONGLONG *ival, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert null-terminated formatted string to an long long integer value */ { char *loc, msg[81]; if (*status > 0) /* inherit input status value if > 0 */ return(*status); errno = 0; *ival = 0; #if defined(_MSC_VER) /* Microsoft Visual C++ 6.0 does not have the strtoll function */ *ival = _atoi64(cval); loc = (char *) cval; while (*loc == ' ') loc++; /* skip spaces */ if (*loc == '-') loc++; /* skip minus sign */ if (*loc == '+') loc++; /* skip plus sign */ while (isdigit(*loc)) loc++; /* skip digits */ #elif (USE_LL_SUFFIX == 1) *ival = strtoll(cval, &loc, 10); /* read the string as an integer */ #else *ival = strtol(cval, &loc, 10); /* read the string as an integer */ #endif /* check for read error, or junk following the integer */ if (*loc != '\0' && *loc != ' ' ) *status = BAD_C2I; if (errno == ERANGE) { strcpy(msg,"Range Error in ffc2jj converting string to longlong int: "); strncat(msg,cval,25); ffpmsg(msg); *status = NUM_OVERFLOW; errno = 0; } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2ll(const char *cval, /* I - string representation of the value: T or F */ int *lval, /* O - numerical value of the input string: 1 or 0 */ int *status) /* IO - error status */ /* convert null-terminated formatted string to a logical value */ { if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (cval[0] == 'T') *lval = 1; else *lval = 0; /* any character besides T is considered false */ return(*status); } /*--------------------------------------------------------------------------*/ int ffc2s(const char *instr, /* I - null terminated quoted input string */ char *outstr, /* O - null terminated output string without quotes */ int *status) /* IO - error status */ /* convert an input quoted string to an unquoted string by removing the leading and trailing quote character. Also, replace any pairs of single quote characters with just a single quote character (FITS used a pair of single quotes to represent a literal quote character within the string). */ { int jj; size_t len, ii; if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (instr[0] != '\'') { if (instr[0] == '\0') { outstr[0] = '\0'; return(*status = VALUE_UNDEFINED); /* null value string */ } else { strcpy(outstr, instr); /* no leading quote, so return input string */ return(*status); } } len = strlen(instr); for (ii=1, jj=0; ii < len; ii++, jj++) { if (instr[ii] == '\'') /* is this the closing quote? */ { if (instr[ii+1] == '\'') /* 2 successive quotes? */ ii++; /* copy only one of the quotes */ else break; /* found the closing quote, so exit this loop */ } outstr[jj] = instr[ii]; /* copy the next character to the output */ } outstr[jj] = '\0'; /* terminate the output string */ if (ii == len) { ffpmsg("This string value has no closing quote (ffc2s):"); ffpmsg(instr); return(*status = 205); } for (jj--; jj >= 0; jj--) /* replace trailing blanks with nulls */ { if (outstr[jj] == ' ') outstr[jj] = 0; else break; } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2rr(const char *cval, /* I - string representation of the value */ float *fval, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert null-terminated formatted string to a float value */ { char *loc, msg[81], tval[73]; struct lconv *lcc = 0; static char decimalpt = 0; short *sptr, iret; if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (!decimalpt) { /* only do this once for efficiency */ lcc = localeconv(); /* set structure containing local decimal point symbol */ decimalpt = *(lcc->decimal_point); } errno = 0; *fval = 0.; if (strchr(cval, 'D') || decimalpt == ',') { /* strtod expects a comma, not a period, as the decimal point */ strcpy(tval, cval); /* The C language does not support a 'D'; replace with 'E' */ if ((loc = strchr(tval, 'D'))) *loc = 'E'; if (decimalpt == ',') { /* strtod expects a comma, not a period, as the decimal point */ if ((loc = strchr(tval, '.'))) *loc = ','; } *fval = (float) strtod(tval, &loc); /* read the string as an float */ } else { *fval = (float) strtod(cval, &loc); } /* check for read error, or junk following the value */ if (*loc != '\0' && *loc != ' ' ) { strcpy(msg,"Error in ffc2rr converting string to float: "); strncat(msg,cval,30); ffpmsg(msg); *status = BAD_C2F; } sptr = (short *) fval; #if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS sptr++; /* point to MSBs */ #endif iret = fnan(*sptr); /* if iret == 1, then the float value is a NaN */ if (errno == ERANGE || (iret == 1) ) { strcpy(msg,"Error in ffc2rr converting string to float: "); strncat(msg,cval,30); ffpmsg(msg); *fval = 0.; *status = NUM_OVERFLOW; errno = 0; } return(*status); } /*--------------------------------------------------------------------------*/ int ffc2dd(const char *cval, /* I - string representation of the value */ double *dval, /* O - numerical value of the input string */ int *status) /* IO - error status */ /* convert null-terminated formatted string to a double value */ { char *loc, msg[81], tval[73]; struct lconv *lcc = 0; static char decimalpt = 0; short *sptr, iret; if (*status > 0) /* inherit input status value if > 0 */ return(*status); if (!decimalpt) { /* only do this once for efficiency */ lcc = localeconv(); /* set structure containing local decimal point symbol */ decimalpt = *(lcc->decimal_point); } errno = 0; *dval = 0.; if (strchr(cval, 'D') || decimalpt == ',') { /* need to modify a temporary copy of the string before parsing it */ strcpy(tval, cval); /* The C language does not support a 'D'; replace with 'E' */ if ((loc = strchr(tval, 'D'))) *loc = 'E'; if (decimalpt == ',') { /* strtod expects a comma, not a period, as the decimal point */ if ((loc = strchr(tval, '.'))) *loc = ','; } *dval = strtod(tval, &loc); /* read the string as an double */ } else { *dval = strtod(cval, &loc); } /* check for read error, or junk following the value */ if (*loc != '\0' && *loc != ' ' ) { strcpy(msg,"Error in ffc2dd converting string to double: "); strncat(msg,cval,30); ffpmsg(msg); *status = BAD_C2D; } sptr = (short *) dval; #if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS sptr += 3; /* point to MSBs */ #endif iret = dnan(*sptr); /* if iret == 1, then the double value is a NaN */ if (errno == ERANGE || (iret == 1) ) { strcpy(msg,"Error in ffc2dd converting string to double: "); strncat(msg,cval,30); ffpmsg(msg); *dval = 0.; *status = NUM_OVERFLOW; errno = 0; } return(*status); } healpy-1.10.3/cfitsio/fitsio.h0000664000175000017500000033540113010375005016434 0ustar zoncazonca00000000000000/* The FITSIO software was written by William Pence at the High Energy */ /* Astrophysic Science Archive Research Center (HEASARC) at the NASA */ /* Goddard Space Flight Center. */ /* Copyright (Unpublished--all rights reserved under the copyright laws of the United States), U.S. Government as represented by the Administrator of the National Aeronautics and Space Administration. No copyright is claimed in the United States under Title 17, U.S. Code. Permission to freely use, copy, modify, and distribute this software and its documentation without fee is hereby granted, provided that this copyright notice and disclaimer of warranty appears in all copies. DISCLAIMER: THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND FREEDOM FROM INFRINGEMENT, AND ANY WARRANTY THAT THE DOCUMENTATION WILL CONFORM TO THE SOFTWARE, OR ANY WARRANTY THAT THE SOFTWARE WILL BE ERROR FREE. IN NO EVENT SHALL NASA BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM, OR IN ANY WAY CONNECTED WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY, CONTRACT, TORT , OR OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM, OR AROSE OUT OF THE RESULTS OF, OR USE OF, THE SOFTWARE OR SERVICES PROVIDED HEREUNDER." */ #ifndef _FITSIO_H #define _FITSIO_H #define CFITSIO_VERSION 3.36 #define CFITSIO_MINOR 36 #define CFITSIO_MAJOR 3 #define CFITSIO_SONAME 2 /* the SONAME is incremented in a new release if the binary shared */ /* library (on linux and Mac systems) is not backward compatible */ /* with the previous release of CFITSIO */ /* CFITS_API is defined below for use on Windows systems. */ /* It is used to identify the public functions which should be exported. */ /* This has no effect on non-windows platforms where "WIN32" is not defined */ #if defined (WIN32) #if defined(cfitsio_EXPORTS) #define CFITS_API __declspec(dllexport) #else #define CFITS_API /* __declspec(dllimport) */ #endif /* CFITS_API */ #else /* defined (WIN32) */ #define CFITS_API #endif #include /* the following was provided by Michael Greason (GSFC) to fix a */ /* C/Fortran compatibility problem on an SGI Altix system running */ /* SGI ProPack 4 [this is a Novell SuSE Enterprise 9 derivative] */ /* and using the Intel C++ and Fortran compilers (version 9.1) */ #if defined(__INTEL_COMPILER) && defined(__itanium__) # define mipsFortran 1 # define _MIPS_SZLONG 64 #endif #if defined(linux) || defined(__APPLE__) || defined(__sgi) # include /* apparently needed on debian linux systems */ #endif /* to define off_t */ #include /* apparently needed to define size_t with gcc 2.8.1 */ #include /* needed for LLONG_MAX and INT64_MAX definitions */ /* Define the datatype for variables which store file offset values. */ /* The newer 'off_t' datatype should be used for this purpose, but some */ /* older compilers do not recognize this type, in which case we use 'long' */ /* instead. Note that _OFF_T is defined (or not) in stdio.h depending */ /* on whether _LARGEFILE_SOURCE is defined in sys/feature_tests.h */ /* (at least on Solaris platforms using cc) */ /* Debian systems require: "(defined(linux) && defined(__off_t_defined))" */ /* the mingw-w64 compiler requires: "(defined(__MINGW32__) && defined(_OFF_T_DEFINED))" */ #if defined(_OFF_T) \ || (defined(linux) && defined(__off_t_defined)) \ || (defined(__MINGW32__) && defined(_OFF_T_DEFINED)) \ || defined(_MIPS_SZLONG) || defined(__APPLE__) || defined(_AIX) # define OFF_T off_t #elif defined(_MSC_VER) && (_MSC_VER>= 1400) # define OFF_T long long #else # define OFF_T long #endif /* this block determines if the the string function name is strtol or strtoll, and whether to use %ld or %lld in printf statements */ /* The following 2 cases for that Athon64 were removed on 4 Jan 2006; they appear to be incorrect now that LONGLONG is always typedef'ed to 'long long' || defined(__ia64__) \ || defined(__x86_64__) \ */ #if (defined(__alpha) && ( defined(__unix__) || defined(__NetBSD__) )) \ || defined(__sparcv9) || (defined(__sparc__) && defined(__arch64__)) \ || defined(__powerpc64__) || defined(__64BIT__) \ || (defined(_MIPS_SZLONG) && _MIPS_SZLONG == 64) \ || defined( _MSC_VER)|| defined(__BORLANDC__) # define USE_LL_SUFFIX 0 #else # define USE_LL_SUFFIX 1 #endif /* Determine what 8-byte integer data type is available. 'long long' is now supported by most compilers, but older MS Visual C++ compilers before V7.0 use '__int64' instead. */ #ifndef LONGLONG_TYPE /* this may have been previously defined */ #if defined(_MSC_VER) /* Microsoft Visual C++ */ #if (_MSC_VER < 1300) /* versions earlier than V7.0 do not have 'long long' */ typedef __int64 LONGLONG; #else /* newer versions do support 'long long' */ typedef long long LONGLONG; #endif #elif defined( __BORLANDC__) /* for the Borland 5.5 compiler, in particular */ typedef __int64 LONGLONG; #else typedef long long LONGLONG; #endif #define LONGLONG_TYPE #endif #ifndef LONGLONG_MAX #ifdef LLONG_MAX /* Linux and Solaris definition */ #define LONGLONG_MAX LLONG_MAX #define LONGLONG_MIN LLONG_MIN #elif defined(LONG_LONG_MAX) #define LONGLONG_MAX LONG_LONG_MAX #define LONGLONG_MIN LONG_LONG_MIN #elif defined(__LONG_LONG_MAX__) /* Mac OS X & CYGWIN defintion */ #define LONGLONG_MAX __LONG_LONG_MAX__ #define LONGLONG_MIN (-LONGLONG_MAX -1LL) #elif defined(INT64_MAX) /* windows definition */ #define LONGLONG_MAX INT64_MAX #define LONGLONG_MIN INT64_MIN #elif defined(_I64_MAX) /* windows definition */ #define LONGLONG_MAX _I64_MAX #define LONGLONG_MIN _I64_MIN #elif (defined(__alpha) && ( defined(__unix__) || defined(__NetBSD__) )) \ || defined(__sparcv9) \ || defined(__ia64__) \ || defined(__x86_64__) \ || defined(_SX) \ || defined(__powerpc64__) || defined(__64BIT__) \ || (defined(_MIPS_SZLONG) && _MIPS_SZLONG == 64) /* sizeof(long) = 64 */ #define LONGLONG_MAX 9223372036854775807L /* max 64-bit integer */ #define LONGLONG_MIN (-LONGLONG_MAX -1L) /* min 64-bit integer */ #else /* define a default value, even if it is never used */ #define LONGLONG_MAX 9223372036854775807LL /* max 64-bit integer */ #define LONGLONG_MIN (-LONGLONG_MAX -1LL) /* min 64-bit integer */ #endif #endif /* end of ndef LONGLONG_MAX section */ /* ================================================================= */ /* The following exclusion if __CINT__ is defined is needed for ROOT */ #ifndef __CINT__ #include "longnam.h" #endif #define NIOBUF 40 /* number of IO buffers to create (default = 40) */ /* !! Significantly increasing NIOBUF may degrade performance !! */ #define IOBUFLEN 2880 /* size in bytes of each IO buffer (DONT CHANGE!) */ /* global variables */ #define FLEN_FILENAME 1025 /* max length of a filename */ #define FLEN_KEYWORD 72 /* max length of a keyword (HIERARCH convention) */ #define FLEN_CARD 81 /* length of a FITS header card */ #define FLEN_VALUE 71 /* max length of a keyword value string */ #define FLEN_COMMENT 73 /* max length of a keyword comment string */ #define FLEN_ERRMSG 81 /* max length of a FITSIO error message */ #define FLEN_STATUS 31 /* max length of a FITSIO status text string */ #define TBIT 1 /* codes for FITS table data types */ #define TBYTE 11 #define TSBYTE 12 #define TLOGICAL 14 #define TSTRING 16 #define TUSHORT 20 #define TSHORT 21 #define TUINT 30 #define TINT 31 #define TULONG 40 #define TLONG 41 #define TINT32BIT 41 /* used when returning datatype of a column */ #define TFLOAT 42 #define TLONGLONG 81 #define TDOUBLE 82 #define TCOMPLEX 83 #define TDBLCOMPLEX 163 #define TYP_STRUC_KEY 10 #define TYP_CMPRS_KEY 20 #define TYP_SCAL_KEY 30 #define TYP_NULL_KEY 40 #define TYP_DIM_KEY 50 #define TYP_RANG_KEY 60 #define TYP_UNIT_KEY 70 #define TYP_DISP_KEY 80 #define TYP_HDUID_KEY 90 #define TYP_CKSUM_KEY 100 #define TYP_WCS_KEY 110 #define TYP_REFSYS_KEY 120 #define TYP_COMM_KEY 130 #define TYP_CONT_KEY 140 #define TYP_USER_KEY 150 #define INT32BIT int /* 32-bit integer datatype. Currently this */ /* datatype is an 'int' on all useful platforms */ /* however, it is possible that that are cases */ /* where 'int' is a 2-byte integer, in which case */ /* INT32BIT would need to be defined as 'long'. */ #define BYTE_IMG 8 /* BITPIX code values for FITS image types */ #define SHORT_IMG 16 #define LONG_IMG 32 #define LONGLONG_IMG 64 #define FLOAT_IMG -32 #define DOUBLE_IMG -64 /* The following 2 codes are not true FITS */ /* datatypes; these codes are only used internally */ /* within cfitsio to make it easier for users */ /* to deal with unsigned integers. */ #define SBYTE_IMG 10 #define USHORT_IMG 20 #define ULONG_IMG 40 #define IMAGE_HDU 0 /* Primary Array or IMAGE HDU */ #define ASCII_TBL 1 /* ASCII table HDU */ #define BINARY_TBL 2 /* Binary table HDU */ #define ANY_HDU -1 /* matches any HDU type */ #define READONLY 0 /* options when opening a file */ #define READWRITE 1 /* adopt a hopefully obscure number to use as a null value flag */ /* could be problems if the FITS files contain data with these values */ #define FLOATNULLVALUE -9.11912E-36F #define DOUBLENULLVALUE -9.1191291391491E-36 /* compression algorithm codes */ #define NO_DITHER -1 #define SUBTRACTIVE_DITHER_1 1 #define SUBTRACTIVE_DITHER_2 2 #define MAX_COMPRESS_DIM 6 #define RICE_1 11 #define GZIP_1 21 #define GZIP_2 22 #define PLIO_1 31 #define HCOMPRESS_1 41 #define BZIP2_1 51 /* not publicly supported; only for test purposes */ #define NOCOMPRESS -1 #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif #define CASESEN 1 /* do case-sensitive string match */ #define CASEINSEN 0 /* do case-insensitive string match */ #define GT_ID_ALL_URI 0 /* hierarchical grouping parameters */ #define GT_ID_REF 1 #define GT_ID_POS 2 #define GT_ID_ALL 3 #define GT_ID_REF_URI 11 #define GT_ID_POS_URI 12 #define OPT_RM_GPT 0 #define OPT_RM_ENTRY 1 #define OPT_RM_MBR 2 #define OPT_RM_ALL 3 #define OPT_GCP_GPT 0 #define OPT_GCP_MBR 1 #define OPT_GCP_ALL 2 #define OPT_MCP_ADD 0 #define OPT_MCP_NADD 1 #define OPT_MCP_REPL 2 #define OPT_MCP_MOV 3 #define OPT_MRG_COPY 0 #define OPT_MRG_MOV 1 #define OPT_CMT_MBR 1 #define OPT_CMT_MBR_DEL 11 typedef struct /* structure used to store table column information */ { char ttype[70]; /* column name = FITS TTYPEn keyword; */ LONGLONG tbcol; /* offset in row to first byte of each column */ int tdatatype; /* datatype code of each column */ LONGLONG trepeat; /* repeat count of column; number of elements */ double tscale; /* FITS TSCALn linear scaling factor */ double tzero; /* FITS TZEROn linear scaling zero point */ LONGLONG tnull; /* FITS null value for int image or binary table cols */ char strnull[20]; /* FITS null value string for ASCII table columns */ char tform[10]; /* FITS tform keyword value */ long twidth; /* width of each ASCII table column */ }tcolumn; #define VALIDSTRUC 555 /* magic value used to identify if structure is valid */ typedef struct /* structure used to store basic FITS file information */ { int filehandle; /* handle returned by the file open function */ int driver; /* defines which set of I/O drivers should be used */ int open_count; /* number of opened 'fitsfiles' using this structure */ char *filename; /* file name */ int validcode; /* magic value used to verify that structure is valid */ int only_one; /* flag meaning only copy the specified extension */ LONGLONG filesize; /* current size of the physical disk file in bytes */ LONGLONG logfilesize; /* logical size of file, including unflushed buffers */ int lasthdu; /* is this the last HDU in the file? 0 = no, else yes */ LONGLONG bytepos; /* current logical I/O pointer position in file */ LONGLONG io_pos; /* current I/O pointer position in the physical file */ int curbuf; /* number of I/O buffer currently in use */ int curhdu; /* current HDU number; 0 = primary array */ int hdutype; /* 0 = primary array, 1 = ASCII table, 2 = binary table */ int writemode; /* 0 = readonly, 1 = readwrite */ int maxhdu; /* highest numbered HDU known to exist in the file */ int MAXHDU; /* dynamically allocated dimension of headstart array */ LONGLONG *headstart; /* byte offset in file to start of each HDU */ LONGLONG headend; /* byte offest in file to end of the current HDU header */ LONGLONG ENDpos; /* byte offest to where the END keyword was last written */ LONGLONG nextkey; /* byte offset in file to beginning of next keyword */ LONGLONG datastart; /* byte offset in file to start of the current data unit */ int imgdim; /* dimension of image; cached for fast access */ LONGLONG imgnaxis[99]; /* length of each axis; cached for fast access */ int tfield; /* number of fields in the table (primary array has 2 */ int startcol; /* used by ffgcnn to record starting column number */ LONGLONG origrows; /* original number of rows (value of NAXIS2 keyword) */ LONGLONG numrows; /* number of rows in the table (dynamically updated) */ LONGLONG rowlength; /* length of a table row or image size (bytes) */ tcolumn *tableptr; /* pointer to the table structure */ LONGLONG heapstart; /* heap start byte relative to start of data unit */ LONGLONG heapsize; /* size of the heap, in bytes */ /* the following elements are related to compressed images */ /* these record the 'requested' options to be used when the image is compressed */ int request_compress_type; /* requested image compression algorithm */ long request_tilesize[MAX_COMPRESS_DIM]; /* requested tiling size */ float request_quantize_level; /* requested quantize level */ int request_quantize_method ; /* requested quantizing method */ int request_dither_seed; /* starting offset into the array of random dithering */ int request_lossy_int_compress; /* lossy compress integer image as if float image? */ int request_huge_hdu; /* use '1Q' rather then '1P' variable length arrays */ float request_hcomp_scale; /* requested HCOMPRESS scale factor */ int request_hcomp_smooth; /* requested HCOMPRESS smooth parameter */ /* these record the actual options that were used when the image was compressed */ int compress_type; /* type of compression algorithm */ long tilesize[MAX_COMPRESS_DIM]; /* size of compression tiles */ float quantize_level; /* floating point quantization level */ int quantize_method; /* floating point pixel quantization algorithm */ int dither_seed; /* starting offset into the array of random dithering */ /* other compression parameters */ int compressimg; /* 1 if HDU contains a compressed image, else 0 */ char zcmptype[12]; /* compression type string */ int zbitpix; /* FITS data type of image (BITPIX) */ int zndim; /* dimension of image */ long znaxis[MAX_COMPRESS_DIM]; /* length of each axis */ long maxtilelen; /* max number of pixels in each image tile */ long maxelem; /* maximum byte length of tile compressed arrays */ int cn_compressed; /* column number for COMPRESSED_DATA column */ int cn_uncompressed; /* column number for UNCOMPRESSED_DATA column */ int cn_gzip_data; /* column number for GZIP2 lossless compressed data */ int cn_zscale; /* column number for ZSCALE column */ int cn_zzero; /* column number for ZZERO column */ int cn_zblank; /* column number for the ZBLANK column */ double zscale; /* scaling value, if same for all tiles */ double zzero; /* zero pt, if same for all tiles */ double cn_bscale; /* value of the BSCALE keyword in header */ double cn_bzero; /* value of the BZERO keyword (may be reset) */ double cn_actual_bzero; /* actual value of the BZERO keyword */ int zblank; /* value for null pixels, if not a column */ int rice_blocksize; /* first compression parameter: Rice pixels/block */ int rice_bytepix; /* 2nd compression parameter: Rice bytes/pixel */ float hcomp_scale; /* 1st hcompress compression parameter */ int hcomp_smooth; /* 2nd hcompress compression parameter */ int *tilerow; /* row number of the array of uncompressed tiledata */ long *tiledatasize; /* length of the array of tile data in bytes */ int *tiletype; /* datatype of the array of tile (TINT, TSHORT, etc) */ void **tiledata; /* array of uncompressed tile of data, for row *tilerow */ void **tilenullarray; /* array of optional array of null value flags */ int *tileanynull; /* anynulls in the array of tile? */ char *iobuffer; /* pointer to FITS file I/O buffers */ long bufrecnum[NIOBUF]; /* file record number of each of the buffers */ int dirty[NIOBUF]; /* has the corresponding buffer been modified? */ int ageindex[NIOBUF]; /* relative age of each buffer */ } FITSfile; typedef struct /* structure used to store basic HDU information */ { int HDUposition; /* HDU position in file; 0 = first HDU */ FITSfile *Fptr; /* pointer to FITS file structure */ }fitsfile; typedef struct /* structure for the iterator function column information */ { /* elements required as input to fits_iterate_data: */ fitsfile *fptr; /* pointer to the HDU containing the column */ int colnum; /* column number in the table (use name if < 1) */ char colname[70]; /* name (= TTYPEn value) of the column (optional) */ int datatype; /* output datatype (converted if necessary */ int iotype; /* = InputCol, InputOutputCol, or OutputCol */ /* output elements that may be useful for the work function: */ void *array; /* pointer to the array (and the null value) */ long repeat; /* binary table vector repeat value */ long tlmin; /* legal minimum data value */ long tlmax; /* legal maximum data value */ char tunit[70]; /* physical unit string */ char tdisp[70]; /* suggested display format */ } iteratorCol; #define InputCol 0 /* flag for input only iterator column */ #define InputOutputCol 1 /* flag for input and output iterator column */ #define OutputCol 2 /* flag for output only iterator column */ /*============================================================================= * * The following wtbarr typedef is used in the fits_read_wcstab() routine, * which is intended for use with the WCSLIB library written by Mark * Calabretta, http://www.atnf.csiro.au/~mcalabre/index.html * * In order to maintain WCSLIB and CFITSIO as independent libraries it * was not permissible for any CFITSIO library code to include WCSLIB * header files, or vice versa. However, the CFITSIO function * fits_read_wcstab() accepts an array of structs defined by wcs.h within * WCSLIB. The problem then was to define this struct within fitsio.h * without including wcs.h, especially noting that wcs.h will often (but * not always) be included together with fitsio.h in an applications * program that uses fits_read_wcstab(). * * Of the various possibilities, the solution adopted was for WCSLIB to * define "struct wtbarr" while fitsio.h defines "typedef wtbarr", a * untagged struct with identical members. This allows both wcs.h and * fitsio.h to define a wtbarr data type without conflict by virtue of * the fact that structure tags and typedef names share different * namespaces in C. Therefore, declarations within WCSLIB look like * * struct wtbarr *w; * * while within CFITSIO they are simply * * wtbarr *w; * * but as suggested by the commonality of the names, these are really the * same aggregate data type. However, in passing a (struct wtbarr *) to * fits_read_wcstab() a cast to (wtbarr *) is formally required. *===========================================================================*/ #ifndef WCSLIB_GETWCSTAB #define WCSLIB_GETWCSTAB typedef struct { int i; /* Image axis number. */ int m; /* Array axis number for index vectors. */ int kind; /* Array type, 'c' (coord) or 'i' (index). */ char extnam[72]; /* EXTNAME of binary table extension. */ int extver; /* EXTVER of binary table extension. */ int extlev; /* EXTLEV of binary table extension. */ char ttype[72]; /* TTYPEn of column containing the array. */ long row; /* Table row number. */ int ndim; /* Expected array dimensionality. */ int *dimlen; /* Where to write the array axis lengths. */ double **arrayp; /* Where to write the address of the array */ /* allocated to store the array. */ } wtbarr; int CFITS_API fits_read_wcstab(fitsfile *fptr, int nwtb, wtbarr *wtb, int *status); #endif /* WCSLIB_GETWCSTAB */ /* error status codes */ #define CREATE_DISK_FILE -106 /* create disk file, without extended filename syntax */ #define OPEN_DISK_FILE -105 /* open disk file, without extended filename syntax */ #define SKIP_TABLE -104 /* move to 1st image when opening file */ #define SKIP_IMAGE -103 /* move to 1st table when opening file */ #define SKIP_NULL_PRIMARY -102 /* skip null primary array when opening file */ #define USE_MEM_BUFF -101 /* use memory buffer when opening file */ #define OVERFLOW_ERR -11 /* overflow during datatype conversion */ #define PREPEND_PRIMARY -9 /* used in ffiimg to insert new primary array */ #define SAME_FILE 101 /* input and output files are the same */ #define TOO_MANY_FILES 103 /* tried to open too many FITS files */ #define FILE_NOT_OPENED 104 /* could not open the named file */ #define FILE_NOT_CREATED 105 /* could not create the named file */ #define WRITE_ERROR 106 /* error writing to FITS file */ #define END_OF_FILE 107 /* tried to move past end of file */ #define READ_ERROR 108 /* error reading from FITS file */ #define FILE_NOT_CLOSED 110 /* could not close the file */ #define ARRAY_TOO_BIG 111 /* array dimensions exceed internal limit */ #define READONLY_FILE 112 /* Cannot write to readonly file */ #define MEMORY_ALLOCATION 113 /* Could not allocate memory */ #define BAD_FILEPTR 114 /* invalid fitsfile pointer */ #define NULL_INPUT_PTR 115 /* NULL input pointer to routine */ #define SEEK_ERROR 116 /* error seeking position in file */ #define BAD_URL_PREFIX 121 /* invalid URL prefix on file name */ #define TOO_MANY_DRIVERS 122 /* tried to register too many IO drivers */ #define DRIVER_INIT_FAILED 123 /* driver initialization failed */ #define NO_MATCHING_DRIVER 124 /* matching driver is not registered */ #define URL_PARSE_ERROR 125 /* failed to parse input file URL */ #define RANGE_PARSE_ERROR 126 /* failed to parse input file URL */ #define SHARED_ERRBASE (150) #define SHARED_BADARG (SHARED_ERRBASE + 1) #define SHARED_NULPTR (SHARED_ERRBASE + 2) #define SHARED_TABFULL (SHARED_ERRBASE + 3) #define SHARED_NOTINIT (SHARED_ERRBASE + 4) #define SHARED_IPCERR (SHARED_ERRBASE + 5) #define SHARED_NOMEM (SHARED_ERRBASE + 6) #define SHARED_AGAIN (SHARED_ERRBASE + 7) #define SHARED_NOFILE (SHARED_ERRBASE + 8) #define SHARED_NORESIZE (SHARED_ERRBASE + 9) #define HEADER_NOT_EMPTY 201 /* header already contains keywords */ #define KEY_NO_EXIST 202 /* keyword not found in header */ #define KEY_OUT_BOUNDS 203 /* keyword record number is out of bounds */ #define VALUE_UNDEFINED 204 /* keyword value field is blank */ #define NO_QUOTE 205 /* string is missing the closing quote */ #define BAD_INDEX_KEY 206 /* illegal indexed keyword name */ #define BAD_KEYCHAR 207 /* illegal character in keyword name or card */ #define BAD_ORDER 208 /* required keywords out of order */ #define NOT_POS_INT 209 /* keyword value is not a positive integer */ #define NO_END 210 /* couldn't find END keyword */ #define BAD_BITPIX 211 /* illegal BITPIX keyword value*/ #define BAD_NAXIS 212 /* illegal NAXIS keyword value */ #define BAD_NAXES 213 /* illegal NAXISn keyword value */ #define BAD_PCOUNT 214 /* illegal PCOUNT keyword value */ #define BAD_GCOUNT 215 /* illegal GCOUNT keyword value */ #define BAD_TFIELDS 216 /* illegal TFIELDS keyword value */ #define NEG_WIDTH 217 /* negative table row size */ #define NEG_ROWS 218 /* negative number of rows in table */ #define COL_NOT_FOUND 219 /* column with this name not found in table */ #define BAD_SIMPLE 220 /* illegal value of SIMPLE keyword */ #define NO_SIMPLE 221 /* Primary array doesn't start with SIMPLE */ #define NO_BITPIX 222 /* Second keyword not BITPIX */ #define NO_NAXIS 223 /* Third keyword not NAXIS */ #define NO_NAXES 224 /* Couldn't find all the NAXISn keywords */ #define NO_XTENSION 225 /* HDU doesn't start with XTENSION keyword */ #define NOT_ATABLE 226 /* the CHDU is not an ASCII table extension */ #define NOT_BTABLE 227 /* the CHDU is not a binary table extension */ #define NO_PCOUNT 228 /* couldn't find PCOUNT keyword */ #define NO_GCOUNT 229 /* couldn't find GCOUNT keyword */ #define NO_TFIELDS 230 /* couldn't find TFIELDS keyword */ #define NO_TBCOL 231 /* couldn't find TBCOLn keyword */ #define NO_TFORM 232 /* couldn't find TFORMn keyword */ #define NOT_IMAGE 233 /* the CHDU is not an IMAGE extension */ #define BAD_TBCOL 234 /* TBCOLn keyword value < 0 or > rowlength */ #define NOT_TABLE 235 /* the CHDU is not a table */ #define COL_TOO_WIDE 236 /* column is too wide to fit in table */ #define COL_NOT_UNIQUE 237 /* more than 1 column name matches template */ #define BAD_ROW_WIDTH 241 /* sum of column widths not = NAXIS1 */ #define UNKNOWN_EXT 251 /* unrecognizable FITS extension type */ #define UNKNOWN_REC 252 /* unrecognizable FITS record */ #define END_JUNK 253 /* END keyword is not blank */ #define BAD_HEADER_FILL 254 /* Header fill area not blank */ #define BAD_DATA_FILL 255 /* Data fill area not blank or zero */ #define BAD_TFORM 261 /* illegal TFORM format code */ #define BAD_TFORM_DTYPE 262 /* unrecognizable TFORM datatype code */ #define BAD_TDIM 263 /* illegal TDIMn keyword value */ #define BAD_HEAP_PTR 264 /* invalid BINTABLE heap address */ #define BAD_HDU_NUM 301 /* HDU number < 1 or > MAXHDU */ #define BAD_COL_NUM 302 /* column number < 1 or > tfields */ #define NEG_FILE_POS 304 /* tried to move before beginning of file */ #define NEG_BYTES 306 /* tried to read or write negative bytes */ #define BAD_ROW_NUM 307 /* illegal starting row number in table */ #define BAD_ELEM_NUM 308 /* illegal starting element number in vector */ #define NOT_ASCII_COL 309 /* this is not an ASCII string column */ #define NOT_LOGICAL_COL 310 /* this is not a logical datatype column */ #define BAD_ATABLE_FORMAT 311 /* ASCII table column has wrong format */ #define BAD_BTABLE_FORMAT 312 /* Binary table column has wrong format */ #define NO_NULL 314 /* null value has not been defined */ #define NOT_VARI_LEN 317 /* this is not a variable length column */ #define BAD_DIMEN 320 /* illegal number of dimensions in array */ #define BAD_PIX_NUM 321 /* first pixel number greater than last pixel */ #define ZERO_SCALE 322 /* illegal BSCALE or TSCALn keyword = 0 */ #define NEG_AXIS 323 /* illegal axis length < 1 */ #define NOT_GROUP_TABLE 340 #define HDU_ALREADY_MEMBER 341 #define MEMBER_NOT_FOUND 342 #define GROUP_NOT_FOUND 343 #define BAD_GROUP_ID 344 #define TOO_MANY_HDUS_TRACKED 345 #define HDU_ALREADY_TRACKED 346 #define BAD_OPTION 347 #define IDENTICAL_POINTERS 348 #define BAD_GROUP_ATTACH 349 #define BAD_GROUP_DETACH 350 #define BAD_I2C 401 /* bad int to formatted string conversion */ #define BAD_F2C 402 /* bad float to formatted string conversion */ #define BAD_INTKEY 403 /* can't interprete keyword value as integer */ #define BAD_LOGICALKEY 404 /* can't interprete keyword value as logical */ #define BAD_FLOATKEY 405 /* can't interprete keyword value as float */ #define BAD_DOUBLEKEY 406 /* can't interprete keyword value as double */ #define BAD_C2I 407 /* bad formatted string to int conversion */ #define BAD_C2F 408 /* bad formatted string to float conversion */ #define BAD_C2D 409 /* bad formatted string to double conversion */ #define BAD_DATATYPE 410 /* bad keyword datatype code */ #define BAD_DECIM 411 /* bad number of decimal places specified */ #define NUM_OVERFLOW 412 /* overflow during datatype conversion */ # define DATA_COMPRESSION_ERR 413 /* error in imcompress routines */ # define DATA_DECOMPRESSION_ERR 414 /* error in imcompress routines */ # define NO_COMPRESSED_TILE 415 /* compressed tile doesn't exist */ #define BAD_DATE 420 /* error in date or time conversion */ #define PARSE_SYNTAX_ERR 431 /* syntax error in parser expression */ #define PARSE_BAD_TYPE 432 /* expression did not evaluate to desired type */ #define PARSE_LRG_VECTOR 433 /* vector result too large to return in array */ #define PARSE_NO_OUTPUT 434 /* data parser failed not sent an out column */ #define PARSE_BAD_COL 435 /* bad data encounter while parsing column */ #define PARSE_BAD_OUTPUT 436 /* Output file not of proper type */ #define ANGLE_TOO_BIG 501 /* celestial angle too large for projection */ #define BAD_WCS_VAL 502 /* bad celestial coordinate or pixel value */ #define WCS_ERROR 503 /* error in celestial coordinate calculation */ #define BAD_WCS_PROJ 504 /* unsupported type of celestial projection */ #define NO_WCS_KEY 505 /* celestial coordinate keywords not found */ #define APPROX_WCS_KEY 506 /* approximate WCS keywords were calculated */ #define NO_CLOSE_ERROR 999 /* special value used internally to switch off */ /* the error message from ffclos and ffchdu */ /*------- following error codes are used in the grparser.c file -----------*/ #define NGP_ERRBASE (360) /* base chosen so not to interfere with CFITSIO */ #define NGP_OK (0) #define NGP_NO_MEMORY (NGP_ERRBASE + 0) /* malloc failed */ #define NGP_READ_ERR (NGP_ERRBASE + 1) /* read error from file */ #define NGP_NUL_PTR (NGP_ERRBASE + 2) /* null pointer passed as argument */ #define NGP_EMPTY_CURLINE (NGP_ERRBASE + 3) /* line read seems to be empty */ #define NGP_UNREAD_QUEUE_FULL (NGP_ERRBASE + 4) /* cannot unread more then 1 line (or single line twice) */ #define NGP_INC_NESTING (NGP_ERRBASE + 5) /* too deep include file nesting (inf. loop ?) */ #define NGP_ERR_FOPEN (NGP_ERRBASE + 6) /* fopen() failed, cannot open file */ #define NGP_EOF (NGP_ERRBASE + 7) /* end of file encountered */ #define NGP_BAD_ARG (NGP_ERRBASE + 8) /* bad arguments passed */ #define NGP_TOKEN_NOT_EXPECT (NGP_ERRBASE + 9) /* token not expected here */ /* The following exclusion if __CINT__ is defined is needed for ROOT */ #ifndef __CINT__ /* the following 3 lines are needed to support C++ compilers */ #ifdef __cplusplus extern "C" { #endif #endif int CFITS2Unit( fitsfile *fptr ); CFITS_API fitsfile* CUnit2FITS(int unit); /*---------------- FITS file URL parsing routines -------------*/ int CFITS_API fits_get_token (char **ptr, char *delimiter, char *token, int *isanumber); int CFITS_API fits_get_token2(char **ptr, char *delimiter, char **token, int *isanumber, int *status); char CFITS_API *fits_split_names(char *list); int CFITS_API ffiurl( char *url, char *urltype, char *infile, char *outfile, char *extspec, char *rowfilter, char *binspec, char *colspec, int *status); int CFITS_API ffifile (char *url, char *urltype, char *infile, char *outfile, char *extspec, char *rowfilter, char *binspec, char *colspec, char *pixfilter, int *status); int CFITS_API ffifile2 (char *url, char *urltype, char *infile, char *outfile, char *extspec, char *rowfilter, char *binspec, char *colspec, char *pixfilter, char *compspec, int *status); int CFITS_API ffrtnm(char *url, char *rootname, int *status); int CFITS_API ffexist(const char *infile, int *exists, int *status); int CFITS_API ffexts(char *extspec, int *extnum, char *extname, int *extvers, int *hdutype, char *colname, char *rowexpress, int *status); int CFITS_API ffextn(char *url, int *extension_num, int *status); int CFITS_API ffurlt(fitsfile *fptr, char *urlType, int *status); int CFITS_API ffbins(char *binspec, int *imagetype, int *haxis, char colname[4][FLEN_VALUE], double *minin, double *maxin, double *binsizein, char minname[4][FLEN_VALUE], char maxname[4][FLEN_VALUE], char binname[4][FLEN_VALUE], double *weight, char *wtname, int *recip, int *status); int CFITS_API ffbinr(char **binspec, char *colname, double *minin, double *maxin, double *binsizein, char *minname, char *maxname, char *binname, int *status); int CFITS_API fits_copy_cell2image(fitsfile *fptr, fitsfile *newptr, char *colname, long rownum, int *status); int CFITS_API fits_copy_image2cell(fitsfile *fptr, fitsfile *newptr, char *colname, long rownum, int copykeyflag, int *status); int CFITS_API fits_copy_pixlist2image(fitsfile *infptr, fitsfile *outfptr, int firstkey, /* I - first HDU record number to start with */ int naxis, int *colnum, int *status); int CFITS_API ffimport_file( char *filename, char **contents, int *status ); int CFITS_API ffrwrg( char *rowlist, LONGLONG maxrows, int maxranges, int *numranges, long *minrow, long *maxrow, int *status); int CFITS_API ffrwrgll( char *rowlist, LONGLONG maxrows, int maxranges, int *numranges, LONGLONG *minrow, LONGLONG *maxrow, int *status); /*---------------- FITS file I/O routines -------------*/ int CFITS_API fits_init_cfitsio(void); int CFITS_API ffomem(fitsfile **fptr, const char *name, int mode, void **buffptr, size_t *buffsize, size_t deltasize, void *(*mem_realloc)(void *p, size_t newsize), int *status); int CFITS_API ffopen(fitsfile **fptr, const char *filename, int iomode, int *status); int CFITS_API ffopentest(int soname, fitsfile **fptr, const char *filename, int iomode, int *status); int CFITS_API ffdopn(fitsfile **fptr, const char *filename, int iomode, int *status); int CFITS_API fftopn(fitsfile **fptr, const char *filename, int iomode, int *status); int CFITS_API ffiopn(fitsfile **fptr, const char *filename, int iomode, int *status); int CFITS_API ffdkopn(fitsfile **fptr, const char *filename, int iomode, int *status); int CFITS_API ffreopen(fitsfile *openfptr, fitsfile **newfptr, int *status); int CFITS_API ffinit( fitsfile **fptr, const char *filename, int *status); int CFITS_API ffdkinit(fitsfile **fptr, const char *filename, int *status); int CFITS_API ffimem(fitsfile **fptr, void **buffptr, size_t *buffsize, size_t deltasize, void *(*mem_realloc)(void *p, size_t newsize), int *status); int CFITS_API fftplt(fitsfile **fptr, const char *filename, const char *tempname, int *status); int CFITS_API ffflus(fitsfile *fptr, int *status); int CFITS_API ffflsh(fitsfile *fptr, int clearbuf, int *status); int CFITS_API ffclos(fitsfile *fptr, int *status); int CFITS_API ffdelt(fitsfile *fptr, int *status); int CFITS_API ffflnm(fitsfile *fptr, char *filename, int *status); int CFITS_API ffflmd(fitsfile *fptr, int *filemode, int *status); int CFITS_API fits_delete_iraf_file(const char *filename, int *status); /*---------------- utility routines -------------*/ float CFITS_API ffvers(float *version); void CFITS_API ffupch(char *string); void CFITS_API ffgerr(int status, char *errtext); void CFITS_API ffpmsg(const char *err_message); void CFITS_API ffpmrk(void); int CFITS_API ffgmsg(char *err_message); void CFITS_API ffcmsg(void); void CFITS_API ffcmrk(void); void CFITS_API ffrprt(FILE *stream, int status); void CFITS_API ffcmps(char *templt, char *colname, int casesen, int *match, int *exact); int CFITS_API fftkey(const char *keyword, int *status); int CFITS_API fftrec(char *card, int *status); int CFITS_API ffnchk(fitsfile *fptr, int *status); int CFITS_API ffkeyn(const char *keyroot, int value, char *keyname, int *status); int CFITS_API ffnkey(int value, const char *keyroot, char *keyname, int *status); int CFITS_API ffgkcl(char *card); int CFITS_API ffdtyp(const char *cval, char *dtype, int *status); int CFITS_API ffinttyp(char *cval, int *datatype, int *negative, int *status); int CFITS_API ffpsvc(char *card, char *value, char *comm, int *status); int CFITS_API ffgknm(char *card, char *name, int *length, int *status); int CFITS_API ffgthd(char *tmplt, char *card, int *hdtype, int *status); int CFITS_API ffmkky(const char *keyname, char *keyval, const char *comm, char *card, int *status); int CFITS_API fits_translate_keyword(char *inrec, char *outrec, char *patterns[][2], int npat, int n_value, int n_offset, int n_range, int *pat_num, int *i, int *j, int *m, int *n, int *status); int CFITS_API fits_translate_keywords(fitsfile *infptr, fitsfile *outfptr, int firstkey, char *patterns[][2], int npat, int n_value, int n_offset, int n_range, int *status); int CFITS_API ffasfm(char *tform, int *datacode, long *width, int *decim, int *status); int CFITS_API ffbnfm(char *tform, int *datacode, long *repeat, long *width, int *status); int CFITS_API ffbnfmll(char *tform, int *datacode, LONGLONG *repeat, long *width, int *status); int CFITS_API ffgabc(int tfields, char **tform, int space, long *rowlen, long *tbcol, int *status); int CFITS_API fits_get_section_range(char **ptr,long *secmin,long *secmax,long *incre, int *status); /* ffmbyt should not normally be used in application programs, but it is defined here as a publicly available routine because there are a few rare cases where it is needed */ int CFITS_API ffmbyt(fitsfile *fptr, LONGLONG bytpos, int ignore_err, int *status); /*----------------- write single keywords --------------*/ int CFITS_API ffpky(fitsfile *fptr, int datatype, const char *keyname, void *value, const char *comm, int *status); int CFITS_API ffprec(fitsfile *fptr, const char *card, int *status); int CFITS_API ffpcom(fitsfile *fptr, const char *comm, int *status); int CFITS_API ffpunt(fitsfile *fptr, const char *keyname, const char *unit, int *status); int CFITS_API ffphis(fitsfile *fptr, const char *history, int *status); int CFITS_API ffpdat(fitsfile *fptr, int *status); int CFITS_API ffverifydate(int year, int month, int day, int *status); int CFITS_API ffgstm(char *timestr, int *timeref, int *status); int CFITS_API ffgsdt(int *day, int *month, int *year, int *status); int CFITS_API ffdt2s(int year, int month, int day, char *datestr, int *status); int CFITS_API fftm2s(int year, int month, int day, int hour, int minute, double second, int decimals, char *datestr, int *status); int CFITS_API ffs2dt(char *datestr, int *year, int *month, int *day, int *status); int CFITS_API ffs2tm(char *datestr, int *year, int *month, int *day, int *hour, int *minute, double *second, int *status); int CFITS_API ffpkyu(fitsfile *fptr, const char *keyname, const char *comm, int *status); int CFITS_API ffpkys(fitsfile *fptr, const char *keyname, const char *value, const char *comm,int *status); int CFITS_API ffpkls(fitsfile *fptr, const char *keyname, const char *value, const char *comm,int *status); int CFITS_API ffplsw(fitsfile *fptr, int *status); int CFITS_API ffpkyl(fitsfile *fptr, const char *keyname, int value, const char *comm, int *status); int CFITS_API ffpkyj(fitsfile *fptr, const char *keyname, LONGLONG value, const char *comm, int *status); int CFITS_API ffpkyf(fitsfile *fptr, const char *keyname, float value, int decim, const char *comm, int *status); int CFITS_API ffpkye(fitsfile *fptr, const char *keyname, float value, int decim, const char *comm, int *status); int CFITS_API ffpkyg(fitsfile *fptr, const char *keyname, double value, int decim, const char *comm, int *status); int CFITS_API ffpkyd(fitsfile *fptr, const char *keyname, double value, int decim, const char *comm, int *status); int CFITS_API ffpkyc(fitsfile *fptr, const char *keyname, float *value, int decim, const char *comm, int *status); int CFITS_API ffpkym(fitsfile *fptr, const char *keyname, double *value, int decim, const char *comm, int *status); int CFITS_API ffpkfc(fitsfile *fptr, const char *keyname, float *value, int decim, const char *comm, int *status); int CFITS_API ffpkfm(fitsfile *fptr, const char *keyname, double *value, int decim, const char *comm, int *status); int CFITS_API ffpkyt(fitsfile *fptr, const char *keyname, long intval, double frac, const char *comm, int *status); int CFITS_API ffptdm( fitsfile *fptr, int colnum, int naxis, long naxes[], int *status); int CFITS_API ffptdmll( fitsfile *fptr, int colnum, int naxis, LONGLONG naxes[], int *status); /*----------------- write array of keywords --------------*/ int CFITS_API ffpkns(fitsfile *fptr, const char *keyroot, int nstart, int nkey, char *value[], char *comm[], int *status); int CFITS_API ffpknl(fitsfile *fptr, const char *keyroot, int nstart, int nkey, int *value, char *comm[], int *status); int CFITS_API ffpknj(fitsfile *fptr, const char *keyroot, int nstart, int nkey, long *value, char *comm[], int *status); int CFITS_API ffpknjj(fitsfile *fptr, const char *keyroot, int nstart, int nkey, LONGLONG *value, char *comm[], int *status); int CFITS_API ffpknf(fitsfile *fptr, const char *keyroot, int nstart, int nkey, float *value, int decim, char *comm[], int *status); int CFITS_API ffpkne(fitsfile *fptr, const char *keyroot, int nstart, int nkey, float *value, int decim, char *comm[], int *status); int CFITS_API ffpkng(fitsfile *fptr, const char *keyroot, int nstart, int nkey, double *value, int decim, char *comm[], int *status); int CFITS_API ffpknd(fitsfile *fptr, const char *keyroot, int nstart, int nkey, double *value, int decim, char *comm[], int *status); int CFITS_API ffcpky(fitsfile *infptr,fitsfile *outfptr,int incol,int outcol, char *rootname, int *status); /*----------------- write required header keywords --------------*/ int CFITS_API ffphps( fitsfile *fptr, int bitpix, int naxis, long naxes[], int *status); int CFITS_API ffphpsll( fitsfile *fptr, int bitpix, int naxis, LONGLONG naxes[], int *status); int CFITS_API ffphpr( fitsfile *fptr, int simple, int bitpix, int naxis, long naxes[], LONGLONG pcount, LONGLONG gcount, int extend, int *status); int CFITS_API ffphprll( fitsfile *fptr, int simple, int bitpix, int naxis, LONGLONG naxes[], LONGLONG pcount, LONGLONG gcount, int extend, int *status); int CFITS_API ffphtb(fitsfile *fptr, LONGLONG naxis1, LONGLONG naxis2, int tfields, char **ttype, long *tbcol, char **tform, char **tunit, const char *extname, int *status); int CFITS_API ffphbn(fitsfile *fptr, LONGLONG naxis2, int tfields, char **ttype, char **tform, char **tunit, const char *extname, LONGLONG pcount, int *status); int CFITS_API ffphext( fitsfile *fptr, const char *xtension, int bitpix, int naxis, long naxes[], LONGLONG pcount, LONGLONG gcount, int *status); /*----------------- write template keywords --------------*/ int CFITS_API ffpktp(fitsfile *fptr, const char *filename, int *status); /*------------------ get header information --------------*/ int CFITS_API ffghsp(fitsfile *fptr, int *nexist, int *nmore, int *status); int CFITS_API ffghps(fitsfile *fptr, int *nexist, int *position, int *status); /*------------------ move position in header -------------*/ int CFITS_API ffmaky(fitsfile *fptr, int nrec, int *status); int CFITS_API ffmrky(fitsfile *fptr, int nrec, int *status); /*------------------ read single keywords -----------------*/ int CFITS_API ffgnxk(fitsfile *fptr, char **inclist, int ninc, char **exclist, int nexc, char *card, int *status); int CFITS_API ffgrec(fitsfile *fptr, int nrec, char *card, int *status); int CFITS_API ffgcrd(fitsfile *fptr, const char *keyname, char *card, int *status); int CFITS_API ffgstr(fitsfile *fptr, const char *string, char *card, int *status); int CFITS_API ffgunt(fitsfile *fptr, const char *keyname, char *unit, int *status); int CFITS_API ffgkyn(fitsfile *fptr, int nkey, char *keyname, char *keyval, char *comm, int *status); int CFITS_API ffgkey(fitsfile *fptr, const char *keyname, char *keyval, char *comm, int *status); int CFITS_API ffgky( fitsfile *fptr, int datatype, const char *keyname, void *value, char *comm, int *status); int CFITS_API ffgkys(fitsfile *fptr, const char *keyname, char *value, char *comm, int *status); int CFITS_API ffgkls(fitsfile *fptr, const char *keyname, char **value, char *comm, int *status); int CFITS_API fffree(void *value, int *status); int CFITS_API fffkls(char *value, int *status); int CFITS_API ffgkyl(fitsfile *fptr, const char *keyname, int *value, char *comm, int *status); int CFITS_API ffgkyj(fitsfile *fptr, const char *keyname, long *value, char *comm, int *status); int CFITS_API ffgkyjj(fitsfile *fptr, const char *keyname, LONGLONG *value, char *comm, int *status); int CFITS_API ffgkye(fitsfile *fptr, const char *keyname, float *value, char *comm,int *status); int CFITS_API ffgkyd(fitsfile *fptr, const char *keyname, double *value,char *comm,int *status); int CFITS_API ffgkyc(fitsfile *fptr, const char *keyname, float *value, char *comm,int *status); int CFITS_API ffgkym(fitsfile *fptr, const char *keyname, double *value,char *comm,int *status); int CFITS_API ffgkyt(fitsfile *fptr, const char *keyname, long *ivalue, double *dvalue, char *comm, int *status); int CFITS_API ffgtdm(fitsfile *fptr, int colnum, int maxdim, int *naxis, long naxes[], int *status); int CFITS_API ffgtdmll(fitsfile *fptr, int colnum, int maxdim, int *naxis, LONGLONG naxes[], int *status); int CFITS_API ffdtdm(fitsfile *fptr, char *tdimstr, int colnum, int maxdim, int *naxis, long naxes[], int *status); int CFITS_API ffdtdmll(fitsfile *fptr, char *tdimstr, int colnum, int maxdim, int *naxis, LONGLONG naxes[], int *status); /*------------------ read array of keywords -----------------*/ int CFITS_API ffgkns(fitsfile *fptr, const char *keyname, int nstart, int nmax, char *value[], int *nfound, int *status); int CFITS_API ffgknl(fitsfile *fptr, const char *keyname, int nstart, int nmax, int *value, int *nfound, int *status); int CFITS_API ffgknj(fitsfile *fptr, const char *keyname, int nstart, int nmax, long *value, int *nfound, int *status); int CFITS_API ffgknjj(fitsfile *fptr, const char *keyname, int nstart, int nmax, LONGLONG *value, int *nfound, int *status); int CFITS_API ffgkne(fitsfile *fptr, const char *keyname, int nstart, int nmax, float *value, int *nfound, int *status); int CFITS_API ffgknd(fitsfile *fptr, const char *keyname, int nstart, int nmax, double *value, int *nfound, int *status); int CFITS_API ffh2st(fitsfile *fptr, char **header, int *status); int CFITS_API ffhdr2str( fitsfile *fptr, int exclude_comm, char **exclist, int nexc, char **header, int *nkeys, int *status); int CFITS_API ffcnvthdr2str( fitsfile *fptr, int exclude_comm, char **exclist, int nexc, char **header, int *nkeys, int *status); /*----------------- read required header keywords --------------*/ int CFITS_API ffghpr(fitsfile *fptr, int maxdim, int *simple, int *bitpix, int *naxis, long naxes[], long *pcount, long *gcount, int *extend, int *status); int CFITS_API ffghprll(fitsfile *fptr, int maxdim, int *simple, int *bitpix, int *naxis, LONGLONG naxes[], long *pcount, long *gcount, int *extend, int *status); int CFITS_API ffghtb(fitsfile *fptr,int maxfield, long *naxis1, long *naxis2, int *tfields, char **ttype, long *tbcol, char **tform, char **tunit, char *extname, int *status); int CFITS_API ffghtbll(fitsfile *fptr,int maxfield, LONGLONG *naxis1, LONGLONG *naxis2, int *tfields, char **ttype, LONGLONG *tbcol, char **tform, char **tunit, char *extname, int *status); int CFITS_API ffghbn(fitsfile *fptr, int maxfield, long *naxis2, int *tfields, char **ttype, char **tform, char **tunit, char *extname, long *pcount, int *status); int CFITS_API ffghbnll(fitsfile *fptr, int maxfield, LONGLONG *naxis2, int *tfields, char **ttype, char **tform, char **tunit, char *extname, LONGLONG *pcount, int *status); /*--------------------- update keywords ---------------*/ int CFITS_API ffuky(fitsfile *fptr, int datatype, const char *keyname, void *value, const char *comm, int *status); int CFITS_API ffucrd(fitsfile *fptr, const char *keyname, const char *card, int *status); int CFITS_API ffukyu(fitsfile *fptr, const char *keyname, const char *comm, int *status); int CFITS_API ffukys(fitsfile *fptr, const char *keyname, const char *value, const char *comm, int *status); int CFITS_API ffukls(fitsfile *fptr, const char *keyname, const char *value, const char *comm, int *status); int CFITS_API ffukyl(fitsfile *fptr, const char *keyname, int value, const char *comm, int *status); int CFITS_API ffukyj(fitsfile *fptr, const char *keyname, LONGLONG value, const char *comm, int *status); int CFITS_API ffukyf(fitsfile *fptr, const char *keyname, float value, int decim, const char *comm, int *status); int CFITS_API ffukye(fitsfile *fptr, const char *keyname, float value, int decim, const char *comm, int *status); int CFITS_API ffukyg(fitsfile *fptr, const char *keyname, double value, int decim, const char *comm, int *status); int CFITS_API ffukyd(fitsfile *fptr, const char *keyname, double value, int decim, const char *comm, int *status); int CFITS_API ffukyc(fitsfile *fptr, const char *keyname, float *value, int decim, const char *comm, int *status); int CFITS_API ffukym(fitsfile *fptr, const char *keyname, double *value, int decim, const char *comm, int *status); int CFITS_API ffukfc(fitsfile *fptr, const char *keyname, float *value, int decim, const char *comm, int *status); int CFITS_API ffukfm(fitsfile *fptr, const char *keyname, double *value, int decim, const char *comm, int *status); /*--------------------- modify keywords ---------------*/ int CFITS_API ffmrec(fitsfile *fptr, int nkey, const char *card, int *status); int CFITS_API ffmcrd(fitsfile *fptr, const char *keyname, const char *card, int *status); int CFITS_API ffmnam(fitsfile *fptr, const char *oldname, const char *newname, int *status); int CFITS_API ffmcom(fitsfile *fptr, const char *keyname, const char *comm, int *status); int CFITS_API ffmkyu(fitsfile *fptr, const char *keyname, const char *comm, int *status); int CFITS_API ffmkys(fitsfile *fptr, const char *keyname, const char *value, const char *comm,int *status); int CFITS_API ffmkls(fitsfile *fptr, const char *keyname, const char *value, const char *comm,int *status); int CFITS_API ffmkyl(fitsfile *fptr, const char *keyname, int value, const char *comm, int *status); int CFITS_API ffmkyj(fitsfile *fptr, const char *keyname, LONGLONG value, const char *comm, int *status); int CFITS_API ffmkyf(fitsfile *fptr, const char *keyname, float value, int decim, const char *comm, int *status); int CFITS_API ffmkye(fitsfile *fptr, const char *keyname, float value, int decim, const char *comm, int *status); int CFITS_API ffmkyg(fitsfile *fptr, const char *keyname, double value, int decim, const char *comm, int *status); int CFITS_API ffmkyd(fitsfile *fptr, const char *keyname, double value, int decim, const char *comm, int *status); int CFITS_API ffmkyc(fitsfile *fptr, const char *keyname, float *value, int decim, const char *comm, int *status); int CFITS_API ffmkym(fitsfile *fptr, const char *keyname, double *value, int decim, const char *comm, int *status); int CFITS_API ffmkfc(fitsfile *fptr, const char *keyname, float *value, int decim, const char *comm, int *status); int CFITS_API ffmkfm(fitsfile *fptr, const char *keyname, double *value, int decim, const char *comm, int *status); /*--------------------- insert keywords ---------------*/ int CFITS_API ffirec(fitsfile *fptr, int nkey, const char *card, int *status); int CFITS_API ffikey(fitsfile *fptr, const char *card, int *status); int CFITS_API ffikyu(fitsfile *fptr, const char *keyname, const char *comm, int *status); int CFITS_API ffikys(fitsfile *fptr, const char *keyname, const char *value, const char *comm,int *status); int CFITS_API ffikls(fitsfile *fptr, const char *keyname, const char *value, const char *comm,int *status); int CFITS_API ffikyl(fitsfile *fptr, const char *keyname, int value, const char *comm, int *status); int CFITS_API ffikyj(fitsfile *fptr, const char *keyname, LONGLONG value, const char *comm, int *status); int CFITS_API ffikyf(fitsfile *fptr, const char *keyname, float value, int decim, const char *comm, int *status); int CFITS_API ffikye(fitsfile *fptr, const char *keyname, float value, int decim, const char *comm, int *status); int CFITS_API ffikyg(fitsfile *fptr, const char *keyname, double value, int decim, const char *comm, int *status); int CFITS_API ffikyd(fitsfile *fptr, const char *keyname, double value, int decim, const char *comm, int *status); int CFITS_API ffikyc(fitsfile *fptr, const char *keyname, float *value, int decim, const char *comm, int *status); int CFITS_API ffikym(fitsfile *fptr, const char *keyname, double *value, int decim, const char *comm, int *status); int CFITS_API ffikfc(fitsfile *fptr, const char *keyname, float *value, int decim, const char *comm, int *status); int CFITS_API ffikfm(fitsfile *fptr, const char *keyname, double *value, int decim, const char *comm, int *status); /*--------------------- delete keywords ---------------*/ int CFITS_API ffdkey(fitsfile *fptr, const char *keyname, int *status); int CFITS_API ffdstr(fitsfile *fptr, const char *string, int *status); int CFITS_API ffdrec(fitsfile *fptr, int keypos, int *status); /*--------------------- get HDU information -------------*/ int CFITS_API ffghdn(fitsfile *fptr, int *chdunum); int CFITS_API ffghdt(fitsfile *fptr, int *exttype, int *status); int CFITS_API ffghad(fitsfile *fptr, long *headstart, long *datastart, long *dataend, int *status); int CFITS_API ffghadll(fitsfile *fptr, LONGLONG *headstart, LONGLONG *datastart, LONGLONG *dataend, int *status); int CFITS_API ffghof(fitsfile *fptr, OFF_T *headstart, OFF_T *datastart, OFF_T *dataend, int *status); int CFITS_API ffgipr(fitsfile *fptr, int maxaxis, int *imgtype, int *naxis, long *naxes, int *status); int CFITS_API ffgiprll(fitsfile *fptr, int maxaxis, int *imgtype, int *naxis, LONGLONG *naxes, int *status); int CFITS_API ffgidt(fitsfile *fptr, int *imgtype, int *status); int CFITS_API ffgiet(fitsfile *fptr, int *imgtype, int *status); int CFITS_API ffgidm(fitsfile *fptr, int *naxis, int *status); int CFITS_API ffgisz(fitsfile *fptr, int nlen, long *naxes, int *status); int CFITS_API ffgiszll(fitsfile *fptr, int nlen, LONGLONG *naxes, int *status); /*--------------------- HDU operations -------------*/ int CFITS_API ffmahd(fitsfile *fptr, int hdunum, int *exttype, int *status); int CFITS_API ffmrhd(fitsfile *fptr, int hdumov, int *exttype, int *status); int CFITS_API ffmnhd(fitsfile *fptr, int exttype, char *hduname, int hduvers, int *status); int CFITS_API ffthdu(fitsfile *fptr, int *nhdu, int *status); int CFITS_API ffcrhd(fitsfile *fptr, int *status); int CFITS_API ffcrim(fitsfile *fptr, int bitpix, int naxis, long *naxes, int *status); int CFITS_API ffcrimll(fitsfile *fptr, int bitpix, int naxis, LONGLONG *naxes, int *status); int CFITS_API ffcrtb(fitsfile *fptr, int tbltype, LONGLONG naxis2, int tfields, char **ttype, char **tform, char **tunit, const char *extname, int *status); int CFITS_API ffiimg(fitsfile *fptr, int bitpix, int naxis, long *naxes, int *status); int CFITS_API ffiimgll(fitsfile *fptr, int bitpix, int naxis, LONGLONG *naxes, int *status); int CFITS_API ffitab(fitsfile *fptr, LONGLONG naxis1, LONGLONG naxis2, int tfields, char **ttype, long *tbcol, char **tform, char **tunit, const char *extname, int *status); int CFITS_API ffibin(fitsfile *fptr, LONGLONG naxis2, int tfields, char **ttype, char **tform, char **tunit, const char *extname, LONGLONG pcount, int *status); int CFITS_API ffrsim(fitsfile *fptr, int bitpix, int naxis, long *naxes, int *status); int CFITS_API ffrsimll(fitsfile *fptr, int bitpix, int naxis, LONGLONG *naxes, int *status); int CFITS_API ffdhdu(fitsfile *fptr, int *hdutype, int *status); int CFITS_API ffcopy(fitsfile *infptr, fitsfile *outfptr, int morekeys, int *status); int CFITS_API ffcpfl(fitsfile *infptr, fitsfile *outfptr, int prev, int cur, int follow, int *status); int CFITS_API ffcphd(fitsfile *infptr, fitsfile *outfptr, int *status); int CFITS_API ffcpdt(fitsfile *infptr, fitsfile *outfptr, int *status); int CFITS_API ffchfl(fitsfile *fptr, int *status); int CFITS_API ffcdfl(fitsfile *fptr, int *status); int CFITS_API ffwrhdu(fitsfile *fptr, FILE *outstream, int *status); int CFITS_API ffrdef(fitsfile *fptr, int *status); int CFITS_API ffhdef(fitsfile *fptr, int morekeys, int *status); int CFITS_API ffpthp(fitsfile *fptr, long theap, int *status); int CFITS_API ffcsum(fitsfile *fptr, long nrec, unsigned long *sum, int *status); void CFITS_API ffesum(unsigned long sum, int complm, char *ascii); unsigned long CFITS_API ffdsum(char *ascii, int complm, unsigned long *sum); int CFITS_API ffpcks(fitsfile *fptr, int *status); int CFITS_API ffupck(fitsfile *fptr, int *status); int CFITS_API ffvcks(fitsfile *fptr, int *datastatus, int *hdustatus, int *status); int CFITS_API ffgcks(fitsfile *fptr, unsigned long *datasum, unsigned long *hdusum, int *status); /*--------------------- define scaling or null values -------------*/ int CFITS_API ffpscl(fitsfile *fptr, double scale, double zero, int *status); int CFITS_API ffpnul(fitsfile *fptr, LONGLONG nulvalue, int *status); int CFITS_API fftscl(fitsfile *fptr, int colnum, double scale, double zero, int *status); int CFITS_API fftnul(fitsfile *fptr, int colnum, LONGLONG nulvalue, int *status); int CFITS_API ffsnul(fitsfile *fptr, int colnum, char *nulstring, int *status); /*--------------------- get column information -------------*/ int CFITS_API ffgcno(fitsfile *fptr, int casesen, char *templt, int *colnum, int *status); int CFITS_API ffgcnn(fitsfile *fptr, int casesen, char *templt, char *colname, int *colnum, int *status); int CFITS_API ffgtcl(fitsfile *fptr, int colnum, int *typecode, long *repeat, long *width, int *status); int CFITS_API ffgtclll(fitsfile *fptr, int colnum, int *typecode, LONGLONG *repeat, LONGLONG *width, int *status); int CFITS_API ffeqty(fitsfile *fptr, int colnum, int *typecode, long *repeat, long *width, int *status); int CFITS_API ffeqtyll(fitsfile *fptr, int colnum, int *typecode, LONGLONG *repeat, LONGLONG *width, int *status); int CFITS_API ffgncl(fitsfile *fptr, int *ncols, int *status); int CFITS_API ffgnrw(fitsfile *fptr, long *nrows, int *status); int CFITS_API ffgnrwll(fitsfile *fptr, LONGLONG *nrows, int *status); int CFITS_API ffgacl(fitsfile *fptr, int colnum, char *ttype, long *tbcol, char *tunit, char *tform, double *tscal, double *tzero, char *tnull, char *tdisp, int *status); int CFITS_API ffgbcl(fitsfile *fptr, int colnum, char *ttype, char *tunit, char *dtype, long *repeat, double *tscal, double *tzero, long *tnull, char *tdisp, int *status); int CFITS_API ffgbclll(fitsfile *fptr, int colnum, char *ttype, char *tunit, char *dtype, LONGLONG *repeat, double *tscal, double *tzero, LONGLONG *tnull, char *tdisp, int *status); int CFITS_API ffgrsz(fitsfile *fptr, long *nrows, int *status); int CFITS_API ffgcdw(fitsfile *fptr, int colnum, int *width, int *status); /*--------------------- read primary array or image elements -------------*/ int CFITS_API ffgpxv(fitsfile *fptr, int datatype, long *firstpix, LONGLONG nelem, void *nulval, void *array, int *anynul, int *status); int CFITS_API ffgpxvll(fitsfile *fptr, int datatype, LONGLONG *firstpix, LONGLONG nelem, void *nulval, void *array, int *anynul, int *status); int CFITS_API ffgpxf(fitsfile *fptr, int datatype, long *firstpix, LONGLONG nelem, void *array, char *nullarray, int *anynul, int *status); int CFITS_API ffgpxfll(fitsfile *fptr, int datatype, LONGLONG *firstpix, LONGLONG nelem, void *array, char *nullarray, int *anynul, int *status); int CFITS_API ffgsv(fitsfile *fptr, int datatype, long *blc, long *trc, long *inc, void *nulval, void *array, int *anynul, int *status); int CFITS_API ffgpv(fitsfile *fptr, int datatype, LONGLONG firstelem, LONGLONG nelem, void *nulval, void *array, int *anynul, int *status); int CFITS_API ffgpf(fitsfile *fptr, int datatype, LONGLONG firstelem, LONGLONG nelem, void *array, char *nullarray, int *anynul, int *status); int CFITS_API ffgpvb(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned char nulval, unsigned char *array, int *anynul, int *status); int CFITS_API ffgpvsb(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, signed char nulval, signed char *array, int *anynul, int *status); int CFITS_API ffgpvui(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned short nulval, unsigned short *array, int *anynul, int *status); int CFITS_API ffgpvi(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, short nulval, short *array, int *anynul, int *status); int CFITS_API ffgpvuj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned long nulval, unsigned long *array, int *anynul, int *status); int CFITS_API ffgpvj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, long nulval, long *array, int *anynul, int *status); int CFITS_API ffgpvjj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, LONGLONG nulval, LONGLONG *array, int *anynul, int *status); int CFITS_API ffgpvuk(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned int nulval, unsigned int *array, int *anynul, int *status); int CFITS_API ffgpvk(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, int nulval, int *array, int *anynul, int *status); int CFITS_API ffgpve(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, float nulval, float *array, int *anynul, int *status); int CFITS_API ffgpvd(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, double nulval, double *array, int *anynul, int *status); int CFITS_API ffgpfb(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned char *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfsb(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, signed char *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfui(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned short *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfi(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, short *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfuj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned long *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, long *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfjj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, LONGLONG *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfuk(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned int *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfk(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, int *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfe(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, float *array, char *nularray, int *anynul, int *status); int CFITS_API ffgpfd(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, double *array, char *nularray, int *anynul, int *status); int CFITS_API ffg2db(fitsfile *fptr, long group, unsigned char nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, unsigned char *array, int *anynul, int *status); int CFITS_API ffg2dsb(fitsfile *fptr, long group, signed char nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, signed char *array, int *anynul, int *status); int CFITS_API ffg2dui(fitsfile *fptr, long group, unsigned short nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, unsigned short *array, int *anynul, int *status); int CFITS_API ffg2di(fitsfile *fptr, long group, short nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, short *array, int *anynul, int *status); int CFITS_API ffg2duj(fitsfile *fptr, long group, unsigned long nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, unsigned long *array, int *anynul, int *status); int CFITS_API ffg2dj(fitsfile *fptr, long group, long nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, long *array, int *anynul, int *status); int CFITS_API ffg2djj(fitsfile *fptr, long group, LONGLONG nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, LONGLONG *array, int *anynul, int *status); int CFITS_API ffg2duk(fitsfile *fptr, long group, unsigned int nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, unsigned int *array, int *anynul, int *status); int CFITS_API ffg2dk(fitsfile *fptr, long group, int nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, int *array, int *anynul, int *status); int CFITS_API ffg2de(fitsfile *fptr, long group, float nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, float *array, int *anynul, int *status); int CFITS_API ffg2dd(fitsfile *fptr, long group, double nulval, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, double *array, int *anynul, int *status); int CFITS_API ffg3db(fitsfile *fptr, long group, unsigned char nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, unsigned char *array, int *anynul, int *status); int CFITS_API ffg3dsb(fitsfile *fptr, long group, signed char nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, signed char *array, int *anynul, int *status); int CFITS_API ffg3dui(fitsfile *fptr, long group, unsigned short nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, unsigned short *array, int *anynul, int *status); int CFITS_API ffg3di(fitsfile *fptr, long group, short nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, short *array, int *anynul, int *status); int CFITS_API ffg3duj(fitsfile *fptr, long group, unsigned long nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, unsigned long *array, int *anynul, int *status); int CFITS_API ffg3dj(fitsfile *fptr, long group, long nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, long *array, int *anynul, int *status); int CFITS_API ffg3djj(fitsfile *fptr, long group, LONGLONG nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, LONGLONG *array, int *anynul, int *status); int CFITS_API ffg3duk(fitsfile *fptr, long group, unsigned int nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, unsigned int *array, int *anynul, int *status); int CFITS_API ffg3dk(fitsfile *fptr, long group, int nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, int *array, int *anynul, int *status); int CFITS_API ffg3de(fitsfile *fptr, long group, float nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, float *array, int *anynul, int *status); int CFITS_API ffg3dd(fitsfile *fptr, long group, double nulval, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, double *array, int *anynul, int *status); int CFITS_API ffgsvb(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned char nulval, unsigned char *array, int *anynul, int *status); int CFITS_API ffgsvsb(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, signed char nulval, signed char *array, int *anynul, int *status); int CFITS_API ffgsvui(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned short nulval, unsigned short *array, int *anynul, int *status); int CFITS_API ffgsvi(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, short nulval, short *array, int *anynul, int *status); int CFITS_API ffgsvuj(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned long nulval, unsigned long *array, int *anynul, int *status); int CFITS_API ffgsvj(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, long nulval, long *array, int *anynul, int *status); int CFITS_API ffgsvjj(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, LONGLONG nulval, LONGLONG *array, int *anynul, int *status); int CFITS_API ffgsvuk(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned int nulval, unsigned int *array, int *anynul, int *status); int CFITS_API ffgsvk(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, int nulval, int *array, int *anynul, int *status); int CFITS_API ffgsve(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, float nulval, float *array, int *anynul, int *status); int CFITS_API ffgsvd(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, double nulval, double *array, int *anynul, int *status); int CFITS_API ffgsfb(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned char *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfsb(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, signed char *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfui(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned short *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfi(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, short *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfuj(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned long *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfj(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, long *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfjj(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, LONGLONG *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfuk(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, unsigned int *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfk(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, int *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfe(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, float *array, char *flagval, int *anynul, int *status); int CFITS_API ffgsfd(fitsfile *fptr, int colnum, int naxis, long *naxes, long *blc, long *trc, long *inc, double *array, char *flagval, int *anynul, int *status); int CFITS_API ffggpb(fitsfile *fptr, long group, long firstelem, long nelem, unsigned char *array, int *status); int CFITS_API ffggpsb(fitsfile *fptr, long group, long firstelem, long nelem, signed char *array, int *status); int CFITS_API ffggpui(fitsfile *fptr, long group, long firstelem, long nelem, unsigned short *array, int *status); int CFITS_API ffggpi(fitsfile *fptr, long group, long firstelem, long nelem, short *array, int *status); int CFITS_API ffggpuj(fitsfile *fptr, long group, long firstelem, long nelem, unsigned long *array, int *status); int CFITS_API ffggpj(fitsfile *fptr, long group, long firstelem, long nelem, long *array, int *status); int CFITS_API ffggpjj(fitsfile *fptr, long group, long firstelem, long nelem, LONGLONG *array, int *status); int CFITS_API ffggpuk(fitsfile *fptr, long group, long firstelem, long nelem, unsigned int *array, int *status); int CFITS_API ffggpk(fitsfile *fptr, long group, long firstelem, long nelem, int *array, int *status); int CFITS_API ffggpe(fitsfile *fptr, long group, long firstelem, long nelem, float *array, int *status); int CFITS_API ffggpd(fitsfile *fptr, long group, long firstelem, long nelem, double *array, int *status); /*--------------------- read column elements -------------*/ int CFITS_API ffgcv( fitsfile *fptr, int datatype, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, void *nulval, void *array, int *anynul, int *status); int CFITS_API ffgcf( fitsfile *fptr, int datatype, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, void *array, char *nullarray, int *anynul, int *status); int CFITS_API ffgcvs(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char *nulval, char **array, int *anynul, int *status); int CFITS_API ffgcl (fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char *array, int *status); int CFITS_API ffgcvl (fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char nulval, char *array, int *anynul, int *status); int CFITS_API ffgcvb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned char nulval, unsigned char *array, int *anynul, int *status); int CFITS_API ffgcvsb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, signed char nulval, signed char *array, int *anynul, int *status); int CFITS_API ffgcvui(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned short nulval, unsigned short *array, int *anynul, int *status); int CFITS_API ffgcvi(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, short nulval, short *array, int *anynul, int *status); int CFITS_API ffgcvuj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned long nulval, unsigned long *array, int *anynul, int *status); int CFITS_API ffgcvj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long nulval, long *array, int *anynul, int *status); int CFITS_API ffgcvjj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, LONGLONG nulval, LONGLONG *array, int *anynul, int *status); int CFITS_API ffgcvuk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned int nulval, unsigned int *array, int *anynul, int *status); int CFITS_API ffgcvk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int nulval, int *array, int *anynul, int *status); int CFITS_API ffgcve(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, float nulval, float *array, int *anynul, int *status); int CFITS_API ffgcvd(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, double nulval, double *array, int *anynul, int *status); int CFITS_API ffgcvc(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, float nulval, float *array, int *anynul, int *status); int CFITS_API ffgcvm(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, double nulval, double *array, int *anynul, int *status); int CFITS_API ffgcx(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstbit, LONGLONG nbits, char *larray, int *status); int CFITS_API ffgcxui(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG nrows, long firstbit, int nbits, unsigned short *array, int *status); int CFITS_API ffgcxuk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG nrows, long firstbit, int nbits, unsigned int *array, int *status); int CFITS_API ffgcfs(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char **array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfl(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned char *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfsb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, signed char *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfui(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned short *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfi(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, short *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfuj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned long *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfjj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, LONGLONG *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfuk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned int *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfe(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, float *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfd(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, double *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfc(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, float *array, char *nularray, int *anynul, int *status); int CFITS_API ffgcfm(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, double *array, char *nularray, int *anynul, int *status); int CFITS_API ffgdes(fitsfile *fptr, int colnum, LONGLONG rownum, long *length, long *heapaddr, int *status); int CFITS_API ffgdesll(fitsfile *fptr, int colnum, LONGLONG rownum, LONGLONG *length, LONGLONG *heapaddr, int *status); int CFITS_API ffgdess(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG nrows, long *length, long *heapaddr, int *status); int CFITS_API ffgdessll(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG nrows, LONGLONG *length, LONGLONG *heapaddr, int *status); int CFITS_API ffpdes(fitsfile *fptr, int colnum, LONGLONG rownum, LONGLONG length, LONGLONG heapaddr, int *status); int CFITS_API fftheap(fitsfile *fptr, LONGLONG *heapsize, LONGLONG *unused, LONGLONG *overlap, int *valid, int *status); int CFITS_API ffcmph(fitsfile *fptr, int *status); int CFITS_API ffgtbb(fitsfile *fptr, LONGLONG firstrow, LONGLONG firstchar, LONGLONG nchars, unsigned char *values, int *status); int CFITS_API ffgextn(fitsfile *fptr, LONGLONG offset, LONGLONG nelem, void *array, int *status); int CFITS_API ffpextn(fitsfile *fptr, LONGLONG offset, LONGLONG nelem, void *array, int *status); /*------------ write primary array or image elements -------------*/ int CFITS_API ffppx(fitsfile *fptr, int datatype, long *firstpix, LONGLONG nelem, void *array, int *status); int CFITS_API ffppxll(fitsfile *fptr, int datatype, LONGLONG *firstpix, LONGLONG nelem, void *array, int *status); int CFITS_API ffppxn(fitsfile *fptr, int datatype, long *firstpix, LONGLONG nelem, void *array, void *nulval, int *status); int CFITS_API ffppxnll(fitsfile *fptr, int datatype, LONGLONG *firstpix, LONGLONG nelem, void *array, void *nulval, int *status); int CFITS_API ffppr(fitsfile *fptr, int datatype, LONGLONG firstelem, LONGLONG nelem, void *array, int *status); int CFITS_API ffpprb(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned char *array, int *status); int CFITS_API ffpprsb(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, signed char *array, int *status); int CFITS_API ffpprui(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned short *array, int *status); int CFITS_API ffppri(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, short *array, int *status); int CFITS_API ffppruj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned long *array, int *status); int CFITS_API ffpprj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, long *array, int *status); int CFITS_API ffppruk(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned int *array, int *status); int CFITS_API ffpprk(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, int *array, int *status); int CFITS_API ffppre(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, float *array, int *status); int CFITS_API ffpprd(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, double *array, int *status); int CFITS_API ffpprjj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, LONGLONG *array, int *status); int CFITS_API ffppru(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, int *status); int CFITS_API ffpprn(fitsfile *fptr, LONGLONG firstelem, LONGLONG nelem, int *status); int CFITS_API ffppn(fitsfile *fptr, int datatype, LONGLONG firstelem, LONGLONG nelem, void *array, void *nulval, int *status); int CFITS_API ffppnb(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned char *array, unsigned char nulval, int *status); int CFITS_API ffppnsb(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, signed char *array, signed char nulval, int *status); int CFITS_API ffppnui(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned short *array, unsigned short nulval, int *status); int CFITS_API ffppni(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, short *array, short nulval, int *status); int CFITS_API ffppnj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, long *array, long nulval, int *status); int CFITS_API ffppnuj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned long *array, unsigned long nulval, int *status); int CFITS_API ffppnuk(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, unsigned int *array, unsigned int nulval, int *status); int CFITS_API ffppnk(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, int *array, int nulval, int *status); int CFITS_API ffppne(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, float *array, float nulval, int *status); int CFITS_API ffppnd(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, double *array, double nulval, int *status); int CFITS_API ffppnjj(fitsfile *fptr, long group, LONGLONG firstelem, LONGLONG nelem, LONGLONG *array, LONGLONG nulval, int *status); int CFITS_API ffp2db(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, unsigned char *array, int *status); int CFITS_API ffp2dsb(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, signed char *array, int *status); int CFITS_API ffp2dui(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, unsigned short *array, int *status); int CFITS_API ffp2di(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, short *array, int *status); int CFITS_API ffp2duj(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, unsigned long *array, int *status); int CFITS_API ffp2dj(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, long *array, int *status); int CFITS_API ffp2duk(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, unsigned int *array, int *status); int CFITS_API ffp2dk(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, int *array, int *status); int CFITS_API ffp2de(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, float *array, int *status); int CFITS_API ffp2dd(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, double *array, int *status); int CFITS_API ffp2djj(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG naxis1, LONGLONG naxis2, LONGLONG *array, int *status); int CFITS_API ffp3db(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, unsigned char *array, int *status); int CFITS_API ffp3dsb(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, signed char *array, int *status); int CFITS_API ffp3dui(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, unsigned short *array, int *status); int CFITS_API ffp3di(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, short *array, int *status); int CFITS_API ffp3duj(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, unsigned long *array, int *status); int CFITS_API ffp3dj(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, long *array, int *status); int CFITS_API ffp3duk(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, unsigned int *array, int *status); int CFITS_API ffp3dk(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, int *array, int *status); int CFITS_API ffp3de(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, float *array, int *status); int CFITS_API ffp3dd(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, double *array, int *status); int CFITS_API ffp3djj(fitsfile *fptr, long group, LONGLONG ncols, LONGLONG nrows, LONGLONG naxis1, LONGLONG naxis2, LONGLONG naxis3, LONGLONG *array, int *status); int CFITS_API ffpss(fitsfile *fptr, int datatype, long *fpixel, long *lpixel, void *array, int *status); int CFITS_API ffpssb(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, unsigned char *array, int *status); int CFITS_API ffpsssb(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, signed char *array, int *status); int CFITS_API ffpssui(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, unsigned short *array, int *status); int CFITS_API ffpssi(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, short *array, int *status); int CFITS_API ffpssuj(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, unsigned long *array, int *status); int CFITS_API ffpssj(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, long *array, int *status); int CFITS_API ffpssuk(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, unsigned int *array, int *status); int CFITS_API ffpssk(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, int *array, int *status); int CFITS_API ffpsse(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, float *array, int *status); int CFITS_API ffpssd(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, double *array, int *status); int CFITS_API ffpssjj(fitsfile *fptr, long group, long naxis, long *naxes, long *fpixel, long *lpixel, LONGLONG *array, int *status); int CFITS_API ffpgpb(fitsfile *fptr, long group, long firstelem, long nelem, unsigned char *array, int *status); int CFITS_API ffpgpsb(fitsfile *fptr, long group, long firstelem, long nelem, signed char *array, int *status); int CFITS_API ffpgpui(fitsfile *fptr, long group, long firstelem, long nelem, unsigned short *array, int *status); int CFITS_API ffpgpi(fitsfile *fptr, long group, long firstelem, long nelem, short *array, int *status); int CFITS_API ffpgpuj(fitsfile *fptr, long group, long firstelem, long nelem, unsigned long *array, int *status); int CFITS_API ffpgpj(fitsfile *fptr, long group, long firstelem, long nelem, long *array, int *status); int CFITS_API ffpgpuk(fitsfile *fptr, long group, long firstelem, long nelem, unsigned int *array, int *status); int CFITS_API ffpgpk(fitsfile *fptr, long group, long firstelem, long nelem, int *array, int *status); int CFITS_API ffpgpe(fitsfile *fptr, long group, long firstelem, long nelem, float *array, int *status); int CFITS_API ffpgpd(fitsfile *fptr, long group, long firstelem, long nelem, double *array, int *status); int CFITS_API ffpgpjj(fitsfile *fptr, long group, long firstelem, long nelem, LONGLONG *array, int *status); /*--------------------- iterator functions -------------*/ int CFITS_API fits_iter_set_by_name(iteratorCol *col, fitsfile *fptr, char *colname, int datatype, int iotype); int CFITS_API fits_iter_set_by_num(iteratorCol *col, fitsfile *fptr, int colnum, int datatype, int iotype); int CFITS_API fits_iter_set_file(iteratorCol *col, fitsfile *fptr); int CFITS_API fits_iter_set_colname(iteratorCol *col, char *colname); int CFITS_API fits_iter_set_colnum(iteratorCol *col, int colnum); int CFITS_API fits_iter_set_datatype(iteratorCol *col, int datatype); int CFITS_API fits_iter_set_iotype(iteratorCol *col, int iotype); CFITS_API fitsfile * fits_iter_get_file(iteratorCol *col); char CFITS_API * fits_iter_get_colname(iteratorCol *col); int CFITS_API fits_iter_get_colnum(iteratorCol *col); int CFITS_API fits_iter_get_datatype(iteratorCol *col); int CFITS_API fits_iter_get_iotype(iteratorCol *col); void CFITS_API *fits_iter_get_array(iteratorCol *col); long CFITS_API fits_iter_get_tlmin(iteratorCol *col); long CFITS_API fits_iter_get_tlmax(iteratorCol *col); long CFITS_API fits_iter_get_repeat(iteratorCol *col); char CFITS_API *fits_iter_get_tunit(iteratorCol *col); char CFITS_API *fits_iter_get_tdisp(iteratorCol *col); int CFITS_API ffiter(int ncols, iteratorCol *data, long offset, long nPerLoop, int (*workFn)( long totaln, long offset, long firstn, long nvalues, int narrays, iteratorCol *data, void *userPointer), void *userPointer, int *status); /*--------------------- write column elements -------------*/ int CFITS_API ffpcl(fitsfile *fptr, int datatype, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, void *array, int *status); int CFITS_API ffpcls(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char **array, int *status); int CFITS_API ffpcll(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char *array, int *status); int CFITS_API ffpclb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned char *array, int *status); int CFITS_API ffpclsb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, signed char *array, int *status); int CFITS_API ffpclui(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned short *array, int *status); int CFITS_API ffpcli(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, short *array, int *status); int CFITS_API ffpcluj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned long *array, int *status); int CFITS_API ffpclj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long *array, int *status); int CFITS_API ffpcluk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned int *array, int *status); int CFITS_API ffpclk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int *array, int *status); int CFITS_API ffpcle(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, float *array, int *status); int CFITS_API ffpcld(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, double *array, int *status); int CFITS_API ffpclc(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, float *array, int *status); int CFITS_API ffpclm(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, double *array, int *status); int CFITS_API ffpclu(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int *status); int CFITS_API ffprwu(fitsfile *fptr, LONGLONG firstrow, LONGLONG nrows, int *status); int CFITS_API ffpcljj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, LONGLONG *array, int *status); int CFITS_API ffpclx(fitsfile *fptr, int colnum, LONGLONG frow, long fbit, long nbit, char *larray, int *status); int CFITS_API ffpcn(fitsfile *fptr, int datatype, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, void *array, void *nulval, int *status); int CFITS_API ffpcns( fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char **array, char *nulvalue, int *status); int CFITS_API ffpcnl( fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, char *array, char nulvalue, int *status); int CFITS_API ffpcnb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned char *array, unsigned char nulvalue, int *status); int CFITS_API ffpcnsb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, signed char *array, signed char nulvalue, int *status); int CFITS_API ffpcnui(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned short *array, unsigned short nulvalue, int *status); int CFITS_API ffpcni(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, short *array, short nulvalue, int *status); int CFITS_API ffpcnuj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned long *array, unsigned long nulvalue, int *status); int CFITS_API ffpcnj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long *array, long nulvalue, int *status); int CFITS_API ffpcnuk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, unsigned int *array, unsigned int nulvalue, int *status); int CFITS_API ffpcnk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int *array, int nulvalue, int *status); int CFITS_API ffpcne(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, float *array, float nulvalue, int *status); int CFITS_API ffpcnd(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, double *array, double nulvalue, int *status); int CFITS_API ffpcnjj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, LONGLONG *array, LONGLONG nulvalue, int *status); int CFITS_API ffptbb(fitsfile *fptr, LONGLONG firstrow, LONGLONG firstchar, LONGLONG nchars, unsigned char *values, int *status); int CFITS_API ffirow(fitsfile *fptr, LONGLONG firstrow, LONGLONG nrows, int *status); int CFITS_API ffdrow(fitsfile *fptr, LONGLONG firstrow, LONGLONG nrows, int *status); int CFITS_API ffdrrg(fitsfile *fptr, char *ranges, int *status); int CFITS_API ffdrws(fitsfile *fptr, long *rownum, long nrows, int *status); int CFITS_API ffdrwsll(fitsfile *fptr, LONGLONG *rownum, LONGLONG nrows, int *status); int CFITS_API fficol(fitsfile *fptr, int numcol, char *ttype, char *tform, int *status); int CFITS_API fficls(fitsfile *fptr, int firstcol, int ncols, char **ttype, char **tform, int *status); int CFITS_API ffmvec(fitsfile *fptr, int colnum, LONGLONG newveclen, int *status); int CFITS_API ffdcol(fitsfile *fptr, int numcol, int *status); int CFITS_API ffcpcl(fitsfile *infptr, fitsfile *outfptr, int incol, int outcol, int create_col, int *status); int CFITS_API ffcprw(fitsfile *infptr, fitsfile *outfptr, LONGLONG firstrow, LONGLONG nrows, int *status); /*--------------------- WCS Utilities ------------------*/ int CFITS_API ffgics(fitsfile *fptr, double *xrval, double *yrval, double *xrpix, double *yrpix, double *xinc, double *yinc, double *rot, char *type, int *status); int CFITS_API ffgicsa(fitsfile *fptr, char version, double *xrval, double *yrval, double *xrpix, double *yrpix, double *xinc, double *yinc, double *rot, char *type, int *status); int CFITS_API ffgtcs(fitsfile *fptr, int xcol, int ycol, double *xrval, double *yrval, double *xrpix, double *yrpix, double *xinc, double *yinc, double *rot, char *type, int *status); int CFITS_API ffwldp(double xpix, double ypix, double xref, double yref, double xrefpix, double yrefpix, double xinc, double yinc, double rot, char *type, double *xpos, double *ypos, int *status); int CFITS_API ffxypx(double xpos, double ypos, double xref, double yref, double xrefpix, double yrefpix, double xinc, double yinc, double rot, char *type, double *xpix, double *ypix, int *status); /* WCS support routines (provide interface to Doug Mink's WCS library */ int CFITS_API ffgiwcs(fitsfile *fptr, char **header, int *status); int CFITS_API ffgtwcs(fitsfile *fptr, int xcol, int ycol, char **header, int *status); /*--------------------- lexical parsing routines ------------------*/ int CFITS_API fftexp( fitsfile *fptr, char *expr, int maxdim, int *datatype, long *nelem, int *naxis, long *naxes, int *status ); int CFITS_API fffrow( fitsfile *infptr, char *expr, long firstrow, long nrows, long *n_good_rows, char *row_status, int *status); int CFITS_API ffffrw( fitsfile *fptr, char *expr, long *rownum, int *status); int CFITS_API fffrwc( fitsfile *fptr, char *expr, char *timeCol, char *parCol, char *valCol, long ntimes, double *times, char *time_status, int *status ); int CFITS_API ffsrow( fitsfile *infptr, fitsfile *outfptr, char *expr, int *status); int CFITS_API ffcrow( fitsfile *fptr, int datatype, char *expr, long firstrow, long nelements, void *nulval, void *array, int *anynul, int *status ); int CFITS_API ffcalc_rng( fitsfile *infptr, char *expr, fitsfile *outfptr, char *parName, char *parInfo, int nRngs, long *start, long *end, int *status ); int CFITS_API ffcalc( fitsfile *infptr, char *expr, fitsfile *outfptr, char *parName, char *parInfo, int *status ); /* ffhist is not really intended as a user-callable routine */ /* but it may be useful for some specialized applications */ /* ffhist2 is a newer version which is strongly recommended instead of ffhist */ int CFITS_API ffhist(fitsfile **fptr, char *outfile, int imagetype, int naxis, char colname[4][FLEN_VALUE], double *minin, double *maxin, double *binsizein, char minname[4][FLEN_VALUE], char maxname[4][FLEN_VALUE], char binname[4][FLEN_VALUE], double weightin, char wtcol[FLEN_VALUE], int recip, char *rowselect, int *status); int CFITS_API ffhist2(fitsfile **fptr, char *outfile, int imagetype, int naxis, char colname[4][FLEN_VALUE], double *minin, double *maxin, double *binsizein, char minname[4][FLEN_VALUE], char maxname[4][FLEN_VALUE], char binname[4][FLEN_VALUE], double weightin, char wtcol[FLEN_VALUE], int recip, char *rowselect, int *status); int CFITS_API fits_select_image_section(fitsfile **fptr, char *outfile, char *imagesection, int *status); int CFITS_API fits_copy_image_section(fitsfile *infptr, fitsfile *outfile, char *imagesection, int *status); int CFITS_API fits_calc_binning(fitsfile *fptr, int naxis, char colname[4][FLEN_VALUE], double *minin, double *maxin, double *binsizein, char minname[4][FLEN_VALUE], char maxname[4][FLEN_VALUE], char binname[4][FLEN_VALUE], int *colnum, long *haxes, float *amin, float *amax, float *binsize, int *status); int CFITS_API fits_write_keys_histo(fitsfile *fptr, fitsfile *histptr, int naxis, int *colnum, int *status); int CFITS_API fits_rebin_wcs( fitsfile *fptr, int naxis, float *amin, float *binsize, int *status); int CFITS_API fits_make_hist(fitsfile *fptr, fitsfile *histptr, int bitpix,int naxis, long *naxes, int *colnum, float *amin, float *amax, float *binsize, float weight, int wtcolnum, int recip, char *selectrow, int *status); typedef struct { /* input(s) */ int count; char ** path; char ** tag; fitsfile ** ifptr; char * expression; /* output control */ int bitpix; long blank; fitsfile * ofptr; char keyword[FLEN_KEYWORD]; char comment[FLEN_COMMENT]; } PixelFilter; int CFITS_API fits_pixel_filter (PixelFilter * filter, int * status); /*--------------------- grouping routines ------------------*/ int CFITS_API ffgtcr(fitsfile *fptr, char *grpname, int grouptype, int *status); int CFITS_API ffgtis(fitsfile *fptr, char *grpname, int grouptype, int *status); int CFITS_API ffgtch(fitsfile *gfptr, int grouptype, int *status); int CFITS_API ffgtrm(fitsfile *gfptr, int rmopt, int *status); int CFITS_API ffgtcp(fitsfile *infptr, fitsfile *outfptr, int cpopt, int *status); int CFITS_API ffgtmg(fitsfile *infptr, fitsfile *outfptr, int mgopt, int *status); int CFITS_API ffgtcm(fitsfile *gfptr, int cmopt, int *status); int CFITS_API ffgtvf(fitsfile *gfptr, long *firstfailed, int *status); int CFITS_API ffgtop(fitsfile *mfptr,int group,fitsfile **gfptr,int *status); int CFITS_API ffgtam(fitsfile *gfptr, fitsfile *mfptr, int hdupos, int *status); int CFITS_API ffgtnm(fitsfile *gfptr, long *nmembers, int *status); int CFITS_API ffgmng(fitsfile *mfptr, long *nmembers, int *status); int CFITS_API ffgmop(fitsfile *gfptr, long member, fitsfile **mfptr, int *status); int CFITS_API ffgmcp(fitsfile *gfptr, fitsfile *mfptr, long member, int cpopt, int *status); int CFITS_API ffgmtf(fitsfile *infptr, fitsfile *outfptr, long member, int tfopt, int *status); int CFITS_API ffgmrm(fitsfile *fptr, long member, int rmopt, int *status); /*--------------------- group template parser routines ------------------*/ int CFITS_API fits_execute_template(fitsfile *ff, char *ngp_template, int *status); int CFITS_API fits_img_stats_short(short *array,long nx, long ny, int nullcheck, short nullvalue,long *ngoodpix, short *minvalue, short *maxvalue, double *mean, double *sigma, double *noise1, double *noise2, double *noise3, double *noise5, int *status); int CFITS_API fits_img_stats_int(int *array,long nx, long ny, int nullcheck, int nullvalue,long *ngoodpix, int *minvalue, int *maxvalue, double *mean, double *sigma, double *noise1, double *noise2, double *noise3, double *noise5, int *status); int CFITS_API fits_img_stats_float(float *array, long nx, long ny, int nullcheck, float nullvalue,long *ngoodpix, float *minvalue, float *maxvalue, double *mean, double *sigma, double *noise1, double *noise2, double *noise3, double *noise5, int *status); /*--------------------- image compression routines ------------------*/ int CFITS_API fits_set_compression_type(fitsfile *fptr, int ctype, int *status); int CFITS_API fits_set_tile_dim(fitsfile *fptr, int ndim, long *dims, int *status); int CFITS_API fits_set_noise_bits(fitsfile *fptr, int noisebits, int *status); int CFITS_API fits_set_quantize_level(fitsfile *fptr, float qlevel, int *status); int CFITS_API fits_set_hcomp_scale(fitsfile *fptr, float scale, int *status); int CFITS_API fits_set_hcomp_smooth(fitsfile *fptr, int smooth, int *status); int CFITS_API fits_set_quantize_method(fitsfile *fptr, int method, int *status); int CFITS_API fits_set_quantize_dither(fitsfile *fptr, int dither, int *status); int CFITS_API fits_set_dither_seed(fitsfile *fptr, int seed, int *status); int CFITS_API fits_set_dither_offset(fitsfile *fptr, int offset, int *status); int CFITS_API fits_set_lossy_int(fitsfile *fptr, int lossy_int, int *status); int CFITS_API fits_set_huge_hdu(fitsfile *fptr, int huge, int *status); int CFITS_API fits_set_compression_pref(fitsfile *infptr, fitsfile *outfptr, int *status); int CFITS_API fits_get_compression_type(fitsfile *fptr, int *ctype, int *status); int CFITS_API fits_get_tile_dim(fitsfile *fptr, int ndim, long *dims, int *status); int CFITS_API fits_get_quantize_level(fitsfile *fptr, float *qlevel, int *status); int CFITS_API fits_get_noise_bits(fitsfile *fptr, int *noisebits, int *status); int CFITS_API fits_get_hcomp_scale(fitsfile *fptr, float *scale, int *status); int CFITS_API fits_get_hcomp_smooth(fitsfile *fptr, int *smooth, int *status); int CFITS_API fits_get_dither_seed(fitsfile *fptr, int *seed, int *status); int CFITS_API fits_img_compress(fitsfile *infptr, fitsfile *outfptr, int *status); int CFITS_API fits_compress_img(fitsfile *infptr, fitsfile *outfptr, int compress_type, long *tilesize, int parm1, int parm2, int *status); int CFITS_API fits_is_compressed_image(fitsfile *fptr, int *status); int CFITS_API fits_is_reentrant(void); int CFITS_API fits_decompress_img (fitsfile *infptr, fitsfile *outfptr, int *status); int CFITS_API fits_img_decompress_header(fitsfile *infptr, fitsfile *outfptr, int *status); int CFITS_API fits_img_decompress (fitsfile *infptr, fitsfile *outfptr, int *status); /* H-compress routines */ int CFITS_API fits_hcompress(int *a, int nx, int ny, int scale, char *output, long *nbytes, int *status); int CFITS_API fits_hcompress64(LONGLONG *a, int nx, int ny, int scale, char *output, long *nbytes, int *status); int CFITS_API fits_hdecompress(unsigned char *input, int smooth, int *a, int *nx, int *ny, int *scale, int *status); int CFITS_API fits_hdecompress64(unsigned char *input, int smooth, LONGLONG *a, int *nx, int *ny, int *scale, int *status); int CFITS_API fits_compress_table (fitsfile *infptr, fitsfile *outfptr, int *status); int CFITS_API fits_uncompress_table(fitsfile *infptr, fitsfile *outfptr, int *status); /* The following exclusion if __CINT__ is defined is needed for ROOT */ #ifndef __CINT__ #ifdef __cplusplus } #endif #endif #endif healpy-1.10.3/cfitsio/fitsio2.h0000664000175000017500000016327613010375005016527 0ustar zoncazonca00000000000000#ifndef _FITSIO2_H #define _FITSIO2_H #include "fitsio.h" /* Threading support using POSIX threads programming interface (supplied by Bruce O'Neel) All threaded programs MUST have the -D_REENTRANT on the compile line and must link with -lpthread. This means that when one builds cfitsio for threads you must have -D_REENTRANT on the gcc or cc command line. */ #ifdef _REENTRANT #include /* #include not needed any more */ extern pthread_mutex_t Fitsio_Lock; extern int Fitsio_Pthread_Status; #define FFLOCK1(lockname) (Fitsio_Pthread_Status = pthread_mutex_lock(&lockname)) #define FFUNLOCK1(lockname) (Fitsio_Pthread_Status = pthread_mutex_unlock(&lockname)) #define FFLOCK FFLOCK1(Fitsio_Lock) #define FFUNLOCK FFUNLOCK1(Fitsio_Lock) #else #define FFLOCK #define FFUNLOCK #endif /* If REPLACE_LINKS is defined, then whenever CFITSIO fails to open a file with write access because it is a soft link to a file that only has read access, then CFITSIO will attempt to replace the link with a local copy of the file, with write access. This feature was originally added to support the ftools in the Hera environment, where many of the user's data file are soft links. */ #if defined(BUILD_HERA) #define REPLACE_LINKS 1 #endif #define USE_LARGE_VALUE -99 /* flag used when writing images */ #define DBUFFSIZE 28800 /* size of data buffer in bytes */ #define NMAXFILES 1000 /* maximum number of FITS files that can be opened */ /* CFITSIO will allocate (NMAXFILES * 80) bytes of memory */ /* plus each file that is opened will use NIOBUF * 2880 bytes of memeory */ /* where NIOBUF is defined in fitio.h and has a default value of 40 */ #define MINDIRECT 8640 /* minimum size for direct reads and writes */ /* MINDIRECT must have a value >= 8640 */ /* it is useful to identify certain specific types of machines */ #define NATIVE 0 /* machine that uses non-byteswapped IEEE formats */ #define OTHERTYPE 1 /* any other type of machine */ #define VAXVMS 3 /* uses an odd floating point format */ #define ALPHAVMS 4 /* uses an odd floating point format */ #define IBMPC 5 /* used in drvrfile.c to work around a bug on PCs */ #define CRAY 6 /* requires a special NaN test algorithm */ #define GFLOAT 1 /* used for VMS */ #define IEEEFLOAT 2 /* used for VMS */ /* ======================================================================= */ /* The following logic is used to determine the type machine, */ /* whether the bytes are swapped, and the number of bits in a long value */ /* ======================================================================= */ /* The following platforms have sizeof(long) == 8 */ /* This block of code should match a similar block in fitsio.h */ /* and the block of code at the beginning of f77_wrap.h */ #if defined(__alpha) && ( defined(__unix__) || defined(__NetBSD__) ) /* old Dec Alpha platforms running OSF */ #define BYTESWAPPED TRUE #define LONGSIZE 64 #elif defined(__sparcv9) || (defined(__sparc__) && defined(__arch64__)) /* SUN Solaris7 in 64-bit mode */ #define BYTESWAPPED FALSE #define MACHINE NATIVE #define LONGSIZE 64 /* IBM System z mainframe support */ #elif defined(__s390x__) #define BYTESWAPPED FALSE #define LONGSIZE 64 #elif defined(__s390__) #define BYTESWAPPED FALSE #define LONGSIZE 32 #elif defined(__ia64__) || defined(__x86_64__) /* Intel itanium 64-bit PC, or AMD opteron 64-bit PC */ #define BYTESWAPPED TRUE #define LONGSIZE 64 #elif defined(_SX) /* Nec SuperUx */ #define BYTESWAPPED FALSE #define MACHINE NATIVE #define LONGSIZE 64 #elif defined(__powerpc64__) || defined(__64BIT__) /* IBM 64-bit AIX powerpc*/ /* could also test for __ppc64__ or __PPC64 */ #define BYTESWAPPED FALSE #define MACHINE NATIVE #define LONGSIZE 64 #elif defined(_MIPS_SZLONG) # if defined(MIPSEL) # define BYTESWAPPED TRUE # else # define BYTESWAPPED FALSE # define MACHINE NATIVE # endif # if _MIPS_SZLONG == 32 # define LONGSIZE 32 # elif _MIPS_SZLONG == 64 # define LONGSIZE 64 # else # error "can't handle long size given by _MIPS_SZLONG" # endif /* ============================================================== */ /* the following are all 32-bit byteswapped platforms */ #elif defined(vax) && defined(VMS) #define MACHINE VAXVMS #define BYTESWAPPED TRUE #elif defined(__alpha) && defined(__VMS) #if (__D_FLOAT == TRUE) /* this float option is the same as for VAX/VMS machines. */ #define MACHINE VAXVMS #define BYTESWAPPED TRUE #elif (__G_FLOAT == TRUE) /* G_FLOAT is the default for ALPHA VMS systems */ #define MACHINE ALPHAVMS #define BYTESWAPPED TRUE #define FLOATTYPE GFLOAT #elif (__IEEE_FLOAT == TRUE) #define MACHINE ALPHAVMS #define BYTESWAPPED TRUE #define FLOATTYPE IEEEFLOAT #endif /* end of alpha VMS case */ #elif defined(ultrix) && defined(unix) /* old Dec ultrix machines */ #define BYTESWAPPED TRUE #elif defined(__i386) || defined(__i386__) || defined(__i486__) || defined(__i586__) \ || defined(_MSC_VER) || defined(__BORLANDC__) || defined(__TURBOC__) \ || defined(_NI_mswin_) || defined(__EMX__) /* generic 32-bit IBM PC */ #define MACHINE IBMPC #define BYTESWAPPED TRUE #elif defined(__arm__) /* This assumes all ARM are little endian. In the future, it might be */ /* necessary to use "if defined(__ARMEL__)" to distinguish little from big. */ /* (__ARMEL__ would be defined on little-endian, but not on big-endian). */ #define BYTESWAPPED TRUE #elif defined(__tile__) /* 64-core 8x8-architecture Tile64 platform */ #define BYTESWAPPED TRUE #elif defined(__sh__) /* SuperH CPU can be used in both little and big endian modes */ #if defined(__LITTLE_ENDIAN__) #define BYTESWAPPED TRUE #else #define BYTESWAPPED FALSE #endif #else /* assume all other machine uses the same IEEE formats as used in FITS files */ /* e.g., Macs fall into this category */ #define MACHINE NATIVE #define BYTESWAPPED FALSE #endif #ifndef MACHINE #define MACHINE OTHERTYPE #endif /* assume longs are 4 bytes long, unless previously set otherwise */ #ifndef LONGSIZE #define LONGSIZE 32 #endif /* end of block that determine long size and byte swapping */ /* ==================================================================== */ #define IGNORE_EOF 1 #define REPORT_EOF 0 #define DATA_UNDEFINED -1 #define NULL_UNDEFINED 1234554321 #define ASCII_NULL_UNDEFINED 1 /* indicate no defined null value */ #define maxvalue(A,B) ((A) > (B) ? (A) : (B)) #define minvalue(A,B) ((A) < (B) ? (A) : (B)) /* faster string comparison macros */ #define FSTRCMP(a,b) ((a)[0]<(b)[0]? -1:(a)[0]>(b)[0]?1:strcmp((a),(b))) #define FSTRNCMP(a,b,n) ((a)[0]<(b)[0]?-1:(a)[0]>(b)[0]?1:strncmp((a),(b),(n))) #if defined(__VMS) || defined(VMS) #define FNANMASK 0xFFFF /* mask all bits */ #define DNANMASK 0xFFFF /* mask all bits */ #else #define FNANMASK 0x7F80 /* mask bits 1 - 8; all set on NaNs */ /* all 0 on underflow or 0. */ #define DNANMASK 0x7FF0 /* mask bits 1 - 11; all set on NaNs */ /* all 0 on underflow or 0. */ #endif #if MACHINE == CRAY /* Cray machines: the large negative integer corresponds to the 3 most sig digits set to 1. If these 3 bits are set in a floating point number (64 bits), then it represents a reserved value (i.e., a NaN) */ #define fnan(L) ( (L) >= 0xE000000000000000 ? 1 : 0) ) #else /* these functions work for both big and little endian machines */ /* that use the IEEE floating point format for internal numbers */ /* These functions tests whether the float value is a reserved IEEE */ /* value such as a Not-a-Number (NaN), or underflow, overflow, or */ /* infinity. The functions returns 1 if the value is a NaN, overflow */ /* or infinity; it returns 2 if the value is an denormalized underflow */ /* value; otherwise it returns 0. fnan tests floats, dnan tests doubles */ #define fnan(L) \ ( (L & FNANMASK) == FNANMASK ? 1 : (L & FNANMASK) == 0 ? 2 : 0) #define dnan(L) \ ( (L & DNANMASK) == DNANMASK ? 1 : (L & DNANMASK) == 0 ? 2 : 0) #endif #define DSCHAR_MAX 127.49 /* max double value that fits in an signed char */ #define DSCHAR_MIN -128.49 /* min double value that fits in an signed char */ #define DUCHAR_MAX 255.49 /* max double value that fits in an unsigned char */ #define DUCHAR_MIN -0.49 /* min double value that fits in an unsigned char */ #define DUSHRT_MAX 65535.49 /* max double value that fits in a unsigned short*/ #define DUSHRT_MIN -0.49 /* min double value that fits in an unsigned short */ #define DSHRT_MAX 32767.49 /* max double value that fits in a short */ #define DSHRT_MIN -32768.49 /* min double value that fits in a short */ #if LONGSIZE == 32 # define DLONG_MAX 2147483647.49 /* max double value that fits in a long */ # define DLONG_MIN -2147483648.49 /* min double value that fits in a long */ # define DULONG_MAX 4294967295.49 /* max double that fits in a unsigned long */ #else # define DLONG_MAX 9.2233720368547752E18 /* max double value long */ # define DLONG_MIN -9.2233720368547752E18 /* min double value long */ # define DULONG_MAX 1.84467440737095504E19 /* max double value ulong */ #endif #define DULONG_MIN -0.49 /* min double value that fits in an unsigned long */ #define DLONGLONG_MAX 9.2233720368547755807E18 /* max double value longlong */ #define DLONGLONG_MIN -9.2233720368547755808E18 /* min double value longlong */ #define DUINT_MAX 4294967295.49 /* max dbl that fits in a unsigned 4-byte int */ #define DUINT_MIN -0.49 /* min dbl that fits in an unsigned 4-byte int */ #define DINT_MAX 2147483647.49 /* max double value that fits in a 4-byte int */ #define DINT_MIN -2147483648.49 /* min double value that fits in a 4-byte int */ #ifndef UINT32_MAX #define UINT32_MAX 4294967295U /* max unsigned 32-bit integer */ #endif #ifndef INT32_MAX #define INT32_MAX 2147483647 /* max 32-bit integer */ #endif #ifndef INT32_MIN #define INT32_MIN (-INT32_MAX -1) /* min 32-bit integer */ #endif #define COMPRESS_NULL_VALUE -2147483647 #define N_RANDOM 10000 /* DO NOT CHANGE THIS; used when quantizing real numbers */ int ffgnky(fitsfile *fptr, char *card, int *status); void ffcfmt(char *tform, char *cform); void ffcdsp(char *tform, char *cform); void ffswap2(short *values, long nvalues); void ffswap4(INT32BIT *values, long nvalues); void ffswap8(double *values, long nvalues); int ffi2c(LONGLONG ival, char *cval, int *status); int ffl2c(int lval, char *cval, int *status); int ffs2c(const char *instr, char *outstr, int *status); int ffr2f(float fval, int decim, char *cval, int *status); int ffr2e(float fval, int decim, char *cval, int *status); int ffd2f(double dval, int decim, char *cval, int *status); int ffd2e(double dval, int decim, char *cval, int *status); int ffc2ii(const char *cval, long *ival, int *status); int ffc2jj(const char *cval, LONGLONG *ival, int *status); int ffc2ll(const char *cval, int *lval, int *status); int ffc2rr(const char *cval, float *fval, int *status); int ffc2dd(const char *cval, double *dval, int *status); int ffc2x(const char *cval, char *dtype, long *ival, int *lval, char *sval, double *dval, int *status); int ffc2xx(const char *cval, char *dtype, LONGLONG *ival, int *lval, char *sval, double *dval, int *status); int ffc2s(const char *instr, char *outstr, int *status); int ffc2i(const char *cval, long *ival, int *status); int ffc2j(const char *cval, LONGLONG *ival, int *status); int ffc2r(const char *cval, float *fval, int *status); int ffc2d(const char *cval, double *dval, int *status); int ffc2l(const char *cval, int *lval, int *status); void ffxmsg(int action, char *err_message); int ffgcnt(fitsfile *fptr, char *value, int *status); int ffgtkn(fitsfile *fptr, int numkey, char *keyname, long *value, int *status); int ffgtknjj(fitsfile *fptr, int numkey, char *keyname, LONGLONG *value, int *status); int fftkyn(fitsfile *fptr, int numkey, char *keyname, char *value, int *status); int ffgphd(fitsfile *fptr, int maxdim, int *simple, int *bitpix, int *naxis, LONGLONG naxes[], long *pcount, long *gcount, int *extend, double *bscale, double *bzero, LONGLONG *blank, int *nspace, int *status); int ffgttb(fitsfile *fptr, LONGLONG *rowlen, LONGLONG *nrows, LONGLONG *pcount, long *tfield, int *status); int ffmkey(fitsfile *fptr, const char *card, int *status); /* ffmbyt has been moved to fitsio.h */ int ffgbyt(fitsfile *fptr, LONGLONG nbytes, void *buffer, int *status); int ffpbyt(fitsfile *fptr, LONGLONG nbytes, void *buffer, int *status); int ffgbytoff(fitsfile *fptr, long gsize, long ngroups, long offset, void *buffer, int *status); int ffpbytoff(fitsfile *fptr, long gsize, long ngroups, long offset, void *buffer, int *status); int ffldrc(fitsfile *fptr, long record, int err_mode, int *status); int ffwhbf(fitsfile *fptr, int *nbuff); int ffbfeof(fitsfile *fptr, int *status); int ffbfwt(FITSfile *Fptr, int nbuff, int *status); int ffpxsz(int datatype); int ffourl(char *url, char *urltype, char *outfile, char *tmplfile, char *compspec, int *status); int ffparsecompspec(fitsfile *fptr, char *compspec, int *status); int ffoptplt(fitsfile *fptr, const char *tempname, int *status); int fits_is_this_a_copy(char *urltype); int fits_store_Fptr(FITSfile *Fptr, int *status); int fits_clear_Fptr(FITSfile *Fptr, int *status); int fits_already_open(fitsfile **fptr, char *url, char *urltype, char *infile, char *extspec, char *rowfilter, char *binspec, char *colspec, int mode,int *isopen, int *status); int ffedit_columns(fitsfile **fptr, char *outfile, char *expr, int *status); int fits_get_col_minmax(fitsfile *fptr, int colnum, float *datamin, float *datamax, int *status); int ffwritehisto(long totaln, long offset, long firstn, long nvalues, int narrays, iteratorCol *imagepars, void *userPointer); int ffcalchist(long totalrows, long offset, long firstrow, long nrows, int ncols, iteratorCol *colpars, void *userPointer); int ffrhdu(fitsfile *fptr, int *hdutype, int *status); int ffpinit(fitsfile *fptr, int *status); int ffainit(fitsfile *fptr, int *status); int ffbinit(fitsfile *fptr, int *status); int ffchdu(fitsfile *fptr, int *status); int ffwend(fitsfile *fptr, int *status); int ffpdfl(fitsfile *fptr, int *status); int ffuptf(fitsfile *fptr, int *status); int ffdblk(fitsfile *fptr, long nblocks, int *status); int ffgext(fitsfile *fptr, int moveto, int *exttype, int *status); int ffgtbc(fitsfile *fptr, LONGLONG *totalwidth, int *status); int ffgtbp(fitsfile *fptr, char *name, char *value, int *status); int ffiblk(fitsfile *fptr, long nblock, int headdata, int *status); int ffshft(fitsfile *fptr, LONGLONG firstbyte, LONGLONG nbytes, LONGLONG nshift, int *status); int ffgcprll(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int writemode, double *scale, double *zero, char *tform, long *twidth, int *tcode, int *maxelem, LONGLONG *startpos, LONGLONG *elemnum, long *incre, LONGLONG *repeat, LONGLONG *rowlen, int *hdutype, LONGLONG *tnull, char *snull, int *status); int ffflushx(FITSfile *fptr); int ffseek(FITSfile *fptr, LONGLONG position); int ffread(FITSfile *fptr, long nbytes, void *buffer, int *status); int ffwrite(FITSfile *fptr, long nbytes, void *buffer, int *status); int fftrun(fitsfile *fptr, LONGLONG filesize, int *status); int ffpcluc(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int *status); int ffgcll(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int nultyp, char nulval, char *array, char *nularray, int *anynul, int *status); int ffgcls(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int nultyp, char *nulval, char **array, char *nularray, int *anynul, int *status); int ffgcls2(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, int nultyp, char *nulval, char **array, char *nularray, int *anynul, int *status); int ffgclb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, unsigned char nulval, unsigned char *array, char *nularray, int *anynul, int *status); int ffgclsb(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, signed char nulval, signed char *array, char *nularray, int *anynul, int *status); int ffgclui(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, unsigned short nulval, unsigned short *array, char *nularray, int *anynul, int *status); int ffgcli(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, short nulval, short *array, char *nularray, int *anynul, int *status); int ffgcluj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, unsigned long nulval, unsigned long *array, char *nularray, int *anynul, int *status); int ffgcljj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, LONGLONG nulval, LONGLONG *array, char *nularray, int *anynul, int *status); int ffgclj(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, long nulval, long *array, char *nularray, int *anynul, int *status); int ffgcluk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, unsigned int nulval, unsigned int *array, char *nularray, int *anynul, int *status); int ffgclk(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, int nulval, int *array, char *nularray, int *anynul, int *status); int ffgcle(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, float nulval, float *array, char *nularray, int *anynul, int *status); int ffgcld(fitsfile *fptr, int colnum, LONGLONG firstrow, LONGLONG firstelem, LONGLONG nelem, long elemincre, int nultyp, double nulval, double *array, char *nularray, int *anynul, int *status); int ffpi1b(fitsfile *fptr, long nelem, long incre, unsigned char *buffer, int *status); int ffpi2b(fitsfile *fptr, long nelem, long incre, short *buffer, int *status); int ffpi4b(fitsfile *fptr, long nelem, long incre, INT32BIT *buffer, int *status); int ffpi8b(fitsfile *fptr, long nelem, long incre, long *buffer, int *status); int ffpr4b(fitsfile *fptr, long nelem, long incre, float *buffer, int *status); int ffpr8b(fitsfile *fptr, long nelem, long incre, double *buffer, int *status); int ffgi1b(fitsfile *fptr, LONGLONG pos, long nelem, long incre, unsigned char *buffer, int *status); int ffgi2b(fitsfile *fptr, LONGLONG pos, long nelem, long incre, short *buffer, int *status); int ffgi4b(fitsfile *fptr, LONGLONG pos, long nelem, long incre, INT32BIT *buffer, int *status); int ffgi8b(fitsfile *fptr, LONGLONG pos, long nelem, long incre, long *buffer, int *status); int ffgr4b(fitsfile *fptr, LONGLONG pos, long nelem, long incre, float *buffer, int *status); int ffgr8b(fitsfile *fptr, LONGLONG pos, long nelem, long incre, double *buffer, int *status); int ffcins(fitsfile *fptr, LONGLONG naxis1, LONGLONG naxis2, LONGLONG nbytes, LONGLONG bytepos, int *status); int ffcdel(fitsfile *fptr, LONGLONG naxis1, LONGLONG naxis2, LONGLONG nbytes, LONGLONG bytepos, int *status); int ffkshf(fitsfile *fptr, int firstcol, int tfields, int nshift, int *status); int fffi1i1(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, unsigned char nullval, char *nullarray, int *anynull, unsigned char *output, int *status); int fffi2i1(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, unsigned char nullval, char *nullarray, int *anynull, unsigned char *output, int *status); int fffi4i1(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, unsigned char nullval, char *nullarray, int *anynull, unsigned char *output, int *status); int fffi8i1(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, unsigned char nullval, char *nullarray, int *anynull, unsigned char *output, int *status); int fffr4i1(float *input, long ntodo, double scale, double zero, int nullcheck, unsigned char nullval, char *nullarray, int *anynull, unsigned char *output, int *status); int fffr8i1(double *input, long ntodo, double scale, double zero, int nullcheck, unsigned char nullval, char *nullarray, int *anynull, unsigned char *output, int *status); int fffstri1(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, unsigned char nullval, char *nullarray, int *anynull, unsigned char *output, int *status); int fffi1s1(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, signed char nullval, char *nullarray, int *anynull, signed char *output, int *status); int fffi2s1(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, signed char nullval, char *nullarray, int *anynull, signed char *output, int *status); int fffi4s1(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, signed char nullval, char *nullarray, int *anynull, signed char *output, int *status); int fffi8s1(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, signed char nullval, char *nullarray, int *anynull, signed char *output, int *status); int fffr4s1(float *input, long ntodo, double scale, double zero, int nullcheck, signed char nullval, char *nullarray, int *anynull, signed char *output, int *status); int fffr8s1(double *input, long ntodo, double scale, double zero, int nullcheck, signed char nullval, char *nullarray, int *anynull, signed char *output, int *status); int fffstrs1(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, signed char nullval, char *nullarray, int *anynull, signed char *output, int *status); int fffi1u2(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, unsigned short nullval, char *nullarray, int *anynull, unsigned short *output, int *status); int fffi2u2(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, unsigned short nullval, char *nullarray, int *anynull, unsigned short *output, int *status); int fffi4u2(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, unsigned short nullval, char *nullarray, int *anynull, unsigned short *output, int *status); int fffi8u2(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, unsigned short nullval, char *nullarray, int *anynull, unsigned short *output, int *status); int fffr4u2(float *input, long ntodo, double scale, double zero, int nullcheck, unsigned short nullval, char *nullarray, int *anynull, unsigned short *output, int *status); int fffr8u2(double *input, long ntodo, double scale, double zero, int nullcheck, unsigned short nullval, char *nullarray, int *anynull, unsigned short *output, int *status); int fffstru2(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, unsigned short nullval, char *nullarray, int *anynull, unsigned short *output, int *status); int fffi1i2(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, short nullval, char *nullarray, int *anynull, short *output, int *status); int fffi2i2(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, short nullval, char *nullarray, int *anynull, short *output, int *status); int fffi4i2(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, short nullval, char *nullarray, int *anynull, short *output, int *status); int fffi8i2(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, short nullval, char *nullarray, int *anynull, short *output, int *status); int fffr4i2(float *input, long ntodo, double scale, double zero, int nullcheck, short nullval, char *nullarray, int *anynull, short *output, int *status); int fffr8i2(double *input, long ntodo, double scale, double zero, int nullcheck, short nullval, char *nullarray, int *anynull, short *output, int *status); int fffstri2(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, short nullval, char *nullarray, int *anynull, short *output, int *status); int fffi1u4(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, unsigned long nullval, char *nullarray, int *anynull, unsigned long *output, int *status); int fffi2u4(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, unsigned long nullval, char *nullarray, int *anynull, unsigned long *output, int *status); int fffi4u4(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, unsigned long nullval, char *nullarray, int *anynull, unsigned long *output, int *status); int fffi8u4(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, unsigned long nullval, char *nullarray, int *anynull, unsigned long *output, int *status); int fffr4u4(float *input, long ntodo, double scale, double zero, int nullcheck, unsigned long nullval, char *nullarray, int *anynull, unsigned long *output, int *status); int fffr8u4(double *input, long ntodo, double scale, double zero, int nullcheck, unsigned long nullval, char *nullarray, int *anynull, unsigned long *output, int *status); int fffstru4(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, unsigned long nullval, char *nullarray, int *anynull, unsigned long *output, int *status); int fffi1i4(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, long nullval, char *nullarray, int *anynull, long *output, int *status); int fffi2i4(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, long nullval, char *nullarray, int *anynull, long *output, int *status); int fffi4i4(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, long nullval, char *nullarray, int *anynull, long *output, int *status); int fffi8i4(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, long nullval, char *nullarray, int *anynull, long *output, int *status); int fffr4i4(float *input, long ntodo, double scale, double zero, int nullcheck, long nullval, char *nullarray, int *anynull, long *output, int *status); int fffr8i4(double *input, long ntodo, double scale, double zero, int nullcheck, long nullval, char *nullarray, int *anynull, long *output, int *status); int fffstri4(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, long nullval, char *nullarray, int *anynull, long *output, int *status); int fffi1int(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, int nullval, char *nullarray, int *anynull, int *output, int *status); int fffi2int(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, int nullval, char *nullarray, int *anynull, int *output, int *status); int fffi4int(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, int nullval, char *nullarray, int *anynull, int *output, int *status); int fffi8int(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, int nullval, char *nullarray, int *anynull, int *output, int *status); int fffr4int(float *input, long ntodo, double scale, double zero, int nullcheck, int nullval, char *nullarray, int *anynull, int *output, int *status); int fffr8int(double *input, long ntodo, double scale, double zero, int nullcheck, int nullval, char *nullarray, int *anynull, int *output, int *status); int fffstrint(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, int nullval, char *nullarray, int *anynull, int *output, int *status); int fffi1uint(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, unsigned int nullval, char *nullarray, int *anynull, unsigned int *output, int *status); int fffi2uint(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, unsigned int nullval, char *nullarray, int *anynull, unsigned int *output, int *status); int fffi4uint(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, unsigned int nullval, char *nullarray, int *anynull, unsigned int *output, int *status); int fffi8uint(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, unsigned int nullval, char *nullarray, int *anynull, unsigned int *output, int *status); int fffr4uint(float *input, long ntodo, double scale, double zero, int nullcheck, unsigned int nullval, char *nullarray, int *anynull, unsigned int *output, int *status); int fffr8uint(double *input, long ntodo, double scale, double zero, int nullcheck, unsigned int nullval, char *nullarray, int *anynull, unsigned int *output, int *status); int fffstruint(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, unsigned int nullval, char *nullarray, int *anynull, unsigned int *output, int *status); int fffi1i8(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, LONGLONG nullval, char *nullarray, int *anynull, LONGLONG *output, int *status); int fffi2i8(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, LONGLONG nullval, char *nullarray, int *anynull, LONGLONG *output, int *status); int fffi4i8(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, LONGLONG nullval, char *nullarray, int *anynull, LONGLONG *output, int *status); int fffi8i8(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, LONGLONG nullval, char *nullarray, int *anynull, LONGLONG *output, int *status); int fffr4i8(float *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG nullval, char *nullarray, int *anynull, LONGLONG *output, int *status); int fffr8i8(double *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG nullval, char *nullarray, int *anynull, LONGLONG *output, int *status); int fffstri8(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, LONGLONG nullval, char *nullarray, int *anynull, LONGLONG *output, int *status); int fffi1r4(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, float nullval, char *nullarray, int *anynull, float *output, int *status); int fffi2r4(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, float nullval, char *nullarray, int *anynull, float *output, int *status); int fffi4r4(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, float nullval, char *nullarray, int *anynull, float *output, int *status); int fffi8r4(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, float nullval, char *nullarray, int *anynull, float *output, int *status); int fffr4r4(float *input, long ntodo, double scale, double zero, int nullcheck, float nullval, char *nullarray, int *anynull, float *output, int *status); int fffr8r4(double *input, long ntodo, double scale, double zero, int nullcheck, float nullval, char *nullarray, int *anynull, float *output, int *status); int fffstrr4(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, float nullval, char *nullarray, int *anynull, float *output, int *status); int fffi1r8(unsigned char *input, long ntodo, double scale, double zero, int nullcheck, unsigned char tnull, double nullval, char *nullarray, int *anynull, double *output, int *status); int fffi2r8(short *input, long ntodo, double scale, double zero, int nullcheck, short tnull, double nullval, char *nullarray, int *anynull, double *output, int *status); int fffi4r8(INT32BIT *input, long ntodo, double scale, double zero, int nullcheck, INT32BIT tnull, double nullval, char *nullarray, int *anynull, double *output, int *status); int fffi8r8(LONGLONG *input, long ntodo, double scale, double zero, int nullcheck, LONGLONG tnull, double nullval, char *nullarray, int *anynull, double *output, int *status); int fffr4r8(float *input, long ntodo, double scale, double zero, int nullcheck, double nullval, char *nullarray, int *anynull, double *output, int *status); int fffr8r8(double *input, long ntodo, double scale, double zero, int nullcheck, double nullval, char *nullarray, int *anynull, double *output, int *status); int fffstrr8(char *input, long ntodo, double scale, double zero, long twidth, double power, int nullcheck, char *snull, double nullval, char *nullarray, int *anynull, double *output, int *status); int ffi1fi1(unsigned char *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffs1fi1(signed char *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffu2fi1(unsigned short *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffi2fi1(short *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffu4fi1(unsigned long *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffi4fi1(long *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffi8fi1(LONGLONG *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffuintfi1(unsigned int *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffintfi1(int *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffr4fi1(float *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffr8fi1(double *array, long ntodo, double scale, double zero, unsigned char *buffer, int *status); int ffi1fi2(unsigned char *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffs1fi2(signed char *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffu2fi2(unsigned short *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffi2fi2(short *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffu4fi2(unsigned long *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffi4fi2(long *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffi8fi2(LONGLONG *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffuintfi2(unsigned int *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffintfi2(int *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffr4fi2(float *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffr8fi2(double *array, long ntodo, double scale, double zero, short *buffer, int *status); int ffi1fi4(unsigned char *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffs1fi4(signed char *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffu2fi4(unsigned short *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffi2fi4(short *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffu4fi4(unsigned long *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffi4fi4(long *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffi8fi4(LONGLONG *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffuintfi4(unsigned int *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffintfi4(int *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffr4fi4(float *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int ffr8fi4(double *array, long ntodo, double scale, double zero, INT32BIT *buffer, int *status); int fflongfi8(long *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffi8fi8(LONGLONG *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffi2fi8(short *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffi1fi8(unsigned char *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffs1fi8(signed char *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffr4fi8(float *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffr8fi8(double *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffintfi8(int *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffu2fi8(unsigned short *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffu4fi8(unsigned long *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffuintfi8(unsigned int *array, long ntodo, double scale, double zero, LONGLONG *buffer, int *status); int ffi1fr4(unsigned char *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffs1fr4(signed char *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffu2fr4(unsigned short *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffi2fr4(short *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffu4fr4(unsigned long *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffi4fr4(long *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffi8fr4(LONGLONG *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffuintfr4(unsigned int *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffintfr4(int *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffr4fr4(float *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffr8fr4(double *array, long ntodo, double scale, double zero, float *buffer, int *status); int ffi1fr8(unsigned char *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffs1fr8(signed char *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffu2fr8(unsigned short *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffi2fr8(short *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffu4fr8(unsigned long *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffi4fr8(long *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffi8fr8(LONGLONG *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffuintfr8(unsigned int *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffintfr8(int *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffr4fr8(float *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffr8fr8(double *array, long ntodo, double scale, double zero, double *buffer, int *status); int ffi1fstr(unsigned char *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffs1fstr(signed char *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffu2fstr(unsigned short *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffi2fstr(short *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffu4fstr(unsigned long *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffi4fstr(long *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffi8fstr(LONGLONG *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffintfstr(int *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffuintfstr(unsigned int *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffr4fstr(float *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); int ffr8fstr(double *input, long ntodo, double scale, double zero, char *cform, long twidth, char *output, int *status); /* the following 4 routines are VMS macros used on VAX or Alpha VMS */ void ieevpd(double *inarray, double *outarray, long *nvals); void ieevud(double *inarray, double *outarray, long *nvals); void ieevpr(float *inarray, float *outarray, long *nvals); void ieevur(float *inarray, float *outarray, long *nvals); /* routines related to the lexical parser */ int ffselect_table(fitsfile **fptr, char *outfile, char *expr, int *status); int ffiprs( fitsfile *fptr, int compressed, char *expr, int maxdim, int *datatype, long *nelem, int *naxis, long *naxes, int *status ); void ffcprs( void ); int ffcvtn( int inputType, void *input, char *undef, long ntodo, int outputType, void *nulval, void *output, int *anynull, int *status ); int parse_data( long totalrows, long offset, long firstrow, long nrows, int nCols, iteratorCol *colData, void *userPtr ); int uncompress_hkdata( fitsfile *fptr, long ntimes, double *times, int *status ); int ffffrw_work( long totalrows, long offset, long firstrow, long nrows, int nCols, iteratorCol *colData, void *userPtr ); int fits_translate_pixkeyword(char *inrec, char *outrec,char *patterns[][2], int npat, int naxis, int *colnum, int *pat_num, int *i, int *j, int *n, int *m, int *l, int *status); /* image compression routines */ int fits_write_compressed_img(fitsfile *fptr, int datatype, long *fpixel, long *lpixel, int nullcheck, void *array, void *nulval, int *status); int fits_write_compressed_pixels(fitsfile *fptr, int datatype, LONGLONG fpixel, LONGLONG npixels, int nullcheck, void *array, void *nulval, int *status); int fits_write_compressed_img_plane(fitsfile *fptr, int datatype, int bytesperpixel, long nplane, long *firstcoord, long *lastcoord, long *naxes, int nullcheck, void *array, void *nullval, long *nread, int *status); int imcomp_init_table(fitsfile *outfptr, int bitpix, int naxis,long *naxes, int writebitpix, int *status); int imcomp_calc_max_elem (int comptype, int nx, int zbitpix, int blocksize); int imcomp_copy_imheader(fitsfile *infptr, fitsfile *outfptr, int *status); int imcomp_copy_img2comp(fitsfile *infptr, fitsfile *outfptr, int *status); int imcomp_copy_comp2img(fitsfile *infptr, fitsfile *outfptr, int norec, int *status); int imcomp_copy_prime2img(fitsfile *infptr, fitsfile *outfptr, int *status); int imcomp_compress_image (fitsfile *infptr, fitsfile *outfptr, int *status); int imcomp_compress_tile (fitsfile *outfptr, long row, int datatype, void *tiledata, long tilelen, long nx, long ny, int nullcheck, void *nullval, int *status); int imcomp_nullscale(int *idata, long tilelen, int nullflagval, int nullval, double scale, double zero, int * status); int imcomp_nullvalues(int *idata, long tilelen, int nullflagval, int nullval, int * status); int imcomp_scalevalues(int *idata, long tilelen, double scale, double zero, int * status); int imcomp_nullscalefloats(float *fdata, long tilelen, int *idata, double scale, double zero, int nullcheck, float nullflagval, int nullval, int *status); int imcomp_nullfloats(float *fdata, long tilelen, int *idata, int nullcheck, float nullflagval, int nullval, int *status); int imcomp_nullscaledoubles(double *fdata, long tilelen, int *idata, double scale, double zero, int nullcheck, double nullflagval, int nullval, int *status); int imcomp_nulldoubles(double *fdata, long tilelen, int *idata, int nullcheck, double nullflagval, int nullval, int *status); /* image decompression routines */ int fits_read_compressed_img(fitsfile *fptr, int datatype, LONGLONG *fpixel,LONGLONG *lpixel,long *inc, int nullcheck, void *nulval, void *array, char *nullarray, int *anynul, int *status); int fits_read_compressed_pixels(fitsfile *fptr, int datatype, LONGLONG fpixel, LONGLONG npixels, int nullcheck, void *nulval, void *array, char *nullarray, int *anynul, int *status); int fits_read_compressed_img_plane(fitsfile *fptr, int datatype, int bytesperpixel, long nplane, LONGLONG *firstcoord, LONGLONG *lastcoord, long *inc, long *naxes, int nullcheck, void *nullval, void *array, char *nullarray, int *anynul, long *nread, int *status); int imcomp_get_compressed_image_par(fitsfile *infptr, int *status); int imcomp_decompress_tile (fitsfile *infptr, int nrow, int tilesize, int datatype, int nullcheck, void *nulval, void *buffer, char *bnullarray, int *anynul, int *status); int imcomp_copy_overlap (char *tile, int pixlen, int ndim, long *tfpixel, long *tlpixel, char *bnullarray, char *image, long *fpixel, long *lpixel, long *inc, int nullcheck, char *nullarray, int *status); int imcomp_test_overlap (int ndim, long *tfpixel, long *tlpixel, long *fpixel, long *lpixel, long *inc, int *status); int imcomp_merge_overlap (char *tile, int pixlen, int ndim, long *tfpixel, long *tlpixel, char *bnullarray, char *image, long *fpixel, long *lpixel, int nullcheck, int *status); int imcomp_decompress_img(fitsfile *infptr, fitsfile *outfptr, int datatype, int *status); int fits_quantize_float (long row, float fdata[], long nx, long ny, int nullcheck, float in_null_value, float quantize_level, int dither_method, int idata[], double *bscale, double *bzero, int *iminval, int *imaxval); int fits_quantize_double (long row, double fdata[], long nx, long ny, int nullcheck, double in_null_value, float quantize_level, int dither_method, int idata[], double *bscale, double *bzero, int *iminval, int *imaxval); int fits_rcomp(int a[], int nx, unsigned char *c, int clen,int nblock); int fits_rcomp_short(short a[], int nx, unsigned char *c, int clen,int nblock); int fits_rcomp_byte(signed char a[], int nx, unsigned char *c, int clen,int nblock); int fits_rdecomp (unsigned char *c, int clen, unsigned int array[], int nx, int nblock); int fits_rdecomp_short (unsigned char *c, int clen, unsigned short array[], int nx, int nblock); int fits_rdecomp_byte (unsigned char *c, int clen, unsigned char array[], int nx, int nblock); int pl_p2li (int *pxsrc, int xs, short *lldst, int npix); int pl_l2pi (short *ll_src, int xs, int *px_dst, int npix); int fits_init_randoms(void); int fits_unset_compression_param( fitsfile *fptr, int *status); int fits_unset_compression_request( fitsfile *fptr, int *status); int fitsio_init_lock(void); /* general driver routines */ int urltype2driver(char *urltype, int *driver); int fits_register_driver( char *prefix, int (*init)(void), int (*fitsshutdown)(void), int (*setoptions)(int option), int (*getoptions)(int *options), int (*getversion)(int *version), int (*checkfile) (char *urltype, char *infile, char *outfile), int (*fitsopen)(char *filename, int rwmode, int *driverhandle), int (*fitscreate)(char *filename, int *driverhandle), int (*fitstruncate)(int driverhandle, LONGLONG filesize), int (*fitsclose)(int driverhandle), int (*fremove)(char *filename), int (*size)(int driverhandle, LONGLONG *size), int (*flush)(int driverhandle), int (*seek)(int driverhandle, LONGLONG offset), int (*fitsread) (int driverhandle, void *buffer, long nbytes), int (*fitswrite)(int driverhandle, void *buffer, long nbytes)); /* file driver I/O routines */ int file_init(void); int file_setoptions(int options); int file_getoptions(int *options); int file_getversion(int *version); int file_shutdown(void); int file_checkfile(char *urltype, char *infile, char *outfile); int file_open(char *filename, int rwmode, int *driverhandle); int file_compress_open(char *filename, int rwmode, int *hdl); int file_openfile(char *filename, int rwmode, FILE **diskfile); int file_create(char *filename, int *driverhandle); int file_truncate(int driverhandle, LONGLONG filesize); int file_size(int driverhandle, LONGLONG *filesize); int file_close(int driverhandle); int file_remove(char *filename); int file_flush(int driverhandle); int file_seek(int driverhandle, LONGLONG offset); int file_read (int driverhandle, void *buffer, long nbytes); int file_write(int driverhandle, void *buffer, long nbytes); int file_is_compressed(char *filename); /* stream driver I/O routines */ int stream_open(char *filename, int rwmode, int *driverhandle); int stream_create(char *filename, int *driverhandle); int stream_size(int driverhandle, LONGLONG *filesize); int stream_close(int driverhandle); int stream_flush(int driverhandle); int stream_seek(int driverhandle, LONGLONG offset); int stream_read (int driverhandle, void *buffer, long nbytes); int stream_write(int driverhandle, void *buffer, long nbytes); /* memory driver I/O routines */ int mem_init(void); int mem_setoptions(int options); int mem_getoptions(int *options); int mem_getversion(int *version); int mem_shutdown(void); int mem_create(char *filename, int *handle); int mem_create_comp(char *filename, int *handle); int mem_openmem(void **buffptr, size_t *buffsize, size_t deltasize, void *(*memrealloc)(void *p, size_t newsize), int *handle); int mem_createmem(size_t memsize, int *handle); int stdin_checkfile(char *urltype, char *infile, char *outfile); int stdin_open(char *filename, int rwmode, int *handle); int stdin2mem(int hd); int stdin2file(int hd); int stdout_close(int handle); int mem_compress_openrw(char *filename, int rwmode, int *hdl); int mem_compress_open(char *filename, int rwmode, int *hdl); int mem_compress_stdin_open(char *filename, int rwmode, int *hdl); int mem_iraf_open(char *filename, int rwmode, int *hdl); int mem_rawfile_open(char *filename, int rwmode, int *hdl); int mem_size(int handle, LONGLONG *filesize); int mem_truncate(int handle, LONGLONG filesize); int mem_close_free(int handle); int mem_close_keep(int handle); int mem_close_comp(int handle); int mem_seek(int handle, LONGLONG offset); int mem_read(int hdl, void *buffer, long nbytes); int mem_write(int hdl, void *buffer, long nbytes); int mem_uncompress2mem(char *filename, FILE *diskfile, int hdl); int iraf2mem(char *filename, char **buffptr, size_t *buffsize, size_t *filesize, int *status); /* root driver I/O routines */ int root_init(void); int root_setoptions(int options); int root_getoptions(int *options); int root_getversion(int *version); int root_shutdown(void); int root_open(char *filename, int rwmode, int *driverhandle); int root_create(char *filename, int *driverhandle); int root_close(int driverhandle); int root_flush(int driverhandle); int root_seek(int driverhandle, LONGLONG offset); int root_read (int driverhandle, void *buffer, long nbytes); int root_write(int driverhandle, void *buffer, long nbytes); int root_size(int handle, LONGLONG *filesize); /* http driver I/O routines */ int http_checkfile(char *urltype, char *infile, char *outfile); int http_open(char *filename, int rwmode, int *driverhandle); int http_file_open(char *filename, int rwmode, int *driverhandle); int http_compress_open(char *filename, int rwmode, int *driverhandle); /* ftp driver I/O routines */ int ftp_checkfile(char *urltype, char *infile, char *outfile); int ftp_open(char *filename, int rwmode, int *driverhandle); int ftp_file_open(char *filename, int rwmode, int *driverhandle); int ftp_compress_open(char *filename, int rwmode, int *driverhandle); int uncompress2mem(char *filename, FILE *diskfile, char **buffptr, size_t *buffsize, void *(*mem_realloc)(void *p, size_t newsize), size_t *filesize, int *status); int uncompress2mem_from_mem( char *inmemptr, size_t inmemsize, char **buffptr, size_t *buffsize, void *(*mem_realloc)(void *p, size_t newsize), size_t *filesize, int *status); int uncompress2file(char *filename, FILE *indiskfile, FILE *outdiskfile, int *status); int compress2mem_from_mem( char *inmemptr, size_t inmemsize, char **buffptr, size_t *buffsize, void *(*mem_realloc)(void *p, size_t newsize), size_t *filesize, int *status); int compress2file_from_mem( char *inmemptr, size_t inmemsize, FILE *outdiskfile, size_t *filesize, /* O - size of file, in bytes */ int *status); #ifdef HAVE_GSIFTP /* prototypes for gsiftp driver I/O routines */ #include "drvrgsiftp.h" #endif #ifdef HAVE_SHMEM_SERVICES /* prototypes for shared memory driver I/O routines */ #include "drvrsmem.h" #endif #if defined(vms) || defined(__vms) || defined(WIN32) || defined(__WIN32__) || (defined(macintosh) && !defined(TARGET_API_MAC_CARBON)) /* A hack for nonunix machines, which lack strcasecmp and strncasecmp */ int strcasecmp (const char *s1, const char *s2 ); int strncasecmp(const char *s1, const char *s2, size_t n); #endif /* end of the entire "ifndef _FITSIO2_H" block */ #endif healpy-1.10.3/cfitsio/fpack.c0000664000175000017500000003451013010375005016213 0ustar zoncazonca00000000000000/* FPACK * R. Seaman, NOAO, with a few enhancements by W. Pence, HEASARC * * Calls fits_img_compress in the CFITSIO library by W. Pence, HEASARC */ #include /* #include */ #include "fitsio.h" #include "fpack.h" /* ================================================================== */ int main(int argc, char *argv[]) { fpstate fpvar; if (argc <= 1) { fp_usage (); fp_hint (); exit (-1); } fp_init (&fpvar); fp_get_param (argc, argv, &fpvar); if (fpvar.listonly) { fp_list (argc, argv, fpvar); } else { fp_preflight (argc, argv, FPACK, &fpvar); fp_loop (argc, argv, FPACK, fpvar); } exit (0); } /* ================================================================== */ int fp_get_param (int argc, char *argv[], fpstate *fpptr) { int gottype=0, gottile=0, wholetile=0, iarg, len, ndim, ii, doffset; char tmp[SZ_STR], tile[SZ_STR]; if (fpptr->initialized != FP_INIT_MAGIC) { fp_msg ("Error: internal initialization error\n"); exit (-1); } tile[0] = 0; /* flags must come first and be separately specified */ for (iarg = 1; iarg < argc; iarg++) { if ((argv[iarg][0] == '-' && strlen (argv[iarg]) == 2) || !strncmp(argv[iarg], "-q", 2) || !strncmp(argv[iarg], "-qz", 3) || !strncmp(argv[iarg], "-g1", 3) || !strncmp(argv[iarg], "-g2", 3) || !strncmp(argv[iarg], "-i2f", 4) || !strncmp(argv[iarg], "-n3ratio", 8) || !strncmp(argv[iarg], "-n3min", 6) || !strncmp(argv[iarg], "-tableonly", 10) || !strncmp(argv[iarg], "-table", 6) ) { /* Rice is the default, so -r is superfluous */ if ( argv[iarg][1] == 'r') { fpptr->comptype = RICE_1; if (gottype) { fp_msg ("Error: multiple compression flags\n"); fp_usage (); exit (-1); } else gottype++; } else if (argv[iarg][1] == 'p') { fpptr->comptype = PLIO_1; if (gottype) { fp_msg ("Error: multiple compression flags\n"); fp_usage (); exit (-1); } else gottype++; } else if (argv[iarg][1] == 'g') { /* test for modifiers following the 'g' */ if (argv[iarg][2] == '2') fpptr->comptype = GZIP_2; else fpptr->comptype = GZIP_1; if (gottype) { fp_msg ("Error: multiple compression flags\n"); fp_usage (); exit (-1); } else gottype++; /* } else if (argv[iarg][1] == 'b') { fpptr->comptype = BZIP2_1; if (gottype) { fp_msg ("Error: multiple compression flags\n"); fp_usage (); exit (-1); } else gottype++; */ } else if (argv[iarg][1] == 'h') { fpptr->comptype = HCOMPRESS_1; if (gottype) { fp_msg ("Error: multiple compression flags\n"); fp_usage (); exit (-1); } else gottype++; } else if (argv[iarg][1] == 'd') { fpptr->comptype = NOCOMPRESS; if (gottype) { fp_msg ("Error: multiple compression flags\n"); fp_usage (); exit (-1); } else gottype++; } else if (!strcmp(argv[iarg], "-i2f")) { /* this means convert integer images to float, and then */ /* quantize and compress the float image. This lossy */ /* compression method may give higher compression than the */ /* lossless compression method that is usually applied to */ /* integer images. */ fpptr->int_to_float = 1; } else if (!strcmp(argv[iarg], "-n3ratio")) { /* this is the minimum ratio between the MAD noise sigma */ /* and the q parameter value in the case where the integer */ /* image is quantized and compressed like a float image. */ if (++iarg >= argc) { fp_usage (); exit (-1); } else { fpptr->n3ratio = (float) atof (argv[iarg]); } } else if (!strcmp(argv[iarg], "-n3min")) { /* this is the minimum MAD noise sigma in the case where the */ /* integer image is quantized and compressed like a float image. */ if (++iarg >= argc) { fp_usage (); exit (-1); } else { fpptr->n3min = (float) atof (argv[iarg]); } } else if (argv[iarg][1] == 'q') { /* test for modifiers following the 'q' */ if (argv[iarg][2] == 'z') { fpptr->dither_method = 2; /* preserve zero pixels */ if (argv[iarg][3] == 't') { fpptr->dither_offset = -1; /* dither based on tile checksum */ } else if (isdigit(argv[iarg][3])) { /* is a number appended to q? */ doffset = atoi(argv[iarg]+3); if (doffset == 0) { fpptr->no_dither = 1; /* don't dither the quantized values */ } else if (doffset > 0 && doffset <= 10000) { fpptr->dither_offset = doffset; } else { fp_msg ("Error: invalid q suffix\n"); fp_usage (); exit (-1); } } } else { if (argv[iarg][2] == 't') { fpptr->dither_offset = -1; /* dither based on tile checksum */ } else if (isdigit(argv[iarg][2])) { /* is a number appended to q? */ doffset = atoi(argv[iarg]+2); if (doffset == 0) { fpptr->no_dither = 1; /* don't dither the quantized values */ } else if (doffset > 0 && doffset <= 10000) { fpptr->dither_offset = doffset; } else { fp_msg ("Error: invalid q suffix\n"); fp_usage (); exit (-1); } } } if (++iarg >= argc) { fp_usage (); exit (-1); } else { fpptr->quantize_level = (float) atof (argv[iarg]); } } else if (argv[iarg][1] == 'n') { if (++iarg >= argc) { fp_usage (); exit (-1); } else { fpptr->rescale_noise = (float) atof (argv[iarg]); } } else if (argv[iarg][1] == 's') { if (++iarg >= argc) { fp_usage (); exit (-1); } else { fpptr->scale = (float) atof (argv[iarg]); } } else if (!strcmp(argv[iarg], "-tableonly")) { fpptr->do_tables = 1; fpptr->do_images = 0; fp_msg ("Note: -tableonly is intended for feasibility studies, not general use.\n"); } else if (!strcmp(argv[iarg], "-table")) { fpptr->do_tables = 1; fp_msg ("Note: -table is intended for feasibility studies, not general use.\n"); } else if (argv[iarg][1] == 't') { if (gottile) { fp_msg ("Error: multiple tile specifications\n"); fp_usage (); exit (-1); } else gottile++; if (++iarg >= argc) { fp_usage (); exit (-1); } else strncpy (tile, argv[iarg], SZ_STR); /* checked below */ } else if (argv[iarg][1] == 'v') { fpptr->verbose = 1; } else if (argv[iarg][1] == 'w') { wholetile++; if (gottile) { fp_msg ("Error: multiple tile specifications\n"); fp_usage (); exit (-1); } else gottile++; } else if (argv[iarg][1] == 'F') { fpptr->clobber++; /* overwrite existing file */ } else if (argv[iarg][1] == 'D') { fpptr->delete_input++; } else if (argv[iarg][1] == 'Y') { fpptr->do_not_prompt++; } else if (argv[iarg][1] == 'S') { fpptr->to_stdout++; } else if (argv[iarg][1] == 'L') { fpptr->listonly++; } else if (argv[iarg][1] == 'C') { fpptr->do_checksums = 0; } else if (argv[iarg][1] == 'T') { fpptr->test_all = 1; } else if (argv[iarg][1] == 'R') { if (++iarg >= argc) { fp_usage (); fp_hint (); exit (-1); } else strncpy (fpptr->outfile, argv[iarg], SZ_STR); } else if (argv[iarg][1] == 'H') { fp_help (); exit (0); } else if (argv[iarg][1] == 'V') { fp_version (); exit (0); } else { fp_msg ("Error: unknown command line flag `"); fp_msg (argv[iarg]); fp_msg ("'\n"); fp_usage (); fp_hint (); exit (-1); } } else break; } if (fpptr->scale != 0. && fpptr->comptype != HCOMPRESS_1 && fpptr->test_all != 1) { fp_msg ("Error: `-s' requires `-h or -T'\n"); exit (-1); } if (fpptr->quantize_level == 0) { if ((fpptr->comptype != GZIP_1) && (fpptr->comptype != GZIP_2)) { fp_msg ("Error: `-q 0' only allowed with GZIP\n"); exit (-1); } if (fpptr->int_to_float == 1) { fp_msg ("Error: `-q 0' not allowed with -i2f\n"); exit (-1); } } if (wholetile) { for (ndim=0; ndim < MAX_COMPRESS_DIM; ndim++) fpptr->ntile[ndim] = (long) -1; } else if (gottile) { len = strlen (tile); for (ii=0, ndim=0; ii < len; ) { if (! (isdigit (tile[ii]) || tile[ii] == ',')) { fp_msg ("Error: `-t' requires comma separated tile dims, "); fp_msg ("e.g., `-t 100,100'\n"); exit (-1); } if (tile[ii] == ',') { ii++; continue; } fpptr->ntile[ndim] = atol (&tile[ii]); for ( ; isdigit(tile[ii]); ii++); if (++ndim > MAX_COMPRESS_DIM) { fp_msg ("Error: too many dimensions for `-t', max="); sprintf (tmp, "%d\n", MAX_COMPRESS_DIM); fp_msg (tmp); exit (-1); } } } if (iarg >= argc) { fp_msg ("Error: no FITS files to compress\n"); fp_usage (); exit (-1); } else fpptr->firstfile = iarg; return(0); } /* ================================================================== */ int fp_usage (void) { fp_msg ("usage: fpack "); fp_msg ( "[-r|-h|-g|-p] [-w|-t ] [-q ] [-s ] [-n ] -v \n"); fp_msg ("more: [-T] [-R] [-F] [-D] [-Y] [-S] [-L] [-C] [-H] [-V] [-i2f]\n"); return(0); } /* ================================================================== */ int fp_hint (void) { fp_msg (" `fpack -H' for help\n"); return(0); } /* ================================================================== */ int fp_help (void) { fp_msg ("fpack, a FITS image compression program. Version "); fp_version (); fp_usage (); fp_msg ("\n"); fp_msg ("NOTE: the compression parameters specified on the fpack command line may\n"); fp_msg ("be over-ridden by compression directive keywords in the header of each HDU\n"); fp_msg ("of the input file(s). See the fpack User's Guide for more details\n"); fp_msg ("\n"); fp_msg ("Flags must be separate and appear before filenames:\n"); fp_msg (" -r Rice compression [default], or\n"); fp_msg (" -h Hcompress compression, or\n"); fp_msg (" -g or -g1 GZIP_1 (per-tile) compression, or\n"); fp_msg (" -g2 GZIP_2 (per-tile) compression (with byte shuffling), or\n"); /* fp_msg (" -b BZIP2 (per-tile) compression, or\n"); */ fp_msg (" -p PLIO compression (only for positive 8 or 16-bit integer images).\n"); fp_msg (" -d Tile the image without compression (debugging mode).\n"); fp_msg (" -w Compress the whole image as a single large tile.\n"); fp_msg (" -t Comma separated list of tile dimensions [default is row by row].\n"); fp_msg (" -q Quantized level spacing when converting floating point images to\n"); fp_msg (" scaled integers. (+value relative to sigma of background noise;\n"); fp_msg (" -value is absolute). Default q value of 4 gives a compression ratio\n"); fp_msg (" of about 6 with very high fidelity (only 0.26% increase in noise).\n"); fp_msg (" Using q values of 2, or 1 will give compression ratios of\n"); fp_msg (" about 8, or 10, respectively (with 1.0% or 4.1% noise increase).\n"); fp_msg (" The scaled quantized values are randomly dithered using a seed \n"); fp_msg (" value determined from the system clock at run time.\n"); fp_msg (" Use -q0 instead of -q to suppress random dithering.\n"); fp_msg (" Use -qz instead of -q to not dither zero-valued pixels.\n"); fp_msg (" Use -qt or -qzt to compute random dithering seed from first tile checksum.\n"); fp_msg (" Use -qN or -qzN, (N in range 1 to 10000) to use a specific dithering seed.\n"); fp_msg (" Floating-point images can be losslessly compressed by selecting\n"); fp_msg (" the GZIP algorithm and specifying -q 0, but this is slower and often\n"); fp_msg (" produces much less compression than the default quantization method.\n"); fp_msg (" -i2f Convert integer images to floating point, then quantize and compress\n"); fp_msg (" using the specified q level. When used appropriately, this lossy\n"); fp_msg (" compression method can give much better compression than the normal\n"); fp_msg (" lossless compression methods without significant loss of information.\n"); fp_msg (" The -n3ratio and -n3min flags control the minimum noise thresholds;\n"); fp_msg (" Images below these thresholds will be losslessly compressed.\n"); fp_msg (" -n3ratio Minimum ratio of background noise sigma divided by q. Default = 2.0.\n"); fp_msg (" -n3min Minimum background noise sigma. Default = 6. The -i2f flag will be ignored\n"); fp_msg (" if the noise level in the image does not exceed both thresholds.\n"); fp_msg (" -s Scale factor for lossy Hcompress [default = 0 = lossless]\n"); fp_msg (" (+values relative to RMS noise; -value is absolute)\n"); fp_msg (" -n Rescale scaled-integer images to reduce noise and improve compression.\n"); fp_msg (" -v Verbose mode; list each file as it is processed.\n"); fp_msg (" -T Show compression algorithm comparison test statistics; files unchanged.\n"); fp_msg (" -R Write the comparison test report (above) to a text file.\n"); fp_msg (" -table Compress FITS binary tables using prototype method, as well as compress\n"); fp_msg (" any image HDUs. This option is intended for experimental use.\n"); fp_msg (" -tableonly Compress only FITS binary tables using prototype method; do not compress\n"); fp_msg (" any image HDUs. This option is intended for experimental use.\n"); fp_msg ("\nkeywords shared with funpack:\n"); fp_msg (" -F Overwrite input file by output file with same name.\n"); fp_msg (" -D Delete input file after writing output.\n"); fp_msg (" -Y Suppress prompts to confirm -F or -D options.\n"); fp_msg (" -S Output compressed FITS files to STDOUT.\n"); fp_msg (" -L List contents; files unchanged.\n"); fp_msg (" -C Don't update FITS checksum keywords.\n"); fp_msg (" -H Show this message.\n"); fp_msg (" -V Show version number.\n"); fp_msg ("\n FITS files to pack; enter '-' (a hyphen) to read input from stdin stream.\n"); fp_msg (" Refer to the fpack User's Guide for more extensive help.\n"); return(0); } healpy-1.10.3/cfitsio/fpack.h0000664000175000017500000001576313010375005016231 0ustar zoncazonca00000000000000/* used by FPACK and FUNPACK * R. Seaman, NOAO * W. Pence, NASA/GSFC */ #include #include #include /* not needed any more */ /* #include */ /* #include */ /* #include */ #define FPACK_VERSION "1.7.0 (Dec 2013)" /* VERSION History 1.7.0 (Dec 2013) - extensive changes to the binary table compression method. All types of binary table columns, including variable length array columns are now supported. The command line table compression flag has been changed to "-table" instead of "-BETAtable", and a new "-tableonly" flag has been introduced to only compress the binary tables in the input files(s) and not the image HDUs. 1.6.1 (Mar 2013) - numerous changes to the BETAtable compression method used to compress binary tables - added support for compression 'steering' keywords that specify the desired compression parameters that should be used when compressing that particular HDU, thus overriding the fpack command line parameter values. 1.6.0 (June 2012) - Fixed behavior of the "rename" function on Windows platforms so that it will clobber/delete an existing file before renaming a file to that name (the rename command behaves differently on POSIX and non-POSIX environments). 1.6.0 (February 2011) - Added full support for compressing and uncompressing FITS binary tables using a newly proposed format convention. This is intended only for further feasibility studies, and is not recommended for use with publicly distributed FITS files. - Use the minimum of the MAD 2nd, 3rd, and 5th order values as a more conservative extimate of the noise when quantizing floating point images. - Enhanced the tile compression routines so that a tile that contains all NaN pixel values will be compressed. - When uncompressing an image that was originally in a FITS primary array, funpack will also append any new keywords that were written into the primary array of the compressed FITS file after the file was compressed. - Added support for the GZIP_2 algorithm, which shuffles the bytes in the pixel values prior to compressing them with gzip. 1.5.1 (December 2010) Added prototype, mainly hidden, support for compressing binary tables. 1.5.0 (August 2010) Added the -i2f option to lossy compress integer images. 1.4.0 (Jan 2010) Reduced the default value for the q floating point image quantization parameter from 16 to 4. This results in about 50% better compression (from about 4.6x to 6.4) with no lost of significant information (with the new subtractive dithering enhancement). Replaced the code for generating temporary filenames to make the code more portable (to Windows). Replaced calls to the unix 'access' and 'stat' functions with more portable code. When unpacking a file, write it first to a temporary file, then rename it when finished, so that other tasks cannot try to read the file before it is complete. 1.3.0 (Oct 2009) added randomization to the dithering pattern so that the same pattern is not used for every image; also added an option for losslessly compressing floating point images with GZIP for test purposes (not recommended for general use). Also added support for reading the input FITS file from the stdin file streams. 1.2.0 (Sept 2009) added subtractive dithering feature (in CFITSIO) when quantizing floating point images; When packing an IRAF .imh + .pix image, the file name is changed to FILE.fits.fz, and if the original file is deleted, then both the .imh and .pix files are deleted. 1.1.4 (May 2009) added -E option to funpack to unpack a list of HDUs 1.1.3 (March 2009) minor modifications to the content and format of the -T report 1.1.2 (September 2008) */ #define FP_INIT_MAGIC 42 #define FPACK 0 #define FUNPACK 1 /* changed from 16 in Jan. 2010 */ #define DEF_QLEVEL 4. #define DEF_HCOMP_SCALE 0. #define DEF_HCOMP_SMOOTH 0 #define DEF_RESCALE_NOISE 0 #define SZ_STR 513 #define SZ_CARD 81 typedef struct { int comptype; float quantize_level; int no_dither; int dither_offset; int dither_method; float scale; float rescale_noise; int smooth; int int_to_float; float n3ratio; float n3min; long ntile[MAX_COMPRESS_DIM]; int to_stdout; int listonly; int clobber; int delete_input; int do_not_prompt; int do_checksums; int do_gzip_file; int do_images; int do_tables; int test_all; int verbose; char prefix[SZ_STR]; char extname[SZ_STR]; int delete_suffix; char outfile[SZ_STR]; int firstfile; int initialized; int preflight_checked; } fpstate; typedef struct { int n_nulls; double minval; double maxval; double mean; double sigma; double noise1; double noise2; double noise3; double noise5; } imgstats; int fp_get_param (int argc, char *argv[], fpstate *fpptr); void abort_fpack(int sig); void fp_abort_output (fitsfile *infptr, fitsfile *outfptr, int stat); int fp_usage (void); int fp_help (void); int fp_hint (void); int fp_init (fpstate *fpptr); int fp_list (int argc, char *argv[], fpstate fpvar); int fp_info (char *infits); int fp_info_hdu (fitsfile *infptr); int fp_preflight (int argc, char *argv[], int unpack, fpstate *fpptr); int fp_loop (int argc, char *argv[], int unpack, fpstate fpvar); int fp_pack (char *infits, char *outfits, fpstate fpvar, int *islossless); int fp_unpack (char *infits, char *outfits, fpstate fpvar); int fp_test (char *infits, char *outfits, char *outfits2, fpstate fpvar); int fp_pack_hdu (fitsfile *infptr, fitsfile *outfptr, fpstate fpvar, int *islossless, int *status); int fp_unpack_hdu (fitsfile *infptr, fitsfile *outfptr, fpstate fpvar, int *status); int fits_read_image_speed (fitsfile *infptr, float *whole_elapse, float *whole_cpu, float *row_elapse, float *row_cpu, int *status); int fp_test_hdu (fitsfile *infptr, fitsfile *outfptr, fitsfile *outfptr2, fpstate fpvar, int *status); int fp_test_table (fitsfile *infptr, fitsfile *outfptr, fitsfile *outfptr2, fpstate fpvar, int *status); int marktime(int *status); int gettime(float *elapse, float *elapscpu, int *status); int fits_read_image_speed (fitsfile *infptr, float *whole_elapse, float *whole_cpu, float *row_elapse, float *row_cpu, int *status); int fp_i2stat(fitsfile *infptr, int naxis, long *naxes, imgstats *imagestats, int *status); int fp_i4stat(fitsfile *infptr, int naxis, long *naxes, imgstats *imagestats, int *status); int fp_r4stat(fitsfile *infptr, int naxis, long *naxes, imgstats *imagestats, int *status); int fp_i2rescale(fitsfile *infptr, int naxis, long *naxes, double rescale, fitsfile *outfptr, int *status); int fp_i4rescale(fitsfile *infptr, int naxis, long *naxes, double rescale, fitsfile *outfptr, int *status); int fp_msg (char *msg); int fp_version (void); int fp_noop (void); int fu_get_param (int argc, char *argv[], fpstate *fpptr); int fu_usage (void); int fu_hint (void); int fu_help (void); healpy-1.10.3/cfitsio/fpackutil.c0000664000175000017500000021770413010375005017121 0ustar zoncazonca00000000000000/* FPACK utility routines R. Seaman, NOAO & W. Pence, NASA/GSFC */ #include #include #include #include /* #include "bzlib.h" only for experimental purposes */ #if defined(unix) || defined(__unix__) || defined(__unix) #include #endif #include #include "fitsio.h" #include "fpack.h" /* these filename buffer are used to delete temporary files */ /* in case the program is aborted */ char tempfilename[SZ_STR]; char tempfilename2[SZ_STR]; char tempfilename3[SZ_STR]; /* nearest integer function */ # define NINT(x) ((x >= 0.) ? (int) (x + 0.5) : (int) (x - 0.5)) # define NSHRT(x) ((x >= 0.) ? (short) (x + 0.5) : (short) (x - 0.5)) /* define variables for measuring elapsed time */ clock_t scpu, ecpu; long startsec; /* start of elapsed time interval */ int startmilli; /* start of elapsed time interval */ /* CLOCKS_PER_SEC should be defined by most compilers */ #if defined(CLOCKS_PER_SEC) #define CLOCKTICKS CLOCKS_PER_SEC #else /* on SUN OS machine, CLOCKS_PER_SEC is not defined, so set its value */ #define CLOCKTICKS 1000000 #endif FILE *outreport; /* dimension of central image area to be sampled for test statistics */ int XSAMPLE = 4100; int YSAMPLE = 4100; int fp_msg (char *msg) { printf ("%s", msg); return(0); } /*--------------------------------------------------------------------------*/ int fp_noop (void) { fp_msg ("Input and output files are unchanged.\n"); return(0); } /*--------------------------------------------------------------------------*/ void fp_abort_output (fitsfile *infptr, fitsfile *outfptr, int stat) { int status = 0, hdunum; char msg[SZ_STR]; fits_file_name(infptr, tempfilename, &status); fits_get_hdu_num(infptr, &hdunum); fits_close_file (infptr, &status); sprintf(msg, "Error processing file: %s\n", tempfilename); fp_msg (msg); sprintf(msg, " in HDU number %d\n", hdunum); fp_msg (msg); fits_report_error (stderr, stat); if (outfptr) { fits_delete_file(outfptr, &status); fp_msg ("Input file is unchanged.\n"); } exit (stat); } /*--------------------------------------------------------------------------*/ int fp_version (void) { float version; char cfitsioversion[40]; fp_msg (FPACK_VERSION); fits_get_version(&version); sprintf(cfitsioversion, " CFITSIO version %5.3f", version); fp_msg(cfitsioversion); fp_msg ("\n"); return(0); } /*--------------------------------------------------------------------------*/ int fp_access (char *filename) { /* test if a file exists */ FILE *diskfile; diskfile = fopen(filename, "r"); if (diskfile) { fclose(diskfile); return(0); } else { return(-1); } } /*--------------------------------------------------------------------------*/ int fp_tmpnam(char *suffix, char *rootname, char *tmpnam) { /* create temporary file name */ int maxtry = 30, i1 = 0, ii; if (strlen(suffix) + strlen(rootname) > SZ_STR-5) { fp_msg ("Error: filename is too long to create tempory file\n"); exit (-1); } strcpy (tmpnam, rootname); /* start with rootname */ strcat(tmpnam, suffix); /* append the suffix */ maxtry = SZ_STR - strlen(tmpnam) - 1; for (ii = 0; ii < maxtry; ii++) { if (fp_access(tmpnam)) break; /* good, the file does not exist */ strcat(tmpnam, "x"); /* append an x to the name, and try again */ } if (ii == maxtry) { fp_msg ("\nCould not create temporary file name:\n"); fp_msg (tmpnam); fp_msg ("\n"); exit (-1); } return(0); } /*--------------------------------------------------------------------------*/ int fp_init (fpstate *fpptr) { int ii; fpptr->comptype = RICE_1; fpptr->quantize_level = DEF_QLEVEL; fpptr->no_dither = 0; fpptr->dither_method = 1; fpptr->dither_offset = 0; fpptr->int_to_float = 0; /* thresholds when using the -i2f flag */ fpptr->n3ratio = 2.0; /* minimum ratio of image noise sigma / q */ fpptr->n3min = 6.; /* minimum noise sigma. */ fpptr->scale = DEF_HCOMP_SCALE; fpptr->smooth = DEF_HCOMP_SMOOTH; fpptr->rescale_noise = DEF_RESCALE_NOISE; fpptr->ntile[0] = (long) -1; /* -1 means extent of axis */ for (ii=1; ii < MAX_COMPRESS_DIM; ii++) fpptr->ntile[ii] = (long) 1; fpptr->to_stdout = 0; fpptr->listonly = 0; fpptr->clobber = 0; fpptr->delete_input = 0; fpptr->do_not_prompt = 0; fpptr->do_checksums = 1; fpptr->do_gzip_file = 0; fpptr->do_tables = 0; /* this is intended for testing purposes */ fpptr->do_images = 1; /* can be turned off with -tableonly switch */ fpptr->test_all = 0; fpptr->verbose = 0; fpptr->prefix[0] = 0; fpptr->extname[0] = 0; fpptr->delete_suffix = 0; fpptr->outfile[0] = 0; fpptr->firstfile = 1; /* magic number for initialization check, boolean for preflight */ fpptr->initialized = FP_INIT_MAGIC; fpptr->preflight_checked = 0; return(0); } /*--------------------------------------------------------------------------*/ int fp_list (int argc, char *argv[], fpstate fpvar) { fitsfile *infptr; char infits[SZ_STR], msg[SZ_STR]; int hdunum, iarg, stat=0; LONGLONG sizell; if (fpvar.initialized != FP_INIT_MAGIC) { fp_msg ("Error: internal initialization error\n"); exit (-1); } for (iarg=fpvar.firstfile; iarg < argc; iarg++) { strncpy (infits, argv[iarg], SZ_STR); if (strchr (infits, '[') || strchr (infits, ']')) { fp_msg ("Error: section/extension notation not supported: "); fp_msg (infits); fp_msg ("\n"); exit (-1); } if (fp_access (infits) != 0) { fp_msg ("Error: can't find or read input file "); fp_msg (infits); fp_msg ("\n"); fp_noop (); exit (-1); } fits_open_file (&infptr, infits, READONLY, &stat); if (stat) { fits_report_error (stderr, stat); exit (stat); } /* move to the end of file, to get the total size in bytes */ fits_get_num_hdus (infptr, &hdunum, &stat); fits_movabs_hdu (infptr, hdunum, NULL, &stat); fits_get_hduaddrll(infptr, NULL, NULL, &sizell, &stat); if (stat) { fp_abort_output(infptr, NULL, stat); } sprintf (msg, "# %s (", infits); fp_msg (msg); #if defined(_MSC_VER) /* Microsoft Visual C++ 6.0 uses '%I64d' syntax for 8-byte integers */ sprintf(msg, "%I64d bytes)\n", sizell); fp_msg (msg); #elif (USE_LL_SUFFIX == 1) sprintf(msg, "%lld bytes)\n", sizell); fp_msg (msg); #else sprintf(msg, "%ld bytes)\n", sizell); fp_msg (msg); #endif fp_info_hdu (infptr); fits_close_file (infptr, &stat); if (stat) { fits_report_error (stderr, stat); exit (stat); } } return(0); } /*--------------------------------------------------------------------------*/ int fp_info_hdu (fitsfile *infptr) { long naxes[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1}; char msg[SZ_STR], val[SZ_CARD], com[SZ_CARD]; int naxis=0, hdutype, bitpix, hdupos, stat=0, ii; unsigned long datasum, hdusum; fits_movabs_hdu (infptr, 1, NULL, &stat); if (stat) { fp_abort_output(infptr, NULL, stat); } for (hdupos=1; ! stat; hdupos++) { fits_get_hdu_type (infptr, &hdutype, &stat); if (stat) { fp_abort_output(infptr, NULL, stat); } /* fits_get_hdu_type calls unknown extensions "IMAGE_HDU" * so consult XTENSION keyword itself */ fits_read_keyword (infptr, "XTENSION", val, com, &stat); if (stat == KEY_NO_EXIST) { /* in primary HDU which by definition is an "image" */ stat=0; /* clear for later error handling */ } else if (stat) { fp_abort_output(infptr, NULL, stat); } else if (hdutype == IMAGE_HDU) { /* that is, if XTENSION != "IMAGE" AND != "BINTABLE" */ if (strncmp (val+1, "IMAGE", 5) && strncmp (val+1, "BINTABLE", 5)) { /* assign something other than any of these */ hdutype = IMAGE_HDU + ASCII_TBL + BINARY_TBL; } } fits_get_chksum(infptr, &datasum, &hdusum, &stat); if (hdutype == IMAGE_HDU) { sprintf (msg, " %d IMAGE", hdupos); fp_msg (msg); sprintf (msg, " SUMS=%lu/%lu", (unsigned long) (~((int) hdusum)), datasum); fp_msg (msg); fits_get_img_param (infptr, 9, &bitpix, &naxis, naxes, &stat); sprintf (msg, " BITPIX=%d", bitpix); fp_msg (msg); if (naxis == 0) { sprintf (msg, " [no_pixels]"); fp_msg (msg); } else if (naxis == 1) { sprintf (msg, " [%ld]", naxes[1]); fp_msg (msg); } else { sprintf (msg, " [%ld", naxes[0]); fp_msg (msg); for (ii=1; ii < naxis; ii++) { sprintf (msg, "x%ld", naxes[ii]); fp_msg (msg); } fp_msg ("]"); } if (fits_is_compressed_image (infptr, &stat)) { fits_read_keyword (infptr, "ZCMPTYPE", val, com, &stat); /* allow for quote in keyword value */ if (! strncmp (val+1, "RICE_1", 6)) fp_msg (" tiled_rice\n"); else if (! strncmp (val+1, "GZIP_1", 6)) fp_msg (" tiled_gzip_1\n"); else if (! strncmp (val+1, "GZIP_2", 6)) fp_msg (" tiled_gzip_2\n"); else if (! strncmp (val+1, "PLIO_1", 6)) fp_msg (" tiled_plio\n"); else if (! strncmp (val+1, "HCOMPRESS_1", 11)) fp_msg (" tiled_hcompress\n"); else fp_msg (" unknown\n"); } else fp_msg (" not_tiled\n"); } else if (hdutype == ASCII_TBL) { sprintf (msg, " %d ASCII_TBL", hdupos); fp_msg (msg); sprintf (msg, " SUMS=%lu/%lu\n", (unsigned long) (~((int) hdusum)), datasum); fp_msg (msg); } else if (hdutype == BINARY_TBL) { sprintf (msg, " %d BINARY_TBL", hdupos); fp_msg (msg); sprintf (msg, " SUMS=%lu/%lu\n", (unsigned long) (~((int) hdusum)), datasum); fp_msg (msg); } else { sprintf (msg, " %d OTHER", hdupos); fp_msg (msg); sprintf (msg, " SUMS=%lu/%lu", (unsigned long) (~((int) hdusum), datasum)); fp_msg (msg); sprintf (msg, " %s\n", val); fp_msg (msg); } fits_movrel_hdu (infptr, 1, NULL, &stat); } return(0); } /*--------------------------------------------------------------------------*/ int fp_preflight (int argc, char *argv[], int unpack, fpstate *fpptr) { char infits[SZ_STR], outfits[SZ_STR]; int iarg, namelen, nfiles = 0; if (fpptr->initialized != FP_INIT_MAGIC) { fp_msg ("Error: internal initialization error\n"); exit (-1); } for (iarg=fpptr->firstfile; iarg < argc; iarg++) { outfits[0] = '\0'; if (strlen(argv[iarg]) > SZ_STR - 4) { /* allow for .fz or .gz suffix */ fp_msg ("Error: input file name\n "); fp_msg (argv[iarg]); fp_msg ("\n is too long\n"); fp_noop (); exit (-1); } strncpy (infits, argv[iarg], SZ_STR); if (infits[0] == '-' && infits[1] != '\0') { /* don't interpret this as intending to read input file from stdin */ fp_msg ("Error: invalid input file name\n "); fp_msg (argv[iarg]); fp_msg ("\n"); fp_noop (); exit (-1); } if (strchr (infits, '[') || strchr (infits, ']')) { fp_msg ("Error: section/extension notation not supported: "); fp_msg (infits); fp_msg ("\n"); fp_noop (); exit (-1); } if (unpack) { /* ********** This section applies to funpack ************ */ /* check that input file exists */ if (infits[0] != '-') { /* if not reading from stdin stream */ if (fp_access (infits) != 0) { /* if not, then check if */ strcat(infits, ".fz"); /* a .fz version exsits */ if (fp_access (infits) != 0) { namelen = strlen(infits); infits[namelen - 3] = '\0'; /* remove the .fz suffix */ fp_msg ("Error: can't find or read input file "); fp_msg (infits); fp_msg ("\n"); fp_noop (); exit (-1); } } else { /* make sure a .fz version of the same file doesn't exist */ namelen = strlen(infits); strcat(infits, ".fz"); if (fp_access (infits) == 0) { infits[namelen] = '\0'; /* remove the .fz suffix */ fp_msg ("Error: ambiguous input file name. Which file should be unpacked?:\n "); fp_msg (infits); fp_msg ("\n "); fp_msg (infits); fp_msg (".fz\n"); fp_noop (); exit (-1); } else { infits[namelen] = '\0'; /* remove the .fz suffix */ } } } /* if writing to stdout, then we are all done */ if (fpptr->to_stdout) { continue; } if (fpptr->outfile[0]) { /* user specified output file name */ nfiles++; if (nfiles > 1) { fp_msg ("Error: cannot use same output file name for multiple files:\n "); fp_msg (fpptr->outfile); fp_msg ("\n"); fp_noop (); exit (-1); } /* check that output file doesn't exist */ if (fp_access (fpptr->outfile) == 0) { fp_msg ("Error: output file already exists:\n "); fp_msg (fpptr->outfile); fp_msg ("\n "); fp_noop (); exit (-1); } continue; } /* construct output file name to test */ if (fpptr->prefix[0]) { if (strlen(fpptr->prefix) + strlen(infits) > SZ_STR - 1) { fp_msg ("Error: output file name for\n "); fp_msg (infits); fp_msg ("\n is too long with the prefix\n"); fp_noop (); exit (-1); } strcat(outfits,fpptr->prefix); } /* construct output file name */ if (infits[0] == '-') { strcpy(outfits, "output.fits"); } else { strcpy(outfits, infits); } /* remove .gz suffix, if present (output is not gzipped) */ namelen = strlen(outfits); if ( !strcmp(".gz", outfits + namelen - 3) ) { outfits[namelen - 3] = '\0'; } /* check for .fz suffix that is sometimes required */ /* and remove it if present */ if (infits[0] != '-') { /* if not reading from stdin stream */ namelen = strlen(outfits); if ( !strcmp(".fz", outfits + namelen - 3) ) { /* suffix is present */ outfits[namelen - 3] = '\0'; } else if (fpptr->delete_suffix) { /* required suffix is missing */ fp_msg ("Error: input compressed file "); fp_msg (infits); fp_msg ("\n does not have the default .fz suffix.\n"); fp_noop (); exit (-1); } } /* if infits != outfits, make sure outfits doesn't already exist */ if (strcmp(infits, outfits)) { if (fp_access (outfits) == 0) { fp_msg ("Error: output file already exists:\n "); fp_msg (outfits); fp_msg ("\n "); fp_noop (); exit (-1); } } /* if gzipping the output, make sure .gz file doesn't exist */ if (fpptr->do_gzip_file) { strcat(outfits, ".gz"); if (fp_access (outfits) == 0) { fp_msg ("Error: output file already exists:\n "); fp_msg (outfits); fp_msg ("\n "); fp_noop (); exit (-1); } namelen = strlen(outfits); outfits[namelen - 3] = '\0'; /* remove the .gz suffix again */ } } else { /* ********** This section applies to fpack ************ */ /* check that input file exists */ if (infits[0] != '-') { /* if not reading from stdin stream */ if (fp_access (infits) != 0) { /* if not, then check if */ strcat(infits, ".gz"); /* a gzipped version exsits */ if (fp_access (infits) != 0) { namelen = strlen(infits); infits[namelen - 3] = '\0'; /* remove the .gz suffix */ fp_msg ("Error: can't find or read input file "); fp_msg (infits); fp_msg ("\n"); fp_noop (); exit (-1); } } } /* make sure the file to pack does not already have a .fz suffix */ namelen = strlen(infits); if ( !strcmp(".fz", infits + namelen - 3) ) { fp_msg ("Error: fpack input file already has '.fz' suffix\n" ); fp_msg (infits); fp_msg ("\n"); fp_noop (); exit (-1); } /* if writing to stdout, or just testing the files, then we are all done */ if (fpptr->to_stdout || fpptr->test_all) { continue; } /* construct output file name */ if (infits[0] == '-') { strcpy(outfits, "input.fits"); } else { strcpy(outfits, infits); } /* remove .gz suffix, if present (output is not gzipped) */ namelen = strlen(outfits); if ( !strcmp(".gz", outfits + namelen - 3) ) { outfits[namelen - 3] = '\0'; } /* remove .imh suffix (IRAF format image), and replace with .fits */ namelen = strlen(outfits); if ( !strcmp(".imh", outfits + namelen - 4) ) { outfits[namelen - 4] = '\0'; strcat(outfits, ".fits"); } /* If not clobbering the input file, add .fz suffix to output name */ if (! fpptr->clobber) strcat(outfits, ".fz"); /* if infits != outfits, make sure outfits doesn't already exist */ if (strcmp(infits, outfits)) { if (fp_access (outfits) == 0) { fp_msg ("Error: output file already exists:\n "); fp_msg (outfits); fp_msg ("\n "); fp_noop (); exit (-1); } } } /* end of fpack section */ } fpptr->preflight_checked++; return(0); } /*--------------------------------------------------------------------------*/ /* must run fp_preflight() before fp_loop() */ int fp_loop (int argc, char *argv[], int unpack, fpstate fpvar) { char infits[SZ_STR], outfits[SZ_STR]; char temp[SZ_STR], answer[30]; int iarg, islossless, namelen, iraf_infile = 0, status = 0, ifail; if (fpvar.initialized != FP_INIT_MAGIC) { fp_msg ("Error: internal initialization error\n"); exit (-1); } else if (! fpvar.preflight_checked) { fp_msg ("Error: internal preflight error\n"); exit (-1); } if (fpvar.test_all && fpvar.outfile[0]) { outreport = fopen(fpvar.outfile, "w"); fprintf(outreport," Filename Extension BITPIX NAXIS1 NAXIS2 Size N_nulls Minval Maxval Mean Sigm Noise1 Noise2 Noise3 Noise5 T_whole T_rowbyrow "); fprintf(outreport,"[Comp_ratio, Pack_cpu, Unpack_cpu, Lossless readtimes] (repeated for Rice, Hcompress, and GZIP)\n"); } tempfilename[0] = '\0'; tempfilename2[0] = '\0'; tempfilename3[0] = '\0'; /* set up signal handler to delete temporary file on abort */ #ifdef SIGINT if (signal(SIGINT, SIG_IGN) != SIG_IGN) { (void) signal(SIGINT, abort_fpack); } #endif #ifdef SIGTERM if (signal(SIGTERM, SIG_IGN) != SIG_IGN) { (void) signal(SIGTERM, abort_fpack); } #endif #ifdef SIGHUP if (signal(SIGHUP, SIG_IGN) != SIG_IGN) { (void) signal(SIGHUP, abort_fpack); } #endif for (iarg=fpvar.firstfile; iarg < argc; iarg++) { temp[0] = '\0'; outfits[0] = '\0'; islossless = 1; strncpy (infits, argv[iarg], SZ_STR - 1); if (unpack) { /* ********** This section applies to funpack ************ */ /* find input file */ if (infits[0] != '-') { /* if not reading from stdin stream */ if (fp_access (infits) != 0) { /* if not, then */ strcat(infits, ".fz"); /* a .fz version must exsit */ } } if (fpvar.to_stdout) { strcpy(outfits, "-"); } else if (fpvar.outfile[0]) { /* user specified output file name */ strcpy(outfits, fpvar.outfile); } else { /* construct output file name */ if (fpvar.prefix[0]) { strcat(outfits,fpvar.prefix); } /* construct output file name */ if (infits[0] == '-') { strcpy(outfits, "output.fits"); } else { strcpy(outfits, infits); } /* remove .gz suffix, if present (output is not gzipped) */ namelen = strlen(outfits); if ( !strcmp(".gz", outfits + namelen - 3) ) { outfits[namelen - 3] = '\0'; } /* check for .fz suffix that is sometimes required */ /* and remove it if present */ namelen = strlen(outfits); if ( !strcmp(".fz", outfits + namelen - 3) ) { /* suffix is present */ outfits[namelen - 3] = '\0'; } } } else { /* ********** This section applies to fpack ************ */ if (fpvar.to_stdout) { strcpy(outfits, "-"); } else if (! fpvar.test_all) { /* construct output file name */ if (infits[0] == '-') { strcpy(outfits, "input.fits"); } else { strcpy(outfits, infits); } /* remove .gz suffix, if present (output is not gzipped) */ namelen = strlen(outfits); if ( !strcmp(".gz", outfits + namelen - 3) ) { outfits[namelen - 3] = '\0'; } /* remove .imh suffix (IRAF format image), and replace with .fits */ namelen = strlen(outfits); if ( !strcmp(".imh", outfits + namelen - 4) ) { outfits[namelen - 4] = '\0'; strcat(outfits, ".fits"); iraf_infile = 1; /* this is an IRAF format input file */ /* change the output name to "NAME.fits.fz" */ } /* If not clobbering the input file, add .fz suffix to output name */ if (! fpvar.clobber) strcat(outfits, ".fz"); } } strncpy(temp, outfits, SZ_STR-1); if (infits[0] != '-') { /* if not reading from stdin stream */ if (!strcmp(infits, outfits) ) { /* are input and output names the same? */ /* clobber the input file with the output file with the same name */ if (! fpvar.clobber) { fp_msg ("\nError: must use -F flag to clobber input file.\n"); exit (-1); } /* create temporary file name in the output directory (same as input directory)*/ fp_tmpnam("Tmp1", infits, outfits); strcpy(tempfilename, outfits); /* store temp file name, in case of abort */ } } /* *************** now do the real work ********************* */ if (fpvar.verbose && ! fpvar.to_stdout) printf("%s ", infits); if (fpvar.test_all) { /* compare all the algorithms */ /* create 2 temporary file names, in the CWD */ fp_tmpnam("Tmpfile1", "", tempfilename); fp_tmpnam("Tmpfile2", "", tempfilename2); fp_test (infits, tempfilename, tempfilename2, fpvar); remove(tempfilename); tempfilename[0] = '\0'; /* clear the temp file name */ remove(tempfilename2); tempfilename2[0] = '\0'; continue; } else if (unpack) { if (fpvar.to_stdout) { /* unpack the input file to the stdout stream */ fp_unpack (infits, outfits, fpvar); } else { /* unpack to temporary file, so other tasks can't open it until it is renamed */ /* create temporary file name, in the output directory */ fp_tmpnam("Tmp2", outfits, tempfilename2); /* unpack the input file to the temporary file */ fp_unpack (infits, tempfilename2, fpvar); /* rename the temporary file to it's real name */ ifail = rename(tempfilename2, outfits); if (ifail) { fp_msg("Failed to rename temporary file name:\n "); fp_msg(tempfilename2); fp_msg(" -> "); fp_msg(outfits); fp_msg("\n"); exit (-1); } else { tempfilename2[0] = '\0'; /* clear temporary file name */ } } } else { fp_pack (infits, outfits, fpvar, &islossless); } if (fpvar.to_stdout) { continue; } /* ********** clobber and/or delete files, if needed ************** */ if (!strcmp(infits, temp) && fpvar.clobber ) { if (!islossless && ! fpvar.do_not_prompt) { fp_msg ("\nFile "); fp_msg (infits); fp_msg ("\nwas compressed with a LOSSY method. Overwrite the\n"); fp_msg ("original file with the compressed version? (Y/N) "); fgets(answer, 29, stdin); if (answer[0] != 'Y' && answer[0] != 'y') { fp_msg ("\noriginal file NOT overwritten!\n"); remove(outfits); continue; } } if (iraf_infile) { /* special case of deleting an IRAF format header and pixel file */ if (fits_delete_iraf_file(infits, &status)) { fp_msg("\nError deleting IRAF .imh and .pix files.\n"); fp_msg(infits); fp_msg ("\n"); exit (-1); } } #if defined(unix) || defined(__unix__) || defined(__unix) /* rename clobbers input on Unix platforms */ if (rename (outfits, temp) != 0) { fp_msg ("\nError renaming tmp file to "); fp_msg (temp); fp_msg ("\n"); exit (-1); } #else /* rename DOES NOT clobber existing files on Windows platforms */ /* so explicitly remove any existing file before renaming the file */ remove(temp); if (rename (outfits, temp) != 0) { fp_msg ("\nError renaming tmp file to "); fp_msg (temp); fp_msg ("\n"); exit (-1); } #endif tempfilename[0] = '\0'; /* clear temporary file name */ strcpy(outfits, temp); } else if (fpvar.clobber || fpvar.delete_input) { /* delete the input file */ if (!islossless && !fpvar.do_not_prompt) { /* user did not turn off delete prompt */ fp_msg ("\nFile "); fp_msg (infits); fp_msg ("\nwas compressed with a LOSSY method. \n"); fp_msg ("Delete the original file? (Y/N) "); fgets(answer, 29, stdin); if (answer[0] != 'Y' && answer[0] != 'y') { /* user abort */ fp_msg ("\noriginal file NOT deleted!\n"); } else { if (iraf_infile) { /* special case of deleting an IRAF format header and pixel file */ if (fits_delete_iraf_file(infits, &status)) { fp_msg("\nError deleting IRAF .imh and .pix files.\n"); fp_msg(infits); fp_msg ("\n"); exit (-1); } } else if (remove(infits) != 0) { /* normal case of deleting input FITS file */ fp_msg ("\nError deleting input file "); fp_msg (infits); fp_msg ("\n"); exit (-1); } } } else { /* user said don't prompt, so just delete the input file */ if (iraf_infile) { /* special case of deleting an IRAF format header and pixel file */ if (fits_delete_iraf_file(infits, &status)) { fp_msg("\nError deleting IRAF .imh and .pix files.\n"); fp_msg(infits); fp_msg ("\n"); exit (-1); } } else if (remove(infits) != 0) { /* normal case of deleting input FITS file */ fp_msg ("\nError deleting input file "); fp_msg (infits); fp_msg ("\n"); exit (-1); } } } iraf_infile = 0; if (fpvar.do_gzip_file) { /* gzip the output file */ strcpy(temp, "gzip -1 "); strcat(temp,outfits); system(temp); strcat(outfits, ".gz"); /* only possibible with funpack */ } if (fpvar.verbose && ! fpvar.to_stdout) printf("-> %s\n", outfits); } if (fpvar.test_all && fpvar.outfile[0]) fclose(outreport); return(0); } /*--------------------------------------------------------------------------*/ /* fp_pack assumes the output file does not exist (checked by preflight) */ int fp_pack (char *infits, char *outfits, fpstate fpvar, int *islossless) { fitsfile *infptr, *outfptr; int stat=0; fits_open_file (&infptr, infits, READONLY, &stat); if (stat) { fits_report_error (stderr, stat); exit (stat); } fits_create_file (&outfptr, outfits, &stat); if (stat) { fp_abort_output(infptr, NULL, stat); } if (stat) { fp_abort_output(infptr, outfptr, stat); } while (! stat) { /* LOOP OVER EACH HDU */ fits_set_lossy_int (outfptr, fpvar.int_to_float, &stat); fits_set_compression_type (outfptr, fpvar.comptype, &stat); fits_set_tile_dim (outfptr, 6, fpvar.ntile, &stat); if (fpvar.no_dither) fits_set_quantize_method(outfptr, -1, &stat); else fits_set_quantize_method(outfptr, fpvar.dither_method, &stat); fits_set_quantize_level (outfptr, fpvar.quantize_level, &stat); fits_set_dither_offset(outfptr, fpvar.dither_offset, &stat); fits_set_hcomp_scale (outfptr, fpvar.scale, &stat); fits_set_hcomp_smooth (outfptr, fpvar.smooth, &stat); fp_pack_hdu (infptr, outfptr, fpvar, islossless, &stat); if (fpvar.do_checksums) { fits_write_chksum (outfptr, &stat); } fits_movrel_hdu (infptr, 1, NULL, &stat); } if (stat == END_OF_FILE) stat = 0; /* set checksum for case of newly created primary HDU */ if (fpvar.do_checksums) { fits_movabs_hdu (outfptr, 1, NULL, &stat); fits_write_chksum (outfptr, &stat); } if (stat) { fp_abort_output(infptr, outfptr, stat); } fits_close_file (outfptr, &stat); fits_close_file (infptr, &stat); return(0); } /*--------------------------------------------------------------------------*/ /* fp_unpack assumes the output file does not exist */ int fp_unpack (char *infits, char *outfits, fpstate fpvar) { fitsfile *infptr, *outfptr; int stat=0, hdutype, extnum, single = 0; char *loc, *hduloc, hduname[SZ_STR]; fits_open_file (&infptr, infits, READONLY, &stat); fits_create_file (&outfptr, outfits, &stat); if (stat) { fp_abort_output(infptr, outfptr, stat); } if (fpvar.extname[0]) { /* unpack a list of HDUs? */ /* move to the first HDU in the list */ hduloc = fpvar.extname; loc = strchr(hduloc, ','); /* look for 'comma' delimiter between names */ if (loc) *loc = '\0'; /* terminate the first name in the string */ strcpy(hduname, hduloc); /* copy the first name into temporary string */ if (loc) hduloc = loc + 1; /* advance to the beginning of the next name, if any */ else { hduloc += strlen(hduname); /* end of the list */ single = 1; /* only 1 HDU is being unpacked */ } if (isdigit( (int) hduname[0]) ) { extnum = strtol(hduname, &loc, 10); /* read the string as an integer */ /* check for junk following the integer */ if (*loc == '\0' ) /* no junk, so move to this HDU number (+1) */ { fits_movabs_hdu(infptr, extnum + 1, &hdutype, &stat); /* move to HDU number */ if (hdutype != IMAGE_HDU) stat = NOT_IMAGE; } else { /* the string is not an integer, so must be the column name */ hdutype = IMAGE_HDU; fits_movnam_hdu(infptr, hdutype, hduname, 0, &stat); } } else { /* move to the named image extension */ hdutype = IMAGE_HDU; fits_movnam_hdu(infptr, hdutype, hduname, 0, &stat); } } if (stat) { fp_msg ("Unable to find and move to extension '"); fp_msg(hduname); fp_msg("'\n"); fp_abort_output(infptr, outfptr, stat); } while (! stat) { if (single) stat = -1; /* special status flag to force output primary array */ fp_unpack_hdu (infptr, outfptr, fpvar, &stat); if (fpvar.do_checksums) { fits_write_chksum (outfptr, &stat); } /* move to the next HDU */ if (fpvar.extname[0]) { /* unpack a list of HDUs? */ if (!(*hduloc)) { stat = END_OF_FILE; /* we reached the end of the list */ } else { /* parse the next HDU name and move to it */ loc = strchr(hduloc, ','); if (loc) /* look for 'comma' delimiter between names */ *loc = '\0'; /* terminate the first name in the string */ strcpy(hduname, hduloc); /* copy the next name into temporary string */ if (loc) hduloc = loc + 1; /* advance to the beginning of the next name, if any */ else *hduloc = '\0'; /* end of the list */ if (isdigit( (int) hduname[0]) ) { extnum = strtol(hduname, &loc, 10); /* read the string as an integer */ /* check for junk following the integer */ if (*loc == '\0' ) /* no junk, so move to this HDU number (+1) */ { fits_movabs_hdu(infptr, extnum + 1, &hdutype, &stat); /* move to HDU number */ if (hdutype != IMAGE_HDU) stat = NOT_IMAGE; } else { /* the string is not an integer, so must be the column name */ hdutype = IMAGE_HDU; fits_movnam_hdu(infptr, hdutype, hduname, 0, &stat); } } else { /* move to the named image extension */ hdutype = IMAGE_HDU; fits_movnam_hdu(infptr, hdutype, hduname, 0, &stat); } if (stat) { fp_msg ("Unable to find and move to extension '"); fp_msg(hduname); fp_msg("'\n"); } } } else { /* increment to the next HDU */ fits_movrel_hdu (infptr, 1, NULL, &stat); } } if (stat == END_OF_FILE) stat = 0; /* set checksum for case of newly created primary HDU */ if (fpvar.do_checksums) { fits_movabs_hdu (outfptr, 1, NULL, &stat); fits_write_chksum (outfptr, &stat); } if (stat) { fp_abort_output(infptr, outfptr, stat); } fits_close_file (outfptr, &stat); fits_close_file (infptr, &stat); return(0); } /*--------------------------------------------------------------------------*/ /* fp_test assumes the output files do not exist */ int fp_test (char *infits, char *outfits, char *outfits2, fpstate fpvar) { fitsfile *inputfptr, *infptr, *outfptr, *outfptr2, *tempfile; long naxes[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1}; long tilesize[9] = {0,1,1,1,1,1,1,1,1}; int stat=0, totpix=0, naxis=0, ii, hdutype, bitpix = 0, extnum = 0, len; int tstatus = 0, hdunum, rescale_flag, bpix, ncols; char dtype[8], dimen[100]; double bscale, rescale, noisemin; long headstart, datastart, dataend; float origdata = 0., whole_cpu, whole_elapse, row_elapse, row_cpu, xbits; LONGLONG nrows; /* structure to hold image statistics (defined in fpack.h) */ imgstats imagestats; fits_open_file (&inputfptr, infits, READONLY, &stat); fits_create_file (&outfptr, outfits, &stat); fits_create_file (&outfptr2, outfits2, &stat); if (stat) { fits_report_error (stderr, stat); exit (stat); } while (! stat) { /* LOOP OVER EACH HDU */ rescale_flag = 0; fits_get_hdu_type (inputfptr, &hdutype, &stat); if (hdutype == IMAGE_HDU) { fits_get_img_param (inputfptr, 9, &bitpix, &naxis, naxes, &stat); for (totpix=1, ii=0; ii < 9; ii++) totpix *= naxes[ii]; } if (!fits_is_compressed_image (inputfptr, &stat) && hdutype == IMAGE_HDU && naxis != 0 && totpix != 0 && fpvar.do_images) { /* rescale a scaled integer image to reduce noise? */ if (fpvar.rescale_noise != 0. && bitpix > 0 && bitpix < LONGLONG_IMG) { tstatus = 0; fits_read_key(inputfptr, TDOUBLE, "BSCALE", &bscale, 0, &tstatus); if (tstatus == 0 && bscale != 1.0) { /* image must be scaled */ if (bitpix == LONG_IMG) fp_i4stat(inputfptr, naxis, naxes, &imagestats, &stat); else fp_i2stat(inputfptr, naxis, naxes, &imagestats, &stat); /* use the minimum of the MAD 2nd, 3rd, and 5th order noise estimates */ noisemin = imagestats.noise3; if (imagestats.noise2 != 0. && imagestats.noise2 < noisemin) noisemin = imagestats.noise2; if (imagestats.noise5 != 0. && imagestats.noise5 < noisemin) noisemin = imagestats.noise5; rescale = noisemin / fpvar.rescale_noise; if (rescale > 1.0) { /* all the criteria are met, so create a temporary file that */ /* contains a rescaled version of the image, in CWD */ /* create temporary file name */ fp_tmpnam("Tmpfile3", "", tempfilename3); fits_create_file(&tempfile, tempfilename3, &stat); fits_get_hdu_num(inputfptr, &hdunum); if (hdunum != 1) { /* the input hdu is an image extension, so create dummy primary */ fits_create_img(tempfile, 8, 0, naxes, &stat); } fits_copy_header(inputfptr, tempfile, &stat); /* copy the header */ /* rescale the data, so that it will compress more efficiently */ if (bitpix == LONG_IMG) fp_i4rescale(inputfptr, naxis, naxes, rescale, tempfile, &stat); else fp_i2rescale(inputfptr, naxis, naxes, rescale, tempfile, &stat); /* scale the BSCALE keyword by the inverse factor */ bscale = bscale * rescale; fits_update_key(tempfile, TDOUBLE, "BSCALE", &bscale, 0, &stat); /* rescan the header, to reset the actual scaling parameters */ fits_set_hdustruc(tempfile, &stat); infptr = tempfile; rescale_flag = 1; } } } if (!rescale_flag) /* just compress the input file, without rescaling */ infptr = inputfptr; /* compute basic statistics about the input image */ if (bitpix == BYTE_IMG) { bpix = 8; strcpy(dtype, "8 "); fp_i2stat(infptr, naxis, naxes, &imagestats, &stat); } else if (bitpix == SHORT_IMG) { bpix = 16; strcpy(dtype, "16 "); fp_i2stat(infptr, naxis, naxes, &imagestats, &stat); } else if (bitpix == LONG_IMG) { bpix = 32; strcpy(dtype, "32 "); fp_i4stat(infptr, naxis, naxes, &imagestats, &stat); } else if (bitpix == LONGLONG_IMG) { bpix = 64; strcpy(dtype, "64 "); } else if (bitpix == FLOAT_IMG) { bpix = 32; strcpy(dtype, "-32"); fp_r4stat(infptr, naxis, naxes, &imagestats, &stat); } else if (bitpix == DOUBLE_IMG) { bpix = 64; strcpy(dtype, "-64"); fp_r4stat(infptr, naxis, naxes, &imagestats, &stat); } /* use the minimum of the MAD 2nd, 3rd, and 5th order noise estimates */ noisemin = imagestats.noise3; if (imagestats.noise2 != 0. && imagestats.noise2 < noisemin) noisemin = imagestats.noise2; if (imagestats.noise5 != 0. && imagestats.noise5 < noisemin) noisemin = imagestats.noise5; xbits = (float) (log10(noisemin)/.301 + 1.792); printf("\n File: %s\n", infits); printf(" Ext BITPIX Dimens. Nulls Min Max Mean Sigma Noise2 Noise3 Noise5 Nbits MaxR\n"); printf(" %3d %s", extnum, dtype); sprintf(dimen," (%ld", naxes[0]); len =strlen(dimen); for (ii = 1; ii < naxis; ii++) { sprintf(dimen+len,",%ld", naxes[ii]); len =strlen(dimen); } strcat(dimen, ")"); printf("%-12s",dimen); fits_get_hduaddr(inputfptr, &headstart, &datastart, &dataend, &stat); origdata = (float) ((dataend - datastart)/1000000.); /* get elapsed and cpu times need to read the uncompressed image */ fits_read_image_speed (infptr, &whole_elapse, &whole_cpu, &row_elapse, &row_cpu, &stat); printf(" %5d %6.0f %6.0f %8.1f %#8.2g %#7.3g %#7.3g %#7.3g %#5.1f %#6.2f\n", imagestats.n_nulls, imagestats.minval, imagestats.maxval, imagestats.mean, imagestats.sigma, imagestats.noise2, imagestats.noise3, imagestats.noise5, xbits, bpix/xbits); printf("\n Type Ratio Size (MB) Pk (Sec) UnPk Exact ElpN CPUN Elp1 CPU1\n"); printf(" Native %5.3f %5.3f %5.3f %5.3f\n", whole_elapse, whole_cpu, row_elapse, row_cpu); if (fpvar.outfile[0]) { fprintf(outreport, " %s %d %d %ld %ld %#10.4g %d %#10.4g %#10.4g %#10.4g %#10.4g %#10.4g %#10.4g %#10.4g %#10.4g %#10.4g %#10.4g %#10.4g %#10.4g", infits, extnum, bitpix, naxes[0], naxes[1], origdata, imagestats.n_nulls, imagestats.minval, imagestats.maxval, imagestats.mean, imagestats.sigma, imagestats.noise1, imagestats.noise2, imagestats.noise3, imagestats.noise5, whole_elapse, whole_cpu, row_elapse, row_cpu); } fits_set_lossy_int (outfptr, fpvar.int_to_float, &stat); if ( (bitpix > 0) && (fpvar.int_to_float != 0) ) { if ( (noisemin < (fpvar.n3ratio * fpvar.quantize_level) ) || (noisemin < fpvar.n3min)) { /* image contains too little noise to quantize effectively */ fits_set_lossy_int (outfptr, 0, &stat); fits_get_hdu_num(infptr, &hdunum); printf(" HDU %d does not meet noise criteria to be quantized, so losslessly compressed.\n", hdunum); } } /* test compression ratio and speed for each algorithm */ if (fpvar.quantize_level != 0) { fits_set_compression_type (outfptr, RICE_1, &stat); fits_set_tile_dim (outfptr, 6, fpvar.ntile, &stat); if (fpvar.no_dither) fits_set_quantize_method(outfptr, -1, &stat); else fits_set_quantize_method(outfptr, fpvar.dither_method, &stat); fits_set_quantize_level (outfptr, fpvar.quantize_level, &stat); fits_set_dither_offset(outfptr, fpvar.dither_offset, &stat); fits_set_hcomp_scale (outfptr, fpvar.scale, &stat); fits_set_hcomp_smooth (outfptr, fpvar.smooth, &stat); fp_test_hdu(infptr, outfptr, outfptr2, fpvar, &stat); } if (fpvar.quantize_level != 0) { \ fits_set_compression_type (outfptr, HCOMPRESS_1, &stat); fits_set_tile_dim (outfptr, 6, fpvar.ntile, &stat); if (fpvar.no_dither) fits_set_quantize_method(outfptr, -1, &stat); else fits_set_quantize_method(outfptr, fpvar.dither_method, &stat); fits_set_quantize_level (outfptr, fpvar.quantize_level, &stat); fits_set_dither_offset(outfptr, fpvar.dither_offset, &stat); fits_set_hcomp_scale (outfptr, fpvar.scale, &stat); fits_set_hcomp_smooth (outfptr, fpvar.smooth, &stat); fp_test_hdu(infptr, outfptr, outfptr2, fpvar, &stat); } if (fpvar.comptype == GZIP_2) { fits_set_compression_type (outfptr, GZIP_2, &stat); } else { fits_set_compression_type (outfptr, GZIP_1, &stat); } fits_set_tile_dim (outfptr, 6, fpvar.ntile, &stat); if (fpvar.no_dither) fits_set_quantize_method(outfptr, -1, &stat); else fits_set_quantize_method(outfptr, fpvar.dither_method, &stat); fits_set_quantize_level (outfptr, fpvar.quantize_level, &stat); fits_set_dither_offset(outfptr, fpvar.dither_offset, &stat); fits_set_hcomp_scale (outfptr, fpvar.scale, &stat); fits_set_hcomp_smooth (outfptr, fpvar.smooth, &stat); fp_test_hdu(infptr, outfptr, outfptr2, fpvar, &stat); /* fits_set_compression_type (outfptr, BZIP2_1, &stat); fits_set_tile_dim (outfptr, 6, fpvar.ntile, &stat); fp_test_hdu(infptr, outfptr, outfptr2, fpvar, &stat); */ /* fits_set_compression_type (outfptr, PLIO_1, &stat); fits_set_tile_dim (outfptr, 6, fpvar.ntile, &stat); fp_test_hdu(infptr, outfptr, outfptr2, fpvar, &stat); */ /* if (bitpix == SHORT_IMG || bitpix == LONG_IMG) { fits_set_compression_type (outfptr, NOCOMPRESS, &stat); fits_set_tile_dim (outfptr, 6, fpvar.ntile, &stat); fp_test_hdu(infptr, outfptr, outfptr2, fpvar, &stat); } */ if (fpvar.outfile[0]) fprintf(outreport,"\n"); /* delete the temporary file */ if (rescale_flag) { fits_delete_file (infptr, &stat); tempfilename3[0] = '\0'; /* clear the temp filename */ } } else if ( (hdutype == BINARY_TBL) && fpvar.do_tables) { fits_get_num_rowsll(inputfptr, &nrows, &stat); fits_get_num_cols(inputfptr, &ncols, &stat); printf("\n File: %s, HDU %d, %d cols X %ld rows\n", infits, extnum, ncols, nrows); fp_test_table(inputfptr, outfptr, outfptr2, fpvar, &stat); } else { fits_copy_hdu (inputfptr, outfptr, 0, &stat); fits_copy_hdu (inputfptr, outfptr2, 0, &stat); } fits_movrel_hdu (inputfptr, 1, NULL, &stat); extnum++; } if (stat == END_OF_FILE) stat = 0; fits_close_file (outfptr2, &stat); fits_close_file (outfptr, &stat); fits_close_file (inputfptr, &stat); if (stat) { fits_report_error (stderr, stat); } return(0); } /*--------------------------------------------------------------------------*/ int fp_pack_hdu (fitsfile *infptr, fitsfile *outfptr, fpstate fpvar, int *islossless, int *status) { fitsfile *tempfile; long naxes[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1}; int stat=0, totpix=0, naxis=0, ii, hdutype, bitpix; int tstatus, hdunum, rescale_flag = 0; double bscale, rescale; char outfits[SZ_STR], fzalgor[FLEN_VALUE]; long headstart, datastart, dataend, datasize; double noisemin; /* structure to hold image statistics (defined in fpack.h) */ imgstats imagestats; if (*status) return(0); fits_get_hdu_type (infptr, &hdutype, &stat); if (hdutype == IMAGE_HDU) { fits_get_img_param (infptr, 9, &bitpix, &naxis, naxes, &stat); for (totpix=1, ii=0; ii < 9; ii++) totpix *= naxes[ii]; } /* check directive keyword to see if this HDU should not be compressed */ tstatus = 0; if (!fits_read_key(infptr, TSTRING, "FZALGOR", fzalgor, NULL, &tstatus) ) { if (!strcmp(fzalgor, "NONE") || !strcmp(fzalgor, "none") ) { fits_copy_hdu (infptr, outfptr, 0, &stat); } *status = stat; return(0); } /* =============================================================== */ /* This block is only for binary table compression */ if (hdutype == BINARY_TBL && fpvar.do_tables) { fits_get_hduaddr(infptr, &headstart, &datastart, &dataend, status); datasize = dataend - datastart; if (datasize <= 2880) { /* data is less than 1 FITS block in size, so don't compress */ fits_copy_hdu (infptr, outfptr, 0, &stat); } else { fits_compress_table (infptr, outfptr, &stat); } *status = stat; return(0); } /* =============================================================== */ /* If this is not a non-null image HDU, just copy it verbatim */ if (fits_is_compressed_image (infptr, &stat) || hdutype != IMAGE_HDU || naxis == 0 || totpix == 0 || !fpvar.do_images) { fits_copy_hdu (infptr, outfptr, 0, &stat); } else { /* remaining code deals only with IMAGE HDUs */ /* special case: rescale a scaled integer image to reduce noise? */ if (fpvar.rescale_noise != 0. && bitpix > 0 && bitpix < LONGLONG_IMG) { tstatus = 0; fits_read_key(infptr, TDOUBLE, "BSCALE", &bscale, 0, &tstatus); if (tstatus == 0 && bscale != 1.0) { /* image must be scaled */ if (bitpix == LONG_IMG) fp_i4stat(infptr, naxis, naxes, &imagestats, &stat); else fp_i2stat(infptr, naxis, naxes, &imagestats, &stat); /* use the minimum of the MAD 2nd, 3rd, and 5th order noise estimates */ noisemin = imagestats.noise3; if (imagestats.noise2 != 0. && imagestats.noise2 < noisemin) noisemin = imagestats.noise2; if (imagestats.noise5 != 0. && imagestats.noise5 < noisemin) noisemin = imagestats.noise5; rescale = noisemin / fpvar.rescale_noise; if (rescale > 1.0) { /* all the criteria are met, so create a temporary file that */ /* contains a rescaled version of the image, in output directory */ /* create temporary file name */ fits_file_name(outfptr, outfits, &stat); /* get the output file name */ fp_tmpnam("Tmp3", outfits, tempfilename3); fits_create_file(&tempfile, tempfilename3, &stat); fits_get_hdu_num(infptr, &hdunum); if (hdunum != 1) { /* the input hdu is an image extension, so create dummy primary */ fits_create_img(tempfile, 8, 0, naxes, &stat); } fits_copy_header(infptr, tempfile, &stat); /* copy the header */ /* rescale the data, so that it will compress more efficiently */ if (bitpix == LONG_IMG) fp_i4rescale(infptr, naxis, naxes, rescale, tempfile, &stat); else fp_i2rescale(infptr, naxis, naxes, rescale, tempfile, &stat); /* scale the BSCALE keyword by the inverse factor */ bscale = bscale * rescale; fits_update_key(tempfile, TDOUBLE, "BSCALE", &bscale, 0, &stat); /* rescan the header, to reset the actual scaling parameters */ fits_set_hdustruc(tempfile, &stat); fits_img_compress (tempfile, outfptr, &stat); fits_delete_file (tempfile, &stat); tempfilename3[0] = '\0'; /* clear the temp filename */ *islossless = 0; /* used a lossy compression method */ *status = stat; return(0); } } } /* if requested to do lossy compression of integer images (by */ /* converting to float), then check if this HDU qualifies */ if ( (bitpix > 0) && (fpvar.int_to_float != 0) ) { if (bitpix >= LONG_IMG) fp_i4stat(infptr, naxis, naxes, &imagestats, &stat); else fp_i2stat(infptr, naxis, naxes, &imagestats, &stat); /* use the minimum of the MAD 2nd, 3rd, and 5th order noise estimates */ noisemin = imagestats.noise3; if (imagestats.noise2 != 0. && imagestats.noise2 < noisemin) noisemin = imagestats.noise2; if (imagestats.noise5 != 0. && imagestats.noise5 < noisemin) noisemin = imagestats.noise5; if ( (noisemin < (fpvar.n3ratio * fpvar.quantize_level) ) || (imagestats.noise3 < fpvar.n3min)) { /* image contains too little noise to quantize effectively */ fits_set_lossy_int (outfptr, 0, &stat); fits_get_hdu_num(infptr, &hdunum); printf(" HDU %d does not meet noise criteria to be quantized, so losslessly compressed.\n", hdunum); } else { /* compressed image is not identical to original */ *islossless = 0; } } /* finally, do the actual image compression */ fits_img_compress (infptr, outfptr, &stat); if (bitpix < 0 || (fpvar.comptype == HCOMPRESS_1 && fpvar.scale != 0.)) { /* compressed image is not identical to original */ *islossless = 0; } } *status = stat; return(0); } /*--------------------------------------------------------------------------*/ int fp_unpack_hdu (fitsfile *infptr, fitsfile *outfptr, fpstate fpvar, int *status) { int hdutype, lval; if (*status > 0) return(0); fits_get_hdu_type (infptr, &hdutype, status); /* =============================================================== */ /* This block is only for beta testing of binary table compression */ if (hdutype == BINARY_TBL) { fits_read_key(infptr, TLOGICAL, "ZTABLE", &lval, NULL, status); if (*status == 0 && lval != 0) { /* uncompress the table */ fits_uncompress_table (infptr, outfptr, status); } else { if (*status == KEY_NO_EXIST) /* table is not compressed */ *status = 0; fits_copy_hdu (infptr, outfptr, 0, status); } return(0); /* =============================================================== */ } else if (fits_is_compressed_image (infptr, status)) { /* uncompress the compressed image HDU */ fits_img_decompress (infptr, outfptr, status); } else { /* not a compressed image HDU, so just copy it to the output */ fits_copy_hdu (infptr, outfptr, 0, status); } return(0); } /*--------------------------------------------------------------------------*/ int fits_read_image_speed (fitsfile *infptr, float *whole_elapse, float *whole_cpu, float *row_elapse, float *row_cpu, int *status) { unsigned char *carray, cnull = 0; short *sarray, snull=0; int bitpix, naxis, anynull, *iarray, inull = 0; long ii, naxes[9], fpixel[9]={1,1,1,1,1,1,1,1,1}, lpixel[9]={1,1,1,1,1,1,1,1,1}; long inc[9]={1,1,1,1,1,1,1,1,1} ; float *earray, enull = 0, filesize; double *darray, dnull = 0; if (*status) return(*status); fits_get_img_param (infptr, 9, &bitpix, &naxis, naxes, status); if (naxis != 2)return(*status); lpixel[0] = naxes[0]; lpixel[1] = naxes[1]; /* filesize in MB */ filesize = (float) (naxes[0] * abs(bitpix) / 8000000. * naxes[1]); /* measure time required to read the raw image */ fits_set_bscale(infptr, 1.0, 0.0, status); *whole_elapse = 0.; *whole_cpu = 0; if (bitpix == BYTE_IMG) { carray = calloc(naxes[1]*naxes[0], sizeof(char)); /* remove any cached uncompressed tile (dangerous to directly modify the structure!) */ /* (infptr->Fptr)->tilerow = 0; */ marktime(status); fits_read_subset(infptr, TBYTE, fpixel, lpixel, inc, &cnull, carray, &anynull, status); /* get elapsped times */ gettime(whole_elapse, whole_cpu, status); /* now read the image again, row by row */ if (row_elapse) { /* remove any cached uncompressed tile (dangerous to directly modify the structure!) */ /* (infptr->Fptr)->tilerow = 0; */ marktime(status); for (ii = 0; ii < naxes[1]; ii++) { fpixel[1] = ii+1; fits_read_pix(infptr, TBYTE, fpixel, naxes[0], &cnull, carray, &anynull, status); } /* get elapsped times */ gettime(row_elapse, row_cpu, status); } free(carray); } else if (bitpix == SHORT_IMG) { sarray = calloc(naxes[0]*naxes[1], sizeof(short)); marktime(status); fits_read_subset(infptr, TSHORT, fpixel, lpixel, inc, &snull, sarray, &anynull, status); gettime(whole_elapse, whole_cpu, status); /* get elapsped times */ /* now read the image again, row by row */ if (row_elapse) { marktime(status); for (ii = 0; ii < naxes[1]; ii++) { fpixel[1] = ii+1; fits_read_pix(infptr, TSHORT, fpixel, naxes[0], &snull, sarray, &anynull, status); } /* get elapsped times */ gettime(row_elapse, row_cpu, status); } free(sarray); } else if (bitpix == LONG_IMG) { iarray = calloc(naxes[0]*naxes[1], sizeof(int)); marktime(status); fits_read_subset(infptr, TINT, fpixel, lpixel, inc, &inull, iarray, &anynull, status); /* get elapsped times */ gettime(whole_elapse, whole_cpu, status); /* now read the image again, row by row */ if (row_elapse) { marktime(status); for (ii = 0; ii < naxes[1]; ii++) { fpixel[1] = ii+1; fits_read_pix(infptr, TINT, fpixel, naxes[0], &inull, iarray, &anynull, status); } /* get elapsped times */ gettime(row_elapse, row_cpu, status); } free(iarray); } else if (bitpix == FLOAT_IMG) { earray = calloc(naxes[1]*naxes[0], sizeof(float)); marktime(status); fits_read_subset(infptr, TFLOAT, fpixel, lpixel, inc, &enull, earray, &anynull, status); /* get elapsped times */ gettime(whole_elapse, whole_cpu, status); /* now read the image again, row by row */ if (row_elapse) { marktime(status); for (ii = 0; ii < naxes[1]; ii++) { fpixel[1] = ii+1; fits_read_pix(infptr, TFLOAT, fpixel, naxes[0], &enull, earray, &anynull, status); } /* get elapsped times */ gettime(row_elapse, row_cpu, status); } free(earray); } else if (bitpix == DOUBLE_IMG) { darray = calloc(naxes[1]*naxes[0], sizeof(double)); marktime(status); fits_read_subset(infptr, TDOUBLE, fpixel, lpixel, inc, &dnull, darray, &anynull, status); /* get elapsped times */ gettime(whole_elapse, whole_cpu, status); /* now read the image again, row by row */ if (row_elapse) { marktime(status); for (ii = 0; ii < naxes[1]; ii++) { fpixel[1] = ii+1; fits_read_pix(infptr, TDOUBLE, fpixel, naxes[0], &dnull, darray, &anynull, status); } /* get elapsped times */ gettime(row_elapse, row_cpu, status); } free(darray); } if (whole_elapse) *whole_elapse = *whole_elapse / filesize; if (row_elapse) *row_elapse = *row_elapse / filesize; if (whole_cpu) *whole_cpu = *whole_cpu / filesize; if (row_cpu) *row_cpu = *row_cpu / filesize; return(*status); } /*--------------------------------------------------------------------------*/ int fp_test_hdu (fitsfile *infptr, fitsfile *outfptr, fitsfile *outfptr2, fpstate fpvar, int *status) { /* This routine is only used for performance testing of image HDUs. */ /* Use fp_test_table for testing binary table HDUs. */ int stat = 0, hdutype, comptype, noloss = 0; char ctype[20], lossless[4]; long headstart, datastart, dataend; float origdata = 0., compressdata = 0.; float compratio = 0., packcpu = 0., unpackcpu = 0.; float elapse, whole_elapse, row_elapse, whole_cpu, row_cpu; unsigned long datasum1, datasum2, hdusum; if (*status) return(0); origdata = 0; compressdata = 0; compratio = 0.; lossless[0] = '\0'; fits_get_compression_type(outfptr, &comptype, &stat); if (comptype == RICE_1) strcpy(ctype, "RICE"); else if (comptype == GZIP_1) strcpy(ctype, "GZIP1"); else if (comptype == GZIP_2) strcpy(ctype, "GZIP2");/* else if (comptype == BZIP2_1) strcpy(ctype, "BZIP2"); */ else if (comptype == PLIO_1) strcpy(ctype, "PLIO"); else if (comptype == HCOMPRESS_1) strcpy(ctype, "HCOMP"); else if (comptype == NOCOMPRESS) strcpy(ctype, "NONE"); else { fp_msg ("Error: unsupported image compression type "); *status = DATA_COMPRESSION_ERR; return(0); } /* -------------- COMPRESS the image ------------------ */ marktime(&stat); fits_img_compress (infptr, outfptr, &stat); /* get elapsped times */ gettime(&elapse, &packcpu, &stat); /* get elapsed and cpu times need to read the compressed image */ fits_read_image_speed (outfptr, &whole_elapse, &whole_cpu, &row_elapse, &row_cpu, &stat); if (!stat) { /* -------------- UNCOMPRESS the image ------------------ */ /* remove any cached uncompressed tile (dangerous to directly modify the structure!) */ /* (outfptr->Fptr)->tilerow = 0; */ marktime(&stat); fits_img_decompress (outfptr, outfptr2, &stat); /* get elapsped times */ gettime(&elapse, &unpackcpu, &stat); /* ----------------------------------------------------- */ /* get sizes of original and compressed images */ fits_get_hduaddr(infptr, &headstart, &datastart, &dataend, &stat); origdata = (float) ((dataend - datastart)/1000000.); fits_get_hduaddr(outfptr, &headstart, &datastart, &dataend, &stat); compressdata = (float) ((dataend - datastart)/1000000.); if (compressdata != 0) compratio = (float) origdata / (float) compressdata; /* is this uncompressed image identical to the original? */ fits_get_chksum(infptr, &datasum1, &hdusum, &stat); fits_get_chksum(outfptr2, &datasum2, &hdusum, &stat); if ( datasum1 == datasum2) { strcpy(lossless, "Yes"); noloss = 1; } else { strcpy(lossless, "No"); } printf(" %-5s %6.2f %7.2f ->%7.2f %7.2f %7.2f %s %5.3f %5.3f %5.3f %5.3f\n", ctype, compratio, origdata, compressdata, packcpu, unpackcpu, lossless, whole_elapse, whole_cpu, row_elapse, row_cpu); if (fpvar.outfile[0]) { fprintf(outreport," %6.3f %5.2f %5.2f %s %7.3f %7.3f %7.3f %7.3f", compratio, packcpu, unpackcpu, lossless, whole_elapse, whole_cpu, row_elapse, row_cpu); } /* delete the output HDUs to concerve disk space */ fits_delete_hdu(outfptr, &hdutype, &stat); fits_delete_hdu(outfptr2, &hdutype, &stat); } else { printf(" %-5s (unable to compress image)\n", ctype); } /* try to recover from any compression errors */ if (stat == DATA_COMPRESSION_ERR) stat = 0; *status = stat; return(0); } /*--------------------------------------------------------------------------*/ int fp_test_table (fitsfile *infptr, fitsfile *outfptr, fitsfile *outfptr2, fpstate fpvar, int *status) { /* this routine is for performance testing of the beta table compression methods */ int stat = 0, hdutype, tstatus = 0; char fzalgor[FLEN_VALUE]; LONGLONG headstart, datastart, dataend; float elapse, cpu; if (*status) return(0); /* check directive keyword to see if this HDU should not be compressed */ if (!fits_read_key(infptr, TSTRING, "FZALGOR", fzalgor, NULL, &tstatus) ) { if (!strcmp(fzalgor, "NONE") || !strcmp(fzalgor, "none")) { return(0); } } fits_get_hduaddrll(infptr, &headstart, &datastart, &dataend, status); /* can't compress small tables with less than 2880 bytes of data */ if (dataend - datastart <= 2880) { return(0); } marktime(&stat); stat= -999; /* set special flag value */ fits_compress_table (infptr, outfptr, &stat); /* get elapsped times */ gettime(&elapse, &cpu, &stat); fits_delete_hdu(outfptr, &hdutype, &stat); printf("\nElapsed time = %f, cpu = %f\n", elapse, cpu); fits_report_error (stderr, stat); return(0); } /*--------------------------------------------------------------------------*/ int marktime(int *status) { #if defined(unix) || defined(__unix__) || defined(__unix) struct timeval tv; /* struct timezone tz; */ /* gettimeofday (&tv, &tz); */ gettimeofday (&tv, NULL); startsec = tv.tv_sec; startmilli = tv.tv_usec/1000; scpu = clock(); #else /* don't support high timing precision on Windows machines */ startsec = 0; startmilli = 0; scpu = clock(); #endif return( *status ); } /*--------------------------------------------------------------------------*/ int gettime(float *elapse, float *elapscpu, int *status) { #if defined(unix) || defined(__unix__) || defined(__unix) struct timeval tv; /* struct timezone tz; */ int stopmilli; long stopsec; /* gettimeofday (&tv, &tz); */ gettimeofday (&tv, NULL); ecpu = clock(); stopmilli = tv.tv_usec/1000; stopsec = tv.tv_sec; *elapse = (stopsec - startsec) + (stopmilli - startmilli)/1000.; *elapscpu = (ecpu - scpu) * 1.0 / CLOCKTICKS; /* printf(" (start: %ld + %d), stop: (%ld + %d) elapse: %f\n ", startsec,startmilli,stopsec, stopmilli, *elapse); */ #else /* set the elapsed time the same as the CPU time on Windows machines */ *elapscpu = (float) ((ecpu - scpu) * 1.0 / CLOCKTICKS); *elapse = *elapscpu; #endif return( *status ); } /*--------------------------------------------------------------------------*/ int fp_i2stat(fitsfile *infptr, int naxis, long *naxes, imgstats *imagestats, int *status) { /* read the central XSAMPLE by YSAMPLE region of pixels in the int*2 image, and then compute basic statistics: min, max, mean, sigma, mean diff, etc. */ long fpixel[9] = {1,1,1,1,1,1,1,1,1}; long lpixel[9] = {1,1,1,1,1,1,1,1,1}; long inc[9] = {1,1,1,1,1,1,1,1,1}; long i1, i2, npix, ngood, nx, ny; short *intarray, minvalue, maxvalue, nullvalue; int anynul, tstatus, checknull = 1; double mean, sigma, noise1, noise2, noise3, noise5; /* select the middle XSAMPLE by YSAMPLE area of the image */ i1 = naxes[0]/2 - (XSAMPLE/2 - 1); i2 = naxes[0]/2 + (XSAMPLE/2); if (i1 < 1) i1 = 1; if (i2 > naxes[0]) i2 = naxes[0]; fpixel[0] = i1; lpixel[0] = i2; nx = i2 - i1 +1; if (naxis > 1) { i1 = naxes[1]/2 - (YSAMPLE/2 - 1); i2 = naxes[1]/2 + (YSAMPLE/2); if (i1 < 1) i1 = 1; if (i2 > naxes[1]) i2 = naxes[1]; fpixel[1] = i1; lpixel[1] = i2; } ny = i2 - i1 +1; npix = nx * ny; /* if there are higher dimensions, read the middle plane of the cube */ if (naxis > 2) { fpixel[2] = naxes[2]/2 + 1; lpixel[2] = naxes[2]/2 + 1; } intarray = calloc(npix, sizeof(short)); if (!intarray) { *status = MEMORY_ALLOCATION; return(*status); } /* turn off any scaling of the integer pixel values */ fits_set_bscale(infptr, 1.0, 0.0, status); fits_read_subset_sht(infptr, 0, naxis, naxes, fpixel, lpixel, inc, 0, intarray, &anynul, status); /* read the null value keyword (BLANK) if present */ tstatus = 0; fits_read_key(infptr, TSHORT, "BLANK", &nullvalue, 0, &tstatus); if (tstatus) { nullvalue = 0; checknull = 0; } /* compute statistics of the image */ fits_img_stats_short(intarray, nx, ny, checknull, nullvalue, &ngood, &minvalue, &maxvalue, &mean, &sigma, &noise1, &noise2, &noise3, &noise5, status); imagestats->n_nulls = npix - ngood; imagestats->minval = minvalue; imagestats->maxval = maxvalue; imagestats->mean = mean; imagestats->sigma = sigma; imagestats->noise1 = noise1; imagestats->noise2 = noise2; imagestats->noise3 = noise3; imagestats->noise5 = noise5; free(intarray); return(*status); } /*--------------------------------------------------------------------------*/ int fp_i4stat(fitsfile *infptr, int naxis, long *naxes, imgstats *imagestats, int *status) { /* read the central XSAMPLE by YSAMPLE region of pixels in the int*2 image, and then compute basic statistics: min, max, mean, sigma, mean diff, etc. */ long fpixel[9] = {1,1,1,1,1,1,1,1,1}; long lpixel[9] = {1,1,1,1,1,1,1,1,1}; long inc[9] = {1,1,1,1,1,1,1,1,1}; long i1, i2, npix, ngood, nx, ny; int *intarray, minvalue, maxvalue, nullvalue; int anynul, tstatus, checknull = 1; double mean, sigma, noise1, noise2, noise3, noise5; /* select the middle XSAMPLE by YSAMPLE area of the image */ i1 = naxes[0]/2 - (XSAMPLE/2 - 1); i2 = naxes[0]/2 + (XSAMPLE/2); if (i1 < 1) i1 = 1; if (i2 > naxes[0]) i2 = naxes[0]; fpixel[0] = i1; lpixel[0] = i2; nx = i2 - i1 +1; if (naxis > 1) { i1 = naxes[1]/2 - (YSAMPLE/2 - 1); i2 = naxes[1]/2 + (YSAMPLE/2); if (i1 < 1) i1 = 1; if (i2 > naxes[1]) i2 = naxes[1]; fpixel[1] = i1; lpixel[1] = i2; } ny = i2 - i1 +1; npix = nx * ny; /* if there are higher dimensions, read the middle plane of the cube */ if (naxis > 2) { fpixel[2] = naxes[2]/2 + 1; lpixel[2] = naxes[2]/2 + 1; } intarray = calloc(npix, sizeof(int)); if (!intarray) { *status = MEMORY_ALLOCATION; return(*status); } /* turn off any scaling of the integer pixel values */ fits_set_bscale(infptr, 1.0, 0.0, status); fits_read_subset_int(infptr, 0, naxis, naxes, fpixel, lpixel, inc, 0, intarray, &anynul, status); /* read the null value keyword (BLANK) if present */ tstatus = 0; fits_read_key(infptr, TINT, "BLANK", &nullvalue, 0, &tstatus); if (tstatus) { nullvalue = 0; checknull = 0; } /* compute statistics of the image */ fits_img_stats_int(intarray, nx, ny, checknull, nullvalue, &ngood, &minvalue, &maxvalue, &mean, &sigma, &noise1, &noise2, &noise3, &noise5, status); imagestats->n_nulls = npix - ngood; imagestats->minval = minvalue; imagestats->maxval = maxvalue; imagestats->mean = mean; imagestats->sigma = sigma; imagestats->noise1 = noise1; imagestats->noise2 = noise2; imagestats->noise3 = noise3; imagestats->noise5 = noise5; free(intarray); return(*status); } /*--------------------------------------------------------------------------*/ int fp_r4stat(fitsfile *infptr, int naxis, long *naxes, imgstats *imagestats, int *status) { /* read the central XSAMPLE by YSAMPLE region of pixels in the int*2 image, and then compute basic statistics: min, max, mean, sigma, mean diff, etc. */ long fpixel[9] = {1,1,1,1,1,1,1,1,1}; long lpixel[9] = {1,1,1,1,1,1,1,1,1}; long inc[9] = {1,1,1,1,1,1,1,1,1}; long i1, i2, npix, ngood, nx, ny; float *array, minvalue, maxvalue, nullvalue = FLOATNULLVALUE; int anynul,checknull = 1; double mean, sigma, noise1, noise2, noise3, noise5; /* select the middle XSAMPLE by YSAMPLE area of the image */ i1 = naxes[0]/2 - (XSAMPLE/2 - 1); i2 = naxes[0]/2 + (XSAMPLE/2); if (i1 < 1) i1 = 1; if (i2 > naxes[0]) i2 = naxes[0]; fpixel[0] = i1; lpixel[0] = i2; nx = i2 - i1 +1; if (naxis > 1) { i1 = naxes[1]/2 - (YSAMPLE/2 - 1); i2 = naxes[1]/2 + (YSAMPLE/2); if (i1 < 1) i1 = 1; if (i2 > naxes[1]) i2 = naxes[1]; fpixel[1] = i1; lpixel[1] = i2; } ny = i2 - i1 +1; npix = nx * ny; /* if there are higher dimensions, read the middle plane of the cube */ if (naxis > 2) { fpixel[2] = naxes[2]/2 + 1; lpixel[2] = naxes[2]/2 + 1; } array = calloc(npix, sizeof(float)); if (!array) { *status = MEMORY_ALLOCATION; return(*status); } fits_read_subset_flt(infptr, 0, naxis, naxes, fpixel, lpixel, inc, nullvalue, array, &anynul, status); /* are there any null values in the array? */ if (!anynul) { nullvalue = 0.; checknull = 0; } /* compute statistics of the image */ fits_img_stats_float(array, nx, ny, checknull, nullvalue, &ngood, &minvalue, &maxvalue, &mean, &sigma, &noise1, &noise2, &noise3, &noise5, status); imagestats->n_nulls = npix - ngood; imagestats->minval = minvalue; imagestats->maxval = maxvalue; imagestats->mean = mean; imagestats->sigma = sigma; imagestats->noise1 = noise1; imagestats->noise2 = noise2; imagestats->noise3 = noise3; imagestats->noise5 = noise5; free(array); return(*status); } /*--------------------------------------------------------------------------*/ int fp_i2rescale(fitsfile *infptr, int naxis, long *naxes, double rescale, fitsfile *outfptr, int *status) { /* divide the integer pixel values in the input file by rescale, and write back out to the output file.. */ long ii, jj, nelem = 1, nx, ny; short *intarray, nullvalue; int anynul, tstatus, checknull = 1; nx = naxes[0]; ny = 1; for (ii = 1; ii < naxis; ii++) { ny = ny * naxes[ii]; } intarray = calloc(nx, sizeof(short)); if (!intarray) { *status = MEMORY_ALLOCATION; return(*status); } /* read the null value keyword (BLANK) if present */ tstatus = 0; fits_read_key(infptr, TSHORT, "BLANK", &nullvalue, 0, &tstatus); if (tstatus) { checknull = 0; } /* turn off any scaling of the integer pixel values */ fits_set_bscale(infptr, 1.0, 0.0, status); fits_set_bscale(outfptr, 1.0, 0.0, status); for (ii = 0; ii < ny; ii++) { fits_read_img_sht(infptr, 1, nelem, nx, 0, intarray, &anynul, status); if (checknull) { for (jj = 0; jj < nx; jj++) { if (intarray[jj] != nullvalue) intarray[jj] = NSHRT( (intarray[jj] / rescale) ); } } else { for (jj = 0; jj < nx; jj++) intarray[jj] = NSHRT( (intarray[jj] / rescale) ); } fits_write_img_sht(outfptr, 1, nelem, nx, intarray, status); nelem += nx; } free(intarray); return(*status); } /*--------------------------------------------------------------------------*/ int fp_i4rescale(fitsfile *infptr, int naxis, long *naxes, double rescale, fitsfile *outfptr, int *status) { /* divide the integer pixel values in the input file by rescale, and write back out to the output file.. */ long ii, jj, nelem = 1, nx, ny; int *intarray, nullvalue; int anynul, tstatus, checknull = 1; nx = naxes[0]; ny = 1; for (ii = 1; ii < naxis; ii++) { ny = ny * naxes[ii]; } intarray = calloc(nx, sizeof(int)); if (!intarray) { *status = MEMORY_ALLOCATION; return(*status); } /* read the null value keyword (BLANK) if present */ tstatus = 0; fits_read_key(infptr, TINT, "BLANK", &nullvalue, 0, &tstatus); if (tstatus) { checknull = 0; } /* turn off any scaling of the integer pixel values */ fits_set_bscale(infptr, 1.0, 0.0, status); fits_set_bscale(outfptr, 1.0, 0.0, status); for (ii = 0; ii < ny; ii++) { fits_read_img_int(infptr, 1, nelem, nx, 0, intarray, &anynul, status); if (checknull) { for (jj = 0; jj < nx; jj++) { if (intarray[jj] != nullvalue) intarray[jj] = NINT( (intarray[jj] / rescale) ); } } else { for (jj = 0; jj < nx; jj++) intarray[jj] = NINT( (intarray[jj] / rescale) ); } fits_write_img_int(outfptr, 1, nelem, nx, intarray, status); nelem += nx; } free(intarray); return(*status); } /* ======================================================================== * Signal and error handler. */ void abort_fpack(int sig) { /* clean up by deleting temporary files */ if (tempfilename[0]) { remove(tempfilename); } if (tempfilename2[0]) { remove(tempfilename2); } if (tempfilename3[0]) { remove(tempfilename3); } exit(-1); } healpy-1.10.3/cfitsio/funpack.c0000664000175000017500000001056013010375005016555 0ustar zoncazonca00000000000000/* FUNPACK * R. Seaman, NOAO * uses fits_img_compress by W. Pence, HEASARC */ #include "fitsio.h" #include "fpack.h" int main (int argc, char *argv[]) { fpstate fpvar; if (argc <= 1) { fu_usage (); fu_hint (); exit (-1); } fp_init (&fpvar); fu_get_param (argc, argv, &fpvar); if (fpvar.listonly) { fp_list (argc, argv, fpvar); } else { fp_preflight (argc, argv, FUNPACK, &fpvar); fp_loop (argc, argv, FUNPACK, fpvar); } exit (0); } int fu_get_param (int argc, char *argv[], fpstate *fpptr) { int gottype=0, gottile=0, wholetile=0, iarg; char tile[SZ_STR]; if (fpptr->initialized != FP_INIT_MAGIC) { fp_msg ("Error: internal initialization error\n"); exit (-1); } tile[0] = 0; /* by default, .fz suffix characters to be deleted from compressed file */ fpptr->delete_suffix = 1; /* flags must come first and be separately specified */ for (iarg = 1; iarg < argc; iarg++) { if (argv[iarg][0] == '-' && strlen (argv[iarg]) == 2) { if (argv[iarg][1] == 'F') { fpptr->clobber++; fpptr->delete_suffix = 0; /* no suffix in this case */ } else if (argv[iarg][1] == 'D') { fpptr->delete_input++; } else if (argv[iarg][1] == 'P') { if (++iarg >= argc) { fu_usage (); fu_hint (); exit (-1); } else strncpy (fpptr->prefix, argv[iarg], SZ_STR); } else if (argv[iarg][1] == 'E') { if (++iarg >= argc) { fu_usage (); fu_hint (); exit (-1); } else strncpy (fpptr->extname, argv[iarg], SZ_STR); } else if (argv[iarg][1] == 'S') { fpptr->to_stdout++; } else if (argv[iarg][1] == 'L') { fpptr->listonly++; } else if (argv[iarg][1] == 'C') { fpptr->do_checksums = 0; } else if (argv[iarg][1] == 'H') { fu_help (); exit (0); } else if (argv[iarg][1] == 'V') { fp_version (); exit (0); } else if (argv[iarg][1] == 'Z') { fpptr->do_gzip_file++; } else if (argv[iarg][1] == 'v') { fpptr->verbose = 1; } else if (argv[iarg][1] == 'O') { if (++iarg >= argc) { fu_usage (); fu_hint (); exit (-1); } else strncpy (fpptr->outfile, argv[iarg], SZ_STR); } else { fp_msg ("Error: unknown command line flag `"); fp_msg (argv[iarg]); fp_msg ("'\n"); fu_usage (); fu_hint (); exit (-1); } } else break; } if (fpptr->extname[0] && (fpptr->clobber || fpptr->delete_input)) { fp_msg ("Error: -E option may not be used with -F or -D\n"); fu_usage (); exit (-1); } if (fpptr->to_stdout && (fpptr->outfile[0] || fpptr->prefix[0]) ) { fp_msg ("Error: -S option may not be used with -P or -O\n"); fu_usage (); exit (-1); } if (fpptr->outfile[0] && fpptr->prefix[0] ) { fp_msg ("Error: -P and -O options may not be used together\n"); fu_usage (); exit (-1); } if (iarg >= argc) { fp_msg ("Error: no FITS files to uncompress\n"); fu_usage (); exit (-1); } else fpptr->firstfile = iarg; return(0); } int fu_usage (void) { fp_msg ("usage: funpack [-E ] [-P 

] [-O ] [-Z] -v \n");
        fp_msg ("more:   [-F] [-D] [-S] [-L] [-C] [-H] [-V] \n");
	return(0);
}

int fu_hint (void)
{
	fp_msg ("      `funpack -H' for help\n");
	return(0);
}

int fu_help (void)
{
fp_msg ("funpack, decompress fpacked files.  Version ");
fp_version ();
fu_usage ();
fp_msg ("\n");

fp_msg ("Flags must be separate and appear before filenames:\n");
fp_msg (" -E  Unpack only the list of HDU names or numbers in the file.\n");
fp_msg (" -P 
    Prepend 
 to create new output filenames.\n");
fp_msg (" -O    Specify full output file name.\n");
fp_msg (" -Z          Recompress the output file with host GZIP program.\n");
fp_msg (" -F          Overwrite input file by output file with same name.\n");
fp_msg (" -D          Delete input file after writing output.\n");
fp_msg (" -S          Output uncompressed file to STDOUT file stream.\n");
fp_msg (" -L          List contents, files unchanged.\n");

fp_msg (" -C          Don't update FITS checksum keywords.\n");

fp_msg (" -v          Verbose mode; list each file as it is processed.\n");
fp_msg (" -H          Show this message.\n");
fp_msg (" -V          Show version number.\n");

fp_msg (" \n       FITS files to unpack; enter '-' (a hyphen) to read from stdin.\n");
fp_msg (" Refer to the fpack User's Guide for more extensive help.\n");
	return(0);
}
healpy-1.10.3/cfitsio/getcol.c0000664000175000017500000011541413010375005016407 0ustar  zoncazonca00000000000000
/*  This file, getcol.c, contains routines that read data elements from    */
/*  a FITS image or table.  There are generic datatype routines.           */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpxv( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            long *firstpix,   /* I - coord of first pixel to read (1s based) */
            LONGLONG nelem,   /* I - number of values to read                */
            void *nulval,     /* I - value for undefined pixels              */
            void *array,      /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    LONGLONG tfirstpix[99];
    int naxis, ii;

    if (*status > 0 || nelem == 0)   /* inherit input status value if > 0 */
        return(*status);

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);
    
    for (ii=0; ii < naxis; ii++)
       tfirstpix[ii] = firstpix[ii];

    ffgpxvll(fptr, datatype, tfirstpix, nelem, nulval, array, anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpxvll( fitsfile *fptr, /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            LONGLONG *firstpix, /* I - coord of first pixel to read (1s based) */
            LONGLONG nelem,   /* I - number of values to read                */
            void *nulval,     /* I - value for undefined pixels              */
            void *array,      /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    int naxis, ii;
    char cdummy;
    int nullcheck = 1;
    LONGLONG naxes[9], trc[9]= {1,1,1,1,1,1,1,1,1};
    long inc[9]= {1,1,1,1,1,1,1,1,1};
    LONGLONG dimsize = 1, firstelem;

    if (*status > 0 || nelem == 0)   /* inherit input status value if > 0 */
        return(*status);

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);

    ffgiszll(fptr, 9, naxes, status);

    if (naxis == 0 || naxes[0] == 0) {
       *status = BAD_DIMEN;
       return(*status);
    }

    /* calculate the position of the first element in the array */
    firstelem = 0;
    for (ii=0; ii < naxis; ii++)
    {
        firstelem += ((firstpix[ii] - 1) * dimsize);
        dimsize *= naxes[ii];
        trc[ii] = firstpix[ii];
    }
    firstelem++;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        /* test for special case of reading an integral number of */
        /* rows in a 2D or 3D image (which includes reading the whole image */

	if (naxis > 1 && naxis < 4 && firstpix[0] == 1 &&
            (nelem / naxes[0]) * naxes[0] == nelem) {

                /* calculate coordinate of last pixel */
		trc[0] = naxes[0];  /* reading whole rows */
		trc[1] = firstpix[1] + (nelem / naxes[0] - 1);
                while (trc[1] > naxes[1])  {
		    trc[1] = trc[1] - naxes[1];
		    trc[2] = trc[2] + 1;  /* increment to next plane of cube */
                }

                fits_read_compressed_img(fptr, datatype, firstpix, trc, inc,
                   1, nulval, array, NULL, anynul, status);

        } else {

                fits_read_compressed_pixels(fptr, datatype, firstelem,
                   nelem, nullcheck, nulval, array, NULL, anynul, status);
        }

        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (datatype == TBYTE)
    {
      if (nulval == 0)
        ffgclb(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (unsigned char *) array, &cdummy, anynul, status);
      else
        ffgclb(fptr, 2, 1, firstelem, nelem, 1, 1, *(unsigned char *) nulval,
               (unsigned char *) array, &cdummy, anynul, status);
    }
    else if (datatype == TSBYTE)
    {
      if (nulval == 0)
        ffgclsb(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (signed char *) array, &cdummy, anynul, status);
      else
        ffgclsb(fptr, 2, 1, firstelem, nelem, 1, 1, *(signed char *) nulval,
               (signed char *) array, &cdummy, anynul, status);
    }
    else if (datatype == TUSHORT)
    {
      if (nulval == 0)
        ffgclui(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (unsigned short *) array, &cdummy, anynul, status);
      else
        ffgclui(fptr, 2, 1, firstelem, nelem, 1, 1, *(unsigned short *) nulval,
               (unsigned short *) array, &cdummy, anynul, status);
    }
    else if (datatype == TSHORT)
    {
      if (nulval == 0)
        ffgcli(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (short *) array, &cdummy, anynul, status);
      else
        ffgcli(fptr, 2, 1, firstelem, nelem, 1, 1, *(short *) nulval,
               (short *) array, &cdummy, anynul, status);
    }
    else if (datatype == TUINT)
    {
      if (nulval == 0)
        ffgcluk(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (unsigned int *) array, &cdummy, anynul, status);
      else
        ffgcluk(fptr, 2, 1, firstelem, nelem, 1, 1, *(unsigned int *) nulval,
               (unsigned int *) array, &cdummy, anynul, status);
    }
    else if (datatype == TINT)
    {
      if (nulval == 0)
        ffgclk(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (int *) array, &cdummy, anynul, status);
      else
        ffgclk(fptr, 2, 1, firstelem, nelem, 1, 1, *(int *) nulval,
               (int *) array, &cdummy, anynul, status);
    }
    else if (datatype == TULONG)
    {
      if (nulval == 0)
        ffgcluj(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (unsigned long *) array, &cdummy, anynul, status);
      else
        ffgcluj(fptr, 2, 1, firstelem, nelem, 1, 1, *(unsigned long *) nulval,
               (unsigned long *) array, &cdummy, anynul, status);
    }
    else if (datatype == TLONG)
    {
      if (nulval == 0)
        ffgclj(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (long *) array, &cdummy, anynul, status);
      else
        ffgclj(fptr, 2, 1, firstelem, nelem, 1, 1, *(long *) nulval,
               (long *) array, &cdummy, anynul, status);
    }
    else if (datatype == TLONGLONG)
    {
      if (nulval == 0)
        ffgcljj(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (LONGLONG *) array, &cdummy, anynul, status);
      else
        ffgcljj(fptr, 2, 1, firstelem, nelem, 1, 1, *(LONGLONG *) nulval,
               (LONGLONG *) array, &cdummy, anynul, status);
    }
    else if (datatype == TFLOAT)
    {
      if (nulval == 0)
        ffgcle(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (float *) array, &cdummy, anynul, status);
      else
        ffgcle(fptr, 2, 1, firstelem, nelem, 1, 1, *(float *) nulval,
               (float *) array, &cdummy, anynul, status);
    }
    else if (datatype == TDOUBLE)
    {
      if (nulval == 0)
        ffgcld(fptr, 2, 1, firstelem, nelem, 1, 1, 0,
               (double *) array, &cdummy, anynul, status);
      else
        ffgcld(fptr, 2, 1, firstelem, nelem, 1, 1, *(double *) nulval,
               (double *) array, &cdummy, anynul, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpxf( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            long *firstpix,   /* I - coord of first pixel to read (1s based) */
            LONGLONG nelem,       /* I - number of values to read            */
            void *array,      /* O - array of values that are returned       */
            char *nullarray,  /* O - returned array of null value flags      */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  The nullarray values will = 1 if the corresponding array value is null.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    LONGLONG tfirstpix[99];
    int naxis, ii;

    if (*status > 0 || nelem == 0)   /* inherit input status value if > 0 */
        return(*status);

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);

    for (ii=0; ii < naxis; ii++)
       tfirstpix[ii] = firstpix[ii];

    ffgpxfll(fptr, datatype, tfirstpix, nelem, array, nullarray, anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpxfll( fitsfile *fptr, /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            LONGLONG *firstpix, /* I - coord of first pixel to read (1s based) */
            LONGLONG nelem,       /* I - number of values to read              */
            void *array,      /* O - array of values that are returned       */
            char *nullarray,  /* O - returned array of null value flags      */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  The nullarray values will = 1 if the corresponding array value is null.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    int naxis, ii;
    int nullcheck = 2;
    LONGLONG naxes[9];
    LONGLONG dimsize = 1, firstelem;

    if (*status > 0 || nelem == 0)   /* inherit input status value if > 0 */
        return(*status);

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);
    ffgiszll(fptr, 9, naxes, status);

    /* calculate the position of the first element in the array */
    firstelem = 0;
    for (ii=0; ii < naxis; ii++)
    {
        firstelem += ((firstpix[ii] - 1) * dimsize);
        dimsize *= naxes[ii];
    }
    firstelem++;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, datatype, firstelem, nelem,
            nullcheck, NULL, array, nullarray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (datatype == TBYTE)
    {
        ffgclb(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (unsigned char *) array, nullarray, anynul, status);
    }
    else if (datatype == TSBYTE)
    {
        ffgclsb(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (signed char *) array, nullarray, anynul, status);
    }
    else if (datatype == TUSHORT)
    {
        ffgclui(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (unsigned short *) array, nullarray, anynul, status);
    }
    else if (datatype == TSHORT)
    {
        ffgcli(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (short *) array, nullarray, anynul, status);
    }
    else if (datatype == TUINT)
    {
        ffgcluk(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (unsigned int *) array, nullarray, anynul, status);
    }
    else if (datatype == TINT)
    {
        ffgclk(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (int *) array, nullarray, anynul, status);
    }
    else if (datatype == TULONG)
    {
        ffgcluj(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (unsigned long *) array, nullarray, anynul, status);
    }
    else if (datatype == TLONG)
    {
        ffgclj(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (long *) array, nullarray, anynul, status);
    }
    else if (datatype == TLONGLONG)
    {
        ffgcljj(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (LONGLONG *) array, nullarray, anynul, status);
    }
    else if (datatype == TFLOAT)
    {
        ffgcle(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (float *) array, nullarray, anynul, status);
    }
    else if (datatype == TDOUBLE)
    {
        ffgcld(fptr, 2, 1, firstelem, nelem, 1, 2, 0,
               (double *) array, nullarray, anynul, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsv(  fitsfile *fptr,   /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            long *blc,        /* I - 'bottom left corner' of the subsection  */
            long *trc ,       /* I - 'top right corner' of the subsection    */
            long *inc,        /* I - increment to be applied in each dim.    */
            void *nulval,     /* I - value for undefined pixels              */
            void *array,      /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an section of values from the primary array. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    int naxis, ii;
    long naxes[9];
    LONGLONG nelem = 1;

    if (*status > 0)   /* inherit input status value if > 0 */
        return(*status);

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);
    ffgisz(fptr, 9, naxes, status);

    /* test for the important special case where we are reading the whole image */
    /* this is only useful for images that are not tile-compressed */
    if (!fits_is_compressed_image(fptr, status)) {
        for (ii = 0; ii < naxis; ii++) {
            if (inc[ii] != 1 || blc[ii] !=1 || trc[ii] != naxes[ii])
                break;

            nelem = nelem * naxes[ii];
        }

        if (ii == naxis) {
            /* read the whole image more efficiently */
            ffgpxv(fptr, datatype, blc, nelem, nulval, array, anynul, status);
            return(*status);
        }
    }

    if (datatype == TBYTE)
    {
      if (nulval == 0)
        ffgsvb(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (unsigned char *) array, anynul, status);
      else
        ffgsvb(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned char *) nulval,
               (unsigned char *) array, anynul, status);
    }
    else if (datatype == TSBYTE)
    {
      if (nulval == 0)
        ffgsvsb(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (signed char *) array, anynul, status);
      else
        ffgsvsb(fptr, 1, naxis, naxes, blc, trc, inc, *(signed char *) nulval,
               (signed char *) array, anynul, status);
    }
    else if (datatype == TUSHORT)
    {
      if (nulval == 0)
        ffgsvui(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (unsigned short *) array, anynul, status);
      else
        ffgsvui(fptr, 1, naxis, naxes,blc, trc, inc, *(unsigned short *) nulval,
               (unsigned short *) array, anynul, status);
    }
    else if (datatype == TSHORT)
    {
      if (nulval == 0)
        ffgsvi(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (short *) array, anynul, status);
      else
        ffgsvi(fptr, 1, naxis, naxes, blc, trc, inc, *(short *) nulval,
               (short *) array, anynul, status);
    }
    else if (datatype == TUINT)
    {
      if (nulval == 0)
        ffgsvuk(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (unsigned int *) array, anynul, status);
      else
        ffgsvuk(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned int *) nulval,
               (unsigned int *) array, anynul, status);
    }
    else if (datatype == TINT)
    {
      if (nulval == 0)
        ffgsvk(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (int *) array, anynul, status);
      else
        ffgsvk(fptr, 1, naxis, naxes, blc, trc, inc, *(int *) nulval,
               (int *) array, anynul, status);
    }
    else if (datatype == TULONG)
    {
      if (nulval == 0)
        ffgsvuj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (unsigned long *) array, anynul, status);
      else
        ffgsvuj(fptr, 1, naxis, naxes, blc, trc, inc, *(unsigned long *) nulval,
               (unsigned long *) array, anynul, status);
    }
    else if (datatype == TLONG)
    {
      if (nulval == 0)
        ffgsvj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (long *) array, anynul, status);
      else
        ffgsvj(fptr, 1, naxis, naxes, blc, trc, inc, *(long *) nulval,
               (long *) array, anynul, status);
    }
    else if (datatype == TLONGLONG)
    {
      if (nulval == 0)
        ffgsvjj(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (LONGLONG *) array, anynul, status);
      else
        ffgsvjj(fptr, 1, naxis, naxes, blc, trc, inc, *(LONGLONG *) nulval,
               (LONGLONG *) array, anynul, status);
    }
    else if (datatype == TFLOAT)
    {
      if (nulval == 0)
        ffgsve(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (float *) array, anynul, status);
      else
        ffgsve(fptr, 1, naxis, naxes, blc, trc, inc, *(float *) nulval,
               (float *) array, anynul, status);
    }
    else if (datatype == TDOUBLE)
    {
      if (nulval == 0)
        ffgsvd(fptr, 1, naxis, naxes, blc, trc, inc, 0,
               (double *) array, anynul, status);
      else
        ffgsvd(fptr, 1, naxis, naxes, blc, trc, inc, *(double *) nulval,
               (double *) array, anynul, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpv(  fitsfile *fptr,   /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            LONGLONG firstelem,   /* I - first vector element to read (1 = 1st)  */
            LONGLONG nelem,       /* I - number of values to read                */
            void *nulval,     /* I - value for undefined pixels              */
            void *array,      /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{

    if (*status > 0 || nelem == 0)   /* inherit input status value if > 0 */
        return(*status);

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (datatype == TBYTE)
    {
      if (nulval == 0)
        ffgpvb(fptr, 1, firstelem, nelem, 0,
               (unsigned char *) array, anynul, status);
      else
        ffgpvb(fptr, 1, firstelem, nelem, *(unsigned char *) nulval,
               (unsigned char *) array, anynul, status);
    }
    else if (datatype == TSBYTE)
    {
      if (nulval == 0)
        ffgpvsb(fptr, 1, firstelem, nelem, 0,
               (signed char *) array, anynul, status);
      else
        ffgpvsb(fptr, 1, firstelem, nelem, *(signed char *) nulval,
               (signed char *) array, anynul, status);
    }
    else if (datatype == TUSHORT)
    {
      if (nulval == 0)
        ffgpvui(fptr, 1, firstelem, nelem, 0,
               (unsigned short *) array, anynul, status);
      else
        ffgpvui(fptr, 1, firstelem, nelem, *(unsigned short *) nulval,
               (unsigned short *) array, anynul, status);
    }
    else if (datatype == TSHORT)
    {
      if (nulval == 0)
        ffgpvi(fptr, 1, firstelem, nelem, 0,
               (short *) array, anynul, status);
      else
        ffgpvi(fptr, 1, firstelem, nelem, *(short *) nulval,
               (short *) array, anynul, status);
    }
    else if (datatype == TUINT)
    {
      if (nulval == 0)
        ffgpvuk(fptr, 1, firstelem, nelem, 0,
               (unsigned int *) array, anynul, status);
      else
        ffgpvuk(fptr, 1, firstelem, nelem, *(unsigned int *) nulval,
               (unsigned int *) array, anynul, status);
    }
    else if (datatype == TINT)
    {
      if (nulval == 0)
        ffgpvk(fptr, 1, firstelem, nelem, 0,
               (int *) array, anynul, status);
      else
        ffgpvk(fptr, 1, firstelem, nelem, *(int *) nulval,
               (int *) array, anynul, status);
    }
    else if (datatype == TULONG)
    {
      if (nulval == 0)
        ffgpvuj(fptr, 1, firstelem, nelem, 0,
               (unsigned long *) array, anynul, status);
      else
        ffgpvuj(fptr, 1, firstelem, nelem, *(unsigned long *) nulval,
               (unsigned long *) array, anynul, status);
    }
    else if (datatype == TLONG)
    {
      if (nulval == 0)
        ffgpvj(fptr, 1, firstelem, nelem, 0,
               (long *) array, anynul, status);
      else
        ffgpvj(fptr, 1, firstelem, nelem, *(long *) nulval,
               (long *) array, anynul, status);
    }
    else if (datatype == TLONGLONG)
    {
      if (nulval == 0)
        ffgpvjj(fptr, 1, firstelem, nelem, 0,
               (LONGLONG *) array, anynul, status);
      else
        ffgpvjj(fptr, 1, firstelem, nelem, *(LONGLONG *) nulval,
               (LONGLONG *) array, anynul, status);
    }
    else if (datatype == TFLOAT)
    {
      if (nulval == 0)
        ffgpve(fptr, 1, firstelem, nelem, 0,
               (float *) array, anynul, status);
      else
        ffgpve(fptr, 1, firstelem, nelem, *(float *) nulval,
               (float *) array, anynul, status);
    }
    else if (datatype == TDOUBLE)
    {
      if (nulval == 0)
        ffgpvd(fptr, 1, firstelem, nelem, 0,
               (double *) array, anynul, status);
      else
      {
        ffgpvd(fptr, 1, firstelem, nelem, *(double *) nulval,
               (double *) array, anynul, status);
      }
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpf(  fitsfile *fptr,   /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            LONGLONG firstelem,   /* I - first vector element to read (1 = 1st)  */
            LONGLONG nelem,       /* I - number of values to read                */
            void *array,      /* O - array of values that are returned       */
            char *nullarray,  /* O - array of null value flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  The nullarray values will = 1 if the corresponding array value is null.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{

    if (*status > 0 || nelem == 0)   /* inherit input status value if > 0 */
        return(*status);

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (datatype == TBYTE)
    {
        ffgpfb(fptr, 1, firstelem, nelem, 
               (unsigned char *) array, nullarray, anynul, status);
    }
    else if (datatype == TSBYTE)
    {
        ffgpfsb(fptr, 1, firstelem, nelem, 
               (signed char *) array, nullarray, anynul, status);
    }
    else if (datatype == TUSHORT)
    {
        ffgpfui(fptr, 1, firstelem, nelem, 
               (unsigned short *) array, nullarray, anynul, status);
    }
    else if (datatype == TSHORT)
    {
        ffgpfi(fptr, 1, firstelem, nelem, 
               (short *) array, nullarray, anynul, status);
    }
    else if (datatype == TUINT)
    {
        ffgpfuk(fptr, 1, firstelem, nelem, 
               (unsigned int *) array, nullarray, anynul, status);
    }
    else if (datatype == TINT)
    {
        ffgpfk(fptr, 1, firstelem, nelem, 
               (int *) array, nullarray, anynul, status);
    }
    else if (datatype == TULONG)
    {
        ffgpfuj(fptr, 1, firstelem, nelem, 
               (unsigned long *) array, nullarray, anynul, status);
    }
    else if (datatype == TLONG)
    {
        ffgpfj(fptr, 1, firstelem, nelem,
               (long *) array, nullarray, anynul, status);
    }
    else if (datatype == TLONGLONG)
    {
        ffgpfjj(fptr, 1, firstelem, nelem,
               (LONGLONG *) array, nullarray, anynul, status);
    }
    else if (datatype == TFLOAT)
    {
        ffgpfe(fptr, 1, firstelem, nelem, 
               (float *) array, nullarray, anynul, status);
    }
    else if (datatype == TDOUBLE)
    {
        ffgpfd(fptr, 1, firstelem, nelem,
               (double *) array, nullarray, anynul, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcv(  fitsfile *fptr,   /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            int  colnum,      /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,   /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG nelem,       /* I - number of values to read                */
            void *nulval,     /* I - value for undefined pixels              */
            void *array,      /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a table column. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of true if any pixels are undefined.
*/
{
    char cdummy[2];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (datatype == TBIT)
    {
      ffgcx(fptr, colnum, firstrow, firstelem, nelem, (char *) array, status);
    }
    else if (datatype == TBYTE)
    {
      if (nulval == 0)
        ffgclb(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
              (unsigned char *) array, cdummy, anynul, status);
      else
       ffgclb(fptr, colnum, firstrow, firstelem, nelem, 1, 1, *(unsigned char *)
              nulval, (unsigned char *) array, cdummy, anynul, status);
    }
    else if (datatype == TSBYTE)
    {
      if (nulval == 0)
        ffgclsb(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
              (signed char *) array, cdummy, anynul, status);
      else
       ffgclsb(fptr, colnum, firstrow, firstelem, nelem, 1, 1, *(signed char *)
              nulval, (signed char *) array, cdummy, anynul, status);
    }
    else if (datatype == TUSHORT)
    {
      if (nulval == 0)
        ffgclui(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
               (unsigned short *) array, cdummy, anynul, status);
      else
        ffgclui(fptr, colnum, firstrow, firstelem, nelem, 1, 1,
               *(unsigned short *) nulval,
               (unsigned short *) array, cdummy, anynul, status);
    }
    else if (datatype == TSHORT)
    {
      if (nulval == 0)
        ffgcli(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
              (short *) array, cdummy, anynul, status);
      else
        ffgcli(fptr, colnum, firstrow, firstelem, nelem, 1, 1, *(short *)
              nulval, (short *) array, cdummy, anynul, status);
    }
    else if (datatype == TUINT)
    {
      if (nulval == 0)
        ffgcluk(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
              (unsigned int *) array, cdummy, anynul, status);
      else
        ffgcluk(fptr, colnum, firstrow, firstelem, nelem, 1, 1,
         *(unsigned int *) nulval, (unsigned int *) array, cdummy, anynul,
         status);
    }
    else if (datatype == TINT)
    {
      if (nulval == 0)
        ffgclk(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
              (int *) array, cdummy, anynul, status);
      else
        ffgclk(fptr, colnum, firstrow, firstelem, nelem, 1, 1, *(int *)
            nulval, (int *) array, cdummy, anynul, status);
    }
    else if (datatype == TULONG)
    {
      if (nulval == 0)
        ffgcluj(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
               (unsigned long *) array, cdummy, anynul, status);
      else
        ffgcluj(fptr, colnum, firstrow, firstelem, nelem, 1, 1,
               *(unsigned long *) nulval, 
               (unsigned long *) array, cdummy, anynul, status);
    }
    else if (datatype == TLONG)
    {
      if (nulval == 0)
        ffgclj(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
              (long *) array, cdummy, anynul, status);
      else
        ffgclj(fptr, colnum, firstrow, firstelem, nelem, 1, 1, *(long *)
              nulval, (long *) array, cdummy, anynul, status);
    }
    else if (datatype == TLONGLONG)
    {
      if (nulval == 0)
        ffgcljj(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0,
              (LONGLONG *) array, cdummy, anynul, status);
      else
        ffgcljj(fptr, colnum, firstrow, firstelem, nelem, 1, 1, *(LONGLONG *)
              nulval, (LONGLONG *) array, cdummy, anynul, status);
    }
    else if (datatype == TFLOAT)
    {
      if (nulval == 0)
        ffgcle(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0.,
              (float *) array, cdummy, anynul, status);
      else
      ffgcle(fptr, colnum, firstrow, firstelem, nelem, 1, 1, *(float *)
               nulval,(float *) array, cdummy, anynul, status);
    }
    else if (datatype == TDOUBLE)
    {
      if (nulval == 0)
        ffgcld(fptr, colnum, firstrow, firstelem, nelem, 1, 1, 0.,
              (double *) array, cdummy, anynul, status);
      else
        ffgcld(fptr, colnum, firstrow, firstelem, nelem, 1, 1, *(double *)
              nulval, (double *) array, cdummy, anynul, status);
    }
    else if (datatype == TCOMPLEX)
    {
      if (nulval == 0)
        ffgcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
           1, 1, 0., (float *) array, cdummy, anynul, status);
      else
        ffgcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
           1, 1, *(float *) nulval, (float *) array, cdummy, anynul, status);
    }
    else if (datatype == TDBLCOMPLEX)
    {
      if (nulval == 0)
        ffgcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2, 
         1, 1, 0., (double *) array, cdummy, anynul, status);
      else
        ffgcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2, 
         1, 1, *(double *) nulval, (double *) array, cdummy, anynul, status);
    }

    else if (datatype == TLOGICAL)
    {
      if (nulval == 0)
        ffgcll(fptr, colnum, firstrow, firstelem, nelem, 1, 0,
          (char *) array, cdummy, anynul, status);
      else
        ffgcll(fptr, colnum, firstrow, firstelem, nelem, 1, *(char *) nulval,
          (char *) array, cdummy, anynul, status);
    }
    else if (datatype == TSTRING)
    {
      if (nulval == 0)
      {
        cdummy[0] = '\0';
        ffgcls(fptr, colnum, firstrow, firstelem, nelem, 1, 
             cdummy, (char **) array, cdummy, anynul, status);
      }
      else
        ffgcls(fptr, colnum, firstrow, firstelem, nelem, 1, (char *)
             nulval, (char **) array, cdummy, anynul, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcf(  fitsfile *fptr,   /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            int  colnum,      /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,   /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG nelem,       /* I - number of values to read                */
            void *array,      /* O - array of values that are returned       */
            char *nullarray,  /* O - array of null value flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a table column. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  ANYNUL is returned with a value of true if any pixels are undefined.
*/
{
    double nulval = 0.;
    char cnulval[2];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (datatype == TBIT)
    {
      ffgcx(fptr, colnum, firstrow, firstelem, nelem, (char *) array, status);
    }
    else if (datatype == TBYTE)
    {
       ffgclb(fptr, colnum, firstrow, firstelem, nelem, 1, 2, (unsigned char )
              nulval, (unsigned char *) array, nullarray, anynul, status);
    }
    else if (datatype == TSBYTE)
    {
       ffgclsb(fptr, colnum, firstrow, firstelem, nelem, 1, 2, (signed char )
              nulval, (signed char *) array, nullarray, anynul, status);
    }
    else if (datatype == TUSHORT)
    {
        ffgclui(fptr, colnum, firstrow, firstelem, nelem, 1, 2,
               (unsigned short ) nulval,
               (unsigned short *) array, nullarray, anynul, status);
    }
    else if (datatype == TSHORT)
    {
        ffgcli(fptr, colnum, firstrow, firstelem, nelem, 1, 2, (short )
              nulval, (short *) array, nullarray, anynul, status);
    }
    else if (datatype == TUINT)
    {
        ffgcluk(fptr, colnum, firstrow, firstelem, nelem, 1, 2,
         (unsigned int ) nulval, (unsigned int *) array, nullarray, anynul,
         status);
    }
    else if (datatype == TINT)
    {
        ffgclk(fptr, colnum, firstrow, firstelem, nelem, 1, 2, (int )
            nulval, (int *) array, nullarray, anynul, status);
    }
    else if (datatype == TULONG)
    {
        ffgcluj(fptr, colnum, firstrow, firstelem, nelem, 1, 2,
               (unsigned long ) nulval, 
               (unsigned long *) array, nullarray, anynul, status);
    }
    else if (datatype == TLONG)
    {
        ffgclj(fptr, colnum, firstrow, firstelem, nelem, 1, 2, (long )
              nulval, (long *) array, nullarray, anynul, status);
    }
    else if (datatype == TLONGLONG)
    {
        ffgcljj(fptr, colnum, firstrow, firstelem, nelem, 1, 2, (LONGLONG )
              nulval, (LONGLONG *) array, nullarray, anynul, status);
    }
    else if (datatype == TFLOAT)
    {
      ffgcle(fptr, colnum, firstrow, firstelem, nelem, 1, 2, (float )
               nulval,(float *) array, nullarray, anynul, status);
    }
    else if (datatype == TDOUBLE)
    {
        ffgcld(fptr, colnum, firstrow, firstelem, nelem, 1, 2, 
              nulval, (double *) array, nullarray, anynul, status);
    }
    else if (datatype == TCOMPLEX)
    {
        ffgcfc(fptr, colnum, firstrow, firstelem, nelem,
           (float *) array, nullarray, anynul, status);
    }
    else if (datatype == TDBLCOMPLEX)
    {
        ffgcfm(fptr, colnum, firstrow, firstelem, nelem, 
           (double *) array, nullarray, anynul, status);
    }

    else if (datatype == TLOGICAL)
    {
        ffgcll(fptr, colnum, firstrow, firstelem, nelem, 2, (char ) nulval,
          (char *) array, nullarray, anynul, status);
    }
    else if (datatype == TSTRING)
    {
        ffgcls(fptr, colnum, firstrow, firstelem, nelem, 2, 
             cnulval, (char **) array, nullarray, anynul, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}

healpy-1.10.3/cfitsio/getcolb.c0000664000175000017500000022552113010375005016552 0ustar  zoncazonca00000000000000/*  This file, getcolb.c, contains routines that read data elements from   */
/*  a FITS image or table, with unsigned char (unsigned byte) data type.   */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvb( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            unsigned char nulval, /* I - value for undefined pixels          */
            unsigned char *array, /* O - array of values that are returned   */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    unsigned char nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TBYTE, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclb(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfb( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            unsigned char *array, /* O - array of values that are returned   */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TBYTE, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclb(fptr, 2, row, firstelem, nelem, 1, 2, 0,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2db(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           unsigned char nulval, /* set undefined pixels equal to this     */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           unsigned char *array, /* O - array to be filled and returned    */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3db(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3db(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           unsigned char nulval, /* set undefined pixels equal to this     */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
           unsigned char *array, /* O - array to be filled and returned    */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    LONGLONG narray, nfits;
    char cdummy;
    int  nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1};
    LONGLONG lpixel[3];
    unsigned char nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TBYTE, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgclb(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgclb(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvb(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           unsigned char nulval, /* I - value to set undefined pixels       */
           unsigned char *array, /* O - array to be filled and returned     */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii, i0, i1, i2, i3, i4, i5, i6, i7, i8, row, rstr, rstp, rinc;
    long str[9], stp[9], incr[9], dir[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int  nullcheck = 1;
    unsigned char nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvb is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TBYTE, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
        dir[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        if (hdutype == IMAGE_HDU)
        {
           dir[ii] = -1;
        }
        else
        {
          sprintf(msg, "ffgsvb: illegal range specified for axis %ld", ii + 1);
          ffpmsg(msg);
          return(*status = BAD_PIX_NUM);
        }
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
      dsize[ii] = dsize[ii] * dir[ii];
    }
    dsize[naxis] = dsize[naxis] * dir[naxis];

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0]*dir[0] - str[0]*dir[0]) / inc[0] + 1;
      ninc = incr[0] * dir[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]*dir[8]; i8 <= stp[8]*dir[8]; i8 += incr[8])
     {
      for (i7 = str[7]*dir[7]; i7 <= stp[7]*dir[7]; i7 += incr[7])
      {
       for (i6 = str[6]*dir[6]; i6 <= stp[6]*dir[6]; i6 += incr[6])
       {
        for (i5 = str[5]*dir[5]; i5 <= stp[5]*dir[5]; i5 += incr[5])
        {
         for (i4 = str[4]*dir[4]; i4 <= stp[4]*dir[4]; i4 += incr[4])
         {
          for (i3 = str[3]*dir[3]; i3 <= stp[3]*dir[3]; i3 += incr[3])
          {
           for (i2 = str[2]*dir[2]; i2 <= stp[2]*dir[2]; i2 += incr[2])
           {
            for (i1 = str[1]*dir[1]; i1 <= stp[1]*dir[1]; i1 += incr[1])
            {

              felem=str[0] + (i1 - dir[1]) * dsize[1] + (i2 - dir[2]) * dsize[2] + 
                             (i3 - dir[3]) * dsize[3] + (i4 - dir[4]) * dsize[4] +
                             (i5 - dir[5]) * dsize[5] + (i6 - dir[6]) * dsize[6] +
                             (i7 - dir[7]) * dsize[7] + (i8 - dir[8]) * dsize[8];

              if ( ffgclb(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfb(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           unsigned char *array, /* O - array to be filled and returned     */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    int hdutype, anyf;
    unsigned char nulval = 0;
    char msg[FLEN_ERRMSG];
    int  nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvb is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TBYTE, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvb: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgclb(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpb( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
            unsigned char *array, /* O - array of values that are returned   */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclb(fptr, 1, row, firstelem, nelem, 1, 1, 0,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvb(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           unsigned char nulval, /* I - value for null pixels               */
           unsigned char *array, /* O - array of values that are read       */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgclb(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfb(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           unsigned char *array, /* O - array of values that are read       */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    unsigned char dummy = 0;

    ffgclb(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgclb( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            unsigned char nulval, /* I - value for null pixels if nultyp = 1 */
            unsigned char *array, /* O - array of values that are read       */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre, ntodo;
    long ii, xwidth;
    int convert, nulcheck, readcheck = 0;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    union u_tag {
       char charval;
       unsigned char ucharval;
    } u;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)      
       memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (elemincre < 0)
        readcheck = -1;  /* don't do range checking in this case */

    ffgcprll( fptr, colnum, firstrow, firstelem, nelem, readcheck, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status);
    maxelem = maxelem2;

    /* special case */
    if (tcode == TLOGICAL && elemincre == 1)
    {
        u.ucharval = nulval;
        ffgcll(fptr, colnum, firstrow, firstelem, nelem, nultyp,
               u.charval, (char *) array, nularray, anynul, status);

        return(*status);
    }

    if (strchr(tform,'A') != NULL) 
    {
        if (*status == BAD_ELEM_NUM)
        {
            /* ignore this error message */
            *status = 0;
            ffcmsg();   /* clear error stack */
        }

        /*  interpret a 'A' ASCII column as a 'B' byte column ('8A' == '8B') */
        /*  This is an undocumented 'feature' in CFITSIO */

        /*  we have to reset some of the values returned by ffgcpr */
        
        tcode = TBYTE;
        incre = 1;         /* each element is 1 byte wide */
        repeat = twidth;   /* total no. of chars in the col */
        twidth = 1;        /* width of each element */
        scale = 1.0;       /* no scaling */
        zero  = 0.0;
        tnull = NULL_UNDEFINED;  /* don't test for nulls */
        maxelem = DBUFFSIZE;
    }

    if (*status > 0)
        return(*status);
        
    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING && hdutype == ASCII_TBL) /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default, check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    convert = 1;
    if (tcode == TBYTE) /* Special Case:                        */
    {                             /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX;
        }

        if (nulcheck == 0 && scale == 1. && zero == 0.)
            convert = 0;  /* no need to scale data or find nulls */
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);
        if (elemincre >= 0)
        {
          ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));
        }
        else
        {
          ntodo = (long) minvalue(ntodo, (elemnum/(-elemincre) +1));
        }

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, &array[next], status);
                if (convert)
                    fffi1i1(&array[next], ntodo, scale, zero, nulcheck, 
                    (unsigned char) tnull, nulval, &nularray[next], anynul, 
                           &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short *) buffer, status);
                fffi2i1((short  *) buffer, ntodo, scale, zero, nulcheck, 
                       (short) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) buffer,
                       status);
                fffi4i1((INT32BIT *) buffer, ntodo, scale, zero, nulcheck, 
                       (INT32BIT) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TLONGLONG):
                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8i1( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4i1((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8i1((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                /* interpret the string as an ASCII formated number */
                fffstri1((char *) buffer, ntodo, scale, zero, twidth, power,
                      nulcheck, snull, nulval, &nularray[next], anynul,
                      &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read bytes from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgclb).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgclb).",
              dtemp+1., dtemp+ntodo);

         ffpmsg(message);
         return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
            else if (elemnum < 0)  /* completed a row; start on a previous row */
            {
                rowincre = (-elemnum - 1) / repeat + 1;
                rownum -= rowincre;
                elemnum = (rowincre * repeat) + elemnum;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgextn( fitsfile *fptr,        /* I - FITS file pointer                        */
            LONGLONG  offset,      /* I - byte offset from start of extension data */
            LONGLONG  nelem,       /* I - number of elements to read               */
            void *buffer,          /* I - stream of bytes to read                  */
            int  *status)          /* IO - error status                            */
/*
  Read a stream of bytes from the current FITS HDU.  This primative routine is mainly
  for reading non-standard "conforming" extensions and should not be used
  for standard IMAGE, TABLE or BINTABLE extensions.
*/
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* rescan header if data structure is undefined */
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               
            return(*status);

    /* move to write position */
    ffmbyt(fptr, (fptr->Fptr)->datastart+ offset, IGNORE_EOF, status);
    
    /* read the buffer */
    ffgbyt(fptr, nelem, buffer, status); 

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1i1(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            unsigned char nullval,/* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            unsigned char *output,/* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {              /* this routine is normally not called in this case */
           memcpy(output, input, ntodo );
        }
        else             /* must scale the data */
        {                
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2i1(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            unsigned char nullval,/* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            unsigned char *output,/* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > UCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }

                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > UCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4i1(INT32BIT *input,          /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            unsigned char nullval,/* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            unsigned char *output,/* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > UCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > UCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8i1(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
            unsigned char nullval,/* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            unsigned char *output,/* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > UCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > UCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4i1(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char nullval,/* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            unsigned char *output,/* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DUCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > DUCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              /* use redundant boolean logic in following statement */
              /* to suppress irritating Borland compiler warning message */
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (zero > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8i1(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char nullval,/* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            unsigned char *output,/* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DUCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > DUCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UCHAR_MAX;
                }
                else
                    output[ii] = (unsigned char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (zero > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UCHAR_MAX;
                    }
                    else
                        output[ii] = (unsigned char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstri1(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
            unsigned char nullval, /* I - set null pixels, if nullcheck = 1  */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            unsigned char *output, /* O - array of converted pixels          */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int  nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')       /* check for decimal point */
        {
          decpt = 1;
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DUCHAR_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = 0;
        }
        else if (dvalue > DUCHAR_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = UCHAR_MAX;
        }
        else
            output[ii] = (unsigned char) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcold.c0000664000175000017500000020333413010375005016552 0ustar  zoncazonca00000000000000/*  This file, getcold.c, contains routines that read data elements from   */
/*  a FITS image or table, with double datatype.                           */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvd( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            double nulval,    /* I - value for undefined pixels              */
            double *array,    /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    double nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TDOUBLE, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcld(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfd( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            double *array,    /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TDOUBLE, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcld(fptr, 2, row, firstelem, nelem, 1, 2, 0.,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2dd(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           double nulval,   /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           double *array,   /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3dd(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3dd(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           double nulval,   /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
           double *array,   /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    LONGLONG nfits, narray;
    long tablerow, ii, jj;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1};
    LONGLONG lpixel[3];
    double nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] =  (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TDOUBLE, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgcld(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgcld(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvd(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           double nulval,  /* I - value to set undefined pixels             */
           double *array,  /* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dir[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    double nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvd is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TDOUBLE, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
        dir[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        if (hdutype == IMAGE_HDU)
        {
           dir[ii] = -1;
        }
        else
        {
          sprintf(msg, "ffgsvd: illegal range specified for axis %ld", ii + 1);
          ffpmsg(msg);
          return(*status = BAD_PIX_NUM);
        }
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
      dsize[ii] = dsize[ii] * dir[ii];
    }
    dsize[naxis] = dsize[naxis] * dir[naxis];

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0]*dir[0] - str[0]*dir[0]) / inc[0] + 1;
      ninc = incr[0] * dir[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]*dir[8]; i8 <= stp[8]*dir[8]; i8 += incr[8])
     {
      for (i7 = str[7]*dir[7]; i7 <= stp[7]*dir[7]; i7 += incr[7])
      {
       for (i6 = str[6]*dir[6]; i6 <= stp[6]*dir[6]; i6 += incr[6])
       {
        for (i5 = str[5]*dir[5]; i5 <= stp[5]*dir[5]; i5 += incr[5])
        {
         for (i4 = str[4]*dir[4]; i4 <= stp[4]*dir[4]; i4 += incr[4])
         {
          for (i3 = str[3]*dir[3]; i3 <= stp[3]*dir[3]; i3 += incr[3])
          {
           for (i2 = str[2]*dir[2]; i2 <= stp[2]*dir[2]; i2 += incr[2])
           {
            for (i1 = str[1]*dir[1]; i1 <= stp[1]*dir[1]; i1 += incr[1])
            {

              felem=str[0] + (i1 - dir[1]) * dsize[1] + (i2 - dir[2]) * dsize[2] + 
                             (i3 - dir[3]) * dsize[3] + (i4 - dir[4]) * dsize[4] +
                             (i5 - dir[5]) * dsize[5] + (i6 - dir[6]) * dsize[6] +
                             (i7 - dir[7]) * dsize[7] + (i8 - dir[8]) * dsize[8];

              if ( ffgcld(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfd(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           double *array,  /* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    int hdutype, anyf;
    double nulval = 0;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvd is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TDOUBLE, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }
/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvd: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgcld(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpd( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
            double *array,    /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcld(fptr, 1, row, firstelem, nelem, 1, 1, 0.,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvd(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           double nulval,    /* I - value for null pixels                   */
           double *array,    /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgcld(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvm(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           double nulval,    /* I - value for null pixels                   */
           double *array,    /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.

  TSCAL and ZERO should not be used with complex values. 
*/
{
    char cdummy;

    /* a complex double value is interpreted as a pair of double values,   */
    /* thus need to multiply the first element and number of elements by 2 */

    ffgcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
        1, 1, nulval, array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfd(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           double *array,    /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    double dummy = 0;

    ffgcld(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfm(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           double *array,    /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.

  TSCAL and ZERO should not be used with complex values. 
*/
{
    LONGLONG ii, jj;
    float dummy = 0;
    char *carray;

    /* a complex double value is interpreted as a pair of double values,   */
    /* thus need to multiply the first element and number of elements by 2 */

    /* allocate temporary array */
    carray = (char *) calloc( (size_t) (nelem * 2), 1); 

    ffgcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
     1, 2, dummy, array, carray, anynul, status);

    for (ii = 0, jj = 0; jj < nelem; ii += 2, jj++)
    {
       if (carray[ii] || carray[ii + 1])
          nularray[jj] = 1;
       else
          nularray[jj] = 0;
    }

    free(carray);    
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcld( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            double nulval,    /* I - value for null pixels if nultyp = 1     */
            double *array,    /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1, dtemp;
    int tcode, hdutype, xcode, decimals, maxelem2;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int convert, nulcheck, readcheck = 0;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (elemincre < 0)
        readcheck = -1;  /* don't do range checking in this case */

    if ( ffgcprll( fptr, colnum, firstrow, firstelem, nelem, readcheck, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }

    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    convert = 1;
    if (tcode == TDOUBLE) /* Special Case:                        */
    {                              /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/8) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/8;
        }

        if (nulcheck == 0 && scale == 1. && zero == 0.)
            convert = 0;  /* no need to scale data or find nulls */
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);
        if (elemincre >= 0)
        {
          ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));
        }
        else
        {
          ntodo = (long) minvalue(ntodo, (elemnum/(-elemincre) +1));
        }

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, &array[next], status);
                if (convert)
                    fffr8r8(&array[next], ntodo, scale, zero, nulcheck, 
                           nulval, &nularray[next], anynul, 
                           &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                       status);
                fffi1r8((unsigned char *) buffer, ntodo, scale, zero, nulcheck, 
                   (unsigned char) tnull, nulval, &nularray[next], anynul, 
                   &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short  *) buffer, status);
                fffi2r8((short  *) buffer, ntodo, scale, zero, nulcheck, 
                    (short) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) buffer,
                       status);
                fffi4r8((INT32BIT *) buffer, ntodo, scale, zero, nulcheck, 
                       (INT32BIT) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TLONGLONG):
                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8r8( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4r8((float  *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstrr8((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;


            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgcld).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgcld).",
              dtemp+1., dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = (long) (elemnum / repeat);
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
            else if (elemnum < 0)  /* completed a row; start on a previous row */
            {
                rowincre = (long) ((-elemnum - 1) / repeat + 1);
                rownum -= rowincre;
                elemnum = (rowincre * repeat) + elemnum;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1r8(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            double nullval,       /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,       /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii]; /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = input[ii] * scale + zero;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (double) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    output[ii] = input[ii] * scale + zero;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2r8(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            double nullval,       /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,       /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii]; /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = input[ii] * scale + zero;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (double) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    output[ii] = input[ii] * scale + zero;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4r8(INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            double nullval,       /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,       /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii]; /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = input[ii] * scale + zero;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (double) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    output[ii] = input[ii] * scale + zero;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8r8(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
            double nullval,       /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,       /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii]; /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = input[ii] * scale + zero;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (double) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    output[ii] = input[ii] * scale + zero;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4r8(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            double nullval,       /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,       /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii]; /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = input[ii] * scale + zero;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                output[ii] = (double) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = zero;
              }
              else
                  output[ii] = input[ii] * scale + zero;
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8r8(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            double nullval,       /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,       /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            memcpy(output, input, ntodo * sizeof(double) );
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = input[ii] * scale + zero;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                    {
                        nullarray[ii] = 1;
                       /* explicitly set value in case output contains a NaN */
                        output[ii] = DOUBLENULLVALUE;
                    }
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                  output[ii] = input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                    {
                        nullarray[ii] = 1;
                       /* explicitly set value in case output contains a NaN */
                        output[ii] = DOUBLENULLVALUE;
                    }
                  }
                  else            /* it's an underflow */
                     output[ii] = zero;
              }
              else
                  output[ii] = input[ii] * scale + zero;
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstrr8(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
            double nullval,       /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,       /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')              /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        output[ii] = (dvalue * scale + zero);   /* apply the scaling */
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcole.c0000664000175000017500000020350613010375005016554 0ustar  zoncazonca00000000000000/*  This file, getcole.c, contains routines that read data elements from   */
/*  a FITS image or table, with float datatype                             */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpve( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            float nulval,     /* I - value for undefined pixels              */
            float *array,     /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    float nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TFLOAT, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcle(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfe( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            float *array,     /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TFLOAT, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcle(fptr, 2, row, firstelem, nelem, 1, 2, 0.F,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2de(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           float nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           float *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3de(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3de(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           float nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
           float *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow;
    LONGLONG narray, nfits, ii, jj;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1};
    LONGLONG lpixel[3];
    float nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TFLOAT, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgcle(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgcle(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsve(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           float nulval,   /* I - value to set undefined pixels             */
           float *array,   /* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dir[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    float nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsve is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TFLOAT, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
        dir[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        if (hdutype == IMAGE_HDU)
        {
           dir[ii] = -1;
        }
        else
        {
          sprintf(msg, "ffgsve: illegal range specified for axis %ld", ii + 1);
          ffpmsg(msg);
          return(*status = BAD_PIX_NUM);
        }
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
      dsize[ii] = dsize[ii] * dir[ii];
    }
    dsize[naxis] = dsize[naxis] * dir[naxis];

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0]*dir[0] - str[0]*dir[0]) / inc[0] + 1;
      ninc = incr[0] * dir[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]*dir[8]; i8 <= stp[8]*dir[8]; i8 += incr[8])
     {
      for (i7 = str[7]*dir[7]; i7 <= stp[7]*dir[7]; i7 += incr[7])
      {
       for (i6 = str[6]*dir[6]; i6 <= stp[6]*dir[6]; i6 += incr[6])
       {
        for (i5 = str[5]*dir[5]; i5 <= stp[5]*dir[5]; i5 += incr[5])
        {
         for (i4 = str[4]*dir[4]; i4 <= stp[4]*dir[4]; i4 += incr[4])
         {
          for (i3 = str[3]*dir[3]; i3 <= stp[3]*dir[3]; i3 += incr[3])
          {
           for (i2 = str[2]*dir[2]; i2 <= stp[2]*dir[2]; i2 += incr[2])
           {
            for (i1 = str[1]*dir[1]; i1 <= stp[1]*dir[1]; i1 += incr[1])
            {

              felem=str[0] + (i1 - dir[1]) * dsize[1] + (i2 - dir[2]) * dsize[2] + 
                             (i3 - dir[3]) * dsize[3] + (i4 - dir[4]) * dsize[4] +
                             (i5 - dir[5]) * dsize[5] + (i6 - dir[6]) * dsize[6] +
                             (i7 - dir[7]) * dsize[7] + (i8 - dir[8]) * dsize[8];

              if ( ffgcle(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfe(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           float *array,   /* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    int hdutype, anyf;
    float nulval = 0;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsve is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TFLOAT, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsve: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgcle(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpe( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
            float *array,     /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcle(fptr, 1, row, firstelem, nelem, 1, 1, 0.F,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcve(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           float nulval,     /* I - value for null pixels                   */
           float *array,     /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgcle(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvc(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           float nulval,     /* I - value for null pixels                   */
           float *array,     /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.

  TSCAL and ZERO should not be used with complex values. 
*/
{
    char cdummy;

    /* a complex value is interpreted as a pair of float values, thus */
    /* need to multiply the first element and number of elements by 2 */

    ffgcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem *2,
           1, 1, nulval, array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfe(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           float *array,     /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    float dummy = 0;

    ffgcle(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfc(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           float *array,     /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.

  TSCAL and ZERO should not be used with complex values. 
*/
{
    LONGLONG ii, jj;
    float dummy = 0;
    char *carray;

    /* a complex value is interpreted as a pair of float values, thus */
    /* need to multiply the first element and number of elements by 2 */
    
    /* allocate temporary array */
    carray = (char *) calloc( (size_t) (nelem * 2), 1); 

    ffgcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
           1, 2, dummy, array, carray, anynul, status);

    for (ii = 0, jj = 0; jj < nelem; ii += 2, jj++)
    {
       if (carray[ii] || carray[ii + 1])
          nularray[jj] = 1;
       else
          nularray[jj] = 0;
    }

    free(carray);    
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcle( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            float nulval,     /* I - value for null pixels if nultyp = 1     */
            float *array,     /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int convert, nulcheck, readcheck = 0;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
       *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (elemincre < 0)
        readcheck = -1;  /* don't do range checking in this case */

    if ( ffgcprll( fptr, colnum, firstrow, firstelem, nelem, readcheck, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }

    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    convert = 1;
    if (tcode == TFLOAT) /* Special Case:                        */
    {                             /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/4) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/4;
        }

        if (nulcheck == 0 && scale == 1. && zero == 0.)
            convert = 0;  /* no need to scale data or find nulls */
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);
        if (elemincre >= 0)
        {
          ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));
        }
        else
        {
          ntodo = (long) minvalue(ntodo, (elemnum/(-elemincre) +1));
        }

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, &array[next], status);
                if (convert)
                    fffr4r4(&array[next], ntodo, scale, zero, nulcheck, 
                           nulval, &nularray[next], anynul, 
                           &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                       status);
                fffi1r4((unsigned char *) buffer, ntodo, scale, zero, nulcheck, 
                    (unsigned char) tnull, nulval, &nularray[next], anynul, 
                     &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short  *) buffer, status);
                fffi2r4((short  *) buffer, ntodo, scale, zero, nulcheck, 
                       (short) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) buffer,
                       status);
                fffi4r4((INT32BIT *) buffer, ntodo, scale, zero, nulcheck, 
                       (INT32BIT) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;

            case (TLONGLONG):
                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8r4( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8r4((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstrr4((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;


            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgcle).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgcle).",
              dtemp+1., dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
            else if (elemnum < 0)  /* completed a row; start on a previous row */
            {
                rowincre = (-elemnum - 1) / repeat + 1;
                rownum -= rowincre;
                elemnum = (rowincre * repeat) + elemnum;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1r4(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];  /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = (float) (( (double) input[ii] ) * scale + zero);
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (float) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    output[ii] = (float) (( (double) input[ii] ) * scale + zero);
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2r4(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];  /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = (float) (input[ii] * scale + zero);
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (float) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    output[ii] = (float) (input[ii] * scale + zero);
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4r4(INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];  /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = (float) (input[ii] * scale + zero);
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (float) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    output[ii] = (float) (input[ii] * scale + zero);
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8r4(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];  /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = (float) (input[ii] * scale + zero);
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (float) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    output[ii] = (float) (input[ii] * scale + zero);
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4r4(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            memcpy(output, input, ntodo * sizeof(float) );
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = (float) (input[ii] * scale + zero);
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                    {
                        nullarray[ii] = 1;
                       /* explicitly set value in case output contains a NaN */
                        output[ii] = FLOATNULLVALUE;
                    }
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                output[ii] = input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                    {
                        nullarray[ii] = 1;
                       /* explicitly set value in case output contains a NaN */
                        output[ii] = FLOATNULLVALUE;
                    }
                  }
                  else            /* it's an underflow */
                     output[ii] = (float) zero;
              }
              else
                  output[ii] = (float) (input[ii] * scale + zero);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8r4(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii]; /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                output[ii] = (float) (input[ii] * scale + zero);
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                  output[ii] = (float) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = (float) zero;
              }
              else
                  output[ii] = (float) (input[ii] * scale + zero);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstrr4(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')       /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        output[ii] = (float) (dvalue * scale + zero);   /* apply the scaling */

      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcoli.c0000664000175000017500000021636213010375005016564 0ustar  zoncazonca00000000000000/*  This file, getcoli.c, contains routines that read data elements from   */
/*  a FITS image or table, with short datatype.                            */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvi( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            short nulval,     /* I - value for undefined pixels              */
            short *array,     /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    short nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */
        fits_read_compressed_pixels(fptr, TSHORT, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcli(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfi( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            short *array,     /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TSHORT, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcli(fptr, 2, row, firstelem, nelem, 1, 2, 0,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2di(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           short nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           short *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3di(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3di(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           short nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
           short *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    LONGLONG nfits, narray;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1};
    LONGLONG lpixel[3];
    short nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TSHORT, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgcli(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgcli(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvi(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           short nulval,   /* I - value to set undefined pixels             */
           short *array,   /* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dir[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    short nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvi is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TSHORT, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);

        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
        dir[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        if (hdutype == IMAGE_HDU)
        {
           dir[ii] = -1;
        }
        else
        {
          sprintf(msg, "ffgsvi: illegal range specified for axis %ld", ii + 1);
          ffpmsg(msg);
          return(*status = BAD_PIX_NUM);
        }
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
      dsize[ii] = dsize[ii] * dir[ii];
    }
    dsize[naxis] = dsize[naxis] * dir[naxis];

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0]*dir[0] - str[0]*dir[0]) / inc[0] + 1;
      ninc = incr[0] * dir[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]*dir[8]; i8 <= stp[8]*dir[8]; i8 += incr[8])
     {
      for (i7 = str[7]*dir[7]; i7 <= stp[7]*dir[7]; i7 += incr[7])
      {
       for (i6 = str[6]*dir[6]; i6 <= stp[6]*dir[6]; i6 += incr[6])
       {
        for (i5 = str[5]*dir[5]; i5 <= stp[5]*dir[5]; i5 += incr[5])
        {
         for (i4 = str[4]*dir[4]; i4 <= stp[4]*dir[4]; i4 += incr[4])
         {
          for (i3 = str[3]*dir[3]; i3 <= stp[3]*dir[3]; i3 += incr[3])
          {
           for (i2 = str[2]*dir[2]; i2 <= stp[2]*dir[2]; i2 += incr[2])
           {
            for (i1 = str[1]*dir[1]; i1 <= stp[1]*dir[1]; i1 += incr[1])
            {

              felem=str[0] + (i1 - dir[1]) * dsize[1] + (i2 - dir[2]) * dsize[2] + 
                             (i3 - dir[3]) * dsize[3] + (i4 - dir[4]) * dsize[4] +
                             (i5 - dir[5]) * dsize[5] + (i6 - dir[6]) * dsize[6] +
                             (i7 - dir[7]) * dsize[7] + (i8 - dir[8]) * dsize[8];

              if ( ffgcli(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfi(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           short *array,   /* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    int hdutype, anyf;
    short nulval = 0;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvi is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TSHORT, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvi: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgcli(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpi( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
            short *array,     /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcli(fptr, 1, row, firstelem, nelem, 1, 1, 0,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvi(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           short nulval,     /* I - value for null pixels                   */
           short *array,     /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgcli(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfi(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           short *array,     /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    short dummy = 0;

    ffgcli(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcli( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  firstelem, /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            short nulval,     /* I - value for null pixels if nultyp = 1     */
            short *array,     /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int convert, nulcheck, readcheck = 0;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (elemincre < 0)
        readcheck = -1;  /* don't do range checking in this case */

    if ( ffgcprll( fptr, colnum, firstrow, firstelem, nelem, readcheck, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    convert = 1;
    if (tcode == TSHORT) /* Special Case:                        */
    {                             /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/2) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/2;
        }

        if (nulcheck == 0 && scale == 1. && zero == 0.)
            convert = 0;  /* no need to scale data or find nulls */
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);
        if (elemincre >= 0)
        {
          ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));
        }
        else
        {
          ntodo = (long) minvalue(ntodo, (elemnum/(-elemincre) +1));
        }

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, &array[next], status);
                if (convert)
                    fffi2i2(&array[next], ntodo, scale, zero, nulcheck, 
                           (short) tnull, nulval, &nularray[next], anynul, 
                           &array[next], status);
                break;
            case (TLONGLONG):

                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8i2( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                      status);
                fffi1i2((unsigned char *) buffer, ntodo, scale, zero, nulcheck, 
                    (unsigned char) tnull, nulval, &nularray[next], anynul, 
                    &array[next], status);
                break;
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) buffer,
                       status);
                fffi4i2((INT32BIT *) buffer, ntodo, scale, zero, nulcheck, 
                       (INT32BIT) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4i2((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8i2((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstri2((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgcli).",
              dtemp+1, dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgcli).",
              dtemp+1, dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
            else if (elemnum < 0) /* completed a row; start on a previous row */
            {
                rowincre = (-elemnum - 1) / repeat + 1;
                rownum -= rowincre;
                elemnum = (rowincre * repeat) + elemnum;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1i2(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (short) input[ii];  /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (dvalue > DSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (short) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (dvalue > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2i2(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            memcpy(output, input, ntodo * sizeof(short) );
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (dvalue > DSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (dvalue > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4i2(INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < SHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (input[ii] > SHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (dvalue > DSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < SHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (input[ii] > SHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (dvalue > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8i2(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
            short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < SHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (input[ii] > SHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (dvalue > DSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < SHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (input[ii] > SHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (dvalue > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4i2(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (input[ii] > DSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (dvalue > DSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (input[ii] > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (zero > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (dvalue > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8i2(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (input[ii] > DSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MIN;
                }
                else if (dvalue > DSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = SHRT_MAX;
                }
                else
                    output[ii] = (short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (input[ii] > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (zero > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MIN;
                    }
                    else if (dvalue > DSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = SHRT_MAX;
                    }
                    else
                        output[ii] = (short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstri2(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
            short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')       /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DSHRT_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = SHRT_MIN;
        }
        else if (dvalue > DSHRT_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = SHRT_MAX;
        }
        else
            output[ii] = (short) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcolj.c0000664000175000017500000043137713010375005016572 0ustar  zoncazonca00000000000000/*  This file, getcolj.c, contains routines that read data elements from   */
/*  a FITS image or table, with long data type.                            */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvj( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  nulval,     /* I - value for undefined pixels              */
            long  *array,     /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    long nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TLONG, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclj(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfj( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  *array,     /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TLONG, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclj(fptr, 2, row, firstelem, nelem, 1, 2, 0L,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2dj(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           long  nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           long  *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3dj(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3dj(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           long  nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
           long  *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1}, nfits, narray;
    LONGLONG lpixel[3], nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TLONG, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgclj(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgclj(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvj(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           long nulval,    /* I - value to set undefined pixels             */
           long *array,    /* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dir[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    long nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TLONG, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
        dir[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        if (hdutype == IMAGE_HDU)
        {
           dir[ii] = -1;
        }
        else
        {
          sprintf(msg, "ffgsvj: illegal range specified for axis %ld", ii + 1);
          ffpmsg(msg);
          return(*status = BAD_PIX_NUM);
        }
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
      dsize[ii] = dsize[ii] * dir[ii];
    }
    dsize[naxis] = dsize[naxis] * dir[naxis];

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0]*dir[0] - str[0]*dir[0]) / inc[0] + 1;
      ninc = incr[0] * dir[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]*dir[8]; i8 <= stp[8]*dir[8]; i8 += incr[8])
     {
      for (i7 = str[7]*dir[7]; i7 <= stp[7]*dir[7]; i7 += incr[7])
      {
       for (i6 = str[6]*dir[6]; i6 <= stp[6]*dir[6]; i6 += incr[6])
       {
        for (i5 = str[5]*dir[5]; i5 <= stp[5]*dir[5]; i5 += incr[5])
        {
         for (i4 = str[4]*dir[4]; i4 <= stp[4]*dir[4]; i4 += incr[4])
         {
          for (i3 = str[3]*dir[3]; i3 <= stp[3]*dir[3]; i3 += incr[3])
          {
           for (i2 = str[2]*dir[2]; i2 <= stp[2]*dir[2]; i2 += incr[2])
           {
            for (i1 = str[1]*dir[1]; i1 <= stp[1]*dir[1]; i1 += incr[1])
            {

              felem=str[0] + (i1 - dir[1]) * dsize[1] + (i2 - dir[2]) * dsize[2] + 
                             (i3 - dir[3]) * dsize[3] + (i4 - dir[4]) * dsize[4] +
                             (i5 - dir[5]) * dsize[5] + (i6 - dir[6]) * dsize[6] +
                             (i7 - dir[7]) * dsize[7] + (i8 - dir[8]) * dsize[8];

              if ( ffgclj(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfj(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           long *array,    /* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    long nulval = 0;
    int hdutype, anyf;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TLONG, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvj: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgclj(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpj( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
            long  *array,     /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclj(fptr, 1, row, firstelem, nelem, 1, 1, 0L,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvj(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           long  nulval,     /* I - value for null pixels                   */
           long *array,      /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgclj(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfj(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           long  *array,     /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    long dummy = 0;

    ffgclj(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgclj( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            long  nulval,     /* I - value for null pixels if nultyp = 1     */
            long  *array,     /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int convert, nulcheck, readcheck = 0;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (elemincre < 0)
        readcheck = -1;  /* don't do range checking in this case */

    if (ffgcprll(fptr, colnum, firstrow, firstelem, nelem, readcheck, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    convert = 1;
    if (tcode == TLONG)  /* Special Case:                        */
    {                             /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/8) {
            maxelem = nelem;
        } else {
        /* divide by 8 instead of 4 in case sizeof(long) = 8 */
            maxelem = INT32_MAX/8;   
        }

        if (nulcheck == 0 && scale == 1. && zero == 0. && LONGSIZE == 32)
            convert = 0;  /* no need to scale data or find nulls */
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);
        if (elemincre >= 0)
        {
          ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));
        }
        else
        {
          ntodo = (long) minvalue(ntodo, (elemnum/(-elemincre) +1));
        }

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) &array[next],
                       status);
                if (convert)
                    fffi4i4((INT32BIT *) &array[next], ntodo, scale, zero, 
                           nulcheck, (INT32BIT) tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TLONGLONG):
                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8i4((LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                       status);
                fffi1i4((unsigned char *) buffer, ntodo, scale, zero, nulcheck, 
                     (unsigned char) tnull, nulval, &nularray[next], anynul, 
                     &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short  *) buffer, status);
                fffi2i4((short  *) buffer, ntodo, scale, zero, nulcheck, 
                      (short) tnull, nulval, &nularray[next], anynul, 
                      &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4i4((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8i4((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstri4((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgclj).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgclj).",
              dtemp+1., dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
            else if (elemnum < 0)  /* completed a row; start on a previous row */
            {
                rowincre = (-elemnum - 1) / repeat + 1;
                rownum -= rowincre;
                elemnum = (rowincre * repeat) + elemnum;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1i4(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (long) input[ii];  /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (dvalue > DLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (long) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (dvalue > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2i4(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (long) input[ii];   /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (dvalue > DLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (long) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (dvalue > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4i4(INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;

  Process the array of data in reverse order, to handle the case where
  the input data is 4-bytes and the output is  8-bytes and the conversion
  is being done in place in the same array.
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = ntodo - 1; ii >= 0; ii--)
                output[ii] = (long) input[ii];   /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = ntodo - 1; ii >= 0; ii--)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (dvalue > DLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = ntodo - 1; ii >= 0; ii--)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = input[ii];

            }
        }
        else                  /* must scale the data */
        {
            for (ii = ntodo - 1; ii >= 0; ii--)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (dvalue > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8i4(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
            long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < LONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (input[ii] > LONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (dvalue > DLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < LONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (input[ii] > LONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (dvalue > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4i4(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (input[ii] > DLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (dvalue > DLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (input[ii] > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (zero > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (dvalue > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8i4(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (input[ii] > DLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MIN;
                }
                else if (dvalue > DLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONG_MAX;
                }
                else
                    output[ii] = (long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (input[ii] > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (zero > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MIN;
                    }
                    else if (dvalue > DLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONG_MAX;
                    }
                    else
                        output[ii] = (long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstri4(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
            long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')    /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DLONG_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = LONG_MIN;
        }
        else if (dvalue > DLONG_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = LONG_MAX;
        }
        else
            output[ii] = (long) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}

/* ======================================================================== */
/*      the following routines support the 'long long' data type            */
/* ======================================================================== */

/*--------------------------------------------------------------------------*/
int ffgpvjj(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            LONGLONG  nulval, /* I - value for undefined pixels              */
            LONGLONG  *array, /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    LONGLONG nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TLONGLONG, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcljj(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfjj(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            LONGLONG  *array, /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;
    LONGLONG dummy = 0;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TLONGLONG, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcljj(fptr, 2, row, firstelem, nelem, 1, 2, dummy,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2djj(fitsfile *fptr, /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           LONGLONG nulval ,/* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  *array,/* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3djj(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3djj(fitsfile *fptr, /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           LONGLONG nulval, /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
           LONGLONG  *array,/* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1}, nfits, narray;
    LONGLONG lpixel[3];
    LONGLONG nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TLONGLONG, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgcljj(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgcljj(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvjj(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           LONGLONG nulval,/* I - value to set undefined pixels             */
           LONGLONG *array,/* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dir[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    LONGLONG nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TLONGLONG, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
        dir[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        if (hdutype == IMAGE_HDU)
        {
           dir[ii] = -1;
        }
        else
        {
          sprintf(msg, "ffgsvj: illegal range specified for axis %ld", ii + 1);
          ffpmsg(msg);
          return(*status = BAD_PIX_NUM);
        }
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
      dsize[ii] = dsize[ii] * dir[ii];
    }
    dsize[naxis] = dsize[naxis] * dir[naxis];

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0]*dir[0] - str[0]*dir[0]) / inc[0] + 1;
      ninc = incr[0] * dir[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]*dir[8]; i8 <= stp[8]*dir[8]; i8 += incr[8])
     {
      for (i7 = str[7]*dir[7]; i7 <= stp[7]*dir[7]; i7 += incr[7])
      {
       for (i6 = str[6]*dir[6]; i6 <= stp[6]*dir[6]; i6 += incr[6])
       {
        for (i5 = str[5]*dir[5]; i5 <= stp[5]*dir[5]; i5 += incr[5])
        {
         for (i4 = str[4]*dir[4]; i4 <= stp[4]*dir[4]; i4 += incr[4])
         {
          for (i3 = str[3]*dir[3]; i3 <= stp[3]*dir[3]; i3 += incr[3])
          {
           for (i2 = str[2]*dir[2]; i2 <= stp[2]*dir[2]; i2 += incr[2])
           {
            for (i1 = str[1]*dir[1]; i1 <= stp[1]*dir[1]; i1 += incr[1])
            {

              felem=str[0] + (i1 - dir[1]) * dsize[1] + (i2 - dir[2]) * dsize[2] + 
                             (i3 - dir[3]) * dsize[3] + (i4 - dir[4]) * dsize[4] +
                             (i5 - dir[5]) * dsize[5] + (i6 - dir[6]) * dsize[6] +
                             (i7 - dir[7]) * dsize[7] + (i8 - dir[8]) * dsize[8];

              if ( ffgcljj(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfjj(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           LONGLONG *array,/* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    LONGLONG nulval = 0;
    int hdutype, anyf;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

         fits_read_compressed_img(fptr, TLONGLONG, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvj: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgcljj(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpjj(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
            LONGLONG  *array, /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    LONGLONG dummy = 0;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcljj(fptr, 1, row, firstelem, nelem, 1, 1, dummy,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvjj(fitsfile *fptr,  /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           LONGLONG  nulval, /* I - value for null pixels                   */
           LONGLONG *array,  /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgcljj(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfjj(fitsfile *fptr,  /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           LONGLONG  *array, /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    LONGLONG dummy = 0;

    ffgcljj(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcljj( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            LONGLONG  nulval, /* I - value for null pixels if nultyp = 1     */
            LONGLONG  *array, /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int convert, nulcheck, readcheck = 0;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (elemincre < 0)
        readcheck = -1;  /* don't do range checking in this case */

    if (ffgcprll(fptr, colnum, firstrow, firstelem, nelem, readcheck, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    convert = 1;
    if (tcode == TLONGLONG)  /* Special Case:                        */
    {                             /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/8) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/8;
        }

        if (nulcheck == 0 && scale == 1. && zero == 0.)
            convert = 0;  /* no need to scale data or find nulls */
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);
        if (elemincre >= 0)
        {
          ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));
        }
        else
        {
          ntodo = (long) minvalue(ntodo, (elemnum/(-elemincre) +1));
        }

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TLONGLONG):
                ffgi8b(fptr, readptr, ntodo, incre, (long *) &array[next],
                       status);
                if (convert)
                    fffi8i8((LONGLONG *) &array[next], ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                           anynul, &array[next], status);
                break;
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) buffer,
                       status);
                fffi4i8((INT32BIT *) buffer, ntodo, scale, zero, 
                        nulcheck, (INT32BIT) tnull, nulval, &nularray[next], 
                        anynul, &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                       status);
                fffi1i8((unsigned char *) buffer, ntodo, scale, zero, nulcheck, 
                     (unsigned char) tnull, nulval, &nularray[next], anynul, 
                     &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short  *) buffer, status);
                fffi2i8((short  *) buffer, ntodo, scale, zero, nulcheck, 
                      (short) tnull, nulval, &nularray[next], anynul, 
                      &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4i8((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8i8((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstri8((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgclj).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgclj).",
              dtemp+1., dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
            else if (elemnum < 0)  /* completed a row; start on a previous row */
            {
                rowincre = (-elemnum - 1) / repeat + 1;
                rownum -= rowincre;
                elemnum = (rowincre * repeat) + elemnum;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1i8(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            LONGLONG nullval,     /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            LONGLONG *output,     /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (LONGLONG) input[ii];  /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONGLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MIN;
                }
                else if (dvalue > DLONGLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MAX;
                }
                else
                    output[ii] = (LONGLONG) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (LONGLONG) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (dvalue > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2i8(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            LONGLONG nullval,     /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            LONGLONG *output,     /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (LONGLONG) input[ii];   /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONGLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MIN;
                }
                else if (dvalue > DLONGLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MAX;
                }
                else
                    output[ii] = (LONGLONG) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (LONGLONG) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (dvalue > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4i8(INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            LONGLONG nullval,     /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            LONGLONG *output,     /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (LONGLONG) input[ii];   /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONGLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MIN;
                }
                else if (dvalue > DLONGLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MAX;
                }
                else
                    output[ii] = (LONGLONG) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (LONGLONG) input[ii];

            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (dvalue > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8i8(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
            LONGLONG nullval,     /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            LONGLONG *output,     /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] =  input[ii];   /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONGLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MIN;
                }
                else if (dvalue > DLONGLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MAX;
                }
                else
                    output[ii] = (LONGLONG) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = input[ii];

            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (dvalue > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4i8(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG nullval,     /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            LONGLONG *output,     /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DLONGLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MIN;
                }
                else if (input[ii] > DLONGLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MAX;
                }
                else
                    output[ii] = (LONGLONG) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONGLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MIN;
                }
                else if (dvalue > DLONGLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MAX;
                }
                else
                    output[ii] = (LONGLONG) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (input[ii] > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (zero > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (dvalue > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8i8(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG nullval,     /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            LONGLONG *output,     /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DLONGLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MIN;
                }
                else if (input[ii] > DLONGLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MAX;
                }
                else
                    output[ii] = (LONGLONG) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DLONGLONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MIN;
                }
                else if (dvalue > DLONGLONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = LONGLONG_MAX;
                }
                else
                    output[ii] = (LONGLONG) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (input[ii] > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (zero > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DLONGLONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MIN;
                    }
                    else if (dvalue > DLONGLONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = LONGLONG_MAX;
                    }
                    else
                        output[ii] = (LONGLONG) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstri8(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
            LONGLONG nullval,     /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            LONGLONG *output,     /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')    /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DLONGLONG_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = LONGLONG_MIN;
        }
        else if (dvalue > DLONGLONG_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = LONGLONG_MAX;
        }
        else
            output[ii] = (LONGLONG) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcolk.c0000664000175000017500000021616313010375005016565 0ustar  zoncazonca00000000000000/*  This file, getcolk.c, contains routines that read data elements from   */
/*  a FITS image or table, with 'int' data type.                           */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvk( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            int   nulval,     /* I - value for undefined pixels              */
            int   *array,     /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    int nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TINT, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclk(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfk( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            int   *array,     /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TINT, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclk(fptr, 2, row, firstelem, nelem, 1, 2, 0L,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2dk(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           int  nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           int  *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3dk(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3dk(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           int   nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
           int   *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1}, nfits, narray;
    LONGLONG lpixel[3];
    int nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TINT, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgclk(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgclk(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvk(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           int  nulval,    /* I - value to set undefined pixels             */
           int  *array,    /* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dir[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    int nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TINT, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
        dir[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        if (hdutype == IMAGE_HDU)
        {
           dir[ii] = -1;
        }
        else
        {
          sprintf(msg, "ffgsvk: illegal range specified for axis %ld", ii + 1);
          ffpmsg(msg);
          return(*status = BAD_PIX_NUM);
        }
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
      dsize[ii] = dsize[ii] * dir[ii];
    }
    dsize[naxis] = dsize[naxis] * dir[naxis];

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0]*dir[0] - str[0]*dir[0]) / inc[0] + 1;
      ninc = incr[0] * dir[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]*dir[8]; i8 <= stp[8]*dir[8]; i8 += incr[8])
     {
      for (i7 = str[7]*dir[7]; i7 <= stp[7]*dir[7]; i7 += incr[7])
      {
       for (i6 = str[6]*dir[6]; i6 <= stp[6]*dir[6]; i6 += incr[6])
       {
        for (i5 = str[5]*dir[5]; i5 <= stp[5]*dir[5]; i5 += incr[5])
        {
         for (i4 = str[4]*dir[4]; i4 <= stp[4]*dir[4]; i4 += incr[4])
         {
          for (i3 = str[3]*dir[3]; i3 <= stp[3]*dir[3]; i3 += incr[3])
          {
           for (i2 = str[2]*dir[2]; i2 <= stp[2]*dir[2]; i2 += incr[2])
           {
            for (i1 = str[1]*dir[1]; i1 <= stp[1]*dir[1]; i1 += incr[1])
            {

              felem=str[0] + (i1 - dir[1]) * dsize[1] + (i2 - dir[2]) * dsize[2] + 
                             (i3 - dir[3]) * dsize[3] + (i4 - dir[4]) * dsize[4] +
                             (i5 - dir[5]) * dsize[5] + (i6 - dir[6]) * dsize[6] +
                             (i7 - dir[7]) * dsize[7] + (i8 - dir[8]) * dsize[8];

              if ( ffgclk(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfk(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           int  *array,    /* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    long nulval = 0;
    int hdutype, anyf;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TINT, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvj: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgclk(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpk( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
            int  *array,     /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclk(fptr, 1, row, firstelem, nelem, 1, 1, 0L,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvk(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           int   nulval,     /* I - value for null pixels                   */
           int  *array,      /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgclk(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfk(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           int   *array,     /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    int dummy = 0;

    ffgclk(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgclk( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            int   nulval,     /* I - value for null pixels if nultyp = 1     */
            int  *array,      /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power, dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int convert, nulcheck, readcheck = 0;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    /* call the 'short' or 'long' version of this routine, if possible */
    if (sizeof(int) == sizeof(short))
        ffgcli(fptr, colnum, firstrow, firstelem, nelem, elemincre, nultyp,
              (short) nulval, (short *) array, nularray, anynul, status);
    else if (sizeof(int) == sizeof(long))
        ffgclj(fptr, colnum, firstrow, firstelem, nelem, elemincre, nultyp,
              (long) nulval, (long *) array, nularray, anynul, status);
    else
    {
    /*
      This is a special case: sizeof(int) is not equal to sizeof(short) or
      sizeof(long).  This occurs on Alpha OSF systems where short = 2 bytes,
      int = 4 bytes, and long = 8 bytes.
    */

    buffer = cbuff;
    power = 1.;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (elemincre < 0)
        readcheck = -1;  /* don't do range checking in this case */

    if ( ffgcprll( fptr, colnum, firstrow, firstelem, nelem, readcheck, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    convert = 1;
    if (tcode == TLONG)           /* Special Case:                        */
    {                             /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/4) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/4;
        }

        if (nulcheck == 0 && scale == 1. && zero == 0.)
            convert = 0;  /* no need to scale data or find nulls */
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);
        if (elemincre >= 0)
        {
          ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));
        }
        else
        {
          ntodo = (long) minvalue(ntodo, (elemnum/(-elemincre) +1));
        }

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) &array[next],
                       status);
                if (convert)
                    fffi4int((INT32BIT *) &array[next], ntodo, scale, zero, 
                             nulcheck, (INT32BIT) tnull, nulval,
                             &nularray[next], anynul, &array[next], status);
                break;
            case (TLONGLONG):

                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8int( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                       status);
                fffi1int((unsigned char *) buffer, ntodo, scale, zero, nulcheck,
                     (unsigned char) tnull, nulval, &nularray[next], anynul, 
                     &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short  *) buffer, status);
                fffi2int((short  *) buffer, ntodo, scale, zero, nulcheck, 
                      (short) tnull, nulval, &nularray[next], anynul, 
                      &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4int((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8int((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstrint((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgclk).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgclk).",
              dtemp+1., dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
            else if (elemnum < 0)  /* completed a row; start on a previous row */
            {
                rowincre = (-elemnum - 1) / repeat + 1;
                rownum -= rowincre;
                elemnum = (rowincre * repeat) + elemnum;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    }  /* end of DEC Alpha special case */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1int(unsigned char *input,/* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (int) input[ii];  /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (dvalue > DINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (int) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (dvalue > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2int(short *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (int) input[ii];   /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (dvalue > DINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (int) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (dvalue > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4int(INT32BIT *input,     /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (int) input[ii];   /* copy input to output */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (dvalue > DINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (int) input[ii];

            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (dvalue > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8int(LONGLONG *input,     /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
            int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < INT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (input[ii] > INT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (dvalue > DINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < INT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (input[ii] > INT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (dvalue > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4int(float *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (input[ii] > DINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (dvalue > DINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (input[ii] > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  { 
                    if (zero < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (zero > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                      output[ii] = (int) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (dvalue > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8int(double *input,       /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (input[ii] > DINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MIN;
                }
                else if (dvalue > DINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = INT_MAX;
                }
                else
                    output[ii] = (int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (input[ii] > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  { 
                    if (zero < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (zero > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                      output[ii] = (int) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MIN;
                    }
                    else if (dvalue > DINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = INT_MAX;
                    }
                    else
                        output[ii] = (int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstrint(char *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
            int nullval,          /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            int *output,          /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')       /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DINT_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = INT_MIN;
        }
        else if (dvalue > DINT_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = INT_MAX;
        }
        else
            output[ii] = (long) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcoll.c0000664000175000017500000005514113010375005016563 0ustar  zoncazonca00000000000000/*  This file, getcoll.c, contains routines that read data elements from   */
/*  a FITS image or table, with logical datatype.                          */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include "fitsio2.h"
/*--------------------------------------------------------------------------*/
int ffgcvl( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            char  nulval,     /* I - value for null pixels                   */
            char *array,      /* O - array of values                         */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of logical values from a column in the current FITS HDU.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgcll( fptr, colnum, firstrow, firstelem, nelem, 1, nulval, array,
            &cdummy, anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcl(  fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            char *array,      /* O - array of values                         */
            int  *status)     /* IO - error status                           */
/*
  !!!! THIS ROUTINE IS DEPRECATED AND SHOULD NOT BE USED !!!!!!
                  !!!! USE ffgcvl INSTEAD  !!!!!!
  Read an array of logical values from a column in the current FITS HDU.
  No checking for null values will be performed.
*/
{
    char nulval = 0;
    int anynul;

    ffgcvl( fptr, colnum, firstrow, firstelem, nelem, nulval, array,
            &anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfl( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            char *array,      /* O - array of values                         */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of logical values from a column in the current FITS HDU.
*/
{
    char nulval = 0;

    ffgcll( fptr, colnum, firstrow, firstelem, nelem, 2, nulval, array,
            nularray, anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcll( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  firstelem, /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            char nulval,      /* I - value for null pixels if nultyp = 1     */
            char *array,      /* O - array of values                         */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of logical values from a column in the current FITS HDU.
*/
{
    double dtemp;
    int tcode, maxelem, hdutype, ii, nulcheck;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, readptr, tnull, rowlen, rownum, remain, next;
    double scale, zero;
    char tform[20];
    char message[FLEN_ERRMSG];
    char snull[20];   /*  the FITS null value  */
    unsigned char buffer[DBUFFSIZE], *buffptr;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    if (anynul)
       *anynul = 0;

    if (nultyp == 2)      
       memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 0, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    if (tcode != TLOGICAL)   
        return(*status = NOT_LOGICAL_COL);
 
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default, check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    /*---------------------------------------------------------------------*/
    /*  Now read the logical values from the FITS column.                  */
    /*---------------------------------------------------------------------*/

    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */
    ntodo = (long) remain;           /* max number of elements to read at one time */

    while (ntodo)
    {
      /*
         limit the number of pixels to read at one time to the number that
         remain in the current vector.    
      */
      ntodo = (long) minvalue(ntodo, maxelem);      
      ntodo = (long) minvalue(ntodo, (repeat - elemnum));

      readptr = startpos + (rowlen * rownum) + (elemnum * incre);

      ffgi1b(fptr, readptr, ntodo, incre, buffer, status);

      /* convert from T or F to 1 or 0 */
      buffptr = buffer;
      for (ii = 0; ii < ntodo; ii++, next++, buffptr++)
      {
        if (*buffptr == 'T')
          array[next] = 1;
        else if (*buffptr =='F') 
          array[next] = 0;
        else if (*buffptr == 0)
        {
          array[next] = nulval;  /* set null values to input nulval */
          if (anynul)
              *anynul = 1;

          if (nulcheck == 2)
          {
            nularray[next] = 1;  /* set null flags */
          }
        }
        else  /* some other illegal character; return the char value */
        {
          if (*buffptr == 1) {
            /* this is an unfortunate case where the illegal value is the same
               as what we set True values to, so set the value to the character '1'
               instead, which has ASCII value 49.  */
            array[next] = 49;
          } else {
            array[next] = (char) *buffptr;
          }
        }
      }

      if (*status > 0)  /* test for error during previous read operation */
      {
	dtemp = (double) next;
        sprintf(message,
          "Error reading elements %.0f thruough %.0f of logical array (ffgcl).",
           dtemp+1., dtemp + ntodo);
        ffpmsg(message);
        return(*status);
      }

      /*--------------------------------------------*/
      /*  increment the counters for the next loop  */
      /*--------------------------------------------*/
      remain -= ntodo;
      if (remain)
      {
        elemnum += ntodo;

        if (elemnum == repeat)  /* completed a row; start on later row */
          {
            elemnum = 0;
            rownum++;
          }
      }
      ntodo = (long) remain;  /* this is the maximum number to do in next loop */

    }  /*  End of main while Loop  */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcx(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int   colnum,    /* I - number of column to write (1 = 1st col) */
            LONGLONG  frow,      /* I - first row to write (1 = 1st row)        */
            LONGLONG  fbit,      /* I - first bit to write (1 = 1st)            */
            LONGLONG  nbit,      /* I - number of bits to write                 */
            char *larray,    /* O - array of logicals corresponding to bits */
            int  *status)    /* IO - error status                           */
/*
  read an array of logical values from a specified bit or byte
  column of the binary table.    larray is set = TRUE, if the corresponding
  bit = 1, otherwise it is set to FALSE.
  The binary table column being read from must have datatype 'B' or 'X'. 
*/
{
    LONGLONG bstart;
    long offset, ndone, ii, repeat, bitloc, fbyte;
    LONGLONG  rstart, estart;
    int tcode, descrp;
    unsigned char cbuff;
    static unsigned char onbit[8] = {128,  64,  32,  16,   8,   4,   2,   1};
    tcolumn *colptr;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /*  check input parameters */
    if (nbit < 1)
        return(*status);
    else if (frow < 1)
        return(*status = BAD_ROW_NUM);
    else if (fbit < 1)
        return(*status = BAD_ELEM_NUM);

    /* position to the correct HDU */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* rescan header if data structure is undefined */
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               
            return(*status);

    fbyte = (long) ((fbit + 7) / 8);
    bitloc = (long) (fbit - 1 - ((fbit - 1) / 8 * 8));
    ndone = 0;
    rstart = frow - 1;
    estart = fbyte - 1;

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode = colptr->tdatatype;

    if (abs(tcode) > TBYTE)
        return(*status = NOT_LOGICAL_COL); /* not correct datatype column */

    if (tcode > 0)
    {
        descrp = FALSE;  /* not a variable length descriptor column */
        /* N.B: REPEAT is the number of bytes, not number of bits */
        repeat = (long) colptr->trepeat;

        if (tcode == TBIT)
            repeat = (repeat + 7) / 8;  /* convert from bits to bytes */

        if (fbyte > repeat)
            return(*status = BAD_ELEM_NUM);

        /* calc the i/o pointer location to start of sequence of pixels */
        bstart = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * rstart) +
               colptr->tbcol + estart;
    }
    else
    {
        descrp = TRUE;  /* a variable length descriptor column */
        /* only bit arrays (tform = 'X') are supported for variable */
        /* length arrays.  REPEAT is the number of BITS in the array. */

        ffgdes(fptr, colnum, frow, &repeat, &offset, status);

        if (tcode == -TBIT)
            repeat = (repeat + 7) / 8;

        if ((fbit + nbit + 6) / 8 > repeat)
            return(*status = BAD_ELEM_NUM);

        /* calc the i/o pointer location to start of sequence of pixels */
        bstart = (fptr->Fptr)->datastart + offset + (fptr->Fptr)->heapstart + estart;
    }

    /* move the i/o pointer to the start of the pixel sequence */
    if (ffmbyt(fptr, bstart, REPORT_EOF, status) > 0)
        return(*status);

    /* read the next byte */
    while (1)
    {
      if (ffgbyt(fptr, 1, &cbuff, status) > 0)
        return(*status);

      for (ii = bitloc; (ii < 8) && (ndone < nbit); ii++, ndone++)
      {
        if(cbuff & onbit[ii])       /* test if bit is set */
          larray[ndone] = TRUE;
        else
          larray[ndone] = FALSE;
      }

      if (ndone == nbit)   /* finished all the bits */
        return(*status);

      /* not done, so get the next byte */
      if (!descrp)
      {
        estart++;
        if (estart == repeat) 
        {
          /* move the i/o pointer to the next row of pixels */
          estart = 0;
          rstart = rstart + 1;
          bstart = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * rstart) +
               colptr->tbcol;

          ffmbyt(fptr, bstart, REPORT_EOF, status);
        }
      }
      bitloc = 0;
    }
}
/*--------------------------------------------------------------------------*/
int ffgcxui(fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  nrows,      /* I - no. of rows to read                     */
            long  input_first_bit, /* I - first bit to read (1 = 1st)        */
            int   input_nbits,     /* I - number of bits to read (<= 32)     */
            unsigned short *array, /* O - array of integer values            */
            int  *status)     /* IO - error status                           */
/*
  Read a consecutive string of bits from an 'X' or 'B' column and
  interprete them as an unsigned integer.  The number of bits must be
  less than or equal to 16 or the total number of bits in the column, 
  which ever is less.
*/
{
    int ii, firstbit, nbits, bytenum, startbit, numbits, endbit;
    int firstbyte, lastbyte, nbytes, rshift, lshift;
    unsigned short colbyte[5];
    tcolumn *colptr;
    char message[81];

    if (*status > 0 || nrows == 0)
        return(*status);

    /*  check input parameters */
    if (firstrow < 1)
    {
          sprintf(message, "Starting row number is less than 1: %ld (ffgcxui)",
                (long) firstrow);
          ffpmsg(message);
          return(*status = BAD_ROW_NUM);
    }
    else if (input_first_bit < 1)
    {
          sprintf(message, "Starting bit number is less than 1: %ld (ffgcxui)",
                input_first_bit);
          ffpmsg(message);
          return(*status = BAD_ELEM_NUM);
    }
    else if (input_nbits > 16)
    {
          sprintf(message, "Number of bits to read is > 16: %d (ffgcxui)",
                input_nbits);
          ffpmsg(message);
          return(*status = BAD_ELEM_NUM);
    }

    /* position to the correct HDU */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* rescan header if data structure is undefined */
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               
            return(*status);

    if ((fptr->Fptr)->hdutype != BINARY_TBL)
    {
        ffpmsg("This is not a binary table extension (ffgcxui)");
        return(*status = NOT_BTABLE);
    }

    if (colnum > (fptr->Fptr)->tfield)
    {
      sprintf(message, "Specified column number is out of range: %d (ffgcxui)",
                colnum);
        ffpmsg(message);
        sprintf(message, "  There are %d columns in this table.",
                (fptr->Fptr)->tfield );
        ffpmsg(message);

        return(*status = BAD_COL_NUM);
    }       

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    if (abs(colptr->tdatatype) > TBYTE)
    {
        ffpmsg("Can only read bits from X or B type columns. (ffgcxui)");
        return(*status = NOT_LOGICAL_COL); /* not correct datatype column */
    }

    firstbyte = (input_first_bit - 1              ) / 8 + 1;
    lastbyte  = (input_first_bit + input_nbits - 2) / 8 + 1;
    nbytes = lastbyte - firstbyte + 1;

    if (colptr->tdatatype == TBIT && 
        input_first_bit + input_nbits - 1 > (long) colptr->trepeat)
    {
        ffpmsg("Too many bits. Tried to read past width of column (ffgcxui)");
        return(*status = BAD_ELEM_NUM);
    }
    else if (colptr->tdatatype == TBYTE && lastbyte > (long) colptr->trepeat)
    {
        ffpmsg("Too many bits. Tried to read past width of column (ffgcxui)");
        return(*status = BAD_ELEM_NUM);
    }

    for (ii = 0; ii < nrows; ii++)
    {
        /* read the relevant bytes from the row */
        if (ffgcvui(fptr, colnum, firstrow+ii, firstbyte, nbytes, 0, 
               colbyte, NULL, status) > 0)
        {
             ffpmsg("Error reading bytes from column (ffgcxui)");
             return(*status);
        }

        firstbit = (input_first_bit - 1) % 8; /* modulus operator */
        nbits = input_nbits;

        array[ii] = 0;

        /* select and shift the bits from each byte into the output word */
        while(nbits)
        {
            bytenum = firstbit / 8;

            startbit = firstbit % 8;  
            numbits = minvalue(nbits, 8 - startbit);
            endbit = startbit + numbits - 1;

            rshift = 7 - endbit;
            lshift = nbits - numbits;

            array[ii] = ((colbyte[bytenum] >> rshift) << lshift) | array[ii];

            nbits -= numbits;
            firstbit += numbits;
        }
    }

    return(*status);
}

/*--------------------------------------------------------------------------*/
int ffgcxuk(fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  nrows,      /* I - no. of rows to read                     */
            long  input_first_bit, /* I - first bit to read (1 = 1st)        */
            int   input_nbits,     /* I - number of bits to read (<= 32)     */
            unsigned int *array,   /* O - array of integer values            */
            int  *status)     /* IO - error status                           */
/*
  Read a consecutive string of bits from an 'X' or 'B' column and
  interprete them as an unsigned integer.  The number of bits must be
  less than or equal to 32 or the total number of bits in the column, 
  which ever is less.
*/
{
    int ii, firstbit, nbits, bytenum, startbit, numbits, endbit;
    int firstbyte, lastbyte, nbytes, rshift, lshift;
    unsigned int colbyte[5];
    tcolumn *colptr;
    char message[81];

    if (*status > 0 || nrows == 0)
        return(*status);

    /*  check input parameters */
    if (firstrow < 1)
    {
          sprintf(message, "Starting row number is less than 1: %ld (ffgcxuk)",
                (long) firstrow);
          ffpmsg(message);
          return(*status = BAD_ROW_NUM);
    }
    else if (input_first_bit < 1)
    {
          sprintf(message, "Starting bit number is less than 1: %ld (ffgcxuk)",
                input_first_bit);
          ffpmsg(message);
          return(*status = BAD_ELEM_NUM);
    }
    else if (input_nbits > 32)
    {
          sprintf(message, "Number of bits to read is > 32: %d (ffgcxuk)",
                input_nbits);
          ffpmsg(message);
          return(*status = BAD_ELEM_NUM);
    }

    /* position to the correct HDU */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* rescan header if data structure is undefined */
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               
            return(*status);

    if ((fptr->Fptr)->hdutype != BINARY_TBL)
    {
        ffpmsg("This is not a binary table extension (ffgcxuk)");
        return(*status = NOT_BTABLE);
    }

    if (colnum > (fptr->Fptr)->tfield)
    {
      sprintf(message, "Specified column number is out of range: %d (ffgcxuk)",
                colnum);
        ffpmsg(message);
        sprintf(message, "  There are %d columns in this table.",
                (fptr->Fptr)->tfield );
        ffpmsg(message);

        return(*status = BAD_COL_NUM);
    }       

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    if (abs(colptr->tdatatype) > TBYTE)
    {
        ffpmsg("Can only read bits from X or B type columns. (ffgcxuk)");
        return(*status = NOT_LOGICAL_COL); /* not correct datatype column */
    }

    firstbyte = (input_first_bit - 1              ) / 8 + 1;
    lastbyte  = (input_first_bit + input_nbits - 2) / 8 + 1;
    nbytes = lastbyte - firstbyte + 1;

    if (colptr->tdatatype == TBIT && 
        input_first_bit + input_nbits - 1 > (long) colptr->trepeat)
    {
        ffpmsg("Too many bits. Tried to read past width of column (ffgcxuk)");
        return(*status = BAD_ELEM_NUM);
    }
    else if (colptr->tdatatype == TBYTE && lastbyte > (long) colptr->trepeat)
    {
        ffpmsg("Too many bits. Tried to read past width of column (ffgcxuk)");
        return(*status = BAD_ELEM_NUM);
    }

    for (ii = 0; ii < nrows; ii++)
    {
        /* read the relevant bytes from the row */
        if (ffgcvuk(fptr, colnum, firstrow+ii, firstbyte, nbytes, 0, 
               colbyte, NULL, status) > 0)
        {
             ffpmsg("Error reading bytes from column (ffgcxuk)");
             return(*status);
        }

        firstbit = (input_first_bit - 1) % 8; /* modulus operator */
        nbits = input_nbits;

        array[ii] = 0;

        /* select and shift the bits from each byte into the output word */
        while(nbits)
        {
            bytenum = firstbit / 8;

            startbit = firstbit % 8;  
            numbits = minvalue(nbits, 8 - startbit);
            endbit = startbit + numbits - 1;

            rshift = 7 - endbit;
            lshift = nbits - numbits;

            array[ii] = ((colbyte[bytenum] >> rshift) << lshift) | array[ii];

            nbits -= numbits;
            firstbit += numbits;
        }
    }

    return(*status);
}
healpy-1.10.3/cfitsio/getcols.c0000664000175000017500000007055213010375005016575 0ustar  zoncazonca00000000000000/*  This file, getcols.c, contains routines that read data elements from   */
/*  a FITS image or table, with a character string datatype.               */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
/* stddef.h is apparently needed to define size_t */
#include 
#include 
#include "fitsio2.h"
/*--------------------------------------------------------------------------*/
int ffgcvs( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of strings to read               */
            char *nulval,     /* I - string for null pixels                  */
            char **array,     /* O - array of values that are read           */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of string values from a column in the current FITS HDU.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = null in which case no checks for undefined pixels will be made.
*/
{
    char cdummy[2];

    ffgcls(fptr, colnum, firstrow, firstelem, nelem, 1, nulval,
           array, cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfs( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col) */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)        */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st) */
            LONGLONG  nelem,      /* I - number of strings to read              */
            char **array,     /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of string values from a column in the current FITS HDU.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    char dummy[2];

    ffgcls(fptr, colnum, firstrow, firstelem, nelem, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcls( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col) */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)        */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st) */
            LONGLONG  nelem,      /* I - number of strings to read              */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            char  *nulval,    /* I - value for null pixels if nultyp = 1     */
            char **array,     /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of string values from a column in the current FITS HDU.
  Returns a formated string value, regardless of the datatype of the column
*/
{
    int tcode, hdutype, tstatus, scaled, intcol, dwidth, nulwidth, ll, dlen;
    long ii, jj;
    tcolumn *colptr;
    char message[FLEN_ERRMSG], *carray, keyname[FLEN_KEYWORD];
    char cform[20], dispfmt[20], tmpstr[400], *flgarray, tmpnull[80];
    unsigned char byteval;
    float *earray;
    double *darray, tscale = 1.0;
    LONGLONG *llarray;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* rescan header if data structure is undefined */
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               
            return(*status);

    if (colnum < 1 || colnum > (fptr->Fptr)->tfield)
    {
        sprintf(message, "Specified column number is out of range: %d",
                colnum);
        ffpmsg(message);
        return(*status = BAD_COL_NUM);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */
    tcode = abs(colptr->tdatatype);

    if (tcode == TSTRING)
    {
      /* simply call the string column reading routine */
      ffgcls2(fptr, colnum, firstrow, firstelem, nelem, nultyp, nulval,
           array, nularray, anynul, status);
    }
    else if (tcode == TLOGICAL)
    {
      /* allocate memory for the array of logical values */
      carray = (char *) malloc((size_t) nelem);

      /*  call the logical column reading routine */
      ffgcll(fptr, colnum, firstrow, firstelem, nelem, nultyp, *nulval,
           carray, nularray, anynul, status); 

      if (*status <= 0)
      {
         /* convert logical values to "T", "F", or "N" (Null) */
         for (ii = 0; ii < nelem; ii++)
         {
           if (carray[ii] == 1)
              strcpy(array[ii], "T");
           else if (carray[ii] == 0)
              strcpy(array[ii], "F");
           else  /* undefined values = 2 */
              strcpy(array[ii],"N");
         }
      }

      free(carray);  /* free the memory */
    }
    else if (tcode == TCOMPLEX)
    {
      /* allocate memory for the array of double values */
      earray = (float *) calloc((size_t) (nelem * 2), sizeof(float) );
      
      ffgcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
        1, 1, FLOATNULLVALUE, earray, nularray, anynul, status);

      if (*status <= 0)
      {

         /* determine the format for the output strings */

         ffgcdw(fptr, colnum, &dwidth, status);
         dwidth = (dwidth - 3) / 2;
 
         /* use the TDISPn keyword if it exists */
         ffkeyn("TDISP", colnum, keyname, status);
         tstatus = 0;
         cform[0] = '\0';

         if (ffgkys(fptr, keyname, dispfmt, NULL, &tstatus) == 0)
         {
             /* convert the Fortran style format to a C style format */
             ffcdsp(dispfmt, cform);
         }

         if (!cform[0])
             strcpy(cform, "%14.6E");

         /* write the formated string for each value:  "(real,imag)" */
         jj = 0;
         for (ii = 0; ii < nelem; ii++)
         {
           strcpy(array[ii], "(");

           /* test for null value */
           if (earray[jj] == FLOATNULLVALUE)
           {
             strcpy(tmpstr, "NULL");
             if (nultyp == 2)
                nularray[ii] = 1;
           }
           else
             sprintf(tmpstr, cform, earray[jj]);

           strncat(array[ii], tmpstr, dwidth);
           strcat(array[ii], ",");
           jj++;

           /* test for null value */
           if (earray[jj] == FLOATNULLVALUE)
           {
             strcpy(tmpstr, "NULL");
             if (nultyp == 2)
                nularray[ii] = 1;
           }
           else
             sprintf(tmpstr, cform, earray[jj]);

           strncat(array[ii], tmpstr, dwidth);
           strcat(array[ii], ")");
           jj++;
         }
      }

      free(earray);  /* free the memory */
    }
    else if (tcode == TDBLCOMPLEX)
    {
      /* allocate memory for the array of double values */
      darray = (double *) calloc((size_t) (nelem * 2), sizeof(double) );
      
      ffgcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
        1, 1, DOUBLENULLVALUE, darray, nularray, anynul, status);

      if (*status <= 0)
      {
         /* determine the format for the output strings */

         ffgcdw(fptr, colnum, &dwidth, status);
         dwidth = (dwidth - 3) / 2;

         /* use the TDISPn keyword if it exists */
         ffkeyn("TDISP", colnum, keyname, status);
         tstatus = 0;
         cform[0] = '\0';
 
         if (ffgkys(fptr, keyname, dispfmt, NULL, &tstatus) == 0)
         {
             /* convert the Fortran style format to a C style format */
             ffcdsp(dispfmt, cform);
         }

         if (!cform[0])
            strcpy(cform, "%23.15E");

         /* write the formated string for each value:  "(real,imag)" */
         jj = 0;
         for (ii = 0; ii < nelem; ii++)
         {
           strcpy(array[ii], "(");

           /* test for null value */
           if (darray[jj] == DOUBLENULLVALUE)
           {
             strcpy(tmpstr, "NULL");
             if (nultyp == 2)
                nularray[ii] = 1;
           }
           else
             sprintf(tmpstr, cform, darray[jj]);

           strncat(array[ii], tmpstr, dwidth);
           strcat(array[ii], ",");
           jj++;

           /* test for null value */
           if (darray[jj] == DOUBLENULLVALUE)
           {
             strcpy(tmpstr, "NULL");
             if (nultyp == 2)
                nularray[ii] = 1;
           }
           else
             sprintf(tmpstr, cform, darray[jj]);

           strncat(array[ii], tmpstr, dwidth);
           strcat(array[ii], ")");
           jj++;
         }
      }

      free(darray);  /* free the memory */
    }
    else if (tcode == TLONGLONG)
    {
      /* allocate memory for the array of LONGLONG values */
      llarray = (LONGLONG *) calloc((size_t) nelem, sizeof(LONGLONG) );
      flgarray = (char *) calloc((size_t) nelem, sizeof(char) );
      dwidth = 20;  /* max width of displayed long long integer value */

      if (ffgcfjj(fptr, colnum, firstrow, firstelem, nelem,
            llarray, flgarray, anynul, status) > 0)
      {
         free(flgarray);
         free(llarray);
         return(*status);
      }

      /* write the formated string for each value */
      if (nulval) {
          strcpy(tmpnull, nulval);
          nulwidth = strlen(nulval);
      } else {
          strcpy(tmpnull, " ");
          nulwidth = 1;
      }

      for (ii = 0; ii < nelem; ii++)
      {
           if ( flgarray[ii] )
           {
              *array[ii] = '\0';
              if (dwidth < nulwidth)
                  strncat(array[ii], tmpnull, dwidth);
              else
                  sprintf(array[ii],"%*s",dwidth,tmpnull);
		  
              if (nultyp == 2)
	          nularray[ii] = 1;
           }
           else
           {	   

#if defined(_MSC_VER)
    /* Microsoft Visual C++ 6.0 uses '%I64d' syntax  for 8-byte integers */
        sprintf(tmpstr, "%20I64d", llarray[ii]);
#elif (USE_LL_SUFFIX == 1)
        sprintf(tmpstr, "%20lld", llarray[ii]);
#else
        sprintf(tmpstr, "%20ld", llarray[ii]);
#endif
              *array[ii] = '\0';
              strncat(array[ii], tmpstr, 20);
           }
      }

      free(flgarray);
      free(llarray);  /* free the memory */

    }
    else
    {
      /* allocate memory for the array of double values */
      darray = (double *) calloc((size_t) nelem, sizeof(double) );
      
      /* read all other numeric type columns as doubles */
      if (ffgcld(fptr, colnum, firstrow, firstelem, nelem, 1, nultyp, 
           DOUBLENULLVALUE, darray, nularray, anynul, status) > 0)
      {
         free(darray);
         return(*status);
      }

      /* determine the format for the output strings */

      ffgcdw(fptr, colnum, &dwidth, status);

      /* check if  column is scaled */
      ffkeyn("TSCAL", colnum, keyname, status);
      tstatus = 0;
      scaled = 0;
      if (ffgkyd(fptr, keyname, &tscale, NULL, &tstatus) == 0)
      {
            if (tscale != 1.0)
                scaled = 1;    /* yes, this is a scaled column */
      }

      intcol = 0;
      if (tcode <= TLONG && !scaled)
             intcol = 1;   /* this is an unscaled integer column */

      /* use the TDISPn keyword if it exists */
      ffkeyn("TDISP", colnum, keyname, status);
      tstatus = 0;
      cform[0] = '\0';

      if (ffgkys(fptr, keyname, dispfmt, NULL, &tstatus) == 0)
      {
           /* convert the Fortran style TDISPn to a C style format */
           ffcdsp(dispfmt, cform);
      }

      if (!cform[0])
      {
            /* no TDISPn keyword; use TFORMn instead */

            ffkeyn("TFORM", colnum, keyname, status);
            ffgkys(fptr, keyname, dispfmt, NULL, status);

            if (scaled && tcode <= TSHORT)
            {
                  /* scaled short integer column == float */
                  strcpy(cform, "%#14.6G");
            }
            else if (scaled && tcode == TLONG)
            {
                  /* scaled long integer column == double */
                  strcpy(cform, "%#23.15G");
            }
            else
            {
               ffghdt(fptr, &hdutype, status);
               if (hdutype == ASCII_TBL)
               {
                  /* convert the Fortran style TFORMn to a C style format */
                  ffcdsp(dispfmt, cform);
               }
               else
               {
                 /* this is a binary table, need to convert the format */
                  if (tcode == TBIT) {            /* 'X' */
                     strcpy(cform, "%4d");
                  } else if (tcode == TBYTE) {    /* 'B' */
                     strcpy(cform, "%4d");
                  } else if (tcode == TSHORT) {   /* 'I' */
                     strcpy(cform, "%6d");
                  } else if (tcode == TLONG) {    /* 'J' */
                     strcpy(cform, "%11.0f");
                     intcol = 0;  /* needed to support unsigned int */
                  } else if (tcode == TFLOAT) {   /* 'E' */
                     strcpy(cform, "%#14.6G");
                  } else if (tcode == TDOUBLE) {  /* 'D' */
                     strcpy(cform, "%#23.15G");
                  }
               }
            }
      } 

      if (nulval) {
          strcpy(tmpnull, nulval);
          nulwidth = strlen(nulval);
      } else {
          strcpy(tmpnull, " ");
          nulwidth = 1;
      }

      /* write the formated string for each value */
      for (ii = 0; ii < nelem; ii++)
      {
           if (tcode == TBIT)
           {
               byteval = (char) darray[ii];

               for (ll=0; ll < 8; ll++)
               {
                   if ( ((unsigned char) (byteval << ll)) >> 7 )
                       *(array[ii] + ll) = '1';
                   else
                       *(array[ii] + ll) = '0';
               }
               *(array[ii] + 8) = '\0';
           }
           /* test for null value */
           else if ( (nultyp == 1 && darray[ii] == DOUBLENULLVALUE) ||
                (nultyp == 2 && nularray[ii]) )
           {
              *array[ii] = '\0';
              if (dwidth < nulwidth)
                  strncat(array[ii], tmpnull, dwidth);
              else
                  sprintf(array[ii],"%*s",dwidth,tmpnull);
           }
           else
           {	   
              if (intcol)
                sprintf(tmpstr, cform, (int) darray[ii]);
              else
                sprintf(tmpstr, cform, darray[ii]);

              /* fill field with '*' if number is too wide */
              dlen = strlen(tmpstr);
	      if (dlen > dwidth) {
	         memset(tmpstr, '*', dwidth);
              }

              *array[ii] = '\0';
              strncat(array[ii], tmpstr, dwidth);
           }
      }

      free(darray);  /* free the memory */
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcdw( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column (1 = 1st col)      */
            int  *width,      /* O - display width                       */
            int  *status)     /* IO - error status                           */
/*
  Get Column Display Width.
*/
{
    tcolumn *colptr;
    char *cptr;
    char message[FLEN_ERRMSG], keyname[FLEN_KEYWORD], dispfmt[20];
    int tcode, hdutype, tstatus, scaled;
    double tscale;

    if (*status > 0)  /* inherit input status value if > 0 */
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if (colnum < 1 || colnum > (fptr->Fptr)->tfield)
    {
        sprintf(message, "Specified column number is out of range: %d",
                colnum);
        ffpmsg(message);
        return(*status = BAD_COL_NUM);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */
    tcode = abs(colptr->tdatatype);

    /* use the TDISPn keyword if it exists */
    ffkeyn("TDISP", colnum, keyname, status);

    *width = 0;
    tstatus = 0;
    if (ffgkys(fptr, keyname, dispfmt, NULL, &tstatus) == 0)
    {
          /* parse TDISPn get the display width */
          cptr = dispfmt;
          while(*cptr == ' ') /* skip leading blanks */
              cptr++;

          if (*cptr == 'A' || *cptr == 'a' ||
              *cptr == 'I' || *cptr == 'i' ||
              *cptr == 'O' || *cptr == 'o' ||
              *cptr == 'Z' || *cptr == 'z' ||
              *cptr == 'F' || *cptr == 'f' ||
              *cptr == 'E' || *cptr == 'e' ||
              *cptr == 'D' || *cptr == 'd' ||
              *cptr == 'G' || *cptr == 'g')
          {

            while(!isdigit((int) *cptr) && *cptr != '\0') /* find 1st digit */
              cptr++;

            *width = atoi(cptr);
            if (tcode >= TCOMPLEX)
              *width = (2 * (*width)) + 3;
          }
    }

    if (*width == 0)
    {
        /* no valid TDISPn keyword; use TFORMn instead */

        ffkeyn("TFORM", colnum, keyname, status);
        ffgkys(fptr, keyname, dispfmt, NULL, status);

        /* check if  column is scaled */
        ffkeyn("TSCAL", colnum, keyname, status);
        tstatus = 0;
        scaled = 0;

        if (ffgkyd(fptr, keyname, &tscale, NULL, &tstatus) == 0)
        {
            if (tscale != 1.0)
                scaled = 1;    /* yes, this is a scaled column */
        }

        if (scaled && tcode <= TSHORT)
        {
            /* scaled short integer col == float; default format is 14.6G */
            *width = 14;
        }
        else if (scaled && tcode == TLONG)
        {
            /* scaled long integer col == double; default format is 23.15G */
            *width = 23;
        }
        else
        {
           ffghdt(fptr, &hdutype, status);  /* get type of table */
           if (hdutype == ASCII_TBL)
           {
              /* parse TFORMn get the display width */
              cptr = dispfmt;
              while(!isdigit((int) *cptr) && *cptr != '\0') /* find 1st digit */
                 cptr++;

              *width = atoi(cptr);
           }
           else
           {
                 /* this is a binary table */
                  if (tcode == TBIT)           /* 'X' */
                     *width = 8;
                  else if (tcode == TBYTE)     /* 'B' */
                     *width = 4;
                  else if (tcode == TSHORT)    /* 'I' */
                     *width = 6;
                  else if (tcode == TLONG)     /* 'J' */
                     *width = 11;
                  else if (tcode == TLONGLONG) /* 'K' */
                     *width = 20;
                  else if (tcode == TFLOAT)    /* 'E' */
                     *width = 14;
                  else if (tcode == TDOUBLE)   /* 'D' */
                     *width = 23;
                  else if (tcode == TCOMPLEX)  /* 'C' */
                     *width = 31;
                  else if (tcode == TDBLCOMPLEX)  /* 'M' */
                     *width = 49;
                  else if (tcode == TLOGICAL)  /* 'L' */
                     *width = 1;
                  else if (tcode == TSTRING)   /* 'A' */
                  {
                     cptr = dispfmt;
                     while(!isdigit((int) *cptr) && *cptr != '\0') 
                         cptr++;

                     *width = atoi(cptr);

                     if (*width < 1)
                         *width = 1;  /* default is at least 1 column */
                  }
            }
        }
    } 
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcls2 ( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col) */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)        */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st) */
            LONGLONG  nelem,      /* I - number of strings to read              */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            char  *nulval,    /* I - value for null pixels if nultyp = 1     */
            char **array,     /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of string values from a column in the current FITS HDU.
*/
{
    double dtemp;
    long nullen; 
    int tcode, maxelem, hdutype, nulcheck;
    long twidth, incre;
    long ii, jj, ntodo;
    LONGLONG repeat, startpos, elemnum, readptr, tnull, rowlen, rownum, remain, next;
    double scale, zero;
    char tform[20];
    char message[FLEN_ERRMSG];
    char snull[20];   /*  the FITS null value  */
    tcolumn *colptr;

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    char *buffer, *arrayptr;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (colnum < 1 || colnum > (fptr->Fptr)->tfield)
    {
        sprintf(message, "Specified column number is out of range: %d",
                colnum);
        ffpmsg(message);
        return(*status = BAD_COL_NUM);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */
    tcode = colptr->tdatatype;

    if (tcode == -TSTRING) /* variable length column in a binary table? */
    {
      /* only read a single string; ignore value of firstelem */

      if (ffgcprll( fptr, colnum, firstrow, 1, 1, 0, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

      remain = 1;
      twidth = (long) repeat;  
    }
    else if (tcode == TSTRING)
    {
      if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 0, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

      /* if string length is greater than a FITS block (2880 char) then must */
      /* only read 1 string at a time, to force reading by ffgbyt instead of */
      /* ffgbytoff (ffgbytoff can't handle this case) */
      if (twidth > IOBUFLEN) {
        maxelem = 1;
        incre = twidth;
        repeat = 1;
      }   

      remain = nelem;
    }
    else
        return(*status = NOT_ASCII_COL);

    nullen = strlen(snull);   /* length of the undefined pixel string */
    if (nullen == 0)
        nullen = 1;
 
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (nultyp == 1 && nulval && nulval[0] == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (snull[0] == ASCII_NULL_UNDEFINED)
       nulcheck = 0;   /* null value string in ASCII table not defined */

    else if (nullen > twidth)
       nulcheck = 0;   /* null value string is longer than width of column  */
                       /* thus impossible for any column elements to = null */

    /*---------------------------------------------------------------------*/
    /*  Now read the strings one at a time from the FITS column.           */
    /*---------------------------------------------------------------------*/
    next = 0;                 /* next element in array to be read  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
      /* limit the number of pixels to process at one time to the number that
         will fit in the buffer space or to the number of pixels that remain
         in the current vector, which ever is smaller.
      */
      ntodo = (long) minvalue(remain, maxelem);      
      ntodo = (long) minvalue(ntodo, (repeat - elemnum));

      readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);
      ffmbyt(fptr, readptr, REPORT_EOF, status);  /* move to read position */

      /* read the array of strings from the FITS file into the buffer */

      if (incre == twidth)
         ffgbyt(fptr, ntodo * twidth, cbuff, status);
      else
         ffgbytoff(fptr, twidth, ntodo, incre - twidth, cbuff, status);

      /* copy from the buffer into the user's array of strings */
      /* work backwards from last char of last string to 1st char of 1st */

      buffer = ((char *) cbuff) + (ntodo * twidth) - 1;

      for (ii = (long) (next + ntodo - 1); ii >= next; ii--)
      {
         arrayptr = array[ii] + twidth - 1;

         for (jj = twidth - 1; jj > 0; jj--)  /* ignore trailing blanks */
         {
            if (*buffer == ' ')
            {
              buffer--;
              arrayptr--;
            }
            else
              break;
         }
         *(arrayptr + 1) = 0;  /* write the string terminator */
         
         for (; jj >= 0; jj--)    /* copy the string itself */
         {
           *arrayptr = *buffer;
           buffer--;
           arrayptr--;
         }

         /* check if null value is defined, and if the   */
         /* column string is identical to the null string */
         if (nulcheck && !strncmp(snull, array[ii], nullen) )
         {
           *anynul = 1;   /* this is a null value */
           if (nultyp == 1) {
	   
	     if (nulval)
                strcpy(array[ii], nulval);
	     else
	        strcpy(array[ii], " ");
	     
           } else
             nularray[ii] = 1;
         }
      }
    
      if (*status > 0)  /* test for error during previous read operation */
      {
         dtemp = (double) next;
         sprintf(message,
          "Error reading elements %.0f thru %.0f of data array (ffpcls).",
             dtemp+1., dtemp+ntodo);

         ffpmsg(message);
         return(*status);
      }

      /*--------------------------------------------*/
      /*  increment the counters for the next loop  */
      /*--------------------------------------------*/
      next += ntodo;
      remain -= ntodo;
      if (remain)
      {
          elemnum += ntodo;
          if (elemnum == repeat)  /* completed a row; start on next row */
          {
              elemnum = 0;
              rownum++;
          }
      }
    }  /*  End of main while Loop  */

    return(*status);
}

healpy-1.10.3/cfitsio/getcolsb.c0000664000175000017500000022324513010375005016736 0ustar  zoncazonca00000000000000/*  This file, getcolsb.c, contains routines that read data elements from   */
/*  a FITS image or table, with signed char (signed byte) data type.        */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvsb(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            signed char nulval, /* I - value for undefined pixels            */
            signed char *array, /* O - array of values that are returned     */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    signed char nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TSBYTE, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclsb(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfsb(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            signed char *array, /* O - array of values that are returned     */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TSBYTE, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclsb(fptr, 2, row, firstelem, nelem, 1, 2, 0,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2dsb(fitsfile *fptr, /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           signed char nulval,   /* set undefined pixels equal to this     */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           signed char *array,   /* O - array to be filled and returned    */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3dsb(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3dsb(fitsfile *fptr, /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
           signed char nulval,   /* set undefined pixels equal to this     */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
           signed char *array,   /* O - array to be filled and returned    */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    LONGLONG  nfits, narray;
    char cdummy;
    int  nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1};
    LONGLONG lpixel[3];
    signed char nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TSBYTE, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgclsb(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgclsb(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvsb(fitsfile *fptr, /* I - FITS file pointer                        */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           signed char nulval, /* I - value to set undefined pixels         */
           signed char *array, /* O - array to be filled and returned       */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii, i0, i1, i2, i3, i4, i5, i6, i7, i8, row, rstr, rstp, rinc;
    long str[9], stp[9], incr[9], dir[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int  nullcheck = 1;
    signed char nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvsb is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TSBYTE, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
        dir[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        if (hdutype == IMAGE_HDU)
        {
           dir[ii] = -1;
        }
        else
        {
          sprintf(msg, "ffgsvsb: illegal range specified for axis %ld", ii + 1);
          ffpmsg(msg);
          return(*status = BAD_PIX_NUM);
        }
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
      dsize[ii] = dsize[ii] * dir[ii];
    }
    dsize[naxis] = dsize[naxis] * dir[naxis];

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0]*dir[0] - str[0]*dir[0]) / inc[0] + 1;
      ninc = incr[0] * dir[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]*dir[8]; i8 <= stp[8]*dir[8]; i8 += incr[8])
     {
      for (i7 = str[7]*dir[7]; i7 <= stp[7]*dir[7]; i7 += incr[7])
      {
       for (i6 = str[6]*dir[6]; i6 <= stp[6]*dir[6]; i6 += incr[6])
       {
        for (i5 = str[5]*dir[5]; i5 <= stp[5]*dir[5]; i5 += incr[5])
        {
         for (i4 = str[4]*dir[4]; i4 <= stp[4]*dir[4]; i4 += incr[4])
         {
          for (i3 = str[3]*dir[3]; i3 <= stp[3]*dir[3]; i3 += incr[3])
          {
           for (i2 = str[2]*dir[2]; i2 <= stp[2]*dir[2]; i2 += incr[2])
           {
            for (i1 = str[1]*dir[1]; i1 <= stp[1]*dir[1]; i1 += incr[1])
            {

              felem=str[0] + (i1 - dir[1]) * dsize[1] + (i2 - dir[2]) * dsize[2] + 
                             (i3 - dir[3]) * dsize[3] + (i4 - dir[4]) * dsize[4] +
                             (i5 - dir[5]) * dsize[5] + (i6 - dir[6]) * dsize[6] +
                             (i7 - dir[7]) * dsize[7] + (i8 - dir[8]) * dsize[8];

              if ( ffgclsb(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfsb(fitsfile *fptr, /* I - FITS file pointer                        */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
           signed char *array,   /* O - array to be filled and returned     */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    int hdutype, anyf;
    signed char nulval = 0;
    char msg[FLEN_ERRMSG];
    int  nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvsb is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TSBYTE, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvsb: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgclsb(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpsb( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
            signed char *array,   /* O - array of values that are returned   */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclsb(fptr, 1, row, firstelem, nelem, 1, 1, 0,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvsb(fitsfile *fptr,  /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           signed char nulval,   /* I - value for null pixels               */
           signed char *array,   /* O - array of values that are read       */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgclsb(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfsb(fitsfile *fptr,  /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
           signed char *array,   /* O - array of values that are read       */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    signed char dummy = 0;

    ffgclsb(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgclsb(fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
            signed char nulval,   /* I - value for null pixels if nultyp = 1 */
            signed char *array,   /* O - array of values that are read       */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int nulcheck, readcheck = 0;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    union u_tag {
       char charval;
       signed char scharval;
    } u;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)      
       memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (elemincre < 0)
        readcheck = -1;  /* don't do range checking in this case */

    ffgcprll( fptr, colnum, firstrow, firstelem, nelem, readcheck, &scale, &zero,
         tform, &twidth, &tcode, &maxelem, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status);

    /* special case: read column of T/F logicals */
    if (tcode == TLOGICAL && elemincre == 1)
    {
        u.scharval = nulval;
        ffgcll(fptr, colnum, firstrow, firstelem, nelem, nultyp,
               u.charval, (char *) array, nularray, anynul, status);

        return(*status);
    }

    if (strchr(tform,'A') != NULL) 
    {
        if (*status == BAD_ELEM_NUM)
        {
            /* ignore this error message */
            *status = 0;
            ffcmsg();   /* clear error stack */
        }

        /*  interpret a 'A' ASCII column as a 'B' byte column ('8A' == '8B') */
        /*  This is an undocumented 'feature' in CFITSIO */

        /*  we have to reset some of the values returned by ffgcpr */
        
        tcode = TBYTE;
        incre = 1;         /* each element is 1 byte wide */
        repeat = twidth;   /* total no. of chars in the col */
        twidth = 1;        /* width of each element */
        scale = 1.0;       /* no scaling */
        zero  = 0.0;
        tnull = NULL_UNDEFINED;  /* don't test for nulls */
        maxelem = DBUFFSIZE;
    }

    if (*status > 0)
        return(*status);
        
    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING && hdutype == ASCII_TBL) /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default, check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);
        if (elemincre >= 0)
        {
          ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));
        }
        else
        {
          ntodo = (long) minvalue(ntodo, (elemnum/(-elemincre) +1));
        }

        readptr = startpos + (rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) &array[next], status);
                fffi1s1((unsigned char *)&array[next], ntodo, scale, zero,
                        nulcheck, (unsigned char) tnull, nulval, &nularray[next], 
                        anynul, &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short *) buffer, status);
                fffi2s1((short  *) buffer, ntodo, scale, zero, nulcheck, 
                       (short) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) buffer,
                       status);
                fffi4s1((INT32BIT *) buffer, ntodo, scale, zero, nulcheck, 
                       (INT32BIT) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TLONGLONG):
                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8s1( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4s1((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8s1((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                /* interpret the string as an ASCII formated number */
                fffstrs1((char *) buffer, ntodo, scale, zero, twidth, power,
                      nulcheck, snull, nulval, &nularray[next], anynul,
                      &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read bytes from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgclsb).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgclsb).",
              dtemp+1., dtemp+ntodo);

         ffpmsg(message);
         return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
            else if (elemnum < 0)  /* completed a row; start on a previous row */
            {
                rowincre = (-elemnum - 1) / repeat + 1;
                rownum -= rowincre;
                elemnum = (rowincre * repeat) + elemnum;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1s1(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            signed char nullval,  /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            signed char *output,  /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == -128.)
        {
            /* Instead of subtracting 128, it is more efficient */
            /* to just flip the sign bit with the XOR operator */

            for (ii = 0; ii < ntodo; ii++)
                 output[ii] =  ( *(signed char *) &input[ii] ) ^ 0x80;
        }
        else if (scale == 1. && zero == 0.)      /* no scaling */
        { 
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] > 127)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) input[ii]; /* copy input */
            }
        }
        else             /* must scale the data */
        {                
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (dvalue > DSCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == -128.)
        {
            /* Instead of subtracting 128, it is more efficient */
            /* to just flip the sign bit with the XOR operator */

            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] =  ( *(signed char *) &input[ii] ) ^ 0x80;
            }
        }
        else if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (signed char) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (dvalue > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2s1(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            signed char nullval,  /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            signed char *output,  /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < -128)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (input[ii] > 127)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (dvalue > DSCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }

                else
                {
                    if (input[ii] < -128)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (input[ii] > 127)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (dvalue > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4s1(INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            signed char nullval,  /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            signed char *output,  /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < -128)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (input[ii] > 127)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (dvalue > DSCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < -128)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (input[ii] > 127)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (dvalue > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8s1(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
            signed char nullval,  /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            signed char *output,  /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < -128)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (input[ii] > 127)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (dvalue > DSCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < -128)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (input[ii] > 127)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (dvalue > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4s1(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            signed char nullval,  /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            signed char *output,  /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DSCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (input[ii] > DSCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (dvalue > DSCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              /* use redundant boolean logic in following statement */
              /* to suppress irritating Borland compiler warning message */
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (input[ii] > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (zero > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (dvalue > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8s1(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            signed char nullval,  /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            signed char *output,  /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DSCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (input[ii] > DSCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DSCHAR_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = -128;
                }
                else if (dvalue > DSCHAR_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 127;
                }
                else
                    output[ii] = (signed char) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (input[ii] > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  {
                    if (zero < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (zero > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DSCHAR_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = -128;
                    }
                    else if (dvalue > DSCHAR_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 127;
                    }
                    else
                        output[ii] = (signed char) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstrs1(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
            signed char nullval,  /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            signed char *output,  /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int  nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')       /* check for decimal point */
        {
          decpt = 1;
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DSCHAR_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = -128;
        }
        else if (dvalue > DSCHAR_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = 127;
        }
        else
            output[ii] = (signed char) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcolui.c0000664000175000017500000021714713010375005016753 0ustar  zoncazonca00000000000000/*  This file, getcolui.c, contains routines that read data elements from   */
/*  a FITS image or table, with unsigned short datatype.                    */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvui( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
   unsigned short nulval,     /* I - value for undefined pixels              */
   unsigned short *array,     /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    unsigned short nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TUSHORT, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclui(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfui( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
   unsigned short *array,     /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TUSHORT, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclui(fptr, 2, row, firstelem, nelem, 1, 2, 0,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2dui(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
  unsigned short nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
  unsigned short *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3dui(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3dui(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
  unsigned short nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
  unsigned short *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1}, nfits, narray;
    LONGLONG lpixel[3];
    unsigned short nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TUSHORT, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgclui(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgclui(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvui(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
  unsigned short nulval,   /* I - value to set undefined pixels             */
  unsigned short *array,   /* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    unsigned short nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvui is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TUSHORT, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvui: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];
              if ( ffgclui(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfui(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
  unsigned short *array,   /* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    int hdutype, anyf;
    unsigned short nulval = 0;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvi is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TUSHORT, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvi: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgclui(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpui( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
   unsigned short *array,     /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgclui(fptr, 1, row, firstelem, nelem, 1, 1, 0,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvui(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
  unsigned short nulval,     /* I - value for null pixels                   */
  unsigned short *array,     /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgclui(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfui(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
  unsigned short *array,     /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    unsigned short dummy = 0;

    ffgclui(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgclui( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
   unsigned short nulval,     /* I - value for null pixels if nultyp = 1     */
   unsigned short *array,     /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int nulcheck;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if ( ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 0, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    if (tcode == TSHORT) /* Special Case:                        */
    {                             /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/2) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/2;
        }
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre,
                       (short *) &array[next], status);
                fffi2u2((short *) &array[next], ntodo, scale,
                       zero, nulcheck, (short) tnull, nulval, &nularray[next],
                       anynul, &array[next], status);
                break;
            case (TLONGLONG):

                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8u2( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                      status);
                fffi1u2((unsigned char *) buffer, ntodo, scale, zero, nulcheck, 
                    (unsigned char) tnull, nulval, &nularray[next], anynul, 
                    &array[next], status);
                break;
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) buffer,
                       status);
                fffi4u2((INT32BIT *) buffer, ntodo, scale, zero, nulcheck, 
                       (INT32BIT) tnull, nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4u2((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8u2((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstru2((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgclui).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgclui).",
              dtemp+1., dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1u2(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
   unsigned short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (unsigned short) input[ii]; /* copy input */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (unsigned short) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2u2(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
   unsigned short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 32768.) 
        {       
           /* Instead of adding 32768, it is more efficient */
           /* to just flip the sign bit with the XOR operator */

           for (ii = 0; ii < ntodo; ii++)
              output[ii] =  ( *(unsigned short *) &input[ii] ) ^ 0x8000;
        }
        else if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else
                    output[ii] = (unsigned short) input[ii]; /* copy input */
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 32768.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] =  ( *(unsigned short *) &input[ii] ) ^ 0x8000;
            }
        }
        else if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else
                    output[ii] = (unsigned short) input[ii]; /* copy input */
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4u2(INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
   unsigned short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > USHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > USHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8u2(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
   unsigned short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > USHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > USHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4u2(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
   unsigned short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DUSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > DUSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )   /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  { 
                    if (zero < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (zero > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                      output[ii] = (unsigned short) zero;
                  }
              }
              else
              {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) dvalue;
              }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8u2(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
   unsigned short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DUSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > DUSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUSHRT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUSHRT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = USHRT_MAX;
                }
                else
                    output[ii] = (unsigned short) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  { 
                    if (zero < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (zero > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                      output[ii] = (unsigned short) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUSHRT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUSHRT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = USHRT_MAX;
                    }
                    else
                        output[ii] = (unsigned short) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstru2(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
   unsigned short nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned short *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')       /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DUSHRT_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = 0;
        }
        else if (dvalue > DUSHRT_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = USHRT_MAX;
        }
        else
            output[ii] = (unsigned short) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcoluj.c0000664000175000017500000021665013010375005016752 0ustar  zoncazonca00000000000000/*  This file, getcoluj.c, contains routines that read data elements from  */
/*  a FITS image or table, with unsigned long data type.                   */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvuj(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
   unsigned long  nulval,     /* I - value for undefined pixels              */
   unsigned long  *array,     /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    unsigned long nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TULONG, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcluj(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfuj(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
   unsigned long  *array,     /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TULONG, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcluj(fptr, 2, row, firstelem, nelem, 1, 2, 0L,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2duj(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
  unsigned long  nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
  unsigned long  *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3duj(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3duj(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
  unsigned long  nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
  unsigned long  *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1}, nfits, narray;
    LONGLONG lpixel[3];
    unsigned long nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TULONG, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgcluj(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgcluj(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvuj(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
  unsigned long nulval,    /* I - value to set undefined pixels             */
  unsigned long *array,    /* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    unsigned long nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvuj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TULONG, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvuj: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgcluj(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfuj(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
  unsigned long *array,    /* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    unsigned long nulval = 0;
    int hdutype, anyf;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TULONG, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvj: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgcluj(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpuj(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
   unsigned long  *array,     /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcluj(fptr, 1, row, firstelem, nelem, 1, 1, 0L,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvuj(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
  unsigned long  nulval,     /* I - value for null pixels                   */
  unsigned long *array,      /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgcluj(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfuj(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
  unsigned long  *array,     /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    unsigned long dummy = 0;

    ffgcluj(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcluj(fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG  firstelem, /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
   unsigned long  nulval,     /* I - value for null pixels if nultyp = 1     */
   unsigned long  *array,     /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int nulcheck;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if ( ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 0, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    if (tcode == TLONG)  /* Special Case:                        */
    {                             /* no type convertion required, so read */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/4) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/4;
        }
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) &array[next],
                       status);
                fffi4u4((INT32BIT *) &array[next], ntodo, scale, zero,
                         nulcheck, (INT32BIT) tnull, nulval, &nularray[next],
                         anynul, &array[next], status);
                break;
            case (TLONGLONG):

                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8u4( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                       status);
                fffi1u4((unsigned char *) buffer, ntodo, scale, zero, nulcheck, 
                     (unsigned char) tnull, nulval, &nularray[next], anynul, 
                     &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short  *) buffer, status);
                fffi2u4((short  *) buffer, ntodo, scale, zero, nulcheck, 
                      (short) tnull, nulval, &nularray[next], anynul, 
                      &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4u4((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8u4((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstru4((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgcluj).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgcluj).",
              dtemp+1., dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1u4(unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
   unsigned long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (unsigned long) input[ii];  /* copy input */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DULONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (unsigned long) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2u4(short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
   unsigned long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else
                    output[ii] = (unsigned long) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DULONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else
                        output[ii] = (unsigned long) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4u4(INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
   unsigned long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;

  Process the array of data in reverse order, to handle the case where
  the input data is 4-bytes and the output is  8-bytes and the conversion
  is being done in place in the same array.
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 2147483648.)
        {       
           /* Instead of adding 2147483648, it is more efficient */
           /* to just flip the sign bit with the XOR operator */

            for (ii = ntodo - 1; ii >= 0; ii--)
               output[ii] =  ( *(unsigned int *) &input[ii] ) ^ 0x80000000;
        }
        else if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = ntodo - 1; ii >= 0; ii--)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else
                    output[ii] = (unsigned long) input[ii]; /* copy input */
            }
        }
        else             /* must scale the data */
        {
            for (ii = ntodo - 1; ii >= 0; ii--)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DULONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 2147483648.) 
        {       
            for (ii = ntodo - 1; ii >= 0; ii--)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                   output[ii] =  ( *(unsigned int *) &input[ii] ) ^ 0x80000000;
            }
        }
        else if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = ntodo - 1; ii >= 0; ii--)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else
                    output[ii] = (unsigned long) input[ii]; /* copy input */
            }
        }
        else                  /* must scale the data */
        {
            for (ii = ntodo - 1; ii >= 0; ii--)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8u4(LONGLONG *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
   unsigned long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > ULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DULONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > ULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4u4(float *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
   unsigned long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DULONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > DULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DULONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  { 
                    if (zero < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (zero > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                      output[ii] = (unsigned long) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8u4(double *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
   unsigned long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DULONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > DULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DULONG_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DULONG_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = ULONG_MAX;
                }
                else
                    output[ii] = (unsigned long) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  { 
                    if (zero < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (zero > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                      output[ii] = (unsigned long) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DULONG_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DULONG_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = ULONG_MAX;
                    }
                    else
                        output[ii] = (unsigned long) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstru4(char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
   unsigned long nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned long *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')       /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DULONG_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = 0;
        }
        else if (dvalue > DULONG_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = ULONG_MAX;
        }
        else
            output[ii] = (unsigned long) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getcoluk.c0000664000175000017500000021750413010375005016752 0ustar  zoncazonca00000000000000/*  This file, getcolk.c, contains routines that read data elements from   */
/*  a FITS image or table, with 'unsigned int' data type.                  */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffgpvuk( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
   unsigned int   nulval,     /* I - value for undefined pixels              */
   unsigned int   *array,     /* O - array of values that are returned       */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Undefined elements will be set equal to NULVAL, unless NULVAL=0
  in which case no checking for undefined values will be performed.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    char cdummy;
    int nullcheck = 1;
    unsigned int nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
         nullvalue = nulval;  /* set local variable */

        fits_read_compressed_pixels(fptr, TUINT, firstelem, nelem,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcluk(fptr, 2, row, firstelem, nelem, 1, 1, nulval,
               array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgpfuk(fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
   unsigned int   *array,     /* O - array of values that are returned       */
            char *nularray,   /* O - array of null pixel flags               */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
  Any undefined pixels in the returned array will be set = 0 and the 
  corresponding nularray value will be set = 1.
  ANYNUL is returned with a value of .true. if any pixels are undefined.
*/
{
    long row;
    int nullcheck = 2;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_read_compressed_pixels(fptr, TUINT, firstelem, nelem,
            nullcheck, NULL, array, nularray, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcluk(fptr, 2, row, firstelem, nelem, 1, 2, 0L,
               array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg2duk(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
  unsigned int  nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
  unsigned int  *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    /* call the 3D reading routine, with the 3rd dimension = 1 */

    ffg3duk(fptr, group, nulval, ncols, naxis2, naxis1, naxis2, 1, array, 
           anynul, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffg3duk(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,     /* I - group to read (1 = 1st group)           */
  unsigned int   nulval,    /* set undefined pixels equal to this          */
           LONGLONG  ncols,     /* I - number of pixels in each row of array   */
           LONGLONG  nrows,     /* I - number of rows in each plane of array   */
           LONGLONG  naxis1,    /* I - FITS image NAXIS1 value                 */
           LONGLONG  naxis2,    /* I - FITS image NAXIS2 value                 */
           LONGLONG  naxis3,    /* I - FITS image NAXIS3 value                 */
  unsigned int   *array,    /* O - array to be filled and returned         */
           int  *anynul,    /* O - set to 1 if any values are null; else 0 */
           int  *status)    /* IO - error status                           */
/*
  Read an entire 3-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being read).  Any null
  values in the array will be set equal to the value of nulval, unless
  nulval = 0 in which case no null checking will be performed.
*/
{
    long tablerow, ii, jj;
    char cdummy;
    int nullcheck = 1;
    long inc[] = {1,1,1};
    LONGLONG fpixel[] = {1,1,1}, nfits, narray;
    LONGLONG lpixel[3];
    unsigned int nullvalue;

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        lpixel[0] = ncols;
        lpixel[1] = nrows;
        lpixel[2] = naxis3;
        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TUINT, fpixel, lpixel, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
       /* all the image pixels are contiguous, so read all at once */
       ffgcluk(fptr, 2, tablerow, 1, naxis1 * naxis2 * naxis3, 1, 1, nulval,
               array, &cdummy, anynul, status);
       return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to read */
    narray = 0;  /* next pixel in output array to be filled */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* reading naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffgcluk(fptr, 2, tablerow, nfits, naxis1, 1, 1, nulval,
          &array[narray], &cdummy, anynul, status) > 0)
          return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsvuk(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
  unsigned int  nulval,    /* I - value to set undefined pixels             */
  unsigned int  *array,    /* O - array to be filled and returned           */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9];
    long nelem, nultyp, ninc, numcol;
    LONGLONG felem, dsize[10], blcll[9], trcll[9];
    int hdutype, anyf;
    char ldummy, msg[FLEN_ERRMSG];
    int nullcheck = 1;
    unsigned int nullvalue;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvuk is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        nullvalue = nulval;  /* set local variable */

        fits_read_compressed_img(fptr, TUINT, blcll, trcll, inc,
            nullcheck, &nullvalue, array, NULL, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 1;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvuk: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgcluk(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &ldummy, &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsfuk(fitsfile *fptr, /* I - FITS file pointer                         */
           int  colnum,    /* I - number of the column to read (1 = 1st)    */
           int naxis,      /* I - number of dimensions in the FITS array    */
           long  *naxes,   /* I - size of each dimension                    */
           long  *blc,     /* I - 'bottom left corner' of the subsection    */
           long  *trc,     /* I - 'top right corner' of the subsection      */
           long  *inc,     /* I - increment to be applied in each dimension */
  unsigned int  *array,    /* O - array to be filled and returned           */
           char *flagval,  /* O - set to 1 if corresponding value is null   */
           int  *anynul,   /* O - set to 1 if any values are null; else 0   */
           int  *status)   /* IO - error status                             */
/*
  Read a subsection of data values from an image or a table column.
  This routine is set up to handle a maximum of nine dimensions.
*/
{
    long ii,i0, i1,i2,i3,i4,i5,i6,i7,i8,row,rstr,rstp,rinc;
    long str[9],stp[9],incr[9],dsize[10];
    LONGLONG blcll[9], trcll[9];
    long felem, nelem, nultyp, ninc, numcol;
    long nulval = 0;
    int hdutype, anyf;
    char msg[FLEN_ERRMSG];
    int nullcheck = 2;

    if (naxis < 1 || naxis > 9)
    {
        sprintf(msg, "NAXIS = %d in call to ffgsvj is out of range", naxis);
        ffpmsg(msg);
        return(*status = BAD_DIMEN);
    }

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        for (ii=0; ii < naxis; ii++) {
	    blcll[ii] = blc[ii];
	    trcll[ii] = trc[ii];
	}

        fits_read_compressed_img(fptr, TUINT, blcll, trcll, inc,
            nullcheck, NULL, array, flagval, anynul, status);
        return(*status);
    }

/*
    if this is a primary array, then the input COLNUM parameter should
    be interpreted as the row number, and we will alway read the image
    data from column 2 (any group parameters are in column 1).
*/
    if (ffghdt(fptr, &hdutype, status) > 0)
        return(*status);

    if (hdutype == IMAGE_HDU)
    {
        /* this is a primary array, or image extension */
        if (colnum == 0)
        {
            rstr = 1;
            rstp = 1;
        }
        else
        {
            rstr = colnum;
            rstp = colnum;
        }
        rinc = 1;
        numcol = 2;
    }
    else
    {
        /* this is a table, so the row info is in the (naxis+1) elements */
        rstr = blc[naxis];
        rstp = trc[naxis];
        rinc = inc[naxis];
        numcol = colnum;
    }

    nultyp = 2;
    if (anynul)
        *anynul = FALSE;

    i0 = 0;
    for (ii = 0; ii < 9; ii++)
    {
        str[ii] = 1;
        stp[ii] = 1;
        incr[ii] = 1;
        dsize[ii] = 1;
    }

    for (ii = 0; ii < naxis; ii++)
    {
      if (trc[ii] < blc[ii])
      {
        sprintf(msg, "ffgsvj: illegal range specified for axis %ld", ii + 1);
        ffpmsg(msg);
        return(*status = BAD_PIX_NUM);
      }

      str[ii] = blc[ii];
      stp[ii] = trc[ii];
      incr[ii] = inc[ii];
      dsize[ii + 1] = dsize[ii] * naxes[ii];
    }

    if (naxis == 1 && naxes[0] == 1)
    {
      /* This is not a vector column, so read all the rows at once */
      nelem = (rstp - rstr) / rinc + 1;
      ninc = rinc;
      rstp = rstr;
    }
    else
    {
      /* have to read each row individually, in all dimensions */
      nelem = (stp[0] - str[0]) / inc[0] + 1;
      ninc = incr[0];
    }

    for (row = rstr; row <= rstp; row += rinc)
    {
     for (i8 = str[8]; i8 <= stp[8]; i8 += incr[8])
     {
      for (i7 = str[7]; i7 <= stp[7]; i7 += incr[7])
      {
       for (i6 = str[6]; i6 <= stp[6]; i6 += incr[6])
       {
        for (i5 = str[5]; i5 <= stp[5]; i5 += incr[5])
        {
         for (i4 = str[4]; i4 <= stp[4]; i4 += incr[4])
         {
          for (i3 = str[3]; i3 <= stp[3]; i3 += incr[3])
          {
           for (i2 = str[2]; i2 <= stp[2]; i2 += incr[2])
           {
            for (i1 = str[1]; i1 <= stp[1]; i1 += incr[1])
            {
              felem=str[0] + (i1 - 1) * dsize[1] + (i2 - 1) * dsize[2] + 
                             (i3 - 1) * dsize[3] + (i4 - 1) * dsize[4] +
                             (i5 - 1) * dsize[5] + (i6 - 1) * dsize[6] +
                             (i7 - 1) * dsize[7] + (i8 - 1) * dsize[8];

              if ( ffgcluk(fptr, numcol, row, felem, nelem, ninc, nultyp,
                   nulval, &array[i0], &flagval[i0], &anyf, status) > 0)
                   return(*status);

              if (anyf && anynul)
                  *anynul = TRUE;

              i0 += nelem;
            }
           }
          }
         }
        }
       }
      }
     }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffggpuk( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to read (1 = 1st group)           */
            long  firstelem,  /* I - first vector element to read (1 = 1st)  */
            long  nelem,      /* I - number of values to read                */
   unsigned int  *array,     /* O - array of values that are returned       */
            int  *status)     /* IO - error status                           */
/*
  Read an array of group parameters from the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being read).
*/
{
    long row;
    int idummy;
    char cdummy;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffgcluk(fptr, 1, row, firstelem, nelem, 1, 1, 0L,
               array, &cdummy, &idummy, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcvuk(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
  unsigned int   nulval,     /* I - value for null pixels                   */
  unsigned int  *array,      /* O - array of values that are read           */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Any undefined pixels will be set equal to the value of 'nulval' unless
  nulval = 0 in which case no checks for undefined pixels will be made.
*/
{
    char cdummy;

    ffgcluk(fptr, colnum, firstrow, firstelem, nelem, 1, 1, nulval,
           array, &cdummy, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcfuk(fitsfile *fptr,   /* I - FITS file pointer                       */
           int  colnum,      /* I - number of column to read (1 = 1st col)  */
           LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
           LONGLONG  firstelem,  /* I - first vector element to read (1 = 1st)  */
           LONGLONG  nelem,      /* I - number of values to read                */
  unsigned int   *array,     /* O - array of values that are read           */
           char *nularray,   /* O - array of flags: 1 if null pixel; else 0 */
           int  *anynul,     /* O - set to 1 if any values are null; else 0 */
           int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU. Automatic
  datatype conversion will be performed if the datatype of the column does not
  match the datatype of the array parameter. The output values will be scaled 
  by the FITS TSCALn and TZEROn values if these values have been defined.
  Nularray will be set = 1 if the corresponding array pixel is undefined, 
  otherwise nularray will = 0.
*/
{
    int dummy = 0;

    ffgcluk(fptr, colnum, firstrow, firstelem, nelem, 1, 2, dummy,
           array, nularray, anynul, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcluk( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to read (1 = 1st col)  */
            LONGLONG  firstrow,   /* I - first row to read (1 = 1st row)         */
            LONGLONG firstelem,  /* I - first vector element to read (1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to read                */
            long  elemincre,  /* I - pixel increment; e.g., 2 = every other  */
            int   nultyp,     /* I - null value handling code:               */
                              /*     1: set undefined pixels = nulval        */
                              /*     2: set nularray=1 for undefined pixels  */
   unsigned int   nulval,     /* I - value for null pixels if nultyp = 1     */
   unsigned int  *array,      /* O - array of values that are read           */
            char *nularray,   /* O - array of flags = 1 if nultyp = 2        */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
  Read an array of values from a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer be a virtual column in a 1 or more grouped FITS primary
  array or image extension.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The output array of values will be converted from the datatype of the column 
  and will be scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    double scale, zero, power = 1., dtemp;
    int tcode, maxelem2, hdutype, xcode, decimals;
    long twidth, incre;
    long ii, xwidth, ntodo;
    int nulcheck;
    LONGLONG repeat, startpos, elemnum, readptr, tnull;
    LONGLONG rowlen, rownum, remain, next, rowincre, maxelem;
    char tform[20];
    char message[81];
    char snull[20];   /*  the FITS null value if reading from ASCII table  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0 || nelem == 0)  /* inherit input status value if > 0 */
        return(*status);

    /* call the 'short' or 'long' version of this routine, if possible */
    if (sizeof(int) == sizeof(short))
        ffgclui(fptr, colnum, firstrow, firstelem, nelem, elemincre, nultyp,
          (unsigned short) nulval, (unsigned short *) array, nularray, anynul,
           status);
    else if (sizeof(int) == sizeof(long))
        ffgcluj(fptr, colnum, firstrow, firstelem, nelem, elemincre, nultyp,
          (unsigned long) nulval, (unsigned long *) array, nularray, anynul,
          status);
    else
    {
    /*
      This is a special case: sizeof(int) is not equal to sizeof(short) or
      sizeof(long).  This occurs on Alpha OSF systems where short = 2 bytes,
      int = 4 bytes, and long = 8 bytes.
    */

    buffer = cbuff;

    if (anynul)
        *anynul = 0;

    if (nultyp == 2)
        memset(nularray, 0, (size_t) nelem);   /* initialize nullarray */

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if ( ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 0, &scale, &zero,
         tform, &twidth, &tcode, &maxelem2, &startpos, &elemnum, &incre,
         &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0 )
         return(*status);
    maxelem = maxelem2;

    incre *= elemincre;   /* multiply incre to just get every nth pixel */

    if (tcode == TSTRING)    /* setup for ASCII tables */
    {
      /* get the number of implied decimal places if no explicit decmal point */
      ffasfm(tform, &xcode, &xwidth, &decimals, status); 
      for(ii = 0; ii < decimals; ii++)
        power *= 10.;
    }
    /*------------------------------------------------------------------*/
    /*  Decide whether to check for null values in the input FITS file: */
    /*------------------------------------------------------------------*/
    nulcheck = nultyp; /* by default check for null values in the FITS file */

    if (nultyp == 1 && nulval == 0)
       nulcheck = 0;    /* calling routine does not want to check for nulls */

    else if (tcode%10 == 1 &&        /* if reading an integer column, and  */ 
            tnull == NULL_UNDEFINED) /* if a null value is not defined,    */
            nulcheck = 0;            /* then do not check for null values. */

    else if (tcode == TSHORT && (tnull > SHRT_MAX || tnull < SHRT_MIN) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TBYTE && (tnull > 255 || tnull < 0) )
            nulcheck = 0;            /* Impossible null value */

    else if (tcode == TSTRING && snull[0] == ASCII_NULL_UNDEFINED)
         nulcheck = 0;

    /*----------------------------------------------------------------------*/
    /*  If FITS column and output data array have same datatype, then we do */
    /*  not need to use a temporary buffer to store intermediate datatype.  */
    /*----------------------------------------------------------------------*/
    if (tcode == TLONG)  /* Special Case: */
    {                             /* data are 4-bytes long, so read       */
                                  /* data directly into output buffer.    */

        if (nelem < (LONGLONG)INT32_MAX/4) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/4;
        }
    }

    /*---------------------------------------------------------------------*/
    /*  Now read the pixels from the FITS column. If the column does not   */
    /*  have the same datatype as the output array, then we have to read   */
    /*  the raw values into a temporary buffer (of limited size).  In      */
    /*  the case of a vector colum read only 1 vector of values at a time  */
    /*  then skip to the next row if more values need to be read.          */
    /*  After reading the raw values, then call the fffXXYY routine to (1) */
    /*  test for undefined values, (2) convert the datatype if necessary,  */
    /*  and (3) scale the values by the FITS TSCALn and TZEROn linear      */
    /*  scaling parameters.                                                */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to read */
    next = 0;                 /* next element in array to be read   */
    rownum = 0;               /* row number, relative to firstrow   */

    while (remain)
    {
        /* limit the number of pixels to read at one time to the number that
           will fit in the buffer or to the number of pixels that remain in
           the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, ((repeat - elemnum - 1)/elemincre +1));

        readptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * (incre / elemincre));

        switch (tcode) 
        {
            case (TLONG):
                ffgi4b(fptr, readptr, ntodo, incre, (INT32BIT *) &array[next],
                       status);
                    fffi4uint((INT32BIT *) &array[next], ntodo, scale, zero, 
                           nulcheck, (INT32BIT) tnull, nulval, &nularray[next],
                           anynul, &array[next], status);
                break;
            case (TLONGLONG):

                ffgi8b(fptr, readptr, ntodo, incre, (long *) buffer, status);
                fffi8uint( (LONGLONG *) buffer, ntodo, scale, zero, 
                           nulcheck, tnull, nulval, &nularray[next], 
                            anynul, &array[next], status);
                break;
            case (TBYTE):
                ffgi1b(fptr, readptr, ntodo, incre, (unsigned char *) buffer,
                       status);
                fffi1uint((unsigned char *) buffer, ntodo, scale, zero,nulcheck,
                     (unsigned char) tnull, nulval, &nularray[next], anynul, 
                     &array[next], status);
                break;
            case (TSHORT):
                ffgi2b(fptr, readptr, ntodo, incre, (short  *) buffer, status);
                fffi2uint((short  *) buffer, ntodo, scale, zero, nulcheck, 
                      (short) tnull, nulval, &nularray[next], anynul, 
                      &array[next], status);
                break;
            case (TFLOAT):
                ffgr4b(fptr, readptr, ntodo, incre, (float  *) buffer, status);
                fffr4uint((float  *) buffer, ntodo, scale, zero, nulcheck, 
                       nulval, &nularray[next], anynul, 
                       &array[next], status);
                break;
            case (TDOUBLE):
                ffgr8b(fptr, readptr, ntodo, incre, (double *) buffer, status);
                fffr8uint((double *) buffer, ntodo, scale, zero, nulcheck, 
                          nulval, &nularray[next], anynul, 
                          &array[next], status);
                break;
            case (TSTRING):
                ffmbyt(fptr, readptr, REPORT_EOF, status);
       
                if (incre == twidth)    /* contiguous bytes */
                     ffgbyt(fptr, ntodo * twidth, buffer, status);
                else
                     ffgbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                               status);

                fffstruint((char *) buffer, ntodo, scale, zero, twidth, power,
                     nulcheck, snull, nulval, &nularray[next], anynul,
                     &array[next], status);
                break;

            default:  /*  error trap for invalid column format */
                sprintf(message, 
                   "Cannot read numbers from column %d which has format %s",
                    colnum, tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous read operation */
        {
	  dtemp = (double) next;
          if (hdutype > 0)
            sprintf(message,
            "Error reading elements %.0f thru %.0f from column %d (ffgcluk).",
              dtemp+1., dtemp+ntodo, colnum);
          else
            sprintf(message,
            "Error reading elements %.0f thru %.0f from image (ffgcluk).",
              dtemp+1., dtemp+ntodo);

          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum = elemnum + (ntodo * elemincre);

            if (elemnum >= repeat)  /* completed a row; start on later row */
            {
                rowincre = elemnum / repeat;
                rownum += rowincre;
                elemnum = elemnum - (rowincre * repeat);
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while reading FITS data.");
        *status = NUM_OVERFLOW;
    }

    }  /* end of DEC Alpha special case */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi1uint(unsigned char *input,/* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
   unsigned int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
                output[ii] = (unsigned int) input[ii];  /* copy input */
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                    output[ii] = (unsigned int) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi2uint(short *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
   unsigned int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else
                    output[ii] = (unsigned int) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else
                        output[ii] = (unsigned int) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi4uint(INT32BIT *input,    /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
   unsigned int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 2147483648.)
        {       
           /* Instead of adding 2147483648, it is more efficient */
           /* to just flip the sign bit with the XOR operator */

            for (ii = 0; ii < ntodo; ii++)
               output[ii] =  ( *(unsigned int *) &input[ii] ) ^ 0x80000000;
        }
        else if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else
                    output[ii] = (unsigned int) input[ii]; /* copy to output */
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 2147483648.) 
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                   output[ii] =  ( *(unsigned int *) &input[ii] ) ^ 0x80000000;
            }
        }
        else if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else
                    output[ii] = (unsigned int) input[ii];
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffi8uint(LONGLONG *input,    /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            LONGLONG tnull,       /* I - value of FITS TNULLn keyword if any */
   unsigned int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to tnull.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < 0)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > UINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (input[ii] < 0)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > UINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr4uint(float *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
   unsigned int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DUINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > DUINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr++;       /* point to MSBs */
#endif

        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 2)
            {
              if (0 != (iret = fnan(*sptr) ) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  { 
                    if (zero < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (zero > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                      output[ii] = (unsigned int) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffr8uint(double *input,       /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
   unsigned int  nullval,         /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned int  *output,         /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file.
  Check for null values and do datatype conversion and scaling if required.
  The nullcheck code value determines how any null values in the input array
  are treated.  A null value is an input pixel that is equal to NaN.  If 
  nullcheck = 0, then no checking for nulls is performed and any null values
  will be transformed just like any other pixel.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    long ii;
    double dvalue;
    short *sptr, iret;

    if (nullcheck == 0)     /* no null checking required */
    {
        if (scale == 1. && zero == 0.)      /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] < DUINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (input[ii] > DUINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) input[ii];
            }
        }
        else             /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++)
            {
                dvalue = input[ii] * scale + zero;

                if (dvalue < DUINT_MIN)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = 0;
                }
                else if (dvalue > DUINT_MAX)
                {
                    *status = OVERFLOW_ERR;
                    output[ii] = UINT_MAX;
                }
                else
                    output[ii] = (unsigned int) dvalue;
            }
        }
    }
    else        /* must check for null values */
    {
        sptr = (short *) input;

#if BYTESWAPPED && MACHINE != VAXVMS && MACHINE != ALPHAVMS
        sptr += 3;       /* point to MSBs */
#endif
        if (scale == 1. && zero == 0.)  /* no scaling */
        {       
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                     output[ii] = 0;
              }
              else
                {
                    if (input[ii] < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (input[ii] > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) input[ii];
                }
            }
        }
        else                  /* must scale the data */
        {
            for (ii = 0; ii < ntodo; ii++, sptr += 4)
            {
              if (0 != (iret = dnan(*sptr)) )  /* test for NaN or underflow */
              {
                  if (iret == 1)  /* is it a NaN? */
                  {  
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                  }
                  else            /* it's an underflow */
                  { 
                    if (zero < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (zero > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                      output[ii] = (unsigned int) zero;
                  }
              }
              else
                {
                    dvalue = input[ii] * scale + zero;

                    if (dvalue < DUINT_MIN)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = 0;
                    }
                    else if (dvalue > DUINT_MAX)
                    {
                        *status = OVERFLOW_ERR;
                        output[ii] = UINT_MAX;
                    }
                    else
                        output[ii] = (unsigned int) dvalue;
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffstruint(char *input,        /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            long twidth,          /* I - width of each substring of chars    */
            double implipower,    /* I - power of 10 of implied decimal      */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            char  *snull,         /* I - value of FITS null string, if any   */
   unsigned int nullval,          /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
   unsigned int *output,          /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
  Copy input to output following reading of the input from a FITS file. Check
  for null values and do scaling if required. The nullcheck code value
  determines how any null values in the input array are treated. A null
  value is an input pixel that is equal to snull.  If nullcheck= 0, then
  no special checking for nulls is performed.  If nullcheck = 1, then the
  output pixel will be set = nullval if the corresponding input pixel is null.
  If nullcheck = 2, then if the pixel is null then the corresponding value of
  nullarray will be set to 1; the value of nullarray for non-null pixels 
  will = 0.  The anynull parameter will be set = 1 if any of the returned
  pixels are null, otherwise anynull will be returned with a value = 0;
*/
{
    int nullen;
    long ii;
    double dvalue;
    char *cstring, message[81];
    char *cptr, *tpos;
    char tempstore, chrzero = '0';
    double val, power;
    int exponent, sign, esign, decpt;

    nullen = strlen(snull);
    cptr = input;  /* pointer to start of input string */
    for (ii = 0; ii < ntodo; ii++)
    {
      cstring = cptr;
      /* temporarily insert a null terminator at end of the string */
      tpos = cptr + twidth;
      tempstore = *tpos;
      *tpos = 0;

      /* check if null value is defined, and if the    */
      /* column string is identical to the null string */
      if (snull[0] != ASCII_NULL_UNDEFINED && 
         !strncmp(snull, cptr, nullen) )
      {
        if (nullcheck)  
        {
          *anynull = 1;    
          if (nullcheck == 1)
            output[ii] = nullval;
          else
            nullarray[ii] = 1;
        }
        cptr += twidth;
      }
      else
      {
        /* value is not the null value, so decode it */
        /* remove any embedded blank characters from the string */

        decpt = 0;
        sign = 1;
        val  = 0.;
        power = 1.;
        exponent = 0;
        esign = 1;

        while (*cptr == ' ')               /* skip leading blanks */
           cptr++;

        if (*cptr == '-' || *cptr == '+')  /* check for leading sign */
        {
          if (*cptr == '-')
             sign = -1;

          cptr++;

          while (*cptr == ' ')         /* skip blanks between sign and value */
            cptr++;
        }

        while (*cptr >= '0' && *cptr <= '9')
        {
          val = val * 10. + *cptr - chrzero;  /* accumulate the value */
          cptr++;

          while (*cptr == ' ')         /* skip embedded blanks in the value */
            cptr++;
        }

        if (*cptr == '.' || *cptr == ',')       /* check for decimal point */
        {
          decpt = 1;       /* set flag to show there was a decimal point */
          cptr++;
          while (*cptr == ' ')         /* skip any blanks */
            cptr++;

          while (*cptr >= '0' && *cptr <= '9')
          {
            val = val * 10. + *cptr - chrzero;  /* accumulate the value */
            power = power * 10.;
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks in the value */
              cptr++;
          }
        }

        if (*cptr == 'E' || *cptr == 'D')  /* check for exponent */
        {
          cptr++;
          while (*cptr == ' ')         /* skip blanks */
              cptr++;
  
          if (*cptr == '-' || *cptr == '+')  /* check for exponent sign */
          {
            if (*cptr == '-')
               esign = -1;

            cptr++;

            while (*cptr == ' ')        /* skip blanks between sign and exp */
              cptr++;
          }

          while (*cptr >= '0' && *cptr <= '9')
          {
            exponent = exponent * 10 + *cptr - chrzero;  /* accumulate exp */
            cptr++;

            while (*cptr == ' ')         /* skip embedded blanks */
              cptr++;
          }
        }

        if (*cptr  != 0)  /* should end up at the null terminator */
        {
          sprintf(message, "Cannot read number from ASCII table");
          ffpmsg(message);
          sprintf(message, "Column field = %s.", cstring);
          ffpmsg(message);
          /* restore the char that was overwritten by the null */
          *tpos = tempstore;
          return(*status = BAD_C2D);
        }

        if (!decpt)  /* if no explicit decimal, use implied */
           power = implipower;

        dvalue = (sign * val / power) * pow(10., (double) (esign * exponent));

        dvalue = dvalue * scale + zero;   /* apply the scaling */

        if (dvalue < DUINT_MIN)
        {
            *status = OVERFLOW_ERR;
            output[ii] = 0;
        }
        else if (dvalue > DUINT_MAX)
        {
            *status = OVERFLOW_ERR;
            output[ii] = UINT_MAX;
        }
        else
            output[ii] = (long) dvalue;
      }
      /* restore the char that was overwritten by the null */
      *tpos = tempstore;
    }
    return(*status);
}
healpy-1.10.3/cfitsio/getkey.c0000664000175000017500000034002413010375005016417 0ustar  zoncazonca00000000000000/*  This file, getkey.c, contains routines that read keywords from         */
/*  a FITS header.                                                         */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
/* stddef.h is apparently needed to define size_t */
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffghsp(fitsfile *fptr,  /* I - FITS file pointer                     */
           int *nexist,     /* O - number of existing keywords in header */
           int *nmore,      /* O - how many more keywords will fit       */
           int *status)     /* IO - error status                         */
/*
  returns the number of existing keywords (not counting the END keyword)
  and the number of more keyword that will fit in the current header 
  without having to insert more FITS blocks.
*/
{
    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if (nexist)
        *nexist = (int) (( ((fptr->Fptr)->headend) - 
                ((fptr->Fptr)->headstart[(fptr->Fptr)->curhdu]) ) / 80);

    if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
      if (nmore)
        *nmore = -1;   /* data not written yet, so room for any keywords */
    }
    else
    {
      /* calculate space available between the data and the END card */
      if (nmore)
        *nmore = (int) (((fptr->Fptr)->datastart - (fptr->Fptr)->headend) / 80 - 1);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffghps(fitsfile *fptr, /* I - FITS file pointer                     */
          int *nexist,     /* O - number of existing keywords in header */
          int *position,   /* O - position of next keyword to be read   */
          int *status)     /* IO - error status                         */
/*
  return the number of existing keywords and the position of the next
  keyword that will be read.
*/
{
    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

  *nexist = (int) (( ((fptr->Fptr)->headend) - ((fptr->Fptr)->headstart[(fptr->Fptr)->curhdu]) ) / 80);
  *position = (int) (( ((fptr->Fptr)->nextkey) - ((fptr->Fptr)->headstart[(fptr->Fptr)->curhdu]) ) / 80 + 1);
  return(*status);
}
/*--------------------------------------------------------------------------*/
int ffnchk(fitsfile *fptr,  /* I - FITS file pointer                     */
           int *status)     /* IO - error status                         */
/*
  function returns the position of the first null character (ASCII 0), if
  any, in the current header.  Null characters are illegal, but the other
  CFITSIO routines that read the header will not detect this error, because
  the null gets interpreted as a normal end of string character.
*/
{
    long ii, nblock;
    LONGLONG bytepos;
    int length, nullpos;
    char block[2881];
    
    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        return(0);  /* Don't check a file that is just being created.  */
                    /* It cannot contain nulls since CFITSIO wrote it. */
    }
    else
    {
        /* calculate number of blocks in the header */
        nblock = (long) (( (fptr->Fptr)->datastart - 
                   (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] ) / 2880);
    }

    bytepos = (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu];
    ffmbyt(fptr, bytepos, REPORT_EOF, status);  /* move to read pos. */

    block[2880] = '\0';
    for (ii = 0; ii < nblock; ii++)
    {
        if (ffgbyt(fptr, 2880, block, status) > 0)
            return(0);   /* read error of some sort */

        length = strlen(block);
        if (length != 2880)
        {
            nullpos = (ii * 2880) + length + 1;
            return(nullpos);
        }
    }

    return(0);
}
/*--------------------------------------------------------------------------*/
int ffmaky(fitsfile *fptr,    /* I - FITS file pointer                    */
          int nrec,           /* I - one-based keyword number to move to  */
          int *status)        /* IO - error status                        */
{
/*
  move pointer to the specified absolute keyword position.  E.g. this keyword 
  will then be read by the next call to ffgnky.
*/
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    (fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] + ( (nrec - 1) * 80);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmrky(fitsfile *fptr,    /* I - FITS file pointer                   */
          int nmove,          /* I - relative number of keywords to move */
          int *status)        /* IO - error status                       */
{
/*
  move pointer to the specified keyword position relative to the current
  position.  E.g. this keyword  will then be read by the next call to ffgnky.
*/

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    (fptr->Fptr)->nextkey += (nmove * 80);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgnky(fitsfile *fptr,  /* I - FITS file pointer     */
           char *card,      /* O - card string           */
           int *status)     /* IO - error status         */
/*
  read the next keyword from the header - used internally by cfitsio
*/
{
    int jj, nrec;
    LONGLONG bytepos, endhead;
    char message[FLEN_ERRMSG];

    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    card[0] = '\0';  /* make sure card is terminated, even affer read error */

/*
  Check that nextkey points to a legal keyword position.  Note that headend
  is the current end of the header, i.e., the position where a new keyword
  would be appended, however, if there are more than 1 FITS block worth of
  blank keywords at the end of the header (36 keywords per 2880 byte block)
  then the actual physical END card must be located at a starting position
  which is just 2880 bytes prior to the start of the data unit.
*/

    bytepos = (fptr->Fptr)->nextkey;
    endhead = maxvalue( ((fptr->Fptr)->headend), ((fptr->Fptr)->datastart - 2880) );

    /* nextkey must be < endhead and > than  headstart */
    if (bytepos > endhead ||  
        bytepos < (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] ) 
    {
        nrec= (int) ((bytepos - (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu]) / 80 + 1);
        sprintf(message, "Cannot get keyword number %d.  It does not exist.",
                nrec);
        ffpmsg(message);
        return(*status = KEY_OUT_BOUNDS);
    }
      
    ffmbyt(fptr, bytepos, REPORT_EOF, status);  /* move to read pos. */

    card[80] = '\0';  /* make sure card is terminate, even if ffgbyt fails */

    if (ffgbyt(fptr, 80, card, status) <= 0) 
    {
        (fptr->Fptr)->nextkey += 80;   /* increment pointer to next keyword */

        /* strip off trailing blanks with terminated string */
        jj = 79;
        while (jj >= 0 && card[jj] == ' ')
               jj--;

        card[jj + 1] = '\0';
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgnxk( fitsfile *fptr,     /* I - FITS file pointer              */
            char **inclist,     /* I - list of included keyword names */
            int ninc,           /* I - number of names in inclist     */
            char **exclist,     /* I - list of excluded keyword names */
            int nexc,           /* I - number of names in exclist     */
            char *card,         /* O - first matching keyword         */
            int  *status)       /* IO - error status                  */
/*
    Return the next keyword that matches one of the names in inclist
    but does not match any of the names in exclist.  The search
    goes from the current position to the end of the header, only.
    Wild card characters may be used in the name lists ('*', '?' and '#').
*/
{
    int casesn, match, exact, namelen;
    long ii, jj;
    char keybuf[FLEN_CARD], keyname[FLEN_KEYWORD];

    card[0] = '\0';
    if (*status > 0)
        return(*status);

    casesn = FALSE;

    /* get next card, and return with an error if hit end of header */
    while( ffgcrd(fptr, "*", keybuf, status) <= 0)
    {
        ffgknm(keybuf, keyname, &namelen, status); /* get the keyword name */
        
        /* does keyword match any names in the include list? */
        for (ii = 0; ii < ninc; ii++)
        {
            ffcmps(inclist[ii], keyname, casesn, &match, &exact);
            if (match)
            {
                /* does keyword match any names in the exclusion list? */
                jj = -1;
                while ( ++jj < nexc )
                {
                    ffcmps(exclist[jj], keyname, casesn, &match, &exact);
                    if (match)
                        break;
                }

                if (jj >= nexc)
                {
                    /* not in exclusion list, so return this keyword */
                    strcat(card, keybuf);
                    return(*status);
                }
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgky( fitsfile *fptr,     /* I - FITS file pointer        */
           int  datatype,      /* I - datatype of the value    */
           const char *keyname,      /* I - name of keyword to read  */
           void *value,        /* O - keyword value            */
           char *comm,         /* O - keyword comment          */
           int  *status)       /* IO - error status            */
/*
  Read (get) the keyword value and comment from the FITS header.
  Reads a keyword value with the datatype specified by the 2nd argument.
*/
{
    long longval;
    double doubleval;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (datatype == TSTRING)
    {
        ffgkys(fptr, keyname, (char *) value, comm, status);
    }
    else if (datatype == TBYTE)
    {
        if (ffgkyj(fptr, keyname, &longval, comm, status) <= 0)
        {
            if (longval > UCHAR_MAX || longval < 0)
                *status = NUM_OVERFLOW;
            else
                *(unsigned char *) value = (unsigned char) longval;
        }
    }
    else if (datatype == TSBYTE)
    {
        if (ffgkyj(fptr, keyname, &longval, comm, status) <= 0)
        {
            if (longval > 127 || longval < -128)
                *status = NUM_OVERFLOW;
            else
                *(signed char *) value = (signed char) longval;
        }
    }
    else if (datatype == TUSHORT)
    {
        if (ffgkyj(fptr, keyname, &longval, comm, status) <= 0)
        {
            if (longval > (long) USHRT_MAX || longval < 0)
                *status = NUM_OVERFLOW;
            else
                *(unsigned short *) value = (unsigned short) longval;
        }
    }
    else if (datatype == TSHORT)
    {
        if (ffgkyj(fptr, keyname, &longval, comm, status) <= 0)
        {
            if (longval > SHRT_MAX || longval < SHRT_MIN)
                *status = NUM_OVERFLOW;
            else
                *(short *) value = (short) longval;
        }
    }
    else if (datatype == TUINT)
    {
        if (ffgkyj(fptr, keyname, &longval, comm, status) <= 0)
        {
            if (longval > (long) UINT_MAX || longval < 0)
                *status = NUM_OVERFLOW;
            else
                *(unsigned int *) value = longval;
        }
    }
    else if (datatype == TINT)
    {
        if (ffgkyj(fptr, keyname, &longval, comm, status) <= 0)
        {
            if (longval > INT_MAX || longval < INT_MIN)
                *status = NUM_OVERFLOW;
            else
                *(int *) value = longval;
        }
    }
    else if (datatype == TLOGICAL)
    {
        ffgkyl(fptr, keyname, (int *) value, comm, status);
    }
    else if (datatype == TULONG)
    {
        if (ffgkyd(fptr, keyname, &doubleval, comm, status) <= 0)
        {
            if (doubleval > (double) ULONG_MAX || doubleval < 0)
                *status = NUM_OVERFLOW;
            else
                 *(unsigned long *) value = (unsigned long) doubleval;
        }
    }
    else if (datatype == TLONG)
    {
        ffgkyj(fptr, keyname, (long *) value, comm, status);
    }
    else if (datatype == TLONGLONG)
    {
        ffgkyjj(fptr, keyname, (LONGLONG *) value, comm, status);
    }
    else if (datatype == TFLOAT)
    {
        ffgkye(fptr, keyname, (float *) value, comm, status);
    }
    else if (datatype == TDOUBLE)
    {
        ffgkyd(fptr, keyname, (double *) value, comm, status);
    }
    else if (datatype == TCOMPLEX)
    {
        ffgkyc(fptr, keyname, (float *) value, comm, status);
    }
    else if (datatype == TDBLCOMPLEX)
    {
        ffgkym(fptr, keyname, (double *) value, comm, status);
    }
    else
        *status = BAD_DATATYPE;

    return(*status);
} 
/*--------------------------------------------------------------------------*/
int ffgkey( fitsfile *fptr,     /* I - FITS file pointer        */
            const char *keyname,      /* I - name of keyword to read  */
            char *keyval,       /* O - keyword value            */
            char *comm,         /* O - keyword comment          */
            int  *status)       /* IO - error status            */
/*
  Read (get) the named keyword, returning the keyword value and comment.
  The value is just the literal string of characters in the value field
  of the keyword.  In the case of a string valued keyword, the returned
  value includes the leading and closing quote characters.  The value may be
  up to 70 characters long, and the comment may be up to 72 characters long.
  If the keyword has no value (no equal sign in column 9) then a null value
  is returned.
*/
{
    char card[FLEN_CARD];

    keyval[0] = '\0';
    if (comm)
       comm[0] = '\0';

    if (*status > 0)
        return(*status);

    if (ffgcrd(fptr, keyname, card, status) > 0)    /* get the 80-byte card */
        return(*status);

    ffpsvc(card, keyval, comm, status);      /* parse the value and comment */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgrec( fitsfile *fptr,     /* I - FITS file pointer          */
            int nrec,           /* I - number of keyword to read  */
            char *card,         /* O - keyword card               */
            int  *status)       /* IO - error status              */
/*
  Read (get) the nrec-th keyword, returning the entire keyword card up to
  80 characters long.  The first keyword in the header has nrec = 1, not 0.
  The returned card value is null terminated with any trailing blank 
  characters removed.  If nrec = 0, then this routine simply moves the
  current header pointer to the top of the header.
*/
{
    if (*status > 0)
        return(*status);

    if (nrec == 0)
    {
        ffmaky(fptr, 1, status);  /* simply move to beginning of header */
        if (card)
            card[0] = '\0';           /* and return null card */
    }
    else if (nrec > 0)
    {
        ffmaky(fptr, nrec, status);
        ffgnky(fptr, card, status);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgcrd( fitsfile *fptr,     /* I - FITS file pointer        */
            const char *name,         /* I - name of keyword to read  */
            char *card,         /* O - keyword card             */
            int  *status)       /* IO - error status            */
/*
  Read (get) the named keyword, returning the entire keyword card up to
  80 characters long.  
  The returned card value is null terminated with any trailing blank 
  characters removed.

  If the input name contains wild cards ('?' matches any single char
  and '*' matches any sequence of chars, # matches any string of decimal
  digits) then the search ends once the end of header is reached and does 
  not automatically resume from the top of the header.
*/
{
    int nkeys, nextkey, ntodo, namelen, namelen_limit, namelenminus1, cardlen;
    int ii = 0, jj, kk, wild, match, exact, hier = 0;
    char keyname[FLEN_KEYWORD], cardname[FLEN_KEYWORD];
    char *ptr1, *ptr2, *gotstar;

    if (*status > 0)
        return(*status);

    *keyname = '\0';
    
    while (name[ii] == ' ')  /* skip leading blanks in name */
        ii++;

    strncat(keyname, &name[ii], FLEN_KEYWORD - 1);

    namelen = strlen(keyname);

    while (namelen > 0 && keyname[namelen - 1] == ' ')
         namelen--;            /* ignore trailing blanks in name */

    keyname[namelen] = '\0';  /* terminate the name */

    for (ii=0; ii < namelen; ii++)       
        keyname[ii] = toupper(keyname[ii]);    /*  make upper case  */

    if (FSTRNCMP("HIERARCH", keyname, 8) == 0)
    {
        if (namelen == 8)
        {
            /* special case: just looking for any HIERARCH keyword */
            hier = 1;
        }
        else
        {
            /* ignore the leading HIERARCH and look for the 'real' name */
            /* starting with first non-blank character following HIERARCH */
            ptr1 = keyname;
            ptr2 = &keyname[8];

            while(*ptr2 == ' ')
                ptr2++;

            namelen = 0;
            while(*ptr2)
            {
                *ptr1 = *ptr2;
                 ptr1++;
                 ptr2++;
                 namelen++;
            }
            *ptr1 = '\0';
        }
    }

    /* does input name contain wild card chars?  ('?',  '*', or '#') */
    /* wild cards are currently not supported with HIERARCH keywords */

    namelen_limit = namelen;
    gotstar = 0;
    if (namelen < 9 && 
       (strchr(keyname,'?') || (gotstar = strchr(keyname,'*')) || 
        strchr(keyname,'#')) )
    {
        wild = 1;

        /* if we found a '*' wild card in the name, there might be */
        /* more than one.  Support up to 2 '*' in the template. */
        /* Thus we need to compare keywords whose names have at least */
        /* namelen - 2 characters.                                   */
        if (gotstar)
           namelen_limit -= 2;           
    }
    else
        wild = 0;

    ffghps(fptr, &nkeys, &nextkey, status); /* get no. keywords and position */

    namelenminus1 = maxvalue(namelen - 1, 1);
    ntodo = nkeys - nextkey + 1;  /* first, read from next keyword to end */
    for (jj=0; jj < 2; jj++)
    {
      for (kk = 0; kk < ntodo; kk++)
      {
        ffgnky(fptr, card, status);     /* get next keyword */

        if (hier)
        {
           if (FSTRNCMP("HIERARCH", card, 8) == 0)
                return(*status);  /* found a HIERARCH keyword */
        }
        else
        {
          ffgknm(card, cardname, &cardlen, status); /* get the keyword name */

          if (cardlen >= namelen_limit)  /* can't match if card < name */
          { 
            /* if there are no wild cards, lengths must be the same */
            if (!( !wild && cardlen != namelen) )
            {
              for (ii=0; ii < cardlen; ii++)
              {    
                /* make sure keyword is in uppercase */
                if (cardname[ii] > 96)
                {
                  /* This assumes the ASCII character set in which */
                  /* upper case characters start at ASCII(97)  */
                  /* Timing tests showed that this is 20% faster */
                  /* than calling the isupper function.          */

                  cardname[ii] = toupper(cardname[ii]);  /* make upper case */
                }
              }

              if (wild)
              {
                ffcmps(keyname, cardname, 1, &match, &exact);
                if (match)
                    return(*status); /* found a matching keyword */
              }
              else if (keyname[namelenminus1] == cardname[namelenminus1])
              {
                /* test the last character of the keyword name first, on */
                /* the theory that it is less likely to match then the first */
                /* character since many keywords begin with 'T', for example */

                if (FSTRNCMP(keyname, cardname, namelenminus1) == 0)
                {
                  return(*status);   /* found the matching keyword */
                }
              }
	      else if (namelen == 0 && cardlen == 0)
	      {
	         /* matched a blank keyword */
		 return(*status);
	      }
            }
          }
        }
      }

      if (wild || jj == 1)
            break;  /* stop at end of header if template contains wildcards */

      ffmaky(fptr, 1, status);  /* reset pointer to beginning of header */
      ntodo = nextkey - 1;      /* number of keyword to read */ 
    }

    return(*status = KEY_NO_EXIST);  /* couldn't find the keyword */
}
/*--------------------------------------------------------------------------*/
int ffgstr( fitsfile *fptr,     /* I - FITS file pointer        */
            const char *string, /* I - string to match  */
            char *card,         /* O - keyword card             */
            int  *status)       /* IO - error status            */
/*
  Read (get) the next keyword record that contains the input character string,
  returning the entire keyword card up to 80 characters long.
  The returned card value is null terminated with any trailing blank 
  characters removed.
*/
{
    int nkeys, nextkey, ntodo, stringlen;
    int jj, kk;

    if (*status > 0)
        return(*status);

    stringlen = strlen(string);
    if (stringlen > 80) {
        return(*status = KEY_NO_EXIST);  /* matching string is too long to exist */
    }

    ffghps(fptr, &nkeys, &nextkey, status); /* get no. keywords and position */
    ntodo = nkeys - nextkey + 1;  /* first, read from next keyword to end */

    for (jj=0; jj < 2; jj++)
    {
      for (kk = 0; kk < ntodo; kk++)
      {
        ffgnky(fptr, card, status);     /* get next keyword */
        if (strstr(card, string) != 0) {
            return(*status);   /* found the matching string */
        }
      }

      ffmaky(fptr, 1, status);  /* reset pointer to beginning of header */
      ntodo = nextkey - 1;      /* number of keyword to read */ 
    }

    return(*status = KEY_NO_EXIST);  /* couldn't find the keyword */
}
/*--------------------------------------------------------------------------*/
int ffgknm( char *card,         /* I - keyword card                   */
            char *name,         /* O - name of the keyword            */
            int *length,        /* O - length of the keyword name     */
            int  *status)       /* IO - error status                  */

/*
  Return the name of the keyword, and the name length.  This supports the
  ESO HIERARCH convention where keyword names may be > 8 characters long.
*/
{
    char *ptr1, *ptr2;
    int ii;

    *name = '\0';
    *length = 0;

    /* support for ESO HIERARCH keywords; find the '=' */
    if (FSTRNCMP(card, "HIERARCH ", 9) == 0)
    {
        ptr2 = strchr(card, '=');

        if (!ptr2)   /* no value indicator ??? */
        {
            /* this probably indicates an error, so just return FITS name */
            strcat(name, "HIERARCH");
            *length = 8;
            return(*status);
        }

        /* find the start and end of the HIERARCH name */
        ptr1 = &card[9];
        while (*ptr1 == ' ')   /* skip spaces */
            ptr1++;

        strncat(name, ptr1, ptr2 - ptr1);
        ii = ptr2 - ptr1;

        while (ii > 0 && name[ii - 1] == ' ')  /* remove trailing spaces */
            ii--;

        name[ii] = '\0';
        *length = ii;
    }
    else
    {
        for (ii = 0; ii < 8; ii++)
        {
           /* look for string terminator, or a blank */
           if (*(card+ii) != ' ' && *(card+ii) !='\0')
           {
               *(name+ii) = *(card+ii);
           }
           else
           {
               name[ii] = '\0';
               *length = ii;
               return(*status);
           }
        }

        /* if we got here, keyword is 8 characters long */
        name[8] = '\0';
        *length = 8;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgunt( fitsfile *fptr,     /* I - FITS file pointer         */
            const char *keyname,      /* I - name of keyword to read   */
            char *unit,         /* O - keyword units             */
            int  *status)       /* IO - error status             */
/*
    Read (get) the units string from the comment field of the existing
    keyword. This routine uses a local FITS convention (not defined in the
    official FITS standard) in which the units are enclosed in 
    square brackets following the '/' comment field delimiter, e.g.:

    KEYWORD =                   12 / [kpc] comment string goes here
*/
{
    char valstring[FLEN_VALUE];
    char comm[FLEN_COMMENT];
    char *loc;

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */

    if (comm[0] == '[')
    {
        loc = strchr(comm, ']');   /*  find the closing bracket */
        if (loc)
            *loc = '\0';           /*  terminate the string */

        strcpy(unit, &comm[1]);    /*  copy the string */
     }
     else
        unit[0] = '\0';
 
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkys( fitsfile *fptr,     /* I - FITS file pointer         */
            const char *keyname,      /* I - name of keyword to read   */
            char *value,        /* O - keyword value             */
            char *comm,         /* O - keyword comment           */
            int  *status)       /* IO - error status             */
/*
  Get KeYword with a String value:
  Read (get) a simple string valued keyword.  The returned value may be up to 
  68 chars long ( + 1 null terminator char).  The routine does not support the
  HEASARC convention for continuing long string values over multiple keywords.
  The ffgkls routine may be used to read long continued strings. The returned
  comment string may be up to 69 characters long (including null terminator).
*/
{
    char valstring[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */
    value[0] = '\0';
    ffc2s(valstring, value, status);   /* remove quotes from string */
 
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkls( fitsfile *fptr,     /* I - FITS file pointer         */
            const char *keyname,      /* I - name of keyword to read   */
            char **value,       /* O - pointer to keyword value  */
            char *comm,         /* O - keyword comment           */
            int  *status)       /* IO - error status             */
/*
  Get Keyword with possible Long String value:
  Read (get) the named keyword, returning the value and comment.
  The returned value string may be arbitrarily long (by using the HEASARC
  convention for continuing long string values over multiple keywords) so
  this routine allocates the required memory for the returned string value.
  It is up to the calling routine to free the memory once it is finished
  with the value string.  The returned comment string may be up to 69
  characters long.
*/
{
    char valstring[FLEN_VALUE];
    int contin;
    size_t len;

    if (*status > 0)
        return(*status);

    *value = NULL;  /* initialize a null pointer in case of error */

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */

    if (*status > 0)
        return(*status);

    if (!valstring[0])   /* null value string? */
    {
      *value = (char *) malloc(1);  /* allocate and return a null string */
      **value = '\0';
    }
    else
    {
      /* allocate space,  plus 1 for null */
      *value = (char *) malloc(strlen(valstring) + 1);

      ffc2s(valstring, *value, status);   /* convert string to value */
      len = strlen(*value);

      /* If last character is a & then value may be continued on next keyword */
      contin = 1;
      while (contin)  
      {
        if (len && *(*value+len-1) == '&')  /*  is last char an anpersand?  */
        {
            ffgcnt(fptr, valstring, status);
            if (*valstring)    /* a null valstring indicates no continuation */
            {
               *(*value+len-1) = '\0';         /* erase the trailing & char */
               len += strlen(valstring) - 1;
               *value = (char *) realloc(*value, len + 1); /* increase size */
               strcat(*value, valstring);     /* append the continued chars */
            }
            else
                contin = 0;
        }
        else
            contin = 0;
      }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fffree( void *value,       /* I - pointer to keyword value  */
            int  *status)      /* IO - error status             */
/*
  Free the memory that was previously allocated by CFITSIO, 
  such as by ffgkls or fits_hdr2str
*/
{
    if (*status > 0)
        return(*status);

    if (value)
        free(value);

    return(*status);
}
 /*--------------------------------------------------------------------------*/
int ffgcnt( fitsfile *fptr,     /* I - FITS file pointer         */
            char *value,        /* O - continued string value    */
            int  *status)       /* IO - error status             */
/*
  Attempt to read the next keyword, returning the string value
  if it is a continuation of the previous string keyword value.
  This uses the HEASARC convention for continuing long string values
  over multiple keywords.  Each continued string is terminated with a
  backslash character, and the continuation follows on the next keyword
  which must have the name CONTINUE without an equal sign in column 9
  of the card.  If the next card is not a continuation, then the returned
  value string will be null.
*/
{
    int tstatus;
    char card[FLEN_CARD], strval[FLEN_VALUE], comm[FLEN_COMMENT];

    if (*status > 0)
        return(*status);

    tstatus = 0;
    value[0] = '\0';

    if (ffgnky(fptr, card, &tstatus) > 0)  /*  read next keyword  */
        return(*status);                   /*  hit end of header  */

    if (strncmp(card, "CONTINUE  ", 10) == 0)  /* a continuation card? */
    {
        strncpy(card, "D2345678=  ", 10); /* overwrite a dummy keyword name */
        ffpsvc(card, strval, comm, &tstatus);  /*  get the string value  */
        ffc2s(strval, value, &tstatus);    /* remove the surrounding quotes */

        if (tstatus)       /*  return null if error status was returned  */
           value[0] = '\0';
    }
    else
        ffmrky(fptr, -1, status);  /* reset the keyword pointer */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkyl( fitsfile *fptr,     /* I - FITS file pointer         */
            const char *keyname,      /* I - name of keyword to read   */
            int  *value,        /* O - keyword value             */
            char *comm,         /* O - keyword comment           */
            int  *status)       /* IO - error status             */
/*
  Read (get) the named keyword, returning the value and comment.
  The returned value = 1 if the keyword is true, else = 0 if false.
  The comment may be up to 69 characters long.
*/
{
    char valstring[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */
    ffc2l(valstring, value, status);   /* convert string to value */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkyj( fitsfile *fptr,     /* I - FITS file pointer         */
            const char *keyname,      /* I - name of keyword to read   */
            long *value,        /* O - keyword value             */
            char *comm,         /* O - keyword comment           */
            int  *status)       /* IO - error status             */
/*
  Read (get) the named keyword, returning the value and comment.
  The value will be implicitly converted to a (long) integer if it not
  already of this datatype.  The comment may be up to 69 characters long.
*/
{
    char valstring[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */
    ffc2i(valstring, value, status);   /* convert string to value */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkyjj( fitsfile *fptr,     /* I - FITS file pointer         */
            const char *keyname,      /* I - name of keyword to read   */
            LONGLONG *value,    /* O - keyword value             */
            char *comm,         /* O - keyword comment           */
            int  *status)       /* IO - error status             */
/*
  Read (get) the named keyword, returning the value and comment.
  The value will be implicitly converted to a (long) integer if it not
  already of this datatype.  The comment may be up to 69 characters long.
*/
{
    char valstring[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */
    ffc2j(valstring, value, status);   /* convert string to value */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkye( fitsfile *fptr,     /* I - FITS file pointer         */
            const char  *keyname,     /* I - name of keyword to read   */
            float *value,       /* O - keyword value             */
            char  *comm,        /* O - keyword comment           */
            int   *status)      /* IO - error status             */
/*
  Read (get) the named keyword, returning the value and comment.
  The value will be implicitly converted to a float if it not
  already of this datatype.  The comment may be up to 69 characters long.
*/
{
    char valstring[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */
    ffc2r(valstring, value, status);   /* convert string to value */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkyd( fitsfile *fptr,      /* I - FITS file pointer         */
            const char   *keyname,     /* I - name of keyword to read   */
            double *value,       /* O - keyword value             */
            char   *comm,        /* O - keyword comment           */
            int    *status)      /* IO - error status             */
/*
  Read (get) the named keyword, returning the value and comment.
  The value will be implicitly converted to a double if it not
  already of this datatype.  The comment may be up to 69 characters long.
*/
{
    char valstring[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */
    ffc2d(valstring, value, status);   /* convert string to value */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkyc( fitsfile *fptr,     /* I - FITS file pointer         */
            const char  *keyname,     /* I - name of keyword to read   */
            float *value,       /* O - keyword value (real,imag) */
            char  *comm,        /* O - keyword comment           */
            int   *status)      /* IO - error status             */
/*
  Read (get) the named keyword, returning the value and comment.
  The keyword must have a complex value. No implicit data conversion
  will be performed.
*/
{
    char valstring[FLEN_VALUE], message[81];
    int len;

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */

    if (valstring[0] != '(' )   /* test that this is a complex keyword */
    {
      sprintf(message, "keyword %s does not have a complex value (ffgkyc):",
              keyname);
      ffpmsg(message);
      ffpmsg(valstring);
      return(*status = BAD_C2F);
    }

    valstring[0] = ' ';            /* delete the opening parenthesis */
    len = strcspn(valstring, ")" );  
    valstring[len] = '\0';         /* delete the closing parenthesis */

    len = strcspn(valstring, ",");
    valstring[len] = '\0';

    ffc2r(valstring, &value[0], status);       /* convert the real part */
    ffc2r(&valstring[len + 1], &value[1], status); /* convert imag. part */
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkym( fitsfile *fptr,     /* I - FITS file pointer         */
            const char  *keyname,     /* I - name of keyword to read   */
            double *value,      /* O - keyword value (real,imag) */
            char  *comm,        /* O - keyword comment           */
            int   *status)      /* IO - error status             */
/*
  Read (get) the named keyword, returning the value and comment.
  The keyword must have a complex value. No implicit data conversion
  will be performed.
*/
{
    char valstring[FLEN_VALUE], message[81];
    int len;

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */

    if (valstring[0] != '(' )   /* test that this is a complex keyword */
    {
      sprintf(message, "keyword %s does not have a complex value (ffgkym):",
              keyname);
      ffpmsg(message);
      ffpmsg(valstring);
      return(*status = BAD_C2D);
    }

    valstring[0] = ' ';            /* delete the opening parenthesis */
    len = strcspn(valstring, ")" );  
    valstring[len] = '\0';         /* delete the closing parenthesis */

    len = strcspn(valstring, ",");
    valstring[len] = '\0';

    ffc2d(valstring, &value[0], status);        /* convert the real part */
    ffc2d(&valstring[len + 1], &value[1], status);  /* convert the imag. part */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkyt( fitsfile *fptr,      /* I - FITS file pointer                 */
            const char   *keyname,     /* I - name of keyword to read           */
            long   *ivalue,      /* O - integer part of keyword value     */
            double *fraction,    /* O - fractional part of keyword value  */
            char   *comm,        /* O - keyword comment                   */
            int    *status)      /* IO - error status                     */
/*
  Read (get) the named keyword, returning the value and comment.
  The integer and fractional parts of the value are returned in separate
  variables, to allow more numerical precision to be passed.  This
  effectively passes a 'triple' precision value, with a 4-byte integer
  and an 8-byte fraction.  The comment may be up to 69 characters long.
*/
{
    char valstring[FLEN_VALUE];
    char *loc;

    if (*status > 0)
        return(*status);

    ffgkey(fptr, keyname, valstring, comm, status);  /* read the keyword */

    /*  read the entire value string as a double, to get the integer part */
    ffc2d(valstring, fraction, status);

    *ivalue = (long) *fraction;

    *fraction = *fraction - *ivalue;

    /* see if we need to read the fractional part again with more precision */
    /* look for decimal point, without an exponential E or D character */

    loc = strchr(valstring, '.');
    if (loc)
    {
        if (!strchr(valstring, 'E') && !strchr(valstring, 'D'))
            ffc2d(loc, fraction, status);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkyn( fitsfile *fptr,      /* I - FITS file pointer             */
            int    nkey,         /* I - number of the keyword to read */
            char   *keyname,     /* O - name of the keyword           */
            char   *value,       /* O - keyword value                 */
            char   *comm,        /* O - keyword comment               */
            int    *status)      /* IO - error status                 */
/*
  Read (get) the nkey-th keyword returning the keyword name, value and comment.
  The value is just the literal string of characters in the value field
  of the keyword.  In the case of a string valued keyword, the returned
  value includes the leading and closing quote characters.  The value may be
  up to 70 characters long, and the comment may be up to 72 characters long.
  If the keyword has no value (no equal sign in column 9) then a null value
  is returned.  If comm = NULL, then do not return the comment string.
*/
{
    char card[FLEN_CARD], sbuff[FLEN_CARD];
    int namelen;

    keyname[0] = '\0';
    value[0] = '\0';
    if (comm)
        comm[0] = '\0';

    if (*status > 0)
        return(*status);

    if (ffgrec(fptr, nkey, card, status) > 0 )  /* get the 80-byte card */
        return(*status);

    ffgknm(card, keyname, &namelen, status); /* get the keyword name */

    if (ffpsvc(card, value, comm, status) > 0)   /* parse value and comment */
        return(*status);

    if (fftrec(keyname, status) > 0)  /* test keyword name; catches no END */
    {
     sprintf(sbuff,"Name of keyword no. %d contains illegal character(s): %s",
              nkey, keyname);
     ffpmsg(sbuff);

     if (nkey % 36 == 0)  /* test if at beginning of 36-card FITS record */
            ffpmsg("  (This may indicate a missing END keyword).");
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkns( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyname,      /* I - root name of keywords to read        */
            int  nstart,        /* I - starting index number                */
            int  nmax,          /* I - maximum number of keywords to return */
            char *value[],      /* O - array of pointers to keyword values  */
            int  *nfound,       /* O - number of values that were returned  */
            int  *status)       /* IO - error status                        */
/*
  Read (get) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NMAX -1) inclusive.  
  This routine does NOT support the HEASARC long string convention.
*/
{
    int nend, lenroot, ii, nkeys, mkeys, tstatus, undefinedval;
    long ival;
    char keyroot[FLEN_KEYWORD], keyindex[8], card[FLEN_CARD];
    char svalue[FLEN_VALUE], comm[FLEN_COMMENT];

    if (*status > 0)
        return(*status);

    *nfound = 0;
    nend = nstart + nmax - 1;

    keyroot[0] = '\0';
    strncat(keyroot, keyname, 8);
     
    lenroot = strlen(keyroot);
    if (lenroot == 0 || lenroot > 7)     /*  root must be 1 - 7 chars long  */
        return(*status);

    for (ii=0; ii < lenroot; ii++)           /*  make sure upper case  */
        keyroot[ii] = toupper(keyroot[ii]);

    ffghps(fptr, &nkeys, &mkeys, status);  /*  get the number of keywords  */

    undefinedval = FALSE;
    for (ii=3; ii <= nkeys; ii++)  
    {
       if (ffgrec(fptr, ii, card, status) > 0)     /*  get next keyword  */
           return(*status);

       if (strncmp(keyroot, card, lenroot) == 0)  /* see if keyword matches */
       {
          keyindex[0] = '\0';
          strncat(keyindex, &card[lenroot], 8-lenroot);  /*  copy suffix */

          tstatus = 0;
          if (ffc2ii(keyindex, &ival, &tstatus) <= 0)     /*  test suffix  */
          {
             if (ival <= nend && ival >= nstart)
             {
                ffpsvc(card, svalue, comm, status);  /*  parse the value */
                ffc2s(svalue, value[ival-nstart], status); /* convert */
                if (ival - nstart + 1 > *nfound)
                      *nfound = ival - nstart + 1;  /*  max found */ 

                if (*status == VALUE_UNDEFINED)
                {
                   undefinedval = TRUE;
                   *status = 0;  /* reset status to read remaining values */
                }
             }
          }
       }
    }
    if (undefinedval && (*status <= 0) )
        *status = VALUE_UNDEFINED;  /* report at least 1 value undefined */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgknl( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyname,      /* I - root name of keywords to read        */
            int  nstart,        /* I - starting index number                */
            int  nmax,          /* I - maximum number of keywords to return */
            int  *value,        /* O - array of keyword values              */
            int  *nfound,       /* O - number of values that were returned  */
            int  *status)       /* IO - error status                        */
/*
  Read (get) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NMAX -1) inclusive.  
  The returned value = 1 if the keyword is true, else = 0 if false.
*/
{
    int nend, lenroot, ii, nkeys, mkeys, tstatus, undefinedval;
    long ival;
    char keyroot[FLEN_KEYWORD], keyindex[8], card[FLEN_CARD];
    char svalue[FLEN_VALUE], comm[FLEN_COMMENT];

    if (*status > 0)
        return(*status);

    *nfound = 0;
    nend = nstart + nmax - 1;

    keyroot[0] = '\0';
    strncat(keyroot, keyname, 8);

    lenroot = strlen(keyroot);
    if (lenroot == 0 || lenroot > 7)     /*  root must be 1 - 7 chars long  */
        return(*status);

    for (ii=0; ii < lenroot; ii++)           /*  make sure upper case  */
        keyroot[ii] = toupper(keyroot[ii]);

    ffghps(fptr, &nkeys, &mkeys, status);  /*  get the number of keywords  */

    ffmaky(fptr, 3, status);  /* move to 3rd keyword (skip 1st 2 keywords) */

    undefinedval = FALSE;
    for (ii=3; ii <= nkeys; ii++)  
    {
       if (ffgnky(fptr, card, status) > 0)     /*  get next keyword  */
           return(*status);

       if (strncmp(keyroot, card, lenroot) == 0)  /* see if keyword matches */
       {
          keyindex[0] = '\0';
          strncat(keyindex, &card[lenroot], 8-lenroot);  /*  copy suffix */

          tstatus = 0;
          if (ffc2ii(keyindex, &ival, &tstatus) <= 0)    /*  test suffix  */
          {
             if (ival <= nend && ival >= nstart)
             {
                ffpsvc(card, svalue, comm, status);   /*  parse the value */
                ffc2l(svalue, &value[ival-nstart], status); /* convert*/
                if (ival - nstart + 1 > *nfound)
                      *nfound = ival - nstart + 1;  /*  max found */ 

                if (*status == VALUE_UNDEFINED)
                {
                    undefinedval = TRUE;
                   *status = 0;  /* reset status to read remaining values */
                }
             }
          }
       }
    }
    if (undefinedval && (*status <= 0) )
        *status = VALUE_UNDEFINED;  /* report at least 1 value undefined */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgknj( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyname,      /* I - root name of keywords to read        */
            int  nstart,        /* I - starting index number                */
            int  nmax,          /* I - maximum number of keywords to return */
            long *value,        /* O - array of keyword values              */
            int  *nfound,       /* O - number of values that were returned  */
            int  *status)       /* IO - error status                        */
/*
  Read (get) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NMAX -1) inclusive.  
*/
{
    int nend, lenroot, ii, nkeys, mkeys, tstatus, undefinedval;
    long ival;
    char keyroot[FLEN_KEYWORD], keyindex[8], card[FLEN_CARD];
    char svalue[FLEN_VALUE], comm[FLEN_COMMENT];

    if (*status > 0)
        return(*status);

    *nfound = 0;
    nend = nstart + nmax - 1;

    keyroot[0] = '\0';
    strncat(keyroot, keyname, 8);

    lenroot = strlen(keyroot);
    if (lenroot == 0 || lenroot > 7)     /* root must be 1 - 7 chars long */
        return(*status);

    for (ii=0; ii < lenroot; ii++)           /*  make sure upper case  */
        keyroot[ii] = toupper(keyroot[ii]);

    ffghps(fptr, &nkeys, &mkeys, status);  /*  get the number of keywords  */

    ffmaky(fptr, 3, status);  /* move to 3rd keyword (skip 1st 2 keywords) */

    undefinedval = FALSE;
    for (ii=3; ii <= nkeys; ii++)  
    {
       if (ffgnky(fptr, card, status) > 0)     /*  get next keyword  */
           return(*status);

       if (strncmp(keyroot, card, lenroot) == 0)  /* see if keyword matches */
       {
          keyindex[0] = '\0';
          strncat(keyindex, &card[lenroot], 8-lenroot);  /*  copy suffix */

          tstatus = 0;
          if (ffc2ii(keyindex, &ival, &tstatus) <= 0)     /*  test suffix  */
          {
             if (ival <= nend && ival >= nstart)
             {
                ffpsvc(card, svalue, comm, status);   /*  parse the value */
                ffc2i(svalue, &value[ival-nstart], status);  /* convert */
                if (ival - nstart + 1 > *nfound)
                      *nfound = ival - nstart + 1;  /*  max found */ 

                if (*status == VALUE_UNDEFINED)
                {
                    undefinedval = TRUE;
                   *status = 0;  /* reset status to read remaining values */
                }
             }
          }
       }
    }
    if (undefinedval && (*status <= 0) )
        *status = VALUE_UNDEFINED;  /* report at least 1 value undefined */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgknjj( fitsfile *fptr,    /* I - FITS file pointer                    */
            const char *keyname,      /* I - root name of keywords to read        */
            int  nstart,        /* I - starting index number                */
            int  nmax,          /* I - maximum number of keywords to return */
            LONGLONG *value,    /* O - array of keyword values              */
            int  *nfound,       /* O - number of values that were returned  */
            int  *status)       /* IO - error status                        */
/*
  Read (get) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NMAX -1) inclusive.  
*/
{
    int nend, lenroot, ii, nkeys, mkeys, tstatus, undefinedval;
    long ival;
    char keyroot[FLEN_KEYWORD], keyindex[8], card[FLEN_CARD];
    char svalue[FLEN_VALUE], comm[FLEN_COMMENT];

    if (*status > 0)
        return(*status);

    *nfound = 0;
    nend = nstart + nmax - 1;

    keyroot[0] = '\0';
    strncat(keyroot, keyname, 8);

    lenroot = strlen(keyroot);
    if (lenroot == 0 || lenroot > 7)     /* root must be 1 - 7 chars long */
        return(*status);

    for (ii=0; ii < lenroot; ii++)           /*  make sure upper case  */
        keyroot[ii] = toupper(keyroot[ii]);

    ffghps(fptr, &nkeys, &mkeys, status);  /*  get the number of keywords  */

    ffmaky(fptr, 3, status);  /* move to 3rd keyword (skip 1st 2 keywords) */

    undefinedval = FALSE;
    for (ii=3; ii <= nkeys; ii++)  
    {
       if (ffgnky(fptr, card, status) > 0)     /*  get next keyword  */
           return(*status);

       if (strncmp(keyroot, card, lenroot) == 0)  /* see if keyword matches */
       {
          keyindex[0] = '\0';
          strncat(keyindex, &card[lenroot], 8-lenroot);  /*  copy suffix */

          tstatus = 0;
          if (ffc2ii(keyindex, &ival, &tstatus) <= 0)     /*  test suffix  */
          {
             if (ival <= nend && ival >= nstart)
             {
                ffpsvc(card, svalue, comm, status);   /*  parse the value */
                ffc2j(svalue, &value[ival-nstart], status);  /* convert */
                if (ival - nstart + 1 > *nfound)
                      *nfound = ival - nstart + 1;  /*  max found */ 

                if (*status == VALUE_UNDEFINED)
                {
                    undefinedval = TRUE;
                   *status = 0;  /* reset status to read remaining values */
                }
             }
          }
       }
    }
    if (undefinedval && (*status <= 0) )
        *status = VALUE_UNDEFINED;  /* report at least 1 value undefined */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgkne( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyname,      /* I - root name of keywords to read        */
            int  nstart,        /* I - starting index number                */
            int  nmax,          /* I - maximum number of keywords to return */
            float *value,       /* O - array of keyword values              */
            int  *nfound,       /* O - number of values that were returned  */
            int  *status)       /* IO - error status                        */
/*
  Read (get) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NMAX -1) inclusive.  
*/
{
    int nend, lenroot, ii, nkeys, mkeys, tstatus, undefinedval;
    long ival;
    char keyroot[FLEN_KEYWORD], keyindex[8], card[FLEN_CARD];
    char svalue[FLEN_VALUE], comm[FLEN_COMMENT];

    if (*status > 0)
        return(*status);

    *nfound = 0;
    nend = nstart + nmax - 1;

    keyroot[0] = '\0';
    strncat(keyroot, keyname, 8);

    lenroot = strlen(keyroot);
    if (lenroot == 0 || lenroot > 7)     /*  root must be 1 - 7 chars long  */
        return(*status);

    for (ii=0; ii < lenroot; ii++)           /*  make sure upper case  */
        keyroot[ii] = toupper(keyroot[ii]);

    ffghps(fptr, &nkeys, &mkeys, status);  /*  get the number of keywords  */

    ffmaky(fptr, 3, status);  /* move to 3rd keyword (skip 1st 2 keywords) */

    undefinedval = FALSE;
    for (ii=3; ii <= nkeys; ii++)  
    {
       if (ffgnky(fptr, card, status) > 0)     /*  get next keyword  */
           return(*status);

       if (strncmp(keyroot, card, lenroot) == 0)  /* see if keyword matches */
       {
          keyindex[0] = '\0';
          strncat(keyindex, &card[lenroot], 8-lenroot);  /*  copy suffix */

          tstatus = 0;
          if (ffc2ii(keyindex, &ival, &tstatus) <= 0)     /*  test suffix  */
          {
             if (ival <= nend && ival >= nstart)
             {
                ffpsvc(card, svalue, comm, status);   /*  parse the value */
                ffc2r(svalue, &value[ival-nstart], status); /* convert */
                if (ival - nstart + 1 > *nfound)
                      *nfound = ival - nstart + 1;  /*  max found */ 

                if (*status == VALUE_UNDEFINED)
                {
                    undefinedval = TRUE;
                   *status = 0;  /* reset status to read remaining values */
                }
             }
          }
       }
    }
    if (undefinedval && (*status <= 0) )
        *status = VALUE_UNDEFINED;  /* report at least 1 value undefined */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgknd( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyname,      /* I - root name of keywords to read        */
            int  nstart,        /* I - starting index number                */
            int  nmax,          /* I - maximum number of keywords to return */
            double *value,      /* O - array of keyword values              */
            int  *nfound,       /* O - number of values that were returned  */
            int  *status)       /* IO - error status                        */
/*
  Read (get) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NMAX -1) inclusive.  
*/
{
    int nend, lenroot, ii, nkeys, mkeys, tstatus, undefinedval;
    long ival;
    char keyroot[FLEN_KEYWORD], keyindex[8], card[FLEN_CARD];
    char svalue[FLEN_VALUE], comm[FLEN_COMMENT];

    if (*status > 0)
        return(*status);

    *nfound = 0;
    nend = nstart + nmax - 1;

    keyroot[0] = '\0';
    strncat(keyroot, keyname, 8);

    lenroot = strlen(keyroot);
    if (lenroot == 0 || lenroot > 7)     /*  root must be 1 - 7 chars long  */
        return(*status);

    for (ii=0; ii < lenroot; ii++)           /*  make sure upper case  */
        keyroot[ii] = toupper(keyroot[ii]);

    ffghps(fptr, &nkeys, &mkeys, status);  /*  get the number of keywords  */

    ffmaky(fptr, 3, status);  /* move to 3rd keyword (skip 1st 2 keywords) */

    undefinedval = FALSE;
    for (ii=3; ii <= nkeys; ii++)  
    {
       if (ffgnky(fptr, card, status) > 0)     /*  get next keyword  */
           return(*status);

       if (strncmp(keyroot, card, lenroot) == 0)   /* see if keyword matches */
       {
          keyindex[0] = '\0';
          strncat(keyindex, &card[lenroot], 8-lenroot);  /*  copy suffix */

          tstatus = 0;
          if (ffc2ii(keyindex, &ival, &tstatus) <= 0)      /*  test suffix */
          {
             if (ival <= nend && ival >= nstart) /* is index within range? */
             {
                ffpsvc(card, svalue, comm, status);   /*  parse the value */
                ffc2d(svalue, &value[ival-nstart], status); /* convert */
                if (ival - nstart + 1 > *nfound)
                      *nfound = ival - nstart + 1;  /*  max found */ 

                if (*status == VALUE_UNDEFINED)
                {
                    undefinedval = TRUE;
                   *status = 0;  /* reset status to read remaining values */
                }
             }
          }
       }
    }
    if (undefinedval && (*status <= 0) )
        *status = VALUE_UNDEFINED;  /* report at least 1 value undefined */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgtdm(fitsfile *fptr,  /* I - FITS file pointer                        */
           int colnum,      /* I - number of the column to read             */
           int maxdim,      /* I - maximum no. of dimensions to read;       */
           int *naxis,      /* O - number of axes in the data array         */
           long naxes[],    /* O - length of each data axis                 */
           int *status)     /* IO - error status                            */
/*
  read and parse the TDIMnnn keyword to get the dimensionality of a column
*/
{
    int tstatus = 0;
    char keyname[FLEN_KEYWORD], tdimstr[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    ffkeyn("TDIM", colnum, keyname, status);      /* construct keyword name */

    ffgkys(fptr, keyname, tdimstr, NULL, &tstatus); /* try reading keyword */

    ffdtdm(fptr, tdimstr, colnum, maxdim,naxis, naxes, status); /* decode it */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgtdmll(fitsfile *fptr,  /* I - FITS file pointer                      */
           int colnum,      /* I - number of the column to read             */
           int maxdim,      /* I - maximum no. of dimensions to read;       */
           int *naxis,      /* O - number of axes in the data array         */
           LONGLONG naxes[], /* O - length of each data axis                 */
           int *status)     /* IO - error status                            */
/*
  read and parse the TDIMnnn keyword to get the dimensionality of a column
*/
{
    int tstatus = 0;
    char keyname[FLEN_KEYWORD], tdimstr[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    ffkeyn("TDIM", colnum, keyname, status);      /* construct keyword name */

    ffgkys(fptr, keyname, tdimstr, NULL, &tstatus); /* try reading keyword */

    ffdtdmll(fptr, tdimstr, colnum, maxdim,naxis, naxes, status); /* decode it */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffdtdm(fitsfile *fptr,  /* I - FITS file pointer                        */
           char *tdimstr,   /* I - TDIMn keyword value string. e.g. (10,10) */
           int colnum,      /* I - number of the column             */
           int maxdim,      /* I - maximum no. of dimensions to read;       */
           int *naxis,      /* O - number of axes in the data array         */
           long naxes[],    /* O - length of each data axis                 */
           int *status)     /* IO - error status                            */
/*
  decode the TDIMnnn keyword to get the dimensionality of a column.
  Check that the value is legal and consistent with the TFORM value.
  If colnum = 0, then the validity checking is disabled.
*/
{
    long dimsize, totalpix = 1;
    char *loc, *lastloc, message[81];
    tcolumn *colptr = 0;

    if (*status > 0)
        return(*status);

    if (colnum != 0) {
        if (fptr->HDUposition != (fptr->Fptr)->curhdu)
            ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

        if (colnum < 1 || colnum > (fptr->Fptr)->tfield)
            return(*status = BAD_COL_NUM);

        colptr = (fptr->Fptr)->tableptr;   /* set pointer to the first column */
        colptr += (colnum - 1);    /* increment to the correct column */

        if (!tdimstr[0])   /* TDIMn keyword doesn't exist? */
        {
            *naxis = 1;                   /* default = 1 dimensional */
            if (maxdim > 0)
                naxes[0] = (long) colptr->trepeat; /* default length = repeat */

            return(*status);
        }
    }

    *naxis = 0;

    loc = strchr(tdimstr, '(' );  /* find the opening quote */
    if (!loc)
    {
            sprintf(message, "Illegal dimensions format: %s", tdimstr);
            return(*status = BAD_TDIM);
    }

    while (loc)
    {
            loc++;
            dimsize = strtol(loc, &loc, 10);  /* read size of next dimension */
            if (*naxis < maxdim)
                naxes[*naxis] = dimsize;

            if (dimsize < 0)
            {
                ffpmsg("one or more dimension are less than 0 (ffdtdm)");
                ffpmsg(tdimstr);
                return(*status = BAD_TDIM);
            }

            totalpix *= dimsize;
            (*naxis)++;
            lastloc = loc;
            loc = strchr(loc, ',');  /* look for comma before next dimension */
    }

    loc = strchr(lastloc, ')' );  /* check for the closing quote */
    if (!loc)
    {
            sprintf(message, "Illegal dimensions format: %s", tdimstr);
            return(*status = BAD_TDIM);
    }

    if (colnum != 0) {
        if ((colptr->tdatatype > 0) && ((long) colptr->trepeat != totalpix))
        {
          sprintf(message,
          "column vector length, %ld, does not equal TDIMn array size, %ld",
          (long) colptr->trepeat, totalpix);
          ffpmsg(message);
          ffpmsg(tdimstr);
          return(*status = BAD_TDIM);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffdtdmll(fitsfile *fptr,  /* I - FITS file pointer                        */
           char *tdimstr,   /* I - TDIMn keyword value string. e.g. (10,10) */
           int colnum,      /* I - number of the column             */
           int maxdim,      /* I - maximum no. of dimensions to read;       */
           int *naxis,      /* O - number of axes in the data array         */
           LONGLONG naxes[],    /* O - length of each data axis                 */
           int *status)     /* IO - error status                            */
/*
  decode the TDIMnnn keyword to get the dimensionality of a column.
  Check that the value is legal and consistent with the TFORM value.
*/
{
    LONGLONG dimsize;
    LONGLONG totalpix = 1;
    char *loc, *lastloc, message[81];
    tcolumn *colptr;
    double doublesize;

    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if (colnum < 1 || colnum > (fptr->Fptr)->tfield)
        return(*status = BAD_COL_NUM);

    colptr = (fptr->Fptr)->tableptr;   /* set pointer to the first column */
    colptr += (colnum - 1);    /* increment to the correct column */

    if (!tdimstr[0])   /* TDIMn keyword doesn't exist? */
    {
        *naxis = 1;                   /* default = 1 dimensional */
        if (maxdim > 0)
            naxes[0] = colptr->trepeat; /* default length = repeat */
    }
    else
    {
        *naxis = 0;

        loc = strchr(tdimstr, '(' );  /* find the opening quote */
        if (!loc)
        {
            sprintf(message, "Illegal TDIM keyword value: %s", tdimstr);
            return(*status = BAD_TDIM);
        }

        while (loc)
        {
            loc++;

    /* Read value as a double because the string to 64-bit int function is  */
    /* platform dependent (strtoll, strtol, _atoI64).  This still gives     */
    /* about 48 bits of precision, which is plenty for this purpose.        */

            doublesize = strtod(loc, &loc);
            dimsize = (LONGLONG) (doublesize + 0.1);

            if (*naxis < maxdim)
                naxes[*naxis] = dimsize;

            if (dimsize < 0)
            {
                ffpmsg("one or more TDIM values are less than 0 (ffdtdm)");
                ffpmsg(tdimstr);
                return(*status = BAD_TDIM);
            }

            totalpix *= dimsize;
            (*naxis)++;
            lastloc = loc;
            loc = strchr(loc, ',');  /* look for comma before next dimension */
        }

        loc = strchr(lastloc, ')' );  /* check for the closing quote */
        if (!loc)
        {
            sprintf(message, "Illegal TDIM keyword value: %s", tdimstr);
            return(*status = BAD_TDIM);
        }

        if ((colptr->tdatatype > 0) && (colptr->trepeat != totalpix))
        {
          sprintf(message,
          "column vector length, %.0f, does not equal TDIMn array size, %.0f",
          (double) (colptr->trepeat), (double) totalpix);
          ffpmsg(message);
          ffpmsg(tdimstr);
          return(*status = BAD_TDIM);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffghpr(fitsfile *fptr,  /* I - FITS file pointer                        */
           int maxdim,      /* I - maximum no. of dimensions to read;       */
           int *simple,     /* O - does file conform to FITS standard? 1/0  */
           int *bitpix,     /* O - number of bits per data value pixel      */
           int *naxis,      /* O - number of axes in the data array         */
           long naxes[],    /* O - length of each data axis                 */
           long *pcount,    /* O - number of group parameters (usually 0)   */
           long *gcount,    /* O - number of random groups (usually 1 or 0) */
           int *extend,     /* O - may FITS file haave extensions?          */
           int *status)     /* IO - error status                            */
/*
  Get keywords from the Header of the PRimary array:
  Check that the keywords conform to the FITS standard and return the
  parameters which determine the size and structure of the primary array
  or IMAGE extension.
*/
{
    int idummy, ii;
    LONGLONG lldummy;
    double ddummy;
    LONGLONG tnaxes[99];

    ffgphd(fptr, maxdim, simple, bitpix, naxis, tnaxes, pcount, gcount, extend,
          &ddummy, &ddummy, &lldummy, &idummy, status);
	  
    if (naxis && naxes) {
         for (ii = 0; (ii < *naxis) && (ii < maxdim); ii++)
	     naxes[ii] = (long) tnaxes[ii];
    } else if (naxes) {
         for (ii = 0; ii < maxdim; ii++)
	     naxes[ii] = (long) tnaxes[ii];
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffghprll(fitsfile *fptr,  /* I - FITS file pointer                        */
           int maxdim,      /* I - maximum no. of dimensions to read;       */
           int *simple,     /* O - does file conform to FITS standard? 1/0  */
           int *bitpix,     /* O - number of bits per data value pixel      */
           int *naxis,      /* O - number of axes in the data array         */
           LONGLONG naxes[],    /* O - length of each data axis                 */
           long *pcount,    /* O - number of group parameters (usually 0)   */
           long *gcount,    /* O - number of random groups (usually 1 or 0) */
           int *extend,     /* O - may FITS file haave extensions?          */
           int *status)     /* IO - error status                            */
/*
  Get keywords from the Header of the PRimary array:
  Check that the keywords conform to the FITS standard and return the
  parameters which determine the size and structure of the primary array
  or IMAGE extension.
*/
{
    int idummy;
    LONGLONG lldummy;
    double ddummy;

    ffgphd(fptr, maxdim, simple, bitpix, naxis, naxes, pcount, gcount, extend,
          &ddummy, &ddummy, &lldummy, &idummy, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffghtb(fitsfile *fptr,  /* I - FITS file pointer                        */
           int maxfield,    /* I - maximum no. of columns to read;          */
           long *naxis1,    /* O - length of table row in bytes             */
           long *naxis2,    /* O - number of rows in the table              */
           int *tfields,    /* O - number of columns in the table           */
           char **ttype,    /* O - name of each column                      */
           long *tbcol,     /* O - byte offset in row to each column        */
           char **tform,    /* O - value of TFORMn keyword for each column  */
           char **tunit,    /* O - value of TUNITn keyword for each column  */
           char *extnm,   /* O - value of EXTNAME keyword, if any         */
           int *status)     /* IO - error status                            */
/*
  Get keywords from the Header of the ASCII TaBle:
  Check that the keywords conform to the FITS standard and return the
  parameters which describe the table.
*/
{
    int ii, maxf, nfound, tstatus;
    long fields;
    char name[FLEN_KEYWORD], value[FLEN_VALUE], comm[FLEN_COMMENT];
    char xtension[FLEN_VALUE], message[81];
    LONGLONG llnaxis1, llnaxis2, pcount;

    if (*status > 0)
        return(*status);

    /* read the first keyword of the extension */
    ffgkyn(fptr, 1, name, value, comm, status);

    if (!strcmp(name, "XTENSION"))
    {
            if (ffc2s(value, xtension, status) > 0)  /* get the value string */
            {
                ffpmsg("Bad value string for XTENSION keyword:");
                ffpmsg(value);
                return(*status);
            }

            /* allow the quoted string value to begin in any column and */
            /* allow any number of trailing blanks before the closing quote */
            if ( (value[0] != '\'')   ||  /* first char must be a quote */
                 ( strcmp(xtension, "TABLE") ) )
            {
                sprintf(message,
                "This is not a TABLE extension: %s", value);
                ffpmsg(message);
                return(*status = NOT_ATABLE);
            }
    }

    else  /* error: 1st keyword of extension != XTENSION */
    {
        sprintf(message,
        "First keyword of the extension is not XTENSION: %s", name);
        ffpmsg(message);
        return(*status = NO_XTENSION);
    }

    if (ffgttb(fptr, &llnaxis1, &llnaxis2, &pcount, &fields, status) > 0)
        return(*status);

    if (naxis1)
       *naxis1 = (long) llnaxis1;

    if (naxis2)
       *naxis2 = (long) llnaxis2;

    if (pcount != 0)
    {
       sprintf(message, "PCOUNT = %.0f is illegal in ASCII table; must = 0",
               (double) pcount);
       ffpmsg(message);
       return(*status = BAD_PCOUNT);
    }

    if (tfields)
       *tfields = fields;

    if (maxfield < 0)
        maxf = fields;
    else
        maxf = minvalue(maxfield, fields);

    if (maxf > 0)
    {
        for (ii = 0; ii < maxf; ii++)
        {   /* initialize optional keyword values */
            if (ttype)
                *ttype[ii] = '\0';   

            if (tunit)
                *tunit[ii] = '\0';
        }

   
        if (ttype)
            ffgkns(fptr, "TTYPE", 1, maxf, ttype, &nfound, status);

        if (tunit)
            ffgkns(fptr, "TUNIT", 1, maxf, tunit, &nfound, status);

        if (*status > 0)
            return(*status);

        if (tbcol)
        {
            ffgknj(fptr, "TBCOL", 1, maxf, tbcol, &nfound, status);

            if (*status > 0 || nfound != maxf)
            {
                ffpmsg(
        "Required TBCOL keyword(s) not found in ASCII table header (ffghtb).");
                return(*status = NO_TBCOL);
            }
        }

        if (tform)
        {
            ffgkns(fptr, "TFORM", 1, maxf, tform, &nfound, status);

            if (*status > 0 || nfound != maxf)
            {
                ffpmsg(
        "Required TFORM keyword(s) not found in ASCII table header (ffghtb).");
                return(*status = NO_TFORM);
            }
        }
    }

    if (extnm)
    {
        extnm[0] = '\0';

        tstatus = *status;
        ffgkys(fptr, "EXTNAME", extnm, comm, status);

        if (*status == KEY_NO_EXIST)
            *status = tstatus;  /* keyword not required, so ignore error */
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffghtbll(fitsfile *fptr, /* I - FITS file pointer                        */
           int maxfield,    /* I - maximum no. of columns to read;          */
           LONGLONG *naxis1, /* O - length of table row in bytes             */
           LONGLONG *naxis2, /* O - number of rows in the table              */
           int *tfields,    /* O - number of columns in the table           */
           char **ttype,    /* O - name of each column                      */
           LONGLONG *tbcol, /* O - byte offset in row to each column        */
           char **tform,    /* O - value of TFORMn keyword for each column  */
           char **tunit,    /* O - value of TUNITn keyword for each column  */
           char *extnm,     /* O - value of EXTNAME keyword, if any         */
           int *status)     /* IO - error status                            */
/*
  Get keywords from the Header of the ASCII TaBle:
  Check that the keywords conform to the FITS standard and return the
  parameters which describe the table.
*/
{
    int ii, maxf, nfound, tstatus;
    long fields;
    char name[FLEN_KEYWORD], value[FLEN_VALUE], comm[FLEN_COMMENT];
    char xtension[FLEN_VALUE], message[81];
    LONGLONG llnaxis1, llnaxis2, pcount;

    if (*status > 0)
        return(*status);

    /* read the first keyword of the extension */
    ffgkyn(fptr, 1, name, value, comm, status);

    if (!strcmp(name, "XTENSION"))
    {
            if (ffc2s(value, xtension, status) > 0)  /* get the value string */
            {
                ffpmsg("Bad value string for XTENSION keyword:");
                ffpmsg(value);
                return(*status);
            }

            /* allow the quoted string value to begin in any column and */
            /* allow any number of trailing blanks before the closing quote */
            if ( (value[0] != '\'')   ||  /* first char must be a quote */
                 ( strcmp(xtension, "TABLE") ) )
            {
                sprintf(message,
                "This is not a TABLE extension: %s", value);
                ffpmsg(message);
                return(*status = NOT_ATABLE);
            }
    }

    else  /* error: 1st keyword of extension != XTENSION */
    {
        sprintf(message,
        "First keyword of the extension is not XTENSION: %s", name);
        ffpmsg(message);
        return(*status = NO_XTENSION);
    }

    if (ffgttb(fptr, &llnaxis1, &llnaxis2, &pcount, &fields, status) > 0)
        return(*status);

    if (naxis1)
       *naxis1 = llnaxis1;

    if (naxis2)
       *naxis2 = llnaxis2;

    if (pcount != 0)
    {
       sprintf(message, "PCOUNT = %.0f is illegal in ASCII table; must = 0",
             (double) pcount);
       ffpmsg(message);
       return(*status = BAD_PCOUNT);
    }

    if (tfields)
       *tfields = fields;

    if (maxfield < 0)
        maxf = fields;
    else
        maxf = minvalue(maxfield, fields);

    if (maxf > 0)
    {
        for (ii = 0; ii < maxf; ii++)
        {   /* initialize optional keyword values */
            if (ttype)
                *ttype[ii] = '\0';   

            if (tunit)
                *tunit[ii] = '\0';
        }

   
        if (ttype)
            ffgkns(fptr, "TTYPE", 1, maxf, ttype, &nfound, status);

        if (tunit)
            ffgkns(fptr, "TUNIT", 1, maxf, tunit, &nfound, status);

        if (*status > 0)
            return(*status);

        if (tbcol)
        {
            ffgknjj(fptr, "TBCOL", 1, maxf, tbcol, &nfound, status);

            if (*status > 0 || nfound != maxf)
            {
                ffpmsg(
        "Required TBCOL keyword(s) not found in ASCII table header (ffghtbll).");
                return(*status = NO_TBCOL);
            }
        }

        if (tform)
        {
            ffgkns(fptr, "TFORM", 1, maxf, tform, &nfound, status);

            if (*status > 0 || nfound != maxf)
            {
                ffpmsg(
        "Required TFORM keyword(s) not found in ASCII table header (ffghtbll).");
                return(*status = NO_TFORM);
            }
        }
    }

    if (extnm)
    {
        extnm[0] = '\0';

        tstatus = *status;
        ffgkys(fptr, "EXTNAME", extnm, comm, status);

        if (*status == KEY_NO_EXIST)
            *status = tstatus;  /* keyword not required, so ignore error */
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffghbn(fitsfile *fptr,  /* I - FITS file pointer                        */
           int maxfield,    /* I - maximum no. of columns to read;          */
           long *naxis2,    /* O - number of rows in the table              */
           int *tfields,    /* O - number of columns in the table           */
           char **ttype,    /* O - name of each column                      */
           char **tform,    /* O - TFORMn value for each column             */
           char **tunit,    /* O - TUNITn value for each column             */
           char *extnm,     /* O - value of EXTNAME keyword, if any         */
           long *pcount,    /* O - value of PCOUNT keyword                  */
           int *status)     /* IO - error status                            */
/*
  Get keywords from the Header of the BiNary table:
  Check that the keywords conform to the FITS standard and return the
  parameters which describe the table.
*/
{
    int ii, maxf, nfound, tstatus;
    long  fields;
    char name[FLEN_KEYWORD], value[FLEN_VALUE], comm[FLEN_COMMENT];
    char xtension[FLEN_VALUE], message[81];
    LONGLONG naxis1ll, naxis2ll, pcountll;

    if (*status > 0)
        return(*status);

    /* read the first keyword of the extension */
    ffgkyn(fptr, 1, name, value, comm, status);

    if (!strcmp(name, "XTENSION"))
    {
            if (ffc2s(value, xtension, status) > 0)  /* get the value string */
            {
                ffpmsg("Bad value string for XTENSION keyword:");
                ffpmsg(value);
                return(*status);
            }

            /* allow the quoted string value to begin in any column and */
            /* allow any number of trailing blanks before the closing quote */
            if ( (value[0] != '\'')   ||  /* first char must be a quote */
                 ( strcmp(xtension, "BINTABLE") &&
                   strcmp(xtension, "A3DTABLE") &&
                   strcmp(xtension, "3DTABLE")
                 ) )
            {
                sprintf(message,
                "This is not a BINTABLE extension: %s", value);
                ffpmsg(message);
                return(*status = NOT_BTABLE);
            }
    }

    else  /* error: 1st keyword of extension != XTENSION */
    {
        sprintf(message,
        "First keyword of the extension is not XTENSION: %s", name);
        ffpmsg(message);
        return(*status = NO_XTENSION);
    }

    if (ffgttb(fptr, &naxis1ll, &naxis2ll, &pcountll, &fields, status) > 0)
        return(*status);

    if (naxis2)
       *naxis2 = (long) naxis2ll;

    if (pcount)
       *pcount = (long) pcountll;

    if (tfields)
        *tfields = fields;

    if (maxfield < 0)
        maxf = fields;
    else
        maxf = minvalue(maxfield, fields);

    if (maxf > 0)
    {
        for (ii = 0; ii < maxf; ii++)
        {   /* initialize optional keyword values */
            if (ttype)
                *ttype[ii] = '\0';   

            if (tunit)
                *tunit[ii] = '\0';
        }

        if (ttype)
            ffgkns(fptr, "TTYPE", 1, maxf, ttype, &nfound, status);

        if (tunit)
            ffgkns(fptr, "TUNIT", 1, maxf, tunit, &nfound, status);

        if (*status > 0)
            return(*status);

        if (tform)
        {
            ffgkns(fptr, "TFORM", 1, maxf, tform, &nfound, status);

            if (*status > 0 || nfound != maxf)
            {
                ffpmsg(
        "Required TFORM keyword(s) not found in binary table header (ffghbn).");
                return(*status = NO_TFORM);
            }
        }
    }

    if (extnm)
    {
        extnm[0] = '\0';

        tstatus = *status;
        ffgkys(fptr, "EXTNAME", extnm, comm, status);

        if (*status == KEY_NO_EXIST)
          *status = tstatus;  /* keyword not required, so ignore error */
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffghbnll(fitsfile *fptr,  /* I - FITS file pointer                        */
           int maxfield,    /* I - maximum no. of columns to read;          */
           LONGLONG *naxis2,    /* O - number of rows in the table              */
           int *tfields,    /* O - number of columns in the table           */
           char **ttype,    /* O - name of each column                      */
           char **tform,    /* O - TFORMn value for each column             */
           char **tunit,    /* O - TUNITn value for each column             */
           char *extnm,     /* O - value of EXTNAME keyword, if any         */
           LONGLONG *pcount,    /* O - value of PCOUNT keyword                  */
           int *status)     /* IO - error status                            */
/*
  Get keywords from the Header of the BiNary table:
  Check that the keywords conform to the FITS standard and return the
  parameters which describe the table.
*/
{
    int ii, maxf, nfound, tstatus;
    long  fields;
    char name[FLEN_KEYWORD], value[FLEN_VALUE], comm[FLEN_COMMENT];
    char xtension[FLEN_VALUE], message[81];
    LONGLONG naxis1ll, naxis2ll, pcountll;

    if (*status > 0)
        return(*status);

    /* read the first keyword of the extension */
    ffgkyn(fptr, 1, name, value, comm, status);

    if (!strcmp(name, "XTENSION"))
    {
            if (ffc2s(value, xtension, status) > 0)  /* get the value string */
            {
                ffpmsg("Bad value string for XTENSION keyword:");
                ffpmsg(value);
                return(*status);
            }

            /* allow the quoted string value to begin in any column and */
            /* allow any number of trailing blanks before the closing quote */
            if ( (value[0] != '\'')   ||  /* first char must be a quote */
                 ( strcmp(xtension, "BINTABLE") &&
                   strcmp(xtension, "A3DTABLE") &&
                   strcmp(xtension, "3DTABLE")
                 ) )
            {
                sprintf(message,
                "This is not a BINTABLE extension: %s", value);
                ffpmsg(message);
                return(*status = NOT_BTABLE);
            }
    }

    else  /* error: 1st keyword of extension != XTENSION */
    {
        sprintf(message,
        "First keyword of the extension is not XTENSION: %s", name);
        ffpmsg(message);
        return(*status = NO_XTENSION);
    }

    if (ffgttb(fptr, &naxis1ll, &naxis2ll, &pcountll, &fields, status) > 0)
        return(*status);

    if (naxis2)
       *naxis2 = naxis2ll;

    if (pcount)
       *pcount = pcountll;

    if (tfields)
        *tfields = fields;

    if (maxfield < 0)
        maxf = fields;
    else
        maxf = minvalue(maxfield, fields);

    if (maxf > 0)
    {
        for (ii = 0; ii < maxf; ii++)
        {   /* initialize optional keyword values */
            if (ttype)
                *ttype[ii] = '\0';   

            if (tunit)
                *tunit[ii] = '\0';
        }

        if (ttype)
            ffgkns(fptr, "TTYPE", 1, maxf, ttype, &nfound, status);

        if (tunit)
            ffgkns(fptr, "TUNIT", 1, maxf, tunit, &nfound, status);

        if (*status > 0)
            return(*status);

        if (tform)
        {
            ffgkns(fptr, "TFORM", 1, maxf, tform, &nfound, status);

            if (*status > 0 || nfound != maxf)
            {
                ffpmsg(
        "Required TFORM keyword(s) not found in binary table header (ffghbn).");
                return(*status = NO_TFORM);
            }
        }
    }

    if (extnm)
    {
        extnm[0] = '\0';

        tstatus = *status;
        ffgkys(fptr, "EXTNAME", extnm, comm, status);

        if (*status == KEY_NO_EXIST)
          *status = tstatus;  /* keyword not required, so ignore error */
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgphd(fitsfile *fptr,  /* I - FITS file pointer                        */
           int maxdim,      /* I - maximum no. of dimensions to read;       */
           int *simple,     /* O - does file conform to FITS standard? 1/0  */
           int *bitpix,     /* O - number of bits per data value pixel      */
           int *naxis,      /* O - number of axes in the data array         */
           LONGLONG naxes[],    /* O - length of each data axis                 */
           long *pcount,    /* O - number of group parameters (usually 0)   */
           long *gcount,    /* O - number of random groups (usually 1 or 0) */
           int *extend,     /* O - may FITS file haave extensions?          */
           double *bscale,  /* O - array pixel linear scaling factor        */
           double *bzero,   /* O - array pixel linear scaling zero point    */
           LONGLONG *blank, /* O - value used to represent undefined pixels */
           int *nspace,     /* O - number of blank keywords prior to END    */
           int *status)     /* IO - error status                            */
{
/*
  Get the Primary HeaDer parameters.  Check that the keywords conform to
  the FITS standard and return the parameters which determine the size and
  structure of the primary array or IMAGE extension.
*/
    int unknown, found_end, tstatus, ii, nextkey, namelen;
    long longbitpix, longnaxis;
    LONGLONG axislen;
    char message[FLEN_ERRMSG], keyword[FLEN_KEYWORD];
    char card[FLEN_CARD];
    char name[FLEN_KEYWORD], value[FLEN_VALUE], comm[FLEN_COMMENT];
    char xtension[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if (simple)
       *simple = 1;

    unknown = 0;

    /*--------------------------------------------------------------------*/
    /*  Get 1st keyword of HDU and test whether it is SIMPLE or XTENSION  */
    /*--------------------------------------------------------------------*/
    ffgkyn(fptr, 1, name, value, comm, status);

    if ((fptr->Fptr)->curhdu == 0) /* Is this the beginning of the FITS file? */
    {
        if (!strcmp(name, "SIMPLE"))
        {
            if (value[0] == 'F')
            {
                if (simple)
                    *simple=0;          /* not a simple FITS file */
            }
            else if (value[0] != 'T')
                return(*status = BAD_SIMPLE);
        }

        else
        {
            sprintf(message,
                   "First keyword of the file is not SIMPLE: %s", name);
            ffpmsg(message);
            return(*status = NO_SIMPLE);
        }
    }

    else    /* not beginning of the file, so presumably an IMAGE extension */
    {       /* or it could be a compressed image in a binary table */

        if (!strcmp(name, "XTENSION"))
        {
            if (ffc2s(value, xtension, status) > 0)  /* get the value string */
            {
                ffpmsg("Bad value string for XTENSION keyword:");
                ffpmsg(value);
                return(*status);
            }

            /* allow the quoted string value to begin in any column and */
            /* allow any number of trailing blanks before the closing quote */
            if ( (value[0] != '\'')   ||  /* first char must be a quote */
                  ( strcmp(xtension, "IMAGE")  &&
                    strcmp(xtension, "IUEIMAGE") ) )
            {
                unknown = 1;  /* unknown type of extension; press on anyway */
                sprintf(message,
                   "This is not an IMAGE extension: %s", value);
                ffpmsg(message);
            }
        }

        else  /* error: 1st keyword of extension != XTENSION */
        {
            sprintf(message,
            "First keyword of the extension is not XTENSION: %s", name);
            ffpmsg(message);
            return(*status = NO_XTENSION);
        }
    }

    if (unknown && (fptr->Fptr)->compressimg)
    {
        /* this is a compressed image, so read ZBITPIX, ZNAXIS keywords */
        unknown = 0;  /* reset flag */
        ffxmsg(3, message); /* clear previous spurious error message */

        if (bitpix)
        {
            ffgidt(fptr, bitpix, status); /* get bitpix value */

            if (*status > 0)
            {
                ffpmsg("Error reading BITPIX value of compressed image");
                return(*status);
            }
        }

        if (naxis)
        {
            ffgidm(fptr, naxis, status); /* get NAXIS value */

            if (*status > 0)
            {
                ffpmsg("Error reading NAXIS value of compressed image");
                return(*status);
            }
        }

        if (naxes)
        {
            ffgiszll(fptr, maxdim, naxes, status);  /* get NAXISn value */

            if (*status > 0)
            {
                ffpmsg("Error reading NAXISn values of compressed image");
                return(*status);
            }
        }

        nextkey = 9; /* skip required table keywords in the following search */
    }
    else
    {

        /*----------------------------------------------------------------*/
        /*  Get 2nd keyword;  test whether it is BITPIX with legal value  */
        /*----------------------------------------------------------------*/
        ffgkyn(fptr, 2, name, value, comm, status);  /* BITPIX = 2nd keyword */

        if (strcmp(name, "BITPIX"))
        {
            sprintf(message,
            "Second keyword of the extension is not BITPIX: %s", name);
            ffpmsg(message);
            return(*status = NO_BITPIX);
        }

        if (ffc2ii(value,  &longbitpix, status) > 0)
        {
            sprintf(message,
            "Value of BITPIX keyword is not an integer: %s", value);
            ffpmsg(message);
            return(*status = BAD_BITPIX);
        }
        else if (longbitpix != BYTE_IMG && longbitpix != SHORT_IMG &&
             longbitpix != LONG_IMG && longbitpix != LONGLONG_IMG &&
             longbitpix != FLOAT_IMG && longbitpix != DOUBLE_IMG)
        {
            sprintf(message,
            "Illegal value for BITPIX keyword: %s", value);
            ffpmsg(message);
            return(*status = BAD_BITPIX);
        }
        if (bitpix)
            *bitpix = longbitpix;  /* do explicit type conversion */

        /*---------------------------------------------------------------*/
        /*  Get 3rd keyword;  test whether it is NAXIS with legal value  */
        /*---------------------------------------------------------------*/
        ffgtkn(fptr, 3, "NAXIS",  &longnaxis, status);

        if (*status == BAD_ORDER)
            return(*status = NO_NAXIS);
        else if (*status == NOT_POS_INT || longnaxis > 999)
        {
            sprintf(message,"NAXIS = %ld is illegal", longnaxis);
            ffpmsg(message);
            return(*status = BAD_NAXIS);
        }
        else
            if (naxis)
                 *naxis = longnaxis;  /* do explicit type conversion */

        /*---------------------------------------------------------*/
        /*  Get the next NAXISn keywords and test for legal values */
        /*---------------------------------------------------------*/
        for (ii=0, nextkey=4; ii < longnaxis; ii++, nextkey++)
        {
            ffkeyn("NAXIS", ii+1, keyword, status);
            ffgtknjj(fptr, 4+ii, keyword, &axislen, status);

            if (*status == BAD_ORDER)
                return(*status = NO_NAXES);
            else if (*status == NOT_POS_INT)
                return(*status = BAD_NAXES);
            else if (ii < maxdim)
                if (naxes)
                    naxes[ii] = axislen;
        }
    }

    /*---------------------------------------------------------*/
    /*  now look for other keywords of interest:               */
    /*  BSCALE, BZERO, BLANK, PCOUNT, GCOUNT, EXTEND, and END  */
    /*---------------------------------------------------------*/

    /*  initialize default values in case keyword is not present */
    if (bscale)
        *bscale = 1.0;
    if (bzero)
        *bzero  = 0.0;
    if (pcount)
        *pcount = 0;
    if (gcount)
        *gcount = 1;
    if (extend)
        *extend = 0;
    if (blank)
      *blank = NULL_UNDEFINED; /* no default null value for BITPIX=8,16,32 */

    *nspace = 0;
    found_end = 0;
    tstatus = *status;

    for (; !found_end; nextkey++)  
    {
      /* get next keyword */
      /* don't use ffgkyn here because it trys to parse the card to read */
      /* the value string, thus failing to read the file just because of */
      /* minor syntax errors in optional keywords.                       */

      if (ffgrec(fptr, nextkey, card, status) > 0 )  /* get the 80-byte card */
      {
        if (*status == KEY_OUT_BOUNDS)
        {
          found_end = 1;  /* simply hit the end of the header */
          *status = tstatus;  /* reset error status */
        }
        else          
        {
          ffpmsg("Failed to find the END keyword in header (ffgphd).");
        }
      }
      else /* got the next keyword without error */
      {
        ffgknm(card, name, &namelen, status); /* get the keyword name */

        if (fftrec(name, status) > 0)  /* test keyword name; catches no END */
        {
          sprintf(message,
              "Name of keyword no. %d contains illegal character(s): %s",
              nextkey, name);
          ffpmsg(message);

          if (nextkey % 36 == 0) /* test if at beginning of 36-card record */
            ffpmsg("  (This may indicate a missing END keyword).");
        }

        if (!strcmp(name, "BSCALE") && bscale)
        {
            *nspace = 0;  /* reset count of blank keywords */
            ffpsvc(card, value, comm, status); /* parse value and comment */

            if (ffc2dd(value, bscale, status) > 0) /* convert to double */
            {
                /* reset error status and continue, but still issue warning */
                *status = tstatus;
                *bscale = 1.0;

                sprintf(message,
                "Error reading BSCALE keyword value as a double: %s", value);
                ffpmsg(message);
            }
        }

        else if (!strcmp(name, "BZERO") && bzero)
        {
            *nspace = 0;  /* reset count of blank keywords */
            ffpsvc(card, value, comm, status); /* parse value and comment */

            if (ffc2dd(value, bzero, status) > 0) /* convert to double */
            {
                /* reset error status and continue, but still issue warning */
                *status = tstatus;
                *bzero = 0.0;

                sprintf(message,
                "Error reading BZERO keyword value as a double: %s", value);
                ffpmsg(message);
            }
        }

        else if (!strcmp(name, "BLANK") && blank)
        {
            *nspace = 0;  /* reset count of blank keywords */
            ffpsvc(card, value, comm, status); /* parse value and comment */

            if (ffc2jj(value, blank, status) > 0) /* convert to LONGLONG */
            {
                /* reset error status and continue, but still issue warning */
                *status = tstatus;
                *blank = NULL_UNDEFINED;

                sprintf(message,
                "Error reading BLANK keyword value as an integer: %s", value);
                ffpmsg(message);
            }
        }

        else if (!strcmp(name, "PCOUNT") && pcount)
        {
            *nspace = 0;  /* reset count of blank keywords */
            ffpsvc(card, value, comm, status); /* parse value and comment */

            if (ffc2ii(value, pcount, status) > 0) /* convert to long */
            {
                sprintf(message,
                "Error reading PCOUNT keyword value as an integer: %s", value);
                ffpmsg(message);
            }
        }

        else if (!strcmp(name, "GCOUNT") && gcount)
        {
            *nspace = 0;  /* reset count of blank keywords */
            ffpsvc(card, value, comm, status); /* parse value and comment */

            if (ffc2ii(value, gcount, status) > 0) /* convert to long */
            {
                sprintf(message,
                "Error reading GCOUNT keyword value as an integer: %s", value);
                ffpmsg(message);
            }
        }

        else if (!strcmp(name, "EXTEND") && extend)
        {
            *nspace = 0;  /* reset count of blank keywords */
            ffpsvc(card, value, comm, status); /* parse value and comment */

            if (ffc2ll(value, extend, status) > 0) /* convert to logical */
            {
                /* reset error status and continue, but still issue warning */
                *status = tstatus;
                *extend = 0;

                sprintf(message,
                "Error reading EXTEND keyword value as a logical: %s", value);
                ffpmsg(message);
            }
        }

        else if (!strcmp(name, "END"))
            found_end = 1;

        else if (!card[0] )
            *nspace = *nspace + 1;  /* this is a blank card in the header */

        else
            *nspace = 0;  /* reset count of blank keywords immediately
                            before the END keyword to zero   */
      }

      if (*status > 0)  /* exit on error after writing error message */
      {
        if ((fptr->Fptr)->curhdu == 0)
            ffpmsg(
            "Failed to read the required primary array header keywords.");
        else
            ffpmsg(
            "Failed to read the required image extension header keywords.");

        return(*status);
      }
    }

    if (unknown)
       *status = NOT_IMAGE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgttb(fitsfile *fptr,      /* I - FITS file pointer*/
           LONGLONG *rowlen,        /* O - length of a table row, in bytes */
           LONGLONG *nrows,         /* O - number of rows in the table */
           LONGLONG *pcount,    /* O - value of PCOUNT keyword */
           long *tfields,       /* O - number of fields in the table */
           int *status)         /* IO - error status    */
{
/*
  Get and Test TaBle;
  Test that this is a legal ASCII or binary table and get some keyword values.
  We assume that the calling routine has already tested the 1st keyword
  of the extension to ensure that this is really a table extension.
*/
    if (*status > 0)
        return(*status);

    if (fftkyn(fptr, 2, "BITPIX", "8", status) == BAD_ORDER) /* 2nd keyword */
        return(*status = NO_BITPIX);  /* keyword not BITPIX */
    else if (*status == NOT_POS_INT)
        return(*status = BAD_BITPIX); /* value != 8 */

    if (fftkyn(fptr, 3, "NAXIS", "2", status) == BAD_ORDER) /* 3rd keyword */
        return(*status = NO_NAXIS);  /* keyword not NAXIS */
    else if (*status == NOT_POS_INT)
        return(*status = BAD_NAXIS); /* value != 2 */

    if (ffgtknjj(fptr, 4, "NAXIS1", rowlen, status) == BAD_ORDER) /* 4th key */
        return(*status = NO_NAXES);  /* keyword not NAXIS1 */
    else if (*status == NOT_POS_INT)
        return(*status == BAD_NAXES); /* bad NAXIS1 value */

    if (ffgtknjj(fptr, 5, "NAXIS2", nrows, status) == BAD_ORDER) /* 5th key */
        return(*status = NO_NAXES);  /* keyword not NAXIS2 */
    else if (*status == NOT_POS_INT)
        return(*status == BAD_NAXES); /* bad NAXIS2 value */

    if (ffgtknjj(fptr, 6, "PCOUNT", pcount, status) == BAD_ORDER) /* 6th key */
        return(*status = NO_PCOUNT);  /* keyword not PCOUNT */
    else if (*status == NOT_POS_INT)
        return(*status = BAD_PCOUNT); /* bad PCOUNT value */

    if (fftkyn(fptr, 7, "GCOUNT", "1", status) == BAD_ORDER) /* 7th keyword */
        return(*status = NO_GCOUNT);  /* keyword not GCOUNT */
    else if (*status == NOT_POS_INT)
        return(*status = BAD_GCOUNT); /* value != 1 */

    if (ffgtkn(fptr, 8, "TFIELDS", tfields, status) == BAD_ORDER) /* 8th key*/
        return(*status = NO_TFIELDS);  /* keyword not TFIELDS */
    else if (*status == NOT_POS_INT || *tfields > 999)
        return(*status == BAD_TFIELDS); /* bad TFIELDS value */


    if (*status > 0)
       ffpmsg(
       "Error reading required keywords in the table header (FTGTTB).");

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgtkn(fitsfile *fptr,  /* I - FITS file pointer              */
           int numkey,      /* I - number of the keyword to read  */
           char *name,      /* I - expected name of the keyword   */
           long *value,     /* O - integer value of the keyword   */
           int *status)     /* IO - error status                  */
{
/*
  test that keyword number NUMKEY has the expected name and get the
  integer value of the keyword.  Return an error if the keyword
  name does not match the input name, or if the value of the
  keyword is not a positive integer.
*/
    char keyname[FLEN_KEYWORD], valuestring[FLEN_VALUE];
    char comm[FLEN_COMMENT], message[FLEN_ERRMSG];
   
    if (*status > 0)
        return(*status);
    
    keyname[0] = '\0';
    valuestring[0] = '\0';

    if (ffgkyn(fptr, numkey, keyname, valuestring, comm, status) <= 0)
    {
        if (strcmp(keyname, name) )
            *status = BAD_ORDER;  /* incorrect keyword name */

        else
        {
            ffc2ii(valuestring, value, status);  /* convert to integer */

            if (*status > 0 || *value < 0 )
               *status = NOT_POS_INT;
        }

        if (*status > 0)
        {
            sprintf(message,
              "ffgtkn found unexpected keyword or value for keyword no. %d.",
              numkey);
            ffpmsg(message);

            sprintf(message,
              " Expected positive integer keyword %s, but instead", name);
            ffpmsg(message);

            sprintf(message,
              " found keyword %s with value %s", keyname, valuestring);
            ffpmsg(message);
        }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgtknjj(fitsfile *fptr,  /* I - FITS file pointer              */
           int numkey,      /* I - number of the keyword to read  */
           char *name,      /* I - expected name of the keyword   */
           LONGLONG *value, /* O - integer value of the keyword   */
           int *status)     /* IO - error status                  */
{
/*
  test that keyword number NUMKEY has the expected name and get the
  integer value of the keyword.  Return an error if the keyword
  name does not match the input name, or if the value of the
  keyword is not a positive integer.
*/
    char keyname[FLEN_KEYWORD], valuestring[FLEN_VALUE];
    char comm[FLEN_COMMENT], message[FLEN_ERRMSG];
   
    if (*status > 0)
        return(*status);
    
    keyname[0] = '\0';
    valuestring[0] = '\0';

    if (ffgkyn(fptr, numkey, keyname, valuestring, comm, status) <= 0)
    {
        if (strcmp(keyname, name) )
            *status = BAD_ORDER;  /* incorrect keyword name */

        else
        {
            ffc2jj(valuestring, value, status);  /* convert to integer */

            if (*status > 0 || *value < 0 )
               *status = NOT_POS_INT;
        }

        if (*status > 0)
        {
            sprintf(message,
              "ffgtknjj found unexpected keyword or value for keyword no. %d.",
              numkey);
            ffpmsg(message);

            sprintf(message,
              " Expected positive integer keyword %s, but instead", name);
            ffpmsg(message);

            sprintf(message,
              " found keyword %s with value %s", keyname, valuestring);
            ffpmsg(message);
        }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fftkyn(fitsfile *fptr,  /* I - FITS file pointer              */
           int numkey,      /* I - number of the keyword to read  */
           char *name,      /* I - expected name of the keyword   */
           char *value,     /* I - expected value of the keyword  */
           int *status)     /* IO - error status                  */
{
/*
  test that keyword number NUMKEY has the expected name and the
  expected value string.
*/
    char keyname[FLEN_KEYWORD], valuestring[FLEN_VALUE];
    char comm[FLEN_COMMENT], message[FLEN_ERRMSG];
   
    if (*status > 0)
        return(*status);
    
    keyname[0] = '\0';
    valuestring[0] = '\0';

    if (ffgkyn(fptr, numkey, keyname, valuestring, comm, status) <= 0)
    {
        if (strcmp(keyname, name) )
            *status = BAD_ORDER;  /* incorrect keyword name */

        if (strcmp(value, valuestring) )
            *status = NOT_POS_INT;  /* incorrect keyword value */
    }

    if (*status > 0)
    {
        sprintf(message,
          "fftkyn found unexpected keyword or value for keyword no. %d.",
          numkey);
        ffpmsg(message);

        sprintf(message,
          " Expected keyword %s with value %s, but", name, value);
        ffpmsg(message);

        sprintf(message,
          " found keyword %s with value %s", keyname, valuestring);
        ffpmsg(message);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffh2st(fitsfile *fptr,   /* I - FITS file pointer           */
           char **header,    /* O - returned header string      */
           int  *status)     /* IO - error status               */

/*
  read header keywords into a long string of chars.  This routine allocates
  memory for the string, so the calling routine must eventually free the
  memory when it is not needed any more.
*/
{
    int nkeys;
    long nrec;
    LONGLONG headstart;

    if (*status > 0)
        return(*status);

    /* get number of keywords in the header (doesn't include END) */
    if (ffghsp(fptr, &nkeys, NULL, status) > 0)
        return(*status);

    nrec = (nkeys / 36 + 1);

    /* allocate memory for all the keywords (multiple of 2880 bytes) */
    *header = (char *) calloc ( nrec * 2880 + 1, 1);
    if (!(*header))
    {
         *status = MEMORY_ALLOCATION;
         ffpmsg("failed to allocate memory to hold all the header keywords");
         return(*status);
    }

    ffghadll(fptr, &headstart, NULL, NULL, status); /* get header address */
    ffmbyt(fptr, headstart, REPORT_EOF, status);   /* move to header */
    ffgbyt(fptr, nrec * 2880, *header, status);     /* copy header */
    *(*header + (nrec * 2880)) = '\0';

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffhdr2str( fitsfile *fptr,  /* I - FITS file pointer                    */
            int exclude_comm,   /* I - if TRUE, exclude commentary keywords */
            char **exclist,     /* I - list of excluded keyword names       */
            int nexc,           /* I - number of names in exclist           */
            char **header,      /* O - returned header string               */
            int *nkeys,         /* O - returned number of 80-char keywords  */
            int  *status)       /* IO - error status                        */
/*
  read header keywords into a long string of chars.  This routine allocates
  memory for the string, so the calling routine must eventually free the
  memory when it is not needed any more.  If exclude_comm is TRUE, then all 
  the COMMENT, HISTORY, and  keywords will be excluded from the output
  string of keywords.  Any other list of keywords to be excluded may be
  specified with the exclist parameter.
*/
{
    int casesn, match, exact, totkeys;
    long ii, jj;
    char keybuf[162], keyname[FLEN_KEYWORD], *headptr;

    *nkeys = 0;

    if (*status > 0)
        return(*status);

    /* get number of keywords in the header (doesn't include END) */
    if (ffghsp(fptr, &totkeys, NULL, status) > 0)
        return(*status);

    /* allocate memory for all the keywords */
    /* (will reallocate it later to minimize the memory size) */
    
    *header = (char *) calloc ( (totkeys + 1) * 80 + 1, 1);
    if (!(*header))
    {
         *status = MEMORY_ALLOCATION;
         ffpmsg("failed to allocate memory to hold all the header keywords");
         return(*status);
    }

    headptr = *header;
    casesn = FALSE;

    /* read every keyword */
    for (ii = 1; ii <= totkeys; ii++) 
    {
        ffgrec(fptr, ii, keybuf, status);
        /* pad record with blanks so that it is at least 80 chars long */
        strcat(keybuf,
    "                                                                                ");

        keyname[0] = '\0';
        strncat(keyname, keybuf, 8); /* copy the keyword name */
        
        if (exclude_comm)
        {
            if (!FSTRCMP("COMMENT ", keyname) ||
                !FSTRCMP("HISTORY ", keyname) ||
                !FSTRCMP("        ", keyname) )
              continue;  /* skip this commentary keyword */
        }

        /* does keyword match any names in the exclusion list? */
        for (jj = 0; jj < nexc; jj++ )
        {
            ffcmps(exclist[jj], keyname, casesn, &match, &exact);
                 if (match)
                     break;
        }

        if (jj == nexc)
        {
            /* not in exclusion list, add this keyword to the string */
            strcpy(headptr, keybuf);
            headptr += 80;
            (*nkeys)++;
        }
    }

    /* add the END keyword */
    strcpy(headptr,
    "END                                                                             ");
    headptr += 80;
    (*nkeys)++;

    *headptr = '\0';   /* terminate the header string */
    /* minimize the allocated memory */
    *header = (char *) realloc(*header, (*nkeys *80) + 1);  

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffcnvthdr2str( fitsfile *fptr,  /* I - FITS file pointer                    */
            int exclude_comm,   /* I - if TRUE, exclude commentary keywords */
            char **exclist,     /* I - list of excluded keyword names       */
            int nexc,           /* I - number of names in exclist           */
            char **header,      /* O - returned header string               */
            int *nkeys,         /* O - returned number of 80-char keywords  */
            int  *status)       /* IO - error status                        */
/*
  Same as ffhdr2str, except that if the input HDU is a tile compressed image
  (stored in a binary table) then it will first convert that header back
  to that of a normal uncompressed FITS image before concatenating the header
  keyword records.
*/
{
    fitsfile *tempfptr;
    
    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status) )
    {
        /* this is a tile compressed image, so need to make an uncompressed */
	/* copy of the image header in memory before concatenating the keywords */
        if (fits_create_file(&tempfptr, "mem://", status) > 0) {
	    return(*status);
	}

	if (fits_img_decompress_header(fptr, tempfptr, status) > 0) {
	    fits_delete_file(tempfptr, status);
	    return(*status);
	}

	ffhdr2str(tempfptr, exclude_comm, exclist, nexc, header, nkeys, status);
	fits_close_file(tempfptr, status);

    } else {
        ffhdr2str(fptr, exclude_comm, exclist, nexc, header, nkeys, status);
    }

    return(*status);
}
healpy-1.10.3/cfitsio/group.c0000664000175000017500000052437713010375005016302 0ustar  zoncazonca00000000000000/*  This file, group.c, contains the grouping convention suport routines.  */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */
/*                                                                         */
/*  The group.c module of CFITSIO was written by Donald G. Jennings of     */
/*  the INTEGRAL Science Data Centre (ISDC) under NASA contract task       */
/*  66002J6. The above copyright laws apply. Copyright guidelines of The   */
/*  University of Geneva might also apply.                                 */

/*  The following routines are designed to create, read, and manipulate    */
/*  FITS Grouping Tables as defined in the FITS Grouping Convention paper  */
/*  by Jennings, Pence, Folk and Schlesinger. The development of the       */
/*  grouping structure was partially funded under the NASA AISRP Program.  */ 
    
#include "fitsio2.h"
#include "group.h"
#include 
#include 
#include 

#if defined(WIN32) || defined(__WIN32__)
#include    /* defines the getcwd function on Windows PCs */
#endif

#if defined(unix) || defined(__unix__)  || defined(__unix)
#include   /* needed for getcwd prototype on unix machines */
#endif

#define HEX_ESCAPE '%'

/*---------------------------------------------------------------------------
 Change record:

D. Jennings, 18/06/98, version 1.0 of group module delivered to B. Pence for
                       integration into CFITSIO 2.005

D. Jennings, 17/11/98, fixed bug in ffgtcpr(). Now use fits_find_nextkey()
                       correctly and insert auxiliary keyword records 
		       directly before the TTYPE1 keyword in the copied
		       group table.

D. Jennings, 22/01/99, ffgmop() now looks for relative file paths when 
                       the MEMBER_LOCATION information is given in a 
		       grouping table.

D. Jennings, 01/02/99, ffgtop() now looks for relatve file paths when 
                       the GRPLCn keyword value is supplied in the member
		       HDU header.

D. Jennings, 01/02/99, ffgtam() now trys to construct relative file paths
                       from the member's file to the group table's file
		       (and visa versa) when both the member's file and
		       group table file are of access type FILE://.

D. Jennings, 05/05/99, removed the ffgtcn() function; made obsolete by
                       fits_get_url().

D. Jennings, 05/05/99, updated entire module to handle partial URLs and
                       absolute URLs more robustly. Host dependent directory
		       paths are now converted to true URLs before being
		       read from/written to grouping tables.

D. Jennings, 05/05/99, added the following new functions (note, none of these
                       are directly callable by the application)

		       int fits_path2url()
		       int fits_url2path()
		       int fits_get_cwd()
		       int fits_get_url()
		       int fits_clean_url()
		       int fits_relurl2url()
		       int fits_encode_url()
		       int fits_unencode_url()
		       int fits_is_url_absolute()

-----------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
int ffgtcr(fitsfile *fptr,      /* FITS file pointer                         */
	   char    *grpname,    /* name of the grouping table                */
	   int      grouptype,  /* code specifying the type of
				   grouping table information:
				   GT_ID_ALL_URI  0 ==> defualt (all columns)
				   GT_ID_REF      1 ==> ID by reference
				   GT_ID_POS      2 ==> ID by position
				   GT_ID_ALL      3 ==> ID by ref. and position
				   GT_ID_REF_URI 11 ==> (1) + URI info 
				   GT_ID_POS_URI 12 ==> (2) + URI info       */
	   int      *status    )/* return status code                        */

/* 
   create a grouping table at the end of the current FITS file. This
   function makes the last HDU in the file the CHDU, then calls the
   fits_insert_group() function to actually create the new grouping table.
*/

{
  int hdutype;
  int hdunum;


  if(*status != 0) return(*status);


  *status = fits_get_num_hdus(fptr,&hdunum,status);

  /* If hdunum is 0 then we are at the beginning of the file and
     we actually haven't closed the first header yet, so don't do
     anything more */

  if (0 != hdunum) {

      *status = fits_movabs_hdu(fptr,hdunum,&hdutype,status);
  }

  /* Now, the whole point of the above two fits_ calls was to get to
     the end of file.  Let's ignore errors at this point and keep
     going since any error is likely to mean that we are already at the 
     EOF, or the file is fatally corrupted.  If we are at the EOF then
     the next fits_ call will be ok.  If it's corrupted then the
     next call will fail, but that's not big deal at this point.
  */

  if (0 != *status ) *status = 0;

  *status = fits_insert_group(fptr,grpname,grouptype,status);

  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgtis(fitsfile *fptr,      /* FITS file pointer                         */
	   char    *grpname,    /* name of the grouping table                */
	   int      grouptype,  /* code specifying the type of
				   grouping table information:
				   GT_ID_ALL_URI  0 ==> defualt (all columns)
				   GT_ID_REF      1 ==> ID by reference
				   GT_ID_POS      2 ==> ID by position
				   GT_ID_ALL      3 ==> ID by ref. and position
				   GT_ID_REF_URI 11 ==> (1) + URI info 
				   GT_ID_POS_URI 12 ==> (2) + URI info       */
	   int      *status)     /* return status code                       */
	   
/* 
   insert a grouping table just after the current HDU of the current FITS file.
   This is the same as fits_create_group() only it allows the user to select
   the place within the FITS file to add the grouping table.
*/

{

  int tfields  = 0;
  int hdunum   = 0;
  int hdutype  = 0;
  int extver;
  int i;
  
  long pcount  = 0;

  char *ttype[6];
  char *tform[6];

  char ttypeBuff[102];  
  char tformBuff[54];  

  char  extname[] = "GROUPING";
  char  keyword[FLEN_KEYWORD];
  char  keyvalue[FLEN_VALUE];
  char  comment[FLEN_COMMENT];
    
  do
    {

      /* set up the ttype and tform character buffers */

      for(i = 0; i < 6; ++i)
	{
	  ttype[i] = ttypeBuff+(i*17);
	  tform[i] = tformBuff+(i*9);
	}

      /* define the columns required according to the grouptype parameter */

      *status = ffgtdc(grouptype,0,0,0,0,0,0,ttype,tform,&tfields,status);

      /* create the grouping table using the columns defined above */

      *status = fits_insert_btbl(fptr,0,tfields,ttype,tform,NULL,
				 NULL,pcount,status);

      if(*status != 0) continue;

      /*
	 retrieve the hdu position of the new grouping table for
	 future use
      */

      fits_get_hdu_num(fptr,&hdunum);

      /*
	 add the EXTNAME and EXTVER keywords to the HDU just after the 
	 TFIELDS keyword; for now the EXTVER value is set to 0, it will be 
	 set to the correct value later on
      */

      fits_read_keyword(fptr,"TFIELDS",keyvalue,comment,status);

      fits_insert_key_str(fptr,"EXTNAME",extname,
			  "HDU contains a Grouping Table",status);
      fits_insert_key_lng(fptr,"EXTVER",0,"Grouping Table vers. (this file)",
			  status);

      /* 
	 if the grpname parameter value was defined (Non NULL and non zero
	 length) then add the GRPNAME keyword and value
      */

      if(grpname != NULL && strlen(grpname) > 0)
	fits_insert_key_str(fptr,"GRPNAME",grpname,"Grouping Table name",
			    status);

      /* 
	 add the TNULL keywords and values for each integer column defined;
	 integer null values are zero (0) for the MEMBER_POSITION and 
	 MEMBER_VERSION columns.
      */

      for(i = 0; i < tfields && *status == 0; ++i)
	{	  
	  if(strcasecmp(ttype[i],"MEMBER_POSITION") == 0 ||
	     strcasecmp(ttype[i],"MEMBER_VERSION")  == 0)
	    {
	      sprintf(keyword,"TFORM%d",i+1);
	      *status = fits_read_key_str(fptr,keyword,keyvalue,comment,
					  status);
	 
	      sprintf(keyword,"TNULL%d",i+1);

	      *status = fits_insert_key_lng(fptr,keyword,0,"Column Null Value",
					    status);
	    }
	}

      /*
	 determine the correct EXTVER value for the new grouping table
	 by finding the highest numbered grouping table EXTVER value
	 the currently exists
      */

      for(extver = 1;
	  (fits_movnam_hdu(fptr,ANY_HDU,"GROUPING",extver,status)) == 0; 
	  ++extver);

      if(*status == BAD_HDU_NUM) *status = 0;

      /*
	 move back to the new grouping table HDU and update the EXTVER
	 keyword value
      */

      fits_movabs_hdu(fptr,hdunum,&hdutype,status);

      fits_modify_key_lng(fptr,"EXTVER",extver,"&",status);

    }while(0);


  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgtch(fitsfile *gfptr,     /* FITS pointer to group                     */
	   int       grouptype, /* code specifying the type of
				   grouping table information:
				   GT_ID_ALL_URI  0 ==> defualt (all columns)
				   GT_ID_REF      1 ==> ID by reference
				   GT_ID_POS      2 ==> ID by position
				   GT_ID_ALL      3 ==> ID by ref. and position
				   GT_ID_REF_URI 11 ==> (1) + URI info 
				   GT_ID_POS_URI 12 ==> (2) + URI info       */
	   int      *status)     /* return status code                       */


/* 
   Change the grouping table structure of the grouping table pointed to by
   gfptr. The grouptype code specifies the new structure of the table. This
   operation only adds or removes grouping table columns, it does not add
   or delete group members (i.e., table rows). If the grouping table already
   has the desired structure then no operations are performed and function   
   simply returns with a (0) success status code. If the requested structure
   change creates new grouping table columns, then the column values for all
   existing members will be filled with the appropriate null values.
*/

{
  int xtensionCol, extnameCol, extverCol, positionCol, locationCol, uriCol;
  int ncols    = 0;
  int colnum   = 0;
  int nrows    = 0;
  int grptype  = 0;
  int i,j;

  long intNull  = 0;
  long tfields  = 0;
  
  char *tform[6];
  char *ttype[6];

  unsigned char  charNull[1] = {'\0'};

  char ttypeBuff[102];  
  char tformBuff[54];  

  char  keyword[FLEN_KEYWORD];
  char  keyvalue[FLEN_VALUE];
  char  comment[FLEN_COMMENT];


  if(*status != 0) return(*status);

  do
    {
      /* set up the ttype and tform character buffers */

      for(i = 0; i < 6; ++i)
	{
	  ttype[i] = ttypeBuff+(i*17);
	  tform[i] = tformBuff+(i*9);
	}

      /* retrieve positions of all Grouping table reserved columns */

      *status = ffgtgc(gfptr,&xtensionCol,&extnameCol,&extverCol,&positionCol,
		       &locationCol,&uriCol,&grptype,status);

      if(*status != 0) continue;

      /* determine the total number of grouping table columns */

      *status = fits_read_key_lng(gfptr,"TFIELDS",&tfields,comment,status);

      /* define grouping table columns to be added to the configuration */

      *status = ffgtdc(grouptype,xtensionCol,extnameCol,extverCol,positionCol,
		       locationCol,uriCol,ttype,tform,&ncols,status);

      /*
	delete any grouping tables columns that exist but do not belong to
	new desired configuration; note that we delete before creating new
	columns for (file size) efficiency reasons
      */

      switch(grouptype)
	{

	case GT_ID_ALL_URI:

	  /* no columns to be deleted in this case */

	  break;

	case GT_ID_REF:

	  if(positionCol != 0) 
	    {
	      *status = fits_delete_col(gfptr,positionCol,status);
	      --tfields;
	      if(uriCol      > positionCol)  --uriCol;
	      if(locationCol > positionCol) --locationCol;
	    }
	  if(uriCol      != 0)
	    { 
	    *status = fits_delete_col(gfptr,uriCol,status);
	      --tfields;
	      if(locationCol > uriCol) --locationCol;
	    }
	  if(locationCol != 0) 
	    *status = fits_delete_col(gfptr,locationCol,status);

	  break;

	case  GT_ID_POS:

	  if(xtensionCol != 0) 
	    {
	      *status = fits_delete_col(gfptr,xtensionCol,status);
	      --tfields;
	      if(extnameCol  > xtensionCol)  --extnameCol;
	      if(extverCol   > xtensionCol)  --extverCol;
	      if(uriCol      > xtensionCol)  --uriCol;
	      if(locationCol > xtensionCol)  --locationCol;
	    }
	  if(extnameCol  != 0) 
	    {
	      *status = fits_delete_col(gfptr,extnameCol,status);
	      --tfields;
	      if(extverCol   > extnameCol)  --extverCol;
	      if(uriCol      > extnameCol)  --uriCol;
	      if(locationCol > extnameCol)  --locationCol;
	    }
	  if(extverCol   != 0)
	    { 
	      *status = fits_delete_col(gfptr,extverCol,status);
	      --tfields;
	      if(uriCol      > extverCol)  --uriCol;
	      if(locationCol > extverCol)  --locationCol;
	    }
	  if(uriCol      != 0)
	    { 
	      *status = fits_delete_col(gfptr,uriCol,status);
	      --tfields;
	      if(locationCol > uriCol)  --locationCol;
	    }
	  if(locationCol != 0)
	    { 
	      *status = fits_delete_col(gfptr,locationCol,status);
	      --tfields;
	    }
	  
	  break;

	case  GT_ID_ALL:

	  if(uriCol      != 0) 
	    {
	      *status = fits_delete_col(gfptr,uriCol,status);
	      --tfields;
	      if(locationCol > uriCol)  --locationCol;
	    }
	  if(locationCol != 0)
	    { 
	      *status = fits_delete_col(gfptr,locationCol,status);
	      --tfields;
	    }

	  break;

	case GT_ID_REF_URI:

	  if(positionCol != 0)
	    { 
	      *status = fits_delete_col(gfptr,positionCol,status);
	      --tfields;
	    }

	  break;

	case  GT_ID_POS_URI:

	  if(xtensionCol != 0) 
	    {
	      *status = fits_delete_col(gfptr,xtensionCol,status);
	      --tfields;
	      if(extnameCol > xtensionCol)  --extnameCol;
	      if(extverCol  > xtensionCol)  --extverCol;
	    }
	  if(extnameCol  != 0)
	    { 
	      *status = fits_delete_col(gfptr,extnameCol,status);
	      --tfields;
	      if(extverCol > extnameCol)  --extverCol;
	    }
	  if(extverCol   != 0)
	    { 
	      *status = fits_delete_col(gfptr,extverCol,status);
	      --tfields;
	    }

	  break;

	default:

	  *status = BAD_OPTION;
	  ffpmsg("Invalid value for grouptype parameter specified (ffgtch)");
	  break;

	}

      /*
	add all the new grouping table columns that were not there
	previously but are called for by the grouptype parameter
      */

      for(i = 0; i < ncols && *status == 0; ++i)
	*status = fits_insert_col(gfptr,tfields+i+1,ttype[i],tform[i],status);

      /* 
	 add the TNULL keywords and values for each new integer column defined;
	 integer null values are zero (0) for the MEMBER_POSITION and 
	 MEMBER_VERSION columns. Insert a null ("/0") into each new string
	 column defined: MEMBER_XTENSION, MEMBER_NAME, MEMBER_URI_TYPE and
	 MEMBER_LOCATION. Note that by convention a null string is the
	 TNULL value for character fields so no TNULL is required.
      */

      for(i = 0; i < ncols && *status == 0; ++i)
	{	  
	  if(strcasecmp(ttype[i],"MEMBER_POSITION") == 0 ||
	     strcasecmp(ttype[i],"MEMBER_VERSION")  == 0)
	    {
	      /* col contains int data; set TNULL and insert 0 for each col */

	      *status = fits_get_colnum(gfptr,CASESEN,ttype[i],&colnum,
					status);
	      
	      sprintf(keyword,"TFORM%d",colnum);

	      *status = fits_read_key_str(gfptr,keyword,keyvalue,comment,
					  status);
	 
	      sprintf(keyword,"TNULL%d",colnum);

	      *status = fits_insert_key_lng(gfptr,keyword,0,
					    "Column Null Value",status);

	      for(j = 1; j <= nrows && *status == 0; ++j)
		*status = fits_write_col_lng(gfptr,colnum,j,1,1,&intNull,
					     status);
	    }
	  else if(strcasecmp(ttype[i],"MEMBER_XTENSION") == 0 ||
		  strcasecmp(ttype[i],"MEMBER_NAME")     == 0 ||
		  strcasecmp(ttype[i],"MEMBER_URI_TYPE") == 0 ||
		  strcasecmp(ttype[i],"MEMBER_LOCATION") == 0)
	    {

	      /* new col contains character data; insert NULLs into each col */

	      *status = fits_get_colnum(gfptr,CASESEN,ttype[i],&colnum,
					status);

	      for(j = 1; j <= nrows && *status == 0; ++j)
	    /* WILL THIS WORK FOR VAR LENTH CHAR COLS??????*/
		*status = fits_write_col_byt(gfptr,colnum,j,1,1,charNull,
					     status);
	    }
	}

    }while(0);

  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgtrm(fitsfile *gfptr,  /* FITS file pointer to group                   */
	   int       rmopt,  /* code specifying if member
				elements are to be deleted:
				OPT_RM_GPT ==> remove only group table
				OPT_RM_ALL ==> recursively remove members
				and their members (if groups)                */
	   int      *status) /* return status code                           */
	    
/*
  remove a grouping table, and optionally all its members. Any groups 
  containing the grouping table are updated, and all members (if not 
  deleted) have their GRPIDn and GRPLCn keywords updated accordingly. 
  If the (deleted) members are members of another grouping table then those
  tables are also updated. The CHDU of the FITS file pointed to by gfptr must 
  be positioned to the grouping table to be deleted.
*/

{
  int hdutype;

  long i;
  long nmembers = 0;

  HDUtracker HDU;
  

  if(*status != 0) return(*status);

  /*
     remove the grouping table depending upon the rmopt parameter
  */

  switch(rmopt)
    {

    case OPT_RM_GPT:

      /*
	 for this option, the grouping table is deleted, but the member
	 HDUs remain; in this case we only have to remove each member from
	 the grouping table by calling fits_remove_member() with the
	 OPT_RM_ENTRY option
      */

      /* get the number of members contained by this table */

      *status = fits_get_num_members(gfptr,&nmembers,status);

      /* loop over all grouping table members and remove them */

      for(i = nmembers; i > 0 && *status == 0; --i)
	*status = fits_remove_member(gfptr,i,OPT_RM_ENTRY,status);
      
	break;

    case OPT_RM_ALL:

      /*
	for this option the entire Group is deleted -- this includes all
	members and their members (if grouping tables themselves). Call 
	the recursive form of this function to perform the removal.
      */

      /* add the current grouping table to the HDUtracker struct */

      HDU.nHDU = 0;

      *status = fftsad(gfptr,&HDU,NULL,NULL);

      /* call the recursive group remove function */

      *status = ffgtrmr(gfptr,&HDU,status);

      /* free the memory allocated to the HDUtracker struct */

      for(i = 0; i < HDU.nHDU; ++i)
	{
	  free(HDU.filename[i]);
	  free(HDU.newFilename[i]);
	}

      break;

    default:
      
      *status = BAD_OPTION;
      ffpmsg("Invalid value for the rmopt parameter specified (ffgtrm)");
      break;

     }

  /*
     if all went well then unlink and delete the grouping table HDU
  */

  *status = ffgmul(gfptr,0,status);

  *status = fits_delete_hdu(gfptr,&hdutype,status);
      
  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgtcp(fitsfile *infptr,  /* input FITS file pointer                     */
	   fitsfile *outfptr, /* output FITS file pointer                    */
	   int        cpopt,  /* code specifying copy options:
				OPT_GCP_GPT (0) ==> copy only grouping table
				OPT_GCP_ALL (2) ==> recusrively copy members 
				                    and their members (if 
						    groups)                  */
	   int      *status)  /* return status code                          */

/*
  copy a grouping table, and optionally all its members, to a new FITS file.
  If the cpopt is set to OPT_GCP_GPT (copy grouping table only) then the 
  existing members have their GRPIDn and GRPLCn keywords updated to reflect 
  the existance of the new group, since they now belong to another group. If 
  cpopt is set to OPT_GCP_ALL (copy grouping table and members recursively) 
  then the original members are not updated; the new grouping table is 
  modified to include only the copied member HDUs and not the original members.

  Note that the recursive version of this function, ffgtcpr(), is called
  to perform the group table copy. In the case of cpopt == OPT_GCP_GPT
  ffgtcpr() does not actually use recursion.
*/

{
  int i;

  HDUtracker HDU;


  if(*status != 0) return(*status);

  /* make sure infptr and outfptr are not the same pointer */

  if(infptr == outfptr) *status = IDENTICAL_POINTERS;
  else
    {

      /* initialize the HDUtracker struct */
      
      HDU.nHDU = 0;
      
      *status = fftsad(infptr,&HDU,NULL,NULL);
      
      /* 
	 call the recursive form of this function to copy the grouping table. 
	 If the cpopt is OPT_GCP_GPT then there is actually no recursion
	 performed
      */

      *status = ffgtcpr(infptr,outfptr,cpopt,&HDU,status);
  
      /* free memory allocated for the HDUtracker struct */

      for(i = 0; i < HDU.nHDU; ++i) 
	{
	  free(HDU.filename[i]);
	  free(HDU.newFilename[i]);
	}
    }

  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgtmg(fitsfile *infptr,  /* FITS file ptr to source grouping table      */
	   fitsfile *outfptr, /* FITS file ptr to target grouping table      */
	   int       mgopt,   /* code specifying merge options:
				 OPT_MRG_COPY (0) ==> copy members to target
				                      group, leaving source 
						      group in place
				 OPT_MRG_MOV  (1) ==> move members to target
				                      group, source group is
						      deleted after merge    */
	   int      *status)   /* return status code                         */
     

/*
  merge two grouping tables by combining their members into a single table. 
  The source grouping table must be the CHDU of the fitsfile pointed to by 
  infptr, and the target grouping table must be the CHDU of the fitsfile to by 
  outfptr. All members of the source grouping table shall be copied to the
  target grouping table. If the mgopt parameter is OPT_MRG_COPY then the source
  grouping table continues to exist after the merge. If the mgopt parameter
  is OPT_MRG_MOV then the source grouping table is deleted after the merge, 
  and all member HDUs are updated accordingly.
*/
{
  long i ;
  long nmembers = 0;

  fitsfile *tmpfptr = NULL;


  if(*status != 0) return(*status);

  do
    {

      *status = fits_get_num_members(infptr,&nmembers,status);

      for(i = 1; i <= nmembers && *status == 0; ++i)
	{
	  *status = fits_open_member(infptr,i,&tmpfptr,status);
	  *status = fits_add_group_member(outfptr,tmpfptr,0,status);

	  if(*status == HDU_ALREADY_MEMBER) *status = 0;

	  if(tmpfptr != NULL)
	    {
	      fits_close_file(tmpfptr,status);
	      tmpfptr = NULL;
	    }
	}

      if(*status != 0) continue;

      if(mgopt == OPT_MRG_MOV) 
	*status = fits_remove_group(infptr,OPT_RM_GPT,status);

    }while(0);

  if(tmpfptr != NULL)
    {
      fits_close_file(tmpfptr,status);
    }

  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgtcm(fitsfile *gfptr,  /* FITS file pointer to grouping table          */
	   int       cmopt,  /* code specifying compact options
				OPT_CMT_MBR      (1) ==> compact only direct 
			                                 members (if groups)
				OPT_CMT_MBR_DEL (11) ==> (1) + delete all 
				                         compacted groups    */
	   int      *status) /* return status code                           */
    
/*
  "Compact" a group pointed to by the FITS file pointer gfptr. This 
  is achieved by flattening the tree structure of a group and its 
  (grouping table) members. All members HDUs of a grouping table which is 
  itself a member of the grouping table gfptr are added to gfptr. Optionally,
  the grouping tables which are "compacted" are deleted. If the grouping 
  table contains no members that are themselves grouping tables then this 
  function performs a NOOP.
*/

{
  long i;
  long nmembers = 0;

  char keyvalue[FLEN_VALUE];
  char comment[FLEN_COMMENT];

  fitsfile *mfptr = NULL;


  if(*status != 0) return(*status);

  do
    {
      if(cmopt != OPT_CMT_MBR && cmopt != OPT_CMT_MBR_DEL)
	{
	  *status = BAD_OPTION;
	  ffpmsg("Invalid value for cmopt parameter specified (ffgtcm)");
	  continue;
	}

      /* reteive the number of grouping table members */

      *status = fits_get_num_members(gfptr,&nmembers,status);

      /*
	loop over all the grouping table members; if the member is a 
	grouping table then merge its members with the parent grouping 
	table 
      */

      for(i = 1; i <= nmembers && *status == 0; ++i)
	{
	  *status = fits_open_member(gfptr,i,&mfptr,status);

	  if(*status != 0) continue;

	  *status = fits_read_key_str(mfptr,"EXTNAME",keyvalue,comment,status);

	  /* if no EXTNAME keyword then cannot be a grouping table */

	  if(*status == KEY_NO_EXIST) 
	    {
	      *status = 0;
	      continue;
	    }
	  prepare_keyvalue(keyvalue);

	  if(*status != 0) continue;

	  /* if EXTNAME == "GROUPING" then process member as grouping table */

	  if(strcasecmp(keyvalue,"GROUPING") == 0)
	    {
	      /* merge the member (grouping table) into the grouping table */

	      *status = fits_merge_groups(mfptr,gfptr,OPT_MRG_COPY,status);

	      *status = fits_close_file(mfptr,status);
	      mfptr = NULL;

	      /* 
		 remove the member from the grouping table now that all of
		 its members have been transferred; if cmopt is set to
		 OPT_CMT_MBR_DEL then remove and delete the member
	      */

	      if(cmopt == OPT_CMT_MBR)
		*status = fits_remove_member(gfptr,i,OPT_RM_ENTRY,status);
	      else
		*status = fits_remove_member(gfptr,i,OPT_RM_MBR,status);
	    }
	  else
	    {
	      /* not a grouping table; just close the opened member */

	      *status = fits_close_file(mfptr,status);
	      mfptr = NULL;
	    }
	}

    }while(0);

  return(*status);
}

/*--------------------------------------------------------------------------*/
int ffgtvf(fitsfile *gfptr,       /* FITS file pointer to group             */
	   long     *firstfailed, /* Member ID (if positive) of first failed
				     member HDU verify check or GRPID index
				     (if negitive) of first failed group
				     link verify check.                     */
	   int      *status)      /* return status code                     */

/*
 check the integrity of a grouping table to make sure that all group members 
 are accessible and all the links to other grouping tables are valid. The
 firstfailed parameter returns the member ID of the first member HDU to fail
 verification if positive or the first group link to fail if negative; 
 otherwise firstfailed contains a return value of 0.
*/

{
  long i;
  long nmembers = 0;
  long ngroups  = 0;

  char errstr[FLEN_VALUE];

  fitsfile *fptr = NULL;


  if(*status != 0) return(*status);

  *firstfailed = 0;

  do
    {
      /*
	attempt to open all the members of the grouping table. We stop
	at the first member which cannot be opened (which implies that it
	cannot be located)
      */

      *status = fits_get_num_members(gfptr,&nmembers,status);

      for(i = 1; i <= nmembers && *status == 0; ++i)
	{
	  *status = fits_open_member(gfptr,i,&fptr,status);
	  fits_close_file(fptr,status);
	}

      /*
	if the status is non-zero from the above loop then record the
	member index that caused the error
      */

      if(*status != 0)
	{
	  *firstfailed = i;
	  sprintf(errstr,"Group table verify failed for member %ld (ffgtvf)",
		  i);
	  ffpmsg(errstr);
	  continue;
	}

      /*
	attempt to open all the groups linked to this grouping table. We stop
	at the first group which cannot be opened (which implies that it
	cannot be located)
      */

      *status = fits_get_num_groups(gfptr,&ngroups,status);

      for(i = 1; i <= ngroups && *status == 0; ++i)
	{
	  *status = fits_open_group(gfptr,i,&fptr,status);
	  fits_close_file(fptr,status);
	}

      /*
	if the status from the above loop is non-zero, then record the
	GRPIDn index of the group that caused the failure
      */

      if(*status != 0)
	{
	  *firstfailed = -1*i;
	  sprintf(errstr,
		  "Group table verify failed for GRPID index %ld (ffgtvf)",i);
	  ffpmsg(errstr);
	  continue;
	}

    }while(0);

  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgtop(fitsfile *mfptr,  /* FITS file pointer to the member HDU          */
	   int       grpid,  /* group ID (GRPIDn index) within member HDU    */
	   fitsfile **gfptr, /* FITS file pointer to grouping table HDU      */
	   int      *status) /* return status code                           */

/*
  open the grouping table that contains the member HDU. The member HDU must
  be the CHDU of the FITS file pointed to by mfptr, and the grouping table
  is identified by the Nth index number of the GRPIDn keywords specified in 
  the member HDU's header. The fitsfile gfptr pointer is positioned with the
  appropriate FITS file with the grouping table as the CHDU. If the group
  grouping table resides in a file other than the member then an attempt
  is first made to open the file readwrite, and failing that readonly.
 
  Note that it is possible for the GRPIDn/GRPLCn keywords in a member 
  header to be non-continuous, e.g., GRPID1, GRPID2, GRPID5, GRPID6. In 
  such cases, the grpid index value specified in the function call shall
  identify the (grpid)th GRPID value. In the above example, if grpid == 3,
  then the group specified by GRPID5 would be opened.
*/
{
  int i;
  int found;

  long ngroups   = 0;
  long grpExtver = 0;

  char keyword[FLEN_KEYWORD];
  char keyvalue[FLEN_FILENAME];
  char *tkeyvalue;
  char location[FLEN_FILENAME];
  char location1[FLEN_FILENAME];
  char location2[FLEN_FILENAME];
  char comment[FLEN_COMMENT];

  char *url[2];


  if(*status != 0) return(*status);

  do
    {
      /* set the grouping table pointer to NULL for error checking later */

      *gfptr = NULL;

      /*
	make sure that the group ID requested is valid ==> cannot be
	larger than the number of GRPIDn keywords in the member HDU header
      */

      *status = fits_get_num_groups(mfptr,&ngroups,status);

      if(grpid > ngroups)
	{
	  *status = BAD_GROUP_ID;
	  sprintf(comment,
		  "GRPID index %d larger total GRPID keywords %ld (ffgtop)",
		  grpid,ngroups);
	  ffpmsg(comment);
	  continue;
	}

      /*
	find the (grpid)th group that the member HDU belongs to and read
	the value of the GRPID(grpid) keyword; fits_get_num_groups()
	automatically re-enumerates the GRPIDn/GRPLCn keywords to fill in
	any gaps
      */

      sprintf(keyword,"GRPID%d",grpid);

      *status = fits_read_key_lng(mfptr,keyword,&grpExtver,comment,status);

      if(*status != 0) continue;

      /*
	if the value of the GRPIDn keyword is positive then the member is
	in the same FITS file as the grouping table and we only have to
	reopen the current FITS file. Else the member and grouping table
	HDUs reside in different files and another FITS file must be opened
	as specified by the corresponding GRPLCn keyword
	
	The DO WHILE loop only executes once and is used to control the
	file opening logic.
      */

      do
	{
	  if(grpExtver > 0) 
	    {
	      /*
		the member resides in the same file as the grouping
		 table, so just reopen the grouping table file
	      */

	      *status = fits_reopen_file(mfptr,gfptr,status);
	      continue;
	    }

	  else if(grpExtver == 0)
	    {
	      /* a GRPIDn value of zero (0) is undefined */

	      *status = BAD_GROUP_ID;
	      sprintf(comment,"Invalid value of %ld for GRPID%d (ffgtop)",
		      grpExtver,grpid);
	      ffpmsg(comment);
	      continue;
	    }

	  /* 
	     The GRPLCn keyword value is negative, which implies that
	     the grouping table must reside in another FITS file;
	     search for the corresponding GRPLCn keyword 
	  */
	  
	  /* set the grpExtver value positive */
  
	  grpExtver = -1*grpExtver;

	  /* read the GRPLCn keyword value */

	  sprintf(keyword,"GRPLC%d",grpid);
	  /* SPR 1738 */
	  *status = fits_read_key_longstr(mfptr,keyword,&tkeyvalue,comment,
				      status);
	  if (0 == *status) {
	    strcpy(keyvalue,tkeyvalue);
	    free(tkeyvalue);
	  }
	  

	  /* if the GRPLCn keyword was not found then there is a problem */

	  if(*status == KEY_NO_EXIST)
	    {
	      *status = BAD_GROUP_ID;

	      sprintf(comment,"Cannot find GRPLC%d keyword (ffgtop)",
		      grpid);
	      ffpmsg(comment);

	      continue;
	    }

	  prepare_keyvalue(keyvalue);

	  /*
	    if the GRPLCn keyword value specifies an absolute URL then
	    try to open the file; we cannot attempt any relative URL
	    or host-dependent file path reconstruction
	  */

	  if(fits_is_url_absolute(keyvalue))
	    {
	      ffpmsg("Try to open group table file as absolute URL (ffgtop)");

	      *status = fits_open_file(gfptr,keyvalue,READWRITE,status);

	      /* if the open was successful then continue */

	      if(*status == 0) continue;

	      /* if READWRITE failed then try opening it READONLY */

	      ffpmsg("OK, try open group table file as READONLY (ffgtop)");
	      
	      *status = 0;
	      *status = fits_open_file(gfptr,keyvalue,READONLY,status);

	      /* continue regardless of the outcome */

	      continue;
	    }

	  /*
	    see if the URL gives a file path that is absolute on the
	    host machine 
	  */

	  *status = fits_url2path(keyvalue,location1,status);

	  *status = fits_open_file(gfptr,location1,READWRITE,status);

	  /* if the file opened then continue */

	  if(*status == 0) continue;

	  /* if READWRITE failed then try opening it READONLY */

	  ffpmsg("OK, try open group table file as READONLY (ffgtop)");
	  
	  *status = 0;
	  *status = fits_open_file(gfptr,location1,READONLY,status);

	  /* if the file opened then continue */

	  if(*status == 0) continue;

	  /*
	    the grouping table location given by GRPLCn must specify a 
	    relative URL. We assume that this URL is relative to the 
	    member HDU's FITS file. Try to construct a full URL location 
	    for the grouping table's FITS file and then open it
	  */

	  *status = 0;
		  
	  /* retrieve the URL information for the member HDU's file */
		  
	  url[0] = location1; url[1] = location2;
		  
	  *status = fits_get_url(mfptr,url[0],url[1],NULL,NULL,NULL,status);

	  /*
	    It is possible that the member HDU file has an initial
	    URL it was opened with and a real URL that the file actually
	    exists at (e.g., an HTTP accessed file copied to a local
	    file). For each possible URL try to construct a
	  */
		  
	  for(i = 0, found = 0, *gfptr = NULL; i < 2 && !found; ++i)
	    {
	      
	      /* the url string could be empty */
	      
	      if(*url[i] == 0) continue;
	      
	      /* 
		 create a full URL from the partial and the member
		 HDU file URL
	      */
	      
	      *status = fits_relurl2url(url[i],keyvalue,location,status);
	      
	      /* if an error occured then contniue */
	      
	      if(*status != 0) 
		{
		  *status = 0;
		  continue;
		}
	      
	      /*
		if the location does not specify an access method
		then turn it into a host dependent path
	      */

	      if(! fits_is_url_absolute(location))
		{
		  *status = fits_url2path(location,url[i],status);
		  strcpy(location,url[i]);
		}
	      
	      /* try to open the grouping table file READWRITE */
	      
	      *status = fits_open_file(gfptr,location,READWRITE,status);
	      
	      if(*status != 0)
		{    
		  /* try to open the grouping table file READONLY */
		  
		  ffpmsg("opening file as READWRITE failed (ffgtop)");
		  ffpmsg("OK, try to open file as READONLY (ffgtop)");
		  *status = 0;
		  *status = fits_open_file(gfptr,location,READONLY,status);
		}
	      
	      /* either set the found flag or reset the status flag */
	      
	      if(*status == 0) 
		found = 1;
	      else
		*status = 0;
	    }

	}while(0); /* end of file opening loop */

      /* if an error occured with the file opening then exit */

      if(*status != 0) continue;
  
      if(*gfptr == NULL)
	{
	  ffpmsg("Cannot open or find grouping table FITS file (ffgtop)");
	  *status = GROUP_NOT_FOUND;
	  continue;
	}

      /* search for the grouping table in its FITS file */

      *status = fits_movnam_hdu(*gfptr,ANY_HDU,"GROUPING",(int)grpExtver,
				status);

      if(*status != 0) *status = GROUP_NOT_FOUND;

    }while(0);

  if(*status != 0 && *gfptr != NULL) 
    {
      fits_close_file(*gfptr,status);
      *gfptr = NULL;
    }

  return(*status);
}
/*---------------------------------------------------------------------------*/
int ffgtam(fitsfile *gfptr,   /* FITS file pointer to grouping table HDU     */
	   fitsfile *mfptr,   /* FITS file pointer to member HDU             */
	   int       hdupos,  /* member HDU position IF in the same file as
			         the grouping table AND mfptr == NULL        */
	   int      *status)  /* return status code                          */
 
/*
  add a member HDU to an existing grouping table. The fitsfile pointer gfptr
  must be positioned with the grouping table as the CHDU. The member HDU
  may either be identifed with the fitsfile *mfptr (which must be positioned
  to the member HDU) or the hdupos parameter (the HDU number of the member 
  HDU) if both reside in the same FITS file. The hdupos value is only used
  if the mfptr parameter has a value of NULL (0). The new member HDU shall 
  have the appropriate GRPIDn and GRPLCn keywords created in its header.

  Note that if the member HDU to be added to the grouping table is already
  a member of the group then it will not be added a sceond time.
*/

{
  int xtensionCol,extnameCol,extverCol,positionCol,locationCol,uriCol;
  int memberPosition = 0;
  int grptype        = 0;
  int hdutype        = 0;
  int useLocation    = 0;
  int nkeys          = 6;
  int found;
  int i;

  int memberIOstate;
  int groupIOstate;
  int iomode;

  long memberExtver = 0;
  long groupExtver  = 0;
  long memberID     = 0;
  long nmembers     = 0;
  long ngroups      = 0;
  long grpid        = 0;

  char memberAccess1[FLEN_VALUE];
  char memberAccess2[FLEN_VALUE];
  char memberFileName[FLEN_FILENAME];
  char memberLocation[FLEN_FILENAME];
  char grplc[FLEN_FILENAME];
  char *tgrplc;
  char memberHDUtype[FLEN_VALUE];
  char memberExtname[FLEN_VALUE];
  char memberURI[] = "URL";

  char groupAccess1[FLEN_VALUE];
  char groupAccess2[FLEN_VALUE];
  char groupFileName[FLEN_FILENAME];
  char groupLocation[FLEN_FILENAME];
  char tmprootname[FLEN_FILENAME], grootname[FLEN_FILENAME];
  char cwd[FLEN_FILENAME];

  char *keys[] = {"GRPNAME","EXTVER","EXTNAME","TFIELDS","GCOUNT","EXTEND"};
  char *tmpPtr[1];

  char keyword[FLEN_KEYWORD];
  char card[FLEN_CARD];

  unsigned char charNull[]  = {'\0'};

  fitsfile *tmpfptr = NULL;

  int parentStatus = 0;

  if(*status != 0) return(*status);

  do
    {
      /*
	make sure the grouping table can be modified before proceeding
      */

      fits_file_mode(gfptr,&iomode,status);

      if(iomode != READWRITE)
	{
	  ffpmsg("cannot modify grouping table (ffgtam)");
	  *status = BAD_GROUP_ATTACH;
	  continue;
	}

      /*
	 if the calling function supplied the HDU position of the member
	 HDU instead of fitsfile pointer then get a fitsfile pointer
      */

      if(mfptr == NULL)
	{
	  *status = fits_reopen_file(gfptr,&tmpfptr,status);
	  *status = fits_movabs_hdu(tmpfptr,hdupos,&hdutype,status);

	  if(*status != 0) continue;
	}
      else
	tmpfptr = mfptr;

      /*
	 determine all the information about the member HDU that will
	 be needed later; note that we establish the default values for
	 all information values that are not explicitly found
      */

      *status = fits_read_key_str(tmpfptr,"XTENSION",memberHDUtype,card,
				  status);

      if(*status == KEY_NO_EXIST) 
	{
	  strcpy(memberHDUtype,"PRIMARY");
	  *status = 0;
	}
      prepare_keyvalue(memberHDUtype);

      *status = fits_read_key_lng(tmpfptr,"EXTVER",&memberExtver,card,status);

      if(*status == KEY_NO_EXIST) 
	{
	  memberExtver = 1;
	  *status      = 0;
	}

      *status = fits_read_key_str(tmpfptr,"EXTNAME",memberExtname,card,
				  status);

      if(*status == KEY_NO_EXIST) 
	{
	  memberExtname[0] = 0;
	  *status          = 0;
	}
      prepare_keyvalue(memberExtname);

      fits_get_hdu_num(tmpfptr,&memberPosition);

      /*
	Determine if the member HDU's FITS file location needs to be
	taken into account when building its grouping table reference

	If the member location needs to be used (==> grouping table and member
	HDU reside in different files) then create an appropriate URL for
	the member HDU's file and grouping table's file. Note that the logic
	for this is rather complicated
      */

      /* SPR 3463, don't do this 
	 if(tmpfptr->Fptr == gfptr->Fptr)
	 {  */
	  /*
	    member HDU and grouping table reside in the same file, no need
	    to use the location information */
	  
      /* printf ("same file\n");
	   
	   useLocation     = 0;
	   memberIOstate   = 1;
	   *memberFileName = 0;
	}
      else
      { */ 
	  /*
	     the member HDU and grouping table FITS file location information 
	     must be used.

	     First determine the correct driver and file name for the group
	     table and member HDU files. If either are disk files then
	     construct an absolute file path for them. Finally, if both are
	     disk files construct relative file paths from the group(member)
	     file to the member(group) file.

	  */

	  /* set the USELOCATION flag to true */

	  useLocation = 1;

	  /* 
	     get the location, access type and iostate (RO, RW) of the
	     member HDU file
	  */

	  *status = fits_get_url(tmpfptr,memberFileName,memberLocation,
				 memberAccess1,memberAccess2,&memberIOstate,
				 status);

	  /*
	     if the memberFileName string is empty then use the values of
	     the memberLocation string. This corresponds to a file where
	     the "real" file is a temporary memory file, and we must assume
	     the the application really wants the original file to be the
	     group member
	   */

	  if(strlen(memberFileName) == 0)
	    {
	      strcpy(memberFileName,memberLocation);
	      strcpy(memberAccess1,memberAccess2);
	    }

	  /* 
	     get the location, access type and iostate (RO, RW) of the
	     grouping table file
	  */

	  *status = fits_get_url(gfptr,groupFileName,groupLocation,
				 groupAccess1,groupAccess2,&groupIOstate,
				 status);
	  
	  if(*status != 0) continue;

	  /*
	    the grouping table file must be writable to continue
	  */

	  if(groupIOstate == 0)
	    {
	      ffpmsg("cannot modify grouping table (ffgtam)");
	      *status = BAD_GROUP_ATTACH;
	      continue;
	    }

	  /*
	    determine how to construct the resulting URLs for the member and
	    group files
	  */

	  if(strcasecmp(groupAccess1,"file://")  &&
	                                   strcasecmp(memberAccess1,"file://"))
	    {
              *cwd = 0;
	      /* 
		 nothing to do in this case; both the member and group files
		 must be of an access type that already gives valid URLs;
		 i.e., URLs that we can pass directly to the file drivers
	      */
	    }
	  else
	    {
	      /*
		 retrieve the Current Working Directory as a Unix-like
		 URL standard string
	      */

	      *status = fits_get_cwd(cwd,status);

	      /*
		 create full file path for the member HDU FITS file URL
		 if it is of access type file://
	      */
	      
	      if(strcasecmp(memberAccess1,"file://") == 0)
		{
		  if(*memberFileName == '/')
		    {
		      strcpy(memberLocation,memberFileName);
		    }
		  else
		    {
		      strcpy(memberLocation,cwd);
		      strcat(memberLocation,"/");
		      strcat(memberLocation,memberFileName);
		    }
		  
		  *status = fits_clean_url(memberLocation,memberFileName,
					   status);
		}

	      /*
		 create full file path for the grouping table HDU FITS file URL
		 if it is of access type file://
	      */

	      if(strcasecmp(groupAccess1,"file://") == 0)
		{
		  if(*groupFileName == '/')
		    {
		      strcpy(groupLocation,groupFileName);
		    }
		  else
		    {
		      strcpy(groupLocation,cwd);
		      strcat(groupLocation,"/");
		      strcat(groupLocation,groupFileName);
		    }
		  
		  *status = fits_clean_url(groupLocation,groupFileName,status);
		}

	      /*
		if both the member and group files are disk files then 
		create a relative path (relative URL) strings with 
		respect to the grouping table's file and the grouping table's 
		file with respect to the member HDU's file
	      */
	      
	      if(strcasecmp(groupAccess1,"file://") == 0 &&
		                      strcasecmp(memberAccess1,"file://") == 0)
		{
		  fits_url2relurl(memberFileName,groupFileName,
				                  groupLocation,status);
		  fits_url2relurl(groupFileName,memberFileName,
				                  memberLocation,status);

		  /*
		     copy the resulting partial URL strings to the
		     memberFileName and groupFileName variables for latter
		     use in the function
		   */
		    
		  strcpy(memberFileName,memberLocation);
		  strcpy(groupFileName,groupLocation);		  
		}
	    }
	  /* beo done */
	  /* }  */
      

      /* retrieve the grouping table's EXTVER value */

      *status = fits_read_key_lng(gfptr,"EXTVER",&groupExtver,card,status);

      /* 
	 if useLocation is true then make the group EXTVER value negative
	 for the subsequent GRPIDn/GRPLCn matching
      */
      /* SPR 3463 change test;  WDP added test for same filename */
      /* Now, if either the Fptr values are the same, or the root filenames
         are the same, then assume these refer to the same file.
      */
      fits_parse_rootname(tmpfptr->Fptr->filename, tmprootname, status);
      fits_parse_rootname(gfptr->Fptr->filename, grootname, status);

      if((tmpfptr->Fptr != gfptr->Fptr) && 
          strncmp(tmprootname, grootname, FLEN_FILENAME))
	   groupExtver = -1*groupExtver;

      /* retrieve the number of group members */

      *status = fits_get_num_members(gfptr,&nmembers,status);
	      
    do {

      /*
	 make sure the member HDU is not already an entry in the
	 grouping table before adding it
      */

      *status = ffgmf(gfptr,memberHDUtype,memberExtname,memberExtver,
		      memberPosition,memberFileName,&memberID,status);

      if(*status == MEMBER_NOT_FOUND) *status = 0;
      else if(*status == 0)
	{  
	  parentStatus = HDU_ALREADY_MEMBER;
    ffpmsg("Specified HDU is already a member of the Grouping table (ffgtam)");
	  continue;
	}
      else continue;

      /*
	 if the member HDU is not already recorded in the grouping table
	 then add it 
      */

      /* add a new row to the grouping table */

      *status = fits_insert_rows(gfptr,nmembers,1,status);
      ++nmembers;

      /* retrieve the grouping table column IDs and structure type */

      *status = ffgtgc(gfptr,&xtensionCol,&extnameCol,&extverCol,&positionCol,
		       &locationCol,&uriCol,&grptype,status);

      /* fill in the member HDU data in the new grouping table row */

      *tmpPtr = memberHDUtype; 

      if(xtensionCol != 0)
	fits_write_col_str(gfptr,xtensionCol,nmembers,1,1,tmpPtr,status);

      *tmpPtr = memberExtname; 

      if(extnameCol  != 0)
	{
	  if(strlen(memberExtname) != 0)
	    fits_write_col_str(gfptr,extnameCol,nmembers,1,1,tmpPtr,status);
	  else
	    /* WILL THIS WORK FOR VAR LENTH CHAR COLS??????*/
	    fits_write_col_byt(gfptr,extnameCol,nmembers,1,1,charNull,status);
	}

      if(extverCol   != 0)
	fits_write_col_lng(gfptr,extverCol,nmembers,1,1,&memberExtver,
			   status);

      if(positionCol != 0)
	fits_write_col_int(gfptr,positionCol,nmembers,1,1,
			   &memberPosition,status);

      *tmpPtr = memberFileName; 

      if(locationCol != 0)
	{
	  /* Change the test for SPR 3463 */
	  /* Now, if either the Fptr values are the same, or the root filenames
	     are the same, then assume these refer to the same file.
	  */
	  fits_parse_rootname(tmpfptr->Fptr->filename, tmprootname, status);
	  fits_parse_rootname(gfptr->Fptr->filename, grootname, status);

	  if((tmpfptr->Fptr != gfptr->Fptr) && 
	          strncmp(tmprootname, grootname, FLEN_FILENAME))
	    fits_write_col_str(gfptr,locationCol,nmembers,1,1,tmpPtr,status);
	  else
	    /* WILL THIS WORK FOR VAR LENTH CHAR COLS??????*/
	    fits_write_col_byt(gfptr,locationCol,nmembers,1,1,charNull,status);
	}

      *tmpPtr = memberURI;

      if(uriCol      != 0)
	{

	  /* Change the test for SPR 3463 */
	  /* Now, if either the Fptr values are the same, or the root filenames
	     are the same, then assume these refer to the same file.
	  */
	  fits_parse_rootname(tmpfptr->Fptr->filename, tmprootname, status);
	  fits_parse_rootname(gfptr->Fptr->filename, grootname, status);

	  if((tmpfptr->Fptr != gfptr->Fptr) && 
	          strncmp(tmprootname, grootname, FLEN_FILENAME))
	    fits_write_col_str(gfptr,uriCol,nmembers,1,1,tmpPtr,status);
	  else
	    /* WILL THIS WORK FOR VAR LENTH CHAR COLS??????*/
	    fits_write_col_byt(gfptr,uriCol,nmembers,1,1,charNull,status);
	}
    } while(0);

      if(0 != *status) continue;
      /*
	 add GRPIDn/GRPLCn keywords to the member HDU header to link
	 it to the grouing table if the they do not already exist and
	 the member file is RW
      */

      fits_file_mode(tmpfptr,&iomode,status);
 
     if(memberIOstate == 0 || iomode != READWRITE) 
	{
	  ffpmsg("cannot add GRPID/LC keywords to member HDU: (ffgtam)");
	  ffpmsg(memberFileName);
	  continue;
	}

      *status = fits_get_num_groups(tmpfptr,&ngroups,status);

      /* 
	 look for the GRPID/LC keywords in the member HDU; if the keywords
	 for the back-link to the grouping table already exist then no
	 need to add them again
       */

      for(i = 1, found = 0; i <= ngroups && !found && *status == 0; ++i)
	{
	  sprintf(keyword,"GRPID%d",(int)ngroups);
	  *status = fits_read_key_lng(tmpfptr,keyword,&grpid,card,status);

	  if(grpid == groupExtver)
	    {
	      if(grpid < 0)
		{

		  /* have to make sure the GRPLCn keyword matches too */

		  sprintf(keyword,"GRPLC%d",(int)ngroups);
		  /* SPR 1738 */
		  *status = fits_read_key_longstr(mfptr,keyword,&tgrplc,card,
						  status);
		  if (0 == *status) {
		    strcpy(grplc,tgrplc);
		    free(tgrplc);
		  }
		  
		  /*
		     always compare files using absolute paths
                     the presence of a non-empty cwd indicates
                     that the file names may require conversion
                     to absolute paths
                  */

                  if(0 < strlen(cwd)) {
                    /* temp buffer for use in assembling abs. path(s) */
                    char tmp[FLEN_FILENAME];

                    /* make grplc absolute if necessary */
                    if(!fits_is_url_absolute(grplc)) {
		      fits_path2url(grplc,groupLocation,status);

		      if(groupLocation[0] != '/')
			{
			  strcpy(tmp, cwd);
			  strcat(tmp,"/");
			  strcat(tmp,groupLocation);
			  fits_clean_url(tmp,grplc,status);
			}
                    }

                    /* make groupFileName absolute if necessary */
                    if(!fits_is_url_absolute(groupFileName)) {
		      fits_path2url(groupFileName,groupLocation,status);

		      if(groupLocation[0] != '/')
			{
			  strcpy(tmp, cwd);
			  strcat(tmp,"/");
			  strcat(tmp,groupLocation);
                          /*
                             note: use groupLocation (which is not used
                             below this block), to store the absolute
                             file name instead of using groupFileName.
                             The latter may be needed unaltered if the
                             GRPLC is written below
                          */

			  fits_clean_url(tmp,groupLocation,status);
			}
                    }
                  }
		  /*
		    see if the grplc value and the group file name match
		  */

		  if(strcmp(grplc,groupLocation) == 0) found = 1;
		}
	      else
		{
		  /* the match is found with GRPIDn alone */
		  found = 1;
		}
	    }
	}

      /*
	 if FOUND is true then no need to continue
      */

      if(found)
	{
	  ffpmsg("HDU already has GRPID/LC keywords for group table (ffgtam)");
	  continue;
	}

      /*
	 add the GRPID/LC keywords to the member header for this grouping
	 table
	 
	 If NGROUPS == 0 then we must position the header pointer to the
	 record where we want to insert the GRPID/LC keywords (the pointer
	 is already correctly positioned if the above search loop activiated)
      */

      if(ngroups == 0)
	{
	  /* 
	     no GRPIDn/GRPLCn keywords currently exist in header so try
	     to position the header pointer to a desirable position
	  */
	  
	  for(i = 0, *status = KEY_NO_EXIST; 
	                       i < nkeys && *status == KEY_NO_EXIST; ++i)
	    {
	      *status = 0;
	      *status = fits_read_card(tmpfptr,keys[i],card,status);
	    }
	      
	  /* all else fails: move write pointer to end of header */
	      
	  if(*status == KEY_NO_EXIST)
	    {
	      *status = 0;
	      fits_get_hdrspace(tmpfptr,&nkeys,&i,status);
	      ffgrec(tmpfptr,nkeys,card,status);
	    }
	  
	  /* any other error status then abort */
	  
	  if(*status != 0) continue;
	}
      
      /* 
	 now that the header pointer is positioned for the GRPID/LC 
	 keyword insertion increment the number of group links counter for 
	 the member HDU 
      */

      ++ngroups;

      /*
	 if the member HDU and grouping table reside in the same FITS file
	 then there is no need to add a GRPLCn keyword
      */
      /* SPR 3463 change test */
      /* Now, if either the Fptr values are the same, or the root filenames
	 are the same, then assume these refer to the same file.
      */
      fits_parse_rootname(tmpfptr->Fptr->filename, tmprootname, status);
      fits_parse_rootname(gfptr->Fptr->filename, grootname, status);

      if((tmpfptr->Fptr == gfptr->Fptr) || 
	          strncmp(tmprootname, grootname, FLEN_FILENAME) == 0)
	{
	  /* add the GRPIDn keyword only */

	  sprintf(keyword,"GRPID%d",(int)ngroups);
	  fits_insert_key_lng(tmpfptr,keyword,groupExtver,
			      "EXTVER of Group containing this HDU",status);
	}
      else 
	{
	  /* add the GRPIDn and GRPLCn keywords */

	  sprintf(keyword,"GRPID%d",(int)ngroups);
	  fits_insert_key_lng(tmpfptr,keyword,groupExtver,
			      "EXTVER of Group containing this HDU",status);

	  sprintf(keyword,"GRPLC%d",(int)ngroups);
	  /* SPR 1738 */
	  fits_insert_key_longstr(tmpfptr,keyword,groupFileName,
			      "URL of file containing Group",status);
	  fits_write_key_longwarn(tmpfptr,status);

	}

    }while(0);

  /* close the tmpfptr pointer if it was opened in this function */

  if(mfptr == NULL)
    {
      *status = fits_close_file(tmpfptr,status);
    }

  *status = 0 == *status ? parentStatus : *status;

  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgtnm(fitsfile *gfptr,    /* FITS file pointer to grouping table        */
	   long     *nmembers, /* member count  of the groping table         */
	   int      *status)   /* return status code                         */

/*
  return the number of member HDUs in a grouping table. The fitsfile pointer
  gfptr must be positioned with the grouping table as the CHDU. The number
  of grouping table member HDUs is just the NAXIS2 value of the grouping
  table.
*/

{
  char keyvalue[FLEN_VALUE];
  char comment[FLEN_COMMENT];
  

  if(*status != 0) return(*status);

  *status = fits_read_keyword(gfptr,"EXTNAME",keyvalue,comment,status);
  
  if(*status == KEY_NO_EXIST)
    *status = NOT_GROUP_TABLE;
  else
    {
      prepare_keyvalue(keyvalue);

      if(strcasecmp(keyvalue,"GROUPING") != 0)
	{
	  *status = NOT_GROUP_TABLE;
	  ffpmsg("Specified HDU is not a Grouping table (ffgtnm)");
	}

      *status = fits_read_key_lng(gfptr,"NAXIS2",nmembers,comment,status);
    }

  return(*status);
}

/*--------------------------------------------------------------------------*/
int ffgmng(fitsfile *mfptr,   /* FITS file pointer to member HDU            */
	   long     *ngroups, /* total number of groups linked to HDU       */
	   int      *status)  /* return status code                         */

/*
  return the number of groups to which a HDU belongs, as defined by the number
  of GRPIDn/GRPLCn keyword records that appear in the HDU header. The 
  fitsfile pointer mfptr must be positioned with the member HDU as the CHDU. 
  Each time this function is called, the indicies of the GRPIDn/GRPLCn
  keywords are checked to make sure they are continuous (ie no gaps) and
  are re-enumerated to eliminate gaps if gaps are found to be present.
*/

{
  int offset;
  int index;
  int newIndex;
  int i;
  
  long grpid;

  char *inclist[] = {"GRPID#"};
  char keyword[FLEN_KEYWORD];
  char newKeyword[FLEN_KEYWORD];
  char card[FLEN_CARD];
  char comment[FLEN_COMMENT];
  char *tkeyvalue;

  if(*status != 0) return(*status);

  *ngroups = 0;

  /* reset the member HDU keyword counter to the beginning */

  *status = ffgrec(mfptr,0,card,status);
  
  /*
    search for the number of GRPIDn keywords in the member HDU header
    and count them with the ngroups variable
  */
  
  while(*status == 0)
    {
      /* read the next GRPIDn keyword in the series */

      *status = fits_find_nextkey(mfptr,inclist,1,NULL,0,card,status);
      
      if(*status != 0) continue;
      
      ++(*ngroups);
    }

  if(*status == KEY_NO_EXIST) *status = 0;
      
  /*
     read each GRPIDn/GRPLCn keyword and adjust their index values so that
     there are no gaps in the index count
  */

  for(index = 1, offset = 0, i = 1; i <= *ngroups && *status == 0; ++index)
    {	  
      sprintf(keyword,"GRPID%d",index);

      /* try to read the next GRPIDn keyword in the series */

      *status = fits_read_key_lng(mfptr,keyword,&grpid,card,status);

      /* if not found then increment the offset counter and continue */

      if(*status == KEY_NO_EXIST) 
	{
	  *status = 0;
	  ++offset;
	}
      else
	{
	  /* 
	     increment the number_keys_found counter and see if the index
	     of the keyword needs to be updated
	  */

	  ++i;

	  if(offset > 0)
	    {
	      /* compute the new index for the GRPIDn/GRPLCn keywords */
	      newIndex = index - offset;

	      /* update the GRPIDn keyword index */

	      sprintf(newKeyword,"GRPID%d",newIndex);
	      fits_modify_name(mfptr,keyword,newKeyword,status);

	      /* If present, update the GRPLCn keyword index */

	      sprintf(keyword,"GRPLC%d",index);
	      sprintf(newKeyword,"GRPLC%d",newIndex);
	      /* SPR 1738 */
	      *status = fits_read_key_longstr(mfptr,keyword,&tkeyvalue,comment,
					      status);
	      if (0 == *status) {
		fits_delete_key(mfptr,keyword,status);
		fits_insert_key_longstr(mfptr,newKeyword,tkeyvalue,comment,status);
		fits_write_key_longwarn(mfptr,status);
		free(tkeyvalue);
	      }
	      

	      if(*status == KEY_NO_EXIST) *status = 0;
	    }
	}
    }

  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgmop(fitsfile *gfptr,  /* FITS file pointer to grouping table          */
	   long      member, /* member ID (row num) within grouping table    */
	   fitsfile **mfptr, /* FITS file pointer to member HDU              */
	   int      *status) /* return status code                           */

/*
  open a grouping table member, returning a pointer to the member's FITS file
  with the CHDU set to the member HDU. The grouping table must be the CHDU of
  the FITS file pointed to by gfptr. The member to open is identified by its
  row number within the grouping table (first row/member == 1).

  If the member resides in a FITS file different from the grouping
  table the member file is first opened readwrite and if this fails then
  it is opened readonly. For access type of FILE:// the member file is
  searched for assuming (1) an absolute path is given, (2) a path relative
  to the CWD is given, and (3) a path relative to the grouping table file
  but not relative to the CWD is given. If all of these fail then the
  error FILE_NOT_FOUND is returned.
*/

{
  int xtensionCol,extnameCol,extverCol,positionCol,locationCol,uriCol;
  int grptype,hdutype;
  int dummy;

  long hdupos = 0;
  long extver = 0;

  char  xtension[FLEN_VALUE];
  char  extname[FLEN_VALUE];
  char  uri[FLEN_VALUE];
  char  grpLocation1[FLEN_FILENAME];
  char  grpLocation2[FLEN_FILENAME];
  char  mbrLocation1[FLEN_FILENAME];
  char  mbrLocation2[FLEN_FILENAME];
  char  mbrLocation3[FLEN_FILENAME];
  char  cwd[FLEN_FILENAME];
  char  card[FLEN_CARD];
  char  nstr[] = {'\0'};
  char *tmpPtr[1];


  if(*status != 0) return(*status);

  do
    {
      /*
	retrieve the Grouping Convention reserved column positions within
	the grouping table
      */

      *status = ffgtgc(gfptr,&xtensionCol,&extnameCol,&extverCol,&positionCol,
		       &locationCol,&uriCol,&grptype,status);

      if(*status != 0) continue;

      /*
	 extract the member information from grouping table
      */

      tmpPtr[0] = xtension;

      if(xtensionCol != 0)
	{

	  *status = fits_read_col_str(gfptr,xtensionCol,member,1,1,nstr,
				      tmpPtr,&dummy,status);

	  /* convert the xtension string to a hdutype code */

	  if(strcasecmp(xtension,"PRIMARY")       == 0) hdutype = IMAGE_HDU; 
	  else if(strcasecmp(xtension,"IMAGE")    == 0) hdutype = IMAGE_HDU; 
	  else if(strcasecmp(xtension,"TABLE")    == 0) hdutype = ASCII_TBL; 
	  else if(strcasecmp(xtension,"BINTABLE") == 0) hdutype = BINARY_TBL; 
	  else hdutype = ANY_HDU; 
	}

      tmpPtr[0] = extname;

      if(extnameCol  != 0)
	  *status = fits_read_col_str(gfptr,extnameCol,member,1,1,nstr,
				      tmpPtr,&dummy,status);

      if(extverCol   != 0)
	  *status = fits_read_col_lng(gfptr,extverCol,member,1,1,0,
				      (long*)&extver,&dummy,status);

      if(positionCol != 0)
	  *status = fits_read_col_lng(gfptr,positionCol,member,1,1,0,
				      (long*)&hdupos,&dummy,status);

      tmpPtr[0] = mbrLocation1;

      if(locationCol != 0)
	*status = fits_read_col_str(gfptr,locationCol,member,1,1,nstr,
				    tmpPtr,&dummy,status);
      tmpPtr[0] = uri;

      if(uriCol != 0)
	*status = fits_read_col_str(gfptr,uriCol,member,1,1,nstr,
				    tmpPtr,&dummy,status);

      if(*status != 0) continue;

      /* 
	 decide what FITS file the member HDU resides in and open the file
	 using the fitsfile* pointer mfptr; note that this logic is rather
	 complicated and is based primiarly upon if a URL specifier is given
	 for the member file in the grouping table
      */

      switch(grptype)
	{

	case GT_ID_POS:
	case GT_ID_REF:
	case GT_ID_ALL:

	  /*
	     no location information is given so we must assume that the
	     member HDU resides in the same FITS file as the grouping table;
	     if the grouping table was incorrectly constructed then this
	     assumption will be false, but there is nothing to be done about
	     it at this point
	  */

	  *status = fits_reopen_file(gfptr,mfptr,status);
	  
	  break;

	case GT_ID_REF_URI:
	case GT_ID_POS_URI:
	case GT_ID_ALL_URI:

	  /*
	    The member location column exists. Determine if the member 
	    resides in the same file as the grouping table or in a
	    separate file; open the member file in either case
	  */

	  if(strlen(mbrLocation1) == 0)
	    {
	      /*
		 since no location information was given we must assume
		 that the member is in the same FITS file as the grouping
		 table
	      */

	      *status = fits_reopen_file(gfptr,mfptr,status);
	    }
	  else
	    {
	      /*
		make sure the location specifiation is "URL"; we cannot
		decode any other URI types at this time
	      */

	      if(strcasecmp(uri,"URL") != 0)
		{
		  *status = FILE_NOT_OPENED;
		  sprintf(card,
		  "Cannot open member HDU file with URI type %s (ffgmop)",
			  uri);
		  ffpmsg(card);

		  continue;
		}

	      /*
		The location string for the member is not NULL, so it 
		does not necessially reside in the same FITS file as the
		grouping table. 

		Three cases are attempted for opening the member's file
		in the following order:

		1. The URL given for the member's file is absolute (i.e.,
		access method supplied); try to open the member

		2. The URL given for the member's file is not absolute but
		is an absolute file path; try to open the member as a file
		after the file path is converted to a host-dependent form

		3. The URL given for the member's file is not absolute
	        and is given as a relative path to the location of the 
		grouping table's file. Create an absolute URL using the 
		grouping table's file URL and try to open the member.
		
		If all three cases fail then an error is returned. In each
		case the file is first opened in read/write mode and failing
		that readonly mode.
		
		The following DO loop is only used as a mechanism to break
		(continue) when the proper file opening method is found
	       */

	      do
		{
		  /*
		     CASE 1:

		     See if the member URL is absolute (i.e., includes a
		     access directive) and if so open the file
		   */

		  if(fits_is_url_absolute(mbrLocation1))
		    {
		      /*
			 the URL must specify an access method, which 
			 implies that its an absolute reference
			 
			 regardless of the access method, pass the whole
			 URL to the open function for processing
		       */
		      
		      ffpmsg("member URL is absolute, try open R/W (ffgmop)");

		      *status = fits_open_file(mfptr,mbrLocation1,READWRITE,
					       status);

		      if(*status == 0) continue;

		      *status = 0;

		      /* 
			 now try to open file using full URL specs in 
			 readonly mode 
		      */ 

		      ffpmsg("OK, now try to open read-only (ffgmop)");

		      *status = fits_open_file(mfptr,mbrLocation1,READONLY,
					       status);

		      /* break from DO loop regardless of status */

		      continue;
		    }

		  /*
		     CASE 2:

		     If we got this far then the member URL location 
		     has no access type ==> FILE:// Try to open the member 
		     file using the URL as is, i.e., assume that it is given 
		     as absolute, if it starts with a '/' character
		   */

		  ffpmsg("Member URL is of type FILE (ffgmop)");

		  if(*mbrLocation1 == '/')
		    {
		      ffpmsg("Member URL specifies abs file path (ffgmop)");

		      /* 
			 convert the URL path to a host dependent path
		      */

		      *status = fits_url2path(mbrLocation1,mbrLocation2,
					      status);

		      ffpmsg("Try to open member URL in R/W mode (ffgmop)");

		      *status = fits_open_file(mfptr,mbrLocation2,READWRITE,
					       status);

		      if(*status == 0) continue;

		      *status = 0;

		      /* 
			 now try to open file using the URL as an absolute 
			 path in readonly mode 
		      */
 
		      ffpmsg("OK, now try to open read-only (ffgmop)");

		      *status = fits_open_file(mfptr,mbrLocation2,READONLY,
					       status);

		      /* break from the Do loop regardless of the status */

		      continue;
		    }
		  
		  /* 
		     CASE 3:

		     If we got this far then the URL does not specify an
		     absoulte file path or URL with access method. Since 
		     the path to the group table's file is (obviously) valid 
		     for the CWD, create a full location string for the
		     member HDU using the grouping table URL as a basis

		     The only problem is that the grouping table file might
		     have two URLs, the original one used to open it and
		     the one that points to the real file being accessed
		     (i.e., a file accessed via HTTP but transferred to a
		     local disk file). Have to attempt to build a URL to
		     the member HDU file using both of these URLs if
		     defined.
		  */

		  ffpmsg("Try to open member file as relative URL (ffgmop)");

		  /* get the URL information for the grouping table file */

		  *status = fits_get_url(gfptr,grpLocation1,grpLocation2,
					 NULL,NULL,NULL,status);

		  /* 
		     if the "real" grouping table file URL is defined then
		     build a full url for the member HDU file using it
		     and try to open the member HDU file
		  */

		  if(*grpLocation1)
		    {
		      /* make sure the group location is absolute */

		      if(! fits_is_url_absolute(grpLocation1) &&
			                              *grpLocation1 != '/')
			{
			  fits_get_cwd(cwd,status);
			  strcat(cwd,"/");
			  strcat(cwd,grpLocation1);
			  strcpy(grpLocation1,cwd);
			}

		      /* create a full URL for the member HDU file */

		      *status = fits_relurl2url(grpLocation1,mbrLocation1,
						mbrLocation2,status);

		      if(*status != 0) continue;

		      /*
			if the URL does not have an access method given then
			translate it into a host dependent file path
		      */

		      if(! fits_is_url_absolute(mbrLocation2))
			{
			  *status = fits_url2path(mbrLocation2,mbrLocation3,
						  status);
			  strcpy(mbrLocation2,mbrLocation3);
			}

		      /* try to open the member file READWRITE */

		      *status = fits_open_file(mfptr,mbrLocation2,READWRITE,
					       status);

		      if(*status == 0) continue;

		      *status = 0;
		  
		      /* now try to open in readonly mode */ 

		      ffpmsg("now try to open file as READONLY (ffgmop)");

		      *status = fits_open_file(mfptr,mbrLocation2,READONLY,
					       status);

		      if(*status == 0) continue;

		      *status = 0;
		    }

		  /* 
		     if we got this far then either the "real" grouping table
		     file URL was not defined or all attempts to open the
		     resulting member HDU file URL failed.

		     if the "original" grouping table file URL is defined then
		     build a full url for the member HDU file using it
		     and try to open the member HDU file
		  */

		  if(*grpLocation2)
		    {
		      /* make sure the group location is absolute */

		      if(! fits_is_url_absolute(grpLocation2) &&
			                              *grpLocation2 != '/')
			{
			  fits_get_cwd(cwd,status);
			  strcat(cwd,"/");
			  strcat(cwd,grpLocation2);
			  strcpy(grpLocation2,cwd);
			}

		      /* create an absolute URL for the member HDU file */

		      *status = fits_relurl2url(grpLocation2,mbrLocation1,
						mbrLocation2,status);
		      if(*status != 0) continue;

		      /*
			if the URL does not have an access method given then
			translate it into a host dependent file path
		      */

		      if(! fits_is_url_absolute(mbrLocation2))
			{
			  *status = fits_url2path(mbrLocation2,mbrLocation3,
						  status);
			  strcpy(mbrLocation2,mbrLocation3);
			}

		      /* try to open the member file READWRITE */

		      *status = fits_open_file(mfptr,mbrLocation2,READWRITE,
					       status);

		      if(*status == 0) continue;

		      *status = 0;
		  
		      /* now try to open in readonly mode */ 

		      ffpmsg("now try to open file as READONLY (ffgmop)");

		      *status = fits_open_file(mfptr,mbrLocation2,READONLY,
					       status);

		      if(*status == 0) continue;

		      *status = 0;
		    }

		  /*
		     if we got this far then the member HDU file could not
		     be opened using any method. Log the error.
		  */

		  ffpmsg("Cannot open member HDU FITS file (ffgmop)");
		  *status = MEMBER_NOT_FOUND;
		  
		}while(0);
	    }

	  break;

	default:

	  /* no default action */
	  
	  break;
	}
	  
      if(*status != 0) continue;

      /*
	 attempt to locate the member HDU within its FITS file as determined
	 and opened above
      */

      switch(grptype)
	{

	case GT_ID_POS:
	case GT_ID_POS_URI:

	  /*
	    try to find the member hdu in the the FITS file pointed to
	    by mfptr based upon its HDU posistion value. Note that is 
	    impossible to verify if the HDU is actually the correct HDU due 
	    to a lack of information.
	  */
	  
	  *status = fits_movabs_hdu(*mfptr,(int)hdupos,&hdutype,status);

	  break;

	case GT_ID_REF:
	case GT_ID_REF_URI:

	  /*
	     try to find the member hdu in the FITS file pointed to
	     by mfptr based upon its XTENSION, EXTNAME and EXTVER keyword 
	     values
	  */

	  *status = fits_movnam_hdu(*mfptr,hdutype,extname,extver,status);

	  if(*status == BAD_HDU_NUM) 
	    {
	      *status = MEMBER_NOT_FOUND;
	      ffpmsg("Cannot find specified member HDU (ffgmop)");
	    }

	  /*
	     if the above function returned without error then the
	     mfptr is pointed to the member HDU
	  */

	  break;

	case GT_ID_ALL:
	case GT_ID_ALL_URI:

	  /*
	     if the member entry has reference information then use it
             (ID by reference is safer than ID by position) else use
	     the position information
	  */

	  if(strlen(xtension) > 0 && strlen(extname) > 0 && extver > 0)
	    {
	      /* valid reference info exists so use it */
	      
	      /* try to find the member hdu in the grouping table's file */

	      *status = fits_movnam_hdu(*mfptr,hdutype,extname,extver,status);

	      if(*status == BAD_HDU_NUM) 
		{
		  *status = MEMBER_NOT_FOUND;
		  ffpmsg("Cannot find specified member HDU (ffgmop)");
		}
	    }
	  else
	      {
		  *status = fits_movabs_hdu(*mfptr,(int)hdupos,&hdutype,
					    status);
		  if(*status == END_OF_FILE) *status = MEMBER_NOT_FOUND;
	      }

	  /*
	     if the above function returned without error then the
	     mfptr is pointed to the member HDU
	  */

	  break;

	default:

	  /* no default action */

	  break;
	}
      
    }while(0);

  if(*status != 0 && *mfptr != NULL) 
    {
      fits_close_file(*mfptr,status);
    }

  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgmcp(fitsfile *gfptr,  /* FITS file pointer to group                   */
	   fitsfile *mfptr,  /* FITS file pointer to new member
				FITS file                                    */
	   long      member, /* member ID (row num) within grouping table    */
	   int       cpopt,  /* code specifying copy options:
				OPT_MCP_ADD  (0) ==> add copied member to the
 				                     grouping table
				OPT_MCP_NADD (1) ==> do not add member copy to
				                     the grouping table
				OPT_MCP_REPL (2) ==> replace current member
				                     entry with member copy  */
	   int      *status) /* return status code                           */
	   
/*
  copy a member HDU of a grouping table to a new FITS file. The grouping table
  must be the CHDU of the FITS file pointed to by gfptr. The copy of the
  group member shall be appended to the end of the FITS file pointed to by
  mfptr. If the cpopt parameter is set to OPT_MCP_ADD then the copy of the 
  member is added to the grouping table as a new member, if OPT_MCP_NADD 
  then the copied member is not added to the grouping table, and if 
  OPT_MCP_REPL then the copied member is used to replace the original member.
  The copied member HDU also has its EXTVER value updated so that its
  combination of XTENSION, EXTNAME and EXVTER is unique within its new
  FITS file.
*/

{
  int numkeys = 0;
  int keypos  = 0;
  int hdunum  = 0;
  int hdutype = 0;
  int i;
  
  char *incList[] = {"GRPID#","GRPLC#"};
  char  extname[FLEN_VALUE];
  char  card[FLEN_CARD];
  char  comment[FLEN_COMMENT];
  char  keyname[FLEN_CARD];
  char  value[FLEN_CARD];

  fitsfile *tmpfptr = NULL;


  if(*status != 0) return(*status);

  do
    {
      /* open the member HDU to be copied */

      *status = fits_open_member(gfptr,member,&tmpfptr,status);

      if(*status != 0) continue;

      /*
	if the member is a grouping table then copy it with a call to
	fits_copy_group() using the "copy only the grouping table" option

	if it is not a grouping table then copy the hdu with fits_copy_hdu()
	remove all GRPIDn and GRPLCn keywords, and update the EXTVER keyword
	value
      */

      /* get the member HDU's EXTNAME value */

      *status = fits_read_key_str(tmpfptr,"EXTNAME",extname,comment,status);

      /* if no EXTNAME value was found then set the extname to a null string */

      if(*status == KEY_NO_EXIST) 
	{
	  extname[0] = 0;
	  *status    = 0;
	}
      else if(*status != 0) continue;

      prepare_keyvalue(extname);

      /* if a grouping table then copy with fits_copy_group() */

      if(strcasecmp(extname,"GROUPING") == 0)
	*status = fits_copy_group(tmpfptr,mfptr,OPT_GCP_GPT,status);
      else
	{
	  /* copy the non-grouping table HDU the conventional way */

	  *status = fits_copy_hdu(tmpfptr,mfptr,0,status);

	  ffgrec(mfptr,0,card,status);

	  /* delete all the GRPIDn and GRPLCn keywords in the copied HDU */

	  while(*status == 0)
	    {
	      *status = fits_find_nextkey(mfptr,incList,2,NULL,0,card,status);
	      *status = fits_get_hdrpos(mfptr,&numkeys,&keypos,status);  
	      /* SPR 1738 */
	      *status = fits_read_keyn(mfptr,keypos-1,keyname,value,
				       comment,status);
	      *status = fits_read_record(mfptr,keypos-1,card,status);
	      *status = fits_delete_key(mfptr,keyname,status);
	    }

	  if(*status == KEY_NO_EXIST) *status = 0;
	  if(*status != 0) continue;
	}

      /* 
	 if the member HDU does not have an EXTNAME keyword then add one
	 with a default value
      */

      if(strlen(extname) == 0)
	{
	  if(fits_get_hdu_num(tmpfptr,&hdunum) == 1)
	    {
	      strcpy(extname,"PRIMARY");
	      *status = fits_write_key_str(mfptr,"EXTNAME",extname,
					   "HDU was Formerly a Primary Array",
					   status);
	    }
	  else
	    {
	      strcpy(extname,"DEFAULT");
	      *status = fits_write_key_str(mfptr,"EXTNAME",extname,
					   "default EXTNAME set by CFITSIO",
					   status);
	    }
	}

      /* 
	 update the member HDU's EXTVER value (add it if not present)
      */

      fits_get_hdu_num(mfptr,&hdunum);
      fits_get_hdu_type(mfptr,&hdutype,status);

      /* set the EXTVER value to 0 for now */

      *status = fits_modify_key_lng(mfptr,"EXTVER",0,NULL,status);

      /* if the EXTVER keyword was not found then add it */

      if(*status == KEY_NO_EXIST)
	{
	  *status = 0;
	  *status = fits_read_key_str(mfptr,"EXTNAME",extname,comment,
				      status);
	  *status = fits_insert_key_lng(mfptr,"EXTVER",0,
					"Extension version ID",status);
	}

      if(*status != 0) continue;

      /* find the first available EXTVER value for the copied HDU */
 
      for(i = 1; fits_movnam_hdu(mfptr,hdutype,extname,i,status) == 0; ++i);

      *status = 0;

      fits_movabs_hdu(mfptr,hdunum,&hdutype,status);

      /* reset the copied member HDUs EXTVER value */

      *status = fits_modify_key_lng(mfptr,"EXTVER",(long)i,NULL,status);    

      /*
	perform member copy operations that are dependent upon the cpopt
	parameter value
      */

      switch(cpopt)
	{
	case OPT_MCP_ADD:

	  /*
	    add the copied member to the grouping table, leaving the
	    entry for the original member in place
	  */

	  *status = fits_add_group_member(gfptr,mfptr,0,status);

	  break;

	case OPT_MCP_NADD:

	  /*
	    nothing to do for this copy option
	  */

	  break;

	case OPT_MCP_REPL:

	  /*
	    remove the original member from the grouping table and add the
	    copied member in its place
	  */

	  *status = fits_remove_member(gfptr,member,OPT_RM_ENTRY,status);
	  *status = fits_add_group_member(gfptr,mfptr,0,status);

	  break;

	default:

	  *status = BAD_OPTION;
	  ffpmsg("Invalid value specified for the cmopt parameter (ffgmcp)");

	  break;
	}

    }while(0);
      
  if(tmpfptr != NULL) 
    {
      fits_close_file(tmpfptr,status);
    }

  return(*status);
}		     

/*---------------------------------------------------------------------------*/
int ffgmtf(fitsfile *infptr,   /* FITS file pointer to source grouping table */
	   fitsfile *outfptr,  /* FITS file pointer to target grouping table */
	   long      member,   /* member ID within source grouping table     */
	   int       tfopt,    /* code specifying transfer opts:
				  OPT_MCP_ADD (0) ==> copy member to dest.
				  OPT_MCP_MOV (3) ==> move member to dest.   */
	   int      *status)   /* return status code                         */

/*
  transfer a group member from one grouping table to another. The source
  grouping table must be the CHDU of the fitsfile pointed to by infptr, and 
  the destination grouping table must be the CHDU of the fitsfile to by 
  outfptr. If the tfopt parameter is OPT_MCP_ADD then the member is made a 
  member of the target group and remains a member of the source group. If
  the tfopt parameter is OPT_MCP_MOV then the member is deleted from the 
  source group after the transfer to the destination group. The member to be
  transfered is identified by its row number within the source grouping table.
*/

{
  fitsfile *mfptr = NULL;


  if(*status != 0) return(*status);

  if(tfopt != OPT_MCP_MOV && tfopt != OPT_MCP_ADD)
    {
      *status = BAD_OPTION;
      ffpmsg("Invalid value specified for the tfopt parameter (ffgmtf)");
    }
  else
    {
      /* open the member of infptr to be transfered */

      *status = fits_open_member(infptr,member,&mfptr,status);
      
      /* add the member to the outfptr grouping table */
      
      *status = fits_add_group_member(outfptr,mfptr,0,status);
      
      /* close the member HDU */
      
      *status = fits_close_file(mfptr,status);
      
      /* 
	 if the tfopt is "move member" then remove it from the infptr 
	 grouping table
      */

      if(tfopt == OPT_MCP_MOV)
	*status = fits_remove_member(infptr,member,OPT_RM_ENTRY,status);
    }
  
  return(*status);
}

/*---------------------------------------------------------------------------*/
int ffgmrm(fitsfile *gfptr,  /* FITS file pointer to group table             */
	   long      member, /* member ID (row num) in the group             */
	   int       rmopt,  /* code specifying the delete option:
				OPT_RM_ENTRY ==> delete the member entry
				OPT_RM_MBR   ==> delete entry and member HDU */
	   int      *status)  /* return status code                          */

/*
  remove a member HDU from a grouping table. The fitsfile pointer gfptr must
  be positioned with the grouping table as the CHDU, and the member to 
  delete is identified by its row number in the table (first member == 1).
  The rmopt parameter determines if the member entry is deleted from the
  grouping table (in which case GRPIDn and GRPLCn keywords in the member 
  HDU's header shall be updated accordingly) or if the member HDU shall 
  itself be removed from its FITS file.
*/

{
  int found;
  int hdutype   = 0;
  int index;
  int iomode    = 0;

  long i;
  long ngroups      = 0;
  long nmembers     = 0;
  long groupExtver  = 0;
  long grpid        = 0;

  char grpLocation1[FLEN_FILENAME];
  char grpLocation2[FLEN_FILENAME];
  char grpLocation3[FLEN_FILENAME];
  char cwd[FLEN_FILENAME];
  char keyword[FLEN_KEYWORD];
  /* SPR 1738 This can now be longer */
  char grplc[FLEN_FILENAME];
  char *tgrplc;
  char keyvalue[FLEN_VALUE];
  char card[FLEN_CARD];
  char *editLocation;
  char mrootname[FLEN_FILENAME], grootname[FLEN_FILENAME];

  fitsfile *mfptr  = NULL;


  if(*status != 0) return(*status);

  do
    {
      /*
	make sure the grouping table can be modified before proceeding
      */

      fits_file_mode(gfptr,&iomode,status);

      if(iomode != READWRITE)
	{
	  ffpmsg("cannot modify grouping table (ffgtam)");
	  *status = BAD_GROUP_DETACH;
	  continue;
	}

      /* open the group member to be deleted and get its IOstatus*/

      *status = fits_open_member(gfptr,member,&mfptr,status);
      *status = fits_file_mode(mfptr,&iomode,status);

      /*
	 if the member HDU is to be deleted then call fits_unlink_member()
	 to remove it from all groups to which it belongs (including
	 this one) and then delete it. Note that if the member is a
	 grouping table then we have to recursively call fits_remove_member()
	 for each member of the member before we delete the member itself.
      */

      if(rmopt == OPT_RM_MBR)
	{
	    /* cannot delete a PHDU */
	    if(fits_get_hdu_num(mfptr,&hdutype) == 1)
		{
		    *status = BAD_HDU_NUM;
		    continue;
		}

	  /* determine if the member HDU is itself a grouping table */

	  *status = fits_read_key_str(mfptr,"EXTNAME",keyvalue,card,status);

	  /* if no EXTNAME is found then the HDU cannot be a grouping table */ 

	  if(*status == KEY_NO_EXIST) 
	    {
	      keyvalue[0] = 0;
	      *status = 0;
	    }
	  prepare_keyvalue(keyvalue);

	  /* Any other error is a reason to abort */

	  if(*status != 0) continue;

	  /* if the EXTNAME == GROUPING then the member is a grouping table */
	  
	  if(strcasecmp(keyvalue,"GROUPING") == 0)
	    {
	      /* remove each of the grouping table members */
	      
	      *status = fits_get_num_members(mfptr,&nmembers,status);
	      
	      for(i = nmembers; i > 0 && *status == 0; --i)
		*status = fits_remove_member(mfptr,i,OPT_RM_ENTRY,status);
	      
	      if(*status != 0) continue;
	    }

	  /* unlink the member HDU from all groups that contain it */

	  *status = ffgmul(mfptr,0,status);

	  if(*status != 0) continue;
 
	  /* reset the grouping table HDU struct */

	  fits_set_hdustruc(gfptr,status);

	  /* delete the member HDU */

	  if(iomode != READONLY)
	    *status = fits_delete_hdu(mfptr,&hdutype,status);
	}
      else if(rmopt == OPT_RM_ENTRY)
	{
	  /* 
	     The member HDU is only to be removed as an entry from this
	     grouping table. Actions are (1) find the GRPIDn/GRPLCn 
	     keywords that link the member to the grouping table, (2)
	     remove the GRPIDn/GRPLCn keyword from the member HDU header
	     and (3) remove the member entry from the grouping table
	  */

	  /*
	    there is no need to seach for and remove the GRPIDn/GRPLCn
	    keywords from the member HDU if it has not been opened
	    in READWRITE mode
	  */

	  if(iomode == READWRITE)
	    {	  	      
	      /* 
		 determine the group EXTVER value of the grouping table; if
		 the member HDU and grouping table HDU do not reside in the 
		 same file then set the groupExtver value to its negative 
	      */
	      
	      *status = fits_read_key_lng(gfptr,"EXTVER",&groupExtver,card,
					  status);
	      /* Now, if either the Fptr values are the same, or the root filenames
	         are the same, then assume these refer to the same file.
	      */
	      fits_parse_rootname(mfptr->Fptr->filename, mrootname, status);
	      fits_parse_rootname(gfptr->Fptr->filename, grootname, status);

	      if((mfptr->Fptr != gfptr->Fptr) && 
	          strncmp(mrootname, grootname, FLEN_FILENAME))
                       groupExtver = -1*groupExtver;
	      
	      /*
		retrieve the URLs for the grouping table; note that it is 
		possible that the grouping table file has two URLs, the 
		one used to open it and the "real" one pointing to the 
		actual file being accessed
	      */
	      
	      *status = fits_get_url(gfptr,grpLocation1,grpLocation2,NULL,
				     NULL,NULL,status);
	      
	      if(*status != 0) continue;
	      
	      /*
		if either of the group location strings specify a relative
		file path then convert them into absolute file paths
	      */

	      *status = fits_get_cwd(cwd,status);
	      
	      if(*grpLocation1 != 0 && *grpLocation1 != '/' &&
		 !fits_is_url_absolute(grpLocation1))
		{
		  strcpy(grpLocation3,cwd);
		  strcat(grpLocation3,"/");
		  strcat(grpLocation3,grpLocation1);
		  fits_clean_url(grpLocation3,grpLocation1,status);
		}
	      
	      if(*grpLocation2 != 0 && *grpLocation2 != '/' &&
		 !fits_is_url_absolute(grpLocation2))
		{
		  strcpy(grpLocation3,cwd);
		  strcat(grpLocation3,"/");
		  strcat(grpLocation3,grpLocation2);
		  fits_clean_url(grpLocation3,grpLocation2,status);
		}
	      
	      /*
		determine the number of groups to which the member HDU 
		belongs
	      */
	      
	      *status = fits_get_num_groups(mfptr,&ngroups,status);
	      
	      /* reset the HDU keyword position counter to the beginning */
	      
	      *status = ffgrec(mfptr,0,card,status);
	      
	      /*
		loop over all the GRPIDn keywords in the member HDU header 
		and find the appropriate GRPIDn and GRPLCn keywords that 
		identify it as belonging to the group
	      */
	      
	      for(index = 1, found = 0; index <= ngroups && *status == 0 && 
		    !found; ++index)
		{	  
		  /* read the next GRPIDn keyword in the series */
		  
		  sprintf(keyword,"GRPID%d",index);
		  
		  *status = fits_read_key_lng(mfptr,keyword,&grpid,card,
					      status);
		  if(*status != 0) continue;
		  
		  /* 
		     grpid value == group EXTVER value then we could have a 
		     match
		  */
		  
		  if(grpid == groupExtver && grpid > 0)
		    {
		      /*
			if GRPID is positive then its a match because 
			both the member HDU and grouping table HDU reside
			in the same FITS file
		      */
		      
		      found = index;
		    }
		  else if(grpid == groupExtver && grpid < 0)
		    {
		      /* 
			 have to look at the GRPLCn value to determine a 
			 match because the member HDU and grouping table 
			 HDU reside in different FITS files
		      */
		      
		      sprintf(keyword,"GRPLC%d",index);
		      
		      /* SPR 1738 */
		      *status = fits_read_key_longstr(mfptr,keyword,&tgrplc,
						      card, status);
		      if (0 == *status) {
			strcpy(grplc,tgrplc);
			free(tgrplc);
		      }
		      		      
		      if(*status == KEY_NO_EXIST)
			{
			  /* 
			     no GRPLCn keyword value found ==> grouping
			     convention not followed; nothing we can do 
			     about it, so just continue
			  */
			  
			  sprintf(card,"No GRPLC%d found for GRPID%d",
				  index,index);
			  ffpmsg(card);
			  *status = 0;
			  continue;
			}
		      else if (*status != 0) continue;
		      
		      /* construct the URL for the GRPLCn value */
		      
		      prepare_keyvalue(grplc);
		      
		      /*
			if the grplc value specifies a relative path then
			turn it into a absolute file path for comparison
			purposes
		      */
		      
		      if(*grplc != 0 && !fits_is_url_absolute(grplc) &&
			 *grplc != '/')
			{
			    /* No, wrong, 
			       strcpy(grpLocation3,cwd);
			       should be */
			    *status = fits_file_name(mfptr,grpLocation3,status);
			    /* Remove everything after the last / */
			    if (NULL != (editLocation = strrchr(grpLocation3,'/'))) {
				*editLocation = '\0';
			    }
				
			  strcat(grpLocation3,"/");
			  strcat(grpLocation3,grplc);
			  *status = fits_clean_url(grpLocation3,grplc,
						   status);
			}
		      
		      /*
			if the absolute value of GRPIDn is equal to the
			EXTVER value of the grouping table and (one of the 
			possible two) grouping table file URL matches the
			GRPLCn keyword value then we hava a match
		      */
		      
		      if(strcmp(grplc,grpLocation1) == 0  || 
			 strcmp(grplc,grpLocation2) == 0) 
			found = index; 
		    }
		}

	      /*
		if found == 0 (false) after the above search then we assume 
		that it is due to an inpromper updating of the GRPIDn and 
		GRPLCn keywords in the member header ==> nothing to delete 
		in the header. Else delete the GRPLCn and GRPIDn keywords 
		that identify the member HDU with the group HDU and 
		re-enumerate the remaining GRPIDn and GRPLCn keywords
	      */

	      if(found != 0)
		{
		  sprintf(keyword,"GRPID%d",found);
		  *status = fits_delete_key(mfptr,keyword,status);
		  
		  sprintf(keyword,"GRPLC%d",found);
		  *status = fits_delete_key(mfptr,keyword,status);
		  
		  *status = 0;
		  
		  /* call fits_get_num_groups() to re-enumerate the GRPIDn */
		  
		  *status = fits_get_num_groups(mfptr,&ngroups,status);
		} 
	    }

	  /*
	     finally, remove the member entry from the current grouping table
	     pointed to by gfptr
	  */

	  *status = fits_delete_rows(gfptr,member,1,status);
	}
      else
	{
	  *status = BAD_OPTION;
	  ffpmsg("Invalid value specified for the rmopt parameter (ffgmrm)");
	}

    }while(0);

  if(mfptr != NULL) 
    {
      fits_close_file(mfptr,status);
    }

  return(*status);
}

/*---------------------------------------------------------------------------
                 Grouping Table support functions
  ---------------------------------------------------------------------------*/
int ffgtgc(fitsfile *gfptr,  /* pointer to the grouping table                */
	   int *xtensionCol, /* column ID of the MEMBER_XTENSION column      */
	   int *extnameCol,  /* column ID of the MEMBER_NAME column          */
	   int *extverCol,   /* column ID of the MEMBER_VERSION column       */
	   int *positionCol, /* column ID of the MEMBER_POSITION column      */
	   int *locationCol, /* column ID of the MEMBER_LOCATION column      */
	   int *uriCol,      /* column ID of the MEMBER_URI_TYPE column      */
	   int *grptype,     /* group structure type code specifying the
				grouping table columns that are defined:
				GT_ID_ALL_URI  (0) ==> all columns defined   
				GT_ID_REF      (1) ==> reference cols only   
				GT_ID_POS      (2) ==> position col only     
				GT_ID_ALL      (3) ==> ref & pos cols        
				GT_ID_REF_URI (11) ==> ref & loc cols        
				GT_ID_POS_URI (12) ==> pos & loc cols        */
	   int *status)      /* return status code                           */
/*
   examine the grouping table pointed to by gfptr and determine the column
   index ID of each possible grouping column. If a column is not found then
   an index of 0 is returned. the grptype parameter returns the structure
   of the grouping table ==> what columns are defined.
*/

{

  char keyvalue[FLEN_VALUE];
  char comment[FLEN_COMMENT];


  if(*status != 0) return(*status);

  do
    {
      /*
	if the HDU does not have an extname of "GROUPING" then it is not
	a grouping table
      */

      *status = fits_read_key_str(gfptr,"EXTNAME",keyvalue,comment,status);
  
      if(*status == KEY_NO_EXIST) 
	{
	  *status = NOT_GROUP_TABLE;
	  ffpmsg("Specified HDU is not a Grouping Table (ffgtgc)");
	}
      if(*status != 0) continue;

      prepare_keyvalue(keyvalue);

      if(strcasecmp(keyvalue,"GROUPING") != 0)
	{
	  *status = NOT_GROUP_TABLE;
	  continue;
	}

      /*
        search for the MEMBER_XTENSION, MEMBER_NAME, MEMBER_VERSION,
	MEMBER_POSITION, MEMBER_LOCATION and MEMBER_URI_TYPE columns
	and determine their column index ID
      */

      *status = fits_get_colnum(gfptr,CASESEN,"MEMBER_XTENSION",xtensionCol,
				status);

      if(*status == COL_NOT_FOUND)
	{
	  *status      = 0;
 	  *xtensionCol = 0;
	}

      if(*status != 0) continue;

      *status = fits_get_colnum(gfptr,CASESEN,"MEMBER_NAME",extnameCol,status);

      if(*status == COL_NOT_FOUND)
	{
	  *status     = 0;
	  *extnameCol = 0;
	}

      if(*status != 0) continue;

      *status = fits_get_colnum(gfptr,CASESEN,"MEMBER_VERSION",extverCol,
				status);

      if(*status == COL_NOT_FOUND)
	{
	  *status    = 0;
	  *extverCol = 0;
	}

      if(*status != 0) continue;

      *status = fits_get_colnum(gfptr,CASESEN,"MEMBER_POSITION",positionCol,
				status);

      if(*status == COL_NOT_FOUND)
	{
	  *status      = 0;
	  *positionCol = 0;
	}

      if(*status != 0) continue;

      *status = fits_get_colnum(gfptr,CASESEN,"MEMBER_LOCATION",locationCol,
				status);

      if(*status == COL_NOT_FOUND)
	{
	  *status      = 0;
	  *locationCol = 0;
	}

      if(*status != 0) continue;

      *status = fits_get_colnum(gfptr,CASESEN,"MEMBER_URI_TYPE",uriCol,
				status);

      if(*status == COL_NOT_FOUND)
	{
	  *status = 0;
	  *uriCol = 0;
	}

      if(*status != 0) continue;

      /*
	 determine the type of grouping table structure used by this
	 grouping table and record it in the grptype parameter
      */

      if(*xtensionCol && *extnameCol && *extverCol && *positionCol &&
	 *locationCol && *uriCol) 
	*grptype = GT_ID_ALL_URI;
      
      else if(*xtensionCol && *extnameCol && *extverCol &&
	      *locationCol && *uriCol) 
	*grptype = GT_ID_REF_URI;

      else if(*xtensionCol && *extnameCol && *extverCol && *positionCol)
	*grptype = GT_ID_ALL;
      
      else if(*xtensionCol && *extnameCol && *extverCol)
	*grptype = GT_ID_REF;
      
      else if(*positionCol && *locationCol && *uriCol) 
	*grptype = GT_ID_POS_URI;
      
      else if(*positionCol)
	*grptype = GT_ID_POS;
      
      else
	*status = NOT_GROUP_TABLE;
      
    }while(0);

  /*
    if the table contained more than one column with a reserved name then
    this cannot be considered a vailid grouping table
  */

  if(*status == COL_NOT_UNIQUE) 
    {
      *status = NOT_GROUP_TABLE;
      ffpmsg("Specified HDU has multipule Group table cols defined (ffgtgc)");
    }

  return(*status);
}

/*****************************************************************************/
int ffgtdc(int   grouptype,     /* code specifying the type of
				   grouping table information:
				   GT_ID_ALL_URI  0 ==> defualt (all columns)
				   GT_ID_REF      1 ==> ID by reference
				   GT_ID_POS      2 ==> ID by position
				   GT_ID_ALL      3 ==> ID by ref. and position
				   GT_ID_REF_URI 11 ==> (1) + URI info 
				   GT_ID_POS_URI 12 ==> (2) + URI info       */
	   int   xtensioncol, /* does MEMBER_XTENSION already exist?         */
	   int   extnamecol,  /* does MEMBER_NAME aleady exist?              */
	   int   extvercol,   /* does MEMBER_VERSION already exist?          */
	   int   positioncol, /* does MEMBER_POSITION already exist?         */
	   int   locationcol, /* does MEMBER_LOCATION already exist?         */
	   int   uricol,      /* does MEMBER_URI_TYPE aleardy exist?         */
	   char *ttype[],     /* array of grouping table column TTYPE names
				 to define (if *col var false)               */
	   char *tform[],     /* array of grouping table column TFORM values
				 to define (if*col variable false)           */
	   int  *ncols,       /* number of TTYPE and TFORM values returned   */
	   int  *status)      /* return status code                          */

/*
  create the TTYPE and TFORM values for the grouping table according to the
  value of the grouptype parameter and the values of the *col flags. The
  resulting TTYPE and TFORM are returned in ttype[] and tform[] respectively.
  The number of TTYPE and TFORMs returned is given by ncols. Both the TTYPE[]
  and TTFORM[] arrays must contain enough pre-allocated strings to hold
  the returned information.
*/

{

  int i = 0;

  char  xtension[]  = "MEMBER_XTENSION";
  char  xtenTform[] = "8A";
  
  char  name[]      = "MEMBER_NAME";
  char  nameTform[] = "32A";

  char  version[]   = "MEMBER_VERSION";
  char  verTform[]  = "1J";
  
  char  position[]  = "MEMBER_POSITION";
  char  posTform[]  = "1J";

  char  URI[]       = "MEMBER_URI_TYPE";
  char  URITform[]  = "3A";

  char  location[]  = "MEMBER_LOCATION";
  /* SPR 01720, move from 160A to 256A */
  char  locTform[]  = "256A";


  if(*status != 0) return(*status);

  switch(grouptype)
    {
      
    case GT_ID_ALL_URI:

      if(xtensioncol == 0)
	{
	  strcpy(ttype[i],xtension);
	  strcpy(tform[i],xtenTform);
	  ++i;
	}
      if(extnamecol == 0)
	{
	  strcpy(ttype[i],name);
	  strcpy(tform[i],nameTform);
	  ++i;
	}
      if(extvercol == 0)
	{
	  strcpy(ttype[i],version);
	  strcpy(tform[i],verTform);
	  ++i;
	}
      if(positioncol == 0)
	{
	  strcpy(ttype[i],position);
	  strcpy(tform[i],posTform);
	  ++i;
	}
      if(locationcol == 0)
	{
	  strcpy(ttype[i],location);
	  strcpy(tform[i],locTform);
	  ++i;
	}
      if(uricol == 0)
	{
	  strcpy(ttype[i],URI);
	  strcpy(tform[i],URITform);
	  ++i;
	}
      break;
      
    case GT_ID_REF:
      
      if(xtensioncol == 0)
	{
	  strcpy(ttype[i],xtension);
	  strcpy(tform[i],xtenTform);
	  ++i;
	}
      if(extnamecol == 0)
	{
	  strcpy(ttype[i],name);
	  strcpy(tform[i],nameTform);
	  ++i;
	}
      if(extvercol == 0)
	{
	  strcpy(ttype[i],version);
	  strcpy(tform[i],verTform);
	  ++i;
	}
      break;
      
    case GT_ID_POS:
      
      if(positioncol == 0)
	{
	  strcpy(ttype[i],position);
	  strcpy(tform[i],posTform);
	  ++i;
	}	  
      break;
      
    case GT_ID_ALL:
      
      if(xtensioncol == 0)
	{
	  strcpy(ttype[i],xtension);
	  strcpy(tform[i],xtenTform);
	  ++i;
	}
      if(extnamecol == 0)
	{
	  strcpy(ttype[i],name);
	  strcpy(tform[i],nameTform);
	  ++i;
	}
      if(extvercol == 0)
	{
	  strcpy(ttype[i],version);
	  strcpy(tform[i],verTform);
	  ++i;
	}
      if(positioncol == 0)
	{
	  strcpy(ttype[i],position);
	  strcpy(tform[i], posTform);
	  ++i;
	}	  
      
      break;
      
    case GT_ID_REF_URI:
      
      if(xtensioncol == 0)
	{
	  strcpy(ttype[i],xtension);
	  strcpy(tform[i],xtenTform);
	  ++i;
	}
      if(extnamecol == 0)
	{
	  strcpy(ttype[i],name);
	  strcpy(tform[i],nameTform);
	  ++i;
	}
      if(extvercol == 0)
	{
	  strcpy(ttype[i],version);
	  strcpy(tform[i],verTform);
	  ++i;
	}
      if(locationcol == 0)
	{
	  strcpy(ttype[i],location);
	  strcpy(tform[i],locTform);
	  ++i;
	}
      if(uricol == 0)
	{
	  strcpy(ttype[i],URI);
	  strcpy(tform[i],URITform);
	  ++i;
	}
      break;
      
    case GT_ID_POS_URI:
      
      if(positioncol == 0)
	{
	  strcpy(ttype[i],position);
	  strcpy(tform[i],posTform);
	  ++i;
	}
      if(locationcol == 0)
	{
	  strcpy(ttype[i],location);
	  strcpy(tform[i],locTform);
	  ++i;
	}
      if(uricol == 0)
	{
	  strcpy(ttype[i],URI);
	  strcpy(tform[i],URITform);
	  ++i;
	}
      break;
      
    default:
      
      *status = BAD_OPTION;
      ffpmsg("Invalid value specified for the grouptype parameter (ffgtdc)");

      break;

    }

  *ncols = i;
  
  return(*status);
}

/*****************************************************************************/
int ffgmul(fitsfile *mfptr,   /* pointer to the grouping table member HDU    */
           int       rmopt,   /* 0 ==> leave GRPIDn/GRPLCn keywords,
				 1 ==> remove GRPIDn/GRPLCn keywords         */
	   int      *status) /* return status code                          */

/*
   examine all the GRPIDn and GRPLCn keywords in the member HDUs header
   and remove the member from the grouping tables referenced; This
   effectively "unlinks" the member from all of its groups. The rmopt 
   specifies if the GRPIDn/GRPLCn keywords are to be removed from the
   member HDUs header after the unlinking.
*/

{
  int memberPosition = 0;
  int iomode;

  long index;
  long ngroups      = 0;
  long memberExtver = 0;
  long memberID     = 0;

  char mbrLocation1[FLEN_FILENAME];
  char mbrLocation2[FLEN_FILENAME];
  char memberHDUtype[FLEN_VALUE];
  char memberExtname[FLEN_VALUE];
  char keyword[FLEN_KEYWORD];
  char card[FLEN_CARD];

  fitsfile *gfptr = NULL;


  if(*status != 0) return(*status);

  do
    {
      /* 
	 determine location parameters of the member HDU; note that
	 default values are supplied if the expected keywords are not
	 found
      */

      *status = fits_read_key_str(mfptr,"XTENSION",memberHDUtype,card,status);

      if(*status == KEY_NO_EXIST) 
	{
	  strcpy(memberHDUtype,"PRIMARY");
	  *status = 0;
	}
      prepare_keyvalue(memberHDUtype);

      *status = fits_read_key_lng(mfptr,"EXTVER",&memberExtver,card,status);

      if(*status == KEY_NO_EXIST) 
	{
	  memberExtver = 1;
	  *status      = 0;
	}

      *status = fits_read_key_str(mfptr,"EXTNAME",memberExtname,card,status);

      if(*status == KEY_NO_EXIST) 
	{
	  memberExtname[0] = 0;
	  *status          = 0;
	}
      prepare_keyvalue(memberExtname);

      fits_get_hdu_num(mfptr,&memberPosition);

      *status = fits_get_url(mfptr,mbrLocation1,mbrLocation2,NULL,NULL,
			     NULL,status);

      if(*status != 0) continue;

      /*
	 open each grouping table linked to this HDU and remove the member 
	 from the grouping tables
      */

      *status = fits_get_num_groups(mfptr,&ngroups,status);

      /* loop over each group linked to the member HDU */

      for(index = 1; index <= ngroups && *status == 0; ++index)
	{
	  /* open the (index)th group linked to the member HDU */ 

	  *status = fits_open_group(mfptr,index,&gfptr,status);

	  /* if the group could not be opened then just skip it */

	  if(*status != 0)
	    {
	      *status = 0;
	      sprintf(card,"Cannot open the %dth group table (ffgmul)",
		      (int)index);
	      ffpmsg(card);
	      continue;
	    }

	  /*
	    make sure the grouping table can be modified before proceeding
	  */
	  
	  fits_file_mode(gfptr,&iomode,status);

	  if(iomode != READWRITE)
	    {
	      sprintf(card,"The %dth group cannot be modified (ffgtam)",
		      (int)index);
	      ffpmsg(card);
	      continue;
	    }

	  /* 
	     try to find the member's row within the grouping table; first 
	     try using the member HDU file's "real" URL string then try
	     using its originally opened URL string if either string exist
	   */
	     
	  memberID = 0;
 
	  if(strlen(mbrLocation1) != 0)
	    {
	      *status = ffgmf(gfptr,memberHDUtype,memberExtname,memberExtver,
			      memberPosition,mbrLocation1,&memberID,status);
	    }

	  if(*status == MEMBER_NOT_FOUND && strlen(mbrLocation2) != 0)
	    {
	      *status = 0;
	      *status = ffgmf(gfptr,memberHDUtype,memberExtname,memberExtver,
			      memberPosition,mbrLocation2,&memberID,status);
	    }

	  /* if the member was found then delete it from the grouping table */

	  if(*status == 0)
	    *status = fits_delete_rows(gfptr,memberID,1,status);

	  /*
	     continue the loop over all member groups even if an error
	     was generated
	  */

	  if(*status == MEMBER_NOT_FOUND)
	    {
	      ffpmsg("cannot locate member's entry in group table (ffgmul)");
	    }
	  *status = 0;

	  /*
	     close the file pointed to by gfptr if it is non NULL to
	     prepare for the next loop iterration
	  */

	  if(gfptr != NULL)
	    {
	      fits_close_file(gfptr,status);
	      gfptr = NULL;
	    }
	}

      if(*status != 0) continue;

      /*
	 if rmopt is non-zero then find and delete the GRPIDn/GRPLCn 
	 keywords from the member HDU header
      */

      if(rmopt != 0)
	{
	  fits_file_mode(mfptr,&iomode,status);

	  if(iomode == READONLY)
	    {
	      ffpmsg("Cannot modify member HDU, opened READONLY (ffgmul)");
	      continue;
	    }

	  /* delete all the GRPIDn/GRPLCn keywords */

	  for(index = 1; index <= ngroups && *status == 0; ++index)
	    {
	      sprintf(keyword,"GRPID%d",(int)index);
	      fits_delete_key(mfptr,keyword,status);
	      
	      sprintf(keyword,"GRPLC%d",(int)index);
	      fits_delete_key(mfptr,keyword,status);

	      if(*status == KEY_NO_EXIST) *status = 0;
	    }
	}
    }while(0);

  /* make sure the gfptr has been closed */

  if(gfptr != NULL)
    { 
      fits_close_file(gfptr,status);
    }

return(*status);
}

/*--------------------------------------------------------------------------*/
int ffgmf(fitsfile *gfptr, /* pointer to grouping table HDU to search       */
	   char *xtension,  /* XTENSION value for member HDU                */
	   char *extname,   /* EXTNAME value for member HDU                 */
	   int   extver,    /* EXTVER value for member HDU                  */
	   int   position,  /* HDU position value for member HDU            */
	   char *location,  /* FITS file location value for member HDU      */
	   long *member,    /* member HDU ID within group table (if found)  */
	   int  *status)    /* return status code                           */

/*
   try to find the entry for the member HDU defined by the xtension, extname,
   extver, position, and location parameters within the grouping table
   pointed to by gfptr. If the member HDU is found then its ID (row number)
   within the grouping table is returned in the member variable; if not
   found then member is returned with a value of 0 and the status return
   code will be set to MEMBER_NOT_FOUND.

   Note that the member HDU postion information is used to obtain a member
   match only if the grouping table type is GT_ID_POS_URI or GT_ID_POS. This
   is because the position information can become invalid much more
   easily then the reference information for a group member.
*/

{
  int xtensionCol,extnameCol,extverCol,positionCol,locationCol,uriCol;
  int mposition = 0;
  int grptype;
  int dummy;
  int i;

  long nmembers = 0;
  long mextver  = 0;
 
  char  charBuff1[FLEN_FILENAME];
  char  charBuff2[FLEN_FILENAME];
  char  tmpLocation[FLEN_FILENAME];
  char  mbrLocation1[FLEN_FILENAME];
  char  mbrLocation2[FLEN_FILENAME];
  char  mbrLocation3[FLEN_FILENAME];
  char  grpLocation1[FLEN_FILENAME];
  char  grpLocation2[FLEN_FILENAME];
  char  cwd[FLEN_FILENAME];

  char  nstr[] = {'\0'};
  char *tmpPtr[2];

  if(*status != 0) return(*status);

  *member = 0;

  tmpPtr[0] = charBuff1;
  tmpPtr[1] = charBuff2;


  if(*status != 0) return(*status);

  /*
    if the passed LOCATION value is not an absolute URL then turn it
    into an absolute path
  */

  if(location == NULL)
    {
      *tmpLocation = 0;
    }

  else if(*location == 0)
    {
      *tmpLocation = 0;
    }

  else if(!fits_is_url_absolute(location))
    {
      fits_path2url(location,tmpLocation,status);

      if(*tmpLocation != '/')
	{
	  fits_get_cwd(cwd,status);
	  strcat(cwd,"/");
	  strcat(cwd,tmpLocation);
	  fits_clean_url(cwd,tmpLocation,status);
	}
    }

  else
    strcpy(tmpLocation,location);

  /*
     retrieve the Grouping Convention reserved column positions within
     the grouping table
  */

  *status = ffgtgc(gfptr,&xtensionCol,&extnameCol,&extverCol,&positionCol,
		   &locationCol,&uriCol,&grptype,status);

  /* retrieve the number of group members */

  *status = fits_get_num_members(gfptr,&nmembers,status);
	      
  /* 
     loop over all grouping table rows until the member HDU is found 
  */

  for(i = 1; i <= nmembers && *member == 0 && *status == 0; ++i)
    {
      if(xtensionCol != 0)
	{
	  fits_read_col_str(gfptr,xtensionCol,i,1,1,nstr,tmpPtr,&dummy,status);
	  if(strcasecmp(tmpPtr[0],xtension) != 0) continue;
	}
	  
      if(extnameCol  != 0)
	{
	  fits_read_col_str(gfptr,extnameCol,i,1,1,nstr,tmpPtr,&dummy,status);
	  if(strcasecmp(tmpPtr[0],extname) != 0) continue;
	}
	  
      if(extverCol   != 0)
	{
	  fits_read_col_lng(gfptr,extverCol,i,1,1,0,
			    (long*)&mextver,&dummy,status);
	  if(extver != mextver) continue;
	}
      
      /* note we only use postionCol if we have to */

      if(positionCol != 0 && 
	            (grptype == GT_ID_POS || grptype == GT_ID_POS_URI))
	{
	  fits_read_col_int(gfptr,positionCol,i,1,1,0,
			    &mposition,&dummy,status);
	  if(position != mposition) continue;
	}
      
      /*
	if no location string was passed to the function then assume that
	the calling application does not wish to use it as a comparision
	critera ==> if we got this far then we have a match
      */

      if(location == NULL)
	{
	  ffpmsg("NULL Location string given ==> ingore location (ffgmf)");
	  *member = i;
	  continue;
	}

      /*
	if the grouping table MEMBER_LOCATION column exists then read the
	location URL for the member, else set the location string to
	a zero-length string for subsequent comparisions
      */

      if(locationCol != 0)
	{
	  fits_read_col_str(gfptr,locationCol,i,1,1,nstr,tmpPtr,&dummy,status);
	  strcpy(mbrLocation1,tmpPtr[0]);
	  *mbrLocation2 = 0;
	}
      else
	*mbrLocation1 = 0;

      /* 
	 if the member location string from the grouping table is zero 
	 length (either implicitly or explicitly) then assume that the 
	 member HDU is in the same file as the grouping table HDU; retrieve
	 the possible URL values of the grouping table HDU file 
       */

      if(*mbrLocation1 == 0)
	{
	  /* retrieve the possible URLs of the grouping table file */
	  *status = fits_get_url(gfptr,mbrLocation1,mbrLocation2,NULL,NULL,
				 NULL,status);

	  /* if non-NULL, make sure the first URL is absolute or a full path */
	  if(*mbrLocation1 != 0 && !fits_is_url_absolute(mbrLocation1) &&
	     *mbrLocation1 != '/')
	    {
	      fits_get_cwd(cwd,status);
	      strcat(cwd,"/");
	      strcat(cwd,mbrLocation1);
	      fits_clean_url(cwd,mbrLocation1,status);
	    }

	  /* if non-NULL, make sure the first URL is absolute or a full path */
	  if(*mbrLocation2 != 0 && !fits_is_url_absolute(mbrLocation2) &&
	     *mbrLocation2 != '/')
	    {
	      fits_get_cwd(cwd,status);
	      strcat(cwd,"/");
	      strcat(cwd,mbrLocation2);
	      fits_clean_url(cwd,mbrLocation2,status);
	    }
	}

      /*
	if the member location was specified, then make sure that it is
	either an absolute URL or specifies a full path
      */

      else if(!fits_is_url_absolute(mbrLocation1) && *mbrLocation1 != '/')
	{
	  strcpy(mbrLocation2,mbrLocation1);

	  /* get the possible URLs for the grouping table file */
	  *status = fits_get_url(gfptr,grpLocation1,grpLocation2,NULL,NULL,
				 NULL,status);
	  
	  if(*grpLocation1 != 0)
	    {
	      /* make sure the first grouping table URL is absolute */
	      if(!fits_is_url_absolute(grpLocation1) && *grpLocation1 != '/')
		{
		  fits_get_cwd(cwd,status);
		  strcat(cwd,"/");
		  strcat(cwd,grpLocation1);
		  fits_clean_url(cwd,grpLocation1,status);
		}
	      
	      /* create an absoute URL for the member */

	      fits_relurl2url(grpLocation1,mbrLocation1,mbrLocation3,status);
	      
	      /* 
		 if URL construction succeeded then copy it to the
		 first location string; else set the location string to 
		 empty
	      */

	      if(*status == 0)
		{
		  strcpy(mbrLocation1,mbrLocation3);
		}

	      else if(*status == URL_PARSE_ERROR)
		{
		  *status       = 0;
		  *mbrLocation1 = 0;
		}
	    }
	  else
	    *mbrLocation1 = 0;

	  if(*grpLocation2 != 0)
	    {
	      /* make sure the second grouping table URL is absolute */
	      if(!fits_is_url_absolute(grpLocation2) && *grpLocation2 != '/')
		{
		  fits_get_cwd(cwd,status);
		  strcat(cwd,"/");
		  strcat(cwd,grpLocation2);
		  fits_clean_url(cwd,grpLocation2,status);
		}
	      
	      /* create an absolute URL for the member */

	      fits_relurl2url(grpLocation2,mbrLocation2,mbrLocation3,status);
	      
	      /* 
		 if URL construction succeeded then copy it to the
		 second location string; else set the location string to 
		 empty
	      */

	      if(*status == 0)
		{
		  strcpy(mbrLocation2,mbrLocation3);
		}

	      else if(*status == URL_PARSE_ERROR)
		{
		  *status       = 0;
		  *mbrLocation2 = 0;
		}
	    }
	  else
	    *mbrLocation2 = 0;
	}

      /*
	compare the passed member HDU file location string with the
	(possibly two) member location strings to see if there is a match
       */

      if(strcmp(mbrLocation1,tmpLocation) != 0 && 
	 strcmp(mbrLocation2,tmpLocation) != 0   ) continue;
  
      /* if we made it this far then a match to the member HDU was found */
      
      *member = i;
    }

  /* if a match was not found then set the return status code */

  if(*member == 0 && *status == 0) 
    {
      *status = MEMBER_NOT_FOUND;
      ffpmsg("Cannot find specified member HDU (ffgmf)");
    }

  return(*status);
}

/*--------------------------------------------------------------------------
                        Recursive Group Functions
  --------------------------------------------------------------------------*/
int ffgtrmr(fitsfile   *gfptr,  /* FITS file pointer to group               */
	    HDUtracker *HDU,    /* list of processed HDUs                   */
	    int        *status) /* return status code                       */
	    
/*
  recursively remove a grouping table and all its members. Each member of
  the grouping table pointed to by gfptr it processed. If the member is itself
  a grouping table then ffgtrmr() is recursively called to process all
  of its members. The HDUtracker struct *HDU is used to make sure a member
  is not processed twice, thus avoiding an infinite loop (e.g., a grouping
  table contains itself as a member).
*/

{
  int i;
  int hdutype;

  long nmembers = 0;

  char keyvalue[FLEN_VALUE];
  char comment[FLEN_COMMENT];
  
  fitsfile *mfptr = NULL;


  if(*status != 0) return(*status);

  /* get the number of members contained by this grouping table */

  *status = fits_get_num_members(gfptr,&nmembers,status);

  /* loop over all group members and delete them */

  for(i = nmembers; i > 0 && *status == 0; --i)
    {
      /* open the member HDU */

      *status = fits_open_member(gfptr,i,&mfptr,status);

      /* if the member cannot be opened then just skip it and continue */

      if(*status == MEMBER_NOT_FOUND) 
	{
	  *status = 0;
	  continue;
	}

      /* Any other error is a reason to abort */
      
      if(*status != 0) continue;

      /* add the member HDU to the HDUtracker struct */

      *status = fftsad(mfptr,HDU,NULL,NULL);

      /* status == HDU_ALREADY_TRACKED ==> HDU has already been processed */

      if(*status == HDU_ALREADY_TRACKED) 
	{
	  *status = 0;
	  fits_close_file(mfptr,status);
	  continue;
	}
      else if(*status != 0) continue;

      /* determine if the member HDU is itself a grouping table */

      *status = fits_read_key_str(mfptr,"EXTNAME",keyvalue,comment,status);

      /* if no EXTNAME is found then the HDU cannot be a grouping table */ 

      if(*status == KEY_NO_EXIST) 
	{
	  *status     = 0;
	  keyvalue[0] = 0;
	}
      prepare_keyvalue(keyvalue);

      /* Any other error is a reason to abort */
      
      if(*status != 0) continue;

      /* 
	 if the EXTNAME == GROUPING then the member is a grouping table 
	 and we must call ffgtrmr() to process its members
      */

      if(strcasecmp(keyvalue,"GROUPING") == 0)
	  *status = ffgtrmr(mfptr,HDU,status);  

      /* 
	 unlink all the grouping tables that contain this HDU as a member 
	 and then delete the HDU (if not a PHDU)
      */

      if(fits_get_hdu_num(mfptr,&hdutype) == 1)
	      *status = ffgmul(mfptr,1,status);
      else
	  {
	      *status = ffgmul(mfptr,0,status);
	      *status = fits_delete_hdu(mfptr,&hdutype,status);
	  }

      /* close the fitsfile pointer */

      fits_close_file(mfptr,status);
    }

  return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgtcpr(fitsfile   *infptr,  /* input FITS file pointer                 */
	    fitsfile   *outfptr, /* output FITS file pointer                */
	    int         cpopt,   /* code specifying copy options:
				    OPT_GCP_GPT (0) ==> cp only grouping table
				    OPT_GCP_ALL (2) ==> recusrively copy 
				    members and their members (if groups)   */
	    HDUtracker *HDU,     /* list of already copied HDUs             */
	    int        *status)  /* return status code                      */

/*
  copy a Group to a new FITS file. If the cpopt parameter is set to 
  OPT_GCP_GPT (copy grouping table only) then the existing members have their 
  GRPIDn and GRPLCn keywords updated to reflect the existance of the new group,
  since they now belong to another group. If cpopt is set to OPT_GCP_ALL 
  (copy grouping table and members recursively) then the original members are 
  not updated; the new grouping table is modified to include only the copied 
  member HDUs and not the original members.

  Note that this function is recursive. When copt is OPT_GCP_ALL it will call
  itself whenever a member HDU of the current grouping table is itself a
  grouping table (i.e., EXTNAME = 'GROUPING').
*/

{

  int i;
  int nexclude     = 8;
  int hdutype      = 0;
  int groupHDUnum  = 0;
  int numkeys      = 0;
  int keypos       = 0;
  int startSearch  = 0;
  int newPosition  = 0;

  long nmembers    = 0;
  long tfields     = 0;
  long newTfields  = 0;

  char keyword[FLEN_KEYWORD];
  char keyvalue[FLEN_VALUE];
  char card[FLEN_CARD];
  char comment[FLEN_CARD];
  char *tkeyvalue;

  char *includeList[] = {"*"};
  char *excludeList[] = {"EXTNAME","EXTVER","GRPNAME","GRPID#","GRPLC#",
			 "THEAP","TDIM#","T????#"};

  fitsfile *mfptr = NULL;


  if(*status != 0) return(*status);

  do
    {
      /*
	create a new grouping table in the FITS file pointed to by outptr
      */

      *status = fits_get_num_members(infptr,&nmembers,status);

      *status = fits_read_key_str(infptr,"GRPNAME",keyvalue,card,status);

      if(*status == KEY_NO_EXIST)
	{
	  keyvalue[0] = 0;
	  *status     = 0;
	}
      prepare_keyvalue(keyvalue);

      *status = fits_create_group(outfptr,keyvalue,GT_ID_ALL_URI,status);
     
      /* save the new grouping table's HDU position for future use */

      fits_get_hdu_num(outfptr,&groupHDUnum);

      /* update the HDUtracker struct with the grouping table's new position */
      
      *status = fftsud(infptr,HDU,groupHDUnum,NULL);

      /*
	Now populate the copied grouping table depending upon the 
	copy option parameter value
      */

      switch(cpopt)
	{

	  /*
	    for the "copy grouping table only" option we only have to
	    add the members of the original grouping table to the new
	    grouping table
	  */

	case OPT_GCP_GPT:

	  for(i = 1; i <= nmembers && *status == 0; ++i)
	    {
	      *status = fits_open_member(infptr,i,&mfptr,status);
	      *status = fits_add_group_member(outfptr,mfptr,0,status);

	      fits_close_file(mfptr,status);
	      mfptr = NULL;
	    }

	  break;

	case OPT_GCP_ALL:
      
	  /*
	    for the "copy the entire group" option
 	  */

	  /* loop over all the grouping table members */

	  for(i = 1; i <= nmembers && *status == 0; ++i)
	    {
	      /* open the ith member */

	      *status = fits_open_member(infptr,i,&mfptr,status);

	      if(*status != 0) continue;

	      /* add it to the HDUtracker struct */

	      *status = fftsad(mfptr,HDU,&newPosition,NULL);

	      /* if already copied then just add the member to the group */

	      if(*status == HDU_ALREADY_TRACKED)
		{
		  *status = 0;
		  *status = fits_add_group_member(outfptr,NULL,newPosition,
						  status);
		  fits_close_file(mfptr,status);
                  mfptr = NULL;
		  continue;
		}
	      else if(*status != 0) continue;

	      /* see if the member is a grouping table */

	      *status = fits_read_key_str(mfptr,"EXTNAME",keyvalue,card,
					  status);

	      if(*status == KEY_NO_EXIST)
		{
		  keyvalue[0] = 0;
		  *status     = 0;
		}
	      prepare_keyvalue(keyvalue);

	      /*
		if the member is a grouping table then copy it and all of
		its members using ffgtcpr(), else copy it using
		fits_copy_member(); the outptr will point to the newly
		copied member upon return from both functions
	      */

	      if(strcasecmp(keyvalue,"GROUPING") == 0)
		*status = ffgtcpr(mfptr,outfptr,OPT_GCP_ALL,HDU,status);
	      else
		*status = fits_copy_member(infptr,outfptr,i,OPT_MCP_NADD,
					   status);

	      /* retrieve the position of the newly copied member */

	      fits_get_hdu_num(outfptr,&newPosition);

	      /* update the HDUtracker struct with member's new position */
	      
	      if(strcasecmp(keyvalue,"GROUPING") != 0)
		*status = fftsud(mfptr,HDU,newPosition,NULL);

	      /* move the outfptr back to the copied grouping table HDU */

	      *status = fits_movabs_hdu(outfptr,groupHDUnum,&hdutype,status);

	      /* add the copied member HDU to the copied grouping table */

	      *status = fits_add_group_member(outfptr,NULL,newPosition,status);

	      /* close the mfptr pointer */

	      fits_close_file(mfptr,status);
	      mfptr = NULL;
	    }

	  break;

	default:
	  
	  *status = BAD_OPTION;
	  ffpmsg("Invalid value specified for cmopt parameter (ffgtcpr)");
	  break;
	}

      if(*status != 0) continue; 

      /* 
	 reposition the outfptr to the grouping table so that the grouping
	 table is the CHDU upon return to the calling function
      */

      fits_movabs_hdu(outfptr,groupHDUnum,&hdutype,status);

      /*
	 copy all auxiliary keyword records from the original grouping table
	 to the new grouping table; they are copied in their original order
	 and inserted just before the TTYPE1 keyword record
      */

      *status = fits_read_card(outfptr,"TTYPE1",card,status);
      *status = fits_get_hdrpos(outfptr,&numkeys,&keypos,status);
      --keypos;

      startSearch = 8;

      while(*status == 0)
	{
	  ffgrec(infptr,startSearch,card,status);

	  *status = fits_find_nextkey(infptr,includeList,1,excludeList,
				      nexclude,card,status);

	  *status = fits_get_hdrpos(infptr,&numkeys,&startSearch,status);

	  --startSearch;
	  /* SPR 1738 */
	  if (strncmp(card,"GRPLC",5)) {
	    /* Not going to be a long string so we're ok */
	    *status = fits_insert_record(outfptr,keypos,card,status);
	  } else {
	    /* We could have a long string */
	    *status = fits_read_record(infptr,startSearch,card,status);
	    card[9] = '\0';
	    *status = fits_read_key_longstr(infptr,card,&tkeyvalue,comment,
					    status);
	    if (0 == *status) {
	      fits_insert_key_longstr(outfptr,card,tkeyvalue,comment,status);
	      fits_write_key_longwarn(outfptr,status);
	      free(tkeyvalue);
	    }
	  }
	  
	  ++keypos;
	}
      
	  
      if(*status == KEY_NO_EXIST) 
	*status = 0;
      else if(*status != 0) continue;

      /*
	 search all the columns of the original grouping table and copy
	 those to the new grouping table that were not part of the grouping
	 convention. Note that is legal to have additional columns in a
	 grouping table. Also note that the order of the columns may
	 not be the same in the original and copied grouping table.
      */

      /* retrieve the number of columns in the original and new group tables */

      *status = fits_read_key_lng(infptr,"TFIELDS",&tfields,card,status);
      *status = fits_read_key_lng(outfptr,"TFIELDS",&newTfields,card,status);

      for(i = 1; i <= tfields; ++i)
	{
	  sprintf(keyword,"TTYPE%d",i);
	  *status = fits_read_key_str(infptr,keyword,keyvalue,card,status);
	  
	  if(*status == KEY_NO_EXIST)
	    {
	      *status = 0;
              keyvalue[0] = 0;
	    }
	  prepare_keyvalue(keyvalue);

	  if(strcasecmp(keyvalue,"MEMBER_XTENSION") != 0 &&
	     strcasecmp(keyvalue,"MEMBER_NAME")     != 0 &&
	     strcasecmp(keyvalue,"MEMBER_VERSION")  != 0 &&
	     strcasecmp(keyvalue,"MEMBER_POSITION") != 0 &&
	     strcasecmp(keyvalue,"MEMBER_LOCATION") != 0 &&
	     strcasecmp(keyvalue,"MEMBER_URI_TYPE") != 0   )
	    {
 
	      /* SPR 3956, add at the end of the table */
	      *status = fits_copy_col(infptr,outfptr,i,newTfields+1,1,status);
	      ++newTfields;
	    }
	}

    }while(0);

  if(mfptr != NULL) 
    {
      fits_close_file(mfptr,status);
    }

  return(*status);
}

/*--------------------------------------------------------------------------
                HDUtracker struct manipulation functions
  --------------------------------------------------------------------------*/
int fftsad(fitsfile   *mfptr,       /* pointer to an member HDU             */
	   HDUtracker *HDU,         /* pointer to an HDU tracker struct     */
	   int        *newPosition, /* new HDU position of the member HDU   */
	   char       *newFileName) /* file containing member HDU           */

/*
  add an HDU to the HDUtracker struct pointed to by HDU. The HDU is only 
  added if it does not already reside in the HDUtracker. If it already
  resides in the HDUtracker then the new HDU postion and file name are
  returned in  newPosition and newFileName (if != NULL)
*/

{
  int i;
  int hdunum;
  int status = 0;

  char filename1[FLEN_FILENAME];
  char filename2[FLEN_FILENAME];

  do
    {
      /* retrieve the HDU's position within the FITS file */

      fits_get_hdu_num(mfptr,&hdunum);
      
      /* retrieve the HDU's file name */
      
      status = fits_file_name(mfptr,filename1,&status);
      
      /* parse the file name and construct the "standard" URL for it */
      
      status = ffrtnm(filename1,filename2,&status);
      
      /* 
	 examine all the existing HDUs in the HDUtracker an see if this HDU
	 has already been registered
      */

      for(i = 0; 
       i < HDU->nHDU &&  !(HDU->position[i] == hdunum 
			   && strcmp(HDU->filename[i],filename2) == 0);
	  ++i);

      if(i != HDU->nHDU) 
	{
	  status = HDU_ALREADY_TRACKED;
	  if(newPosition != NULL) *newPosition = HDU->newPosition[i];
	  if(newFileName != NULL) strcpy(newFileName,HDU->newFilename[i]);
	  continue;
	}

      if(HDU->nHDU == MAX_HDU_TRACKER) 
	{
	  status = TOO_MANY_HDUS_TRACKED;
	  continue;
	}

      HDU->filename[i] = (char*) malloc(FLEN_FILENAME * sizeof(char));

      if(HDU->filename[i] == NULL)
	{
	  status = MEMORY_ALLOCATION;
	  continue;
	}

      HDU->newFilename[i] = (char*) malloc(FLEN_FILENAME * sizeof(char));

      if(HDU->newFilename[i] == NULL)
	{
	  status = MEMORY_ALLOCATION;
	  free(HDU->filename[i]);
	  continue;
	}

      HDU->position[i]    = hdunum;
      HDU->newPosition[i] = hdunum;

      strcpy(HDU->filename[i],filename2);
      strcpy(HDU->newFilename[i],filename2);
 
       ++(HDU->nHDU);

    }while(0);

  return(status);
}
/*--------------------------------------------------------------------------*/
int fftsud(fitsfile   *mfptr,       /* pointer to an member HDU             */
	   HDUtracker *HDU,         /* pointer to an HDU tracker struct     */
	   int         newPosition, /* new HDU position of the member HDU   */
	   char       *newFileName) /* file containing member HDU           */

/*
  update the HDU information in the HDUtracker struct pointed to by HDU. The 
  HDU to update is pointed to by mfptr. If non-zero, the value of newPosition
  is used to update the HDU->newPosition[] value for the mfptr, and if
  non-NULL the newFileName value is used to update the HDU->newFilename[]
  value for mfptr.
*/

{
  int i;
  int hdunum;
  int status = 0;

  char filename1[FLEN_FILENAME];
  char filename2[FLEN_FILENAME];


  /* retrieve the HDU's position within the FITS file */
  
  fits_get_hdu_num(mfptr,&hdunum);
  
  /* retrieve the HDU's file name */
  
  status = fits_file_name(mfptr,filename1,&status);
  
  /* parse the file name and construct the "standard" URL for it */
      
  status = ffrtnm(filename1,filename2,&status);

  /* 
     examine all the existing HDUs in the HDUtracker an see if this HDU
     has already been registered
  */

  for(i = 0; i < HDU->nHDU && 
      !(HDU->position[i] == hdunum && strcmp(HDU->filename[i],filename2) == 0);
      ++i);

  /* if previously registered then change newPosition and newFileName */

  if(i != HDU->nHDU) 
    {
      if(newPosition  != 0) HDU->newPosition[i] = newPosition;
      if(newFileName  != NULL) 
	{
	  strcpy(HDU->newFilename[i],newFileName);
	}
    }
  else
    status = MEMBER_NOT_FOUND;
 
  return(status);
}

/*---------------------------------------------------------------------------*/

void prepare_keyvalue(char *keyvalue) /* string containing keyword value     */

/*
  strip off all single quote characters "'" and blank spaces from a keyword
  value retrieved via fits_read_key*() routines

  this is necessary so that a standard comparision of keyword values may
  be made
*/

{

  int i;
  int length;

  /*
    strip off any leading or trailing single quotes (`) and (') from
    the keyword value
  */

  length = strlen(keyvalue) - 1;

  if(keyvalue[0] == '\'' && keyvalue[length] == '\'')
    {
      for(i = 0; i < length - 1; ++i) keyvalue[i] = keyvalue[i+1];
      keyvalue[length-1] = 0;
    }
  
  /*
    strip off any trailing blanks from the keyword value; note that if the
    keyvalue consists of nothing but blanks then no blanks are stripped
  */

  length = strlen(keyvalue) - 1;

  for(i = 0; i < length && keyvalue[i] == ' '; ++i);

  if(i != length)
    {
      for(i = length; i >= 0 && keyvalue[i] == ' '; --i) keyvalue[i] = '\0';
    }
}

/*---------------------------------------------------------------------------
        Host dependent directory path to/from URL functions
  --------------------------------------------------------------------------*/
int fits_path2url(char *inpath,  /* input file path string                  */
		  char *outpath, /* output file path string                 */
		  int  *status)
  /*
     convert a file path into its Unix-style equivelent for URL 
     purposes. Note that this process is platform dependent. This
     function supports Unix, MSDOS/WIN32, VMS and Macintosh platforms. 
     The plaform dependant code is conditionally compiled depending upon
     the setting of the appropriate C preprocessor macros.
   */
{
  char buff[FLEN_FILENAME];

#if defined(WINNT) || defined(__WINNT__)

  /*
    Microsoft Windows NT case. We assume input file paths of the form:

    //disk/path/filename

     All path segments may be null, so that a single file name is the
     simplist case.

     The leading "//" becomes a single "/" if present. If no "//" is present,
     then make sure the resulting URL path is relative, i.e., does not
     begin with a "/". In other words, the only way that an absolute URL
     file path may be generated is if the drive specification is given.
  */

  if(*status > 0) return(*status);

  if(inpath[0] == '/')
    {
      strcpy(buff,inpath+1);
    }
  else
    {
      strcpy(buff,inpath);
    }

#elif defined(MSDOS) || defined(__WIN32__) || defined(WIN32)

  /*
     MSDOS or Microsoft windows/NT case. The assumed form of the
     input path is:

     disk:\path\filename

     All path segments may be null, so that a single file name is the
     simplist case.

     All back-slashes '\' become slashes '/'; if the path starts with a
     string of the form "X:" then it is replaced with "/X/"
  */

  int i,j,k;
  int size;
  if(*status > 0) return(*status);

  for(i = 0, j = 0, size = strlen(inpath), buff[0] = 0; 
                                           i < size; j = strlen(buff))
    {
      switch(inpath[i])
	{

	case ':':

	  /*
	     must be a disk desiginator; add a slash '/' at the start of
	     outpath to designate that the path is absolute, then change
	     the colon ':' to a slash '/'
	   */

	  for(k = j; k >= 0; --k) buff[k+1] = buff[k];
	  buff[0] = '/';
	  strcat(buff,"/");
	  ++i;
	  
	  break;

	case '\\':

	  /* just replace the '\' with a '/' IF its not the first character */

	  if(i != 0 && buff[(j == 0 ? 0 : j-1)] != '/')
	    {
	      buff[j] = '/';
	      buff[j+1] = 0;
	    }

	  ++i;

	  break;

	default:

	  /* copy the character from inpath to buff as is */

	  buff[j]   = inpath[i];
	  buff[j+1] = 0;
	  ++i;

	  break;
	}
    }

#elif defined(VMS) || defined(vms) || defined(__vms)

  /*
     VMS case. Assumed format of the input path is:

     node::disk:[path]filename.ext;version

     Any part of the file path may be missing, so that in the simplist
     case a single file name/extension is given.

     all brackets "[", "]" and dots "." become "/"; dashes "-" become "..", 
     all single colons ":" become ":/", all double colons "::" become
     "FILE://"
   */

  int i,j,k;
  int done;
  int size;

  if(*status > 0) return(*status);
     
  /* see if inpath contains a directory specification */

  if(strchr(inpath,']') == NULL) 
    done = 1;
  else
    done = 0;

  for(i = 0, j = 0, size = strlen(inpath), buff[0] = 0; 
                           i < size && j < FLEN_FILENAME - 8; j = strlen(buff))
    {
      switch(inpath[i])
	{

	case ':':

	  /*
	     must be a logical/symbol separator or (in the case of a double
	     colon "::") machine node separator
	   */

	  if(inpath[i+1] == ':')
	    {
	      /* insert a "FILE://" at the start of buff ==> machine given */

	      for(k = j; k >= 0; --k) buff[k+7] = buff[k];
	      strncpy(buff,"FILE://",7);
	      i += 2;
	    }
	  else if(strstr(buff,"FILE://") == NULL)
	    {
	      /* insert a "/" at the start of buff ==> absolute path */

	      for(k = j; k >= 0; --k) buff[k+1] = buff[k];
	      buff[0] = '/';
	      ++i;
	    }
	  else
	    ++i;

	  /* a colon always ==> path separator */

	  strcat(buff,"/");

	  break;
  
	case ']':

	  /* end of directory spec, file name spec begins after this */

	  done = 1;

	  buff[j]   = '/';
	  buff[j+1] = 0;
	  ++i;

	  break;

	case '[':

	  /* 
	     begin directory specification; add a '/' only if the last char 
	     is not '/' 
	  */

	  if(i != 0 && buff[(j == 0 ? 0 : j-1)] != '/')
	    {
	      buff[j]   = '/';
	      buff[j+1] = 0;
	    }

	  ++i;

	  break;

	case '.':

	  /* 
	     directory segment separator or file name/extension separator;
	     we decide which by looking at the value of done
	  */

	  if(!done)
	    {
	    /* must be a directory segment separator */
	      if(inpath[i-1] == '[')
		{
		  strcat(buff,"./");
		  ++j;
		}
	      else
		buff[j] = '/';
	    }
	  else
	    /* must be a filename/extension separator */
	    buff[j] = '.';

	  buff[j+1] = 0;

	  ++i;

	  break;

	case '-':

	  /* 
	     a dash is the same as ".." in Unix speak, but lets make sure
	     that its not part of the file name first!
	   */

	  if(!done)
	    /* must be part of the directory path specification */
	    strcat(buff,"..");
	  else
	    {
	      /* the dash is part of the filename, so just copy it as is */
	      buff[j] = '-';
	      buff[j+1] = 0;
	    }

	  ++i;

	  break;

	default:

	  /* nothing special, just copy the character as is */

	  buff[j]   = inpath[i];
	  buff[j+1] = 0;

	  ++i;

	  break;

	}
    }

  if(j > FLEN_FILENAME - 8)
    {
      *status = URL_PARSE_ERROR;
      ffpmsg("resulting path to URL conversion too big (fits_path2url)");
    }

#elif defined(macintosh)

  /*
     MacOS case. The assumed form of the input path is:

     disk:path:filename

     It is assumed that all paths are absolute with disk and path specified,
     unless no colons ":" are supplied with the string ==> a single file name
     only. All colons ":" become slashes "/", and if one or more colon is 
     encountered then the path is specified as absolute.
  */

  int i,j,k;
  int firstColon;
  int size;

  if(*status > 0) return(*status);

  for(i = 0, j = 0, firstColon = 1, size = strlen(inpath), buff[0] = 0; 
                                                   i < size; j = strlen(buff))
    {
      switch(inpath[i])
	{

	case ':':

	  /*
	     colons imply path separators. If its the first colon encountered
	     then assume that its the disk designator and add a slash to the
	     beginning of the buff string
	   */
	  
	  if(firstColon)
	    {
	      firstColon = 0;

	      for(k = j; k >= 0; --k) buff[k+1] = buff[k];
	      buff[0] = '/';
	    }

	  /* all colons become slashes */

	  strcat(buff,"/");

	  ++i;
	  
	  break;

	default:

	  /* copy the character from inpath to buff as is */

	  buff[j]   = inpath[i];
	  buff[j+1] = 0;

	  ++i;

	  break;
	}
    }

#else 

  /*
     Default Unix case.

     Nothing special to do here except to remove the double or more // and 
     replace them with single /
   */

  int ii = 0;
  int jj = 0;

  if(*status > 0) return(*status);

  while (inpath[ii]) {
      if (inpath[ii] == '/' && inpath[ii+1] == '/') {
	  /* do nothing */
      } else {
	  buff[jj] = inpath[ii];
	  jj++;
      }
      ii++;
  }
  buff[jj] = '\0';
  /* printf("buff is %s\ninpath is %s\n",buff,inpath); */
  /* strcpy(buff,inpath); */

#endif

  /*
    encode all "unsafe" and "reserved" URL characters
  */

  *status = fits_encode_url(buff,outpath,status);

  return(*status);
}

/*---------------------------------------------------------------------------*/
int fits_url2path(char *inpath,  /* input file path string  */
		  char *outpath, /* output file path string */
		  int  *status)
  /*
     convert a Unix-style URL into a platform dependent directory path. 
     Note that this process is platform dependent. This
     function supports Unix, MSDOS/WIN32, VMS and Macintosh platforms. Each
     platform dependent code segment is conditionally compiled depending 
     upon the setting of the appropriate C preprocesser macros.
   */
{
  char buff[FLEN_FILENAME];
  int absolute;

#if defined(MSDOS) || defined(__WIN32__) || defined(WIN32)
  char *tmpStr;
#elif defined(VMS) || defined(vms) || defined(__vms)
  int i;
  char *tmpStr;
#elif defined(macintosh)
  char *tmpStr;
#endif

  if(*status != 0) return(*status);

  /*
    make a copy of the inpath so that we can manipulate it
  */

  strcpy(buff,inpath);

  /*
    convert any encoded characters to their unencoded values
  */

  *status = fits_unencode_url(inpath,buff,status);

  /*
    see if the URL is given as absolute w.r.t. the "local" file system
  */

  if(buff[0] == '/') 
    absolute = 1;
  else
    absolute = 0;

#if defined(WINNT) || defined(__WINNT__)

  /*
    Microsoft Windows NT case. We create output paths of the form

    //disk/path/filename

     All path segments but the last may be null, so that a single file name 
     is the simplist case.     
  */

  if(absolute)
    {
      strcpy(outpath,"/");
      strcat(outpath,buff);
    }
  else
    {
      strcpy(outpath,buff);
    }

#elif defined(MSDOS) || defined(__WIN32__) || defined(WIN32)

  /*
     MSDOS or Microsoft windows/NT case. The output path will be of the
     form

     disk:\path\filename

     All path segments but the last may be null, so that a single file name 
     is the simplist case.
  */

  /*
    separate the URL into tokens at each slash '/' and process until
    all tokens have been examined
  */

  for(tmpStr = strtok(buff,"/"), outpath[0] = 0;
                                 tmpStr != NULL; tmpStr = strtok(NULL,"/"))
    {
      strcat(outpath,tmpStr);

      /* 
	 if the absolute flag is set then process the token as a disk 
	 specification; else just process it as a directory path or filename
      */

      if(absolute)
	{
	  strcat(outpath,":\\");
	  absolute = 0;
	}
      else
	strcat(outpath,"\\");
    }

  /* remove the last "\" from the outpath, it does not belong there */

  outpath[strlen(outpath)-1] = 0;

#elif defined(VMS) || defined(vms) || defined(__vms)

  /*
     VMS case. The output path will be of the form:

     node::disk:[path]filename.ext;version

     Any part of the file path may be missing execpt filename.ext, so that in 
     the simplist case a single file name/extension is given.

     if the path is specified as relative starting with "./" then the first
     part of the VMS path is "[.". If the path is relative and does not start
     with "./" (e.g., "a/b/c") then the VMS path is constructed as
     "[a.b.c]"
   */
     
  /*
    separate the URL into tokens at each slash '/' and process until
    all tokens have been examined
  */

  for(tmpStr = strtok(buff,"/"), outpath[0] = 0; 
                                 tmpStr != NULL; tmpStr = strtok(NULL,"/"))
    {

      if(strcasecmp(tmpStr,"FILE:") == 0)
	{
	  /* the next token should contain the DECnet machine name */

	  tmpStr = strtok(NULL,"/");
	  if(tmpStr == NULL) continue;

	  strcat(outpath,tmpStr);
	  strcat(outpath,"::");

	  /* set the absolute flag to true for the next token */
	  absolute = 1;
	}

      else if(strcmp(tmpStr,"..") == 0)
	{
	  /* replace all Unix-like ".." with VMS "-" */

	  if(strlen(outpath) == 0) strcat(outpath,"[");
	  strcat(outpath,"-.");
	}

      else if(strcmp(tmpStr,".") == 0 && strlen(outpath) == 0)
	{
	  /*
	    must indicate a relative path specifier
	  */

	  strcat(outpath,"[.");
	}
  
      else if(strchr(tmpStr,'.') != NULL)
	{
	  /* 
	     must be up to the file name; turn the last "." path separator
	     into a "]" and then add the file name to the outpath
	  */
	  
	  i = strlen(outpath);
	  if(i > 0 && outpath[i-1] == '.') outpath[i-1] = ']';

	  strcat(outpath,tmpStr);
	}

      else
	{
	  /*
	    process the token as a a directory path segement
	  */

	  if(absolute)
	    {
	      /* treat the token as a disk specifier */
	      absolute = 0;
	      strcat(outpath,tmpStr);
	      strcat(outpath,":[");
	    }
	  else if(strlen(outpath) == 0)
	    {
	      /* treat the token as the first directory path specifier */
	      strcat(outpath,"[");
	      strcat(outpath,tmpStr);
	      strcat(outpath,".");
	    }
	  else
	    {
	      /* treat the token as an imtermediate path specifier */
	      strcat(outpath,tmpStr);
	      strcat(outpath,".");
	    }
	}
    }

#elif defined(macintosh)

  /*
     MacOS case. The output path will be of the form

     disk:path:filename

     All path segments but the last may be null, so that a single file name 
     is the simplist case.
  */

  /*
    separate the URL into tokens at each slash '/' and process until
    all tokens have been examined
  */

  for(tmpStr = strtok(buff,"/"), outpath[0] = 0;
                                 tmpStr != NULL; tmpStr = strtok(NULL,"/"))
    {
      strcat(outpath,tmpStr);
      strcat(outpath,":");
    }

  /* remove the last ":" from the outpath, it does not belong there */

  outpath[strlen(outpath)-1] = 0;

#else

  /*
     Default Unix case.

     Nothing special to do here
   */

  strcpy(outpath,buff);

#endif

  return(*status);
}

/****************************************************************************/
int fits_get_cwd(char *cwd,  /* IO current working directory string */
		 int  *status)
  /*
     retrieve the string containing the current working directory absolute
     path in Unix-like URL standard notation. It is assumed that the CWD
     string has a size of at least FLEN_FILENAME.

     Note that this process is platform dependent. This
     function supports Unix, MSDOS/WIN32, VMS and Macintosh platforms. Each
     platform dependent code segment is conditionally compiled depending 
     upon the setting of the appropriate C preprocesser macros.
   */
{

  char buff[FLEN_FILENAME];


  if(*status != 0) return(*status);

#if defined(macintosh)

  /*
     MacOS case. Currently unknown !!!!
  */

  *buff = 0;

#else
  /*
    Good old getcwd() seems to work with all other platforms
  */

  getcwd(buff,FLEN_FILENAME);

#endif

  /*
    convert the cwd string to a URL standard path string
  */

  fits_path2url(buff,cwd,status);

  return(*status);
}

/*---------------------------------------------------------------------------*/
int  fits_get_url(fitsfile *fptr,       /* I ptr to FITS file to evaluate    */
		  char     *realURL,    /* O URL of real FITS file           */
		  char     *startURL,   /* O URL of starting FITS file       */
		  char     *realAccess, /* O true access method of FITS file */
		  char     *startAccess,/* O "official" access of FITS file  */
		  int      *iostate,    /* O can this file be modified?      */
		  int      *status)
/*
  For grouping convention purposes, determine the URL of the FITS file
  associated with the fitsfile pointer fptr. The true access type (file://,
  mem://, shmem://, root://), starting "official" access type, and iostate 
  (0 ==> readonly, 1 ==> readwrite) are also returned.

  It is assumed that the url string has enough room to hold the resulting
  URL, and the the accessType string has enough room to hold the access type.
*/
{
  int i;
  int tmpIOstate = 0;

  char infile[FLEN_FILENAME];
  char outfile[FLEN_FILENAME];
  char tmpStr1[FLEN_FILENAME];
  char tmpStr2[FLEN_FILENAME];
  char tmpStr3[FLEN_FILENAME];
  char tmpStr4[FLEN_FILENAME];
  char *tmpPtr;


  if(*status != 0) return(*status);

  do
    {
      /* 
	 retrieve the member HDU's file name as opened by ffopen() 
	 and parse it into its constitutent pieces; get the currently
	 active driver token too
       */
	  
      *tmpStr1 = *tmpStr2 = *tmpStr3 = *tmpStr4 = 0;

      *status = fits_file_name(fptr,tmpStr1,status);

      *status = ffiurl(tmpStr1,NULL,infile,outfile,NULL,tmpStr2,tmpStr3,
		       tmpStr4,status);

      if((*tmpStr2) || (*tmpStr3) || (*tmpStr4)) tmpIOstate = -1;
 
      *status = ffurlt(fptr,tmpStr3,status);

      strcpy(tmpStr4,tmpStr3);

      *status = ffrtnm(tmpStr1,tmpStr2,status);
      strcpy(tmpStr1,tmpStr2);

      /*
	for grouping convention purposes (only) determine the URL of the
	actual FITS file being used for the given fptr, its true access 
	type (file://, mem://, shmem://, root://) and its iostate (0 ==>
	read only, 1 ==> readwrite)
      */

      /*
	The first set of access types are "simple" in that they do not
	use any redirection to temporary memory or outfiles
       */

      /* standard disk file driver is in use */
      
      if(strcasecmp(tmpStr3,"file://")              == 0)         
	{
	  tmpIOstate = 1;
	  
	  if(strlen(outfile)) strcpy(tmpStr1,outfile);
	  else *tmpStr2 = 0;

	  /*
	    make sure no FILE:// specifier is given in the tmpStr1
	    or tmpStr2 strings; the convention calls for local files
	    to have no access specification
	  */

	  if((tmpPtr = strstr(tmpStr1,"://")) != NULL)
	    {
	      strcpy(infile,tmpPtr+3);
	      strcpy(tmpStr1,infile);
	    }

	  if((tmpPtr = strstr(tmpStr2,"://")) != NULL)
	    {
	      strcpy(infile,tmpPtr+3);
	      strcpy(tmpStr2,infile);
	    }
	}

      /* file stored in conventional memory */
	  
      else if(strcasecmp(tmpStr3,"mem://")          == 0)          
	{
	  if(tmpIOstate < 0)
	    {
	      /* file is a temp mem file only */
	      ffpmsg("cannot make URL from temp MEM:// file (fits_get_url)");
	      *status = URL_PARSE_ERROR;
	    }
	  else
	    {
	      /* file is a "perminate" mem file for this process */
	      tmpIOstate = 1;
	      *tmpStr2 = 0;
	    }
	}

      /* file stored in conventional memory */
 
     else if(strcasecmp(tmpStr3,"memkeep://")      == 0)      
	{
	  strcpy(tmpStr3,"mem://");
	  *tmpStr4 = 0;
	  *tmpStr2 = 0;
	  tmpIOstate = 1;
	}

      /* file residing in shared memory */

      else if(strcasecmp(tmpStr3,"shmem://")        == 0)        
	{
	  *tmpStr4   = 0;
	  *tmpStr2   = 0;
	  tmpIOstate = 1;
	}
      
      /* file accessed via the ROOT network protocol */

      else if(strcasecmp(tmpStr3,"root://")         == 0)         
	{
	  *tmpStr4   = 0;
	  *tmpStr2   = 0;
	  tmpIOstate = 1;
	}
  
      /*
	the next set of access types redirect the contents of the original
	file to an special outfile because the original could not be
	directly modified (i.e., resides on the network, was compressed).
	In these cases the URL string takes on the value of the OUTFILE,
	the access type becomes file://, and the iostate is set to 1 (can
	read/write to the file).
      */

      /* compressed file uncompressed and written to disk */

      else if(strcasecmp(tmpStr3,"compressfile://") == 0) 
	{
	  strcpy(tmpStr1,outfile);
	  strcpy(tmpStr2,infile);
	  strcpy(tmpStr3,"file://");
	  strcpy(tmpStr4,"file://");
	  tmpIOstate = 1;
	}

      /* HTTP accessed file written locally to disk */

      else if(strcasecmp(tmpStr3,"httpfile://")     == 0)     
	{
	  strcpy(tmpStr1,outfile);
	  strcpy(tmpStr3,"file://");
	  strcpy(tmpStr4,"http://");
	  tmpIOstate = 1;
	}
      
      /* FTP accessd file written locally to disk */

      else if(strcasecmp(tmpStr3,"ftpfile://")      == 0)      
	{
	  strcpy(tmpStr1,outfile);
	  strcpy(tmpStr3,"file://");
	  strcpy(tmpStr4,"ftp://");
	  tmpIOstate = 1;
	}
      
      /* file from STDIN written to disk */

      else if(strcasecmp(tmpStr3,"stdinfile://")    == 0)    
	{
	  strcpy(tmpStr1,outfile);
	  strcpy(tmpStr3,"file://");
	  strcpy(tmpStr4,"stdin://");
	  tmpIOstate = 1;
	}

      /* 
	 the following access types use memory resident files as temporary
	 storage; they cannot be modified or be made group members for 
	 grouping conventions purposes, but their original files can be.
	 Thus, their tmpStr3s are reset to mem://, their iostate
	 values are set to 0 (for no-modification), and their URL string
	 values remain set to their original values
       */

      /* compressed disk file uncompressed into memory */

      else if(strcasecmp(tmpStr3,"compress://")     == 0)     
	{
	  *tmpStr1 = 0;
	  strcpy(tmpStr2,infile);
	  strcpy(tmpStr3,"mem://");
	  strcpy(tmpStr4,"file://");
	  tmpIOstate = 0;
	}
      
      /* HTTP accessed file transferred into memory */

      else if(strcasecmp(tmpStr3,"http://")         == 0)         
	{
	  *tmpStr1 = 0;
	  strcpy(tmpStr3,"mem://");
	  strcpy(tmpStr4,"http://");
	  tmpIOstate = 0;
	}
      
      /* HTTP accessed compressed file transferred into memory */

      else if(strcasecmp(tmpStr3,"httpcompress://") == 0) 
	{
	  *tmpStr1 = 0;
	  strcpy(tmpStr3,"mem://");
	  strcpy(tmpStr4,"http://");
	  tmpIOstate = 0;
	}
      
      /* FTP accessed file transferred into memory */
      
      else if(strcasecmp(tmpStr3,"ftp://")          == 0)          
	{
	  *tmpStr1 = 0;
	  strcpy(tmpStr3,"mem://");
	  strcpy(tmpStr4,"ftp://");
	  tmpIOstate = 0;
	}
      
      /* FTP accessed compressed file transferred into memory */

      else if(strcasecmp(tmpStr3,"ftpcompress://")  == 0)  
	{
	  *tmpStr1 = 0;
	  strcpy(tmpStr3,"mem://");
	  strcpy(tmpStr4,"ftp://");
	  tmpIOstate = 0;
	}	
      
      /*
	The last set of access types cannot be used to make a meaningful URL 
	strings from; thus an error is generated
       */

      else if(strcasecmp(tmpStr3,"stdin://")        == 0)        
	{
	  *status = URL_PARSE_ERROR;
	  ffpmsg("cannot make vaild URL from stdin:// (fits_get_url)");
	  *tmpStr1 = *tmpStr2 = 0;
	}

      else if(strcasecmp(tmpStr3,"stdout://")       == 0)       
	{
	  *status = URL_PARSE_ERROR;
	  ffpmsg("cannot make vaild URL from stdout:// (fits_get_url)");
	  *tmpStr1 = *tmpStr2 = 0;
	}

      else if(strcasecmp(tmpStr3,"irafmem://")      == 0)      
	{
	  *status = URL_PARSE_ERROR;
	  ffpmsg("cannot make vaild URL from irafmem:// (fits_get_url)");
	  *tmpStr1 = *tmpStr2 = 0;
	}

      if(*status != 0) continue;

      /*
	 assign values to the calling parameters if they are non-NULL
      */

      if(realURL != NULL)
	{
	  if(strlen(tmpStr1) == 0)
	    *realURL = 0;
	  else
	    {
	      if((tmpPtr = strstr(tmpStr1,"://")) != NULL)
		{
		  tmpPtr += 3;
		  i = (long)tmpPtr - (long)tmpStr1;
		  strncpy(realURL,tmpStr1,i);
		}
	      else
		{
		  tmpPtr = tmpStr1;
		  i = 0;
		}

	      *status = fits_path2url(tmpPtr,realURL+i,status);
	    }
	}

      if(startURL != NULL)
	{
	  if(strlen(tmpStr2) == 0)
	    *startURL = 0;
	  else
	    {
	      if((tmpPtr = strstr(tmpStr2,"://")) != NULL)
		{
		  tmpPtr += 3;
		  i = (long)tmpPtr - (long)tmpStr2;
		  strncpy(startURL,tmpStr2,i);
		}
	      else
		{
		  tmpPtr = tmpStr2;
		  i = 0;
		}

	      *status = fits_path2url(tmpPtr,startURL+i,status);
	    }
	}

      if(realAccess  != NULL)  strcpy(realAccess,tmpStr3);
      if(startAccess != NULL)  strcpy(startAccess,tmpStr4);
      if(iostate     != NULL) *iostate = tmpIOstate;

    }while(0);

  return(*status);
}

/*--------------------------------------------------------------------------
                           URL parse support functions
  --------------------------------------------------------------------------*/

/* simple push/pop/shift/unshift string stack for use by fits_clean_url */
typedef char* grp_stack_data; /* type of data held by grp_stack */

typedef struct grp_stack_item_struct {
  grp_stack_data data; /* value of this stack item */
  struct grp_stack_item_struct* next; /* next stack item */
  struct grp_stack_item_struct* prev; /* previous stack item */
} grp_stack_item;

typedef struct grp_stack_struct {
  size_t stack_size; /* number of items on stack */
  grp_stack_item* top; /* top item */
} grp_stack;

static char* grp_stack_default = NULL; /* initial value for new instances
                                          of grp_stack_data */

/* the following functions implement the group string stack grp_stack */
static void delete_grp_stack(grp_stack** mystack);
static grp_stack_item* grp_stack_append(
  grp_stack_item* last, grp_stack_data data
);
static grp_stack_data grp_stack_remove(grp_stack_item* last);
static grp_stack* new_grp_stack(void);
static grp_stack_data pop_grp_stack(grp_stack* mystack);
static void push_grp_stack(grp_stack* mystack, grp_stack_data data);
static grp_stack_data shift_grp_stack(grp_stack* mystack);
/* static void unshift_grp_stack(grp_stack* mystack, grp_stack_data data); */

int fits_clean_url(char *inURL,  /* I input URL string                      */
		   char *outURL, /* O output URL string                     */
		   int  *status)
/*
  clean the URL by eliminating any ".." or "." specifiers in the inURL
  string, and write the output to the outURL string.

  Note that this function must have a valid Unix-style URL as input; platform
  dependent path strings are not allowed.
 */
{
  grp_stack* mystack; /* stack to hold pieces of URL */
  char* tmp;

  if(*status) return *status;

  mystack = new_grp_stack();
  *outURL = 0;

  do {
    /* handle URL scheme and domain if they exist */
    tmp = strstr(inURL, "://");
    if(tmp) {
      /* there is a URL scheme, so look for the end of the domain too */
      tmp = strchr(tmp + 3, '/');
      if(tmp) {
        /* tmp is now the end of the domain, so
         * copy URL scheme and domain as is, and terminate by hand */
        size_t string_size = (size_t) (tmp - inURL);
        strncpy(outURL, inURL, string_size);
        outURL[string_size] = 0;

        /* now advance the input pointer to just after the domain and go on */
        inURL = tmp;
      } else {
        /* '/' was not found, which means there are no path-like
         * portions, so copy whole inURL to outURL and we're done */
        strcpy(outURL, inURL);
        continue; /* while(0) */
      }
    }

    /* explicitly copy a leading / (absolute path) */
    if('/' == *inURL) strcat(outURL, "/");

    /* now clean the remainder of the inURL. push URL segments onto
     * stack, dealing with .. and . as we go */
    tmp = strtok(inURL, "/"); /* finds first / */
    while(tmp) {
      if(!strcmp(tmp, "..")) {
        /* discard previous URL segment, if there was one. if not,
         * add the .. to the stack if this is *not* an absolute path
         * (for absolute paths, leading .. has no effect, so skip it) */
        if(0 < mystack->stack_size) pop_grp_stack(mystack);
        else if('/' != *inURL) push_grp_stack(mystack, tmp);
      } else {
        /* always just skip ., but otherwise add segment to stack */
        if(strcmp(tmp, ".")) push_grp_stack(mystack, tmp);
      }
      tmp = strtok(NULL, "/"); /* get the next segment */
    }

    /* stack now has pieces of cleaned URL, so just catenate them
     * onto output string until stack is empty */
    while(0 < mystack->stack_size) {
      tmp = shift_grp_stack(mystack);
      strcat(outURL, tmp);
      strcat(outURL, "/");
    }
    outURL[strlen(outURL) - 1] = 0; /* blank out trailing / */
  } while(0);
  delete_grp_stack(&mystack);
  return *status;
}

/* free all stack contents using pop_grp_stack before freeing the
 * grp_stack itself */
static void delete_grp_stack(grp_stack** mystack) {
  if(!mystack || !*mystack) return;
  while((*mystack)->stack_size) pop_grp_stack(*mystack);
  free(*mystack);
  *mystack = NULL;
}

/* append an item to the stack, handling the special case of the first
 * item appended */
static grp_stack_item* grp_stack_append(
  grp_stack_item* last, grp_stack_data data
) {
  /* first create a new stack item, and copy data to it */
  grp_stack_item* new_item = (grp_stack_item*) malloc(sizeof(grp_stack_item));
  new_item->data = data;
  if(last) {
    /* attach this item between the "last" item and its "next" item */
    new_item->next = last->next;
    new_item->prev = last;
    last->next->prev = new_item;
    last->next = new_item;
  } else {
    /* stack is empty, so "next" and "previous" both point back to it */
    new_item->next = new_item;
    new_item->prev = new_item;
  }
  return new_item;
}

/* remove an item from the stack, handling the special case of the last
 * item removed */
static grp_stack_data grp_stack_remove(grp_stack_item* last) {
  grp_stack_data retval = last->data;
  last->prev->next = last->next;
  last->next->prev = last->prev;
  free(last);
  return retval;
}

/* create new stack dynamically, and give it valid initial values */
static grp_stack* new_grp_stack(void) {
  grp_stack* retval = (grp_stack*) malloc(sizeof(grp_stack));
  if(retval) {
    retval->stack_size = 0;
    retval->top = NULL;
  }
  return retval;
}

/* return the value at the top of the stack and remove it, updating
 * stack_size. top->prev becomes the new "top" */
static grp_stack_data pop_grp_stack(grp_stack* mystack) {
  grp_stack_data retval = grp_stack_default;
  if(mystack && mystack->top) {
    grp_stack_item* newtop = mystack->top->prev;
    retval = grp_stack_remove(mystack->top);
    mystack->top = newtop;
    if(0 == --mystack->stack_size) mystack->top = NULL;
  }
  return retval;
}

/* add to the stack after the top element. the added element becomes
 * the new "top" */
static void push_grp_stack(grp_stack* mystack, grp_stack_data data) {
  if(!mystack) return;
  mystack->top = grp_stack_append(mystack->top, data);
  ++mystack->stack_size;
  return;
}

/* return the value at the bottom of the stack and remove it, updating
 * stack_size. "top" pointer is unaffected */
static grp_stack_data shift_grp_stack(grp_stack* mystack) {
  grp_stack_data retval = grp_stack_default;
  if(mystack && mystack->top) {
    retval = grp_stack_remove(mystack->top->next); /* top->next == bottom */
    if(0 == --mystack->stack_size) mystack->top = NULL;
  }
  return retval;
}

/* add to the stack after the top element. "top" is unaffected, except
 * in the special case of an initially empty stack */
/* static void unshift_grp_stack(grp_stack* mystack, grp_stack_data data) {
   if(!mystack) return;
   if(mystack->top) grp_stack_append(mystack->top, data);
   else mystack->top = grp_stack_append(NULL, data);
   ++mystack->stack_size;
   return;
   } */

/*--------------------------------------------------------------------------*/
int fits_url2relurl(char     *refURL, /* I reference URL string             */
		    char     *absURL, /* I absoulute URL string to process  */
		    char     *relURL, /* O resulting relative URL string    */
		    int      *status)
/*
  create a relative URL to the file referenced by absURL with respect to the
  reference URL refURL. The relative URL is returned in relURL.

  Both refURL and absURL must be absolute URL strings; i.e. either begin
  with an access method specification "XXX://" or with a '/' character
  signifiying that they are absolute file paths.

  Note that it is possible to make a relative URL from two input URLs
  (absURL and refURL) that are not compatable. This function does not
  check to see if the resulting relative URL makes any sence. For instance,
  it is impossible to make a relative URL from the following two inputs:

  absURL = ftp://a.b.c.com/x/y/z/foo.fits
  refURL = /a/b/c/ttt.fits

  The resulting relURL will be:

  ../../../ftp://a.b.c.com/x/y/z/foo.fits 

  Which is syntically correct but meaningless. The problem is that a file
  with an access method of ftp:// cannot be expressed a a relative URL to
  a local disk file.
*/

{
  int i,j;
  int refcount,abscount;
  int refsize,abssize;
  int done;


  if(*status != 0) return(*status);

  /* initialize the relative URL string */
  relURL[0] = 0;

  do
    {
      /*
	refURL and absURL must be absolute to process
      */

      if(!(fits_is_url_absolute(refURL) || *refURL == '/') ||
	 !(fits_is_url_absolute(absURL) || *absURL == '/'))
	{
	  *status = URL_PARSE_ERROR;
	  ffpmsg("Cannot make rel. URL from non abs. URLs (fits_url2relurl)");
	  continue;
	}

      /* determine the size of the refURL and absURL strings */

      refsize = strlen(refURL);
      abssize = strlen(absURL);

      /* process the two URL strings and build the relative URL between them */
		

      for(done = 0, refcount = 0, abscount = 0; 
	  !done && refcount < refsize && abscount < abssize; 
	  ++refcount, ++abscount)
	{
	  for(; abscount < abssize && absURL[abscount] == '/'; ++abscount);
	  for(; refcount < refsize && refURL[refcount] == '/'; ++refcount);

	  /* find the next path segment in absURL */ 
	  for(i = abscount; absURL[i] != '/' && i < abssize; ++i);
	  
	  /* find the next path segment in refURL */
	  for(j = refcount; refURL[j] != '/' && j < refsize; ++j);
	  
	  /* do the two path segments match? */
	  if(i == j && 
	     strncmp(absURL+abscount, refURL+refcount,i-refcount) == 0)
	    {
	      /* they match, so ignore them and continue */
	      abscount = i; refcount = j;
	      continue;
	    }
	  
	  /* We found a difference in the paths in refURL and absURL.
	     For every path segment remaining in the refURL string, append
	     a "../" path segment to the relataive URL relURL.
	  */

	  for(j = refcount; j < refsize; ++j)
	    if(refURL[j] == '/') strcat(relURL,"../");
	  
	  /* copy all remaining characters of absURL to the output relURL */

	  strcat(relURL,absURL+abscount);
	  
	  /* we are done building the relative URL */
	  done = 1;
	}

    }while(0);

  return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_relurl2url(char     *refURL, /* I reference URL string             */
		    char     *relURL, /* I relative URL string to process   */
		    char     *absURL, /* O absolute URL string              */
		    int      *status)
/*
  create an absolute URL from a relative url and a reference URL. The 
  reference URL is given by the FITS file pointed to by fptr.

  The construction of the absolute URL from the partial and reference URl
  is performed using the rules set forth in:
 
  http://www.w3.org/Addressing/URL/URL_TOC.html
  and
  http://www.w3.org/Addressing/URL/4_3_Partial.html

  Note that the relative URL string relURL must conform to the Unix-like
  URL syntax; host dependent partial URL strings are not allowed.
*/
{
  int i;

  char tmpStr[FLEN_FILENAME];

  char *tmpStr1, *tmpStr2;


  if(*status != 0) return(*status);
  
  do
    {

      /*
	make a copy of the reference URL string refURL for parsing purposes
      */

      strcpy(tmpStr,refURL);

      /*
	if the reference file has an access method of mem:// or shmem://
	then we cannot use it as the basis of an absolute URL construction
	for a partial URL
      */
	  
      if(strncasecmp(tmpStr,"MEM:",4)   == 0 ||
                	                strncasecmp(tmpStr,"SHMEM:",6) == 0)
	{
	  ffpmsg("ref URL has access mem:// or shmem:// (fits_relurl2url)");
	  ffpmsg("   cannot construct full URL from a partial URL and ");
	  ffpmsg("   MEM/SHMEM base URL");
	  *status = URL_PARSE_ERROR;
	  continue;
	}

      if(relURL[0] != '/')
	{
	  /*
	    just append the relative URL string to the reference URL
	    string (minus the reference URL file name) to form the 
	    absolute URL string
	  */
	      
	  tmpStr1 = strrchr(tmpStr,'/');
	  
	  if(tmpStr1 != NULL) tmpStr1[1] = 0;
	  else                tmpStr[0]  = 0;
	  
	  strcat(tmpStr,relURL);
	}
      else
	{
	  /*
	    have to parse the refURL string for the first occurnace of the 
	    same number of '/' characters as contained in the beginning of
	    location that is not followed by a greater number of consective 
	    '/' charaters (yes, that is a confusing statement); this is the 
	    location in the refURL string where the relURL string is to
	    be appended to form the new absolute URL string
	   */
	  
	  /*
	    first, build up a slash pattern string that has one more
	    slash in it than the starting slash pattern of the
	    relURL string
	  */
	  
	  strcpy(absURL,"/");
	  
	  for(i = 0; relURL[i] == '/'; ++i) strcat(absURL,"/");
	  
	  /*
	    loop over the refURL string until the slash pattern stored
	    in absURL is no longer found
	  */

	  for(tmpStr1 = tmpStr, i = strlen(absURL); 
	      (tmpStr2 = strstr(tmpStr1,absURL)) != NULL;
	      tmpStr1 = tmpStr2 + i);
	  
	  /* reduce the slash pattern string by one slash */
	  
	  absURL[i-1] = 0;
	  
	  /* 
	     search for the slash pattern in the remaining portion
	     of the refURL string
	  */

	  tmpStr2 = strstr(tmpStr1,absURL);
	  
	  /* if no slash pattern match was found */
	  
	  if(tmpStr2 == NULL)
	    {
	      /* just strip off the file name from the refURL  */
	      
	      tmpStr2 = strrchr(tmpStr1,'/');
	      
	      if(tmpStr2 != NULL) tmpStr2[0] = 0;
	      else                tmpStr[0]  = 0;
	    }
	  else
	    {
	      /* set a string terminator at the slash pattern match */
	      
	      *tmpStr2 = 0;
	    }
	  
	  /* 
	    conatenate the relURL string to the refURL string to form
	    the absURL
	   */

	  strcat(tmpStr,relURL);
	}

      /*
	normalize the absURL by removing any ".." or "." specifiers
	in the string
      */

      *status = fits_clean_url(tmpStr,absURL,status);

    }while(0);

  return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_encode_url(char *inpath,  /* I URL  to be encoded                  */ 
		    char *outpath, /* O output encoded URL                  */
		    int *status)
     /*
       encode all URL "unsafe" and "reserved" characters using the "%XX"
       convention, where XX stand for the two hexidecimal digits of the
       encode character's ASCII code.

       Note that the output path is at least as large as, if not larger than
       the input path, so that OUTPATH should be passed to this function
       with room for growth. If not a runtime error could result. It is
       assumed that OUTPATH has been allocated with enough room to hold
       the resulting encoded URL.

       This function was adopted from code in the libwww.a library available
       via the W3 consortium 
     */
{
  unsigned char a;
  
  char *p;
  char *q;
  char *hex = "0123456789ABCDEF";
  
unsigned const char isAcceptable[96] =
{/* 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xA 0xB 0xC 0xD 0xE 0xF */
  
    0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xF,0xE,0x0,0xF,0xF,0xC, 
                                           /* 2x  !"#$%&'()*+,-./   */
    0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0x8,0x0,0x0,0x0,0x0,0x0,
                                           /* 3x 0123456789:;<=>?   */
    0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF, 
                                           /* 4x @ABCDEFGHIJKLMNO   */
    0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0x0,0x0,0x0,0x0,0xF,
                                           /* 5X PQRSTUVWXYZ[\]^_   */
    0x0,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,
                                           /* 6x `abcdefghijklmno   */
    0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,0x0,0x0,0x0,0x0,0x0  
                                           /* 7X pqrstuvwxyz{\}~DEL */
};

  if(*status != 0) return(*status);
  
  /* loop over all characters in inpath until '\0' is encountered */

  for(q = outpath, p = inpath; *p; p++)
    {
      a = (unsigned char)*p;

      /* if the charcter requires encoding then process it */

      if(!( a>=32 && a<128 && (isAcceptable[a-32])))
	{
	  /* add a '%' character to the outpath */
	  *q++ = HEX_ESCAPE;
	  /* add the most significant ASCII code hex value */
	  *q++ = hex[a >> 4];
	  /* add the least significant ASCII code hex value */
	  *q++ = hex[a & 15];
	}
      /* else just copy the character as is */
      else *q++ = *p;
    }

  /* null terminate the outpath string */

  *q++ = 0; 
  
  return(*status);
}

/*---------------------------------------------------------------------------*/
int fits_unencode_url(char *inpath,  /* I input URL with encoding            */
		      char *outpath, /* O unencoded URL                      */
		      int  *status)
     /*
       unencode all URL "unsafe" and "reserved" characters to their actual
       ASCII representation. All tokens of the form "%XX" where XX is the
       hexidecimal code for an ASCII character, are searched for and
       translated into the actuall ASCII character (so three chars become
       1 char).

       It is assumed that OUTPATH has enough room to hold the unencoded
       URL.

       This function was adopted from code in the libwww.a library available
       via the W3 consortium 
     */

{
    char *p;
    char *q;
    char  c;

    if(*status != 0) return(*status);

    p = inpath;
    q = outpath;

    /* 
       loop over all characters in the inpath looking for the '%' escape
       character; if found the process the escape sequence
    */

    while(*p != 0) 
      {
	/* 
	   if the character is '%' then unencode the sequence, else
	   just copy the character from inpath to outpath
        */

        if (*p == HEX_ESCAPE)
	  {
            if((c = *(++p)) != 0)
	      { 
		*q = (
		      (c >= '0' && c <= '9') ?
		      (c - '0') : ((c >= 'A' && c <= 'F') ?
				   (c - 'A' + 10) : (c - 'a' + 10))
		      )*16;

		if((c = *(++p)) != 0)
		  {
		    *q = *q + (
			       (c >= '0' && c <= '9') ? 
		               (c - '0') : ((c >= 'A' && c <= 'F') ? 
					    (c - 'A' + 10) : (c - 'a' + 10))
			       );
		    p++, q++;
		  }
	      }
	  } 
	else
	  *q++ = *p++; 
      }
 
    /* terminate the outpath */
    *q = 0;

    return(*status);   
}
/*---------------------------------------------------------------------------*/

int fits_is_url_absolute(char *url)
/*
  Return a True (1) or False (0) value indicating whether or not the passed
  URL string contains an access method specifier or not. Note that this is
  a boolean function and it neither reads nor returns the standard error
  status parameter
*/
{
  char *tmpStr1, *tmpStr2;

  char reserved[] = {':',';','/','?','@','&','=','+','$',','};

  /*
    The rule for determing if an URL is relative or absolute is that it (1)
    must have a colon ":" and (2) that the colon must appear before any other
    reserved URL character in the URL string. We first see if a colon exists,
    get its position in the string, and then check to see if any of the other
    reserved characters exists and if their position in the string is greater
    than that of the colons. 
   */

  if( (tmpStr1 = strchr(url,reserved[0])) != NULL                       &&
     ((tmpStr2 = strchr(url,reserved[1])) == NULL || tmpStr2 > tmpStr1) &&
     ((tmpStr2 = strchr(url,reserved[2])) == NULL || tmpStr2 > tmpStr1) &&
     ((tmpStr2 = strchr(url,reserved[3])) == NULL || tmpStr2 > tmpStr1) &&
     ((tmpStr2 = strchr(url,reserved[4])) == NULL || tmpStr2 > tmpStr1) &&
     ((tmpStr2 = strchr(url,reserved[5])) == NULL || tmpStr2 > tmpStr1) &&
     ((tmpStr2 = strchr(url,reserved[6])) == NULL || tmpStr2 > tmpStr1) &&
     ((tmpStr2 = strchr(url,reserved[7])) == NULL || tmpStr2 > tmpStr1) &&
     ((tmpStr2 = strchr(url,reserved[8])) == NULL || tmpStr2 > tmpStr1) &&
     ((tmpStr2 = strchr(url,reserved[9])) == NULL || tmpStr2 > tmpStr1)   )
    {
      return(1);
    }
  else
    {
      return(0);
    }
}
healpy-1.10.3/cfitsio/group.h0000664000175000017500000000360613010375005016272 0ustar  zoncazonca00000000000000#define MAX_HDU_TRACKER 1000

typedef struct _HDUtracker HDUtracker;

struct _HDUtracker
{
  int nHDU;

  char *filename[MAX_HDU_TRACKER];
  int  position[MAX_HDU_TRACKER];

  char *newFilename[MAX_HDU_TRACKER];
  int  newPosition[MAX_HDU_TRACKER];
};

/* functions used internally in the grouping convention module */

int ffgtdc(int grouptype, int xtensioncol, int extnamecol, int extvercol,
	   int positioncol, int locationcol, int uricol, char *ttype[],
	   char *tform[], int *ncols, int  *status);

int ffgtgc(fitsfile *gfptr, int *xtensionCol, int *extnameCol, int *extverCol,
	   int *positionCol, int *locationCol, int *uriCol, int *grptype,
	   int *status);

int ffgmul(fitsfile *mfptr, int rmopt, int *status);

int ffgmf(fitsfile *gfptr, char *xtension, char *extname, int extver,	   
	  int position,	char *location,	long *member, int *status);

int ffgtrmr(fitsfile *gfptr, HDUtracker *HDU, int *status);

int ffgtcpr(fitsfile *infptr, fitsfile *outfptr, int cpopt, HDUtracker *HDU,
	    int *status);

int fftsad(fitsfile *mfptr, HDUtracker *HDU, int *newPosition, 
	   char *newFileName);

int fftsud(fitsfile *mfptr, HDUtracker *HDU, int newPosition, 
	   char *newFileName);

void prepare_keyvalue(char *keyvalue);

int fits_path2url(char *inpath, char *outpath, int  *status);

int fits_url2path(char *inpath, char *outpath, int  *status);

int fits_get_cwd(char *cwd, int *status);

int fits_get_url(fitsfile *fptr, char *realURL, char *startURL, 
		 char *realAccess, char *startAccess, int *iostate, 
		 int *status);

int fits_clean_url(char *inURL, char *outURL, int *status);

int fits_relurl2url(char *refURL, char *relURL, char *absURL, int *status);

int fits_url2relurl(char *refURL, char *absURL, char *relURL, int *status);

int fits_encode_url(char *inpath, char *outpath, int *status);

int fits_unencode_url(char *inpath, char *outpath, int *status);

int fits_is_url_absolute(char *url);

healpy-1.10.3/cfitsio/grparser.c0000664000175000017500000013315213010375005016756 0ustar  zoncazonca00000000000000/*		T E M P L A T E   P A R S E R
		=============================

		by Jerzy.Borkowski@obs.unige.ch

		Integral Science Data Center
		ch. d'Ecogia 16
		1290 Versoix
		Switzerland

14-Oct-98: initial release
16-Oct-98: code cleanup, #include  included, now gcc -Wall prints no
		warnings during compilation. Bugfix: now one can specify additional
		columns in group HDU. Autoindexing also works in this situation
		(colunms are number from 7 however).
17-Oct-98: bugfix: complex keywords were incorrectly written (was TCOMPLEX should
		be TDBLCOMPLEX).
20-Oct-98: bugfix: parser was writing EXTNAME twice, when first HDU in template is
		defined with XTENSION IMAGE then parser creates now dummy PHDU,
		SIMPLE T is now allowed only at most once and in first HDU only.
		WARNING: one should not define EXTNAME keyword for GROUP HDUs, as
		they have them already defined by parser (EXTNAME = GROUPING).
		Parser accepts EXTNAME oin GROUP HDU definition, but in this
		case multiple EXTNAME keywords will present in HDU header.
23-Oct-98: bugfix: unnecessary space was written to FITS file for blank
		keywords.
24-Oct-98: syntax change: empty lines and lines with only whitespaces are 
		written to FITS files as blank keywords (if inside group/hdu
		definition). Previously lines had to have at least 8 spaces.
		Please note, that due to pecularities of CFITSIO if the
		last keyword(s) defined for given HDU are blank keywords
		consisting of only 80 spaces, then (some of) those keywords
		may be silently deleted by CFITSIO.
13-Nov-98: bugfix: parser was writing GRPNAME twice. Parser still creates
                GRPNAME keywords for GROUP HDU's which do not specify them.
                However, values (of form DEFAULT_GROUP_XXX) are assigned
                not necessarily in order HDUs appear in template file, but
                rather in order parser completes their creation in FITS
                file. Also, when including files, if fopen fails, parser
                tries to open file with a name = directory_of_top_level
                file + name of file to be included, as long as name
                of file to be included does not specify absolute pathname.
16-Nov-98: bugfix to bugfix from 13-Nov-98
19-Nov-98: EXTVER keyword is now automatically assigned value by parser.
17-Dev-98: 2 new things added: 1st: CFITSIO_INCLUDE_FILES environment
		variable can contain a colon separated list of directories
		to look for when looking for template include files (and master
		template also). 2nd: it is now possible to append template
		to nonempty FITS. file. fitsfile *ff no longer needs to point
		to an empty FITS file with 0 HDUs in it. All data written by
		parser will simple be appended at the end of file.
22-Jan-99: changes to parser: when in append mode parser initially scans all
		existing HDUs to built a list of already used EXTNAME/EXTVERs
22-Jan-99: Bruce O'Neel, bugfix : TLONG should always reference long type
		variable on OSF/Alpha and on 64-bit archs in general
20-Jun-2002 Wm Pence, added support for the HIERARCH keyword convention in
                which keyword names can effectively be longer than 8 characters.
                Example:
                HIERARCH  LongKeywordName = 'value' / comment
30-Jan-2003 Wm Pence, bugfix: ngp_read_xtension was testing for "ASCIITABLE" 
                instead of "TABLE" as the XTENSION value of an ASCII table,
                and it did not allow for optional trailing spaces in the
                "IMAGE" or "TABLE" string. 
16-Dec-2003 James Peachey: ngp_keyword_all_write was modified to apply
                comments from the template file to the output file in
                the case of reserved keywords (e.g. tform#, ttype# etcetera).
*/


#include 
#include 

#ifdef sparc
#include 
#include 
#endif

#include 
#include "fitsio2.h"
#include "grparser.h"

NGP_RAW_LINE	ngp_curline = { NULL, NULL, NULL, NGP_TTYPE_UNKNOWN, NULL, NGP_FORMAT_OK, 0 };
NGP_RAW_LINE	ngp_prevline = { NULL, NULL, NULL, NGP_TTYPE_UNKNOWN, NULL, NGP_FORMAT_OK, 0 };

int		ngp_inclevel = 0;		/* number of included files, 1 - means mean file */
int		ngp_grplevel = 0;		/* group nesting level, 0 - means no grouping */

FILE		*ngp_fp[NGP_MAX_INCLUDE];	/* stack of included file handles */
int		ngp_keyidx = NGP_TOKEN_UNKNOWN;	/* index of token in current line */
NGP_TOKEN	ngp_linkey;			/* keyword after line analyze */

char            ngp_master_dir[NGP_MAX_FNAME];  /* directory of top level include file */

NGP_TKDEF	ngp_tkdef[] = 			/* tokens recognized by parser */
      { {	"\\INCLUDE",	NGP_TOKEN_INCLUDE },
	{	"\\GROUP",	NGP_TOKEN_GROUP },
	{	"\\END",	NGP_TOKEN_END },
	{	"XTENSION",	NGP_TOKEN_XTENSION },
	{	"SIMPLE",	NGP_TOKEN_SIMPLE },
	{	NULL,		NGP_TOKEN_UNKNOWN }
      };

int	master_grp_idx = 1;			/* current unnamed group in object */

int		ngp_extver_tab_size = 0;
NGP_EXTVER_TAB	*ngp_extver_tab = NULL;


int	ngp_get_extver(char *extname, int *version)
 { NGP_EXTVER_TAB *p;
   char 	*p2;
   int		i;

   if ((NULL == extname) || (NULL == version)) return(NGP_BAD_ARG);
   if ((NULL == ngp_extver_tab) && (ngp_extver_tab_size > 0)) return(NGP_BAD_ARG);
   if ((NULL != ngp_extver_tab) && (ngp_extver_tab_size <= 0)) return(NGP_BAD_ARG);

   for (i=0; i 0)) return(NGP_BAD_ARG);
   if ((NULL != ngp_extver_tab) && (ngp_extver_tab_size <= 0)) return(NGP_BAD_ARG);

   for (i=0; i ngp_extver_tab[i].version)  ngp_extver_tab[i].version = version;
          return(NGP_OK);
        }
    }

   if (NULL == ngp_extver_tab)
     { p = (NGP_EXTVER_TAB *)ngp_alloc(sizeof(NGP_EXTVER_TAB)); }
   else
     { p = (NGP_EXTVER_TAB *)ngp_realloc(ngp_extver_tab, (ngp_extver_tab_size + 1) * sizeof(NGP_EXTVER_TAB)); }

   if (NULL == p) return(NGP_NO_MEMORY);

   p2 = ngp_alloc(strlen(extname) + 1);
   if (NULL == p2)
     { ngp_free(p);
       return(NGP_NO_MEMORY);
     }

   strcpy(p2, extname);
   ngp_extver_tab = p;
   ngp_extver_tab[ngp_extver_tab_size].extname = p2;
   ngp_extver_tab[ngp_extver_tab_size].version = version;

   ngp_extver_tab_size++;

   return(NGP_OK);
 }


int	ngp_delete_extver_tab(void)
 { int i;

   if ((NULL == ngp_extver_tab) && (ngp_extver_tab_size > 0)) return(NGP_BAD_ARG);
   if ((NULL != ngp_extver_tab) && (ngp_extver_tab_size <= 0)) return(NGP_BAD_ARG);
   if ((NULL == ngp_extver_tab) && (0 == ngp_extver_tab_size)) return(NGP_OK);

   for (i=0; i= 'a') && (c1 <= 'z')) c1 += ('A' - 'a');

      c2 = *p2;
      if ((c2 >= 'a') && (c2 <= 'z')) c2 += ('A' - 'a');

      if (c1 < c2) return(-1);
      if (c1 > c2) return(1);
      if (0 == c1) return(0);
      p1++;
      p2++;
    }
 }

int	ngp_strcasencmp(char *p1, char *p2, int n)
 { char c1, c2;
   int ii;

   for (ii=0;ii= 'a') && (c1 <= 'z')) c1 += ('A' - 'a');

      c2 = *p2;
      if ((c2 >= 'a') && (c2 <= 'z')) c2 += ('A' - 'a');

      if (c1 < c2) return(-1);
      if (c1 > c2) return(1);
      if (0 == c1) return(0);
      p1++;
      p2++;
    }
    return(0);
 }

	/* read one line from file */

int	ngp_line_from_file(FILE *fp, char **p)
 { int	c, r, llen, allocsize, alen;
   char	*p2;

   if (NULL == fp) return(NGP_NUL_PTR);		/* check for stupid args */
   if (NULL == p) return(NGP_NUL_PTR);		/* more foolproof checks */
   
   r = NGP_OK;					/* initialize stuff, reset err code */
   llen = 0;					/* 0 characters read so far */
   *p = (char *)ngp_alloc(1);			/* preallocate 1 byte */
   allocsize = 1;				/* signal that we have allocated 1 byte */
   if (NULL == *p) return(NGP_NO_MEMORY);	/* if this failed, system is in dire straits */

   for (;;)
    { c = getc(fp);				/* get next character */
      if ('\r' == c) continue;			/* carriage return character ?  Just ignore it */
      if (EOF == c)				/* EOF signalled ? */
        { 
          if (ferror(fp)) r = NGP_READ_ERR;	/* was it real error or simply EOF ? */
	  if (0 == llen) return(NGP_EOF);	/* signal EOF only if 0 characters read so far */
          break;
        }
      if ('\n' == c) break;			/* end of line character ? */
      
      llen++;					/* we have new character, make room for it */
      alen = ((llen + NGP_ALLOCCHUNK) / NGP_ALLOCCHUNK) * NGP_ALLOCCHUNK;
      if (alen > allocsize)
        { p2 = (char *)ngp_realloc(*p, alen);	/* realloc buffer, if there is need */
          if (NULL == p2)
            { r = NGP_NO_MEMORY;
              break;
            }
	  *p = p2;
          allocsize = alen;
        }
      (*p)[llen - 1] = c;			/* copy character to buffer */
    }

   llen++;					/* place for terminating \0 */
   if (llen != allocsize)
     { p2 = (char *)ngp_realloc(*p, llen);
       if (NULL == p2) r = NGP_NO_MEMORY;
       else
         { *p = p2;
           (*p)[llen - 1] = 0;			/* copy \0 to buffer */
         }         
     }
   else
     { (*p)[llen - 1] = 0;			/* necessary when line read was empty */
     }

   if ((NGP_EOF != r) && (NGP_OK != r))		/* in case of errors free resources */
     { ngp_free(*p);
       *p = NULL;
     }
   
   return(r);					/* return  status code */
 }

	/* free current line structure */

int	ngp_free_line(void)
 {
   if (NULL != ngp_curline.line)
     { ngp_free(ngp_curline.line);
       ngp_curline.line = NULL;
       ngp_curline.name = NULL;
       ngp_curline.value = NULL;
       ngp_curline.comment = NULL;
       ngp_curline.type = NGP_TTYPE_UNKNOWN;
       ngp_curline.format = NGP_FORMAT_OK;
       ngp_curline.flags = 0;
     }
   return(NGP_OK);
 }

	/* free cached line structure */

int	ngp_free_prevline(void)
 {
   if (NULL != ngp_prevline.line)
     { ngp_free(ngp_prevline.line);
       ngp_prevline.line = NULL;
       ngp_prevline.name = NULL;
       ngp_prevline.value = NULL;
       ngp_prevline.comment = NULL;
       ngp_prevline.type = NGP_TTYPE_UNKNOWN;
       ngp_prevline.format = NGP_FORMAT_OK;
       ngp_prevline.flags = 0;
     }
   return(NGP_OK);
 }

	/* read one line */

int	ngp_read_line_buffered(FILE *fp)
 {
   ngp_free_line();				/* first free current line (if any) */
   
   if (NULL != ngp_prevline.line)		/* if cached, return cached line */
     { ngp_curline = ngp_prevline;
       ngp_prevline.line = NULL;
       ngp_prevline.name = NULL;
       ngp_prevline.value = NULL;
       ngp_prevline.comment = NULL;
       ngp_prevline.type = NGP_TTYPE_UNKNOWN;
       ngp_prevline.format = NGP_FORMAT_OK;
       ngp_prevline.flags = 0;
       ngp_curline.flags = NGP_LINE_REREAD;
       return(NGP_OK);
     }

   ngp_curline.flags = 0;   			/* if not cached really read line from file */
   return(ngp_line_from_file(fp, &(ngp_curline.line)));
 }

	/* unread line */

int	ngp_unread_line(void)
 {
   if (NULL == ngp_curline.line)		/* nothing to unread */
     return(NGP_EMPTY_CURLINE);

   if (NULL != ngp_prevline.line)		/* we cannot unread line twice */
     return(NGP_UNREAD_QUEUE_FULL);

   ngp_prevline = ngp_curline;
   ngp_curline.line = NULL;
   return(NGP_OK);
 }

	/* a first guess line decomposition */

int	ngp_extract_tokens(NGP_RAW_LINE *cl)
 { char *p, *s;
   int	cl_flags, i;

   p = cl->line;				/* start from beginning of line */
   if (NULL == p) return(NGP_NUL_PTR);

   cl->name = cl->value = cl->comment = NULL;
   cl->type = NGP_TTYPE_UNKNOWN;
   cl->format = NGP_FORMAT_OK;

   cl_flags = 0;

   for (i=0;; i++)				/* if 8 spaces at beginning then line is comment */
    { if ((0 == *p) || ('\n' == *p))
        {					/* if line has only blanks -> write blank keyword */
          cl->line[0] = 0;			/* create empty name (0 length string) */
          cl->comment = cl->name = cl->line;
	  cl->type = NGP_TTYPE_RAW;		/* signal write unformatted to FITS file */
          return(NGP_OK);
        }
      if ((' ' != *p) && ('\t' != *p)) break;
      if (i >= 7)
        { 
          cl->comment = p + 1;
          for (s = cl->comment;; s++)		/* filter out any EOS characters in comment */
           { if ('\n' == *s) *s = 0;
	     if (0 == *s) break;
           }
          cl->line[0] = 0;			/* create empty name (0 length string) */
          cl->name = cl->line;
	  cl->type = NGP_TTYPE_RAW;
          return(NGP_OK);
        }
      p++;
    }

   cl->name = p;

   for (;;)					/* we need to find 1st whitespace */
    { if ((0 == *p) || ('\n' == *p))
        { *p = 0;
          break;
        }

      /*
        from Richard Mathar, 2002-05-03, add 10 lines:
        if upper/lowercase HIERARCH followed also by an equal sign...
      */
      if( strncasecmp("HIERARCH",p,strlen("HIERARCH")) == 0 )
      {
           char * const eqsi=strchr(p,'=') ;
           if( eqsi )
           {
              cl_flags |= NGP_FOUND_EQUAL_SIGN ;
              p=eqsi ;
              break ;
           }
      }

      if ((' ' == *p) || ('\t' == *p)) break;
      if ('=' == *p)
        { cl_flags |= NGP_FOUND_EQUAL_SIGN;
          break;
        }

      p++;
    }

   if (*p) *(p++) = 0;				/* found end of keyname so terminate string with zero */

   if ((!ngp_strcasecmp("HISTORY", cl->name))
    || (!ngp_strcasecmp("COMMENT", cl->name))
    || (!ngp_strcasecmp("CONTINUE", cl->name)))
     { cl->comment = p;
       for (s = cl->comment;; s++)		/* filter out any EOS characters in comment */
        { if ('\n' == *s) *s = 0;
	  if (0 == *s) break;
        }
       cl->type = NGP_TTYPE_RAW;
       return(NGP_OK);
     }

   if (!ngp_strcasecmp("\\INCLUDE", cl->name))
     {
       for (;; p++)  if ((' ' != *p) && ('\t' != *p)) break; /* skip whitespace */

       cl->value = p;
       for (s = cl->value;; s++)		/* filter out any EOS characters */
        { if ('\n' == *s) *s = 0;
	  if (0 == *s) break;
        }
       cl->type = NGP_TTYPE_UNKNOWN;
       return(NGP_OK);
     }
       
   for (;; p++)
    { if ((0 == *p) || ('\n' == *p))  return(NGP_OK);	/* test if at end of string */
      if ((' ' == *p) || ('\t' == *p)) continue; /* skip whitespace */
      if (cl_flags & NGP_FOUND_EQUAL_SIGN) break;
      if ('=' != *p) break;			/* ignore initial equal sign */
      cl_flags |= NGP_FOUND_EQUAL_SIGN;
    }
      
   if ('/' == *p)				/* no value specified, comment only */
     { p++;
       if ((' ' == *p) || ('\t' == *p)) p++;
       cl->comment = p;
       for (s = cl->comment;; s++)		/* filter out any EOS characters in comment */
        { if ('\n' == *s) *s = 0;
	  if (0 == *s) break;
        }
       return(NGP_OK);
     }

   if ('\'' == *p)				/* we have found string within quotes */
     { cl->value = s = ++p;			/* set pointer to beginning of that string */
       cl->type = NGP_TTYPE_STRING;		/* signal that it is of string type */

       for (;;)					/* analyze it */
        { if ((0 == *p) || ('\n' == *p))	/* end of line -> end of string */
            { *s = 0; return(NGP_OK); }

          if ('\'' == *p)			/* we have found doublequote */
            { if ((0 == p[1]) || ('\n' == p[1]))/* doublequote is the last character in line */
                { *s = 0; return(NGP_OK); }
              if (('\t' == p[1]) || (' ' == p[1])) /* duoblequote was string terminator */
                { *s = 0; p++; break; }
              if ('\'' == p[1]) p++;		/* doublequote is inside string, convert "" -> " */ 
            }

          *(s++) = *(p++);			/* compact string in place, necess. by "" -> " conversion */
        }
     }
   else						/* regular token */
     { 
       cl->value = p;				/* set pointer to token */
       cl->type = NGP_TTYPE_UNKNOWN;		/* we dont know type at the moment */
       for (;; p++)				/* we need to find 1st whitespace */
        { if ((0 == *p) || ('\n' == *p))
            { *p = 0; return(NGP_OK); }
          if ((' ' == *p) || ('\t' == *p)) break;
        }
       if (*p)  *(p++) = 0;			/* found so terminate string with zero */
     }
       
   for (;; p++)
    { if ((0 == *p) || ('\n' == *p))  return(NGP_OK);	/* test if at end of string */
      if ((' ' != *p) && ('\t' != *p)) break;	/* skip whitespace */
    }
      
   if ('/' == *p)				/* no value specified, comment only */
     { p++;
       if ((' ' == *p) || ('\t' == *p)) p++;
       cl->comment = p;
       for (s = cl->comment;; s++)		/* filter out any EOS characters in comment */
        { if ('\n' == *s) *s = 0;
	  if (0 == *s) break;
        }
       return(NGP_OK);
     }

   cl->format = NGP_FORMAT_ERROR;
   return(NGP_OK);				/* too many tokens ... */
 }

/*      try to open include file. If open fails and fname
        does not specify absolute pathname, try to open fname
        in any directory specified in CFITSIO_INCLUDE_FILES
        environment variable. Finally try to open fname
        relative to ngp_master_dir, which is directory of top
        level include file
*/

int	ngp_include_file(char *fname)		/* try to open include file */
 { char *p, *p2, *cp, *envar, envfiles[NGP_MAX_ENVFILES];

   if (NULL == fname) return(NGP_NUL_PTR);

   if (ngp_inclevel >= NGP_MAX_INCLUDE)		/* too many include files */
     return(NGP_INC_NESTING);

   if (NULL == (ngp_fp[ngp_inclevel] = fopen(fname, "r")))
     {                                          /* if simple open failed .. */
       envar = getenv("CFITSIO_INCLUDE_FILES");	/* scan env. variable, and retry to open */

       if (NULL != envar)			/* is env. variable defined ? */
         { strncpy(envfiles, envar, NGP_MAX_ENVFILES - 1);
           envfiles[NGP_MAX_ENVFILES - 1] = 0;	/* copy search path to local variable, env. is fragile */

           for (p2 = strtok(envfiles, ":"); NULL != p2; p2 = strtok(NULL, ":"))
            {
	      cp = (char *)ngp_alloc(strlen(fname) + strlen(p2) + 2);
	      if (NULL == cp) return(NGP_NO_MEMORY);

	      strcpy(cp, p2);
#ifdef  MSDOS
              strcat(cp, "\\");			/* abs. pathname for MSDOS */
               
#else
              strcat(cp, "/");			/* and for unix */
#endif
	      strcat(cp, fname);
	  
	      ngp_fp[ngp_inclevel] = fopen(cp, "r");
	      ngp_free(cp);

	      if (NULL != ngp_fp[ngp_inclevel]) break;
	    }
        }
                                      
       if (NULL == ngp_fp[ngp_inclevel])	/* finally try to open relative to top level */
         {
#ifdef  MSDOS
           if ('\\' == fname[0]) return(NGP_ERR_FOPEN); /* abs. pathname for MSDOS, does not support C:\\PATH */
#else
           if ('/' == fname[0]) return(NGP_ERR_FOPEN); /* and for unix */
#endif
           if (0 == ngp_master_dir[0]) return(NGP_ERR_FOPEN);

	   p = ngp_alloc(strlen(fname) + strlen(ngp_master_dir) + 1);
           if (NULL == p) return(NGP_NO_MEMORY);

           strcpy(p, ngp_master_dir);		/* construct composite pathname */
           strcat(p, fname);			/* comp = master + fname */

           ngp_fp[ngp_inclevel] = fopen(p, "r");/* try to open composite */
           ngp_free(p);				/* we don't need buffer anymore */

           if (NULL == ngp_fp[ngp_inclevel])
             return(NGP_ERR_FOPEN);		/* fail if error */
         }
     }

   ngp_inclevel++;
   return(NGP_OK);
 }


/* read line in the intelligent way. All \INCLUDE directives are handled,
   empty and comment line skipped. If this function returns NGP_OK, than
   decomposed line (name, type, value in proper type and comment) are
   stored in ngp_linkey structure. ignore_blank_lines parameter is zero
   when parser is inside GROUP or HDU definition. Nonzero otherwise.
*/

int	ngp_read_line(int ignore_blank_lines)
 { int r, nc, savec;
   unsigned k;

   if (ngp_inclevel <= 0)		/* do some sanity checking first */
     { ngp_keyidx = NGP_TOKEN_EOF;	/* no parents, so report error */
       return(NGP_OK);	
     }
   if (ngp_inclevel > NGP_MAX_INCLUDE)  return(NGP_INC_NESTING);
   if (NULL == ngp_fp[ngp_inclevel - 1]) return(NGP_NUL_PTR);

   for (;;)
    { switch (r = ngp_read_line_buffered(ngp_fp[ngp_inclevel - 1]))
       { case NGP_EOF:
		ngp_inclevel--;			/* end of file, revert to parent */
		if (ngp_fp[ngp_inclevel])	/* we can close old file */
		  fclose(ngp_fp[ngp_inclevel]);

		ngp_fp[ngp_inclevel] = NULL;
		if (ngp_inclevel <= 0)
		  { ngp_keyidx = NGP_TOKEN_EOF;	/* no parents, so report error */
		    return(NGP_OK);	
		  }
		continue;

	 case NGP_OK:
		if (ngp_curline.flags & NGP_LINE_REREAD) return(r);
		break;
	 default:
		return(r);
       }
      
      switch (ngp_curline.line[0])
       { case 0: if (0 == ignore_blank_lines) break; /* ignore empty lines if told so */
         case '#': continue;			/* ignore comment lines */
       }
      
      r = ngp_extract_tokens(&ngp_curline);	/* analyse line, extract tokens and comment */
      if (NGP_OK != r) return(r);

      if (NULL == ngp_curline.name)  continue;	/* skip lines consisting only of whitespaces */

      for (k = 0; k < strlen(ngp_curline.name); k++)
       { if ((ngp_curline.name[k] >= 'a') && (ngp_curline.name[k] <= 'z')) 
           ngp_curline.name[k] += 'A' - 'a';	/* force keyword to be upper case */
         if (k == 7) break;  /* only first 8 chars are required to be upper case */
       }

      for (k=0;; k++)				/* find index of keyword in keyword table */
       { if (NGP_TOKEN_UNKNOWN == ngp_tkdef[k].code) break;
         if (0 == strcmp(ngp_curline.name, ngp_tkdef[k].name)) break;
       }

      ngp_keyidx = ngp_tkdef[k].code;		/* save this index, grammar parser will need this */

      if (NGP_TOKEN_INCLUDE == ngp_keyidx)	/* if this is \INCLUDE keyword, try to include file */
        { if (NGP_OK != (r = ngp_include_file(ngp_curline.value))) return(r);
	  continue;				/* and read next line */
        }

      ngp_linkey.type = NGP_TTYPE_UNKNOWN;	/* now, get the keyword type, it's a long story ... */

      if (NULL != ngp_curline.value)		/* if no value given signal it */
        { if (NGP_TTYPE_STRING == ngp_curline.type)  /* string type test */
            { ngp_linkey.type = NGP_TTYPE_STRING;
              ngp_linkey.value.s = ngp_curline.value;
            }
          if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* bool type test */
            { if ((!ngp_strcasecmp("T", ngp_curline.value)) || (!ngp_strcasecmp("F", ngp_curline.value)))
                { ngp_linkey.type = NGP_TTYPE_BOOL;
                  ngp_linkey.value.b = (ngp_strcasecmp("T", ngp_curline.value) ? 0 : 1);
                }
            }
          if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* complex type test */
            { if (2 == sscanf(ngp_curline.value, "(%lg,%lg)%n", &(ngp_linkey.value.c.re), &(ngp_linkey.value.c.im), &nc))
                { if ((' ' == ngp_curline.value[nc]) || ('\t' == ngp_curline.value[nc])
                   || ('\n' == ngp_curline.value[nc]) || (0 == ngp_curline.value[nc]))
                    { ngp_linkey.type = NGP_TTYPE_COMPLEX;
                    }
                }
            }
          if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* real type test */
            { if (strchr(ngp_curline.value, '.') && (1 == sscanf(ngp_curline.value, "%lg%n", &(ngp_linkey.value.d), &nc)))
                {
		 if ('D' == ngp_curline.value[nc]) {
		   /* test if template used a 'D' rather than an 'E' as the exponent character (added by WDP in 12/2010) */
                   savec = nc;
		   ngp_curline.value[nc] = 'E';
		   sscanf(ngp_curline.value, "%lg%n", &(ngp_linkey.value.d), &nc);
		   if ((' ' == ngp_curline.value[nc]) || ('\t' == ngp_curline.value[nc])
                    || ('\n' == ngp_curline.value[nc]) || (0 == ngp_curline.value[nc]))  {
                       ngp_linkey.type = NGP_TTYPE_REAL;
                     } else {  /* no, this is not a real value */
		       ngp_curline.value[savec] = 'D';  /* restore the original D character */
 		     }
		 } else {
		  if ((' ' == ngp_curline.value[nc]) || ('\t' == ngp_curline.value[nc])
                   || ('\n' == ngp_curline.value[nc]) || (0 == ngp_curline.value[nc]))
                    { ngp_linkey.type = NGP_TTYPE_REAL;
                    }
                 } 
                }
            }
          if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* integer type test */
            { if (1 == sscanf(ngp_curline.value, "%d%n", &(ngp_linkey.value.i), &nc))
                { if ((' ' == ngp_curline.value[nc]) || ('\t' == ngp_curline.value[nc])
                   || ('\n' == ngp_curline.value[nc]) || (0 == ngp_curline.value[nc]))
                    { ngp_linkey.type = NGP_TTYPE_INT;
                    }
                }
            }
          if (NGP_TTYPE_UNKNOWN == ngp_linkey.type) /* force string type */
            { ngp_linkey.type = NGP_TTYPE_STRING;
              ngp_linkey.value.s = ngp_curline.value;
            }
        }
      else
        { if (NGP_TTYPE_RAW == ngp_curline.type) ngp_linkey.type = NGP_TTYPE_RAW;
	  else ngp_linkey.type = NGP_TTYPE_NULL;
	}

      if (NULL != ngp_curline.comment)
        { strncpy(ngp_linkey.comment, ngp_curline.comment, NGP_MAX_COMMENT); /* store comment */
	  ngp_linkey.comment[NGP_MAX_COMMENT - 1] = 0;
	}
      else
        { ngp_linkey.comment[0] = 0;
        }

      strncpy(ngp_linkey.name, ngp_curline.name, NGP_MAX_NAME); /* and keyword's name */
      ngp_linkey.name[NGP_MAX_NAME - 1] = 0;

      if (strlen(ngp_linkey.name) > FLEN_KEYWORD)  /* WDP: 20-Jun-2002:  mod to support HIERARCH */
        { 
           return(NGP_BAD_ARG);		/* cfitsio does not allow names > 8 chars */
        }
      
      return(NGP_OK);			/* we have valid non empty line, so return success */
    }
 }

	/* check whether keyword can be written as is */

int	ngp_keyword_is_write(NGP_TOKEN *ngp_tok)
 { int i, j, l, spc;
                        /* indexed variables not to write */

   static char *nm[] = { "NAXIS", "TFORM", "TTYPE", NULL } ;

                        /* non indexed variables not allowed to write */
  
   static char *nmni[] = { "SIMPLE", "XTENSION", "BITPIX", "NAXIS", "PCOUNT",
                           "GCOUNT", "TFIELDS", "THEAP", "EXTEND", "EXTVER",
                           NULL } ;

   if (NULL == ngp_tok) return(NGP_NUL_PTR);

   for (j = 0; ; j++)           /* first check non indexed */
    { if (NULL == nmni[j]) break;
      if (0 == strcmp(nmni[j], ngp_tok->name)) return(NGP_BAD_ARG);
    } 

   for (j = 0; ; j++)           /* now check indexed */
    { if (NULL == nm[j]) return(NGP_OK);
      l = strlen(nm[j]);
      if ((l < 1) || (l > 5)) continue;
      if (0 == strncmp(nm[j], ngp_tok->name, l)) break;
    } 

   if ((ngp_tok->name[l] < '1') || (ngp_tok->name[l] > '9')) return(NGP_OK);
   spc = 0;
   for (i = l + 1; i < 8; i++)
    { if (spc) { if (' ' != ngp_tok->name[i]) return(NGP_OK); }
      else
       { if ((ngp_tok->name[i] >= '0') && (ngp_tok->name[i] <= '9')) continue;
         if (' ' == ngp_tok->name[i]) { spc = 1; continue; }
         if (0 == ngp_tok->name[i]) break;
         return(NGP_OK);
       }
    }
   return(NGP_BAD_ARG);
 }

	/* write (almost) all keywords from given HDU to disk */

int     ngp_keyword_all_write(NGP_HDU *ngph, fitsfile *ffp, int mode)
 { int		i, r, ib;
   char		buf[200];
   long		l;


   if (NULL == ngph) return(NGP_NUL_PTR);
   if (NULL == ffp) return(NGP_NUL_PTR);
   r = NGP_OK;
   
   for (i=0; itokcnt; i++)
    { r = ngp_keyword_is_write(&(ngph->tok[i]));
      if ((NGP_REALLY_ALL & mode) || (NGP_OK == r))
        { switch (ngph->tok[i].type)
           { case NGP_TTYPE_BOOL:
			ib = ngph->tok[i].value.b;
			fits_write_key(ffp, TLOGICAL, ngph->tok[i].name, &ib, ngph->tok[i].comment, &r);
			break;
             case NGP_TTYPE_STRING:
			fits_write_key_longstr(ffp, ngph->tok[i].name, ngph->tok[i].value.s, ngph->tok[i].comment, &r);
			break;
             case NGP_TTYPE_INT:
			l = ngph->tok[i].value.i;	/* bugfix - 22-Jan-99, BO - nonalignment of OSF/Alpha */
			fits_write_key(ffp, TLONG, ngph->tok[i].name, &l, ngph->tok[i].comment, &r);
			break;
             case NGP_TTYPE_REAL:
			fits_write_key(ffp, TDOUBLE, ngph->tok[i].name, &(ngph->tok[i].value.d), ngph->tok[i].comment, &r);
			break;
             case NGP_TTYPE_COMPLEX:
			fits_write_key(ffp, TDBLCOMPLEX, ngph->tok[i].name, &(ngph->tok[i].value.c), ngph->tok[i].comment, &r);
			break;
             case NGP_TTYPE_NULL:
			fits_write_key_null(ffp, ngph->tok[i].name, ngph->tok[i].comment, &r);
			break;
             case NGP_TTYPE_RAW:
			if (0 == strcmp("HISTORY", ngph->tok[i].name))
			  { fits_write_history(ffp, ngph->tok[i].comment, &r);
			    break;
			  }
			if (0 == strcmp("COMMENT", ngph->tok[i].name))
			  { fits_write_comment(ffp, ngph->tok[i].comment, &r);
			    break;
			  }
			sprintf(buf, "%-8.8s%s", ngph->tok[i].name, ngph->tok[i].comment);
			fits_write_record(ffp, buf, &r);
                        break;
           }
        }
      else if (NGP_BAD_ARG == r) /* enhancement 10 dec 2003, James Peachey: template comments replace defaults */
        { r = NGP_OK;						/* update comments of special keywords like TFORM */
          if (ngph->tok[i].comment && *ngph->tok[i].comment)	/* do not update with a blank comment */
            { fits_modify_comment(ffp, ngph->tok[i].name, ngph->tok[i].comment, &r);
            }
        }
      else /* other problem, typically a blank token */
        { r = NGP_OK;						/* skip this token, but continue */
        }
      if (r) return(r);
    }
     
   fits_set_hdustruc(ffp, &r);				/* resync cfitsio */
   return(r);
 }

	/* init HDU structure */

int	ngp_hdu_init(NGP_HDU *ngph)
 { if (NULL == ngph) return(NGP_NUL_PTR);
   ngph->tok = NULL;
   ngph->tokcnt = 0;
   return(NGP_OK);
 }

	/* clear HDU structure */

int	ngp_hdu_clear(NGP_HDU *ngph)
 { int i;

   if (NULL == ngph) return(NGP_NUL_PTR);

   for (i=0; itokcnt; i++)
    { if (NGP_TTYPE_STRING == ngph->tok[i].type)
        if (NULL != ngph->tok[i].value.s)
          { ngp_free(ngph->tok[i].value.s);
            ngph->tok[i].value.s = NULL;
          }
    }

   if (NULL != ngph->tok) ngp_free(ngph->tok);

   ngph->tok = NULL;
   ngph->tokcnt = 0;

   return(NGP_OK);
 }

	/* insert new token to HDU structure */

int	ngp_hdu_insert_token(NGP_HDU *ngph, NGP_TOKEN *newtok)
 { NGP_TOKEN *tkp;
   
   if (NULL == ngph) return(NGP_NUL_PTR);
   if (NULL == newtok) return(NGP_NUL_PTR);

   if (0 == ngph->tokcnt)
     tkp = (NGP_TOKEN *)ngp_alloc((ngph->tokcnt + 1) * sizeof(NGP_TOKEN));
   else
     tkp = (NGP_TOKEN *)ngp_realloc(ngph->tok, (ngph->tokcnt + 1) * sizeof(NGP_TOKEN));

   if (NULL == tkp) return(NGP_NO_MEMORY);
       
   ngph->tok = tkp;
   ngph->tok[ngph->tokcnt] = *newtok;

   if (NGP_TTYPE_STRING == newtok->type)
     { if (NULL != newtok->value.s)
         { ngph->tok[ngph->tokcnt].value.s = (char *)ngp_alloc(1 + strlen(newtok->value.s));
           if (NULL == ngph->tok[ngph->tokcnt].value.s) return(NGP_NO_MEMORY);
           strcpy(ngph->tok[ngph->tokcnt].value.s, newtok->value.s);
         }
     }

   ngph->tokcnt++;
   return(NGP_OK);
 }


int	ngp_append_columns(fitsfile *ff, NGP_HDU *ngph, int aftercol)
 { int		r, i, j, exitflg, ngph_i;
   char 	*my_tform, *my_ttype;
   char		ngph_ctmp;


   if (NULL == ff) return(NGP_NUL_PTR);
   if (NULL == ngph) return(NGP_NUL_PTR);
   if (0 == ngph->tokcnt) return(NGP_OK);	/* nothing to do ! */

   r = NGP_OK;
   exitflg = 0;

   for (j=aftercol; jtok[i].name, "TFORM%d%c", &ngph_i, &ngph_ctmp))
           { if ((NGP_TTYPE_STRING == ngph->tok[i].type) && (ngph_i == (j + 1)))
   	    { my_tform = ngph->tok[i].value.s;
   	    }
                }
         else if (1 == sscanf(ngph->tok[i].name, "TTYPE%d%c", &ngph_i, &ngph_ctmp))
           { if ((NGP_TTYPE_STRING == ngph->tok[i].type) && (ngph_i == (j + 1)))
               { my_ttype = ngph->tok[i].value.s;
               }
           }
         
         if ((NULL != my_tform) && (my_ttype[0])) break;
         
         if (i < (ngph->tokcnt - 1)) continue;
         exitflg = 1;
         break;
       }
      if ((NGP_OK == r) && (NULL != my_tform))
        fits_insert_col(ff, j + 1, my_ttype, my_tform, &r);

      if ((NGP_OK != r) || exitflg) break;
    }
   return(r);
 }

	/* read complete HDU */

int	ngp_read_xtension(fitsfile *ff, int parent_hn, int simple_mode)
 { int		r, exflg, l, my_hn, tmp0, incrementor_index, i, j;
   int		ngph_dim, ngph_bitpix, ngph_node_type, my_version;
   char		incrementor_name[NGP_MAX_STRING], ngph_ctmp;
   char 	*ngph_extname = 0;
   long		ngph_size[NGP_MAX_ARRAY_DIM];
   NGP_HDU	ngph;
   long		lv;

   incrementor_name[0] = 0;			/* signal no keyword+'#' found yet */
   incrementor_index = 0;

   if (NGP_OK != (r = ngp_hdu_init(&ngph))) return(r);

   if (NGP_OK != (r = ngp_read_line(0))) return(r);	/* EOF always means error here */
   switch (NGP_XTENSION_SIMPLE & simple_mode)
     {
       case 0:  if (NGP_TOKEN_XTENSION != ngp_keyidx) return(NGP_TOKEN_NOT_EXPECT);
		break;
       default:	if (NGP_TOKEN_SIMPLE != ngp_keyidx) return(NGP_TOKEN_NOT_EXPECT);
		break;
     }
       	
   if (NGP_OK != (r = ngp_hdu_insert_token(&ngph, &ngp_linkey))) return(r);

   for (;;)
    { if (NGP_OK != (r = ngp_read_line(0))) return(r);	/* EOF always means error here */
      exflg = 0;
      switch (ngp_keyidx)
       { 
	 case NGP_TOKEN_SIMPLE:
	 		r = NGP_TOKEN_NOT_EXPECT;
			break;
	 		                        
	 case NGP_TOKEN_END:
         case NGP_TOKEN_XTENSION:
         case NGP_TOKEN_GROUP:
         		r = ngp_unread_line();	/* WARNING - not break here .... */
         case NGP_TOKEN_EOF:
			exflg = 1;
 			break;

         default:	l = strlen(ngp_linkey.name);
			if ((l >= 2) && (l <= 6))
			  { if ('#' == ngp_linkey.name[l - 1])
			      { if (0 == incrementor_name[0])
			          { memcpy(incrementor_name, ngp_linkey.name, l - 1);
			            incrementor_name[l - 1] = 0;
			          }
			        if (((l - 1) == (int)strlen(incrementor_name)) && (0 == memcmp(incrementor_name, ngp_linkey.name, l - 1)))
			          { incrementor_index++;
			          }
			        sprintf(ngp_linkey.name + l - 1, "%d", incrementor_index);
			      }
			  }
			r = ngp_hdu_insert_token(&ngph, &ngp_linkey);
 			break;
       }
      if ((NGP_OK != r) || exflg) break;
    }

   if (NGP_OK == r)
     { 				/* we should scan keywords, and calculate HDU's */
				/* structure ourselves .... */

       ngph_node_type = NGP_NODE_INVALID;	/* init variables */
       ngph_bitpix = 0;
       ngph_extname = NULL;
       for (i=0; i=1) && (j <= NGP_MAX_ARRAY_DIM))
		  { ngph_size[j - 1] = ngph.tok[i].value.i;
		  }
            }
        }

       switch (ngph_node_type)
        { case NGP_NODE_IMAGE:
			if (NGP_XTENSION_FIRST == ((NGP_XTENSION_FIRST | NGP_XTENSION_SIMPLE) & simple_mode))
			  { 		/* if caller signals that this is 1st HDU in file */
					/* and it is IMAGE defined with XTENSION, then we */
					/* need create dummy Primary HDU */			  
			    fits_create_img(ff, 16, 0, NULL, &r);
			  }
					/* create image */
			fits_create_img(ff, ngph_bitpix, ngph_dim, ngph_size, &r);

					/* update keywords */
			if (NGP_OK == r)  r = ngp_keyword_all_write(&ngph, ff, NGP_NON_SYSTEM_ONLY);
			break;

          case NGP_NODE_ATABLE:
          case NGP_NODE_BTABLE:
					/* create table, 0 rows and 0 columns for the moment */
			fits_create_tbl(ff, ((NGP_NODE_ATABLE == ngph_node_type)
					     ? ASCII_TBL : BINARY_TBL),
					0, 0, NULL, NULL, NULL, NULL, &r);
			if (NGP_OK != r) break;

					/* add columns ... */
			r = ngp_append_columns(ff, &ngph, 0);
			if (NGP_OK != r) break;

					/* add remaining keywords */
			r = ngp_keyword_all_write(&ngph, ff, NGP_NON_SYSTEM_ONLY);
			if (NGP_OK != r) break;

					/* if requested add rows */
			if (ngph_size[1] > 0) fits_insert_rows(ff, 0, ngph_size[1], &r);
			break;

	  default:	r = NGP_BAD_ARG;
	  		break;
	}

     }

   if ((NGP_OK == r) && (NULL != ngph_extname))
     { r = ngp_get_extver(ngph_extname, &my_version);	/* write correct ext version number */
       lv = my_version;		/* bugfix - 22-Jan-99, BO - nonalignment of OSF/Alpha */
       fits_write_key(ff, TLONG, "EXTVER", &lv, "auto assigned by template parser", &r); 
     }

   if (NGP_OK == r)
     { if (parent_hn > 0)
         { fits_get_hdu_num(ff, &my_hn);
           fits_movabs_hdu(ff, parent_hn, &tmp0, &r);	/* link us to parent */
           fits_add_group_member(ff, NULL, my_hn, &r);
           fits_movabs_hdu(ff, my_hn, &tmp0, &r);
           if (NGP_OK != r) return(r);
         }
     }

   if (NGP_OK != r)					/* in case of error - delete hdu */
     { tmp0 = 0;
       fits_delete_hdu(ff, NULL, &tmp0);
     }

   ngp_hdu_clear(&ngph);
   return(r);
 }

	/* read complete GROUP */

int	ngp_read_group(fitsfile *ff, char *grpname, int parent_hn)
 { int		r, exitflg, l, my_hn, tmp0, incrementor_index;
   char		grnm[NGP_MAX_STRING];			/* keyword holding group name */
   char		incrementor_name[NGP_MAX_STRING];
   NGP_HDU	ngph;

   incrementor_name[0] = 0;			/* signal no keyword+'#' found yet */
   incrementor_index = 6;			/* first 6 cols are used by group */

   ngp_grplevel++;
   if (NGP_OK != (r = ngp_hdu_init(&ngph))) return(r);

   r = NGP_OK;
   if (NGP_OK != (r = fits_create_group(ff, grpname, GT_ID_ALL_URI, &r))) return(r);
   fits_get_hdu_num(ff, &my_hn);
   if (parent_hn > 0)
     { fits_movabs_hdu(ff, parent_hn, &tmp0, &r);	/* link us to parent */
       fits_add_group_member(ff, NULL, my_hn, &r);
       fits_movabs_hdu(ff, my_hn, &tmp0, &r);
       if (NGP_OK != r) return(r);
     }

   for (exitflg = 0; 0 == exitflg;)
    { if (NGP_OK != (r = ngp_read_line(0))) break;	/* EOF always means error here */
      switch (ngp_keyidx)
       {
	 case NGP_TOKEN_SIMPLE:
	 case NGP_TOKEN_EOF:
			r = NGP_TOKEN_NOT_EXPECT;
			break;

         case NGP_TOKEN_END:
         		ngp_grplevel--;
			exitflg = 1;
			break;

         case NGP_TOKEN_GROUP:
			if (NGP_TTYPE_STRING == ngp_linkey.type)
			  { strncpy(grnm, ngp_linkey.value.s, NGP_MAX_STRING);
			  }
			else
			  { sprintf(grnm, "DEFAULT_GROUP_%d", master_grp_idx++);
			  }
			grnm[NGP_MAX_STRING - 1] = 0;
			r = ngp_read_group(ff, grnm, my_hn);
			break;			/* we can have many subsequent GROUP defs */

         case NGP_TOKEN_XTENSION:
         		r = ngp_unread_line();
         		if (NGP_OK != r) break;
         		r = ngp_read_xtension(ff, my_hn, 0);
			break;			/* we can have many subsequent HDU defs */

         default:	l = strlen(ngp_linkey.name);
			if ((l >= 2) && (l <= 6))
			  { if ('#' == ngp_linkey.name[l - 1])
			      { if (0 == incrementor_name[0])
			          { memcpy(incrementor_name, ngp_linkey.name, l - 1);
			            incrementor_name[l - 1] = 0;
			          }
			        if (((l - 1) == (int)strlen(incrementor_name)) && (0 == memcmp(incrementor_name, ngp_linkey.name, l - 1)))
			          { incrementor_index++;
			          }
			        sprintf(ngp_linkey.name + l - 1, "%d", incrementor_index);
			      }
			  }
         		r = ngp_hdu_insert_token(&ngph, &ngp_linkey); 
			break;			/* here we can add keyword */
       }
      if (NGP_OK != r) break;
    }

   fits_movabs_hdu(ff, my_hn, &tmp0, &r);	/* back to our HDU */

   if (NGP_OK == r)				/* create additional columns, if requested */
     r = ngp_append_columns(ff, &ngph, 6);

   if (NGP_OK == r)				/* and write keywords */
     r = ngp_keyword_all_write(&ngph, ff, NGP_NON_SYSTEM_ONLY);

   if (NGP_OK != r)			/* delete group in case of error */
     { tmp0 = 0;
       fits_remove_group(ff, OPT_RM_GPT, &tmp0);
     }

   ngp_hdu_clear(&ngph);		/* we are done with this HDU, so delete it */
   return(r);
 }

		/* top level API functions */

/* read whole template. ff should point to the opened empty fits file. */

int	fits_execute_template(fitsfile *ff, char *ngp_template, int *status)
 { int		r, exit_flg, first_extension, i, my_hn, tmp0, keys_exist, more_keys, used_ver;
   char		grnm[NGP_MAX_STRING], used_name[NGP_MAX_STRING];
   long		luv;

   if (NULL == status) return(NGP_NUL_PTR);
   if (NGP_OK != *status) return(*status);

   if ((NULL == ff) || (NULL == ngp_template))
     { *status = NGP_NUL_PTR;
       return(*status);
     }

   ngp_inclevel = 0;				/* initialize things, not all should be zero */
   ngp_grplevel = 0;
   master_grp_idx = 1;
   exit_flg = 0;
   ngp_master_dir[0] = 0;			/* this should be before 1st call to ngp_include_file */
   first_extension = 1;				/* we need to create PHDU */

   if (NGP_OK != (r = ngp_delete_extver_tab()))
     { *status = r;
       return(r);
     }

   fits_get_hdu_num(ff, &my_hn);		/* our HDU position */
   if (my_hn <= 1)				/* check whether we really need to create PHDU */
     { fits_movabs_hdu(ff, 1, &tmp0, status);
       fits_get_hdrspace(ff, &keys_exist, &more_keys, status);
       fits_movabs_hdu(ff, my_hn, &tmp0, status);
       if (NGP_OK != *status) return(*status);	/* error here means file is corrupted */
       if (keys_exist > 0) first_extension = 0;	/* if keywords exist assume PHDU already exist */
     }
   else
     { first_extension = 0;			/* PHDU (followed by 1+ extensions) exist */

       for (i = 2; i<= my_hn; i++)
        { *status = NGP_OK;
          fits_movabs_hdu(ff, 1, &tmp0, status);
          if (NGP_OK != *status) break;

          fits_read_key(ff, TSTRING, "EXTNAME", used_name, NULL, status);
          if (NGP_OK != *status)  continue;

          fits_read_key(ff, TLONG, "EXTVER", &luv, NULL, status);
          used_ver = luv;			/* bugfix - 22-Jan-99, BO - nonalignment of OSF/Alpha */
          if (VALUE_UNDEFINED == *status)
            { used_ver = 1;
              *status = NGP_OK;
            }

          if (NGP_OK == *status) *status = ngp_set_extver(used_name, used_ver);
        }

       fits_movabs_hdu(ff, my_hn, &tmp0, status);
     }
   if (NGP_OK != *status) return(*status);
                                                                          
   if (NGP_OK != (*status = ngp_include_file(ngp_template))) return(*status);

   for (i = strlen(ngp_template) - 1; i >= 0; i--) /* strlen is > 0, otherwise fopen failed */
    { 
#ifdef MSDOS
      if ('\\' == ngp_template[i]) break;
#else
      if ('/' == ngp_template[i]) break;
#endif
    } 
      
   i++;
   if (i > (NGP_MAX_FNAME - 1)) i = NGP_MAX_FNAME - 1;

   if (i > 0)
     { memcpy(ngp_master_dir, ngp_template, i);
       ngp_master_dir[i] = 0;
     }


   for (;;)
    { if (NGP_OK != (r = ngp_read_line(1))) break;	/* EOF always means error here */
      switch (ngp_keyidx)
       {
         case NGP_TOKEN_SIMPLE:
			if (0 == first_extension)	/* simple only allowed in first HDU */
			  { r = NGP_TOKEN_NOT_EXPECT;
			    break;
			  }
			if (NGP_OK != (r = ngp_unread_line())) break;
			r = ngp_read_xtension(ff, 0, NGP_XTENSION_SIMPLE | NGP_XTENSION_FIRST);
			first_extension = 0;
			break;

         case NGP_TOKEN_XTENSION:
			if (NGP_OK != (r = ngp_unread_line())) break;
			r = ngp_read_xtension(ff, 0, (first_extension ? NGP_XTENSION_FIRST : 0));
			first_extension = 0;
			break;

         case NGP_TOKEN_GROUP:
			if (NGP_TTYPE_STRING == ngp_linkey.type)
			  { strncpy(grnm, ngp_linkey.value.s, NGP_MAX_STRING); }
			else
			  { sprintf(grnm, "DEFAULT_GROUP_%d", master_grp_idx++); }
			grnm[NGP_MAX_STRING - 1] = 0;
			r = ngp_read_group(ff, grnm, 0);
			first_extension = 0;
			break;

	 case NGP_TOKEN_EOF:
			exit_flg = 1;
			break;

         default:	r = NGP_TOKEN_NOT_EXPECT;
			break;
       }
      if (exit_flg || (NGP_OK != r)) break;
    }

/* all top level HDUs up to faulty one are left intact in case of i/o error. It is up
   to the caller to call fits_close_file or fits_delete_file when this function returns
   error. */

   ngp_free_line();		/* deallocate last line (if any) */
   ngp_free_prevline();		/* deallocate cached line (if any) */
   ngp_delete_extver_tab();	/* delete extver table (if present), error ignored */
   
   *status = r;
   return(r);
 }
healpy-1.10.3/cfitsio/grparser.h0000664000175000017500000001326513010375005016765 0ustar  zoncazonca00000000000000/*		T E M P L A T E   P A R S E R   H E A D E R   F I L E
		=====================================================

		by Jerzy.Borkowski@obs.unige.ch

		Integral Science Data Center
		ch. d'Ecogia 16
		1290 Versoix
		Switzerland

14-Oct-98: initial release
16-Oct-98: reference to fitsio.h removed, also removed strings after #endif
		directives to make gcc -Wall not to complain
20-Oct-98: added declarations NGP_XTENSION_SIMPLE and NGP_XTENSION_FIRST
24-Oct-98: prototype of ngp_read_line() function updated.
22-Jan-99: prototype for ngp_set_extver() function added.
20-Jun-2002 Wm Pence, added support for the HIERARCH keyword convention
            (changed NGP_MAX_NAME from (20) to FLEN_KEYWORD)
*/

#ifndef	GRPARSER_H_INCLUDED
#define	GRPARSER_H_INCLUDED

#ifdef __cplusplus
extern "C" {
#endif

	/* error codes  - now defined in fitsio.h */

	/* common constants definitions */

#define	NGP_ALLOCCHUNK		(1000)
#define	NGP_MAX_INCLUDE		(10)			/* include file nesting limit */
#define	NGP_MAX_COMMENT		(80)			/* max size for comment */
#define	NGP_MAX_NAME		FLEN_KEYWORD		/* max size for KEYWORD (FITS limits it to 8 chars) */
                                                        /* except HIERARCH can have longer effective keyword names */
#define	NGP_MAX_STRING		(80)			/* max size for various strings */
#define	NGP_MAX_ARRAY_DIM	(999)			/* max. number of dimensions in array */
#define NGP_MAX_FNAME           (1000)                  /* max size of combined path+fname */
#define	NGP_MAX_ENVFILES	(10000)			/* max size of CFITSIO_INCLUDE_FILES env. variable */

#define	NGP_TOKEN_UNKNOWN	(-1)			/* token type unknown */
#define	NGP_TOKEN_INCLUDE	(0)			/* \INCLUDE token */
#define	NGP_TOKEN_GROUP		(1)			/* \GROUP token */
#define	NGP_TOKEN_END		(2)			/* \END token */
#define	NGP_TOKEN_XTENSION	(3)			/* XTENSION token */
#define	NGP_TOKEN_SIMPLE	(4)			/* SIMPLE token */
#define	NGP_TOKEN_EOF		(5)			/* End Of File pseudo token */

#define	NGP_TTYPE_UNKNOWN	(0)			/* undef (yet) token type - invalid to print/write to disk */
#define	NGP_TTYPE_BOOL		(1)			/* boolean, it is 'T' or 'F' */
#define	NGP_TTYPE_STRING	(2)			/* something withing "" or starting with letter */
#define	NGP_TTYPE_INT		(3)			/* starting with digit and not with '.' */
#define	NGP_TTYPE_REAL		(4)			/* digits + '.' */
#define	NGP_TTYPE_COMPLEX	(5)			/* 2 reals, separated with ',' */
#define	NGP_TTYPE_NULL		(6)			/* NULL token, format is : NAME = / comment */
#define	NGP_TTYPE_RAW		(7)			/* HISTORY/COMMENT/8SPACES + comment string without / */

#define	NGP_FOUND_EQUAL_SIGN	(1)			/* line contains '=' after keyword name */

#define	NGP_FORMAT_OK		(0)			/* line format OK */
#define	NGP_FORMAT_ERROR	(1)			/* line format error */

#define	NGP_NODE_INVALID	(0)			/* default node type - invalid (to catch errors) */
#define	NGP_NODE_IMAGE		(1)			/* IMAGE type */
#define	NGP_NODE_ATABLE		(2)			/* ASCII table type */
#define	NGP_NODE_BTABLE		(3)			/* BINARY table type */

#define	NGP_NON_SYSTEM_ONLY	(0)			/* save all keywords except NAXIS,BITPIX,etc.. */
#define	NGP_REALLY_ALL		(1)			/* save really all keywords */

#define	NGP_XTENSION_SIMPLE	(1)			/* HDU defined with SIMPLE T */
#define	NGP_XTENSION_FIRST	(2)			/* this is first extension in template */

#define	NGP_LINE_REREAD		(1)			/* reread line */

#define	NGP_BITPIX_INVALID	(-12345)		/* default BITPIX (to catch errors) */

	/* common macro definitions */

#ifdef	NGP_PARSER_DEBUG_MALLOC

#define	ngp_alloc(x)		dal_malloc(x)
#define	ngp_free(x)		dal_free(x)
#define	ngp_realloc(x,y)	dal_realloc(x,y)

#else

#define	ngp_alloc(x)		malloc(x)
#define	ngp_free(x)		free(x)
#define	ngp_realloc(x,y)	realloc(x,y)

#endif

	/* type definitions */

typedef struct NGP_RAW_LINE_STRUCT
      {	char	*line;
	char	*name;
	char	*value;
	int	type;
	char	*comment;
	int	format;
	int	flags;
      } NGP_RAW_LINE;


typedef union NGP_TOKVAL_UNION
      {	char	*s;		/* space allocated separately, be careful !!! */
	char	b;
	int	i;
	double	d;
	struct NGP_COMPLEX_STRUCT
	 { double re;
	   double im;
	 } c;			/* complex value */
      } NGP_TOKVAL;


typedef struct NGP_TOKEN_STRUCT
      { int		type;
        char		name[NGP_MAX_NAME];
        NGP_TOKVAL	value;
        char		comment[NGP_MAX_COMMENT];
      } NGP_TOKEN;


typedef struct NGP_HDU_STRUCT
      {	int		tokcnt;
        NGP_TOKEN	*tok;
      } NGP_HDU;


typedef struct NGP_TKDEF_STRUCT
      {	char	*name;
	int	code;
      } NGP_TKDEF;


typedef struct NGP_EXTVER_TAB_STRUCT
      {	char	*extname;
	int	version;
      } NGP_EXTVER_TAB;


	/* globally visible variables declarations */

extern	NGP_RAW_LINE	ngp_curline;
extern	NGP_RAW_LINE	ngp_prevline;

extern	int		ngp_extver_tab_size;
extern	NGP_EXTVER_TAB	*ngp_extver_tab;


	/* globally visible functions declarations */

int	ngp_get_extver(char *extname, int *version);
int	ngp_set_extver(char *extname, int version);
int	ngp_delete_extver_tab(void);
int	ngp_strcasecmp(char *p1, char *p2);
int	ngp_strcasencmp(char *p1, char *p2, int n);
int	ngp_line_from_file(FILE *fp, char **p);
int	ngp_free_line(void);
int	ngp_free_prevline(void);
int	ngp_read_line_buffered(FILE *fp);
int	ngp_unread_line(void);
int	ngp_extract_tokens(NGP_RAW_LINE *cl);
int	ngp_include_file(char *fname);
int	ngp_read_line(int ignore_blank_lines);
int	ngp_keyword_is_write(NGP_TOKEN *ngp_tok);
int     ngp_keyword_all_write(NGP_HDU *ngph, fitsfile *ffp, int mode);
int	ngp_hdu_init(NGP_HDU *ngph);
int	ngp_hdu_clear(NGP_HDU *ngph);
int	ngp_hdu_insert_token(NGP_HDU *ngph, NGP_TOKEN *newtok);
int	ngp_append_columns(fitsfile *ff, NGP_HDU *ngph, int aftercol);
int	ngp_read_xtension(fitsfile *ff, int parent_hn, int simple_mode);
int	ngp_read_group(fitsfile *ff, char *grpname, int parent_hn);

		/* top level API function - now defined in fitsio.h */

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/cfitsio/histo.c0000664000175000017500000022162313010375005016260 0ustar  zoncazonca00000000000000/*   Globally defined histogram parameters */
#include 
#include 
#include 
#include 
#include "fitsio2.h"

typedef struct {  /*  Structure holding all the histogramming information   */
   union {        /*  the iterator work functions (ffwritehist, ffcalchist) */
      char   *b;  /*  need to do their job... passed via *userPointer.      */
      short  *i;
      int    *j;
      float  *r;
      double *d;
   } hist;

   fitsfile *tblptr;

   int   haxis, hcolnum[4], himagetype;
   long  haxis1, haxis2, haxis3, haxis4;
   float amin1, amin2, amin3, amin4;
   float maxbin1, maxbin2, maxbin3, maxbin4;
   float binsize1, binsize2, binsize3, binsize4;
   int   wtrecip, wtcolnum;
   float weight;
   char  *rowselector;

} histType;

/*--------------------------------------------------------------------------*/
int ffbins(char *binspec,   /* I - binning specification */
                   int *imagetype,      /* O - image type, TINT or TSHORT */
                   int *histaxis,       /* O - no. of axes in the histogram */
                   char colname[4][FLEN_VALUE],  /* column name for axis */
                   double *minin,        /* minimum value for each axis */
                   double *maxin,        /* maximum value for each axis */
                   double *binsizein,    /* size of bins on each axis */
                   char minname[4][FLEN_VALUE],  /* keyword name for min */
                   char maxname[4][FLEN_VALUE],  /* keyword name for max */
                   char binname[4][FLEN_VALUE],  /* keyword name for binsize */
                   double *wt,          /* weighting factor          */
                   char *wtname,        /* keyword or column name for weight */
                   int *recip,          /* the reciprocal of the weight? */
                   int *status)
{
/*
   Parse the input binning specification string, returning the binning
   parameters.  Supports up to 4 dimensions.  The binspec string has
   one of these forms:

   bin binsize                  - 2D histogram with binsize on each axis
   bin xcol                     - 1D histogram on column xcol
   bin (xcol, ycol) = binsize   - 2D histogram with binsize on each axis
   bin x=min:max:size, y=min:max:size, z..., t... 
   bin x=:max, y=::size
   bin x=size, y=min::size

   most other reasonable combinations are supported.        
*/
    int ii, slen, defaulttype;
    char *ptr, tmpname[30], *file_expr = NULL;
    double  dummy;

    if (*status > 0)
         return(*status);

    /* set the default values */
    *histaxis = 2;
    *imagetype = TINT;
    defaulttype = 1;
    *wt = 1.;
    *recip = 0;
    *wtname = '\0';

    /* set default values */
    for (ii = 0; ii < 4; ii++)
    {
        *colname[ii] = '\0';
        *minname[ii] = '\0';
        *maxname[ii] = '\0';
        *binname[ii] = '\0';
        minin[ii] = DOUBLENULLVALUE;  /* undefined values */
        maxin[ii] = DOUBLENULLVALUE;
        binsizein[ii] = DOUBLENULLVALUE;
    }

    ptr = binspec + 3;  /* skip over 'bin' */

    if (*ptr == 'i' )  /* bini */
    {
        *imagetype = TSHORT;
        defaulttype = 0;
        ptr++;
    }
    else if (*ptr == 'j' )  /* binj; same as default */
    {
        defaulttype = 0;
        ptr ++;
    }
    else if (*ptr == 'r' )  /* binr */
    {
        *imagetype = TFLOAT;
        defaulttype = 0;
        ptr ++;
    }
    else if (*ptr == 'd' )  /* bind */
    {
        *imagetype = TDOUBLE;
        defaulttype = 0;
        ptr ++;
    }
    else if (*ptr == 'b' )  /* binb */
    {
        *imagetype = TBYTE;
        defaulttype = 0;
        ptr ++;
    }

    if (*ptr == '\0')  /* use all defaults for other parameters */
        return(*status);
    else if (*ptr != ' ')  /* must be at least one blank */
    {
        ffpmsg("binning specification syntax error:");
        ffpmsg(binspec);
        return(*status = URL_PARSE_ERROR);
    }

    while (*ptr == ' ')  /* skip over blanks */
           ptr++;

    if (*ptr == '\0')   /* no other parameters; use defaults */
        return(*status);

    /* Check if need to import expression from a file */

    if( *ptr=='@' ) {
       if( ffimport_file( ptr+1, &file_expr, status ) ) return(*status);
       ptr = file_expr;
       while (*ptr == ' ')
               ptr++;       /* skip leading white space... again */
    }

    if (*ptr == '(' )
    {
        /* this must be the opening parenthesis around a list of column */
        /* names, optionally followed by a '=' and the binning spec. */

        for (ii = 0; ii < 4; ii++)
        {
            ptr++;               /* skip over the '(', ',', or ' ') */
            while (*ptr == ' ')  /* skip over blanks */
                ptr++;

            slen = strcspn(ptr, " ,)");
            strncat(colname[ii], ptr, slen); /* copy 1st column name */

            ptr += slen;
            while (*ptr == ' ')  /* skip over blanks */
                ptr++;

            if (*ptr == ')' )   /* end of the list of names */
            {
                *histaxis = ii + 1;
                break;
            }
        }

        if (ii == 4)   /* too many names in the list , or missing ')'  */
        {
            ffpmsg(
 "binning specification has too many column names or is missing closing ')':");
            ffpmsg(binspec);
	    if( file_expr ) free( file_expr );
            return(*status = URL_PARSE_ERROR);
        }

        ptr++;  /* skip over the closing parenthesis */
        while (*ptr == ' ')  /* skip over blanks */
            ptr++;

        if (*ptr == '\0') {
	    if( file_expr ) free( file_expr );
            return(*status);  /* parsed the entire string */
	}

        else if (*ptr != '=')  /* must be an equals sign now*/
        {
            ffpmsg("illegal binning specification in URL:");
            ffpmsg(" an equals sign '=' must follow the column names");
            ffpmsg(binspec);
	    if( file_expr ) free( file_expr );
            return(*status = URL_PARSE_ERROR);
        }

        ptr++;  /* skip over the equals sign */
        while (*ptr == ' ')  /* skip over blanks */
            ptr++;

        /* get the single range specification for all the columns */
        ffbinr(&ptr, tmpname, minin,
                                     maxin, binsizein, minname[0],
                                     maxname[0], binname[0], status);
        if (*status > 0)
        {
            ffpmsg("illegal binning specification in URL:");
            ffpmsg(binspec);
	    if( file_expr ) free( file_expr );
            return(*status);
        }

        for (ii = 1; ii < *histaxis; ii++)
        {
            minin[ii] = minin[0];
            maxin[ii] = maxin[0];
            binsizein[ii] = binsizein[0];
            strcpy(minname[ii], minname[0]);
            strcpy(maxname[ii], maxname[0]);
            strcpy(binname[ii], binname[0]);
        }

        while (*ptr == ' ')  /* skip over blanks */
            ptr++;

        if (*ptr == ';')
            goto getweight;   /* a weighting factor is specified */

        if (*ptr != '\0')  /* must have reached end of string */
        {
            ffpmsg("illegal syntax after binning range specification in URL:");
            ffpmsg(binspec);
	    if( file_expr ) free( file_expr );
            return(*status = URL_PARSE_ERROR);
        }

        return(*status);
    }             /* end of case with list of column names in ( )  */

    /* if we've reached this point, then the binning specification */
    /* must be of the form: XCOL = min:max:binsize, YCOL = ...     */
    /* where the column name followed by '=' are optional.         */
    /* If the column name is not specified, then use the default name */

    for (ii = 0; ii < 4; ii++) /* allow up to 4 histogram dimensions */
    {
        ffbinr(&ptr, colname[ii], &minin[ii],
                                     &maxin[ii], &binsizein[ii], minname[ii],
                                     maxname[ii], binname[ii], status);

        if (*status > 0)
        {
            ffpmsg("illegal syntax in binning range specification in URL:");
            ffpmsg(binspec);
	    if( file_expr ) free( file_expr );
            return(*status);
        }

        if (*ptr == '\0' || *ptr == ';')
            break;        /* reached the end of the string */

        if (*ptr == ' ')
        {
            while (*ptr == ' ')  /* skip over blanks */
                ptr++;

            if (*ptr == '\0' || *ptr == ';')
                break;        /* reached the end of the string */

            if (*ptr == ',')
                ptr++;  /* comma separates the next column specification */
        }
        else if (*ptr == ',')
        {          
            ptr++;  /* comma separates the next column specification */
        }
        else
        {
            ffpmsg("illegal characters following binning specification in URL:");
            ffpmsg(binspec);
	    if( file_expr ) free( file_expr );
            return(*status = URL_PARSE_ERROR);
        }
    }

    if (ii == 4)
    {
        /* there are yet more characters in the string */
        ffpmsg("illegal binning specification in URL:");
        ffpmsg("apparently greater than 4 histogram dimensions");
        ffpmsg(binspec);
        return(*status = URL_PARSE_ERROR);
    }
    else
        *histaxis = ii + 1;

    /* special case: if a single number was entered it should be      */
    /* interpreted as the binning factor for the default X and Y axes */

    if (*histaxis == 1 && *colname[0] == '\0' && 
         minin[0] == DOUBLENULLVALUE && maxin[0] == DOUBLENULLVALUE)
    {
        *histaxis = 2;
        binsizein[1] = binsizein[0];
    }

getweight:
    if (*ptr == ';')  /* looks like a weighting factor is given */
    {
        ptr++;
       
        while (*ptr == ' ')  /* skip over blanks */
            ptr++;

        recip = 0;
        if (*ptr == '/')
        {
            *recip = 1;  /* the reciprocal of the weight is entered */
            ptr++;

            while (*ptr == ' ')  /* skip over blanks */
                ptr++;
        }

        /* parse the weight as though it were a binrange. */
        /* either a column name or a numerical value will be returned */

        ffbinr(&ptr, wtname, &dummy, &dummy, wt, tmpname,
                                     tmpname, tmpname, status);

        if (*status > 0)
        {
            ffpmsg("illegal binning weight specification in URL:");
            ffpmsg(binspec);
	    if( file_expr ) free( file_expr );
            return(*status);
        }

        /* creat a float datatype histogram by default, if weight */
        /* factor is not = 1.0  */

        if ( (defaulttype && *wt != 1.0) || (defaulttype && *wtname) )
            *imagetype = TFLOAT;
    }

    while (*ptr == ' ')  /* skip over blanks */
         ptr++;

    if (*ptr != '\0')  /* should have reached the end of string */
    {
        ffpmsg("illegal syntax after binning weight specification in URL:");
        ffpmsg(binspec);
        *status = URL_PARSE_ERROR;
    }

    if( file_expr ) free( file_expr );
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffbinr(char **ptr, 
                   char *colname, 
                   double *minin,
                   double *maxin, 
                   double *binsizein,
                   char *minname,
                   char *maxname,
                   char *binname,
                   int *status)
/*
   Parse the input binning range specification string, returning 
   the column name, histogram min and max values, and bin size.
*/
{
    int slen, isanumber;
    char token[FLEN_VALUE];

    if (*status > 0)
        return(*status);

    slen = fits_get_token(ptr, " ,=:;", token, &isanumber); /* get 1st token */

    if (slen == 0 && (**ptr == '\0' || **ptr == ',' || **ptr == ';') )
        return(*status);   /* a null range string */

    if (!isanumber && **ptr != ':')
    {
        /* this looks like the column name */

        if (token[0] == '#' && isdigit((int) token[1]) )
        {
            /* omit the leading '#' in the column number */
            strcpy(colname, token+1);
        }
        else
            strcpy(colname, token);

        while (**ptr == ' ')  /* skip over blanks */
             (*ptr)++;

        if (**ptr != '=')
            return(*status);  /* reached the end */

        (*ptr)++;   /* skip over the = sign */

        while (**ptr == ' ')  /* skip over blanks */
             (*ptr)++;

        slen = fits_get_token(ptr, " ,:;", token, &isanumber); /* get token */
    }

    if (**ptr != ':')
    {
        /* this is the first token, and since it is not followed by */
        /* a ':' this must be the binsize token */
        if (!isanumber)
            strcpy(binname, token);
        else
            *binsizein =  strtod(token, NULL);

        return(*status);  /* reached the end */
    }
    else
    {
        /* the token contains the min value */
        if (slen)
        {
            if (!isanumber)
                strcpy(minname, token);
            else
                *minin = strtod(token, NULL);
        }
    }

    (*ptr)++;  /* skip the colon between the min and max values */
    slen = fits_get_token(ptr, " ,:;", token, &isanumber); /* get token */

    /* the token contains the max value */
    if (slen)
    {
        if (!isanumber)
            strcpy(maxname, token);
        else
            *maxin = strtod(token, NULL);
    }

    if (**ptr != ':')
        return(*status);  /* reached the end; no binsize token */

    (*ptr)++;  /* skip the colon between the max and binsize values */
    slen = fits_get_token(ptr, " ,:;", token, &isanumber); /* get token */

    /* the token contains the binsize value */
    if (slen)
    {
        if (!isanumber)
            strcpy(binname, token);
        else
            *binsizein = strtod(token, NULL);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffhist2(fitsfile **fptr,  /* IO - pointer to table with X and Y cols;    */
                             /*     on output, points to histogram image    */
           char *outfile,    /* I - name for the output histogram file      */
           int imagetype,    /* I - datatype for image: TINT, TSHORT, etc   */
           int naxis,        /* I - number of axes in the histogram image   */
           char colname[4][FLEN_VALUE],   /* I - column names               */
           double *minin,     /* I - minimum histogram value, for each axis */
           double *maxin,     /* I - maximum histogram value, for each axis */
           double *binsizein, /* I - bin size along each axis               */
           char minname[4][FLEN_VALUE], /* I - optional keywords for min    */
           char maxname[4][FLEN_VALUE], /* I - optional keywords for max    */
           char binname[4][FLEN_VALUE], /* I - optional keywords for binsize */
           double weightin,        /* I - binning weighting factor          */
           char wtcol[FLEN_VALUE], /* I - optional keyword or col for weight*/
           int recip,              /* I - use reciprocal of the weight?     */
           char *selectrow,        /* I - optional array (length = no. of   */
                             /* rows in the table).  If the element is true */
                             /* then the corresponding row of the table will*/
                             /* be included in the histogram, otherwise the */
                             /* row will be skipped.  Ingnored if *selectrow*/
                             /* is equal to NULL.                           */
           int *status)
{
    fitsfile *histptr;
    int   bitpix, colnum[4], wtcolnum;
    long haxes[4];
    float amin[4], amax[4], binsize[4],  weight;

    if (*status > 0)
        return(*status);

    if (naxis > 4)
    {
        ffpmsg("histogram has more than 4 dimensions");
        return(*status = BAD_DIMEN);
    }

    /* reset position to the correct HDU if necessary */
    if ((*fptr)->HDUposition != ((*fptr)->Fptr)->curhdu)
        ffmahd(*fptr, ((*fptr)->HDUposition) + 1, NULL, status);

    if (imagetype == TBYTE)
        bitpix = BYTE_IMG;
    else if (imagetype == TSHORT)
        bitpix = SHORT_IMG;
    else if (imagetype == TINT)
        bitpix = LONG_IMG;
    else if (imagetype == TFLOAT)
        bitpix = FLOAT_IMG;
    else if (imagetype == TDOUBLE)
        bitpix = DOUBLE_IMG;
    else
        return(*status = BAD_DATATYPE);

    
    /*    Calculate the binning parameters:    */
    /*   columm numbers, axes length, min values,  max values, and binsizes.  */

    if (fits_calc_binning(
      *fptr, naxis, colname, minin, maxin, binsizein, minname, maxname, binname,
      colnum,  haxes, amin, amax, binsize, status) > 0)
    {
        ffpmsg("failed to determine binning parameters");
        return(*status);
    }
 
    /* get the histogramming weighting factor, if any */
    if (*wtcol)
    {
        /* first, look for a keyword with the weight value */
        if (ffgky(*fptr, TFLOAT, wtcol, &weight, NULL, status) )
        {
            /* not a keyword, so look for column with this name */
            *status = 0;

            /* get the column number in the table */
            if (ffgcno(*fptr, CASEINSEN, wtcol, &wtcolnum, status) > 0)
            {
               ffpmsg(
               "keyword or column for histogram weights doesn't exist: ");
               ffpmsg(wtcol);
               return(*status);
            }

            weight = FLOATNULLVALUE;
        }
    }
    else
        weight = (float) weightin;

    if (weight <= 0. && weight != FLOATNULLVALUE)
    {
        ffpmsg("Illegal histogramming weighting factor <= 0.");
        return(*status = URL_PARSE_ERROR);
    }

    if (recip && weight != FLOATNULLVALUE)
       /* take reciprocal of weight */
       weight = (float) (1.0 / weight);

    /* size of histogram is now known, so create temp output file */
    if (fits_create_file(&histptr, outfile, status) > 0)
    {
        ffpmsg("failed to create temp output file for histogram");
        return(*status);
    }

    /* create output FITS image HDU */
    if (ffcrim(histptr, bitpix, naxis, haxes, status) > 0)
    {
        ffpmsg("failed to create output histogram FITS image");
        return(*status);
    }

    /* copy header keywords, converting pixel list WCS keywords to image WCS form */
    if (fits_copy_pixlist2image(*fptr, histptr, 9, naxis, colnum, status) > 0)
    {
        ffpmsg("failed to copy pixel list keywords to new histogram header");
        return(*status);
    }

    /* if the table columns have no WCS keywords, then write default keywords */
    fits_write_keys_histo(*fptr, histptr, naxis, colnum, status);
    
    /* update the WCS keywords for the ref. pixel location, and pixel size */
    fits_rebin_wcs(histptr, naxis, amin, binsize,  status);      
    
    /* now compute the output image by binning the column values */
    if (fits_make_hist(*fptr, histptr, bitpix, naxis, haxes, colnum, amin, amax,
        binsize, weight, wtcolnum, recip, selectrow, status) > 0)
    {
        ffpmsg("failed to calculate new histogram values");
        return(*status);
    }
              
    /* finally, close the original file and return ptr to the new image */
    ffclos(*fptr, status);
    *fptr = histptr;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffhist(fitsfile **fptr,  /* IO - pointer to table with X and Y cols;    */
                             /*     on output, points to histogram image    */
           char *outfile,    /* I - name for the output histogram file      */
           int imagetype,    /* I - datatype for image: TINT, TSHORT, etc   */
           int naxis,        /* I - number of axes in the histogram image   */
           char colname[4][FLEN_VALUE],   /* I - column names               */
           double *minin,     /* I - minimum histogram value, for each axis */
           double *maxin,     /* I - maximum histogram value, for each axis */
           double *binsizein, /* I - bin size along each axis               */
           char minname[4][FLEN_VALUE], /* I - optional keywords for min    */
           char maxname[4][FLEN_VALUE], /* I - optional keywords for max    */
           char binname[4][FLEN_VALUE], /* I - optional keywords for binsize */
           double weightin,        /* I - binning weighting factor          */
           char wtcol[FLEN_VALUE], /* I - optional keyword or col for weight*/
           int recip,              /* I - use reciprocal of the weight?     */
           char *selectrow,        /* I - optional array (length = no. of   */
                             /* rows in the table).  If the element is true */
                             /* then the corresponding row of the table will*/
                             /* be included in the histogram, otherwise the */
                             /* row will be skipped.  Ingnored if *selectrow*/
                             /* is equal to NULL.                           */
           int *status)
{
    int ii, datatype, repeat, imin, imax, ibin, bitpix, tstatus, use_datamax = 0;
    long haxes[4];
    fitsfile *histptr;
    char errmsg[FLEN_ERRMSG], keyname[FLEN_KEYWORD], card[FLEN_CARD];
    tcolumn *colptr;
    iteratorCol imagepars[1];
    int n_cols = 1, nkeys;
    long  offset = 0;
    long n_per_loop = -1;  /* force whole array to be passed at one time */
    histType histData;    /* Structure holding histogram info for iterator */
    
    float amin[4], amax[4], binsize[4], maxbin[4];
    float datamin = FLOATNULLVALUE, datamax = FLOATNULLVALUE;
    char svalue[FLEN_VALUE];
    double dvalue;
    char cpref[4][FLEN_VALUE];
    char *cptr;

    if (*status > 0)
        return(*status);

    if (naxis > 4)
    {
        ffpmsg("histogram has more than 4 dimensions");
        return(*status = BAD_DIMEN);
    }

    /* reset position to the correct HDU if necessary */
    if ((*fptr)->HDUposition != ((*fptr)->Fptr)->curhdu)
        ffmahd(*fptr, ((*fptr)->HDUposition) + 1, NULL, status);

    histData.tblptr     = *fptr;
    histData.himagetype = imagetype;
    histData.haxis      = naxis;
    histData.rowselector = selectrow;

    if (imagetype == TBYTE)
        bitpix = BYTE_IMG;
    else if (imagetype == TSHORT)
        bitpix = SHORT_IMG;
    else if (imagetype == TINT)
        bitpix = LONG_IMG;
    else if (imagetype == TFLOAT)
        bitpix = FLOAT_IMG;
    else if (imagetype == TDOUBLE)
        bitpix = DOUBLE_IMG;
    else
        return(*status = BAD_DATATYPE);

    /* The CPREF keyword, if it exists, gives the preferred columns. */
    /* Otherwise, assume "X", "Y", "Z", and "T"  */

    tstatus = 0;
    ffgky(*fptr, TSTRING, "CPREF", cpref[0], NULL, &tstatus);

    if (!tstatus)
    {
        /* Preferred column names are given;  separate them */
        cptr = cpref[0];

        /* the first preferred axis... */
        while (*cptr != ',' && *cptr != '\0')
           cptr++;

        if (*cptr != '\0')
        {
           *cptr = '\0';
           cptr++;
           while (*cptr == ' ')
               cptr++;

           strcpy(cpref[1], cptr);
           cptr = cpref[1];

          /* the second preferred axis... */
          while (*cptr != ',' && *cptr != '\0')
             cptr++;

          if (*cptr != '\0')
          {
             *cptr = '\0';
             cptr++;
             while (*cptr == ' ')
                 cptr++;

             strcpy(cpref[2], cptr);
             cptr = cpref[2];

            /* the third preferred axis... */
            while (*cptr != ',' && *cptr != '\0')
               cptr++;

            if (*cptr != '\0')
            {
               *cptr = '\0';
               cptr++;
               while (*cptr == ' ')
                   cptr++;

               strcpy(cpref[3], cptr);

            }
          }
        }
    }

    for (ii = 0; ii < naxis; ii++)
    {

      /* get the min, max, and binsize values from keywords, if specified */

      if (*minname[ii])
      {
         if (ffgky(*fptr, TDOUBLE, minname[ii], &minin[ii], NULL, status) )
         {
             ffpmsg("error reading histogramming minimum keyword");
             ffpmsg(minname[ii]);
             return(*status);
         }
      }

      if (*maxname[ii])
      {
         if (ffgky(*fptr, TDOUBLE, maxname[ii], &maxin[ii], NULL, status) )
         {
             ffpmsg("error reading histogramming maximum keyword");
             ffpmsg(maxname[ii]);
             return(*status);
         }
      }

      if (*binname[ii])
      {
         if (ffgky(*fptr, TDOUBLE, binname[ii], &binsizein[ii], NULL, status) )
         {
             ffpmsg("error reading histogramming binsize keyword");
             ffpmsg(binname[ii]);
             return(*status);
         }
      }

      if (binsizein[ii] == 0.)
      {
        ffpmsg("error: histogram binsize = 0");
        return(*status = ZERO_SCALE);
      }

      if (*colname[ii] == '\0')
      {
         strcpy(colname[ii], cpref[ii]); /* try using the preferred column */
         if (*colname[ii] == '\0')
         {
           if (ii == 0)
              strcpy(colname[ii], "X");
           else if (ii == 1)
              strcpy(colname[ii], "Y");
           else if (ii == 2)
              strcpy(colname[ii], "Z");
           else if (ii == 3)
              strcpy(colname[ii], "T");
         }
      }

      /* get the column number in the table */
      if (ffgcno(*fptr, CASEINSEN, colname[ii], histData.hcolnum+ii, status)
              > 0)
      {
        strcpy(errmsg, "column for histogram axis doesn't exist: ");
        strcat(errmsg, colname[ii]);
        ffpmsg(errmsg);
        return(*status);
      }

      colptr = ((*fptr)->Fptr)->tableptr;
      colptr += (histData.hcolnum[ii] - 1);

      repeat = (int) colptr->trepeat;  /* vector repeat factor of the column */
      if (repeat > 1)
      {
        strcpy(errmsg, "Can't bin a vector column: ");
        strcat(errmsg, colname[ii]);
        ffpmsg(errmsg);
        return(*status = BAD_DATATYPE);
      }

      /* get the datatype of the column */
      fits_get_coltype(*fptr, histData.hcolnum[ii], &datatype,
         NULL, NULL, status);

      if (datatype < 0 || datatype == TSTRING)
      {
        strcpy(errmsg, "Inappropriate datatype; can't bin this column: ");
        strcat(errmsg, colname[ii]);
        ffpmsg(errmsg);
        return(*status = BAD_DATATYPE);
      }

      /* use TLMINn and TLMAXn keyword values if min and max were not given */
      /* else use actual data min and max if TLMINn and TLMAXn don't exist */
 
      if (minin[ii] == DOUBLENULLVALUE)
      {
        ffkeyn("TLMIN", histData.hcolnum[ii], keyname, status);
        if (ffgky(*fptr, TFLOAT, keyname, amin+ii, NULL, status) > 0)
        {
            /* use actual data minimum value for the histogram minimum */
            *status = 0;
            if (fits_get_col_minmax(*fptr, histData.hcolnum[ii], amin+ii, &datamax, status) > 0)
            {
                strcpy(errmsg, "Error calculating datamin and datamax for column: ");
                strcat(errmsg, colname[ii]);
                ffpmsg(errmsg);
                return(*status);
            }
         }
      }
      else
      {
        amin[ii] = (float) minin[ii];
      }

      if (maxin[ii] == DOUBLENULLVALUE)
      {
        ffkeyn("TLMAX", histData.hcolnum[ii], keyname, status);
        if (ffgky(*fptr, TFLOAT, keyname, &amax[ii], NULL, status) > 0)
        {
          *status = 0;
          if(datamax != FLOATNULLVALUE)  /* already computed max value */
          {
             amax[ii] = datamax;
          }
          else
          {
             /* use actual data maximum value for the histogram maximum */
             if (fits_get_col_minmax(*fptr, histData.hcolnum[ii], &datamin, &amax[ii], status) > 0)
             {
                 strcpy(errmsg, "Error calculating datamin and datamax for column: ");
                 strcat(errmsg, colname[ii]);
                 ffpmsg(errmsg);
                 return(*status);
             }
          }
        }
        use_datamax = 1;  /* flag that the max was determined by the data values */
                          /* and not specifically set by the calling program */
      }
      else
      {
        amax[ii] = (float) maxin[ii];
      }

      /* use TDBINn keyword or else 1 if bin size is not given */
      if (binsizein[ii] == DOUBLENULLVALUE)
      {
         tstatus = 0;
         ffkeyn("TDBIN", histData.hcolnum[ii], keyname, &tstatus);

         if (ffgky(*fptr, TDOUBLE, keyname, binsizein + ii, NULL, &tstatus) > 0)
         {
	    /* make at least 10 bins */
            binsizein[ii] = (amax[ii] - amin[ii]) / 10. ;
            if (binsizein[ii] > 1.)
                binsizein[ii] = 1.;  /* use default bin size */
         }
      }

      if ( (amin[ii] > amax[ii] && binsizein[ii] > 0. ) ||
           (amin[ii] < amax[ii] && binsizein[ii] < 0. ) )
          binsize[ii] = (float) -binsizein[ii];  /* reverse the sign of binsize */
      else
          binsize[ii] =  (float) binsizein[ii];  /* binsize has the correct sign */

      ibin = (int) binsize[ii];
      imin = (int) amin[ii];
      imax = (int) amax[ii];

      /* Determine the range and number of bins in the histogram. This  */
      /* depends on whether the input columns are integer or floats, so */
      /* treat each case separately.                                    */

      if (datatype <= TLONG && (float) imin == amin[ii] &&
                               (float) imax == amax[ii] &&
                               (float) ibin == binsize[ii] )
      {
        /* This is an integer column and integer limits were entered. */
        /* Shift the lower and upper histogramming limits by 0.5, so that */
        /* the values fall in the center of the bin, not on the edge. */

        haxes[ii] = (imax - imin) / ibin + 1;  /* last bin may only */
                                               /* be partially full */
        maxbin[ii] = (float) (haxes[ii] + 1.);  /* add 1. instead of .5 to avoid roundoff */

        if (amin[ii] < amax[ii])
        {
          amin[ii] = (float) (amin[ii] - 0.5);
          amax[ii] = (float) (amax[ii] + 0.5);
        }
        else
        {
          amin[ii] = (float) (amin[ii] + 0.5);
          amax[ii] = (float) (amax[ii] - 0.5);
        }
      }
      else if (use_datamax)  
      {
        /* Either the column datatype and/or the limits are floating point, */
        /* and the histogram limits are being defined by the min and max */
        /* values of the array.  Add 1 to the number of histogram bins to */
        /* make sure that pixels that are equal to the maximum or are */
        /* in the last partial bin are included.  */

        maxbin[ii] = (amax[ii] - amin[ii]) / binsize[ii]; 
        haxes[ii] = (long) (maxbin[ii] + 1);
      }
      else  
      {
        /*  float datatype column and/or limits, and the maximum value to */
        /*  include in the histogram is specified by the calling program. */
        /*  The lower limit is inclusive, but upper limit is exclusive    */
        maxbin[ii] = (amax[ii] - amin[ii]) / binsize[ii];
        haxes[ii] = (long) maxbin[ii];

        if (amin[ii] < amax[ii])
        {
          if (amin[ii] + (haxes[ii] * binsize[ii]) < amax[ii])
            haxes[ii]++;   /* need to include another partial bin */
        }
        else
        {
          if (amin[ii] + (haxes[ii] * binsize[ii]) > amax[ii])
            haxes[ii]++;   /* need to include another partial bin */
        }
      }
    }

       /* get the histogramming weighting factor */
    if (*wtcol)
    {
        /* first, look for a keyword with the weight value */
        if (ffgky(*fptr, TFLOAT, wtcol, &histData.weight, NULL, status) )
        {
            /* not a keyword, so look for column with this name */
            *status = 0;

            /* get the column number in the table */
            if (ffgcno(*fptr, CASEINSEN, wtcol, &histData.wtcolnum, status) > 0)
            {
               ffpmsg(
               "keyword or column for histogram weights doesn't exist: ");
               ffpmsg(wtcol);
               return(*status);
            }

            histData.weight = FLOATNULLVALUE;
        }
    }
    else
        histData.weight = (float) weightin;

    if (histData.weight <= 0. && histData.weight != FLOATNULLVALUE)
    {
        ffpmsg("Illegal histogramming weighting factor <= 0.");
        return(*status = URL_PARSE_ERROR);
    }

    if (recip && histData.weight != FLOATNULLVALUE)
       /* take reciprocal of weight */
       histData.weight = (float) (1.0 / histData.weight);

    histData.wtrecip = recip;
        
    /* size of histogram is now known, so create temp output file */
    if (ffinit(&histptr, outfile, status) > 0)
    {
        ffpmsg("failed to create temp output file for histogram");
        return(*status);
    }

    if (ffcrim(histptr, bitpix, histData.haxis, haxes, status) > 0)
    {
        ffpmsg("failed to create primary array histogram in temp file");
        ffclos(histptr, status);
        return(*status);
    }

    /* copy all non-structural keywords from the table to the image */
    fits_get_hdrspace(*fptr, &nkeys, NULL, status);
    for (ii = 1; ii <= nkeys; ii++)
    {
       fits_read_record(*fptr, ii, card, status);
       if (fits_get_keyclass(card) >= 120)
           fits_write_record(histptr, card, status);
    }           

    /* Set global variables with histogram parameter values.    */
    /* Use separate scalar variables rather than arrays because */
    /* it is more efficient when computing the histogram.       */

    histData.amin1 = amin[0];
    histData.maxbin1 = maxbin[0];
    histData.binsize1 = binsize[0];
    histData.haxis1 = haxes[0];

    if (histData.haxis > 1)
    {
      histData.amin2 = amin[1];
      histData.maxbin2 = maxbin[1];
      histData.binsize2 = binsize[1];
      histData.haxis2 = haxes[1];

      if (histData.haxis > 2)
      {
        histData.amin3 = amin[2];
        histData.maxbin3 = maxbin[2];
        histData.binsize3 = binsize[2];
        histData.haxis3 = haxes[2];

        if (histData.haxis > 3)
        {
          histData.amin4 = amin[3];
          histData.maxbin4 = maxbin[3];
          histData.binsize4 = binsize[3];
          histData.haxis4 = haxes[3];
        }
      }
    }

    /* define parameters of image for the iterator function */
    fits_iter_set_file(imagepars, histptr);        /* pointer to image */
    fits_iter_set_datatype(imagepars, imagetype);  /* image datatype   */
    fits_iter_set_iotype(imagepars, OutputCol);    /* image is output  */

    /* call the iterator function to write out the histogram image */
    if (fits_iterate_data(n_cols, imagepars, offset, n_per_loop,
                          ffwritehisto, (void*)&histData, status) )
         return(*status);

    /* write the World Coordinate System (WCS) keywords */
    /* create default values if WCS keywords are not present in the table */
    for (ii = 0; ii < histData.haxis; ii++)
    {
     /*  CTYPEn  */
       tstatus = 0;
       ffkeyn("TCTYP", histData.hcolnum[ii], keyname, &tstatus);
       ffgky(*fptr, TSTRING, keyname, svalue, NULL, &tstatus);
       if (tstatus)
       {               /* just use column name as the type */
          tstatus = 0;
          ffkeyn("TTYPE", histData.hcolnum[ii], keyname, &tstatus);
          ffgky(*fptr, TSTRING, keyname, svalue, NULL, &tstatus);
       }

       if (!tstatus)
       {
        ffkeyn("CTYPE", ii + 1, keyname, &tstatus);
        ffpky(histptr, TSTRING, keyname, svalue, "Coordinate Type", &tstatus);
       }
       else
          tstatus = 0;

     /*  CUNITn  */
       ffkeyn("TCUNI", histData.hcolnum[ii], keyname, &tstatus);
       ffgky(*fptr, TSTRING, keyname, svalue, NULL, &tstatus);
       if (tstatus)
       {         /* use the column units */
          tstatus = 0;
          ffkeyn("TUNIT", histData.hcolnum[ii], keyname, &tstatus);
          ffgky(*fptr, TSTRING, keyname, svalue, NULL, &tstatus);
       }

       if (!tstatus)
       {
        ffkeyn("CUNIT", ii + 1, keyname, &tstatus);
        ffpky(histptr, TSTRING, keyname, svalue, "Coordinate Units", &tstatus);
       }
       else
         tstatus = 0;

     /*  CRPIXn  - Reference Pixel  */
       ffkeyn("TCRPX", histData.hcolnum[ii], keyname, &tstatus);
       ffgky(*fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus);
       if (tstatus)
       {
         dvalue = 1.0; /* choose first pixel in new image as ref. pix. */
         tstatus = 0;
       }
       else
       {
           /* calculate locate of the ref. pix. in the new image */
           dvalue = (dvalue - amin[ii]) / binsize[ii] + .5;
       }

       ffkeyn("CRPIX", ii + 1, keyname, &tstatus);
       ffpky(histptr, TDOUBLE, keyname, &dvalue, "Reference Pixel", &tstatus);

     /*  CRVALn - Value at the location of the reference pixel */
       ffkeyn("TCRVL", histData.hcolnum[ii], keyname, &tstatus);
       ffgky(*fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus);
       if (tstatus)
       {
         /* calculate value at ref. pix. location (at center of 1st pixel) */
         dvalue = amin[ii] + binsize[ii]/2.;
         tstatus = 0;
       }

       ffkeyn("CRVAL", ii + 1, keyname, &tstatus);
       ffpky(histptr, TDOUBLE, keyname, &dvalue, "Reference Value", &tstatus);

     /*  CDELTn - unit size of pixels  */
       ffkeyn("TCDLT", histData.hcolnum[ii], keyname, &tstatus);
       ffgky(*fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus);
       if (tstatus)
       {
         dvalue = 1.0;  /* use default pixel size */
         tstatus = 0;
       }

       dvalue = dvalue * binsize[ii];
       ffkeyn("CDELT", ii + 1, keyname, &tstatus);
       ffpky(histptr, TDOUBLE, keyname, &dvalue, "Pixel size", &tstatus);

     /*  CROTAn - Rotation angle (degrees CCW)  */
     /*  There should only be a CROTA2 keyword, and only for 2+ D images */
       if (ii == 1)
       {
         ffkeyn("TCROT", histData.hcolnum[ii], keyname, &tstatus);
         ffgky(*fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus);
         if (!tstatus && dvalue != 0.)  /* only write keyword if angle != 0 */
         {
           ffkeyn("CROTA", ii + 1, keyname, &tstatus);
           ffpky(histptr, TDOUBLE, keyname, &dvalue,
                 "Rotation angle", &tstatus);
         }
         else
         {
            /* didn't find CROTA for the 2nd axis, so look for one */
            /* on the first axis */
           tstatus = 0;
           ffkeyn("TCROT", histData.hcolnum[0], keyname, &tstatus);
           ffgky(*fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus);
           if (!tstatus && dvalue != 0.)  /* only write keyword if angle != 0 */
           {
             dvalue *= -1.;   /* negate the value, because mirror image */
             ffkeyn("CROTA", ii + 1, keyname, &tstatus);
             ffpky(histptr, TDOUBLE, keyname, &dvalue,
                   "Rotation angle", &tstatus);
           }
         }
       }
    }

    /* convert any TPn_k keywords to PCi_j; the value remains unchanged */
    /* also convert any TCn_k to CDi_j; the value is modified by n binning size */
    /* This is a bit of a kludge, and only works for 2D WCS */

    if (histData.haxis == 2) {

      /* PC1_1 */
      tstatus = 0;
      ffkeyn("TP", histData.hcolnum[0], card, &tstatus);
      strcat(card,"_");
      ffkeyn(card, histData.hcolnum[0], keyname, &tstatus);
      ffgky(*fptr, TDOUBLE, keyname, &dvalue, card, &tstatus);
      if (!tstatus) 
         ffpky(histptr, TDOUBLE, "PC1_1", &dvalue, card, &tstatus);

      tstatus = 0;
      keyname[1] = 'C';
      ffgky(*fptr, TDOUBLE, keyname, &dvalue, card, &tstatus);
      if (!tstatus) {
         dvalue *=  binsize[0];
         ffpky(histptr, TDOUBLE, "CD1_1", &dvalue, card, &tstatus);
      }

      /* PC1_2 */
      tstatus = 0;
      ffkeyn("TP", histData.hcolnum[0], card, &tstatus);
      strcat(card,"_");
      ffkeyn(card, histData.hcolnum[1], keyname, &tstatus);
      ffgky(*fptr, TDOUBLE, keyname, &dvalue, card, &tstatus);
      if (!tstatus) 
         ffpky(histptr, TDOUBLE, "PC1_2", &dvalue, card, &tstatus);
 
      tstatus = 0;
      keyname[1] = 'C';
      ffgky(*fptr, TDOUBLE, keyname, &dvalue, card, &tstatus);
      if (!tstatus) {
        dvalue *=  binsize[0];
        ffpky(histptr, TDOUBLE, "CD1_2", &dvalue, card, &tstatus);
      }
       
      /* PC2_1 */
      tstatus = 0;
      ffkeyn("TP", histData.hcolnum[1], card, &tstatus);
      strcat(card,"_");
      ffkeyn(card, histData.hcolnum[0], keyname, &tstatus);
      ffgky(*fptr, TDOUBLE, keyname, &dvalue, card, &tstatus);
      if (!tstatus) 
         ffpky(histptr, TDOUBLE, "PC2_1", &dvalue, card, &tstatus);
 
      tstatus = 0;
      keyname[1] = 'C';
      ffgky(*fptr, TDOUBLE, keyname, &dvalue, card, &tstatus);
      if (!tstatus) {
         dvalue *=  binsize[1];
         ffpky(histptr, TDOUBLE, "CD2_1", &dvalue, card, &tstatus);
      }
       
       /* PC2_2 */
      tstatus = 0;
      ffkeyn("TP", histData.hcolnum[1], card, &tstatus);
      strcat(card,"_");
      ffkeyn(card, histData.hcolnum[1], keyname, &tstatus);
      ffgky(*fptr, TDOUBLE, keyname, &dvalue, card, &tstatus);
      if (!tstatus) 
         ffpky(histptr, TDOUBLE, "PC2_2", &dvalue, card, &tstatus);
        
      tstatus = 0;
      keyname[1] = 'C';
      ffgky(*fptr, TDOUBLE, keyname, &dvalue, card, &tstatus);
      if (!tstatus) {
         dvalue *=  binsize[1];
         ffpky(histptr, TDOUBLE, "CD2_2", &dvalue, card, &tstatus);
      }
    }   
       
    /* finally, close the original file and return ptr to the new image */
    ffclos(*fptr, status);
    *fptr = histptr;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_calc_binning(
      fitsfile *fptr,  /* IO - pointer to table to be binned      ;       */
      int naxis,       /* I - number of axes/columns in the binned image  */
      char colname[4][FLEN_VALUE],   /* I - optional column names         */
      double *minin,     /* I - optional lower bound value for each axis  */
      double *maxin,     /* I - optional upper bound value, for each axis */
      double *binsizein, /* I - optional bin size along each axis         */
      char minname[4][FLEN_VALUE], /* I - optional keywords for min       */
      char maxname[4][FLEN_VALUE], /* I - optional keywords for max       */
      char binname[4][FLEN_VALUE], /* I - optional keywords for binsize   */

    /* The returned parameters for each axis of the n-dimensional histogram are */

      int *colnum,     /* O - column numbers, to be binned */
      long *haxes,     /* O - number of bins in each histogram axis */
      float *amin,     /* O - lower bound of the histogram axes */
      float *amax,     /* O - upper bound of the histogram axes */
      float *binsize,  /* O - width of histogram bins/pixels on each axis */
      int *status)
/*_
    Calculate the actual binning parameters, based on various user input
    options.
*/
{
    tcolumn *colptr;
    char *cptr, cpref[4][FLEN_VALUE];
    char errmsg[FLEN_ERRMSG], keyname[FLEN_KEYWORD];
    int tstatus, ii;
    int datatype, repeat, imin, imax, ibin,  use_datamax = 0;
    float datamin, datamax;

    /* check inputs */
    
    if (*status > 0)
        return(*status);

    if (naxis > 4)
    {
        ffpmsg("histograms with more than 4 dimensions are not supported");
        return(*status = BAD_DIMEN);
    }

    /* reset position to the correct HDU if necessary */
    if ((fptr)->HDUposition != ((fptr)->Fptr)->curhdu)
        ffmahd(fptr, ((fptr)->HDUposition) + 1, NULL, status);
    
    /* ============================================================= */
    /* The CPREF keyword, if it exists, gives the preferred columns. */
    /* Otherwise, assume "X", "Y", "Z", and "T"  */

    *cpref[0] = '\0';
    *cpref[1] = '\0';
    *cpref[2] = '\0';
    *cpref[3] = '\0';

    tstatus = 0;
    ffgky(fptr, TSTRING, "CPREF", cpref[0], NULL, &tstatus);

    if (!tstatus)
    {
        /* Preferred column names are given;  separate them */
        cptr = cpref[0];

        /* the first preferred axis... */
        while (*cptr != ',' && *cptr != '\0')
           cptr++;

        if (*cptr != '\0')
        {
           *cptr = '\0';
           cptr++;
           while (*cptr == ' ')
               cptr++;

           strcpy(cpref[1], cptr);
           cptr = cpref[1];

          /* the second preferred axis... */
          while (*cptr != ',' && *cptr != '\0')
             cptr++;

          if (*cptr != '\0')
          {
             *cptr = '\0';
             cptr++;
             while (*cptr == ' ')
                 cptr++;

             strcpy(cpref[2], cptr);
             cptr = cpref[2];

            /* the third preferred axis... */
            while (*cptr != ',' && *cptr != '\0')
               cptr++;

            if (*cptr != '\0')
            {
               *cptr = '\0';
               cptr++;
               while (*cptr == ' ')
                   cptr++;

               strcpy(cpref[3], cptr);

            }
          }
        }
    }

    /* ============================================================= */
    /* Main Loop for calculating parameters for each column          */

    for (ii = 0; ii < naxis; ii++)
    {

      /* =========================================================== */
      /* Determine column Number, based on, in order of priority,
         1  input column name, or
	 2  name given by CPREF keyword, or
	 3  assume X, Y, Z and T for the name
      */
	  
      if (*colname[ii] == '\0')
      {
         strcpy(colname[ii], cpref[ii]); /* try using the preferred column */
         if (*colname[ii] == '\0')
         {
           if (ii == 0)
              strcpy(colname[ii], "X");
           else if (ii == 1)
              strcpy(colname[ii], "Y");
           else if (ii == 2)
              strcpy(colname[ii], "Z");
           else if (ii == 3)
              strcpy(colname[ii], "T");
         }
      }

      /* get the column number in the table */
      if (ffgcno(fptr, CASEINSEN, colname[ii], colnum+ii, status)
              > 0)
      {
          strcpy(errmsg, "column for histogram axis doesn't exist: ");
          strcat(errmsg, colname[ii]);
          ffpmsg(errmsg);
          return(*status);
      }

      /* ================================================================ */
      /* check tha column is not a vector or a string                     */

      colptr = ((fptr)->Fptr)->tableptr;
      colptr += (colnum[ii] - 1);

      repeat = (int) colptr->trepeat;  /* vector repeat factor of the column */
      if (repeat > 1)
      {
        strcpy(errmsg, "Can't bin a vector column: ");
        strcat(errmsg, colname[ii]);
        ffpmsg(errmsg);
        return(*status = BAD_DATATYPE);
      }

      /* get the datatype of the column */
      fits_get_coltype(fptr, colnum[ii], &datatype,
         NULL, NULL, status);

      if (datatype < 0 || datatype == TSTRING)
      {
        strcpy(errmsg, "Inappropriate datatype; can't bin this column: ");
        strcat(errmsg, colname[ii]);
        ffpmsg(errmsg);
        return(*status = BAD_DATATYPE);
      }

      /* ================================================================ */
      /* get the minimum value */

      datamin = FLOATNULLVALUE;
      datamax = FLOATNULLVALUE;
      
      if (*minname[ii])
      {
         if (ffgky(fptr, TDOUBLE, minname[ii], &minin[ii], NULL, status) )
         {
             ffpmsg("error reading histogramming minimum keyword");
             ffpmsg(minname[ii]);
             return(*status);
         }
      }

      if (minin[ii] != DOUBLENULLVALUE)
      {
        amin[ii] = (float) minin[ii];
      }
      else
      {
        ffkeyn("TLMIN", colnum[ii], keyname, status);
        if (ffgky(fptr, TFLOAT, keyname, amin+ii, NULL, status) > 0)
        {
            /* use actual data minimum value for the histogram minimum */
            *status = 0;
            if (fits_get_col_minmax(fptr, colnum[ii], amin+ii, &datamax, status) > 0)
            {
                strcpy(errmsg, "Error calculating datamin and datamax for column: ");
                strcat(errmsg, colname[ii]);
                ffpmsg(errmsg);
                return(*status);
            }
         }
      }

      /* ================================================================ */
      /* get the maximum value */

      if (*maxname[ii])
      {
         if (ffgky(fptr, TDOUBLE, maxname[ii], &maxin[ii], NULL, status) )
         {
             ffpmsg("error reading histogramming maximum keyword");
             ffpmsg(maxname[ii]);
             return(*status);
         }
      }

      if (maxin[ii] != DOUBLENULLVALUE)
      {
        amax[ii] = (float) maxin[ii];
      }
      else
      {
        ffkeyn("TLMAX", colnum[ii], keyname, status);
        if (ffgky(fptr, TFLOAT, keyname, &amax[ii], NULL, status) > 0)
        {
          *status = 0;
          if(datamax != FLOATNULLVALUE)  /* already computed max value */
          {
             amax[ii] = datamax;
          }
          else
          {
             /* use actual data maximum value for the histogram maximum */
             if (fits_get_col_minmax(fptr, colnum[ii], &datamin, &amax[ii], status) > 0)
             {
                 strcpy(errmsg, "Error calculating datamin and datamax for column: ");
                 strcat(errmsg, colname[ii]);
                 ffpmsg(errmsg);
                 return(*status);
             }
          }
        }
        use_datamax = 1;  /* flag that the max was determined by the data values */
                          /* and not specifically set by the calling program */
      }


      /* ================================================================ */
      /* determine binning size and range                                 */

      if (*binname[ii])
      {
         if (ffgky(fptr, TDOUBLE, binname[ii], &binsizein[ii], NULL, status) )
         {
             ffpmsg("error reading histogramming binsize keyword");
             ffpmsg(binname[ii]);
             return(*status);
         }
      }

      if (binsizein[ii] == 0.)
      {
        ffpmsg("error: histogram binsize = 0");
        return(*status = ZERO_SCALE);
      }

      /* use TDBINn keyword or else 1 if bin size is not given */
      if (binsizein[ii] != DOUBLENULLVALUE)
      { 
         binsize[ii] = (float) binsizein[ii];
      }
      else
      {
         tstatus = 0;
         ffkeyn("TDBIN", colnum[ii], keyname, &tstatus);

         if (ffgky(fptr, TDOUBLE, keyname, binsizein + ii, NULL, &tstatus) > 0)
         {
	    /* make at least 10 bins */
            binsize[ii] = (amax[ii] - amin[ii]) / 10.F ;
            if (binsize[ii] > 1.)
                binsize[ii] = 1.;  /* use default bin size */
         }
      }

      /* ================================================================ */
      /* if the min is greater than the max, make the binsize negative */
      if ( (amin[ii] > amax[ii] && binsize[ii] > 0. ) ||
           (amin[ii] < amax[ii] && binsize[ii] < 0. ) )
          binsize[ii] =  -binsize[ii];  /* reverse the sign of binsize */


      ibin = (int) binsize[ii];
      imin = (int) amin[ii];
      imax = (int) amax[ii];

      /* Determine the range and number of bins in the histogram. This  */
      /* depends on whether the input columns are integer or floats, so */
      /* treat each case separately.                                    */

      if (datatype <= TLONG && (float) imin == amin[ii] &&
                               (float) imax == amax[ii] &&
                               (float) ibin == binsize[ii] )
      {
        /* This is an integer column and integer limits were entered. */
        /* Shift the lower and upper histogramming limits by 0.5, so that */
        /* the values fall in the center of the bin, not on the edge. */

        haxes[ii] = (imax - imin) / ibin + 1;  /* last bin may only */
                                               /* be partially full */
        if (amin[ii] < amax[ii])
        {
          amin[ii] = (float) (amin[ii] - 0.5);
          amax[ii] = (float) (amax[ii] + 0.5);
        }
        else
        {
          amin[ii] = (float) (amin[ii] + 0.5);
          amax[ii] = (float) (amax[ii] - 0.5);
        }
      }
      else if (use_datamax)  
      {
        /* Either the column datatype and/or the limits are floating point, */
        /* and the histogram limits are being defined by the min and max */
        /* values of the array.  Add 1 to the number of histogram bins to */
        /* make sure that pixels that are equal to the maximum or are */
        /* in the last partial bin are included.  */

        haxes[ii] = (long) (((amax[ii] - amin[ii]) / binsize[ii]) + 1.); 
      }
      else  
      {
        /*  float datatype column and/or limits, and the maximum value to */
        /*  include in the histogram is specified by the calling program. */
        /*  The lower limit is inclusive, but upper limit is exclusive    */
        haxes[ii] = (long) ((amax[ii] - amin[ii]) / binsize[ii]);

        if (amin[ii] < amax[ii])
        {
          if (amin[ii] + (haxes[ii] * binsize[ii]) < amax[ii])
            haxes[ii]++;   /* need to include another partial bin */
        }
        else
        {
          if (amin[ii] + (haxes[ii] * binsize[ii]) > amax[ii])
            haxes[ii]++;   /* need to include another partial bin */
        }
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_write_keys_histo(
      fitsfile *fptr,   /* I - pointer to table to be binned              */
      fitsfile *histptr,  /* I - pointer to output histogram image HDU      */
      int naxis,        /* I - number of axes in the histogram image      */
      int *colnum,      /* I - column numbers (array length = naxis)      */
      int *status)     
{      
   /*  Write default WCS keywords in the output histogram image header */
   /*  if the keywords do not already exist.   */

    int ii, tstatus;
    char keyname[FLEN_KEYWORD], svalue[FLEN_VALUE];
    double dvalue;
    
    if (*status > 0)
        return(*status);

    for (ii = 0; ii < naxis; ii++)
    {
     /*  CTYPEn  */
       tstatus = 0;
       ffkeyn("CTYPE", ii+1, keyname, &tstatus);
       ffgky(histptr, TSTRING, keyname, svalue, NULL, &tstatus);
       
       if (!tstatus) continue;  /* keyword already exists, so skip to next axis */
       
       /* use column name as the axis name */
       tstatus = 0;
       ffkeyn("TTYPE", colnum[ii], keyname, &tstatus);
       ffgky(fptr, TSTRING, keyname, svalue, NULL, &tstatus);

       if (!tstatus)
       {
         ffkeyn("CTYPE", ii + 1, keyname, &tstatus);
         ffpky(histptr, TSTRING, keyname, svalue, "Coordinate Type", &tstatus);
       }

       /*  CUNITn,  use the column units */
       tstatus = 0;
       ffkeyn("TUNIT", colnum[ii], keyname, &tstatus);
       ffgky(fptr, TSTRING, keyname, svalue, NULL, &tstatus);

       if (!tstatus)
       {
         ffkeyn("CUNIT", ii + 1, keyname, &tstatus);
         ffpky(histptr, TSTRING, keyname, svalue, "Coordinate Units", &tstatus);
       }

       /*  CRPIXn  - Reference Pixel choose first pixel in new image as ref. pix. */
       dvalue = 1.0;
       tstatus = 0;
       ffkeyn("CRPIX", ii + 1, keyname, &tstatus);
       ffpky(histptr, TDOUBLE, keyname, &dvalue, "Reference Pixel", &tstatus);

       /*  CRVALn - Value at the location of the reference pixel */
       dvalue = 1.0;
       tstatus = 0;
       ffkeyn("CRVAL", ii + 1, keyname, &tstatus);
       ffpky(histptr, TDOUBLE, keyname, &dvalue, "Reference Value", &tstatus);

       /*  CDELTn - unit size of pixels  */
       dvalue = 1.0;  
       tstatus = 0;
       dvalue = 1.;
       ffkeyn("CDELT", ii + 1, keyname, &tstatus);
       ffpky(histptr, TDOUBLE, keyname, &dvalue, "Pixel size", &tstatus);

    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_rebin_wcs(
      fitsfile *fptr,   /* I - pointer to table to be binned           */
      int naxis,        /* I - number of axes in the histogram image   */
      float *amin,        /* I - first pixel include in each axis        */
      float *binsize,     /* I - binning factor for each axis            */
      int *status)      
{      
   /*  Update the  WCS keywords that define the location of the reference */
   /*  pixel, and the pixel size, along each axis.   */

    int ii, jj, tstatus, reset ;
    char keyname[FLEN_KEYWORD], svalue[FLEN_VALUE];
    double dvalue;
    
    if (*status > 0)
        return(*status);
  
    for (ii = 0; ii < naxis; ii++)
    {
       reset = 0;  /* flag to reset the reference pixel */
       tstatus = 0;
       ffkeyn("CRVAL", ii + 1, keyname, &tstatus);
       /* get previous (pre-binning) value */
       ffgky(fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus); 
       if (!tstatus && dvalue == 1.0)
           reset = 1;

       tstatus = 0;
       /*  CRPIXn - update location of the ref. pix. in the binned image */
       ffkeyn("CRPIX", ii + 1, keyname, &tstatus);

       /* get previous (pre-binning) value */
       ffgky(fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus); 

       if (!tstatus)
       {
           if (dvalue != 1.0)
	      reset = 0;

           /* updated value to give pixel location after binning */
           dvalue = (dvalue - amin[ii]) / ((double) binsize[ii]) + .5;  

           fits_modify_key_dbl(fptr, keyname, dvalue, -14, NULL, &tstatus);
       } else {
          reset = 0;
       }

       /*  CDELTn - update unit size of pixels  */
       tstatus = 0;
       ffkeyn("CDELT", ii + 1, keyname, &tstatus);

       /* get previous (pre-binning) value */
       ffgky(fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus); 

       if (!tstatus)
       {
           if (dvalue != 1.0)
	      reset = 0;

           /* updated to give post-binning value */
           dvalue = dvalue * binsize[ii];  

           fits_modify_key_dbl(fptr, keyname, dvalue, -14, NULL, &tstatus);
       }
       else
       {   /* no CDELTn keyword, so look for a CDij keywords */
          reset = 0;

          for (jj = 0; jj < naxis; jj++)
	  {
             tstatus = 0;
             ffkeyn("CD", jj + 1, svalue, &tstatus);
	     strcat(svalue,"_");
	     ffkeyn(svalue, ii + 1, keyname, &tstatus);

             /* get previous (pre-binning) value */
             ffgky(fptr, TDOUBLE, keyname, &dvalue, NULL, &tstatus); 

             if (!tstatus)
             {
                /* updated to give post-binning value */
               dvalue = dvalue * binsize[ii];  

               fits_modify_key_dbl(fptr, keyname, dvalue, -14, NULL, &tstatus);
             }
	  }
       }

       if (reset) {
          /* the original CRPIX, CRVAL, and CDELT keywords were all = 1.0 */
	  /* In this special case, reset the reference pixel to be the */
	  /* first pixel in the array (instead of possibly far off the array) */
 
           dvalue = 1.0;
           ffkeyn("CRPIX", ii + 1, keyname, &tstatus);
           fits_modify_key_dbl(fptr, keyname, dvalue, -14, NULL, &tstatus);

           ffkeyn("CRVAL", ii + 1, keyname, &tstatus);
	   dvalue = amin[ii] + (binsize[ii] / 2.0);	  
           fits_modify_key_dbl(fptr, keyname, dvalue, -14, NULL, &tstatus);
	}

    }
    return(*status);
}
/*--------------------------------------------------------------------------*/

int fits_make_hist(fitsfile *fptr, /* IO - pointer to table with X and Y cols; */
    fitsfile *histptr, /* I - pointer to output FITS image      */
    int bitpix,       /* I - datatype for image: 16, 32, -32, etc    */
    int naxis,        /* I - number of axes in the histogram image   */
    long *naxes,      /* I - size of axes in the histogram image   */
    int *colnum,    /* I - column numbers (array length = naxis)   */
    float *amin,     /* I - minimum histogram value, for each axis */
    float *amax,     /* I - maximum histogram value, for each axis */
    float *binsize, /* I - bin size along each axis               */
    float weight,        /* I - binning weighting factor          */
    int wtcolnum, /* I - optional keyword or col for weight*/
    int recip,              /* I - use reciprocal of the weight?     */
    char *selectrow,        /* I - optional array (length = no. of   */
                             /* rows in the table).  If the element is true */
                             /* then the corresponding row of the table will*/
                             /* be included in the histogram, otherwise the */
                             /* row will be skipped.  Ingnored if *selectrow*/
                             /* is equal to NULL.                           */
    int *status)
{		  
    int ii, imagetype, datatype;
    int n_cols = 1;
    long imin, imax, ibin;
    long  offset = 0;
    long n_per_loop = -1;  /* force whole array to be passed at one time */
    float taxes[4], tmin[4], tmax[4], tbin[4], maxbin[4];
    histType histData;    /* Structure holding histogram info for iterator */
    iteratorCol imagepars[1];

    /* check inputs */
    
    if (*status > 0)
        return(*status);

    if (naxis > 4)
    {
        ffpmsg("histogram has more than 4 dimensions");
        return(*status = BAD_DIMEN);
    }

    if   (bitpix == BYTE_IMG)
         imagetype = TBYTE;
    else if (bitpix == SHORT_IMG)
         imagetype = TSHORT;
    else if (bitpix == LONG_IMG)
         imagetype = TINT;    
    else if (bitpix == FLOAT_IMG)
         imagetype = TFLOAT;    
    else if (bitpix == DOUBLE_IMG)
         imagetype = TDOUBLE;    
    else
        return(*status = BAD_DATATYPE);

    /* reset position to the correct HDU if necessary */
    if ((fptr)->HDUposition != ((fptr)->Fptr)->curhdu)
        ffmahd(fptr, ((fptr)->HDUposition) + 1, NULL, status);

    histData.weight     = weight;
    histData.wtcolnum   = wtcolnum;
    histData.wtrecip    = recip;
    histData.tblptr     = fptr;
    histData.himagetype = imagetype;
    histData.haxis      = naxis;
    histData.rowselector = selectrow;

    for (ii = 0; ii < naxis; ii++)
    {
      taxes[ii] = (float) naxes[ii];
      tmin[ii] = amin[ii];
      tmax[ii] = amax[ii];
      if ( (amin[ii] > amax[ii] && binsize[ii] > 0. ) ||
           (amin[ii] < amax[ii] && binsize[ii] < 0. ) )
          tbin[ii] =  -binsize[ii];  /* reverse the sign of binsize */
      else
          tbin[ii] =   binsize[ii];  /* binsize has the correct sign */
          
      imin = (long) tmin[ii];
      imax = (long) tmax[ii];
      ibin = (long) tbin[ii];
    
      /* get the datatype of the column */
      fits_get_coltype(fptr, colnum[ii], &datatype, NULL, NULL, status);

      if (datatype <= TLONG && (float) imin == tmin[ii] &&
                               (float) imax == tmax[ii] &&
                               (float) ibin == tbin[ii] )
      {
        /* This is an integer column and integer limits were entered. */
        /* Shift the lower and upper histogramming limits by 0.5, so that */
        /* the values fall in the center of the bin, not on the edge. */

        maxbin[ii] = (taxes[ii] + 1.F);  /* add 1. instead of .5 to avoid roundoff */

        if (tmin[ii] < tmax[ii])
        {
          tmin[ii] = tmin[ii] - 0.5F;
          tmax[ii] = tmax[ii] + 0.5F;
        }
        else
        {
          tmin[ii] = tmin[ii] + 0.5F;
          tmax[ii] = tmax[ii] - 0.5F;
        }
      } else {  /* not an integer column with integer limits */
          maxbin[ii] = (tmax[ii] - tmin[ii]) / tbin[ii]; 
      }
    }

    /* Set global variables with histogram parameter values.    */
    /* Use separate scalar variables rather than arrays because */
    /* it is more efficient when computing the histogram.       */

    histData.hcolnum[0]  = colnum[0];
    histData.amin1 = tmin[0];
    histData.maxbin1 = maxbin[0];
    histData.binsize1 = tbin[0];
    histData.haxis1 = (long) taxes[0];

    if (histData.haxis > 1)
    {
      histData.hcolnum[1]  = colnum[1];
      histData.amin2 = tmin[1];
      histData.maxbin2 = maxbin[1];
      histData.binsize2 = tbin[1];
      histData.haxis2 = (long) taxes[1];

      if (histData.haxis > 2)
      {
        histData.hcolnum[2]  = colnum[2];
        histData.amin3 = tmin[2];
        histData.maxbin3 = maxbin[2];
        histData.binsize3 = tbin[2];
        histData.haxis3 = (long) taxes[2];

        if (histData.haxis > 3)
        {
          histData.hcolnum[3]  = colnum[3];
          histData.amin4 = tmin[3];
          histData.maxbin4 = maxbin[3];
          histData.binsize4 = tbin[3];
          histData.haxis4 = (long) taxes[3];
        }
      }
    }

    /* define parameters of image for the iterator function */
    fits_iter_set_file(imagepars, histptr);        /* pointer to image */
    fits_iter_set_datatype(imagepars, imagetype);  /* image datatype   */
    fits_iter_set_iotype(imagepars, OutputCol);    /* image is output  */

    /* call the iterator function to write out the histogram image */
    fits_iterate_data(n_cols, imagepars, offset, n_per_loop,
                          ffwritehisto, (void*)&histData, status);
       
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_get_col_minmax(fitsfile *fptr, int colnum, float *datamin, 
                     float *datamax, int *status)
/* 
   Simple utility routine to compute the min and max value in a column
*/
{
    int anynul;
    long nrows, ntodo, firstrow, ii;
    float array[1000], nulval;

    ffgky(fptr, TLONG, "NAXIS2", &nrows, NULL, status); /* no. of rows */

    firstrow = 1;
    nulval = FLOATNULLVALUE;
    *datamin =  9.0E36F;
    *datamax = -9.0E36F;

    while(nrows)
    {
        ntodo = minvalue(nrows, 100);
        ffgcv(fptr, TFLOAT, colnum, firstrow, 1, ntodo, &nulval, array,
              &anynul, status);

        for (ii = 0; ii < ntodo; ii++)
        {
            if (array[ii] != nulval)
            {
                *datamin = minvalue(*datamin, array[ii]);
                *datamax = maxvalue(*datamax, array[ii]);
            }
        }

        nrows -= ntodo;
        firstrow += ntodo;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffwritehisto(long totaln, long pixoffset, long firstn, long nvalues,
             int narrays, iteratorCol *imagepars, void *userPointer)
/*
   Interator work function that writes out the histogram.
   The histogram values are calculated by another work function, ffcalchisto.
   This work function only gets called once, and totaln = nvalues.
*/
{
    iteratorCol colpars[5];
    int ii, status = 0, ncols;
    long rows_per_loop = 0, offset = 0;
    histType *histData;

    histData = (histType *)userPointer;

    /* store pointer to the histogram array, and initialize to zero */

    switch( histData->himagetype ) {
    case TBYTE:
       histData->hist.b = (char *  ) fits_iter_get_array(imagepars);
       break;
    case TSHORT:
       histData->hist.i = (short * ) fits_iter_get_array(imagepars);
       break;
    case TINT:
       histData->hist.j = (int *   ) fits_iter_get_array(imagepars);
       break;
    case TFLOAT:
       histData->hist.r = (float * ) fits_iter_get_array(imagepars);
       break;
    case TDOUBLE:
       histData->hist.d = (double *) fits_iter_get_array(imagepars);
       break;
    }

    /* set the column parameters for the iterator function */
    for (ii = 0; ii < histData->haxis; ii++)
    {
      fits_iter_set_by_num(&colpars[ii], histData->tblptr,
			   histData->hcolnum[ii], TFLOAT, InputCol);
    }
    ncols = histData->haxis;

    if (histData->weight == FLOATNULLVALUE)
    {
      fits_iter_set_by_num(&colpars[histData->haxis], histData->tblptr,
			   histData->wtcolnum, TFLOAT, InputCol);
      ncols = histData->haxis + 1;
    }

    /* call iterator function to calc the histogram pixel values */

    /* must lock this call in multithreaded environoments because */
    /* the ffcalchist work routine uses static vaiables that would */
    /* get clobbered if multiple threads were running at the same time */
    FFLOCK;
    fits_iterate_data(ncols, colpars, offset, rows_per_loop,
                          ffcalchist, (void*)histData, &status);
    FFUNLOCK;

    return(status);
}
/*--------------------------------------------------------------------------*/
int ffcalchist(long totalrows, long offset, long firstrow, long nrows,
             int ncols, iteratorCol *colpars, void *userPointer)
/*
   Interator work function that calculates values for the 2D histogram.
*/
{
    long ii, ipix, iaxisbin;
    float pix, axisbin;
    static float *col1, *col2, *col3, *col4; /* static to preserve values */
    static float *wtcol;
    static long incr2, incr3, incr4;
    static histType histData;
    static char *rowselect;

    /*  Initialization procedures: execute on the first call  */
    if (firstrow == 1)
    {

      /*  Copy input histogram data to static local variable so we */
      /*  don't have to constantly dereference it.                 */

      histData = *(histType*)userPointer;
      rowselect = histData.rowselector;

      /* assign the input array pointers to local pointers */
      col1 = (float *) fits_iter_get_array(&colpars[0]);
      if (histData.haxis > 1)
      {
        col2 = (float *) fits_iter_get_array(&colpars[1]);
        incr2 = histData.haxis1;

        if (histData.haxis > 2)
        {
          col3 = (float *) fits_iter_get_array(&colpars[2]);
          incr3 = incr2 * histData.haxis2;

          if (histData.haxis > 3)
          {
            col4 = (float *) fits_iter_get_array(&colpars[3]);
            incr4 = incr3 * histData.haxis3;
          }
        }
      }

      if (ncols > histData.haxis)  /* then weights are give in a column */
      {
        wtcol = (float *) fits_iter_get_array(&colpars[histData.haxis]);
      }
    }   /* end of Initialization procedures */

    /*  Main loop: increment the histogram at position of each event */
    for (ii = 1; ii <= nrows; ii++) 
    {
        if (rowselect)     /* if a row selector array is supplied... */
        {
           if (*rowselect)
           {
               rowselect++;   /* this row is included in the histogram */
           }
           else
           {
               rowselect++;   /* this row is excluded from the histogram */
               continue;
           }
        }

        if (col1[ii] == FLOATNULLVALUE)  /* test for null value */
            continue;

        pix = (col1[ii] - histData.amin1) / histData.binsize1;
        ipix = (long) (pix + 1.); /* add 1 because the 1st pixel is the null value */

	/* test if bin is within range */
        if (ipix < 1 || ipix > histData.haxis1 || pix > histData.maxbin1)
            continue;

        if (histData.haxis > 1)
        {
          if (col2[ii] == FLOATNULLVALUE)
              continue;

          axisbin = (col2[ii] - histData.amin2) / histData.binsize2;
          iaxisbin = (long) axisbin;

          if (axisbin < 0. || iaxisbin >= histData.haxis2 || axisbin > histData.maxbin2)
              continue;

          ipix += (iaxisbin * incr2);

          if (histData.haxis > 2)
          {
            if (col3[ii] == FLOATNULLVALUE)
                continue;

            axisbin = (col3[ii] - histData.amin3) / histData.binsize3;
            iaxisbin = (long) axisbin;
            if (axisbin < 0. || iaxisbin >= histData.haxis3 || axisbin > histData.maxbin3)
                continue;

            ipix += (iaxisbin * incr3);
 
            if (histData.haxis > 3)
            {
              if (col4[ii] == FLOATNULLVALUE)
                  continue;

              axisbin = (col4[ii] - histData.amin4) / histData.binsize4;
              iaxisbin = (long) axisbin;
              if (axisbin < 0. || iaxisbin >= histData.haxis4 || axisbin > histData.maxbin4)
                  continue;

              ipix += (iaxisbin * incr4);

            }  /* end of haxis > 3 case */
          }    /* end of haxis > 2 case */
        }      /* end of haxis > 1 case */

        /* increment the histogram pixel */
        if (histData.weight != FLOATNULLVALUE) /* constant weight factor */
        {
            if (histData.himagetype == TINT)
              histData.hist.j[ipix] += (int) histData.weight;
            else if (histData.himagetype == TSHORT)
              histData.hist.i[ipix] += (short) histData.weight;
            else if (histData.himagetype == TFLOAT)
              histData.hist.r[ipix] += histData.weight;
            else if (histData.himagetype == TDOUBLE)
              histData.hist.d[ipix] += histData.weight;
            else if (histData.himagetype == TBYTE)
              histData.hist.b[ipix] += (char) histData.weight;
        }
        else if (histData.wtrecip) /* use reciprocal of the weight */
        {
            if (histData.himagetype == TINT)
              histData.hist.j[ipix] += (int) (1./wtcol[ii]);
            else if (histData.himagetype == TSHORT)
              histData.hist.i[ipix] += (short) (1./wtcol[ii]);
            else if (histData.himagetype == TFLOAT)
              histData.hist.r[ipix] += (float) (1./wtcol[ii]);
            else if (histData.himagetype == TDOUBLE)
              histData.hist.d[ipix] += 1./wtcol[ii];
            else if (histData.himagetype == TBYTE)
              histData.hist.b[ipix] += (char) (1./wtcol[ii]);
        }
        else   /* no weights */
        {
            if (histData.himagetype == TINT)
              histData.hist.j[ipix] += (int) wtcol[ii];
            else if (histData.himagetype == TSHORT)
              histData.hist.i[ipix] += (short) wtcol[ii];
            else if (histData.himagetype == TFLOAT)
              histData.hist.r[ipix] += wtcol[ii];
            else if (histData.himagetype == TDOUBLE)
              histData.hist.d[ipix] += wtcol[ii];
            else if (histData.himagetype == TBYTE)
              histData.hist.b[ipix] += (char) wtcol[ii];
        }

    }  /* end of main loop over all rows */

    return(0);
}

healpy-1.10.3/cfitsio/imcompress.c0000664000175000017500000127366013010375005017324 0ustar  zoncazonca00000000000000# include 
# include 
# include 
# include 
# include 
# include 
# include "fitsio2.h"

#define NULL_VALUE -2147483647 /* value used to represent undefined pixels */
#define ZERO_VALUE -2147483646 /* value used to represent zero-valued pixels */

/* nearest integer function */
# define NINT(x)  ((x >= 0.) ? (int) (x + 0.5) : (int) (x - 0.5))

/* special quantize level value indicates that floating point image pixels */
/* should not be quantized and instead losslessly compressed (with GZIP) */
#define NO_QUANTIZE 9999

/* string array for storing the individual column compression stats */
char results[999][30];

float *fits_rand_value = 0;

int imcomp_write_nocompress_tile(fitsfile *outfptr, long row, int datatype, 
    void *tiledata, long tilelen, int nullcheck, void *nullflagval, int *status);
int imcomp_convert_tile_tshort(fitsfile *outfptr, void *tiledata, long tilelen,
    int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale,
    double zero, double actual_bzero, int *intlength, int *status);
int imcomp_convert_tile_tushort(fitsfile *outfptr, void *tiledata, long tilelen,
    int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale,
    double zero, int *intlength, int *status);
int imcomp_convert_tile_tint(fitsfile *outfptr, void *tiledata, long tilelen,
    int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale,
    double zero, int *intlength, int *status);
int imcomp_convert_tile_tuint(fitsfile *outfptr, void *tiledata, long tilelen,
    int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale,
    double zero, int *intlength, int *status);
int imcomp_convert_tile_tbyte(fitsfile *outfptr, void *tiledata, long tilelen,
    int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale,
    double zero, int *intlength, int *status);
int imcomp_convert_tile_tsbyte(fitsfile *outfptr, void *tiledata, long tilelen,
    int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale,
    double zero, int *intlength, int *status);
int imcomp_convert_tile_tfloat(fitsfile *outfptr, long row, void *tiledata, long tilelen,
    long tilenx, long tileny, int nullcheck, void *nullflagval, int nullval, int zbitpix,
    double scale, double zero, int *intlength, int *flag, double *bscale, double *bzero,int *status);
int imcomp_convert_tile_tdouble(fitsfile *outfptr, long row, void *tiledata, long tilelen,
    long tilenx, long tileny, int nullcheck, void *nullflagval, int nullval, int zbitpix, 
    double scale, double zero, int *intlength, int *flag, double *bscale, double *bzero, int *status);

static int unquantize_i1r4(long row,
            unsigned char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - which subtractive dither method to use */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,          /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status);          /* IO - error status                       */
static int unquantize_i2r4(long row,
            short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - which subtractive dither method to use */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status);          /* IO - error status                       */
static int unquantize_i4r4(long row,
            INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - which subtractive dither method to use */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status);          /* IO - error status                       */
static int unquantize_i1r8(long row,
            unsigned char *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - which subtractive dither method to use */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,          /* I - value of FITS TNULLn keyword if any */
            double nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,        /* O - array of converted pixels           */
            int *status);          /* IO - error status                       */
static int unquantize_i2r8(long row,
            short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - which subtractive dither method to use */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            double nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,        /* O - array of converted pixels           */
            int *status);          /* IO - error status                       */
static int unquantize_i4r8(long row,
            INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - which subtractive dither method to use */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            double nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,        /* O - array of converted pixels           */
            int *status);          /* IO - error status                       */
static int imcomp_float2nan(float *indata, long tilelen, int *outdata,
    float nullflagval,  int *status);
static int imcomp_double2nan(double *indata, long tilelen, LONGLONG *outdata,
    double nullflagval,  int *status);    
static int fits_read_write_compressed_img(fitsfile *fptr,   /* I - FITS file pointer */
            int  datatype,  /* I - datatype of the array to be returned      */
            LONGLONG  *infpixel, /* I - 'bottom left corner' of the subsection    */
            LONGLONG  *inlpixel, /* I - 'top right corner' of the subsection      */
            long  *ininc,    /* I - increment to be applied in each dimension */
            int  nullcheck,  /* I - 0 for no null checking                   */
                              /*     1: set undefined pixels = nullval       */
            void *nullval,    /* I - value for undefined pixels              */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            fitsfile *outfptr,   /* I - FITS file pointer                    */
            int  *status);

static int fits_shuffle_8bytes(char *heap, LONGLONG length, int *status);
static int fits_shuffle_4bytes(char *heap, LONGLONG length, int *status);
static int fits_shuffle_2bytes(char *heap, LONGLONG length, int *status);
static int fits_unshuffle_8bytes(char *heap, LONGLONG length, int *status);
static int fits_unshuffle_4bytes(char *heap, LONGLONG length, int *status);
static int fits_unshuffle_2bytes(char *heap, LONGLONG length, int *status);

/* only used for diagnoitic purposes */
/* int fits_get_case(int *c1, int*c2, int*c3); */ 
/*---------------------------------------------------------------------------*/
int fits_init_randoms(void) {

/* initialize an array of random numbers */

    int ii;
    double a = 16807.0;
    double m = 2147483647.0;
    double temp, seed;

    FFLOCK;
 
    if (fits_rand_value) {
       FFUNLOCK;
       return(0);  /* array is already initialized */
    }

    /* allocate array for the random number sequence */
    /* THIS MEMORY IS NEVER FREED */
    fits_rand_value = calloc(N_RANDOM, sizeof(float));

    if (!fits_rand_value) {
        FFUNLOCK;
	return(MEMORY_ALLOCATION);
    }
		       
    /*  We need a portable algorithm that anyone can use to generate this
        exact same sequence of random number.  The C 'rand' function is not
	suitable because it is not available to Fortran or Java programmers.
	Instead, use a well known simple algorithm published here: 
	"Random number generators: good ones are hard to find", Communications of the ACM,
        Volume 31 ,  Issue 10  (October 1988) Pages: 1192 - 1201 
    */  

    /* initialize the random numbers */
    seed = 1;
    for (ii = 0; ii < N_RANDOM; ii++) {
        temp = a * seed;
	seed = temp -m * ((int) (temp / m) );
	fits_rand_value[ii] = (float) (seed / m);
    }

    FFUNLOCK;

    /* 
    IMPORTANT NOTE: the 10000th seed value must have the value 1043618065 if the 
       algorithm has been implemented correctly */
    
    if ( (int) seed != 1043618065) {
        ffpmsg("fits_init_randoms generated incorrect random number sequence");
	return(1);
    } else {
        return(0);
    }
}
/*--------------------------------------------------------------------------*/
void bz_internal_error(int errcode)
{
    /* external function declared by the bzip2 code in bzlib_private.h */
    ffpmsg("bzip2 returned an internal error");
    ffpmsg("This should never happen");
    return;
}
/*--------------------------------------------------------------------------*/
int fits_set_compression_type(fitsfile *fptr,  /* I - FITS file pointer     */
       int ctype,    /* image compression type code;                        */
                     /* allowed values: RICE_1, GZIP_1, GZIP_2, PLIO_1,     */
                     /*  HCOMPRESS_1, BZIP2_1, and NOCOMPRESS               */
       int *status)  /* IO - error status                                   */
{
/*
   This routine specifies the image compression algorithm that should be
   used when writing a FITS image.  The image is divided into tiles, and
   each tile is compressed and stored in a row of at variable length binary
   table column.
*/

    if (ctype != RICE_1 && 
        ctype != GZIP_1 && 
        ctype != GZIP_2 && 
        ctype != PLIO_1 && 
        ctype != HCOMPRESS_1 && 
        ctype != BZIP2_1 && 
        ctype != NOCOMPRESS &&
	ctype != 0)
    {
	ffpmsg("unknown compression algorithm (fits_set_compression_type)");
	*status = DATA_COMPRESSION_ERR; 
    } else {
        (fptr->Fptr)->request_compress_type = ctype;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_tile_dim(fitsfile *fptr,  /* I - FITS file pointer             */
           int ndim,   /* number of dimensions in the compressed image      */
           long *dims, /* size of image compression tile in each dimension  */
                      /* default tile size = (NAXIS1, 1, 1, ...)            */
           int *status)         /* IO - error status                        */
{
/*
   This routine specifies the size (dimension) of the image
   compression  tiles that should be used when writing a FITS
   image.  The image is divided into tiles, and each tile is compressed
   and stored in a row of at variable length binary table column.
*/
    int ii;

    if (ndim < 0 || ndim > MAX_COMPRESS_DIM)
    {
        *status = BAD_DIMEN;
	ffpmsg("illegal number of tile dimensions (fits_set_tile_dim)");
        return(*status);
    }

    for (ii = 0; ii < ndim; ii++)
    {
        (fptr->Fptr)->request_tilesize[ii] = dims[ii];
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_quantize_level(fitsfile *fptr,  /* I - FITS file pointer   */
           float qlevel,        /* floating point quantization level      */
           int *status)         /* IO - error status                */
{
/*
   This routine specifies the value of the quantization level, q,  that
   should be used when compressing floating point images.  The image is
   divided into tiles, and each tile is compressed and stored in a row
   of at variable length binary table column.
*/
    if (qlevel == 0.)
    {
        /* this means don't quantize the floating point values. Instead, */
	/* the floating point values will be losslessly compressed */
       (fptr->Fptr)->request_quantize_level = NO_QUANTIZE;
    } else {

        (fptr->Fptr)->request_quantize_level = qlevel;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_quantize_method(fitsfile *fptr,  /* I - FITS file pointer   */
           int method,          /* quantization method       */
           int *status)         /* IO - error status                */
{
/*
   This routine specifies what type of dithering (randomization) should
   be performed when quantizing floating point images to integer prior to
   compression.   A value of -1 means do no dithering.  A value of 0 means
   use the default SUBTRACTIVE_DITHER_1 (which is equivalent to dither = 1).
   A value of 2 means use SUBTRACTIVE_DITHER_2.
*/

    if (method < -1 || method > 2)
    {
	ffpmsg("illegal dithering value (fits_set_quantize_method)");
	*status = DATA_COMPRESSION_ERR; 
    } else {
       
        if (method == 0) method = 1;
        (fptr->Fptr)->request_quantize_method = method;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_quantize_dither(fitsfile *fptr,  /* I - FITS file pointer   */
           int dither,        /* dither type      */
           int *status)         /* IO - error status                */
{
/*
   the name of this routine has changed.  This is kept here only for backwards
   compatibility for any software that may be calling the old routine.
*/

    fits_set_quantize_method(fptr, dither, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_dither_seed(fitsfile *fptr,  /* I - FITS file pointer   */
           int seed,        /* random dithering seed value (1 to 10000) */
           int *status)         /* IO - error status                */
{
/*
   This routine specifies the value of the offset that should be applied when
   calculating the random dithering when quantizing floating point iamges.
   A random offset should be applied to each image to avoid quantization 
   effects when taking the difference of 2 images, or co-adding a set of
   images.  Without this random offset, the corresponding pixel in every image
   will have exactly the same dithering.
   
   offset = 0 means use the default random dithering based on system time
   offset = negative means randomly chose dithering based on 1st tile checksum
   offset = [1 - 10000] means use that particular dithering pattern

*/
    /* if positive, ensure that the value is in the range 1 to 10000 */
    if (seed > 10000) {
	ffpmsg("illegal dithering seed value (fits_set_dither_seed)");
	*status = DATA_COMPRESSION_ERR;
    } else {
       (fptr->Fptr)->request_dither_seed = seed; 
    }
    
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_dither_offset(fitsfile *fptr,  /* I - FITS file pointer   */
           int offset,        /* random dithering offset value (1 to 10000) */
           int *status)         /* IO - error status                */
{
/*
    The name of this routine has changed.  This is kept just for
    backwards compatibility with any software that calls the old name
*/

    fits_set_dither_seed(fptr, offset, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_noise_bits(fitsfile *fptr,  /* I - FITS file pointer   */
           int noisebits,       /* noise_bits parameter value       */
                                /* (default = 4)                    */
           int *status)         /* IO - error status                */
{
/*
   ********************************************************************
   ********************************************************************
   THIS ROUTINE IS PROVIDED ONLY FOR BACKWARDS COMPATIBILITY;
   ALL NEW SOFTWARE SHOULD CALL fits_set_quantize_level INSTEAD
   ********************************************************************
   ********************************************************************

   This routine specifies the value of the noice_bits parameter that
   should be used when compressing floating point images.  The image is
   divided into tiles, and each tile is compressed and stored in a row
   of at variable length binary table column.

   Feb 2008:  the "noisebits" parameter has been replaced with the more
   general "quantize level" parameter.
*/
    float qlevel;

    if (noisebits < 1 || noisebits > 16)
    {
        *status = DATA_COMPRESSION_ERR;
	ffpmsg("illegal number of noise bits (fits_set_noise_bits)");
        return(*status);
    }

    qlevel = (float) pow (2., (double)noisebits);
    fits_set_quantize_level(fptr, qlevel, status);
    
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_hcomp_scale(fitsfile *fptr,  /* I - FITS file pointer   */
           float scale,       /* hcompress scale parameter value       */
                                /* (default = 0.)                    */
           int *status)         /* IO - error status                */
{
/*
   This routine specifies the value of the hcompress scale parameter.
*/
    (fptr->Fptr)->request_hcomp_scale = scale;
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_hcomp_smooth(fitsfile *fptr,  /* I - FITS file pointer   */
           int smooth,       /* hcompress smooth parameter value       */
                                /* if scale > 1 and smooth != 0, then */
				/*  the image will be smoothed when it is */
				/* decompressed to remove some of the */
				/* 'blockiness' in the image produced */
				/* by the lossy compression    */
           int *status)         /* IO - error status                */
{
/*
   This routine specifies the value of the hcompress scale parameter.
*/

    (fptr->Fptr)->request_hcomp_smooth = smooth;
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_lossy_int(fitsfile *fptr,  /* I - FITS file pointer   */
           int lossy_int,       /* I - True (!= 0) or False (0) */
           int *status)         /* IO - error status                */
{
/*
   This routine specifies whether images with integer pixel values should
   quantized and compressed the same way float images are compressed.
   The default is to not do this, and instead apply a lossless compression
   algorithm to integer images.
*/

    (fptr->Fptr)->request_lossy_int_compress = lossy_int;
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_huge_hdu(fitsfile *fptr,  /* I - FITS file pointer   */
           int huge,       /* I - True (!= 0) or False (0) */
           int *status)         /* IO - error status                */
{
/*
   This routine specifies whether the HDU that is being compressed is so large
   (i.e., > 4 GB) that the 'Q' type variable length array columns should be used
   rather than the normal 'P' type.  The allows the heap pointers to be stored
   as 64-bit quantities, rather than just 32-bits.
*/

    (fptr->Fptr)->request_huge_hdu = huge;
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_get_compression_type(fitsfile *fptr,  /* I - FITS file pointer     */
       int *ctype,   /* image compression type code;                        */
                     /* allowed values:                                     */
		     /* RICE_1, GZIP_1, GZIP_2, PLIO_1, HCOMPRESS_1, BZIP2_1 */
       int *status)  /* IO - error status                                   */
{
/*
   This routine returns the image compression algorithm that should be
   used when writing a FITS image.  The image is divided into tiles, and
   each tile is compressed and stored in a row of at variable length binary
   table column.
*/
    *ctype = (fptr->Fptr)->request_compress_type;

    if (*ctype != RICE_1 && 
        *ctype != GZIP_1 && 
        *ctype != GZIP_2 && 
        *ctype != PLIO_1 && 
        *ctype != HCOMPRESS_1 && 
        *ctype != BZIP2_1 && 
        *ctype != NOCOMPRESS &&
	*ctype != 0   ) 

    {
	ffpmsg("unknown compression algorithm (fits_get_compression_type)");
	*status = DATA_COMPRESSION_ERR; 
    }
 
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_get_tile_dim(fitsfile *fptr,  /* I - FITS file pointer             */
           int ndim,   /* number of dimensions in the compressed image      */
           long *dims, /* size of image compression tile in each dimension  */
                       /* default tile size = (NAXIS1, 1, 1, ...)           */
           int *status)         /* IO - error status                        */
{
/*
   This routine returns the size (dimension) of the image
   compression  tiles that should be used when writing a FITS
   image.  The image is divided into tiles, and each tile is compressed
   and stored in a row of at variable length binary table column.
*/
    int ii;

    if (ndim < 0 || ndim > MAX_COMPRESS_DIM)
    {
        *status = BAD_DIMEN;
	ffpmsg("illegal number of tile dimensions (fits_get_tile_dim)");
        return(*status);
    }

    for (ii = 0; ii < ndim; ii++)
    {
        dims[ii] = (fptr->Fptr)->request_tilesize[ii];
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_unset_compression_param(
      fitsfile *fptr,
      int *status) 
{
    int ii;

    (fptr->Fptr)->compress_type = 0;
    (fptr->Fptr)->quantize_level = 0;
    (fptr->Fptr)->quantize_method = 0;
    (fptr->Fptr)->dither_seed = 0; 
    (fptr->Fptr)->hcomp_scale = 0;

    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        (fptr->Fptr)->tilesize[ii] = 0;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_unset_compression_request(
      fitsfile *fptr,
      int *status) 
{
    int ii;

    (fptr->Fptr)->request_compress_type = 0;
    (fptr->Fptr)->request_quantize_level = 0;
    (fptr->Fptr)->request_quantize_method = 0;
    (fptr->Fptr)->request_dither_seed = 0; 
    (fptr->Fptr)->request_hcomp_scale = 0;
    (fptr->Fptr)->request_lossy_int_compress = 0;
    (fptr->Fptr)->request_huge_hdu = 0;

    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        (fptr->Fptr)->request_tilesize[ii] = 0;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_set_compression_pref(
      fitsfile *infptr,
      fitsfile *outfptr,
      int *status) 
{
/*
   Set the preference for various compression options, based
   on keywords in the input file that
   provide guidance about how the HDU should be compressed when written
   to the output file.
*/

    int ii, naxis, nkeys, comptype;
    int  ivalue, tstatus;
    long tiledim[6]= {1,1,1,1,1,1};
    char card[FLEN_CARD], value[FLEN_VALUE];
    double  qvalue;
    float hscale;
    LONGLONG datastart, dataend; 
    if (*status > 0)
        return(*status);

    /* check the size of the HDU that is to be compressed */
    fits_get_hduaddrll(infptr, NULL, &datastart, &dataend, status);
    if ( (LONGLONG)(dataend - datastart) > UINT32_MAX) {
       /* use 64-bit '1Q' variable length columns instead of '1P' columns */
       /* for large files, in case the heap size becomes larger than 2**32 bytes*/
       fits_set_huge_hdu(outfptr, 1, status);
    }

    fits_get_hdrspace(infptr, &nkeys, NULL, status);
 
   /* look for a image compression directive keywords (begin with 'FZ') */
    for (ii = 2; ii <= nkeys; ii++) {
        
	fits_read_record(infptr, ii, card, status);

	if (!strncmp(card, "FZ", 2) ){
	
            /* get the keyword value string */
            fits_parse_value(card, value, NULL, status);
	    
	    if      (!strncmp(card+2, "ALGOR", 5) ) {

	        /* set the desired compression algorithm */
                /* allowed values: RICE_1, GZIP_1, GZIP_2, PLIO_1,     */
                /*  HCOMPRESS_1, BZIP2_1, and NOCOMPRESS               */

                if        (!strncasecmp(value, "'RICE_1", 7) ) {
		    comptype = RICE_1;
                } else if (!strncasecmp(value, "'GZIP_1", 7) ) {
		    comptype = GZIP_1;
                } else if (!strncasecmp(value, "'GZIP_2", 7) ) {
		    comptype = GZIP_2;
                } else if (!strncasecmp(value, "'PLIO_1", 7) ) {
		    comptype = PLIO_1;
                } else if (!strncasecmp(value, "'HCOMPRESS_1", 12) ) {
		    comptype = HCOMPRESS_1;
                } else if (!strncasecmp(value, "'NONE", 5) ) {
		    comptype = NOCOMPRESS;
		} else {
			ffpmsg("Unknown FZALGOR keyword compression algorithm:");
			ffpmsg(value);
			return(*status = DATA_COMPRESSION_ERR);
		}  

	        fits_set_compression_type (outfptr, comptype, status);

	    } else if (!strncmp(card+2, "TILE  ", 6) ) {

		tstatus = 0;
                if (!strncasecmp(value, "'row", 4) ) {
                   tiledim[0] = -1;
		} else if (!strncasecmp(value, "'whole", 6) ) {
                   tiledim[0] = -1;
                   tiledim[1] = -1;
                   tiledim[2] = -1;
                } else {
		   ffdtdm(infptr, value, 0,6, &naxis, tiledim, status);
                }

	        /* set the desired tile size */
		fits_set_tile_dim (outfptr, 6, tiledim, status);

	    } else if (!strncmp(card+2, "QVALUE", 6) ) {

	        /* set the desired Q quantization value */
		qvalue = atof(value);
		fits_set_quantize_level (outfptr, (float) qvalue, status);

	    } else if (!strncmp(card+2, "QMETHD", 6) ) {

                    if (!strncasecmp(value, "'no_dither", 10) ) {
                        ivalue = -1; /* just quantize, with no dithering */
		    } else if (!strncasecmp(value, "'subtractive_dither_1", 21) ) {
                        ivalue = SUBTRACTIVE_DITHER_1; /* use subtractive dithering */
		    } else if (!strncasecmp(value, "'subtractive_dither_2", 21) ) {
                        ivalue = SUBTRACTIVE_DITHER_2; /* dither, except preserve zero-valued pixels */
		    } else {
		        ffpmsg("Unknown value for FZQUANT keyword: (set_compression_pref)");
			ffpmsg(value);
                        return(*status = DATA_COMPRESSION_ERR);
		    }

		    fits_set_quantize_method(outfptr, ivalue, status);
		    
	    } else if (!strncmp(card+2, "DTHRSD", 6) ) {

                if (!strncasecmp(value, "'checksum", 9) ) {
                    ivalue = -1; /* use checksum of first tile */
		} else if (!strncasecmp(value, "'clock", 6) ) {
                    ivalue = 0; /* set dithering seed based on system clock */
		} else {  /* read integer value */
		    if (*value == '\'')
                        ivalue = (int) atol(value+1); /* allow for leading quote character */
                    else 
                        ivalue = (int) atol(value); 

                    if (ivalue < 1 || ivalue > 10000) {
		        ffpmsg("Invalid value for FZDTHRSD keyword: (set_compression_pref)");
			ffpmsg(value);
                        return(*status = DATA_COMPRESSION_ERR);
                    }
		}

	        /* set the desired dithering */
		fits_set_dither_seed(outfptr, ivalue, status);

	    } else if (!strncmp(card+2, "I2F", 3) ) {

	        /* set whether to convert integers to float then use lossy compression */
                if (!strcasecmp(value, "t") ) {
		    fits_set_lossy_int (outfptr, 1, status);
		} else if (!strcasecmp(value, "f") ) {
		    fits_set_lossy_int (outfptr, 0, status);
		} else {
		        ffpmsg("Unknown value for FZI2F keyword: (set_compression_pref)");
			ffpmsg(value);
                        return(*status = DATA_COMPRESSION_ERR);
                }

	    } else if (!strncmp(card+2, "HSCALE ", 6) ) {

	        /* set the desired Hcompress scale value */
		hscale = (float) atof(value);
		fits_set_hcomp_scale (outfptr, hscale, status);
            }
	}    
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_get_noise_bits(fitsfile *fptr,  /* I - FITS file pointer   */
           int *noisebits,       /* noise_bits parameter value       */
                                /* (default = 4)                    */
           int *status)         /* IO - error status                */
{
/*
   ********************************************************************
   ********************************************************************
   THIS ROUTINE IS PROVIDED ONLY FOR BACKWARDS COMPATIBILITY;
   ALL NEW SOFTWARE SHOULD CALL fits_set_quantize_level INSTEAD
   ********************************************************************
   ********************************************************************


   This routine returns the value of the noice_bits parameter that
   should be used when compressing floating point images.  The image is
   divided into tiles, and each tile is compressed and stored in a row
   of at variable length binary table column.

   Feb 2008: code changed to use the more general "quantize level" parameter
   rather than the "noise bits" parameter.  If quantize level is greater than
   zero, then the previous noisebits parameter is approximately given by
   
   noise bits = natural logarithm (quantize level) / natural log (2)
   
   This result is rounded to the nearest integer.
*/
    double qlevel;

    qlevel = (fptr->Fptr)->request_quantize_level;

    if (qlevel > 0. && qlevel < 65537. )
         *noisebits =  (int) ((log(qlevel) / log(2.0)) + 0.5);
    else 
        *noisebits = 0;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_get_quantize_level(fitsfile *fptr,  /* I - FITS file pointer   */
           float *qlevel,       /* quantize level parameter value       */
           int *status)         /* IO - error status                */
{
/*
   This routine returns the value of the noice_bits parameter that
   should be used when compressing floating point images.  The image is
   divided into tiles, and each tile is compressed and stored in a row
   of at variable length binary table column.
*/

    if ((fptr->Fptr)->request_quantize_level == NO_QUANTIZE) {
      *qlevel = 0;
    } else {
      *qlevel = (fptr->Fptr)->request_quantize_level;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_get_dither_seed(fitsfile *fptr,  /* I - FITS file pointer   */
           int *offset,       /* dithering offset parameter value       */
           int *status)         /* IO - error status                */
{
/*
   This routine returns the value of the dithering offset parameter that
   is used when compressing floating point images.  The image is
   divided into tiles, and each tile is compressed and stored in a row
   of at variable length binary table column.
*/

    *offset = (fptr->Fptr)->request_dither_seed;
    return(*status);
}/*--------------------------------------------------------------------------*/
int fits_get_hcomp_scale(fitsfile *fptr,  /* I - FITS file pointer   */
           float *scale,          /* Hcompress scale parameter value       */
           int *status)         /* IO - error status                */

{
/*
   This routine returns the value of the noice_bits parameter that
   should be used when compressing floating point images.  The image is
   divided into tiles, and each tile is compressed and stored in a row
   of at variable length binary table column.
*/

    *scale = (fptr->Fptr)->request_hcomp_scale;
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_get_hcomp_smooth(fitsfile *fptr,  /* I - FITS file pointer   */
           int *smooth,          /* Hcompress smooth parameter value       */
           int *status)         /* IO - error status                */

{
    *smooth = (fptr->Fptr)->request_hcomp_smooth;
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_img_compress(fitsfile *infptr, /* pointer to image to be compressed */
                 fitsfile *outfptr, /* empty HDU for output compressed image */
                 int *status)       /* IO - error status               */

/*
   This routine initializes the output table, copies all the keywords,
   and  loops through the input image, compressing the data and
   writing the compressed tiles to the output table.
   
   This is a high level routine that is called by the fpack and funpack
   FITS compression utilities.
*/
{
    int bitpix, naxis;
    long naxes[MAX_COMPRESS_DIM];
/*    int c1, c2, c3; */

    if (*status > 0)
        return(*status);


    /* get datatype and size of input image */
    if (fits_get_img_param(infptr, MAX_COMPRESS_DIM, &bitpix, 
                       &naxis, naxes, status) > 0)
        return(*status);

    if (naxis < 1 || naxis > MAX_COMPRESS_DIM)
    {
        ffpmsg("Image cannot be compressed: NAXIS out of range");
        return(*status = BAD_NAXIS);
    }

    /* create a new empty HDU in the output file now, before setting the */
    /* compression preferences.  This HDU will become a binary table that */
    /* contains the compressed image.  If necessary, create a dummy primary */
    /* array, which much precede the binary table extension. */
    
    ffcrhd(outfptr, status);  /* this does nothing if the output file is empty */

    if ((outfptr->Fptr)->curhdu == 0)  /* have to create dummy primary array */
    {
       ffcrim(outfptr, 16, 0, NULL, status);
       ffcrhd(outfptr, status);
    } else {
        /* unset any compress parameter preferences that may have been
           set when closing the previous HDU in the output file */
        fits_unset_compression_param(outfptr, status);
    }
    
    /* set any compress parameter preferences as given in the input file */
    fits_set_compression_pref(infptr, outfptr, status);

    /* special case: the quantization level is not given by a keyword in  */
    /* the HDU header, so we have to explicitly copy the requested value */
    /* to the actual value */
/* do this in imcomp_get_compressed_image_par, instead
    if ( (outfptr->Fptr)->request_quantize_level != 0.)
        (outfptr->Fptr)->quantize_level = (outfptr->Fptr)->request_quantize_level;
*/
    /* if requested, treat integer images same as a float image. */
    /* Then the pixels will be quantized (lossy algorithm) to achieve */
    /* higher amounts of compression than with lossless algorithms */

    if ( (outfptr->Fptr)->request_lossy_int_compress != 0  && bitpix > 0) 
	bitpix = FLOAT_IMG;  /* compress integer images as if float */

    /* initialize output table */
    if (imcomp_init_table(outfptr, bitpix, naxis, naxes, 0, status) > 0)
        return (*status);    

    /* Copy the image header keywords to the table header. */
    if (imcomp_copy_img2comp(infptr, outfptr, status) > 0)
	    return (*status);

    /* turn off any intensity scaling (defined by BSCALE and BZERO */
    /* keywords) so that unscaled values will be read by CFITSIO */
    /* (except if quantizing an int image, same as a float image) */
    if ( (outfptr->Fptr)->request_lossy_int_compress == 0 && bitpix > 0) 
        ffpscl(infptr, 1.0, 0.0, status);

    /* force a rescan of the output file keywords, so that */
    /* the compression parameters will be copied to the internal */
    /* fitsfile structure used by CFITSIO */
    ffrdef(outfptr, status);

    /* turn off any intensity scaling (defined by BSCALE and BZERO */
    /* keywords) so that unscaled values will be written by CFITSIO */
    /* (except if quantizing an int image, same as a float image) */
    if ( (outfptr->Fptr)->request_lossy_int_compress == 0 && bitpix > 0) 
        ffpscl(outfptr, 1.0, 0.0, status);

    /* Read each image tile, compress, and write to a table row. */
    imcomp_compress_image (infptr, outfptr, status);

    /* force another rescan of the output file keywords, to */
    /* update PCOUNT and TFORMn = '1PB(iii)' keyword values. */
    ffrdef(outfptr, status);

    /* unset any previously set compress parameter preferences */
    fits_unset_compression_request(outfptr, status);

/*
    fits_get_case(&c1, &c2, &c3);
    printf("c1, c2, c3 = %d, %d, %d\n", c1, c2, c3); 
*/

    return (*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_init_table(fitsfile *outfptr,
        int inbitpix,
        int naxis,
        long *naxes,
	int writebitpix,    /* write the ZBITPIX, ZNAXIS, and ZNAXES keyword? */
        int *status)
/* 
  create a BINTABLE extension for the output compressed image.
*/
{
    char keyname[FLEN_KEYWORD], zcmptype[12];
    int ii,  remain,  ncols, bitpix;
    long nrows;
    char *ttype[] = {"COMPRESSED_DATA", "ZSCALE", "ZZERO"};
    char *tform[3];
    char tf0[4], tf1[4], tf2[4];
    char *tunit[] = {"\0",            "\0",            "\0"  };
    char comm[FLEN_COMMENT];
    long actual_tilesize[MAX_COMPRESS_DIM]; /* Actual size to use for tiles */
    
    if (*status > 0)
        return(*status);

    /* check for special case of losslessly compressing floating point */
    /* images.  Only compression algorithm that supports this is GZIP */
    if ( (outfptr->Fptr)->request_quantize_level == NO_QUANTIZE) {
       if (((outfptr->Fptr)->request_compress_type != GZIP_1) &&
           ((outfptr->Fptr)->request_compress_type != GZIP_2)) {
         ffpmsg("Lossless compression of floating point images must use GZIP (imcomp_init_table)");
         return(*status = DATA_COMPRESSION_ERR);
       }
    }
 
     /* set default compression parameter values, if undefined */
    
    if ( (outfptr->Fptr)->request_compress_type == 0) {
	/* use RICE_1 by default */
	(outfptr->Fptr)->request_compress_type = RICE_1;
    }

    if (inbitpix < 0 && (outfptr->Fptr)->request_quantize_level != NO_QUANTIZE) {  
	/* set defaults for quantizing floating point images */
	if ( (outfptr->Fptr)->request_quantize_method == 0) {
	      /* set default dithering method */
              (outfptr->Fptr)->request_quantize_method = SUBTRACTIVE_DITHER_1;
	}

	if ( (outfptr->Fptr)->request_quantize_level == 0) {
	    if ((outfptr->Fptr)->request_quantize_method == NO_DITHER) {
	        /* must use finer quantization if no dithering is done */
	        (outfptr->Fptr)->request_quantize_level = 16; 
	    } else {
	        (outfptr->Fptr)->request_quantize_level = 4; 
	    }
        }
    }

    /* special case: the quantization level is not given by a keyword in  */
    /* the HDU header, so we have to explicitly copy the requested value */
    /* to the actual value */
/* do this in imcomp_get_compressed_image_par, instead
    if ( (outfptr->Fptr)->request_quantize_level != 0.)
        (outfptr->Fptr)->quantize_level = (outfptr->Fptr)->request_quantize_level;
*/
    /* test for the 2 special cases that represent unsigned integers */
    if (inbitpix == USHORT_IMG)
        bitpix = SHORT_IMG;
    else if (inbitpix == ULONG_IMG)
        bitpix = LONG_IMG;
    else if (inbitpix == SBYTE_IMG)
        bitpix = BYTE_IMG;
    else 
        bitpix = inbitpix;

    /* reset default tile dimensions too if required */
    memcpy(actual_tilesize, outfptr->Fptr->request_tilesize, MAX_COMPRESS_DIM * sizeof(long));

    if ((outfptr->Fptr)->request_compress_type == HCOMPRESS_1) {

         if (naxis < 2 ) {
            ffpmsg("Hcompress cannot be used with 1-dimensional images (imcomp_init_table)");
            return(*status = DATA_COMPRESSION_ERR);

	 } else if  (naxes[0] < 4 || naxes[1] < 4) {
            ffpmsg("Hcompress minimum image dimension is 4 pixels (imcomp_init_table)");
            return(*status = DATA_COMPRESSION_ERR);
         }

         if ((actual_tilesize[0] <= 0) &&
             (actual_tilesize[1] == -1) ){
	     
	    /* compress the whole image as a single tile */
             actual_tilesize[0] = naxes[0];
             actual_tilesize[1] = naxes[1];

              for (ii = 2; ii < naxis; ii++) {
	             /* set all higher tile dimensions = 1 */
                     actual_tilesize[ii] = 1;
	      }

         } else if ((actual_tilesize[0] <= 0) &&
             (actual_tilesize[1] == 0 || actual_tilesize[1] == 1) ){
	     
             /*
              The Hcompress algorithm is inherently 2D in nature, so the row by row
	      tiling that is used for other compression algorithms is not appropriate.
	      If the image has less than 30 rows, then the entire image will be compressed
	      as a single tile.  Otherwise the tiles will consist of 16 rows of the image. 
	      This keeps the tiles to a reasonable size, and it also includes enough rows
	      to allow good compression efficiency.  If the last tile of the image 
	      happens to contain less than 4 rows, then find another tile size with
	      between 14 and 30 rows (preferably even), so that the last tile has 
	      at least 4 rows
	     */ 
	      
             /* 1st tile dimension is the row length of the image */
             actual_tilesize[0] = naxes[0];

              if (naxes[1] <= 30) {  /* use whole image if it is small */
                   actual_tilesize[1] = naxes[1];
	      } else {
                /* look for another good tile dimension */
	          if        (naxes[1] % 16 == 0 || naxes[1] % 16 > 3) {
                      actual_tilesize[1] = 16;
		  } else if (naxes[1] % 24 == 0 || naxes[1] % 24 > 3) {
                      actual_tilesize[1] = 24;
		  } else if (naxes[1] % 20 == 0 || naxes[1] % 20 > 3) {
                      actual_tilesize[1] = 20;
		  } else if (naxes[1] % 30 == 0 || naxes[1] % 30 > 3) {
                      actual_tilesize[1] = 30;
		  } else if (naxes[1] % 28 == 0 || naxes[1] % 28 > 3) {
                      actual_tilesize[1] = 28;
		  } else if (naxes[1] % 26 == 0 || naxes[1] % 26 > 3) {
                      actual_tilesize[1] = 26;
		  } else if (naxes[1] % 22 == 0 || naxes[1] % 22 > 3) {
                      actual_tilesize[1] = 22;
		  } else if (naxes[1] % 18 == 0 || naxes[1] % 18 > 3) {
                      actual_tilesize[1] = 18;
		  } else if (naxes[1] % 14 == 0 || naxes[1] % 14 > 3) {
                      actual_tilesize[1] = 14;
		  } else  {
                      actual_tilesize[1] = 17;
		  }
	      }
        } else if (actual_tilesize[0] < 4 ||
                   actual_tilesize[1] < 4) {

            /* user-specified tile size is too small */
            ffpmsg("Hcompress minimum tile dimension is 4 pixels (imcomp_init_table)");
            return(*status = DATA_COMPRESSION_ERR);
	}
	
        /* check if requested tile size causes the last tile to to have less than 4 pixels */
        remain = naxes[0] % (actual_tilesize[0]);  /* 1st dimension */
        if (remain > 0 && remain < 4) {
            (actual_tilesize[0])++; /* try increasing tile size by 1 */
	   
            remain = naxes[0] % (actual_tilesize[0]);
            if (remain > 0 && remain < 4) {
                ffpmsg("Last tile along 1st dimension has less than 4 pixels (imcomp_init_table)");
                return(*status = DATA_COMPRESSION_ERR);	
            }        
        }

        remain = naxes[1] % (actual_tilesize[1]);  /* 2nd dimension */
        if (remain > 0 && remain < 4) {
            (actual_tilesize[1])++; /* try increasing tile size by 1 */
	   
            remain = naxes[1] % (actual_tilesize[1]);
            if (remain > 0 && remain < 4) {
                ffpmsg("Last tile along 2nd dimension has less than 4 pixels (imcomp_init_table)");
                return(*status = DATA_COMPRESSION_ERR);	
            }        
        }

    } /* end, if HCOMPRESS_1 */
    
    for (ii = 0; ii < naxis; ii++) {
	if (ii == 0) { /* first axis is different */
	    if (actual_tilesize[ii] <= 0) {
                actual_tilesize[ii] = naxes[ii]; 
	    }
	} else {
	    if (actual_tilesize[ii] < 0) {
                actual_tilesize[ii] = naxes[ii];  /* negative value maean use whole length */
	    } else if (actual_tilesize[ii] == 0) {
                actual_tilesize[ii] = 1;  /* zero value means use default value = 1 */
	    }
	}
    }

    /* ---- set up array of TFORM strings -------------------------------*/
    if ( (outfptr->Fptr)->request_huge_hdu != 0) {
        strcpy(tf0, "1QB");
    } else {
        strcpy(tf0, "1PB");
    }
    strcpy(tf1, "1D");
    strcpy(tf2, "1D");

    tform[0] = tf0;
    tform[1] = tf1;
    tform[2] = tf2;

    /* calculate number of rows in output table */
    nrows = 1;
    for (ii = 0; ii < naxis; ii++)
    {
        nrows = nrows * ((naxes[ii] - 1)/ (actual_tilesize[ii]) + 1);
    }

    /* determine the default  number of columns in the output table */
    if (bitpix < 0 && (outfptr->Fptr)->request_quantize_level != NO_QUANTIZE)  
        ncols = 3;  /* quantized and scaled floating point image */
    else
        ncols = 1; /* default table has just one 'COMPRESSED_DATA' column */

    if ((outfptr->Fptr)->request_compress_type == RICE_1)
    {
        strcpy(zcmptype, "RICE_1");
    }
    else if ((outfptr->Fptr)->request_compress_type == GZIP_1)
    {
        strcpy(zcmptype, "GZIP_1");
    }
    else if ((outfptr->Fptr)->request_compress_type == GZIP_2)
    {
        strcpy(zcmptype, "GZIP_2");
    }
    else if ((outfptr->Fptr)->request_compress_type == BZIP2_1)
    {
        strcpy(zcmptype, "BZIP2_1");
    }
    else if ((outfptr->Fptr)->request_compress_type == PLIO_1)
    {
        strcpy(zcmptype, "PLIO_1");
       /* the PLIO compression algorithm outputs short integers, not bytes */
        if ( (outfptr->Fptr)->request_huge_hdu != 0) {
            strcpy(tform[0], "1QI");
        } else {
            strcpy(tform[0], "1PI");
        }
    }
    else if ((outfptr->Fptr)->request_compress_type == HCOMPRESS_1)
    {
        strcpy(zcmptype, "HCOMPRESS_1");
    }
    else if ((outfptr->Fptr)->request_compress_type == NOCOMPRESS)
    {
        strcpy(zcmptype, "NOCOMPRESS");
    }    
    else
    {
        ffpmsg("unknown compression type (imcomp_init_table)");
        return(*status = DATA_COMPRESSION_ERR);
    }

    /* create the bintable extension to contain the compressed image */
    ffcrtb(outfptr, BINARY_TBL, nrows, ncols, ttype, 
                tform, tunit, 0, status);

    /* Add standard header keywords. */
    ffpkyl (outfptr, "ZIMAGE", 1, 
           "extension contains compressed image", status);  

    if (writebitpix) {
        /*  write the keywords defining the datatype and dimensions of */
	/*  the uncompressed image.  If not, these keywords will be */
        /*  copied later from the input uncompressed image  */
	   
        ffpkyl (outfptr, "ZSIMPLE", 1,
			"file does conform to FITS standard", status);
        ffpkyj (outfptr, "ZBITPIX", bitpix,
			"data type of original image", status);
        ffpkyj (outfptr, "ZNAXIS", naxis,
			"dimension of original image", status);

        for (ii = 0;  ii < naxis;  ii++)
        {
            sprintf (keyname, "ZNAXIS%d", ii+1);
            ffpkyj (outfptr, keyname, naxes[ii],
			"length of original image axis", status);
        }
    }
                      
    for (ii = 0;  ii < naxis;  ii++)
    {
        sprintf (keyname, "ZTILE%d", ii+1);
        ffpkyj (outfptr, keyname, actual_tilesize[ii],
			"size of tiles to be compressed", status);
    }

    if (bitpix < 0) {
       
	if ((outfptr->Fptr)->request_quantize_level == NO_QUANTIZE) {
	    ffpkys(outfptr, "ZQUANTIZ", "NONE", 
	      "Lossless compression without quantization", status);
	} else {
	    
	    /* Unless dithering has been specifically turned off by setting */
	    /* request_quantize_method = -1, use dithering by default */
	    /* when quantizing floating point images. */
	
	    if ( (outfptr->Fptr)->request_quantize_method == 0) 
              (outfptr->Fptr)->request_quantize_method = SUBTRACTIVE_DITHER_1;
       
	    if ((outfptr->Fptr)->request_quantize_method == SUBTRACTIVE_DITHER_1) {
	      ffpkys(outfptr, "ZQUANTIZ", "SUBTRACTIVE_DITHER_1", 
	        "Pixel Quantization Algorithm", status);

	      /* also write the associated ZDITHER0 keyword with a default value */
	      /* which may get updated later. */
              ffpky(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->request_dither_seed), 
	       "dithering offset when quantizing floats", status);
 
            } else if ((outfptr->Fptr)->request_quantize_method == SUBTRACTIVE_DITHER_2) {
	      ffpkys(outfptr, "ZQUANTIZ", "SUBTRACTIVE_DITHER_2", 
	        "Pixel Quantization Algorithm", status);

	      /* also write the associated ZDITHER0 keyword with a default value */
	      /* which may get updated later. */
              ffpky(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->request_dither_seed), 
	       "dithering offset when quantizing floats", status);

	      if (!strcmp(zcmptype, "RICE_1"))  {
	        /* when using this new dithering method, change the compression type */
		/* to an alias, so that old versions of funpack will not be able to */
		/* created a corrupted uncompressed image. */
		/* ******* can remove this cludge after about June 2015, after most old versions of fpack are gone */
        	strcpy(zcmptype, "RICE_ONE");
	      }

            } else if ((outfptr->Fptr)->request_quantize_method == NO_DITHER) {
	      ffpkys(outfptr, "ZQUANTIZ", "NO_DITHER", 
	        "No dithering during quantization", status);
	    }

	}
    }

    ffpkys (outfptr, "ZCMPTYPE", zcmptype,
	          "compression algorithm", status);

    /* write any algorithm-specific keywords */
    if ((outfptr->Fptr)->request_compress_type == RICE_1)
    {
        ffpkys (outfptr, "ZNAME1", "BLOCKSIZE",
            "compression block size", status);

        /* for now at least, the block size is always 32 */
        ffpkyj (outfptr, "ZVAL1", 32,
			"pixels per block", status);

        ffpkys (outfptr, "ZNAME2", "BYTEPIX",
            "bytes per pixel (1, 2, 4, or 8)", status);

        if (bitpix == BYTE_IMG)
            ffpkyj (outfptr, "ZVAL2", 1,
			"bytes per pixel (1, 2, 4, or 8)", status);
        else if (bitpix == SHORT_IMG)
            ffpkyj (outfptr, "ZVAL2", 2,
			"bytes per pixel (1, 2, 4, or 8)", status);
        else 
            ffpkyj (outfptr, "ZVAL2", 4,
			"bytes per pixel (1, 2, 4, or 8)", status);

    }
    else if ((outfptr->Fptr)->request_compress_type == HCOMPRESS_1)
    {
        ffpkys (outfptr, "ZNAME1", "SCALE",
            "HCOMPRESS scale factor", status);
        ffpkye (outfptr, "ZVAL1", (outfptr->Fptr)->request_hcomp_scale,
		7, "HCOMPRESS scale factor", status);

        ffpkys (outfptr, "ZNAME2", "SMOOTH",
            "HCOMPRESS smooth option", status);
        ffpkyj (outfptr, "ZVAL2", (long) (outfptr->Fptr)->request_hcomp_smooth,
			"HCOMPRESS smooth option", status);
    }

    /* Write the BSCALE and BZERO keywords, if an unsigned integer image */
    if (inbitpix == USHORT_IMG)
    {
        strcpy(comm, "offset data range to that of unsigned short");
        ffpkyg(outfptr, "BZERO", 32768., 0, comm, status);
        strcpy(comm, "default scaling factor");
        ffpkyg(outfptr, "BSCALE", 1.0, 0, comm, status);
    }
    else if (inbitpix == SBYTE_IMG)
    {
        strcpy(comm, "offset data range to that of signed byte");
        ffpkyg(outfptr, "BZERO", -128., 0, comm, status);
        strcpy(comm, "default scaling factor");
        ffpkyg(outfptr, "BSCALE", 1.0, 0, comm, status);
    }
    else if (inbitpix == ULONG_IMG)
    {
        strcpy(comm, "offset data range to that of unsigned long");
        ffpkyg(outfptr, "BZERO", 2147483648., 0, comm, status);
        strcpy(comm, "default scaling factor");
        ffpkyg(outfptr, "BSCALE", 1.0, 0, comm, status);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_calc_max_elem (int comptype, int nx, int zbitpix, int blocksize)

/* This function returns the maximum number of bytes in a compressed
   image line.

    nx = maximum number of pixels in a tile
    blocksize is only relevant for RICE compression
*/
{    
    if (comptype == RICE_1)
    {
        if (zbitpix == 16)
            return (sizeof(short) * nx + nx / blocksize + 2 + 4);
	else
            return (sizeof(float) * nx + nx / blocksize + 2 + 4);
    }
    else if ((comptype == GZIP_1) || (comptype == GZIP_2))
    {
        /* gzip usually compressed by at least a factor of 2 for I*4 images */
        /* and somewhat less for I*2 images */
        /* If this size turns out to be too small, then the gzip */
        /* compression routine will allocate more space as required */
        /* to be on the safe size, allocate buffer same size as input */
	
        if (zbitpix == 16)
            return(nx * 2);
	else if (zbitpix == 8)
            return(nx);
	else
            return(nx * 4);
    }
    else if (comptype == BZIP2_1)
    {
        /* To guarantee that the compressed data will fit, allocate an output
	   buffer of size 1% larger than the uncompressed data, plus 600 bytes */

            return((int) (nx * 1.01 * zbitpix / 8. + 601.));
    }
     else if (comptype == HCOMPRESS_1)
    {
        /* Imperical evidence suggests in the worst case, 
	   the compressed stream could be up to 10% larger than the original
	   image.  Add 26 byte overhead, only significant for very small tiles
	   
         Possible improvement: may need to allow a larger size for 32-bit images */

        if (zbitpix == 16 || zbitpix == 8)
	
            return( (int) (nx * 2.2 + 26));   /* will be compressing 16-bit int array */
        else
            return( (int) (nx * 4.4 + 26));   /* will be compressing 32-bit int array */
    }
    else
        return(nx * sizeof(int));
}
/*--------------------------------------------------------------------------*/
int imcomp_compress_image (fitsfile *infptr, fitsfile *outfptr, int *status)

/* This routine does the following:
        - reads an image one tile at a time
        - if it is a float or double image, then it tries to quantize the pixels
          into scaled integers.
        - it then compressess the integer pixels, or if the it was not
	  possible to quantize the floating point pixels, then it losslessly
	  compresses them with gzip
	- writes the compressed byte stream to the output FITS file
*/
{
    double *tiledata;
    int anynul, gotnulls = 0, datatype;
    long ii, row;
    int naxis;
    double dummy = 0., dblnull = DOUBLENULLVALUE;
    float fltnull = FLOATNULLVALUE;
    long maxtilelen, tilelen, incre[] = {1, 1, 1, 1, 1, 1};
    long naxes[MAX_COMPRESS_DIM], fpixel[MAX_COMPRESS_DIM];
    long lpixel[MAX_COMPRESS_DIM], tile[MAX_COMPRESS_DIM];
    long tilesize[MAX_COMPRESS_DIM];
    long i0, i1, i2, i3, i4, i5;
    char card[FLEN_CARD];

    if (*status > 0)
        return(*status);

    maxtilelen = (outfptr->Fptr)->maxtilelen;

    /* 
     Allocate buffer to hold 1 tile of data; size depends on which compression 
     algorithm is used:

      Rice and GZIP will compress byte, short, or int arrays without conversion.
      PLIO requires 4-byte int values, so byte and short arrays must be converted to int.
      HCompress internally converts byte or short values to ints, and
         converts int values to 8-byte longlong integers.
    */
    
    if ((outfptr->Fptr)->zbitpix == FLOAT_IMG)
    {
        datatype = TFLOAT;

        if ( (outfptr->Fptr)->compress_type == HCOMPRESS_1) {
	    /* need twice as much scratch space (8 bytes per pixel) */
            tiledata = (double*) malloc (maxtilelen * 2 *sizeof (float));	
	} else {
            tiledata = (double*) malloc (maxtilelen * sizeof (float));
	}
    }
    else if ((outfptr->Fptr)->zbitpix == DOUBLE_IMG)
    {
        datatype = TDOUBLE;
        tiledata = (double*) malloc (maxtilelen * sizeof (double));
    }
    else if ((outfptr->Fptr)->zbitpix == SHORT_IMG)
    {
        datatype = TSHORT;
        if ( (outfptr->Fptr)->compress_type == RICE_1  ||
	     (outfptr->Fptr)->compress_type == GZIP_1  ||
	     (outfptr->Fptr)->compress_type == GZIP_2  ||
	     (outfptr->Fptr)->compress_type == BZIP2_1 ||
             (outfptr->Fptr)->compress_type == NOCOMPRESS) {
	    /* only need  buffer of I*2 pixels for gzip, bzip2, and Rice */

            tiledata = (double*) malloc (maxtilelen * sizeof (short));	
	} else {
 	    /*  need  buffer of I*4 pixels for Hcompress and PLIO */
            tiledata = (double*) malloc (maxtilelen * sizeof (int));
        }
    }
    else if ((outfptr->Fptr)->zbitpix == BYTE_IMG)
    {

        datatype = TBYTE;
        if ( (outfptr->Fptr)->compress_type == RICE_1  ||
	     (outfptr->Fptr)->compress_type == BZIP2_1 ||
	     (outfptr->Fptr)->compress_type == GZIP_1  ||
	     (outfptr->Fptr)->compress_type == GZIP_2) {
	    /* only need  buffer of I*1 pixels for gzip, bzip2, and Rice */

            tiledata = (double*) malloc (maxtilelen);	
	} else {
 	    /*  need  buffer of I*4 pixels for Hcompress and PLIO */
            tiledata = (double*) malloc (maxtilelen * sizeof (int));
        }
    }
    else if ((outfptr->Fptr)->zbitpix == LONG_IMG)
    {
        datatype = TINT;
        if ( (outfptr->Fptr)->compress_type == HCOMPRESS_1) {
	    /* need twice as much scratch space (8 bytes per pixel) */

            tiledata = (double*) malloc (maxtilelen * 2 * sizeof (int));	
	} else {
 	    /* only need  buffer of I*4 pixels for gzip, bzip2,  Rice, and PLIO */

            tiledata = (double*) malloc (maxtilelen * sizeof (int));
        }
    }
    else
    {
	ffpmsg("Bad image datatype. (imcomp_compress_image)");
	return (*status = MEMORY_ALLOCATION);
    }
    
    if (tiledata == NULL)
    {
	ffpmsg("Out of memory. (imcomp_compress_image)");
	return (*status = MEMORY_ALLOCATION);
    }

    /*  calculate size of tile in each dimension */
    naxis = (outfptr->Fptr)->zndim;
    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        if (ii < naxis)
        {
             naxes[ii] = (outfptr->Fptr)->znaxis[ii];
             tilesize[ii] = (outfptr->Fptr)->tilesize[ii];
        }
        else
        {
            naxes[ii] = 1;
            tilesize[ii] = 1;
        }
    }
    row = 1;

    /* set up big loop over up to 6 dimensions */
    for (i5 = 1; i5 <= naxes[5]; i5 += tilesize[5])
    {
     fpixel[5] = i5;
     lpixel[5] = minvalue(i5 + tilesize[5] - 1, naxes[5]);
     tile[5] = lpixel[5] - fpixel[5] + 1;
     for (i4 = 1; i4 <= naxes[4]; i4 += tilesize[4])
     {
      fpixel[4] = i4;
      lpixel[4] = minvalue(i4 + tilesize[4] - 1, naxes[4]);
      tile[4] = lpixel[4] - fpixel[4] + 1;
      for (i3 = 1; i3 <= naxes[3]; i3 += tilesize[3])
      {
       fpixel[3] = i3;
       lpixel[3] = minvalue(i3 + tilesize[3] - 1, naxes[3]);
       tile[3] = lpixel[3] - fpixel[3] + 1;
       for (i2 = 1; i2 <= naxes[2]; i2 += tilesize[2])
       {
        fpixel[2] = i2;
        lpixel[2] = minvalue(i2 + tilesize[2] - 1, naxes[2]);
        tile[2] = lpixel[2] - fpixel[2] + 1;
        for (i1 = 1; i1 <= naxes[1]; i1 += tilesize[1])
        {
         fpixel[1] = i1;
         lpixel[1] = minvalue(i1 + tilesize[1] - 1, naxes[1]);
         tile[1] = lpixel[1] - fpixel[1] + 1;
         for (i0 = 1; i0 <= naxes[0]; i0 += tilesize[0])
         {
          fpixel[0] = i0;
          lpixel[0] = minvalue(i0 + tilesize[0] - 1, naxes[0]);
          tile[0] = lpixel[0] - fpixel[0] + 1;

          /* number of pixels in this tile */
          tilelen = tile[0];
          for (ii = 1; ii < naxis; ii++)
          {
             tilelen *= tile[ii];
          }

          /* read next tile of data from image */
	  anynul = 0;
          if (datatype == TFLOAT)
          {
              ffgsve(infptr, 1, naxis, naxes, fpixel, lpixel, incre, 
                  FLOATNULLVALUE, (float *) tiledata,  &anynul, status);
          }
          else if (datatype == TDOUBLE)
          {
              ffgsvd(infptr, 1, naxis, naxes, fpixel, lpixel, incre, 
                  DOUBLENULLVALUE, tiledata, &anynul, status);
          }
          else if (datatype == TINT)
          {
              ffgsvk(infptr, 1, naxis, naxes, fpixel, lpixel, incre, 
                  0, (int *) tiledata,  &anynul, status);
          }
          else if (datatype == TSHORT)
          {
              ffgsvi(infptr, 1, naxis, naxes, fpixel, lpixel, incre, 
                  0, (short *) tiledata,  &anynul, status);
          }
          else if (datatype == TBYTE)
          {
              ffgsvb(infptr, 1, naxis, naxes, fpixel, lpixel, incre, 
                  0, (unsigned char *) tiledata,  &anynul, status);
          }
          else 
          {
              ffpmsg("Error bad datatype of image tile to compress");
              free(tiledata);
              return (*status);
          }

          /* now compress the tile, and write to row of binary table */
          /*   NOTE: we don't have to worry about the presence of null values in the
	       array if it is an integer array:  the null value is simply encoded
	       in the compressed array just like any other pixel value.  
	       
	       If it is a floating point array, then we need to check for null
	       only if the anynul parameter returned a true value when reading the tile
	  */
          if (anynul && datatype == TFLOAT) {
              imcomp_compress_tile(outfptr, row, datatype, tiledata, tilelen,
                               tile[0], tile[1], 1, &fltnull, status);
          } else if (anynul && datatype == TDOUBLE) {
              imcomp_compress_tile(outfptr, row, datatype, tiledata, tilelen,
                               tile[0], tile[1], 1, &dblnull, status);
          } else {
              imcomp_compress_tile(outfptr, row, datatype, tiledata, tilelen,
                               tile[0], tile[1], 0, &dummy, status);
          }

          /* set flag if we found any null values */
          if (anynul)
              gotnulls = 1;

          /* check for any error in the previous operations */
          if (*status > 0)
          {
              ffpmsg("Error writing compressed image to table");
              free(tiledata);
              return (*status);
          }

	  row++;
         }
        }
       }
      }
     }
    }

    free (tiledata);  /* finished with this buffer */

    /* insert ZBLANK keyword if necessary; only for TFLOAT or TDOUBLE images */
    if (gotnulls)
    {
          ffgcrd(outfptr, "ZCMPTYPE", card, status);
          ffikyj(outfptr, "ZBLANK", COMPRESS_NULL_VALUE, 
             "null value in the compressed integer array", status);
    }

    return (*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_compress_tile (fitsfile *outfptr,
    long row,  /* tile number = row in the binary table that holds the compressed data */
    int datatype, 
    void *tiledata, 
    long tilelen,
    long tilenx,
    long tileny,
    int nullcheck,
    void *nullflagval,
    int *status)

/*
   This is the main compression routine.

   This routine does the following to the input tile of pixels:
        - if it is a float or double image, then it quantizes the pixels
        - compresses the integer pixel values
        - writes the compressed byte stream to the FITS file.

   If the tile cannot be quantized than the raw float or double values
   are losslessly compressed with gzip and then written to the output table.
   
   This input array may be modified by this routine.  If the array is of type TINT
   or TFLOAT, and the compression type is HCOMPRESS, then it must have been 
   allocated to be twice as large (8 bytes per pixel) to provide scratch space.

  Note that this routine does not fully support the implicit datatype conversion that
  is supported when writing to normal FITS images.  The datatype of the input array
  must have the same datatype (either signed or unsigned) as the output (compressed)
  FITS image in some cases.
*/
{
    int *idata;		/* quantized integer data */
    int cn_zblank, zbitpix, nullval;
    int flag = 1;  /* true by default; only = 0 if float data couldn't be quantized */
    int intlength;      /* size of integers to be compressed */
    double scale, zero, actual_bzero;
    long ii;
    size_t clen;		/* size of cbuf */
    short *cbuf;	/* compressed data */
    int  nelem = 0;		/* number of bytes */
    int tilecol;
    size_t gzip_nelem = 0;
    unsigned int bzlen;
    int ihcompscale;
    float hcompscale;
    double noise2, noise3, noise5;
    double bscale[1] = {1.}, bzero[1] = {0.};	/* scaling parameters */
    long  hcomp_len;
    LONGLONG *lldata;

    if (*status > 0)
        return(*status);

    /* check for special case of losslessly compressing floating point */
    /* images.  Only compression algorithm that supports this is GZIP */
    if ( (outfptr->Fptr)->quantize_level == NO_QUANTIZE) {
       if (((outfptr->Fptr)->compress_type != GZIP_1) &&
           ((outfptr->Fptr)->compress_type != GZIP_2)) {
         ffpmsg("Lossless compression of floating point images must use GZIP (imcomp_compress_tile)");
         return(*status = DATA_COMPRESSION_ERR);
       }
    }

    /* free the previously saved tile if the input tile is for the same row */
    if ((outfptr->Fptr)->tilerow) {  /* has the tile cache been allocated? */

      /* calculate the column bin of the compressed tile */
      tilecol = (row - 1) % ((long)(((outfptr->Fptr)->znaxis[0] - 1) / ((outfptr->Fptr)->tilesize[0])) + 1);
      
      if ((outfptr->Fptr)->tilerow[tilecol] == row) {
        if (((outfptr->Fptr)->tiledata)[tilecol]) {
            free(((outfptr->Fptr)->tiledata)[tilecol]);
        }
	  
        if (((outfptr->Fptr)->tilenullarray)[tilecol]) {
            free(((outfptr->Fptr)->tilenullarray)[tilecol]);
        }

        ((outfptr->Fptr)->tiledata)[tilecol] = 0;
        ((outfptr->Fptr)->tilenullarray)[tilecol] = 0;
        (outfptr->Fptr)->tilerow[tilecol] = 0;
        (outfptr->Fptr)->tiledatasize[tilecol] = 0;
        (outfptr->Fptr)->tiletype[tilecol] = 0;
        (outfptr->Fptr)->tileanynull[tilecol] = 0;
      }
    }

    if ( (outfptr->Fptr)->compress_type == NOCOMPRESS) {
         /* Special case when using NOCOMPRESS for diagnostic purposes in fpack */
         if (imcomp_write_nocompress_tile(outfptr, row, datatype, tiledata, tilelen, 
	     nullcheck, nullflagval, status) > 0) {
             return(*status);
         }
         return(*status);
    }

    /* =========================================================================== */
    /* initialize various parameters */
    idata = (int *) tiledata;   /* may overwrite the input tiledata in place */

    /* zbitpix is the BITPIX keyword value in the uncompressed FITS image */
    zbitpix = (outfptr->Fptr)->zbitpix;

    /* if the tile/image has an integer datatype, see if a null value has */
    /* been defined (with the BLANK keyword in a normal FITS image).  */
    /* If so, and if the input tile array also contains null pixels, */
    /* (represented by pixels that have a value = nullflagval) then  */
    /* any pixels whose value = nullflagval, must be set to the value = nullval */
    /* before the pixel array is compressed.  These null pixel values must */
    /* not be inverse scaled by the BSCALE/BZERO values, if present. */

    cn_zblank = (outfptr->Fptr)->cn_zblank;
    nullval = (outfptr->Fptr)->zblank;

    if (zbitpix > 0 && cn_zblank != -1)  /* If the integer image has no defined null */
        nullcheck = 0;    /* value, then don't bother checking input array for nulls. */

    /* if the BSCALE and BZERO keywords exist, then the input values must */
    /* be inverse scaled by this factor, before the values are compressed. */
    /* (The program may have turned off scaling, which over rides the keywords) */
    
    scale = (outfptr->Fptr)->cn_bscale;
    zero  = (outfptr->Fptr)->cn_bzero;
    actual_bzero = (outfptr->Fptr)->cn_actual_bzero;

    /* =========================================================================== */
    /* prepare the tile of pixel values for compression */
    if (datatype == TSHORT) {
       imcomp_convert_tile_tshort(outfptr, tiledata, tilelen, nullcheck, nullflagval,
           nullval, zbitpix, scale, zero, actual_bzero, &intlength, status);
    } else if (datatype == TUSHORT) {
       imcomp_convert_tile_tushort(outfptr, tiledata, tilelen, nullcheck, nullflagval,
           nullval, zbitpix, scale, zero, &intlength, status);
    } else if (datatype == TBYTE) {
       imcomp_convert_tile_tbyte(outfptr, tiledata, tilelen, nullcheck, nullflagval,
           nullval, zbitpix, scale, zero,  &intlength, status);
    } else if (datatype == TSBYTE) {
       imcomp_convert_tile_tsbyte(outfptr, tiledata, tilelen, nullcheck, nullflagval,
           nullval, zbitpix, scale, zero,  &intlength, status);
    } else if (datatype == TINT) {
       imcomp_convert_tile_tint(outfptr, tiledata, tilelen, nullcheck, nullflagval,
           nullval, zbitpix, scale, zero, &intlength, status);
    } else if (datatype == TUINT) {
       imcomp_convert_tile_tuint(outfptr, tiledata, tilelen, nullcheck, nullflagval,
           nullval, zbitpix, scale, zero, &intlength, status);
    } else if (datatype == TLONG && sizeof(long) == 8) {
           ffpmsg("Integer*8 Long datatype is not supported when writing to compressed images");
           return(*status = BAD_DATATYPE);
    } else if (datatype == TULONG && sizeof(long) == 8) {
           ffpmsg("Unsigned integer*8 datatype is not supported when writing to compressed images");
           return(*status = BAD_DATATYPE);
    } else if (datatype == TFLOAT) {
        imcomp_convert_tile_tfloat(outfptr, row, tiledata, tilelen, tilenx, tileny, nullcheck,
        nullflagval, nullval, zbitpix, scale, zero, &intlength, &flag, bscale, bzero, status);
    } else if (datatype == TDOUBLE) {
       imcomp_convert_tile_tdouble(outfptr, row, tiledata, tilelen, tilenx, tileny, nullcheck,
       nullflagval, nullval, zbitpix, scale, zero, &intlength, &flag, bscale, bzero, status);
    } else {
          ffpmsg("unsupported image datatype (imcomp_compress_tile)");
          return(*status = BAD_DATATYPE);
    }

    if (*status > 0)
      return(*status);      /* return if error occurs */

    /* =========================================================================== */
    if (flag)   /* now compress the integer data array */
    {
        /* allocate buffer for the compressed tile bytes */
        clen = (outfptr->Fptr)->maxelem;
        cbuf = (short *) calloc (clen, sizeof (unsigned char));

        if (cbuf == NULL) {
            ffpmsg("Memory allocation failure. (imcomp_compress_tile)");
	    return (*status = MEMORY_ALLOCATION);
        }

        /* =========================================================================== */
        if ( (outfptr->Fptr)->compress_type == RICE_1)
        {
            if (intlength == 2) {
  	        nelem = fits_rcomp_short ((short *)idata, tilelen, (unsigned char *) cbuf,
                       clen, (outfptr->Fptr)->rice_blocksize);
            } else if (intlength == 1) {
  	        nelem = fits_rcomp_byte ((signed char *)idata, tilelen, (unsigned char *) cbuf,
                       clen, (outfptr->Fptr)->rice_blocksize);
            } else {
  	        nelem = fits_rcomp (idata, tilelen, (unsigned char *) cbuf,
                       clen, (outfptr->Fptr)->rice_blocksize);
            }

	    if (nelem < 0)  /* data compression error condition */
            {
	        free (cbuf);
                ffpmsg("error Rice compressing image tile (imcomp_compress_tile)");
                return (*status = DATA_COMPRESSION_ERR);
            }

	    /* Write the compressed byte stream. */
            ffpclb(outfptr, (outfptr->Fptr)->cn_compressed, row, 1,
                     nelem, (unsigned char *) cbuf, status);
        }

        /* =========================================================================== */
        else if ( (outfptr->Fptr)->compress_type == PLIO_1)
        {
              for (ii = 0; ii < tilelen; ii++)  {
                if (idata[ii] < 0 || idata[ii] > 16777215)
                {
                   /* plio algorithn only supports positive 24 bit ints */
                   ffpmsg("data out of range for PLIO compression (0 - 2**24)");
                   return(*status = DATA_COMPRESSION_ERR);
                }
              }

  	      nelem = pl_p2li (idata, 1, cbuf, tilelen);

	      if (nelem < 0)  /* data compression error condition */
              {
	        free (cbuf);
                ffpmsg("error PLIO compressing image tile (imcomp_compress_tile)");
                return (*status = DATA_COMPRESSION_ERR);
              }

	      /* Write the compressed byte stream. */
              ffpcli(outfptr, (outfptr->Fptr)->cn_compressed, row, 1,
                     nelem, cbuf, status);
        }

        /* =========================================================================== */
        else if ( ((outfptr->Fptr)->compress_type == GZIP_1) ||
                  ((outfptr->Fptr)->compress_type == GZIP_2) )   {

	    if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE && datatype == TFLOAT) {
	      /* Special case of losslessly compressing floating point pixels with GZIP */
	      /* In this case we compress the input tile array directly */

#if BYTESWAPPED
               ffswap4((int*) tiledata, tilelen); 
#endif
               if ( (outfptr->Fptr)->compress_type == GZIP_2 )
		    fits_shuffle_4bytes((char *) tiledata, tilelen, status);

                compress2mem_from_mem((char *) tiledata, tilelen * sizeof(float),
                    (char **) &cbuf,  &clen, realloc, &gzip_nelem, status);

	    } else if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE && datatype == TDOUBLE) {
	      /* Special case of losslessly compressing double pixels with GZIP */
	      /* In this case we compress the input tile array directly */

#if BYTESWAPPED
               ffswap8((double *) tiledata, tilelen); 
#endif
               if ( (outfptr->Fptr)->compress_type == GZIP_2 )
		    fits_shuffle_8bytes((char *) tiledata, tilelen, status);

                compress2mem_from_mem((char *) tiledata, tilelen * sizeof(double),
                    (char **) &cbuf,  &clen, realloc, &gzip_nelem, status);

	    } else {

	        /* compress the integer idata array */

#if BYTESWAPPED
	       if (intlength == 2)
                 ffswap2((short *) idata, tilelen); 
	       else if (intlength == 4)
                 ffswap4(idata, tilelen); 
#endif

               if (intlength == 2) {

                  if ( (outfptr->Fptr)->compress_type == GZIP_2 )
		    fits_shuffle_2bytes((char *) tiledata, tilelen, status);

                  compress2mem_from_mem((char *) idata, tilelen * sizeof(short),
                   (char **) &cbuf,  &clen, realloc, &gzip_nelem, status);

               } else if (intlength == 1) {

                  compress2mem_from_mem((char *) idata, tilelen * sizeof(unsigned char),
                   (char **) &cbuf,  &clen, realloc, &gzip_nelem, status);

               } else {

                  if ( (outfptr->Fptr)->compress_type == GZIP_2 )
		    fits_shuffle_4bytes((char *) tiledata, tilelen, status);

                  compress2mem_from_mem((char *) idata, tilelen * sizeof(int),
                   (char **) &cbuf,  &clen, realloc, &gzip_nelem, status);
               }
            }

	    /* Write the compressed byte stream. */
            ffpclb(outfptr, (outfptr->Fptr)->cn_compressed, row, 1,
                     gzip_nelem, (unsigned char *) cbuf, status);

        /* =========================================================================== */
        } else if ( (outfptr->Fptr)->compress_type == BZIP2_1) {

#if BYTESWAPPED
	   if (intlength == 2)
               ffswap2((short *) idata, tilelen); 
	   else if (intlength == 4)
               ffswap4(idata, tilelen); 
#endif

           bzlen = (unsigned int) clen;
	   
           /* call bzip2 with blocksize = 900K, verbosity = 0, and default workfactor */

/*  bzip2 is not supported in the public release.  This is only for test purposes.
           if (BZ2_bzBuffToBuffCompress( (char *) cbuf, &bzlen,
	         (char *) idata, (unsigned int) (tilelen * intlength), 9, 0, 0) ) 
*/
	   {
                   ffpmsg("bzip2 compression error");
                   return(*status = DATA_COMPRESSION_ERR);
           }

	    /* Write the compressed byte stream. */
            ffpclb(outfptr, (outfptr->Fptr)->cn_compressed, row, 1,
                     bzlen, (unsigned char *) cbuf, status);

        /* =========================================================================== */
        }  else if ( (outfptr->Fptr)->compress_type == HCOMPRESS_1)     {
	    /*
	      if hcompscale is positive, then we have to multiply
	      the value by the RMS background noise to get the 
	      absolute scale value.  If negative, then it gives the
	      absolute scale value directly.
	    */
            hcompscale = (outfptr->Fptr)->hcomp_scale;

	    if (hcompscale > 0.) {
	       fits_img_stats_int(idata, tilenx, tileny, nullcheck,
	                nullval, 0,0,0,0,0,0,&noise2,&noise3,&noise5,status);

		/* use the minimum of the 3 noise estimates */
		if (noise2 != 0. && noise2 < noise3) noise3 = noise2;
		if (noise5 != 0. && noise5 < noise3) noise3 = noise5;
		
		hcompscale = (float) (hcompscale * noise3);

	    } else if (hcompscale < 0.) {

		hcompscale = hcompscale * -1.0F;
	    }

	    ihcompscale = (int) (hcompscale + 0.5);

            hcomp_len = clen;  /* allocated size of the buffer */
	    
            if (zbitpix == BYTE_IMG || zbitpix == SHORT_IMG) {
                fits_hcompress(idata, tilenx, tileny, 
		  ihcompscale, (char *) cbuf, &hcomp_len, status);

            } else {
                 /* have to convert idata to an I*8 array, in place */
                 /* idata must have been allocated large enough to do this */
                lldata = (LONGLONG *) idata;
		
                for (ii = tilelen - 1; ii >= 0; ii--) {
		    lldata[ii] = idata[ii];
		}

                fits_hcompress64(lldata, tilenx, tileny, 
		  ihcompscale, (char *) cbuf, &hcomp_len, status);
            }

	    /* Write the compressed byte stream. */
            ffpclb(outfptr, (outfptr->Fptr)->cn_compressed, row, 1,
                     hcomp_len, (unsigned char *) cbuf, status);
        }

        /* =========================================================================== */
        if ((outfptr->Fptr)->cn_zscale > 0)
        {
              /* write the linear scaling parameters for this tile */
	      ffpcld (outfptr, (outfptr->Fptr)->cn_zscale, row, 1, 1,
                      bscale, status);
	      ffpcld (outfptr, (outfptr->Fptr)->cn_zzero,  row, 1, 1,
                      bzero,  status);
        }

        free(cbuf);  /* finished with this buffer */

    /* =========================================================================== */
    } else {    /* if flag == 0., floating point data couldn't be quantized */

	 /* losslessly compress the data with gzip. */

         /* if gzip2 compressed data column doesn't exist, create it */
         if ((outfptr->Fptr)->cn_gzip_data < 1) {
              if ( (outfptr->Fptr)->request_huge_hdu != 0) {
                 fits_insert_col(outfptr, 999, "GZIP_COMPRESSED_DATA", "1QB", status);
              } else {
                 fits_insert_col(outfptr, 999, "GZIP_COMPRESSED_DATA", "1PB", status);
              }

                 if (*status <= 0)  /* save the number of this column */
                       ffgcno(outfptr, CASEINSEN, "GZIP_COMPRESSED_DATA",
                                &(outfptr->Fptr)->cn_gzip_data, status);
         }

         if (datatype == TFLOAT)  {
               /* allocate buffer for the compressed tile bytes */
	       /* make it 10% larger than the original uncompressed data */
               clen = (size_t) (tilelen * sizeof(float) * 1.1);
               cbuf = (short *) calloc (clen, sizeof (unsigned char));

               if (cbuf == NULL)
               {
                   ffpmsg("Memory allocation error. (imcomp_compress_tile)");
	           return (*status = MEMORY_ALLOCATION);
               }

	       /* convert null values to NaNs in place, if necessary */
	       if (nullcheck == 1) {
	           imcomp_float2nan((float *) tiledata, tilelen, (int *) tiledata,
	               *(float *) (nullflagval), status);
	       }

#if BYTESWAPPED
               ffswap4((int*) tiledata, tilelen); 
#endif
               compress2mem_from_mem((char *) tiledata, tilelen * sizeof(float),
                    (char **) &cbuf,  &clen, realloc, &gzip_nelem, status);

         } else if (datatype == TDOUBLE) {

               /* allocate buffer for the compressed tile bytes */
	       /* make it 10% larger than the original uncompressed data */
               clen = (size_t) (tilelen * sizeof(double) * 1.1);
               cbuf = (short *) calloc (clen, sizeof (unsigned char));

               if (cbuf == NULL)
               {
                   ffpmsg("Memory allocation error. (imcomp_compress_tile)");
	           return (*status = MEMORY_ALLOCATION);
               }

	       /* convert null values to NaNs in place, if necessary */
	       if (nullcheck == 1) {
	           imcomp_double2nan((double *) tiledata, tilelen, (LONGLONG *) tiledata,
	               *(double *) (nullflagval), status);
	       }

#if BYTESWAPPED
               ffswap8((double*) tiledata, tilelen); 
#endif
               compress2mem_from_mem((char *) tiledata, tilelen * sizeof(double),
                    (char **) &cbuf,  &clen, realloc, &gzip_nelem, status);
        }

	/* Write the compressed byte stream. */
        ffpclb(outfptr, (outfptr->Fptr)->cn_gzip_data, row, 1,
             gzip_nelem, (unsigned char *) cbuf, status);

        free(cbuf);  /* finished with this buffer */
    }

    return(*status);
}

/*--------------------------------------------------------------------------*/
int imcomp_write_nocompress_tile(fitsfile *outfptr,
    long row,
    int datatype, 
    void *tiledata, 
    long tilelen,
    int nullcheck,
    void *nullflagval,
    int *status)
{
    char coltype[4];

    /* Write the uncompressed image tile pixels to the tile-compressed image file. */
    /* This is a special case when using NOCOMPRESS for diagnostic purposes in fpack. */ 
    /* Currently, this only supports a limited number of data types and */
    /* does not fully support null-valued pixels in the image. */

    if ((outfptr->Fptr)->cn_uncompressed < 1) {
        /* uncompressed data column doesn't exist, so append new column to table */
        if (datatype == TSHORT) {
	    strcpy(coltype, "1PI");
	} else if (datatype == TINT) {
	    strcpy(coltype, "1PJ");
	} else if (datatype == TFLOAT) {
	    strcpy(coltype, "1QE");
        } else {
	    ffpmsg("NOCOMPRESSION option only supported for int*2, int*4, and float*4 images");
            return(*status = DATA_COMPRESSION_ERR);
        }

        fits_insert_col(outfptr, 999, "UNCOMPRESSED_DATA", coltype, status); /* create column */
    }

    fits_get_colnum(outfptr, CASEINSEN, "UNCOMPRESSED_DATA",
                    &(outfptr->Fptr)->cn_uncompressed, status);  /* save col. num. */
    
    fits_write_col(outfptr, datatype, (outfptr->Fptr)->cn_uncompressed, row, 1,
                      tilelen, tiledata, status);  /* write the tile data */
    return (*status);
}
 /*--------------------------------------------------------------------------*/
int imcomp_convert_tile_tshort(
    fitsfile *outfptr,
    void *tiledata, 
    long tilelen,
    int nullcheck,
    void *nullflagval,
    int nullval,
    int zbitpix,
    double scale,
    double zero,
    double actual_bzero,
    int *intlength,
    int *status)
{
    /*  Prepare the input tile array of pixels for compression. */
    /*  Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */
    /*  If needed, convert 4 or 8-byte ints and do null value substitution. */
    /*  Note that the calling routine must have allocated the input array big enough */
    /* to be able to do this.  */

    short *sbuff;
    int flagval, *idata;
    long ii;
    
       /* We only support writing this integer*2 tile data to a FITS image with 
          BITPIX = 16 and with BZERO = 0 and BSCALE = 1.  */
	  
       if (zbitpix != SHORT_IMG || scale != 1.0 || zero != 0.0) {
           ffpmsg("Datatype conversion/scaling is not supported when writing to compressed images");
           return(*status = DATA_COMPRESSION_ERR);
       } 

       sbuff = (short *) tiledata;
       idata = (int *) tiledata;
       
       if ( (outfptr->Fptr)->compress_type == RICE_1 || (outfptr->Fptr)->compress_type == GZIP_1
         || (outfptr->Fptr)->compress_type == GZIP_2 || (outfptr->Fptr)->compress_type == BZIP2_1 ) 
       {
           /* don't have to convert to int if using gzip, bzip2 or Rice compression */
           *intlength = 2;
             
           if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression */
               flagval = *(short *) (nullflagval);
               if (flagval != nullval) {
                  for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (sbuff[ii] == (short) flagval)
		       sbuff[ii] = (short) nullval;
                  }
               }
           }
       } else if ((outfptr->Fptr)->compress_type == HCOMPRESS_1) {
           /* have to convert to int if using HCOMPRESS */
           *intlength = 4;

           if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression */
               flagval = *(short *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (sbuff[ii] == (short) flagval)
		       idata[ii] = nullval;
                    else
                       idata[ii] = (int) sbuff[ii];
               }
           } else {  /* just do the data type conversion to int */
               for (ii = tilelen - 1; ii >= 0; ii--) 
                   idata[ii] = (int) sbuff[ii];
           }
       } else {
           /* have to convert to int if using PLIO */
           *intlength = 4;
           if (zero == 0. && actual_bzero == 32768.) {
             /* Here we are compressing unsigned 16-bit integers that have */
	     /* been offset by -32768 using the standard FITS convention. */
	     /* Since PLIO cannot deal with negative values, we must apply */
	     /* the shift of 32786 to the values to make them all positive. */
	     /* The inverse negative shift will be applied in */
	     /* imcomp_decompress_tile when reading the compressed tile. */
             if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression */
               flagval = *(short *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (sbuff[ii] == (short) flagval)
		       idata[ii] = nullval;
                    else
                       idata[ii] = (int) sbuff[ii] + 32768;
               }
             } else {  /* just do the data type conversion to int */
               for (ii = tilelen - 1; ii >= 0; ii--) 
                   idata[ii] = (int) sbuff[ii] + 32768;
             }
           } else {
	     /* This is not an unsigned 16-bit integer array, so process normally */
             if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression */
               flagval = *(short *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (sbuff[ii] == (short) flagval)
		       idata[ii] = nullval;
                    else
                       idata[ii] = (int) sbuff[ii];
               }
             } else {  /* just do the data type conversion to int */
               for (ii = tilelen - 1; ii >= 0; ii--) 
                   idata[ii] = (int) sbuff[ii];
             }
           }
        }
        return(*status);
}
 /*--------------------------------------------------------------------------*/
int imcomp_convert_tile_tushort(
    fitsfile *outfptr,
    void *tiledata, 
    long tilelen,
    int nullcheck,
    void *nullflagval,
    int nullval,
    int zbitpix,
    double scale,
    double zero,
    int *intlength,
    int *status)
{
    /*  Prepare the input  tile array of pixels for compression. */
    /*  Convert input unsigned integer*2 tile array in place to 4 or 8-byte ints for compression, */
    /*  If needed, convert 4 or 8-byte ints and do null value substitution. */
    /*  Note that the calling routine must have allocated the input array big enough */
    /* to be able to do this.  */

    unsigned short *usbuff;
    short *sbuff;
    int flagval, *idata;
    long ii;
    
       /* datatype of input array is unsigned short.  We only support writing this datatype
          to a FITS image with BITPIX = 16 and with BZERO = 0 and BSCALE = 32768.  */

       if (zbitpix != SHORT_IMG || scale != 1.0 || zero != 32768.) {
           ffpmsg("Implicit datatype conversion is not supported when writing to compressed images");
           return(*status = DATA_COMPRESSION_ERR);
       } 

       usbuff = (unsigned short *) tiledata;
       sbuff = (short *) tiledata;
       idata = (int *) tiledata;

       if ((outfptr->Fptr)->compress_type == RICE_1 || (outfptr->Fptr)->compress_type == GZIP_1
        || (outfptr->Fptr)->compress_type == GZIP_2 || (outfptr->Fptr)->compress_type == BZIP2_1) 
       {
           /* don't have to convert to int if using gzip, bzip2, or Rice compression */
           *intlength = 2;

          /* offset the unsigned value by -32768 to a signed short value. */
	  /* It is more efficient to do this by just flipping the most significant of the 16 bits */

           if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression  */
               flagval = *(unsigned short *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (usbuff[ii] == (unsigned short) flagval)
		       sbuff[ii] = (short) nullval;
                    else
		       usbuff[ii] =  (usbuff[ii]) ^ 0x8000;
               }
           } else {
               /* just offset the pixel values by 32768 (by flipping the MSB */
               for (ii = tilelen - 1; ii >= 0; ii--)
		       usbuff[ii] =  (usbuff[ii]) ^ 0x8000;
           }
       } else {
           /* have to convert to int if using HCOMPRESS or PLIO */
           *intlength = 4;

           if (nullcheck == 1) {
               /* offset the pixel values by 32768, and */
               /* reset pixels equal to flagval to nullval */
               flagval = *(unsigned short *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (usbuff[ii] == (unsigned short) flagval)
		       idata[ii] = nullval;
                    else
		       idata[ii] = ((int) usbuff[ii]) - 32768;
               }
           } else {  /* just do the data type conversion to int */
               for (ii = tilelen - 1; ii >= 0; ii--)
		       idata[ii] = ((int) usbuff[ii]) - 32768;
           }
        }

        return(*status);
}
 /*--------------------------------------------------------------------------*/
int imcomp_convert_tile_tint(
    fitsfile *outfptr,
    void *tiledata, 
    long tilelen,
    int nullcheck,
    void *nullflagval,
    int nullval,
    int zbitpix,
    double scale,
    double zero,
    int *intlength,
    int *status)
{
    /*  Prepare the input tile array of pixels for compression. */
    /*  Convert input integer tile array in place to 4 or 8-byte ints for compression, */
    /*  If needed, do null value substitution. */
   
    int flagval, *idata;
    long ii;
    
 
        /* datatype of input array is int.  We only support writing this datatype
           to a FITS image with BITPIX = 32 and with BZERO = 0 and BSCALE = 1.  */

       if (zbitpix != LONG_IMG || scale != 1.0 || zero != 0.) {
           ffpmsg("Implicit datatype conversion is not supported when writing to compressed images");
           return(*status = DATA_COMPRESSION_ERR);
       } 

       idata = (int *) tiledata;
       *intlength = 4;

       if (nullcheck == 1) {
               /* no datatype conversion is required for any of the compression algorithms,
	         except possibly for HCOMPRESS (to I*8), which is handled later.
		 Just reset pixels equal to flagval to the FITS null value */
               flagval = *(int *) (nullflagval);
               if (flagval != nullval) {
                  for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (idata[ii] == flagval)
		       idata[ii] = nullval;
                  }
               }
       }

       return(*status);
}
 /*--------------------------------------------------------------------------*/
int imcomp_convert_tile_tuint(
    fitsfile *outfptr,
    void *tiledata, 
    long tilelen,
    int nullcheck,
    void *nullflagval,
    int nullval,
    int zbitpix,
    double scale,
    double zero,
    int *intlength,
    int *status)
{
    /*  Prepare the input tile array of pixels for compression. */
    /*  Convert input unsigned integer tile array in place to 4 or 8-byte ints for compression, */
    /*  If needed, do null value substitution. */


    int *idata;
    unsigned int *uintbuff, uintflagval;
    long ii;
 
       /* datatype of input array is unsigned int.  We only support writing this datatype
          to a FITS image with BITPIX = 32 and with BZERO = 0 and BSCALE = 2147483648.  */

       if (zbitpix != LONG_IMG || scale != 1.0 || zero != 2147483648.) {
           ffpmsg("Implicit datatype conversion is not supported when writing to compressed images");
           return(*status = DATA_COMPRESSION_ERR);
       } 

       *intlength = 4;
       idata = (int *) tiledata;
       uintbuff = (unsigned int *) tiledata;

       /* offset the unsigned value by -2147483648 to a signed int value. */
       /* It is more efficient to do this by just flipping the most significant of the 32 bits */

       if (nullcheck == 1) {
               /* reset pixels equal to flagval to nullval and */
               /* offset the other pixel values (by flipping the MSB) */
               uintflagval = *(unsigned int *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (uintbuff[ii] == uintflagval)
		       idata[ii] = nullval;
                    else
		       uintbuff[ii] = (uintbuff[ii]) ^ 0x80000000;
               }
       } else {
               /* just offset the pixel values (by flipping the MSB) */
               for (ii = tilelen - 1; ii >= 0; ii--)
		       uintbuff[ii] = (uintbuff[ii]) ^ 0x80000000;
       }

       return(*status);
}
 /*--------------------------------------------------------------------------*/
int imcomp_convert_tile_tbyte(
    fitsfile *outfptr,
    void *tiledata, 
    long tilelen,
    int nullcheck,
    void *nullflagval,
    int nullval,
    int zbitpix,
    double scale,
    double zero,
    int *intlength,
    int *status)
{
    /*  Prepare the input tile array of pixels for compression. */
    /*  Convert input unsigned integer*1 tile array in place to 4 or 8-byte ints for compression, */
    /*  If needed, convert 4 or 8-byte ints and do null value substitution. */
    /*  Note that the calling routine must have allocated the input array big enough */
    /* to be able to do this.  */

    int flagval, *idata;
    long ii;
    unsigned char *usbbuff;
        
       /* datatype of input array is unsigned byte.  We only support writing this datatype
          to a FITS image with BITPIX = 8 and with BZERO = 0 and BSCALE = 1.  */

       if (zbitpix != BYTE_IMG || scale != 1.0 || zero != 0.) {
           ffpmsg("Implicit datatype conversion is not supported when writing to compressed images");
           return(*status = DATA_COMPRESSION_ERR);
       } 

       idata = (int *) tiledata;
       usbbuff = (unsigned char *) tiledata;

       if ( (outfptr->Fptr)->compress_type == RICE_1 || (outfptr->Fptr)->compress_type == GZIP_1
         || (outfptr->Fptr)->compress_type == GZIP_2 || (outfptr->Fptr)->compress_type == BZIP2_1 ) 
       {
           /* don't have to convert to int if using gzip, bzip2, or Rice compression */
           *intlength = 1;
             
           if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression */
               flagval = *(unsigned char *) (nullflagval);
               if (flagval != nullval) {
                  for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (usbbuff[ii] == (unsigned char) flagval)
		       usbbuff[ii] = (unsigned char) nullval;
                    }
               }
           }
       } else {
           /* have to convert to int if using HCOMPRESS or PLIO */
           *intlength = 4;

           if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression */
               flagval = *(unsigned char *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (usbbuff[ii] == (unsigned char) flagval)
		       idata[ii] = nullval;
                    else
                       idata[ii] = (int) usbbuff[ii];
               }
           } else {  /* just do the data type conversion to int */
               for (ii = tilelen - 1; ii >= 0; ii--) 
                   idata[ii] = (int) usbbuff[ii];
           }
       }

       return(*status);
}
 /*--------------------------------------------------------------------------*/
int imcomp_convert_tile_tsbyte(
    fitsfile *outfptr,
    void *tiledata, 
    long tilelen,
    int nullcheck,
    void *nullflagval,
    int nullval,
    int zbitpix,
    double scale,
    double zero,
    int *intlength,
    int *status)
{
    /*  Prepare the input tile array of pixels for compression. */
    /*  Convert input integer*1 tile array in place to 4 or 8-byte ints for compression, */
    /*  If needed, convert 4 or 8-byte ints and do null value substitution. */
    /*  Note that the calling routine must have allocated the input array big enough */
    /* to be able to do this.  */

    int flagval, *idata;
    long ii;
    signed char *sbbuff;
 
       /* datatype of input array is signed byte.  We only support writing this datatype
          to a FITS image with BITPIX = 8 and with BZERO = 0 and BSCALE = -128.  */

       if (zbitpix != BYTE_IMG|| scale != 1.0 || zero != -128.) {
           ffpmsg("Implicit datatype conversion is not supported when writing to compressed images");
           return(*status = DATA_COMPRESSION_ERR);
       }

       idata = (int *) tiledata;
       sbbuff = (signed char *) tiledata;

       if ( (outfptr->Fptr)->compress_type == RICE_1 || (outfptr->Fptr)->compress_type == GZIP_1
         || (outfptr->Fptr)->compress_type == GZIP_2 || (outfptr->Fptr)->compress_type == BZIP2_1 ) 
       {
           /* don't have to convert to int if using gzip, bzip2 or Rice compression */
           *intlength = 1;
             
           if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression */
               /* offset the other pixel values (by flipping the MSB) */

               flagval = *(signed char *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (sbbuff[ii] == (signed char) flagval)
		       sbbuff[ii] = (signed char) nullval;
                    else
		       sbbuff[ii] = (sbbuff[ii]) ^ 0x80;               }
           } else {  /* just offset the pixel values (by flipping the MSB) */
               for (ii = tilelen - 1; ii >= 0; ii--) 
		       sbbuff[ii] = (sbbuff[ii]) ^ 0x80;
           }

       } else {
           /* have to convert to int if using HCOMPRESS or PLIO */
           *intlength = 4;

           if (nullcheck == 1) {
               /* reset pixels equal to flagval to the FITS null value, prior to compression */
               flagval = *(signed char *) (nullflagval);
               for (ii = tilelen - 1; ii >= 0; ii--) {
	            if (sbbuff[ii] == (signed char) flagval)
		       idata[ii] = nullval;
                    else
                       idata[ii] = ((int) sbbuff[ii]) + 128;
               }
           } else {  /* just do the data type conversion to int */
               for (ii = tilelen - 1; ii >= 0; ii--) 
                   idata[ii] = ((int) sbbuff[ii]) + 128;
           }
       }
 
       return(*status);
}
 /*--------------------------------------------------------------------------*/
int imcomp_convert_tile_tfloat(
    fitsfile *outfptr,
    long row,
    void *tiledata, 
    long tilelen,
    long tilenx,
    long tileny,
    int nullcheck,
    void *nullflagval,
    int nullval,
    int zbitpix,
    double scale,
    double zero,
    int *intlength,
    int *flag,
    double *bscale,
    double *bzero,
    int *status)
{
    /*  Prepare the input tile array of pixels for compression. */
    /*  Convert input float tile array in place to 4 or 8-byte ints for compression, */
    /*  If needed, convert 4 or 8-byte ints and do null value substitution. */
    /*  Note that the calling routine must have allocated the input array big enough */
    /* to be able to do this.  */

    int *idata;
    long irow, ii;
    float floatnull;
    unsigned char *usbbuff;
    unsigned long dithersum;
    int iminval = 0, imaxval = 0;  /* min and max quantized integers */

        /* datatype of input array is double.  We only support writing this datatype
           to a FITS image with BITPIX = -64 or -32, except we also support the special case where
	   BITPIX = 32 and BZERO = 0 and BSCALE = 1.  */

       if ((zbitpix != LONG_IMG && zbitpix != DOUBLE_IMG && zbitpix != FLOAT_IMG) || scale != 1.0 || zero != 0.) {
           ffpmsg("Implicit datatype conversion is not supported when writing to compressed images");
           return(*status = DATA_COMPRESSION_ERR);
       } 

           *intlength = 4;
           idata = (int *) tiledata;

          /* if the tile-compressed table contains zscale and zzero columns */
          /* then scale and quantize the input floating point data.    */

          if ((outfptr->Fptr)->cn_zscale > 0) {
	    /* quantize the float values into integers */

            if (nullcheck == 1)
	      floatnull = *(float *) (nullflagval);
	    else
	      floatnull = FLOATNULLVALUE;  /* NaNs are represented by this, by default */

            if ((outfptr->Fptr)->quantize_method == SUBTRACTIVE_DITHER_1  ||
	        (outfptr->Fptr)->quantize_method == SUBTRACTIVE_DITHER_2) {
	      
	          /* see if the dithering offset value needs to be initialized */                  
	          if ((outfptr->Fptr)->request_dither_seed == 0 && (outfptr->Fptr)->dither_seed == 0) {

		     /* This means randomly choose the dithering offset based on the system time. */
		     /* The offset will have a value between 1 and 10000, inclusive. */
		     /* The time function returns an integer value that is incremented each second. */
		     /* The clock function returns the elapsed CPU time, in integer CLOCKS_PER_SEC units. */
		     /* The CPU time returned by clock is typically (on linux PC) only good to 0.01 sec */
		     /* Summing the 2 quantities may help avoid cases where 2 executions of the program */
		     /* (perhaps in a multithreaded environoment) end up with exactly the same dither seed */
		     /* value.  The sum is incremented by the current HDU number in the file to provide */
		     /* further randomization.  This randomization is desireable if multiple compressed */
		     /* images will be summed (or differenced). In such cases, the benefits of dithering */
		     /* may be lost if all the images use exactly the same sequence of random numbers when */
		     /* calculating the dithering offsets. */	     
		     
		     (outfptr->Fptr)->dither_seed = 
		       (( (int)time(NULL) + ( (int) clock() / (int) (CLOCKS_PER_SEC / 100)) + (outfptr->Fptr)->curhdu) % 10000) + 1;
		     
                     /* update the header keyword with this new value */
		     fits_update_key(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->dither_seed), 
	                        NULL, status);

	          } else if ((outfptr->Fptr)->request_dither_seed < 0 && (outfptr->Fptr)->dither_seed < 0) {

		     /* this means randomly choose the dithering offset based on some hash function */
		     /* of the first input tile of data to be quantized and compressed.  This ensures that */
                     /* the same offset value is used for a given image every time it is compressed. */

		     usbbuff = (unsigned char *) tiledata;
		     dithersum = 0;
		     for (ii = 0; ii < 4 * tilelen; ii++) {
		         dithersum += usbbuff[ii];  /* doesn't matter if there is an integer overflow */
	             }
		     (outfptr->Fptr)->dither_seed = ((int) (dithersum % 10000)) + 1;
		
                     /* update the header keyword with this new value */
		     fits_update_key(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->dither_seed), 
	                        NULL, status);
		  }

                  /* subtract 1 to convert from 1-based to 0-based element number */
	          irow = row + (outfptr->Fptr)->dither_seed - 1; /* dither the quantized values */

	      } else if ((outfptr->Fptr)->quantize_method == -1) {
	          irow = 0;  /* do not dither the quantized values */
              } else {
                  ffpmsg("Unknown dithering method.");
                  ffpmsg("May need to install a newer version of CFITSIO.");
                  return(*status = DATA_COMPRESSION_ERR);
              }

              *flag = fits_quantize_float (irow, (float *) tiledata, tilenx, tileny,
                   nullcheck, floatnull, (outfptr->Fptr)->quantize_level, 
		   (outfptr->Fptr)->quantize_method, idata, bscale, bzero, &iminval, &imaxval);

              if (*flag > 1)
		   return(*status = *flag);
          }
          else if ((outfptr->Fptr)->quantize_level != NO_QUANTIZE)
	  {
	    /* if floating point pixels are not being losslessly compressed, then */
	    /* input float data is implicitly converted (truncated) to integers */
            if ((scale != 1. || zero != 0.))  /* must scale the values */
	       imcomp_nullscalefloats((float *) tiledata, tilelen, idata, scale, zero,
	           nullcheck, *(float *) (nullflagval), nullval, status);
             else
	       imcomp_nullfloats((float *) tiledata, tilelen, idata,
	           nullcheck, *(float *) (nullflagval), nullval,  status);
          }
          else if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE)
	  {
	      /* just convert null values to NaNs in place, if necessary, then do lossless gzip compression */
		if (nullcheck == 1) {
	            imcomp_float2nan((float *) tiledata, tilelen, (int *) tiledata,
	                *(float *) (nullflagval), status);
		}
          }

          return(*status);
}
 /*--------------------------------------------------------------------------*/
int imcomp_convert_tile_tdouble(
    fitsfile *outfptr,
    long row,
    void *tiledata, 
    long tilelen,
    long tilenx,
    long tileny,
    int nullcheck,
    void *nullflagval,
    int nullval,
    int zbitpix,
    double scale,
    double zero,
    int *intlength,
    int *flag,
    double *bscale,
    double *bzero,
    int *status)
{
    /*  Prepare the input tile array of pixels for compression. */
    /*  Convert input double tile array in place to 4-byte ints for compression, */
    /*  If needed, convert 4 or 8-byte ints and do null value substitution. */
    /*  Note that the calling routine must have allocated the input array big enough */
    /* to be able to do this.  */

    int *idata;
    long irow, ii;
    double doublenull;
    unsigned char *usbbuff;
    unsigned long dithersum;
    int iminval = 0, imaxval = 0;  /* min and max quantized integers */

        /* datatype of input array is double.  We only support writing this datatype
           to a FITS image with BITPIX = -64 or -32, except we also support the special case where
	   BITPIX = 32 and BZERO = 0 and BSCALE = 1.  */

       if ((zbitpix != LONG_IMG && zbitpix != DOUBLE_IMG && zbitpix != FLOAT_IMG) || scale != 1.0 || zero != 0.) {
           ffpmsg("Implicit datatype conversion is not supported when writing to compressed images");
           return(*status = DATA_COMPRESSION_ERR);
       } 

           *intlength = 4;
           idata = (int *) tiledata;

          /* if the tile-compressed table contains zscale and zzero columns */
          /* then scale and quantize the input floating point data.    */
          /* Otherwise, just truncate the floats to integers.          */

          if ((outfptr->Fptr)->cn_zscale > 0)
          {
            if (nullcheck == 1)
	      doublenull = *(double *) (nullflagval);
	    else
	      doublenull = DOUBLENULLVALUE;

            /* quantize the double values into integers */
              if ((outfptr->Fptr)->quantize_method == SUBTRACTIVE_DITHER_1 ||
	          (outfptr->Fptr)->quantize_method == SUBTRACTIVE_DITHER_2) {

	          /* see if the dithering offset value needs to be initialized (see above) */                  
	          if ((outfptr->Fptr)->request_dither_seed == 0 && (outfptr->Fptr)->dither_seed == 0) {

		     (outfptr->Fptr)->dither_seed = 
		       (( (int)time(NULL) + ( (int) clock() / (int) (CLOCKS_PER_SEC / 100)) + (outfptr->Fptr)->curhdu) % 10000) + 1;
		     
                     /* update the header keyword with this new value */
		     fits_update_key(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->dither_seed), 
	                        NULL, status);

	          } else if ((outfptr->Fptr)->request_dither_seed < 0 && (outfptr->Fptr)->dither_seed < 0) {

		     usbbuff = (unsigned char *) tiledata;
		     dithersum = 0;
		     for (ii = 0; ii < 8 * tilelen; ii++) {
		         dithersum += usbbuff[ii];
	             }
		     (outfptr->Fptr)->dither_seed = ((int) (dithersum % 10000)) + 1;
		
                     /* update the header keyword with this new value */
		     fits_update_key(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->dither_seed), 
	                        NULL, status);
		  }

	          irow = row + (outfptr->Fptr)->dither_seed - 1; /* dither the quantized values */

	      } else if ((outfptr->Fptr)->quantize_method == -1) {
	          irow = 0;  /* do not dither the quantized values */
              } else {
                  ffpmsg("Unknown subtractive dithering method.");
                  ffpmsg("May need to install a newer version of CFITSIO.");
                  return(*status = DATA_COMPRESSION_ERR);
              }

            *flag = fits_quantize_double (irow, (double *) tiledata, tilenx, tileny,
               nullcheck, doublenull, (outfptr->Fptr)->quantize_level, 
	       (outfptr->Fptr)->quantize_method, idata,
               bscale, bzero, &iminval, &imaxval);

            if (*flag > 1)
		return(*status = *flag);
          }
          else if ((outfptr->Fptr)->quantize_level != NO_QUANTIZE)
	  {
	    /* if floating point pixels are not being losslessly compressed, then */
	    /* input float data is implicitly converted (truncated) to integers */
             if ((scale != 1. || zero != 0.))  /* must scale the values */
	       imcomp_nullscaledoubles((double *) tiledata, tilelen, idata, scale, zero,
	           nullcheck, *(double *) (nullflagval), nullval, status);
             else
	       imcomp_nulldoubles((double *) tiledata, tilelen, idata,
	           nullcheck, *(double *) (nullflagval), nullval,  status);
          }
          else if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE)
	  {
	      /* just convert null values to NaNs in place, if necessary, then do lossless gzip compression */
		if (nullcheck == 1) {
	            imcomp_double2nan((double *) tiledata, tilelen, (LONGLONG *) tiledata,
	                *(double *) (nullflagval), status);
		}
          }
 
          return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_nullscale(
     int *idata, 
     long tilelen,
     int nullflagval,
     int nullval,
     double scale,
     double zero,
     int *status)
/*
   do null value substitution AND scaling of the integer array.
   If array value = nullflagval, then set the value to nullval.
   Otherwise, inverse scale the integer value.
*/
{
    long ii;
    double dvalue;
    
    for (ii=0; ii < tilelen; ii++)
    {
        if (idata[ii] == nullflagval)
	    idata[ii] = nullval;
	else 
	{
            dvalue = (idata[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_nullvalues(
     int *idata, 
     long tilelen,
     int nullflagval,
     int nullval,
     int *status)
/*
   do null value substitution.
   If array value = nullflagval, then set the value to nullval.
*/
{
    long ii;
    
    for (ii=0; ii < tilelen; ii++)
    {
        if (idata[ii] == nullflagval)
	    idata[ii] = nullval;
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_scalevalues(
     int *idata, 
     long tilelen,
     double scale,
     double zero,
     int *status)
/*
   do inverse scaling the integer values.
*/
{
    long ii;
    double dvalue;
    
    for (ii=0; ii < tilelen; ii++)
    {
            dvalue = (idata[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_nullscalei2(
     short *idata, 
     long tilelen,
     short nullflagval,
     short nullval,
     double scale,
     double zero,
     int *status)
/*
   do null value substitution AND scaling of the integer array.
   If array value = nullflagval, then set the value to nullval.
   Otherwise, inverse scale the integer value.
*/
{
    long ii;
    double dvalue;
    
    for (ii=0; ii < tilelen; ii++)
    {
        if (idata[ii] == nullflagval)
	    idata[ii] = nullval;
	else 
	{
            dvalue = (idata[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_nullvaluesi2(
     short *idata, 
     long tilelen,
     short nullflagval,
     short nullval,
     int *status)
/*
   do null value substitution.
   If array value = nullflagval, then set the value to nullval.
*/
{
    long ii;
    
    for (ii=0; ii < tilelen; ii++)
    {
        if (idata[ii] == nullflagval)
	    idata[ii] = nullval;
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_scalevaluesi2(
     short *idata, 
     long tilelen,
     double scale,
     double zero,
     int *status)
/*
   do inverse scaling the integer values.
*/
{
    long ii;
    double dvalue;
    
    for (ii=0; ii < tilelen; ii++)
    {
            dvalue = (idata[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_nullfloats(
     float *fdata,
     long tilelen,
     int *idata, 
     int nullcheck,
     float nullflagval,
     int nullval,
     int *status)
/*
   do null value substitution  of the float array.
   If array value = nullflagval, then set the output value to FLOATNULLVALUE.
*/
{
    long ii;
    double dvalue;
    
    if (nullcheck == 1) /* must check for null values */
    {
      for (ii=0; ii < tilelen; ii++)
      {
        if (fdata[ii] == nullflagval)
	    idata[ii] = nullval;
	else 
	{
            dvalue = fdata[ii];

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
        }
      }
    }
    else  /* don't have to worry about null values */
    {
      for (ii=0; ii < tilelen; ii++)
      {
            dvalue = fdata[ii];

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
      }
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_nullscalefloats(
     float *fdata,
     long tilelen,
     int *idata, 
     double scale,
     double zero,
     int nullcheck,
     float nullflagval,
     int nullval,
     int *status)
/*
   do null value substitution  of the float array.
   If array value = nullflagval, then set the output value to FLOATNULLVALUE.
   Otherwise, inverse scale the integer value.
*/
{
    long ii;
    double dvalue;
    
    if (nullcheck == 1) /* must check for null values */
    {
      for (ii=0; ii < tilelen; ii++)
      {
        if (fdata[ii] == nullflagval)
	    idata[ii] = nullval;
	else 
	{
            dvalue = (fdata[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0.)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
        }
      }
    }
    else  /* don't have to worry about null values */
    {
      for (ii=0; ii < tilelen; ii++)
      {
            dvalue = (fdata[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0.)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
      }
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_nulldoubles(
     double *fdata,
     long tilelen,
     int *idata, 
     int nullcheck,
     double nullflagval,
     int nullval,
     int *status)
/*
   do null value substitution  of the float array.
   If array value = nullflagval, then set the output value to FLOATNULLVALUE.
   Otherwise, inverse scale the integer value.
*/
{
    long ii;
    double dvalue;
    
    if (nullcheck == 1) /* must check for null values */
    {
      for (ii=0; ii < tilelen; ii++)
      {
        if (fdata[ii] == nullflagval)
	    idata[ii] = nullval;
	else 
	{
            dvalue = fdata[ii];

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0.)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
        }
      }
    }
    else  /* don't have to worry about null values */
    {
      for (ii=0; ii < tilelen; ii++)
      {
            dvalue = fdata[ii];

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0.)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
      }
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int imcomp_nullscaledoubles(
     double *fdata,
     long tilelen,
     int *idata, 
     double scale,
     double zero,
     int nullcheck,
     double nullflagval,
     int nullval,
     int *status)
/*
   do null value substitution  of the float array.
   If array value = nullflagval, then set the output value to FLOATNULLVALUE.
   Otherwise, inverse scale the integer value.
*/
{
    long ii;
    double dvalue;
    
    if (nullcheck == 1) /* must check for null values */
    {
      for (ii=0; ii < tilelen; ii++)
      {
        if (fdata[ii] == nullflagval)
	    idata[ii] = nullval;
	else 
	{
            dvalue = (fdata[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0.)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
        }
      }
    }
    else  /* don't have to worry about null values */
    {
      for (ii=0; ii < tilelen; ii++)
      {
            dvalue = (fdata[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                idata[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0.)
                    idata[ii] = (int) (dvalue + .5);
                else
                    idata[ii] = (int) (dvalue - .5);
            }
      }
    }
    return(*status);
}
/*---------------------------------------------------------------------------*/
int fits_write_compressed_img(fitsfile *fptr,   /* I - FITS file pointer     */
            int  datatype,   /* I - datatype of the array to be written      */
            long  *infpixel, /* I - 'bottom left corner' of the subsection   */
            long  *inlpixel, /* I - 'top right corner' of the subsection     */
            int  nullcheck,  /* I - 0 for no null checking                   */
                             /*     1: pixels that are = nullval will be     */
                             /*     written with the FITS null pixel value   */
                             /*     (floating point arrays only)             */
            void *array,     /* I - array of values to be written            */
            void *nullval,   /* I - undefined pixel value                    */
            int  *status)    /* IO - error status                            */
/*
   Write a section of a compressed image.
*/
{
    int  tiledim[MAX_COMPRESS_DIM];
    long naxis[MAX_COMPRESS_DIM];
    long tilesize[MAX_COMPRESS_DIM], thistilesize[MAX_COMPRESS_DIM];
    long ftile[MAX_COMPRESS_DIM], ltile[MAX_COMPRESS_DIM];
    long tfpixel[MAX_COMPRESS_DIM], tlpixel[MAX_COMPRESS_DIM];
    long rowdim[MAX_COMPRESS_DIM], offset[MAX_COMPRESS_DIM],ntemp;
    long fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM];
    long i5, i4, i3, i2, i1, i0, irow;
    int ii, ndim, pixlen, tilenul;
    int  tstatus, buffpixsiz;
    void *buffer;
    char *bnullarray = 0, card[FLEN_CARD];

    if (*status > 0) 
        return(*status);

    if (!fits_is_compressed_image(fptr, status) )
    {
        ffpmsg("CHDU is not a compressed image (fits_write_compressed_img)");
        return(*status = DATA_COMPRESSION_ERR);
    }

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* rescan header if data structure is undefined */
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               
            return(*status);


    /* ===================================================================== */


    if (datatype == TSHORT || datatype == TUSHORT)
    {
       pixlen = sizeof(short);
    }
    else if (datatype == TINT || datatype == TUINT)
    {
       pixlen = sizeof(int);
    }
    else if (datatype == TBYTE || datatype == TSBYTE)
    {
       pixlen = 1;
    }
    else if (datatype == TLONG || datatype == TULONG)
    {
       pixlen = sizeof(long);
    }
    else if (datatype == TFLOAT)
    {
       pixlen = sizeof(float);
    }
    else if (datatype == TDOUBLE)
    {
       pixlen = sizeof(double);
    }
    else
    {
        ffpmsg("unsupported datatype for compressing image");
        return(*status = BAD_DATATYPE);
    }

    /* ===================================================================== */

    /* allocate scratch space for processing one tile of the image */
    buffpixsiz = pixlen;  /* this is the minimum pixel size */
    
    if ( (fptr->Fptr)->compress_type == HCOMPRESS_1) { /* need 4 or 8 bytes per pixel */
        if ((fptr->Fptr)->zbitpix == BYTE_IMG ||
	    (fptr->Fptr)->zbitpix == SHORT_IMG )
                buffpixsiz = maxvalue(buffpixsiz, 4);
        else
	        buffpixsiz = 8;
    }
    else if ( (fptr->Fptr)->compress_type == PLIO_1) { /* need 4 bytes per pixel */
                buffpixsiz = maxvalue(buffpixsiz, 4);
    }
    else if ( (fptr->Fptr)->compress_type == RICE_1  ||
              (fptr->Fptr)->compress_type == GZIP_1 ||
              (fptr->Fptr)->compress_type == GZIP_2 ||
              (fptr->Fptr)->compress_type == BZIP2_1) {  /* need 1, 2, or 4 bytes per pixel */
        if ((fptr->Fptr)->zbitpix == BYTE_IMG)
            buffpixsiz = maxvalue(buffpixsiz, 1);
        else if ((fptr->Fptr)->zbitpix == SHORT_IMG)
            buffpixsiz = maxvalue(buffpixsiz, 2);
        else 
            buffpixsiz = maxvalue(buffpixsiz, 4);
    }
    else
    {
        ffpmsg("unsupported image compression algorithm");
        return(*status = BAD_DATATYPE);
    }
    
    /* cast to double to force alignment on 8-byte addresses */
    buffer = (double *) calloc ((fptr->Fptr)->maxtilelen, buffpixsiz);

    if (buffer == NULL)
    {
	    ffpmsg("Out of memory (fits_write_compress_img)");
	    return (*status = MEMORY_ALLOCATION);
    }

    /* ===================================================================== */

    /* initialize all the arrays */
    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        naxis[ii] = 1;
        tiledim[ii] = 1;
        tilesize[ii] = 1;
        ftile[ii] = 1;
        ltile[ii] = 1;
        rowdim[ii] = 1;
    }

    ndim = (fptr->Fptr)->zndim;
    ntemp = 1;
    for (ii = 0; ii < ndim; ii++)
    {
        fpixel[ii] = infpixel[ii];
        lpixel[ii] = inlpixel[ii];

        /* calc number of tiles in each dimension, and tile containing */
        /* the first and last pixel we want to read in each dimension  */
        naxis[ii] = (fptr->Fptr)->znaxis[ii];
        if (fpixel[ii] < 1)
        {
            free(buffer);
            return(*status = BAD_PIX_NUM);
        }

        tilesize[ii] = (fptr->Fptr)->tilesize[ii];
        tiledim[ii] = (naxis[ii] - 1) / tilesize[ii] + 1;
        ftile[ii]   = (fpixel[ii] - 1)   / tilesize[ii] + 1;
        ltile[ii]   = minvalue((lpixel[ii] - 1) / tilesize[ii] + 1, 
                                tiledim[ii]);
        rowdim[ii]  = ntemp;  /* total tiles in each dimension */
        ntemp *= tiledim[ii];
    }

    /* support up to 6 dimensions for now */
    /* tfpixel and tlpixel are the first and last image pixels */
    /* along each dimension of the compression tile */
    for (i5 = ftile[5]; i5 <= ltile[5]; i5++)
    {
     tfpixel[5] = (i5 - 1) * tilesize[5] + 1;
     tlpixel[5] = minvalue(tfpixel[5] + tilesize[5] - 1, 
                            naxis[5]);
     thistilesize[5] = tlpixel[5] - tfpixel[5] + 1;
     offset[5] = (i5 - 1) * rowdim[5];
     for (i4 = ftile[4]; i4 <= ltile[4]; i4++)
     {
      tfpixel[4] = (i4 - 1) * tilesize[4] + 1;
      tlpixel[4] = minvalue(tfpixel[4] + tilesize[4] - 1, 
                            naxis[4]);
      thistilesize[4] = thistilesize[5] * (tlpixel[4] - tfpixel[4] + 1);
      offset[4] = (i4 - 1) * rowdim[4] + offset[5];
      for (i3 = ftile[3]; i3 <= ltile[3]; i3++)
      {
        tfpixel[3] = (i3 - 1) * tilesize[3] + 1;
        tlpixel[3] = minvalue(tfpixel[3] + tilesize[3] - 1, 
                              naxis[3]);
        thistilesize[3] = thistilesize[4] * (tlpixel[3] - tfpixel[3] + 1);
        offset[3] = (i3 - 1) * rowdim[3] + offset[4];
        for (i2 = ftile[2]; i2 <= ltile[2]; i2++)
        {
          tfpixel[2] = (i2 - 1) * tilesize[2] + 1;
          tlpixel[2] = minvalue(tfpixel[2] + tilesize[2] - 1, 
                                naxis[2]);
          thistilesize[2] = thistilesize[3] * (tlpixel[2] - tfpixel[2] + 1);
          offset[2] = (i2 - 1) * rowdim[2] + offset[3];
          for (i1 = ftile[1]; i1 <= ltile[1]; i1++)
          {
            tfpixel[1] = (i1 - 1) * tilesize[1] + 1;
            tlpixel[1] = minvalue(tfpixel[1] + tilesize[1] - 1, 
                                  naxis[1]);
            thistilesize[1] = thistilesize[2] * (tlpixel[1] - tfpixel[1] + 1);
            offset[1] = (i1 - 1) * rowdim[1] + offset[2];
            for (i0 = ftile[0]; i0 <= ltile[0]; i0++)
            {
              tfpixel[0] = (i0 - 1) * tilesize[0] + 1;
              tlpixel[0] = minvalue(tfpixel[0] + tilesize[0] - 1, 
                                    naxis[0]);
              thistilesize[0] = thistilesize[1] * (tlpixel[0] - tfpixel[0] + 1);
              /* calculate row of table containing this tile */
              irow = i0 + offset[1];

              /* read and uncompress this row (tile) of the table */
              /* also do type conversion and undefined pixel substitution */
              /* at this point */
              imcomp_decompress_tile(fptr, irow, thistilesize[0],
                    datatype, nullcheck, nullval, buffer, bnullarray, &tilenul,
                     status);

              if (*status == NO_COMPRESSED_TILE)
              {
                   /* tile doesn't exist, so initialize to zero */
                   memset(buffer, 0, pixlen * thistilesize[0]);
                   *status = 0;
              }

              /* copy the intersecting pixels to this tile from the input */
              imcomp_merge_overlap(buffer, pixlen, ndim, tfpixel, tlpixel, 
                     bnullarray, array, fpixel, lpixel, nullcheck, status);

              /* compress the tile again, and write it back to the FITS file */
              imcomp_compress_tile (fptr, irow, datatype, buffer, 
                                    thistilesize[0],
				    tlpixel[0] - tfpixel[0] + 1,
				    tlpixel[1] - tfpixel[1] + 1,
				    nullcheck, nullval, 
				    status);
            }
          }
        }
      }
     }
    }
    free(buffer);
    

    if ((fptr->Fptr)->zbitpix < 0 && nullcheck != 0) { 
/*
     This is a floating point FITS image with possible null values.
     It is too messy to test if any null values are actually written, so 
     just assume so.  We need to make sure that the
     ZBLANK keyword is present in the compressed image header.  If it is not
     there then we need to insert the keyword. 
*/   
        tstatus = 0;
        ffgcrd(fptr, "ZBLANK", card, &tstatus);

	if (tstatus) {   /* have to insert the ZBLANK keyword */
           ffgcrd(fptr, "ZCMPTYPE", card, status);
           ffikyj(fptr, "ZBLANK", COMPRESS_NULL_VALUE, 
                "null value in the compressed integer array", status);
	
           /* set this value into the internal structure; it is used if */
	   /* the program reads back the values from the array */
	 
          (fptr->Fptr)->zblank = COMPRESS_NULL_VALUE;
          (fptr->Fptr)->cn_zblank = -1;  /* flag for a constant ZBLANK */
        }  
    }  
    
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_write_compressed_pixels(fitsfile *fptr, /* I - FITS file pointer   */
            int  datatype,  /* I - datatype of the array to be written      */
            LONGLONG   fpixel,  /* I - 'first pixel to write          */
            LONGLONG   npixel,  /* I - number of pixels to write      */
            int  nullcheck,  /* I - 0 for no null checking                   */
                             /*     1: pixels that are = nullval will be     */
                             /*     written with the FITS null pixel value   */
                             /*     (floating point arrays only)             */
            void *array,      /* I - array of values to write                */
            void *nullval,    /* I - value used to represent undefined pixels*/
            int  *status)     /* IO - error status                           */
/*
   Write a consecutive set of pixels to a compressed image.  This routine
   interpretes the n-dimensional image as a long one-dimensional array. 
   This is actually a rather inconvenient way to write compressed images in
   general, and could be rather inefficient if the requested pixels to be
   written are located in many different image compression tiles.    

   The general strategy used here is to write the requested pixels in blocks
   that correspond to rectangular image sections.  
*/
{
    int naxis, ii, bytesperpixel;
    long naxes[MAX_COMPRESS_DIM], nread;
    LONGLONG tfirst, tlast, last0, last1, dimsize[MAX_COMPRESS_DIM];
    long nplane, firstcoord[MAX_COMPRESS_DIM], lastcoord[MAX_COMPRESS_DIM];
    char *arrayptr;

    if (*status > 0)
        return(*status);

    arrayptr = (char *) array;

    /* get size of array pixels, in bytes */
    bytesperpixel = ffpxsz(datatype);

    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        naxes[ii] = 1;
        firstcoord[ii] = 0;
        lastcoord[ii] = 0;
    }

    /*  determine the dimensions of the image to be written */
    ffgidm(fptr, &naxis, status);
    ffgisz(fptr, MAX_COMPRESS_DIM, naxes, status);

    /* calc the cumulative number of pixels in each successive dimension */
    dimsize[0] = 1;
    for (ii = 1; ii < MAX_COMPRESS_DIM; ii++)
         dimsize[ii] = dimsize[ii - 1] * naxes[ii - 1];

    /*  determine the coordinate of the first and last pixel in the image */
    /*  Use zero based indexes here */
    tfirst = fpixel - 1;
    tlast = tfirst + npixel - 1;
    for (ii = naxis - 1; ii >= 0; ii--)
    {
        firstcoord[ii] = (long) (tfirst / dimsize[ii]);
        lastcoord[ii]  = (long) (tlast / dimsize[ii]);
        tfirst = tfirst - firstcoord[ii] * dimsize[ii];
        tlast = tlast - lastcoord[ii] * dimsize[ii];
    }

    /* to simplify things, treat 1-D, 2-D, and 3-D images as separate cases */

    if (naxis == 1)
    {
        /* Simple: just write the requested range of pixels */

        firstcoord[0] = firstcoord[0] + 1;
        lastcoord[0] = lastcoord[0] + 1;
        fits_write_compressed_img(fptr, datatype, firstcoord, lastcoord,
            nullcheck, array, nullval, status);
        return(*status);
    }
    else if (naxis == 2)
    {
        nplane = 0;  /* write 1st (and only) plane of the image */
        fits_write_compressed_img_plane(fptr, datatype, bytesperpixel,
          nplane, firstcoord, lastcoord, naxes, nullcheck,
          array, nullval, &nread, status);
    }
    else if (naxis == 3)
    {
        /* test for special case: writing an integral number of planes */
        if (firstcoord[0] == 0 && firstcoord[1] == 0 &&
            lastcoord[0] == naxes[0] - 1 && lastcoord[1] == naxes[1] - 1)
        {
            for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
            {
                /* convert from zero base to 1 base */
                (firstcoord[ii])++;
                (lastcoord[ii])++;
            }

            /* we can write the contiguous block of pixels in one go */
            fits_write_compressed_img(fptr, datatype, firstcoord, lastcoord,
                nullcheck, array, nullval, status);
            return(*status);
        }

        /* save last coordinate in temporary variables */
        last0 = lastcoord[0];
        last1 = lastcoord[1];

        if (firstcoord[2] < lastcoord[2])
        {
            /* we will write up to the last pixel in all but the last plane */
            lastcoord[0] = naxes[0] - 1;
            lastcoord[1] = naxes[1] - 1;
        }

        /* write one plane of the cube at a time, for simplicity */
        for (nplane = firstcoord[2]; nplane <= lastcoord[2]; nplane++)
        {
            if (nplane == lastcoord[2])
            {
                lastcoord[0] = (long) last0;
                lastcoord[1] = (long) last1;
            }

            fits_write_compressed_img_plane(fptr, datatype, bytesperpixel,
              nplane, firstcoord, lastcoord, naxes, nullcheck,
              arrayptr, nullval, &nread, status);

            /* for all subsequent planes, we start with the first pixel */
            firstcoord[0] = 0;
            firstcoord[1] = 0;

            /* increment pointers to next elements to be written */
            arrayptr = arrayptr + nread * bytesperpixel;
        }
    }
    else
    {
        ffpmsg("only 1D, 2D, or 3D images are currently supported");
        return(*status = DATA_COMPRESSION_ERR);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_write_compressed_img_plane(fitsfile *fptr, /* I - FITS file    */
            int  datatype,  /* I - datatype of the array to be written    */
            int  bytesperpixel, /* I - number of bytes per pixel in array */
            long   nplane,  /* I - which plane of the cube to write      */
            long *firstcoord, /* I coordinate of first pixel to write */
            long *lastcoord,  /* I coordinate of last pixel to write */
            long *naxes,     /* I size of each image dimension */
            int  nullcheck,  /* I - 0 for no null checking                   */
                             /*     1: pixels that are = nullval will be     */
                             /*     written with the FITS null pixel value   */
                             /*     (floating point arrays only)             */
            void *array,      /* I - array of values that are written        */
            void *nullval,    /* I - value for undefined pixels              */
            long *nread,      /* O - total number of pixels written          */
            int  *status)     /* IO - error status                           */

   /*
           in general we have to write the first partial row of the image,
           followed by the middle complete rows, followed by the last
           partial row of the image.  If the first or last rows are complete,
           then write them at the same time as all the middle rows.
    */
{
    /* bottom left coord. and top right coord. */
    long blc[MAX_COMPRESS_DIM], trc[MAX_COMPRESS_DIM]; 
    char *arrayptr;

    *nread = 0;

    arrayptr = (char *) array;

    blc[2] = nplane + 1;
    trc[2] = nplane + 1;

    if (firstcoord[0] != 0)
    { 
            /* have to read a partial first row */
            blc[0] = firstcoord[0] + 1;
            blc[1] = firstcoord[1] + 1;
            trc[1] = blc[1];  
            if (lastcoord[1] == firstcoord[1])
               trc[0] = lastcoord[0] + 1; /* 1st and last pixels in same row */
            else
               trc[0] = naxes[0];  /* read entire rest of the row */

            fits_write_compressed_img(fptr, datatype, blc, trc,
                nullcheck, arrayptr, nullval, status);

            *nread = *nread + trc[0] - blc[0] + 1;

            if (lastcoord[1] == firstcoord[1])
            {
               return(*status);  /* finished */
            }

            /* set starting coord to beginning of next line */
            firstcoord[0] = 0;
            firstcoord[1] += 1;
            arrayptr = arrayptr + (trc[0] - blc[0] + 1) * bytesperpixel;
    }

    /* write contiguous complete rows of the image, if any */
    blc[0] = 1;
    blc[1] = firstcoord[1] + 1;
    trc[0] = naxes[0];

    if (lastcoord[0] + 1 == naxes[0])
    {
            /* can write the last complete row, too */
            trc[1] = lastcoord[1] + 1;
    }
    else
    {
            /* last row is incomplete; have to read it separately */
            trc[1] = lastcoord[1];
    }

    if (trc[1] >= blc[1])  /* must have at least one whole line to read */
    {
        fits_write_compressed_img(fptr, datatype, blc, trc,
                nullcheck, arrayptr, nullval, status);

        *nread = *nread + (trc[1] - blc[1] + 1) * naxes[0];

        if (lastcoord[1] + 1 == trc[1])
               return(*status);  /* finished */

        /* increment pointers for the last partial row */
        arrayptr = arrayptr + (trc[1] - blc[1] + 1) * naxes[0] * bytesperpixel;

     }

    if (trc[1] == lastcoord[1] + 1)
        return(*status);           /* all done */

    /* set starting and ending coord to last line */

    trc[0] = lastcoord[0] + 1;
    trc[1] = lastcoord[1] + 1;
    blc[1] = trc[1];

    fits_write_compressed_img(fptr, datatype, blc, trc,
                nullcheck, arrayptr, nullval, status);

    *nread = *nread + trc[0] - blc[0] + 1;

    return(*status);
}

/* ######################################################################## */
/* ###                 Image Decompression Routines                     ### */
/* ######################################################################## */

/*--------------------------------------------------------------------------*/
int fits_img_decompress (fitsfile *infptr, /* image (bintable) to uncompress */
              fitsfile *outfptr,   /* empty HDU for output uncompressed image */
              int *status)         /* IO - error status               */

/* 
  This routine decompresses the whole image and writes it to the output file.
*/

{
    int ii, datatype = 0;
    int nullcheck, anynul;
    LONGLONG fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM];
    long inc[MAX_COMPRESS_DIM];
    long imgsize;
    float *nulladdr, fnulval;
    double dnulval;

    if (fits_img_decompress_header(infptr, outfptr, status) > 0)
    {
    	return (*status);
    }

    /* force a rescan of the output header keywords, then reset the scaling */
    /* in case the BSCALE and BZERO keywords are present, so that the       */
    /* decompressed values won't be scaled when written to the output image */
    ffrdef(outfptr, status);
    ffpscl(outfptr, 1.0, 0.0, status);
    ffpscl(infptr, 1.0, 0.0, status);

    /* initialize; no null checking is needed for integer images */
    nullcheck = 0;
    nulladdr =  &fnulval;

    /* determine datatype for image */
    if ((infptr->Fptr)->zbitpix == BYTE_IMG)
    {
        datatype = TBYTE;
    }
    else if ((infptr->Fptr)->zbitpix == SHORT_IMG)
    {
        datatype = TSHORT;
    }
    else if ((infptr->Fptr)->zbitpix == LONG_IMG)
    {
        datatype = TINT;
    }
    else if ((infptr->Fptr)->zbitpix == FLOAT_IMG)
    {
        /* In the case of float images we must check for NaNs  */
        nullcheck = 1;
        fnulval = FLOATNULLVALUE;
        nulladdr =  &fnulval;
        datatype = TFLOAT;
    }
    else if ((infptr->Fptr)->zbitpix == DOUBLE_IMG)
    {
        /* In the case of double images we must check for NaNs  */
        nullcheck = 1;
        dnulval = DOUBLENULLVALUE;
        nulladdr = (float *) &dnulval;
        datatype = TDOUBLE;
    }

    /* calculate size of the image (in pixels) */
    imgsize = 1;
    for (ii = 0; ii < (infptr->Fptr)->zndim; ii++)
    {
        imgsize *= (infptr->Fptr)->znaxis[ii];
        fpixel[ii] = 1;              /* Set first and last pixel to */
        lpixel[ii] = (infptr->Fptr)->znaxis[ii]; /* include the entire image. */
        inc[ii] = 1;
    }

    /* uncompress the input image and write to output image, one tile at a time */

    fits_read_write_compressed_img(infptr, datatype, fpixel, lpixel, inc,  
            nullcheck, nulladdr, &anynul, outfptr, status);

    return (*status);
}
/*--------------------------------------------------------------------------*/
int fits_decompress_img (fitsfile *infptr, /* image (bintable) to uncompress */
              fitsfile *outfptr,   /* empty HDU for output uncompressed image */
              int *status)         /* IO - error status               */

/* 
  THIS IS AN OBSOLETE ROUTINE.  USE fits_img_decompress instead!!!
  
  This routine decompresses the whole image and writes it to the output file.
*/

{
    double *data;
    int ii, datatype = 0, byte_per_pix = 0;
    int nullcheck, anynul;
    LONGLONG fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM];
    long inc[MAX_COMPRESS_DIM];
    long imgsize, memsize;
    float *nulladdr, fnulval;
    double dnulval;

    if (*status > 0)
        return(*status);

    if (!fits_is_compressed_image(infptr, status) )
    {
        ffpmsg("CHDU is not a compressed image (fits_decompress_img)");
        return(*status = DATA_DECOMPRESSION_ERR);
    }

    /* create an empty output image with the correct dimensions */
    if (ffcrim(outfptr, (infptr->Fptr)->zbitpix, (infptr->Fptr)->zndim, 
       (infptr->Fptr)->znaxis, status) > 0)
    {
        ffpmsg("error creating output decompressed image HDU");
    	return (*status);
    }
    /* Copy the table header to the image header. */
    if (imcomp_copy_imheader(infptr, outfptr, status) > 0)
    {
        ffpmsg("error copying header of compressed image");
    	return (*status);
    }

    /* force a rescan of the output header keywords, then reset the scaling */
    /* in case the BSCALE and BZERO keywords are present, so that the       */
    /* decompressed values won't be scaled when written to the output image */
    ffrdef(outfptr, status);
    ffpscl(outfptr, 1.0, 0.0, status);
    ffpscl(infptr, 1.0, 0.0, status);

    /* initialize; no null checking is needed for integer images */
    nullcheck = 0;
    nulladdr =  &fnulval;

    /* determine datatype for image */
    if ((infptr->Fptr)->zbitpix == BYTE_IMG)
    {
        datatype = TBYTE;
        byte_per_pix = 1;
    }
    else if ((infptr->Fptr)->zbitpix == SHORT_IMG)
    {
        datatype = TSHORT;
        byte_per_pix = sizeof(short);
    }
    else if ((infptr->Fptr)->zbitpix == LONG_IMG)
    {
        datatype = TINT;
        byte_per_pix = sizeof(int);
    }
    else if ((infptr->Fptr)->zbitpix == FLOAT_IMG)
    {
        /* In the case of float images we must check for NaNs  */
        nullcheck = 1;
        fnulval = FLOATNULLVALUE;
        nulladdr =  &fnulval;
        datatype = TFLOAT;
        byte_per_pix = sizeof(float);
    }
    else if ((infptr->Fptr)->zbitpix == DOUBLE_IMG)
    {
        /* In the case of double images we must check for NaNs  */
        nullcheck = 1;
        dnulval = DOUBLENULLVALUE;
        nulladdr = (float *) &dnulval;
        datatype = TDOUBLE;
        byte_per_pix = sizeof(double);
    }

    /* calculate size of the image (in pixels) */
    imgsize = 1;
    for (ii = 0; ii < (infptr->Fptr)->zndim; ii++)
    {
        imgsize *= (infptr->Fptr)->znaxis[ii];
        fpixel[ii] = 1;              /* Set first and last pixel to */
        lpixel[ii] = (infptr->Fptr)->znaxis[ii]; /* include the entire image. */
        inc[ii] = 1;
    }
    /* Calc equivalent number of double pixels same size as whole the image. */
    /* We use double datatype to force the memory to be aligned properly */
    memsize = ((imgsize * byte_per_pix) - 1) / sizeof(double) + 1;

    /* allocate memory for the image */
    data = (double*) calloc (memsize, sizeof(double));
    if (!data)
    { 
        ffpmsg("Couldn't allocate memory for the uncompressed image");
        return(*status = MEMORY_ALLOCATION);
    }

    /* uncompress the entire image into memory */
    /* This routine should be enhanced sometime to only need enough */
    /* memory to uncompress one tile at a time.  */
    fits_read_compressed_img(infptr, datatype, fpixel, lpixel, inc,  
            nullcheck, nulladdr, data, NULL, &anynul, status);

    /* write the image to the output file */
    if (anynul)
        fits_write_imgnull(outfptr, datatype, 1, imgsize, data, nulladdr, 
                          status);
    else
        fits_write_img(outfptr, datatype, 1, imgsize, data, status);

    free(data);
    return (*status);
}
/*--------------------------------------------------------------------------*/
int fits_img_decompress_header(fitsfile *infptr, /* image (bintable) to uncompress */
              fitsfile *outfptr,   /* empty HDU for output uncompressed image */
              int *status)         /* IO - error status               */

/* 
  This routine reads the header of the input tile compressed image and 
  converts it to that of a standard uncompress FITS image.
*/

{
    int writeprime = 0;
    int hdupos, inhdupos, numkeys;
    int nullprime = 0, copyprime = 0, norec = 0, tstatus;
    char card[FLEN_CARD];
    int ii, naxis, bitpix;
    long naxes[MAX_COMPRESS_DIM];

    if (*status > 0)
        return(*status);
    else if (*status == -1) {
        *status = 0;
	writeprime = 1;
    }

    if (!fits_is_compressed_image(infptr, status) )
    {
        ffpmsg("CHDU is not a compressed image (fits_img_decompress)");
        return(*status = DATA_DECOMPRESSION_ERR);
    }

    /* get information about the state of the output file; does it already */
    /* contain any keywords and HDUs?  */
    fits_get_hdu_num(infptr, &inhdupos);  /* Get the current output HDU position */
    fits_get_hdu_num(outfptr, &hdupos);  /* Get the current output HDU position */
    fits_get_hdrspace(outfptr, &numkeys, 0, status);

    /* Was the input compressed HDU originally the primary array image? */
    tstatus = 0;
    if (!fits_read_card(infptr, "ZSIMPLE", card, &tstatus)) { 
      /* yes, input HDU was a primary array (not an IMAGE extension) */
      /* Now determine if we can uncompress it into the primary array of */
      /* the output file.  This is only possible if the output file */
      /* currently only contains a null primary array, with no addition */
      /* header keywords and with no following extension in the FITS file. */
      
      if (hdupos == 1) {  /* are we positioned at the primary array? */
            if (numkeys == 0) { /* primary HDU is completely empty */
	        nullprime = 1;
            } else {
                fits_get_img_param(outfptr, MAX_COMPRESS_DIM, &bitpix, &naxis, naxes, status);
	
	        if (naxis == 0) { /* is this a null image? */
                   nullprime = 1;

		   if (inhdupos == 2)  /* must be at the first extension */
		      copyprime = 1;
		}
           }
      }
    } 

    if (nullprime) {  
       /* We will delete the existing keywords in the null primary array
          and uncompress the input image into the primary array of the output.
	  Some of these keywords may be added back to the uncompressed image
	  header later.
       */

       for (ii = numkeys; ii > 0; ii--)
          fits_delete_record(outfptr, ii, status);

    } else  {

       /* if the ZTENSION keyword doesn't exist, then we have to 
          write the required keywords manually */
       tstatus = 0;
       if (fits_read_card(infptr, "ZTENSION", card, &tstatus)) {

          /* create an empty output image with the correct dimensions */
          if (ffcrim(outfptr, (infptr->Fptr)->zbitpix, (infptr->Fptr)->zndim, 
             (infptr->Fptr)->znaxis, status) > 0)
          {
             ffpmsg("error creating output decompressed image HDU");
    	     return (*status);
          }

	  norec = 1;  /* the required keywords have already been written */

       } else {  /* the input compressed image does have ZTENSION keyword */
       
          if (writeprime) {  /* convert the image extension to a primary array */
	      /* have to write the required keywords manually */

              /* create an empty output image with the correct dimensions */
              if (ffcrim(outfptr, (infptr->Fptr)->zbitpix, (infptr->Fptr)->zndim, 
                 (infptr->Fptr)->znaxis, status) > 0)
              {
                 ffpmsg("error creating output decompressed image HDU");
    	         return (*status);
              }

	      norec = 1;  /* the required keywords have already been written */

          } else {  /* write the input compressed image to an image extension */

              if (numkeys == 0) {  /* the output file is currently completely empty */
	  
	         /* In this case, the input is a compressed IMAGE extension. */
	         /* Since the uncompressed output file is currently completely empty, */
	         /* we need to write a null primary array before uncompressing the */
                 /* image extension */
	     
                 ffcrim(outfptr, 8, 0, naxes, status); /* naxes is not used */
	     
	         /* now create the empty extension to uncompress into */
                 if (fits_create_hdu(outfptr, status) > 0)
                 {
                      ffpmsg("error creating output decompressed image HDU");
    	              return (*status);
                 }
	  
	      } else {
                  /* just create a new empty extension, then copy all the required */
	          /* keywords into it.  */
                 fits_create_hdu(outfptr, status);
	      }
           }
       }

    }

    if (*status > 0)  {
        ffpmsg("error creating output decompressed image HDU");
    	return (*status);
    }

    /* Copy the table header to the image header. */

    if (imcomp_copy_comp2img(infptr, outfptr, norec, status) > 0)
    {
        ffpmsg("error copying header keywords from compressed image");
    }

    if (copyprime) {  
	/* append any unexpected keywords from the primary array.
	   This includes any keywords except SIMPLE, BITPIX, NAXIS,
	   EXTEND, COMMENT, HISTORY, CHECKSUM, and DATASUM.
	*/

        fits_movabs_hdu(infptr, 1, NULL, status);  /* move to primary array */
	
        /* do this so that any new keywords get written before any blank
	   keywords that may have been appended by imcomp_copy_comp2img  */
        fits_set_hdustruc(outfptr, status);

        if (imcomp_copy_prime2img(infptr, outfptr, status) > 0)
        {
            ffpmsg("error copying primary keywords from compressed file");
        }

        fits_movabs_hdu(infptr, 2, NULL, status); /* move back to where we were */
    }

    return (*status);
}
/*---------------------------------------------------------------------------*/
int fits_read_compressed_img(fitsfile *fptr,   /* I - FITS file pointer      */
            int  datatype,  /* I - datatype of the array to be returned      */
            LONGLONG  *infpixel, /* I - 'bottom left corner' of the subsection    */
            LONGLONG  *inlpixel, /* I - 'top right corner' of the subsection      */
            long  *ininc,    /* I - increment to be applied in each dimension */
            int  nullcheck,  /* I - 0 for no null checking                   */
                              /*     1: set undefined pixels = nullval       */
                              /*     2: set nullarray=1 for undefined pixels */
            void *nullval,    /* I - value for undefined pixels              */
            void *array,      /* O - array of values that are returned       */
            char *nullarray,  /* O - array of flags = 1 if nullcheck = 2     */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
   Read a section of a compressed image;  Note: lpixel may be larger than the 
   size of the uncompressed image.  Only the pixels within the image will be
   returned.
*/
{
    long naxis[MAX_COMPRESS_DIM], tiledim[MAX_COMPRESS_DIM];
    long tilesize[MAX_COMPRESS_DIM], thistilesize[MAX_COMPRESS_DIM];
    long ftile[MAX_COMPRESS_DIM], ltile[MAX_COMPRESS_DIM];
    long tfpixel[MAX_COMPRESS_DIM], tlpixel[MAX_COMPRESS_DIM];
    long rowdim[MAX_COMPRESS_DIM], offset[MAX_COMPRESS_DIM],ntemp;
    long fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM];
    long inc[MAX_COMPRESS_DIM];
    long i5, i4, i3, i2, i1, i0, irow;
    int ii, ndim, pixlen, tilenul;
    void *buffer;
    char *bnullarray = 0;
    double testnullval = 0.;

    if (*status > 0) 
        return(*status);

    if (!fits_is_compressed_image(fptr, status) )
    {
        ffpmsg("CHDU is not a compressed image (fits_read_compressed_img)");
        return(*status = DATA_DECOMPRESSION_ERR);
    }

    /* get temporary space for uncompressing one image tile */
    if (datatype == TSHORT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (short)); 
       pixlen = sizeof(short);
       if (nullval)
           testnullval = *(short *) nullval;
    }
    else if (datatype == TINT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (int));
       pixlen = sizeof(int);
       if (nullval)
           testnullval = *(int *) nullval;
    }
    else if (datatype == TLONG)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (long));
       pixlen = sizeof(long);
       if (nullval)
           testnullval = *(long *) nullval;
    }
    else if (datatype == TFLOAT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (float));
       pixlen = sizeof(float);
       if (nullval)
           testnullval = *(float *) nullval;
    }
    else if (datatype == TDOUBLE)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (double));
       pixlen = sizeof(double);
       if (nullval)
           testnullval = *(double *) nullval;
    }
    else if (datatype == TUSHORT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned short));
       pixlen = sizeof(short);
       if (nullval)
           testnullval = *(unsigned short *) nullval;
    }
    else if (datatype == TUINT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned int));
       pixlen = sizeof(int);
       if (nullval)
           testnullval = *(unsigned int *) nullval;
    }
    else if (datatype == TULONG)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned long));
       pixlen = sizeof(long);
       if (nullval)
           testnullval = *(unsigned long *) nullval;
    }
    else if (datatype == TBYTE || datatype == TSBYTE)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (char));
       pixlen = 1;
       if (nullval)
           testnullval = *(unsigned char *) nullval;
    }
    else
    {
        ffpmsg("unsupported datatype for uncompressing image");
        return(*status = BAD_DATATYPE);
    }

    /* If nullcheck ==1 and nullval == 0, then this means that the */
    /* calling routine does not want to check for null pixels in the array */
    if (nullcheck == 1 && testnullval == 0.)
        nullcheck = 0;

    if (buffer == NULL)
    {
	    ffpmsg("Out of memory (fits_read_compress_img)");
	    return (*status = MEMORY_ALLOCATION);
    }
	
    /* allocate memory for a null flag array, if needed */
    if (nullcheck == 2)
    {
        bnullarray = calloc ((fptr->Fptr)->maxtilelen, sizeof (char));

        if (bnullarray == NULL)
        {
	    ffpmsg("Out of memory (fits_read_compress_img)");
            free(buffer);
	    return (*status = MEMORY_ALLOCATION);
        }
    }

    /* initialize all the arrays */
    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        naxis[ii] = 1;
        tiledim[ii] = 1;
        tilesize[ii] = 1;
        ftile[ii] = 1;
        ltile[ii] = 1;
        rowdim[ii] = 1;
    }

    ndim = (fptr->Fptr)->zndim;
    ntemp = 1;
    for (ii = 0; ii < ndim; ii++)
    {
        /* support for mirror-reversed image sections */
        if (infpixel[ii] <= inlpixel[ii])
        {
           fpixel[ii] = (long) infpixel[ii];
           lpixel[ii] = (long) inlpixel[ii];
           inc[ii]    = ininc[ii];
        }
        else
        {
           fpixel[ii] = (long) inlpixel[ii];
           lpixel[ii] = (long) infpixel[ii];
           inc[ii]    = -ininc[ii];
        }

        /* calc number of tiles in each dimension, and tile containing */
        /* the first and last pixel we want to read in each dimension  */
        naxis[ii] = (fptr->Fptr)->znaxis[ii];
        if (fpixel[ii] < 1)
        {
            if (nullcheck == 2)
            {
                free(bnullarray);
            }
            free(buffer);
            return(*status = BAD_PIX_NUM);
        }

        tilesize[ii] = (fptr->Fptr)->tilesize[ii];
        tiledim[ii] = (naxis[ii] - 1) / tilesize[ii] + 1;
        ftile[ii]   = (fpixel[ii] - 1)   / tilesize[ii] + 1;
        ltile[ii]   = minvalue((lpixel[ii] - 1) / tilesize[ii] + 1, 
                                tiledim[ii]);
        rowdim[ii]  = ntemp;  /* total tiles in each dimension */
        ntemp *= tiledim[ii];
    }

    if (anynul)
       *anynul = 0;  /* initialize */

    /* support up to 6 dimensions for now */
    /* tfpixel and tlpixel are the first and last image pixels */
    /* along each dimension of the compression tile */
    for (i5 = ftile[5]; i5 <= ltile[5]; i5++)
    {
     tfpixel[5] = (i5 - 1) * tilesize[5] + 1;
     tlpixel[5] = minvalue(tfpixel[5] + tilesize[5] - 1, 
                            naxis[5]);
     thistilesize[5] = tlpixel[5] - tfpixel[5] + 1;
     offset[5] = (i5 - 1) * rowdim[5];
     for (i4 = ftile[4]; i4 <= ltile[4]; i4++)
     {
      tfpixel[4] = (i4 - 1) * tilesize[4] + 1;
      tlpixel[4] = minvalue(tfpixel[4] + tilesize[4] - 1, 
                            naxis[4]);
      thistilesize[4] = thistilesize[5] * (tlpixel[4] - tfpixel[4] + 1);
      offset[4] = (i4 - 1) * rowdim[4] + offset[5];
      for (i3 = ftile[3]; i3 <= ltile[3]; i3++)
      {
        tfpixel[3] = (i3 - 1) * tilesize[3] + 1;
        tlpixel[3] = minvalue(tfpixel[3] + tilesize[3] - 1, 
                              naxis[3]);
        thistilesize[3] = thistilesize[4] * (tlpixel[3] - tfpixel[3] + 1);
        offset[3] = (i3 - 1) * rowdim[3] + offset[4];
        for (i2 = ftile[2]; i2 <= ltile[2]; i2++)
        {
          tfpixel[2] = (i2 - 1) * tilesize[2] + 1;
          tlpixel[2] = minvalue(tfpixel[2] + tilesize[2] - 1, 
                                naxis[2]);
          thistilesize[2] = thistilesize[3] * (tlpixel[2] - tfpixel[2] + 1);
          offset[2] = (i2 - 1) * rowdim[2] + offset[3];
          for (i1 = ftile[1]; i1 <= ltile[1]; i1++)
          {
            tfpixel[1] = (i1 - 1) * tilesize[1] + 1;
            tlpixel[1] = minvalue(tfpixel[1] + tilesize[1] - 1, 
                                  naxis[1]);
            thistilesize[1] = thistilesize[2] * (tlpixel[1] - tfpixel[1] + 1);
            offset[1] = (i1 - 1) * rowdim[1] + offset[2];
            for (i0 = ftile[0]; i0 <= ltile[0]; i0++)
            {
             tfpixel[0] = (i0 - 1) * tilesize[0] + 1;
             tlpixel[0] = minvalue(tfpixel[0] + tilesize[0] - 1, 
                                    naxis[0]);
              thistilesize[0] = thistilesize[1] * (tlpixel[0] - tfpixel[0] + 1);
              /* calculate row of table containing this tile */
              irow = i0 + offset[1];

/*
printf("row %d, %d %d, %d %d, %d %d; %d\n",
              irow, tfpixel[0],tlpixel[0],tfpixel[1],tlpixel[1],tfpixel[2],tlpixel[2],
	      thistilesize[0]);
*/   
              /* test if there are any intersecting pixels in this tile and the output image */
              if (imcomp_test_overlap(ndim, tfpixel, tlpixel, 
                      fpixel, lpixel, inc, status)) {
                  /* read and uncompress this row (tile) of the table */
                  /* also do type conversion and undefined pixel substitution */
                  /* at this point */

                  imcomp_decompress_tile(fptr, irow, thistilesize[0],
                    datatype, nullcheck, nullval, buffer, bnullarray, &tilenul,
                     status);

                  if (tilenul && anynul)
                      *anynul = 1;  /* there are null pixels */
/*
printf(" pixlen=%d, ndim=%d, %d %d %d, %d %d %d, %d %d %d\n",
     pixlen, ndim, fpixel[0],lpixel[0],inc[0],fpixel[1],lpixel[1],inc[1],
     fpixel[2],lpixel[2],inc[2]);
*/
                  /* copy the intersecting pixels from this tile to the output */
                  imcomp_copy_overlap(buffer, pixlen, ndim, tfpixel, tlpixel, 
                     bnullarray, array, fpixel, lpixel, inc, nullcheck, 
                     nullarray, status);
               }
            }
          }
        }
      }
     }
    }
    if (nullcheck == 2)
    {
        free(bnullarray);
    }
    free(buffer);

    return(*status);
}
/*---------------------------------------------------------------------------*/
int fits_read_write_compressed_img(fitsfile *fptr,   /* I - FITS file pointer      */
            int  datatype,  /* I - datatype of the array to be returned      */
            LONGLONG  *infpixel, /* I - 'bottom left corner' of the subsection    */
            LONGLONG  *inlpixel, /* I - 'top right corner' of the subsection      */
            long  *ininc,    /* I - increment to be applied in each dimension */
            int  nullcheck,  /* I - 0 for no null checking                   */
                              /*     1: set undefined pixels = nullval       */
            void *nullval,    /* I - value for undefined pixels              */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            fitsfile *outfptr,   /* I - FITS file pointer                    */
            int  *status)     /* IO - error status                           */
/*
   This is similar to fits_read_compressed_img, except that it writes
   the pixels to the output image, on a tile by tile basis instead of returning
   the array.
*/
{
    long naxis[MAX_COMPRESS_DIM], tiledim[MAX_COMPRESS_DIM];
    long tilesize[MAX_COMPRESS_DIM], thistilesize[MAX_COMPRESS_DIM];
    long ftile[MAX_COMPRESS_DIM], ltile[MAX_COMPRESS_DIM];
    long tfpixel[MAX_COMPRESS_DIM], tlpixel[MAX_COMPRESS_DIM];
    long rowdim[MAX_COMPRESS_DIM], offset[MAX_COMPRESS_DIM],ntemp;
    long fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM];
    long inc[MAX_COMPRESS_DIM];
    long i5, i4, i3, i2, i1, i0, irow;
    int ii, ndim, pixlen, tilenul;
    void *buffer;
    char *bnullarray = 0, *cnull;
    LONGLONG firstelem;

    if (*status > 0) 
        return(*status);

    if (!fits_is_compressed_image(fptr, status) )
    {
        ffpmsg("CHDU is not a compressed image (fits_read_compressed_img)");
        return(*status = DATA_DECOMPRESSION_ERR);
    }

    cnull = (char *) nullval;  /* used to test if the nullval = 0 */
    
    /* get temporary space for uncompressing one image tile */
    /* If nullval == 0, then this means that the */
    /* calling routine does not want to check for null pixels in the array */
    if (datatype == TSHORT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (short)); 
       pixlen = sizeof(short);
       if (cnull) {
         if (cnull[0] == 0 && cnull[1] == 0 ) {
           nullcheck = 0;
	 }
       }
    }
    else if (datatype == TINT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (int));
       pixlen = sizeof(int);
       if (cnull) {
         if (cnull[0] == 0 && cnull[1] == 0 && cnull[2] == 0 && cnull[3] == 0 ) {
           nullcheck = 0;
	 }
       }
    }
    else if (datatype == TLONG)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (long));
       pixlen = sizeof(long);
       if (cnull) {
         if (cnull[0] == 0 && cnull[1] == 0 && cnull[2] == 0 && cnull[3] == 0 ) {
           nullcheck = 0;
	 }
       }
    }
    else if (datatype == TFLOAT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (float));
       pixlen = sizeof(float);
       if (cnull) {
         if (cnull[0] == 0 && cnull[1] == 0 && cnull[2] == 0 && cnull[3] == 0  ) {
           nullcheck = 0;
	 }
       }
    }
    else if (datatype == TDOUBLE)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (double));
       pixlen = sizeof(double);
       if (cnull) {
         if (cnull[0] == 0 && cnull[1] == 0 && cnull[2] == 0 && cnull[3] == 0 &&
	     cnull[4] == 0 && cnull[5] == 0 && cnull[6] == 0 && cnull[7] == 0 ) {
           nullcheck = 0;
	 }
       }
    }
    else if (datatype == TUSHORT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned short));
       pixlen = sizeof(short);
       if (cnull) {
         if (cnull[0] == 0 && cnull[1] == 0 ){
           nullcheck = 0;
	 }
       }
    }
    else if (datatype == TUINT)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned int));
       pixlen = sizeof(int);
       if (cnull) {
         if (cnull[0] == 0 && cnull[1] == 0 && cnull[2] == 0 && cnull[3] == 0 ){
           nullcheck = 0;
	 }
       }
    }
    else if (datatype == TULONG)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned long));
       pixlen = sizeof(long);
       if (cnull) {
         if (cnull[0] == 0 && cnull[1] == 0 && cnull[2] == 0 && cnull[3] == 0 ){
           nullcheck = 0;
	 }
       }
    }
    else if (datatype == TBYTE || datatype == TSBYTE)
    {
       buffer =  malloc ((fptr->Fptr)->maxtilelen * sizeof (char));
       pixlen = 1;
       if (cnull) {
         if (cnull[0] == 0){
           nullcheck = 0;
	 }
       }
    }
    else
    {
        ffpmsg("unsupported datatype for uncompressing image");
        return(*status = BAD_DATATYPE);
    }

    if (buffer == NULL)
    {
	    ffpmsg("Out of memory (fits_read_compress_img)");
	    return (*status = MEMORY_ALLOCATION);
    }

    /* initialize all the arrays */
    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        naxis[ii] = 1;
        tiledim[ii] = 1;
        tilesize[ii] = 1;
        ftile[ii] = 1;
        ltile[ii] = 1;
        rowdim[ii] = 1;
    }

    ndim = (fptr->Fptr)->zndim;
    ntemp = 1;
    for (ii = 0; ii < ndim; ii++)
    {
        /* support for mirror-reversed image sections */
        if (infpixel[ii] <= inlpixel[ii])
        {
           fpixel[ii] = (long) infpixel[ii];
           lpixel[ii] = (long) inlpixel[ii];
           inc[ii]    = ininc[ii];
        }
        else
        {
           fpixel[ii] = (long) inlpixel[ii];
           lpixel[ii] = (long) infpixel[ii];
           inc[ii]    = -ininc[ii];
        }

        /* calc number of tiles in each dimension, and tile containing */
        /* the first and last pixel we want to read in each dimension  */
        naxis[ii] = (fptr->Fptr)->znaxis[ii];
        if (fpixel[ii] < 1)
        {
            free(buffer);
            return(*status = BAD_PIX_NUM);
        }

        tilesize[ii] = (fptr->Fptr)->tilesize[ii];
        tiledim[ii] = (naxis[ii] - 1) / tilesize[ii] + 1;
        ftile[ii]   = (fpixel[ii] - 1)   / tilesize[ii] + 1;
        ltile[ii]   = minvalue((lpixel[ii] - 1) / tilesize[ii] + 1, 
                                tiledim[ii]);
        rowdim[ii]  = ntemp;  /* total tiles in each dimension */
        ntemp *= tiledim[ii];
    }

    if (anynul)
       *anynul = 0;  /* initialize */

    firstelem = 1;

    /* support up to 6 dimensions for now */
    /* tfpixel and tlpixel are the first and last image pixels */
    /* along each dimension of the compression tile */
    for (i5 = ftile[5]; i5 <= ltile[5]; i5++)
    {
     tfpixel[5] = (i5 - 1) * tilesize[5] + 1;
     tlpixel[5] = minvalue(tfpixel[5] + tilesize[5] - 1, 
                            naxis[5]);
     thistilesize[5] = tlpixel[5] - tfpixel[5] + 1;
     offset[5] = (i5 - 1) * rowdim[5];
     for (i4 = ftile[4]; i4 <= ltile[4]; i4++)
     {
      tfpixel[4] = (i4 - 1) * tilesize[4] + 1;
      tlpixel[4] = minvalue(tfpixel[4] + tilesize[4] - 1, 
                            naxis[4]);
      thistilesize[4] = thistilesize[5] * (tlpixel[4] - tfpixel[4] + 1);
      offset[4] = (i4 - 1) * rowdim[4] + offset[5];
      for (i3 = ftile[3]; i3 <= ltile[3]; i3++)
      {
        tfpixel[3] = (i3 - 1) * tilesize[3] + 1;
        tlpixel[3] = minvalue(tfpixel[3] + tilesize[3] - 1, 
                              naxis[3]);
        thistilesize[3] = thistilesize[4] * (tlpixel[3] - tfpixel[3] + 1);
        offset[3] = (i3 - 1) * rowdim[3] + offset[4];
        for (i2 = ftile[2]; i2 <= ltile[2]; i2++)
        {
          tfpixel[2] = (i2 - 1) * tilesize[2] + 1;
          tlpixel[2] = minvalue(tfpixel[2] + tilesize[2] - 1, 
                                naxis[2]);
          thistilesize[2] = thistilesize[3] * (tlpixel[2] - tfpixel[2] + 1);
          offset[2] = (i2 - 1) * rowdim[2] + offset[3];
          for (i1 = ftile[1]; i1 <= ltile[1]; i1++)
          {
            tfpixel[1] = (i1 - 1) * tilesize[1] + 1;
            tlpixel[1] = minvalue(tfpixel[1] + tilesize[1] - 1, 
                                  naxis[1]);
            thistilesize[1] = thistilesize[2] * (tlpixel[1] - tfpixel[1] + 1);
            offset[1] = (i1 - 1) * rowdim[1] + offset[2];
            for (i0 = ftile[0]; i0 <= ltile[0]; i0++)
            {
              tfpixel[0] = (i0 - 1) * tilesize[0] + 1;
              tlpixel[0] = minvalue(tfpixel[0] + tilesize[0] - 1, 
                                    naxis[0]);
              thistilesize[0] = thistilesize[1] * (tlpixel[0] - tfpixel[0] + 1);
              /* calculate row of table containing this tile */
              irow = i0 + offset[1];
 
              /* read and uncompress this row (tile) of the table */
              /* also do type conversion and undefined pixel substitution */
              /* at this point */

              imcomp_decompress_tile(fptr, irow, thistilesize[0],
                    datatype, nullcheck, nullval, buffer, bnullarray, &tilenul,
                     status);

               /* write the image to the output file */

              if (tilenul && anynul) {     
                   /* this assumes that the tiled pixels are in the same order
		      as in the uncompressed FITS image.  This is not necessarily
		      the case, but it almost alway is in practice.  
		      Note that null checking is not performed for integer images,
		      so this could only be a problem for tile compressed floating
		      point images that use an unconventional tiling pattern.
		   */
                   fits_write_imgnull(outfptr, datatype, firstelem, thistilesize[0],
		      buffer, nullval, status);
              } else {
                  fits_write_subset(outfptr, datatype, tfpixel, tlpixel, 
		      buffer, status);
              }

              firstelem += thistilesize[0];

            }
          }
        }
      }
     }
    }

    free(buffer);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_read_compressed_pixels(fitsfile *fptr, /* I - FITS file pointer    */
            int  datatype,  /* I - datatype of the array to be returned     */
            LONGLONG   fpixel, /* I - 'first pixel to read          */
            LONGLONG   npixel,  /* I - number of pixels to read      */
            int  nullcheck,  /* I - 0 for no null checking                   */
                              /*     1: set undefined pixels = nullval       */
                              /*     2: set nullarray=1 for undefined pixels */
            void *nullval,    /* I - value for undefined pixels              */
            void *array,      /* O - array of values that are returned       */
            char *nullarray,  /* O - array of flags = 1 if nullcheck = 2     */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            int  *status)     /* IO - error status                           */
/*
   Read a consecutive set of pixels from a compressed image.  This routine
   interpretes the n-dimensional image as a long one-dimensional array. 
   This is actually a rather inconvenient way to read compressed images in
   general, and could be rather inefficient if the requested pixels to be
   read are located in many different image compression tiles.    

   The general strategy used here is to read the requested pixels in blocks
   that correspond to rectangular image sections.  
*/
{
    int naxis, ii, bytesperpixel, planenul;
    long naxes[MAX_COMPRESS_DIM], nread;
    long nplane, inc[MAX_COMPRESS_DIM];
    LONGLONG tfirst, tlast, last0, last1, dimsize[MAX_COMPRESS_DIM];
    LONGLONG firstcoord[MAX_COMPRESS_DIM], lastcoord[MAX_COMPRESS_DIM];
    char *arrayptr, *nullarrayptr;

    if (*status > 0)
        return(*status);

    arrayptr = (char *) array;
    nullarrayptr = nullarray;

    /* get size of array pixels, in bytes */
    bytesperpixel = ffpxsz(datatype);

    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        naxes[ii] = 1;
        firstcoord[ii] = 0;
        lastcoord[ii] = 0;
        inc[ii] = 1;
    }

    /*  determine the dimensions of the image to be read */
    ffgidm(fptr, &naxis, status);
    ffgisz(fptr, MAX_COMPRESS_DIM, naxes, status);

    /* calc the cumulative number of pixels in each successive dimension */
    dimsize[0] = 1;
    for (ii = 1; ii < MAX_COMPRESS_DIM; ii++)
         dimsize[ii] = dimsize[ii - 1] * naxes[ii - 1];

    /*  determine the coordinate of the first and last pixel in the image */
    /*  Use zero based indexes here */
    tfirst = fpixel - 1;
    tlast = tfirst + npixel - 1;
    for (ii = naxis - 1; ii >= 0; ii--)
    {
        firstcoord[ii] = tfirst / dimsize[ii];
        lastcoord[ii] =  tlast / dimsize[ii];
        tfirst = tfirst - firstcoord[ii] * dimsize[ii];
        tlast = tlast - lastcoord[ii] * dimsize[ii];
    }

    /* to simplify things, treat 1-D, 2-D, and 3-D images as separate cases */

    if (naxis == 1)
    {
        /* Simple: just read the requested range of pixels */

        firstcoord[0] = firstcoord[0] + 1;
        lastcoord[0] = lastcoord[0] + 1;
        fits_read_compressed_img(fptr, datatype, firstcoord, lastcoord, inc,
            nullcheck, nullval, array, nullarray, anynul, status);
        return(*status);
    }
    else if (naxis == 2)
    {
        nplane = 0;  /* read 1st (and only) plane of the image */

        fits_read_compressed_img_plane(fptr, datatype, bytesperpixel,
          nplane, firstcoord, lastcoord, inc, naxes, nullcheck, nullval,
          array, nullarray, anynul, &nread, status);
    }
    else if (naxis == 3)
    {
        /* test for special case: reading an integral number of planes */
        if (firstcoord[0] == 0 && firstcoord[1] == 0 &&
            lastcoord[0] == naxes[0] - 1 && lastcoord[1] == naxes[1] - 1)
        {
            for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
            {
                /* convert from zero base to 1 base */
                (firstcoord[ii])++;
                (lastcoord[ii])++;
            }

            /* we can read the contiguous block of pixels in one go */
            fits_read_compressed_img(fptr, datatype, firstcoord, lastcoord, inc,
                nullcheck, nullval, array, nullarray, anynul, status);

            return(*status);
        }

        if (anynul)
            *anynul = 0;  /* initialize */

        /* save last coordinate in temporary variables */
        last0 = lastcoord[0];
        last1 = lastcoord[1];

        if (firstcoord[2] < lastcoord[2])
        {
            /* we will read up to the last pixel in all but the last plane */
            lastcoord[0] = naxes[0] - 1;
            lastcoord[1] = naxes[1] - 1;
        }

        /* read one plane of the cube at a time, for simplicity */
        for (nplane = (long) firstcoord[2]; nplane <= lastcoord[2]; nplane++)
        {
            if (nplane == lastcoord[2])
            {
                lastcoord[0] = last0;
                lastcoord[1] = last1;
            }

            fits_read_compressed_img_plane(fptr, datatype, bytesperpixel,
              nplane, firstcoord, lastcoord, inc, naxes, nullcheck, nullval,
              arrayptr, nullarrayptr, &planenul, &nread, status);

            if (planenul && anynul)
               *anynul = 1;  /* there are null pixels */

            /* for all subsequent planes, we start with the first pixel */
            firstcoord[0] = 0;
            firstcoord[1] = 0;

            /* increment pointers to next elements to be read */
            arrayptr = arrayptr + nread * bytesperpixel;
            if (nullarrayptr && (nullcheck == 2) )
                nullarrayptr = nullarrayptr + nread;
        }
    }
    else
    {
        ffpmsg("only 1D, 2D, or 3D images are currently supported");
        return(*status = DATA_DECOMPRESSION_ERR);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_read_compressed_img_plane(fitsfile *fptr, /* I - FITS file   */
            int  datatype,  /* I - datatype of the array to be returned      */
            int  bytesperpixel, /* I - number of bytes per pixel in array */
            long   nplane,  /* I - which plane of the cube to read      */
            LONGLONG *firstcoord,  /* coordinate of first pixel to read */
            LONGLONG *lastcoord,   /* coordinate of last pixel to read */
            long *inc,         /* increment of pixels to read */
            long *naxes,      /* size of each image dimension */
            int  nullcheck,  /* I - 0 for no null checking                   */
                              /*     1: set undefined pixels = nullval       */
                              /*     2: set nullarray=1 for undefined pixels */
            void *nullval,    /* I - value for undefined pixels              */
            void *array,      /* O - array of values that are returned       */
            char *nullarray,  /* O - array of flags = 1 if nullcheck = 2     */
            int  *anynul,     /* O - set to 1 if any values are null; else 0 */
            long *nread,      /* O - total number of pixels read and returned*/
            int  *status)     /* IO - error status                           */

   /*
           in general we have to read the first partial row of the image,
           followed by the middle complete rows, followed by the last
           partial row of the image.  If the first or last rows are complete,
           then read them at the same time as all the middle rows.
    */
{
     /* bottom left coord. and top right coord. */
    LONGLONG blc[MAX_COMPRESS_DIM], trc[MAX_COMPRESS_DIM]; 
    char *arrayptr, *nullarrayptr;
    int tnull;

    if (anynul)
        *anynul = 0;

    *nread = 0;

    arrayptr = (char *) array;
    nullarrayptr = nullarray;

    blc[2] = nplane + 1;
    trc[2] = nplane + 1;

    if (firstcoord[0] != 0)
    { 
            /* have to read a partial first row */
            blc[0] = firstcoord[0] + 1;
            blc[1] = firstcoord[1] + 1;
            trc[1] = blc[1];  
            if (lastcoord[1] == firstcoord[1])
               trc[0] = lastcoord[0] + 1; /* 1st and last pixels in same row */
            else
               trc[0] = naxes[0];  /* read entire rest of the row */

            fits_read_compressed_img(fptr, datatype, blc, trc, inc,
                nullcheck, nullval, arrayptr, nullarrayptr, &tnull, status);

            *nread = *nread + (long) (trc[0] - blc[0] + 1);

            if (tnull && anynul)
               *anynul = 1;  /* there are null pixels */

            if (lastcoord[1] == firstcoord[1])
            {
               return(*status);  /* finished */
            }

            /* set starting coord to beginning of next line */
            firstcoord[0] = 0;
            firstcoord[1] += 1;
            arrayptr = arrayptr + (trc[0] - blc[0] + 1) * bytesperpixel;
            if (nullarrayptr && (nullcheck == 2) )
                nullarrayptr = nullarrayptr + (trc[0] - blc[0] + 1);

    }

    /* read contiguous complete rows of the image, if any */
    blc[0] = 1;
    blc[1] = firstcoord[1] + 1;
    trc[0] = naxes[0];

    if (lastcoord[0] + 1 == naxes[0])
    {
            /* can read the last complete row, too */
            trc[1] = lastcoord[1] + 1;
    }
    else
    {
            /* last row is incomplete; have to read it separately */
            trc[1] = lastcoord[1];
    }

    if (trc[1] >= blc[1])  /* must have at least one whole line to read */
    {
        fits_read_compressed_img(fptr, datatype, blc, trc, inc,
                nullcheck, nullval, arrayptr, nullarrayptr, &tnull, status);

        *nread = *nread + (long) ((trc[1] - blc[1] + 1) * naxes[0]);

        if (tnull && anynul)
           *anynul = 1;

        if (lastcoord[1] + 1 == trc[1])
               return(*status);  /* finished */

        /* increment pointers for the last partial row */
        arrayptr = arrayptr + (trc[1] - blc[1] + 1) * naxes[0] * bytesperpixel;
        if (nullarrayptr && (nullcheck == 2) )
                nullarrayptr = nullarrayptr + (trc[1] - blc[1] + 1) * naxes[0];
     }

    if (trc[1] == lastcoord[1] + 1)
        return(*status);           /* all done */

    /* set starting and ending coord to last line */

    trc[0] = lastcoord[0] + 1;
    trc[1] = lastcoord[1] + 1;
    blc[1] = trc[1];

    fits_read_compressed_img(fptr, datatype, blc, trc, inc,
                nullcheck, nullval, arrayptr, nullarrayptr, &tnull, status);

    if (tnull && anynul)
       *anynul = 1;

    *nread = *nread + (long) (trc[0] - blc[0] + 1);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_get_compressed_image_par(fitsfile *infptr, int *status)
 
/* 
    This routine reads keywords from a BINTABLE extension containing a
    compressed image.
*/
{
    char keyword[FLEN_KEYWORD];
    char value[FLEN_VALUE];
    int ii, tstatus, doffset;
    long expect_nrows, maxtilelen;

    if (*status > 0)
        return(*status);

    /* Copy relevant header keyword values to structure */
    if (ffgky (infptr, TSTRING, "ZCMPTYPE", value, NULL, status) > 0)
    {
        ffpmsg("required ZCMPTYPE compression keyword not found in");
        ffpmsg(" imcomp_get_compressed_image_par");
        return(*status);
    }

    (infptr->Fptr)->zcmptype[0] = '\0';
    strncat((infptr->Fptr)->zcmptype, value, 11);

    if (!FSTRCMP(value, "RICE_1") || !FSTRCMP(value, "RICE_ONE") )
        (infptr->Fptr)->compress_type = RICE_1;
    else if (!FSTRCMP(value, "HCOMPRESS_1") )
        (infptr->Fptr)->compress_type = HCOMPRESS_1;
    else if (!FSTRCMP(value, "GZIP_1") )
        (infptr->Fptr)->compress_type = GZIP_1;
    else if (!FSTRCMP(value, "GZIP_2") )
        (infptr->Fptr)->compress_type = GZIP_2;
    else if (!FSTRCMP(value, "BZIP2_1") )
        (infptr->Fptr)->compress_type = BZIP2_1;
    else if (!FSTRCMP(value, "PLIO_1") )
        (infptr->Fptr)->compress_type = PLIO_1;
    else if (!FSTRCMP(value, "NOCOMPRESS") )
        (infptr->Fptr)->compress_type = NOCOMPRESS;
    else
    {
        ffpmsg("Unknown image compression type:");
        ffpmsg(value);
	return (*status = DATA_DECOMPRESSION_ERR);
    }

    /* get the floating point to integer quantization type, if present. */
    /* FITS files produced before 2009 will not have this keyword */
    tstatus = 0;
    if (ffgky(infptr, TSTRING, "ZQUANTIZ", value, NULL, &tstatus) > 0)
    {
        (infptr->Fptr)->quantize_method = 0;
    } else {

        if (!FSTRCMP(value, "NONE") ) {
            (infptr->Fptr)->quantize_level = NO_QUANTIZE;
       } else if (!FSTRCMP(value, "SUBTRACTIVE_DITHER_1") )
            (infptr->Fptr)->quantize_method = SUBTRACTIVE_DITHER_1;
        else if (!FSTRCMP(value, "SUBTRACTIVE_DITHER_2") )
            (infptr->Fptr)->quantize_method = SUBTRACTIVE_DITHER_2;
        else if (!FSTRCMP(value, "NO_DITHER") )
            (infptr->Fptr)->quantize_method = NO_DITHER;
        else
            (infptr->Fptr)->quantize_method = 0;
    }

    /* get the floating point quantization dithering offset, if present. */
    /* FITS files produced before October 2009 will not have this keyword */
    tstatus = 0;
    if (ffgky(infptr, TINT, "ZDITHER0", &doffset, NULL, &tstatus) > 0)
    {
	/* by default start with 1st element of random sequence */
        (infptr->Fptr)->dither_seed = 1;  
    } else {
        (infptr->Fptr)->dither_seed = doffset;
    }

    if (ffgky (infptr, TINT,  "ZBITPIX",  &(infptr->Fptr)->zbitpix,  
               NULL, status) > 0)
    {
        ffpmsg("required ZBITPIX compression keyword not found");
        return(*status);
    }

    if (ffgky (infptr,TINT, "ZNAXIS", &(infptr->Fptr)->zndim, NULL, status) > 0)
    {
        ffpmsg("required ZNAXIS compression keyword not found");
        return(*status);
    }

    if ((infptr->Fptr)->zndim < 1)
    {
        ffpmsg("Compressed image has no data (ZNAXIS < 1)");
	return (*status = BAD_NAXIS);
    }

    if ((infptr->Fptr)->zndim > MAX_COMPRESS_DIM)
    {
        ffpmsg("Compressed image has too many dimensions");
        return(*status = BAD_NAXIS);
    }

    expect_nrows = 1;
    maxtilelen = 1;
    for (ii = 0;  ii < (infptr->Fptr)->zndim;  ii++)
    {
        /* get image size */
        sprintf (keyword, "ZNAXIS%d", ii+1);
	ffgky (infptr, TLONG,keyword, &(infptr->Fptr)->znaxis[ii],NULL,status);

        if (*status > 0)
        {
            ffpmsg("required ZNAXISn compression keyword not found");
            return(*status);
        }

        /* get compression tile size */
	sprintf (keyword, "ZTILE%d", ii+1);

        /* set default tile size in case keywords are not present */
        if (ii == 0)
            (infptr->Fptr)->tilesize[0] = (infptr->Fptr)->znaxis[0];
        else
            (infptr->Fptr)->tilesize[ii] = 1;

        tstatus = 0;
	ffgky (infptr, TLONG, keyword, &(infptr->Fptr)->tilesize[ii], NULL, 
               &tstatus);

        expect_nrows *= (((infptr->Fptr)->znaxis[ii] - 1) / 
                  (infptr->Fptr)->tilesize[ii]+ 1);
        maxtilelen *= (infptr->Fptr)->tilesize[ii];
    }

    /* check number of rows */
    if (expect_nrows != (infptr->Fptr)->numrows)
    {
        ffpmsg(
        "number of table rows != the number of tiles in compressed image");
        return (*status = DATA_DECOMPRESSION_ERR);
    }

    /* read any algorithm specific parameters */
    if ((infptr->Fptr)->compress_type == RICE_1 )
    {
        if (ffgky(infptr, TINT,"ZVAL1", &(infptr->Fptr)->rice_blocksize,
                  NULL, status) > 0)
        {
            ffpmsg("required ZVAL1 compression keyword not found");
            return(*status);
        }

        tstatus = 0;
        if (ffgky(infptr, TINT,"ZVAL2", &(infptr->Fptr)->rice_bytepix,
                  NULL, &tstatus) > 0)
        {
            (infptr->Fptr)->rice_bytepix = 4;  /* default value */
        }

        if ((infptr->Fptr)->rice_blocksize < 16 &&
	    (infptr->Fptr)->rice_bytepix > 8) {
	     /* values are reversed */
	     tstatus = (infptr->Fptr)->rice_bytepix;
	     (infptr->Fptr)->rice_bytepix = (infptr->Fptr)->rice_blocksize;
	     (infptr->Fptr)->rice_blocksize = tstatus;
        }
    } else if ((infptr->Fptr)->compress_type == HCOMPRESS_1 ) {

        if (ffgky(infptr, TFLOAT,"ZVAL1", &(infptr->Fptr)->hcomp_scale,
                  NULL, status) > 0)
        {
            ffpmsg("required ZVAL1 compression keyword not found");
            return(*status);
        }

        tstatus = 0;
        ffgky(infptr, TINT,"ZVAL2", &(infptr->Fptr)->hcomp_smooth,
                  NULL, &tstatus);
    }    

    /* store number of pixels in each compression tile, */
    /* and max size of the compressed tile buffer */
    (infptr->Fptr)->maxtilelen = maxtilelen;

    (infptr->Fptr)->maxelem = 
           imcomp_calc_max_elem ((infptr->Fptr)->compress_type, maxtilelen, 
               (infptr->Fptr)->zbitpix, (infptr->Fptr)->rice_blocksize);

    /* Get Column numbers. */
    if (ffgcno(infptr, CASEINSEN, "COMPRESSED_DATA",
         &(infptr->Fptr)->cn_compressed, status) > 0)
    {
        ffpmsg("couldn't find COMPRESSED_DATA column (fits_get_compressed_img_par)");
        return(*status = DATA_DECOMPRESSION_ERR);
    }

    ffpmrk(); /* put mark on message stack; erase any messages after this */

    tstatus = 0;
    ffgcno(infptr,CASEINSEN, "UNCOMPRESSED_DATA",
          &(infptr->Fptr)->cn_uncompressed, &tstatus);

    tstatus = 0;
    ffgcno(infptr,CASEINSEN, "GZIP_COMPRESSED_DATA",
          &(infptr->Fptr)->cn_gzip_data, &tstatus);

    tstatus = 0;
    if (ffgcno(infptr, CASEINSEN, "ZSCALE", &(infptr->Fptr)->cn_zscale,
              &tstatus) > 0)
    {
        /* CMPSCALE column doesn't exist; see if there is a keyword */
        tstatus = 0;
        if (ffgky(infptr, TDOUBLE, "ZSCALE", &(infptr->Fptr)->zscale, NULL, 
                 &tstatus) <= 0)
            (infptr->Fptr)->cn_zscale = -1;  /* flag for a constant ZSCALE */
    }

    tstatus = 0;
    if (ffgcno(infptr, CASEINSEN, "ZZERO", &(infptr->Fptr)->cn_zzero,
               &tstatus) > 0)
    {
        /* CMPZERO column doesn't exist; see if there is a keyword */
        tstatus = 0;
        if (ffgky(infptr, TDOUBLE, "ZZERO", &(infptr->Fptr)->zzero, NULL, 
                  &tstatus) <= 0)
            (infptr->Fptr)->cn_zzero = -1;  /* flag for a constant ZZERO */
    }

    tstatus = 0;
    if (ffgcno(infptr, CASEINSEN, "ZBLANK", &(infptr->Fptr)->cn_zblank,
               &tstatus) > 0)
    {
        /* ZBLANK column doesn't exist; see if there is a keyword */
        tstatus = 0;
        if (ffgky(infptr, TINT, "ZBLANK", &(infptr->Fptr)->zblank, NULL,
                  &tstatus) <= 0)  {
            (infptr->Fptr)->cn_zblank = -1;  /* flag for a constant ZBLANK */

        } else {
           /* ZBLANK keyword doesn't exist; see if there is a BLANK keyword */
           tstatus = 0;
           if (ffgky(infptr, TINT, "BLANK", &(infptr->Fptr)->zblank, NULL,
                  &tstatus) <= 0)  
              (infptr->Fptr)->cn_zblank = -1;  /* flag for a constant ZBLANK */
        }
    }

    /* read the conventional BSCALE and BZERO scaling keywords, if present */
    tstatus = 0;
    if (ffgky (infptr, TDOUBLE, "BSCALE", &(infptr->Fptr)->cn_bscale, 
        NULL, &tstatus) > 0)
    {
        (infptr->Fptr)->cn_bscale = 1.0;
    }

    tstatus = 0;
    if (ffgky (infptr, TDOUBLE, "BZERO", &(infptr->Fptr)->cn_bzero, 
        NULL, &tstatus) > 0)
    {
        (infptr->Fptr)->cn_bzero = 0.0;
        (infptr->Fptr)->cn_actual_bzero = 0.0;
    } else {
        (infptr->Fptr)->cn_actual_bzero = (infptr->Fptr)->cn_bzero;
    }

    /* special case: the quantization level is not given by a keyword in  */
    /* the HDU header, so we have to explicitly copy the requested value */
    /* to the actual value */
    if ( (infptr->Fptr)->request_quantize_level != 0.)
        (infptr->Fptr)->quantize_level = (infptr->Fptr)->request_quantize_level;

    ffcmrk();  /* clear any spurious error messages, back to the mark */
    return (*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_copy_imheader(fitsfile *infptr, fitsfile *outfptr, int *status)
/*
    This routine reads the header keywords from the input image and
    copies them to the output image;  the manditory structural keywords
    and the checksum keywords are not copied. If the DATE keyword is copied,
    then it is updated with the current date and time.
*/
{
    int nkeys, ii, keyclass;
    char card[FLEN_CARD];	/* a header record */

    if (*status > 0)
        return(*status);

    ffghsp(infptr, &nkeys, NULL, status); /* get number of keywords in image */

    for (ii = 5; ii <= nkeys; ii++)  /* skip the first 4 keywords */
    {
        ffgrec(infptr, ii, card, status);

	keyclass = ffgkcl(card);  /* Get the type/class of keyword */

        /* don't copy structural keywords or checksum keywords */
        if ((keyclass <= TYP_CMPRS_KEY) || (keyclass == TYP_CKSUM_KEY))
	    continue;

        if (FSTRNCMP(card, "DATE ", 5) == 0) /* write current date */
        {
            ffpdat(outfptr, status);
        }
        else if (FSTRNCMP(card, "EXTNAME ", 8) == 0) 
        {
            /* don't copy default EXTNAME keyword from a compressed image */
            if (FSTRNCMP(card, "EXTNAME = 'COMPRESSED_IMAGE'", 28))
            {
                /* if EXTNAME keyword already exists, overwrite it */
                /* otherwise append a new EXTNAME keyword */
                ffucrd(outfptr, "EXTNAME", card, status);
            }
        }
        else
        {
            /* just copy the keyword to the output header */
	    ffprec (outfptr, card, status);
        }

        if (*status > 0)
           return (*status);
    }
    return (*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_copy_img2comp(fitsfile *infptr, fitsfile *outfptr, int *status)
/*
    This routine copies the header keywords from the uncompressed input image 
    and to the compressed image (in a binary table) 
*/
{
    char card[FLEN_CARD], card2[FLEN_CARD];	/* a header record */
    int nkeys, nmore, ii, jj, tstatus, bitpix;

    /* tile compressed image keyword translation table  */
    /*                        INPUT      OUTPUT  */
    /*                       01234567   01234567 */
    char *patterns[][2] = {{"SIMPLE",  "ZSIMPLE" },  
			   {"XTENSION", "ZTENSION" },
			   {"BITPIX",  "ZBITPIX" },
			   {"NAXIS",   "ZNAXIS"  },
			   {"NAXISm",  "ZNAXISm" },
			   {"EXTEND",  "ZEXTEND" },
			   {"BLOCKED", "ZBLOCKED"},
			   {"PCOUNT",  "ZPCOUNT" },  
			   {"GCOUNT",  "ZGCOUNT" },

			   {"CHECKSUM","ZHECKSUM"},  /* save original checksums */
			   {"DATASUM", "ZDATASUM"},
			   
			   {"*",       "+"       }}; /* copy all other keywords */
    int npat;

    if (*status > 0)
        return(*status);

    /* write a default EXTNAME keyword if it doesn't exist in input file*/
    fits_read_card(infptr, "EXTNAME", card, status);
    
    if (*status) {
       *status = 0;
       strcpy(card, "EXTNAME = 'COMPRESSED_IMAGE'");
       fits_write_record(outfptr, card, status);
    }

    /* copy all the keywords from the input file to the output */
    npat = sizeof(patterns)/sizeof(patterns[0][0])/2;
    fits_translate_keywords(infptr, outfptr, 1, patterns, npat,
			    0, 0, 0, status);


    if ( (outfptr->Fptr)->request_lossy_int_compress != 0) { 

	/* request was made to compress integer images as if they had float pixels. */
	/* If input image has positive bitpix value, then reset the output ZBITPIX */
	/* value to -32. */

	fits_read_key(infptr, TINT, "BITPIX", &bitpix, NULL, status);

	if (*status <= 0 && bitpix > 0) {
	    fits_modify_key_lng(outfptr, "ZBITPIX", -32, NULL, status);

	    /* also delete the BSCALE, BZERO, and BLANK keywords */
	    tstatus = 0;
	    fits_delete_key(outfptr, "BSCALE", &tstatus);
	    tstatus = 0;
	    fits_delete_key(outfptr, "BZERO", &tstatus);
	    tstatus = 0;
	    fits_delete_key(outfptr, "BLANK", &tstatus);
	}
    }

   /*
     For compatibility with software that uses an older version of CFITSIO,
     we must make certain that the new ZQUANTIZ keyword, if it exists, must
     occur after the other peudo-required keywords (e.g., ZSIMPLE, ZBITPIX,
     etc.).  Do this by trying to delete the keyword.  If that succeeds (and
     thus the keyword did exist) then rewrite the keyword at the end of header.
     In principle this should not be necessary once all software has upgraded
     to a newer version of CFITSIO (version number greater than 3.181, newer
     than August 2009).
     
     Do the same for the new ZDITHER0 keyword.
   */

   tstatus = 0;
   if (fits_read_card(outfptr, "ZQUANTIZ", card, &tstatus) == 0)
   {
        fits_delete_key(outfptr, "ZQUANTIZ", status);

        /* rewrite the deleted keyword at the end of the header */
        fits_write_record(outfptr, card, status);

	/* write some associated HISTORY keywords */
        fits_parse_value(card, card2, NULL, status);
	if (strncasecmp(card2, "'NONE", 5) ) {
	    /* the value is not 'NONE' */	
	    fits_write_history(outfptr, 
	        "Image was compressed by CFITSIO using scaled integer quantization:", status);
	    sprintf(card2, "  q = %f / quantized level scaling parameter", 
	        (outfptr->Fptr)->request_quantize_level);
	    fits_write_history(outfptr, card2, status); 
	    fits_write_history(outfptr, card+10, status); 
	}
   }

   tstatus = 0;
   if (fits_read_card(outfptr, "ZDITHER0", card, &tstatus) == 0)
   {
        fits_delete_key(outfptr, "ZDITHER0", status);

        /* rewrite the deleted keyword at the end of the header */
        fits_write_record(outfptr, card, status);
   }


    ffghsp(infptr, &nkeys, &nmore, status); /* get number of keywords in image */

    nmore = nmore / 36;  /* how many completely empty header blocks are there? */
     
     /* preserve the same number of spare header blocks in the output header */
     
    for (jj = 0; jj < nmore; jj++)
       for (ii = 0; ii < 36; ii++)
          fits_write_record(outfptr, "    ", status);

    return (*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_copy_comp2img(fitsfile *infptr, fitsfile *outfptr, 
                          int norec, int *status)
/*
    This routine copies the header keywords from the compressed input image 
    and to the uncompressed image (in a binary table) 
*/
{
    char card[FLEN_CARD];	/* a header record */
    char *patterns[40][2];
    char negative[] = "-";
    int ii,jj, npat, nreq, nsp, tstatus = 0;
    int nkeys, nmore;
    
    /* tile compressed image keyword translation table  */
    /*                        INPUT      OUTPUT  */
    /*                       01234567   01234567 */

    /*  only translate these if required keywords not already written */
    char *reqkeys[][2] = {  
			   {"ZSIMPLE",   "SIMPLE" },  
			   {"ZTENSION", "XTENSION"},
			   {"ZBITPIX",   "BITPIX" },
			   {"ZNAXIS",    "NAXIS"  },
			   {"ZNAXISm",   "NAXISm" },
			   {"ZEXTEND",   "EXTEND" },
			   {"ZBLOCKED",  "BLOCKED"},
			   {"ZPCOUNT",   "PCOUNT" },  
			   {"ZGCOUNT",   "GCOUNT" },
			   {"ZHECKSUM",  "CHECKSUM"},  /* restore original checksums */
			   {"ZDATASUM",  "DATASUM"}}; 

    /* other special keywords */
    char *spkeys[][2] = {
			   {"XTENSION", "-"      },
			   {"BITPIX",  "-"       },
			   {"NAXIS",   "-"       },
			   {"NAXISm",  "-"       },
			   {"PCOUNT",  "-"       },
			   {"GCOUNT",  "-"       },
			   {"TFIELDS", "-"       },
			   {"TTYPEm",  "-"       },
			   {"TFORMm",  "-"       },
			   {"ZIMAGE",  "-"       },
			   {"ZQUANTIZ", "-"      },
			   {"ZDITHER0", "-"      },
			   {"ZTILEm",  "-"       },
			   {"ZCMPTYPE", "-"      },
			   {"ZBLANK",  "-"       },
			   {"ZNAMEm",  "-"       },
			   {"ZVALm",   "-"       },

			   {"CHECKSUM","-"       },  /* delete checksums */
			   {"DATASUM", "-"       },
			   {"EXTNAME", "+"       },  /* we may change this, below */
			   {"*",       "+"      }};  


    if (*status > 0)
        return(*status);
	
    nreq = sizeof(reqkeys)/sizeof(reqkeys[0][0])/2;
    nsp = sizeof(spkeys)/sizeof(spkeys[0][0])/2;

    /* construct translation patterns */

    for (ii = 0; ii < nreq; ii++) {
        patterns[ii][0] = reqkeys[ii][0];
	
        if (norec) 
            patterns[ii][1] = negative;
        else
            patterns[ii][1] = reqkeys[ii][1];
    }
    
    for (ii = 0; ii < nsp; ii++) {
        patterns[ii+nreq][0] = spkeys[ii][0];
        patterns[ii+nreq][1] = spkeys[ii][1];
    }

    npat = nreq + nsp;
    
    /* see if the EXTNAME keyword should be copied or not */
    fits_read_card(infptr, "EXTNAME", card, &tstatus);

    if (tstatus == 0) {
      if (!strncmp(card, "EXTNAME = 'COMPRESSED_IMAGE'", 28)) 
        patterns[npat-2][1] = negative;
    }
    
    /* translate and copy the keywords from the input file to the output */
    fits_translate_keywords(infptr, outfptr, 1, patterns, npat,
			    0, 0, 0, status);

    ffghsp(infptr, &nkeys, &nmore, status); /* get number of keywords in image */

    nmore = nmore / 36;  /* how many completely empty header blocks are there? */
     
    /* preserve the same number of spare header blocks in the output header */
     
    for (jj = 0; jj < nmore; jj++)
       for (ii = 0; ii < 36; ii++)
          fits_write_record(outfptr, "    ", status);


    return (*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_copy_prime2img(fitsfile *infptr, fitsfile *outfptr, int *status)
/*
    This routine copies any unexpected keywords from the primary array
    of the compressed input image into the header of the uncompressed image
    (which is the primary array of the output file). 
*/
{
    int  nsp;

    /* keywords that will not be copied */
    char *spkeys[][2] = {
			   {"SIMPLE", "-"      },
			   {"BITPIX",  "-"       },
			   {"NAXIS",   "-"       },
			   {"NAXISm",  "-"       },
			   {"PCOUNT",  "-"       },
			   {"EXTEND",  "-"       },
			   {"GCOUNT",  "-"       },
			   {"CHECKSUM","-"       }, 
			   {"DATASUM", "-"       },
			   {"EXTNAME", "-"       },
			   {"HISTORY", "-"       },
			   {"COMMENT", "-"       },
			   {"*",       "+"      }};  

    if (*status > 0)
        return(*status);
	
    nsp = sizeof(spkeys)/sizeof(spkeys[0][0])/2;

    /* translate and copy the keywords from the input file to the output */
    fits_translate_keywords(infptr, outfptr, 1, spkeys, nsp,
			    0, 0, 0, status);

    return (*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_decompress_tile (fitsfile *infptr,
          int nrow,            /* I - row of table to read and uncompress */
          int tilelen,         /* I - number of pixels in the tile        */
          int datatype,        /* I - datatype to be returned in 'buffer' */
          int nullcheck,       /* I - 0 for no null checking */
          void *nulval,        /* I - value to be used for undefined pixels */
          void *buffer,        /* O - buffer for returned decompressed values */
          char *bnullarray,    /* O - buffer for returned null flags */
          int *anynul,         /* O - any null values returned?  */
          int *status)

/* This routine decompresses one tile of the image */
{
    int *idata = 0;
    int tiledatatype, pixlen = 0;          /* uncompressed integer data */
    size_t idatalen, tilebytesize;
    int ii, tnull;        /* value in the data which represents nulls */
    unsigned char *cbuf; /* compressed data */
    unsigned char charnull = 0;
    short snull = 0;
    int blocksize, ntilebins, tilecol = 0;
    float fnulval=0;
    float *tempfloat = 0;
    double dnulval=0;
    double bscale, bzero, actual_bzero, dummy = 0;    /* scaling parameters */
    long nelem = 0, offset = 0, tilesize;      /* number of bytes */
    int smooth, nx, ny, scale;  /* hcompress parameters */

    if (*status > 0)
       return(*status);


    /* **************************************************************** */
    /* allocate pointers to array of cached uncompressed tiles, if not already done */
    if ((infptr->Fptr)->tilerow == 0)  {

      /* calculate number of column bins of compressed tile */
      ntilebins =  (((infptr->Fptr)->znaxis[0] - 1) / ((infptr->Fptr)->tilesize[0])) + 1;

     if ((infptr->Fptr)->znaxis[0]   != (infptr->Fptr)->tilesize[0] ||
        (infptr->Fptr)->tilesize[1] != 1 ) {   /* don't cache the tile if only single row of the image */

        (infptr->Fptr)->tilerow = (int *) calloc (ntilebins, sizeof(int));
        (infptr->Fptr)->tiledata = (void**) calloc (ntilebins, sizeof(void*));
        (infptr->Fptr)->tilenullarray = (void **) calloc (ntilebins, sizeof(char*));
        (infptr->Fptr)->tiledatasize = (long *) calloc (ntilebins, sizeof(long));
        (infptr->Fptr)->tiletype = (int *) calloc (ntilebins, sizeof(int));
        (infptr->Fptr)->tileanynull = (int *) calloc (ntilebins, sizeof(int));
      }
    }
 
    /* **************************************************************** */
    /* check if this tile was cached; if so, just copy it out */
    if ((infptr->Fptr)->tilerow)  {
      /* calculate the column bin of the compressed tile */
      tilecol = (nrow - 1) % ((long)(((infptr->Fptr)->znaxis[0] - 1) / ((infptr->Fptr)->tilesize[0])) + 1);

      if (nrow == (infptr->Fptr)->tilerow[tilecol] && datatype == (infptr->Fptr)->tiletype[tilecol] ) {

         memcpy(buffer, ((infptr->Fptr)->tiledata)[tilecol], (infptr->Fptr)->tiledatasize[tilecol]);
	 
	 if (nullcheck == 2)
             memcpy(bnullarray, (infptr->Fptr)->tilenullarray[tilecol], tilelen);

         *anynul = (infptr->Fptr)->tileanynull[tilecol];

         return(*status);
       }
    }

    /* **************************************************************** */
    /* get length of the compressed byte stream */
    ffgdes (infptr, (infptr->Fptr)->cn_compressed, nrow, &nelem, &offset, 
            status);

    /* EOF error here indicates that this tile has not yet been written */
    if (*status == END_OF_FILE)
           return(*status = NO_COMPRESSED_TILE);
      
    /* **************************************************************** */
    if (nelem == 0)  /* special case: tile was not compressed normally */
    {
        if ((infptr->Fptr)->cn_uncompressed >= 1 ) {

	    /* This option of writing the uncompressed floating point data */
	    /* to the tile compressed file was used until about May 2011. */
	    /* This was replaced by the more efficient option of gzipping the */
	    /* floating point data before writing it to the tile-compressed file */
	    
            /* no compressed data, so simply read the uncompressed data */
            /* directly from the UNCOMPRESSED_DATA column */   
            ffgdes (infptr, (infptr->Fptr)->cn_uncompressed, nrow, &nelem,
               &offset, status);

            if (nelem == 0 && offset == 0)  /* this should never happen */
	        return (*status = NO_COMPRESSED_TILE);

            if (nullcheck <= 1) { /* set any null values in the array = nulval */
                fits_read_col(infptr, datatype, (infptr->Fptr)->cn_uncompressed,
                  nrow, 1, nelem, nulval, buffer, anynul, status);
            } else  { /* set the bnullarray = 1 for any null values in the array */
                fits_read_colnull(infptr, datatype, (infptr->Fptr)->cn_uncompressed,
                  nrow, 1, nelem, buffer, bnullarray, anynul, status);
            }
        } else if ((infptr->Fptr)->cn_gzip_data >= 1) {

            /* This is the newer option, that was introduced in May 2011 */
            /* floating point data was not quantized,  so read the losslessly */
	    /* compressed data from the GZIP_COMPRESSED_DATA column */   

            ffgdes (infptr, (infptr->Fptr)->cn_gzip_data, nrow, &nelem,
               &offset, status);

            if (nelem == 0 && offset == 0) /* this should never happen */
	        return (*status = NO_COMPRESSED_TILE);

	    /* allocate memory for the compressed tile of data */
            cbuf = (unsigned char *) malloc (nelem);  
            if (cbuf == NULL) {
	        ffpmsg("error allocating memory for gzipped tile (imcomp_decompress_tile)");
	        return (*status = MEMORY_ALLOCATION);
            }

            /* read array of compressed bytes */
            if (fits_read_col(infptr, TBYTE, (infptr->Fptr)->cn_gzip_data, nrow,
                 1, nelem, &charnull, cbuf, NULL, status) > 0) {
                ffpmsg("error reading compressed byte stream from binary table");
	        free (cbuf);
                return (*status);
            }

            /* size of the returned (uncompressed) data buffer, in bytes */
            if ((infptr->Fptr)->zbitpix == FLOAT_IMG) {
	         idatalen = tilelen * sizeof(float);
            } else if ((infptr->Fptr)->zbitpix == DOUBLE_IMG) {
	         idatalen = tilelen * sizeof(double);
            } else {
                /* this should never happen! */
                ffpmsg("incompatible data type in gzipped floating-point tile-compressed image");
                free (cbuf);
                return (*status = DATA_DECOMPRESSION_ERR);
            }

            if (datatype == TDOUBLE && (infptr->Fptr)->zbitpix == FLOAT_IMG) {  
                /*  have to allocat a temporary buffer for the uncompressed data in the */
                /*  case where a gzipped "float" tile is returned as a "double" array   */
                tempfloat = (float*) malloc (idatalen); 

                if (tempfloat == NULL) {
	            ffpmsg("Memory allocation failure for tempfloat. (imcomp_decompress_tile)");
                    free (cbuf);
	            return (*status = MEMORY_ALLOCATION);
                }

                /* uncompress the data into temp buffer */
                if (uncompress2mem_from_mem ((char *)cbuf, nelem,
                     (char **) &tempfloat, &idatalen, NULL, &tilebytesize, status)) {
                    ffpmsg("failed to gunzip the image tile");
                    free (tempfloat);
                    free (cbuf);
                    return (*status);
                }
            } else {

                /* uncompress the data directly into the output buffer in all other cases */
                if (uncompress2mem_from_mem ((char *)cbuf, nelem,
                  (char **) &buffer, &idatalen, NULL, &tilebytesize, status)) {
                    ffpmsg("failed to gunzip the image tile");
                    free (cbuf);
                    return (*status);
                }
            }

            free(cbuf);

            /* do byte swapping and null value substitution for the tile of pixels */
            if (tilebytesize == 4 * tilelen) {  /* float pixels */

#if BYTESWAPPED
                if (tempfloat)
                    ffswap4((int *) tempfloat, tilelen);
                else
                    ffswap4((int *) buffer, tilelen);
#endif
               if (datatype == TFLOAT) {
                  if (nulval) {
		    fnulval = *(float *) nulval;
  		  }

                  fffr4r4((float *) buffer, (long) tilelen, 1., 0., nullcheck,   
                        fnulval, bnullarray, anynul,
                        (float *) buffer, status);
                } else if (datatype == TDOUBLE) {
                  if (nulval) {
		    dnulval = *(double *) nulval;
		  }

                  /* note that the R*4 data are in the tempfloat array in this case */
                  fffr4r8((float *) tempfloat, (long) tilelen, 1., 0., nullcheck,   
                   dnulval, bnullarray, anynul,
                    (double *) buffer, status);            
                  free(tempfloat);

                } else {
                  ffpmsg("implicit data type conversion is not supported for gzipped image tiles");
                  return (*status = DATA_DECOMPRESSION_ERR);
                }
            } else if (tilebytesize == 8 * tilelen) { /* double pixels */

#if BYTESWAPPED
                ffswap8((double *) buffer, tilelen);
#endif
                if (datatype == TFLOAT) {
                  if (nulval) {
		    fnulval = *(float *) nulval;
  		  }

                  fffr8r4((double *) buffer, (long) tilelen, 1., 0., nullcheck,   
                        fnulval, bnullarray, anynul,
                        (float *) buffer, status);
                } else if (datatype == TDOUBLE) {
                  if (nulval) {
		    dnulval = *(double *) nulval;
		  }

                  fffr8r8((double *) buffer, (long) tilelen, 1., 0., nullcheck,   
                   dnulval, bnullarray, anynul,
                    (double *) buffer, status);            
                } else {
                  ffpmsg("implicit data type conversion is not supported in tile-compressed images");
                  return (*status = DATA_DECOMPRESSION_ERR);
                }
	    } else {
                ffpmsg("error: uncompressed tile has wrong size");
                return (*status = DATA_DECOMPRESSION_ERR);
            }

          /* end of special case of losslessly gzipping a floating-point image tile */
        } else {  /* this should never happen */
	   *status = NO_COMPRESSED_TILE;
        }

        return(*status);
    }

    /* **************************************************************** */
    /* deal with the normal case of a compressed tile of pixels */
    if (nullcheck == 2)  {
        for (ii = 0; ii < tilelen; ii++)  /* initialize the null flage array */
            bnullarray[ii] = 0;
    }

    if (anynul)
       *anynul = 0;

    /* get linear scaling and offset values, if they exist */
    actual_bzero = (infptr->Fptr)->cn_actual_bzero;
    if ((infptr->Fptr)->cn_zscale == 0) {
         /* set default scaling, if scaling is not defined */
         bscale = 1.;
         bzero = 0.;
    } else if ((infptr->Fptr)->cn_zscale == -1) {
        bscale = (infptr->Fptr)->zscale;
        bzero  = (infptr->Fptr)->zzero;
    } else {
        /* read the linear scale and offset values for this row */
	ffgcvd (infptr, (infptr->Fptr)->cn_zscale, nrow, 1, 1, 0.,
				&bscale, NULL, status);
	ffgcvd (infptr, (infptr->Fptr)->cn_zzero, nrow, 1, 1, 0.,
				&bzero, NULL, status);
        if (*status > 0)
        {
          ffpmsg("error reading scaling factor and offset for compressed tile");
          return (*status);
        }

        /* test if floating-point FITS image also has non-default BSCALE and  */
	/* BZERO keywords.  If so, we have to combine the 2 linear scaling factors. */
	
	if ( ((infptr->Fptr)->zbitpix == FLOAT_IMG || 
	      (infptr->Fptr)->zbitpix == DOUBLE_IMG )
	    &&  
	      ((infptr->Fptr)->cn_bscale != 1.0 ||
	       (infptr->Fptr)->cn_bzero  != 0.0 )    ) 
	    {
	       bscale = bscale * (infptr->Fptr)->cn_bscale;
	       bzero  = bzero  * (infptr->Fptr)->cn_bscale + (infptr->Fptr)->cn_bzero;
	    }
    }

    if (bscale == 1.0 && bzero == 0.0 ) {
      /* if no other scaling has been specified, try using the values
         given by the BSCALE and BZERO keywords, if any */

        bscale = (infptr->Fptr)->cn_bscale;
        bzero  = (infptr->Fptr)->cn_bzero;
    }

    /* ************************************************************* */
    /* get the value used to represent nulls in the int array */
    if ((infptr->Fptr)->cn_zblank == 0) {
        nullcheck = 0;  /* no null value; don't check for nulls */
    } else if ((infptr->Fptr)->cn_zblank == -1) {
        tnull = (infptr->Fptr)->zblank;  /* use the the ZBLANK keyword */
    } else {
        /* read the null value for this row */
	ffgcvk (infptr, (infptr->Fptr)->cn_zblank, nrow, 1, 1, 0,
				&tnull, NULL, status);
        if (*status > 0) {
            ffpmsg("error reading null value for compressed tile");
            return (*status);
        }
    }

    /* ************************************************************* */
    /* allocate memory for the uncompressed array of tile integers */
    /* The size depends on the datatype and the compression type. */
    
    if ((infptr->Fptr)->compress_type == HCOMPRESS_1 &&
          ((infptr->Fptr)->zbitpix != BYTE_IMG &&
	   (infptr->Fptr)->zbitpix != SHORT_IMG) ) {

           idatalen = tilelen * sizeof(LONGLONG);  /* 8 bytes per pixel */

    } else if ( (infptr->Fptr)->compress_type == RICE_1 &&
               (infptr->Fptr)->zbitpix == BYTE_IMG && 
	       (infptr->Fptr)->rice_bytepix == 1) {

           idatalen = tilelen * sizeof(char); /* 1 byte per pixel */
    } else if ( ( (infptr->Fptr)->compress_type == GZIP_1  ||
                  (infptr->Fptr)->compress_type == GZIP_2  ||
                  (infptr->Fptr)->compress_type == BZIP2_1 ) &&
               (infptr->Fptr)->zbitpix == BYTE_IMG ) {

           idatalen = tilelen * sizeof(char); /* 1 byte per pixel */
    } else if ( (infptr->Fptr)->compress_type == RICE_1 &&
               (infptr->Fptr)->zbitpix == SHORT_IMG && 
	       (infptr->Fptr)->rice_bytepix == 2) {

           idatalen = tilelen * sizeof(short); /* 2 bytes per pixel */
    } else if ( ( (infptr->Fptr)->compress_type == GZIP_1  ||
                  (infptr->Fptr)->compress_type == GZIP_2  ||
                  (infptr->Fptr)->compress_type == BZIP2_1 )  &&
               (infptr->Fptr)->zbitpix == SHORT_IMG ) {

           idatalen = tilelen * sizeof(short); /* 2 bytes per pixel */
    } else if ( ( (infptr->Fptr)->compress_type == GZIP_1  ||
                  (infptr->Fptr)->compress_type == GZIP_2  ||
                  (infptr->Fptr)->compress_type == BZIP2_1 ) &&
               (infptr->Fptr)->zbitpix == DOUBLE_IMG ) {

           idatalen = tilelen * sizeof(double); /* 8 bytes per pixel  */
    } else {
           idatalen = tilelen * sizeof(int);  /* all other cases have int pixels */
    }

    idata = (int*) malloc (idatalen); 
    if (idata == NULL) {
	    ffpmsg("Memory allocation failure for idata. (imcomp_decompress_tile)");
	    return (*status = MEMORY_ALLOCATION);
    }

    /* ************************************************************* */
    /* allocate memory for the compressed bytes */

    if ((infptr->Fptr)->compress_type == PLIO_1) {
        cbuf = (unsigned char *) malloc (nelem * sizeof (short));
    } else {
        cbuf = (unsigned char *) malloc (nelem);
    }
    if (cbuf == NULL) {
	ffpmsg("Out of memory for cbuf. (imcomp_decompress_tile)");
        free(idata);
	return (*status = MEMORY_ALLOCATION);
    }
    
    /* ************************************************************* */
    /* read the compressed bytes from the FITS file */

    if ((infptr->Fptr)->compress_type == PLIO_1) {
        fits_read_col(infptr, TSHORT, (infptr->Fptr)->cn_compressed, nrow,
             1, nelem, &snull, (short *) cbuf, NULL, status);
    } else {
       fits_read_col(infptr, TBYTE, (infptr->Fptr)->cn_compressed, nrow,
             1, nelem, &charnull, cbuf, NULL, status);
    }

    if (*status > 0) {
        ffpmsg("error reading compressed byte stream from binary table");
	free (cbuf);
        free(idata);
        return (*status);
    }

    /* ************************************************************* */
    /*  call the algorithm-specific code to uncompress the tile */

    if ((infptr->Fptr)->compress_type == RICE_1) {

        blocksize = (infptr->Fptr)->rice_blocksize;

        if ((infptr->Fptr)->rice_bytepix == 1 ) {
            *status = fits_rdecomp_byte (cbuf, nelem, (unsigned char *)idata,
                        tilelen, blocksize);
            tiledatatype = TBYTE;
        } else if ((infptr->Fptr)->rice_bytepix == 2 ) {
            *status = fits_rdecomp_short (cbuf, nelem, (unsigned short *)idata,
                        tilelen, blocksize);
            tiledatatype = TSHORT;
        } else {
            *status = fits_rdecomp (cbuf, nelem, (unsigned int *)idata,
                         tilelen, blocksize);
            tiledatatype = TINT;
        }

    /* ************************************************************* */
    } else if ((infptr->Fptr)->compress_type == HCOMPRESS_1)  {

        smooth = (infptr->Fptr)->hcomp_smooth;

        if ( ((infptr->Fptr)->zbitpix == BYTE_IMG || (infptr->Fptr)->zbitpix == SHORT_IMG)) {
            *status = fits_hdecompress(cbuf, smooth, idata, &nx, &ny,
	        &scale, status);
        } else {  /* zbitpix = LONG_IMG (32) */
            /* idata must have been allocated twice as large for this to work */
            *status = fits_hdecompress64(cbuf, smooth, (LONGLONG *) idata, &nx, &ny,
	        &scale, status);
        }       

        tiledatatype = TINT;

    /* ************************************************************* */
    } else if ((infptr->Fptr)->compress_type == PLIO_1) {

        pl_l2pi ((short *) cbuf, 1, idata, tilelen);  /* uncompress the data */
        tiledatatype = TINT;

    /* ************************************************************* */
    } else if ( ((infptr->Fptr)->compress_type == GZIP_1) ||
                ((infptr->Fptr)->compress_type == GZIP_2) ) {

        uncompress2mem_from_mem ((char *)cbuf, nelem,
             (char **) &idata, &idatalen, realloc, &tilebytesize, status);

        /* determine the data type of the uncompressed array, and */
	/*  do byte unshuffling and unswapping if needed */
	if (tilebytesize == (size_t) (tilelen * 2)) {
	    /* this is a short I*2 array */
            tiledatatype = TSHORT;

            if ( (infptr->Fptr)->compress_type == GZIP_2 )
		    fits_unshuffle_2bytes((char *) idata, tilelen, status);

#if BYTESWAPPED
            ffswap2((short *) idata, tilelen);
#endif

	} else if (tilebytesize == (size_t) (tilelen * 4)) {
	    /* this is a int I*4 array (or maybe R*4) */
            tiledatatype = TINT;

            if ( (infptr->Fptr)->compress_type == GZIP_2 )
		    fits_unshuffle_4bytes((char *) idata, tilelen, status);

#if BYTESWAPPED
            ffswap4(idata, tilelen);
#endif

	} else if (tilebytesize == (size_t) (tilelen * 8)) {
	    /* this is a R*8 double array */
            tiledatatype = TDOUBLE;

            if ( (infptr->Fptr)->compress_type == GZIP_2 )
		    fits_unshuffle_8bytes((char *) idata, tilelen, status);
#if BYTESWAPPED
            ffswap8((double *) idata, tilelen);
#endif

        } else if (tilebytesize == (size_t) tilelen) {
	    
	    /* this is an unsigned char I*1 array */
            tiledatatype = TBYTE;

        } else {
            ffpmsg("error: uncompressed tile has wrong size");
            free(idata);
            return (*status = DATA_DECOMPRESSION_ERR);
        }

    /* ************************************************************* */
    } else if ((infptr->Fptr)->compress_type == BZIP2_1) {

/*  BZIP2 is not supported in the public release; this is only for test purposes 

        if (BZ2_bzBuffToBuffDecompress ((char *) idata, &idatalen, 
		(char *)cbuf, (unsigned int) nelem, 0, 0) )
*/
        {
            ffpmsg("bzip2 decompression error");
            free(idata);
            free (cbuf);
            return (*status = DATA_DECOMPRESSION_ERR);
        }

        if ((infptr->Fptr)->zbitpix == BYTE_IMG) {
	     tiledatatype = TBYTE;
        } else if ((infptr->Fptr)->zbitpix == SHORT_IMG) {
  	     tiledatatype = TSHORT;
#if BYTESWAPPED
            ffswap2((short *) idata, tilelen);
#endif
	} else {
  	     tiledatatype = TINT;
#if BYTESWAPPED
            ffswap4(idata, tilelen);
#endif
	}

    /* ************************************************************* */
    } else {
        ffpmsg("unknown compression algorithm");
        free(idata);
        return (*status = DATA_DECOMPRESSION_ERR);
    }

    free(cbuf);
    if (*status)  {  /* error uncompressing the tile */
            free(idata);
            return (*status);
    }

    /* ************************************************************* */
    /* copy the uncompressed tile data to the output buffer, doing */
    /* null checking, datatype conversion and linear scaling, if necessary */

    if (nulval == 0)
         nulval = &dummy;  /* set address to dummy value */

    if (datatype == TSHORT)
    {
        pixlen = sizeof(short);

	if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) {
	 /* the floating point pixels were losselessly compressed with GZIP */
	 /* Just have to copy the values to the output array */
	 
          if (tiledatatype == TINT) {
              fffr4i2((float *) idata, tilelen, bscale, bzero, nullcheck,   
                *(short *) nulval, bnullarray, anynul,
                (short *) buffer, status);
          } else {
              fffr8i2((double *) idata, tilelen, bscale, bzero, nullcheck,   
                *(short *) nulval, bnullarray, anynul,
                (short *) buffer, status);
          }
        } else if (tiledatatype == TINT)
          if ((infptr->Fptr)->compress_type == PLIO_1 &&
	    bzero == 0. && actual_bzero == 32768.) {
	    /* special case where unsigned 16-bit integers have been */
	    /* offset by +32768 when using PLIO */
            fffi4i2(idata, tilelen, bscale, -32768., nullcheck, tnull,
             *(short *) nulval, bnullarray, anynul,
            (short *) buffer, status);
          } else {
            fffi4i2(idata, tilelen, bscale, bzero, nullcheck, tnull,
             *(short *) nulval, bnullarray, anynul,
            (short *) buffer, status);

            /*
	       Hcompress is a special case:  ignore any numerical overflow
	       errors that may have occurred during the integer*4 to integer*2
	       convertion.  Overflows can happen when a lossy Hcompress algorithm
	       is invoked (with a non-zero scale factor).  The fffi4i2 routine
	       clips the returned values to be within the legal I*2 range, so
	       all we need to is to reset the error status to zero.
	    */
	       
            if ((infptr->Fptr)->compress_type == HCOMPRESS_1) {
	        if (*status == NUM_OVERFLOW) *status = 0;
	    }
          }
        else if (tiledatatype == TSHORT)
          fffi2i2((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           *(short *) nulval, bnullarray, anynul,
          (short *) buffer, status);
        else if (tiledatatype == TBYTE)
          fffi1i2((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           *(short *) nulval, bnullarray, anynul,
          (short *) buffer, status);
    }
    else if (datatype == TINT)
    {
        pixlen = sizeof(int);

	if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) {
	 /* the floating point pixels were losselessly compressed with GZIP */
	 /* Just have to copy the values to the output array */
	 
          if (tiledatatype == TINT) {
              fffr4int((float *) idata, tilelen, bscale, bzero, nullcheck,   
                *(int *) nulval, bnullarray, anynul,
                (int *) buffer, status);
          } else {
              fffr8int((double *) idata, tilelen, bscale, bzero, nullcheck,   
                *(int *) nulval, bnullarray, anynul,
                (int *) buffer, status);
          }
        } else if (tiledatatype == TINT)
          fffi4int(idata, (long) tilelen, bscale, bzero, nullcheck, tnull,
           *(int *) nulval, bnullarray, anynul,
           (int *) buffer, status);
        else if (tiledatatype == TSHORT)
          fffi2int((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           *(int *) nulval, bnullarray, anynul,
           (int *) buffer, status);
        else if (tiledatatype == TBYTE)
          fffi1int((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           *(int *) nulval, bnullarray, anynul,
           (int *) buffer, status);
    }
    else if (datatype == TLONG)
    {
        pixlen = sizeof(long);

	if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) {
	 /* the floating point pixels were losselessly compressed with GZIP */
	 /* Just have to copy the values to the output array */
	 
          if (tiledatatype == TINT) {
              fffr4i4((float *) idata, tilelen, bscale, bzero, nullcheck,   
                *(long *) nulval, bnullarray, anynul,
                (long *) buffer, status);
          } else {
              fffr8i4((double *) idata, tilelen, bscale, bzero, nullcheck,   
                *(long *) nulval, bnullarray, anynul,
                (long *) buffer, status);
          }
        } else if (tiledatatype == TINT)
          fffi4i4(idata, tilelen, bscale, bzero, nullcheck, tnull,
           *(long *) nulval, bnullarray, anynul,
            (long *) buffer, status);
        else if (tiledatatype == TSHORT)
          fffi2i4((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           *(long *) nulval, bnullarray, anynul,
            (long *) buffer, status);
        else if (tiledatatype == TBYTE)
          fffi1i4((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           *(long *) nulval, bnullarray, anynul,
            (long *) buffer, status);
    }
    else if (datatype == TFLOAT)
    {
        pixlen = sizeof(float);
        if (nulval) {
	      fnulval = *(float *) nulval;
	}
 
	if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) {
	 /* the floating point pixels were losselessly compressed with GZIP */
	 /* Just have to copy the values to the output array */
	 
          if (tiledatatype == TINT) {
              fffr4r4((float *) idata, tilelen, bscale, bzero, nullcheck,   
                fnulval, bnullarray, anynul,
                (float *) buffer, status);
          } else {
              fffr8r4((double *) idata, tilelen, bscale, bzero, nullcheck,   
                fnulval, bnullarray, anynul,
                (float *) buffer, status);
          }
	
        } else if ((infptr->Fptr)->quantize_method == SUBTRACTIVE_DITHER_1 ||
	           (infptr->Fptr)->quantize_method == SUBTRACTIVE_DITHER_2) {

         /* use the new dithering algorithm (introduced in July 2009) */

         if (tiledatatype == TINT)
          unquantize_i4r4(nrow + (infptr->Fptr)->dither_seed - 1, idata, 
	   tilelen, bscale, bzero, (infptr->Fptr)->quantize_method, nullcheck, tnull,
           fnulval, bnullarray, anynul,
            (float *) buffer, status);
         else if (tiledatatype == TSHORT)
          unquantize_i2r4(nrow + (infptr->Fptr)->dither_seed - 1, (short *)idata, 
	   tilelen, bscale, bzero, (infptr->Fptr)->quantize_method, nullcheck, (short) tnull,
           fnulval, bnullarray, anynul,
            (float *) buffer, status);
         else if (tiledatatype == TBYTE)
          unquantize_i1r4(nrow + (infptr->Fptr)->dither_seed - 1, (unsigned char *)idata, 
	   tilelen, bscale, bzero, (infptr->Fptr)->quantize_method, nullcheck, (unsigned char) tnull,
           fnulval, bnullarray, anynul,
            (float *) buffer, status);

        } else {  /* use the old "round to nearest level" quantization algorithm */

         if (tiledatatype == TINT)
          fffi4r4(idata, tilelen, bscale, bzero, nullcheck, tnull,  
           fnulval, bnullarray, anynul,
            (float *) buffer, status);
         else if (tiledatatype == TSHORT)
          fffi2r4((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,  
           fnulval, bnullarray, anynul,
            (float *) buffer, status);
         else if (tiledatatype == TBYTE)
          fffi1r4((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           fnulval, bnullarray, anynul,
            (float *) buffer, status);
	}
    }
    else if (datatype == TDOUBLE)
    {
        pixlen = sizeof(double);
        if (nulval) {
	     dnulval = *(double *) nulval;
	}

	if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) {
	 /* the floating point pixels were losselessly compressed with GZIP */
	 /* Just have to copy the values to the output array */

          if (tiledatatype == TINT) {
              fffr4r8((float *) idata, tilelen, bscale, bzero, nullcheck,   
                dnulval, bnullarray, anynul,
                (double *) buffer, status);
          } else {
              fffr8r8((double *) idata, tilelen, bscale, bzero, nullcheck,   
                dnulval, bnullarray, anynul,
                (double *) buffer, status);
          }
	
	} else if ((infptr->Fptr)->quantize_method == SUBTRACTIVE_DITHER_1 ||
	           (infptr->Fptr)->quantize_method == SUBTRACTIVE_DITHER_2) {

         /* use the new dithering algorithm (introduced in July 2009) */
         if (tiledatatype == TINT)
          unquantize_i4r8(nrow + (infptr->Fptr)->dither_seed - 1, idata,
	   tilelen, bscale, bzero, (infptr->Fptr)->quantize_method, nullcheck, tnull,
           dnulval, bnullarray, anynul,
            (double *) buffer, status);
         else if (tiledatatype == TSHORT)
          unquantize_i2r8(nrow + (infptr->Fptr)->dither_seed - 1, (short *)idata,
	   tilelen, bscale, bzero, (infptr->Fptr)->quantize_method, nullcheck, (short) tnull,
           dnulval, bnullarray, anynul,
            (double *) buffer, status);
         else if (tiledatatype == TBYTE)
          unquantize_i1r8(nrow + (infptr->Fptr)->dither_seed - 1, (unsigned char *)idata,
	   tilelen, bscale, bzero, (infptr->Fptr)->quantize_method, nullcheck, (unsigned char) tnull,
           dnulval, bnullarray, anynul,
            (double *) buffer, status);

        } else {  /* use the old "round to nearest level" quantization algorithm */

         if (tiledatatype == TINT)
          fffi4r8(idata, tilelen, bscale, bzero, nullcheck, tnull,
           dnulval, bnullarray, anynul,
            (double *) buffer, status);
         else if (tiledatatype == TSHORT)
          fffi2r8((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           dnulval, bnullarray, anynul,
            (double *) buffer, status);
         else if (tiledatatype == TBYTE)
          fffi1r8((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           dnulval, bnullarray, anynul,
            (double *) buffer, status);
	}
    }
    else if (datatype == TBYTE)
    {
        pixlen = sizeof(char);
        if (tiledatatype == TINT)
          fffi4i1(idata, tilelen, bscale, bzero, nullcheck, tnull,
           *(unsigned char *) nulval, bnullarray, anynul,
            (unsigned char *) buffer, status);
        else if (tiledatatype == TSHORT)
          fffi2i1((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           *(unsigned char *) nulval, bnullarray, anynul,
            (unsigned char *) buffer, status);
        else if (tiledatatype == TBYTE)
          fffi1i1((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           *(unsigned char *) nulval, bnullarray, anynul,
            (unsigned char *) buffer, status);
    }
    else if (datatype == TSBYTE)
    {
        pixlen = sizeof(char);
        if (tiledatatype == TINT)
          fffi4s1(idata, tilelen, bscale, bzero, nullcheck, tnull,
           *(signed char *) nulval, bnullarray, anynul,
            (signed char *) buffer, status);
        else if (tiledatatype == TSHORT)
          fffi2s1((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           *(signed char *) nulval, bnullarray, anynul,
            (signed char *) buffer, status);
        else if (tiledatatype == TBYTE)
          fffi1s1((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           *(signed char *) nulval, bnullarray, anynul,
            (signed char *) buffer, status);
    }
    else if (datatype == TUSHORT)
    {
        pixlen = sizeof(short);

	if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) {
	 /* the floating point pixels were losselessly compressed with GZIP */
	 /* Just have to copy the values to the output array */
	 
          if (tiledatatype == TINT) {
              fffr4u2((float *) idata, tilelen, bscale, bzero, nullcheck,   
                *(unsigned short *) nulval, bnullarray, anynul,
                (unsigned short *) buffer, status);
          } else {
              fffr8u2((double *) idata, tilelen, bscale, bzero, nullcheck,   
                *(unsigned short *) nulval, bnullarray, anynul,
                (unsigned short *) buffer, status);
          }
        } else if (tiledatatype == TINT)
          fffi4u2(idata, tilelen, bscale, bzero, nullcheck, tnull,
           *(unsigned short *) nulval, bnullarray, anynul,
            (unsigned short *) buffer, status);
        else if (tiledatatype == TSHORT)
          fffi2u2((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           *(unsigned short *) nulval, bnullarray, anynul,
            (unsigned short *) buffer, status);
        else if (tiledatatype == TBYTE)
          fffi1u2((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           *(unsigned short *) nulval, bnullarray, anynul,
            (unsigned short *) buffer, status);
    }
    else if (datatype == TUINT)
    {
        pixlen = sizeof(int);

	if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) {
	 /* the floating point pixels were losselessly compressed with GZIP */
	 /* Just have to copy the values to the output array */
	 
          if (tiledatatype == TINT) {
              fffr4uint((float *) idata, tilelen, bscale, bzero, nullcheck,   
                *(unsigned int *) nulval, bnullarray, anynul,
                (unsigned int *) buffer, status);
          } else {
              fffr8uint((double *) idata, tilelen, bscale, bzero, nullcheck,   
                *(unsigned int *) nulval, bnullarray, anynul,
                (unsigned int *) buffer, status);
          }
        } else         if (tiledatatype == TINT)
          fffi4uint(idata, tilelen, bscale, bzero, nullcheck, tnull,
           *(unsigned int *) nulval, bnullarray, anynul,
            (unsigned int *) buffer, status);
        else if (tiledatatype == TSHORT)
          fffi2uint((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           *(unsigned int *) nulval, bnullarray, anynul,
            (unsigned int *) buffer, status);
        else if (tiledatatype == TBYTE)
          fffi1uint((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           *(unsigned int *) nulval, bnullarray, anynul,
            (unsigned int *) buffer, status);
    }
    else if (datatype == TULONG)
    {
        pixlen = sizeof(long);

	if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) {
	 /* the floating point pixels were losselessly compressed with GZIP */
	 /* Just have to copy the values to the output array */
	 
          if (tiledatatype == TINT) {
              fffr4u4((float *) idata, tilelen, bscale, bzero, nullcheck,   
                *(unsigned long *) nulval, bnullarray, anynul,
                (unsigned long *) buffer, status);
          } else {
              fffr8u4((double *) idata, tilelen, bscale, bzero, nullcheck,   
                *(unsigned long *) nulval, bnullarray, anynul,
                (unsigned long *) buffer, status);
          }
        } else if (tiledatatype == TINT)
          fffi4u4(idata, tilelen, bscale, bzero, nullcheck, tnull,
           *(unsigned long *) nulval, bnullarray, anynul, 
            (unsigned long *) buffer, status);
        else if (tiledatatype == TSHORT)
          fffi2u4((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull,
           *(unsigned long *) nulval, bnullarray, anynul, 
            (unsigned long *) buffer, status);
        else if (tiledatatype == TBYTE)
          fffi1u4((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull,
           *(unsigned long *) nulval, bnullarray, anynul, 
            (unsigned long *) buffer, status);
    }
    else
         *status = BAD_DATATYPE;

    free(idata);  /* don't need the uncompressed tile any more */

    /* **************************************************************** */
    /* cache the tile, in case the application wants it again  */

    /*   Don't cache the tile if tile is a single row of the image; 
         it is less likely that the cache will be used in this cases,
	 so it is not worth the time and the memory overheads.
    */
    
    if ((infptr->Fptr)->tilerow)  {  /* make sure cache has been allocated */
     if ((infptr->Fptr)->znaxis[0]   != (infptr->Fptr)->tilesize[0] ||
        (infptr->Fptr)->tilesize[1] != 1 )
     {
      tilesize = pixlen * tilelen;

      /* check that tile size/type has not changed */
      if (tilesize != (infptr->Fptr)->tiledatasize[tilecol] ||
        datatype != (infptr->Fptr)->tiletype[tilecol] )  {

        if (((infptr->Fptr)->tiledata)[tilecol]) {
            free(((infptr->Fptr)->tiledata)[tilecol]);	    
        }
	
        if (((infptr->Fptr)->tilenullarray)[tilecol]) {
            free(((infptr->Fptr)->tilenullarray)[tilecol]);
        }
	
        ((infptr->Fptr)->tilenullarray)[tilecol] = 0;
        ((infptr->Fptr)->tilerow)[tilecol] = 0;
        ((infptr->Fptr)->tiledatasize)[tilecol] = 0;
        ((infptr->Fptr)->tiletype)[tilecol] = 0;

        /* allocate new array(s) */
	((infptr->Fptr)->tiledata)[tilecol] = malloc(tilesize);

	if (((infptr->Fptr)->tiledata)[tilecol] == 0)
	   return (*status);

        if (nullcheck == 2) {  /* also need array of null pixel flags */
	    (infptr->Fptr)->tilenullarray[tilecol] = malloc(tilelen);
	    if ((infptr->Fptr)->tilenullarray[tilecol] == 0)
	        return (*status);
        }

        (infptr->Fptr)->tiledatasize[tilecol] = tilesize;
        (infptr->Fptr)->tiletype[tilecol] = datatype;
      }

      /* copy the tile array(s) into cache buffer */
      memcpy((infptr->Fptr)->tiledata[tilecol], buffer, tilesize);

      if (nullcheck == 2) {
	    if ((infptr->Fptr)->tilenullarray == 0)  {
       	      (infptr->Fptr)->tilenullarray[tilecol] = malloc(tilelen);
            }
            memcpy((infptr->Fptr)->tilenullarray[tilecol], bnullarray, tilelen);
      }

      (infptr->Fptr)->tilerow[tilecol] = nrow;
      (infptr->Fptr)->tileanynull[tilecol] = *anynul;
     }
    }
    return (*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_test_overlap (
    int ndim,           /* I - number of dimension in the tile and image */
    long *tfpixel,      /* I - first pixel number in each dim. of the tile */
    long *tlpixel,      /* I - last pixel number in each dim. of the tile */
    long *fpixel,       /* I - first pixel number in each dim. of the image */
    long *lpixel,       /* I - last pixel number in each dim. of the image */
    long *ininc,        /* I - increment to be applied in each image dimen. */
    int *status)

/* 
  test if there are any intersecting pixels between this tile and the section
  of the image defined by fixel, lpixel, ininc. 
*/
{
    long imgdim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */
                                   /* output image, allowing for inc factor */
    long tiledim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */
                                 /* tile, array;  inc factor is not relevant */
    long imgfpix[MAX_COMPRESS_DIM]; /* 1st img pix overlapping tile: 0 base, */
                                    /*  allowing for inc factor */
    long imglpix[MAX_COMPRESS_DIM]; /* last img pix overlapping tile 0 base, */
                                    /*  allowing for inc factor */
    long tilefpix[MAX_COMPRESS_DIM]; /* 1st tile pix overlapping img 0 base, */
                                    /*  allowing for inc factor */
    long inc[MAX_COMPRESS_DIM]; /* local copy of input ininc */
    int ii;
    long tf, tl;

    if (*status > 0)
        return(*status);


    /* ------------------------------------------------------------ */
    /* calc amount of overlap in each dimension; if there is zero   */
    /* overlap in any dimension then just return  */
    /* ------------------------------------------------------------ */
    
    for (ii = 0; ii < ndim; ii++)
    {
        if (tlpixel[ii] < fpixel[ii] || tfpixel[ii] > lpixel[ii])
            return(0);  /* there are no overlapping pixels */

        inc[ii] = ininc[ii];

        /* calc dimensions of the output image section */
        imgdim[ii] = (lpixel[ii] - fpixel[ii]) / labs(inc[ii]) + 1;
        if (imgdim[ii] < 1) {
            *status = NEG_AXIS;
            return(0);
        }

        /* calc dimensions of the tile */
        tiledim[ii] = tlpixel[ii] - tfpixel[ii] + 1;
        if (tiledim[ii] < 1) {
            *status = NEG_AXIS;
            return(0);
        }

        if (ii > 0)
           tiledim[ii] *= tiledim[ii - 1];  /* product of dimensions */

        /* first and last pixels in image that overlap with the tile, 0 base */
        tf = tfpixel[ii] - 1;
        tl = tlpixel[ii] - 1;

        /* skip this plane if it falls in the cracks of the subsampled image */
        while ((tf-(fpixel[ii] - 1)) % labs(inc[ii]))
        {
           tf++;
           if (tf > tl)
             return(0);  /* no overlapping pixels */
        }

        while ((tl-(fpixel[ii] - 1)) % labs(inc[ii]))
        {
           tl--;
           if (tf > tl)
             return(0);  /* no overlapping pixels */
        }
        imgfpix[ii] = maxvalue((tf - fpixel[ii] +1) / labs(inc[ii]) , 0);
        imglpix[ii] = minvalue((tl - fpixel[ii] +1) / labs(inc[ii]) ,
                               imgdim[ii] - 1);

        /* first pixel in the tile that overlaps with the image (0 base) */
        tilefpix[ii] = maxvalue(fpixel[ii] - tfpixel[ii], 0);

        while ((tfpixel[ii] + tilefpix[ii] - fpixel[ii]) % labs(inc[ii]))
        {
           (tilefpix[ii])++;
           if (tilefpix[ii] >= tiledim[ii])
              return(0);  /* no overlapping pixels */
        }

        if (ii > 0)
           imgdim[ii] *= imgdim[ii - 1];  /* product of dimensions */
    }

    return(1);  /* there appears to be  intersecting pixels */
}
/*--------------------------------------------------------------------------*/
int imcomp_copy_overlap (
    char *tile,         /* I - multi dimensional array of tile pixels */
    int pixlen,         /* I - number of bytes in each tile or image pixel */
    int ndim,           /* I - number of dimension in the tile and image */
    long *tfpixel,      /* I - first pixel number in each dim. of the tile */
    long *tlpixel,      /* I - last pixel number in each dim. of the tile */
    char *bnullarray,   /* I - array of null flags; used if nullcheck = 2 */
    char *image,        /* O - multi dimensional output image */
    long *fpixel,       /* I - first pixel number in each dim. of the image */
    long *lpixel,       /* I - last pixel number in each dim. of the image */
    long *ininc,        /* I - increment to be applied in each image dimen. */
    int nullcheck,      /* I - 0, 1: do nothing; 2: set nullarray for nulls */
    char *nullarray, 
    int *status)

/* 
  copy the intersecting pixels from a decompressed tile to the output image. 
  Both the tile and the image must have the same number of dimensions. 
*/
{
    long imgdim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */
                                   /* output image, allowing for inc factor */
    long tiledim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */
                                 /* tile, array;  inc factor is not relevant */
    long imgfpix[MAX_COMPRESS_DIM]; /* 1st img pix overlapping tile: 0 base, */
                                    /*  allowing for inc factor */
    long imglpix[MAX_COMPRESS_DIM]; /* last img pix overlapping tile 0 base, */
                                    /*  allowing for inc factor */
    long tilefpix[MAX_COMPRESS_DIM]; /* 1st tile pix overlapping img 0 base, */
                                    /*  allowing for inc factor */
    long inc[MAX_COMPRESS_DIM]; /* local copy of input ininc */
    long i1, i2, i3, i4;   /* offset along each axis of the image */
    long it1, it2, it3, it4;
    long im1, im2, im3, im4;  /* offset to image pixel, allowing for inc */
    long ipos, tf, tl;
    long t2, t3, t4;   /* offset along each axis of the tile */
    long tilepix, imgpix, tilepixbyte, imgpixbyte;
    int ii, overlap_bytes, overlap_flags;

    if (*status > 0)
        return(*status);

    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        /* set default values for higher dimensions */
        inc[ii] = 1;
        imgdim[ii] = 1;
        tiledim[ii] = 1;
        imgfpix[ii] = 0;
        imglpix[ii] = 0;
        tilefpix[ii] = 0;
    }

    /* ------------------------------------------------------------ */
    /* calc amount of overlap in each dimension; if there is zero   */
    /* overlap in any dimension then just return  */
    /* ------------------------------------------------------------ */
    
    for (ii = 0; ii < ndim; ii++)
    {
        if (tlpixel[ii] < fpixel[ii] || tfpixel[ii] > lpixel[ii])
            return(*status);  /* there are no overlapping pixels */

        inc[ii] = ininc[ii];

        /* calc dimensions of the output image section */
        imgdim[ii] = (lpixel[ii] - fpixel[ii]) / labs(inc[ii]) + 1;
        if (imgdim[ii] < 1)
            return(*status = NEG_AXIS);

        /* calc dimensions of the tile */
        tiledim[ii] = tlpixel[ii] - tfpixel[ii] + 1;
        if (tiledim[ii] < 1)
            return(*status = NEG_AXIS);

        if (ii > 0)
           tiledim[ii] *= tiledim[ii - 1];  /* product of dimensions */

        /* first and last pixels in image that overlap with the tile, 0 base */
        tf = tfpixel[ii] - 1;
        tl = tlpixel[ii] - 1;

        /* skip this plane if it falls in the cracks of the subsampled image */
        while ((tf-(fpixel[ii] - 1)) % labs(inc[ii]))
        {
           tf++;
           if (tf > tl)
             return(*status);  /* no overlapping pixels */
        }

        while ((tl-(fpixel[ii] - 1)) % labs(inc[ii]))
        {
           tl--;
           if (tf > tl)
             return(*status);  /* no overlapping pixels */
        }
        imgfpix[ii] = maxvalue((tf - fpixel[ii] +1) / labs(inc[ii]) , 0);
        imglpix[ii] = minvalue((tl - fpixel[ii] +1) / labs(inc[ii]) ,
                               imgdim[ii] - 1);

        /* first pixel in the tile that overlaps with the image (0 base) */
        tilefpix[ii] = maxvalue(fpixel[ii] - tfpixel[ii], 0);

        while ((tfpixel[ii] + tilefpix[ii] - fpixel[ii]) % labs(inc[ii]))
        {
           (tilefpix[ii])++;
           if (tilefpix[ii] >= tiledim[ii])
              return(*status);  /* no overlapping pixels */
        }
/*
printf("ii tfpixel, tlpixel %d %d %d \n",ii, tfpixel[ii], tlpixel[ii]);
printf("ii, tf, tl, imgfpix,imglpix, tilefpix %d %d %d %d %d %d\n",ii,
 tf,tl,imgfpix[ii], imglpix[ii],tilefpix[ii]);
*/
        if (ii > 0)
           imgdim[ii] *= imgdim[ii - 1];  /* product of dimensions */
    }

    /* ---------------------------------------------------------------- */
    /* calc number of pixels in each row (first dimension) that overlap */
    /* multiply by pixlen to get number of bytes to copy in each loop   */
    /* ---------------------------------------------------------------- */

    if (inc[0] != 1)
       overlap_flags = 1;  /* can only copy 1 pixel at a time */
    else
       overlap_flags = imglpix[0] - imgfpix[0] + 1;  /* can copy whole row */

    overlap_bytes = overlap_flags * pixlen;

    /* support up to 5 dimensions for now */
    for (i4 = 0, it4=0; i4 <= imglpix[4] - imgfpix[4]; i4++, it4++)
    {
     /* increment plane if it falls in the cracks of the subsampled image */
     while (ndim > 4 &&  (tfpixel[4] + tilefpix[4] - fpixel[4] + it4)
                          % labs(inc[4]) != 0)
        it4++;

       /* offset to start of hypercube */
       if (inc[4] > 0)
          im4 = (i4 + imgfpix[4]) * imgdim[3];
       else
          im4 = imgdim[4] - (i4 + 1 + imgfpix[4]) * imgdim[3];

      t4 = (tilefpix[4] + it4) * tiledim[3];
      for (i3 = 0, it3=0; i3 <= imglpix[3] - imgfpix[3]; i3++, it3++)
      {
       /* increment plane if it falls in the cracks of the subsampled image */
       while (ndim > 3 &&  (tfpixel[3] + tilefpix[3] - fpixel[3] + it3)
                            % labs(inc[3]) != 0)
          it3++;

       /* offset to start of cube */
       if (inc[3] > 0)
          im3 = (i3 + imgfpix[3]) * imgdim[2] + im4;
       else
          im3 = imgdim[3] - (i3 + 1 + imgfpix[3]) * imgdim[2] + im4;

       t3 = (tilefpix[3] + it3) * tiledim[2] + t4;

       /* loop through planes of the image */
       for (i2 = 0, it2=0; i2 <= imglpix[2] - imgfpix[2]; i2++, it2++)
       {
          /* incre plane if it falls in the cracks of the subsampled image */
          while (ndim > 2 &&  (tfpixel[2] + tilefpix[2] - fpixel[2] + it2)
                               % labs(inc[2]) != 0)
             it2++;

          /* offset to start of plane */
          if (inc[2] > 0)
             im2 = (i2 + imgfpix[2]) * imgdim[1] + im3;
          else
             im2 = imgdim[2] - (i2 + 1 + imgfpix[2]) * imgdim[1] + im3;

          t2 = (tilefpix[2] + it2) * tiledim[1] + t3;

          /* loop through rows of the image */
          for (i1 = 0, it1=0; i1 <= imglpix[1] - imgfpix[1]; i1++, it1++)
          {
             /* incre row if it falls in the cracks of the subsampled image */
             while (ndim > 1 &&  (tfpixel[1] + tilefpix[1] - fpixel[1] + it1)
                                  % labs(inc[1]) != 0)
                it1++;

             /* calc position of first pixel in tile to be copied */
             tilepix = tilefpix[0] + (tilefpix[1] + it1) * tiledim[0] + t2;

             /* offset to start of row */
             if (inc[1] > 0)
                im1 = (i1 + imgfpix[1]) * imgdim[0] + im2;
             else
                im1 = imgdim[1] - (i1 + 1 + imgfpix[1]) * imgdim[0] + im2;
/*
printf("inc = %d %d %d %d\n",inc[0],inc[1],inc[2],inc[3]);
printf("im1,im2,im3,im4 = %d %d %d %d\n",im1,im2,im3,im4);
*/
             /* offset to byte within the row */
             if (inc[0] > 0)
                imgpix = imgfpix[0] + im1;
             else
                imgpix = imgdim[0] - 1 - imgfpix[0] + im1;
/*
printf("tilefpix0,1, imgfpix1, it1, inc1, t2= %d %d %d %d %d %d\n",
       tilefpix[0],tilefpix[1],imgfpix[1],it1,inc[1], t2);
printf("i1, it1, tilepix, imgpix %d %d %d %d \n", i1, it1, tilepix, imgpix);
*/
             /* loop over pixels along one row of the image */
             for (ipos = imgfpix[0]; ipos <= imglpix[0]; ipos += overlap_flags)
             {
               if (nullcheck == 2)
               {
                   /* copy overlapping null flags from tile to image */
                   memcpy(nullarray + imgpix, bnullarray + tilepix,
                          overlap_flags);
               }

               /* convert from image pixel to byte offset */
               tilepixbyte = tilepix * pixlen;
               imgpixbyte  = imgpix  * pixlen;
/*
printf("  tilepix, tilepixbyte, imgpix, imgpixbyte= %d %d %d %d\n",
          tilepix, tilepixbyte, imgpix, imgpixbyte);
*/
               /* copy overlapping row of pixels from tile to image */
               memcpy(image + imgpixbyte, tile + tilepixbyte, overlap_bytes);

               tilepix += (overlap_flags * labs(inc[0]));
               if (inc[0] > 0)
                 imgpix += overlap_flags;
               else
                 imgpix -= overlap_flags;
            }
          }
        }
      }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int imcomp_merge_overlap (
    char *tile,         /* O - multi dimensional array of tile pixels */
    int pixlen,         /* I - number of bytes in each tile or image pixel */
    int ndim,           /* I - number of dimension in the tile and image */
    long *tfpixel,      /* I - first pixel number in each dim. of the tile */
    long *tlpixel,      /* I - last pixel number in each dim. of the tile */
    char *bnullarray,   /* I - array of null flags; used if nullcheck = 2 */
    char *image,        /* I - multi dimensional output image */
    long *fpixel,       /* I - first pixel number in each dim. of the image */
    long *lpixel,       /* I - last pixel number in each dim. of the image */
    int nullcheck,      /* I - 0, 1: do nothing; 2: set nullarray for nulls */
    int *status)

/* 
  Similar to imcomp_copy_overlap, except it copies the overlapping pixels from
  the 'image' to the 'tile'.
*/
{
    long imgdim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */
                                   /* output image, allowing for inc factor */
    long tiledim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */
                                 /* tile, array;  inc factor is not relevant */
    long imgfpix[MAX_COMPRESS_DIM]; /* 1st img pix overlapping tile: 0 base, */
                                    /*  allowing for inc factor */
    long imglpix[MAX_COMPRESS_DIM]; /* last img pix overlapping tile 0 base, */
                                    /*  allowing for inc factor */
    long tilefpix[MAX_COMPRESS_DIM]; /* 1st tile pix overlapping img 0 base, */
                                    /*  allowing for inc factor */
    long inc[MAX_COMPRESS_DIM]; /* local copy of input ininc */
    long i1, i2, i3, i4;   /* offset along each axis of the image */
    long it1, it2, it3, it4;
    long im1, im2, im3, im4;  /* offset to image pixel, allowing for inc */
    long ipos, tf, tl;
    long t2, t3, t4;   /* offset along each axis of the tile */
    long tilepix, imgpix, tilepixbyte, imgpixbyte;
    int ii, overlap_bytes, overlap_flags;

    if (*status > 0)
        return(*status);

    for (ii = 0; ii < MAX_COMPRESS_DIM; ii++)
    {
        /* set default values for higher dimensions */
        inc[ii] = 1;
        imgdim[ii] = 1;
        tiledim[ii] = 1;
        imgfpix[ii] = 0;
        imglpix[ii] = 0;
        tilefpix[ii] = 0;
    }

    /* ------------------------------------------------------------ */
    /* calc amount of overlap in each dimension; if there is zero   */
    /* overlap in any dimension then just return  */
    /* ------------------------------------------------------------ */
    
    for (ii = 0; ii < ndim; ii++)
    {
        if (tlpixel[ii] < fpixel[ii] || tfpixel[ii] > lpixel[ii])
            return(*status);  /* there are no overlapping pixels */

        /* calc dimensions of the output image section */
        imgdim[ii] = (lpixel[ii] - fpixel[ii]) / labs(inc[ii]) + 1;
        if (imgdim[ii] < 1)
            return(*status = NEG_AXIS);

        /* calc dimensions of the tile */
        tiledim[ii] = tlpixel[ii] - tfpixel[ii] + 1;
        if (tiledim[ii] < 1)
            return(*status = NEG_AXIS);

        if (ii > 0)
           tiledim[ii] *= tiledim[ii - 1];  /* product of dimensions */

        /* first and last pixels in image that overlap with the tile, 0 base */
        tf = tfpixel[ii] - 1;
        tl = tlpixel[ii] - 1;

        /* skip this plane if it falls in the cracks of the subsampled image */
        while ((tf-(fpixel[ii] - 1)) % labs(inc[ii]))
        {
           tf++;
           if (tf > tl)
             return(*status);  /* no overlapping pixels */
        }

        while ((tl-(fpixel[ii] - 1)) % labs(inc[ii]))
        {
           tl--;
           if (tf > tl)
             return(*status);  /* no overlapping pixels */
        }
        imgfpix[ii] = maxvalue((tf - fpixel[ii] +1) / labs(inc[ii]) , 0);
        imglpix[ii] = minvalue((tl - fpixel[ii] +1) / labs(inc[ii]) ,
                               imgdim[ii] - 1);

        /* first pixel in the tile that overlaps with the image (0 base) */
        tilefpix[ii] = maxvalue(fpixel[ii] - tfpixel[ii], 0);

        while ((tfpixel[ii] + tilefpix[ii] - fpixel[ii]) % labs(inc[ii]))
        {
           (tilefpix[ii])++;
           if (tilefpix[ii] >= tiledim[ii])
              return(*status);  /* no overlapping pixels */
        }
/*
printf("ii tfpixel, tlpixel %d %d %d \n",ii, tfpixel[ii], tlpixel[ii]);
printf("ii, tf, tl, imgfpix,imglpix, tilefpix %d %d %d %d %d %d\n",ii,
 tf,tl,imgfpix[ii], imglpix[ii],tilefpix[ii]);
*/
        if (ii > 0)
           imgdim[ii] *= imgdim[ii - 1];  /* product of dimensions */
    }

    /* ---------------------------------------------------------------- */
    /* calc number of pixels in each row (first dimension) that overlap */
    /* multiply by pixlen to get number of bytes to copy in each loop   */
    /* ---------------------------------------------------------------- */

    if (inc[0] != 1)
       overlap_flags = 1;  /* can only copy 1 pixel at a time */
    else
       overlap_flags = imglpix[0] - imgfpix[0] + 1;  /* can copy whole row */

    overlap_bytes = overlap_flags * pixlen;

    /* support up to 5 dimensions for now */
    for (i4 = 0, it4=0; i4 <= imglpix[4] - imgfpix[4]; i4++, it4++)
    {
     /* increment plane if it falls in the cracks of the subsampled image */
     while (ndim > 4 &&  (tfpixel[4] + tilefpix[4] - fpixel[4] + it4)
                          % labs(inc[4]) != 0)
        it4++;

       /* offset to start of hypercube */
       if (inc[4] > 0)
          im4 = (i4 + imgfpix[4]) * imgdim[3];
       else
          im4 = imgdim[4] - (i4 + 1 + imgfpix[4]) * imgdim[3];

      t4 = (tilefpix[4] + it4) * tiledim[3];
      for (i3 = 0, it3=0; i3 <= imglpix[3] - imgfpix[3]; i3++, it3++)
      {
       /* increment plane if it falls in the cracks of the subsampled image */
       while (ndim > 3 &&  (tfpixel[3] + tilefpix[3] - fpixel[3] + it3)
                            % labs(inc[3]) != 0)
          it3++;

       /* offset to start of cube */
       if (inc[3] > 0)
          im3 = (i3 + imgfpix[3]) * imgdim[2] + im4;
       else
          im3 = imgdim[3] - (i3 + 1 + imgfpix[3]) * imgdim[2] + im4;

       t3 = (tilefpix[3] + it3) * tiledim[2] + t4;

       /* loop through planes of the image */
       for (i2 = 0, it2=0; i2 <= imglpix[2] - imgfpix[2]; i2++, it2++)
       {
          /* incre plane if it falls in the cracks of the subsampled image */
          while (ndim > 2 &&  (tfpixel[2] + tilefpix[2] - fpixel[2] + it2)
                               % labs(inc[2]) != 0)
             it2++;

          /* offset to start of plane */
          if (inc[2] > 0)
             im2 = (i2 + imgfpix[2]) * imgdim[1] + im3;
          else
             im2 = imgdim[2] - (i2 + 1 + imgfpix[2]) * imgdim[1] + im3;

          t2 = (tilefpix[2] + it2) * tiledim[1] + t3;

          /* loop through rows of the image */
          for (i1 = 0, it1=0; i1 <= imglpix[1] - imgfpix[1]; i1++, it1++)
          {
             /* incre row if it falls in the cracks of the subsampled image */
             while (ndim > 1 &&  (tfpixel[1] + tilefpix[1] - fpixel[1] + it1)
                                  % labs(inc[1]) != 0)
                it1++;

             /* calc position of first pixel in tile to be copied */
             tilepix = tilefpix[0] + (tilefpix[1] + it1) * tiledim[0] + t2;

             /* offset to start of row */
             if (inc[1] > 0)
                im1 = (i1 + imgfpix[1]) * imgdim[0] + im2;
             else
                im1 = imgdim[1] - (i1 + 1 + imgfpix[1]) * imgdim[0] + im2;
/*
printf("inc = %d %d %d %d\n",inc[0],inc[1],inc[2],inc[3]);
printf("im1,im2,im3,im4 = %d %d %d %d\n",im1,im2,im3,im4);
*/
             /* offset to byte within the row */
             if (inc[0] > 0)
                imgpix = imgfpix[0] + im1;
             else
                imgpix = imgdim[0] - 1 - imgfpix[0] + im1;
/*
printf("tilefpix0,1, imgfpix1, it1, inc1, t2= %d %d %d %d %d %d\n",
       tilefpix[0],tilefpix[1],imgfpix[1],it1,inc[1], t2);
printf("i1, it1, tilepix, imgpix %d %d %d %d \n", i1, it1, tilepix, imgpix);
*/
             /* loop over pixels along one row of the image */
             for (ipos = imgfpix[0]; ipos <= imglpix[0]; ipos += overlap_flags)
             {
               /* convert from image pixel to byte offset */
               tilepixbyte = tilepix * pixlen;
               imgpixbyte  = imgpix  * pixlen;
/*
printf("  tilepix, tilepixbyte, imgpix, imgpixbyte= %d %d %d %d\n",
          tilepix, tilepixbyte, imgpix, imgpixbyte);
*/
               /* copy overlapping row of pixels from image to tile */
               memcpy(tile + tilepixbyte, image + imgpixbyte,  overlap_bytes);

               tilepix += (overlap_flags * labs(inc[0]));
               if (inc[0] > 0)
                 imgpix += overlap_flags;
               else
                 imgpix -= overlap_flags;
            }
          }
        }
      }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
static int unquantize_i1r4(long row, /* tile number = row number in table  */
            unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - dithering method to use             */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
    Unquantize byte values into the scaled floating point values
*/
{
    long ii;
    int nextrand, iseed;

    if (!fits_rand_value) 
       if (fits_init_randoms()) return(MEMORY_ALLOCATION);

    /* initialize the index to the next random number in the list */
    iseed = (int) ((row - 1) % N_RANDOM);
    nextrand = (int) (fits_rand_value[iseed] * 500);

    if (nullcheck == 0)     /* no null checking required */
    {
             for (ii = 0; ii < ntodo; ii++)
            {
/*
		if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		    output[ii] = 0.0;
		else
*/
                    output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }
    else        /* must check for null values */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
/*
		    if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		        output[ii] = 0.0;
		    else
*/
                        output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);
                } 

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
	            nextrand = (int) (fits_rand_value[iseed] * 500);
                }
            }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
static int unquantize_i2r4(long row, /* seed for random values  */
            short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - dithering method to use             */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
    Unquantize short integer values into the scaled floating point values
*/
{
    long ii;
    int nextrand, iseed;

    if (!fits_rand_value) 
       if (fits_init_randoms()) return(MEMORY_ALLOCATION);

    /* initialize the index to the next random number in the list */
    iseed = (int) ((row - 1) % N_RANDOM);
    nextrand = (int) (fits_rand_value[iseed] * 500);

    if (nullcheck == 0)     /* no null checking required */
    {
           for (ii = 0; ii < ntodo; ii++)
            {
/*
		if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		    output[ii] = 0.0;
		else
*/
                    output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }
    else        /* must check for null values */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
/*
                    if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		        output[ii] = 0.0;
		    else
*/
                        output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);
                }

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
             }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
static int unquantize_i4r4(long row, /* tile number = row number in table    */
            INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - dithering method to use             */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            float nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            float *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
    Unquantize int integer values into the scaled floating point values
*/
{
    long ii;
    int nextrand, iseed;

    if (fits_rand_value == 0) 
       if (fits_init_randoms()) return(MEMORY_ALLOCATION);

    /* initialize the index to the next random number in the list */
    iseed = (int) ((row - 1) % N_RANDOM);
    nextrand = (int) (fits_rand_value[iseed] * 500);

    if (nullcheck == 0)     /* no null checking required */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		    output[ii] = 0.0;
		else
                    output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }
    else        /* must check for null values */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		        output[ii] = 0.0;
		    else
                        output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);
                }

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
static int unquantize_i1r8(long row, /* tile number = row number in table  */
            unsigned char *input, /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - dithering method to use             */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            unsigned char tnull,  /* I - value of FITS TNULLn keyword if any */
            double nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
    Unquantize byte values into the scaled floating point values
*/
{
    long ii;
    int nextrand, iseed;

    if (!fits_rand_value) 
       if (fits_init_randoms()) return(MEMORY_ALLOCATION);

    /* initialize the index to the next random number in the list */
    iseed = (int) ((row - 1) % N_RANDOM);
    nextrand = (int) (fits_rand_value[iseed] * 500);

    if (nullcheck == 0)     /* no null checking required */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
/*
                if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		    output[ii] = 0.0;
		else
*/
                    output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }
    else        /* must check for null values */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
/*
                    if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		        output[ii] = 0.0;
		    else
*/
                        output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);
                }

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
static int unquantize_i2r8(long row, /* tile number = row number in table  */
            short *input,         /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - dithering method to use             */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            short tnull,          /* I - value of FITS TNULLn keyword if any */
            double nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
    Unquantize short integer values into the scaled floating point values
*/
{
    long ii;
    int nextrand, iseed;

    if (!fits_rand_value) 
       if (fits_init_randoms()) return(MEMORY_ALLOCATION);

    /* initialize the index to the next random number in the list */
    iseed = (int) ((row - 1) % N_RANDOM);
    nextrand = (int) (fits_rand_value[iseed] * 500);

    if (nullcheck == 0)     /* no null checking required */
    {
           for (ii = 0; ii < ntodo; ii++)
            {
/*
                if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		    output[ii] = 0.0;
		else
*/
                    output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }
    else        /* must check for null values */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
/*                    if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		        output[ii] = 0.0;
		    else
*/
                        output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);
                }

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
static int unquantize_i4r8(long row, /* tile number = row number in table    */
            INT32BIT *input,      /* I - array of values to be converted     */
            long ntodo,           /* I - number of elements in the array     */
            double scale,         /* I - FITS TSCALn or BSCALE value         */
            double zero,          /* I - FITS TZEROn or BZERO  value         */
            int dither_method,    /* I - dithering method to use             */
            int nullcheck,        /* I - null checking code; 0 = don't check */
                                  /*     1:set null pixels = nullval         */
                                  /*     2: if null pixel, set nullarray = 1 */
            INT32BIT tnull,       /* I - value of FITS TNULLn keyword if any */
            double nullval,        /* I - set null pixels, if nullcheck = 1   */
            char *nullarray,      /* I - bad pixel array, if nullcheck = 2   */
            int  *anynull,        /* O - set to 1 if any pixels are null     */
            double *output,        /* O - array of converted pixels           */
            int *status)          /* IO - error status                       */
/*
    Unquantize int integer values into the scaled floating point values
*/
{
    long ii;
    int nextrand, iseed;

    if (fits_rand_value == 0) 
       if (fits_init_randoms()) return(MEMORY_ALLOCATION);

    /* initialize the index to the next random number in the list */
    iseed = (int) ((row - 1) % N_RANDOM);
    nextrand = (int) (fits_rand_value[iseed] * 500);

    if (nullcheck == 0)     /* no null checking required */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		    output[ii] = 0.0;
		else
                    output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }
    else        /* must check for null values */
    {
            for (ii = 0; ii < ntodo; ii++)
            {
                if (input[ii] == tnull)
                {
                    *anynull = 1;
                    if (nullcheck == 1)
                        output[ii] = nullval;
                    else
                        nullarray[ii] = 1;
                }
                else
                {
                    if (dither_method == SUBTRACTIVE_DITHER_2 && input[ii] == ZERO_VALUE)
		        output[ii] = 0.0;
		    else
                        output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero);
                }

	        nextrand++;
	        if (nextrand == N_RANDOM) {
	            iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
		    nextrand = (int) (fits_rand_value[iseed] * 500);
	        }
            }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
static int imcomp_float2nan(float *indata, 
    long tilelen,
    int *outdata,
    float nullflagval, 
    int *status)
/*
  convert pixels that are equal to nullflag to NaNs.
  Note that indata and outdata point to the same location.
*/
{
    int ii;
    
    for (ii = 0; ii < tilelen; ii++) {

      if (indata[ii] == nullflagval)
        outdata[ii] = -1;  /* integer -1 has the same bit pattern as a real*4 NaN */
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
static int imcomp_double2nan(double *indata, 
    long tilelen,
    LONGLONG *outdata,
    double nullflagval, 
    int *status)
/*
  convert pixels that are equal to nullflag to NaNs.
  Note that indata and outdata point to the same location.
*/
{
    int ii;
    
    for (ii = 0; ii < tilelen; ii++) {

      if (indata[ii] == nullflagval)
        outdata[ii] = -1;  /* integer -1 has the same bit pattern as a real*8 NaN */
    }

    return(*status);
}

/* ======================================================================= */
/*    TABLE COMPRESSION ROUTINES                                           */
/* =-====================================================================== */

/*--------------------------------------------------------------------------*/
int fits_compress_table(fitsfile *infptr, fitsfile *outfptr, int *status)

/*
  Compress the input FITS Binary Table.
  
  First divide the table into equal sized chunks (analogous to image tiles) where all
  the contain the same number of rows (except perhaps for the last chunk
  which may contain fewer rows).   The chunks should not be too large to copy into memory
  (currently, about 100 MB max seems a reasonable size).
  
  Then, on a chunk by piece basis, do the following:
  
  1. Transpose the table from its original row-major order, into column-major order.
  All the bytes for each column are then continuous.  In addition, the bytes within
  each table element may be shuffled so that the most significant
  byte of every element occurs first in the array, followed by the next most
  significant byte, and so on to the least significant byte.  Byte shuffling often
  improves the gzip compression of floating-point arrays.
   
  2. Compress the contiguous array of bytes in each column using the specified
  compression method.  If no method is specifed, then a default method for that
  data type is chosen. 
  
  3. Store the compressed stream of bytes into a column that has the same name
  as in the input table, but which has a variable-length array data type (1QB).
  The output table will contain one row for each piece of the original table.
  
  4. If the input table contain variable-length arrays, then each VLA
  is compressed individually, and written to the heap in the output table.
  Note that the output table will contain 2 sets of pointers for each VLA column.  
  The first set contains the pointers to the uncompressed VLAs from the input table
  and the second is the set of pointers to the compressed VLAs in the output table.
  The latter set of pointers is used to reconstruct table when it is uncompressed,
  so that the heap has exactly the same structure as in the original file.  The 2
  sets of pointers are concatinated together, compressed with gzip, and written to
  the output table.  When reading the compressed table, the only VLA that is directly
  visible is this compressed array of descriptors.  One has to uncompress this array
  to be able to to read all the descriptors to the individual VLAs in the column.  
*/
{ 
    long maxchunksize = 10000000; /* default value for the size of each chunk of the table */

    char *cm_buffer;  /* memory buffer for the transposed, Column-Major, chunk of the table */ 
    LONGLONG cm_colstart[1000];  /* starting offset of each column in the cm_buffer */
    LONGLONG rm_repeat[1000];    /* repeat count of each column in the input row-major table */
    LONGLONG rm_colwidth[999];   /* width in bytes of each column in the input row-major table */
    LONGLONG cm_repeat[999];  /* total number of elements in each column of the transposed column-major table */

    int coltype[999];         /* data type code for each column */
    int compalgor[999], default_algor = 0;       /* compression algorithm to be applied to each column */
    float cratio[999];        /* compression ratio for each column (for diagnostic purposes) */

    float compressed_size, uncompressed_size, tot_compressed_size, tot_uncompressed_size;
    LONGLONG nrows, firstrow;
    LONGLONG headstart, datastart, dataend, startbyte, jj, kk, naxis1;
    LONGLONG vlalen, vlamemlen, vlastart, bytepos;
    long repeat, width, nchunks, rowspertile, lastrows;
    int ii, ll, ncols, hdutype, ltrue = 1, print_report = 0, tstatus;
    char *cptr, keyname[9], tform[40], *cdescript;
    char comm[FLEN_COMMENT], keyvalue[FLEN_VALUE], *cvlamem, tempstring[FLEN_VALUE], card[FLEN_CARD];

    LONGLONG *descriptors, *outdescript, *vlamem;
    int *pdescriptors;
    size_t dlen, datasize, compmemlen;

    /* ================================================================================== */
    /* perform initial sanity checks */
    /* ================================================================================== */
    
    /* special input flag value that means print out diagnostics */
    if (*status == -999) {
       print_report = 1;
       *status = 0;
    }

    if (*status > 0)
        return(*status);
    
    fits_get_hdu_type(infptr, &hdutype, status);
    if (hdutype != BINARY_TBL) {
        *status = NOT_BTABLE;
        return(*status);
    }

    if (infptr == outfptr) {
        ffpmsg("Cannot compress table 'in place' (fits_compress_table)");
        ffpmsg(" outfptr cannot be the same as infptr.");
        *status = DATA_COMPRESSION_ERR;
        return(*status);
    }

    /* get dimensions of the table */
    fits_get_num_rowsll(infptr, &nrows, status);
    fits_get_num_cols(infptr, &ncols, status);
    fits_read_key(infptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status);
    /* get offset to the start of the data and total size of the table (including the heap) */
    fits_get_hduaddrll(infptr, &headstart, &datastart, &dataend, status);

    if (*status > 0)
        return(*status);

    tstatus = 0;
    if (!fits_read_key(infptr, TSTRING, "FZALGOR", tempstring, NULL, &tstatus)) {

	    if (!strcasecmp(tempstring, "NONE")) {
	            default_algor = NOCOMPRESS;
	    } else if (!strcasecmp(tempstring, "GZIP") || !strcasecmp(tempstring, "GZIP_1")) {
	            default_algor = GZIP_1;
	    } else if (!strcasecmp(tempstring, "GZIP_2")) {
	            default_algor = GZIP_2;
 	    } else if (!strcasecmp(tempstring, "RICE_1")) {
	            default_algor = RICE_1;
 	    } else {
 	        ffpmsg("FZALGOR specifies unsupported table compression algorithm:");
		ffpmsg(tempstring);
	        *status = DATA_COMPRESSION_ERR;
	        return(*status);
	    }
    }

     /* just copy the HDU verbatim if the table has 0 columns or rows or if the table */
    /* is less than 5760 bytes (2 blocks) in size, or compression directive keyword = "NONE" */
    if (nrows < 1  || ncols < 1 || (dataend - datastart) < 5760  || default_algor == NOCOMPRESS) {
	fits_copy_hdu (infptr, outfptr, 0, status);
	return(*status);
    }
   
    /* Check if the chunk size has been specified with the FZTILELN keyword. */
    /* If not, calculate a default number of rows per chunck, */

    tstatus = 0;
    if (fits_read_key(infptr, TLONG, "FZTILELN", &rowspertile, NULL, &tstatus)) {
	rowspertile = (long) (maxchunksize / naxis1);
    }

    if (rowspertile < 1) rowspertile = 1;  
    if (rowspertile > nrows) rowspertile = (long) nrows;
    
    nchunks = (long) ((nrows - 1) / rowspertile + 1);  /* total number of chunks */
    lastrows = (long) (nrows - ((nchunks - 1) * rowspertile)); /* number of rows in last chunk */

    /* allocate space for the transposed, column-major chunk of the table */
    cm_buffer = calloc((size_t) naxis1, (size_t) rowspertile);
    if (!cm_buffer) {
        ffpmsg("Could not allocate cm_buffer for transposed table");
        *status = MEMORY_ALLOCATION;
        return(*status);
    }

    /* ================================================================================== */
    /*  Construct the header of the output compressed table  */
    /* ================================================================================== */
    fits_copy_header(infptr, outfptr, status);  /* start with verbatim copy of the input header */

    fits_write_key(outfptr, TLOGICAL, "ZTABLE", <rue, "this is a compressed table", status);
    fits_write_key(outfptr, TLONGLONG, "ZTILELEN", &rowspertile, "number of rows in each tile", status);

    fits_read_card(outfptr, "NAXIS1", card, status); /* copy NAXIS1 to ZNAXIS1 */
    strncpy(card, "ZNAXIS1", 7);
    fits_write_record(outfptr, card, status);
    
    fits_read_card(outfptr, "NAXIS2", card, status); /* copy NAXIS2 to ZNAXIS2 */
    strncpy(card, "ZNAXIS2", 7);
    fits_write_record(outfptr, card, status);

    fits_read_card(outfptr, "PCOUNT", card, status); /* copy PCOUNT to ZPCOUNT */
    strncpy(card, "ZPCOUNT", 7);
    fits_write_record(outfptr, card, status);

    fits_modify_key_lng(outfptr, "NAXIS2", nchunks, "&", status);  /* 1 row per chunk */
    fits_modify_key_lng(outfptr, "NAXIS1", ncols * 16, "&", status); /* 16 bytes for each 1QB column */
    fits_modify_key_lng(outfptr, "PCOUNT", 0L, "&", status); /* reset PCOUNT to 0 */
    
    /* rename the Checksum keywords, if they exist */
    tstatus = 0;
    fits_modify_name(outfptr, "CHECKSUM", "ZHECKSUM", &tstatus);
    tstatus = 0;
    fits_modify_name(outfptr, "DATASUM", "ZDATASUM", &tstatus);

    /* ================================================================================== */
    /*  Now loop over each column of the input table: write the column-specific keywords */
    /*  and determine which compression algorithm to use.     */
    /*  Also calculate various offsets to the start of the column data in both the */
    /*  original row-major table and in the transposed column-major form of the table.  */
    /* ================================================================================== */

    cm_colstart[0] = 0;
    for (ii = 0; ii < ncols; ii++) {  

 	/* get the structural parameters of the original uncompressed column */
	fits_make_keyn("TFORM", ii+1, keyname, status);
	fits_read_key(outfptr, TSTRING, keyname, tform, comm, status);
        fits_binary_tform(tform, coltype+ii, &repeat, &width, status); /* get the repeat count and the width */

	/* preserve the original TFORM value and comment string in a ZFORMn keyword */
	fits_read_card(outfptr, keyname, card, status); 
	card[0] = 'Z';
	fits_write_record(outfptr, card, status);
 
        /* All columns in the compressed table will have a variable-length array type. */
	fits_modify_key_str(outfptr, keyname, "1QB", "&", status);  /* Use 'Q' pointers (64-bit) */ 

	/* deal with special cases: bit, string, and variable length array columns */
	if (coltype[ii] == TBIT) {
	    repeat = (repeat + 7) / 8;  /* convert from bits to equivalent number of bytes */
	} else if (coltype[ii] == TSTRING) {
	    width = 1;  /* ignore the optional 'w' in 'rAw' format */
	} else if (coltype[ii] < 0) {  /* pointer to variable length array */
	    if (strchr(tform,'Q') ) {
	        width = 16;  /* 'Q' descriptor has 64-bit pointers */
	    } else {
	        width = 8;  /* 'P' descriptor has 32-bit pointers */
 	    }
	    repeat = 1;
	}

	rm_repeat[ii] = repeat;   
	rm_colwidth[ii] = repeat * width; /* column width (in bytes)in the input table */
	
	/* starting offset of each field in the OUTPUT transposed column-major table */
	cm_colstart[ii + 1] = cm_colstart[ii] + rm_colwidth[ii] * rowspertile;
	/* total number of elements in each column of the transposed column-major table */
	cm_repeat[ii] = rm_repeat[ii] * rowspertile;

	compalgor[ii] = default_algor;  /* initialize the column compression algorithm to the default */
	
	/*  check if a compression method has been specified for this column */
	fits_make_keyn("FZALG", ii+1, keyname, status);
	tstatus = 0;
	if (!fits_read_key(outfptr, TSTRING, keyname, tempstring, NULL, &tstatus)) {

	    if (!strcasecmp(tempstring, "GZIP") || !strcasecmp(tempstring, "GZIP_1")) {
	            compalgor[ii] = GZIP_1;
	    } else if (!strcasecmp(tempstring, "GZIP_2")) {
	            compalgor[ii] = GZIP_2;
	    } else if (!strcasecmp(tempstring, "RICE_1")) {
	            compalgor[ii] = RICE_1;
	    } else {
	        ffpmsg("Unsupported table compression algorithm specification.");
		ffpmsg(keyname);
		ffpmsg(tempstring);
	        *status = DATA_COMPRESSION_ERR;
		free(cm_buffer);
	        return(*status);
	    }
	}

	/* do sanity check of the requested algorithm and override if necessary */
	if ( abs(coltype[ii]) == TLOGICAL || abs(coltype[ii]) == TBIT || abs(coltype[ii]) == TSTRING) {
	        if (compalgor[ii] != GZIP_1) {
			compalgor[ii] = GZIP_1;
		}
	} else if ( abs(coltype[ii]) == TCOMPLEX || abs(coltype[ii]) == TDBLCOMPLEX ||
	                abs(coltype[ii]) == TFLOAT   || abs(coltype[ii]) == TDOUBLE ||
			abs(coltype[ii]) == TLONGLONG ) {
	        if (compalgor[ii] != GZIP_1 && compalgor[ii] != GZIP_2) {
			compalgor[ii] = GZIP_2;  /* gzip_2 usually works better gzip_1 */
		}
	} else if ( abs(coltype[ii]) == TSHORT ) {
	        if (compalgor[ii] != GZIP_1 && compalgor[ii] != GZIP_2 && compalgor[ii] != RICE_1) {
			compalgor[ii] = GZIP_2;  /* gzip_2 usually works better rice_1 */
		 }
	} else if (  abs(coltype[ii]) == TLONG	) {
	        if (compalgor[ii] != GZIP_1 && compalgor[ii] != GZIP_2 && compalgor[ii] != RICE_1) {
			compalgor[ii] = RICE_1;
		}
	} else if ( abs(coltype[ii]) == TBYTE ) {
	        if (compalgor[ii] != GZIP_1 && compalgor[ii] != RICE_1 ) {
			compalgor[ii] = GZIP_1;
		}
	}
    }  /* end of loop over columns */

    /* ================================================================================== */
    /*    now process each chunk of the table, in turn          */
    /* ================================================================================== */

    tot_uncompressed_size = 0.;
    tot_compressed_size = 0;
    firstrow = 1;
    for (ll = 0; ll < nchunks; ll++) {

        if (ll == nchunks - 1) {  /* the last chunk may have fewer rows */
	    rowspertile = lastrows; 
            for (ii = 0; ii < ncols; ii++) { 
		cm_colstart[ii + 1] = cm_colstart[ii] + (rm_colwidth[ii] * rowspertile);
		cm_repeat[ii] = rm_repeat[ii] * rowspertile;
	    }
	}

        /* move to the start of the chunk in the input table */
        ffmbyt(infptr, datastart, 0, status);

        /* ================================================================================*/
        /*  First, transpose this chunck from row-major order to column-major order  */
	/*  At the same time, shuffle the bytes in each datum, if doing GZIP_2 compression */
        /* ================================================================================*/

        for (jj = 0; jj < rowspertile; jj++)   {    /* loop over rows */
          for (ii = 0; ii < ncols; ii++) {  /* loop over columns */
      
           if (rm_repeat[ii] > 0) {  /*  skip virtual columns that have 0 elements */

	    kk = 0;	

	     /* if the  GZIP_2 compression algorithm is used, shuffle the bytes */
	    if (coltype[ii] == TSHORT && compalgor[ii] == GZIP_2) {
	      while(kk < rm_colwidth[ii]) {
	        cptr = cm_buffer + (cm_colstart[ii] + (jj * rm_repeat[ii]) + kk/2);  
	        ffgbyt(infptr, 1, cptr, status);  /* get 1st byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 2nd byte */
	        kk += 2;
	      }
	    } else if ((coltype[ii] == TFLOAT || coltype[ii] == TLONG) && compalgor[ii] == GZIP_2) {
	      while(kk < rm_colwidth[ii]) {
	        cptr = cm_buffer + (cm_colstart[ii] + (jj * rm_repeat[ii]) + kk/4);  
	        ffgbyt(infptr, 1, cptr, status);  /* get 1st byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 2nd byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 3rd byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 4th byte */
	        kk += 4;
	      }
	    } else if ( (coltype[ii] == TDOUBLE || coltype[ii] == TLONGLONG) && compalgor[ii] == GZIP_2) {
	      while(kk < rm_colwidth[ii]) {
	        cptr = cm_buffer + (cm_colstart[ii] + (jj * rm_repeat[ii]) + kk/8);  
	        ffgbyt(infptr, 1, cptr, status);  /* get 1st byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 2nd byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 3rd byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 4th byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 5th byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 6th byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 7th byte */
	        cptr += cm_repeat[ii];  
	        ffgbyt(infptr, 1, cptr, status);  /* get 8th byte */
	        kk += 8;
	      }
	    } else  { /* all other cases: don't shuffle the bytes; simply transpose the column */
	        cptr = cm_buffer + (cm_colstart[ii] + (jj * rm_colwidth[ii]));   /* addr to copy to */
	        startbyte = (infptr->Fptr)->bytepos;  /* save the starting byte location */
	        ffgbyt(infptr, rm_colwidth[ii], cptr, status);  /* copy all the bytes */

	        if (rm_colwidth[ii] >= MINDIRECT) { /* have to explicitly move to next byte */
	  	    ffmbyt(infptr, startbyte + rm_colwidth[ii], 0, status);
	        }
	    }  /* end of test of coltypee */

           }  /* end of not virtual column */
          }  /* end of loop over columns */
        }  /* end of loop over rows */

        /* ================================================================================*/
        /*  now compress each column in the transposed chunk of the table    */
        /* ================================================================================*/

        fits_set_hdustruc(outfptr, status);  /* initialize structures in the output table */
    
        for (ii = 0; ii < ncols; ii++) {  /* loop over columns */
	  /* initialize the diagnostic compression results string */
	  sprintf(results[ii],"%3d %3d %3d ", ii+1, coltype[ii], compalgor[ii]);  
          cratio[ii] = 0;
	  
          if (rm_repeat[ii] > 0) {  /* skip virtual columns with zero width */

	    if (coltype[ii] < 0)  {  /* this is a variable length array (VLA) column */

		/*=========================================================================*/	    
	        /* variable-length array columns are a complicated special case  */
		/*=========================================================================*/

		/* allocate memory to hold all the VLA descriptors from the input table, plus */
		/* room to hold the descriptors to the compressed VLAs in the output table */
		/* In total, there will be 2 descriptors for each row in this chunk */

		uncompressed_size = 0.;
		compressed_size = 0;
		
		datasize = (size_t) (cm_colstart[ii + 1] - cm_colstart[ii]); /* size of input descriptors */

		cdescript =  calloc(datasize + (rowspertile * 16), 1); /* room for both descriptors */
		if (!cdescript) {
                    ffpmsg("Could not allocate buffer for descriptors");
                    *status = MEMORY_ALLOCATION;
		    free(cm_buffer);
	            return(*status);
		}

		/* copy the input descriptors to this array */
		memcpy(cdescript, &cm_buffer[cm_colstart[ii]], datasize);
#if BYTESWAPPED
		/* byte-swap the integer values into the native machine representation */
		if (rm_colwidth[ii] == 16) {
		    ffswap8((double *) cdescript,  rowspertile * 2);
		} else {
		    ffswap4((int *) cdescript,  rowspertile * 2);
		}
#endif
		descriptors = (LONGLONG *) cdescript;  /* use this for Q type descriptors */
		pdescriptors = (int *) cdescript;     /* use this instead for or P type descriptors */
		/* pointer to the 2nd set of descriptors */
		outdescript = (LONGLONG *) (cdescript + datasize);  /* this is a LONGLONG pointer */
		
		for (jj = 0; jj < rowspertile; jj++)   {    /* loop to compress each VLA in turn */

		  if (rm_colwidth[ii] == 16) { /* if Q pointers */
			vlalen = descriptors[jj * 2];
			vlastart = descriptors[(jj * 2) + 1];
		  } else {  /* if P pointers */
			vlalen = (LONGLONG) pdescriptors[jj * 2];
			vlastart = (LONGLONG) pdescriptors[(jj * 2) + 1];
		  }

		  if (vlalen > 0) {  /* skip zero-length VLAs */

		    vlamemlen = vlalen * (int) (-coltype[ii] / 10);
		    vlamem = (LONGLONG *) malloc((size_t) vlamemlen); /* memory for the input uncompressed VLA */
		    if (!vlamem) {
			ffpmsg("Could not allocate buffer for VLA");
			*status = MEMORY_ALLOCATION;
			free(cdescript); free(cm_buffer);
			return(*status);
		    }

		    compmemlen = (size_t) (vlalen * ((LONGLONG) (-coltype[ii] / 10)) * 1.5);
		    if (compmemlen < 100) compmemlen = 100;
		    cvlamem = malloc(compmemlen);  /* memory for the output compressed VLA */
		    if (!cvlamem) {
			ffpmsg("Could not allocate buffer for compressed data");
			*status = MEMORY_ALLOCATION;
			free(vlamem); free(cdescript); free(cm_buffer);
			return(*status);
		    }

		    /* read the raw bytes directly from the heap, without any byte-swapping or null value detection */
		    bytepos = (infptr->Fptr)->datastart + (infptr->Fptr)->heapstart + vlastart;
		    ffmbyt(infptr, bytepos, REPORT_EOF, status);
		    ffgbyt(infptr, vlamemlen, vlamem, status);  /* read the bytes */
		    uncompressed_size += vlamemlen;  /* total size of the uncompressed VLAs */
		    tot_uncompressed_size += vlamemlen;  /* total size of the uncompressed file */

		    /* compress the VLA with the appropriate algorithm */
	    	    if (compalgor[ii] == RICE_1) {

		        if (-coltype[ii] == TSHORT) {
#if BYTESWAPPED
			  ffswap2((short *) (vlamem),  (long) vlalen); 
#endif
			  dlen = fits_rcomp_short ((short *)(vlamem), (int) vlalen, (unsigned char *) cvlamem,
			   (int) compmemlen, 32);
		        } else if (-coltype[ii] == TLONG) {
#if BYTESWAPPED
			  ffswap4((int *) (vlamem),  (long) vlalen); 
#endif
			  dlen = fits_rcomp ((int *)(vlamem), (int) vlalen, (unsigned char *) cvlamem,
                           (int) compmemlen, 32);
		        } else if (-coltype[ii] == TBYTE) {
			  dlen = fits_rcomp_byte ((signed char *)(vlamem), (int) vlalen, (unsigned char *) cvlamem,
                           (int) compmemlen, 32);
		        } else {
			  /* this should not happen */
			  ffpmsg(" Error: cannot compress this column type with the RICE algorthm");
			  free(vlamem); free(cdescript); free(cm_buffer); free(cvlamem);
			  *status = DATA_COMPRESSION_ERR;
			  return(*status);
		        }  
		    } else if (compalgor[ii] == GZIP_1 || compalgor[ii] == GZIP_2){  
		       if (compalgor[ii] == GZIP_2 ) {  /* shuffle the bytes before gzipping them */
			   if ( (int) (-coltype[ii] / 10) == 2) {
			       fits_shuffle_2bytes((char *) vlamem, vlalen, status);
			   } else if ( (int) (-coltype[ii] / 10) == 4) {
			       fits_shuffle_4bytes((char *) vlamem, vlalen, status);
			   } else if ( (int) (-coltype[ii] / 10) == 8) {
			       fits_shuffle_8bytes((char *) vlamem, vlalen, status);
			   }
		        }
		        /*: gzip compress the array of bytes */
		        compress2mem_from_mem( (char *) vlamem, (size_t) vlamemlen,
	    		    &cvlamem,  &compmemlen, realloc, &dlen, status);        
		    } else {
			  /* this should not happen */
			  ffpmsg(" Error: unknown compression algorthm");
			  free(vlamem); free(cdescript); free(cm_buffer); free(cvlamem);
			  *status = DATA_COMPRESSION_ERR;
			  return(*status);
		    }  

		    /* write the compressed array to the output table, but... */
		    /* We use a trick of always writing the array to the same row of the output table */
		    /* and then copy the descriptor into the array of descriptors that we allocated. */
		     
		    /* First, reset the descriptor */
		    fits_write_descript(outfptr, ii+1, ll+1, 0, 0, status);

		    /* write the compressed VLA if it is smaller than the original, else write */
		    /* the uncompressed array */
		    fits_set_tscale(outfptr, ii + 1, 1.0, 0.0, status);  /* turn off any data scaling, first */
		    if (dlen < vlamemlen) {
		        fits_write_col(outfptr, TBYTE, ii + 1, ll+1, 1, dlen, cvlamem, status);
		        compressed_size += dlen;  /* total size of the compressed VLAs */
		        tot_compressed_size += dlen;  /* total size of the compressed file */
		    } else {
			if ( -coltype[ii] != TBYTE && compalgor[ii] != GZIP_1) {
			    /* it is probably faster to reread the raw bytes, rather than unshuffle or unswap them */
			    bytepos = (infptr->Fptr)->datastart + (infptr->Fptr)->heapstart + vlastart;
			    ffmbyt(infptr, bytepos, REPORT_EOF, status);
			    ffgbyt(infptr, vlamemlen, vlamem, status);  /* read the bytes */
			}
		        fits_write_col(outfptr, TBYTE, ii + 1, ll+1, 1, vlamemlen, vlamem, status);
		        compressed_size += vlamemlen;  /* total size of the compressed VLAs */
		        tot_compressed_size += vlamemlen;  /* total size of the compressed file */
		    }

		    /* read back the descriptor and save it in the array of descriptors */
		    fits_read_descriptll(outfptr, ii + 1, ll + 1, outdescript+(jj*2), outdescript+(jj*2)+1, status);
		    free(cvlamem);  free(vlamem);

		  } /* end of vlalen > 0 */
		}  /* end of loop over rows */

		if (compressed_size != 0)
		    cratio[ii] = uncompressed_size / compressed_size;

		sprintf(tempstring," r=%6.2f",cratio[ii]);
		strcat(results[ii],tempstring);

		/* now we just have to compress the array of descriptors (both input and output) */
		/* and write them to the output table. */

		/* allocate memory for the compressed descriptors */
		cvlamem = malloc(datasize + (rowspertile * 16) );
		if (!cvlamem) {
		    ffpmsg("Could not allocate buffer for compressed data");
		    *status = MEMORY_ALLOCATION;
		    free(cdescript); free(cm_buffer);
		    return(*status);
		}

#if BYTESWAPPED
		/* byte swap the input and output descriptors */
		if (rm_colwidth[ii] == 16) {
		    ffswap8((double *) cdescript,  rowspertile * 2);
		} else {
		    ffswap4((int *) cdescript,  rowspertile * 2);
		}
		ffswap8((double *) outdescript,  rowspertile * 2);
#endif
		/* compress the array contain both sets of descriptors */
		compress2mem_from_mem((char *) cdescript, datasize + (rowspertile * 16),
	    		&cvlamem,  &datasize, realloc, &dlen, status);        

		free(cdescript);

		/* write the compressed descriptors to the output column */
		fits_set_tscale(outfptr, ii + 1, 1.0, 0.0, status);  /* turn off any data scaling, first */
		fits_write_descript(outfptr, ii+1, ll+1, 0, 0, status); /* First, reset the descriptor */
		fits_write_col(outfptr, TBYTE, ii + 1, ll+1, 1, dlen, cvlamem, status);
		free(cvlamem); 

		if (ll == 0) {  /* only write the ZCTYPn keyword once, while processing the first column */
			fits_make_keyn("ZCTYP", ii+1, keyname, status);

			if (compalgor[ii] == RICE_1) {
			     strcpy(keyvalue, "RICE_1");
			} else if (compalgor[ii] == GZIP_2) {
			     strcpy(keyvalue, "GZIP_2");
			} else {
			     strcpy(keyvalue, "GZIP_1");
			}

			fits_write_key(outfptr, TSTRING, keyname, keyvalue,
			"compression algorithm for column", status);
		}

	        continue;  /* jump to end of loop, to go to next column */
	    }  /* end of VLA case */

	    /* ================================================================================*/
	    /* deal with all the normal fixed-length columns here */
	    /* ================================================================================*/

	    /* allocate memory for the compressed data */
	    datasize = (size_t) (cm_colstart[ii + 1] - cm_colstart[ii]);
	    cvlamem = malloc(datasize*2);
	    tot_uncompressed_size += datasize;
	    
	    if (!cvlamem) {
                ffpmsg("Could not allocate buffer for compressed data");
                *status = MEMORY_ALLOCATION;
		free(cm_buffer);
	        return(*status);
	    }

	    if (compalgor[ii] == RICE_1) {
	        if (coltype[ii] == TSHORT) {
#if BYTESWAPPED
                    ffswap2((short *) (cm_buffer + cm_colstart[ii]),  datasize / 2); 
#endif
  	            dlen = fits_rcomp_short ((short *)(cm_buffer + cm_colstart[ii]), datasize / 2, (unsigned char *) cvlamem,
                       datasize * 2, 32);

	        } else if (coltype[ii] == TLONG) {
#if BYTESWAPPED
                    ffswap4((int *) (cm_buffer + cm_colstart[ii]),  datasize / 4); 
#endif
   	            dlen = fits_rcomp ((int *)(cm_buffer + cm_colstart[ii]), datasize / 4, (unsigned char *) cvlamem,
                       datasize * 2, 32);

	        } else if (coltype[ii] == TBYTE) {

  	            dlen = fits_rcomp_byte ((signed char *)(cm_buffer + cm_colstart[ii]), datasize, (unsigned char *) cvlamem,
                       datasize * 2, 32);
	        } else {  /* this should not happen */
                    ffpmsg(" Error: cannot compress this column type with the RICE algorthm");
		    free(cvlamem);  free(cm_buffer);
	            *status = DATA_COMPRESSION_ERR;
	            return(*status);
	        }
	    } else {
	    	/* all other cases: gzip compress the column (bytes may have been shuffled previously) */
		compress2mem_from_mem(cm_buffer + cm_colstart[ii], datasize,
	    		&cvlamem,  &datasize, realloc, &dlen, status);        
	    }

	    if (ll == 0) {  /* only write the ZCTYPn keyword once, while processing the first column */
		fits_make_keyn("ZCTYP", ii+1, keyname, status);

		if (compalgor[ii] == RICE_1) {
		     strcpy(keyvalue, "RICE_1");
		} else if (compalgor[ii] == GZIP_2) {
		     strcpy(keyvalue, "GZIP_2");
		} else {
		     strcpy(keyvalue, "GZIP_1");
		}

		fits_write_key(outfptr, TSTRING, keyname, keyvalue,
		"compression algorithm for column", status);
	    }

	    /* write the compressed data to the output column */
	    fits_set_tscale(outfptr, ii + 1, 1.0, 0.0, status);  /* turn off any data scaling, first */
	    fits_write_col(outfptr, TBYTE, ii + 1, ll+1, 1, dlen, cvlamem, status);
	    tot_compressed_size += dlen;

	    free(cvlamem);   /* don't need the compressed data any more */

            /* create diagnostic messages */
	    if (dlen != 0)
	       cratio[ii] = (float) datasize / (float) dlen;  /* compression ratio of the column */

	    sprintf(tempstring," r=%6.2f",cratio[ii]);
	    strcat(results[ii],tempstring);
 
          }  /* end of not a virtual column */
        }  /* end of loop over columns */

        datastart += (rowspertile * naxis1);   /* increment to start of next chunk */
        firstrow += rowspertile;  /* increment first row in next chunk */

       if (print_report) {
	  printf("\nChunk = %d\n",ll+1);
	  for (ii = 0; ii < ncols; ii++) {  
		printf("%s\n", results[ii]);
	  }
	}
	
    }  /* end of loop over chunks of the table */

    /* =================================================================================*/
    /*  all done; just clean up and return  */
    /* ================================================================================*/

    free(cm_buffer);
    fits_set_hdustruc(outfptr, status);  /* reset internal structures */
       	
    if (print_report) {

       if (tot_compressed_size != 0)
           printf("\nTotal data size (MB) %.3f -> %.3f, ratio = %.3f\n", tot_uncompressed_size/1000000., 
	     tot_compressed_size/1000000., tot_uncompressed_size/tot_compressed_size);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_uncompress_table(fitsfile *infptr, fitsfile *outfptr, int *status)

/*
  Uncompress the table that was compressed with fits_compress_table
*/
{ 
    char colcode[999];  /* column data type code character */
    char coltype[999];  /* column data type numeric code value */
    char *cm_buffer;   /* memory buffer for the transposed, Column-Major, chunk of the table */ 
    char *rm_buffer;   /* memory buffer for the original, Row-Major, chunk of the table */ 
    LONGLONG nrows, rmajor_colwidth[999], rmajor_colstart[1000], cmajor_colstart[1000];
    LONGLONG cmajor_repeat[999], rmajor_repeat[999], cmajor_bytespan[999], kk;
    LONGLONG headstart, datastart = 0, dataend, rowsremain, *descript, *qdescript = 0;
    LONGLONG rowstart, cvlalen, cvlastart, vlalen, vlastart;
    long repeat, width, vla_repeat, vla_address, rowspertile, ntile;
    int  ncols, hdutype, inttype, anynull, tstatus, zctype[999], addspace = 0, *pdescript = 0;
    char *cptr, keyname[9], tform[40];
    long  pcount, zheapptr, naxis1, naxis2, ii, jj;
    char *ptr, comm[FLEN_COMMENT], zvalue[FLEN_VALUE], *uncompressed_vla = 0, *compressed_vla;
    char card[FLEN_CARD];
    size_t dlen, fullsize, cm_size, bytepos, vlamemlen;

    /* ================================================================================== */
    /* perform initial sanity checks */
    /* ================================================================================== */
    if (*status > 0)
        return(*status);
     
    fits_get_hdu_type(infptr, &hdutype, status);
    if (hdutype != BINARY_TBL) {
        ffpmsg("This is not a binary table, so cannot uncompress it!");
        *status = NOT_BTABLE;
        return(*status);
    }

    if (fits_read_key(infptr, TLOGICAL, "ZTABLE", &tstatus, NULL, status)) {
	/* just copy the HDU if the table is not compressed */
	if (infptr != outfptr) { 
		fits_copy_hdu (infptr, outfptr, 0, status);
	}
	return(*status);
    }
 
    fits_get_num_rowsll(infptr, &nrows, status);
    fits_get_num_cols(infptr, &ncols, status);

    if ((ncols < 1)) {
	/* just copy the HDU if the table does not have  more than 0 columns */
	if (infptr != outfptr) { 
		fits_copy_hdu (infptr, outfptr, 0, status);
	}
	return(*status);
    }

    fits_read_key(infptr, TLONG, "ZTILELEN", &rowspertile, comm, status);
    if (*status > 0) {
        ffpmsg("Could not find the required ZTILELEN keyword");
        *status = DATA_DECOMPRESSION_ERR;
        return(*status);
    }

    /**** get size of the uncompressed table */
    fits_read_key(infptr, TLONG, "ZNAXIS1", &naxis1, comm, status);
    if (*status > 0) {
        ffpmsg("Could not find the required ZNAXIS1 keyword");
        *status = DATA_DECOMPRESSION_ERR;
        return(*status);
    }

    fits_read_key(infptr, TLONG, "ZNAXIS2", &naxis2, comm, status);
    if (*status > 0) {
        ffpmsg("Could not find the required ZNAXIS2 keyword");
        *status = DATA_DECOMPRESSION_ERR;
        return(*status);
    }

    fits_read_key(infptr, TLONG, "ZPCOUNT", &pcount, comm, status);
    if (*status > 0) {
        ffpmsg("Could not find the required ZPCOUNT keyword");
        *status = DATA_DECOMPRESSION_ERR;
        return(*status);
    }

    tstatus = 0;
    fits_read_key(infptr, TLONG, "ZHEAPPTR", &zheapptr, comm, &tstatus);
    if (tstatus > 0) {
        zheapptr = 0;  /* uncompressed table has no heap */
    }

    /* ================================================================================== */
    /* copy of the input header, then recreate the uncompressed table keywords */
    /* ================================================================================== */
    fits_copy_header(infptr, outfptr, status);

    /* reset the NAXIS1, NAXIS2. and PCOUNT keywords to the original */
    fits_read_card(outfptr, "ZNAXIS1", card, status);
    strncpy(card, "NAXIS1 ", 7);
    fits_update_card(outfptr, "NAXIS1", card, status);
    
    fits_read_card(outfptr, "ZNAXIS2", card, status);
    strncpy(card, "NAXIS2 ", 7);
    fits_update_card(outfptr, "NAXIS2", card, status);
    
    fits_read_card(outfptr, "ZPCOUNT", card, status);
    strncpy(card, "PCOUNT ", 7);
    fits_update_card(outfptr, "PCOUNT", card, status);

    fits_delete_key(outfptr, "ZTABLE", status);
    fits_delete_key(outfptr, "ZTILELEN", status);
    fits_delete_key(outfptr, "ZNAXIS1", status);
    fits_delete_key(outfptr, "ZNAXIS2", status);
    fits_delete_key(outfptr, "ZPCOUNT", status);
    tstatus = 0;
    fits_delete_key(outfptr, "CHECKSUM", &tstatus); 
    tstatus = 0;
    fits_delete_key(outfptr, "DATASUM", &tstatus); 
    /* restore the Checksum keywords, if they exist */
    tstatus = 0;
    fits_modify_name(outfptr, "ZHECKSUM", "CHECKSUM", &tstatus);
    tstatus = 0;
    fits_modify_name(outfptr, "ZDATASUM", "DATASUM", &tstatus);

    /* ================================================================================== */
    /* determine compression paramters for each column and write column-specific keywords */
    /* ================================================================================== */
    for (ii = 0; ii < ncols; ii++) {

	/* get the original column type, repeat count, and unit width */
	fits_make_keyn("ZFORM", ii+1, keyname, status);
	fits_read_key(infptr, TSTRING, keyname, tform, comm, status);

	/* restore the original TFORM value and comment */
	fits_read_card(outfptr, keyname, card, status);
	card[0] = 'T';
	keyname[0] = 'T';
	fits_update_card(outfptr, keyname, card, status);

	/* now delete the ZFORM keyword */
        keyname[0] = 'Z';
	fits_delete_key(outfptr, keyname, status);

	cptr = tform;
	while(isdigit(*cptr)) cptr++;
	colcode[ii] = *cptr; /* save the column type code */

        fits_binary_tform(tform, &inttype, &repeat, &width, status);
        coltype[ii] = inttype;

	/* deal with special cases */
	if (abs(coltype[ii]) == TBIT) { 
	        repeat = (repeat + 7) / 8 ;   /* convert from bits to bytes */
	} else if (abs(coltype[ii]) == TSTRING) {
	        width = 1;
	} else if (coltype[ii] < 0) {  /* pointer to variable length array */
	        if (colcode[ii] == 'P')
	           width = 8;  /* this is a 'P' column */
	        else
	           width = 16;  /* this is a 'Q' not a 'P' column */

                addspace += 16; /* need space for a second set of Q pointers for this column */
	}

	rmajor_repeat[ii] = repeat;

	/* width (in bytes) of each field in the row-major table */
	rmajor_colwidth[ii] = rmajor_repeat[ii] * width;

	/* construct the ZCTYPn keyword name then read the keyword */
	fits_make_keyn("ZCTYP", ii+1, keyname, status);
	tstatus = 0;
        fits_read_key(infptr, TSTRING, keyname, zvalue, NULL, &tstatus);
	if (tstatus) {
           zctype[ii] = GZIP_2;
	} else {
	   if (!strcmp(zvalue, "GZIP_2")) {
               zctype[ii] = GZIP_2;
	   } else if (!strcmp(zvalue, "GZIP_1")) {
               zctype[ii] = GZIP_1;
	   } else if (!strcmp(zvalue, "RICE_1")) {
               zctype[ii] = RICE_1;
	   } else {
	       ffpmsg("Unrecognized ZCTYPn keyword compression code:");
	       ffpmsg(zvalue);
	       *status = DATA_DECOMPRESSION_ERR;
	       return(*status);
	   }
	   
	   /* delete this keyword from the uncompressed header */
	   fits_delete_key(outfptr, keyname, status);
	}
    }

    /* rescan header keywords to reset internal table structure parameters */
    fits_set_hdustruc(outfptr, status);

    /* ================================================================================== */
    /* allocate memory for the transposed and untransposed tile of the table */
    /* ================================================================================== */

    fullsize = naxis1 * rowspertile;
    cm_size = fullsize + (addspace * rowspertile);

    cm_buffer = malloc(cm_size);
    if (!cm_buffer) {
        ffpmsg("Could not allocate buffer for transformed column-major table");
        *status = MEMORY_ALLOCATION;
        return(*status);
    }

    rm_buffer = malloc(fullsize);
    if (!rm_buffer) {
        ffpmsg("Could not allocate buffer for untransformed row-major table");
        *status = MEMORY_ALLOCATION;
        free(cm_buffer);
        return(*status);
    }

    /* ================================================================================== */
    /* Main loop over all the tiles */
    /* ================================================================================== */

    rowsremain = naxis2;
    rowstart = 1;
    ntile = 0;

    while(rowsremain) {

        /* ================================================================================== */
        /* loop over each column: read and uncompress the bytes */
        /* ================================================================================== */
        ntile++;
        rmajor_colstart[0] = 0;
        cmajor_colstart[0] = 0;
        for (ii = 0; ii < ncols; ii++) {

	    cmajor_repeat[ii] = rmajor_repeat[ii] * rowspertile;

	    /* starting offset of each field in the column-major table */
            if (coltype[ii] > 0) {  /* normal fixed length column */
	          cmajor_colstart[ii + 1] = cmajor_colstart[ii] + rmajor_colwidth[ii] * rowspertile;
	    } else { /* VLA column: reserve space for the 2nd set of Q pointers */
	          cmajor_colstart[ii + 1] = cmajor_colstart[ii] + (rmajor_colwidth[ii] + 16) * rowspertile;
	    }
	    /* length of each sequence of bytes, after sorting them in signicant order */
	    cmajor_bytespan[ii] = (rmajor_repeat[ii] * rowspertile);

	    /* starting offset of each field in the  row-major table */
	    rmajor_colstart[ii + 1] = rmajor_colstart[ii] + rmajor_colwidth[ii];

            if (rmajor_repeat[ii] > 0) { /* ignore columns with 0 elements */
	
	        /* read compressed bytes from input table */
	        fits_read_descript(infptr, ii + 1, ntile, &vla_repeat, &vla_address, status);
	
	        /* allocate memory and read in the compressed bytes */
	        ptr = malloc(vla_repeat);
	        if (!ptr) {
                   ffpmsg("Could not allocate buffer for uncompressed bytes");
                   *status = MEMORY_ALLOCATION;
                   free(rm_buffer);  free(cm_buffer);
                   return(*status);
	        }

	        fits_set_tscale(infptr, ii + 1, 1.0, 0.0, status);  /* turn off any data scaling, first */
	        fits_read_col_byt(infptr, ii + 1, ntile, 1, vla_repeat, 0, (unsigned char *) ptr, &anynull, status);
                cptr = cm_buffer + cmajor_colstart[ii];
	
		/* size in bytes of the uncompressed column of bytes */
	        fullsize = (size_t) (cmajor_colstart[ii+1] - cmajor_colstart[ii]);

	        switch (colcode[ii]) {

	        case 'I':

	          if (zctype[ii] == RICE_1) {
   	             dlen = fits_rdecomp_short((unsigned char *)ptr, vla_repeat, (unsigned short *)cptr, 
		       fullsize / 2, 32);
#if BYTESWAPPED
                     ffswap2((short *) cptr, fullsize / 2); 
#endif
	          } else { /* gunzip the data into the correct location */
	             uncompress2mem_from_mem(ptr, vla_repeat, &cptr, &fullsize, realloc, &dlen, status);        
	          }
	          break;

	        case 'J':

	          if (zctype[ii] == RICE_1) {
   	              dlen = fits_rdecomp ((unsigned char *) ptr, vla_repeat, (unsigned int *)cptr, 
		        fullsize / 4, 32);
#if BYTESWAPPED
                      ffswap4((int *) cptr,  fullsize / 4); 
#endif
	          } else { /* gunzip the data into the correct location */
	             uncompress2mem_from_mem(ptr, vla_repeat, &cptr, &fullsize, realloc, &dlen, status);        
	          }
	          break;

	        case 'B':

	          if (zctype[ii] == RICE_1) {
   	              dlen = fits_rdecomp_byte ((unsigned char *) ptr, vla_repeat, (unsigned char *)cptr, 
		        fullsize, 32);
	          } else { /* gunzip the data into the correct location */
	             uncompress2mem_from_mem(ptr, vla_repeat, &cptr, &fullsize, realloc, &dlen, status);        
	          }
	          break;

	        default: 
		  /* all variable length array columns are included in this case */
	          /* gunzip the data into the correct location in the full table buffer */
	          uncompress2mem_from_mem(ptr, vla_repeat,
	              &cptr,  &fullsize, realloc, &dlen, status);              

	        } /* end of switch block */

	        free(ptr);
	  }  /* end of rmajor_repeat > 0 */
      }  /* end of loop over columns */
      
      /* now transpose the rows and columns (from cm_buffer to rm_buffer) */
      /* move each byte, in turn, from the cm_buffer to the appropriate place in the rm_buffer */
      for (ii = 0; ii < ncols; ii++) {  /* loop over columns */
	 ptr = (char *) (cm_buffer + cmajor_colstart[ii]);  /* initialize ptr to start of the column in the cm_buffer */
         if (rmajor_repeat[ii] > 0) {  /* skip columns with zero elements */
             if (coltype[ii] > 0) {  /* normal fixed length array columns */
                 if ((zctype[ii] == GZIP_2)) {  /*  need to unshuffle the bytes */

	             /* recombine the byte planes for the 2-byte, 4-byte, and 8-byte numeric columns */
	             switch (colcode[ii]) {
	
		     case 'I':
		         /* get the 1st byte of each I*2 value */
	                 for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		             cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]));  
		             for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		                 *cptr = *ptr;  /* copy 1 byte */
		                 ptr++;
		                 cptr += 2;  
			     }
			 }
		         /* get the 2nd byte of each I*2 value */
	                 for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		            cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 1);  
		            for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		                *cptr = *ptr;  /* copy 1 byte */
		                ptr++;
		                cptr += 2;  
		            }
		         }
		         break;

		   case 'J':
		   case 'E':
		       /* get the 1st byte of each 4-byte value */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]));  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 4;  
		         }
		       }
		       /* get the 2nd byte  */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 1);  
		          for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		            *cptr = *ptr;  /* copy 1 byte */
		            ptr++;
		            cptr += 4;  
		          }
		       }
		       /* get the 3rd byte  */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 2);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 4;  
		         }
		       }
		       /* get the 4th byte  */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 3);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 4;  
		         }
		       }
		       break;

		 case 'D':
		 case 'K':
		       /* get the 1st byte of each 8-byte value */
 	              for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]));  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 8;  
		         }
		       }
		       /* get the 2nd byte  */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 1);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 8;  
		         }
		       }
		       /* get the 3rd byte  */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 2);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 8;  
		         }
		       }
		       /* get the 4th byte  */
	  	       for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 3);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 8;  
		         }
		       }
		       /* get the 5th byte */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 4);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 8;  
		         }
		       }
		       /* get the 6th byte  */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 5);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 8;  
		         }
		       }
		       /* get the 7th byte  */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 6);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 8;  
		         }
		       }
		       /* get the 8th byte  */
	               for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		         cptr = rm_buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 7);  
		         for (kk = 0; kk < rmajor_repeat[ii]; kk++) {
		           *cptr = *ptr;  /* copy 1 byte */
		           ptr++;
		           cptr += 8;  
		         }
		       }
		       break;

		default: /*  should never get here */
	            ffpmsg("Error: unexpected attempt to use GZIP_2 to compress a column unsuitable data type");
		    *status = DATA_DECOMPRESSION_ERR;
                    free(rm_buffer);  free(cm_buffer);
	            return(*status);

	        }  /* end of switch  for shuffling the bytes*/

            } else {  /* not GZIP_2, don't have to shuffle bytes, so just transpose the rows and columns */

	         for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output table */
		     cptr = rm_buffer + (rmajor_colstart[ii] + jj * rmajor_colstart[ncols]);   /* addr to copy to */
		     memcpy(cptr, ptr, (size_t) rmajor_colwidth[ii]);
	 
		     ptr += (rmajor_colwidth[ii]);
		 }
	    }
        } else {  /* transpose the variable length array pointers */

              for (jj = 0; jj < rowspertile; jj++) {  /* loop over number of rows in the output uncompressed table */
	        cptr = rm_buffer + (rmajor_colstart[ii] + jj * rmajor_colstart[ncols]);   /* addr to copy to */
	        memcpy(cptr, ptr, (size_t) rmajor_colwidth[ii]);
	 
	        ptr += (rmajor_colwidth[ii]);
	      }

	      if (rmajor_colwidth[ii] == 8 ) {  /* these are P-type descriptors */
	           pdescript = (int *) (cm_buffer + cmajor_colstart[ii]);
#if BYTESWAPPED
	           ffswap4((int *) pdescript,  rowspertile * 2);  /* byte-swap the descriptor */
#endif
	      } else if (rmajor_colwidth[ii] == 16 ) {  /* these are Q-type descriptors */
	           qdescript = (LONGLONG *) (cm_buffer + cmajor_colstart[ii]);
#if BYTESWAPPED
	           ffswap8((double *) qdescript,  rowspertile * 2); /* byte-swap the descriptor */
#endif
	      } else { /* this should never happen */
	            ffpmsg("Error: Descriptor column is neither 8 nor 16 bytes wide");
                    free(rm_buffer);  free(cm_buffer);
		    *status = DATA_DECOMPRESSION_ERR;
	            return(*status);
	      }	
	      	
	      /* First, set pointer to the Q descriptors, and byte-swap them, if needed */
	      descript = (LONGLONG*) (cm_buffer + cmajor_colstart[ii] + (rmajor_colwidth[ii] * rowspertile));
#if BYTESWAPPED
	      /* byte-swap the descriptor */
	      ffswap8((double *) descript,  rowspertile * 2);
#endif

	      /* now uncompress all the individual VLAs, and */
	      /* write them to their original location in the uncompressed file */

	      for (jj = 0; jj < rowspertile; jj++)   {    /* loop over rows */
                    /* get the size and location of the compressed VLA in the compressed table */
		    cvlalen = descript[jj * 2];
		    cvlastart = descript[(jj * 2) + 1]; 
		    if (cvlalen > 0 ) {

			/* get the size and location to write the uncompressed VLA in the uncompressed table */
			if (rmajor_colwidth[ii] == 8 ) { 
			    vlalen = pdescript[jj * 2];
			    vlastart = pdescript[(jj * 2) + 1];
			} else  {
			    vlalen = qdescript[jj * 2];
			    vlastart = qdescript[(jj * 2) + 1];
			}			
			vlamemlen = (size_t) (vlalen * (-coltype[ii] / 10));  /* size of the uncompressed VLA, in bytes */

			/* allocate memory for the compressed vla */
			compressed_vla = malloc( (size_t) cvlalen);
			if (!compressed_vla) {
			    ffpmsg("Could not allocate buffer for compressed VLA");
			    free(rm_buffer);  free(cm_buffer);
			    *status = MEMORY_ALLOCATION;
			    return(*status);
			}

			/* read the compressed VLA from the heap in the input compressed table */
			bytepos = (size_t) ((infptr->Fptr)->datastart + (infptr->Fptr)->heapstart + cvlastart);
			ffmbyt(infptr, bytepos, REPORT_EOF, status);
			ffgbyt(infptr, cvlalen, compressed_vla, status);  /* read the bytes */
			/* if the VLA couldn't be compressed, just copy it directly to the output uncompressed table */
			if (cvlalen   == vlamemlen ) {
			    bytepos = (size_t) ((outfptr->Fptr)->datastart + (outfptr->Fptr)->heapstart + vlastart);
			    ffmbyt(outfptr, bytepos, IGNORE_EOF, status);
			    ffpbyt(outfptr, cvlalen, compressed_vla, status);  /* write the bytes */
			} else {  /* uncompress the VLA  */
		  
			    /* allocate memory for the uncompressed VLA */
			    uncompressed_vla =  malloc(vlamemlen);
			    if (!uncompressed_vla) {
				ffpmsg("Could not allocate buffer for uncompressed VLA");
				*status = MEMORY_ALLOCATION;
			        free(compressed_vla); free(rm_buffer);  free(cm_buffer);
				return(*status);
			    }
			    /* uncompress the VLA with the appropriate algorithm */
			    if (zctype[ii] == RICE_1) {

				if (-coltype[ii] == TSHORT) {
				    dlen = fits_rdecomp_short((unsigned char *) compressed_vla, (int) cvlalen, (unsigned short *)uncompressed_vla, 
					(int) vlalen, 32);
#if BYTESWAPPED
				   ffswap2((short *) uncompressed_vla, (long) vlalen); 
#endif
				} else if (-coltype[ii] == TLONG) {
				    dlen = fits_rdecomp((unsigned char *) compressed_vla, (int) cvlalen, (unsigned int *)uncompressed_vla, 
					(int) vlalen, 32);
#if BYTESWAPPED
				   ffswap4((int *) uncompressed_vla, (long) vlalen); 
#endif
 				} else if (-coltype[ii] == TBYTE) {
				    dlen = fits_rdecomp_byte((unsigned char *) compressed_vla, (int) cvlalen, (unsigned char *) uncompressed_vla, 
					(int) vlalen, 32);
				} else {
				    /* this should not happen */
				    ffpmsg(" Error: cannot uncompress this column type with the RICE algorthm");

				    *status = DATA_DECOMPRESSION_ERR;
			            free(uncompressed_vla); free(compressed_vla); free(rm_buffer);  free(cm_buffer);
				    return(*status);
				}  

			    } else if (zctype[ii] == GZIP_1 || zctype[ii] == GZIP_2){  

			       /*: gzip uncompress the array of bytes */
			       uncompress2mem_from_mem( compressed_vla, (size_t) cvlalen, &uncompressed_vla, &vlamemlen, realloc, &vlamemlen, status);

			       if (zctype[ii] == GZIP_2 ) {
				  /* unshuffle the bytes after ungzipping them */
				  if ( (int) (-coltype[ii] / 10) == 2) {
				    fits_unshuffle_2bytes((char *) uncompressed_vla, vlalen, status);
				  } else if ( (int) (-coltype[ii] / 10) == 4) {
				    fits_unshuffle_4bytes((char *) uncompressed_vla, vlalen, status);
				  } else if ( (int) (-coltype[ii] / 10) == 8) {
				    fits_unshuffle_8bytes((char *) uncompressed_vla, vlalen, status);
				  }
			       }

			    } else {
				/* this should not happen */
				ffpmsg(" Error: unknown compression algorthm");
			        free(uncompressed_vla); free(compressed_vla); free(rm_buffer);  free(cm_buffer);
				*status = DATA_COMPRESSION_ERR;
				return(*status);
			    }  		     

			    bytepos = (size_t) ((outfptr->Fptr)->datastart + (outfptr->Fptr)->heapstart + vlastart);
			    ffmbyt(outfptr, bytepos, IGNORE_EOF, status);
			    ffpbyt(outfptr, vlamemlen, uncompressed_vla, status);  /* write the bytes */
			    
			     free(uncompressed_vla);
			}  /* end of uncompress VLA */

		        free(compressed_vla);

		  } /* end of vlalen > 0 */
		} /* end of loop over rowspertile */

              } /* end of variable length array section*/
           }  /* end of if column repeat > 0 */
        }  /* end of ncols loop */

        /* copy the buffer of data to the output data unit */

        if (datastart == 0) fits_get_hduaddrll(outfptr, &headstart, &datastart, &dataend, status);        

        ffmbyt(outfptr, datastart, 1, status);
        ffpbyt(outfptr, naxis1 * rowspertile, rm_buffer, status);

	/* increment pointers for next tile */
	rowstart += rowspertile;
        rowsremain -= rowspertile;
	datastart += (naxis1 * rowspertile);
	if (rowspertile > rowsremain) rowspertile = (long) rowsremain;

    }  /* end of while rows still remain */

    free(rm_buffer);
    free(cm_buffer);
	
    /* reset internal table structure parameters */
    fits_set_hdustruc(outfptr, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
static int fits_shuffle_2bytes(char *heap, LONGLONG length, int *status)

/* shuffle the bytes in an array of 2-byte integers in the heap */

{
    LONGLONG ii;
    char *ptr, *cptr, *heapptr;
    
    ptr = malloc((size_t) (length * 2));
    heapptr = heap;
    cptr = ptr;
    
    for (ii = 0; ii < length; ii++) {
       *cptr = *heapptr;
       heapptr++;
       *(cptr + length) = *heapptr;
       heapptr++;
       cptr++;
    }
         
    memcpy(heap, ptr, (size_t) (length * 2));
    free(ptr);
    return(*status);
}
/*--------------------------------------------------------------------------*/
static int fits_shuffle_4bytes(char *heap, LONGLONG length, int *status)

/* shuffle the bytes in an array of 4-byte integers or floats  */

{
    LONGLONG ii;
    char *ptr, *cptr, *heapptr;
    
    ptr = malloc((size_t) (length * 4));
    if (!ptr) {
      ffpmsg("malloc failed\n");
      return(*status);
    }

    heapptr = heap;
    cptr = ptr;
 
    for (ii = 0; ii < length; ii++) {
       *cptr = *heapptr;
       heapptr++;
       *(cptr + length) = *heapptr;
       heapptr++;
       *(cptr + (length * 2)) = *heapptr;
       heapptr++;
       *(cptr + (length * 3)) = *heapptr;
       heapptr++;
       cptr++;
    }
        
    memcpy(heap, ptr, (size_t) (length * 4));
    free(ptr);

    return(*status);
}
/*--------------------------------------------------------------------------*/
static int fits_shuffle_8bytes(char *heap, LONGLONG length, int *status)

/* shuffle the bytes in an array of 8-byte integers or doubles in the heap */

{
    LONGLONG ii;
    char *ptr, *cptr, *heapptr;
    
    ptr = calloc(1, (size_t) (length * 8));
    heapptr = heap;
    
/* for some bizarre reason this loop fails to compile under OpenSolaris using
   the proprietary SunStudioExpress C compiler;  use the following equivalent
   loop instead.
   
    cptr = ptr;

    for (ii = 0; ii < length; ii++) {
       *cptr = *heapptr;
       heapptr++;
       *(cptr + length) = *heapptr;
       heapptr++;
       *(cptr + (length * 2)) = *heapptr;
       heapptr++;
       *(cptr + (length * 3)) = *heapptr;
       heapptr++;
       *(cptr + (length * 4)) = *heapptr;
       heapptr++;
       *(cptr + (length * 5)) = *heapptr;
       heapptr++;
       *(cptr + (length * 6)) = *heapptr;
       heapptr++;
       *(cptr + (length * 7)) = *heapptr;
       heapptr++;
       cptr++;
     }
*/
     for (ii = 0; ii < length; ii++) {
        cptr = ptr + ii;

        *cptr = *heapptr;

        heapptr++;
        cptr += length;
        *cptr = *heapptr;

        heapptr++;
        cptr += length;
        *cptr = *heapptr;

        heapptr++;
        cptr += length;
        *cptr = *heapptr;

        heapptr++;
        cptr += length;
        *cptr = *heapptr;

        heapptr++;
        cptr += length;
        *cptr = *heapptr;

        heapptr++;
        cptr += length;
        *cptr = *heapptr;

        heapptr++;
        cptr += length;
        *cptr = *heapptr;

        heapptr++;
     }
        
    memcpy(heap, ptr, (size_t) (length * 8));
    free(ptr);
 
    return(*status);
}
/*--------------------------------------------------------------------------*/
static int fits_unshuffle_2bytes(char *heap, LONGLONG length, int *status)

/* unshuffle the bytes in an array of 2-byte integers */

{
    LONGLONG ii;
    char *ptr, *cptr, *heapptr;
    
    ptr = malloc((size_t) (length * 2));
    heapptr = heap + (2 * length) - 1;
    cptr = ptr + (2 * length) - 1;
    
    for (ii = 0; ii < length; ii++) {
       *cptr = *heapptr;
       cptr--;
       *cptr = *(heapptr - length);
       cptr--;
       heapptr--;
    }
         
    memcpy(heap, ptr, (size_t) (length * 2));
    free(ptr);
    return(*status);
}
/*--------------------------------------------------------------------------*/
static int fits_unshuffle_4bytes(char *heap, LONGLONG length, int *status)

/* unshuffle the bytes in an array of 4-byte integers or floats */

{
    LONGLONG ii;
    char *ptr, *cptr, *heapptr;
    
    ptr = malloc((size_t) (length * 4));
    heapptr = heap + (4 * length) -1;
    cptr = ptr + (4 * length) -1;
 
    for (ii = 0; ii < length; ii++) {
       *cptr = *heapptr;
       cptr--;
       *cptr = *(heapptr - length);
       cptr--;
       *cptr = *(heapptr - (2 * length));
       cptr--;
       *cptr = *(heapptr - (3 * length));
       cptr--;
       heapptr--;
    }
        
    memcpy(heap, ptr, (size_t) (length * 4));
    free(ptr);
    return(*status);
}
/*--------------------------------------------------------------------------*/
static int fits_unshuffle_8bytes(char *heap, LONGLONG length, int *status)

/* unshuffle the bytes in an array of 8-byte integers or doubles */

{
    LONGLONG ii;
    char *ptr, *cptr, *heapptr;
    
    ptr = malloc((size_t) (length * 8));
    heapptr = heap + (8 * length) - 1;
    cptr = ptr + (8 * length)  -1;
    
    for (ii = 0; ii < length; ii++) {
       *cptr = *heapptr;
       cptr--;
       *cptr = *(heapptr - length);
       cptr--;
       *cptr = *(heapptr - (2 * length));
       cptr--;
       *cptr = *(heapptr - (3 * length));
       cptr--;
       *cptr = *(heapptr - (4 * length));
       cptr--;
       *cptr = *(heapptr - (5 * length));
       cptr--;
       *cptr = *(heapptr - (6 * length));
       cptr--;
       *cptr = *(heapptr - (7 * length));
       cptr--;
       heapptr--;
    }
       
    memcpy(heap, ptr, (size_t) (length * 8));
    free(ptr);
    return(*status);
}
healpy-1.10.3/cfitsio/imcopy.c0000664000175000017500000002223013010375005016423 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include "fitsio.h"

int main(int argc, char *argv[])
{
    fitsfile *infptr, *outfptr;   /* FITS file pointers defined in fitsio.h */
    int status = 0, tstatus, ii = 1, iteration = 0, single = 0, hdupos;
    int hdutype, bitpix, bytepix, naxis = 0, nkeys, datatype = 0, anynul;
    long naxes[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
    long first, totpix = 0, npix;
    double *array, bscale = 1.0, bzero = 0.0, nulval = 0.;
    char card[81];

    if (argc != 3)
    {
 printf("\n");
 printf("Usage:  imcopy inputImage outputImage[compress]\n");
 printf("\n");
 printf("Copy an input image to an output image, optionally compressing\n");
 printf("or uncompressing the image in the process.  If the [compress]\n");
 printf("qualifier is appended to the output file name then the input image\n");
 printf("will be compressed using the tile-compressed format.  In this format,\n");
 printf("the image is divided into rectangular tiles and each tile of pixels\n");
 printf("is compressed and stored in a variable-length row of a binary table.\n");
 printf("If the [compress] qualifier is omitted, and the input image is\n");
 printf("in tile-compressed format, then the output image will be uncompressed.\n");
 printf("\n");
 printf("If an extension name or number is appended to the input file name, \n");
 printf("enclosed in square brackets, then only that single extension will be\n");
 printf("copied to the output file.  Otherwise, every extension in the input file\n");
 printf("will be processed in turn and copied to the output file.\n");
 printf("\n");
 printf("Examples:\n");
 printf("\n");
 printf("1)  imcopy image.fit 'cimage.fit[compress]'\n");
 printf("\n");
 printf("    This compresses the input image using the default parameters, i.e.,\n");
 printf("    using the Rice compression algorithm and using row by row tiles.\n");
 printf("\n");
 printf("2)  imcopy cimage.fit image2.fit\n");
 printf("\n");
 printf("    This uncompresses the image created in the first example.\n");
 printf("    image2.fit should be identical to image.fit if the image\n");
 printf("    has an integer datatype.  There will be small differences\n");
 printf("    in the pixel values if it is a floating point image.\n");
 printf("\n");
 printf("3)  imcopy image.fit 'cimage.fit[compress GZIP 100,100;q 16]'\n");
 printf("\n");
 printf("    This compresses the input image using the following parameters:\n");
 printf("         GZIP compression algorithm;\n");
 printf("         100 X 100 pixel compression tiles;\n");
 printf("         quantization level = 16 (only used with floating point images)\n");
 printf("\n");
 printf("The full syntax of the compression qualifier is:\n");
 printf("    [compress ALGORITHM TDIM1,TDIM2,...; q QLEVEL s SCALE]\n");
 printf("where the allowed ALGORITHM values are:\n");
 printf("      Rice, HCOMPRESS, HSCOMPRESS, GZIP, or PLIO. \n");
 printf("       (HSCOMPRESS is a variant of HCOMPRESS in which a small\n");
 printf("        amount of smoothing is applied to the uncompressed image\n");
 printf("        to help suppress blocky compression artifacts in the image\n");
 printf("        when using large values for the 'scale' parameter).\n");
 printf("TDIMn is the size of the compression tile in each dimension,\n");
 printf("\n");
 printf("QLEVEL specifies the quantization level when converting a floating\n");
 printf("point image into integers, prior to compressing the image.  The\n");
 printf("default value = 16, which means the image will be quantized into\n");
 printf("integer levels that are spaced at intervals of sigma/16., where \n");
 printf("sigma is the estimated noise level in background areas of the image.\n");
 printf("If QLEVEL is negative, this means use the absolute value for the\n");
 printf("quantization spacing (e.g. 'q -0.005' means quantize the floating\n");
 printf("point image such that the scaled integers represent steps of 0.005\n");
 printf("in the original image).\n");
 printf("\n");
 printf("SCALE is the integer scale factor that only applies to the HCOMPRESS\n");
 printf("algorithm.  The default value SCALE = 0 forces the image to be\n");
 printf("losslessly compressed; Greater amounts of lossy compression (resulting\n");
 printf("in smaller compressed files) can be specified with larger SCALE values.\n");
 printf("\n");
 printf("\n");
 printf("Note that it may be necessary to enclose the file names\n");
 printf("in single quote characters on the Unix command line.\n");
      return(0);
    }

    /* Open the input file and create output file */
    fits_open_file(&infptr, argv[1], READONLY, &status);
    fits_create_file(&outfptr, argv[2], &status);

    if (status != 0) {    
        fits_report_error(stderr, status);
        return(status);
    }

    fits_get_hdu_num(infptr, &hdupos);  /* Get the current HDU position */

    /* Copy only a single HDU if a specific extension was given */ 
    if (hdupos != 1 || strchr(argv[1], '[')) single = 1;

    for (; !status; hdupos++)  /* Main loop through each extension */
    {

      fits_get_hdu_type(infptr, &hdutype, &status);

      if (hdutype == IMAGE_HDU) {

          /* get image dimensions and total number of pixels in image */
          for (ii = 0; ii < 9; ii++)
              naxes[ii] = 1;

          fits_get_img_param(infptr, 9, &bitpix, &naxis, naxes, &status);

          totpix = naxes[0] * naxes[1] * naxes[2] * naxes[3] * naxes[4]
             * naxes[5] * naxes[6] * naxes[7] * naxes[8];
      }

      if (hdutype != IMAGE_HDU || naxis == 0 || totpix == 0) { 

          /* just copy tables and null images */
          fits_copy_hdu(infptr, outfptr, 0, &status);

      } else {

          /* Explicitly create new image, to support compression */
          fits_create_img(outfptr, bitpix, naxis, naxes, &status);
          if (status) {
                 fits_report_error(stderr, status);
                 return(status);
          }

          if (fits_is_compressed_image(outfptr, &status)) {
              /* write default EXTNAME keyword if it doesn't already exist */
	      tstatus = 0;
              fits_read_card(infptr, "EXTNAME", card, &tstatus);
	      if (tstatus) {
	         strcpy(card, "EXTNAME = 'COMPRESSED_IMAGE'   / name of this binary table extension");
	         fits_write_record(outfptr, card, &status);
	      }
          }
	  	    
          /* copy all the user keywords (not the structural keywords) */
          fits_get_hdrspace(infptr, &nkeys, NULL, &status); 

          for (ii = 1; ii <= nkeys; ii++) {
              fits_read_record(infptr, ii, card, &status);
              if (fits_get_keyclass(card) > TYP_CMPRS_KEY)
                  fits_write_record(outfptr, card, &status);
          }

              /* delete default EXTNAME keyword if it exists */
/*
          if (!fits_is_compressed_image(outfptr, &status)) {
	      tstatus = 0;
              fits_read_key(outfptr, TSTRING, "EXTNAME", card, NULL, &tstatus);
	      if (!tstatus) {
	         if (strcmp(card, "COMPRESSED_IMAGE") == 0)
	            fits_delete_key(outfptr, "EXTNAME", &status);
	      }
          }
*/
	  
          switch(bitpix) {
              case BYTE_IMG:
                  datatype = TBYTE;
                  break;
              case SHORT_IMG:
                  datatype = TSHORT;
                  break;
              case LONG_IMG:
                  datatype = TINT;
                  break;
              case FLOAT_IMG:
                  datatype = TFLOAT;
                  break;
              case DOUBLE_IMG:
                  datatype = TDOUBLE;
                  break;
          }

          bytepix = abs(bitpix) / 8;

          npix = totpix;
          iteration = 0;

          /* try to allocate memory for the entire image */
          /* use double type to force memory alignment */
          array = (double *) calloc(npix, bytepix);

          /* if allocation failed, divide size by 2 and try again */
          while (!array && iteration < 10)  {
              iteration++;
              npix = npix / 2;
              array = (double *) calloc(npix, bytepix);
          }

          if (!array)  {
              printf("Memory allocation error\n");
              return(0);
          }

          /* turn off any scaling so that we copy the raw pixel values */
          fits_set_bscale(infptr,  bscale, bzero, &status);
          fits_set_bscale(outfptr, bscale, bzero, &status);

          first = 1;
          while (totpix > 0 && !status)
          {
             /* read all or part of image then write it back to the output file */
             fits_read_img(infptr, datatype, first, npix, 
                     &nulval, array, &anynul, &status);

             fits_write_img(outfptr, datatype, first, npix, array, &status);
             totpix = totpix - npix;
             first  = first  + npix;
          }
          free(array);
      }

      if (single) break;  /* quit if only copying a single HDU */
      fits_movrel_hdu(infptr, 1, NULL, &status);  /* try to move to next HDU */
    }

    if (status == END_OF_FILE)  status = 0; /* Reset after normal error */

    fits_close_file(outfptr,  &status);
    fits_close_file(infptr, &status);

    /* if error occurred, print out error message */
    if (status)
       fits_report_error(stderr, status);
    return(status);
}
healpy-1.10.3/cfitsio/install-sh0000775000175000017500000001272112761067631017006 0ustar  zoncazonca00000000000000#! /bin/sh
#
# install - install a program, script, or datafile
# This comes from X11R5 (mit/util/scripts/install.sh).
#
# Copyright 1991 by the Massachusetts Institute of Technology
#
# Permission to use, copy, modify, distribute, and sell this software and its
# documentation for any purpose is hereby granted without fee, provided that
# the above copyright notice appear in all copies and that both that
# copyright notice and this permission notice appear in supporting
# documentation, and that the name of M.I.T. not be used in advertising or
# publicity pertaining to distribution of the software without specific,
# written prior permission.  M.I.T. makes no representations about the
# suitability of this software for any purpose.  It is provided "as is"
# without express or implied warranty.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# `make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch.  It can only install one file at a time, a restriction
# shared with many OS's install programs.


# set DOITPROG to echo to test this script

# Don't use :- since 4.3BSD and earlier shells don't like it.
doit="${DOITPROG-}"


# put in absolute paths if you don't have them in your path; or use env. vars.

mvprog="${MVPROG-mv}"
cpprog="${CPPROG-cp}"
chmodprog="${CHMODPROG-chmod}"
chownprog="${CHOWNPROG-chown}"
chgrpprog="${CHGRPPROG-chgrp}"
stripprog="${STRIPPROG-strip}"
rmprog="${RMPROG-rm}"
mkdirprog="${MKDIRPROG-mkdir}"

transformbasename=""
transform_arg=""
instcmd="$mvprog"
chmodcmd="$chmodprog 0755"
chowncmd=""
chgrpcmd=""
stripcmd=""
rmcmd="$rmprog -f"
mvcmd="$mvprog"
src=""
dst=""
dir_arg=""

while [ x"$1" != x ]; do
    case $1 in
	-c) instcmd="$cpprog"
	    shift
	    continue;;

	-d) dir_arg=true
	    shift
	    continue;;

	-m) chmodcmd="$chmodprog $2"
	    shift
	    shift
	    continue;;

	-o) chowncmd="$chownprog $2"
	    shift
	    shift
	    continue;;

	-g) chgrpcmd="$chgrpprog $2"
	    shift
	    shift
	    continue;;

	-s) stripcmd="$stripprog"
	    shift
	    continue;;

	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
	    shift
	    continue;;

	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
	    shift
	    continue;;

	*)  if [ x"$src" = x ]
	    then
		src=$1
	    else
		# this colon is to work around a 386BSD /bin/sh bug
		:
		dst=$1
	    fi
	    shift
	    continue;;
    esac
done

if [ x"$src" = x ]
then
	echo "install:	no input file specified"
	exit 1
else
	true
fi

if [ x"$dir_arg" != x ]; then
	dst=$src
	src=""
	
	if [ -d $dst ]; then
		instcmd=:
	else
		instcmd=mkdir
	fi
else

# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
# might cause directories to be created, which would be especially bad 
# if $src (and thus $dsttmp) contains '*'.

	if [ -f $src -o -d $src ]
	then
		true
	else
		echo "install:  $src does not exist"
		exit 1
	fi
	
	if [ x"$dst" = x ]
	then
		echo "install:	no destination specified"
		exit 1
	else
		true
	fi

# If destination is a directory, append the input filename; if your system
# does not like double slashes in filenames, you may need to add some logic

	if [ -d $dst ]
	then
		dst="$dst"/`basename $src`
	else
		true
	fi
fi

## this sed command emulates the dirname command
dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`

# Make sure that the destination directory exists.
#  this part is taken from Noah Friedman's mkinstalldirs script

# Skip lots of stat calls in the usual case.
if [ ! -d "$dstdir" ]; then
defaultIFS='	
'
IFS="${IFS-${defaultIFS}}"

oIFS="${IFS}"
# Some sh's can't handle IFS=/ for some reason.
IFS='%'
set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
IFS="${oIFS}"

pathcomp=''

while [ $# -ne 0 ] ; do
	pathcomp="${pathcomp}${1}"
	shift

	if [ ! -d "${pathcomp}" ] ;
        then
		$mkdirprog "${pathcomp}"
	else
		true
	fi

	pathcomp="${pathcomp}/"
done
fi

if [ x"$dir_arg" != x ]
then
	$doit $instcmd $dst &&

	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
else

# If we're going to rename the final executable, determine the name now.

	if [ x"$transformarg" = x ] 
	then
		dstfile=`basename $dst`
	else
		dstfile=`basename $dst $transformbasename | 
			sed $transformarg`$transformbasename
	fi

# don't allow the sed command to completely eliminate the filename

	if [ x"$dstfile" = x ] 
	then
		dstfile=`basename $dst`
	else
		true
	fi

# Make a temp file name in the proper directory.

	dsttmp=$dstdir/#inst.$$#

# Move or copy the file name to the temp name

	$doit $instcmd $src $dsttmp &&

	trap "rm -f ${dsttmp}" 0 &&

# and set any options; do chmod last to preserve setuid bits

# If any of these fail, we abort the whole thing.  If we want to
# ignore errors from any of these, just make sure not to ignore
# errors from the above "$doit $instcmd $src $dsttmp" command.

	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&

# Now rename the file to the real destination.

	$doit $rmcmd -f $dstdir/$dstfile &&
	$doit $mvcmd $dsttmp $dstdir/$dstfile 

fi &&


exit 0
healpy-1.10.3/cfitsio/iraffits.c0000664000175000017500000016015413010375005016742 0ustar  zoncazonca00000000000000/*------------------------------------------------------------------------*/
/*                                                                        */
/*  These routines have been modified by William Pence for use by CFITSIO */
/*        The original files were provided by Doug Mink                   */
/*------------------------------------------------------------------------*/

/* File imhfile.c
 * August 6, 1998
 * By Doug Mink, based on Mike VanHilst's readiraf.c

 * Module:      imhfile.c (IRAF .imh image file reading and writing)
 * Purpose:     Read and write IRAF image files (and translate headers)
 * Subroutine:  irafrhead (filename, lfhead, fitsheader, lihead)
 *              Read IRAF image header
 * Subroutine:  irafrimage (fitsheader)
 *              Read IRAF image pixels (call after irafrhead)
 * Subroutine:	same_path (pixname, hdrname)
 *		Put filename and header path together
 * Subroutine:	iraf2fits (hdrname, irafheader, nbiraf, nbfits)
 *		Convert IRAF image header to FITS image header
 * Subroutine:  irafgeti4 (irafheader, offset)
 *		Get 4-byte integer from arbitrary part of IRAF header
 * Subroutine:  irafgetc2 (irafheader, offset)
 *		Get character string from arbitrary part of IRAF v.1 header
 * Subroutine:  irafgetc (irafheader, offset)
 *		Get character string from arbitrary part of IRAF header
 * Subroutine:  iraf2str (irafstring, nchar)
 * 		Convert 2-byte/char IRAF string to 1-byte/char string
 * Subroutine:	irafswap (bitpix,string,nbytes)
 *		Swap bytes in string in place, with FITS bits/pixel code
 * Subroutine:	irafswap2 (string,nbytes)
 *		Swap bytes in string in place
 * Subroutine	irafswap4 (string,nbytes)
 *		Reverse bytes of Integer*4 or Real*4 vector in place
 * Subroutine	irafswap8 (string,nbytes)
 *		Reverse bytes of Real*8 vector in place


 * Copyright:   2000 Smithsonian Astrophysical Observatory
 *              You may do anything you like with this file except remove
 *              this copyright.  The Smithsonian Astrophysical Observatory
 *              makes no representations about the suitability of this
 *              software for any purpose.  It is provided "as is" without
 *              express or implied warranty.
 */

#include 		/* define stderr, FD, and NULL */
#include 
#include   /* stddef.h is apparently needed to define size_t */
#include 

#define FILE_NOT_OPENED 104

/* Parameters from iraf/lib/imhdr.h for IRAF version 1 images */
#define SZ_IMPIXFILE	 79		/* name of pixel storage file */
#define SZ_IMHDRFILE	 79   		/* length of header storage file */
#define SZ_IMTITLE	 79		/* image title string */
#define LEN_IMHDR	2052		/* length of std header */

/* Parameters from iraf/lib/imhdr.h for IRAF version 2 images */
#define	SZ_IM2PIXFILE	255		/* name of pixel storage file */
#define	SZ_IM2HDRFILE	255		/* name of header storage file */
#define	SZ_IM2TITLE	383		/* image title string */
#define LEN_IM2HDR	2046		/* length of std header */

/* Offsets into header in bytes for parameters in IRAF version 1 images */
#define IM_HDRLEN	 12		/* Length of header in 4-byte ints */
#define IM_PIXTYPE       16             /* Datatype of the pixels */
#define IM_NDIM          20             /* Number of dimensions */
#define IM_LEN           24             /* Length (as stored) */
#define IM_PHYSLEN       52             /* Physical length (as stored) */
#define IM_PIXOFF        88             /* Offset of the pixels */
#define IM_CTIME        108             /* Time of image creation */
#define IM_MTIME        112             /* Time of last modification */
#define IM_LIMTIME      116             /* Time of min,max computation */
#define IM_MAX          120             /* Maximum pixel value */
#define IM_MIN          124             /* Maximum pixel value */
#define IM_PIXFILE      412             /* Name of pixel storage file */
#define IM_HDRFILE      572             /* Name of header storage file */
#define IM_TITLE        732             /* Image name string */

/* Offsets into header in bytes for parameters in IRAF version 2 images */
#define IM2_HDRLEN	  6		/* Length of header in 4-byte ints */
#define IM2_PIXTYPE      10             /* Datatype of the pixels */
#define IM2_SWAPPED      14             /* Pixels are byte swapped */
#define IM2_NDIM         18             /* Number of dimensions */
#define IM2_LEN          22             /* Length (as stored) */
#define IM2_PHYSLEN      50             /* Physical length (as stored) */
#define IM2_PIXOFF       86             /* Offset of the pixels */
#define IM2_CTIME       106             /* Time of image creation */
#define IM2_MTIME       110             /* Time of last modification */
#define IM2_LIMTIME     114             /* Time of min,max computation */
#define IM2_MAX         118             /* Maximum pixel value */
#define IM2_MIN         122             /* Maximum pixel value */
#define IM2_PIXFILE     126             /* Name of pixel storage file */
#define IM2_HDRFILE     382             /* Name of header storage file */
#define IM2_TITLE       638             /* Image name string */

/* Codes from iraf/unix/hlib/iraf.h */
#define	TY_CHAR		2
#define	TY_SHORT	3
#define	TY_INT		4
#define	TY_LONG		5
#define	TY_REAL		6
#define	TY_DOUBLE	7
#define	TY_COMPLEX	8
#define TY_POINTER      9
#define TY_STRUCT       10
#define TY_USHORT       11
#define TY_UBYTE        12

#define LEN_PIXHDR	1024
#define MAXINT  2147483647 /* Biggest number that can fit in long */

static int isirafswapped(char *irafheader, int offset);
static int irafgeti4(char *irafheader, int offset);
static char *irafgetc2(char *irafheader, int offset, int nc);
static char *irafgetc(char *irafheader,	int offset, int	nc);
static char *iraf2str(char *irafstring, int nchar);
static char *irafrdhead(const char *filename, int *lihead);
static int irafrdimage (char **buffptr, size_t *buffsize,
    size_t *filesize, int *status);
static int iraftofits (char *hdrname, char *irafheader, int nbiraf,
    char **buffptr, size_t *nbfits, size_t *fitssize, int *status);
static char *same_path(char *pixname, const char *hdrname);

static int swaphead=0;	/* =1 to swap data bytes of IRAF header values */
static int swapdata=0;  /* =1 to swap bytes in IRAF data pixels */

static void irafswap(int bitpix, char *string, int nbytes);
static void irafswap2(char *string, int nbytes);
static void irafswap4(char *string, int nbytes);
static void irafswap8(char *string, int nbytes);
static int pix_version (char *irafheader);
static int irafncmp (char *irafheader, char *teststring, int nc);
static int machswap(void);
static int head_version (char *irafheader);
static int hgeti4(char* hstring, char* keyword, int* val);
static int hgets(char* hstring, char* keyword, int lstr, char* string);
static char* hgetc(char* hstring, char* keyword);
static char* ksearch(char* hstring, char* keyword);
static char *blsearch (char* hstring, char* keyword);	
static char *strsrch (char* s1,	char* s2);
static char *strnsrch (	char* s1,char* s2,int ls1);
static void hputi4(char* hstring,char* keyword,	int ival);
static void hputs(char* hstring,char* keyword,char* cval);
static void hputcom(char* hstring,char* keyword,char* comment);
static void hputl(char* hstring,char* keyword,int lval);
static void hputc(char* hstring,char* keyword,char* cval);
static int getirafpixname (const char *hdrname, char *irafheader, char *pixfilename, int *status);
int iraf2mem(char *filename, char **buffptr, size_t *buffsize, 
      size_t *filesize, int *status);

void ffpmsg(const char *err_message);

/* CFITS_API is defined below for use on Windows systems.  */
/* It is used to identify the public functions which should be exported. */
/* This has no effect on non-windows platforms where "WIN32" is not defined */

/* this is only needed to export the "fits_delete_iraf_file" symbol, which */
/* is called in fpackutil.c (and perhaps in other applications programs) */

#if defined (WIN32)
  #if defined(cfitsio_EXPORTS)
    #define CFITS_API __declspec(dllexport)
  #else
    #define CFITS_API //__declspec(dllimport)
  #endif /* CFITS_API */
#else /* defined (WIN32) */
 #define CFITS_API
#endif

int CFITS_API fits_delete_iraf_file(const char *filename, int *status);


/*--------------------------------------------------------------------------*/
int fits_delete_iraf_file(const char *filename,  /* name of input file      */
             int *status)                        /* IO - error status       */

/*
   Delete the iraf .imh header file and the associated .pix data file
*/
{
    char *irafheader;
    int lenirafhead;

    char pixfilename[SZ_IM2PIXFILE+1];

    /* read IRAF header into dynamically created char array (free it later!) */
    irafheader = irafrdhead(filename, &lenirafhead);

    if (!irafheader)
    {
	return(*status = FILE_NOT_OPENED);
    }

    getirafpixname (filename, irafheader, pixfilename, status);

    /* don't need the IRAF header any more */
    free(irafheader);

    if (*status > 0)
       return(*status);

    remove(filename);
    remove(pixfilename);
    
    return(*status);
}

/*--------------------------------------------------------------------------*/
int iraf2mem(char *filename,     /* name of input file                 */
             char **buffptr,     /* O - memory pointer (initially NULL)    */
             size_t *buffsize,   /* O - size of mem buffer, in bytes        */
             size_t *filesize,   /* O - size of FITS file, in bytes         */
             int *status)        /* IO - error status                       */

/*
   Driver routine that reads an IRAF image into memory, also converting
   it into FITS format.
*/
{
    char *irafheader;
    int lenirafhead;

    *buffptr = NULL;
    *buffsize = 0;
    *filesize = 0;

    /* read IRAF header into dynamically created char array (free it later!) */
    irafheader = irafrdhead(filename, &lenirafhead);

    if (!irafheader)
    {
	return(*status = FILE_NOT_OPENED);
    }

    /* convert IRAF header to FITS header in memory */
    iraftofits(filename, irafheader, lenirafhead, buffptr, buffsize, filesize,
               status);

    /* don't need the IRAF header any more */
    free(irafheader);

    if (*status > 0)
       return(*status);

    *filesize = (((*filesize - 1) / 2880 ) + 1 ) * 2880; /* multiple of 2880 */

    /* append the image data onto the FITS header */
    irafrdimage(buffptr, buffsize, filesize, status);

    return(*status);
}

/*--------------------------------------------------------------------------*/
/* Subroutine:	irafrdhead  (was irafrhead in D. Mink's original code)
 * Purpose:	Open and read the iraf .imh file.
 * Returns:	NULL if failure, else pointer to IRAF .imh image header
 * Notes:	The imhdr format is defined in iraf/lib/imhdr.h, some of
 *		which defines or mimicked, above.
 */

static char *irafrdhead (
    const char *filename,  /* Name of IRAF header file */
    int *lihead)           /* Length of IRAF image header in bytes (returned) */
{
    FILE *fd;
    int nbr;
    char *irafheader;
    char errmsg[81];
    long nbhead;
    int nihead;

    *lihead = 0;

    /* open the image header file */
    fd = fopen (filename, "rb");
    if (fd == NULL) {
        ffpmsg("unable to open IRAF header file:");
        ffpmsg(filename);
	return (NULL);
	}

    /* Find size of image header file */
    if (fseek(fd, 0, 2) != 0)  /* move to end of the file */
    {
        ffpmsg("IRAFRHEAD: cannot seek in file:");
        ffpmsg(filename);
        return(NULL);
    }

    nbhead = ftell(fd);     /* position = size of file */
    if (nbhead < 0)
    {
        ffpmsg("IRAFRHEAD: cannot get pos. in file:");
        ffpmsg(filename);
        return(NULL);
    }

    if (fseek(fd, 0, 0) != 0) /* move back to beginning */
    {
        ffpmsg("IRAFRHEAD: cannot seek to beginning of file:");
        ffpmsg(filename);
        return(NULL);
    }

    /* allocate initial sized buffer */
    nihead = nbhead + 5000;
    irafheader = (char *) calloc (1, nihead);
    if (irafheader == NULL) {
	sprintf(errmsg, "IRAFRHEAD Cannot allocate %d-byte header",
		      nihead);
        ffpmsg(errmsg);
        ffpmsg(filename);
	return (NULL);
	}
    *lihead = nihead;

    /* Read IRAF header */
    nbr = fread (irafheader, 1, nbhead, fd);
    fclose (fd);

    /* Reject if header less than minimum length */
    if (nbr < LEN_PIXHDR) {
	sprintf(errmsg, "IRAFRHEAD header file: %d / %d bytes read.",
		      nbr,LEN_PIXHDR);
        ffpmsg(errmsg);
        ffpmsg(filename);
	free (irafheader);
	return (NULL);
	}

    return (irafheader);
}
/*--------------------------------------------------------------------------*/
static int irafrdimage (
    char **buffptr,	/* FITS image header (filled) */
    size_t *buffsize,      /* allocated size of the buffer */
    size_t *filesize,      /* actual size of the FITS file */
    int *status)
{
    FILE *fd;
    char *bang;
    int nax = 1, naxis1 = 1, naxis2 = 1, naxis3 = 1, naxis4 = 1, npaxis1 = 1, npaxis2;
    int bitpix, bytepix, i;
    char *fitsheader, *image;
    int nbr, nbimage, nbaxis, nbl, nbdiff;
    char *pixheader;
    char *linebuff;
    int imhver, lpixhead = 0;
    char pixname[SZ_IM2PIXFILE+1];
    char errmsg[81];
    size_t newfilesize;
 
    fitsheader = *buffptr;           /* pointer to start of header */

    /* Convert pixel file name to character string */
    hgets (fitsheader, "PIXFILE", SZ_IM2PIXFILE, pixname);
    hgeti4 (fitsheader, "PIXOFF", &lpixhead);

    /* Open pixel file, ignoring machine name if present */
    if ((bang = strchr (pixname, '!')) != NULL )
	fd = fopen (bang + 1, "rb");
    else
	fd = fopen (pixname, "rb");

    /* Print error message and exit if pixel file is not found */
    if (!fd) {
        ffpmsg("IRAFRIMAGE: Cannot open IRAF pixel file:");
        ffpmsg(pixname);
	return (*status = FILE_NOT_OPENED);
	}

    /* Read pixel header */
    pixheader = (char *) calloc (lpixhead, 1);
    if (pixheader == NULL) {
            ffpmsg("IRAFRIMAGE: Cannot alloc memory for pixel header");
            ffpmsg(pixname);
            fclose (fd);
	    return (*status = FILE_NOT_OPENED);
	}
    nbr = fread (pixheader, 1, lpixhead, fd);

    /* Check size of pixel header */
    if (nbr < lpixhead) {
	sprintf(errmsg, "IRAF pixel file: %d / %d bytes read.",
		      nbr,LEN_PIXHDR);
        ffpmsg(errmsg);
	free (pixheader);
	fclose (fd);
	return (*status = FILE_NOT_OPENED);
	}

    /* check pixel header magic word */
    imhver = pix_version (pixheader);
    if (imhver < 1) {
        ffpmsg("File not valid IRAF pixel file:");
        ffpmsg(pixname);
	free (pixheader);
	fclose (fd);
	return (*status = FILE_NOT_OPENED);
	}
    free (pixheader);

    /* Find number of bytes to read */
    hgeti4 (fitsheader,"NAXIS",&nax);
    hgeti4 (fitsheader,"NAXIS1",&naxis1);
    hgeti4 (fitsheader,"NPAXIS1",&npaxis1);
    if (nax > 1) {
        hgeti4 (fitsheader,"NAXIS2",&naxis2);
        hgeti4 (fitsheader,"NPAXIS2",&npaxis2);
	}
    if (nax > 2)
        hgeti4 (fitsheader,"NAXIS3",&naxis3);
    if (nax > 3)
        hgeti4 (fitsheader,"NAXIS4",&naxis4);

    hgeti4 (fitsheader,"BITPIX",&bitpix);
    if (bitpix < 0)
	bytepix = -bitpix / 8;
    else
	bytepix = bitpix / 8;

    nbimage = naxis1 * naxis2 * naxis3 * naxis4 * bytepix;
    
    newfilesize = *filesize + nbimage;  /* header + data */
    newfilesize = (((newfilesize - 1) / 2880 ) + 1 ) * 2880;

    if (newfilesize > *buffsize)   /* need to allocate more memory? */
    {
      fitsheader =  (char *) realloc (*buffptr, newfilesize);
      if (fitsheader == NULL) {
	sprintf(errmsg, "IRAFRIMAGE Cannot allocate %d-byte image buffer",
		(int) (*filesize));
        ffpmsg(errmsg);
        ffpmsg(pixname);
	fclose (fd);
	return (*status = FILE_NOT_OPENED);
	}
    }

    *buffptr = fitsheader;
    *buffsize = newfilesize;

    image = fitsheader + *filesize;
    *filesize = newfilesize;

    /* Read IRAF image all at once if physical and image dimensions are the same */
    if (npaxis1 == naxis1)
	nbr = fread (image, 1, nbimage, fd);

    /* Read IRAF image one line at a time if physical and image dimensions differ */
    else {
	nbdiff = (npaxis1 - naxis1) * bytepix;
	nbaxis = naxis1 * bytepix;
	linebuff = image;
	nbr = 0;
	if (naxis2 == 1 && naxis3 > 1)
	    naxis2 = naxis3;
	for (i = 0; i < naxis2; i++) {
	    nbl = fread (linebuff, 1, nbaxis, fd);
	    nbr = nbr + nbl;
	    fseek (fd, nbdiff, 1);
	    linebuff = linebuff + nbaxis;
	    }
	}
    fclose (fd);

    /* Check size of image */
    if (nbr < nbimage) {
	sprintf(errmsg, "IRAF pixel file: %d / %d bytes read.",
		      nbr,nbimage);
        ffpmsg(errmsg);
        ffpmsg(pixname);
	return (*status = FILE_NOT_OPENED);
	}

    /* Byte-reverse image, if necessary */
    if (swapdata)
	irafswap (bitpix, image, nbimage);

    return (*status);
}
/*--------------------------------------------------------------------------*/
/* Return IRAF image format version number from magic word in IRAF header*/

static int head_version (
    char *irafheader)	/* IRAF image header from file */

{

    /* Check header file magic word */
    if (irafncmp (irafheader, "imhdr", 5) != 0 ) {
	if (strncmp (irafheader, "imhv2", 5) != 0)
	    return (0);
	else
	    return (2);
	}
    else
	return (1);
}

/*--------------------------------------------------------------------------*/
/* Return IRAF image format version number from magic word in IRAF pixel file */

static int pix_version (
    char *irafheader)   /* IRAF image header from file */
{

    /* Check pixel file header magic word */
    if (irafncmp (irafheader, "impix", 5) != 0) {
	if (strncmp (irafheader, "impv2", 5) != 0)
	    return (0);
	else
	    return (2);
	}
    else
	return (1);
}

/*--------------------------------------------------------------------------*/
/* Verify that file is valid IRAF imhdr or impix by checking first 5 chars
 * Returns:	0 on success, 1 on failure */

static int irafncmp (

char	*irafheader,	/* IRAF image header from file */
char	*teststring,	/* C character string to compare */
int	nc)		/* Number of characters to compate */

{
    char *line;

    if ((line = iraf2str (irafheader, nc)) == NULL)
	return (1);
    if (strncmp (line, teststring, nc) == 0) {
	free (line);
	return (0);
	}
    else {
	free (line);
	return (1);
	}
}
/*--------------------------------------------------------------------------*/

/* Convert IRAF image header to FITS image header, returning FITS header */

static int iraftofits (
    char    *hdrname,  /* IRAF header file name (may be path) */
    char    *irafheader,  /* IRAF image header */
    int	    nbiraf,	  /* Number of bytes in IRAF header */
    char    **buffptr,    /* pointer to the FITS header  */
    size_t  *nbfits,      /* allocated size of the FITS header buffer */
    size_t  *fitssize,  /* Number of bytes in FITS header (returned) */
                        /*  = number of bytes to the end of the END keyword */
    int     *status)
{
    char *objname;	/* object name from FITS file */
    int lstr, i, j, k, ib, nax, nbits;
    char *pixname, *newpixname, *bang, *chead;
    char *fitsheader;
    int nblock, nlines;
    char *fhead, *fhead1, *fp, endline[81];
    char irafchar;
    char fitsline[81];
    int pixtype;
    int imhver, n, imu, pixoff, impixoff;
/*    int immax, immin, imtime;  */
    int imndim, imlen, imphyslen, impixtype;
    char errmsg[81];

    /* Set up last line of FITS header */
    (void)strncpy (endline,"END", 3);
    for (i = 3; i < 80; i++)
	endline[i] = ' ';
    endline[80] = 0;

    /* Check header magic word */
    imhver = head_version (irafheader);
    if (imhver < 1) {
	ffpmsg("File not valid IRAF image header");
        ffpmsg(hdrname);
	return(*status = FILE_NOT_OPENED);
	}
    if (imhver == 2) {
	nlines = 24 + ((nbiraf - LEN_IM2HDR) / 81);
	imndim = IM2_NDIM;
	imlen = IM2_LEN;
	imphyslen = IM2_PHYSLEN;
	impixtype = IM2_PIXTYPE;
	impixoff = IM2_PIXOFF;
/*	imtime = IM2_MTIME; */
/*	immax = IM2_MAX;  */
/*	immin = IM2_MIN; */
	}
    else {
	nlines = 24 + ((nbiraf - LEN_IMHDR) / 162);
	imndim = IM_NDIM;
	imlen = IM_LEN;
	imphyslen = IM_PHYSLEN;
	impixtype = IM_PIXTYPE;
	impixoff = IM_PIXOFF;
/*	imtime = IM_MTIME; */
/*	immax = IM_MAX; */
/*	immin = IM_MIN; */
	}

    /*  Initialize FITS header */
    nblock = (nlines * 80) / 2880;
    *nbfits = (nblock + 5) * 2880 + 4;
    fitsheader = (char *) calloc (*nbfits, 1);
    if (fitsheader == NULL) {
	sprintf(errmsg, "IRAF2FITS Cannot allocate %d-byte FITS header",
		(int) (*nbfits));
        ffpmsg(hdrname);
	return (*status = FILE_NOT_OPENED);
	}

    fhead = fitsheader;
    *buffptr = fitsheader;
    (void)strncpy (fitsheader, endline, 80);
    hputl (fitsheader, "SIMPLE", 1);
    fhead = fhead + 80;

    /*  check if the IRAF file is in big endian (sun) format (= 0) or not. */
    /*  This is done by checking the 4 byte integer in the header that     */
    /*  represents the iraf pixel type.  This 4-byte word is guaranteed to */
    /*  have the least sig byte != 0 and the most sig byte = 0,  so if the */
    /*  first byte of the word != 0, then the file in little endian format */
    /*  like on an Alpha machine.                                          */

    swaphead = isirafswapped(irafheader, impixtype);
    if (imhver == 1)
        swapdata = swaphead; /* vers 1 data has same swapness as header */
    else
        swapdata = irafgeti4 (irafheader, IM2_SWAPPED); 

    /*  Set pixel size in FITS header */
    pixtype = irafgeti4 (irafheader, impixtype);
    switch (pixtype) {
	case TY_CHAR:
	    nbits = 8;
	    break;
	case TY_UBYTE:
	    nbits = 8;
	    break;
	case TY_SHORT:
	    nbits = 16;
	    break;
	case TY_USHORT:
	    nbits = -16;
	    break;
	case TY_INT:
	case TY_LONG:
	    nbits = 32;
	    break;
	case TY_REAL:
	    nbits = -32;
	    break;
	case TY_DOUBLE:
	    nbits = -64;
	    break;
	default:
	    sprintf(errmsg,"Unsupported IRAF data type: %d", pixtype);
            ffpmsg(errmsg);
            ffpmsg(hdrname);
	    return (*status = FILE_NOT_OPENED);
	}
    hputi4 (fitsheader,"BITPIX",nbits);
    hputcom (fitsheader,"BITPIX", "IRAF .imh pixel type");
    fhead = fhead + 80;

    /*  Set image dimensions in FITS header */
    nax = irafgeti4 (irafheader, imndim);
    hputi4 (fitsheader,"NAXIS",nax);
    hputcom (fitsheader,"NAXIS", "IRAF .imh naxis");
    fhead = fhead + 80;

    n = irafgeti4 (irafheader, imlen);
    hputi4 (fitsheader, "NAXIS1", n);
    hputcom (fitsheader,"NAXIS1", "IRAF .imh image naxis[1]");
    fhead = fhead + 80;

    if (nax > 1) {
	n = irafgeti4 (irafheader, imlen+4);
	hputi4 (fitsheader, "NAXIS2", n);
	hputcom (fitsheader,"NAXIS2", "IRAF .imh image naxis[2]");
        fhead = fhead + 80;
	}
    if (nax > 2) {
	n = irafgeti4 (irafheader, imlen+8);
	hputi4 (fitsheader, "NAXIS3", n);
	hputcom (fitsheader,"NAXIS3", "IRAF .imh image naxis[3]");
	fhead = fhead + 80;
	}
    if (nax > 3) {
	n = irafgeti4 (irafheader, imlen+12);
	hputi4 (fitsheader, "NAXIS4", n);
	hputcom (fitsheader,"NAXIS4", "IRAF .imh image naxis[4]");
	fhead = fhead + 80;
	}

    /* Set object name in FITS header */
    if (imhver == 2)
	objname = irafgetc (irafheader, IM2_TITLE, SZ_IM2TITLE);
    else
	objname = irafgetc2 (irafheader, IM_TITLE, SZ_IMTITLE);
    if ((lstr = strlen (objname)) < 8) {
	for (i = lstr; i < 8; i++)
	    objname[i] = ' ';
	objname[8] = 0;
	}
    hputs (fitsheader,"OBJECT",objname);
    hputcom (fitsheader,"OBJECT", "IRAF .imh title");
    free (objname);
    fhead = fhead + 80;

    /* Save physical axis lengths so image file can be read */
    n = irafgeti4 (irafheader, imphyslen);
    hputi4 (fitsheader, "NPAXIS1", n);
    hputcom (fitsheader,"NPAXIS1", "IRAF .imh physical naxis[1]");
    fhead = fhead + 80;
    if (nax > 1) {
	n = irafgeti4 (irafheader, imphyslen+4);
	hputi4 (fitsheader, "NPAXIS2", n);
	hputcom (fitsheader,"NPAXIS2", "IRAF .imh physical naxis[2]");
	fhead = fhead + 80;
	}
    if (nax > 2) {
	n = irafgeti4 (irafheader, imphyslen+8);
	hputi4 (fitsheader, "NPAXIS3", n);
	hputcom (fitsheader,"NPAXIS3", "IRAF .imh physical naxis[3]");
	fhead = fhead + 80;
	}
    if (nax > 3) {
	n = irafgeti4 (irafheader, imphyslen+12);
	hputi4 (fitsheader, "NPAXIS4", n);
	hputcom (fitsheader,"NPAXIS4", "IRAF .imh physical naxis[4]");
	fhead = fhead + 80;
	}

    /* Save image header filename in header */
    hputs (fitsheader,"IMHFILE",hdrname);
    hputcom (fitsheader,"IMHFILE", "IRAF header file name");
    fhead = fhead + 80;

    /* Save image pixel file pathname in header */
    if (imhver == 2)
	pixname = irafgetc (irafheader, IM2_PIXFILE, SZ_IM2PIXFILE);
    else
	pixname = irafgetc2 (irafheader, IM_PIXFILE, SZ_IMPIXFILE);
    if (strncmp(pixname, "HDR", 3) == 0 ) {
	newpixname = same_path (pixname, hdrname);
        if (newpixname) {
          free (pixname);
          pixname = newpixname;
	  }
	}
    if (strchr (pixname, '/') == NULL && strchr (pixname, '$') == NULL) {
	newpixname = same_path (pixname, hdrname);
        if (newpixname) {
          free (pixname);
          pixname = newpixname;
	  }
	}
	
    if ((bang = strchr (pixname, '!')) != NULL )
	hputs (fitsheader,"PIXFILE",bang+1);
    else
	hputs (fitsheader,"PIXFILE",pixname);
    free (pixname);
    hputcom (fitsheader,"PIXFILE", "IRAF .pix pixel file");
    fhead = fhead + 80;

    /* Save image offset from star of pixel file */
    pixoff = irafgeti4 (irafheader, impixoff);
    pixoff = (pixoff - 1) * 2;
    hputi4 (fitsheader, "PIXOFF", pixoff);
    hputcom (fitsheader,"PIXOFF", "IRAF .pix pixel offset (Do not change!)");
    fhead = fhead + 80;

    /* Save IRAF file format version in header */
    hputi4 (fitsheader,"IMHVER",imhver);
    hputcom (fitsheader,"IMHVER", "IRAF .imh format version (1 or 2)");
    fhead = fhead + 80;

    /* Save flag as to whether to swap IRAF data for this file and machine */
    if (swapdata)
	hputl (fitsheader, "PIXSWAP", 1);
    else
	hputl (fitsheader, "PIXSWAP", 0);
    hputcom (fitsheader,"PIXSWAP", "IRAF pixels, FITS byte orders differ if T");
    fhead = fhead + 80;

    /* Add user portion of IRAF header to FITS header */
    fitsline[80] = 0;
    if (imhver == 2) {
	imu = LEN_IM2HDR;
	chead = irafheader;
	j = 0;
	for (k = 0; k < 80; k++)
	    fitsline[k] = ' ';
	for (i = imu; i < nbiraf; i++) {
	    irafchar = chead[i];
	    if (irafchar == 0)
		break;
	    else if (irafchar == 10) {
		(void)strncpy (fhead, fitsline, 80);
		/* fprintf (stderr,"%80s\n",fitsline); */
		if (strncmp (fitsline, "OBJECT ", 7) != 0) {
		    fhead = fhead + 80;
		    }
		for (k = 0; k < 80; k++)
		    fitsline[k] = ' ';
		j = 0;
		}
	    else {
		if (j > 80) {
		    if (strncmp (fitsline, "OBJECT ", 7) != 0) {
			(void)strncpy (fhead, fitsline, 80);
			/* fprintf (stderr,"%80s\n",fitsline); */
			j = 9;
			fhead = fhead + 80;
			}
		    for (k = 0; k < 80; k++)
			fitsline[k] = ' ';
		    }
		if (irafchar > 32 && irafchar < 127)
		    fitsline[j] = irafchar;
		j++;
		}
	    }
	}
    else {
	imu = LEN_IMHDR;
	chead = irafheader;
	if (swaphead == 1)
	    ib = 0;
	else
	    ib = 1;
	for (k = 0; k < 80; k++)
	    fitsline[k] = ' ';
	j = 0;
	for (i = imu; i < nbiraf; i=i+2) {
	    irafchar = chead[i+ib];
	    if (irafchar == 0)
		break;
	    else if (irafchar == 10) {
		if (strncmp (fitsline, "OBJECT ", 7) != 0) {
		    (void)strncpy (fhead, fitsline, 80);
		    fhead = fhead + 80;
		    }
		/* fprintf (stderr,"%80s\n",fitsline); */
		j = 0;
		for (k = 0; k < 80; k++)
		    fitsline[k] = ' ';
		}
	    else {
		if (j > 80) {
		    if (strncmp (fitsline, "OBJECT ", 7) != 0) {
			(void)strncpy (fhead, fitsline, 80);
			j = 9;
			fhead = fhead + 80;
			}
		    /* fprintf (stderr,"%80s\n",fitsline); */
		    for (k = 0; k < 80; k++)
			fitsline[k] = ' ';
		    }
		if (irafchar > 32 && irafchar < 127)
		    fitsline[j] = irafchar;
		j++;
		}
	    }
	}

    /* Add END to last line */
    (void)strncpy (fhead, endline, 80);

    /* Find end of last 2880-byte block of header */
    fhead = ksearch (fitsheader, "END") + 80;
    nblock = *nbfits / 2880;
    fhead1 = fitsheader + (nblock * 2880);
    *fitssize = fhead - fitsheader;  /* no. of bytes to end of END keyword */

    /* Pad rest of header with spaces */
    strncpy (endline,"   ",3);
    for (fp = fhead; fp < fhead1; fp = fp + 80) {
	(void)strncpy (fp, endline,80);
	}

    return (*status);
}
/*--------------------------------------------------------------------------*/

/* get the IRAF pixel file name */

static int getirafpixname (
    const char *hdrname,  /* IRAF header file name (may be path) */
    char    *irafheader,  /* IRAF image header */
    char    *pixfilename,     /* IRAF pixel file name */
    int     *status)
{
    int imhver;
    char *pixname, *newpixname, *bang;

    /* Check header magic word */
    imhver = head_version (irafheader);
    if (imhver < 1) {
	ffpmsg("File not valid IRAF image header");
        ffpmsg(hdrname);
	return(*status = FILE_NOT_OPENED);
	}

    /* get image pixel file pathname in header */
    if (imhver == 2)
	pixname = irafgetc (irafheader, IM2_PIXFILE, SZ_IM2PIXFILE);
    else
	pixname = irafgetc2 (irafheader, IM_PIXFILE, SZ_IMPIXFILE);

    if (strncmp(pixname, "HDR", 3) == 0 ) {
	newpixname = same_path (pixname, hdrname);
        if (newpixname) {
          free (pixname);
          pixname = newpixname;
	  }
	}

    if (strchr (pixname, '/') == NULL && strchr (pixname, '$') == NULL) {
	newpixname = same_path (pixname, hdrname);
        if (newpixname) {
          free (pixname);
          pixname = newpixname;
	  }
	}
	
    if ((bang = strchr (pixname, '!')) != NULL )
	strcpy(pixfilename,bang+1);
    else
	strcpy(pixfilename,pixname);

    free (pixname);

    return (*status);
}

/*--------------------------------------------------------------------------*/
/* Put filename and header path together */

static char *same_path (

char	*pixname,	/* IRAF pixel file pathname */
const char	*hdrname)	/* IRAF image header file pathname */

{
    int len;
    char *newpixname;

/*  WDP - 10/16/2007 - increased allocation to avoid possible overflow */
/*    newpixname = (char *) calloc (SZ_IM2PIXFILE, sizeof (char)); */

    newpixname = (char *) calloc (2*SZ_IM2PIXFILE+1, sizeof (char));
    if (newpixname == NULL) {
            ffpmsg("iraffits same_path: Cannot alloc memory for newpixname");
	    return (NULL);
	}

    /* Pixel file is in same directory as header */
    if (strncmp(pixname, "HDR$", 4) == 0 ) {
	(void)strncpy (newpixname, hdrname, SZ_IM2PIXFILE);

	/* find the end of the pathname */
	len = strlen (newpixname);
#ifndef VMS
	while( (len > 0) && (newpixname[len-1] != '/') )
#else
	while( (len > 0) && (newpixname[len-1] != ']') && (newpixname[len-1] != ':') )
#endif
	    len--;

	/* add name */
	newpixname[len] = '\0';
	(void)strncat (newpixname, &pixname[4], SZ_IM2PIXFILE);
	}

    /* Bare pixel file with no path is assumed to be same as HDR$filename */
    else if (strchr (pixname, '/') == NULL && strchr (pixname, '$') == NULL) {
	(void)strncpy (newpixname, hdrname, SZ_IM2PIXFILE);

	/* find the end of the pathname */
	len = strlen (newpixname);
#ifndef VMS
	while( (len > 0) && (newpixname[len-1] != '/') )
#else
	while( (len > 0) && (newpixname[len-1] != ']') && (newpixname[len-1] != ':') )
#endif
	    len--;

	/* add name */
	newpixname[len] = '\0';
	(void)strncat (newpixname, pixname, SZ_IM2PIXFILE);
	}

    /* Pixel file has same name as header file, but with .pix extension */
    else if (strncmp (pixname, "HDR", 3) == 0) {

	/* load entire header name string into name buffer */
	(void)strncpy (newpixname, hdrname, SZ_IM2PIXFILE);
	len = strlen (newpixname);
	newpixname[len-3] = 'p';
	newpixname[len-2] = 'i';
	newpixname[len-1] = 'x';
	}

    return (newpixname);
}

/*--------------------------------------------------------------------------*/
static int isirafswapped (

char	*irafheader,	/* IRAF image header */
int	offset)		/* Number of bytes to skip before number */

    /*  check if the IRAF file is in big endian (sun) format (= 0) or not */
    /*  This is done by checking the 4 byte integer in the header that */
    /*  represents the iraf pixel type.  This 4-byte word is guaranteed to */
    /*  have the least sig byte != 0 and the most sig byte = 0,  so if the */
    /*  first byte of the word != 0, then the file in little endian format */
    /*  like on an Alpha machine.                                          */

{
    int  swapped;

    if (irafheader[offset] != 0)
	swapped = 1;
    else
	swapped = 0;

    return (swapped);
}
/*--------------------------------------------------------------------------*/
static int irafgeti4 (

char	*irafheader,	/* IRAF image header */
int	offset)		/* Number of bytes to skip before number */

{
    char *ctemp, *cheader;
    int  temp;

    cheader = irafheader;
    ctemp = (char *) &temp;

    if (machswap() != swaphead) {
	ctemp[3] = cheader[offset];
	ctemp[2] = cheader[offset+1];
	ctemp[1] = cheader[offset+2];
	ctemp[0] = cheader[offset+3];
	}
    else {
	ctemp[0] = cheader[offset];
	ctemp[1] = cheader[offset+1];
	ctemp[2] = cheader[offset+2];
	ctemp[3] = cheader[offset+3];
	}
    return (temp);
}

/*--------------------------------------------------------------------------*/
/* IRAFGETC2 -- Get character string from arbitrary part of v.1 IRAF header */

static char *irafgetc2 (

char	*irafheader,	/* IRAF image header */
int	offset,		/* Number of bytes to skip before string */
int	nc)		/* Maximum number of characters in string */

{
    char *irafstring, *string;

    irafstring = irafgetc (irafheader, offset, 2*(nc+1));
    string = iraf2str (irafstring, nc);
    free (irafstring);

    return (string);
}

/*--------------------------------------------------------------------------*/
/* IRAFGETC -- Get character string from arbitrary part of IRAF header */

static char *irafgetc (

char	*irafheader,	/* IRAF image header */
int	offset,		/* Number of bytes to skip before string */
int	nc)		/* Maximum number of characters in string */

{
    char *ctemp, *cheader;
    int i;

    cheader = irafheader;
    ctemp = (char *) calloc (nc+1, 1);
    if (ctemp == NULL) {
	ffpmsg("IRAFGETC Cannot allocate memory for string variable");
	return (NULL);
	}
    for (i = 0; i < nc; i++) {
	ctemp[i] = cheader[offset+i];
	if (ctemp[i] > 0 && ctemp[i] < 32)
	    ctemp[i] = ' ';
	}

    return (ctemp);
}

/*--------------------------------------------------------------------------*/
/* Convert IRAF 2-byte/char string to 1-byte/char string */

static char *iraf2str (

char	*irafstring,	/* IRAF 2-byte/character string */
int	nchar)		/* Number of characters in string */
{
    char *string;
    int i, j;

    string = (char *) calloc (nchar+1, 1);
    if (string == NULL) {
	ffpmsg("IRAF2STR Cannot allocate memory for string variable");
	return (NULL);
	}

    /* the chars are in bytes 1, 3, 5, ... if bigendian format (SUN) */
    /* else in bytes 0, 2, 4, ... if little endian format (Alpha)    */

    if (irafstring[0] != 0)
	j = 0;
    else
	j = 1;

    /* Convert appropriate byte of input to output character */
    for (i = 0; i < nchar; i++) {
	string[i] = irafstring[j];
	j = j + 2;
	}

    return (string);
}

/*--------------------------------------------------------------------------*/
/* IRAFSWAP -- Reverse bytes of any type of vector in place */

static void irafswap (

int	bitpix,		/* Number of bits per pixel */
			/*  16 = short, -16 = unsigned short, 32 = int */
			/* -32 = float, -64 = double */
char	*string,	/* Address of starting point of bytes to swap */
int	nbytes)		/* Number of bytes to swap */

{
    switch (bitpix) {

	case 16:
	    if (nbytes < 2) return;
	    irafswap2 (string,nbytes);
	    break;

	case 32:
	    if (nbytes < 4) return;
	    irafswap4 (string,nbytes);
	    break;

	case -16:
	    if (nbytes < 2) return;
	    irafswap2 (string,nbytes);
	    break;

	case -32:
	    if (nbytes < 4) return;
	    irafswap4 (string,nbytes);
	    break;

	case -64:
	    if (nbytes < 8) return;
	    irafswap8 (string,nbytes);
	    break;

	}
    return;
}

/*--------------------------------------------------------------------------*/
/* IRAFSWAP2 -- Swap bytes in string in place */

static void irafswap2 (

char *string,	/* Address of starting point of bytes to swap */
int nbytes)	/* Number of bytes to swap */

{
    char *sbyte, temp, *slast;

    slast = string + nbytes;
    sbyte = string;
    while (sbyte < slast) {
	temp = sbyte[0];
	sbyte[0] = sbyte[1];
	sbyte[1] = temp;
	sbyte= sbyte + 2;
	}
    return;
}

/*--------------------------------------------------------------------------*/
/* IRAFSWAP4 -- Reverse bytes of Integer*4 or Real*4 vector in place */

static void irafswap4 (

char *string,	/* Address of Integer*4 or Real*4 vector */
int nbytes)	/* Number of bytes to reverse */

{
    char *sbyte, *slast;
    char temp0, temp1, temp2, temp3;

    slast = string + nbytes;
    sbyte = string;
    while (sbyte < slast) {
	temp3 = sbyte[0];
	temp2 = sbyte[1];
	temp1 = sbyte[2];
	temp0 = sbyte[3];
	sbyte[0] = temp0;
	sbyte[1] = temp1;
	sbyte[2] = temp2;
	sbyte[3] = temp3;
	sbyte = sbyte + 4;
	}

    return;
}

/*--------------------------------------------------------------------------*/
/* IRAFSWAP8 -- Reverse bytes of Real*8 vector in place */

static void irafswap8 (

char *string,	/* Address of Real*8 vector */
int nbytes)	/* Number of bytes to reverse */

{
    char *sbyte, *slast;
    char temp[8];

    slast = string + nbytes;
    sbyte = string;
    while (sbyte < slast) {
	temp[7] = sbyte[0];
	temp[6] = sbyte[1];
	temp[5] = sbyte[2];
	temp[4] = sbyte[3];
	temp[3] = sbyte[4];
	temp[2] = sbyte[5];
	temp[1] = sbyte[6];
	temp[0] = sbyte[7];
	sbyte[0] = temp[0];
	sbyte[1] = temp[1];
	sbyte[2] = temp[2];
	sbyte[3] = temp[3];
	sbyte[4] = temp[4];
	sbyte[5] = temp[5];
	sbyte[6] = temp[6];
	sbyte[7] = temp[7];
	sbyte = sbyte + 8;
	}
    return;
}

/*--------------------------------------------------------------------------*/
static int
machswap (void)

{
    char *ctest;
    int itest;

    itest = 1;
    ctest = (char *)&itest;
    if (*ctest)
	return (1);
    else
	return (0);
}

/*--------------------------------------------------------------------------*/
/*             the following routines were originally in hget.c             */
/*--------------------------------------------------------------------------*/


static int lhead0 = 0;

/*--------------------------------------------------------------------------*/

/* Extract long value for variable from FITS header string */

static int
hgeti4 (hstring,keyword,ival)

char *hstring;	/* character string containing FITS header information
		   in the format =  {/ } */
char *keyword;	/* character string containing the name of the keyword
		   the value of which is returned.  hget searches for a
		   line beginning with this string.  if "[n]" is present,
		   the n'th token in the value is returned.
		   (the first 8 characters must be unique) */
int *ival;
{
char *value;
double dval;
int minint;
char val[30]; 

/* Get value and comment from header string */
	value = hgetc (hstring,keyword);

/* Translate value from ASCII to binary */
	if (value != NULL) {
	    minint = -MAXINT - 1;
	    strcpy (val, value);
	    dval = atof (val);
	    if (dval+0.001 > MAXINT)
		*ival = MAXINT;
	    else if (dval >= 0)
		*ival = (int) (dval + 0.001);
	    else if (dval-0.001 < minint)
		*ival = minint;
	    else
		*ival = (int) (dval - 0.001);
	    return (1);
	    }
	else {
	    return (0);
	    }
}

/*-------------------------------------------------------------------*/
/* Extract string value for variable from FITS header string */

static int
hgets (hstring, keyword, lstr, str)

char *hstring;	/* character string containing FITS header information
		   in the format =  {/ } */
char *keyword;	/* character string containing the name of the keyword
		   the value of which is returned.  hget searches for a
		   line beginning with this string.  if "[n]" is present,
		   the n'th token in the value is returned.
		   (the first 8 characters must be unique) */
int lstr;	/* Size of str in characters */
char *str;	/* String (returned) */
{
	char *value;
	int lval;

/* Get value and comment from header string */
	value = hgetc (hstring,keyword);

	if (value != NULL) {
	    lval = strlen (value);
	    if (lval < lstr)
		strcpy (str, value);
	    else if (lstr > 1)
		strncpy (str, value, lstr-1);
	    else
		str[0] = value[0];
	    return (1);
	    }
	else
	    return (0);
}

/*-------------------------------------------------------------------*/
/* Extract character value for variable from FITS header string */

static char *
hgetc (hstring,keyword0)

char *hstring;	/* character string containing FITS header information
		   in the format =  {/ } */
char *keyword0;	/* character string containing the name of the keyword
		   the value of which is returned.  hget searches for a
		   line beginning with this string.  if "[n]" is present,
		   the n'th token in the value is returned.
		   (the first 8 characters must be unique) */
{
	static char cval[80];
	char *value;
	char cwhite[2];
	char squot[2], dquot[2], lbracket[2], rbracket[2], slash[2], comma[2];
	char keyword[81]; /* large for ESO hierarchical keywords */
	char line[100];
	char *vpos, *cpar = NULL;
	char *q1, *q2 = NULL, *v1, *v2, *c1, *brack1, *brack2;
	int ipar, i;

	squot[0] = 39;
	squot[1] = 0;
	dquot[0] = 34;
	dquot[1] = 0;
	lbracket[0] = 91;
	lbracket[1] = 0;
	comma[0] = 44;
	comma[1] = 0;
	rbracket[0] = 93;
	rbracket[1] = 0;
	slash[0] = 47;
	slash[1] = 0;

/* Find length of variable name */
	strncpy (keyword,keyword0, sizeof(keyword)-1);
	brack1 = strsrch (keyword,lbracket);
	if (brack1 == NULL)
	    brack1 = strsrch (keyword,comma);
	if (brack1 != NULL) {
	    *brack1 = '\0';
	    brack1++;
	    }

/* Search header string for variable name */
	vpos = ksearch (hstring,keyword);

/* Exit if not found */
	if (vpos == NULL) {
	    return (NULL);
	    }

/* Initialize line to nulls */
	 for (i = 0; i < 100; i++)
	    line[i] = 0;

/* In standard FITS, data lasts until 80th character */

/* Extract entry for this variable from the header */
	strncpy (line,vpos,80);

/* check for quoted value */
	q1 = strsrch (line,squot);
	c1 = strsrch (line,slash);
	if (q1 != NULL) {
	    if (c1 != NULL && q1 < c1)
		q2 = strsrch (q1+1,squot);
	    else if (c1 == NULL)
		q2 = strsrch (q1+1,squot);
	    else
		q1 = NULL;
	    }
	else {
	    q1 = strsrch (line,dquot);
	    if (q1 != NULL) {
		if (c1 != NULL && q1 < c1)
		    q2 = strsrch (q1+1,dquot);
		else if (c1 == NULL)
		    q2 = strsrch (q1+1,dquot);
		else
		    q1 = NULL;
		}
	    else {
		q1 = NULL;
		q2 = line + 10;
		}
	    }

/* Extract value and remove excess spaces */
	if (q1 != NULL) {
	    v1 = q1 + 1;
	    v2 = q2;
	    c1 = strsrch (q2,"/");
	    }
	else {
	    v1 = strsrch (line,"=") + 1;
	    c1 = strsrch (line,"/");
	    if (c1 != NULL)
		v2 = c1;
	    else
		v2 = line + 79;
	    }

/* Ignore leading spaces */
	while (*v1 == ' ' && v1 < v2) {
	    v1++;
	    }

/* Drop trailing spaces */
	*v2 = '\0';
	v2--;
	while (*v2 == ' ' && v2 > v1) {
	    *v2 = '\0';
	    v2--;
	    }

	if (!strcmp (v1, "-0"))
	    v1++;
	strcpy (cval,v1);
	value = cval;

/* If keyword has brackets, extract appropriate token from value */
	if (brack1 != NULL) {
	    brack2 = strsrch (brack1,rbracket);
	    if (brack2 != NULL)
		*brack2 = '\0';
	    ipar = atoi (brack1);
	    if (ipar > 0) {
		cwhite[0] = ' ';
		cwhite[1] = '\0';
		for (i = 1; i <= ipar; i++) {
		    cpar = strtok (v1,cwhite);
		    v1 = NULL;
		    }
		if (cpar != NULL) {
		    strcpy (cval,cpar);
		    }
		else
		    value = NULL;
		}
	    }

	return (value);
}


/*-------------------------------------------------------------------*/
/* Find beginning of fillable blank line before FITS header keyword line */

static char *
blsearch (hstring,keyword)

/* Find entry for keyword keyword in FITS header string hstring.
   (the keyword may have a maximum of eight letters)
   NULL is returned if the keyword is not found */

char *hstring;	/* character string containing fits-style header
		information in the format =  {/ }
		the default is that each entry is 80 characters long;
		however, lines may be of arbitrary length terminated by
		nulls, carriage returns or linefeeds, if packed is true.  */
char *keyword;	/* character string containing the name of the variable
		to be returned.  ksearch searches for a line beginning
		with this string.  The string may be a character
		literal or a character variable terminated by a null
		or '$'.  it is truncated to 8 characters. */
{
    char *loc, *headnext, *headlast, *pval, *lc, *line;
    char *bval;
    int icol, nextchar, lkey, nleft, lhstr;

    pval = 0;

    /* Search header string for variable name */
    if (lhead0)
	lhstr = lhead0;
    else {
	lhstr = 0;
	while (lhstr < 57600 && hstring[lhstr] != 0)
	    lhstr++;
	}
    headlast = hstring + lhstr;
    headnext = hstring;
    pval = NULL;
    while (headnext < headlast) {
	nleft = headlast - headnext;
	loc = strnsrch (headnext, keyword, nleft);

	/* Exit if keyword is not found */
	if (loc == NULL) {
	    break;
	    }

	icol = (loc - hstring) % 80;
	lkey = strlen (keyword);
	nextchar = (int) *(loc + lkey);

	/* If this is not in the first 8 characters of a line, keep searching */
	if (icol > 7)
	    headnext = loc + 1;

	/* If parameter name in header is longer, keep searching */
	else if (nextchar != 61 && nextchar > 32 && nextchar < 127)
	    headnext = loc + 1;

	/* If preceeding characters in line are not blanks, keep searching */
	else {
	    line = loc - icol;
	    for (lc = line; lc < loc; lc++) {
		if (*lc != ' ')
		    headnext = loc + 1;
		}

	/* Return pointer to start of line if match */
	    if (loc >= headnext) {
		pval = line;
		break;
		}
	    }
	}

    /* Return NULL if keyword is found at start of FITS header string */
    if (pval == NULL)
	return (pval);

    /* Return NULL if  found the first keyword in the header */
    if (pval == hstring)
        return (NULL);

    /* Find last nonblank line before requested keyword */
    bval = pval - 80;
    while (!strncmp (bval,"        ",8))
	bval = bval - 80;
    bval = bval + 80;

    /* Return pointer to calling program if blank lines found */
    if (bval < pval)
	return (bval);
    else
	return (NULL);
}


/*-------------------------------------------------------------------*/
/* Find FITS header line containing specified keyword */

static char *ksearch (hstring,keyword)

/* Find entry for keyword keyword in FITS header string hstring.
   (the keyword may have a maximum of eight letters)
   NULL is returned if the keyword is not found */

char *hstring;	/* character string containing fits-style header
		information in the format =  {/ }
		the default is that each entry is 80 characters long;
		however, lines may be of arbitrary length terminated by
		nulls, carriage returns or linefeeds, if packed is true.  */
char *keyword;	/* character string containing the name of the variable
		to be returned.  ksearch searches for a line beginning
		with this string.  The string may be a character
		literal or a character variable terminated by a null
		or '$'.  it is truncated to 8 characters. */
{
    char *loc, *headnext, *headlast, *pval, *lc, *line;
    int icol, nextchar, lkey, nleft, lhstr;

    pval = 0;

/* Search header string for variable name */
    if (lhead0)
	lhstr = lhead0;
    else {
	lhstr = 0;
	while (lhstr < 57600 && hstring[lhstr] != 0)
	    lhstr++;
	}
    headlast = hstring + lhstr;
    headnext = hstring;
    pval = NULL;
    while (headnext < headlast) {
	nleft = headlast - headnext;
	loc = strnsrch (headnext, keyword, nleft);

	/* Exit if keyword is not found */
	if (loc == NULL) {
	    break;
	    }

	icol = (loc - hstring) % 80;
	lkey = strlen (keyword);
	nextchar = (int) *(loc + lkey);

	/* If this is not in the first 8 characters of a line, keep searching */
	if (icol > 7)
	    headnext = loc + 1;

	/* If parameter name in header is longer, keep searching */
	else if (nextchar != 61 && nextchar > 32 && nextchar < 127)
	    headnext = loc + 1;

	/* If preceeding characters in line are not blanks, keep searching */
	else {
	    line = loc - icol;
	    for (lc = line; lc < loc; lc++) {
		if (*lc != ' ')
		    headnext = loc + 1;
		}

	/* Return pointer to start of line if match */
	    if (loc >= headnext) {
		pval = line;
		break;
		}
	    }
	}

/* Return pointer to calling program */
	return (pval);

}

/*-------------------------------------------------------------------*/
/* Find string s2 within null-terminated string s1 */

static char *
strsrch (s1, s2)

char *s1;	/* String to search */
char *s2;	/* String to look for */

{
    int ls1;
    ls1 = strlen (s1);
    return (strnsrch (s1, s2, ls1));
}

/*-------------------------------------------------------------------*/
/* Find string s2 within string s1 */

static char *
strnsrch (s1, s2, ls1)

char	*s1;	/* String to search */
char	*s2;	/* String to look for */
int	ls1;	/* Length of string being searched */

{
    char *s,*s1e;
    char cfirst,clast;
    int i,ls2;

    /* Return null string if either pointer is NULL */
    if (s1 == NULL || s2 == NULL)
	return (NULL);

    /* A zero-length pattern is found in any string */
    ls2 = strlen (s2);
    if (ls2 ==0)
	return (s1);

    /* Only a zero-length string can be found in a zero-length string */
    if (ls1 ==0)
	return (NULL);

    cfirst = s2[0];
    clast = s2[ls2-1];
    s1e = s1 + ls1 - ls2 + 1;
    s = s1;
    while (s < s1e) { 

	/* Search for first character in pattern string */
	if (*s == cfirst) {

	    /* If single character search, return */
	    if (ls2 == 1)
		return (s);

	    /* Search for last character in pattern string if first found */
	    if (s[ls2-1] == clast) {

		/* If two-character search, return */
		if (ls2 == 2)
		    return (s);

		/* If 3 or more characters, check for rest of search string */
		i = 1;
		while (i < ls2 && s[i] == s2[i])
		    i++;

		/* If entire string matches, return */
		if (i >= ls2)
		    return (s);
		}
	    }
	s++;
	}
    return (NULL);
}

/*-------------------------------------------------------------------*/
/*             the following routines were originally in hget.c      */
/*-------------------------------------------------------------------*/
/*  HPUTI4 - Set int keyword = ival in FITS header string */

static void
hputi4 (hstring,keyword,ival)

  char *hstring;	/* character string containing FITS-style header
			   information in the format
			   =  {/ }
			   each entry is padded with spaces to 80 characters */

  char *keyword;		/* character string containing the name of the variable
			   to be returned.  hput searches for a line beginning
			   with this string, and if there isn't one, creates one.
		   	   The first 8 characters of keyword must be unique. */
  int ival;		/* int number */
{
    char value[30];

    /* Translate value from binary to ASCII */
    sprintf (value,"%d",ival);

    /* Put value into header string */
    hputc (hstring,keyword,value);

    /* Return to calling program */
    return;
}

/*-------------------------------------------------------------------*/

/*  HPUTL - Set keyword = F if lval=0, else T, in FITS header string */

static void
hputl (hstring, keyword,lval)

char *hstring;		/* FITS header */
char *keyword;		/* Keyword name */
int lval;		/* logical variable (0=false, else true) */
{
    char value[8];

    /* Translate value from binary to ASCII */
    if (lval)
	strcpy (value, "T");
    else
	strcpy (value, "F");

    /* Put value into header string */
    hputc (hstring,keyword,value);

    /* Return to calling program */
    return;
}

/*-------------------------------------------------------------------*/

/*  HPUTS - Set character string keyword = 'cval' in FITS header string */

static void
hputs (hstring,keyword,cval)

char *hstring;	/* FITS header */
char *keyword;	/* Keyword name */
char *cval;	/* character string containing the value for variable
		   keyword.  trailing and leading blanks are removed.  */
{
    char squot = 39;
    char value[70];
    int lcval;

    /*  find length of variable string */

    lcval = strlen (cval);
    if (lcval > 67)
	lcval = 67;

    /* Put quotes around string */
    value[0] = squot;
    strncpy (&value[1],cval,lcval);
    value[lcval+1] = squot;
    value[lcval+2] = 0;

    /* Put value into header string */
    hputc (hstring,keyword,value);

    /* Return to calling program */
    return;
}

/*---------------------------------------------------------------------*/
/*  HPUTC - Set character string keyword = value in FITS header string */

static void
hputc (hstring,keyword,value)

char *hstring;
char *keyword;
char *value;	/* character string containing the value for variable
		   keyword.  trailing and leading blanks are removed.  */
{
    char squot = 39;
    char line[100];
    char newcom[50];
    char blank[80];
    char *v, *vp, *v1, *v2, *q1, *q2, *c1, *ve;
    int lkeyword, lcom, lval, lc, i;

    for (i = 0; i < 80; i++)
	blank[i] = ' ';

    /*  find length of keyword and value */
    lkeyword = strlen (keyword);
    lval = strlen (value);

    /*  If COMMENT or HISTORY, always add it just before the END */
    if (lkeyword == 7 && (strncmp (keyword,"COMMENT",7) == 0 ||
	strncmp (keyword,"HISTORY",7) == 0)) {

	/* Find end of header */
	v1 = ksearch (hstring,"END");
	v2 = v1 + 80;

	/* Move END down one line */
	strncpy (v2, v1, 80);

	/* Insert keyword */
	strncpy (v1,keyword,7);

	/* Pad with spaces */
	for (vp = v1+lkeyword; vp < v2; vp++)
	    *vp = ' ';

	/* Insert comment */
	strncpy (v1+9,value,lval);
	return;
	}

    /* Otherwise search for keyword */
    else
	v1 = ksearch (hstring,keyword);

    /*  If parameter is not found, find a place to put it */
    if (v1 == NULL) {
	
	/* First look for blank lines before END */
        v1 = blsearch (hstring, "END");
    
	/*  Otherwise, create a space for it at the end of the header */
	if (v1 == NULL) {
	    ve = ksearch (hstring,"END");
	    v1 = ve;
	    v2 = v1 + 80;
	    strncpy (v2, ve, 80);
	    }
	else
	    v2 = v1 + 80;
	lcom = 0;
	newcom[0] = 0;
	}

    /*  Otherwise, extract the entry for this keyword from the header */
    else {
	strncpy (line, v1, 80);
	line[80] = 0;
	v2 = v1 + 80;

	/*  check for quoted value */
	q1 = strchr (line, squot);
	if (q1 != NULL)
	    q2 = strchr (q1+1,squot);
	else
	    q2 = line;

	/*  extract comment and remove trailing spaces */

	c1 = strchr (q2,'/');
	if (c1 != NULL) {
	    lcom = 80 - (c1 - line);
	    strncpy (newcom, c1+1, lcom);
	    vp = newcom + lcom - 1;
	    while (vp-- > newcom && *vp == ' ')
		*vp = 0;
	    lcom = strlen (newcom);
	    }
	else {
	    newcom[0] = 0;
	    lcom = 0;
	    }
	}

    /* Fill new entry with spaces */
    for (vp = v1; vp < v2; vp++)
	*vp = ' ';

    /*  Copy keyword to new entry */
    strncpy (v1, keyword, lkeyword);

    /*  Add parameter value in the appropriate place */
    vp = v1 + 8;
    *vp = '=';
    vp = v1 + 9;
    *vp = ' ';
    vp = vp + 1;
    if (*value == squot) {
	strncpy (vp, value, lval);
	if (lval+12 > 31)
	    lc = lval + 12;
	else
	    lc = 30;
	}
    else {
	vp = v1 + 30 - lval;
	strncpy (vp, value, lval);
	lc = 30;
	}

    /* Add comment in the appropriate place */
	if (lcom > 0) {
	    if (lc+2+lcom > 80)
		lcom = 78 - lc;
	    vp = v1 + lc + 2;     /* Jul 16 1997: was vp = v1 + lc * 2 */
	    *vp = '/';
	    vp = vp + 1;
	    strncpy (vp, newcom, lcom);
	    for (v = vp + lcom; v < v2; v++)
		*v = ' ';
	    }

	return;
}

/*-------------------------------------------------------------------*/
/*  HPUTCOM - Set comment for keyword or on line in FITS header string */

static void
hputcom (hstring,keyword,comment)

  char *hstring;
  char *keyword;
  char *comment;
{
	char squot;
	char line[100];
	int lkeyword, lcom;
	char *vp, *v1, *v2, *c0 = NULL, *c1, *q1, *q2;

	squot = 39;

/*  Find length of variable name */
	lkeyword = strlen (keyword);

/*  If COMMENT or HISTORY, always add it just before the END */
	if (lkeyword == 7 && (strncmp (keyword,"COMMENT",7) == 0 ||
	    strncmp (keyword,"HISTORY",7) == 0)) {

	/* Find end of header */
	    v1 = ksearch (hstring,"END");
	    v2 = v1 + 80;
	    strncpy (v2, v1, 80);

	/*  blank out new line and insert keyword */
	    for (vp = v1; vp < v2; vp++)
		*vp = ' ';
	    strncpy (v1, keyword, lkeyword);
	    }

/* search header string for variable name */
	else {
	    v1 = ksearch (hstring,keyword);
	    v2 = v1 + 80;

	/* if parameter is not found, return without doing anything */
	    if (v1 == NULL) {
		return;
		}

	/* otherwise, extract entry for this variable from the header */
	    strncpy (line, v1, 80);

	/* check for quoted value */
	    q1 = strchr (line,squot);
	    if (q1 != NULL)
		q2 = strchr (q1+1,squot);
	    else
		q2 = NULL;

	    if (q2 == NULL || q2-line < 31)
		c0 = v1 + 31;
	    else
		c0 = v1 + (q2-line) + 2; /* allan: 1997-09-30, was c0=q2+2 */

	    strncpy (c0, "/ ",2);
	    }

/* create new entry */
	lcom = strlen (comment);

	if (lcom > 0) {
	    c1 = c0 + 2;
	    if (c1+lcom > v2)
		lcom = v2 - c1;
	    strncpy (c1, comment, lcom);
	    }

}
healpy-1.10.3/cfitsio/iter_a.c0000664000175000017500000001220513010375005016367 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include "fitsio.h"

/*
  This program illustrates how to use the CFITSIO iterator function.
  It reads and modifies the input 'iter_a.fit' file by computing a
  value for the 'rate' column as a function of the values in the other
  'counts' and 'time' columns.
*/
main()
{
    extern flux_rate(); /* external work function is passed to the iterator */
    fitsfile *fptr;
    iteratorCol cols[3];  /* structure used by the iterator function */
    int n_cols;
    long rows_per_loop, offset;

    int status, nkeys, keypos, hdutype, ii, jj;
    char filename[]  = "iter_a.fit";     /* name of rate FITS file */

    status = 0; 

    fits_open_file(&fptr, filename, READWRITE, &status); /* open file */

    /* move to the desired binary table extension */
    if (fits_movnam_hdu(fptr, BINARY_TBL, "RATE", 0, &status) )
        fits_report_error(stderr, status);    /* print out error messages */

    n_cols  = 3;   /* number of columns */

    /* define input column structure members for the iterator function */
    fits_iter_set_by_name(&cols[0], fptr, "COUNTS", TLONG,  InputCol);
    fits_iter_set_by_name(&cols[1], fptr, "TIME",   TFLOAT, InputCol);
    fits_iter_set_by_name(&cols[2], fptr, "RATE",   TFLOAT, OutputCol);

    rows_per_loop = 0;  /* use default optimum number of rows */
    offset = 0;         /* process all the rows */

    /* apply the rate function to each row of the table */
    printf("Calling iterator function...%d\n", status);

    fits_iterate_data(n_cols, cols, offset, rows_per_loop,
                      flux_rate, 0L, &status);

    fits_close_file(fptr, &status);      /* all done */

    if (status)
        fits_report_error(stderr, status);  /* print out error messages */

    return(status);
}
/*--------------------------------------------------------------------------*/
int flux_rate(long totalrows, long offset, long firstrow, long nrows,
             int ncols, iteratorCol *cols, void *user_strct ) 

/*
   Sample iterator function that calculates the output flux 'rate' column
   by dividing the input 'counts' by the 'time' column.
   It also applies a constant deadtime correction factor if the 'deadtime'
   keyword exists.  Finally, this creates or updates the 'LIVETIME'
   keyword with the sum of all the individual integration times.
*/
{
    int ii, status = 0;

    /* declare variables static to preserve their values between calls */
    static long *counts;
    static float *interval;
    static float *rate;
    static float deadtime, livetime; /* must preserve values between calls */

    /*--------------------------------------------------------*/
    /*  Initialization procedures: execute on the first call  */
    /*--------------------------------------------------------*/
    if (firstrow == 1)
    {
       if (ncols != 3)
           return(-1);  /* number of columns incorrect */

       if (fits_iter_get_datatype(&cols[0]) != TLONG  ||
           fits_iter_get_datatype(&cols[1]) != TFLOAT ||
           fits_iter_get_datatype(&cols[2]) != TFLOAT )
           return(-2);  /* bad data type */

       /* assign the input pointers to the appropriate arrays and null ptrs*/
       counts       = (long *)  fits_iter_get_array(&cols[0]);
       interval     = (float *) fits_iter_get_array(&cols[1]);
       rate         = (float *) fits_iter_get_array(&cols[2]);

       livetime = 0;  /* initialize the total integration time */

       /* try to get the deadtime keyword value */
       fits_read_key(cols[0].fptr, TFLOAT, "DEADTIME", &deadtime, '\0',
                     &status);
       if (status)
       {
           deadtime = 1.0;  /* default deadtime if keyword doesn't exist */
       }
       else if (deadtime < 0. || deadtime > 1.0)
       {
           return(-1);    /* bad deadtime value */
       }

       printf("deadtime = %f\n", deadtime);
    }

    /*--------------------------------------------*/
    /*  Main loop: process all the rows of data */
    /*--------------------------------------------*/

    /*  NOTE: 1st element of array is the null pixel value!  */
    /*  Loop from 1 to nrows, not 0 to nrows - 1.  */

    /* this version tests for null values */
    rate[0] = DOUBLENULLVALUE;   /* define the value that represents null */

    for (ii = 1; ii <= nrows; ii++)
    {
       if (counts[ii] == counts[0])   /*  undefined counts value? */
       {
           rate[ii] = DOUBLENULLVALUE;
       }
       else if (interval[ii] > 0.)
       {
           rate[ii] = counts[ii] / interval[ii] / deadtime;
           livetime += interval[ii];  /* accumulate total integration time */
       }
       else
           return(-2);  /* bad integration time */
    }

    /*-------------------------------------------------------*/
    /*  Clean up procedures:  after processing all the rows  */
    /*-------------------------------------------------------*/

    if (firstrow + nrows - 1 == totalrows)
    {
        /*  update the LIVETIME keyword value */

        fits_update_key(cols[0].fptr, TFLOAT, "LIVETIME", &livetime, 
                 "total integration time", &status);
        printf("livetime = %f\n", livetime);
   }
    return(0);  /* return successful status */
}
healpy-1.10.3/cfitsio/iter_a.f0000664000175000017500000001533213010375005016376 0ustar  zoncazonca00000000000000      program f77iterate_a

      external flux_rate
      integer ncols
      parameter (ncols=3)
      integer units(ncols), colnum(ncols), datatype(ncols)
      integer iotype(ncols), offset, rows_per_loop, status
      character*70 colname(ncols)
      integer iunit, blocksize
      character*80 fname

C     include f77.inc -------------------------------------
C     Codes for FITS extension types
      integer IMAGE_HDU, ASCII_TBL, BINARY_TBL
      parameter (
     &     IMAGE_HDU  = 0,
     &     ASCII_TBL  = 1,
     &     BINARY_TBL = 2  )

C     Codes for FITS table data types

      integer TBIT,TBYTE,TLOGICAL,TSTRING,TSHORT,TINT
      integer TFLOAT,TDOUBLE,TCOMPLEX,TDBLCOMPLEX
      parameter (
     &     TBIT        =   1,
     &     TBYTE       =  11,
     &     TLOGICAL    =  14,
     &     TSTRING     =  16,
     &     TSHORT      =  21,
     &     TINT        =  31,
     &     TFLOAT      =  42,
     &     TDOUBLE     =  82,
     &     TCOMPLEX    =  83,
     &     TDBLCOMPLEX = 163  )

C     Codes for iterator column types

      integer InputCol, InputOutputCol, OutputCol
      parameter (
     &     InputCol       = 0,
     &     InputOutputCol = 1,
     &     OutputCol      = 2  )
C     End of f77.inc -------------------------------------


      iunit = 15

      units(1) = iunit
      units(2) = iunit
      units(3) = iunit

C open the file
      fname = 'iter_a.fit'
      call ftopen(iunit,fname,1,blocksize,status)

C move to the HDU containing the rate table
      call ftmnhd(iunit, BINARY_TBL, 'RATE', 0, status)

C Select iotypes for column data
      iotype(1) = InputCol
      iotype(2) = InputCol
      iotype(3) = OutputCol

C Select desired datatypes for column data
      datatype(1) = TINT
      datatype(2) = TFLOAT
      datatype(3) = TFLOAT

C find the column number corresponding to each column
      call ftgcno( iunit, 0, 'counts', colnum(1), status )
      call ftgcno( iunit, 0, 'time', colnum(2), status )
      call ftgcno( iunit, 0, 'rate', colnum(3), status )

C use default optimum number of rows
      rows_per_loop = 0
      offset = 0

C apply the rate function to each row of the table
      print *, 'Calling iterator function...', status

C although colname is not being used, still need to send a string
C array in the function
      call ftiter( ncols, units, colnum, colname, datatype, iotype,
     &      offset, rows_per_loop, flux_rate, 3, status )

      call ftclos(iunit, status)
      stop
      end

C***************************************************************************
C   Sample iterator function that calculates the output flux 'rate' column
C   by dividing the input 'counts' by the 'time' column.
C   It also applies a constant deadtime correction factor if the 'deadtime'
C   keyword exists.  Finally, this creates or updates the 'LIVETIME'
C   keyword with the sum of all the individual integration times.
C***************************************************************************
      subroutine flux_rate(totalrows, offset, firstrow, nrows, ncols,
     &     units, colnum, datatype, iotype, repeat, status, userData,
     &     counts, interval, rate )

      integer totalrows, offset, firstrow, nrows, ncols
      integer units(ncols), colnum(ncols), datatype(ncols)
      integer iotype(ncols), repeat(ncols)
      integer userData

C     include f77.inc -------------------------------------
C     Codes for FITS extension types
      integer IMAGE_HDU, ASCII_TBL, BINARY_TBL
      parameter (
     &     IMAGE_HDU  = 0,
     &     ASCII_TBL  = 1,
     &     BINARY_TBL = 2  )

C     Codes for FITS table data types

      integer TBIT,TBYTE,TLOGICAL,TSTRING,TSHORT,TINT
      integer TFLOAT,TDOUBLE,TCOMPLEX,TDBLCOMPLEX
      parameter (
     &     TBIT        =   1,
     &     TBYTE       =  11,
     &     TLOGICAL    =  14,
     &     TSTRING     =  16,
     &     TSHORT      =  21,
     &     TINT        =  31,
     &     TFLOAT      =  42,
     &     TDOUBLE     =  82,
     &     TCOMPLEX    =  83,
     &     TDBLCOMPLEX = 163  )

C     Codes for iterator column types

      integer InputCol, InputOutputCol, OutputCol
      parameter (
     &     InputCol       = 0,
     &     InputOutputCol = 1,
     &     OutputCol      = 2  )
C     End of f77.inc -------------------------------------

      integer counts(*)
      real interval(*),rate(*)

      integer ii, status
      character*80 comment

C**********************************************************************
C  must preserve these values between calls
      real deadtime, livetime
      common /fluxblock/ deadtime, livetime
C**********************************************************************

      if (status .ne. 0) return

C    --------------------------------------------------------
C      Initialization procedures: execute on the first call  
C    --------------------------------------------------------
      if (firstrow .eq. 1) then
         if (ncols .ne. 3) then
C     wrong number of columns
            status = -1
            return
         endif

         if (datatype(1).ne.TINT .or. datatype(2).ne.TFLOAT .or.
     &        datatype(3).ne.TFLOAT ) then
C     bad data type
            status = -2
            return
         endif

C     try to get the deadtime keyword value
         call ftgkye( units(1), 'DEADTIME', deadtime, comment, status )

         if (status.ne.0) then
C     default deadtime if keyword doesn't exist
            deadtime = 1.0
            status = 0
         elseif (deadtime .lt. 0.0 .or. deadtime .gt. 1.0) then
C     bad deadtime value
            status = -3
            return
         endif

         print *, 'deadtime = ', deadtime

         livetime = 0.0
      endif

C    --------------------------------------------
C      Main loop: process all the rows of data
C    --------------------------------------------
      
C     NOTE: 1st element of array is the null pixel value!
C     Loop over elements 2 to nrows+1, not 1 to nrows.
      
C     this version ignores null values

C     set the output null value to zero to ignore nulls */
      rate(1) = 0.0
      do 10 ii = 2,nrows+1
         if ( interval(ii) .gt. 0.0) then
           rate(ii) = counts(ii) / interval(ii) / deadtime
           livetime = livetime + interval(ii)
        else
C     Nonsensical negative time interval
           status = -3
           return
        endif
 10   continue

C    -------------------------------------------------------
C      Clean up procedures:  after processing all the rows  
C    -------------------------------------------------------

      if (firstrow + nrows - 1 .eq. totalrows) then
C     update the LIVETIME keyword value

         call ftukye( units(1),'LIVETIME', livetime, 3,
     &        'total integration time', status )
         print *,'livetime = ', livetime

      endif
 
      return
      end
healpy-1.10.3/cfitsio/iter_a.fit0000664000175000017500000037510013010375005016735 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   16 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format defined in Astronomy andCOMMENT   Astrophysics Supplement Series v44/p363, v44/p371, v73/p359, v73/p365.COMMENT   Contact the NASA Science Office of Standards and Technology for the   COMMENT   FITS Definition document #100 and other FITS information.             HISTORY    TASK:FMERGE on file ratefile.fits                                    HISTORY   fmerge3.1c at 29/12/97 16:1:37.                                       HISTORY    TASK:FMERGE on file m1.fits                                          HISTORY   fmerge3.1c at 29/12/97 16:2:30.                                       HISTORY    TASK:FMERGE on file m3.fits                                          HISTORY   fmerge3.1c at 29/12/97 16:3:38.                                       HISTORY    TASK:FMERGE on file m5.fits                                          HISTORY   fmerge3.1c at 29/12/97 16:4:15.                                       HISTORY    TASK:FMERGE on file m7.fits                                          HISTORY   fmerge3.1c at 29/12/97 16:5:1.0                                       HISTORY    TASK:FMERGE on file m9.fits                                          HISTORY   fmerge3.1c at 29/12/97 16:6:48.                                       END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   12 / width of table in bytes                        NAXIS2  =                10000 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   TTYPE1  = 'Counts  '           / label for field   1                            TFORM1  = 'J       '           / data format of field: 4-byte INTEGER           TTYPE2  = 'Time    '           / label for field   2                            TFORM2  = 'E       '           / data format of field: 4-byte REAL              TTYPE3  = 'Rate    '           / label for field   3                            TFORM3  = 'E       '           / data format of field: 4-byte REAL              EXTNAME = 'rate    '           / name of this binary table extension            DEADTIME=                  1.0                                                  HISTORY   This FITS file was created by the FCREATE task.                       HISTORY   fcreate3.1 at 29/12/97                                                HISTORY   File modified by user 'pence' with fv  on 97-12-29T15:45:06           HISTORY   File modified by user 'pence' with fv  on 97-12-29T15:54:30           LIVETIME=              30554.5 / total integration time                         HISTORY    TASK:FMERGE copied   26924 rows from file ratefile.fits              HISTORY    TASK:FMERGE appended   26924 rows from file r2.fits                  HISTORY    TASK:FMERGE copied   53848 rows from file m1.fits                    HISTORY    TASK:FMERGE appended   53848 rows from file m2.fits                  HISTORY    TASK:FMERGE copied  107696 rows from file m3.fits                    HISTORY    TASK:FMERGE appended  107696 rows from file m4.fits                  HISTORY    TASK:FMERGE copied  215392 rows from file m5.fits                    HISTORY    TASK:FMERGE appended  215392 rows from file m6.fits                  HISTORY    TASK:FMERGE copied  430784 rows from file m7.fits                    HISTORY    TASK:FMERGE appended  430784 rows from file m8.fits                  HISTORY    TASK:FMERGE copied  861568 rows from file m9.fits                    HISTORY    TASK:FMERGE appended  861568 rows from file m10.fits                 HISTORY   File modified by user 'pence' with fv  on 97-12-30T10:44:37           HISTORY   File modified by user 'pence' with fv  on 97-12-30T10:51:44           HISTORY   ftabcopy V4.0a copied columns from ratefile.fits                      HISTORY   ftabcopy V4.0a at 5/1/98 23:10:24                                     END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@@@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@@@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@?@dA A ?@?@@@AUU-@@
?A @@?@healpy-1.10.3/cfitsio/iter_b.c0000664000175000017500000000716613010375005016402 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include "fitsio.h"

/*
  This program illustrates how to use the CFITSIO iterator function.
  It simply prints out the values in a character string and a logical
  type column in a table, and toggles the value in the logical column
  so that T -> F and F -> T.
*/
main()
{
    extern str_iter(); /* external work function is passed to the iterator */
    fitsfile *fptr;
    iteratorCol cols[2];
    int n_cols;
    long rows_per_loop, offset;
    int status = 0;
    char filename[]  = "iter_b.fit";     /* name of rate FITS file */

    /* open the file and move to the correct extension */
    fits_open_file(&fptr, filename, READWRITE, &status);
    fits_movnam_hdu(fptr, BINARY_TBL, "iter_test", 0, &status);

    /* define input column structure members for the iterator function */
    n_cols  = 2;   /* number of columns */

    /* define input column structure members for the iterator function */
    fits_iter_set_by_name(&cols[0], fptr, "Avalue", TSTRING,  InputOutputCol);
    fits_iter_set_by_name(&cols[1], fptr, "Lvalue", TLOGICAL, InputOutputCol);

    rows_per_loop = 0;  /* use default optimum number of rows */
    offset = 0;         /* process all the rows */

    /* apply the  function to each row of the table */
    printf("Calling iterator function...%d\n", status);

    fits_iterate_data(n_cols, cols, offset, rows_per_loop,
                      str_iter, 0L, &status);

    fits_close_file(fptr, &status);      /* all done */

    if (status)
       fits_report_error(stderr, status); /* print out error messages */

    return(status);
}
/*--------------------------------------------------------------------------*/
int str_iter(long totalrows, long offset, long firstrow, long nrows,
             int ncols, iteratorCol *cols, void *user_strct )

/*
   Sample iterator function.
*/
{
    int ii;

    /* declare variables static to preserve their values between calls */
    static char **stringvals;
    static char *logicalvals;

    /*--------------------------------------------------------*/
    /*  Initialization procedures: execute on the first call  */
    /*--------------------------------------------------------*/
    if (firstrow == 1)
    {
       if (ncols != 2)
           return(-1);  /* number of columns incorrect */

       if (fits_iter_get_datatype(&cols[0]) != TSTRING ||
           fits_iter_get_datatype(&cols[1]) != TLOGICAL )
           return(-2);  /* bad data type */

       /* assign the input pointers to the appropriate arrays */
       stringvals       = (char **) fits_iter_get_array(&cols[0]);
       logicalvals      = (char *)  fits_iter_get_array(&cols[1]);

       printf("Total rows, No. rows = %d %d\n",totalrows, nrows);
    }

    /*------------------------------------------*/
    /*  Main loop: process all the rows of data */
    /*------------------------------------------*/

    /*  NOTE: 1st element of array is the null pixel value!  */
    /*  Loop from 1 to nrows, not 0 to nrows - 1.  */
   
    for (ii = 1; ii <= nrows; ii++)
    {
      printf("%s %d\n", stringvals[ii], logicalvals[ii]);
      if (logicalvals[ii])
      {
         logicalvals[ii] = FALSE;
         strcpy(stringvals[ii], "changed to false");
      }
      else
      {
         logicalvals[ii] = TRUE;
         strcpy(stringvals[ii], "changed to true");
      }
    }

    /*-------------------------------------------------------*/
    /*  Clean up procedures:  after processing all the rows  */
    /*-------------------------------------------------------*/

    if (firstrow + nrows - 1 == totalrows)
    {
      /* no action required in this case */
    }
 
    return(0);
}
healpy-1.10.3/cfitsio/iter_b.f0000664000175000017500000001305713010375005016401 0ustar  zoncazonca00000000000000      program f77iterate_b

C     external work function is passed to the iterator
      external str_iter

      integer ncols
      parameter (ncols=2)
      integer units(ncols), colnum(ncols), datatype(ncols)
      integer iotype(ncols), offset, rows_per_loop, status
      character*70 colname(ncols)

      integer iunit, blocksize
      character*80 fname

C     include f77.inc -------------------------------------
C     Codes for FITS extension types
      integer IMAGE_HDU, ASCII_TBL, BINARY_TBL
      parameter (
     &     IMAGE_HDU  = 0,
     &     ASCII_TBL  = 1,
     &     BINARY_TBL = 2  )

C     Codes for FITS table data types

      integer TBIT,TBYTE,TLOGICAL,TSTRING,TSHORT,TINT
      integer TFLOAT,TDOUBLE,TCOMPLEX,TDBLCOMPLEX
      parameter (
     &     TBIT        =   1,
     &     TBYTE       =  11,
     &     TLOGICAL    =  14,
     &     TSTRING     =  16,
     &     TSHORT      =  21,
     &     TINT        =  31,
     &     TFLOAT      =  42,
     &     TDOUBLE     =  82,
     &     TCOMPLEX    =  83,
     &     TDBLCOMPLEX = 163  )

C     Codes for iterator column types

      integer InputCol, InputOutputCol, OutputCol
      parameter (
     &     InputCol       = 0,
     &     InputOutputCol = 1,
     &     OutputCol      = 2  )
C     End of f77.inc -------------------------------------

      status = 0

      fname = 'iter_b.fit'
      iunit = 15

C     both columns are in the same FITS file
      units(1) = iunit
      units(2) = iunit

C     open the file and move to the correct extension
      call ftopen(iunit,fname,1,blocksize,status)
      call ftmnhd(iunit, BINARY_TBL, 'iter_test', 0, status)

C     define the desired columns by name
      colname(1) = 'Avalue'
      colname(2) = 'Lvalue'

C     leave column numbers undefined
      colnum(1) = 0
      colnum(2) = 0  

C     define the desired datatype for each column: TSTRING & TLOGICAL
      datatype(1) = TSTRING
      datatype(2) = TLOGICAL

C     define whether columns are input, input/output, or output only
C     Both in/out
      iotype(1) = InputOutputCol
      iotype(2) = InputOutputCol
 
C     use default optimum number of rows and process all the rows
      rows_per_loop = 0
      offset = 0

C     apply the  function to each row of the table
      print *,'Calling iterator function...', status

      call ftiter( ncols, units, colnum, colname, datatype, iotype,
     &      offset, rows_per_loop, str_iter, 0, status )

      call ftclos(iunit, status)

C     print out error messages if problem
      if (status.ne.0) call ftrprt('STDERR', status)
      stop
      end

C--------------------------------------------------------------------------
C
C   Sample iterator function.
C
C--------------------------------------------------------------------------
      subroutine str_iter(totalrows, offset, firstrow, nrows, ncols,
     &     units, colnum, datatype, iotype, repeat, status, 
     &     userData, stringCol, logicalCol )

      integer totalrows,offset,firstrow,nrows,ncols,status
      integer units(*),colnum(*),datatype(*),iotype(*),repeat(*)
      integer userData
      character*(*) stringCol(*)
      logical logicalCol(*)

      integer ii

C     include f77.inc -------------------------------------
C     Codes for FITS extension types
      integer IMAGE_HDU, ASCII_TBL, BINARY_TBL
      parameter (
     &     IMAGE_HDU  = 0,
     &     ASCII_TBL  = 1,
     &     BINARY_TBL = 2  )

C     Codes for FITS table data types

      integer TBIT,TBYTE,TLOGICAL,TSTRING,TSHORT,TINT
      integer TFLOAT,TDOUBLE,TCOMPLEX,TDBLCOMPLEX
      parameter (
     &     TBIT        =   1,
     &     TBYTE       =  11,
     &     TLOGICAL    =  14,
     &     TSTRING     =  16,
     &     TSHORT      =  21,
     &     TINT        =  31,
     &     TFLOAT      =  42,
     &     TDOUBLE     =  82,
     &     TCOMPLEX    =  83,
     &     TDBLCOMPLEX = 163  )

C     Codes for iterator column types

      integer InputCol, InputOutputCol, OutputCol
      parameter (
     &     InputCol       = 0,
     &     InputOutputCol = 1,
     &     OutputCol      = 2  )
C     End of f77.inc -------------------------------------

      if (status .ne. 0) return

C    --------------------------------------------------------
C      Initialization procedures: execute on the first call  
C    --------------------------------------------------------
      if (firstrow .eq. 1) then
         if (ncols .ne. 2) then
            status = -1
            return
         endif
         
         if (datatype(1).ne.TSTRING .or. datatype(2).ne.TLOGICAL) then
            status = -2
            return
         endif
         
         print *,'Total rows, No. rows = ',totalrows, nrows
         
      endif
      
C     -------------------------------------------
C       Main loop: process all the rows of data 
C     -------------------------------------------
      
C     NOTE: 1st element of array is the null pixel value!
C     Loop over elements 2 to nrows+1, not 1 to nrows.
      
      do 10 ii=2,nrows+1
         print *, stringCol(ii), logicalCol(ii)
         if( logicalCol(ii) ) then
            logicalCol(ii) = .false.
            stringCol(ii) = 'changed to false'
         else
            logicalCol(ii) = .true.
            stringCol(ii) = 'changed to true'
         endif
 10   continue
      
C     -------------------------------------------------------
C     Clean up procedures:  after processing all the rows  
C     -------------------------------------------------------
      
      if (firstrow + nrows - 1 .eq. totalrows) then
C     no action required in this case
      endif
      
      return
      end
      
healpy-1.10.3/cfitsio/iter_b.fit0000664000175000017500000143660013010375005016742 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   16 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format defined in Astronomy andCOMMENT   Astrophysics Supplement Series v44/p363, v44/p371, v73/p359, v73/p365.COMMENT   Contact the NASA Science Office of Standards and Technology for the   COMMENT   FITS Definition document #100 and other FITS information.             END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                 4021 / width of table in bytes                        NAXIS2  =                  100 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   TTYPE1  = 'Avalue  '           / label for field   1                            TFORM1  = '20A     '           / data format of field: ASCII Character          TTYPE2  = 'Lvalue  '           / label for field   2                            TFORM2  = '1L      '           / data format of field: 1-byte LOGICAL           TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Evalue  '           / label for field   3                            TFORM3  = '1000E   '           / data format of field: 4-byte REAL              TUNIT3  = 'cm      '           / physical unit of field                         EXTNAME = 'iter_test'          / name of this binary table extension            END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             changed to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to false    Fchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Tchanged to true     Thealpy-1.10.3/cfitsio/iter_c.c0000664000175000017500000001356713010375005016405 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include "fitsio.h"

/*
    This example program illustrates how to use the CFITSIO iterator function.

    This program creates a 2D histogram of the X and Y columns of an event
    list.  The 'main' routine just creates the empty new image, then executes
    the 'writehisto' work function by calling the CFITSIO iterator function.

    'writehisto' opens the FITS event list that contains the X and Y columns.
    It then calls a second work function, calchisto, (by recursively calling
    the CFITSIO iterator function) which actually computes the 2D histogram.
*/

/*   Globally defined parameters */

long xsize = 480; /* size of the histogram image */
long ysize = 480;
long xbinsize = 32;
long ybinsize = 32;

main()
{
    extern writehisto();  /* external work function passed to the iterator */
    extern long xsize, ysize;  /* size of image */

    fitsfile *fptr;
    iteratorCol cols[1];
    int n_cols, status = 0;
    long n_per_loop, offset, naxes[2];
    char filename[]  = "histoimg.fit";     /* name of FITS image */

    remove(filename);   /* delete previous version of the file if it exists */
    fits_create_file(&fptr, filename, &status);  /* create new output image */

    naxes[0] = xsize;
    naxes[1] = ysize;
    fits_create_img(fptr, LONG_IMG, 2, naxes, &status); /* create primary HDU */

    n_cols  = 1;   /* number of columns */

    /* define input column structure members for the iterator function */
    fits_iter_set_by_name(&cols[0], fptr, " ", TLONG, OutputCol);

    n_per_loop = -1;  /* force whole array to be passed at one time */
    offset = 0;       /* don't skip over any pixels */

    /* execute the function to create and write the 2D histogram */
    printf("Calling writehisto iterator work function... %d\n", status);

    fits_iterate_data(n_cols, cols, offset, n_per_loop,
                      writehisto, 0L, &status);

    fits_close_file(fptr, &status);      /* all done; close the file */

    if (status)
        fits_report_error(stderr, status);  /* print out error messages */
    else
        printf("Program completed successfully.\n");

    return(status);
}
/*--------------------------------------------------------------------------*/
int writehisto(long totaln, long offset, long firstn, long nvalues,
             int narrays, iteratorCol *histo, void *userPointer)
/*
   Iterator work function that writes out the 2D histogram.
   The histogram values are calculated by another work function, calchisto.

   This routine is executed only once since nvalues was forced to = totaln.
*/
{
    extern calchisto();  /* external function called by the iterator */
    long *histogram;
    fitsfile *tblptr;
    iteratorCol cols[2];
    int n_cols, status = 0;
    long rows_per_loop, rowoffset;
    char filename[]  = "iter_c.fit";     /* name of FITS table */

    /* do sanity checking of input values */
    if (totaln != nvalues)
        return(-1);  /* whole image must be passed at one time */

    if (narrays != 1)
        return(-2);  /* number of images is incorrect */

    if (fits_iter_get_datatype(&histo[0]) != TLONG)
        return(-3);  /* input array has wrong data type */

    /* assign the FITS array pointer to the global histogram pointer */
    histogram = (long *) fits_iter_get_array(&histo[0]);

    /* open the file and move to the table containing the X and Y columns */
    fits_open_file(&tblptr, filename, READONLY, &status);
    fits_movnam_hdu(tblptr, BINARY_TBL, "EVENTS", 0, &status);
    if (status)
       return(status);
   
    n_cols = 2; /* number of columns */

    /* define input column structure members for the iterator function */
    fits_iter_set_by_name(&cols[0], tblptr, "X", TLONG,  InputCol);
    fits_iter_set_by_name(&cols[1], tblptr, "Y", TLONG, InputCol);

    rows_per_loop = 0;  /* take default number of rows per interation */
    rowoffset = 0;     

    /* calculate the histogram */
    printf("Calling calchisto iterator work function... %d\n", status);

    fits_iterate_data(n_cols, cols, rowoffset, rows_per_loop,
                      calchisto, histogram, &status);

    fits_close_file(tblptr, &status);      /* all done */
    return(status);
}
/*--------------------------------------------------------------------------*/
int calchisto(long totalrows, long offset, long firstrow, long nrows,
             int ncols, iteratorCol *cols, void *userPointer)

/*
   Interator work function that calculates values for the 2D histogram.
*/
{
    extern long xsize, ysize, xbinsize, ybinsize;
    long ii, ihisto, xbin, ybin;
    static long *xcol, *ycol, *histogram;  /* static to preserve values */

    /*--------------------------------------------------------*/
    /*  Initialization procedures: execute on the first call  */
    /*--------------------------------------------------------*/
    if (firstrow == 1)
    {
        /* do sanity checking of input values */
       if (ncols != 2)
         return(-3);  /* number of arrays is incorrect */

       if (fits_iter_get_datatype(&cols[0]) != TLONG ||
           fits_iter_get_datatype(&cols[1]) != TLONG)
         return(-4);  /* wrong datatypes */

       /* assign the input array points to the X and Y arrays */
       xcol = (long *) fits_iter_get_array(&cols[0]);
       ycol = (long *) fits_iter_get_array(&cols[1]);
       histogram = (long *) userPointer;

       /* initialize the histogram image pixels = 0 */
       for (ii = 0; ii <= xsize * ysize; ii++)
           histogram[ii] = 0L;
    }

    /*------------------------------------------------------------------*/
    /*  Main loop: increment the 2D histogram at position of each event */
    /*------------------------------------------------------------------*/

    for (ii = 1; ii <= nrows; ii++) 
    {
        xbin = xcol[ii] / xbinsize;
        ybin = ycol[ii] / ybinsize;

        ihisto = ( ybin * xsize ) + xbin + 1;
        histogram[ihisto]++;
    }

    return(0);
}

healpy-1.10.3/cfitsio/iter_c.f0000664000175000017500000002443513010375005016404 0ustar  zoncazonca00000000000000      program f77iterate_c
C
C    This example program illustrates how to use the CFITSIO iterator function.
C
C    This program creates a 2D histogram of the X and Y columns of an event
C    list.  The 'main' routine just creates the empty new image, then executes
C    the 'writehisto' work function by calling the CFITSIO iterator function.
C
C    'writehisto' opens the FITS event list that contains the X and Y columns.
C    It then calls a second work function, calchisto, (by recursively calling
C    the CFITSIO iterator function) which actually computes the 2D histogram.

C     external work function to be passed to the iterator
      external writehisto

      integer ncols
      parameter (ncols=1)
      integer units(ncols), colnum(ncols), datatype(ncols)
      integer iotype(ncols), offset, n_per_loop, status
      character*70 colname(ncols)

      integer naxes(2), ounit, blocksize
      character*80 fname
      logical exists

C     include f77.inc -------------------------------------
C     Codes for FITS extension types
      integer IMAGE_HDU, ASCII_TBL, BINARY_TBL
      parameter (
     &     IMAGE_HDU  = 0,
     &     ASCII_TBL  = 1,
     &     BINARY_TBL = 2  )

C     Codes for FITS table data types

      integer TBIT,TBYTE,TLOGICAL,TSTRING,TSHORT,TINT
      integer TFLOAT,TDOUBLE,TCOMPLEX,TDBLCOMPLEX
      parameter (
     &     TBIT        =   1,
     &     TBYTE       =  11,
     &     TLOGICAL    =  14,
     &     TSTRING     =  16,
     &     TSHORT      =  21,
     &     TINT        =  31,
     &     TFLOAT      =  42,
     &     TDOUBLE     =  82,
     &     TCOMPLEX    =  83,
     &     TDBLCOMPLEX = 163  )

C     Codes for iterator column types

      integer InputCol, InputOutputCol, OutputCol
      parameter (
     &     InputCol       = 0,
     &     InputOutputCol = 1,
     &     OutputCol      = 2  )
C     End of f77.inc -------------------------------------

C**********************************************************************
C     Need to make these variables available to the 2 work functions
      integer xsize,ysize,xbinsize,ybinsize
      common /histcomm/ xsize,ysize,xbinsize,ybinsize
C**********************************************************************

      status = 0

      xsize = 480
      ysize = 480
      xbinsize = 32
      ybinsize = 32

      fname = 'histoimg.fit'
      ounit = 15

C     delete previous version of the file if it exists
      inquire(file=fname,exist=exists)
      if( exists ) then
         open(ounit,file=fname,status='old')
         close(ounit,status='delete')
      endif
 99   blocksize = 2880

C     create new output image
      call ftinit(ounit,fname,blocksize,status)

      naxes(1) = xsize
      naxes(2) = ysize

C     create primary HDU
      call ftiimg(ounit,32,2,naxes,status)

      units(1) = ounit

C     Define column as TINT and Output
      datatype(1) = TINT
      iotype(1) = OutputCol

C     force whole array to be passed at one time
      n_per_loop = -1
      offset = 0

C     execute the function to create and write the 2D histogram
      print *,'Calling writehisto iterator work function... ',status

      call ftiter( ncols, units, colnum, colname, datatype, iotype,
     &      offset, n_per_loop, writehisto, 0, status )

      call ftclos(ounit, status)

C     print out error messages if problem
      if (status.ne.0) then
         call ftrprt('STDERR', status)
      else
        print *,'Program completed successfully.'
      endif

      stop
      end

C--------------------------------------------------------------------------
C
C   Sample iterator function.
C
C   Iterator work function that writes out the 2D histogram.
C   The histogram values are calculated by another work function, calchisto.
C
C--------------------------------------------------------------------------
      subroutine writehisto(totaln, offset, firstn, nvalues, narrays,
     &     units_out, colnum_out, datatype_out, iotype_out, repeat,
     &     status, userData, histogram )

      integer totaln,offset,firstn,nvalues,narrays,status
      integer units_out(narrays),colnum_out(narrays)
      integer datatype_out(narrays),iotype_out(narrays)
      integer repeat(narrays)
      integer histogram(*), userData

      external calchisto
      integer ncols
      parameter (ncols=2)
      integer units(ncols), colnum(ncols), datatype(ncols)
      integer iotype(ncols), rowoffset, rows_per_loop
      character*70 colname(ncols)

      integer iunit, blocksize
      character*80 fname

C     include f77.inc -------------------------------------
C     Codes for FITS extension types
      integer IMAGE_HDU, ASCII_TBL, BINARY_TBL
      parameter (
     &     IMAGE_HDU  = 0,
     &     ASCII_TBL  = 1,
     &     BINARY_TBL = 2  )

C     Codes for FITS table data types

      integer TBIT,TBYTE,TLOGICAL,TSTRING,TSHORT,TINT
      integer TFLOAT,TDOUBLE,TCOMPLEX,TDBLCOMPLEX
      parameter (
     &     TBIT        =   1,
     &     TBYTE       =  11,
     &     TLOGICAL    =  14,
     &     TSTRING     =  16,
     &     TSHORT      =  21,
     &     TINT        =  31,
     &     TFLOAT      =  42,
     &     TDOUBLE     =  82,
     &     TCOMPLEX    =  83,
     &     TDBLCOMPLEX = 163  )

C     Codes for iterator column types

      integer InputCol, InputOutputCol, OutputCol
      parameter (
     &     InputCol       = 0,
     &     InputOutputCol = 1,
     &     OutputCol      = 2  )
C     End of f77.inc -------------------------------------

C**********************************************************************
C     Need to make these variables available to the 2 work functions
      integer xsize,ysize,xbinsize,ybinsize
      common /histcomm/ xsize,ysize,xbinsize,ybinsize
C**********************************************************************

      if (status .ne. 0) return

C     name of FITS table
      fname = 'iter_c.fit'
      iunit = 16

C     do sanity checking of input values
      if (totaln .ne. nvalues) then
C     whole image must be passed at one time
         status = -1
         return
      endif

      if (narrays .ne. 1) then
C     number of images is incorrect
         status = -2
         return
      endif

      if (datatype_out(1) .ne. TINT) then
C     input array has wrong data type
         status = -3
         return
      endif

C     open the file and move to the table containing the X and Y columns
      call ftopen(iunit,fname,0,blocksize,status)
      call ftmnhd(iunit, BINARY_TBL, 'EVENTS', 0, status)
      if (status) return
   
C     both the columns are in the same FITS file
      units(1) = iunit
      units(2) = iunit

C     desired datatype for each column: TINT
      datatype(1) = TINT
      datatype(2) = TINT

C     names of the columns
      colname(1) = 'X'
      colname(2) = 'Y'

C     leave column numbers undefined
      colnum(1) = 0
      colnum(2) = 0

C     define whether columns are input, input/output, or output only
C     Both input
      iotype(1) = InputCol
      iotype(1) = InputCol
 
C     take default number of rows per iteration
      rows_per_loop = 0
      rowoffset = 0

C     calculate the histogram
      print *,'Calling calchisto iterator work function... ', status

      call ftiter( ncols, units, colnum, colname, datatype, iotype,
     &      rowoffset, rows_per_loop, calchisto, histogram, status )

      call ftclos(iunit,status)
      return
      end

C--------------------------------------------------------------------------
C
C   Iterator work function that calculates values for the 2D histogram.
C
C--------------------------------------------------------------------------
      subroutine calchisto(totalrows, offset, firstrow, nrows, ncols,
     &     units, colnum, datatype, iotype, repeat, status, 
     &     histogram, xcol, ycol )

      integer totalrows,offset,firstrow,nrows,ncols,status
      integer units(ncols),colnum(ncols),datatype(ncols)
      integer iotype(ncols),repeat(ncols)
      integer histogram(*),xcol(*),ycol(*)
C     include f77.inc -------------------------------------
C     Codes for FITS extension types
      integer IMAGE_HDU, ASCII_TBL, BINARY_TBL
      parameter (
     &     IMAGE_HDU  = 0,
     &     ASCII_TBL  = 1,
     &     BINARY_TBL = 2  )

C     Codes for FITS table data types

      integer TBIT,TBYTE,TLOGICAL,TSTRING,TSHORT,TINT
      integer TFLOAT,TDOUBLE,TCOMPLEX,TDBLCOMPLEX
      parameter (
     &     TBIT        =   1,
     &     TBYTE       =  11,
     &     TLOGICAL    =  14,
     &     TSTRING     =  16,
     &     TSHORT      =  21,
     &     TINT        =  31,
     &     TFLOAT      =  42,
     &     TDOUBLE     =  82,
     &     TCOMPLEX    =  83,
     &     TDBLCOMPLEX = 163  )

C     Codes for iterator column types

      integer InputCol, InputOutputCol, OutputCol
      parameter (
     &     InputCol       = 0,
     &     InputOutputCol = 1,
     &     OutputCol      = 2  )
C     End of f77.inc -------------------------------------

      integer ii, ihisto, xbin, ybin

C**********************************************************************
C     Need to make these variables available to the 2 work functions
      integer xsize,ysize,xbinsize,ybinsize
      common /histcomm/ xsize,ysize,xbinsize,ybinsize
C**********************************************************************

      if (status .ne. 0) return

C    --------------------------------------------------------
C      Initialization procedures: execute on the first call  
C    --------------------------------------------------------
      if (firstrow .eq. 1) then
C     do sanity checking of input values

         if (ncols .ne. 2) then
C     number of arrays is incorrect
            status = -4
            return
         endif

         if (datatype(1).ne.TINT .or. datatype(2).ne.TINT) then
C     wrong datatypes
            status = -5
            return
         endif

C     initialize the histogram image pixels = 0, including null value
         do 10 ii = 1, xsize * ysize + 1
            histogram(ii) = 0
 10     continue

      endif

C     ------------------------------------------------------------------
C       Main loop: increment the 2D histogram at position of each event 
C     ------------------------------------------------------------------

      do 20 ii=2,nrows+1
        xbin = xcol(ii) / xbinsize
        ybin = ycol(ii) / ybinsize

        ihisto = ( ybin * xsize ) + xbin + 2
        histogram(ihisto) = histogram(ihisto) + 1
 20   continue

      return
      end

healpy-1.10.3/cfitsio/iter_c.fit0000664000175000017500000026400013010375005016733 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format defined in Astronomy andCOMMENT   Astrophysics Supplement Series v44/p363, v44/p371, v73/p359, v73/p365.COMMENT   Contact the NASA Science Office of Standards and Technology for the   COMMENT   FITS Definition document #100 and other FITS information.             END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'  /  FITS 3D BINARY TABLE                                   BITPIX  =                    8  /  Binary data                                  NAXIS   =                    2  /  Table is a matrix                            NAXIS1  =                   16 /  Width of table in bytes                       NAXIS2  =                 5000 /  Number of entries in table                    PCOUNT  =                    0  /  Random parameter count                       GCOUNT  =                    1  /  Group count                                  TFIELDS =                    5 /  Number of fields in each row                  EXTNAME = 'EVENTS  '  /  Table name                                             EXTVER  =                    1  /  Version number of table                      TFORM1  = '1I      '  /  Data type for field                                    TTYPE1  = 'X       '  /  Label for field                                        TUNIT1  = '        '  /  Physical units for field                               TFORM2  = '1I      '  /  Data type for field                                    TTYPE2  = 'Y       '  /  Label for field                                        TUNIT2  = '        '  /  Physical units for field                               TFORM3  = '1I      '  /  Data type for field                                    TTYPE3  = 'PHA     '  /  Label for field                                        TUNIT3  = '        '  /  Physical units for field                               TFORM4  = '1D      '  /  Data type for field                                    TTYPE4  = 'TIME    '  /  Label for field                                        TUNIT4  = '        '  /  Physical units for field                               TFORM5  = '1I      '  /  Data type for field                                    TTYPE5  = 'DY      '  /  Label for field                                        TUNIT5  = '        '  /  Physical units for field                               TLMIN1  =                    1                                                  TLMAX1  =                15360                                                  TLMIN2  =                    1                                                  TLMAX2  =                15360                                                  NAXLEN  =                    2  /  Number of QPOE axes                          AXLEN1  =                15360  /  Dim. of qpoe axis 1                          AXLEN2  =                15360  /  Dim. of qpoe axis 2                          TELESCOP= 'ROSAT   '  /  telescope (mission) name                               INSTRUME= 'PSPC    '  /  instrument (detector) name                             RADECSYS= 'FK5     '  /  WCS for this file (e.g. Fk4)                           EQUINOX =           2.000000E3  /  equinox (epoch) for WCS                      CTYPE1  = 'RA---TAN'  /  axis type for dim. 1 (e.g. RA---TAN)                   CTYPE2  = 'DEC--TAN'  /  axis type for dim. 2 (e.g. DEC--TAN)                   CRVAL1  =           8.588000E1  /  sky coord of 1st axis (deg.)                 CRVAL2  =           6.926986E1  /  sky coord of 2nd axis (deg.)                 CDELT1  =         -1.388889E-4  /  x degrees per pixel                          CDELT2  =          1.388889E-4  /  y degrees per pixel                          CRPIX1  =           7.680000E3  /  x pixel of tangent plane direction           CRPIX2  =           7.680000E3  /  y pixel of tangent plane direction           CROTA2  =           0.000000E0  /  rotation angle (degrees)                     MJD-OBS =           4.905444E4  /  MJD of start of obs.                         DATE-OBS= '08/03/93'  /  date of observation start                              TIME-OBS= '10:30:32'  /  time of observation start                              DATE-END= '11/03/93'  /  date of observation end                                TIME-END= '05:02:18'  /  time of observation end                                XS-OBSID= 'US800282P.N1    '  /  observation ID                                 XS-SEQPI= 'ROTS, DR., ARNOLD,H.                                           '  /  XS-SUBIN=                    2  /  subinstrument id                             XS-OBSV =               800282  /  observer id                                  XS-CNTRY= 'USA     '  /  country where data was processed                       XS-FILTR=                    0  /  filter id: 0=none, 1=PSPC boron              XS-MODE =                    1  /  pointing mode: 1=point,2=slew,3=scan         XS-DANG =           0.000000E0  /  detector roll angle (degrees)                XS-MJDRD=                48043  /  integer portion of mjd for SC clock start    XS-MJDRF= 8.797453703700740E-1  /  fractional portion of mjd for SC clock start XS-EVREF=                    0  /  day offset from mjdrday to evenr start times XS-TBASE=  0.000000000000000E0  /  seconds from s/c clock start to obs start    XS-ONTI =  1.476600000000000E4  /  on time (seconds)                            XS-LIVTI=  1.476600000000000E4  /  live time (seconds)                          XS-DTCOR=           1.000000E0  /  dead time correction                         XS-BKDEN=           0.000000E0  /  bkgd density cts/arcmin**2                   XS-MINLT=           0.000000E0  /  min live time factor                         XS-MAXLT=           0.000000E0  /  max live time factor                         XS-XAOPT=           0.000000E0  /  avg. opt. axis x in degrees from tangent planXS-YAOPT=           0.000000E0  /  avg. opt. axis y in degrees from tangent planXS-XAOFF=           0.000000E0  /  avg x aspect offset (degrees)                XS-YAOFF=           0.000000E0  /  avg y aspect offset (degrees)                XS-RAROT=           0.000000E0  /  avg aspect rotation (degrees)                XS-XARMS=           0.000000E0  /  avg x aspect RMS (arcsec)                    XS-YARMS=           0.000000E0  /  avg y aspect RMS (arcsec)                    XS-RARMS=           0.000000E0  /  avg aspect rotation RMS (degrees)            XS-RAPT =           8.588000E1  /  nominal right ascension (degrees)            XS-DECPT=           6.926986E1  /  nominal declination (degrees)                XS-XPT  =                 4096  /  target pointing direction (pixels)           XS-YPT  =                 4096  /  target pointing direction (pixels)           XS-XDET =                 8192  /  x dimen. of detector                         XS-YDET =                 8192  /  y dimen. of detector                         XS-FOV  =                    0  /  field of view (degrees)                      XS-INPXX=          2.595021E-4  /  original degrees per pixel                   XS-INPXY=          2.595021E-4  /  original degrees per pixel                   XS-XDOPT=           4.119000E3  /  detector opt. axis x in detector pixels      XS-YDOPT=           3.929000E3  /  detector opt. axis y in detector pixels      XS-CHANS=                  256  /  pha channels                                 TDISP4  = 'I12     '                                                            HISTORY   modified by pence on Thu Apr 24 15:04:08 EDT 1997                     HISTORY   modified by pence on Thu Apr 24 15:07:24 EDT 1997                     TDISP5  = 'I4      '                                                            HISTORY   modified by pence on Thu Apr 24 16:06:08 EDT 1997                     HISTORY   File modified by user 'pence' with fv  on 97-11-25T14:34:58           HISTORY   File modified by user 'pence' with fv  on 98-01-12T14:03:09           HISTORY   File modified by user 'pence' with fv  on 98-02-06T15:18:24           END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             AU=q1&AUA	=#t6AVo(RAX/@)P#FAX@Y[	AX
,~AY@ S?AZW^AZĀ},aAZ@LzA[":$A^NrA_MuA_@'nA`g@
 	NA`$Aa@*	Aa+912Aa%	Ab tB( AbD@	*vhAb I X,4Ab@OAc7e$.+Ac] 3	OAdW2+
Ad*2IAdC	 )Ad`[#Af$&^AfM
AgoxAg !%AjS-`hAk\
Ak|"0$SAl@
?-aTAl@ f)
Am~s1\#Am`
 Am`-V%An
Aq`5	Ar{-Ar#*)
Ar Ps	Asg' 
AtyAu@ PwXAv`#cAy@3+KA{/ ! \/A{Q@
u,D
bA{`
:
A{@g"'*%A|	M*SA} 	'2^Q
A}sf A~0`"0YA~
eA%DIA`!v3A}T"-A*	A X,AN
A`($_A
OA`i:AϠv*-DA
 0A y	A	AL$)oA)-bA@
A(
Z(A&@+ A	#kA/91
Ah 4Ao'ASA,/B%vA	3Aji!?A{+Af."D:A l3AP'	A`
1
Ak DzA&=Avy#
A@
Q3&A	h'3&0AÀ
(AA/A! ~A: 
A@SA&	V2Ay*&8A@ZAv`#
YALSAa@A1,PAn /3xwA7 PA*E	A<3ApA=`?&A@zA\h0A 
#?Aɠ
(U+DAb*:BA$$A-3DAL*[3'
A}zAl`
$s
Aŵ.^A
$_'AmF1Aʒ+A`O&A֠s
7A"AJ@/ P4EAͻ`

A+
A`'
A
/
AЛAh#
A+"SEAҁ Aҫ / 35A	)7A	4A4 ln	A:@2%
AZ 
?aFAi.]FA*

 JAn`-
A`+XAU`v AW A,4`!A@"dA C(jA%,&A	>%L
Ao@
AA"!!#A
3$
A`H/&XA 	h(-3A- -A[,Ac`+%$A4SA-z3
A 0(%A
J	]{A y!7A \'
A`	}&&|A 	&,	A	`e9A
`d%x.A"*WAp}A5`(AO+9AX|"rAAy\'A7@	%
A
^

8Ae)0A31AWA
"
A
RA<s-A`A cA`L2A@
,'B@A?,	A`u(-A@
;AIwAC !%Amq%,d+Aq
A ,1{
A`xv-tAk@k'*A4`Pc-sA m!ISA!h!`
A!`CA!$A"%,
+A#Pk;1A$."6A$l!H
A&- g%A'@
4`PA(Z@_A(Ƞ)-(%A)P		A)w,)A)`
>A*AA,*@f
A-I#{]A-@_t
A.֠yn;A/O b6	A/.'A/4vA4S`/A5%;A5
4A5./A5 %{A6`!A6`
R3A7_0r
A7r!mA8@
>iA9`/WA:f WfA;"y "A;:

A;S.b!"A;c` )eA>@
)"t{A>-A?=`	N&D5A?gxb0A? @E	A? PA@'$TA@V.VOA@
A@`AAW`s!AB֠e,s*ACXw1
ACi$Z$AC D
_(UAD
QJAE& wAF(%'AF b
1)2AG
	^
^nAG;-+AHAJGAJ#$AJ@h1"%
AJ@	0"sAMo 
3ANq AO/jAPcD#;(e
AQ@-AQ\4d
AQ |eAR)`G
AR- 8,dAR3$x3AT&&AV
*
BAAWd AW@3jAY81m AY?!
A\ (4	A]ΠFPTA^+4	A^@)1*	A_`)*>A`F.{OA`#JAa*7Ab*4^Ab,`,4Ab@WAeZ'&Ae
fAe1}!'jAe	

Ae1+AfA'~AfI!w	AfrAg(mAh@	u	-EAhD.6Ai
	Ajj~Aj #lPAj("jHAk*~JAk!1`Ak@J#\8Al
\1AlH@.%An܀y//
Ao@%C#Ao3`eA$rApSXAq0nAq5)I	Aq@2Ar26:Ar[At%+VAtN3At
Au@G 
Au'!{Avg 7Av-!7Av%tAx'4 Ay@1-Azl`&) Az
t#AzǠ(3Azm"*A{>&BA{l6	A}("iA~%_	A~@)i%QA~
Y4pA~ :&A@!:	A)A	1!AL?3A 
.	ABA$1f7A`2'AIU>A$!A{
LA A4JLAsANdK?A
,|LA5A2(A&.!,A1gA*@!6AU 
<A 3AQ--f
A &E
AI2V(A2%A	$C5
AAD M-!WA 
6~ Ay	AI!=9A1A 

m
Aa
+A |mA~`
'A<HjAo 4AA(! A 
&2"vA!)$A
-AT
ACAYAmAdY.A
 }]A
5tA@A@,A A-&f	A	'0	A@YAʀt#A 
T!A
4!	A1!Y	A$L#AC
s'y#UA{@,
NA|`s

A&A
 6ASR":A
+#3AmyA )A 6v"%A
4"#2AAt}("A	AdbB
A <.ISAl|A)Ajn
A6@m.Aj

A`BA`|hA#a&A A !5A&'3QA%.x
A`{(VAp5%A`		{ A%y-AO)bAS0*f'
PA:	,6VAD@(Aß&A`!2!r	A'`-^/5Ak
''-A	
s	A_$K[Aɞ	Aɷ`%5 A`
B5A3!Ae
4-AʁA
%LAϧBMA`&A]k)AրY, Ai
9-A19A ;)A@	x Aָ 	A`6!AT :A\ 7t(AX!	Aؕ`A$
1)VAِ`
&bpA@z0z+A\##AS@",6HA~#;.#Aڠ73m%Aݞ`Tj$A@@) 
AX
e |
Aރ
Aި`4!-A`! oAp.A @m#Ai@
X"*A !9!OA9
J-~1FAg`
D.Au1jA?)!'A
AK	A*(&A`	6%AJF!$
AP3AJA(Q5*2AA]A 6A@0
,Aπ<4A݀
A (%oAiu!E5+Ap`3L		A5@!A|@
-A`T^AL.[)A	AW< *
A [A'

A;!5A
5e:AI`A #@#V+uA @*A Ϡ"PA !	=A  ""VRA 4@
S
#A 	
.6A 
sIA  %7|=A  C/

A `.8
A ڠ
caA ,.A 
uM&A 
 &	*8A 	
A XA &DA  | A LA M[("5A S A ,CA  
"~A 
3B5A `DA ŀU!
A   0.A 3@s!A `@
#&A kS
A  ?QA 
1A >0	A h$[A `'(A C5A U )
[A ,$A !A O(2A !A #u("A #`
]A %`5	A & A 't=!A 'A (	*eAA (:`(E A (`
7*A ('UA )
+!EA + 
vjA +j#}$A +op6A +  6
A ,*`',@A ,@Q$1A -`?'a1KA -Yh1A .b`A~A .`!
=A .A /#	A /*'A 0 %A 1;MKA 2:@>']A 3S	%&VA 3@
? NA 3~:A 4@%(uFA 4 	:+A 4 YA 8z6C6A 8}X@&
A :
]AA <`0h,oA >? A ?r.A A7 +uGA A Z$&w
A BG 
_9
PA Cv@A C@aA D&A E1#>A H*

#A HeA J{xA J@*%jZA K`%-^*A M`W4A M ][A N`jA N? 5A NX@|
*A P`	r&`A Q .ZJA R=
R7A S@\.A S`e$?SA T 6W>A TK
A TLA U2_A V2 [.{SA Wb qA X EA X /TA Y€ A Z
`g,A ZSZ A \c6JA ]`H}A ]	A _%`%
A _@`?EA `F0)f	A `(A b,@2$m*A c
0A da 
Z1A eS?
!A e
KA e ?-0A e$CpA g4$A g
+A h p:A h'/!A i]5)A i4
A jJ o"j4A kӠ!zA kq]KA l  #0NA mH)PY
A n*A p`I-ZJA q@&I/A r+@s!o2(A rÀ,5A u
	&.A u '	A v8uA v f
A v"dA w
h+eA w  $?A y(A {

3f?A { 
$
A |6A `a&'*A >@
(J a*A .`
-)wA `i
*A >	|%$A H
2I#A 
A k!T4A l@"A A 
HA - Y3KA I *(|.`"A A TO
g(CA ֠.`A "4-A @UA @A !%A Z`0q	,A _8A *`H2+
A (SA  	'f$A vR"A 
&V6iA v-A  j	A `+)5A 
H"	+A `I>#A 0 ]"sA |"$A `JA ;`+
A A0/
A lF%*vA *7A @r/v
A GA Π!OA &4 A  s"Y1A @

#
A !Oe
A m
@
QA  '@+gA +&*DA  	A @}2I	A e"A 
-A !A 9-	A 5d#A ('.A Z%A jt" _A 
5PA @
}E
A ThA X@
!'A =)!#)A v
&&(%A 	0%7A UR
!A {f!TA  
&0A </A ``3A k0$D A s
,2x	A FA %f	/A +'A Fr(	A 
&yA 6FA L*
A ?Y
RA 0A #hA n
 bA `N0";A 2%5E$A 5A 1)A Q= 
?CA `G.!vA ņ  !Z4A ź@
,A$A P`%%
A W@Y"A 
IP=A p  o9A qU/MA ˩`,'%A @lA @#-,.
A ̄`"t	{A ̀-v9A  D*p:A /9A @`!A F
1(A @DA qN!fXA ӊ@`"rA ӪN&u*lA Գ u,)U	A `	#=hA 'l)A 4A ٹ@*A ڀ$hA /
A  C]A `!;A (@#.*tA ݸ2"A @I
A t` -A ޞj2"
A ޯ:	5A 4A V 1!!
A 
O
@A '	'A Რ3: A `4+l
A ~%0J A ?
"`A 
)A 0!A _nA 5!	A 4P!WA KO8A 5 
A @#'HA 쵀w
1
A *	vA n $o4A t3?A `rgA G(A O
6A ;4->?A @y02QA (A `	(=
A @
	'yA  6#A L #A 
,1A $A 
)-A 5
91/A `1$@A }
)?/A  p&*A ] S(XA s]CA H`!(%A ڀ
:1A [ ")A s*5A @JH1TA y@%A6}KA (A @A @v	3~
A T1/A!c*A! ~
A! 565A!jT19
A!`/i=A!
@s1A!F 0t*A!`	$\
A!	T'A!	/()A!mA!@%=A!	4 A! A!(;A!@
)	A! 
A!?A!%,
A!Y@L,~A!7(_A!-:+A!> $A!V 0DA!
A!
@Y
E

A!NF!	A!ŀ5(A!-@&)A!6@	^*4A!UU!
A!m-	A!m
4A!IA! `6N%A!!+3A!!R`mG)\A!"SIr2vA!"ǀc A!"`5:	A!#3}lA!'	.8A!'-jNA!'58A!(cY
#$A!)=
%&A!)F
0
SA!*,.d
A!-+~+A!-|"
A!-`-o)	A!..A!.)/	A!/0#A!0z"A!1.@!1
A!1=s*A!1"?RA!2<VA!2ˠT#~A!3
.%A!3 3A!4N@	)A!4l1%-
A!4
$$!cA!4
A!5`E.%QA!5׀s2&GA!6\(kA!6
l],A!6@)(
A!7R8F
A!8@7&	A!8m&6A!8`*$A!8 1zA!9@!,kA!:u@/F33A!:~2.4A!: '0
A!;$@#ZA!< )gA!<&d7]A!=e.jV	A!=
*5A!=#"L	A!?
-"
A!@M
5A!@-
A!@ 0A!AG));A!D ]!J	A!D\A!D`/!@A!F`V"2A!FF#+#0OA!G( Z\A!GE`K((RA!HEA!H .7	A!I /HRA!J
@4E1A!J9]	,/A!Ld$,QA!LSQ!7A!Ld%b!A!L}
qTA!M@.*A!M J%(-wA!Nf%
A!NK1A!OvR1VA!Q!2A!Qh #I'
A!Sz
[:	A!V# L3 A!V,
:A!Wz1!(A!W	 )5A!W@7 A!W MA!X43A!Y)#!'A!Ze4--
A!Zu`!
A![FA![2A!\)-	A!]aP0erA!]r(A!^a,W,dA!^q@X"	A!^`'@A!a.
&2A!a8@OfaA!a@
zA!ar]	A!c8h5A!cO- zA!cd-A!d$A!d
'5A!e4%A!f!
%+sA!f@'
`#|	A!g|`
*A!gf)$;A!gɠ%MA!g5-/A!h zPA!hv6]A!i66A!iE !EA!j
-A!j7 R1"A!j:()
A!ji@	!Z,?A!j
! !A!kr	A!k[V=A!m-FA!m@

A!mg!EA!mZA!o`BA!o#3 DA!o`
mLA!rb,A!r@)PA!r%6A!sB3A!sTS!!/3A!s 
6A!t
	h$A!u`
b='&(A!v@gS,%
A!wh#c/A!y`	A!y='%a8
A!y`(A!z,dj#A!zr 
)43A!{.

aA!~
 LKA!~ 0\
A!^	A!1`,A!n@yP
A!y5-'A!2NA!
 
*A%BA!#l1
A!3A7$6A!A 
1SA!@  FA!
A!U+,A!#XA!C`
	(MA!
"A!xA!J{3]A!C0A!70^A!_$A!1@.h A!J #7
A!ks`A! 3.R%}A!
*@(A!y`@2"	A!@(#8]	A!z013A!(1A!
XS
A!x@mA!v"A!:k'sA!a/bCA!%8^A!@!"A! 3-A!S@K
A!@,]A!`3A!!A!#
J7A!@G#/,A! 6!wA!M7A!8uf*-A!@	4A! 9"5A!b-L#A!T
	A!V@"qA!z@0F
A!xA!e &66A!Q"O2A!D*B!A! 
UA!`lBA!@A!xA!
&IA!/($A!X

A!W,,9A! *FA!`
#%0fA!@A!?F2*yA!Z
$"A!@@bA!jA!lA!Ú'A!?`jA!d"lA!
/sA!`6+ &(A!V
1-HA!>!sA!+~)]-A!_ 
R-,A!ܛg IA! G8A! ?#CJA!^@+2A!@X AA! A!>1
A!>@4y 	A!P%.THA!#-qA!쩠+
qZA!b2A!+/.1A!]@"A!4$A!؀$&A!Y h8A!s`%	A!g
9A!O@,A!`?*iA!	,X+	A!A@Q+
A!Π*p
A!"	%o|A!s,A!`	%,	A!t@E5A!׀Q,@A!
	& 8A!`
o7A!6aBA!
*q
A!	n
A!<@2A!@0 A!@
+`!A!ՠ
v$A"i
	A"7.	A"'!=-A"W

/A"jA"u4bA"Z& 2A"F'A"
*NA"	/`	[
VA"	 (/	A"
C@1
'(A"
8_:"A"
w@-(~A"
Ƞ	,
A"b1+A"M&*A"+ .(cA"	6$kA"|8.A"`.&
A"ۀt
GNA" q!YA"@&$F7
A" RA"t
*wA"@/f(vA"h	LA"3A"%f(&A"&	!A"j |1A"{`A"@(c
A"@	%8
A"f kA"? 8A"6A"W}A"v.50A") )Y
A"`(\ A"ʠ'A" {)i&hA"#*wMA"$=;5^A"$O<k	A"$&
A"%4$K93A"%`+A"%	>
$~	A"&R

A"&r`+L	A"& q4)A"' 73EA"'"sA"'f+JA"(	3g"]A"(->(4EYA"(j&A"( %7
A"(@	*$[*`$)DA"> ({q
A">A"?%>-A"@o
+OA"Bk*#3A"BY**H0A"C)^"A"C`"bA"D@ $5'5A"D"DA"D@J'eA"F@T
A/(A"G`&A"H#:A"Inf!?!CA"Ia`!A"K7)A"K 
/A"LW& A"M4 R KA"Mr+,+qA"NC-t2GA"N ,v2'A"P14A"QV/=]A"Q"3^A"R}!8fA"T 1+GA"U@	3"A"V&*A"Vl)AA"V
LJA"Wq_^0	A"X<)7A"X 
0$EA"Y[_3+A"Z",{5mA"Z@6
A"[@*)3A"]	sl\A"^@#gA"_
zq'_A"`%!$r^A"`z'a_3A"`)5F:
A"` k!>F$A"a3!iA"a@R"A"b4 M)A"bs`/A"c&@U7A"c4`Ux6A"d[$R
A"e@) A"e*}'lcA"e/d
A"fX`c0
A"gQ@QcA"h
iO0A"h%0Q#A"h!!!_A"h ~jA"hΠ'\y	A"hQ(	A"jC0A"n\n
 A"o~%
A"ob 2-A"o`&2IA"o`

!A"pu"7A"q	^A"r (eA"rA6
A"u{N+H A"vd 
MA"v@7A"w!@n:6A"yr35A"z` S
A"~X|3jA"pA">$FA"-=A"4A"A"	A"&*eA"`'.3({A"@A" .
A" 2>A" 'A".
BqA"F0`&H
A"K@
{ bA"K5%/gA"V
BA"& 6A"T47A"l w0$9
A"8SA"A@G%A"('',A"
A"*`t3)>A"
'A"d`<.1A"ߠ/"+A"I+aA"(O,	A" a+oJA"	I BCA"	a0NA"`9!$A"	6z A"@U'A" p	A"-7"A"
CA"΀
if
A"`"])B	A"L@	1RA"@}0|(9
A"	c+S	ZA"K`9A"HjA" P-7TA"g`j!TA"x`$
.QA"@3<
A"`h A"A"5|mA"2
 A"`4{!I
A"܀.,TA"ś 3"A"+o )A"r &A"`
%7{LA"(\
A"E&|	A"&/*A"' )2(A"@`n(A"t[%	A"~  A"ʄ%t:A"ʢB&1A"ʹ`:
A"#ZA"K4VWA"@-
A"?) A" 
}RA"<#A" 
DA"|0i
A"ѭPA"9$S*A"4H)A"Ӝji@A"A"1
TA"֐@
JA"
GA"@$A"+v8A"ذ`.+A" i(mA"ق(A"

%)DA"!A"۷%A"o"<A"`OP)A"m 	;6A"ܖtRCA")A"@iaA" (427A"@YVA"@/V'A"	!
A"2,+A"5	A"V e"j
PA"bqA"&( A"
.A"(
W	A"t5A"< *"!1A"
p
A"@_!
h
A"@_$EA"#Z-A"/6A"} /A"v7A"(
A"i!CA"103A"`%A"<AA"$0/
A"%3&FA"=)A"O0H1WA"A,(;A"
"
;A"L`A"j 1/B>A"k@9-&46A"
z)/#jA" 5+?A#/A#c@"
A#]
25+A#@##5A#|@Y=A#@
A#+A#Ā	A#	O@s4bA#	o@w_A#	%A#
kGA#`a)NA#9`
`"3A#NA#50A#@#2ZA#>`pA#P %A#|*A#à9 @ 	A#.DsA#
"(A#j@
))A#`(
A#ŠL2/	A#y;
A#i)A#@	,0A#1#'IA#t
b^7A#V"A#/2^A#H<(A#)`	#qA#0#A#n %5A#@
A#B&'A#o`
U4A#@V\:A#6A#
 ,A#  1P)A# 6+S2LA#!
.A#!~@
05A#"N-/XVA#"`,q0A#">
.A##
R$X#$AA## $i
A#$67A#$5+WA#$Q%A#'@1k%
A#(@
$A#*z 01
A#,e(O
A#-B-(^A#.À	8%=#A#/F`A#/p`1$A#0`
#1
A#10#:A#1'4'-
A#>0
AA#?r#7	A#@_ g2A#@b #5"A#B
A#B A#C&A#D 
i. A#Fg.3PA#F,,A#F e![0A#F1$A#G?MA#G`*A#HM-@$=
A#J`d!J wA#Jm@0pA#K@3)%A#Kc	2A#L+*A#Mr26A#MxA#M2A#N׀6A#O%`A#O#quA#O@.2A#P 3A#Qh 
F H'A#Q`
?+
A#R@E#A	A#T
A#T7`&#cA#TEQ/*A#T`05"A#T`+'	A#Uh	*>)A#U@( A#U
 
A#V  M3A#VF	A#W`S(
1A#X3 z/A#Xv/y
A#X,)&A#YV
U
A#]ik.A#_2%A#_
1#o'A#_ 
%A#`q0N++A#` |xA#a%oA#b $+	A#c T#AA#c"}A#d8	(JA#f(&">
A#huA#hb!c!eA#iT
'"A#k	%vA#lA#lm$BRA#m%rKA#m8 A#nA#oM, A#o`
2%
A#pR$2A#pYA#q!`)-A#s`nA#sz@H7d
A#tp jmA#u1"A#u>}$xA#u-*[7A#uۀ!
A#v
4+A#x?@d"8 aA#xv7m#vGA#x'"6
A#y! ;A#y-(*A#y`	\,7A#y#
#A#z
-1^A#|P`"*A#)mWA# /!MA#y$30A#%:.A#.
A#d*	A#`	5A#f@0E"^A#lA#A@>.H(2A#`%1OA#`r0(~A#
8/A#@	7;`
A#	_
A#["(A#	n+8A#CG.#
A#P@/A#@C!2A#e'2A#ɀ(A#	.8+A#6
A#3!6A#E/
A#m (~A#H`\A#.A#@
A#F5ZA#`OG"A#o
n!@&R
A#@
'&fA#/`
f	9A#@"*A#R	xA#@A#@rA#^A#V.A#a ;1A# /!:A# n!A#]`$0.A#&A#@W|A#@3*SA#	(
)qA#2*
A#Hp-[A#@
[+A#@	.R/
A#|A/*6A#5 !0A#S/
A#	w
A# @A#!@D+%
A#٠
^A#N7eA#d 0AA#n -A#3
A#@0A#, A#1oi	A#j)+A#/A#%7A#\5:A#, IA# `V4A# anA#If	-A#m
A#Ƞ3(A#.
A#DY"(A#ɀ	&;.A# 
!,
A#3h"A# 
]"7A#`6%heA#2daA#,)feA#W1A#^U0	A#`A#ǽX6A#
)A.A#- *W%%
A#ʘ
2#}A#J0pXA#Wp
A#ˣb
A#~)A#x	A#,-A#%b	,
A#נ#Y+mA#2 #;(A#qA# F)PA#p
+++
A#ϐE3A#Q-daA#N@QA#`1
A## 1A#ҡ!xA#Ҥ
A#ӎ*3V	A#<@y+A#Զ %2A#."}A#ms
'A#؜7
A# -9A#di{A#D*
A#ۦ1-~'A#,'(:A#I@	Q A#S.A#-`$A#r5$|A#`
	(xA#
(:$A#;%|$A#+A#j*'PA# 	%A#kxA#@%A#5	+A#`	)A#
) -A#7
;5A#[XA#@]A#@	
A#Ok0A#`&		!
A#+@a&
XA#E &[A#q`c* A#D
8$1?
A# "7
A# $XA#
6tA#S@)0A#Y2eAA#zx!A#@'!A#.[A#8GA#"A#*qA# 	+$A#ހ
$HA#`S,&{*A# 	(

A#q ]A$  y+@A$ 
A$XV2A$6DA$f
!6PXA$~0"A$@GA$`.-!
A$n4A$&AAAS` 

OAS/ X ASh <%P7-AS@4%%AS'
*! AS8 YAS -
AS@&3AS PAS@,4	AS_T+?QASSQ!uAS`72ASe:'?ASo 
AS@&{"AS@"vASJ`>AASy&k
AS`r-AS	.AS !0AS#ASÊ'4jASá@7

AS@$
AS@7AS/1GAS	AS>AtOASǕ`'
%
AS 8AS1
iASB7pAS3')AS̮	Zq
ASʹ -D#b
AS (#AS@ASo`
+H&WASе`
AS@w19"ASіGASN@V3"TASd`f!lASo':AS D NASC"AS=
m"-ASՊ 
 HAT.!U{	"
AT.I#"{AT/
PTAT1/$`AT1F |AT2rk
AT37@`",
AT3`w|AT3@Rv/AT5.+2AT5ݠ
@$AT6@
"%AT6)f AT71XlAT7 AT9(	?AT9c]	AT9| #%TAT:
/9
AT:{@A(|/bAT:3?+$AT:"lAT=`
AT=#AT=.@1	AT>@&
AT> F"ZAT?
~]AT?i$*AT?!AT@@1ATC@
ATD]H(ATE( *eATEL2(
ATF$ ATG&;4zATG6f&RATG@	-kATG*ATH+ATH_$X
ATI@%ATI`j-%	ATJ
S7LATJV21 ATJ ATK: c	ATKU  "ATK^
ATK 	>ATK@".4ATMj7C0MATN? 60ATQ\*!
ATRq#	ATR`2%ATSY
%5ZATS~(
ATTO@
5a	ATT`1ATU@;..1ATVG"ATW.
ATW?d]ATWo I4]ATW`V4<ATWܠ%5wATX 'ATX@%59ATX۠/!]ATYJ`4.6ATYP  rATYu@&[ATYx`U*ATZ`WQAT[7.|%	AT[2AT\nT%AT\`+5AT]N`/AT]K/AT^ ,AT^1'AT^G!AT_kM1AT_4-AATb$#ATbk`5GATb@3\
ATc#.-)ATcj*1ATcЀ	'(;ATc`
IATd@ATe.`ATe<@(
-ATe@$iATe
&&
ATf0#ATfa2|CATgVATh!ATiF&8g
ATi`(#:
ATj+'mATjѠ+$1	ATj`	,t.ATkGu'hOATk3&FATlV&)|	ATm@	~$ATm!Q3$) 2ATm5@sATn4 $ATn =ATo	P
ATpu
|.fATqR@J1ATqU4ATr@.&		ATr#ATs%%	ATsv6W!5ATt
.1 ATt 
	!&OATt`~%ATvv*ATv	/
ATy 7:ATy b&ATz<'xATz-xAT~+E5&iAT~р
La1
ATa AT+AT	%ATATU(aNAT_	
ATo 
/55AT)#AT^ 
v14$ATb]w zAT0W
AT@D#ATՀ
+s[AT
e4-]'ATy[zATY	/AT6+ATÀ	X!8'XAT*`
5SdAT2 +zAT	0%,AT4*lAT@19
AT!"2AT`
hg2lATd'ATe,!	AT
/qAT9=i
AT=b.FKATK@JmAT@1gATK;,p&ATu YFAT$AT5AT'.-	AT[/!AT
gATD!-AT(gAT/.,!AT\@al)AT4
#(/s
AT`%(x7AT !*$AT
C+RAT`!@ATj
%
cAT`'-AT5!$ATw#ATd
tCiATҀ2ATӠvNAT2|6AT`N4%HAT@
9%.AT
("6AT+AT&'AT8Io
ATU~#$E
ATX]P	ATo!=AT E#3ATڀ
;4AT'?/bATC,XxEAT
8i&&AT)	.EAT+HAT		.ATp)AToAT|"7AT 
"DGAT"AT 2JPAT /AT` %AT%TAT`!&ATUh0*
AT`1-BAT@!AT#r#lAT8
AT)ATX`	"vHAT{ LAT9`}*AT|K'8FATHATBAT~`s0AT
$CATȀ,"	
AT~0`AT5)Y?ATCE*0
AT`*cAT`,&ATŎ%6~AT6 #5qAT #AT'`
	ATȨf+KNAT@	1H,AT `z#*
AT!
k&ATK@1AT@FATϠ10AT{@&
X!ATЀT!ATҪFATɀ.#"W
ATJ(0MATl}&	AT,`+-2#:ATԠ 8!7AT`.s,ATys]6QATՀ`5-7ATe#	ATִ
3ATigAT/ 23AT/@r*PAT*AT@46AT\.1-,hAT6#ATw
5` ATۙ
}$AT`
ATܱ )AT0ATD $OL5ATݖ +ATަ4#AT`
(bATE
+ATX	/3AT0EAT15;AT9'ATh
w5AT؀9o;AT.AT䭀:!-ATS)(AT	3AT*, AT QIATH)(
AT		(h!
AT
x5+PAT@	6,AT/"
ATS-KAT@w#9-
AT <|"IATL`\a%OAT`84#H#AT*!
AT@
8	0"AT %'	AT
j.ZVAT|)	AT2	{78,AT-0
ATG@.z
ATc@=9AT AT`

OAToTjN	ATp`%*ATw5{AT}+?!/AT
&$ATV
*AUA@-,AU$CAU& +
AUp #,\AU #q7.PAUt( $
AU:AUb`XAUiu
-AUOVAU sAU&AU	;(AU	|
\_AU
.
AU
:`E$N'AU
 	`'AU#
AUS
#)<%AUyRAULG!1	AU&*AU
4AU
. %"#5AU
w g!9NAU
@+AU
`5
AU@`1/
AU	
AUՀ6l
AU	ScAUG,
AU0AU,/SBAUj/FAU{+AU؀A%d#efAU.AU'(JAU 	AU= jAUg`+2$AUŠW,AU(AU>$AU`5.;AU@7,4AU$G(AU`8"lAU
-2
AU,`6~	AU	@m%V.AUr`
76d
AU`.'=AU:(qrAUj3&" sAU@
"#AU8)/AU+ZAU	AU!<)AU!*)!AU"U
*)WAU#	
V(AU#`
a 18AU#g4B
AU#v2!AU#v!0AU%vR*AU%H8AU%`".R*OAU%`S!T/8AU&nl)S
AU(6	.	AU(#O"AU*'
/AU*Ҁ?.+5AU+AU,.J!AU,6G6s7AU,O
&AU,}
@AU- ,AU-= @7@AU-;AU.! B-AU05S)VAU0
$	fAU0@H&dAU2>*)W
AU2U7'
AU2 o	AU3] x*16NAU4	%BAU5KB"AU5V
"AU5πa% AU6:@)dAU7`
p*>AU7,)0AU8:+2AU8l)AU9`J$)AU:	8AU;%1L
AU<x$&AU=`
-AU>T*AU?) 
~AU?C'?
AU? D
QAU? %) AU?	-$AU?ǀ/%AU?!32 8AU@,(aAUA4	#,1TAUBI`#AUBeAUC-/mGAUC('
AUCԀ	:.
AUC )	mAUGZ:"AUG>80AUH@
,AUH {%.AUI$[8-,AUI2(uAUI>[AUIZ[
AUI[ S
AUJ, 0*P	AUJ 3 !'AUJ +tAUKy`-xAUL#=AUM 
 pWRAUM 2UAUM-ZlAUM@4)AUN+ !{AUO]#7}&AUO`n3|	AUPk`D/AUQ
EAAUQ9
$'AUQ3b!AUQ`%*AUR`5y(AUR`$#8AUSC , _qAUSJ$AUT"w&AUT
P{0AUU &
AUU W5#AUU/DsAUV 
AUVFl4AUW1!"<	AUXV
=+'AUXy	!2S*AUX (4$AUX "2AUYրm e2
AU[l.AU[`"AU\H.AU\`$|1
AU\`	I%}fAU\@&
/#|AU^
Q,;AU^		AU_452
AU_@5
SAU_71[AUat
&Q8AUa"j
AUc8,\AUc3($
AUdS
0AUds
UAUdր!30!AUe ,AUe!!$)AUe-
AAUfTy4)AUfms

6AUgWD
AUh(`KV*AUho	7 
AUix )%	/AUjK`!&J
AUjߠ'2pbAUlZ%@AUlo'NAUlu
3
AUm48NOAUA	&(AU
HAU,2
AUA/@AUJ(AU@	TMAAU7&AU2+)AU@S
.AU@u%8AU4m@5AU-*KAUÀ	IAUlYAU.AUkAU`y&d AUa
3,f	AUF $AU`
AUz@
"AU?F/`	AUL`C-C"
AUy !{;AU[ORAUV"b8AUS`
)AU 
AU`i 0AUO L5AU@o
AU 
1?AU`7
s^AU ( (	AU

0?AU]*o
AU5AUZ*=	AUJ@	q2AU 
AUn`!AUæ#A5AU1aMAUī 
2%AU/-D3AUH`$PAUI;(+mAUǼ@!	AUq!,	AUqS6_&N	AU`	*(AUp`}#AU

AU@9=!^YAU6j p*AUs'6FAU< 
.(pAU˯	AUܠ$UAUy!$3AU p%AUH5kjAU$AU·@B
AU΢&AUq0AU--"VAUY G)AU
w/O7AU`2r+JAU7
|AUs*kAUх j,/tAUьZ+%_AUa')=AUҒ
y0=AU	 AU~`{%8AUӡ`
p 'AU-3:;6AU2C0AUH.2AUo@
AUױ7AUWB?AUٷ5
AUN`96qfAUڈ 
AUCZ&AU80SAUr@p!1AU 3AU$P#AU`AUРG<UAU*
`
AU{!"AU`2AU`$/AU
AU`Y%l	AU#4`	AU@,(AAU
(RGAUAU'	[AUG	AU> 2"
AUEYAU`
)AAU
Q#M0"AU q!AU '1AUV`f4fWAU@!RAUx`CAUZMAUxB`1AU؀m+;
AUOs.AU9 -	
AU:"iAUk$AUB
HHAU0HAUڀV
AU݀RAVg 6AV *H	AV'@(,_AV(.B	AV

AV@c$dAV@,+
4AVn 1AV`mAV c2AV 
)
AV	 AV	
t/7bAV	*l/AV
 &"I6AV
`
1*O"	AV@-QAV'AV-I	AV
q`I
AV
`0I)!AV@0(
AVh
m (WAVl	+1AV`? AVC %3,N1AVXXAV`iAlAV&AV 

$AV
-#AV
*7AV@w
AV)`'7	AV - 6AV 
#BAV])2'cAVd@	4!M-AVЀ$MAVZ~!7;AV%e	*AV	>4AVeX/AAV'2,.AV[1AV3`!&#b@AV(1AV'0{AVSAV J5gAV8(jAVF`XAVa`/ AV`$%_AV /AAV @w#2AV |AV!:`|KAV"I^%[(AV"	H"'?AV$*
'AV$ 
F$
AV%Do$^	AV%t;"JAV%
'$
AV%1	AV&e'AV'O`
`3P]AV(5AV)P@Q,AV)e 4AV)+eAV*y(1wAV*aP{AV+J#$AV+%AV,-@3AV,tAV,@J&"AV-C
;4
AV.U;-AV/ 
AV0][-*AV0 AV1`
AV2:":AV2? 
z$	AV2d?AV3P.AV31AV3'Y
AV4vO_AV5`
#AV5	g	AV6,NAV811&AV9	
AV93*AV:.	n$K2	AV:2"	AV: $&
AV; ;0"6AV;!L%AV;
-+AV<$*AV>@)DAV>	 B
AV?#!AV?`,AV?%x-N0	AV?kYAV?
$
AV?`
AV@&@d)3AV@eQ	PAV@@!fwUAV@n-	AVA@@p#$AVB@:-wAVB-`x
LAVB@t?m+AVCE("AVC@(Q+KAVD +1LAVEBHAVErq3LAVE"
AVF`f.AVGĀ+
AVG'2"lAVH`*?AVJĠ#>=AVK@
#
AVL!@%
AVLk <c-AVMZ&,AVO=`I&L3A-AVO n*.U
AVO&AVP~@,p
-AVQ	@["k0AVQ2`J>.AVQQ@*2AVQ	5%!AVST`*{AVUQ 	"s)AVV 	"I	AVW0AVWr@AVW "(AVW  AVX2
EJ.AVX@0%AVY ^,AVZaNAVZˠ)$AV[=`
6&AV[	.@AV\@[*;NAV\!WAV]; 
t**'AV]>@_AV^&&*@AV^k	bbAV^{ ECAV^.AV^e0/	AV_ 3AV`Vh=AV`X\7AVaKM+,eTAVa $jAVa
"iAVbR
.AVbs`-!K 4AVc
h?:AVc} )u2/
AVc;l
AVe
(",gAVe0 &AVfq^AVf'AVf[*'AVftq&AVf@6	AVh[		AVh6##1A
AVh 
rAVi`%AVjg2AVj1-,AVj@:2D u;AVk,0AVkc`AVk`3AVlC')&AVl 	"&lAVnK@
QAVn@AVo%z
AVp7"D AVp
i;)?"AVp	B 1+AVqL.pAVr1@
U/AVr 1m*	AVuU`
(ZAVu
lA
AVu 2vAVv~d*"AVwm	!).
AVx 	2:%5AVz
"I,[AVz`G11AVz{#5	AV{V

'AV{ 
6AV|4 j%W	UAV|Fu.kAV~	.7yAV~o aAV~ !
AV.49AVd#d+[AV`S(	AV5!
?
AV J4tIMAVIM$9$0AV؀"s*AVT@V)AVt	 /dAVm31AV!JAV

AV!FAVZ
*AV&)v
AV	eDAV`@0AV@/d AVt#'AV 
P!RAVd*dAV`3GAV
BzAVq*a1	AV`IAV!P:AVAVX2AV'JAV2'
AV,j&o%
AVS
W)[jAVw1:AV#	AVN("0qAVl@mAV@
AVtkAV^$4c":AVg^	,AVìCAVĴ+AVŘ` mAVť4$PAV
EAVƆ@>)l1
AV`
dAV'
2AVXsDAVȡ@.F$AV`
05AAV4F-0AV,`(,,AVݎMAVL
5$eAVt	%AV`^0AV߹%0%2AV	5)AV AVcVAV`,,
AV@{6yAV
 
)AVh4AV, +h0AVN$#AV`"AV۠tAVv)+AV -AV|RAV3~JAVrAV(!a$AV
'AV甀C"
AV`/#A\AV!XAV,B	AWm`!31*AWB"91
AWY@E
V"m?AW
}%DAW"
AW "B	AW:)I+nAWf0)%AW@4qAW`f13AW
C2AW@@R&AWB
!AW 2AW)H8AW5B1AWn ]Z!?AW 
'	AWj 7
AWj@U.+OAWm*;7AW 	j'AWg$H
AW@Q"=,lAW	}AWzc
AW@(LAW`$	AW)AW #"!AW!L+%AW#`R3
AW& $!%0?AW&-5AW&D
F
AW'@^4
AW'-uAW).+
AW*H)3AW+/!NAW,i&AW--DI6AW-;$9AW/D!%AW0
B,kK(AW1 f4i}AW2- AW2(19AW3`AW3,oAW3%j.?AW4f "9AW4@b3(AW5@3	AW5!"AW6@/	AW6 3LAW7;/$AAW7	;AW8`!T;=AW8à
:YAW;`0"gAW< 
54wAW=AAW>q0-	AW>N@E AW>Y)q3AW@a)PAW@@	08AW@@U~AWA8 G2AWA<o&$'	AWAe
$BAWAo $kAWA<%,AWB 1 c B	AWB`
R6AWCo'/
AWDy	LAWDȠ
&|(AWD0u,gAWE*WAWEwAWE	KAWE`"4QAWF`"!e&AWF@&	*AWG@/;AWH4I=AWH`
*#>AWH@()?AWI%>AWJ3`+A%JAWJ>l+($AWJ54AWJ sAWLt`+>+AWM#5AWN`~3 JIAWNˀ6P!4AWN
wXAWOj@4Q}AWPd$9~9AWQ0FAWQr+0
b.AWQw@#AWR&,qAWR@
"aAWSA 
)AWTC	+BAWU|`3AWW 4"+AWX&iZAWX=@zkAWX
AWX )YAWY!B"vAWZ9
~)9AW[ H'EvAW[!@	'(r
AW\"9	AW\ $$AW\
!AW]s&ZAW^`D,*AW^` oHAW`L`Y&##AWag3%.AWa@2AWe*AWfƀS=AWg`"7AWgX,-AWg`s%!	AWh
$
AWh,rGAWi*vAWi`(AWjc&,	$UAWjx`)&]AWk("*"AWk	TwAWl v}!CAWp 
4z%1AWp
#AWq
 ?8AWrK
G$MAWs@)-AWt@1fAWt( $RTwAWtM!#AWt@LB*AWu C	@AWu Z}AWv@ TQAWw|*AWw`a5AWy i'3AWyAWyE
AWy€~4-7AWy$!]AW{L@
;AW{
AW{1V%^$AW|@	$sAW}x 
-
AW~Q"GAW
~1'	AW.
AGAWo cAW[	)EAW 	&{AWF
	k+AW@Y,0n%AW, "2&n;AWY	-&AWPV08AW!'=iAW	m,
AW `+$AW@.5
AWvAW-XAWa'tE$AW@+'AW+1/
AW
"AWG P$e2.	AW@nYAW ~
AW2rAW@/"fAWG@{*3AW*-
[AẀ&l
AWe9AW0|AWӀ+(tAW@+
AWi FAW4WAW`)
FAW1hFAWa5AW44S$AW`1AWqcMAWVfAW`AWeAWAW@$.MAWlAWb`T,
AW`#h! AW AWaZ-&AW}-f'4AWw1lAW1AW 9bAW)@@^AW`
AW]AWk*s#AW'@I
+
AWI@G6AWc@e#\AWe@""AW
q0*kAWY` ,6AWF"HAW
}fAW!@x)eAWE+RAW`	AWM F%>FAWѠ

].w	AW/"2	AW5^21,AWqh!X0AW!0zrAWq(EAW	-D.AWe 3
AW9`
!.AWԀ
^
AW2AWAIZAW@(^
AW:`	'5AWև C3QAWD2
$AW\	'H2"AWzdDAW@%	
AW
5-AWط`
03
'AW
)+kAW1`/%
AWU	"1AWٔ}/B	AW )

AW.AWr
W
AWr#
6DAWNAWn@ 64AW`V/,0AW /
AW305AW1J,>AW@.\AW
DAWMAWU*.r
AW22dAWp@*1<AWs*WqAW"@s%+"qAWK`AW92AW+>AW
AW`*;$2AW+Z
AW9
AW@V<	AW%bAW$D'	AW
	kAW$AW5`(3U	AWV'-E
AWu (2'	AW퓠T*AW ':AW
sAW@"-mAW7$RAWw
83AW@~pAWr-
AWSpAW`i*?AW*"e40AWId'%AW#JAW`5	"AW 
+!3AWJ.AW -/AW`%FAW
\AW V%VAW`[**AW
/AXJ)AX+`
7AXl583AX`&{AX /X9AX 2w"*AX\AXl`P AX eAX 1AX	E,B1
AX	 1(yAX
 
AXp#	SAX
- (P+AX
&gAX &AX@&AXH 
YJAXzv{+AX *.AX@1%;AX@>"	AX5w
AXbAXl<*	AX'"#EAX@&&AX"	q
C\AXK"$AXi`R0dAX	)AXmAX*"AX3EAX@	
oAXx#AX h
YWAXl%S
AXc
 7AXg !gh*AX2sAX\4@
AXn@#v('AXx	5wAX 2AX))^AX+"'Q
AX`	#
AX'`~z7UAX~J(PAX@N	AXL+?AX`5BAX `u$AX  'E_AX!
#s	AX"@R.AX# 
h
AX#`0%AX%W1AX%@1$#AX&x
4%-AX&!K}AX&(GAX&`	k+S	AX(v	$R!AX( -UAX(AX) 0O'2AX+
I.nAX,}',1AX,!
AX-@ 
BAX-xAX.@$( AX0L
V	AX0V%yAX0u#^AX2M
+AX2S &
-AX3s,!-
AX3`b#AX3
AX4I@$AX4@#4:AX4.-yAX5AX5A.AX5~fp1AX5`7AX7@3AX8^	,jAX8W@"B$AX8Z3 5AX93@,AX9ƀ%"AX:g %AX=z@ 
	AX=sfAX>c DAX?&AXA(j
'AXAV-AXAg`>AXDG)
AXEwU'yAXF'O4?AXG6
AXG$`0LAXGm 
+
AXG*\Y
AXI
*_5*AXI #QAXJ
l1^NAXKHV!AXKJ`
<EAXKz(hAXL\
n(dAXL@
Z)3IAXL /!AXM6l&!AXMՠw#>&AXN`
!(
AXN
7AXOj1:AXQ`
RAXQ5
	AXQLA
AXR/"AXRD-#AXRv#&,AXR`
.AXTy ;AXT@E3rAXU  7nAXU`!.AXVl/1'
AXXdAXZP"4#AX[w%.AX["0AX\(1!9UAX\{@8*1AX]5`2?AX] n+oAX^4b#AX^
3
2AX^`2%AX_h@	&	LAX_@t5AX`~@
AX`)!AX`@e{*
AXbA2)SAXb`v)1&>#u$AXoAXp)AXtY	z!!:AXu6@
$vAXuq_AXv1AXw= 	ZAXw 'Y$v
AXx=.kAXyl5-AXy@|YAXz`/q$,AXz 
*
AXz	u%dAXz͠5 oAXzT^AX|c EAX|f2AX}`$3	AX~
 k"#<
AX~a,@ZAX~@,AX~ȠfyAX~Nd2pAX"@~ AX=@AXAXd&AX
*!AX	hAAXǠ=xbjAXt .AX*%{4AX J#H(AX@	*P-AXf@)
AX`AX%$"FAX`AX 9+~AX2"AX@4 [AXo`z2
AXlAX@S&vAX)fAX 	B}AX+` AXlb?70AX N4'LAXl`3PTAX`*+{AX%^AX
"AX@4^"AX~AX$*AX-@!7AX,AX #/AX
?	`'bAX82AX`<.dAX{BF)BAX`	a+"AX'FAX
"HAX)K>AX)

"	AX *	FAX `O
&AX$x,#AX@eOAX}r+!|AXS,tO	AX?3

AXπ-VAAX3IKAX(]"}.CAXX;7{	AXrc05,AXX`</
AX`
>BAX 6u-AXA-e
AX[_KAX!Hn1AX`j
AX-@/!tXAXI,3AXV@~AXcOAX%%5AX
R4AXD*7AX@\1AX,AXa-YAXi=-
AXǠ2zAX#"AX`+AX";b		AXHT~AX1>"3*AXJn)$AX
AXĠ

AX,=4AX@
AX AX /$AX`*:	AX1AX3..WsAXb1 AX-u c	AX[AXg"&
AX	.AX@
AX'+AXŹ ==CAX`AX&)AX&: 73AXTt*HAXʪ	uNAX Q*"nAX`C
AX8+
AAXD@`+"AX̨`\0$"+AX )AX͏&WAX`"!AXG $q4'AX/`0.n	AXЪD,AX`A(AX
	b
AXԇ
'/AX:*qAXh _5z%?>AXw	h"AX)`
"#'NAX	#..AX77j	AX_@'-KAX`q'<AX)AX-!@AXA@O%-AXLfAXa&lAXq(|<AX(&+AXۋ`j6AX۱	AXܨ ->,AX@'L$NAX6,.?AXP`i.
AXݵ1AX1%lAXn`YAXަ)!#AXߞ%>AX߰ AXӀ2AX!_AXC@rAXf 61AX w"AX*`:&AXV 
'jAX㩀#_r
AX;2&#AX#2m	AX6 
AX:s
AXZ@z#AX@%AX###9AXa6AX`3AX 7=1|AX@:$AXv3"AXɀ(-/AXo"CcAX#&,3AX'2e
AXRy;AXna';AX할AX_3AX*  =AXf ,JAXр+]AXAAX$AX4@QAX> &AX`
*	AX	
AX"7AXN HAXi`/6JZAX`
8?AXa (!AX2#!7AX)%AX
*"	AX N%AX 
&AX6 0;'AXPp
AX@30	AYB	#^)AY!DAY OAY@}
AYנ,{AY<
c0AYL"XAY	D`Q H
AY	z2}RAY
=k1%6AY
Ӏ
M\FAYG]eAY`T(H
AY
n`9AY
 
,/AY`+()1AY
.&AYp%$'AY$7AY@z
 'pTAY!#1QAY9@+AY@iAY`$=AY AY
)'3eAY@7$*AAY{2+i&bAY@
%%AY=w)
AY $!8AY3AY[@:
?AY+)AYG@BEPAY)`8AYF+AY`|
0 0QAY,)1AYR 
4
,
AY@0'AYŠ]4	)AY@AY"3W
AY"`S%AY#`mAY$:u*EAY$	$2AY$͠9!AY% %	AY%75AY%`)zMAY&=!/'AY& 	2&AY&c)45qAY'+s
AY' $ 
AY'f
t-AY(2'AY)`	H%*!wAY)!
	W&#AY)n]AY*=aAY,11-oAY-Q@!V+AY-@!(
AY/
+,1AY1fmAY1	[AY1`AY2@24
AY3
2 AY3' ~*AY3	
" 	AY4.@AY4
7^
AY6@
I!AY7~ 
x6cAY7wAY7`
,
AY8AY9 .+JAY:@O![,AY;`<'#AY;xgRAY;
AY;s#AY<@!SAY<r$6PAY=y)#rAY=8,DAY= 0v+QAY>7-)@AY?B 	##AY?t)AY?l!AY@@
h&8AYAZ@-AYC0h+rAYC@8AYC`AYD C!f-AYD`,%FAYEJ(1
AYF(tAYFYt`AYF QAYF!IAYGI)AYHh#
,AYHۀB1(AYI~4AYI`s#AYI #,AYJ`W	AYK]	2AYLs`N	yAYM ,AYP`Z%)AYQP:"1,AYQ 7'AYR@(/?"-AYR/)AYS`!LAYS &n=
AYT@e;5lAYO'7AY AY AYQi+OAY%yAY@Y'-vAY``/dAYP`XB/AY^4-AYr.AY//-AYIAY6#
AYDAYA)3	AYz$66AY t
AYaGAYK&AY$QAY #AYAY)AY;/!AY`
ziwAYy..3
AY@.A.AYT$v-AY@
s%
AY
!c
AY
j(}
AY9&/
AYd+4+AY AY1`(",AY+AY;@R&5OAYi%HAYd2	g
AYQ+AY`
%HAYP\ E
AY`+AY!EAYAY}]AY`
-(AY~B(AYu /AY
 ps(SAY, 
@->AY@3MAY^AYX3)9AY%!AY:$	AY`3?AYS/	-RAY %.5QAY6K(AY v$AY`%A5AY"H AY=%!	AY
3#D(AY  	#AY
k*AY 
,(AY5IAY@r AY 
AY)!0RAYV Z	'AY@-2)AY`t1rAY .|AYǹ
7:AYȳ +!
-AY
/4AY`QaAY.@AYVa6cAYJ2*	AY'AY˵ AY y*:AY̱
!
/
AY?
/.AY 5*:AYm~)!kAY̓'rAŸ́dAYͻ'HiAYK@a)LAY#`	q d^AYe")lAYω5 AYϓ e.'AY϶_$AYs ,AYd 
,KAY%mAYa

Q!AYPB&AY`f$AYC@LcAYղ4AY[`AYe<
AYހ+$
AY}Z8/AY@3;0AY%).\"AY{	AY 
AYM2AY5)jAY<`	;"AYQ
u,mlAY&5AYBUB6AY߸@"AY@%$AY+AY\"!AY: Y%AYt)AY#F/AY
>*AAY#`o.=qAY- )AYz 	HAYM&@-AY}-	AY#&&]AY %AY
AY!)	AY	0,AY,AY
/0AY)$ `*g%AY8"oAY 
w/&:AYs 3!x)AY3*
YAY`",2AY@
gAY		AYb
4AYl $&H
AY!AYʠhAYh &
AY
x"AY@A"
=AY-AY@AY16
,]UAYS$r(AYH	)DAY`1 HuAY^%*NAY	8KAY	AY@AYz_u$AY	s	AYg$AYKX"AYT
V	AYX/)AYg/AY0)#
AYɀ'AY
6*%AZS
^AZJ*AZg
SdAZ`*JW
AZ@`xAZoAZUU5w!),AZ3AZ ?e2
AZ-AZ	W` BAZ	!$UAZ		C)IAZ

VAZ
@9#4AZ`@O4
AZi
4AZ@$c2
AZl&v+AZ
@#VRAZ
"6AZ ,@AZ"t
u4AZb`n*dAZ@	7+AZ`!hAZc5 J AZ!AZ0
##AZv` L%3DAZ
@49
AZ )NAZ,!vAZ"9AZY3%SAZ"`E AZ[*
AZ##AZHG&AZ; i!)0	AZ\	AZgK7AZx(AZ}$:.c!AZ(}AZ1J.	AZ/2-AZ7	AZ:/N
AZ.	AZ "AZO3AZ+
4V AZ`$O!AZn0AZIaAZ 
Ss1AZ SD$9'I9AZ"
y,h+AZ").JiAZ"@q%B2AZ"'L	AZ#C HAZ#`!#FAZ$
m5AZ&ԠC	AZ(q39AZ)y*	-AZ)@3lAZ*RC
f!AZ*C
#p7AZ+` 
[AZ+{"l\AZ+ 1ZtAZ, AZ-@*AZ-g#e
AZ.
	1)AZ/Z 
HAZ1Qs  7AZ5| Z*1	AZ5&AZ6Lg
|AZ6I)AZ6
d0DAZ7 
1AZ7`&!AZ8! 89eAZ8O9AZ8 *1AZ8@1	9%AZ9`c+l8AZ9V@0AZ9(~AZ:c$+AZ;V 2#>FAZ;!AZ.+VAZA	2K!LAZAk`*%AZA#
AZB+(.AZC@1#AZD!H)AZG/`\AZG@)^|AZH.`)/aAZH	'AZH<2+AZHG)66{AZI,:"1AZI AZK E-,AZK`+8#
AZLF 'AZLNAZN! &O#AZN[@nAZN  }7AZQF$+AZR`	4AZR-$3AZS_`"5UAZS8/.2AZTl*/~AZU
3~ AZV:@u7/sfAZVF1OAZVX&A	AZWU7AZW@	E#AZW$
AZW $fAZX `
AZX3 +9BAZXՀ&AZYr#1/AZY_	XAZYŀL2[AZZ*j.2&AZ[b-8AZ[k/4AZ[ -
UAZ\#d
AZ\
=#^
AZ\j
%j
AZ]M 2$LAZ]xz
>AZ]ʀ(&AZ]
&;AZ] !+ AZ^ F'(xfAZ_ހ	/
AZ`iY3z*[AZaf`1/AZa RAZb#@zrAZb@DKWAZco4L'AZc	M8:AZd'`SAZde@]AZdh)AZd@
(RAZd {$'
AZd
#
AZeQ*F*
AZf),v}AZfI*
AZh%S"AZhR S'AZi4&	AZiǠb!idAZjtB*P#AZjC	y#AZjZ$8AZjŀ$C6;+AZkAZk* (
AZkH+#	AZk;AZl<"AZme%>AZo 53AZo01
AZou,AZpH&	AZp`5'fGAZq9@PHAZqu*m4S
AZr3&AZsd`
/J	AZtDAZuxV$Q$6AZv?)VAZvKTAZv_#AZv 

AZw7@/`AZxD@+;AZy%  T,cAZy`B//CAZy0+AZz-@!Q*AZ{F 	5A4AZ|I4
1AZ|\c+oAZ|`	8!AZ}R )N!AZ}l
YICAZ}v`.sAZ~ 	O, AZ7`	$`,znAZ$AZQAZ!dAZS3AZs	AZhAZk5"W?AZ A%,AZ*/mAZf' AZ`0
AZ@$"AZE
-
%'$AZn
[AwAZ##5AZq
+'AZ
wAZAZ@'04AZ AZ@'~AZ@^#L
AZa
p8AZ*$AZ`J#(&AZNAZ;3$+AZ\S1AZ`Z9?gAZZ/%AZ{AZ]((AZ@	)
AZDAZ>"0AZ@_AZ_	+OAZ/+	AZ
)sAZ "(	AZ%
ZAZ/>AZ*2AZLVAZˀn-AZ )#AZph&&AZi	)9AZ'AZUA-AZ%y	AZ`bOAZU3PAZ&$AZ-
5UAZ $
AZ@,@
AZF@'*
AZH`E4N,.AZ@fs&AZ&AZ] 5#
AZj,%0<
AZ# 
p.b1AZE)AZ	"/AZ@%0QAZ !!9}AZu@G#|
AZ
y)b%AZ@lAZ!7iAZZS/&)AZ0=2&AZ+@"Mg#AZV'AZ
AZ_
AZzI7AZ'*L	AZ9@	( _AZ?^1EAZ 6h!AZ`-,=AZ#'yAZ_ 
7eAZ"JAZ 
'7?AZc>
$AZˀ
0(AZ`t8AZ)
AZ@- 	AZsAZVhAZtiAZ`+vAZ7 	% AZ=9;~	AZ +$AZ!AZ odAZ‚!\
AZ…@'y,AZ¬GaAZ*r
AZn	'!
	AZ1uAZנ0Y
AZ*` 3EAZƪ`	F
AZEhealpy-1.10.3/cfitsio/iter_image.c0000664000175000017500000000600413010375005017231 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include "fitsio.h"

/*
  This program illustrates how to use the CFITSIO iterator function.
  It reads and modifies the input 'iter_image.fit' image file by setting
  all the pixel values to zero (DESTROYING THE ORIGINAL IMAGE!!!)
*/
main()
{
    extern zero_image(); /* external work function is passed to the iterator */
    fitsfile *fptr;
    iteratorCol cols[3];  /* structure used by the iterator function */
    int n_cols;
    long rows_per_loop, offset;

    int status, nkeys, keypos, hdutype, ii, jj;
    char filename[]  = "iter_image.fit";     /* name of rate FITS file */

    status = 0; 

    fits_open_file(&fptr, filename, READWRITE, &status); /* open file */


    n_cols = 1;

    /* define input column structure members for the iterator function */
    fits_iter_set_file(&cols[0], fptr);
    fits_iter_set_iotype(&cols[0], InputOutputCol);
    fits_iter_set_datatype(&cols[0], 0);

    rows_per_loop = 0;  /* use default optimum number of rows */
    offset = 0;         /* process all the rows */

    /* apply the rate function to each row of the table */
    printf("Calling iterator function...%d\n", status);

    fits_iterate_data(n_cols, cols, offset, rows_per_loop,
                      zero_image, 0L, &status);

    fits_close_file(fptr, &status);      /* all done */

    if (status)
        fits_report_error(stderr, status);  /* print out error messages */

    return(status);
}
/*--------------------------------------------------------------------------*/
int zero_image(long totalrows, long offset, long firstrow, long nrows,
             int ncols, iteratorCol *cols, void *user_strct ) 

/*
   Sample iterator function that calculates the output flux 'rate' column
   by dividing the input 'counts' by the 'time' column.
   It also applies a constant deadtime correction factor if the 'deadtime'
   keyword exists.  Finally, this creates or updates the 'LIVETIME'
   keyword with the sum of all the individual integration times.
*/
{
    int ii, status = 0;

    /* declare variables static to preserve their values between calls */
    static int *counts;

    /*--------------------------------------------------------*/
    /*  Initialization procedures: execute on the first call  */
    /*--------------------------------------------------------*/
    if (firstrow == 1)
    {
       if (ncols != 1)
           return(-1);  /* number of columns incorrect */

       /* assign the input pointers to the appropriate arrays and null ptrs*/
       counts       = (int *)  fits_iter_get_array(&cols[0]);
    }

    /*--------------------------------------------*/
    /*  Main loop: process all the rows of data */
    /*--------------------------------------------*/

    /*  NOTE: 1st element of array is the null pixel value!  */
    /*  Loop from 1 to nrows, not 0 to nrows - 1.  */

    for (ii = 1; ii <= nrows; ii++)
    {
       counts[ii] = 1.;
    }
    printf("firstrows, nrows = %d %d\n", firstrow, nrows);
    
    return(0);  /* return successful status */
}
healpy-1.10.3/cfitsio/iter_var.c0000664000175000017500000000636713010375005016753 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include "fitsio.h"

/*
  This program illustrates how to use the CFITSIO iterator function.
  It reads and modifies the input 'iter_a.fit' file by computing a
  value for the 'rate' column as a function of the values in the other
  'counts' and 'time' columns.
*/
main()
{
    extern flux_rate(); /* external work function is passed to the iterator */
    fitsfile *fptr;
    iteratorCol cols[3];  /* structure used by the iterator function */
    int n_cols;
    long rows_per_loop, offset;

    int status, nkeys, keypos, hdutype, ii, jj;
    char filename[]  = "vari.fits";     /* name of rate FITS file */

    status = 0; 

    fits_open_file(&fptr, filename, READWRITE, &status); /* open file */

    /* move to the desired binary table extension */
    if (fits_movnam_hdu(fptr, BINARY_TBL, "COMPRESSED_IMAGE", 0, &status) )
        fits_report_error(stderr, status);    /* print out error messages */

    n_cols  = 1;   /* number of columns */

    /* define input column structure members for the iterator function */
    fits_iter_set_by_name(&cols[0], fptr, "COMPRESSED_DATA", 0,  InputCol);

    rows_per_loop = 0;  /* use default optimum number of rows */
    offset = 0;         /* process all the rows */

    /* apply the rate function to each row of the table */
    printf("Calling iterator function...%d\n", status);

    fits_iterate_data(n_cols, cols, offset, rows_per_loop,
                      flux_rate, 0L, &status);

    fits_close_file(fptr, &status);      /* all done */

    if (status)
        fits_report_error(stderr, status);  /* print out error messages */

    return(status);
}
/*--------------------------------------------------------------------------*/
int flux_rate(long totalrows, long offset, long firstrow, long nrows,
             int ncols, iteratorCol *cols, void *user_strct ) 

/*
   Sample iterator function that calculates the output flux 'rate' column
   by dividing the input 'counts' by the 'time' column.
   It also applies a constant deadtime correction factor if the 'deadtime'
   keyword exists.  Finally, this creates or updates the 'LIVETIME'
   keyword with the sum of all the individual integration times.
*/
{
    int ii, status = 0;
    long repeat;

    /* declare variables static to preserve their values between calls */
    static unsigned char *counts;

    /*--------------------------------------------------------*/
    /*  Initialization procedures: execute on the first call  */
    /*--------------------------------------------------------*/
    if (firstrow == 1)
    {

printf("Datatype of column = %d\n",fits_iter_get_datatype(&cols[0]));

       /* assign the input pointers to the appropriate arrays and null ptrs*/
       counts       = (long *)  fits_iter_get_array(&cols[0]);

    }

    /*--------------------------------------------*/
    /*  Main loop: process all the rows of data */
    /*--------------------------------------------*/

    /*  NOTE: 1st element of array is the null pixel value!  */
    /*  Loop from 1 to nrows, not 0 to nrows - 1.  */


    for (ii = 1; ii <= nrows; ii++)
    {
       repeat = fits_iter_get_repeat(&cols[0]);
       printf ("repeat = %d, %d\n",repeat, counts[1]);
       
    }


    return(0);  /* return successful status */
}
healpy-1.10.3/cfitsio/longnam.h0000664000175000017500000005010013010375005016560 0ustar  zoncazonca00000000000000#ifndef _LONGNAME_H
#define _LONGNAME_H

#define fits_parse_input_url ffiurl
#define fits_parse_input_filename ffifile
#define fits_parse_rootname ffrtnm
#define fits_file_exists    ffexist
#define fits_parse_output_url ffourl
#define fits_parse_extspec  ffexts
#define fits_parse_extnum   ffextn
#define fits_parse_binspec  ffbins
#define fits_parse_binrange ffbinr
#define fits_parse_range    ffrwrg
#define fits_parse_rangell    ffrwrgll
#define fits_open_memfile   ffomem

/* 
   use the following special macro to test that the fitsio.h include file
   that was used to build the CFITSIO library is compatible with the version
   as included when compiling the application program
*/
#define fits_open_file(A, B, C, D)  ffopentest( CFITSIO_SONAME, A, B, C, D)

#define fits_open_data      ffdopn
#define fits_open_table     fftopn
#define fits_open_image     ffiopn
#define fits_open_diskfile  ffdkopn
#define fits_reopen_file    ffreopen
#define fits_create_file    ffinit
#define fits_create_diskfile ffdkinit
#define fits_create_memfile ffimem
#define fits_create_template fftplt
#define fits_flush_file     ffflus
#define fits_flush_buffer   ffflsh
#define fits_close_file     ffclos
#define fits_delete_file    ffdelt
#define fits_file_name      ffflnm
#define fits_file_mode      ffflmd
#define fits_url_type       ffurlt

#define fits_get_version    ffvers
#define fits_uppercase      ffupch
#define fits_get_errstatus  ffgerr
#define fits_write_errmsg   ffpmsg
#define fits_write_errmark  ffpmrk
#define fits_read_errmsg    ffgmsg
#define fits_clear_errmsg   ffcmsg
#define fits_clear_errmark  ffcmrk
#define fits_report_error   ffrprt
#define fits_compare_str    ffcmps
#define fits_test_keyword   fftkey
#define fits_test_record    fftrec
#define fits_null_check     ffnchk
#define fits_make_keyn      ffkeyn
#define fits_make_nkey      ffnkey
#define fits_make_key       ffmkky
#define fits_get_keyclass   ffgkcl
#define fits_get_keytype    ffdtyp
#define fits_get_inttype    ffinttyp
#define fits_parse_value    ffpsvc
#define fits_get_keyname    ffgknm
#define fits_parse_template ffgthd
#define fits_ascii_tform    ffasfm
#define fits_binary_tform   ffbnfm
#define fits_binary_tformll   ffbnfmll
#define fits_get_tbcol      ffgabc
#define fits_get_rowsize    ffgrsz
#define fits_get_col_display_width    ffgcdw

#define fits_write_record       ffprec
#define fits_write_key          ffpky
#define fits_write_key_unit     ffpunt
#define fits_write_comment      ffpcom
#define fits_write_history      ffphis 
#define fits_write_date         ffpdat
#define fits_get_system_time    ffgstm
#define fits_get_system_date    ffgsdt
#define fits_date2str           ffdt2s
#define fits_time2str           fftm2s
#define fits_str2date           ffs2dt
#define fits_str2time           ffs2tm
#define fits_write_key_longstr  ffpkls
#define fits_write_key_longwarn ffplsw
#define fits_write_key_null     ffpkyu
#define fits_write_key_str      ffpkys
#define fits_write_key_log      ffpkyl
#define fits_write_key_lng      ffpkyj
#define fits_write_key_fixflt   ffpkyf
#define fits_write_key_flt      ffpkye
#define fits_write_key_fixdbl   ffpkyg
#define fits_write_key_dbl      ffpkyd
#define fits_write_key_fixcmp   ffpkfc
#define fits_write_key_cmp      ffpkyc
#define fits_write_key_fixdblcmp ffpkfm
#define fits_write_key_dblcmp   ffpkym
#define fits_write_key_triple   ffpkyt
#define fits_write_tdim         ffptdm
#define fits_write_tdimll       ffptdmll
#define fits_write_keys_str     ffpkns
#define fits_write_keys_log     ffpknl
#define fits_write_keys_lng     ffpknj
#define fits_write_keys_fixflt  ffpknf
#define fits_write_keys_flt     ffpkne
#define fits_write_keys_fixdbl  ffpkng
#define fits_write_keys_dbl     ffpknd
#define fits_copy_key           ffcpky
#define fits_write_imghdr       ffphps
#define fits_write_imghdrll     ffphpsll
#define fits_write_grphdr       ffphpr
#define fits_write_grphdrll     ffphprll
#define fits_write_atblhdr      ffphtb
#define fits_write_btblhdr      ffphbn
#define fits_write_exthdr       ffphext
#define fits_write_key_template ffpktp

#define fits_get_hdrspace      ffghsp
#define fits_get_hdrpos        ffghps
#define fits_movabs_key        ffmaky
#define fits_movrel_key        ffmrky
#define fits_find_nextkey      ffgnxk

#define fits_read_record       ffgrec
#define fits_read_card         ffgcrd
#define fits_read_str          ffgstr
#define fits_read_key_unit     ffgunt
#define fits_read_keyn         ffgkyn
#define fits_read_key          ffgky
#define fits_read_keyword      ffgkey
#define fits_read_key_str      ffgkys
#define fits_read_key_log      ffgkyl
#define fits_read_key_lng      ffgkyj
#define fits_read_key_lnglng   ffgkyjj
#define fits_read_key_flt      ffgkye
#define fits_read_key_dbl      ffgkyd
#define fits_read_key_cmp      ffgkyc
#define fits_read_key_dblcmp   ffgkym
#define fits_read_key_triple   ffgkyt
#define fits_read_key_longstr  ffgkls
#define fits_free_memory       fffree
#define fits_read_tdim         ffgtdm
#define fits_read_tdimll       ffgtdmll
#define fits_decode_tdim       ffdtdm
#define fits_decode_tdimll     ffdtdmll
#define fits_read_keys_str     ffgkns
#define fits_read_keys_log     ffgknl
#define fits_read_keys_lng     ffgknj
#define fits_read_keys_lnglng  ffgknjj
#define fits_read_keys_flt     ffgkne
#define fits_read_keys_dbl     ffgknd
#define fits_read_imghdr       ffghpr
#define fits_read_imghdrll     ffghprll
#define fits_read_atblhdr      ffghtb
#define fits_read_btblhdr      ffghbn
#define fits_read_atblhdrll    ffghtbll
#define fits_read_btblhdrll    ffghbnll
#define fits_hdr2str           ffhdr2str
#define fits_convert_hdr2str   ffcnvthdr2str

#define fits_update_card       ffucrd
#define fits_update_key        ffuky
#define fits_update_key_null   ffukyu
#define fits_update_key_str    ffukys
#define fits_update_key_longstr    ffukls
#define fits_update_key_log    ffukyl
#define fits_update_key_lng    ffukyj
#define fits_update_key_fixflt ffukyf
#define fits_update_key_flt    ffukye
#define fits_update_key_fixdbl ffukyg
#define fits_update_key_dbl    ffukyd
#define fits_update_key_fixcmp ffukfc
#define fits_update_key_cmp    ffukyc
#define fits_update_key_fixdblcmp ffukfm
#define fits_update_key_dblcmp ffukym

#define fits_modify_record     ffmrec
#define fits_modify_card       ffmcrd
#define fits_modify_name       ffmnam
#define fits_modify_comment    ffmcom
#define fits_modify_key_null   ffmkyu
#define fits_modify_key_str    ffmkys
#define fits_modify_key_longstr    ffmkls
#define fits_modify_key_log    ffmkyl
#define fits_modify_key_lng    ffmkyj
#define fits_modify_key_fixflt ffmkyf
#define fits_modify_key_flt    ffmkye
#define fits_modify_key_fixdbl ffmkyg
#define fits_modify_key_dbl    ffmkyd
#define fits_modify_key_fixcmp ffmkfc
#define fits_modify_key_cmp    ffmkyc
#define fits_modify_key_fixdblcmp ffmkfm
#define fits_modify_key_dblcmp ffmkym

#define fits_insert_record     ffirec
#define fits_insert_card       ffikey
#define fits_insert_key_null   ffikyu
#define fits_insert_key_str    ffikys
#define fits_insert_key_longstr    ffikls
#define fits_insert_key_log    ffikyl
#define fits_insert_key_lng    ffikyj
#define fits_insert_key_fixflt ffikyf
#define fits_insert_key_flt    ffikye
#define fits_insert_key_fixdbl ffikyg
#define fits_insert_key_dbl    ffikyd
#define fits_insert_key_fixcmp ffikfc
#define fits_insert_key_cmp    ffikyc
#define fits_insert_key_fixdblcmp ffikfm
#define fits_insert_key_dblcmp ffikym

#define fits_delete_key     ffdkey
#define fits_delete_str     ffdstr
#define fits_delete_record  ffdrec
#define fits_get_hdu_num    ffghdn
#define fits_get_hdu_type   ffghdt
#define fits_get_hduaddr    ffghad
#define fits_get_hduaddrll    ffghadll
#define fits_get_hduoff     ffghof

#define fits_get_img_param  ffgipr
#define fits_get_img_paramll  ffgiprll

#define fits_get_img_type   ffgidt
#define fits_get_img_equivtype   ffgiet
#define fits_get_img_dim    ffgidm
#define fits_get_img_size   ffgisz
#define fits_get_img_sizell   ffgiszll

#define fits_movabs_hdu     ffmahd
#define fits_movrel_hdu     ffmrhd
#define fits_movnam_hdu     ffmnhd
#define fits_get_num_hdus   ffthdu
#define fits_create_img     ffcrim
#define fits_create_imgll   ffcrimll
#define fits_create_tbl     ffcrtb
#define fits_create_hdu     ffcrhd
#define fits_insert_img     ffiimg
#define fits_insert_imgll   ffiimgll
#define fits_insert_atbl    ffitab
#define fits_insert_btbl    ffibin
#define fits_resize_img     ffrsim
#define fits_resize_imgll   ffrsimll

#define fits_delete_hdu     ffdhdu
#define fits_copy_hdu       ffcopy
#define fits_copy_file      ffcpfl
#define fits_copy_header    ffcphd
#define fits_copy_data      ffcpdt
#define fits_write_hdu      ffwrhdu

#define fits_set_hdustruc   ffrdef
#define fits_set_hdrsize    ffhdef
#define fits_write_theap    ffpthp

#define fits_encode_chksum  ffesum
#define fits_decode_chksum  ffdsum
#define fits_write_chksum   ffpcks
#define fits_update_chksum  ffupck
#define fits_verify_chksum  ffvcks
#define fits_get_chksum     ffgcks

#define fits_set_bscale     ffpscl
#define fits_set_tscale     fftscl
#define fits_set_imgnull    ffpnul
#define fits_set_btblnull   fftnul
#define fits_set_atblnull   ffsnul

#define fits_get_colnum     ffgcno
#define fits_get_colname    ffgcnn
#define fits_get_coltype    ffgtcl
#define fits_get_coltypell  ffgtclll
#define fits_get_eqcoltype  ffeqty
#define fits_get_eqcoltypell ffeqtyll
#define fits_get_num_rows   ffgnrw
#define fits_get_num_rowsll   ffgnrwll
#define fits_get_num_cols   ffgncl
#define fits_get_acolparms  ffgacl
#define fits_get_bcolparms  ffgbcl
#define fits_get_bcolparmsll  ffgbclll

#define fits_iterate_data   ffiter

#define fits_read_grppar_byt  ffggpb
#define fits_read_grppar_sbyt  ffggpsb
#define fits_read_grppar_usht  ffggpui
#define fits_read_grppar_ulng  ffggpuj
#define fits_read_grppar_sht  ffggpi
#define fits_read_grppar_lng  ffggpj
#define fits_read_grppar_lnglng  ffggpjj
#define fits_read_grppar_int  ffggpk
#define fits_read_grppar_uint  ffggpuk
#define fits_read_grppar_flt  ffggpe
#define fits_read_grppar_dbl  ffggpd

#define fits_read_pix         ffgpxv
#define fits_read_pixll       ffgpxvll
#define fits_read_pixnull     ffgpxf
#define fits_read_pixnullll   ffgpxfll
#define fits_read_img         ffgpv
#define fits_read_imgnull     ffgpf
#define fits_read_img_byt     ffgpvb
#define fits_read_img_sbyt     ffgpvsb
#define fits_read_img_usht     ffgpvui
#define fits_read_img_ulng     ffgpvuj
#define fits_read_img_sht     ffgpvi
#define fits_read_img_lng     ffgpvj
#define fits_read_img_lnglng     ffgpvjj
#define fits_read_img_uint     ffgpvuk
#define fits_read_img_int     ffgpvk
#define fits_read_img_flt     ffgpve
#define fits_read_img_dbl     ffgpvd

#define fits_read_imgnull_byt ffgpfb
#define fits_read_imgnull_sbyt ffgpfsb
#define fits_read_imgnull_usht ffgpfui
#define fits_read_imgnull_ulng ffgpfuj
#define fits_read_imgnull_sht ffgpfi
#define fits_read_imgnull_lng ffgpfj
#define fits_read_imgnull_lnglng ffgpfjj
#define fits_read_imgnull_uint ffgpfuk
#define fits_read_imgnull_int ffgpfk
#define fits_read_imgnull_flt ffgpfe
#define fits_read_imgnull_dbl ffgpfd

#define fits_read_2d_byt      ffg2db
#define fits_read_2d_sbyt     ffg2dsb
#define fits_read_2d_usht      ffg2dui
#define fits_read_2d_ulng      ffg2duj
#define fits_read_2d_sht      ffg2di
#define fits_read_2d_lng      ffg2dj
#define fits_read_2d_lnglng      ffg2djj
#define fits_read_2d_uint      ffg2duk
#define fits_read_2d_int      ffg2dk
#define fits_read_2d_flt      ffg2de
#define fits_read_2d_dbl      ffg2dd

#define fits_read_3d_byt      ffg3db
#define fits_read_3d_sbyt      ffg3dsb
#define fits_read_3d_usht      ffg3dui
#define fits_read_3d_ulng      ffg3duj
#define fits_read_3d_sht      ffg3di
#define fits_read_3d_lng      ffg3dj
#define fits_read_3d_lnglng      ffg3djj
#define fits_read_3d_uint      ffg3duk
#define fits_read_3d_int      ffg3dk
#define fits_read_3d_flt      ffg3de
#define fits_read_3d_dbl      ffg3dd

#define fits_read_subset      ffgsv
#define fits_read_subset_byt  ffgsvb
#define fits_read_subset_sbyt  ffgsvsb
#define fits_read_subset_usht  ffgsvui
#define fits_read_subset_ulng  ffgsvuj
#define fits_read_subset_sht  ffgsvi
#define fits_read_subset_lng  ffgsvj
#define fits_read_subset_lnglng  ffgsvjj
#define fits_read_subset_uint  ffgsvuk
#define fits_read_subset_int  ffgsvk
#define fits_read_subset_flt  ffgsve
#define fits_read_subset_dbl  ffgsvd

#define fits_read_subsetnull_byt ffgsfb
#define fits_read_subsetnull_sbyt ffgsfsb
#define fits_read_subsetnull_usht ffgsfui
#define fits_read_subsetnull_ulng ffgsfuj
#define fits_read_subsetnull_sht ffgsfi
#define fits_read_subsetnull_lng ffgsfj
#define fits_read_subsetnull_lnglng ffgsfjj
#define fits_read_subsetnull_uint ffgsfuk
#define fits_read_subsetnull_int ffgsfk
#define fits_read_subsetnull_flt ffgsfe
#define fits_read_subsetnull_dbl ffgsfd

#define ffcpimg fits_copy_image_section
#define fits_compress_img fits_comp_img
#define fits_decompress_img fits_decomp_img

#define fits_read_col        ffgcv
#define fits_read_colnull    ffgcf
#define fits_read_col_str    ffgcvs
#define fits_read_col_log    ffgcvl
#define fits_read_col_byt    ffgcvb
#define fits_read_col_sbyt    ffgcvsb
#define fits_read_col_usht    ffgcvui
#define fits_read_col_ulng    ffgcvuj
#define fits_read_col_sht    ffgcvi
#define fits_read_col_lng    ffgcvj
#define fits_read_col_lnglng    ffgcvjj
#define fits_read_col_uint    ffgcvuk
#define fits_read_col_int    ffgcvk
#define fits_read_col_flt    ffgcve
#define fits_read_col_dbl    ffgcvd
#define fits_read_col_cmp    ffgcvc
#define fits_read_col_dblcmp ffgcvm
#define fits_read_col_bit    ffgcx
#define fits_read_col_bit_usht ffgcxui
#define fits_read_col_bit_uint ffgcxuk

#define fits_read_colnull_str    ffgcfs
#define fits_read_colnull_log    ffgcfl
#define fits_read_colnull_byt    ffgcfb
#define fits_read_colnull_sbyt    ffgcfsb
#define fits_read_colnull_usht    ffgcfui
#define fits_read_colnull_ulng    ffgcfuj
#define fits_read_colnull_sht    ffgcfi
#define fits_read_colnull_lng    ffgcfj
#define fits_read_colnull_lnglng    ffgcfjj
#define fits_read_colnull_uint    ffgcfuk
#define fits_read_colnull_int    ffgcfk
#define fits_read_colnull_flt    ffgcfe
#define fits_read_colnull_dbl    ffgcfd
#define fits_read_colnull_cmp    ffgcfc
#define fits_read_colnull_dblcmp ffgcfm

#define fits_read_descript ffgdes
#define fits_read_descriptll ffgdesll
#define fits_read_descripts ffgdess
#define fits_read_descriptsll ffgdessll
#define fits_read_tblbytes    ffgtbb

#define fits_write_grppar_byt ffpgpb
#define fits_write_grppar_sbyt ffpgpsb
#define fits_write_grppar_usht ffpgpui
#define fits_write_grppar_ulng ffpgpuj
#define fits_write_grppar_sht ffpgpi
#define fits_write_grppar_lng ffpgpj
#define fits_write_grppar_lnglng ffpgpjj
#define fits_write_grppar_uint ffpgpuk
#define fits_write_grppar_int ffpgpk
#define fits_write_grppar_flt ffpgpe
#define fits_write_grppar_dbl ffpgpd

#define fits_write_pix        ffppx
#define fits_write_pixll      ffppxll
#define fits_write_pixnull    ffppxn
#define fits_write_pixnullll  ffppxnll
#define fits_write_img        ffppr
#define fits_write_img_byt    ffpprb
#define fits_write_img_sbyt    ffpprsb
#define fits_write_img_usht    ffpprui
#define fits_write_img_ulng    ffppruj
#define fits_write_img_sht    ffppri
#define fits_write_img_lng    ffpprj
#define fits_write_img_lnglng    ffpprjj
#define fits_write_img_uint    ffppruk
#define fits_write_img_int    ffpprk
#define fits_write_img_flt    ffppre
#define fits_write_img_dbl    ffpprd

#define fits_write_imgnull     ffppn
#define fits_write_imgnull_byt ffppnb
#define fits_write_imgnull_sbyt ffppnsb
#define fits_write_imgnull_usht ffppnui
#define fits_write_imgnull_ulng ffppnuj
#define fits_write_imgnull_sht ffppni
#define fits_write_imgnull_lng ffppnj
#define fits_write_imgnull_lnglng ffppnjj
#define fits_write_imgnull_uint ffppnuk
#define fits_write_imgnull_int ffppnk
#define fits_write_imgnull_flt ffppne
#define fits_write_imgnull_dbl ffppnd

#define fits_write_img_null ffppru
#define fits_write_null_img ffpprn

#define fits_write_2d_byt   ffp2db
#define fits_write_2d_sbyt   ffp2dsb
#define fits_write_2d_usht   ffp2dui
#define fits_write_2d_ulng   ffp2duj
#define fits_write_2d_sht   ffp2di
#define fits_write_2d_lng   ffp2dj
#define fits_write_2d_lnglng   ffp2djj
#define fits_write_2d_uint   ffp2duk
#define fits_write_2d_int   ffp2dk
#define fits_write_2d_flt   ffp2de
#define fits_write_2d_dbl   ffp2dd

#define fits_write_3d_byt   ffp3db
#define fits_write_3d_sbyt   ffp3dsb
#define fits_write_3d_usht   ffp3dui
#define fits_write_3d_ulng   ffp3duj
#define fits_write_3d_sht   ffp3di
#define fits_write_3d_lng   ffp3dj
#define fits_write_3d_lnglng   ffp3djj
#define fits_write_3d_uint   ffp3duk
#define fits_write_3d_int   ffp3dk
#define fits_write_3d_flt   ffp3de
#define fits_write_3d_dbl   ffp3dd

#define fits_write_subset  ffpss
#define fits_write_subset_byt  ffpssb
#define fits_write_subset_sbyt  ffpsssb
#define fits_write_subset_usht  ffpssui
#define fits_write_subset_ulng  ffpssuj
#define fits_write_subset_sht  ffpssi
#define fits_write_subset_lng  ffpssj
#define fits_write_subset_lnglng  ffpssjj
#define fits_write_subset_uint  ffpssuk
#define fits_write_subset_int  ffpssk
#define fits_write_subset_flt  ffpsse
#define fits_write_subset_dbl  ffpssd

#define fits_write_col         ffpcl
#define fits_write_col_str     ffpcls
#define fits_write_col_log     ffpcll
#define fits_write_col_byt     ffpclb
#define fits_write_col_sbyt     ffpclsb
#define fits_write_col_usht     ffpclui
#define fits_write_col_ulng     ffpcluj
#define fits_write_col_sht     ffpcli
#define fits_write_col_lng     ffpclj
#define fits_write_col_lnglng     ffpcljj
#define fits_write_col_uint     ffpcluk
#define fits_write_col_int     ffpclk
#define fits_write_col_flt     ffpcle
#define fits_write_col_dbl     ffpcld
#define fits_write_col_cmp     ffpclc
#define fits_write_col_dblcmp  ffpclm
#define fits_write_col_null    ffpclu
#define fits_write_col_bit     ffpclx
#define fits_write_nulrows     ffprwu
#define fits_write_nullrows    ffprwu

#define fits_write_colnull ffpcn
#define fits_write_colnull_str ffpcns
#define fits_write_colnull_log ffpcnl
#define fits_write_colnull_byt ffpcnb
#define fits_write_colnull_sbyt ffpcnsb
#define fits_write_colnull_usht ffpcnui
#define fits_write_colnull_ulng ffpcnuj
#define fits_write_colnull_sht ffpcni
#define fits_write_colnull_lng ffpcnj
#define fits_write_colnull_lnglng ffpcnjj
#define fits_write_colnull_uint ffpcnuk
#define fits_write_colnull_int ffpcnk
#define fits_write_colnull_flt ffpcne
#define fits_write_colnull_dbl ffpcnd

#define fits_write_ext ffpextn
#define fits_read_ext  ffgextn

#define fits_write_descript  ffpdes
#define fits_compress_heap   ffcmph
#define fits_test_heap   fftheap

#define fits_write_tblbytes  ffptbb
#define fits_insert_rows  ffirow
#define fits_delete_rows  ffdrow
#define fits_delete_rowrange ffdrrg
#define fits_delete_rowlist ffdrws
#define fits_delete_rowlistll ffdrwsll
#define fits_insert_col   fficol
#define fits_insert_cols  fficls
#define fits_delete_col   ffdcol
#define fits_copy_col     ffcpcl
#define fits_copy_rows    ffcprw
#define fits_modify_vector_len  ffmvec

#define fits_read_img_coord ffgics
#define fits_read_img_coord_version ffgicsa
#define fits_read_tbl_coord ffgtcs
#define fits_pix_to_world ffwldp
#define fits_world_to_pix ffxypx

#define fits_get_image_wcs_keys ffgiwcs
#define fits_get_table_wcs_keys ffgtwcs

#define fits_find_rows          fffrow
#define fits_find_first_row     ffffrw
#define fits_find_rows_cmp      fffrwc
#define fits_select_rows        ffsrow
#define fits_calc_rows          ffcrow
#define fits_calculator         ffcalc
#define fits_calculator_rng     ffcalc_rng
#define fits_test_expr          fftexp

#define fits_create_group       ffgtcr 
#define fits_insert_group       ffgtis 
#define fits_change_group       ffgtch 
#define fits_remove_group       ffgtrm 
#define fits_copy_group         ffgtcp 
#define fits_merge_groups       ffgtmg 
#define fits_compact_group      ffgtcm 
#define fits_verify_group       ffgtvf 
#define fits_open_group         ffgtop 
#define fits_add_group_member   ffgtam 
#define fits_get_num_members    ffgtnm 

#define fits_get_num_groups     ffgmng 
#define fits_open_member        ffgmop 
#define fits_copy_member        ffgmcp 
#define fits_transfer_member    ffgmtf 
#define fits_remove_member      ffgmrm

#endif
healpy-1.10.3/cfitsio/makefile.bc0000664000175000017500000003072213010375005017047 0ustar  zoncazonca00000000000000#
# Borland C++ IDE generated makefile
# Generated 10/12/99 at 1:24:11 PM 
#
.AUTODEPEND


#
# Borland C++ tools
#
IMPLIB  = Implib
BCC32   = Bcc32 +BccW32.cfg 
BCC32I  = Bcc32i +BccW32.cfg 
TLINK32 = TLink32
ILINK32 = Ilink32
TLIB    = TLib
BRC32   = Brc32
TASM32  = Tasm32
#
# IDE macros
#


#
# Options
#
IDE_LinkFLAGS32 =  -LD:\BC5\LIB
LinkerLocalOptsAtC32_cfitsiodlib =  -Tpd -ap -c
ResLocalOptsAtC32_cfitsiodlib = 
BLocalOptsAtC32_cfitsiodlib = 
CompInheritOptsAt_cfitsiodlib = -ID:\BC5\INCLUDE -D_RTLDLL -DWIN32;
LinkerInheritOptsAt_cfitsiodlib = -x
LinkerOptsAt_cfitsiodlib = $(LinkerLocalOptsAtC32_cfitsiodlib)
ResOptsAt_cfitsiodlib = $(ResLocalOptsAtC32_cfitsiodlib)
BOptsAt_cfitsiodlib = $(BLocalOptsAtC32_cfitsiodlib)

#
# Dependency List
#
Dep_cfitsio = \
   cfitsio.lib

cfitsio : BccW32.cfg $(Dep_cfitsio)
  echo MakeNode

cfitsio.lib : cfitsio.dll
  $(IMPLIB) $@ cfitsio.dll


Dep_cfitsioddll = \
   listhead.obj\
   imcompress.obj\
   quantize.obj\
   ricecomp.obj\
   pliocomp.obj\
   iraffits.obj\
   wcsutil.obj\
   histo.obj\
   scalnull.obj\
   region.obj\
   putkey.obj\
   putcoluk.obj\
   putcoluj.obj\
   putcolui.obj\
   putcolu.obj\
   putcols.obj\
   putcoll.obj\
   putcolk.obj\
   putcolj.obj\
   putcoli.obj\
   putcole.obj\
   putcold.obj\
   putcolb.obj\
   putcolsb.obj\
   putcol.obj\
   modkey.obj\
   swapproc.obj\
   getcol.obj\
   group.obj\
   getkey.obj\
   getcoluk.obj\
   getcoluj.obj\
   getcolui.obj\
   getcols.obj\
   getcoll.obj\
   getcolk.obj\
   getcolj.obj\
   getcoli.obj\
   getcole.obj\
   getcold.obj\
   getcolb.obj\
   getcolsb.obj\
   grparser.obj\
   fitscore.obj\
   f77_wrap1.obj\
   f77_wrap2.obj\
   f77_wrap3.obj\
   f77_wrap4.obj\
   eval_y.obj\
   eval_l.obj\
   eval_f.obj\
   edithdu.obj\
   editcol.obj\
   drvrmem.obj\
   drvrfile.obj\
   checksum.obj\
   cfileio.obj\
   buffers.obj\
   fits_hcompress.obj\
   fits_hdecompress.obj\
   zuncompress.obj\
   zcompress.obj\
   adler32.obj\
   crc32.obj\
   inffast.obj\
   inftrees.obj\
   trees.obj\
   zutil.obj\
   deflate.obj\
   infback.obj\
   inflate.obj\
   uncompr.obj

cfitsio.dll : $(Dep_cfitsioddll) cfitsio.def
  $(ILINK32) @&&|
 /v $(IDE_LinkFLAGS32) $(LinkerOptsAt_cfitsiodlib) $(LinkerInheritOptsAt_cfitsiodlib) +
D:\BC5\LIB\c0d32.obj+
listhead.obj+
imcompress.obj+
quantize.obj+
ricecomp.obj+
pliocomp.obj+
iraffits.obj+
wcsutil.obj+
histo.obj+
iraffits.obj+
scalnull.obj+
region.obj+
putkey.obj+
putcoluk.obj+
putcoluj.obj+
putcolui.obj+
putcolu.obj+
putcols.obj+
putcoll.obj+
putcolk.obj+
putcolj.obj+
putcoli.obj+
putcole.obj+
putcold.obj+
putcolb.obj+
putcolsb.obj+
putcol.obj+
modkey.obj+
swapproc.obj+
getcol.obj+
group.obj+
getkey.obj+
getcoluk.obj+
getcoluj.obj+
getcolui.obj+
getcols.obj+
getcoll.obj+
getcolk.obj+
getcolj.obj+
getcoli.obj+
getcole.obj+
getcold.obj+
getcolb.obj+
getcolsb.obj+
grparser.obj+
fitscore.obj+
f77_wrap1.obj+
f77_wrap2.obj+
f77_wrap3.obj+
f77_wrap4.obj+
eval_y.obj+
eval_l.obj+
eval_f.obj+
edithdu.obj+
editcol.obj+
drvrmem.obj+
drvrfile.obj+
checksum.obj+
cfileio.obj+
buffers.obj+
fits_hcompress.obj+
fits_hdecompress.obj+
zuncompress.obj+
zcompress.obj+
adler32.obj+
crc32.obj+
inffast.obj+
inftrees.obj+
trees.obj+
zutil.obj+
deflate.obj+
infback.obj+
inflate.obj+
uncompr.obj
$<,$*
D:\BC5\LIB\import32.lib+
D:\BC5\LIB\cw32i.lib
cfitsio.def


|
wcsutil.obj :  wcsutil.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ wcsutil.c
|
iraffits.obj :  iraffits.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ iraffits.c
|
histo.obj :  histo.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ histo.c
|

scalnull.obj :  scalnull.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ scalnull.c
|

region.obj :  region.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ region.c
|

putkey.obj :  putkey.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putkey.c
|

putcoluk.obj :  putcoluk.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcoluk.c
|

putcoluj.obj :  putcoluj.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcoluj.c
|

putcolui.obj :  putcolui.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcolui.c
|

putcolu.obj :  putcolu.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcolu.c
|

putcols.obj :  putcols.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcols.c
|

putcoll.obj :  putcoll.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcoll.c
|

putcolk.obj :  putcolk.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcolk.c
|

putcolj.obj :  putcolj.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcolj.c
|

putcoli.obj :  putcoli.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcoli.c
|

putcole.obj :  putcole.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcole.c
|

putcold.obj :  putcold.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcold.c
|

putcolb.obj :  putcolb.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcolb.c
|

putcolsb.obj :  putcolsb.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcolsb.c
|

putcol.obj :  putcol.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ putcol.c
|

modkey.obj :  modkey.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ modkey.c
|

swapproc.obj :  swapproc.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ swapproc.c
|

getcol.obj :  getcol.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcol.c
|

group.obj :  group.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ group.c
|

getkey.obj :  getkey.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getkey.c
|

getcoluk.obj :  getcoluk.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcoluk.c
|

getcoluj.obj :  getcoluj.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcoluj.c
|

getcolui.obj :  getcolui.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcolui.c
|

getcols.obj :  getcols.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcols.c
|

getcoll.obj :  getcoll.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcoll.c
|

getcolk.obj :  getcolk.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcolk.c
|

getcolj.obj :  getcolj.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcolj.c
|

getcoli.obj :  getcoli.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcoli.c
|

getcole.obj :  getcole.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcole.c
|

getcold.obj :  getcold.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcold.c
|

getcolb.obj :  getcolb.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcolb.c
|
getcolsb.obj :  getcolsb.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ getcolsb.c
|

grparser.obj :  grparser.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ grparser.c
|

fitscore.obj :  fitscore.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ fitscore.c
|

f77_wrap1.obj :  f77_wrap1.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ f77_wrap1.c
|

f77_wrap2.obj :  f77_wrap2.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ f77_wrap2.c
|

f77_wrap3.obj :  f77_wrap3.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ f77_wrap3.c
|

f77_wrap4.obj :  f77_wrap4.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ f77_wrap4.c
|

eval_y.obj :  eval_y.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ eval_y.c
|

eval_l.obj :  eval_l.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ eval_l.c
|

eval_f.obj :  eval_f.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ eval_f.c
|

edithdu.obj :  edithdu.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ edithdu.c
|

editcol.obj :  editcol.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ editcol.c
|

drvrmem.obj :  drvrmem.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ drvrmem.c
|

drvrfile.obj :  drvrfile.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ drvrfile.c
|

checksum.obj :  checksum.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ checksum.c
|

cfileio.obj :  cfileio.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ cfileio.c
|

listhead.obj :  listhead.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ listhead.c
|

imcompress.obj :  imcompress.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ imcompress.c
|

quantize.obj :  quantize.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ quantize.c
|

ricecomp.obj :  ricecomp.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ ricecomp.c
|

pliocomp.obj :  pliocomp.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ pliocomp.c
|

buffers.obj :  buffers.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ buffers.c
|

fits_hcompress.obj :  fits_hcompress.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ fits_hcompress.c
|

fits_hdecompress.obj :  fits_hdecompress.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ fits_hdecompress.c
|

zuncompress.obj :  zuncompress.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ zuncompress.c
|

zcompress.obj :  zcompress.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ zcompress.c
|

adler32.obj :  adler32.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ adler32.c
|

crc32.obj :  crc32.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ crc32.c
|

inffast.obj :  inffast.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ inffast.c
|

inftrees.obj :  inftrees.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ inftrees.c
|

trees.obj :  trees.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ trees.c
|

zutil.obj :  zutil.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ zutil.c
|

deflate.obj :  deflate.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ deflate.c
|

infback.obj :  infback.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ infback.c
|

inflate.obj :  inflate.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ inflate.c
|

uncompr.obj :  uncompr.c
  $(BCC32) -P- -c @&&|
 $(CompOptsAt_cfitsiodlib) $(CompInheritOptsAt_cfitsiodlib) -o$@ uncompr.c
|


windumpexts.exe :  windumpexts.c
  bcc32 windumpexts.c


cfitsio.def: windumpexts.exe
	windumpexts -o cfitsio.def cfitsio.dll @&&|
		$(Dep_cfitsioddll)
|

# Compiler configuration file
BccW32.cfg : 
   Copy &&|
-w
-R
-v
-WM-
-vi
-H
-H=cfitsio.csm
-WCD
| $@


healpy-1.10.3/cfitsio/makefile.vcc0000664000175000017500000004317013010375005017237 0ustar  zoncazonca00000000000000# Microsoft Developer Studio Generated NMAKE File, Based on cfitsio.dsp
!IF "$(CFG)" == ""
CFG=Win32 Release
!MESSAGE No configuration specified. Defaulting to Win32 Release.
!ENDIF 

!IF "$(CFG)" != "Win32 Release" && "$(CFG)" != "Win32 Debug"
!MESSAGE Invalid configuration "$(CFG)" specified.
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE 
!MESSAGE NMAKE /f "cfitsio.mak" CFG="Win32 Debug"
!MESSAGE 
!MESSAGE Possible choices for configuration are:
!MESSAGE 
!MESSAGE "Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE 
!ERROR An invalid configuration is specified.
!ENDIF 

!IF "$(OS)" == "Windows_NT"
NULL=
!ELSE 
NULL=nul
!ENDIF 

CPP=cl.exe
MTL=midl.exe
RSC=rc.exe

!IF  "$(CFG)" == "Win32 Release"

OUTDIR=.
INTDIR=.\Release
# Begin Custom Macros
OutDir=.
# End Custom Macros

ALL : "$(OUTDIR)\cfitsio.dll"


CLEAN :
	-@erase "$(INTDIR)\buffers.obj"
	-@erase "$(INTDIR)\cfileio.obj"
	-@erase "$(INTDIR)\checksum.obj"
	-@erase "$(INTDIR)\drvrfile.obj"
	-@erase "$(INTDIR)\drvrmem.obj"
	-@erase "$(INTDIR)\editcol.obj"
	-@erase "$(INTDIR)\edithdu.obj"
	-@erase "$(INTDIR)\eval_f.obj"
	-@erase "$(INTDIR)\eval_l.obj"
	-@erase "$(INTDIR)\eval_y.obj"
	-@erase "$(INTDIR)\fitscore.obj"
	-@erase "$(INTDIR)\f77_wrap1.obj"
	-@erase "$(INTDIR)\f77_wrap2.obj"
	-@erase "$(INTDIR)\f77_wrap3.obj"
	-@erase "$(INTDIR)\f77_wrap4.obj"
	-@erase "$(INTDIR)\getcol.obj"
	-@erase "$(INTDIR)\getcolb.obj"
	-@erase "$(INTDIR)\getcolsb.obj"
	-@erase "$(INTDIR)\getcold.obj"
	-@erase "$(INTDIR)\getcole.obj"
	-@erase "$(INTDIR)\getcoli.obj"
	-@erase "$(INTDIR)\getcolj.obj"
	-@erase "$(INTDIR)\getcolk.obj"
	-@erase "$(INTDIR)\getcoll.obj"
	-@erase "$(INTDIR)\getcols.obj"
	-@erase "$(INTDIR)\getcolui.obj"
	-@erase "$(INTDIR)\getcoluj.obj"
	-@erase "$(INTDIR)\getcoluk.obj"
	-@erase "$(INTDIR)\getkey.obj"
	-@erase "$(INTDIR)\group.obj"
	-@erase "$(INTDIR)\grparser.obj"
	-@erase "$(INTDIR)\histo.obj"
	-@erase "$(INTDIR)\iraffits.obj"
	-@erase "$(INTDIR)\modkey.obj"
	-@erase "$(INTDIR)\putcol.obj"
	-@erase "$(INTDIR)\putcolb.obj"
	-@erase "$(INTDIR)\putcolsb.obj"
	-@erase "$(INTDIR)\putcold.obj"
	-@erase "$(INTDIR)\putcole.obj"
	-@erase "$(INTDIR)\putcoli.obj"
	-@erase "$(INTDIR)\putcolj.obj"
	-@erase "$(INTDIR)\putcolk.obj"
	-@erase "$(INTDIR)\putcoll.obj"
	-@erase "$(INTDIR)\putcols.obj"
	-@erase "$(INTDIR)\putcolu.obj"
	-@erase "$(INTDIR)\putcolui.obj"
	-@erase "$(INTDIR)\putcoluj.obj"
	-@erase "$(INTDIR)\putcoluk.obj"
	-@erase "$(INTDIR)\putkey.obj"
	-@erase "$(INTDIR)\region.obj"
	-@erase "$(INTDIR)\scalnull.obj"
	-@erase "$(INTDIR)\swapproc.obj"
	-@erase "$(INTDIR)\wcssub.obj"
	-@erase "$(INTDIR)\wcsutil.obj"
	-@erase "$(INTDIR)\imcompress.obj"
	-@erase "$(INTDIR)\ricecomp.obj"
	-@erase "$(INTDIR)\quantize.obj"
	-@erase "$(INTDIR)\pliocomp.obj"
	-@erase "$(INTDIR)\fits_hcompress.obj"
	-@erase "$(INTDIR)\fits_hdecompress.obj"
	-@erase "$(INTDIR)\zuncompress.obj"
	-@erase "$(INTDIR)\zcompress.obj"
	-@erase "$(INTDIR)\adler32.obj"
	-@erase "$(INTDIR)\crc32.obj"
	-@erase "$(INTDIR)\inffast.obj"
	-@erase "$(INTDIR)\inftrees.obj"
	-@erase "$(INTDIR)\trees.obj"
	-@erase "$(INTDIR)\zutil.obj"
	-@erase "$(INTDIR)\deflate.obj"
	-@erase "$(INTDIR)\infback.obj"
	-@erase "$(INTDIR)\inflate.obj"
	-@erase "$(INTDIR)\uncompr.obj"
	-@erase "$(INTDIR)\vc60.idb"
	-@erase "$(OUTDIR)\cfitsio.dll"
	-@erase "$(OUTDIR)\cfitsio.exp"
	-@erase "$(OUTDIR)\cfitsio.lib"

"$(OUTDIR)" :
    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"

"$(INTDIR)" :
    if not exist "$(INTDIR)/$(NULL)" mkdir "$(INTDIR)"

CPP_PROJ=/nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CFITSIO_EXPORTS" /D "_CRT_SECURE_NO_DEPRECATE" /Fp"$(INTDIR)\cfitsio.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c 
MTL_PROJ=/nologo /D "NDEBUG" /mktyplib203 /win32 
BSC32=bscmake.exe
BSC32_FLAGS=/nologo /o"$(OUTDIR)\cfitsio.bsc" 
BSC32_SBRS= \
	
LINK32=link.exe
LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /pdb:"$(OUTDIR)\cfitsio.pdb" /machine:I386 /def:".\cfitsio.def" /out:"$(OUTDIR)\cfitsio.dll" /implib:"$(OUTDIR)\cfitsio.lib" 
DEF_FILE= ".\cfitsio.def"
LINK32_OBJS= \
	"$(INTDIR)\buffers.obj" \
	"$(INTDIR)\cfileio.obj" \
	"$(INTDIR)\checksum.obj" \
	"$(INTDIR)\drvrfile.obj" \
	"$(INTDIR)\drvrmem.obj" \
	"$(INTDIR)\editcol.obj" \
	"$(INTDIR)\edithdu.obj" \
	"$(INTDIR)\eval_f.obj" \
	"$(INTDIR)\eval_l.obj" \
	"$(INTDIR)\eval_y.obj" \
	"$(INTDIR)\fitscore.obj" \
	"$(INTDIR)\f77_wrap1.obj" \
	"$(INTDIR)\f77_wrap2.obj" \
	"$(INTDIR)\f77_wrap3.obj" \
	"$(INTDIR)\f77_wrap4.obj" \
	"$(INTDIR)\getcol.obj" \
	"$(INTDIR)\getcolb.obj" \
	"$(INTDIR)\getcolsb.obj" \
	"$(INTDIR)\getcold.obj" \
	"$(INTDIR)\getcole.obj" \
	"$(INTDIR)\getcoli.obj" \
	"$(INTDIR)\getcolj.obj" \
	"$(INTDIR)\getcolk.obj" \
	"$(INTDIR)\getcoll.obj" \
	"$(INTDIR)\getcols.obj" \
	"$(INTDIR)\getcolui.obj" \
	"$(INTDIR)\getcoluj.obj" \
	"$(INTDIR)\getcoluk.obj" \
	"$(INTDIR)\getkey.obj" \
	"$(INTDIR)\group.obj" \
	"$(INTDIR)\grparser.obj" \
	"$(INTDIR)\histo.obj" \
	"$(INTDIR)\iraffits.obj" \
	"$(INTDIR)\modkey.obj" \
	"$(INTDIR)\putcol.obj" \
	"$(INTDIR)\putcolb.obj" \
	"$(INTDIR)\putcolsb.obj" \
	"$(INTDIR)\putcold.obj" \
	"$(INTDIR)\putcole.obj" \
	"$(INTDIR)\putcoli.obj" \
	"$(INTDIR)\putcolj.obj" \
	"$(INTDIR)\putcolk.obj" \
	"$(INTDIR)\putcoll.obj" \
	"$(INTDIR)\putcols.obj" \
	"$(INTDIR)\putcolu.obj" \
	"$(INTDIR)\putcolui.obj" \
	"$(INTDIR)\putcoluj.obj" \
	"$(INTDIR)\putcoluk.obj" \
	"$(INTDIR)\putkey.obj" \
	"$(INTDIR)\region.obj" \
	"$(INTDIR)\scalnull.obj" \
	"$(INTDIR)\swapproc.obj" \
	"$(INTDIR)\wcssub.obj"  \
	"$(INTDIR)\wcsutil.obj" \
	"$(INTDIR)\imcompress.obj" \
	"$(INTDIR)\ricecomp.obj" \
	"$(INTDIR)\quantize.obj" \
	"$(INTDIR)\pliocomp.obj" \
	"$(INTDIR)\fits_hcompress.obj" \
	"$(INTDIR)\fits_hdecompress.obj" \
	"$(INTDIR)\zuncompress.obj" \
	"$(INTDIR)\zcompress.obj" \
	"$(INTDIR)\adler32.obj" \
	"$(INTDIR)\crc32.obj" \
	"$(INTDIR)\inffast.obj" \
	"$(INTDIR)\inftrees.obj" \
	"$(INTDIR)\trees.obj" \
	"$(INTDIR)\zutil.obj" \
	"$(INTDIR)\deflate.obj" \
	"$(INTDIR)\infback.obj" \
	"$(INTDIR)\inflate.obj" \
	"$(INTDIR)\uncompr.obj" 

"$(OUTDIR)\cfitsio.dll" : $(LINK32_OBJS) WINDUMP
	windumpexts -o $(DEF_FILE) cfitsio.dll $(LINK32_OBJS)
	$(LINK32) @<<
  $(LINK32_FLAGS) $(LINK32_OBJS)
<<

!ELSEIF  "$(CFG)" == "Win32 Debug"

OUTDIR=.
INTDIR=.\Debug
# Begin Custom Macros
OutDir=.
# End Custom Macros

ALL : "$(OUTDIR)\cfitsio.dll"


CLEAN :
	-@erase "$(INTDIR)\buffers.obj"
	-@erase "$(INTDIR)\cfileio.obj"
	-@erase "$(INTDIR)\checksum.obj"
	-@erase "$(INTDIR)\drvrfile.obj"
	-@erase "$(INTDIR)\drvrmem.obj"
	-@erase "$(INTDIR)\editcol.obj"
	-@erase "$(INTDIR)\edithdu.obj"
	-@erase "$(INTDIR)\eval_f.obj"
	-@erase "$(INTDIR)\eval_l.obj"
	-@erase "$(INTDIR)\eval_y.obj"
	-@erase "$(INTDIR)\fitscore.obj"
	-@erase "$(INTDIR)\f77_wrap1.obj"
	-@erase "$(INTDIR)\f77_wrap2.obj"
	-@erase "$(INTDIR)\f77_wrap3.obj"
	-@erase "$(INTDIR)\f77_wrap4.obj"
	-@erase "$(INTDIR)\getcol.obj"
	-@erase "$(INTDIR)\getcolb.obj"
	-@erase "$(INTDIR)\getcolsb.obj"
	-@erase "$(INTDIR)\getcold.obj"
	-@erase "$(INTDIR)\getcole.obj"
	-@erase "$(INTDIR)\getcoli.obj"
	-@erase "$(INTDIR)\getcolj.obj"
	-@erase "$(INTDIR)\getcolk.obj"
	-@erase "$(INTDIR)\getcoll.obj"
	-@erase "$(INTDIR)\getcols.obj"
	-@erase "$(INTDIR)\getcolui.obj"
	-@erase "$(INTDIR)\getcoluj.obj"
	-@erase "$(INTDIR)\getcoluk.obj"
	-@erase "$(INTDIR)\getkey.obj"
	-@erase "$(INTDIR)\group.obj"
	-@erase "$(INTDIR)\grparser.obj"
	-@erase "$(INTDIR)\histo.obj"
	-@erase "$(INTDIR)\iraffits.obj"
	-@erase "$(INTDIR)\modkey.obj"
	-@erase "$(INTDIR)\putcol.obj"
	-@erase "$(INTDIR)\putcolb.obj"
	-@erase "$(INTDIR)\putcolsb.obj"
	-@erase "$(INTDIR)\putcold.obj"
	-@erase "$(INTDIR)\putcole.obj"
	-@erase "$(INTDIR)\putcoli.obj"
	-@erase "$(INTDIR)\putcolj.obj"
	-@erase "$(INTDIR)\putcolk.obj"
	-@erase "$(INTDIR)\putcoll.obj"
	-@erase "$(INTDIR)\putcols.obj"
	-@erase "$(INTDIR)\putcolu.obj"
	-@erase "$(INTDIR)\putcolui.obj"
	-@erase "$(INTDIR)\putcoluj.obj"
	-@erase "$(INTDIR)\putcoluk.obj"
	-@erase "$(INTDIR)\putkey.obj"
	-@erase "$(INTDIR)\region.obj"
	-@erase "$(INTDIR)\scalnull.obj"
	-@erase "$(INTDIR)\swapproc.obj"
	-@erase "$(INTDIR)\vc60.idb"
	-@erase "$(INTDIR)\vc60.pdb"
	-@erase "$(INTDIR)\wcssub.obj"
	-@erase "$(INTDIR)\wcsutil.obj"
	-@erase "$(INTDIR)\imcompress.obj"
	-@erase "$(INTDIR)\ricecomp.obj"
	-@erase "$(INTDIR)\quantize.obj"
	-@erase "$(INTDIR)\pliocomp.obj"
	-@erase "$(INTDIR)\fits_hcompress.obj"
	-@erase "$(INTDIR)\fits_hdecompress.obj"
	-@erase "$(INTDIR)\zuncompress.obj"
	-@erase "$(INTDIR)\zcompress.obj"
	-@erase "$(INTDIR)\adler32.obj"
	-@erase "$(INTDIR)\crc32.obj"
	-@erase "$(INTDIR)\inffast.obj"
	-@erase "$(INTDIR)\inftrees.obj"
	-@erase "$(INTDIR)\trees.obj"
	-@erase "$(INTDIR)\zutil.obj"
	-@erase "$(INTDIR)\deflate.obj"
	-@erase "$(INTDIR)\infback.obj"
	-@erase "$(INTDIR)\inflate.obj"
	-@erase "$(INTDIR)\uncompr.obj"
	-@erase "$(OUTDIR)\cfitsio.dll"
	-@erase "$(OUTDIR)\cfitsio.exp"
	-@erase "$(OUTDIR)\cfitsio.ilk"
	-@erase "$(OUTDIR)\cfitsio.lib"
	-@erase "$(OUTDIR)\cfitsio.pdb"

"$(OUTDIR)" :
    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"

"$(INTDIR)" :
    if not exist "$(INTDIR)/$(NULL)" mkdir "$(INTDIR)"

CPP_PROJ=/nologo /MDd /W3 /Gm /GX /ZI /Od /D "__WIN32__" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "CFITSIO_EXPORTS" /D "_CRT_SECURE_NO_DEPRECATE" /Fp"$(INTDIR)\cfitsio.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /GZ /c 
MTL_PROJ=/nologo /D "_DEBUG" /mktyplib203 /win32 
BSC32=bscmake.exe
BSC32_FLAGS=/nologo /o"$(OUTDIR)\cfitsio.bsc" 
BSC32_SBRS= \
	
LINK32=link.exe
LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:yes /pdb:"$(OUTDIR)\cfitsio.pdb" /debug /machine:I386 /def:".\cfitsio.def" /out:"$(OUTDIR)\cfitsio.dll" /implib:"$(OUTDIR)\cfitsio.lib" /pdbtype:sept 
DEF_FILE= ".\cfitsio.def"
LINK32_OBJS= \
	"$(INTDIR)\buffers.obj" \
	"$(INTDIR)\cfileio.obj" \
	"$(INTDIR)\checksum.obj" \
	"$(INTDIR)\drvrfile.obj" \
	"$(INTDIR)\drvrmem.obj" \
	"$(INTDIR)\editcol.obj" \
	"$(INTDIR)\edithdu.obj" \
	"$(INTDIR)\eval_f.obj" \
	"$(INTDIR)\eval_l.obj" \
	"$(INTDIR)\eval_y.obj" \
	"$(INTDIR)\fitscore.obj" \
	"$(INTDIR)\f77_wrap1.obj" \
	"$(INTDIR)\f77_wrap2.obj" \
	"$(INTDIR)\f77_wrap3.obj" \
	"$(INTDIR)\f77_wrap4.obj" \
	"$(INTDIR)\getcol.obj" \
	"$(INTDIR)\getcolb.obj" \
	"$(INTDIR)\getcolsb.obj" \
	"$(INTDIR)\getcold.obj" \
	"$(INTDIR)\getcole.obj" \
	"$(INTDIR)\getcoli.obj" \
	"$(INTDIR)\getcolj.obj" \
	"$(INTDIR)\getcolk.obj" \
	"$(INTDIR)\getcoll.obj" \
	"$(INTDIR)\getcols.obj" \
	"$(INTDIR)\getcolui.obj" \
	"$(INTDIR)\getcoluj.obj" \
	"$(INTDIR)\getcoluk.obj" \
	"$(INTDIR)\getkey.obj" \
	"$(INTDIR)\group.obj" \
	"$(INTDIR)\grparser.obj" \
	"$(INTDIR)\histo.obj" \
	"$(INTDIR)\iraffits.obj" \
	"$(INTDIR)\modkey.obj" \
	"$(INTDIR)\putcol.obj" \
	"$(INTDIR)\putcolb.obj" \
	"$(INTDIR)\putcolsb.obj" \
	"$(INTDIR)\putcold.obj" \
	"$(INTDIR)\putcole.obj" \
	"$(INTDIR)\putcoli.obj" \
	"$(INTDIR)\putcolj.obj" \
	"$(INTDIR)\putcolk.obj" \
	"$(INTDIR)\putcoll.obj" \
	"$(INTDIR)\putcols.obj" \
	"$(INTDIR)\putcolu.obj" \
	"$(INTDIR)\putcolui.obj" \
	"$(INTDIR)\putcoluj.obj" \
	"$(INTDIR)\putcoluk.obj" \
	"$(INTDIR)\putkey.obj" \
	"$(INTDIR)\region.obj" \
	"$(INTDIR)\scalnull.obj" \
	"$(INTDIR)\swapproc.obj" \
	"$(INTDIR)\wcssub.obj" \
	"$(INTDIR)\wcsutil.obj" \
	"$(INTDIR)\imcompress.obj" \
	"$(INTDIR)\ricecomp.obj" \
	"$(INTDIR)\quantize.obj" \
	"$(INTDIR)\pliocomp.obj" \
	"$(INTDIR)\fits_hcompress.obj" \
	"$(INTDIR)\fits_hdecompress.obj" \
	"$(INTDIR)\zuncompress.obj" \
	"$(INTDIR)\zcompress.obj" \
	"$(INTDIR)\adler32.obj" \
	"$(INTDIR)\crc32.obj" \
	"$(INTDIR)\inffast.obj" \
	"$(INTDIR)\inftrees.obj" \
	"$(INTDIR)\trees.obj" \
	"$(INTDIR)\zutil.obj" \
	"$(INTDIR)\deflate.obj" \
	"$(INTDIR)\infback.obj" \
	"$(INTDIR)\inflate.obj" \
	"$(INTDIR)\uncompr.obj" 

"$(OUTDIR)\cfitsio.dll" : $(LINK32_OBJS) WINDUMP
	windumpexts -o $(DEF_FILE) cfitsio.dll $(LINK32_OBJS)    
	$(LINK32) @<<
	$(LINK32_FLAGS) $(LINK32_OBJS)
<<

!ENDIF 

.c{$(INTDIR)}.obj::
   $(CPP) @<<
   $(CPP_PROJ) $< 
<<

.cpp{$(INTDIR)}.obj::
   $(CPP) @<<
   $(CPP_PROJ) $< 
<<

.cxx{$(INTDIR)}.obj::
   $(CPP) @<<
   $(CPP_PROJ) $< 
<<

.c{$(INTDIR)}.sbr::
   $(CPP) @<<
   $(CPP_PROJ) $< 
<<

.cpp{$(INTDIR)}.sbr::
   $(CPP) @<<
   $(CPP_PROJ) $< 
<<

.cxx{$(INTDIR)}.sbr::
   $(CPP) @<<
   $(CPP_PROJ) $< 
<<


!IF "$(NO_EXTERNAL_DEPS)" != "1"
!IF EXISTS("cfitsio.dep")
!INCLUDE "cfitsio.dep"
!ELSE 
!MESSAGE Warning: cannot find "cfitsio.dep"
!ENDIF 
!ENDIF 


!IF "$(CFG)" == "Win32 Release" || "$(CFG)" == "Win32 Debug"
SOURCE=.\buffers.c

"$(INTDIR)\buffers.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\cfileio.c

"$(INTDIR)\cfileio.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\checksum.c

"$(INTDIR)\checksum.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\drvrfile.c

"$(INTDIR)\drvrfile.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\drvrmem.c

"$(INTDIR)\drvrmem.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\editcol.c

"$(INTDIR)\editcol.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\edithdu.c

"$(INTDIR)\edithdu.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\eval_f.c

"$(INTDIR)\eval_f.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\eval_l.c

"$(INTDIR)\eval_l.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\eval_y.c

"$(INTDIR)\eval_y.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\fitscore.c

"$(INTDIR)\fitscore.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\f77_wrap1.c

"$(INTDIR)\f77_wrap1.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\f77_wrap2.c

"$(INTDIR)\f77_wrap2.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\f77_wrap3.c

"$(INTDIR)\f77_wrap3.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\f77_wrap4.c

"$(INTDIR)\f77_wrap4.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcol.c

"$(INTDIR)\getcol.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcolb.c

"$(INTDIR)\getcolb.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcolsb.c

"$(INTDIR)\getcolsb.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcold.c

"$(INTDIR)\getcold.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcole.c

"$(INTDIR)\getcole.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcoli.c

"$(INTDIR)\getcoli.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcolj.c

"$(INTDIR)\getcolj.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcolk.c

"$(INTDIR)\getcolk.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcoll.c

"$(INTDIR)\getcoll.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcols.c

"$(INTDIR)\getcols.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcolui.c

"$(INTDIR)\getcolui.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcoluj.c

"$(INTDIR)\getcoluj.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getcoluk.c

"$(INTDIR)\getcoluk.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\getkey.c

"$(INTDIR)\getkey.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\group.c

"$(INTDIR)\group.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\grparser.c

"$(INTDIR)\grparser.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\histo.c

"$(INTDIR)\histo.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\iraffits.c

"$(INTDIR)\iraffits.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\modkey.c

"$(INTDIR)\modkey.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcol.c

"$(INTDIR)\putcol.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcolb.c

"$(INTDIR)\putcolb.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcolsb.c

"$(INTDIR)\putcolsb.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcold.c

"$(INTDIR)\putcold.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcole.c

"$(INTDIR)\putcole.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcoli.c

"$(INTDIR)\putcoli.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcolj.c

"$(INTDIR)\putcolj.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcolk.c

"$(INTDIR)\putcolk.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcoll.c

"$(INTDIR)\putcoll.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcols.c

"$(INTDIR)\putcols.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcolu.c

"$(INTDIR)\putcolu.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcolui.c

"$(INTDIR)\putcolui.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcoluj.c

"$(INTDIR)\putcoluj.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putcoluk.c

"$(INTDIR)\putcoluk.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\putkey.c

"$(INTDIR)\putkey.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\region.c

"$(INTDIR)\region.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\scalnull.c

"$(INTDIR)\scalnull.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\swapproc.c

"$(INTDIR)\swapproc.obj" : $(SOURCE) "$(INTDIR)"


SOURCE=.\wcssub.c

"$(INTDIR)\wcssub.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=.\wcsutil.c

"$(INTDIR)\wcsutil.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=imcompress.c

"$(INTDIR)\imcompress.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=ricecomp.c

"$(INTDIR)\ricecomp.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=quantize.c

"$(INTDIR)\quantize.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=pliocomp.c

"$(INTDIR)\pliocomp.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=fits_hcompress.c

"$(INTDIR)\fits_hcompress.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=fits_hdecompress.c

"$(INTDIR)\fits_hdecompress.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=zuncompress.c

"$(INTDIR)\zuncompress.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=zcompress.c

"$(INTDIR)\zcompress.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=adler32.c

"$(INTDIR)\adler32.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=crc32.c

"$(INTDIR)\crc32.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=inffast.c

"$(INTDIR)\inffast.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=inftrees.c

"$(INTDIR)\inftrees.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=trees.c

"$(INTDIR)\trees.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=zutil.c

"$(INTDIR)\zutil.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=deflate.c

"$(INTDIR)\deflate.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=infback.c

"$(INTDIR)\infback.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=inflate.c

"$(INTDIR)\inflate.obj" : $(SOURCE) "$(INTDIR)"

SOURCE=uncompr.c

"$(INTDIR)\uncompr.obj" : $(SOURCE) "$(INTDIR)"

!ENDIF 

$(DEF_FILE):  



WINDUMP:
	nmake -f winDumpExts.mak
healpy-1.10.3/cfitsio/makepc.bat0000664000175000017500000000440313010375005016711 0ustar  zoncazonca00000000000000rem:  this batch file builds the cfitsio library 
rem:  using the Borland C++ v4.5 or new free v5.5 compiler
rem:
bcc32 -c buffers.c
bcc32 -c cfileio.c
bcc32 -c checksum.c
bcc32 -c drvrfile.c
bcc32 -c drvrmem.c
bcc32 -c editcol.c
bcc32 -c edithdu.c
bcc32 -c eval_l.c
bcc32 -c eval_y.c
bcc32 -c eval_f.c
bcc32 -c fitscore.c
bcc32 -c getcol.c
bcc32 -c getcolb.c
bcc32 -c getcolsb.c
bcc32 -c getcoli.c
bcc32 -c getcolj.c
bcc32 -c getcolui.c
bcc32 -c getcoluj.c
bcc32 -c getcoluk.c
bcc32 -c getcolk.c
bcc32 -c getcole.c
bcc32 -c getcold.c
bcc32 -c getcoll.c
bcc32 -c getcols.c
bcc32 -c getkey.c
bcc32 -c group.c
bcc32 -c grparser.c
bcc32 -c histo.c
bcc32 -c iraffits.c
bcc32 -c modkey.c
bcc32 -c putcol.c
bcc32 -c putcolb.c
bcc32 -c putcolsb.c
bcc32 -c putcoli.c
bcc32 -c putcolj.c
bcc32 -c putcolui.c
bcc32 -c putcoluj.c
bcc32 -c putcoluk.c
bcc32 -c putcolk.c
bcc32 -c putcole.c
bcc32 -c putcold.c
bcc32 -c putcols.c
bcc32 -c putcoll.c
bcc32 -c putcolu.c
bcc32 -c putkey.c
bcc32 -c region.c
bcc32 -c scalnull.c
bcc32 -c swapproc.c
bcc32 -c wcsutil.c
bcc32 -c wcssub.c
bcc32 -c imcompress.c
bcc32 -c quantize.c
bcc32 -c ricecomp.c
bcc32 -c pliocomp.c
bcc32 -c fits_hcompress.c
bcc32 -c fits_hdecompress.c
bcc32 -c zuncompress.c
bcc32 -c zcompress.c
bcc32 -c adler32.c
bcc32 -c crc32.c
bcc32 -c inffast.c
bcc32 -c inftrees.c
bcc32 -c trees.c
bcc32 -c zutil.c
bcc32 -c deflate.c
bcc32 -c infback.c
bcc32 -c inflate.c
bcc32 -c uncompr.c
del cfitsio.lib
tlib cfitsio +buffers +cfileio +checksum +drvrfile +drvrmem 
tlib cfitsio +editcol +edithdu +eval_l +eval_y +eval_f +fitscore
tlib cfitsio +getcol +getcolb +getcolsb +getcoli +getcolj +getcolk +getcoluk 
tlib cfitsio +getcolui +getcoluj +getcole +getcold +getcoll +getcols
tlib cfitsio +getkey +group +grparser +histo +iraffits +modkey +putkey 
tlib cfitsio +putcol  +putcolb +putcoli +putcolj +putcolk +putcole +putcold
tlib cfitsio +putcoll +putcols +putcolu +putcolui +putcoluj +putcoluk
tlib cfitsio +region +scalnull +swapproc +wcsutil +wcssub +putcolsb
tlib cfitsio +imcompress +quantize +ricecomp +pliocomp
tlib cfitsio +fits_hcompress +fits_hdecompress
tlib cfitsio +zuncompress +zcompress +adler32 +crc32 +inffast
tlib cfitsio +inftrees +trees +zutil +deflate +infback +inflate +uncompr
bcc32 -f testprog.c cfitsio.lib
bcc32 -f cookbook.c cfitsio.lib

healpy-1.10.3/cfitsio/modkey.c0000664000175000017500000017563213010375005016432 0ustar  zoncazonca00000000000000/*  This file, modkey.c, contains routines that modify, insert, or update  */
/*  keywords in a FITS header.                                             */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
/* stddef.h is apparently needed to define size_t */
#include 
#include 
#include 
#include "fitsio2.h"
/*--------------------------------------------------------------------------*/
int ffuky( fitsfile *fptr,     /* I - FITS file pointer        */
           int  datatype,      /* I - datatype of the value    */
           const char *keyname,/* I - name of keyword to write */
           void *value,        /* I - keyword value            */
           const char *comm,   /* I - keyword comment          */
           int  *status)       /* IO - error status            */
/*
  Update the keyword, value and comment in the FITS header.
  The datatype is specified by the 2nd argument.
*/
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (datatype == TSTRING)
    {
        ffukys(fptr, keyname, (char *) value, comm, status);
    }
    else if (datatype == TBYTE)
    {
        ffukyj(fptr, keyname, (LONGLONG) *(unsigned char *) value, comm, status);
    }
    else if (datatype == TSBYTE)
    {
        ffukyj(fptr, keyname, (LONGLONG) *(signed char *) value, comm, status);
    }
    else if (datatype == TUSHORT)
    {
        ffukyj(fptr, keyname, (LONGLONG) *(unsigned short *) value, comm, status);
    }
    else if (datatype == TSHORT)
    {
        ffukyj(fptr, keyname, (LONGLONG) *(short *) value, comm, status);
    }
    else if (datatype == TINT)
    {
        ffukyj(fptr, keyname, (LONGLONG) *(int *) value, comm, status);
    }
    else if (datatype == TUINT)
    {
        ffukyg(fptr, keyname, (double) *(unsigned int *) value, 0,
               comm, status);
    }
    else if (datatype == TLOGICAL)
    {
        ffukyl(fptr, keyname, *(int *) value, comm, status);
    }
    else if (datatype == TULONG)
    {
        ffukyg(fptr, keyname, (double) *(unsigned long *) value, 0,
               comm, status);
    }
    else if (datatype == TLONG)
    {
        ffukyj(fptr, keyname, (LONGLONG) *(long *) value, comm, status);
    }
    else if (datatype == TLONGLONG)
    {
        ffukyj(fptr, keyname, *(LONGLONG *) value, comm, status);
    }
    else if (datatype == TFLOAT)
    {
        ffukye(fptr, keyname, *(float *) value, -7, comm, status);
    }
    else if (datatype == TDOUBLE)
    {
        ffukyd(fptr, keyname, *(double *) value, -15, comm, status);
    }
    else if (datatype == TCOMPLEX)
    {
        ffukyc(fptr, keyname, (float *) value, -7, comm, status);
    }
    else if (datatype == TDBLCOMPLEX)
    {
        ffukym(fptr, keyname, (double *) value, -15, comm, status);
    }
    else
        *status = BAD_DATATYPE;

    return(*status);
} 
/*--------------------------------------------------------------------------*/
int ffukyu(fitsfile *fptr,      /* I - FITS file pointer  */
           const char *keyname, /* I - keyword name       */
           const char *comm,    /* I - keyword comment    */
           int *status)         /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkyu(fptr, keyname, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkyu(fptr, keyname, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukys(fitsfile *fptr,       /* I - FITS file pointer  */
           const char *keyname,  /* I - keyword name       */
           const char *value,    /* I - keyword value      */
           const char *comm,     /* I - keyword comment    */
           int *status)          /* IO - error status      */ 
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkys(fptr, keyname, value, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkys(fptr, keyname, value, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukls(fitsfile *fptr,      /* I - FITS file pointer  */
           const char *keyname, /* I - keyword name       */
           const char *value,   /* I - keyword value      */
           const char *comm,    /* I - keyword comment    */
           int *status)         /* IO - error status      */ 
{
    /* update a long string keyword */

    int tstatus;
    char junk[FLEN_ERRMSG];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkls(fptr, keyname, value, comm, status) == KEY_NO_EXIST)
    {
        /* since the ffmkls call failed, it wrote a bogus error message */
        fits_read_errmsg(junk);  /* clear the error message */
	
        *status = tstatus;
        ffpkls(fptr, keyname, value, comm, status);
    }
    return(*status);
}/*--------------------------------------------------------------------------*/
int ffukyl(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           int value,          /* I - keyword value      */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkyl(fptr, keyname, value, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkyl(fptr, keyname, value, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukyj(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           LONGLONG value,     /* I - keyword value      */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkyj(fptr, keyname, value, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkyj(fptr, keyname, value, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukyf(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           float value,        /* I - keyword value      */
           int decim,          /* I - no of decimals     */         
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkyf(fptr, keyname, value, decim, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkyf(fptr, keyname, value, decim, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukye(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           float value,        /* I - keyword value      */
           int decim,          /* I - no of decimals     */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkye(fptr, keyname, value, decim, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkye(fptr, keyname, value, decim, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukyg(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           double value,       /* I - keyword value      */
           int decim,          /* I - no of decimals     */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkyg(fptr, keyname, value, decim, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkyg(fptr, keyname, value, decim, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukyd(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           double value,       /* I - keyword value      */
           int decim,          /* I - no of decimals     */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkyd(fptr, keyname, value, decim, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkyd(fptr, keyname, value, decim, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukfc(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           float *value,       /* I - keyword value      */
           int decim,          /* I - no of decimals     */         
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkfc(fptr, keyname, value, decim, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkfc(fptr, keyname, value, decim, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukyc(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           float *value,       /* I - keyword value      */
           int decim,          /* I - no of decimals     */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkyc(fptr, keyname, value, decim, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkyc(fptr, keyname, value, decim, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukfm(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           double *value,      /* I - keyword value      */
           int decim,          /* I - no of decimals     */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkfm(fptr, keyname, value, decim, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkfm(fptr, keyname, value, decim, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffukym(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           double *value,      /* I - keyword value      */
           int decim,          /* I - no of decimals     */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmkym(fptr, keyname, value, decim, comm, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffpkym(fptr, keyname, value, decim, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffucrd(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           const char *card,   /* I - card string value  */
           int *status)        /* IO - error status      */
{
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = *status;

    if (ffmcrd(fptr, keyname, card, status) == KEY_NO_EXIST)
    {
        *status = tstatus;
        ffprec(fptr, card, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmrec(fitsfile *fptr,    /* I - FITS file pointer               */
           int nkey,          /* I - number of the keyword to modify */
           const char *card,  /* I - card string value               */
           int *status)       /* IO - error status                   */
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffmaky(fptr, nkey+1, status);
    ffmkey(fptr, card, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmcrd(fitsfile *fptr,      /* I - FITS file pointer  */
           const char *keyname, /* I - keyword name       */
           const char *card,    /* I - card string value  */
           int *status)         /* IO - error status      */
{
    char tcard[FLEN_CARD], valstring[FLEN_CARD], comm[FLEN_CARD], value[FLEN_CARD];
    int keypos, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgcrd(fptr, keyname, tcard, status) > 0)
        return(*status);

    ffmkey(fptr, card, status);

    /* calc position of keyword in header */
    keypos = (int) ((((fptr->Fptr)->nextkey) - ((fptr->Fptr)->headstart[(fptr->Fptr)->curhdu])) / 80) + 1;

    ffpsvc(tcard, valstring, comm, status);

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check for string value which may be continued over multiple keywords */
    ffpmrk(); /* put mark on message stack; erase any messages after this */
    ffc2s(valstring, value, status);   /* remove quotes and trailing spaces */

    if (*status == VALUE_UNDEFINED) {
       ffcmrk();  /* clear any spurious error messages, back to the mark */
       *status = 0;
    } else {
 
      len = strlen(value);

      while (len && value[len - 1] == '&')  /* ampersand used as continuation char */
      {
        ffgcnt(fptr, value, status);
        if (*value)
        {
            ffdrec(fptr, keypos, status);  /* delete the keyword */
            len = strlen(value);
        }
        else   /* a null valstring indicates no continuation */
            len = 0;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmnam(fitsfile *fptr,     /* I - FITS file pointer     */
           const char *oldname,/* I - existing keyword name */
           const char *newname,/* I - new name for keyword  */
           int *status)        /* IO - error status         */
{
    char comm[FLEN_COMMENT];
    char value[FLEN_VALUE];
    char card[FLEN_CARD];
 
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, oldname, value, comm, status) > 0)
        return(*status);

    ffmkky(newname, value, comm, card, status);  /* construct the card */
    ffmkey(fptr, card, status);  /* rewrite with new name */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmcom(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    char oldcomm[FLEN_COMMENT];
    char value[FLEN_VALUE];
    char card[FLEN_CARD];
 
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, value, oldcomm, status) > 0)
        return(*status);

    ffmkky(keyname, value, comm, card, status);  /* construct the card */
    ffmkey(fptr, card, status);  /* rewrite with new comment */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpunt(fitsfile *fptr,     /* I - FITS file pointer   */
           const char *keyname,/* I - keyword name        */
           const char *unit,   /* I - keyword unit string */
           int *status)        /* IO - error status       */
/*
    Write (put) the units string into the comment field of the existing
    keyword. This routine uses a local FITS convention (not defined in the
    official FITS standard) in which the units are enclosed in 
    square brackets following the '/' comment field delimiter, e.g.:

    KEYWORD =                   12 / [kpc] comment string goes here
*/
{
    char oldcomm[FLEN_COMMENT];
    char newcomm[FLEN_COMMENT];
    char value[FLEN_VALUE];
    char card[FLEN_CARD];
    char *loc;
    size_t len;
 
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, value, oldcomm, status) > 0)
        return(*status);

    /* copy the units string to the new comment string if not null */
    if (*unit)
    {
        strcpy(newcomm, "[");
        strncat(newcomm, unit, 45);  /* max allowed length is about 45 chars */
        strcat(newcomm, "] ");
        len = strlen(newcomm);  
        len = FLEN_COMMENT - len - 1;  /* amount of space left in the field */
    }
    else
    {
        newcomm[0] = '\0';
        len = FLEN_COMMENT - 1;
    }

    if (oldcomm[0] == '[')  /* check for existing units field */
    {
        loc = strchr(oldcomm, ']');  /* look for the closing bracket */
        if (loc)
        {
            loc++;
            while (*loc == ' ')   /* skip any blank spaces */
               loc++;

            strncat(newcomm, loc, len);  /* concat remainder of comment */
        }
        else
        {
            strncat(newcomm, oldcomm, len);  /* append old comment onto new */
        }
    }
    else
    {
        strncat(newcomm, oldcomm, len);
    }

    ffmkky(keyname, value, newcomm, card, status);  /* construct the card */
    ffmkey(fptr, card, status);  /* rewrite with new units string */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkyu(fitsfile *fptr,     /* I - FITS file pointer  */
           const char *keyname,/* I - keyword name       */
           const char *comm,   /* I - keyword comment    */
           int *status)        /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    strcpy(valstring," ");  /* create a dummy value string */

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkys(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           const char *value,       /* I - keyword value      */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
  /* NOTE: This routine does not support long continued strings */
  /*  It will correctly overwrite an existing long continued string, */
  /*  but it will not write a new long string.  */

    char oldval[FLEN_VALUE], valstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];
    int len, keypos;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, oldval, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    ffs2c(value, valstring, status);   /* convert value to a string */

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status); /* overwrite the previous keyword */

    keypos = (int) (((((fptr->Fptr)->nextkey) - ((fptr->Fptr)->headstart[(fptr->Fptr)->curhdu])) / 80) + 1);

    if (*status > 0)           
        return(*status);

    /* check if old string value was continued over multiple keywords */
    ffpmrk(); /* put mark on message stack; erase any messages after this */
    ffc2s(oldval, valstring, status); /* remove quotes and trailing spaces */

    if (*status == VALUE_UNDEFINED) {
       ffcmrk();  /* clear any spurious error messages, back to the mark */
       *status = 0;
    } else {
        
      len = strlen(valstring);

      while (len && valstring[len - 1] == '&')  /* ampersand is continuation char */
      {
        ffgcnt(fptr, valstring, status);
        if (*valstring)
        {
            ffdrec(fptr, keypos, status);  /* delete the continuation */
            len = strlen(valstring);
        }
        else   /* a null valstring indicates no continuation */
            len = 0;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkls( fitsfile *fptr,           /* I - FITS file pointer        */
            const char *keyname,      /* I - name of keyword to write */
            const char *value,        /* I - keyword value            */
            const char *incomm,       /* I - keyword comment          */
            int  *status)             /* IO - error status            */
/*
  Modify the value and optionally the comment of a long string keyword.
  This routine supports the
  HEASARC long string convention and can modify arbitrarily long string
  keyword values.  The value is continued over multiple keywords that
  have the name COMTINUE without an equal sign in column 9 of the card.
  This routine also supports simple string keywords which are less than
  69 characters in length.

  This routine is not very efficient, so it should be used sparingly.
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD], tmpkeyname[FLEN_CARD];
    char comm[FLEN_COMMENT];
    char tstring[FLEN_VALUE], *cptr;
    char *longval;
    int next, remain, vlen, nquote, nchar, namelen, contin, tstatus = -1;
    int nkeys, keypos;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (!incomm || incomm[0] == '&')  /* preserve the old comment string */
    {
        ffghps(fptr, &nkeys, &keypos, status); /* save current position */

        if (ffgkls(fptr, keyname, &longval, comm, status) > 0)
            return(*status);            /* keyword doesn't exist */

        free(longval);  /* don't need the old value */

        /* move back to previous position to ensure that we delete */
        /* the right keyword in case there are more than one keyword */
        /* with this same name. */
        ffgrec(fptr, keypos - 1, card, status); 
    } else {
        /* copy the input comment string */
        strncpy(comm, incomm, FLEN_COMMENT-1);
        comm[FLEN_COMMENT-1] = '\0';
    }

    /* delete the old keyword */
    if (ffdkey(fptr, keyname, status) > 0)
        return(*status);            /* keyword doesn't exist */

    ffghps(fptr, &nkeys, &keypos, status); /* save current position */

    /* now construct the new keyword, and insert into header */
    remain = strlen(value);    /* number of characters to write out */
    next = 0;                  /* pointer to next character to write */
    
    /* count the number of single quote characters in the string */
    nquote = 0;
    cptr = strchr(value, '\'');   /* search for quote character */

    while (cptr)  /* search for quote character */
    {
        nquote++;            /*  increment no. of quote characters  */
        cptr++;              /*  increment pointer to next character */
        cptr = strchr(cptr, '\'');  /* search for another quote char */
    }

    strncpy(tmpkeyname, keyname, 80);
    tmpkeyname[80] = '\0';
    
    cptr = tmpkeyname;
    while(*cptr == ' ')   /* skip over leading spaces in name */
        cptr++;

    /* determine the number of characters that will fit on the line */
    /* Note: each quote character is expanded to 2 quotes */

    namelen = strlen(cptr);
    if (namelen <= 8 && (fftkey(cptr, &tstatus) <= 0) )
    {
        /* This a normal 8-character FITS keyword */
        nchar = 68 - nquote; /*  max of 68 chars fit in a FITS string value */
    }
    else
    {
        /* This a HIERARCH keyword */
        if (FSTRNCMP(cptr, "HIERARCH ", 9) && 
            FSTRNCMP(cptr, "hierarch ", 9))
            nchar = 66 - nquote - namelen;
        else
            nchar = 75 - nquote - namelen;  /* don't count 'HIERARCH' twice */

    }

    contin = 0;
    while (remain > 0)
    {
        strncpy(tstring, &value[next], nchar); /* copy string to temp buff */
        tstring[nchar] = '\0';
        ffs2c(tstring, valstring, status);  /* put quotes around the string */

        if (remain > nchar)   /* if string is continued, put & as last char */
        {
            vlen = strlen(valstring);
            nchar -= 1;        /* outputting one less character now */

            if (valstring[vlen-2] != '\'')
                valstring[vlen-2] = '&';  /*  over write last char with &  */
            else
            { /* last char was a pair of single quotes, so over write both */
                valstring[vlen-3] = '&';
                valstring[vlen-1] = '\0';
            }
        }

        if (contin)           /* This is a CONTINUEd keyword */
        {
           ffmkky("CONTINUE", valstring, comm, card, status); /* make keyword */
           strncpy(&card[8], "   ",  2);  /* overwrite the '=' */
        }
        else
        {
           ffmkky(keyname, valstring, comm, card, status);  /* make keyword */
        }

        ffirec(fptr, keypos, card, status);  /* insert the keyword */
       
        keypos++;        /* next insert position */
        contin = 1;
        remain -= nchar;
        next  += nchar;
        nchar = 68 - nquote;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkyl(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           int value,               /* I - keyword value      */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    ffl2c(value, valstring, status);   /* convert value to a string */

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkyj(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           LONGLONG value,          /* I - keyword value      */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    ffi2c(value, valstring, status);   /* convert value to a string */

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkyf(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           float value,             /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    ffr2f(value, decim, valstring, status);   /* convert value to a string */

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkye(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           float value,             /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    ffr2e(value, decim, valstring, status);   /* convert value to a string */

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkyg(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           double value,            /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    ffd2f(value, decim, valstring, status);   /* convert value to a string */

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkyd(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           double value,            /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    ffd2e(value, decim, valstring, status);   /* convert value to a string */

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkfc(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           float *value,            /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    strcpy(valstring, "(" );
    ffr2f(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffr2f(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkyc(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           float *value,            /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    strcpy(valstring, "(" );
    ffr2e(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffr2e(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkfm(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           double *value,           /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    strcpy(valstring, "(" );
    ffd2f(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffd2f(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffmkym(fitsfile *fptr,    /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           double *value,     /* I - keyword value      */
           int decim,         /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */
           int *status)       /* IO - error status      */
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char oldcomm[FLEN_COMMENT];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, oldcomm, status) > 0)
        return(*status);                               /* get old comment */

    strcpy(valstring, "(" );
    ffd2e(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffd2e(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    if (!comm || comm[0] == '&')  /* preserve the current comment string */
        ffmkky(keyname, valstring, oldcomm, card, status);
    else
        ffmkky(keyname, valstring, comm, card, status);

    ffmkey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikyu(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
/*
  Insert a null-valued keyword and comment into the FITS header.  
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring," ");  /* create a dummy value string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikys(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           const char *value,       /* I - keyword value      */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffs2c(value, valstring, status);   /* put quotes around the string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikls( fitsfile *fptr,           /* I - FITS file pointer        */
            const char *keyname,      /* I - name of keyword to write */
            const char *value,        /* I - keyword value            */
            const char *comm,         /* I - keyword comment          */
            int  *status)             /* IO - error status            */
/*
  Insert a long string keyword.  This routine supports the
  HEASARC long string convention and can insert arbitrarily long string
  keyword values.  The value is continued over multiple keywords that
  have the name COMTINUE without an equal sign in column 9 of the card.
  This routine also supports simple string keywords which are less than
  69 characters in length.
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD], tmpkeyname[FLEN_CARD];
    char tstring[FLEN_VALUE], *cptr;
    int next, remain, vlen, nquote, nchar, namelen, contin, tstatus = -1;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /*  construct the new keyword, and insert into header */
    remain = strlen(value);    /* number of characters to write out */
    next = 0;                  /* pointer to next character to write */
    
    /* count the number of single quote characters in the string */
    nquote = 0;
    cptr = strchr(value, '\'');   /* search for quote character */

    while (cptr)  /* search for quote character */
    {
        nquote++;            /*  increment no. of quote characters  */
        cptr++;              /*  increment pointer to next character */
        cptr = strchr(cptr, '\'');  /* search for another quote char */
    }


    strncpy(tmpkeyname, keyname, 80);
    tmpkeyname[80] = '\0';
    
    cptr = tmpkeyname;
    while(*cptr == ' ')   /* skip over leading spaces in name */
        cptr++;

    /* determine the number of characters that will fit on the line */
    /* Note: each quote character is expanded to 2 quotes */

    namelen = strlen(cptr);
    if (namelen <= 8 && (fftkey(cptr, &tstatus) <= 0) )
    {
        /* This a normal 8-character FITS keyword */
        nchar = 68 - nquote; /*  max of 68 chars fit in a FITS string value */
    }
    else
    {
        /* This a HIERARCH keyword */
        if (FSTRNCMP(cptr, "HIERARCH ", 9) && 
            FSTRNCMP(cptr, "hierarch ", 9))
            nchar = 66 - nquote - namelen;
        else
            nchar = 75 - nquote - namelen;  /* don't count 'HIERARCH' twice */

    }

    contin = 0;
    while (remain > 0)
    {
        strncpy(tstring, &value[next], nchar); /* copy string to temp buff */
        tstring[nchar] = '\0';
        ffs2c(tstring, valstring, status);  /* put quotes around the string */

        if (remain > nchar)   /* if string is continued, put & as last char */
        {
            vlen = strlen(valstring);
            nchar -= 1;        /* outputting one less character now */

            if (valstring[vlen-2] != '\'')
                valstring[vlen-2] = '&';  /*  over write last char with &  */
            else
            { /* last char was a pair of single quotes, so over write both */
                valstring[vlen-3] = '&';
                valstring[vlen-1] = '\0';
            }
        }

        if (contin)           /* This is a CONTINUEd keyword */
        {
           ffmkky("CONTINUE", valstring, comm, card, status); /* make keyword */
           strncpy(&card[8], "   ",  2);  /* overwrite the '=' */
        }
        else
        {
           ffmkky(keyname, valstring, comm, card, status);  /* make keyword */
        }

        ffikey(fptr, card, status);  /* insert the keyword */
       
        contin = 1;
        remain -= nchar;
        next  += nchar;
        nchar = 68 - nquote;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikyl(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           int value,               /* I - keyword value      */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffl2c(value, valstring, status);   /* convert logical to 'T' or 'F' */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikyj(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           LONGLONG value,          /* I - keyword value      */
           const char *comm,        /* I - keyword comment    */
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffi2c(value, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikyf(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           float value,             /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */ 
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffr2f(value, decim, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status); 
}
/*--------------------------------------------------------------------------*/
int ffikye(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           float value,             /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */ 
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffr2e(value, decim, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikyg(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           double value,            /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */ 
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffd2f(value, decim, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikyd(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           double value,            /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */ 
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffd2e(value, decim, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikfc(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           float *value,            /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */ 
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring, "(" );
    ffr2f(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffr2f(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikyc(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           float *value,            /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */ 
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring, "(" );
    ffr2e(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffr2e(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikfm(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           double *value,           /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */ 
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);


    strcpy(valstring, "(" );
    ffd2f(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffd2f(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikym(fitsfile *fptr,          /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           double *value,           /* I - keyword value      */
           int decim,               /* I - no of decimals     */
           const char *comm,        /* I - keyword comment    */ 
           int *status)             /* IO - error status      */
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring, "(" );
    ffd2e(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffd2e(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffikey(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffirec(fitsfile *fptr,    /* I - FITS file pointer              */
           int nkey,          /* I - position to insert new keyword */
           const char *card,  /* I - card string value              */
           int *status)       /* IO - error status                  */
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffmaky(fptr, nkey, status);  /* move to insert position */
    ffikey(fptr, card, status);  /* insert the keyword card */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffikey(fitsfile *fptr,    /* I - FITS file pointer  */
           const char *card,  /* I - card string value  */
           int *status)       /* IO - error status      */
/*
  insert a keyword at the position of (fptr->Fptr)->nextkey
*/
{
    int ii, len, nshift;
    long nblocks;
    LONGLONG bytepos;
    char *inbuff, *outbuff, *tmpbuff, buff1[FLEN_CARD], buff2[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if ( ((fptr->Fptr)->datastart - (fptr->Fptr)->headend) == 80) /* only room for END card */
    {
        nblocks = 1;
        if (ffiblk(fptr, nblocks, 0, status) > 0) /* add new 2880-byte block*/
            return(*status);  
    }

    /* no. keywords to shift */
    nshift= (int) (( (fptr->Fptr)->headend - (fptr->Fptr)->nextkey ) / 80); 

    strncpy(buff2, card, 80);     /* copy card to output buffer */
    buff2[80] = '\0';

    len = strlen(buff2);

    /* silently replace any illegal characters with a space */
    for (ii=0; ii < len; ii++)   
        if (buff2[ii] < ' ' || buff2[ii] > 126) buff2[ii] = ' ';

    for (ii=len; ii < 80; ii++)   /* fill buffer with spaces if necessary */
        buff2[ii] = ' ';

    for (ii=0; ii < 8; ii++)       /* make sure keyword name is uppercase */
        buff2[ii] = toupper(buff2[ii]);

    fftkey(buff2, status);        /* test keyword name contains legal chars */

/*  no need to do this any more, since any illegal characters have been removed
    fftrec(buff2, status);  */      /* test rest of keyword for legal chars   */

    inbuff = buff1;
    outbuff = buff2;

    bytepos = (fptr->Fptr)->nextkey;           /* pointer to next keyword in header */
    ffmbyt(fptr, bytepos, REPORT_EOF, status);

    for (ii = 0; ii < nshift; ii++) /* shift each keyword down one position */
    {
        ffgbyt(fptr, 80, inbuff, status);   /* read the current keyword */

        ffmbyt(fptr, bytepos, REPORT_EOF, status); /* move back */
        ffpbyt(fptr, 80, outbuff, status);  /* overwrite with other buffer */

        tmpbuff = inbuff;   /* swap input and output buffers */
        inbuff = outbuff;
        outbuff = tmpbuff;

        bytepos += 80;
    }

    ffpbyt(fptr, 80, outbuff, status);  /* write the final keyword */

    (fptr->Fptr)->headend += 80; /* increment the position of the END keyword */
    (fptr->Fptr)->nextkey += 80; /* increment the pointer to next keyword */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffdkey(fitsfile *fptr,    /* I - FITS file pointer  */
           const char *keyname,     /* I - keyword name       */
           int *status)       /* IO - error status      */
/*
  delete a specified header keyword
*/
{
    int keypos, len;
    char valstring[FLEN_VALUE], comm[FLEN_COMMENT], value[FLEN_VALUE];
    char message[FLEN_ERRMSG];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgkey(fptr, keyname, valstring, comm, status) > 0) /* read keyword */
    {
        sprintf(message, "Could not find the %s keyword to delete (ffdkey)",
                keyname);
        ffpmsg(message);
        return(*status);
    }

    /* calc position of keyword in header */
    keypos = (int) ((((fptr->Fptr)->nextkey) - ((fptr->Fptr)->headstart[(fptr->Fptr)->curhdu])) / 80);

    ffdrec(fptr, keypos, status);  /* delete the keyword */

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check for string value which may be continued over multiple keywords */
    ffpmrk(); /* put mark on message stack; erase any messages after this */
    ffc2s(valstring, value, status);   /* remove quotes and trailing spaces */

    if (*status == VALUE_UNDEFINED) {
       ffcmrk();  /* clear any spurious error messages, back to the mark */
       *status = 0;
    } else {
 
      len = strlen(value);

      while (len && value[len - 1] == '&')  /* ampersand used as continuation char */
      {
        ffgcnt(fptr, value, status);
        if (*value)
        {
            ffdrec(fptr, keypos, status);  /* delete the keyword */
            len = strlen(value);
        }
        else   /* a null valstring indicates no continuation */
            len = 0;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffdstr(fitsfile *fptr,    /* I - FITS file pointer  */
           const char *string,     /* I - keyword name       */
           int *status)       /* IO - error status      */
/*
  delete a specified header keyword containing the input string
*/
{
    int keypos, len;
    char valstring[FLEN_VALUE], comm[FLEN_COMMENT], value[FLEN_VALUE];
    char card[FLEN_CARD], message[FLEN_ERRMSG];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (ffgstr(fptr, string, card, status) > 0) /* read keyword */
    {
        sprintf(message, "Could not find the %s keyword to delete (ffdkey)",
                string);
        ffpmsg(message);
        return(*status);
    }

    /* calc position of keyword in header */
    keypos = (int) ((((fptr->Fptr)->nextkey) - ((fptr->Fptr)->headstart[(fptr->Fptr)->curhdu])) / 80);

    ffdrec(fptr, keypos, status);  /* delete the keyword */

        /* check for string value which may be continued over multiple keywords */
    ffpsvc(card, valstring, comm, status);

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check for string value which may be continued over multiple keywords */
    ffpmrk(); /* put mark on message stack; erase any messages after this */
    ffc2s(valstring, value, status);   /* remove quotes and trailing spaces */

    if (*status == VALUE_UNDEFINED) {
       ffcmrk();  /* clear any spurious error messages, back to the mark */
       *status = 0;
    } else {
 
      len = strlen(value);

      while (len && value[len - 1] == '&')  /* ampersand used as continuation char */
      {
        ffgcnt(fptr, value, status);
        if (*value)
        {
            ffdrec(fptr, keypos, status);  /* delete the keyword */
            len = strlen(value);
        }
        else   /* a null valstring indicates no continuation */
            len = 0;
      }
    }

    return(*status);
}/*--------------------------------------------------------------------------*/
int ffdrec(fitsfile *fptr,   /* I - FITS file pointer  */
           int keypos,       /* I - position in header of keyword to delete */
           int *status)      /* IO - error status      */
/*
  Delete a header keyword at position keypos. The 1st keyword is at keypos=1.
*/
{
    int ii, nshift;
    LONGLONG bytepos;
    char *inbuff, *outbuff, *tmpbuff, buff1[81], buff2[81];
    char message[FLEN_ERRMSG];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if (keypos < 1 ||
        keypos > (fptr->Fptr)->headend - (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] / 80 )
        return(*status = KEY_OUT_BOUNDS);

    (fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] + (keypos - 1) * 80;

    nshift=(int) (( (fptr->Fptr)->headend - (fptr->Fptr)->nextkey ) / 80); /* no. keywords to shift */

    if (nshift <= 0)
    {
        sprintf(message, "Cannot delete keyword number %d.  It does not exist.",
                keypos);
        ffpmsg(message);
        return(*status = KEY_OUT_BOUNDS);
    }

    bytepos = (fptr->Fptr)->headend - 80;  /* last keyword in header */  

    /* construct a blank keyword */
    strcpy(buff2, "                                        ");
    strcat(buff2, "                                        ");
    inbuff  = buff1;
    outbuff = buff2;
    for (ii = 0; ii < nshift; ii++) /* shift each keyword up one position */
    {

        ffmbyt(fptr, bytepos, REPORT_EOF, status);
        ffgbyt(fptr, 80, inbuff, status);   /* read the current keyword */

        ffmbyt(fptr, bytepos, REPORT_EOF, status);
        ffpbyt(fptr, 80, outbuff, status);  /* overwrite with next keyword */

        tmpbuff = inbuff;   /* swap input and output buffers */
        inbuff = outbuff;
        outbuff = tmpbuff;

        bytepos -= 80;
    }

    (fptr->Fptr)->headend -= 80; /* decrement the position of the END keyword */
    return(*status);
}

healpy-1.10.3/cfitsio/pliocomp.c0000664000175000017500000001563313010375005016756 0ustar  zoncazonca00000000000000/* stdlib is needed for the abs function */
#include 
/*
   The following prototype code was provided by Doug Tody, NRAO, for
   performing conversion between pixel arrays and line lists.  The
   compression technique is used in IRAF.
*/
int pl_p2li (int *pxsrc, int xs, short *lldst, int npix);
int pl_l2pi (short *ll_src, int xs, int *px_dst, int npix);


/*
 * PL_P2L -- Convert a pixel array to a line list.  The length of the list is
 * returned as the function value.
 *
 * Translated from the SPP version using xc -f, f2c.  8Sep99 DCT.
 */

#ifndef min
#define min(a,b)        (((a)<(b))?(a):(b))
#endif
#ifndef max
#define max(a,b)        (((a)>(b))?(a):(b))
#endif

int pl_p2li (int *pxsrc, int xs, short *lldst, int npix)
/* int *pxsrc;                      input pixel array */
/* int xs;                          starting index in pxsrc (?) */
/* short *lldst;                    encoded line list */
/* int npix;                        number of pixels to convert */
{
    /* System generated locals */
    int ret_val, i__1, i__2, i__3;

    /* Local variables */
    int zero, v, x1, hi, ip, dv, xe, np, op, iz, nv = 0, pv, nz;

    /* Parameter adjustments */
    --lldst;
    --pxsrc;

    /* Function Body */
    if (! (npix <= 0)) {
        goto L110;
    }
    ret_val = 0;
    goto L100;
L110:
    lldst[3] = -100;
    lldst[2] = 7;
    lldst[1] = 0;
    lldst[6] = 0;
    lldst[7] = 0;
    xe = xs + npix - 1;
    op = 8;
    zero = 0;
/* Computing MAX */
    i__1 = zero, i__2 = pxsrc[xs];
    pv = max(i__1,i__2);
    x1 = xs;
    iz = xs;
    hi = 1;
    i__1 = xe;
    for (ip = xs; ip <= i__1; ++ip) {
        if (! (ip < xe)) {
            goto L130;
        }
/* Computing MAX */
        i__2 = zero, i__3 = pxsrc[ip + 1];
        nv = max(i__2,i__3);
        if (! (nv == pv)) {
            goto L140;
        }
        goto L120;
L140:
        if (! (pv == 0)) {
            goto L150;
        }
        pv = nv;
        x1 = ip + 1;
        goto L120;
L150:
        goto L131;
L130:
        if (! (pv == 0)) {
            goto L160;
        }
        x1 = xe + 1;
L160:
L131:
        np = ip - x1 + 1;
        nz = x1 - iz;
        if (! (pv > 0)) {
            goto L170;
        }
        dv = pv - hi;
        if (! (dv != 0)) {
            goto L180;
        }
        hi = pv;
        if (! (abs(dv) > 4095)) {
            goto L190;
        }
        lldst[op] = (short) ((pv & 4095) + 4096);
        ++op;
        lldst[op] = (short) (pv / 4096);
        ++op;
        goto L191;
L190:
        if (! (dv < 0)) {
            goto L200;
        }
        lldst[op] = (short) (-dv + 12288);
        goto L201;
L200:
        lldst[op] = (short) (dv + 8192);
L201:
        ++op;
        if (! (np == 1 && nz == 0)) {
            goto L210;
        }
        v = lldst[op - 1];
        lldst[op - 1] = (short) (v | 16384);
        goto L91;
L210:
L191:
L180:
L170:
        if (! (nz > 0)) {
            goto L220;
        }
L230:
        if (! (nz > 0)) {
            goto L232;
        }
        lldst[op] = (short) min(4095,nz);
        ++op;
/* L231: */
        nz += -4095;
        goto L230;
L232:
        if (! (np == 1 && pv > 0)) {
            goto L240;
        }
        lldst[op - 1] = (short) (lldst[op - 1] + 20481);
        goto L91;
L240:
L220:
L250:
        if (! (np > 0)) {
            goto L252;
        }
        lldst[op] = (short) (min(4095,np) + 16384);
        ++op;
/* L251: */
        np += -4095;
        goto L250;
L252:
L91:
        x1 = ip + 1;
        iz = x1;
        pv = nv;
L120:
        ;
    }
/* L121: */
    lldst[4] = (short) ((op - 1) % 32768);
    lldst[5] = (short) ((op - 1) / 32768);
    ret_val = op - 1;
    goto L100;
L100:
    return ret_val;
} /* plp2li_ */

/*
 * PL_L2PI -- Translate a PLIO line list into an integer pixel array.
 * The number of pixels output (always npix) is returned as the function
 * value.
 *
 * Translated from the SPP version using xc -f, f2c.  8Sep99 DCT.
 */

int pl_l2pi (short *ll_src, int xs, int *px_dst, int npix)
/* short *ll_src;                   encoded line list */
/* int xs;                          starting index in ll_src */
/* int *px_dst;                    output pixel array */
/* int npix;                       number of pixels to convert */
{
    /* System generated locals */
    int ret_val, i__1, i__2;

    /* Local variables */
    int data, sw0001, otop, i__, lllen, i1, i2, x1, x2, ip, xe, np,
             op, pv, opcode, llfirt;
    int skipwd;

    /* Parameter adjustments */
    --px_dst;
    --ll_src;

    /* Function Body */
    if (! (ll_src[3] > 0)) {
        goto L110;
    }
    lllen = ll_src[3];
    llfirt = 4;
    goto L111;
L110:
    lllen = (ll_src[5] << 15) + ll_src[4];
    llfirt = ll_src[2] + 1;
L111:
    if (! (npix <= 0 || lllen <= 0)) {
        goto L120;
    }
    ret_val = 0;
    goto L100;
L120:
    xe = xs + npix - 1;
    skipwd = 0;
    op = 1;
    x1 = 1;
    pv = 1;
    i__1 = lllen;
    for (ip = llfirt; ip <= i__1; ++ip) {
        if (! skipwd) {
            goto L140;
        }
        skipwd = 0;
        goto L130;
L140:
        opcode = ll_src[ip] / 4096;
        data = ll_src[ip] & 4095;
        sw0001 = opcode;
        goto L150;
L160:
        x2 = x1 + data - 1;
        i1 = max(x1,xs);
        i2 = min(x2,xe);
        np = i2 - i1 + 1;
        if (! (np > 0)) {
            goto L170;
        }
        otop = op + np - 1;
        if (! (opcode == 4)) {
            goto L180;
        }
        i__2 = otop;
        for (i__ = op; i__ <= i__2; ++i__) {
            px_dst[i__] = pv;
/* L190: */
        }
/* L191: */
        goto L181;
L180:
        i__2 = otop;
        for (i__ = op; i__ <= i__2; ++i__) {
            px_dst[i__] = 0;
/* L200: */
        }
/* L201: */
        if (! (opcode == 5 && i2 == x2)) {
            goto L210;
        }
        px_dst[otop] = pv;
L210:
L181:
        op = otop + 1;
L170:
        x1 = x2 + 1;
        goto L151;
L220:
        pv = (ll_src[ip + 1] << 12) + data;
        skipwd = 1;
        goto L151;
L230:
        pv += data;
        goto L151;
L240:
        pv -= data;
        goto L151;
L250:
        pv += data;
        goto L91;
L260:
        pv -= data;
L91:
        if (! (x1 >= xs && x1 <= xe)) {
            goto L270;
        }
        px_dst[op] = pv;
        ++op;
L270:
        ++x1;
        goto L151;
L150:
        ++sw0001;
        if (sw0001 < 1 || sw0001 > 8) {
            goto L151;
        }
        switch ((int)sw0001) {
            case 1:  goto L160;
            case 2:  goto L220;
            case 3:  goto L230;
            case 4:  goto L240;
            case 5:  goto L160;
            case 6:  goto L160;
            case 7:  goto L250;
            case 8:  goto L260;
        }
L151:
        if (! (x1 > xe)) {
            goto L280;
        }
        goto L131;
L280:
L130:
        ;
    }
L131:
    i__1 = npix;
    for (i__ = op; i__ <= i__1; ++i__) {
        px_dst[i__] = 0;
/* L290: */
    }
/* L291: */
    ret_val = npix;
    goto L100;
L100:
    return ret_val;
} /* pll2pi_ */

healpy-1.10.3/cfitsio/putcol.c0000664000175000017500000017765013010375005016452 0ustar  zoncazonca00000000000000/*  This file, putcol.c, contains routines that write data elements to     */
/*  a FITS image or table. These are the generic routines.                 */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffppx(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int  datatype,   /* I - datatype of the value                   */
            long  *firstpix, /* I - coord of  first pixel to write(1 based) */
            LONGLONG  nelem,     /* I - number of values to write               */
            void  *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of pixels to the primary array.  The datatype of the
  input array is defined by the 2nd argument. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written). 
  
  This routine is simillar to ffppr, except it supports writing to 
  large images with more than 2**31 pixels.
*/
{
    int naxis, ii;
    long group = 1;
    LONGLONG firstelem, dimsize = 1, naxes[9];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);
    ffgiszll(fptr, 9, naxes, status);

    firstelem = 0;
    for (ii=0; ii < naxis; ii++)
    {
        firstelem += ((firstpix[ii] - 1) * dimsize);
        dimsize *= naxes[ii];
    }
    firstelem++;

    if (datatype == TBYTE)
    {
      ffpprb(fptr, group, firstelem, nelem, (unsigned char *) array, status);
    }
    else if (datatype == TSBYTE)
    {
      ffpprsb(fptr, group, firstelem, nelem, (signed char *) array, status);
    }
    else if (datatype == TUSHORT)
    {
      ffpprui(fptr, group, firstelem, nelem, (unsigned short *) array,
              status);
    }
    else if (datatype == TSHORT)
    {
      ffppri(fptr, group, firstelem, nelem, (short *) array, status);
    }
    else if (datatype == TUINT)
    {
      ffppruk(fptr, group, firstelem, nelem, (unsigned int *) array, status);
    }
    else if (datatype == TINT)
    {
      ffpprk(fptr, group, firstelem, nelem, (int *) array, status);
    }
    else if (datatype == TULONG)
    {
      ffppruj(fptr, group, firstelem, nelem, (unsigned long *) array, status);
    }
    else if (datatype == TLONG)
    {
      ffpprj(fptr, group, firstelem, nelem, (long *) array, status);
    }
    else if (datatype == TLONGLONG)
    {
      ffpprjj(fptr, group, firstelem, nelem, (LONGLONG *) array, status);
    }
    else if (datatype == TFLOAT)
    {
      ffppre(fptr, group, firstelem, nelem, (float *) array, status);
    }
    else if (datatype == TDOUBLE)
    {
      ffpprd(fptr, group, firstelem, nelem, (double *) array, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppxll(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int  datatype,   /* I - datatype of the value                   */
            LONGLONG  *firstpix, /* I - coord of  first pixel to write(1 based) */
            LONGLONG  nelem,     /* I - number of values to write               */
            void  *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of pixels to the primary array.  The datatype of the
  input array is defined by the 2nd argument. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written). 
  
  This routine is simillar to ffppr, except it supports writing to 
  large images with more than 2**31 pixels.
*/
{
    int naxis, ii;
    long group = 1;
    LONGLONG firstelem, dimsize = 1, naxes[9];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);
    ffgiszll(fptr, 9, naxes, status);

    firstelem = 0;
    for (ii=0; ii < naxis; ii++)
    {
        firstelem += ((firstpix[ii] - 1) * dimsize);
        dimsize *= naxes[ii];
    }
    firstelem++;

    if (datatype == TBYTE)
    {
      ffpprb(fptr, group, firstelem, nelem, (unsigned char *) array, status);
    }
    else if (datatype == TSBYTE)
    {
      ffpprsb(fptr, group, firstelem, nelem, (signed char *) array, status);
    }
    else if (datatype == TUSHORT)
    {
      ffpprui(fptr, group, firstelem, nelem, (unsigned short *) array,
              status);
    }
    else if (datatype == TSHORT)
    {
      ffppri(fptr, group, firstelem, nelem, (short *) array, status);
    }
    else if (datatype == TUINT)
    {
      ffppruk(fptr, group, firstelem, nelem, (unsigned int *) array, status);
    }
    else if (datatype == TINT)
    {
      ffpprk(fptr, group, firstelem, nelem, (int *) array, status);
    }
    else if (datatype == TULONG)
    {
      ffppruj(fptr, group, firstelem, nelem, (unsigned long *) array, status);
    }
    else if (datatype == TLONG)
    {
      ffpprj(fptr, group, firstelem, nelem, (long *) array, status);
    }
    else if (datatype == TLONGLONG)
    {
      ffpprjj(fptr, group, firstelem, nelem, (LONGLONG *) array, status);
    }
    else if (datatype == TFLOAT)
    {
      ffppre(fptr, group, firstelem, nelem, (float *) array, status);
    }
    else if (datatype == TDOUBLE)
    {
      ffpprd(fptr, group, firstelem, nelem, (double *) array, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppxn(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int  datatype,   /* I - datatype of the value                   */
            long  *firstpix, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            void  *array,    /* I - array of values that are written        */
            void  *nulval,   /* I - pointer to the null value               */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array.  The datatype of the
  input array is defined by the 2nd argument. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).

  This routine supports writing to large images with
  more than 2**31 pixels.
*/
{
    int naxis, ii;
    long group = 1;
    LONGLONG firstelem, dimsize = 1, naxes[9];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (nulval == NULL)  /* null value not defined? */
    {
        ffppx(fptr, datatype, firstpix, nelem, array, status);
        return(*status);
    }

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);
    ffgiszll(fptr, 9, naxes, status);

    firstelem = 0;
    for (ii=0; ii < naxis; ii++)
    {
        firstelem += ((firstpix[ii] - 1) * dimsize);
        dimsize *= naxes[ii];
    }
    firstelem++;

    if (datatype == TBYTE)
    {
      ffppnb(fptr, group, firstelem, nelem, (unsigned char *) array, 
             *(unsigned char *) nulval, status);
    }
    else if (datatype == TSBYTE)
    {
      ffppnsb(fptr, group, firstelem, nelem, (signed char *) array, 
             *(signed char *) nulval, status);
    }
    else if (datatype == TUSHORT)
    {
      ffppnui(fptr, group, firstelem, nelem, (unsigned short *) array,
              *(unsigned short *) nulval,status);
    }
    else if (datatype == TSHORT)
    {
      ffppni(fptr, group, firstelem, nelem, (short *) array,
             *(short *) nulval, status);
    }
    else if (datatype == TUINT)
    {
      ffppnuk(fptr, group, firstelem, nelem, (unsigned int *) array,
             *(unsigned int *) nulval, status);
    }
    else if (datatype == TINT)
    {
      ffppnk(fptr, group, firstelem, nelem, (int *) array,
             *(int *) nulval, status);
    }
    else if (datatype == TULONG)
    {
      ffppnuj(fptr, group, firstelem, nelem, (unsigned long *) array,
              *(unsigned long *) nulval,status);
    }
    else if (datatype == TLONG)
    {
      ffppnj(fptr, group, firstelem, nelem, (long *) array,
             *(long *) nulval, status);
    }
    else if (datatype == TLONGLONG)
    {
      ffppnjj(fptr, group, firstelem, nelem, (LONGLONG *) array,
             *(LONGLONG *) nulval, status);
    }
    else if (datatype == TFLOAT)
    {
      ffppne(fptr, group, firstelem, nelem, (float *) array,
             *(float *) nulval, status);
    }
    else if (datatype == TDOUBLE)
    {
      ffppnd(fptr, group, firstelem, nelem, (double *) array,
             *(double *) nulval, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppxnll(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int  datatype,   /* I - datatype of the value                   */
            LONGLONG  *firstpix, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            void  *array,    /* I - array of values that are written        */
            void  *nulval,   /* I - pointer to the null value               */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array.  The datatype of the
  input array is defined by the 2nd argument. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).

  This routine supports writing to large images with
  more than 2**31 pixels.
*/
{
    int naxis, ii;
    long  group = 1;
    LONGLONG firstelem, dimsize = 1, naxes[9];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (nulval == NULL)  /* null value not defined? */
    {
        ffppxll(fptr, datatype, firstpix, nelem, array, status);
        return(*status);
    }

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);
    ffgiszll(fptr, 9, naxes, status);

    firstelem = 0;
    for (ii=0; ii < naxis; ii++)
    {
        firstelem += ((firstpix[ii] - 1) * dimsize);
        dimsize *= naxes[ii];
    }
    firstelem++;

    if (datatype == TBYTE)
    {
      ffppnb(fptr, group, firstelem, nelem, (unsigned char *) array, 
             *(unsigned char *) nulval, status);
    }
    else if (datatype == TSBYTE)
    {
      ffppnsb(fptr, group, firstelem, nelem, (signed char *) array, 
             *(signed char *) nulval, status);
    }
    else if (datatype == TUSHORT)
    {
      ffppnui(fptr, group, firstelem, nelem, (unsigned short *) array,
              *(unsigned short *) nulval,status);
    }
    else if (datatype == TSHORT)
    {
      ffppni(fptr, group, firstelem, nelem, (short *) array,
             *(short *) nulval, status);
    }
    else if (datatype == TUINT)
    {
      ffppnuk(fptr, group, firstelem, nelem, (unsigned int *) array,
             *(unsigned int *) nulval, status);
    }
    else if (datatype == TINT)
    {
      ffppnk(fptr, group, firstelem, nelem, (int *) array,
             *(int *) nulval, status);
    }
    else if (datatype == TULONG)
    {
      ffppnuj(fptr, group, firstelem, nelem, (unsigned long *) array,
              *(unsigned long *) nulval,status);
    }
    else if (datatype == TLONG)
    {
      ffppnj(fptr, group, firstelem, nelem, (long *) array,
             *(long *) nulval, status);
    }
    else if (datatype == TLONGLONG)
    {
      ffppnjj(fptr, group, firstelem, nelem, (LONGLONG *) array,
             *(LONGLONG *) nulval, status);
    }
    else if (datatype == TFLOAT)
    {
      ffppne(fptr, group, firstelem, nelem, (float *) array,
             *(float *) nulval, status);
    }
    else if (datatype == TDOUBLE)
    {
      ffppnd(fptr, group, firstelem, nelem, (double *) array,
             *(double *) nulval, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppr(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int  datatype,   /* I - datatype of the value                   */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            void  *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array.  The datatype of the
  input array is defined by the 2nd argument. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).

*/
{
    long group = 1;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (datatype == TBYTE)
    {
      ffpprb(fptr, group, firstelem, nelem, (unsigned char *) array, status);
    }
    else if (datatype == TSBYTE)
    {
      ffpprsb(fptr, group, firstelem, nelem, (signed char *) array, status);
    }
    else if (datatype == TUSHORT)
    {
      ffpprui(fptr, group, firstelem, nelem, (unsigned short *) array,
              status);
    }
    else if (datatype == TSHORT)
    {
      ffppri(fptr, group, firstelem, nelem, (short *) array, status);
    }
    else if (datatype == TUINT)
    {
      ffppruk(fptr, group, firstelem, nelem, (unsigned int *) array, status);
    }
    else if (datatype == TINT)
    {
      ffpprk(fptr, group, firstelem, nelem, (int *) array, status);
    }
    else if (datatype == TULONG)
    {
      ffppruj(fptr, group, firstelem, nelem, (unsigned long *) array, status);
    }
    else if (datatype == TLONG)
    {
      ffpprj(fptr, group, firstelem, nelem, (long *) array, status);
    }
    else if (datatype == TLONGLONG)
    {
      ffpprjj(fptr, group, firstelem, nelem, (LONGLONG *) array, status);
    }
    else if (datatype == TFLOAT)
    {
      ffppre(fptr, group, firstelem, nelem, (float *) array, status);
    }
    else if (datatype == TDOUBLE)
    {
      ffpprd(fptr, group, firstelem, nelem, (double *) array, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppn(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int  datatype,   /* I - datatype of the value                   */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            void  *array,    /* I - array of values that are written        */
            void  *nulval,   /* I - pointer to the null value               */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array.  The datatype of the
  input array is defined by the 2nd argument. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).

*/
{
    long group = 1;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (nulval == NULL)  /* null value not defined? */
    {
        ffppr(fptr, datatype, firstelem, nelem, array, status);
        return(*status);
    }

    if (datatype == TBYTE)
    {
      ffppnb(fptr, group, firstelem, nelem, (unsigned char *) array, 
             *(unsigned char *) nulval, status);
    }
    else if (datatype == TSBYTE)
    {
      ffppnsb(fptr, group, firstelem, nelem, (signed char *) array, 
             *(signed char *) nulval, status);
    }
    else if (datatype == TUSHORT)
    {
      ffppnui(fptr, group, firstelem, nelem, (unsigned short *) array,
              *(unsigned short *) nulval,status);
    }
    else if (datatype == TSHORT)
    {
      ffppni(fptr, group, firstelem, nelem, (short *) array,
             *(short *) nulval, status);
    }
    else if (datatype == TUINT)
    {
      ffppnuk(fptr, group, firstelem, nelem, (unsigned int *) array,
             *(unsigned int *) nulval, status);
    }
    else if (datatype == TINT)
    {
      ffppnk(fptr, group, firstelem, nelem, (int *) array,
             *(int *) nulval, status);
    }
    else if (datatype == TULONG)
    {
      ffppnuj(fptr, group, firstelem, nelem, (unsigned long *) array,
              *(unsigned long *) nulval,status);
    }
    else if (datatype == TLONG)
    {
      ffppnj(fptr, group, firstelem, nelem, (long *) array,
             *(long *) nulval, status);
    }
    else if (datatype == TLONGLONG)
    {
      ffppnjj(fptr, group, firstelem, nelem, (LONGLONG *) array,
             *(LONGLONG *) nulval, status);
    }
    else if (datatype == TFLOAT)
    {
      ffppne(fptr, group, firstelem, nelem, (float *) array,
             *(float *) nulval, status);
    }
    else if (datatype == TDOUBLE)
    {
      ffppnd(fptr, group, firstelem, nelem, (double *) array,
             *(double *) nulval, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpss(  fitsfile *fptr,   /* I - FITS file pointer                       */
            int  datatype,    /* I - datatype of the value                   */
            long *blc,        /* I - 'bottom left corner' of the subsection  */
            long *trc ,       /* I - 'top right corner' of the subsection    */
            void *array,      /* I - array of values that are written        */
            int  *status)     /* IO - error status                           */
/*
  Write a section of values to the primary array. The datatype of the
  input array is defined by the 2nd argument.  Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).

  This routine supports writing to large images with
  more than 2**31 pixels.
*/
{
    int naxis;
    long naxes[9];

    if (*status > 0)   /* inherit input status value if > 0 */
        return(*status);

    /* get the size of the image */
    ffgidm(fptr, &naxis, status);
    ffgisz(fptr, 9, naxes, status);

    if (datatype == TBYTE)
    {
        ffpssb(fptr, 1, naxis, naxes, blc, trc,
               (unsigned char *) array, status);
    }
    else if (datatype == TSBYTE)
    {
        ffpsssb(fptr, 1, naxis, naxes, blc, trc,
               (signed char *) array, status);
    }
    else if (datatype == TUSHORT)
    {
        ffpssui(fptr, 1, naxis, naxes, blc, trc,
               (unsigned short *) array, status);
    }
    else if (datatype == TSHORT)
    {
        ffpssi(fptr, 1, naxis, naxes, blc, trc,
               (short *) array, status);
    }
    else if (datatype == TUINT)
    {
        ffpssuk(fptr, 1, naxis, naxes, blc, trc,
               (unsigned int *) array, status);
    }
    else if (datatype == TINT)
    {
        ffpssk(fptr, 1, naxis, naxes, blc, trc,
               (int *) array, status);
    }
    else if (datatype == TULONG)
    {
        ffpssuj(fptr, 1, naxis, naxes, blc, trc,
               (unsigned long *) array, status);
    }
    else if (datatype == TLONG)
    {
        ffpssj(fptr, 1, naxis, naxes, blc, trc,
               (long *) array, status);
    }
    else if (datatype == TLONGLONG)
    {
        ffpssjj(fptr, 1, naxis, naxes, blc, trc,
               (LONGLONG *) array, status);
    }    else if (datatype == TFLOAT)
    {
        ffpsse(fptr, 1, naxis, naxes, blc, trc,
               (float *) array, status);
    }
    else if (datatype == TDOUBLE)
    {
        ffpssd(fptr, 1, naxis, naxes, blc, trc,
               (double *) array, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcl(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int  datatype,   /* I - datatype of the value                   */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of elements to write             */
            void  *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a table column.  The datatype of the
  input array is defined by the 2nd argument. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS column is not the same as the array being written).

*/
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (datatype == TBIT)
    {
      ffpclx(fptr, colnum, firstrow, (long) firstelem, (long) nelem, (char *) array, 
             status);
    }
    else if (datatype == TBYTE)
    {
      ffpclb(fptr, colnum, firstrow, firstelem, nelem, (unsigned char *) array,
             status);
    }
    else if (datatype == TSBYTE)
    {
      ffpclsb(fptr, colnum, firstrow, firstelem, nelem, (signed char *) array,
             status);
    }
    else if (datatype == TUSHORT)
    {
      ffpclui(fptr, colnum, firstrow, firstelem, nelem, 
             (unsigned short *) array, status);
    }
    else if (datatype == TSHORT)
    {
      ffpcli(fptr, colnum, firstrow, firstelem, nelem, (short *) array,
             status);
    }
    else if (datatype == TUINT)
    {
      ffpcluk(fptr, colnum, firstrow, firstelem, nelem, (unsigned int *) array,
               status);
    }
    else if (datatype == TINT)
    {
      ffpclk(fptr, colnum, firstrow, firstelem, nelem, (int *) array,
               status);
    }
    else if (datatype == TULONG)
    {
      ffpcluj(fptr, colnum, firstrow, firstelem, nelem, (unsigned long *) array,
              status);
    }
    else if (datatype == TLONG)
    {
      ffpclj(fptr, colnum, firstrow, firstelem, nelem, (long *) array,
             status);
    }
    else if (datatype == TLONGLONG)
    {
      ffpcljj(fptr, colnum, firstrow, firstelem, nelem, (LONGLONG *) array,
             status);
    }
    else if (datatype == TFLOAT)
    {
      ffpcle(fptr, colnum, firstrow, firstelem, nelem, (float *) array,
             status);
    }
    else if (datatype == TDOUBLE)
    {
      ffpcld(fptr, colnum, firstrow, firstelem, nelem, (double *) array,
             status);
    }
    else if (datatype == TCOMPLEX)
    {
      ffpcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
             (float *) array, status);
    }
    else if (datatype == TDBLCOMPLEX)
    {
      ffpcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
             (double *) array, status);
    }
    else if (datatype == TLOGICAL)
    {
      ffpcll(fptr, colnum, firstrow, firstelem, nelem, (char *) array,
             status);
    }
    else if (datatype == TSTRING)
    {
      ffpcls(fptr, colnum, firstrow, firstelem, nelem, (char **) array,
             status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcn(  fitsfile *fptr,  /* I - FITS file pointer                       */
            int  datatype,   /* I - datatype of the value                   */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of elements to write             */
            void  *array,    /* I - array of values that are written        */
            void  *nulval,   /* I - pointer to the null value               */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a table column.  The datatype of the
  input array is defined by the 2nd argument. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS column is not the same as the array being written).

*/
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (nulval == NULL)  /* null value not defined? */
    {
        ffpcl(fptr, datatype, colnum, firstrow, firstelem, nelem, array,
              status);
        return(*status);
    }

    if (datatype == TBYTE)
    {
      ffpcnb(fptr, colnum, firstrow, firstelem, nelem, (unsigned char *) array,
            *(unsigned char *) nulval, status);
    }
    else if (datatype == TSBYTE)
    {
      ffpcnsb(fptr, colnum, firstrow, firstelem, nelem, (signed char *) array,
            *(signed char *) nulval, status);
    }
    else if (datatype == TUSHORT)
    {
     ffpcnui(fptr, colnum, firstrow, firstelem, nelem, (unsigned short *) array,
             *(unsigned short *) nulval, status);
    }
    else if (datatype == TSHORT)
    {
      ffpcni(fptr, colnum, firstrow, firstelem, nelem, (short *) array,
             *(unsigned short *) nulval, status);
    }
    else if (datatype == TUINT)
    {
      ffpcnuk(fptr, colnum, firstrow, firstelem, nelem, (unsigned int *) array,
             *(unsigned int *) nulval, status);
    }
    else if (datatype == TINT)
    {
      ffpcnk(fptr, colnum, firstrow, firstelem, nelem, (int *) array,
             *(int *) nulval, status);
    }
    else if (datatype == TULONG)
    {
      ffpcnuj(fptr, colnum, firstrow, firstelem, nelem, (unsigned long *) array,
              *(unsigned long *) nulval, status);
    }
    else if (datatype == TLONG)
    {
      ffpcnj(fptr, colnum, firstrow, firstelem, nelem, (long *) array,
             *(long *) nulval, status);
    }
    else if (datatype == TLONGLONG)
    {
      ffpcnjj(fptr, colnum, firstrow, firstelem, nelem, (LONGLONG *) array,
             *(LONGLONG *) nulval, status);
    }
    else if (datatype == TFLOAT)
    {
      ffpcne(fptr, colnum, firstrow, firstelem, nelem, (float *) array,
             *(float *) nulval, status);
    }
    else if (datatype == TDOUBLE)
    {
      ffpcnd(fptr, colnum, firstrow, firstelem, nelem, (double *) array,
             *(double *) nulval, status);
    }
    else if (datatype == TCOMPLEX)
    {
      ffpcne(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
             (float *) array, *(float *) nulval, status);
    }
    else if (datatype == TDBLCOMPLEX)
    {
      ffpcnd(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, nelem * 2,
             (double *) array, *(double *) nulval, status);
    }
    else if (datatype == TLOGICAL)
    {
      ffpcnl(fptr, colnum, firstrow, firstelem, nelem, (char *) array,
             *(char *) nulval, status);
    }
    else if (datatype == TSTRING)
    {
      ffpcns(fptr, colnum, firstrow, firstelem, nelem, (char **) array,
             (char *) nulval, status);
    }
    else
      *status = BAD_DATATYPE;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_iter_set_by_name(iteratorCol *col, /* I - iterator col structure */
           fitsfile *fptr,  /* I - FITS file pointer                      */
           char *colname,   /* I - column name                            */
           int datatype,    /* I - column datatype                        */
           int iotype)      /* I - InputCol, InputOutputCol, or OutputCol */
/*
  set all the parameters for an iterator column, by column name
*/
{
    col->fptr = fptr;
    strcpy(col->colname, colname);
    col->colnum = 0;  /* set column number undefined since name is given */
    col->datatype = datatype;
    col->iotype = iotype;
    return(0);
}
/*--------------------------------------------------------------------------*/
int fits_iter_set_by_num(iteratorCol *col, /* I - iterator column structure */
           fitsfile *fptr,  /* I - FITS file pointer                      */
           int colnum,      /* I - column number                          */
           int datatype,    /* I - column datatype                        */
           int iotype)      /* I - InputCol, InputOutputCol, or OutputCol */
/*
  set all the parameters for an iterator column, by column number
*/
{
    col->fptr = fptr;
    col->colnum = colnum; 
    col->datatype = datatype;
    col->iotype = iotype;
    return(0);
}
/*--------------------------------------------------------------------------*/
int fits_iter_set_file(iteratorCol *col, /* I - iterator column structure   */
           fitsfile *fptr)   /* I - FITS file pointer                      */
/*
  set iterator column parameter
*/
{
    col->fptr = fptr;
    return(0);
}
/*--------------------------------------------------------------------------*/
int fits_iter_set_colname(iteratorCol *col, /* I - iterator col structure  */
           char *colname)    /* I - column name                            */
/*
  set iterator column parameter
*/
{
    strcpy(col->colname, colname);
    col->colnum = 0;  /* set column number undefined since name is given */
    return(0);
}
/*--------------------------------------------------------------------------*/
int fits_iter_set_colnum(iteratorCol *col, /* I - iterator column structure */
           int colnum)       /* I - column number                          */
/*
  set iterator column parameter
*/
{
    col->colnum = colnum; 
    return(0);
}
/*--------------------------------------------------------------------------*/
int fits_iter_set_datatype(iteratorCol *col, /* I - iterator col structure */
           int datatype)    /* I - column datatype                        */
/*
  set iterator column parameter
*/
{
    col->datatype = datatype;
    return(0);
}
/*--------------------------------------------------------------------------*/
int fits_iter_set_iotype(iteratorCol *col, /* I - iterator column structure */
           int iotype)       /* I - InputCol, InputOutputCol, or OutputCol */
/*
  set iterator column parameter
*/
{
    col->iotype = iotype;
    return(0);
}
/*--------------------------------------------------------------------------*/
fitsfile * fits_iter_get_file(iteratorCol *col) /* I -iterator col structure */
/*
  get iterator column parameter
*/
{
     return(col->fptr);
}
/*--------------------------------------------------------------------------*/
char * fits_iter_get_colname(iteratorCol *col) /* I -iterator col structure */
/*
  get iterator column parameter
*/
{
    return(col->colname);
}
/*--------------------------------------------------------------------------*/
int fits_iter_get_colnum(iteratorCol *col) /* I - iterator column structure */
/*
  get iterator column parameter
*/
{
    return(col->colnum);
}
/*--------------------------------------------------------------------------*/
int fits_iter_get_datatype(iteratorCol *col) /* I - iterator col structure */
/*
  get iterator column parameter
*/
{
    return(col->datatype);
}
/*--------------------------------------------------------------------------*/
int fits_iter_get_iotype(iteratorCol *col) /* I - iterator column structure */
/*
  get iterator column parameter
*/
{
     return(col->iotype);
}
/*--------------------------------------------------------------------------*/
void * fits_iter_get_array(iteratorCol *col) /* I - iterator col structure */
/*
  get iterator column parameter
*/
{
     return(col->array);
}
/*--------------------------------------------------------------------------*/
long fits_iter_get_tlmin(iteratorCol *col) /* I - iterator column structure */
/*
  get iterator column parameter
*/
{
     return(col->tlmin);
}
/*--------------------------------------------------------------------------*/
long fits_iter_get_tlmax(iteratorCol *col) /* I - iterator column structure */
/*
  get iterator column parameter
*/
{
     return(col->tlmax);
}
/*--------------------------------------------------------------------------*/
long fits_iter_get_repeat(iteratorCol *col) /* I - iterator col structure */
/*
  get iterator column parameter
*/
{
     return(col->repeat);
}
/*--------------------------------------------------------------------------*/
char * fits_iter_get_tunit(iteratorCol *col) /* I - iterator col structure */
/*
  get iterator column parameter
*/
{
    return(col->tunit);
}
/*--------------------------------------------------------------------------*/
char * fits_iter_get_tdisp(iteratorCol *col) /* I -iterator col structure   */
/*
  get iterator column parameter
*/
{
    return(col->tdisp);
}
/*--------------------------------------------------------------------------*/
int ffiter(int n_cols,
           iteratorCol *cols,
           long offset,
           long n_per_loop,
           int (*work_fn)(long total_n,
                          long offset,
                          long first_n,
                          long n_values,
                          int n_cols,
                          iteratorCol *cols,
                          void *userPointer),
           void *userPointer,
           int *status)
/*
   The iterator function.  This function will pass the specified
   columns from a FITS table or pixels from a FITS image to the 
   user-supplied function.  Depending on the size of the table
   or image, only a subset of the rows or pixels may be passed to the
   function on each call, in which case the function will be called
   multiple times until all the rows or pixels have been processed.
*/
{
    typedef struct  /* structure to store the column null value */
    {  
        int      nullsize;    /* length of the null value, in bytes */
        union {   /*  default null value for the column */
            char   *stringnull;
            unsigned char   charnull;
            signed char scharnull;
            int    intnull;
            short  shortnull;
            long   longnull;
            unsigned int   uintnull;
            unsigned short ushortnull;
            unsigned long  ulongnull;
            float  floatnull;
            double doublenull;
	    LONGLONG longlongnull;
        } null;
    } colNulls;

    void *dataptr, *defaultnull;
    colNulls *col;
    int ii, jj, tstatus, naxis, bitpix;
    int typecode, hdutype, jtype, type, anynul, nfiles, nbytes;
    long totaln, nleft, frow, felement, n_optimum, i_optimum, ntodo;
    long rept, rowrept, width, tnull, naxes[9] = {1,1,1,1,1,1,1,1,1}, groups;
    double zeros = 0.;
    char message[FLEN_ERRMSG], keyname[FLEN_KEYWORD], nullstr[FLEN_VALUE];
    char **stringptr, *nullptr, *cptr;

    if (*status > 0)
        return(*status);

    if (n_cols  < 0 || n_cols > 999 )
    {
        ffpmsg("Illegal number of columms (ffiter)");
        return(*status = BAD_COL_NUM);  /* negative number of columns */
    }

    /*------------------------------------------------------------*/
    /* Make sure column numbers and datatypes are in legal range  */
    /* and column numbers and datatypes are legal.                */ 
    /* Also fill in other parameters in the column structure.     */
    /*------------------------------------------------------------*/

    ffghdt(cols[0].fptr, &hdutype, status);  /* type of first HDU */

    for (jj = 0; jj < n_cols; jj++)
    {
        /* check that output datatype code value is legal */
        type = cols[jj].datatype;  

        /* Allow variable length arrays for InputCol and InputOutputCol columns,
	   but not for OutputCol columns.  Variable length arrays have a
	   negative type code value. */

        if ((cols[jj].iotype != OutputCol) && (type<0)) {
            type*=-1;
        }

        if (type != 0      && type != TBYTE  &&
            type != TSBYTE && type != TLOGICAL && type != TSTRING &&
            type != TSHORT && type != TINT     && type != TLONG && 
            type != TFLOAT && type != TDOUBLE  && type != TCOMPLEX &&
            type != TULONG && type != TUSHORT  && type != TDBLCOMPLEX &&
	    type != TLONGLONG )
        {
	    if (type < 0) {
	      sprintf(message,
              "Variable length array not allowed for output column number %d (ffiter)",
                    jj + 1);
	    } else {
            sprintf(message,
                   "Illegal datatype for column number %d: %d  (ffiter)",
                    jj + 1, cols[jj].datatype);
	    }
	    
            ffpmsg(message);
            return(*status = BAD_DATATYPE);
        }

        /* initialize TLMINn, TLMAXn, column name, and display format */
        cols[jj].tlmin = 0;
        cols[jj].tlmax = 0;
        cols[jj].tunit[0] = '\0';
        cols[jj].tdisp[0] = '\0';

        ffghdt(cols[jj].fptr, &jtype, status);  /* get HDU type */

        if (hdutype == IMAGE_HDU) /* operating on FITS images */
        {
            if (jtype != IMAGE_HDU)
            {
                sprintf(message,
                "File %d not positioned to an image extension (ffiter)",
                    jj + 1);
                return(*status = NOT_IMAGE);
            }

            /* since this is an image, set a dummy column number = 0 */
            cols[jj].colnum = 0;
            strcpy(cols[jj].colname, "IMAGE");  /* dummy name for images */

            tstatus = 0;
            ffgkys(cols[jj].fptr, "BUNIT", cols[jj].tunit, 0, &tstatus);
        }
        else  /* operating on FITS tables */
        {
            if (jtype == IMAGE_HDU)
            {
                sprintf(message,
                "File %d not positioned to a table extension (ffiter)",
                    jj + 1);
                return(*status = NOT_TABLE);
            }

            if (cols[jj].colnum < 1)
            {
                /* find the column number for the named column */
                if (ffgcno(cols[jj].fptr, CASEINSEN, cols[jj].colname,
                           &cols[jj].colnum, status) )
                {
                    sprintf(message,
                      "Column '%s' not found for column number %d  (ffiter)",
                       cols[jj].colname, jj + 1);
                    ffpmsg(message);
                    return(*status);
                }
            }

            /* check that the column number is valid */
            if (cols[jj].colnum < 1 || 
                cols[jj].colnum > ((cols[jj].fptr)->Fptr)->tfield)
            {
                sprintf(message,
                  "Column %d has illegal table position number: %d  (ffiter)",
                    jj + 1, cols[jj].colnum);
                ffpmsg(message);
                return(*status = BAD_COL_NUM);
            }

            /* look for column description keywords and update structure */
            tstatus = 0;
            ffkeyn("TLMIN", cols[jj].colnum, keyname, &tstatus);
            ffgkyj(cols[jj].fptr, keyname, &cols[jj].tlmin, 0, &tstatus);

            tstatus = 0;
            ffkeyn("TLMAX", cols[jj].colnum, keyname, &tstatus);
            ffgkyj(cols[jj].fptr, keyname, &cols[jj].tlmax, 0, &tstatus);

            tstatus = 0;
            ffkeyn("TTYPE", cols[jj].colnum, keyname, &tstatus);
            ffgkys(cols[jj].fptr, keyname, cols[jj].colname, 0, &tstatus);
            if (tstatus)
                cols[jj].colname[0] = '\0';

            tstatus = 0;
            ffkeyn("TUNIT", cols[jj].colnum, keyname, &tstatus);
            ffgkys(cols[jj].fptr, keyname, cols[jj].tunit, 0, &tstatus);

            tstatus = 0;
            ffkeyn("TDISP", cols[jj].colnum, keyname, &tstatus);
            ffgkys(cols[jj].fptr, keyname, cols[jj].tdisp, 0, &tstatus);
        }
    }  /* end of loop over all columns */

    /*-----------------------------------------------------------------*/
    /* use the first file to set the total number of values to process */
    /*-----------------------------------------------------------------*/

    offset = maxvalue(offset, 0L);  /* make sure offset is legal */

    if (hdutype == IMAGE_HDU)   /* get total number of pixels in the image */
    {
      fits_get_img_dim(cols[0].fptr, &naxis, status);
      fits_get_img_size(cols[0].fptr, 9, naxes, status);

      tstatus = 0;
      ffgkyj(cols[0].fptr, "GROUPS", &groups, NULL, &tstatus);
      if (!tstatus && groups && (naxis > 1) && (naxes[0] == 0) )
      {
         /* this is a random groups file, with NAXIS1 = 0 */
         /* Use GCOUNT, the number of groups, as the first multiplier  */
         /* to calculate the total number of pixels in all the groups. */
         ffgkyj(cols[0].fptr, "GCOUNT", &totaln, NULL, status);

      }  else {
         totaln = naxes[0];
      }

      for (ii = 1; ii < naxis; ii++)
          totaln *= naxes[ii];

      frow = 1;
      felement = 1 + offset;
    }
    else   /* get total number or rows in the table */
    {
      ffgkyj(cols[0].fptr, "NAXIS2", &totaln, 0, status);
      frow = 1 + offset;
      felement = 1;
    }

    /*  adjust total by the input starting offset value */
    totaln -= offset;
    totaln = maxvalue(totaln, 0L);   /* don't allow negative number */

    /*------------------------------------------------------------------*/
    /* Determine number of values to pass to work function on each loop */
    /*------------------------------------------------------------------*/

    if (n_per_loop == 0)
    {
        /* Determine optimum number of values for each iteration.    */
        /* Look at all the fitsfile pointers to determine the number */
        /* of unique files.                                          */

        nfiles = 1;
        ffgrsz(cols[0].fptr, &n_optimum, status);

        for (jj = 1; jj < n_cols; jj++)
        {
            for (ii = 0; ii < jj; ii++)
            {
                if (cols[ii].fptr == cols[jj].fptr)
                   break;
            }

            if (ii == jj)  /* this is a new file */
            {
                nfiles++;
                ffgrsz(cols[jj].fptr, &i_optimum, status);
                n_optimum = minvalue(n_optimum, i_optimum);
            }
        }

        /* divid n_optimum by the number of files that will be processed */
        n_optimum = n_optimum / nfiles;
        n_optimum = maxvalue(n_optimum, 1);
    }
    else if (n_per_loop < 0)  /* must pass all the values at one time */
    {
        n_optimum = totaln;
    }
    else /* calling routine specified how many values to pass at a time */
    {
        n_optimum = minvalue(n_per_loop, totaln);
    }

    /*--------------------------------------*/
    /* allocate work arrays for each column */
    /* and determine the null pixel value   */
    /*--------------------------------------*/

    col = calloc(n_cols, sizeof(colNulls) ); /* memory for the null values */
    if (!col)
    {
        ffpmsg("ffiter failed to allocate memory for null values");
        *status = MEMORY_ALLOCATION;  /* memory allocation failed */
        return(*status);
    }

    for (jj = 0; jj < n_cols; jj++)
    {
        /* get image or column datatype and vector length */
        if (hdutype == IMAGE_HDU)   /* get total number of pixels in the image */
        {
           fits_get_img_type(cols[jj].fptr, &bitpix, status);
           switch(bitpix) {
             case BYTE_IMG:
                 typecode = TBYTE;
                 break;
             case SHORT_IMG:
                 typecode = TSHORT;
                 break;
             case LONG_IMG:
                 typecode = TLONG;
                 break;
             case FLOAT_IMG:
                 typecode = TFLOAT;
                 break;
             case DOUBLE_IMG:
                 typecode = TDOUBLE;
                 break;
             case LONGLONG_IMG:
                 typecode = TLONGLONG;
                 break;
            }
        }
        else
        {
            if (ffgtcl(cols[jj].fptr, cols[jj].colnum, &typecode, &rept,
                  &width, status) > 0)
                goto cleanup;
		
	    if (typecode < 0) {  /* if any variable length arrays, then the */ 
	        n_optimum = 1;   /* must process the table 1 row at a time */
		
              /* Allow variable length arrays for InputCol and InputOutputCol columns,
	       but not for OutputCol columns.  Variable length arrays have a
	       negative type code value. */

              if (cols[jj].iotype == OutputCol) {
 	        sprintf(message,
                "Variable length array not allowed for output column number %d (ffiter)",
                    jj + 1);
                ffpmsg(message);
                return(*status = BAD_DATATYPE);
              }
	   }
        }

        /* special case where sizeof(long) = 8: use TINT instead of TLONG */
        if (abs(typecode) == TLONG && sizeof(long) == 8 && sizeof(int) == 4) {
		if(typecode<0) {
			typecode = -TINT;
		} else {
			typecode = TINT;
		}
        }

        /* Special case: interprete 'X' column as 'B' */
        if (abs(typecode) == TBIT)
        {
            typecode  = typecode / TBIT * TBYTE;
            rept = (rept + 7) / 8;
        }

        if (cols[jj].datatype == 0)    /* output datatype not specified? */
        {
            /* special case if sizeof(long) = 8: use TINT instead of TLONG */
            if (abs(typecode) == TLONG && sizeof(long) == 8 && sizeof(int) == 4)
                cols[jj].datatype = TINT;
            else
                cols[jj].datatype = abs(typecode);
        }

        /* calc total number of elements to do on each iteration */
        if (hdutype == IMAGE_HDU || cols[jj].datatype == TSTRING)
        {
            ntodo = n_optimum; 
            cols[jj].repeat = 1;

            /* get the BLANK keyword value, if it exists */
            if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
            {
                tstatus = 0;
                ffgkyj(cols[jj].fptr, "BLANK", &tnull, 0, &tstatus);
                if (tstatus)
                {
                    tnull = 0L;  /* no null values */
                }
            }
        }
        else
        {
	    if (typecode < 0) 
	    {
              /* get max size of the variable length vector; dont't trust the value
	         given by the TFORM keyword  */
	      rept = 1;
	      for (ii = 0; ii < totaln; ii++) {
		ffgdes(cols[jj].fptr, cols[jj].colnum, frow + ii, &rowrept, NULL, status);
		
		rept = maxvalue(rept, rowrept);
	      }
            }
	    
            ntodo = n_optimum * rept;   /* vector columns */
            cols[jj].repeat = rept;

            /* get the TNULL keyword value, if it exists */
            if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
            {
                tstatus = 0;
                if (hdutype == ASCII_TBL) /* TNULLn value is a string */
                {
                    ffkeyn("TNULL", cols[jj].colnum, keyname, &tstatus);
                    ffgkys(cols[jj].fptr, keyname, nullstr, 0, &tstatus);
                    if (tstatus)
                    {
                        tnull = 0L; /* keyword doesn't exist; no null values */
                    }
                    else
                    {
                        cptr = nullstr;
                        while (*cptr == ' ')  /* skip over leading blanks */
                           cptr++;

                        if (*cptr == '\0')  /* TNULLn is all blanks? */
                            tnull = LONG_MIN;
                        else
                        {                                                
                            /* attempt to read TNULLn string as an integer */
                            ffc2ii(nullstr, &tnull, &tstatus);

                            if (tstatus)
                                tnull = LONG_MIN;  /* choose smallest value */
                        }                          /* to represent nulls */
                    }
                }
                else  /* Binary table; TNULLn value is an integer */
                {
                    ffkeyn("TNULL", cols[jj].colnum, keyname, &tstatus);
                    ffgkyj(cols[jj].fptr, keyname, &tnull, 0, &tstatus);
                    if (tstatus)
                    {
                        tnull = 0L; /* keyword doesn't exist; no null values */
                    }
                    else if (tnull == 0)
                    {
                        /* worst possible case: a value of 0 is used to   */
                        /* represent nulls in the FITS file.  We have to  */
                        /* use a non-zero null value here (zero is used to */
                        /* mean there are no null values in the array) so we */
                        /* will use the smallest possible integer instead. */

                        tnull = LONG_MIN;  /* choose smallest possible value */
                    }
                }
            }
        }

        /* Note that the data array starts with 2nd element;  */
        /* 1st element of the array gives the null data value */

        switch (cols[jj].datatype)
        {
         case TBYTE:
          cols[jj].array = calloc(ntodo + 1, sizeof(char));
          col[jj].nullsize  = sizeof(char);  /* number of bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              tnull = minvalue(tnull, 255);
              tnull = maxvalue(tnull, 0);
              col[jj].null.charnull = (unsigned char) tnull;
          }
          else
          {
              col[jj].null.charnull = (unsigned char) 255; /* use 255 as null */
          }
          break;

         case TSBYTE:
          cols[jj].array = calloc(ntodo + 1, sizeof(char));
          col[jj].nullsize  = sizeof(char);  /* number of bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              tnull = minvalue(tnull, 127);
              tnull = maxvalue(tnull, -128);
              col[jj].null.scharnull = (signed char) tnull;
          }
          else
          {
              col[jj].null.scharnull = (signed char) -128; /* use -128  null */
          }
          break;

         case TSHORT:
          cols[jj].array = calloc(ntodo + 1, sizeof(short));
          col[jj].nullsize  = sizeof(short);  /* number of bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              tnull = minvalue(tnull, SHRT_MAX);
              tnull = maxvalue(tnull, SHRT_MIN);
              col[jj].null.shortnull = (short) tnull;
          }
          else
          {
              col[jj].null.shortnull = SHRT_MIN;  /* use minimum as null */
          }
          break;

         case TUSHORT:
          cols[jj].array = calloc(ntodo + 1, sizeof(unsigned short));
          col[jj].nullsize  = sizeof(unsigned short);  /* bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              tnull = minvalue(tnull, (long) USHRT_MAX);
              tnull = maxvalue(tnull, 0);  /* don't allow negative value */
              col[jj].null.ushortnull = (unsigned short) tnull;
          }
          else
          {
              col[jj].null.ushortnull = USHRT_MAX;   /* use maximum null */
          }
          break;

         case TINT:
          cols[jj].array = calloc(sizeof(int), ntodo + 1);
          col[jj].nullsize  = sizeof(int);  /* number of bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              tnull = minvalue(tnull, INT_MAX);
              tnull = maxvalue(tnull, INT_MIN);
              col[jj].null.intnull = (int) tnull;
          }
          else
          {
              col[jj].null.intnull = INT_MIN;  /* use minimum as null */
          }
          break;

         case TUINT:
          cols[jj].array = calloc(ntodo + 1, sizeof(unsigned int));
          col[jj].nullsize  = sizeof(unsigned int);  /* bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              tnull = minvalue(tnull, INT32_MAX);
              tnull = maxvalue(tnull, 0);
              col[jj].null.uintnull = (unsigned int) tnull;
          }
          else
          {
              col[jj].null.intnull = UINT_MAX;  /* use maximum as null */
          }
          break;

         case TLONG:
          cols[jj].array = calloc(ntodo + 1, sizeof(long));
          col[jj].nullsize  = sizeof(long);  /* number of bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              col[jj].null.longnull = tnull;
          }
          else
          {
              col[jj].null.longnull = LONG_MIN;   /* use minimum as null */
          }
          break;

         case TULONG:
          cols[jj].array = calloc(ntodo + 1, sizeof(unsigned long));
          col[jj].nullsize  = sizeof(unsigned long);  /* bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              if (tnull < 0)  /* can't use a negative null value */
                  col[jj].null.ulongnull = LONG_MAX;
              else
                  col[jj].null.ulongnull = (unsigned long) tnull;
          }
          else
          {
              col[jj].null.ulongnull = LONG_MAX;   /* use maximum as null */
          }
          break;

         case TFLOAT:
          cols[jj].array = calloc(ntodo + 1, sizeof(float));
          col[jj].nullsize  = sizeof(float);  /* number of bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              col[jj].null.floatnull = (float) tnull;
          }
          else
          {
              col[jj].null.floatnull = FLOATNULLVALUE;  /* special value */
          }
          break;

         case TCOMPLEX:
          cols[jj].array = calloc((ntodo * 2) + 1, sizeof(float));
          col[jj].nullsize  = sizeof(float);  /* number of bytes per value */
          col[jj].null.floatnull = FLOATNULLVALUE;  /* special value */
          break;

         case TDOUBLE:
          cols[jj].array = calloc(ntodo + 1, sizeof(double));
          col[jj].nullsize  = sizeof(double);  /* number of bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG)
          {
              col[jj].null.doublenull = (double) tnull;
          }
          else
          {
              col[jj].null.doublenull = DOUBLENULLVALUE;  /* special value */
          }
          break;

         case TDBLCOMPLEX:
          cols[jj].array = calloc((ntodo * 2) + 1, sizeof(double));
          col[jj].nullsize  = sizeof(double);  /* number of bytes per value */
          col[jj].null.doublenull = DOUBLENULLVALUE;  /* special value */
          break;

         case TSTRING:
          /* allocate array of pointers to all the strings  */
	  if( hdutype==ASCII_TBL ) rept = width;
          stringptr = calloc((ntodo + 1) , sizeof(stringptr));
          cols[jj].array = stringptr;
          col[jj].nullsize  = rept + 1;  /* number of bytes per value */

          if (stringptr)
          {
            /* allocate string to store the null string value */
            col[jj].null.stringnull = calloc(rept + 1, sizeof(char) );
            col[jj].null.stringnull[1] = 1; /* to make sure string != 0 */

            /* allocate big block for the array of table column strings */
            stringptr[0] = calloc((ntodo + 1) * (rept + 1), sizeof(char) );

            if (stringptr[0])
            {
              for (ii = 1; ii <= ntodo; ii++)
              {   /* pointer to each string */
                stringptr[ii] = stringptr[ii - 1] + (rept + 1);
              }

              /* get the TNULL keyword value, if it exists */
              tstatus = 0;
              ffkeyn("TNULL", cols[jj].colnum, keyname, &tstatus);
              ffgkys(cols[jj].fptr, keyname, nullstr, 0, &tstatus);
              if (!tstatus)
                  strncat(col[jj].null.stringnull, nullstr, rept);
            }
            else
            {
              ffpmsg("ffiter failed to allocate memory arrays");
              *status = MEMORY_ALLOCATION;  /* memory allocation failed */
              goto cleanup;
            }
          }
          break;

         case TLOGICAL:

          cols[jj].array = calloc(ntodo + 1, sizeof(char));
          col[jj].nullsize  = sizeof(char);  /* number of bytes per value */

          /* use value = 2 to flag null values in logical columns */
          col[jj].null.charnull = 2;
          break;

         case TLONGLONG:
          cols[jj].array = calloc(ntodo + 1, sizeof(LONGLONG));
          col[jj].nullsize  = sizeof(LONGLONG);  /* number of bytes per value */

          if (abs(typecode) == TBYTE || abs(typecode) == TSHORT || abs(typecode) == TLONG ||
	      abs(typecode) == TLONGLONG)
          {
              col[jj].null.longlongnull = tnull;
          }
          else
          {
              col[jj].null.longlongnull = LONGLONG_MIN;   /* use minimum as null */
          }
          break;

         default:
          sprintf(message,
                  "Column %d datatype currently not supported: %d:  (ffiter)",
                   jj + 1, cols[jj].datatype);
          ffpmsg(message);
          *status = BAD_DATATYPE;
          goto cleanup;

        }   /* end of switch block */

        /* check that all the arrays were allocated successfully */
        if (!cols[jj].array)
        {
            ffpmsg("ffiter failed to allocate memory arrays");
            *status = MEMORY_ALLOCATION;  /* memory allocation failed */
            goto cleanup;
        }
    }

    /*--------------------------------------------------*/
    /* main loop while there are values left to process */
    /*--------------------------------------------------*/

    nleft = totaln;

    while (nleft)
    {
      ntodo = minvalue(nleft, n_optimum); /* no. of values for this loop */

      /*  read input columns from FITS file(s)  */
      for (jj = 0; jj < n_cols; jj++)
      {
        if (cols[jj].iotype != OutputCol)
        {
          if (cols[jj].datatype == TSTRING)
          {
            stringptr = cols[jj].array;
            dataptr = stringptr + 1;
            defaultnull = col[jj].null.stringnull; /* ptr to the null value */
          }
          else
          {
            dataptr = (char *) cols[jj].array + col[jj].nullsize;
            defaultnull = &col[jj].null.charnull; /* ptr to the null value */
          }

          if (hdutype == IMAGE_HDU)   
          {
              if (ffgpv(cols[jj].fptr, cols[jj].datatype,
                    felement, cols[jj].repeat * ntodo, defaultnull,
                    dataptr,  &anynul, status) > 0)
              {
                 break;
              }
          }
          else
          {
	      if (ffgtcl(cols[jj].fptr, cols[jj].colnum, &typecode, &rept,&width, status) > 0)
	          goto cleanup;
		  
	      if (typecode<0)
	      {
	        /* get size of the variable length vector */
		ffgdes(cols[jj].fptr, cols[jj].colnum, frow,&cols[jj].repeat, NULL,status);
	      }
		
              if (ffgcv(cols[jj].fptr, cols[jj].datatype, cols[jj].colnum,
                    frow, felement, cols[jj].repeat * ntodo, defaultnull,
                    dataptr,  &anynul, status) > 0)
              {
                 break;
              }
          }

          /* copy the appropriate null value into first array element */

          if (anynul)   /* are there any nulls in the data? */
          {   
            if (cols[jj].datatype == TSTRING)
            {
              stringptr = cols[jj].array;
              memcpy(*stringptr, col[jj].null.stringnull, col[jj].nullsize);
            }
            else
            {
              memcpy(cols[jj].array, defaultnull, col[jj].nullsize);
            }
          }
          else /* no null values so copy zero into first element */
          {
            if (cols[jj].datatype == TSTRING)
            {
              stringptr = cols[jj].array;
              memset(*stringptr, 0, col[jj].nullsize);  
            }
            else
            {
              memset(cols[jj].array, 0, col[jj].nullsize);  
            }
          }
        }
      }

      if (*status > 0) 
         break;   /* looks like an error occurred; quit immediately */

      /* call work function */

      if (hdutype == IMAGE_HDU) 
          *status = work_fn(totaln, offset, felement, ntodo, n_cols, cols,
                    userPointer);
      else
          *status = work_fn(totaln, offset, frow, ntodo, n_cols, cols,
                    userPointer);

      if (*status > 0 || *status < -1 ) 
         break;   /* looks like an error occurred; quit immediately */

      /*  write output columns  before quiting if status = -1 */
      tstatus = 0;
      for (jj = 0; jj < n_cols; jj++)
      {
        if (cols[jj].iotype != InputCol)
        {
          if (cols[jj].datatype == TSTRING)
          {
            stringptr = cols[jj].array;
            dataptr = stringptr + 1;
            nullptr = *stringptr;
            nbytes = 2;
          }
          else
          {
            dataptr = (char *) cols[jj].array + col[jj].nullsize;
            nullptr = (char *) cols[jj].array;
            nbytes = col[jj].nullsize;
          }

          if (memcmp(nullptr, &zeros, nbytes) ) 
          {
            /* null value flag not zero; must check for and write nulls */
            if (hdutype == IMAGE_HDU)   
            {
                if (ffppn(cols[jj].fptr, cols[jj].datatype, 
                      felement, cols[jj].repeat * ntodo, dataptr,
                      nullptr, &tstatus) > 0)
                break;
            }
            else
            {
	    	if (ffgtcl(cols[jj].fptr, cols[jj].colnum, &typecode, &rept,&width, status) > 0)
		    goto cleanup;
		    
		if (typecode<0)  /* variable length array colum */
		{
		   ffgdes(cols[jj].fptr, cols[jj].colnum, frow,&cols[jj].repeat, NULL,status);
		}

                if (ffpcn(cols[jj].fptr, cols[jj].datatype, cols[jj].colnum, frow,
                      felement, cols[jj].repeat * ntodo, dataptr,
                      nullptr, &tstatus) > 0)
                break;
            }
          }
          else
          { 
            /* no null values; just write the array */
            if (hdutype == IMAGE_HDU)   
            {
                if (ffppr(cols[jj].fptr, cols[jj].datatype,
                      felement, cols[jj].repeat * ntodo, dataptr,
                      &tstatus) > 0)
                break;
            }
            else
            {
	    	if (ffgtcl(cols[jj].fptr, cols[jj].colnum, &typecode, &rept,&width, status) > 0)
		    goto cleanup;
		    
		if (typecode<0)  /* variable length array column */
		{
		   ffgdes(cols[jj].fptr, cols[jj].colnum, frow,&cols[jj].repeat, NULL,status);
		}

                 if (ffpcl(cols[jj].fptr, cols[jj].datatype, cols[jj].colnum, frow,
                      felement, cols[jj].repeat * ntodo, dataptr,
                      &tstatus) > 0)
                break;
            }
          }
        }
      }

      if (*status == 0)
         *status = tstatus;   /* propagate any error status from the writes */

      if (*status) 
         break;   /* exit on any error */

      nleft -= ntodo;

      if (hdutype == IMAGE_HDU)
          felement += ntodo;
      else
          frow  += ntodo;
    }

cleanup:

    /*----------------------------------*/
    /* free work arrays for the columns */
    /*----------------------------------*/

    for (jj = 0; jj < n_cols; jj++)
    {
        if (cols[jj].datatype == TSTRING)
        {
            if (cols[jj].array)
            {
                stringptr = cols[jj].array;
                free(*stringptr);     /* free the block of strings */
                free(col[jj].null.stringnull); /* free the null string */
            }
        }
        if (cols[jj].array)
            free(cols[jj].array); /* memory for the array of values from the col */
    }
    free(col);   /* the structure containing the null values */
    return(*status);
}

healpy-1.10.3/cfitsio/putcolb.c0000664000175000017500000010745013010375005016603 0ustar  zoncazonca00000000000000/*  This file, putcolb.c, contains routines that write data elements to    */
/*  a FITS image or table with char (byte) datatype.                       */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffpprb( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            unsigned char *array, /* I - array of values that are written   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    unsigned char nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TBYTE, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpclb(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnb( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            unsigned char *array, /* I - array of values that are written   */
            unsigned char nulval, /* I - undefined pixel value              */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    unsigned char nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */


        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TBYTE, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcnb(fptr, 2, row, firstelem, nelem, array, nulval, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2db(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           unsigned char *array, /* I - array to be written               */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3db(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3db(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
           unsigned char *array, /* I - array to be written               */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    LONGLONG nfits, narray;
    long fpixel[3]= {1,1,1}, lpixel[3];
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TBYTE, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpclb(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpclb(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssb(fitsfile *fptr,   /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
           unsigned char *array, /* I - array to be written                 */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TBYTE, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpclb(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpb( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
            unsigned char *array, /* I - array of values that are written   */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpclb(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclb( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            unsigned char *array, /* I - array of values to write           */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table with
  2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem2, hdutype, writeraw;
    long twidth, incre;
    long  ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull, maxelem;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem2, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);
    maxelem = maxelem2;

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*
      if there is no scaling 
      then we can simply write the raw data bytes into the FITS file if the
      datatype of the FITS column is the same as the input values.  Otherwise,
      we must convert the raw values into the scaled and/or machine dependent
      format in a temporary buffer that has been allocated for this purpose.
    */
    if (scale == 1. && zero == 0. && tcode == TBYTE)
    {
        writeraw = 1;
        if (nelem < (LONGLONG)INT32_MAX) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX;
        }
     }
    else
        writeraw = 0;

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);
        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TBYTE):
              if (writeraw)
              {
                /* write raw input bytes without conversion */
                ffpi1b(fptr, ntodo, incre, &array[next], status);
              }
              else
              {
                /* convert the raw data before writing to FITS file */
                ffi1fi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
              }

              break;

            case (TLONGLONG):

                ffi1fi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TSHORT):
 
                ffi1fi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TLONG):

                ffi1fi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TFLOAT):

                ffi1fr4(&array[next], ntodo, scale, zero,
                        (float *)  buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffi1fr8(&array[next], ntodo, scale, zero,
                        (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (strchr(tform,'A'))
                {
                    /* write raw input bytes without conversion        */
                    /* This case is a hack to let users write a stream */
                    /* of bytes directly to the 'A' format column      */

                    if (incre == twidth)
                        ffpbyt(fptr, ntodo, &array[next], status);
                    else
                        ffpbytoff(fptr, twidth, ntodo/twidth, incre - twidth, 
                                &array[next], status);
                    break;
                }
                else if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffi1fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);
                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                       "Cannot write numbers to column %d which has format %s",
                        colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpclb).",
              (double) (next+1), (double) (next+ntodo));
          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
      ffpmsg(
      "Numerical overflow during type conversion while writing FITS data.");
      *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnb( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            unsigned char *array,   /* I - array of values to write         */
            unsigned char nulvalue, /* I - flag for undefined pixels        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpclb(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood + 1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpclb(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad + 1;  /* the consecutive number of bad pixels */
      }
    }
    
    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpclb(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpextn( fitsfile *fptr,        /* I - FITS file pointer                        */
            LONGLONG  offset,      /* I - byte offset from start of extension data */
            LONGLONG  nelem,       /* I - number of elements to write              */
            void *buffer,          /* I - stream of bytes to write                 */
            int  *status)          /* IO - error status                            */
/*
  Write a stream of bytes to the current FITS HDU.  This primative routine is mainly
  for writing non-standard "conforming" extensions and should not be used
  for standard IMAGE, TABLE or BINTABLE extensions.
*/
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* rescan header if data structure is undefined */
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               
            return(*status);

    /* move to write position */
    ffmbyt(fptr, (fptr->Fptr)->datastart+ offset, IGNORE_EOF, status);
    
    /* write the buffer */
    ffpbyt(fptr, nelem, buffer, status); 

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi1fi1(unsigned char *input,  /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        memcpy(output, input, ntodo); /* just copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = ( ((double) input[ii]) - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi1fi2(unsigned char *input,  /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            short *output,         /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = input[ii];   /* just copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (((double) input[ii]) - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi1fi4(unsigned char *input,  /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,      /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (INT32BIT) input[ii];   /* copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (((double) input[ii]) - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi1fi8(unsigned char *input, /* I - array of values to be converted  */
            long ntodo,           /* I - number of elements in the array  */
            double scale,         /* I - FITS TSCALn or BSCALE value      */
            double zero,          /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,     /* O - output array of converted values */
            int *status)          /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi1fr4(unsigned char *input,  /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            float *output,         /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) (( ( (double) input[ii] ) - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi1fr8(unsigned char *input,  /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            double *output,        /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = ( ( (double) input[ii] ) - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi1fstr(unsigned char *input, /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;

    cptr = output;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = ((double) input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putcold.c0000664000175000017500000011206613010375005016604 0ustar  zoncazonca00000000000000/*  This file, putcold.c, contains routines that write data elements to    */
/*  a FITS image or table, with double datatype.                           */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffpprd( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            double *array,   /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    double nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TDOUBLE, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcld(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnd( fitsfile *fptr,   /* I - FITS file pointer                       */
            long  group,      /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem,  /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,      /* I - number of values to write               */
            double *array,    /* I - array of values that are written        */
            double nulval,    /* I - undefined pixel value                   */
            int  *status)     /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    double nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TDOUBLE, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcnd(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2dd(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           double *array,    /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3dd(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3dd(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
           double *array,    /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;

        fits_write_compressed_img(fptr, TDOUBLE, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpcld(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpcld(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssd(fitsfile *fptr,   /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
           double *array,    /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TDOUBLE, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpcld(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpd( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
            double *array,    /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpcld(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcld( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            double *array,   /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem2, hdutype, writeraw;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull, maxelem;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem2, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);
    maxelem = maxelem2;

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*
      if there is no scaling and the native machine format is not byteswapped,
      then we can simply write the raw data bytes into the FITS file if the
      datatype of the FITS column is the same as the input values.  Otherwise,
      we must convert the raw values into the scaled and/or machine dependent
      format in a temporary buffer that has been allocated for this purpose.
    */
    if (scale == 1. && zero == 0. && 
       MACHINE == NATIVE && tcode == TDOUBLE)
    {
        writeraw = 1;
        if (nelem < (LONGLONG)INT32_MAX) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/8;
        }
     }
    else
        writeraw = 0;

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TDOUBLE):
              if (writeraw)
              {
                /* write raw input bytes without conversion */
                ffpr8b(fptr, ntodo, incre, &array[next], status);
              }
              else
              {
                /* convert the raw data before writing to FITS file */
                ffr8fr8(&array[next], ntodo, scale, zero,
                        (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
              }

              break;

            case (TLONGLONG):

                ffr8fi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TBYTE):
 
                ffr8fi1(&array[next], ntodo, scale, zero, 
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TSHORT):

                ffr8fi2(&array[next], ntodo, scale, zero, 
                       (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TLONG):

                ffr8fi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TFLOAT):
                ffr8fr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffr8fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                      "Cannot write numbers to column %d which has format %s",
                       colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpcld).",
              (double) (next+1), (double) (next+ntodo));
         ffpmsg(message);
         return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while writing FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclm( fitsfile *fptr,   /* I - FITS file pointer                       */
            int  colnum,      /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,   /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem,  /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,      /* I - number of values to write               */
            double *array,    /* I - array of values to write                */
            int  *status)     /* IO - error status                           */
/*
  Write an array of double complex values to a column in the current FITS HDU.
  Each complex number if interpreted as a pair of float values.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column
  if necessary, but normally complex values should only be written to a binary
  table with TFORMn = 'rM' where r is an optional repeat count. The TSCALn and
  TZERO keywords should not be used with complex numbers because mathmatically
  the scaling should only be applied to the real (first) component of the
  complex value.
*/
{
    /* simply multiply the number of elements by 2, and call ffpcld */

    ffpcld(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1, 
            nelem * 2, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnd( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            double *array,   /* I - array of values to write                */
            double nulvalue, /* I - value used to flag undefined pixels     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    if (abs(tcode) >= TCOMPLEX)
    { /* treat complex columns as pairs of numbers */
        repeat *= 2;
    }

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpcld(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
	if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            /* call ffpcluc, not ffpclu, in case we are writing to a
	       complex ('C') binary table column */
            if (ffpcluc(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpcld(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else {
                  return(*status);
		}
	      }
            }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpcld(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */
      ffpcluc(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr8fi1(double *input,         /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (input[ii] > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr8fi2(double *input,     /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            short *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (input[ii] > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
                output[ii] = (short) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr8fi4(double *input,     /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (input[ii] > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
                output[ii] = (INT32BIT) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr8fi8(double *input,     /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (input[ii] > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
                output[ii] = (LONGLONG) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr8fr4(double *input,     /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) ((input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr8fr8(double *input,     /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
      memcpy(output, input, ntodo * sizeof(double) ); /* copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr8fstr(double *input,     /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;
    
    cptr = output;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = (input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putcole.c0000664000175000017500000011315213010375005016602 0ustar  zoncazonca00000000000000/*  This file, putcole.c, contains routines that write data elements to    */
/*  a FITS image or table, with float datatype.                            */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffppre( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG nelem,     /* I - number of values to write               */
            float *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).

  This routine cannot be called directly by users to write to large
  arrays with > 2**31 pixels (although CFITSIO can do so by passing
  the firstelem thru a LONGLONG sized global variable)
*/
{
    long row;
    float nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TFLOAT, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcle(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppne( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG nelem,     /* I - number of values to write               */
            float *array,    /* I - array of values that are written        */
            float nulval,    /* I - undefined pixel value                   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.

  This routine cannot be called directly by users to write to large
  arrays with > 2**31 pixels (although CFITSIO can do so by passing
  the firstelem thru a LONGLONG sized global variable)
*/
{
    long row;
    float nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TFLOAT, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcne(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2de(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           float *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).

  This routine does not support writing to large images with
  more than 2**31 pixels.
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3de(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3de(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
           float *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).

  This routine does not support writing to large images with
  more than 2**31 pixels.
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TFLOAT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpcle(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpcle(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpsse(fitsfile *fptr,   /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
           float *array,     /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TFLOAT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpcle(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpe( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
            float *array,     /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpcle(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcle( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            float *array,    /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem2, hdutype, writeraw;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull, maxelem;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem2, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);
    maxelem = maxelem2;

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*
       if there is no scaling and the native machine format is not byteswapped
       then we can simply write the raw data bytes into the FITS file if the
       datatype of the FITS column is the same as the input values.  Otherwise,
       we must convert the raw values into the scaled and/or machine dependent
       format in a temporary buffer that has been allocated for this purpose.
    */
    if (scale == 1. && zero == 0. && 
       MACHINE == NATIVE && tcode == TFLOAT)
    {
        writeraw = 1;
        if (nelem < (LONGLONG)INT32_MAX) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/4;
        }
     }
    else
        writeraw = 0;

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TFLOAT):
              if (writeraw)
              {
                /* write raw input bytes without conversion */
                ffpr4b(fptr, ntodo, incre, &array[next], status);
              }
              else
              {
                /* convert the raw data before writing to FITS file */
                ffr4fr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
              }

              break;

            case (TLONGLONG):

                ffr4fi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TBYTE):
 
                ffr4fi1(&array[next], ntodo, scale, zero, 
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TSHORT):

                ffr4fi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TLONG):

                ffr4fi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TDOUBLE):
                ffr4fr8(&array[next], ntodo, scale, zero,
                       (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffr4fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                       "Cannot write numbers to column %d which has format %s",
                        colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpcle).",
             (double) (next+1), (double) (next+ntodo));
         ffpmsg(message);
         return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while writing FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclc( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            float *array,    /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of complex values to a column in the current FITS HDU.
  Each complex number if interpreted as a pair of float values.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column
  if necessary, but normally complex values should only be written to a binary
  table with TFORMn = 'rC' where r is an optional repeat count. The TSCALn and
  TZERO keywords should not be used with complex numbers because mathmatically
  the scaling should only be applied to the real (first) component of the
  complex value.
*/
{
    /* simply multiply the number of elements by 2, and call ffpcle */

    ffpcle(fptr, colnum, firstrow, (firstelem - 1) * 2 + 1,
            nelem * 2, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcne( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            float *array,    /* I - array of values to write                */
            float  nulvalue, /* I - value used to flag undefined pixels     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    if (abs(tcode) >= TCOMPLEX)
    { /* treat complex columns as pairs of numbers */
        repeat *= 2;
    }
    
    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpcle(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            /* call ffpcluc, not ffpclu, in case we are writing to a
	       complex ('C') binary table column */
            if (ffpcluc(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpcle(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
              }
	    }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpcle(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */
      ffpcluc(fptr, colnum, fstrow, fstelm, nbad, status);
    }
    
    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr4fi1(float *input,          /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (input[ii] > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr4fi2(float *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            short *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {           
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (input[ii] > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
                output[ii] = (short) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr4fi4(float *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (input[ii] > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
                output[ii] = (INT32BIT) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr4fi8(float *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (input[ii] > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
                output[ii] = (long) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr4fr4(float *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
      memcpy(output, input, ntodo * sizeof(float) ); /* copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) ((input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr4fr8(float *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr4fstr(float *input,     /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;
    
    cptr = output;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = (input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putcoli.c0000664000175000017500000010404113010375005016603 0ustar  zoncazonca00000000000000/*  This file, putcoli.c, contains routines that write data elements to    */
/*  a FITS image or table, with short datatype.                            */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffppri( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write (1 = 1st group)          */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            short *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    short nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */


        fits_write_compressed_pixels(fptr, TSHORT, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcli(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppni( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            short *array,    /* I - array of values that are written        */
            short nulval,    /* I - undefined pixel value                   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    short nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TSHORT, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcni(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2di(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           short *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3di(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3di(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
           short *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TSHORT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpcli(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpcli(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssi(fitsfile *fptr,   /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
           short *array,     /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TSHORT, fpixel, lpixel,
            0,  array, NULL, status);

        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpcli(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpi( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
            short *array,     /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpcli(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcli( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            short *array,    /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table with
  2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem2, hdutype, writeraw;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull, maxelem;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem2, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);
    maxelem = maxelem2;

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*
      if there is no scaling and the native machine format is not byteswapped,
      then we can simply write the raw data bytes into the FITS file if the
      datatype of the FITS column is the same as the input values.  Otherwise,
      we must convert the raw values into the scaled and/or machine dependent
      format in a temporary buffer that has been allocated for this purpose.
    */
    if (scale == 1. && zero == 0. &&
       MACHINE == NATIVE && tcode == TSHORT)
    {
        writeraw = 1;
        if (nelem < (LONGLONG)INT32_MAX) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/2;
        }
    }
    else
        writeraw = 0;

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TSHORT):
              if (writeraw)
              {
                /* write raw input bytes without conversion */
                ffpi2b(fptr, ntodo, incre, &array[next], status);
              }
              else
              {
                /* convert the raw data before writing to FITS file */
                ffi2fi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
              }

              break;

            case (TLONGLONG):

                ffi2fi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

             case (TBYTE):

                ffi2fi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TLONG):

                ffi2fi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TFLOAT):

                ffi2fr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffi2fr8(&array[next], ntodo, scale, zero,
                        (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffi2fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);


                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                    "Cannot write numbers to column %d which has format %s",
                      colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
         sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpcli).",
             (double) (next+1), (double) (next+ntodo));
         ffpmsg(message);
         return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
       ffpmsg(
       "Numerical overflow during type conversion while writing FITS data.");
       *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcni( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            short *array,    /* I - array of values to write                */
            short  nulvalue, /* I - value used to flag undefined pixels     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpcli(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpcli(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpcli(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi2fi1(short *input,          /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < 0)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (input[ii] > UCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi2fi2(short *input,       /* I - array of values to be converted  */
            long ntodo,         /* I - number of elements in the array  */
            double scale,       /* I - FITS TSCALn or BSCALE value      */
            double zero,        /* I - FITS TZEROn or BZERO  value      */
            short *output,      /* O - output array of converted values */
            int *status)        /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        memcpy(output, input, ntodo * sizeof(short) );
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi2fi4(short *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (INT32BIT) input[ii];   /* just copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi2fi8(short *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi2fr4(short *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) ((input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi2fr8(short *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi2fstr(short *input,     /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr, *tptr;
    
    cptr = output;
    tptr = output;


    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = (input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';

    return(*status);
}
healpy-1.10.3/cfitsio/putcolj.c0000664000175000017500000021102513010375005016605 0ustar  zoncazonca00000000000000/*  This file, putcolj.c, contains routines that write data elements to    */
/*  a FITS image or table, with long datatype.                             */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffpprj( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            long  *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    long nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TLONG, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpclj(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnj( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            long  *array,    /* I - array of values that are written        */
            long  nulval,    /* I - undefined pixel value                   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    long nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TLONG, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcnj(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2dj(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           long  *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{

    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3dj(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3dj(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
           long  *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TLONG, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpclj(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpclj(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssj(fitsfile *fptr,   /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
           long *array,      /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TLONG, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpclj(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpj( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
            long  *array,     /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpclj(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclj( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            long  *array,    /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem2, hdutype, writeraw;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull, maxelem;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem2, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);
    maxelem = maxelem2;

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*
       if there is no scaling and the native machine format is not byteswapped
       then we can simply write the raw data bytes into the FITS file if the
       datatype of the FITS column is the same as the input values.  Otherwise
       we must convert the raw values into the scaled and/or machine dependent
       format in a temporary buffer that has been allocated for this purpose.
    */
    if (scale == 1. && zero == 0. && 
       MACHINE == NATIVE && tcode == TLONG && LONGSIZE == 32)
    {
        writeraw = 1;
        if (nelem < (LONGLONG)INT32_MAX) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/8;
        }
    }
    else
        writeraw = 0;

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TLONG):
              if (writeraw)
              {
                /* write raw input bytes without conversion */
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) &array[next], status);
              }
              else
              {
                /* convert the raw data before writing to FITS file */
                ffi4fi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
              }

              break;

            case (TLONGLONG):

                fflongfi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TBYTE):
 
                ffi4fi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TSHORT):

                ffi4fi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TFLOAT):

                ffi4fr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffi4fr8(&array[next], ntodo, scale, zero,
                       (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffi4fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                     "Cannot write numbers to column %d which has format %s",
                      colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpclj).",
              (double) (next+1), (double) (next+ntodo));
          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while writing FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnj( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            long  *array,    /* I - array of values to write                */
            long   nulvalue, /* I - value used to flag undefined pixels     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;
 
    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpclj(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */
	  
            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood + 1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpclj(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpclj(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi4fi1(long *input,           /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < 0)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (input[ii] > UCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi4fi2(long *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            short *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < SHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (input[ii] > SHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
                output[ii] = (short) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi4fi4(long *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (INT32BIT) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int fflongfi8(long *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi4fr4(long *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) ((input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi4fr8(long *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi4fstr(long *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;

    cptr = output;
    
    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = (input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';

    return(*status);
}

/* ======================================================================== */
/*      the following routines support the 'long long' data type            */
/* ======================================================================== */

/*--------------------------------------------------------------------------*/
int ffpprjj(fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            LONGLONG  *array, /* I - array of values that are written       */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        ffpmsg("writing to compressed image is not supported");

        return(*status = DATA_COMPRESSION_ERR);
    }

    row=maxvalue(1,group);

    ffpcljj(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnjj(fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            LONGLONG  *array, /* I - array of values that are written       */
            LONGLONG  nulval,    /* I - undefined pixel value                   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        ffpmsg("writing to compressed image is not supported");

        return(*status = DATA_COMPRESSION_ERR);
    }

    row=maxvalue(1,group);

    ffpcnjj(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2djj(fitsfile *fptr,  /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  *array, /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{

    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3djj(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3djj(fitsfile *fptr,  /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
           LONGLONG  *array, /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        ffpmsg("writing to compressed image is not supported");

        return(*status = DATA_COMPRESSION_ERR);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpcljj(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpcljj(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssjj(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
           LONGLONG *array,  /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        ffpmsg("writing to compressed image is not supported");


        return(*status = DATA_COMPRESSION_ERR);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpcljj(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpjj(fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
            LONGLONG  *array, /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpcljj(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcljj(fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            LONGLONG  *array, /* I - array of values to write               */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem2, hdutype, writeraw;
    long twidth, incre;
    long  ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull, maxelem;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem2, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);
    maxelem = maxelem2;

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*
       if there is no scaling and the native machine format is not byteswapped
       then we can simply write the raw data bytes into the FITS file if the
       datatype of the FITS column is the same as the input values.  Otherwise
       we must convert the raw values into the scaled and/or machine dependent
       format in a temporary buffer that has been allocated for this purpose.
    */
    if (scale == 1. && zero == 0. && 
       MACHINE == NATIVE && tcode == TLONGLONG)
    {
        writeraw = 1;
        if (nelem < (LONGLONG)INT32_MAX/8) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/8;
        }
    }
    else
        writeraw = 0;

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TLONGLONG):
              if (writeraw)
              {
                /* write raw input bytes without conversion */
                ffpi8b(fptr, ntodo, incre, (long *) &array[next], status);
              }
              else
              {
                /* convert the raw data before writing to FITS file */
                ffi8fi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
              }

              break;

            case (TLONG):

                ffi8fi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TBYTE):
 
                ffi8fi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TSHORT):

                ffi8fi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TFLOAT):

                ffi8fr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffi8fr8(&array[next], ntodo, scale, zero,
                       (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffi8fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                     "Cannot write numbers to column %d which has format %s",
                      colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpclj).",
              (double) (next+1), (double) (next+ntodo));
          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while writing FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnjj(fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            LONGLONG *array, /* I - array of values to write                */
            LONGLONG nulvalue, /* I - value used to flag undefined pixels   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpcljj(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpcljj(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpcljj(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi8fi1(LONGLONG *input,       /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < 0)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (input[ii] > UCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi8fi2(LONGLONG *input,   /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            short *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < SHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (input[ii] > SHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
                output[ii] = (short) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi8fi4(LONGLONG *input,   /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < INT32_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (input[ii] > INT32_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
                output[ii] = (INT32BIT) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi8fi8(LONGLONG *input,   /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi8fr4(LONGLONG *input,   /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) ((input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi8fr8(LONGLONG *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi8fstr(LONGLONG *input,  /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;
    
    cptr = output;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = (input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putcolk.c0000664000175000017500000010566113010375005016616 0ustar  zoncazonca00000000000000/*  This file, putcolk.c, contains routines that write data elements to    */
/*  a FITS image or table, with 'int' datatype.                            */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffpprk( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            int   *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    int nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TINT, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpclk(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnk( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            int   *array,    /* I - array of values that are written        */
            int   nulval,    /* I - undefined pixel value                   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    int nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TINT, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcnk(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2dk(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           int   *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3dk(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3dk(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
           int   *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TINT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpclk(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpclk(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssk(fitsfile *fptr,   /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
           int *array,      /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TINT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpclk(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpk( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
            int   *array,     /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpclk(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclk( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            int   *array,    /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem2, hdutype, writeraw;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull, maxelem;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* call the 'short' or 'long' version of this routine, if possible */
    if (sizeof(int) == sizeof(short))
        ffpcli(fptr, colnum, firstrow, firstelem, nelem, 
              (short *) array, status);
    else if (sizeof(int) == sizeof(long))
        ffpclj(fptr, colnum, firstrow, firstelem, nelem, 
              (long *) array, status);
    else
    {
    /*
      This is a special case: sizeof(int) is not equal to sizeof(short) or
      sizeof(long).  This occurs on Alpha OSF systems where short = 2 bytes,
      int = 4 bytes, and long = 8 bytes.
    */

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem2, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);
    maxelem = maxelem2;

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*
       if there is no scaling and the native machine format is not byteswapped
       then we can simply write the raw data bytes into the FITS file if the
       datatype of the FITS column is the same as the input values.  Otherwise
       we must convert the raw values into the scaled and/or machine dependent
       format in a temporary buffer that has been allocated for this purpose.
    */
    if (scale == 1. && zero == 0. && 
       MACHINE == NATIVE && tcode == TLONG)
    {
        writeraw = 1;
        if (nelem < (LONGLONG)INT32_MAX) {
            maxelem = nelem;
        } else {
            maxelem = INT32_MAX/4;
        }
    }
    else
        writeraw = 0;

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TLONG):
              if (writeraw)
              {
                /* write raw input bytes without conversion */
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) &array[next], status);
              }
              else
              {
                /* convert the raw data before writing to FITS file */
                ffintfi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
              }

                break;

            case (TLONGLONG):

                ffintfi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TBYTE):
 
                ffintfi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TSHORT):

                ffintfi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TFLOAT):

                ffintfr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffintfr8(&array[next], ntodo, scale, zero,
                       (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffintfstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                     "Cannot write numbers to column %d which has format %s",
                      colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpclk).",
              (double) (next+1), (double) (next+ntodo));
          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while writing FITS data.");
        *status = NUM_OVERFLOW;
    }

    }   /* end of Dec ALPHA special case */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnk( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            int   *array,    /* I - array of values to write                */
            int    nulvalue, /* I - value used to flag undefined pixels     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpclk(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpclk(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0)  {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpclk(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffintfi1(int *input,           /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < 0)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (input[ii] > UCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffintfi2(int *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            short *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < SHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (input[ii] > SHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
                output[ii] = input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffintfi4(int *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)  
    {       
        memcpy(output, input, ntodo * sizeof(int) );
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffintfi8(int *input,  /* I - array of values to be converted  */
            long ntodo,             /* I - number of elements in the array  */
            double scale,           /* I - FITS TSCALn or BSCALE value      */
            double zero,            /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,       /* O - output array of converted values */
            int *status)            /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffintfr4(int *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) ((input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffintfr8(int *input,       /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffintfstr(int *input,      /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;
    
    cptr = output;


    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = (input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putcoll.c0000664000175000017500000003264513010375005016620 0ustar  zoncazonca00000000000000/*  This file, putcoll.c, contains routines that write data elements to    */
/*  a FITS image or table, with logical datatype.                          */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffpcll( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            char *array,     /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of logical values to a column in the current FITS HDU.
*/
{
    int tcode, maxelem, hdutype;
    long twidth, incre;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
    double scale, zero;
    char tform[20], ctrue = 'T', cfalse = 'F';
    char message[FLEN_ERRMSG];
    char snull[20];   /*  the FITS null value  */

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    if (tcode != TLOGICAL)   
        return(*status = NOT_LOGICAL_COL);

    /*---------------------------------------------------------------------*/
    /*  Now write the logical values one at a time to the FITS column.     */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
      wrtptr = startpos + (rowlen * rownum) + (elemnum * incre);

      ffmbyt(fptr, wrtptr, IGNORE_EOF, status);  /* move to write position */

      if (array[next])
         ffpbyt(fptr, 1, &ctrue, status);
      else
         ffpbyt(fptr, 1, &cfalse, status);

      if (*status > 0)  /* test for error during previous write operation */
      {
        sprintf(message,
           "Error writing element %.0f of input array of logicals (ffpcll).",
            (double) (next+1));
        ffpmsg(message);
        return(*status);
      }

      /*--------------------------------------------*/
      /*  increment the counters for the next loop  */
      /*--------------------------------------------*/
      remain--;
      if (remain)
      {
        next++;
        elemnum++;
        if (elemnum == repeat)  /* completed a row; start on next row */
        {
           elemnum = 0;
           rownum++;
        }
      }

    }  /*  End of main while Loop  */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnl( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            char  *array,    /* I - array of values to write                */
            char  nulvalue,  /* I - array flagging undefined pixels if true */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels flagged as null will be replaced by the appropriate
  null value in the output FITS file. 
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* first write the whole input vector, then go back and fill in the nulls */
    if (ffpcll(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0)
          return(*status);

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

/*  good values have already been written
            if (ffpcll(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0)
                return(*status);
*/
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

/*  these have already been written
      ffpcll(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
*/
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclx( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  frow,      /* I - first row to write (1 = 1st row)        */
            long  fbit,      /* I - first bit to write (1 = 1st)            */
            long  nbit,      /* I - number of bits to write                 */
            char *larray,    /* I - array of logicals corresponding to bits */
            int  *status)    /* IO - error status                           */
/*
  write an array of logical values to a specified bit or byte
  column of the binary table.   If larray is TRUE, then the corresponding
  bit is set to 1, otherwise it is set to 0.
  The binary table column being written to must have datatype 'B' or 'X'. 
*/
{
    LONGLONG offset, bstart, repeat, rowlen, elemnum, rstart, estart, tnull;
    long fbyte, lbyte, nbyte, bitloc, ndone;
    long ii, twidth, incre;
    int tcode, descrp, maxelem, hdutype;
    double dummyd;
    char tform[12], snull[12];
    unsigned char cbuff;
    static unsigned char onbit[8] = {128,  64,  32,  16,   8,   4,   2,   1};
    static unsigned char offbit[8] = {127, 191, 223, 239, 247, 251, 253, 254};
    tcolumn *colptr;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /*  check input parameters */
    if (nbit < 1)
        return(*status);
    else if (frow < 1)
        return(*status = BAD_ROW_NUM);
    else if (fbit < 1)
        return(*status = BAD_ELEM_NUM);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* rescan header if data structure is undefined */
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               
            return(*status);

    fbyte = (fbit + 7) / 8;
    lbyte = (fbit + nbit + 6) / 8;
    nbyte = lbyte - fbyte +1;

    /* Save the current heapsize; ffgcprll will increment the value if */
    /* we are writing to a variable length column. */
    offset = (fptr->Fptr)->heapsize;

    /* call ffgcprll in case we are writing beyond the current end of   */
    /* the table; it will allocate more space and shift any following */
    /* HDU's.  Otherwise, we have little use for most of the returned */
    /* parameters, therefore just use dummy parameters.               */

    if (ffgcprll( fptr, colnum, frow, fbyte, nbyte, 1, &dummyd, &dummyd,
        tform, &twidth, &tcode, &maxelem, &bstart, &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    bitloc = fbit - 1 - ((fbit - 1) / 8 * 8);
    ndone = 0;
    rstart = frow - 1;
    estart = fbyte - 1;

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode = colptr->tdatatype;

    if (abs(tcode) > TBYTE)
        return(*status = NOT_LOGICAL_COL); /* not correct datatype column */

    if (tcode > 0)
    {
        descrp = FALSE;  /* not a variable length descriptor column */
        repeat = colptr->trepeat;

        if (tcode == TBIT)
            repeat = (repeat + 7) / 8; /* convert from bits to bytes */

        if (fbyte > repeat)
            return(*status = BAD_ELEM_NUM);

        /* calc the i/o pointer location to start of sequence of pixels */
        bstart = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * rstart) +
               colptr->tbcol + estart;
    }
    else
    {
        descrp = TRUE;  /* a variable length descriptor column */
        /* only bit arrays (tform = 'X') are supported for variable */
        /* length arrays.  REPEAT is the number of BITS in the array. */

        repeat = fbit + nbit -1;

        /* write the number of elements and the starting offset.    */
        /* Note: ffgcprll previous wrote the descripter, but with the */
        /* wrong repeat value  (gave bytes instead of bits).        */

        if (tcode == -TBIT)
            ffpdes(fptr, colnum, frow, (long) repeat, offset, status);

        /* Calc the i/o pointer location to start of sequence of pixels.   */
        /* ffgcprll has already calculated a value for bstart that         */
        /* points to the first element of the vector; we just have to      */
        /* increment it to point to the first element we want to write to. */
        /* Note: ffgcprll also already updated the size of the heap, so we */
        /* don't have to do that again here.                               */

        bstart += estart;
    }

    /* move the i/o pointer to the start of the pixel sequence */
    ffmbyt(fptr, bstart, IGNORE_EOF, status);

    /* read the next byte (we may only be modifying some of the bits) */
    while (1)
    {
      if (ffgbyt(fptr, 1, &cbuff, status) == END_OF_FILE)
      {
        /* hit end of file trying to read the byte, so just set byte = 0 */
        *status = 0;
        cbuff = 0;
      }

      /* move back, to be able to overwrite the byte */
      ffmbyt(fptr, bstart, IGNORE_EOF, status);
 
      for (ii = bitloc; (ii < 8) && (ndone < nbit); ii++, ndone++)
      {
        if(larray[ndone])
          cbuff = cbuff | onbit[ii];
        else
          cbuff = cbuff & offbit[ii];
      }

      ffpbyt(fptr, 1, &cbuff, status); /* write the modified byte */

      if (ndone == nbit)  /* finished all the bits */
        return(*status);

      /* not done, so get the next byte */
      bstart++;
      if (!descrp)
      {
        estart++;
        if (estart == repeat)
        {
          /* move the i/o pointer to the next row of pixels */
          estart = 0;
          rstart = rstart + 1;
          bstart = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * rstart) +
               colptr->tbcol;

          ffmbyt(fptr, bstart, IGNORE_EOF, status);
        }
      }
      bitloc = 0;
    }
}

healpy-1.10.3/cfitsio/putcols.c0000664000175000017500000002523113010375005016620 0ustar  zoncazonca00000000000000/*  This file, putcols.c, contains routines that write data elements to    */
/*  a FITS image or table, of type character string.                       */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include "fitsio2.h"
/*--------------------------------------------------------------------------*/
int ffpcls( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of strings to write              */
            char  **array,   /* I - array of pointers to strings            */
            int  *status)    /* IO - error status                           */
/*
  Write an array of string values to a column in the current FITS HDU.
*/
{
    int tcode, maxelem, hdutype, nchar;
    long twidth, incre;
    long ii, jj, ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
    double scale, zero;
    char tform[20], *blanks;
    char message[FLEN_ERRMSG];
    char snull[20];   /*  the FITS null value  */
    tcolumn *colptr;

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    char *buffer, *arrayptr;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (colnum < 1 || colnum > (fptr->Fptr)->tfield)
    {
        sprintf(message, "Specified column number is out of range: %d",
                colnum);
        ffpmsg(message);
        return(*status = BAD_COL_NUM);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */
    tcode = colptr->tdatatype;

    if (tcode == -TSTRING) /* variable length column in a binary table? */
    {
      /* only write a single string; ignore value of firstelem */
      nchar = maxvalue(1,strlen(array[0])); /* will write at least 1 char */
                                          /* even if input string is null */

      if (ffgcprll( fptr, colnum, firstrow, 1, nchar, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);
	
      /* simply move to write position, then write the string */
      ffmbyt(fptr, startpos, IGNORE_EOF, status); 
      ffpbyt(fptr, nchar, array[0], status);

      if (*status > 0)  /* test for error during previous write operation */
      {
         sprintf(message,
          "Error writing to variable length string column (ffpcls).");
         ffpmsg(message);
      }

      return(*status);
    }
    else if (tcode == TSTRING)
    {
      if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

      /* if string length is greater than a FITS block (2880 char) then must */
      /* only write 1 string at a time, to force writein by ffpbyt instead of */
      /* ffpbytoff (ffpbytoff can't handle this case) */
      if (twidth > IOBUFLEN) {
        maxelem = 1;
        incre = twidth;
        repeat = 1;
      }   

      blanks = (char *) malloc(twidth); /* string for blank fill values */
      if (!blanks)
      {
        ffpmsg("Could not allocate memory for string (ffpcls)");
        return(*status = ARRAY_TOO_BIG);
      }

      for (ii = 0; ii < twidth; ii++)
          blanks[ii] = ' ';          /* fill string with blanks */

      remain = nelem;           /* remaining number of values to write  */
    }
    else 
      return(*status = NOT_ASCII_COL);
 
    /*-------------------------------------------------------*/
    /*  Now write the strings to the FITS column.            */
    /*-------------------------------------------------------*/

    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
      /* limit the number of pixels to process at one time to the number that
         will fit in the buffer space or to the number of pixels that remain
         in the current vector, which ever is smaller.
      */
      ntodo = (long) minvalue(remain, maxelem);      
      ntodo = (long) minvalue(ntodo, (repeat - elemnum));

      wrtptr = startpos + (rownum * rowlen) + (elemnum * incre);
      ffmbyt(fptr, wrtptr, IGNORE_EOF, status);  /* move to write position */

      buffer = (char *) cbuff;

      /* copy the user's strings into the buffer */
      for (ii = 0; ii < ntodo; ii++)
      {
         arrayptr = array[next];

         for (jj = 0; jj < twidth; jj++)  /*  copy the string, char by char */
         {
            if (*arrayptr)
            {
              *buffer = *arrayptr;
              buffer++;
              arrayptr++;
            }
            else
              break;
         }

         for (;jj < twidth; jj++)    /* fill field with blanks, if needed */
         {
           *buffer = ' ';
           buffer++;
         }

         next++;
      }

      /* write the buffer full of strings to the FITS file */
      if (incre == twidth)
         ffpbyt(fptr, ntodo * twidth, cbuff, status);
      else
         ffpbytoff(fptr, twidth, ntodo, incre - twidth, cbuff, status);

      if (*status > 0)  /* test for error during previous write operation */
      {
         sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpcls).",
             (double) (next+1), (double) (next+ntodo));
         ffpmsg(message);

         if (blanks)
           free(blanks);

         return(*status);
      }

      /*--------------------------------------------*/
      /*  increment the counters for the next loop  */
      /*--------------------------------------------*/
      remain -= ntodo;
      if (remain)
      {
          elemnum += ntodo;
          if (elemnum == repeat)  /* completed a row; start on next row */
          {
              elemnum = 0;
              rownum++;
          }
       }
    }  /*  End of main while Loop  */

    if (blanks)
      free(blanks);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcns( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            char  **array,   /* I - array of values to write                */
            char  *nulvalue, /* I - string representing a null value        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels flagged as null will be replaced by the appropriate
  null value in the output FITS file. 
*/
{
    long repeat, width;
    LONGLONG ngood = 0, nbad = 0, ii;
    LONGLONG first, fstelm, fstrow;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    /* get the vector repeat length of the column */
    ffgtcl(fptr, colnum, NULL, &repeat, &width, status);

    if ((fptr->Fptr)->hdutype == BINARY_TBL)
        repeat = repeat / width;    /* convert from chars to unit strings */

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (strcmp(nulvalue, array[ii]))  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);
            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpcls(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0)
                return(*status);

            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpcls(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    return(*status);
}
healpy-1.10.3/cfitsio/putcolsb.c0000664000175000017500000010404113010375005016757 0ustar  zoncazonca00000000000000/*  This file, putcolsb.c, contains routines that write data elements to   */
/*  a FITS image or table with signed char (signed byte) datatype.         */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffpprsb( fitsfile *fptr,  /* I - FITS file pointer                      */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            signed char *array, /* I - array of values that are written     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    signed char nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TSBYTE, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpclsb(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnsb( fitsfile *fptr,  /* I - FITS file pointer                      */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
            signed char *array, /* I - array of values that are written     */
            signed char nulval, /* I - undefined pixel value                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    signed char nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TSBYTE, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcnsb(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2dsb(fitsfile *fptr,   /* I - FITS file pointer                    */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           signed char *array, /* I - array to be written                 */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3dsb(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3dsb(fitsfile *fptr,   /* I - FITS file pointer                    */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
           signed char *array, /* I - array to be written                 */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TSBYTE, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpclsb(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpclsb(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpsssb(fitsfile *fptr,   /* I - FITS file pointer                      */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
           signed char *array, /* I - array to be written                   */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TSBYTE, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpclsb(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpsb( fitsfile *fptr,   /* I - FITS file pointer                     */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
            signed char *array, /* I - array of values that are written     */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpclsb(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclsb( fitsfile *fptr,  /* I - FITS file pointer                      */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            signed char *array, /* I - array of values to write             */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table with
  2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem, hdutype;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);
        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TBYTE):

                /* convert the raw data before writing to FITS file */
                ffs1fi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);

              break;

            case (TLONGLONG):

                ffs1fi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TSHORT):
 
                ffs1fi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TLONG):

                ffs1fi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TFLOAT):

                ffs1fr4(&array[next], ntodo, scale, zero,
                        (float *)  buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffs1fr8(&array[next], ntodo, scale, zero,
                        (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (strchr(tform,'A'))
                {
                    /* write raw input bytes without conversion        */
                    /* This case is a hack to let users write a stream */
                    /* of bytes directly to the 'A' format column      */

                    if (incre == twidth)
                        ffpbyt(fptr, ntodo, &array[next], status);
                    else
                        ffpbytoff(fptr, twidth, ntodo/twidth, incre - twidth, 
                                &array[next], status);
                    break;
                }
                else if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffs1fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);
                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                       "Cannot write numbers to column %d which has format %s",
                        colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpclsb).",
              (double) (next+1), (double) (next+ntodo));
          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
      ffpmsg(
      "Numerical overflow during type conversion while writing FITS data.");
      *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnsb( fitsfile *fptr,  /* I - FITS file pointer                      */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            signed char *array,   /* I - array of values to write           */
            signed char nulvalue, /* I - flag for undefined pixels          */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpclsb(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood + 1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpclsb(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad + 1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpclsb(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffs1fi1(signed char *input,    /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == -128.)
    {
        /* Instead of adding 128, it is more efficient */
        /* to just flip the sign bit with the XOR operator */

        for (ii = 0; ii < ntodo; ii++)
             output[ii] =  ( *(unsigned char *) &input[ii] ) ^ 0x80;
    }
    else if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] < 0)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else
                output[ii] = (unsigned char) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = ( ((double) input[ii]) - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffs1fi2(signed char *input,    /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            short *output,         /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = input[ii];   /* just copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (((double) input[ii]) - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffs1fi4(signed char *input,    /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,      /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (INT32BIT) input[ii];   /* copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (((double) input[ii]) - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffs1fi8(signed char *input,   /* I - array of values to be converted  */
            long ntodo,           /* I - number of elements in the array  */
            double scale,         /* I - FITS TSCALn or BSCALE value      */
            double zero,          /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,     /* O - output array of converted values */
            int *status)          /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffs1fr4(signed char *input,    /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            float *output,         /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) (( ( (double) input[ii] ) - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffs1fr8(signed char *input,    /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            double *output,        /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = ( ( (double) input[ii] ) - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffs1fstr(signed char *input, /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;
    
    cptr = output;


    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = ((double) input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putcolu.c0000664000175000017500000005177713010375005016640 0ustar  zoncazonca00000000000000/*  This file, putcolu.c, contains routines that write data elements to    */
/*  a FITS image or table.  Writes null values.                            */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffppru( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,      /* I - group to write(1 = 1st group)          */
            LONGLONG  firstelem,  /* I - first vector element to write(1 = 1st) */
            LONGLONG  nelem,      /* I - number of values to write              */
            int  *status)     /* IO - error status                          */
/*
  Write null values to the primary array.

*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        ffpmsg("writing to compressed image is not supported");

        return(*status = DATA_COMPRESSION_ERR);
    }

    row=maxvalue(1,group);

    ffpclu(fptr, 2, row, firstelem, nelem, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpprn( fitsfile *fptr,  /* I - FITS file pointer                       */
            LONGLONG  firstelem,  /* I - first vector element to write(1 = 1st) */
            LONGLONG  nelem,      /* I - number of values to write              */
            int  *status)     /* IO - error status                          */
/*
  Write null values to the primary array. (Doesn't support groups).

*/
{
    long row = 1;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        ffpmsg("writing to compressed image is not supported");

        return(*status = DATA_COMPRESSION_ERR);
    }

    ffpclu(fptr, 2, row, firstelem, nelem, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclu( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelempar,     /* I - number of values to write               */
            int  *status)    /* IO - error status                           */
/*
  Set elements of a table column to the appropriate null value for the column
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.
  
  This routine support COMPLEX and DOUBLE COMPLEX binary table columns, and
  sets both the real and imaginary components of the element to a NaN.
*/
{
    int tcode, maxelem, hdutype, writemode = 2, leng;
    short i2null;
    INT32BIT i4null;
    long twidth, incre;
    LONGLONG ii;
    LONGLONG largeelem, nelem, tnull, i8null;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, ntodo;
    double scale, zero;
    unsigned char i1null, lognul = 0;
    char tform[20], *cstring = 0;
    char message[FLEN_ERRMSG];
    char snull[20];   /*  the FITS null value  */
    long   jbuff[2] = { -1, -1};  /* all bits set is equivalent to a NaN */
    size_t buffsize;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    nelem = nelempar;
    
    largeelem = firstelem;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/

    /* note that writemode = 2 by default (not 1), so that the returned */
    /* repeat and incre values will be the actual values for this column. */

    /* If writing nulls to a variable length column then dummy data values  */
    /* must have already been written to the heap. */
    /* We just have to overwrite the previous values with null values. */
    /* Set writemode = 0 in this case, to test that values have been written */

    fits_get_coltype(fptr, colnum, &tcode, NULL, NULL, status);
    if (tcode < 0)
         writemode = 0;  /* this is a variable length column */

    if (abs(tcode) >= TCOMPLEX)
    { /* treat complex columns as pairs of numbers */
      largeelem = (largeelem - 1) * 2 + 1;
      nelem *= 2;
    }

    if (ffgcprll( fptr, colnum, firstrow, largeelem, nelem, writemode, &scale,
       &zero, tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    if (tcode == TSTRING)
    {
      if (snull[0] == ASCII_NULL_UNDEFINED)
      {
        ffpmsg(
        "Null value string for ASCII table column is not defined (FTPCLU).");
        return(*status = NO_NULL);
      }

      /* allocate buffer to hold the null string.  Must write the entire */
      /* width of the column (twidth bytes) to avoid possible problems */
      /* with uninitialized FITS blocks, in case the field spans blocks */

      buffsize = maxvalue(20, twidth);
      cstring = (char *) malloc(buffsize);
      if (!cstring)
         return(*status = MEMORY_ALLOCATION);

      memset(cstring, ' ', buffsize);  /* initialize  with blanks */

      leng = strlen(snull);
      if (hdutype == BINARY_TBL)
         leng++;        /* copy the terminator too in binary tables */

      strncpy(cstring, snull, leng);  /* copy null string to temp buffer */
    }
    else if ( tcode == TBYTE  ||
              tcode == TSHORT ||
              tcode == TLONG  ||
              tcode == TLONGLONG) 
    {
      if (tnull == NULL_UNDEFINED)
      {
        ffpmsg(
        "Null value for integer table column is not defined (FTPCLU).");
        return(*status = NO_NULL);
      }

      if (tcode == TBYTE)
         i1null = (unsigned char) tnull;
      else if (tcode == TSHORT)
      {
         i2null = (short) tnull;
#if BYTESWAPPED
         ffswap2(&i2null, 1); /* reverse order of bytes */
#endif
      }
      else if (tcode == TLONG)
      {
         i4null = (INT32BIT) tnull;
#if BYTESWAPPED
         ffswap4(&i4null, 1); /* reverse order of bytes */
#endif
      }
      else
      {
         i8null = tnull;
#if BYTESWAPPED
         ffswap8((double *)(&i8null), 1);  /* reverse order of bytes */
#endif
      }
    }

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */
    ntodo = remain;           /* number of elements to write at one time */

    while (ntodo)
    {
        /* limit the number of pixels to process at one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = minvalue(ntodo, (repeat - elemnum));
        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TBYTE):
 
                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 1,  &i1null, status);
                break;

            case (TSHORT):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 2, &i2null, status);
                break;

            case (TLONG):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 4, &i4null, status);
                break;

            case (TLONGLONG):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 8, &i8null, status);
                break;

            case (TFLOAT):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 4, jbuff, status);
                break;

            case (TDOUBLE):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 8, jbuff, status);
                break;

            case (TLOGICAL):
 
                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 1, &lognul, status);
                break;

            case (TSTRING):  /* an ASCII table column */
                /* repeat always = 1, so ntodo is also guaranteed to = 1 */
                ffpbyt(fptr, twidth, cstring, status);
                break;

            default:  /*  error trap  */
                sprintf(message, 
                   "Cannot write null value to column %d which has format %s",
                     colnum,tform);
                ffpmsg(message);
                return(*status);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
           sprintf(message,
             "Error writing %.0f thru %.0f of null values (ffpclu).",
              (double) (next+1), (double) (next+ntodo));
           ffpmsg(message);

           if (cstring)
              free(cstring);

           return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
        ntodo = remain;  /* this is the maximum number to do in next loop */

    }  /*  End of main while Loop  */

    if (cstring)
       free(cstring);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcluc( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
            int  *status)    /* IO - error status                           */
/*
  Set elements of a table column to the appropriate null value for the column
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.
  
  This routine does not do anything special in the case of COMPLEX table columns
  (unlike the similar ffpclu routine).  This routine is mainly for use by
  ffpcne which already compensates for the effective doubling of the number of 
  elements in a complex column.
*/
{
    int tcode, maxelem, hdutype, writemode = 2, leng;
    short i2null;
    INT32BIT i4null;
    long twidth, incre;
    LONGLONG ii;
    LONGLONG tnull, i8null;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, ntodo;
    double scale, zero;
    unsigned char i1null, lognul = 0;
    char tform[20], *cstring = 0;
    char message[FLEN_ERRMSG];
    char snull[20];   /*  the FITS null value  */
    long   jbuff[2] = { -1, -1};  /* all bits set is equivalent to a NaN */
    size_t buffsize;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/

    /* note that writemode = 2 by default (not 1), so that the returned */
    /* repeat and incre values will be the actual values for this column. */

    /* If writing nulls to a variable length column then dummy data values  */
    /* must have already been written to the heap. */
    /* We just have to overwrite the previous values with null values. */
    /* Set writemode = 0 in this case, to test that values have been written */

    fits_get_coltype(fptr, colnum, &tcode, NULL, NULL, status);
    if (tcode < 0)
         writemode = 0;  /* this is a variable length column */
    
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, writemode, &scale,
       &zero, tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    if (tcode == TSTRING)
    {
      if (snull[0] == ASCII_NULL_UNDEFINED)
      {
        ffpmsg(
        "Null value string for ASCII table column is not defined (FTPCLU).");
        return(*status = NO_NULL);
      }

      /* allocate buffer to hold the null string.  Must write the entire */
      /* width of the column (twidth bytes) to avoid possible problems */
      /* with uninitialized FITS blocks, in case the field spans blocks */

      buffsize = maxvalue(20, twidth);
      cstring = (char *) malloc(buffsize);
      if (!cstring)
         return(*status = MEMORY_ALLOCATION);

      memset(cstring, ' ', buffsize);  /* initialize  with blanks */

      leng = strlen(snull);
      if (hdutype == BINARY_TBL)
         leng++;        /* copy the terminator too in binary tables */

      strncpy(cstring, snull, leng);  /* copy null string to temp buffer */

    }
    else if ( tcode == TBYTE  ||
              tcode == TSHORT ||
              tcode == TLONG  ||
              tcode == TLONGLONG) 
    {
      if (tnull == NULL_UNDEFINED)
      {
        ffpmsg(
        "Null value for integer table column is not defined (FTPCLU).");
        return(*status = NO_NULL);
      }

      if (tcode == TBYTE)
         i1null = (unsigned char) tnull;
      else if (tcode == TSHORT)
      {
         i2null = (short) tnull;
#if BYTESWAPPED
         ffswap2(&i2null, 1); /* reverse order of bytes */
#endif
      }
      else if (tcode == TLONG)
      {
         i4null = (INT32BIT) tnull;
#if BYTESWAPPED
         ffswap4(&i4null, 1); /* reverse order of bytes */
#endif
      }
      else
      {
         i8null = tnull;
#if BYTESWAPPED
         ffswap4( (INT32BIT*) &i8null, 2); /* reverse order of bytes */
#endif
      }
    }

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */
    ntodo = remain;           /* number of elements to write at one time */

    while (ntodo)
    {
        /* limit the number of pixels to process at one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = minvalue(ntodo, (repeat - elemnum));
        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TBYTE):
 
                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 1,  &i1null, status);
                break;

            case (TSHORT):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 2, &i2null, status);
                break;

            case (TLONG):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 4, &i4null, status);
                break;

            case (TLONGLONG):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 8, &i8null, status);
                break;

            case (TFLOAT):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 4, jbuff, status);
                break;

            case (TDOUBLE):

                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 8, jbuff, status);
                break;

            case (TLOGICAL):
 
                for (ii = 0; ii < ntodo; ii++)
                  ffpbyt(fptr, 1, &lognul, status);
                break;

            case (TSTRING):  /* an ASCII table column */
                /* repeat always = 1, so ntodo is also guaranteed to = 1 */
                ffpbyt(fptr, twidth, cstring, status);
                break;

            default:  /*  error trap  */
                sprintf(message, 
                   "Cannot write null value to column %d which has format %s",
                     colnum,tform);
                ffpmsg(message);
                return(*status);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
           sprintf(message,
             "Error writing %.0f thru %.0f of null values (ffpclu).",
              (double) (next+1), (double) (next+ntodo));
           ffpmsg(message);

           if (cstring)
              free(cstring);

           return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
        ntodo = remain;  /* this is the maximum number to do in next loop */

    }  /*  End of main while Loop  */

    if (cstring)
       free(cstring);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffprwu(fitsfile *fptr,
           LONGLONG firstrow,
           LONGLONG nrows, 
           int *status)

/* 
 * fits_write_nullrows / ffprwu - write TNULLs to all columns in one or more rows
 *
 * fitsfile *fptr - pointer to FITS HDU opened for read/write
 * long int firstrow - first table row to set to null. (firstrow >= 1)
 * long int nrows - total number or rows to set to null. (nrows >= 1)
 * int *status - upon return, *status contains CFITSIO status code
 *
 * RETURNS: CFITSIO status code
 *
 * written by Craig Markwardt, GSFC 
 */
{
  LONGLONG ntotrows;
  int ncols, i;
  int typecode = 0;
  LONGLONG repeat = 0, width = 0;
  int nullstatus;

  if (*status > 0) return *status;

  if ((firstrow <= 0) || (nrows <= 0)) return (*status = BAD_ROW_NUM);

  fits_get_num_rowsll(fptr, &ntotrows, status);

  if (firstrow + nrows - 1 > ntotrows) return (*status = BAD_ROW_NUM);
  
  fits_get_num_cols(fptr, &ncols, status);
  if (*status) return *status;


  /* Loop through each column and write nulls */
  for (i=1; i <= ncols; i++) {
    repeat = 0;  typecode = 0;  width = 0;
    fits_get_coltypell(fptr, i, &typecode, &repeat, &width, status);
    if (*status) break;

    /* NOTE: data of TSTRING type must not write the total repeat
       count, since the repeat count is the *character* count, not the
       nstring count.  Divide by string width to get number of
       strings. */
    
    if (typecode == TSTRING) repeat /= width;

    /* Write NULLs */
    nullstatus = 0;
    fits_write_col_null(fptr, i, firstrow, 1, repeat*nrows, &nullstatus);

    /* ignore error if no null value is defined for the column */
    if (nullstatus && nullstatus != NO_NULL) return (*status = nullstatus);
    
  }
    
  return *status;
}

healpy-1.10.3/cfitsio/putcolui.c0000664000175000017500000010275513010375005017002 0ustar  zoncazonca00000000000000/*  This file, putcolui.c, contains routines that write data elements to    */
/*  a FITS image or table, with unsigned short datatype.                            */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffpprui(fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write (1 = 1st group)          */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned short *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    unsigned short nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TUSHORT, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpclui(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnui(fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned short *array,    /* I - array of values that are written        */
   unsigned short nulval,    /* I - undefined pixel value                   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    unsigned short nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TUSHORT, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcnui(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2dui(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
  unsigned short *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3dui(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3dui(fitsfile *fptr,   /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
  unsigned short *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TUSHORT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpclui(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpclui(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssui(fitsfile *fptr,   /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
  unsigned short *array,     /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TUSHORT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpclui(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpui( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
   unsigned short *array,     /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpclui(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclui( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned short *array,    /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table with
  2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem, hdutype;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TSHORT):

              ffu2fi2(&array[next], ntodo, scale, zero,
                      (short *) buffer, status);
              ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
              break;

            case (TLONGLONG):

                ffu2fi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TBYTE):
 
                ffu2fi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TLONG):

                ffu2fi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TFLOAT):

                ffu2fr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffu2fr8(&array[next], ntodo, scale, zero,
                        (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffu2fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);


                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                    "Cannot write numbers to column %d which has format %s",
                      colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
         sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpclui).",
             (double) (next+1), (double) (next+ntodo));
         ffpmsg(message);
         return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
       ffpmsg(
       "Numerical overflow during type conversion while writing FITS data.");
       *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnui(fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned short *array,    /* I - array of values to write                */
   unsigned short  nulvalue, /* I - value used to flag undefined pixels     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpclui(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpclui(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpclui(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu2fi1(unsigned short *input, /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] > UCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = ((double) input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu2fi2(unsigned short *input, /* I - array of values to be converted */
            long ntodo,         /* I - number of elements in the array  */
            double scale,       /* I - FITS TSCALn or BSCALE value      */
            double zero,        /* I - FITS TZEROn or BZERO  value      */
            short *output,      /* O - output array of converted values */
            int *status)        /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 32768.)
    {
        /* Instead of subtracting 32768, it is more efficient */
        /* to just flip the sign bit with the XOR operator */

        for (ii = 0; ii < ntodo; ii++)
             output[ii] =  ( *(short *) &input[ii] ) ^ 0x8000;
    }
    else if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] > SHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
                output[ii] = input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = ((double) input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu2fi4(unsigned short *input, /* I - array of values to be converted */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (INT32BIT) input[ii];   /* copy input to output */
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = ((double) input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu2fi8(unsigned short *input,  /* I - array of values to be converted  */
            long ntodo,             /* I - number of elements in the array  */
            double scale,           /* I - FITS TSCALn or BSCALE value      */
            double zero,            /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,       /* O - output array of converted values */
            int *status)            /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu2fr4(unsigned short *input, /* I - array of values to be converted */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) (((double) input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu2fr8(unsigned short *input, /* I - array of values to be converted */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = ((double) input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu2fstr(unsigned short *input, /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;
    
    cptr = output;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = ((double) input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putcoluj.c0000664000175000017500000010316513010375005016777 0ustar  zoncazonca00000000000000/*  This file, putcoluj.c, contains routines that write data elements to   */
/*  a FITS image or table, with unsigned long datatype.                             */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffppruj( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned long  *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    unsigned long nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TULONG, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcluj(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnuj( fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned long  *array,    /* I - array of values that are written        */
   unsigned long  nulval,    /* I - undefined pixel value                   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    unsigned long nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TULONG, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcnuj(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2duj(fitsfile *fptr,   /* I - FITS file pointer                    */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
  unsigned long  *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3duj(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3duj(fitsfile *fptr,   /* I - FITS file pointer                    */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
  unsigned long  *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TULONG, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpcluj(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpcluj(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssuj(fitsfile *fptr,   /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
  unsigned long *array,      /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TULONG, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpcluj(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpuj( fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
   unsigned long  *array,     /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpcluj(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcluj( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned long  *array,    /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem, hdutype;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TLONG):

                ffu4fi4(&array[next], ntodo, scale, zero,
                      (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TLONGLONG):

                ffu4fi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TBYTE):
 
                ffu4fi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TSHORT):

                ffu4fi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TFLOAT):

                ffu4fr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffu4fr8(&array[next], ntodo, scale, zero,
                       (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffu4fstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                     "Cannot write numbers to column %d which has format %s",
                      colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpcluj).",
              (double) (next+1), (double) (next+ntodo));
          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while writing FITS data.");
        *status = NUM_OVERFLOW;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnuj( fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned long  *array,    /* I - array of values to write                */
   unsigned long   nulvalue, /* I - value used to flag undefined pixels     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpcluj(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpcluj(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpcluj(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu4fi1(unsigned long *input,  /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] > UCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu4fi2(unsigned long *input, /* I - array of values to be converted */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            short *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] > SHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
                output[ii] = (short) input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu4fi4(unsigned long *input, /* I - array of values to be converted */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 2147483648. && sizeof(long) == 4)
    {       
        /* Instead of subtracting 2147483648, it is more efficient */
        /* to just flip the sign bit with the XOR operator */

        for (ii = 0; ii < ntodo; ii++)
             output[ii] =  ( *(long *) &input[ii] ) ^ 0x80000000;
    }
    else if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] > INT32_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
                output[ii] = input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu4fi8(unsigned long *input,  /* I - array of values to be converted  */
            long ntodo,             /* I - number of elements in the array  */
            double scale,           /* I - FITS TSCALn or BSCALE value      */
            double zero,            /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,       /* O - output array of converted values */
            int *status)            /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu4fr4(unsigned long *input, /* I - array of values to be converted */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) ((input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu4fr8(unsigned long *input, /* I - array of values to be converted */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffu4fstr(unsigned long *input, /* I - array of values to be converted */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;
    
    cptr = output;


    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = (input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putcoluk.c0000664000175000017500000010442313010375005016776 0ustar  zoncazonca00000000000000/*  This file, putcolk.c, contains routines that write data elements to    */
/*  a FITS image or table, with 'unsigned int' datatype.                   */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffppruk(fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned int   *array,    /* I - array of values that are written        */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;
    unsigned int nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_pixels(fptr, TUINT, firstelem, nelem,
            0, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcluk(fptr, 2, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffppnuk(fitsfile *fptr,  /* I - FITS file pointer                       */
            long  group,     /* I - group to write(1 = 1st group)           */
            LONGLONG  firstelem, /* I - first vector element to write(1 = 1st)  */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned int   *array,    /* I - array of values that are written        */
   unsigned int   nulval,    /* I - undefined pixel value                   */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).  Any array values
  that are equal to the value of nulval will be replaced with the null
  pixel value that is appropriate for this column.
*/
{
    long row;
    unsigned int nullvalue;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        nullvalue = nulval;  /* set local variable */
        fits_write_compressed_pixels(fptr, TUINT, firstelem, nelem,
            1, array, &nullvalue, status);
        return(*status);
    }

    row=maxvalue(1,group);

    ffpcnuk(fptr, 2, row, firstelem, nelem, array, nulval, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp2duk(fitsfile *fptr,  /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
  unsigned int   *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 2-D array of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    /* call the 3D writing routine, with the 3rd dimension = 1 */

    ffp3duk(fptr, group, ncols, naxis2, naxis1, naxis2, 1, array, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffp3duk(fitsfile *fptr,  /* I - FITS file pointer                     */
           long  group,      /* I - group to write(1 = 1st group)         */
           LONGLONG  ncols,      /* I - number of pixels in each row of array */
           LONGLONG  nrows,      /* I - number of rows in each plane of array */
           LONGLONG  naxis1,     /* I - FITS image NAXIS1 value               */
           LONGLONG  naxis2,     /* I - FITS image NAXIS2 value               */
           LONGLONG  naxis3,     /* I - FITS image NAXIS3 value               */
  unsigned int   *array,     /* I - array to be written                   */
           int  *status)     /* IO - error status                         */
/*
  Write an entire 3-D cube of values to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of the
  FITS array is not the same as the array being written).
*/
{
    long tablerow, ii, jj;
    long fpixel[3]= {1,1,1}, lpixel[3];
    LONGLONG nfits, narray;
    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */
           
    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */
        lpixel[0] = (long) ncols;
        lpixel[1] = (long) nrows;
        lpixel[2] = (long) naxis3;
       
        fits_write_compressed_img(fptr, TUINT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    tablerow=maxvalue(1,group);

    if (ncols == naxis1 && nrows == naxis2)  /* arrays have same size? */
    {
      /* all the image pixels are contiguous, so write all at once */
      ffpcluk(fptr, 2, tablerow, 1L, naxis1 * naxis2 * naxis3, array, status);
      return(*status);
    }

    if (ncols < naxis1 || nrows < naxis2)
       return(*status = BAD_DIMEN);

    nfits = 1;   /* next pixel in FITS image to write to */
    narray = 0;  /* next pixel in input array to be written */

    /* loop over naxis3 planes in the data cube */
    for (jj = 0; jj < naxis3; jj++)
    {
      /* loop over the naxis2 rows in the FITS image, */
      /* writing naxis1 pixels to each row            */

      for (ii = 0; ii < naxis2; ii++)
      {
       if (ffpcluk(fptr, 2, tablerow, nfits, naxis1,&array[narray],status) > 0)
         return(*status);

       nfits += naxis1;
       narray += ncols;
      }
      narray += (nrows - naxis2) * ncols;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpssuk(fitsfile *fptr,  /* I - FITS file pointer                       */
           long  group,      /* I - group to write(1 = 1st group)           */
           long  naxis,      /* I - number of data axes in array            */
           long  *naxes,     /* I - size of each FITS axis                  */
           long  *fpixel,    /* I - 1st pixel in each axis to write (1=1st) */
           long  *lpixel,    /* I - last pixel in each axis to write        */
  unsigned int  *array,      /* I - array to be written                     */
           int  *status)     /* IO - error status                           */
/*
  Write a subsection of pixels to the primary array or image.
  A subsection is defined to be any contiguous rectangular
  array of pixels within the n-dimensional FITS data file.
  Data conversion and scaling will be performed if necessary 
  (e.g, if the datatype of the FITS array is not the same as
  the array being written).
*/
{
    long tablerow;
    LONGLONG fpix[7], dimen[7], astart, pstart;
    LONGLONG off2, off3, off4, off5, off6, off7;
    LONGLONG st10, st20, st30, st40, st50, st60, st70;
    LONGLONG st1, st2, st3, st4, st5, st6, st7;
    long ii, i1, i2, i3, i4, i5, i6, i7, irange[7];

    if (*status > 0)
        return(*status);

    if (fits_is_compressed_image(fptr, status))
    {
        /* this is a compressed image in a binary table */

        fits_write_compressed_img(fptr, TUINT, fpixel, lpixel,
            0,  array, NULL, status);
    
        return(*status);
    }

    if (naxis < 1 || naxis > 7)
      return(*status = BAD_DIMEN);

    tablerow=maxvalue(1,group);

     /* calculate the size and number of loops to perform in each dimension */
    for (ii = 0; ii < 7; ii++)
    {
      fpix[ii]=1;
      irange[ii]=1;
      dimen[ii]=1;
    }

    for (ii = 0; ii < naxis; ii++)
    {    
      fpix[ii]=fpixel[ii];
      irange[ii]=lpixel[ii]-fpixel[ii]+1;
      dimen[ii]=naxes[ii];
    }

    i1=irange[0];

    /* compute the pixel offset between each dimension */
    off2 =     dimen[0];
    off3 = off2 * dimen[1];
    off4 = off3 * dimen[2];
    off5 = off4 * dimen[3];
    off6 = off5 * dimen[4];
    off7 = off6 * dimen[5];

    st10 = fpix[0];
    st20 = (fpix[1] - 1) * off2;
    st30 = (fpix[2] - 1) * off3;
    st40 = (fpix[3] - 1) * off4;
    st50 = (fpix[4] - 1) * off5;
    st60 = (fpix[5] - 1) * off6;
    st70 = (fpix[6] - 1) * off7;

    /* store the initial offset in each dimension */
    st1 = st10;
    st2 = st20;
    st3 = st30;
    st4 = st40;
    st5 = st50;
    st6 = st60;
    st7 = st70;

    astart = 0;

    for (i7 = 0; i7 < irange[6]; i7++)
    {
     for (i6 = 0; i6 < irange[5]; i6++)
     {
      for (i5 = 0; i5 < irange[4]; i5++)
      {
       for (i4 = 0; i4 < irange[3]; i4++)
       {
        for (i3 = 0; i3 < irange[2]; i3++)
        {
         pstart = st1 + st2 + st3 + st4 + st5 + st6 + st7;

         for (i2 = 0; i2 < irange[1]; i2++)
         {
           if (ffpcluk(fptr, 2, tablerow, pstart, i1, &array[astart],
              status) > 0)
              return(*status);

           astart += i1;
           pstart += off2;
         }
         st2 = st20;
         st3 = st3+off3;    
        }
        st3 = st30;
        st4 = st4+off4;
       }
       st4 = st40;
       st5 = st5+off5;
      }
      st5 = st50;
      st6 = st6+off6;
     }
     st6 = st60;
     st7 = st7+off7;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpgpuk(fitsfile *fptr,   /* I - FITS file pointer                      */
            long  group,      /* I - group to write(1 = 1st group)          */
            long  firstelem,  /* I - first vector element to write(1 = 1st) */
            long  nelem,      /* I - number of values to write              */
   unsigned int   *array,     /* I - array of values that are written       */
            int  *status)     /* IO - error status                          */
/*
  Write an array of group parameters to the primary array. Data conversion
  and scaling will be performed if necessary (e.g, if the datatype of
  the FITS array is not the same as the array being written).
*/
{
    long row;

    /*
      the primary array is represented as a binary table:
      each group of the primary array is a row in the table,
      where the first column contains the group parameters
      and the second column contains the image itself.
    */

    row=maxvalue(1,group);

    ffpcluk(fptr, 1L, row, firstelem, nelem, array, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcluk(fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned int   *array,    /* I - array of values to write                */
            int  *status)    /* IO - error status                           */
/*
  Write an array of values to a column in the current FITS HDU.
  The column number may refer to a real column in an ASCII or binary table, 
  or it may refer to a virtual column in a 1 or more grouped FITS primary
  array.  FITSIO treats a primary array as a binary table
  with 2 vector columns: the first column contains the group parameters (often
  with length = 0) and the second column contains the array of image pixels.
  Each row of the table represents a group in the case of multigroup FITS
  images.

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary.
*/
{
    int tcode, maxelem, hdutype;
    long twidth, incre;
    long ntodo;
    LONGLONG repeat, startpos, elemnum, wrtptr, rowlen, rownum, remain, next, tnull;
    double scale, zero;
    char tform[20], cform[20];
    char message[FLEN_ERRMSG];

    char snull[20];   /*  the FITS null value  */

    double cbuff[DBUFFSIZE / sizeof(double)]; /* align cbuff on word boundary */
    void *buffer;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* call the 'short' or 'long' version of this routine, if possible */
    if (sizeof(int) == sizeof(short))
        ffpclui(fptr, colnum, firstrow, firstelem, nelem, 
              (unsigned short *) array, status);
    else if (sizeof(int) == sizeof(long))
        ffpcluj(fptr, colnum, firstrow, firstelem, nelem, 
              (unsigned long *) array, status);
    else
    {
    /*
      This is a special case: sizeof(int) is not equal to sizeof(short) or
      sizeof(long).  This occurs on Alpha OSF systems where short = 2 bytes,
      int = 4 bytes, and long = 8 bytes.
    */

    buffer = cbuff;

    /*---------------------------------------------------*/
    /*  Check input and get parameters about the column: */
    /*---------------------------------------------------*/
    if (ffgcprll( fptr, colnum, firstrow, firstelem, nelem, 1, &scale, &zero,
        tform, &twidth, &tcode, &maxelem, &startpos,  &elemnum, &incre,
        &repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
        return(*status);

    if (tcode == TSTRING)   
         ffcfmt(tform, cform);     /* derive C format for writing strings */

    /*---------------------------------------------------------------------*/
    /*  Now write the pixels to the FITS column.                           */
    /*  First call the ffXXfYY routine to  (1) convert the datatype        */
    /*  if necessary, and (2) scale the values by the FITS TSCALn and      */
    /*  TZEROn linear scaling parameters into a temporary buffer.          */
    /*---------------------------------------------------------------------*/
    remain = nelem;           /* remaining number of values to write  */
    next = 0;                 /* next element in array to be written  */
    rownum = 0;               /* row number, relative to firstrow     */

    while (remain)
    {
        /* limit the number of pixels to process a one time to the number that
           will fit in the buffer space or to the number of pixels that remain
           in the current vector, which ever is smaller.
        */
        ntodo = (long) minvalue(remain, maxelem);      
        ntodo = (long) minvalue(ntodo, (repeat - elemnum));

        wrtptr = startpos + ((LONGLONG)rownum * rowlen) + (elemnum * incre);

        ffmbyt(fptr, wrtptr, IGNORE_EOF, status); /* move to write position */

        switch (tcode) 
        {
            case (TLONG):
                /* convert the raw data before writing to FITS file */
                ffuintfi4(&array[next], ntodo, scale, zero,
                        (INT32BIT *) buffer, status);
                ffpi4b(fptr, ntodo, incre, (INT32BIT *) buffer, status);
                break;

            case (TLONGLONG):

                ffuintfi8(&array[next], ntodo, scale, zero,
                        (LONGLONG *) buffer, status);
                ffpi8b(fptr, ntodo, incre, (long *) buffer, status);
                break;

            case (TBYTE):
 
                ffuintfi1(&array[next], ntodo, scale, zero,
                        (unsigned char *) buffer, status);
                ffpi1b(fptr, ntodo, incre, (unsigned char *) buffer, status);
                break;

            case (TSHORT):

                ffuintfi2(&array[next], ntodo, scale, zero,
                        (short *) buffer, status);
                ffpi2b(fptr, ntodo, incre, (short *) buffer, status);
                break;

            case (TFLOAT):

                ffuintfr4(&array[next], ntodo, scale, zero,
                        (float *) buffer, status);
                ffpr4b(fptr, ntodo, incre, (float *) buffer, status);
                break;

            case (TDOUBLE):
                ffuintfr8(&array[next], ntodo, scale, zero,
                       (double *) buffer, status);
                ffpr8b(fptr, ntodo, incre, (double *) buffer, status);
                break;

            case (TSTRING):  /* numerical column in an ASCII table */

                if (cform[1] != 's')  /*  "%s" format is a string */
                {
                  ffuintfstr(&array[next], ntodo, scale, zero, cform,
                          twidth, (char *) buffer, status);

                  if (incre == twidth)    /* contiguous bytes */
                     ffpbyt(fptr, ntodo * twidth, buffer, status);
                  else
                     ffpbytoff(fptr, twidth, ntodo, incre - twidth, buffer,
                            status);

                  break;
                }
                /* can't write to string column, so fall thru to default: */

            default:  /*  error trap  */
                sprintf(message, 
                     "Cannot write numbers to column %d which has format %s",
                      colnum,tform);
                ffpmsg(message);
                if (hdutype == ASCII_TBL)
                    return(*status = BAD_ATABLE_FORMAT);
                else
                    return(*status = BAD_BTABLE_FORMAT);

        } /* End of switch block */

        /*-------------------------*/
        /*  Check for fatal error  */
        /*-------------------------*/
        if (*status > 0)  /* test for error during previous write operation */
        {
          sprintf(message,
          "Error writing elements %.0f thru %.0f of input data array (ffpcluk).",
              (double) (next+1), (double) (next+ntodo));
          ffpmsg(message);
          return(*status);
        }

        /*--------------------------------------------*/
        /*  increment the counters for the next loop  */
        /*--------------------------------------------*/
        remain -= ntodo;
        if (remain)
        {
            next += ntodo;
            elemnum += ntodo;
            if (elemnum == repeat)  /* completed a row; start on next row */
            {
                elemnum = 0;
                rownum++;
            }
        }
    }  /*  End of main while Loop  */


    /*--------------------------------*/
    /*  check for numerical overflow  */
    /*--------------------------------*/
    if (*status == OVERFLOW_ERR)
    {
        ffpmsg(
        "Numerical overflow during type conversion while writing FITS data.");
        *status = NUM_OVERFLOW;
    }

    }   /* end of Dec ALPHA special case */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpcnuk(fitsfile *fptr,  /* I - FITS file pointer                       */
            int  colnum,     /* I - number of column to write (1 = 1st col) */
            LONGLONG  firstrow,  /* I - first row to write (1 = 1st row)        */
            LONGLONG  firstelem, /* I - first vector element to write (1 = 1st) */
            LONGLONG  nelem,     /* I - number of values to write               */
   unsigned int   *array,    /* I - array of values to write                */
   unsigned int    nulvalue, /* I - value used to flag undefined pixels     */
            int  *status)    /* IO - error status                           */
/*
  Write an array of elements to the specified column of a table.  Any input
  pixels equal to the value of nulvalue will be replaced by the appropriate
  null value in the output FITS file. 

  The input array of values will be converted to the datatype of the column 
  and will be inverse-scaled by the FITS TSCALn and TZEROn values if necessary
*/
{
    tcolumn *colptr;
    LONGLONG  ngood = 0, nbad = 0, ii;
    LONGLONG repeat, first, fstelm, fstrow;
    int tcode, overflow = 0;

    if (*status > 0)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
    {
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    }
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
    {
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);
    }

    colptr  = (fptr->Fptr)->tableptr;   /* point to first column */
    colptr += (colnum - 1);     /* offset to correct column structure */

    tcode  = colptr->tdatatype;

    if (tcode > 0)
       repeat = colptr->trepeat;  /* repeat count for this column */
    else
       repeat = firstelem -1 + nelem;  /* variable length arrays */

    /* if variable length array, first write the whole input vector, 
       then go back and fill in the nulls */
    if (tcode < 0) {
      if (ffpcluk(fptr, colnum, firstrow, firstelem, nelem, array, status) > 0) {
        if (*status == NUM_OVERFLOW) 
	{
	  /* ignore overflows, which are possibly the null pixel values */
	  /*  overflow = 1;   */
	  *status = 0;
	} else { 
          return(*status);
	}
      }
    }

    /* absolute element number in the column */
    first = (firstrow - 1) * repeat + firstelem;

    for (ii = 0; ii < nelem; ii++)
    {
      if (array[ii] != nulvalue)  /* is this a good pixel? */
      {
         if (nbad)  /* write previous string of bad pixels */
         {
            fstelm = ii - nbad + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (ffpclu(fptr, colnum, fstrow, fstelm, nbad, status) > 0)
                return(*status);

            nbad=0;
         }

         ngood = ngood +1;  /* the consecutive number of good pixels */
      }
      else
      {
         if (ngood)  /* write previous string of good pixels */
         {
            fstelm = ii - ngood + first;  /* absolute element number */
            fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
            fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

            if (tcode > 0) {  /* variable length arrays have already been written */
              if (ffpcluk(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood],
                status) > 0) {
		if (*status == NUM_OVERFLOW) 
		{
		  overflow = 1;
		  *status = 0;
		} else { 
                  return(*status);
		}
	      }
	    }
            ngood=0;
         }

         nbad = nbad +1;  /* the consecutive number of bad pixels */
      }
    }

    /* finished loop;  now just write the last set of pixels */

    if (ngood)  /* write last string of good pixels */
    {
      fstelm = ii - ngood + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      if (tcode > 0) {  /* variable length arrays have already been written */
        ffpcluk(fptr, colnum, fstrow, fstelm, ngood, &array[ii-ngood], status);
      }
    }
    else if (nbad) /* write last string of bad pixels */
    {
      fstelm = ii - nbad + first;  /* absolute element number */
      fstrow = (fstelm - 1) / repeat + 1;  /* starting row number */
      fstelm = fstelm - (fstrow - 1) * repeat;  /* relative number */

      ffpclu(fptr, colnum, fstrow, fstelm, nbad, status);
    }

    if (*status <= 0) {
      if (overflow) {
        *status = NUM_OVERFLOW;
      }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffuintfi1(unsigned int *input, /* I - array of values to be converted  */
            long ntodo,            /* I - number of elements in the array  */
            double scale,          /* I - FITS TSCALn or BSCALE value      */
            double zero,           /* I - FITS TZEROn or BZERO  value      */
            unsigned char *output, /* O - output array of converted values */
            int *status)           /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] > UCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DUCHAR_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = 0;
            }
            else if (dvalue > DUCHAR_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = UCHAR_MAX;
            }
            else
                output[ii] = (unsigned char) (dvalue + .5);
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffuintfi2(unsigned int *input,  /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            short *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] > SHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
                output[ii] = input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DSHRT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MIN;
            }
            else if (dvalue > DSHRT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = SHRT_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (short) (dvalue + .5);
                else
                    output[ii] = (short) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffuintfi4(unsigned int *input,  /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            INT32BIT *output,  /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 2147483648.)
    {       
        /* Instead of subtracting 2147483648, it is more efficient */
        /* to just flip the sign bit with the XOR operator */

        for (ii = 0; ii < ntodo; ii++)
             output[ii] =  ( *(int *) &input[ii] ) ^ 0x80000000;
    }
    else if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
            if (input[ii] > INT32_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
                output[ii] = input[ii];
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DINT_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MIN;
            }
            else if (dvalue > DINT_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = INT32_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (INT32BIT) (dvalue + .5);
                else
                    output[ii] = (INT32BIT) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffuintfi8(unsigned int *input,  /* I - array of values to be converted  */
            long ntodo,             /* I - number of elements in the array  */
            double scale,           /* I - FITS TSCALn or BSCALE value      */
            double zero,            /* I - FITS TZEROn or BZERO  value      */
            LONGLONG *output,       /* O - output array of converted values */
            int *status)            /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required
*/
{
    long ii;
    double dvalue;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
            dvalue = (input[ii] - zero) / scale;

            if (dvalue < DLONGLONG_MIN)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MIN;
            }
            else if (dvalue > DLONGLONG_MAX)
            {
                *status = OVERFLOW_ERR;
                output[ii] = LONGLONG_MAX;
            }
            else
            {
                if (dvalue >= 0)
                    output[ii] = (LONGLONG) (dvalue + .5);
                else
                    output[ii] = (LONGLONG) (dvalue - .5);
            }
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffuintfr4(unsigned int *input,  /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            float *output,     /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (float) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (float) ((input[ii] - zero) / scale);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffuintfr8(unsigned int *input,  /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            double *output,    /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do datatype conversion and scaling if required.
*/
{
    long ii;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
                output[ii] = (double) input[ii];
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
            output[ii] = (input[ii] - zero) / scale;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffuintfstr(unsigned int *input, /* I - array of values to be converted  */
            long ntodo,        /* I - number of elements in the array  */
            double scale,      /* I - FITS TSCALn or BSCALE value      */
            double zero,       /* I - FITS TZEROn or BZERO  value      */
            char *cform,       /* I - format for output string values  */
            long twidth,       /* I - width of each field, in chars    */
            char *output,      /* O - output array of converted values */
            int *status)       /* IO - error status                    */
/*
  Copy input to output prior to writing output to a FITS file.
  Do scaling if required.
*/
{
    long ii;
    double dvalue;
    char *cptr;
    
    cptr = output;

    if (scale == 1. && zero == 0.)
    {       
        for (ii = 0; ii < ntodo; ii++)
        {
           sprintf(output, cform, (double) input[ii]);
           output += twidth;

           if (*output)  /* if this char != \0, then overflow occurred */
              *status = OVERFLOW_ERR;
        }
    }
    else
    {
        for (ii = 0; ii < ntodo; ii++)
        {
          dvalue = (input[ii] - zero) / scale;
          sprintf(output, cform, dvalue);
          output += twidth;

          if (*output)  /* if this char != \0, then overflow occurred */
            *status = OVERFLOW_ERR;
        }
    }

    /* replace any commas with periods (e.g., in French locale) */
    while ((cptr = strchr(cptr, ','))) *cptr = '.';
    
    return(*status);
}
healpy-1.10.3/cfitsio/putkey.c0000664000175000017500000032176013010375005016456 0ustar  zoncazonca00000000000000/*  This file, putkey.c, contains routines that write keywords to          */
/*  a FITS header.                                                         */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include 
#include 
#include 
/* stddef.h is apparently needed to define size_t */
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int ffcrim(fitsfile *fptr,      /* I - FITS file pointer           */
           int bitpix,          /* I - bits per pixel              */
           int naxis,           /* I - number of axes in the array */
           long *naxes,         /* I - size of each axis           */
           int *status)         /* IO - error status               */
/*
  create an IMAGE extension following the current HDU. If the
  current HDU is empty (contains no header keywords), then simply
  write the required image (or primary array) keywords to the current
  HDU. 
*/
{
    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* create new extension if current header is not empty */
    if ((fptr->Fptr)->headend != (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
        ffcrhd(fptr, status);

    /* write the required header keywords */
    ffphpr(fptr, TRUE, bitpix, naxis, naxes, 0, 1, TRUE, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffcrimll(fitsfile *fptr,    /* I - FITS file pointer           */
           int bitpix,          /* I - bits per pixel              */
           int naxis,           /* I - number of axes in the array */
           LONGLONG *naxes,     /* I - size of each axis           */
           int *status)         /* IO - error status               */
/*
  create an IMAGE extension following the current HDU. If the
  current HDU is empty (contains no header keywords), then simply
  write the required image (or primary array) keywords to the current
  HDU. 
*/
{
    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* create new extension if current header is not empty */
    if ((fptr->Fptr)->headend != (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
        ffcrhd(fptr, status);

    /* write the required header keywords */
    ffphprll(fptr, TRUE, bitpix, naxis, naxes, 0, 1, TRUE, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffcrtb(fitsfile *fptr,  /* I - FITS file pointer                        */
           int tbltype,     /* I - type of table to create                  */
           LONGLONG naxis2, /* I - number of rows in the table              */
           int tfields,     /* I - number of columns in the table           */
           char **ttype,    /* I - name of each column                      */
           char **tform,    /* I - value of TFORMn keyword for each column  */
           char **tunit,    /* I - value of TUNITn keyword for each column  */
           const char *extnm, /* I - value of EXTNAME keyword, if any         */
           int *status)     /* IO - error status                            */
/*
  Create a table extension in a FITS file. 
*/
{
    LONGLONG naxis1 = 0;
    long *tbcol = 0;

    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    /* create new extension if current header is not empty */
    if ((fptr->Fptr)->headend != (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
        ffcrhd(fptr, status);

    if ((fptr->Fptr)->curhdu == 0)  /* have to create dummy primary array */
    {
       ffcrim(fptr, 16, 0, tbcol, status);
       ffcrhd(fptr, status);
    }
    
    if (tbltype == BINARY_TBL)
    {
      /* write the required header keywords. This will write PCOUNT = 0 */
      ffphbn(fptr, naxis2, tfields, ttype, tform, tunit, extnm, 0, status);
    }
    else if (tbltype == ASCII_TBL)
    {
      /* write the required header keywords */
      /* default values for naxis1 and tbcol will be calculated */
      ffphtb(fptr, naxis1, naxis2, tfields, ttype, tbcol, tform, tunit,
             extnm, status);
    }
    else
      *status = NOT_TABLE;

    return(*status);
}
/*-------------------------------------------------------------------------*/
int ffpktp(fitsfile *fptr,       /* I - FITS file pointer       */
           const char *filename, /* I - name of template file   */
           int *status)          /* IO - error status           */
/*
  read keywords from template file and append to the FITS file
*/
{
    FILE *diskfile;
    char card[FLEN_CARD], template[161];
    char keyname[FLEN_KEYWORD], newname[FLEN_KEYWORD];
    int keytype;
    size_t slen;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    diskfile = fopen(filename,"r"); 
    if (!diskfile)          /* couldn't open file */
    {
            ffpmsg("ffpktp could not open the following template file:");
            ffpmsg(filename);
            return(*status = FILE_NOT_OPENED); 
    }

    while (fgets(template, 160, diskfile) )  /* get next template line */
    {
      template[160] = '\0';      /* make sure string is terminated */
      slen = strlen(template);   /* get string length */
      template[slen - 1] = '\0';  /* over write the 'newline' char */

      if (ffgthd(template, card, &keytype, status) > 0) /* parse template */
         break;

      strncpy(keyname, card, 8);
      keyname[8] = '\0';

      if (keytype == -2)            /* rename the card */
      {
         strncpy(newname, &card[40], 8);
         newname[8] = '\0';

         ffmnam(fptr, keyname, newname, status); 
      }
      else if (keytype == -1)      /* delete the card */
      {
         ffdkey(fptr, keyname, status);
      }
      else if (keytype == 0)       /* update the card */
      {
         ffucrd(fptr, keyname, card, status);
      }
      else if (keytype == 1)      /* append the card */
      {
         ffprec(fptr, card, status);
      }
      else    /* END card; stop here */
      {
         break; 
      }
    }

    fclose(diskfile);   /* close the template file */
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpky( fitsfile *fptr,     /* I - FITS file pointer        */
           int  datatype,      /* I - datatype of the value    */
           const char *keyname,/* I - name of keyword to write */
           void *value,        /* I - keyword value            */
           const char *comm,   /* I - keyword comment          */
           int  *status)       /* IO - error status            */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes a keyword value with the datatype specified by the 2nd argument.
*/
{
    char errmsg[81];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (datatype == TSTRING)
    {
        ffpkys(fptr, keyname, (char *) value, comm, status);
    }
    else if (datatype == TBYTE)
    {
        ffpkyj(fptr, keyname, (LONGLONG) *(unsigned char *) value, comm, status);
    }
    else if (datatype == TSBYTE)
    {
        ffpkyj(fptr, keyname, (LONGLONG) *(signed char *) value, comm, status);
    }
    else if (datatype == TUSHORT)
    {
        ffpkyj(fptr, keyname, (LONGLONG) *(unsigned short *) value, comm, status);
    }
    else if (datatype == TSHORT)
    {
        ffpkyj(fptr, keyname, (LONGLONG) *(short *) value, comm, status);
    }
    else if (datatype == TUINT)
    {
        ffpkyg(fptr, keyname, (double) *(unsigned int *) value, 0,
               comm, status);
    }
    else if (datatype == TINT)
    {
        ffpkyj(fptr, keyname, (LONGLONG) *(int *) value, comm, status);
    }
    else if (datatype == TLOGICAL)
    {
        ffpkyl(fptr, keyname, *(int *) value, comm, status);
    }
    else if (datatype == TULONG)
    {
        ffpkyg(fptr, keyname, (double) *(unsigned long *) value, 0,
               comm, status);
    }
    else if (datatype == TLONG)
    {
        ffpkyj(fptr, keyname, (LONGLONG) *(long *) value, comm, status);
    }
    else if (datatype == TLONGLONG)
    {
        ffpkyj(fptr, keyname, *(LONGLONG *) value, comm, status);
    }
    else if (datatype == TFLOAT)
    {
        ffpkye(fptr, keyname, *(float *) value, -7, comm, status);
    }
    else if (datatype == TDOUBLE)
    {
        ffpkyd(fptr, keyname, *(double *) value, -15, comm, status);
    }
    else if (datatype == TCOMPLEX)
    {
        ffpkyc(fptr, keyname, (float *) value, -7, comm, status);
    }
    else if (datatype == TDBLCOMPLEX)
    {
        ffpkym(fptr, keyname, (double *) value, -15, comm, status);
    }
    else
    {
        sprintf(errmsg, "Bad keyword datatype code: %d (ffpky)", datatype);
        ffpmsg(errmsg);
        *status = BAD_DATATYPE;
    }

    return(*status);
} 
/*-------------------------------------------------------------------------*/
int ffprec(fitsfile *fptr,     /* I - FITS file pointer        */
           const char *card,   /* I - string to be written     */
           int *status)        /* IO - error status            */
/*
  write a keyword record (80 bytes long) to the end of the header
*/
{
    char tcard[FLEN_CARD];
    size_t len, ii;
    long nblocks;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if ( ((fptr->Fptr)->datastart - (fptr->Fptr)->headend) == 80) /* no room */
    {
        nblocks = 1;
        if (ffiblk(fptr, nblocks, 0, status) > 0) /* insert 2880-byte block */
            return(*status);  
    }

    strncpy(tcard,card,80);
    tcard[80] = '\0';

    len = strlen(tcard);

    /* silently replace any illegal characters with a space */
    for (ii=0; ii < len; ii++)   
        if (tcard[ii] < ' ' || tcard[ii] > 126) tcard[ii] = ' ';

    for (ii=len; ii < 80; ii++)    /* fill card with spaces if necessary */
        tcard[ii] = ' ';

    for (ii=0; ii < 8; ii++)       /* make sure keyword name is uppercase */
        tcard[ii] = toupper(tcard[ii]);

    fftkey(tcard, status);        /* test keyword name contains legal chars */

/*  no need to do this any more, since any illegal characters have been removed
    fftrec(tcard, status);  */        /* test rest of keyword for legal chars */

    ffmbyt(fptr, (fptr->Fptr)->headend, IGNORE_EOF, status); /* move to end */

    ffpbyt(fptr, 80, tcard, status);   /* write the 80 byte card */

    if (*status <= 0)
       (fptr->Fptr)->headend += 80;    /* update end-of-header position */

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkyu( fitsfile *fptr,     /* I - FITS file pointer        */
            const char *keyname,/* I - name of keyword to write */
            const char *comm,   /* I - keyword comment          */
            int  *status)       /* IO - error status            */
/*
  Write (put) a null-valued keyword and comment into the FITS header.  
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring," ");  /* create a dummy value string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword */
    ffprec(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkys( fitsfile *fptr,     /* I - FITS file pointer        */
            const char *keyname,/* I - name of keyword to write */
            const char *value,  /* I - keyword value            */
            const char *comm,   /* I - keyword comment          */
            int  *status)       /* IO - error status            */
/*
  Write (put) the keyword, value and comment into the FITS header.
  The value string will be truncated at 68 characters which is the
  maximum length that will fit on a single FITS keyword.
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffs2c(value, valstring, status);   /* put quotes around the string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword */
    ffprec(fptr, card, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkls( fitsfile *fptr,     /* I - FITS file pointer        */
            const char *keyname,/* I - name of keyword to write */
            const char *value,  /* I - keyword value            */
            const char *comm,   /* I - keyword comment          */
            int  *status)       /* IO - error status            */
/*
  Write (put) the keyword, value and comment into the FITS header.
  This routine is a modified version of ffpkys which supports the
  HEASARC long string convention and can write arbitrarily long string
  keyword values.  The value is continued over multiple keywords that
  have the name COMTINUE without an equal sign in column 9 of the card.
  This routine also supports simple string keywords which are less than
  69 characters in length.
*/
{
    char valstring[FLEN_CARD];
    char card[FLEN_CARD], tmpkeyname[FLEN_CARD];
    char tstring[FLEN_CARD], *cptr;
    int next, remain, vlen, nquote, nchar, namelen, contin, tstatus = -1;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    remain = maxvalue(strlen(value), 1); /* no. of chars to write (at least 1) */    
    /* count the number of single quote characters are in the string */
    tstring[0] = '\0';
    strncat(tstring, value, 68); /* copy 1st part of string to temp buff */
    nquote = 0;
    cptr = strchr(tstring, '\'');   /* search for quote character */
    while (cptr)  /* search for quote character */
    {
        nquote++;            /*  increment no. of quote characters  */
        cptr++;              /*  increment pointer to next character */
        cptr = strchr(cptr, '\'');  /* search for another quote char */
    }

    strncpy(tmpkeyname, keyname, 80);
    tmpkeyname[80] = '\0';
    
    cptr = tmpkeyname;
    while(*cptr == ' ')   /* skip over leading spaces in name */
        cptr++;

    /* determine the number of characters that will fit on the line */
    /* Note: each quote character is expanded to 2 quotes */

    namelen = strlen(cptr);
    if (namelen <= 8 && (fftkey(cptr, &tstatus) <= 0) )
    {
        /* This a normal 8-character FITS keyword */
        nchar = 68 - nquote; /*  max of 68 chars fit in a FITS string value */
    }
    else
    {
        /* This a HIERARCH keyword */
        if (FSTRNCMP(cptr, "HIERARCH ", 9) && 
            FSTRNCMP(cptr, "hierarch ", 9))
            nchar = 66 - nquote - namelen;
        else
            nchar = 75 - nquote - namelen;  /* don't count 'HIERARCH' twice */

    }

    contin = 0;
    next = 0;                  /* pointer to next character to write */

    while (remain > 0)
    {
        tstring[0] = '\0';
        strncat(tstring, &value[next], nchar); /* copy string to temp buff */
        ffs2c(tstring, valstring, status);  /* put quotes around the string */

        if (remain > nchar)   /* if string is continued, put & as last char */
        {
            vlen = strlen(valstring);
            nchar -= 1;        /* outputting one less character now */

            if (valstring[vlen-2] != '\'')
                valstring[vlen-2] = '&';  /*  over write last char with &  */
            else
            { /* last char was a pair of single quotes, so over write both */
                valstring[vlen-3] = '&';
                valstring[vlen-1] = '\0';
            }
        }

        if (contin)           /* This is a CONTINUEd keyword */
        {
           ffmkky("CONTINUE", valstring, comm, card, status); /* make keyword */
           strncpy(&card[8], "   ",  2);  /* overwrite the '=' */
        }
        else
        {
           ffmkky(keyname, valstring, comm, card, status);  /* make keyword */
        }

        ffprec(fptr, card, status);  /* write the keyword */

        contin = 1;
        remain -= nchar;
        next  += nchar;

        if (remain > 0) 
        {
           /* count the number of single quote characters in next section */
           tstring[0] = '\0';
           strncat(tstring, &value[next], 68); /* copy next part of string */
           nquote = 0;
           cptr = strchr(tstring, '\'');   /* search for quote character */
           while (cptr)  /* search for quote character */
           {
               nquote++;            /*  increment no. of quote characters  */
               cptr++;              /*  increment pointer to next character */
               cptr = strchr(cptr, '\'');  /* search for another quote char */
           }
           nchar = 68 - nquote;  /* max number of chars to write this time */
        }
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffplsw( fitsfile *fptr,     /* I - FITS file pointer  */
            int  *status)       /* IO - error status       */
/*
  Write the LONGSTRN keyword and a series of related COMMENT keywords
  which document that this FITS header may contain long string keyword
  values which are continued over multiple keywords using the HEASARC
  long string keyword convention.  If the LONGSTRN keyword already exists
  then this routine simple returns without doing anything.
*/
{
    char valstring[FLEN_VALUE], comm[FLEN_COMMENT];
    int tstatus;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    tstatus = 0;
    if (ffgkys(fptr, "LONGSTRN", valstring, comm, &tstatus) == 0)
        return(*status);     /* keyword already exists, so just return */

    ffpkys(fptr, "LONGSTRN", "OGIP 1.0", 
       "The HEASARC Long String Convention may be used.", status);

    ffpcom(fptr,
    "  This FITS file may contain long string keyword values that are", status);

    ffpcom(fptr,
    "  continued over multiple keywords.  The HEASARC convention uses the &",
    status);

    ffpcom(fptr,
    "  character at the end of each substring which is then continued", status);

    ffpcom(fptr,
    "  on the next keyword which has the name CONTINUE.", status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkyl( fitsfile *fptr,     /* I - FITS file pointer        */
            const char *keyname,/* I - name of keyword to write */
            int  value,         /* I - keyword value            */
            const char *comm,   /* I - keyword comment          */
            int  *status)       /* IO - error status            */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Values equal to 0 will result in a False FITS keyword; any other
  non-zero value will result in a True FITS keyword.
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffl2c(value, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkyj( fitsfile *fptr,     /* I - FITS file pointer        */
            const char *keyname,/* I - name of keyword to write */
            LONGLONG value,     /* I - keyword value            */
            const char *comm,   /* I - keyword comment          */
            int  *status)       /* IO - error status            */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes an integer keyword value.
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffi2c(value, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkyf( fitsfile *fptr,      /* I - FITS file pointer                   */
            const char  *keyname,/* I - name of keyword to write            */
            float value,         /* I - keyword value                       */
            int   decim,         /* I - number of decimal places to display */
            const char  *comm,   /* I - keyword comment                     */
            int   *status)       /* IO - error status                       */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes a fixed float keyword value.
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffr2f(value, decim, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkye( fitsfile *fptr,      /* I - FITS file pointer                   */
            const char  *keyname,/* I - name of keyword to write            */
            float value,         /* I - keyword value                       */
            int   decim,         /* I - number of decimal places to display */
            const char  *comm,   /* I - keyword comment                     */
            int   *status)       /* IO - error status                       */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes an exponential float keyword value.
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffr2e(value, decim, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkyg( fitsfile *fptr,      /* I - FITS file pointer                   */
            const char  *keyname,/* I - name of keyword to write            */
            double value,        /* I - keyword value                       */
            int   decim,         /* I - number of decimal places to display */
            const char  *comm,   /* I - keyword comment                     */
            int   *status)       /* IO - error status                       */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes a fixed double keyword value.*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffd2f(value, decim, valstring, status);  /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkyd( fitsfile *fptr,      /* I - FITS file pointer                   */
            const char  *keyname,/* I - name of keyword to write            */
            double value,        /* I - keyword value                       */
            int   decim,         /* I - number of decimal places to display */
            const char  *comm,   /* I - keyword comment                     */
            int   *status)       /* IO - error status                       */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes an exponential double keyword value.*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffd2e(value, decim, valstring, status);  /* convert to formatted string */
    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkyc( fitsfile *fptr,      /* I - FITS file pointer                   */
            const char  *keyname,/* I - name of keyword to write            */
            float *value,        /* I - keyword value (real, imaginary)     */
            int   decim,         /* I - number of decimal places to display */
            const char  *comm,   /* I - keyword comment                     */
            int   *status)       /* IO - error status                       */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes an complex float keyword value. Format = (realvalue, imagvalue)
*/
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring, "(" );
    ffr2e(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffr2e(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkym( fitsfile *fptr,      /* I - FITS file pointer                   */
            const char  *keyname,/* I - name of keyword to write            */
            double *value,       /* I - keyword value (real, imaginary)     */
            int   decim,         /* I - number of decimal places to display */
            const char  *comm,   /* I - keyword comment                     */
            int   *status)       /* IO - error status                       */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes an complex double keyword value. Format = (realvalue, imagvalue)
*/
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring, "(" );
    ffd2e(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffd2e(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkfc( fitsfile *fptr,      /* I - FITS file pointer                   */
            const char  *keyname,/* I - name of keyword to write            */
            float *value,        /* I - keyword value (real, imaginary)     */
            int   decim,         /* I - number of decimal places to display */
            const char  *comm,   /* I - keyword comment                     */
            int   *status)       /* IO - error status                       */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes an complex float keyword value. Format = (realvalue, imagvalue)
*/
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring, "(" );
    ffr2f(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffr2f(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkfm( fitsfile *fptr,      /* I - FITS file pointer                   */
            const char  *keyname,/* I - name of keyword to write            */
            double *value,       /* I - keyword value (real, imaginary)     */
            int   decim,         /* I - number of decimal places to display */
            const char  *comm,   /* I - keyword comment                     */
            int   *status)       /* IO - error status                       */
/*
  Write (put) the keyword, value and comment into the FITS header.
  Writes an complex double keyword value. Format = (realvalue, imagvalue)
*/
{
    char valstring[FLEN_VALUE], tmpstring[FLEN_VALUE];
    char card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    strcpy(valstring, "(" );
    ffd2f(value[0], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ", ");
    ffd2f(value[1], decim, tmpstring, status); /* convert to string */
    strcat(valstring, tmpstring);
    strcat(valstring, ")");

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkyt( fitsfile *fptr,      /* I - FITS file pointer        */
            const char  *keyname,/* I - name of keyword to write */
            long  intval,        /* I - integer part of value    */
            double fraction,     /* I - fractional part of value */
            const char  *comm,   /* I - keyword comment          */
            int   *status)       /* IO - error status            */
/*
  Write (put) a 'triple' precision keyword where the integer and
  fractional parts of the value are passed in separate parameters to
  increase the total amount of numerical precision.
*/
{
    char valstring[FLEN_VALUE];
    char card[FLEN_CARD];
    char fstring[20], *cptr;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (fraction > 1. || fraction < 0.)
    {
        ffpmsg("fraction must be between 0. and 1. (ffpkyt)");
        return(*status = BAD_F2C);
    }

    ffi2c(intval, valstring, status);  /* convert integer to string */
    ffd2f(fraction, 16, fstring, status);  /* convert to 16 decimal string */

    cptr = strchr(fstring, '.');    /* find the decimal point */
    strcat(valstring, cptr);    /* append the fraction to the integer */

    ffmkky(keyname, valstring, comm, card, status);  /* construct the keyword*/
    ffprec(fptr, card, status);  /* write the keyword*/

    return(*status);
}
/*-----------------------------------------------------------------*/
int ffpcom( fitsfile *fptr,      /* I - FITS file pointer   */
            const char  *comm,   /* I - comment string      */
            int   *status)       /* IO - error status       */
/*
  Write 1 or more COMMENT keywords.  If the comment string is too
  long to fit on a single keyword (72 chars) then it will automatically
  be continued on multiple CONTINUE keywords.
*/
{
    char card[FLEN_CARD];
    int len, ii;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    len = strlen(comm);
    ii = 0;

    for (; len > 0; len -= 72)
    {
        strcpy(card, "COMMENT ");
        strncat(card, &comm[ii], 72);
        ffprec(fptr, card, status);
        ii += 72;
    }

    return(*status);
}
/*-----------------------------------------------------------------*/
int ffphis( fitsfile *fptr,      /* I - FITS file pointer  */
            const char *history, /* I - history string     */
            int   *status)       /* IO - error status      */
/*
  Write 1 or more HISTORY keywords.  If the history string is too
  long to fit on a single keyword (72 chars) then it will automatically
  be continued on multiple HISTORY keywords.
*/
{
    char card[FLEN_CARD];
    int len, ii;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    len = strlen(history);
    ii = 0;

    for (; len > 0; len -= 72)
    {
        strcpy(card, "HISTORY ");
        strncat(card, &history[ii], 72);
        ffprec(fptr, card, status);
        ii += 72;
    }

    return(*status);
}
/*-----------------------------------------------------------------*/
int ffpdat( fitsfile *fptr,      /* I - FITS file pointer  */
            int   *status)       /* IO - error status      */
/*
  Write the DATE keyword into the FITS header.  If the keyword already
  exists then the date will simply be updated in the existing keyword.
*/
{
    int timeref;
    char date[30], tmzone[10], card[FLEN_CARD];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    ffgstm(date, &timeref, status);

    if (timeref)           /* GMT not available on this machine */
        strcpy(tmzone, " Local");    
    else
        strcpy(tmzone, " UT");    

    strcpy(card, "DATE    = '");
    strcat(card, date);
    strcat(card, "' / file creation date (YYYY-MM-DDThh:mm:ss");
    strcat(card, tmzone);
    strcat(card, ")");

    ffucrd(fptr, "DATE", card, status);

    return(*status);
}
/*-------------------------------------------------------------------*/
int ffverifydate(int year,          /* I - year (0 - 9999)           */
                 int month,         /* I - month (1 - 12)            */
                 int day,           /* I - day (1 - 31)              */
                 int   *status)     /* IO - error status             */
/*
  Verify that the date is valid
*/
{
    int ndays[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    char errmsg[81];
    

    if (year < 0 || year > 9999)
    {
       sprintf(errmsg, 
       "input year value = %d is out of range 0 - 9999", year);
       ffpmsg(errmsg);
       return(*status = BAD_DATE);
    }
    else if (month < 1 || month > 12)
    {
       sprintf(errmsg, 
       "input month value = %d is out of range 1 - 12", month);
       ffpmsg(errmsg);
       return(*status = BAD_DATE);
    }
    
    if (ndays[month] == 31) {
        if (day < 1 || day > 31)
        {
           sprintf(errmsg, 
           "input day value = %d is out of range 1 - 31 for month %d", day, month);
           ffpmsg(errmsg);
           return(*status = BAD_DATE);
        }
    } else if (ndays[month] == 30) {
        if (day < 1 || day > 30)
        {
           sprintf(errmsg, 
           "input day value = %d is out of range 1 - 30 for month %d", day, month);
           ffpmsg(errmsg);
           return(*status = BAD_DATE);
        }
    } else {
        if (day < 1 || day > 28)
        {
            if (day == 29)
            {
	      /* year is a leap year if it is divisible by 4 but not by 100,
	         except years divisible by 400 are leap years
	      */
	        if ((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0)
		   return (*status);
		   
 	        sprintf(errmsg, 
           "input day value = %d is out of range 1 - 28 for February %d (not leap year)", day, year);
                ffpmsg(errmsg);
	    } else {
                sprintf(errmsg, 
                "input day value = %d is out of range 1 - 28 (or 29) for February", day);
                ffpmsg(errmsg);
	    }
	    
            return(*status = BAD_DATE);
        }
    }
    return(*status);
}
/*-----------------------------------------------------------------*/
int ffgstm( char *timestr,   /* O  - returned system date and time string  */
            int  *timeref,   /* O - GMT = 0, Local time = 1  */
            int   *status)   /* IO - error status      */
/*
  Returns the current date and time in format 'yyyy-mm-ddThh:mm:ss'.
*/
{
    time_t tp;
    struct tm *ptr;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    time(&tp);
    ptr = gmtime(&tp);         /* get GMT (= UTC) time */

    if (timeref)
    {
        if (ptr)
            *timeref = 0;   /* returning GMT */
        else
            *timeref = 1;   /* returning local time */
    }

    if (!ptr)                  /* GMT not available on this machine */
        ptr = localtime(&tp); 

    strftime(timestr, 25, "%Y-%m-%dT%H:%M:%S", ptr);

    return(*status);
}
/*-----------------------------------------------------------------*/
int ffdt2s(int year,          /* I - year (0 - 9999)           */
           int month,         /* I - month (1 - 12)            */
           int day,           /* I - day (1 - 31)              */
           char *datestr,     /* O - date string: "YYYY-MM-DD" */
           int   *status)     /* IO - error status             */
/*
  Construct a date character string
*/
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    *datestr = '\0';
    
    if (ffverifydate(year, month, day, status) > 0)
    {
        ffpmsg("invalid date (ffdt2s)");
        return(*status);
    }

    if (year >= 1900 && year <= 1998)  /* use old 'dd/mm/yy' format */
        sprintf(datestr, "%.2d/%.2d/%.2d", day, month, year - 1900);

    else  /* use the new 'YYYY-MM-DD' format */
        sprintf(datestr, "%.4d-%.2d-%.2d", year, month, day);

    return(*status);
}
/*-----------------------------------------------------------------*/
int ffs2dt(char *datestr,   /* I - date string: "YYYY-MM-DD" or "dd/mm/yy" */
           int *year,       /* O - year (0 - 9999)                         */
           int *month,      /* O - month (1 - 12)                          */
           int *day,        /* O - day (1 - 31)                            */
           int   *status)   /* IO - error status                           */
/*
  Parse a date character string into year, month, and day values
*/
{
    int slen, lyear, lmonth, lday;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (year)
        *year = 0;
    if (month)
        *month = 0;
    if (day)
        *day   = 0;

    if (!datestr)
    {
        ffpmsg("error: null input date string (ffs2dt)");
        return(*status = BAD_DATE);   /* Null datestr pointer ??? */
    }

    slen = strlen(datestr);

    if (slen == 8 && datestr[2] == '/' && datestr[5] == '/')
    {
        if (isdigit((int) datestr[0]) && isdigit((int) datestr[1])
         && isdigit((int) datestr[3]) && isdigit((int) datestr[4])
         && isdigit((int) datestr[6]) && isdigit((int) datestr[7]) )
        {
            /* this is an old format string: "dd/mm/yy" */
            lyear  = atoi(&datestr[6]) + 1900;
            lmonth = atoi(&datestr[3]);
	    lday   = atoi(datestr);
	    
            if (year)
                *year = lyear;
            if (month)
                *month = lmonth;
            if (day)
                *day   = lday;
        }
        else
        {
            ffpmsg("input date string has illegal format (ffs2dt):");
            ffpmsg(datestr);
            return(*status = BAD_DATE);
        }
    }
    else if (slen >= 10 && datestr[4] == '-' && datestr[7] == '-')
        {
        if (isdigit((int) datestr[0]) && isdigit((int) datestr[1])
         && isdigit((int) datestr[2]) && isdigit((int) datestr[3])
         && isdigit((int) datestr[5]) && isdigit((int) datestr[6])
         && isdigit((int) datestr[8]) && isdigit((int) datestr[9]) )
        {
            if (slen > 10 && datestr[10] != 'T')
            {
                ffpmsg("input date string has illegal format (ffs2dt):");
                ffpmsg(datestr);
                return(*status = BAD_DATE);
            }

            /* this is a new format string: "yyyy-mm-dd" */
            lyear  = atoi(datestr);
            lmonth = atoi(&datestr[5]);
            lday   = atoi(&datestr[8]);

            if (year)
               *year  = lyear;
            if (month)
               *month = lmonth;
            if (day)
               *day   = lday;
        }
        else
        {
                ffpmsg("input date string has illegal format (ffs2dt):");
                ffpmsg(datestr);
                return(*status = BAD_DATE);
        }
    }
    else
    {
                ffpmsg("input date string has illegal format (ffs2dt):");
                ffpmsg(datestr);
                return(*status = BAD_DATE);
    }


    if (ffverifydate(lyear, lmonth, lday, status) > 0)
    {
        ffpmsg("invalid date (ffs2dt)");
    }

    return(*status);
}
/*-----------------------------------------------------------------*/
int fftm2s(int year,          /* I - year (0 - 9999)           */
           int month,         /* I - month (1 - 12)            */
           int day,           /* I - day (1 - 31)              */
           int hour,          /* I - hour (0 - 23)             */
           int minute,        /* I - minute (0 - 59)           */
           double second,     /* I - second (0. - 60.9999999)  */
           int decimals,      /* I - number of decimal points to write      */
           char *datestr,     /* O - date string: "YYYY-MM-DDThh:mm:ss.ddd" */
                              /*   or "hh:mm:ss.ddd" if year, month day = 0 */
           int   *status)     /* IO - error status             */
/*
  Construct a date and time character string
*/
{
    int width;
    char errmsg[81];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    *datestr='\0';

    if (year != 0 || month != 0 || day !=0)
    { 
        if (ffverifydate(year, month, day, status) > 0)
	{
            ffpmsg("invalid date (fftm2s)");
            return(*status);
        }
    }

    if (hour < 0 || hour > 23)
    {
       sprintf(errmsg, 
       "input hour value is out of range 0 - 23: %d (fftm2s)", hour);
       ffpmsg(errmsg);
       return(*status = BAD_DATE);
    }
    else if (minute < 0 || minute > 59)
    {
       sprintf(errmsg, 
       "input minute value is out of range 0 - 59: %d (fftm2s)", minute);
       ffpmsg(errmsg);
       return(*status = BAD_DATE);
    }
    else if (second < 0. || second >= 61)
    {
       sprintf(errmsg, 
       "input second value is out of range 0 - 60.999: %f (fftm2s)", second);
       ffpmsg(errmsg);
       return(*status = BAD_DATE);
    }
    else if (decimals > 25)
    {
       sprintf(errmsg, 
       "input decimals value is out of range 0 - 25: %d (fftm2s)", decimals);
       ffpmsg(errmsg);
       return(*status = BAD_DATE);
    }

    if (decimals == 0)
       width = 2;
    else
       width = decimals + 3;

    if (decimals < 0)
    {
        /* a negative decimals value means return only the date, not time */
        sprintf(datestr, "%.4d-%.2d-%.2d", year, month, day);
    }
    else if (year == 0 && month == 0 && day == 0)
    {
        /* return only the time, not the date */
        sprintf(datestr, "%.2d:%.2d:%0*.*f",
            hour, minute, width, decimals, second);
    }
    else
    {
        /* return both the time and date */
        sprintf(datestr, "%.4d-%.2d-%.2dT%.2d:%.2d:%0*.*f",
            year, month, day, hour, minute, width, decimals, second);
    }
    return(*status);
}
/*-----------------------------------------------------------------*/
int ffs2tm(char *datestr,     /* I - date string: "YYYY-MM-DD"    */
                              /*     or "YYYY-MM-DDThh:mm:ss.ddd" */
                              /*     or "dd/mm/yy"                */
           int *year,         /* O - year (0 - 9999)              */
           int *month,        /* O - month (1 - 12)               */
           int *day,          /* O - day (1 - 31)                 */
           int *hour,          /* I - hour (0 - 23)                */
           int *minute,        /* I - minute (0 - 59)              */
           double *second,     /* I - second (0. - 60.9999999)     */
           int   *status)     /* IO - error status                */
/*
  Parse a date character string into date and time values
*/
{
    int slen;
    char errmsg[81];

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (year)
       *year   = 0;
    if (month)
       *month  = 0;
    if (day)
       *day    = 0;
    if (hour)
       *hour   = 0;
    if (minute)
       *minute = 0;
    if (second)
       *second = 0.;

    if (!datestr)
    {
        ffpmsg("error: null input date string (ffs2tm)");
        return(*status = BAD_DATE);   /* Null datestr pointer ??? */
    }

    if (datestr[2] == '/' || datestr[4] == '-')
    {
        /*  Parse the year, month, and date */
        if (ffs2dt(datestr, year, month, day, status) > 0)
            return(*status);

        slen = strlen(datestr);
        if (slen == 8 || slen == 10)
            return(*status);               /* OK, no time fields */
        else if (slen < 19) 
        {
            ffpmsg("input date string has illegal format:");
            ffpmsg(datestr);
            return(*status = BAD_DATE);
        }

        else if (datestr[10] == 'T' && datestr[13] == ':' && datestr[16] == ':')
        {
          if (isdigit((int) datestr[11]) && isdigit((int) datestr[12])
           && isdigit((int) datestr[14]) && isdigit((int) datestr[15])
           && isdigit((int) datestr[17]) && isdigit((int) datestr[18]) )
            {
                if (slen > 19 && datestr[19] != '.')
                {
                  ffpmsg("input date string has illegal format:");
                  ffpmsg(datestr);
                  return(*status = BAD_DATE);
                }

                /* this is a new format string: "yyyy-mm-ddThh:mm:ss.dddd" */
                if (hour)
                    *hour   = atoi(&datestr[11]);

                if (minute)
                    *minute = atoi(&datestr[14]);

                if (second)
                    *second = atof(&datestr[17]);
            }
            else
            {
                  ffpmsg("input date string has illegal format:");
                  ffpmsg(datestr);
                  return(*status = BAD_DATE);
            }

        }
    }
    else   /* no date fields */
    {
        if (datestr[2] == ':' && datestr[5] == ':')   /* time string */
        {
            if (isdigit((int) datestr[0]) && isdigit((int) datestr[1])
             && isdigit((int) datestr[3]) && isdigit((int) datestr[4])
             && isdigit((int) datestr[6]) && isdigit((int) datestr[7]) )
            {
                 /* this is a time string: "hh:mm:ss.dddd" */
                 if (hour)
                    *hour   = atoi(&datestr[0]);

                 if (minute)
                    *minute = atoi(&datestr[3]);

                if (second)
                    *second = atof(&datestr[6]);
            }
            else
            {
                  ffpmsg("input date string has illegal format:");
                  ffpmsg(datestr);
                  return(*status = BAD_DATE);
            }

        }
        else
        {
                  ffpmsg("input date string has illegal format:");
                  ffpmsg(datestr);
                  return(*status = BAD_DATE);
        }

    }

    if (hour)
       if (*hour < 0 || *hour > 23)
       {
          sprintf(errmsg, 
          "hour value is out of range 0 - 23: %d (ffs2tm)", *hour);
          ffpmsg(errmsg);
          return(*status = BAD_DATE);
       }

    if (minute)
       if (*minute < 0 || *minute > 59)
       {
          sprintf(errmsg, 
          "minute value is out of range 0 - 59: %d (ffs2tm)", *minute);
          ffpmsg(errmsg);
          return(*status = BAD_DATE);
       }

    if (second)
       if (*second < 0 || *second >= 61.)
       {
          sprintf(errmsg, 
          "second value is out of range 0 - 60.9999: %f (ffs2tm)", *second);
          ffpmsg(errmsg);
          return(*status = BAD_DATE);
       }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgsdt( int *day, int *month, int *year, int *status )
{  
/*
      This routine is included for backward compatibility
            with the Fortran FITSIO library.

   ffgsdt : Get current System DaTe (GMT if available)

      Return integer values of the day, month, and year

         Function parameters:
            day      Day of the month
            month    Numerical month (1=Jan, etc.)
            year     Year (1999, 2000, etc.)
            status   output error status

*/
   time_t now;
   struct tm *date;

   now = time( NULL );
   date = gmtime(&now);         /* get GMT (= UTC) time */

   if (!date)                  /* GMT not available on this machine */
   {
       date = localtime(&now); 
   }

   *day = date->tm_mday;
   *month = date->tm_mon + 1;
   *year = date->tm_year + 1900;  /* tm_year is defined as years since 1900 */
   return( *status );
}
/*--------------------------------------------------------------------------*/
int ffpkns( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyroot,      /* I - root name of keywords to write       */
            int  nstart,        /* I - starting index number                */
            int  nkey,          /* I - number of keywords to write          */
            char *value[],      /* I - array of pointers to keyword values  */
            char *comm[],       /* I - array of pointers to keyword comment */
            int  *status)       /* IO - error status                        */
/*
  Write (put) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NKEY -1) inclusive.  Writes string keywords.
  The value strings will be truncated at 68 characters, and the HEASARC
  long string keyword convention is not supported by this routine.
*/
{
    char keyname[FLEN_KEYWORD], tcomment[FLEN_COMMENT];
    int ii, jj, repeat, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check if first comment string is to be repeated for all the keywords */
    /* by looking to see if the last non-blank character is a '&' char      */

    repeat = 0;

    if (comm)
    {
      len = strlen(comm[0]);

      while (len > 0  && comm[0][len - 1] == ' ')
        len--;                               /* ignore trailing blanks */

      if (comm[0][len - 1] == '&')
      {
        len = minvalue(len, FLEN_COMMENT);
        tcomment[0] = '\0';
        strncat(tcomment, comm[0], len-1); /* don't copy the final '&' char */
        repeat = 1;
      }
    }
    else
    {
      repeat = 1;
      tcomment[0] = '\0';
    }

    for (ii=0, jj=nstart; ii < nkey; ii++, jj++)
    {
        ffkeyn(keyroot, jj, keyname, status);
        if (repeat)
            ffpkys(fptr, keyname, value[ii], tcomment, status);
        else
            ffpkys(fptr, keyname, value[ii], comm[ii], status);

        if (*status > 0)
            return(*status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpknl( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyroot,      /* I - root name of keywords to write       */
            int  nstart,        /* I - starting index number                */
            int  nkey,          /* I - number of keywords to write          */
            int  *value,        /* I - array of keyword values              */
            char *comm[],       /* I - array of pointers to keyword comment */
            int  *status)       /* IO - error status                        */
/*
  Write (put) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NKEY -1) inclusive.  Writes logical keywords
  Values equal to zero will be written as a False FITS keyword value; any
  other non-zero value will result in a True FITS keyword.
*/
{
    char keyname[FLEN_KEYWORD], tcomment[FLEN_COMMENT];
    int ii, jj, repeat, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check if first comment string is to be repeated for all the keywords */
    /* by looking to see if the last non-blank character is a '&' char      */

    repeat = 0;
    if (comm)
    {
      len = strlen(comm[0]);

      while (len > 0  && comm[0][len - 1] == ' ')
        len--;                               /* ignore trailing blanks */

      if (comm[0][len - 1] == '&')
      {
        len = minvalue(len, FLEN_COMMENT);
        tcomment[0] = '\0';
        strncat(tcomment, comm[0], len-1); /* don't copy the final '&' char */
        repeat = 1;
      }
    }
    else
    {
      repeat = 1;
      tcomment[0] = '\0';
    }


    for (ii=0, jj=nstart; ii < nkey; ii++, jj++)
    {
        ffkeyn(keyroot, jj, keyname, status);

        if (repeat)
            ffpkyl(fptr, keyname, value[ii], tcomment, status);
        else
            ffpkyl(fptr, keyname, value[ii], comm[ii], status);

        if (*status > 0)
            return(*status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpknj( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyroot,      /* I - root name of keywords to write       */
            int  nstart,        /* I - starting index number                */
            int  nkey,          /* I - number of keywords to write          */
            long *value,        /* I - array of keyword values              */
            char *comm[],       /* I - array of pointers to keyword comment */
            int  *status)       /* IO - error status                        */
/*
  Write (put) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NKEY -1) inclusive.  Write integer keywords
*/
{
    char keyname[FLEN_KEYWORD], tcomment[FLEN_COMMENT];
    int ii, jj, repeat, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check if first comment string is to be repeated for all the keywords */
    /* by looking to see if the last non-blank character is a '&' char      */

    repeat = 0;

    if (comm)
    {
      len = strlen(comm[0]);

      while (len > 0  && comm[0][len - 1] == ' ')
        len--;                               /* ignore trailing blanks */

      if (comm[0][len - 1] == '&')
      {
        len = minvalue(len, FLEN_COMMENT);
        tcomment[0] = '\0';
        strncat(tcomment, comm[0], len-1); /* don't copy the final '&' char */
        repeat = 1;
      }
    }
    else
    {
      repeat = 1;
      tcomment[0] = '\0';
    }

    for (ii=0, jj=nstart; ii < nkey; ii++, jj++)
    {
        ffkeyn(keyroot, jj, keyname, status);
        if (repeat)
            ffpkyj(fptr, keyname, value[ii], tcomment, status);
        else
            ffpkyj(fptr, keyname, value[ii], comm[ii], status);

        if (*status > 0)
            return(*status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpknjj( fitsfile *fptr,    /* I - FITS file pointer                    */
            const char *keyroot,      /* I - root name of keywords to write       */
            int  nstart,        /* I - starting index number                */
            int  nkey,          /* I - number of keywords to write          */
            LONGLONG *value,    /* I - array of keyword values              */
            char *comm[],       /* I - array of pointers to keyword comment */
            int  *status)       /* IO - error status                        */
/*
  Write (put) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NKEY -1) inclusive.  Write integer keywords
*/
{
    char keyname[FLEN_KEYWORD], tcomment[FLEN_COMMENT];
    int ii, jj, repeat, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check if first comment string is to be repeated for all the keywords */
    /* by looking to see if the last non-blank character is a '&' char      */

    repeat = 0;

    if (comm)
    {
      len = strlen(comm[0]);

      while (len > 0  && comm[0][len - 1] == ' ')
        len--;                               /* ignore trailing blanks */

      if (comm[0][len - 1] == '&')
      {
        len = minvalue(len, FLEN_COMMENT);
        tcomment[0] = '\0';
        strncat(tcomment, comm[0], len-1); /* don't copy the final '&' char */
        repeat = 1;
      }
    }
    else
    {
      repeat = 1;
      tcomment[0] = '\0';
    }

    for (ii=0, jj=nstart; ii < nkey; ii++, jj++)
    {
        ffkeyn(keyroot, jj, keyname, status);
        if (repeat)
            ffpkyj(fptr, keyname, value[ii], tcomment, status);
        else
            ffpkyj(fptr, keyname, value[ii], comm[ii], status);

        if (*status > 0)
            return(*status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpknf( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyroot,      /* I - root name of keywords to write       */
            int  nstart,        /* I - starting index number                */
            int  nkey,          /* I - number of keywords to write          */
            float *value,       /* I - array of keyword values              */
            int decim,          /* I - number of decimals to display        */
            char *comm[],       /* I - array of pointers to keyword comment */
            int  *status)       /* IO - error status                        */
/*
  Write (put) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NKEY -1) inclusive.  Writes fixed float values.
*/
{
    char keyname[FLEN_KEYWORD], tcomment[FLEN_COMMENT];
    int ii, jj, repeat, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check if first comment string is to be repeated for all the keywords */
    /* by looking to see if the last non-blank character is a '&' char      */

    repeat = 0;

    if (comm)
    {
      len = strlen(comm[0]);

      while (len > 0  && comm[0][len - 1] == ' ')
        len--;                               /* ignore trailing blanks */

      if (comm[0][len - 1] == '&')
      {
        len = minvalue(len, FLEN_COMMENT);
        tcomment[0] = '\0';
        strncat(tcomment, comm[0], len-1); /* don't copy the final '&' char */
        repeat = 1;
      }
    }
    else
    {
      repeat = 1;
      tcomment[0] = '\0';
    }

    for (ii=0, jj=nstart; ii < nkey; ii++, jj++)
    {
        ffkeyn(keyroot, jj, keyname, status);
        if (repeat)
            ffpkyf(fptr, keyname, value[ii], decim, tcomment, status);
        else
            ffpkyf(fptr, keyname, value[ii], decim, comm[ii], status);

        if (*status > 0)
            return(*status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkne( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyroot,      /* I - root name of keywords to write       */
            int  nstart,        /* I - starting index number                */
            int  nkey,          /* I - number of keywords to write          */
            float *value,       /* I - array of keyword values              */
            int decim,          /* I - number of decimals to display        */
            char *comm[],       /* I - array of pointers to keyword comment */
            int  *status)       /* IO - error status                        */
/*
  Write (put) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NKEY -1) inclusive.  Writes exponential float values.
*/
{
    char keyname[FLEN_KEYWORD], tcomment[FLEN_COMMENT];
    int ii, jj, repeat, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check if first comment string is to be repeated for all the keywords */
    /* by looking to see if the last non-blank character is a '&' char      */

    repeat = 0;

    if (comm)
    {
      len = strlen(comm[0]);

      while (len > 0  && comm[0][len - 1] == ' ')
        len--;                               /* ignore trailing blanks */

      if (comm[0][len - 1] == '&')
      {
        len = minvalue(len, FLEN_COMMENT);
        tcomment[0] = '\0';
        strncat(tcomment, comm[0], len-1); /* don't copy the final '&' char */
        repeat = 1;
      }
    }
    else
    {
      repeat = 1;
      tcomment[0] = '\0';
    }

    for (ii=0, jj=nstart; ii < nkey; ii++, jj++)
    {
        ffkeyn(keyroot, jj, keyname, status);
        if (repeat)
            ffpkye(fptr, keyname, value[ii], decim, tcomment, status);
        else
            ffpkye(fptr, keyname, value[ii], decim, comm[ii], status);

        if (*status > 0)
            return(*status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpkng( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyroot,      /* I - root name of keywords to write       */
            int  nstart,        /* I - starting index number                */
            int  nkey,          /* I - number of keywords to write          */
            double *value,      /* I - array of keyword values              */
            int decim,          /* I - number of decimals to display        */
            char *comm[],       /* I - array of pointers to keyword comment */
            int  *status)       /* IO - error status                        */
/*
  Write (put) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NKEY -1) inclusive.  Writes fixed double values.
*/
{
    char keyname[FLEN_KEYWORD], tcomment[FLEN_COMMENT];
    int ii, jj, repeat, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check if first comment string is to be repeated for all the keywords */
    /* by looking to see if the last non-blank character is a '&' char      */

    repeat = 0;

    if (comm)
    {
      len = strlen(comm[0]);

      while (len > 0  && comm[0][len - 1] == ' ')
        len--;                               /* ignore trailing blanks */

      if (comm[0][len - 1] == '&')
      {
        len = minvalue(len, FLEN_COMMENT);
        tcomment[0] = '\0';
        strncat(tcomment, comm[0], len-1); /* don't copy the final '&' char */
        repeat = 1;
      }
    }
    else
    {
      repeat = 1;
      tcomment[0] = '\0';
    }

    for (ii=0, jj=nstart; ii < nkey; ii++, jj++)
    {
        ffkeyn(keyroot, jj, keyname, status);
        if (repeat)
            ffpkyg(fptr, keyname, value[ii], decim, tcomment, status);
        else
            ffpkyg(fptr, keyname, value[ii], decim, comm[ii], status);

        if (*status > 0)
            return(*status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpknd( fitsfile *fptr,     /* I - FITS file pointer                    */
            const char *keyroot,      /* I - root name of keywords to write       */
            int  nstart,        /* I - starting index number                */
            int  nkey,          /* I - number of keywords to write          */
            double *value,      /* I - array of keyword values              */
            int decim,          /* I - number of decimals to display        */
            char *comm[],       /* I - array of pointers to keyword comment */
            int  *status)       /* IO - error status                        */
/*
  Write (put) an indexed array of keywords with index numbers between
  NSTART and (NSTART + NKEY -1) inclusive.  Writes exponential double values.
*/
{
    char keyname[FLEN_KEYWORD], tcomment[FLEN_COMMENT];
    int ii, jj, repeat, len;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    /* check if first comment string is to be repeated for all the keywords */
    /* by looking to see if the last non-blank character is a '&' char      */

    repeat = 0;

    if (comm)
    {
      len = strlen(comm[0]);

      while (len > 0  && comm[0][len - 1] == ' ')
        len--;                               /* ignore trailing blanks */

      if (comm[0][len - 1] == '&')
      {
        len = minvalue(len, FLEN_COMMENT);
        tcomment[0] = '\0';
        strncat(tcomment, comm[0], len-1); /* don't copy the final '&' char */
        repeat = 1;
      }
    }
    else
    {
      repeat = 1;
      tcomment[0] = '\0';
    }

    for (ii=0, jj=nstart; ii < nkey; ii++, jj++)
    {
        ffkeyn(keyroot, jj, keyname, status);
        if (repeat)
            ffpkyd(fptr, keyname, value[ii], decim, tcomment, status);
        else
            ffpkyd(fptr, keyname, value[ii], decim, comm[ii], status);

        if (*status > 0)
            return(*status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffptdm( fitsfile *fptr, /* I - FITS file pointer                        */
            int colnum,     /* I - column number                            */
            int naxis,      /* I - number of axes in the data array         */
            long naxes[],   /* I - length of each data axis                 */
            int *status)    /* IO - error status                            */
/*
  write the TDIMnnn keyword describing the dimensionality of a column
*/
{
    char keyname[FLEN_KEYWORD], tdimstr[FLEN_VALUE], comm[FLEN_COMMENT];
    char value[80], message[81];
    int ii;
    long totalpix = 1, repeat;
    tcolumn *colptr;

    if (*status > 0)
        return(*status);

    if (colnum < 1 || colnum > 999)
    {
        ffpmsg("column number is out of range 1 - 999 (ffptdm)");
        return(*status = BAD_COL_NUM);
    }

    if (naxis < 1)
    {
        ffpmsg("naxis is less than 1 (ffptdm)");
        return(*status = BAD_DIMEN);
    }

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);

    if ( (fptr->Fptr)->hdutype != BINARY_TBL)
    {
       ffpmsg(
    "Error: The TDIMn keyword is only allowed in BINTABLE extensions (ffptdm)");
       return(*status = NOT_BTABLE);
    }

    strcpy(tdimstr, "(");            /* start constructing the TDIM value */   

    for (ii = 0; ii < naxis; ii++)
    {
        if (ii > 0)
            strcat(tdimstr, ",");   /* append the comma separator */

        if (naxes[ii] < 0)
        {
            ffpmsg("one or more TDIM values are less than 0 (ffptdm)");
            return(*status = BAD_TDIM);
        }

        sprintf(value, "%ld", naxes[ii]);
        strcat(tdimstr, value);     /* append the axis size */

        totalpix *= naxes[ii];
    }

    colptr = (fptr->Fptr)->tableptr;  /* point to first column structure */
    colptr += (colnum - 1);      /* point to the specified column number */

    if ((long) colptr->trepeat != totalpix)
    {
      /* There is an apparent inconsistency between TDIMn and TFORMn. */
      /* The colptr->trepeat value may be out of date, so re-read     */
      /* the TFORMn keyword to be sure.                               */

      ffkeyn("TFORM", colnum, keyname, status);   /* construct TFORMn name  */
      ffgkys(fptr, keyname, value, NULL, status); /* read TFORMn keyword    */
      ffbnfm(value, NULL, &repeat, NULL, status); /* parse the repeat count */

      if (*status > 0 || repeat != totalpix)
      {
        sprintf(message,
        "column vector length, %ld, does not equal TDIMn array size, %ld",
        (long) colptr->trepeat, totalpix);
        ffpmsg(message);
        return(*status = BAD_TDIM);
      }
    }

    strcat(tdimstr, ")" );            /* append the closing parenthesis */

    strcpy(comm, "size of the multidimensional array");
    ffkeyn("TDIM", colnum, keyname, status);      /* construct TDIMn name */
    ffpkys(fptr, keyname, tdimstr, comm, status);  /* write the keyword */
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffptdmll( fitsfile *fptr, /* I - FITS file pointer                      */
            int colnum,     /* I - column number                            */
            int naxis,      /* I - number of axes in the data array         */
            LONGLONG naxes[], /* I - length of each data axis               */
            int *status)    /* IO - error status                            */
/*
  write the TDIMnnn keyword describing the dimensionality of a column
*/
{
    char keyname[FLEN_KEYWORD], tdimstr[FLEN_VALUE], comm[FLEN_COMMENT];
    char value[80], message[81];
    int ii;
    LONGLONG totalpix = 1, repeat;
    tcolumn *colptr;

    if (*status > 0)
        return(*status);

    if (colnum < 1 || colnum > 999)
    {
        ffpmsg("column number is out of range 1 - 999 (ffptdm)");
        return(*status = BAD_COL_NUM);
    }

    if (naxis < 1)
    {
        ffpmsg("naxis is less than 1 (ffptdm)");
        return(*status = BAD_DIMEN);
    }

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
    else if ((fptr->Fptr)->datastart == DATA_UNDEFINED)
        if ( ffrdef(fptr, status) > 0)               /* rescan header */
            return(*status);

    if ( (fptr->Fptr)->hdutype != BINARY_TBL)
    {
       ffpmsg(
    "Error: The TDIMn keyword is only allowed in BINTABLE extensions (ffptdm)");
       return(*status = NOT_BTABLE);
    }

    strcpy(tdimstr, "(");            /* start constructing the TDIM value */   

    for (ii = 0; ii < naxis; ii++)
    {
        if (ii > 0)
            strcat(tdimstr, ",");   /* append the comma separator */

        if (naxes[ii] < 0)
        {
            ffpmsg("one or more TDIM values are less than 0 (ffptdm)");
            return(*status = BAD_TDIM);
        }

        /* cast to double because the 64-bit int conversion character in */
        /* sprintf is platform dependent ( %lld, %ld, %I64d )            */

        sprintf(value, "%.0f", (double) naxes[ii]);

        strcat(tdimstr, value);     /* append the axis size */

        totalpix *= naxes[ii];
    }

    colptr = (fptr->Fptr)->tableptr;  /* point to first column structure */
    colptr += (colnum - 1);      /* point to the specified column number */

    if ( colptr->trepeat != totalpix)
    {
      /* There is an apparent inconsistency between TDIMn and TFORMn. */
      /* The colptr->trepeat value may be out of date, so re-read     */
      /* the TFORMn keyword to be sure.                               */

      ffkeyn("TFORM", colnum, keyname, status);   /* construct TFORMn name  */
      ffgkys(fptr, keyname, value, NULL, status); /* read TFORMn keyword    */
      ffbnfmll(value, NULL, &repeat, NULL, status); /* parse the repeat count */

      if (*status > 0 || repeat != totalpix)
      {
        sprintf(message,
        "column vector length, %.0f, does not equal TDIMn array size, %.0f",
        (double) (colptr->trepeat), (double) totalpix);
        ffpmsg(message);
        return(*status = BAD_TDIM);
      }
    }

    strcat(tdimstr, ")" );            /* append the closing parenthesis */

    strcpy(comm, "size of the multidimensional array");
    ffkeyn("TDIM", colnum, keyname, status);      /* construct TDIMn name */
    ffpkys(fptr, keyname, tdimstr, comm, status);  /* write the keyword */
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffphps( fitsfile *fptr, /* I - FITS file pointer                        */
            int bitpix,     /* I - number of bits per data value pixel      */
            int naxis,      /* I - number of axes in the data array         */
            long naxes[],   /* I - length of each data axis                 */
            int *status)    /* IO - error status                            */
/*
  write STANDARD set of required primary header keywords
*/
{
    int simple = 1;     /* does file conform to FITS standard? 1/0  */
    long pcount = 0;    /* number of group parameters (usually 0)   */
    long gcount = 1;    /* number of random groups (usually 1 or 0) */
    int extend = 1;     /* may FITS file have extensions?           */

    ffphpr(fptr, simple, bitpix, naxis, naxes, pcount, gcount, extend, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffphpsll( fitsfile *fptr, /* I - FITS file pointer                        */
            int bitpix,     /* I - number of bits per data value pixel      */
            int naxis,      /* I - number of axes in the data array         */
            LONGLONG naxes[],   /* I - length of each data axis                 */
            int *status)    /* IO - error status                            */
/*
  write STANDARD set of required primary header keywords
*/
{
    int simple = 1;     /* does file conform to FITS standard? 1/0  */
    LONGLONG pcount = 0;    /* number of group parameters (usually 0)   */
    LONGLONG gcount = 1;    /* number of random groups (usually 1 or 0) */
    int extend = 1;     /* may FITS file have extensions?           */

    ffphprll(fptr, simple, bitpix, naxis, naxes, pcount, gcount, extend, status);
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffphpr( fitsfile *fptr, /* I - FITS file pointer                        */
            int simple,     /* I - does file conform to FITS standard? 1/0  */
            int bitpix,     /* I - number of bits per data value pixel      */
            int naxis,      /* I - number of axes in the data array         */
            long naxes[],   /* I - length of each data axis                 */
            LONGLONG pcount, /* I - number of group parameters (usually 0)   */
            LONGLONG gcount, /* I - number of random groups (usually 1 or 0) */
            int extend,     /* I - may FITS file have extensions?           */
            int *status)    /* IO - error status                            */
/*
  write required primary header keywords
*/
{
    int ii;
    LONGLONG naxesll[20];
   
    for (ii = 0; (ii < naxis) && (ii < 20); ii++)
       naxesll[ii] = naxes[ii];

    ffphprll(fptr, simple, bitpix, naxis, naxesll, pcount, gcount,
             extend, status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffphprll( fitsfile *fptr, /* I - FITS file pointer                        */
            int simple,     /* I - does file conform to FITS standard? 1/0  */
            int bitpix,     /* I - number of bits per data value pixel      */
            int naxis,      /* I - number of axes in the data array         */
            LONGLONG naxes[], /* I - length of each data axis                 */
            LONGLONG pcount,  /* I - number of group parameters (usually 0)   */
            LONGLONG gcount,  /* I - number of random groups (usually 1 or 0) */
            int extend,     /* I - may FITS file have extensions?           */
            int *status)    /* IO - error status                            */
/*
  write required primary header keywords
*/
{
    int ii;
    long longbitpix, tnaxes[20];
    char name[FLEN_KEYWORD], comm[FLEN_COMMENT], message[FLEN_ERRMSG];

    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if ((fptr->Fptr)->headend != (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
        return(*status = HEADER_NOT_EMPTY);

    if (naxis != 0)   /* never try to compress a null image */
    {
      if ( (fptr->Fptr)->request_compress_type )
      {
      
       for (ii = 0; ii < naxis; ii++)
           tnaxes[ii] = (long) naxes[ii];
	   
        /* write header for a compressed image */
        imcomp_init_table(fptr, bitpix, naxis, tnaxes, 1, status);
        return(*status);
      }
    }  

    if ((fptr->Fptr)->curhdu == 0)
    {                /* write primary array header */
        if (simple)
            strcpy(comm, "file does conform to FITS standard");
        else
            strcpy(comm, "file does not conform to FITS standard");

        ffpkyl(fptr, "SIMPLE", simple, comm, status);
    }
    else
    {               /* write IMAGE extension header */
        strcpy(comm, "IMAGE extension");
        ffpkys(fptr, "XTENSION", "IMAGE", comm, status);
    }

    longbitpix = bitpix;

    /* test for the 3 special cases that represent unsigned integers */
    if (longbitpix == USHORT_IMG)
        longbitpix = SHORT_IMG;
    else if (longbitpix == ULONG_IMG)
        longbitpix = LONG_IMG;
    else if (longbitpix == SBYTE_IMG)
        longbitpix = BYTE_IMG;

    if (longbitpix != BYTE_IMG && longbitpix != SHORT_IMG && 
        longbitpix != LONG_IMG && longbitpix != LONGLONG_IMG &&
        longbitpix != FLOAT_IMG && longbitpix != DOUBLE_IMG)
    {
        sprintf(message,
        "Illegal value for BITPIX keyword: %d", bitpix);
        ffpmsg(message);
        return(*status = BAD_BITPIX);
    }

    strcpy(comm, "number of bits per data pixel");
    if (ffpkyj(fptr, "BITPIX", longbitpix, comm, status) > 0)
        return(*status);

    if (naxis < 0 || naxis > 999)
    {
        sprintf(message,
        "Illegal value for NAXIS keyword: %d", naxis);
        ffpmsg(message);
        return(*status = BAD_NAXIS);
    }

    strcpy(comm, "number of data axes");
    ffpkyj(fptr, "NAXIS", naxis, comm, status);

    strcpy(comm, "length of data axis ");
    for (ii = 0; ii < naxis; ii++)
    {
        if (naxes[ii] < 0)
        {
            sprintf(message,
            "Illegal negative value for NAXIS%d keyword: %.0f", ii + 1, (double) (naxes[ii]));
            ffpmsg(message);
            return(*status = BAD_NAXES);
        }

        sprintf(&comm[20], "%d", ii + 1);
        ffkeyn("NAXIS", ii + 1, name, status);
        ffpkyj(fptr, name, naxes[ii], comm, status);
    }

    if ((fptr->Fptr)->curhdu == 0)  /* the primary array */
    {
        if (extend)
        {
            /* only write EXTEND keyword if value = true */
            strcpy(comm, "FITS dataset may contain extensions");
            ffpkyl(fptr, "EXTEND", extend, comm, status);
        }

        if (pcount < 0)
        {
            ffpmsg("pcount value is less than 0");
            return(*status = BAD_PCOUNT);
        }

        else if (gcount < 1)
        {
            ffpmsg("gcount value is less than 1");
            return(*status = BAD_GCOUNT);
        }

        else if (pcount > 0 || gcount > 1)
        {
            /* only write these keyword if non-standard values */
            strcpy(comm, "random group records are present");
            ffpkyl(fptr, "GROUPS", 1, comm, status);

            strcpy(comm, "number of random group parameters");
            ffpkyj(fptr, "PCOUNT", pcount, comm, status);
  
            strcpy(comm, "number of random groups");
            ffpkyj(fptr, "GCOUNT", gcount, comm, status);
        }

      /* write standard block of self-documentating comments */
      ffprec(fptr,
      "COMMENT   FITS (Flexible Image Transport System) format is defined in 'Astronomy",
      status);
      ffprec(fptr,
      "COMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H",
      status);
    }

    else  /* an IMAGE extension */

    {   /* image extension; cannot have random groups */
        if (pcount != 0)
        {
            ffpmsg("image extensions must have pcount = 0");
            *status = BAD_PCOUNT;
        }

        else if (gcount != 1)
        {
            ffpmsg("image extensions must have gcount = 1");
            *status = BAD_GCOUNT;
        }

        else
        {
            strcpy(comm, "required keyword; must = 0");
            ffpkyj(fptr, "PCOUNT", 0, comm, status);
  
            strcpy(comm, "required keyword; must = 1");
            ffpkyj(fptr, "GCOUNT", 1, comm, status);
        }
    }

    /* Write the BSCALE and BZERO keywords, if an unsigned integer image */
    if (bitpix == USHORT_IMG)
    {
        strcpy(comm, "offset data range to that of unsigned short");
        ffpkyg(fptr, "BZERO", 32768., 0, comm, status);
        strcpy(comm, "default scaling factor");
        ffpkyg(fptr, "BSCALE", 1.0, 0, comm, status);
    }
    else if (bitpix == ULONG_IMG)
    {
        strcpy(comm, "offset data range to that of unsigned long");
        ffpkyg(fptr, "BZERO", 2147483648., 0, comm, status);
        strcpy(comm, "default scaling factor");
        ffpkyg(fptr, "BSCALE", 1.0, 0, comm, status);
    }
    else if (bitpix == SBYTE_IMG)
    {
        strcpy(comm, "offset data range to that of signed byte");
        ffpkyg(fptr, "BZERO", -128., 0, comm, status);
        strcpy(comm, "default scaling factor");
        ffpkyg(fptr, "BSCALE", 1.0, 0, comm, status);
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffphtb(fitsfile *fptr,  /* I - FITS file pointer                        */
           LONGLONG naxis1,     /* I - width of row in the table                */
           LONGLONG naxis2,     /* I - number of rows in the table              */
           int tfields,     /* I - number of columns in the table           */
           char **ttype,    /* I - name of each column                      */
           long *tbcol,     /* I - byte offset in row to each column        */
           char **tform,    /* I - value of TFORMn keyword for each column  */
           char **tunit,    /* I - value of TUNITn keyword for each column  */
           const char *extnmx,   /* I - value of EXTNAME keyword, if any         */
           int *status)     /* IO - error status                            */
/*
  Put required Header keywords into the ASCII TaBle:
*/
{
    int ii, ncols, gotmem = 0;
    long rowlen; /* must be 'long' because it is passed to ffgabc */
    char tfmt[30], name[FLEN_KEYWORD], comm[FLEN_COMMENT], extnm[FLEN_VALUE];

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if (*status > 0)
        return(*status);
    else if ((fptr->Fptr)->headend != (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
        return(*status = HEADER_NOT_EMPTY);
    else if (naxis1 < 0)
        return(*status = NEG_WIDTH);
    else if (naxis2 < 0)
        return(*status = NEG_ROWS);
    else if (tfields < 0 || tfields > 999)
        return(*status = BAD_TFIELDS);
    
    extnm[0] = '\0';
    if (extnmx)
        strncat(extnm, extnmx, FLEN_VALUE-1);

    rowlen = (long) naxis1;

    if (!tbcol || !tbcol[0] || (!naxis1 && tfields)) /* spacing not defined? */
    {
      /* allocate mem for tbcol; malloc can have problems allocating small */
      /* arrays, so allocate at least 20 bytes */

      ncols = maxvalue(5, tfields);
      tbcol = (long *) calloc(ncols, sizeof(long));

      if (tbcol)
      {
        gotmem = 1;

        /* calculate width of a row and starting position of each column. */
        /* Each column will be separated by 1 blank space */
        ffgabc(tfields, tform, 1, &rowlen, tbcol, status);
      }
    }
    ffpkys(fptr, "XTENSION", "TABLE", "ASCII table extension", status);
    ffpkyj(fptr, "BITPIX", 8, "8-bit ASCII characters", status);
    ffpkyj(fptr, "NAXIS", 2, "2-dimensional ASCII table", status);
    ffpkyj(fptr, "NAXIS1", rowlen, "width of table in characters", status);
    ffpkyj(fptr, "NAXIS2", naxis2, "number of rows in table", status);
    ffpkyj(fptr, "PCOUNT", 0, "no group parameters (required keyword)", status);
    ffpkyj(fptr, "GCOUNT", 1, "one data group (required keyword)", status);
    ffpkyj(fptr, "TFIELDS", tfields, "number of fields in each row", status);

    for (ii = 0; ii < tfields; ii++) /* loop over every column */
    {
        if ( *(ttype[ii]) )  /* optional TTYPEn keyword */
        {
          sprintf(comm, "label for field %3d", ii + 1);
          ffkeyn("TTYPE", ii + 1, name, status);
          ffpkys(fptr, name, ttype[ii], comm, status);
        }

        if (tbcol[ii] < 1 || tbcol[ii] > rowlen)
           *status = BAD_TBCOL;

        sprintf(comm, "beginning column of field %3d", ii + 1);
        ffkeyn("TBCOL", ii + 1, name, status);
        ffpkyj(fptr, name, tbcol[ii], comm, status);

        strcpy(tfmt, tform[ii]);  /* required TFORMn keyword */
        ffupch(tfmt);
        ffkeyn("TFORM", ii + 1, name, status);
        ffpkys(fptr, name, tfmt, "Fortran-77 format of field", status);

        if (tunit)
        {
         if (tunit[ii] && *(tunit[ii]) )  /* optional TUNITn keyword */
         {
          ffkeyn("TUNIT", ii + 1, name, status);
          ffpkys(fptr, name, tunit[ii], "physical unit of field", status) ;
         }
        }

        if (*status > 0)
            break;       /* abort loop on error */
    }

    if (extnm[0])       /* optional EXTNAME keyword */
        ffpkys(fptr, "EXTNAME", extnm,
               "name of this ASCII table extension", status);

    if (*status > 0)
        ffpmsg("Failed to write ASCII table header keywords (ffphtb)");

    if (gotmem)
        free(tbcol); 

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffphbn(fitsfile *fptr,  /* I - FITS file pointer                        */
           LONGLONG naxis2,     /* I - number of rows in the table              */
           int tfields,     /* I - number of columns in the table           */
           char **ttype,    /* I - name of each column                      */
           char **tform,    /* I - value of TFORMn keyword for each column  */
           char **tunit,    /* I - value of TUNITn keyword for each column  */
           const char *extnmx,   /* I - value of EXTNAME keyword, if any         */
           LONGLONG pcount,     /* I - size of the variable length heap area    */
           int *status)     /* IO - error status                            */
/*
  Put required Header keywords into the Binary Table:
*/
{
    int ii, datatype, iread = 0;
    long repeat, width;
    LONGLONG naxis1;

    char tfmt[30], name[FLEN_KEYWORD], comm[FLEN_COMMENT], extnm[FLEN_VALUE];
    char *cptr;

    if (*status > 0)
        return(*status);

    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if ((fptr->Fptr)->headend != (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
        return(*status = HEADER_NOT_EMPTY);
    else if (naxis2 < 0)
        return(*status = NEG_ROWS);
    else if (pcount < 0)
        return(*status = BAD_PCOUNT);
    else if (tfields < 0 || tfields > 999)
        return(*status = BAD_TFIELDS);

    extnm[0] = '\0';
    if (extnmx)
        strncat(extnm, extnmx, FLEN_VALUE-1);

    ffpkys(fptr, "XTENSION", "BINTABLE", "binary table extension", status);
    ffpkyj(fptr, "BITPIX", 8, "8-bit bytes", status);
    ffpkyj(fptr, "NAXIS", 2, "2-dimensional binary table", status);

    naxis1 = 0;
    for (ii = 0; ii < tfields; ii++)  /* sum the width of each field */
    {
        ffbnfm(tform[ii], &datatype, &repeat, &width, status);

        if (datatype == TSTRING)
            naxis1 += repeat;   /* one byte per char */
        else if (datatype == TBIT)
            naxis1 += (repeat + 7) / 8;
        else if (datatype > 0)
            naxis1 += repeat * (datatype / 10);
        else if (tform[ii][0] == 'P' || tform[ii][1] == 'P')
           /* this is a 'P' variable length descriptor (neg. datatype) */
            naxis1 += 8;
        else
           /* this is a 'Q' variable length descriptor (neg. datatype) */
            naxis1 += 16;

        if (*status > 0)
            break;       /* abort loop on error */
    }

    ffpkyj(fptr, "NAXIS1", naxis1, "width of table in bytes", status);
    ffpkyj(fptr, "NAXIS2", naxis2, "number of rows in table", status);

    /*
      the initial value of PCOUNT (= size of the variable length array heap)
      should always be zero.  If any variable length data is written, then
      the value of PCOUNT will be updated when the HDU is closed
    */
    ffpkyj(fptr, "PCOUNT", 0, "size of special data area", status);
    ffpkyj(fptr, "GCOUNT", 1, "one data group (required keyword)", status);
    ffpkyj(fptr, "TFIELDS", tfields, "number of fields in each row", status);

    for (ii = 0; ii < tfields; ii++) /* loop over every column */
    {
        if ( *(ttype[ii]) )  /* optional TTYPEn keyword */
        {
          sprintf(comm, "label for field %3d", ii + 1);
          ffkeyn("TTYPE", ii + 1, name, status);
          ffpkys(fptr, name, ttype[ii], comm, status);
        }

        strcpy(tfmt, tform[ii]);  /* required TFORMn keyword */
        ffupch(tfmt);

        ffkeyn("TFORM", ii + 1, name, status);
        strcpy(comm, "data format of field");

        ffbnfm(tfmt, &datatype, &repeat, &width, status);

        if (datatype == TSTRING)
        {
            strcat(comm, ": ASCII Character");

            /* Do sanity check to see if an ASCII table format was used,  */
            /* e.g., 'A8' instead of '8A', or a bad unit width eg '8A9'.  */
            /* Don't want to return an error status, so write error into  */
            /* the keyword comment.  */

            cptr = strchr(tfmt,'A');
            cptr++;

            if (cptr)
               iread = sscanf(cptr,"%ld", &width);

            if (iread == 1 && (width > repeat)) 
            {
              if (repeat == 1)
                strcpy(comm, "ERROR??  USING ASCII TABLE SYNTAX BY MISTAKE??");
              else
                strcpy(comm, "rAw FORMAT ERROR! UNIT WIDTH w > COLUMN WIDTH r");
            }
        }
        else if (datatype == TBIT)
           strcat(comm, ": BIT");
        else if (datatype == TBYTE)
           strcat(comm, ": BYTE");
        else if (datatype == TLOGICAL)
           strcat(comm, ": 1-byte LOGICAL");
        else if (datatype == TSHORT)
           strcat(comm, ": 2-byte INTEGER");
        else if (datatype == TUSHORT)
           strcat(comm, ": 2-byte INTEGER");
        else if (datatype == TLONG)
           strcat(comm, ": 4-byte INTEGER");
        else if (datatype == TLONGLONG)
           strcat(comm, ": 8-byte INTEGER");
        else if (datatype == TULONG)
           strcat(comm, ": 4-byte INTEGER");
        else if (datatype == TFLOAT)
           strcat(comm, ": 4-byte REAL");
        else if (datatype == TDOUBLE)
           strcat(comm, ": 8-byte DOUBLE");
        else if (datatype == TCOMPLEX)
           strcat(comm, ": COMPLEX");
        else if (datatype == TDBLCOMPLEX)
           strcat(comm, ": DOUBLE COMPLEX");
        else if (datatype < 0)
           strcat(comm, ": variable length array");

        if (abs(datatype) == TSBYTE) /* signed bytes */
        {
           /* Replace the 'S' with an 'B' in the TFORMn code */
           cptr = tfmt;
           while (*cptr != 'S') 
              cptr++;

           *cptr = 'B';
           ffpkys(fptr, name, tfmt, comm, status);

           /* write the TZEROn and TSCALn keywords */
           ffkeyn("TZERO", ii + 1, name, status);
           strcpy(comm, "offset for signed bytes");

           ffpkyg(fptr, name, -128., 0, comm, status);

           ffkeyn("TSCAL", ii + 1, name, status);
           strcpy(comm, "data are not scaled");
           ffpkyg(fptr, name, 1., 0, comm, status);
        }
        else if (abs(datatype) == TUSHORT) 
        {
           /* Replace the 'U' with an 'I' in the TFORMn code */
           cptr = tfmt;
           while (*cptr != 'U') 
              cptr++;

           *cptr = 'I';
           ffpkys(fptr, name, tfmt, comm, status);

           /* write the TZEROn and TSCALn keywords */
           ffkeyn("TZERO", ii + 1, name, status);
           strcpy(comm, "offset for unsigned integers");

           ffpkyg(fptr, name, 32768., 0, comm, status);

           ffkeyn("TSCAL", ii + 1, name, status);
           strcpy(comm, "data are not scaled");
           ffpkyg(fptr, name, 1., 0, comm, status);
        }
        else if (abs(datatype) == TULONG) 
        {
           /* Replace the 'V' with an 'J' in the TFORMn code */
           cptr = tfmt;
           while (*cptr != 'V') 
              cptr++;

           *cptr = 'J';
           ffpkys(fptr, name, tfmt, comm, status);

           /* write the TZEROn and TSCALn keywords */
           ffkeyn("TZERO", ii + 1, name, status);
           strcpy(comm, "offset for unsigned integers");

           ffpkyg(fptr, name, 2147483648., 0, comm, status);

           ffkeyn("TSCAL", ii + 1, name, status);
           strcpy(comm, "data are not scaled");
           ffpkyg(fptr, name, 1., 0, comm, status);
        }
        else
        {
           ffpkys(fptr, name, tfmt, comm, status);
        }

        if (tunit)
        {
         if (tunit[ii] && *(tunit[ii]) ) /* optional TUNITn keyword */
         {
          ffkeyn("TUNIT", ii + 1, name, status);
          ffpkys(fptr, name, tunit[ii],
             "physical unit of field", status);
         }
        }

        if (*status > 0)
            break;       /* abort loop on error */
    }

    if (extnm[0])       /* optional EXTNAME keyword */
        ffpkys(fptr, "EXTNAME", extnm,
               "name of this binary table extension", status);

    if (*status > 0)
        ffpmsg("Failed to write binary table header keywords (ffphbn)");

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffphext(fitsfile *fptr,  /* I - FITS file pointer                       */
           const char *xtensionx,   /* I - value for the XTENSION keyword          */
           int bitpix,       /* I - value for the BIXPIX keyword            */
           int naxis,        /* I - value for the NAXIS keyword             */
           long naxes[],     /* I - value for the NAXISn keywords           */
           LONGLONG pcount,  /* I - value for the PCOUNT keyword            */
           LONGLONG gcount,  /* I - value for the GCOUNT keyword            */
           int *status)      /* IO - error status                           */
/*
  Put required Header keywords into a conforming extension:
*/
{
    char message[FLEN_ERRMSG],comm[81], name[20], xtension[FLEN_VALUE];
    int ii;
 
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    if (*status > 0)
        return(*status);
    else if ((fptr->Fptr)->headend != (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
        return(*status = HEADER_NOT_EMPTY);

    if (naxis < 0 || naxis > 999)
    {
        sprintf(message,
        "Illegal value for NAXIS keyword: %d", naxis);
        ffpmsg(message);
        return(*status = BAD_NAXIS);
    }

    xtension[0] = '\0';
    strncat(xtension, xtensionx, FLEN_VALUE-1);

    ffpkys(fptr, "XTENSION", xtension, "extension type", status);
    ffpkyj(fptr, "BITPIX",   bitpix,   "number of bits per data pixel", status);
    ffpkyj(fptr, "NAXIS",    naxis,    "number of data axes", status);

    strcpy(comm, "length of data axis ");
    for (ii = 0; ii < naxis; ii++)
    {
        if (naxes[ii] < 0)
        {
            sprintf(message,
            "Illegal negative value for NAXIS%d keyword: %.0f", ii + 1, (double) (naxes[ii]));
            ffpmsg(message);
            return(*status = BAD_NAXES);
        }

        sprintf(&comm[20], "%d", ii + 1);
        ffkeyn("NAXIS", ii + 1, name, status);
        ffpkyj(fptr, name, naxes[ii], comm, status);
    }


    ffpkyj(fptr, "PCOUNT", pcount, " ", status);
    ffpkyj(fptr, "GCOUNT", gcount, " ", status);

    if (*status > 0)
        ffpmsg("Failed to write extension header keywords (ffphext)");

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffi2c(LONGLONG ival,  /* I - value to be converted to a string */
          char *cval,     /* O - character string representation of the value */
          int *status)    /* IO - error status */
/*
  convert  value to a null-terminated formatted string.
*/
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    cval[0] = '\0';

#if defined(_MSC_VER)
    /* Microsoft Visual C++ 6.0 uses '%I64d' syntax  for 8-byte integers */
    if (sprintf(cval, "%I64d", ival) < 0)

#elif (USE_LL_SUFFIX == 1)
    if (sprintf(cval, "%lld", ival) < 0)
#else
    if (sprintf(cval, "%ld", ival) < 0)
#endif
    {
        ffpmsg("Error in ffi2c converting integer to string");
        *status = BAD_I2C;
    }
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffl2c(int lval,    /* I - value to be converted to a string */
          char *cval,  /* O - character string representation of the value */
          int *status) /* IO - error status ) */
/*
  convert logical value to a null-terminated formatted string.  If the
  input value == 0, then the output character is the letter F, else
  the output character is the letter T.  The output string is null terminated.
*/
{
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (lval)
        strcpy(cval,"T");
    else
        strcpy(cval,"F");

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffs2c(const char *instr, /* I - null terminated input string  */
          char *outstr,      /* O - null terminated quoted output string */
          int *status)       /* IO - error status */
/*
  convert an input string to a quoted string. Leading spaces 
  are significant.  FITS string keyword values must be at least 
  8 chars long so pad out string with spaces if necessary.
      Example:   km/s ==> 'km/s    '
  Single quote characters in the input string will be replace by
  two single quote characters. e.g., o'brian ==> 'o''brian'
*/
{
    size_t len, ii, jj;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    if (!instr)            /* a null input pointer?? */
    {
       strcpy(outstr, "''");   /* a null FITS string */
       return(*status);
    }

    outstr[0] = '\'';      /* start output string with a quote */

    len = strlen(instr);
    if (len > 68)
        len = 68;    /* limit input string to 68 chars */

    for (ii=0, jj=1; ii < len && jj < 69; ii++, jj++)
    {
        outstr[jj] = instr[ii];  /* copy each char from input to output */
        if (instr[ii] == '\'')
        {
            jj++;
            outstr[jj]='\'';   /* duplicate any apostrophies in the input */
        }
    }

    for (; jj < 9; jj++)       /* pad string so it is at least 8 chars long */
        outstr[jj] = ' ';

    if (jj == 70)   /* only occurs if the last char of string was a quote */
        outstr[69] = '\0';
    else
    {
        outstr[jj] = '\'';         /* append closing quote character */
        outstr[jj+1] = '\0';          /* terminate the string */
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr2f(float fval,   /* I - value to be converted to a string */
          int  decim,   /* I - number of decimal places to display */
          char *cval,   /* O - character string representation of the value */
          int  *status) /* IO - error status */
/*
  convert float value to a null-terminated F format string
*/
{
    char *cptr;
        
    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    cval[0] = '\0';

    if (decim < 0)
    {
        ffpmsg("Error in ffr2f:  no. of decimal places < 0");
        return(*status = BAD_DECIM);
    }

    if (sprintf(cval, "%.*f", decim, fval) < 0)
    {
        ffpmsg("Error in ffr2f converting float to string");
        *status = BAD_F2C;
    }

    /* replace comma with a period (e.g. in French locale) */
    if ( (cptr = strchr(cval, ','))) *cptr = '.';

    /* test if output string is 'NaN', 'INDEF', or 'INF' */
    if (strchr(cval, 'N'))
    {
        ffpmsg("Error in ffr2f: float value is a NaN or INDEF");
        *status = BAD_F2C;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffr2e(float fval,  /* I - value to be converted to a string */
         int decim,    /* I - number of decimal places to display */
         char *cval,   /* O - character string representation of the value */
         int *status)  /* IO - error status */
/*
  convert float value to a null-terminated exponential format string
*/
{
    char *cptr;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    cval[0] = '\0';

    if (decim < 0)
    {   /* use G format if decim is negative */
        if ( sprintf(cval, "%.*G", -decim, fval) < 0)
        {
            ffpmsg("Error in ffr2e converting float to string");
            *status = BAD_F2C;
        }
        else
        {
            /* test if E format was used, and there is no displayed decimal */
            if ( !strchr(cval, '.') && strchr(cval,'E') )
            {
                /* reformat value with a decimal point and single zero */
                if ( sprintf(cval, "%.1E", fval) < 0)
                {
                    ffpmsg("Error in ffr2e converting float to string");
                    *status = BAD_F2C;
                }

                return(*status);  
            }
        }
    }
    else
    {
        if ( sprintf(cval, "%.*E", decim, fval) < 0)
        {
            ffpmsg("Error in ffr2e converting float to string");
            *status = BAD_F2C;
        }
    }

    if (*status <= 0)
    {
        /* replace comma with a period (e.g. in French locale) */
        if ( (cptr = strchr(cval, ','))) *cptr = '.';

        /* test if output string is 'NaN', 'INDEF', or 'INF' */
        if (strchr(cval, 'N'))
        {
            ffpmsg("Error in ffr2e: float value is a NaN or INDEF");
            *status = BAD_F2C;
        }
        else if ( !strchr(cval, '.') && !strchr(cval,'E') )
        {
            /* add decimal point if necessary to distinquish from integer */
            strcat(cval, ".");
        }
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffd2f(double dval,  /* I - value to be converted to a string */
          int decim,    /* I - number of decimal places to display */
          char *cval,   /* O - character string representation of the value */
          int *status)  /* IO - error status */
/*
  convert double value to a null-terminated F format string
*/
{
    char *cptr;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    cval[0] = '\0';

    if (decim < 0)
    {
        ffpmsg("Error in ffd2f:  no. of decimal places < 0");
        return(*status = BAD_DECIM);
    }

    if (sprintf(cval, "%.*f", decim, dval) < 0)
    {
        ffpmsg("Error in ffd2f converting double to string");
        *status = BAD_F2C;
    }

    /* replace comma with a period (e.g. in French locale) */
    if ( (cptr = strchr(cval, ','))) *cptr = '.';

    /* test if output string is 'NaN', 'INDEF', or 'INF' */
    if (strchr(cval, 'N'))
    {
        ffpmsg("Error in ffd2f: double value is a NaN or INDEF");
        *status = BAD_F2C;
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffd2e(double dval,  /* I - value to be converted to a string */
          int decim,    /* I - number of decimal places to display */
          char *cval,   /* O - character string representation of the value */
          int *status)  /* IO - error status */
/*
  convert double value to a null-terminated exponential format string.
*/
{
    char *cptr;

    if (*status > 0)           /* inherit input status value if > 0 */
        return(*status);

    cval[0] = '\0';

    if (decim < 0)
    {   /* use G format if decim is negative */
        if ( sprintf(cval, "%.*G", -decim, dval) < 0)
        {
            ffpmsg("Error in ffd2e converting float to string");
            *status = BAD_F2C;
        }
        else
        {
            /* test if E format was used, and there is no displayed decimal */
            if ( !strchr(cval, '.') && strchr(cval,'E') )
            {
                /* reformat value with a decimal point and single zero */
                if ( sprintf(cval, "%.1E", dval) < 0)
                {
                    ffpmsg("Error in ffd2e converting float to string");
                    *status = BAD_F2C;
                }

                return(*status);  
            }
        }
    }
    else
    {
        if ( sprintf(cval, "%.*E", decim, dval) < 0)
        {
            ffpmsg("Error in ffd2e converting float to string");
            *status = BAD_F2C;
        }
    }

    if (*status <= 0)
    {
        /* replace comma with a period (e.g. in French locale) */
        if ( (cptr = strchr(cval, ','))) *cptr = '.';

        /* test if output string is 'NaN', 'INDEF', or 'INF' */
        if (strchr(cval, 'N'))
        {
            ffpmsg("Error in ffd2e: double value is a NaN or INDEF");
            *status = BAD_F2C;
        }
        else if ( !strchr(cval, '.') && !strchr(cval,'E') )
        {
            /* add decimal point if necessary to distinquish from integer */
            strcat(cval, ".");
        }
    }

    return(*status);
}

healpy-1.10.3/cfitsio/quantize.c0000664000175000017500000034727313010375005017004 0ustar  zoncazonca00000000000000/*
  The following code is based on algorithms written by Richard White at STScI and made
  available for use in CFITSIO in July 1999 and updated in January 2008. 
*/

# include 
# include 
# include 
# include 
# include 

#include "fitsio2.h"

/* nearest integer function */
# define NINT(x)  ((x >= 0.) ? (int) (x + 0.5) : (int) (x - 0.5))

#define NULL_VALUE -2147483647 /* value used to represent undefined pixels */
#define ZERO_VALUE -2147483646 /* value used to represent zero-valued pixels */
#define N_RESERVED_VALUES 10   /* number of reserved values, starting with */
                               /* and including NULL_VALUE.  These values */
                               /* may not be used to represent the quantized */
                               /* and scaled floating point pixel values */
			       /* If lossy Hcompression is used, and the */
			       /* array contains null values, then it is also */
			       /* possible for the compressed values to slightly */
			       /* exceed the range of the actual (lossless) values */
			       /* so we must reserve a little more space */
			       
/* more than this many standard deviations from the mean is an outlier */
# define SIGMA_CLIP     5.
# define NITER          3	/* number of sigma-clipping iterations */

static int FnMeanSigma_short(short *array, long npix, int nullcheck, 
  short nullvalue, long *ngoodpix, double *mean, double *sigma, int *status);       
static int FnMeanSigma_int(int *array, long npix, int nullcheck,
  int nullvalue, long *ngoodpix, double *mean, double *sigma, int *status);       
static int FnMeanSigma_float(float *array, long npix, int nullcheck,
  float nullvalue, long *ngoodpix, double *mean, double *sigma, int *status);       
static int FnMeanSigma_double(double *array, long npix, int nullcheck,
  double nullvalue, long *ngoodpix, double *mean, double *sigma, int *status);       

static int FnNoise5_short(short *array, long nx, long ny, int nullcheck, 
   short nullvalue, long *ngood, short *minval, short *maxval, 
   double *n2, double *n3, double *n5, int *status);   
static int FnNoise5_int(int *array, long nx, long ny, int nullcheck, 
   int nullvalue, long *ngood, int *minval, int *maxval, 
   double *n2, double *n3, double *n5, int *status);   
static int FnNoise5_float(float *array, long nx, long ny, int nullcheck, 
   float nullvalue, long *ngood, float *minval, float *maxval, 
   double *n2, double *n3, double *n5, int *status);   
static int FnNoise5_double(double *array, long nx, long ny, int nullcheck, 
   double nullvalue, long *ngood, double *minval, double *maxval, 
   double *n2, double *n3, double *n5, int *status);   

static int FnNoise3_short(short *array, long nx, long ny, int nullcheck, 
   short nullvalue, long *ngood, short *minval, short *maxval, double *noise, int *status);       
static int FnNoise3_int(int *array, long nx, long ny, int nullcheck, 
   int nullvalue, long *ngood, int *minval, int *maxval, double *noise, int *status);          
static int FnNoise3_float(float *array, long nx, long ny, int nullcheck, 
   float nullvalue, long *ngood, float *minval, float *maxval, double *noise, int *status);        
static int FnNoise3_double(double *array, long nx, long ny, int nullcheck, 
   double nullvalue, long *ngood, double *minval, double *maxval, double *noise, int *status);        

static int FnNoise1_short(short *array, long nx, long ny, 
   int nullcheck, short nullvalue, double *noise, int *status);       
static int FnNoise1_int(int *array, long nx, long ny, 
   int nullcheck, int nullvalue, double *noise, int *status);       
static int FnNoise1_float(float *array, long nx, long ny, 
   int nullcheck, float nullvalue, double *noise, int *status);       
static int FnNoise1_double(double *array, long nx, long ny, 
   int nullcheck, double nullvalue, double *noise, int *status);       

static int FnCompare_short (const void *, const void *);
static int FnCompare_int (const void *, const void *);
static int FnCompare_float (const void *, const void *);
static int FnCompare_double (const void *, const void *);
static float quick_select_float(float arr[], int n);
static short quick_select_short(short arr[], int n);
static int quick_select_int(int arr[], int n);
static LONGLONG quick_select_longlong(LONGLONG arr[], int n);
static double quick_select_double(double arr[], int n);

/*---------------------------------------------------------------------------*/
int fits_quantize_float (long row, float fdata[], long nxpix, long nypix, int nullcheck, 
	float in_null_value, float qlevel, int dither_method, int idata[], double *bscale,
	double *bzero, int *iminval, int *imaxval) {

/* arguments:
long row            i: if positive, used to calculate random dithering seed value
                       (this is only used when dithering the quantized values)
float fdata[]       i: array of image pixels to be compressed
long nxpix          i: number of pixels in each row of fdata
long nypix          i: number of rows in fdata
nullcheck           i: check for nullvalues in fdata?
float in_null_value i: value used to represent undefined pixels in fdata
float qlevel        i: quantization level
int dither_method   i; which dithering method to use
int idata[]         o: values of fdata after applying bzero and bscale
double bscale       o: scale factor
double bzero        o: zero offset
int iminval         o: minimum quantized value that is returned
int imaxval         o: maximum quantized value that is returned

The function value will be one if the input fdata were copied to idata;
in this case the parameters bscale and bzero can be used to convert back to
nearly the original floating point values:  fdata ~= idata * bscale + bzero.
If the function value is zero, the data were not copied to idata.
*/

	int status, iseed = 0;
	long i, nx, ngood = 0;
	double stdev, noise2, noise3, noise5;	/* MAD 2nd, 3rd, and 5th order noise values */
	float minval = 0., maxval = 0.;  /* min & max of fdata */
	double delta;		/* bscale, 1 in idata = delta in fdata */
	double zeropt;	        /* bzero */
	double temp;
        int nextrand = 0;
	extern float *fits_rand_value; /* this is defined in imcompress.c */
	LONGLONG iqfactor;

	nx = nxpix * nypix;
	if (nx <= 1) {
	    *bscale = 1.;
	    *bzero  = 0.;
	    return (0);
	}

        if (qlevel >= 0.) {

	    /* estimate background noise using MAD pixel differences */
	    FnNoise5_float(fdata, nxpix, nypix, nullcheck, in_null_value, &ngood,
	        &minval, &maxval, &noise2, &noise3, &noise5, &status);      

	    if (nullcheck && ngood == 0) {   /* special case of an image filled with Nulls */
	        /* set parameters to dummy values, which are not used */
		minval = 0.;
		maxval = 1.;
		stdev = 1;
	    } else {

	        /* use the minimum of noise2, noise3, and noise5 as the best noise value */
	        stdev = noise3;
	        if (noise2 != 0. && noise2 < stdev) stdev = noise2;
	        if (noise5 != 0. && noise5 < stdev) stdev = noise5;
            }

	    if (qlevel == 0.)
	        delta = stdev / 4.;  /* default quantization */
	    else
	        delta = stdev / qlevel;

	    if (delta == 0.) 
	        return (0);			/* don't quantize */

	} else {
	    /* negative value represents the absolute quantization level */
	    delta = -qlevel;

	    /* only nned to calculate the min and max values */
	    FnNoise3_float(fdata, nxpix, nypix, nullcheck, in_null_value, &ngood,
	        &minval, &maxval, 0, &status);      
 	}

        /* check that the range of quantized levels is not > range of int */
	if ((maxval - minval) / delta > 2. * 2147483647. - N_RESERVED_VALUES )
	    return (0);			/* don't quantize */

        if (row > 0) { /* we need to dither the quantized values */
            if (!fits_rand_value) 
	        if (fits_init_randoms()) return(MEMORY_ALLOCATION);

	    /* initialize the index to the next random number in the list */
            iseed = (int) ((row - 1) % N_RANDOM);
	    nextrand = (int) (fits_rand_value[iseed] * 500.);
	}

        if (ngood == nx) {   /* don't have to check for nulls */
            /* return all positive values, if possible since some */
            /* compression algorithms either only work for positive integers, */
            /* or are more efficient.  */

            if (dither_method == SUBTRACTIVE_DITHER_2)
	    {
                /* shift the range to be close to the value used to represent zeros */
                zeropt = minval - delta * (NULL_VALUE + N_RESERVED_VALUES);
            }
	    else if ((maxval - minval) / delta < 2147483647. - N_RESERVED_VALUES )
            {
                zeropt = minval;
		/* fudge the zero point so it is an integer multiple of delta */
		/* This helps to ensure the same scaling will be performed if the */
		/* file undergoes multiple fpack/funpack cycles */
		iqfactor = (LONGLONG) (zeropt/delta  + 0.5);
		zeropt = iqfactor * delta;               
            }
            else
            {
                /* center the quantized levels around zero */
                zeropt = (minval + maxval) / 2.;
            }

            if (row > 0) {  /* dither the values when quantizing */
              for (i = 0;  i < nx;  i++) {
	    
		if (dither_method == SUBTRACTIVE_DITHER_2 && fdata[i] == 0.0) {
		   idata[i] = ZERO_VALUE;
		} else {
		   idata[i] =  NINT((((double) fdata[i] - zeropt) / delta) + fits_rand_value[nextrand] - 0.5);
		}

                nextrand++;
		if (nextrand == N_RANDOM) {
                    iseed++;
		    if (iseed == N_RANDOM) iseed = 0;
	            nextrand = (int) (fits_rand_value[iseed] * 500);
                }
              }
            } else {  /* do not dither the values */

       	        for (i = 0;  i < nx;  i++) {
	            idata[i] = NINT ((fdata[i] - zeropt) / delta);
                }
            } 
        }
        else {
            /* data contains null values; shift the range to be */
            /* close to the value used to represent null values */
            zeropt = minval - delta * (NULL_VALUE + N_RESERVED_VALUES);

            if (row > 0) {  /* dither the values */
	      for (i = 0;  i < nx;  i++) {
                if (fdata[i] != in_null_value) {
		    if (dither_method == SUBTRACTIVE_DITHER_2 && fdata[i] == 0.0) {
		       idata[i] = ZERO_VALUE;
		    } else {
		       idata[i] =  NINT((((double) fdata[i] - zeropt) / delta) + fits_rand_value[nextrand] - 0.5);
		    }
                } else {
                    idata[i] = NULL_VALUE;
                }

                /* increment the random number index, regardless */
                nextrand++;
		if (nextrand == N_RANDOM) {
                      iseed++;
		      if (iseed == N_RANDOM) iseed = 0;
	              nextrand = (int) (fits_rand_value[iseed] * 500);
                }
              }
            } else {  /* do not dither the values */
	       for (i = 0;  i < nx;  i++) {
 
                 if (fdata[i] != in_null_value) {
		    idata[i] =  NINT((fdata[i] - zeropt) / delta);
                 } else { 
                    idata[i] = NULL_VALUE;
                 }
               }
            }
	}

        /* calc min and max values */
        temp = (minval - zeropt) / delta;
        *iminval =  NINT (temp);
        temp = (maxval - zeropt) / delta;
        *imaxval =  NINT (temp);

	*bscale = delta;
	*bzero = zeropt;
	return (1);			/* yes, data have been quantized */
}
/*---------------------------------------------------------------------------*/
int fits_quantize_double (long row, double fdata[], long nxpix, long nypix, int nullcheck, 
	double in_null_value, float qlevel, int dither_method, int idata[], double *bscale,
	double *bzero, int *iminval, int *imaxval) {

/* arguments:
long row            i: tile number = row number in the binary table
double fdata[]      i: array of image pixels to be compressed
long nxpix          i: number of pixels in each row of fdata
long nypix          i: number of rows in fdata
nullcheck           i: check for nullvalues in fdata?
double in_null_value i: value used to represent undefined pixels in fdata
float qlevel        i: quantization level
int dither_method   i; which dithering method to use
int idata[]         o: values of fdata after applying bzero and bscale
double bscale       o: scale factor
double bzero        o: zero offset
int iminval         o: minimum quantized value that is returned
int imaxval         o: maximum quantized value that is returned

The function value will be one if the input fdata were copied to idata;
in this case the parameters bscale and bzero can be used to convert back to
nearly the original floating point values:  fdata ~= idata * bscale + bzero.
If the function value is zero, the data were not copied to idata.
*/

	int status, iseed = 0;
	long i, nx, ngood = 0;
	double stdev, noise2 = 0., noise3 = 0., noise5 = 0.;	/* MAD 2nd, 3rd, and 5th order noise values */
	double minval = 0., maxval = 0.;  /* min & max of fdata */
	double delta;		/* bscale, 1 in idata = delta in fdata */
	double zeropt;	        /* bzero */
	double temp;
        int nextrand = 0;
	extern float *fits_rand_value;
	LONGLONG iqfactor;

	nx = nxpix * nypix;
	if (nx <= 1) {
	    *bscale = 1.;
	    *bzero  = 0.;
	    return (0);
	}

        if (qlevel >= 0.) {

	    /* estimate background noise using MAD pixel differences */
	    FnNoise5_double(fdata, nxpix, nypix, nullcheck, in_null_value, &ngood,
	        &minval, &maxval, &noise2, &noise3, &noise5, &status);      

	    if (nullcheck && ngood == 0) {   /* special case of an image filled with Nulls */
	        /* set parameters to dummy values, which are not used */
		minval = 0.;
		maxval = 1.;
		stdev = 1;
	    } else {

	        /* use the minimum of noise2, noise3, and noise5 as the best noise value */
	        stdev = noise3;
	        if (noise2 != 0. && noise2 < stdev) stdev = noise2;
	        if (noise5 != 0. && noise5 < stdev) stdev = noise5;
            }

	    if (qlevel == 0.)
	        delta = stdev / 4.;  /* default quantization */
	    else
	        delta = stdev / qlevel;

	    if (delta == 0.) 
	        return (0);			/* don't quantize */

	} else {
	    /* negative value represents the absolute quantization level */
	    delta = -qlevel;

	    /* only nned to calculate the min and max values */
	    FnNoise3_double(fdata, nxpix, nypix, nullcheck, in_null_value, &ngood,
	        &minval, &maxval, 0, &status);      
 	}

        /* check that the range of quantized levels is not > range of int */
	if ((maxval - minval) / delta > 2. * 2147483647. - N_RESERVED_VALUES )
	    return (0);			/* don't quantize */

        if (row > 0) { /* we need to dither the quantized values */
            if (!fits_rand_value) 
	       if (fits_init_randoms()) return(MEMORY_ALLOCATION);

	    /* initialize the index to the next random number in the list */
            iseed = (int) ((row - 1) % N_RANDOM);
	    nextrand = (int) (fits_rand_value[iseed] * 500);
	}

        if (ngood == nx) {   /* don't have to check for nulls */
            /* return all positive values, if possible since some */
            /* compression algorithms either only work for positive integers, */
            /* or are more efficient.  */

            if (dither_method == SUBTRACTIVE_DITHER_2)
	    {
                /* shift the range to be close to the value used to represent zeros */
                zeropt = minval - delta * (NULL_VALUE + N_RESERVED_VALUES);
            }
	    else if ((maxval - minval) / delta < 2147483647. - N_RESERVED_VALUES )
            {
                zeropt = minval;
		/* fudge the zero point so it is an integer multiple of delta */
		/* This helps to ensure the same scaling will be performed if the */
		/* file undergoes multiple fpack/funpack cycles */
		iqfactor = (LONGLONG) (zeropt/delta  + 0.5);
		zeropt = iqfactor * delta;               
            }
            else
            {
                /* center the quantized levels around zero */
                zeropt = (minval + maxval) / 2.;
            }

            if (row > 0) {  /* dither the values when quantizing */
       	      for (i = 0;  i < nx;  i++) {

		if (dither_method == SUBTRACTIVE_DITHER_2 && fdata[i] == 0.0) {
		   idata[i] = ZERO_VALUE;
		} else {
		   idata[i] =  NINT((((double) fdata[i] - zeropt) / delta) + fits_rand_value[nextrand] - 0.5);
		}

                nextrand++;
		if (nextrand == N_RANDOM) {
                    iseed++;
	            nextrand = (int) (fits_rand_value[iseed] * 500);
                }
              }
            } else {  /* do not dither the values */

       	        for (i = 0;  i < nx;  i++) {
	            idata[i] = NINT ((fdata[i] - zeropt) / delta);
                }
            } 
        }
        else {
            /* data contains null values; shift the range to be */
            /* close to the value used to represent null values */
            zeropt = minval - delta * (NULL_VALUE + N_RESERVED_VALUES);

            if (row > 0) {  /* dither the values */
	      for (i = 0;  i < nx;  i++) {
                if (fdata[i] != in_null_value) {
		    if (dither_method == SUBTRACTIVE_DITHER_2 && fdata[i] == 0.0) {
		       idata[i] = ZERO_VALUE;
		    } else {
		       idata[i] =  NINT((((double) fdata[i] - zeropt) / delta) + fits_rand_value[nextrand] - 0.5);
		    }
                } else {
                    idata[i] = NULL_VALUE;
                }

                /* increment the random number index, regardless */
                nextrand++;
		if (nextrand == N_RANDOM) {
                        iseed++;
	                nextrand = (int) (fits_rand_value[iseed] * 500);
                } 
              }
            } else {  /* do not dither the values */
	       for (i = 0;  i < nx;  i++) {
                 if (fdata[i] != in_null_value)
		    idata[i] =  NINT((fdata[i] - zeropt) / delta);
                 else 
                    idata[i] = NULL_VALUE;
               }
            }
	}

        /* calc min and max values */
        temp = (minval - zeropt) / delta;
        *iminval =  NINT (temp);
        temp = (maxval - zeropt) / delta;
        *imaxval =  NINT (temp);

	*bscale = delta;
	*bzero = zeropt;

	return (1);			/* yes, data have been quantized */
}
/*--------------------------------------------------------------------------*/
int fits_img_stats_short(short *array, /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
	long ny,            /* number of rows in the image */
	                    /* (if this is a 3D image, then ny should be the */
			    /* product of the no. of rows times the no. of planes) */
	int nullcheck,      /* check for null values, if true */
	short nullvalue,    /* value of null pixels, if nullcheck is true */

   /* returned parameters (if the pointer is not null)  */
	long *ngoodpix,     /* number of non-null pixels in the image */
	short *minvalue,    /* returned minimum non-null value in the array */
	short *maxvalue,    /* returned maximum non-null value in the array */
	double *mean,       /* returned mean value of all non-null pixels */
	double *sigma,      /* returned R.M.S. value of all non-null pixels */
	double *noise1,     /* 1st order estimate of noise in image background level */
	double *noise2,     /* 2nd order estimate of noise in image background level */
	double *noise3,     /* 3rd order estimate of noise in image background level */
	double *noise5,     /* 5th order estimate of noise in image background level */
	int *status)        /* error status */

/*
    Compute statistics of the input short integer image.
*/
{
	long ngood;
	short minval = 0, maxval = 0;
	double xmean = 0., xsigma = 0., xnoise = 0., xnoise2 = 0., xnoise3 = 0., xnoise5 = 0.;

	/* need to calculate mean and/or sigma and/or limits? */
	if (mean || sigma ) {
		FnMeanSigma_short(array, nx * ny, nullcheck, nullvalue, 
			&ngood, &xmean, &xsigma, status);

	    if (ngoodpix) *ngoodpix = ngood;
	    if (mean)     *mean = xmean;
	    if (sigma)    *sigma = xsigma;
	}

	if (noise1) {
		FnNoise1_short(array, nx, ny, nullcheck, nullvalue, 
		  &xnoise, status);

		*noise1  = xnoise;
	}

	if (minvalue || maxvalue || noise3) {
		FnNoise5_short(array, nx, ny, nullcheck, nullvalue, 
			&ngood, &minval, &maxval, &xnoise2, &xnoise3, &xnoise5, status);

		if (ngoodpix) *ngoodpix = ngood;
		if (minvalue) *minvalue= minval;
		if (maxvalue) *maxvalue = maxval;
		if (noise2) *noise2  = xnoise2;
		if (noise3) *noise3  = xnoise3;
		if (noise5) *noise5  = xnoise5;
	}
	return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_img_stats_int(int *array, /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
	long ny,            /* number of rows in the image */
	                    /* (if this is a 3D image, then ny should be the */
			    /* product of the no. of rows times the no. of planes) */
	int nullcheck,      /* check for null values, if true */
	int nullvalue,    /* value of null pixels, if nullcheck is true */

   /* returned parameters (if the pointer is not null)  */
	long *ngoodpix,     /* number of non-null pixels in the image */
	int *minvalue,    /* returned minimum non-null value in the array */
	int *maxvalue,    /* returned maximum non-null value in the array */
	double *mean,       /* returned mean value of all non-null pixels */
	double *sigma,      /* returned R.M.S. value of all non-null pixels */
	double *noise1,     /* 1st order estimate of noise in image background level */
	double *noise2,     /* 2nd order estimate of noise in image background level */
	double *noise3,     /* 3rd order estimate of noise in image background level */
	double *noise5,     /* 5th order estimate of noise in image background level */
	int *status)        /* error status */

/*
    Compute statistics of the input integer image.
*/
{
	long ngood;
	int minval = 0, maxval = 0;
	double xmean = 0., xsigma = 0., xnoise = 0., xnoise2 = 0., xnoise3 = 0., xnoise5 = 0.;

	/* need to calculate mean and/or sigma and/or limits? */
	if (mean || sigma ) {
		FnMeanSigma_int(array, nx * ny, nullcheck, nullvalue, 
			&ngood, &xmean, &xsigma, status);

	    if (ngoodpix) *ngoodpix = ngood;
	    if (mean)     *mean = xmean;
	    if (sigma)    *sigma = xsigma;
	}

	if (noise1) {
		FnNoise1_int(array, nx, ny, nullcheck, nullvalue, 
		  &xnoise, status);

		*noise1  = xnoise;
	}

	if (minvalue || maxvalue || noise3) {
		FnNoise5_int(array, nx, ny, nullcheck, nullvalue, 
			&ngood, &minval, &maxval, &xnoise2, &xnoise3, &xnoise5, status);

		if (ngoodpix) *ngoodpix = ngood;
		if (minvalue) *minvalue= minval;
		if (maxvalue) *maxvalue = maxval;
		if (noise2) *noise2  = xnoise2;
		if (noise3) *noise3  = xnoise3;
		if (noise5) *noise5  = xnoise5;
	}
	return(*status);
}
/*--------------------------------------------------------------------------*/
int fits_img_stats_float(float *array, /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
	long ny,            /* number of rows in the image */
	                    /* (if this is a 3D image, then ny should be the */
			    /* product of the no. of rows times the no. of planes) */
	int nullcheck,      /* check for null values, if true */
	float nullvalue,    /* value of null pixels, if nullcheck is true */

   /* returned parameters (if the pointer is not null)  */
	long *ngoodpix,     /* number of non-null pixels in the image */
	float *minvalue,    /* returned minimum non-null value in the array */
	float *maxvalue,    /* returned maximum non-null value in the array */
	double *mean,       /* returned mean value of all non-null pixels */
	double *sigma,      /* returned R.M.S. value of all non-null pixels */
	double *noise1,     /* 1st order estimate of noise in image background level */
	double *noise2,     /* 2nd order estimate of noise in image background level */
	double *noise3,     /* 3rd order estimate of noise in image background level */
	double *noise5,     /* 5th order estimate of noise in image background level */
	int *status)        /* error status */

/*
    Compute statistics of the input float image.
*/
{
	long ngood;
	float minval, maxval;
	double xmean = 0., xsigma = 0., xnoise = 0., xnoise2 = 0., xnoise3 = 0., xnoise5 = 0.;

	/* need to calculate mean and/or sigma and/or limits? */
	if (mean || sigma ) {
		FnMeanSigma_float(array, nx * ny, nullcheck, nullvalue, 
			&ngood, &xmean, &xsigma, status);

	    if (ngoodpix) *ngoodpix = ngood;
	    if (mean)     *mean = xmean;
	    if (sigma)    *sigma = xsigma;
	}

	if (noise1) {
		FnNoise1_float(array, nx, ny, nullcheck, nullvalue, 
		  &xnoise, status);

		*noise1  = xnoise;
	}

	if (minvalue || maxvalue || noise3) {
		FnNoise5_float(array, nx, ny, nullcheck, nullvalue, 
			&ngood, &minval, &maxval, &xnoise2, &xnoise3, &xnoise5, status);

		if (ngoodpix) *ngoodpix = ngood;
		if (minvalue) *minvalue= minval;
		if (maxvalue) *maxvalue = maxval;
		if (noise2) *noise2  = xnoise2;
		if (noise3) *noise3  = xnoise3;
		if (noise5) *noise5  = xnoise5;
	}
	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnMeanSigma_short
       (short *array,       /*  2 dimensional array of image pixels */
        long npix,          /* number of pixels in the image */
	int nullcheck,      /* check for null values, if true */
	short nullvalue,    /* value of null pixels, if nullcheck is true */

   /* returned parameters */
   
	long *ngoodpix,     /* number of non-null pixels in the image */
	double *mean,       /* returned mean value of all non-null pixels */
	double *sigma,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */

/*
Compute mean and RMS sigma of the non-null pixels in the input array.
*/
{
	long ii, ngood = 0;
	short *value;
	double sum = 0., sum2 = 0., xtemp;

	value = array;
	    
	if (nullcheck) {
	        for (ii = 0; ii < npix; ii++, value++) {
		    if (*value != nullvalue) {
		        ngood++;
		        xtemp = (double) *value;
		        sum += xtemp;
		        sum2 += (xtemp * xtemp);
		    }
		}
	} else {
	        ngood = npix;
	        for (ii = 0; ii < npix; ii++, value++) {
		        xtemp = (double) *value;
		        sum += xtemp;
		        sum2 += (xtemp * xtemp);
		}
	}

	if (ngood > 1) {
		if (ngoodpix) *ngoodpix = ngood;
		xtemp = sum / ngood;
		if (mean)     *mean = xtemp;
		if (sigma)    *sigma = sqrt((sum2 / ngood) - (xtemp * xtemp));
	} else if (ngood == 1){
		if (ngoodpix) *ngoodpix = 1;
		if (mean)     *mean = sum;
		if (sigma)    *sigma = 0.0;
	} else {
		if (ngoodpix) *ngoodpix = 0;
	        if (mean)     *mean = 0.;
		if (sigma)    *sigma = 0.;
	}	    
	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnMeanSigma_int
       (int *array,       /*  2 dimensional array of image pixels */
        long npix,          /* number of pixels in the image */
	int nullcheck,      /* check for null values, if true */
	int nullvalue,    /* value of null pixels, if nullcheck is true */

   /* returned parameters */
   
	long *ngoodpix,     /* number of non-null pixels in the image */
	double *mean,       /* returned mean value of all non-null pixels */
	double *sigma,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */

/*
Compute mean and RMS sigma of the non-null pixels in the input array.
*/
{
	long ii, ngood = 0;
	int *value;
	double sum = 0., sum2 = 0., xtemp;

	value = array;
	    
	if (nullcheck) {
	        for (ii = 0; ii < npix; ii++, value++) {
		    if (*value != nullvalue) {
		        ngood++;
		        xtemp = (double) *value;
		        sum += xtemp;
		        sum2 += (xtemp * xtemp);
		    }
		}
	} else {
	        ngood = npix;
	        for (ii = 0; ii < npix; ii++, value++) {
		        xtemp = (double) *value;
		        sum += xtemp;
		        sum2 += (xtemp * xtemp);
		}
	}

	if (ngood > 1) {
		if (ngoodpix) *ngoodpix = ngood;
		xtemp = sum / ngood;
		if (mean)     *mean = xtemp;
		if (sigma)    *sigma = sqrt((sum2 / ngood) - (xtemp * xtemp));
	} else if (ngood == 1){
		if (ngoodpix) *ngoodpix = 1;
		if (mean)     *mean = sum;
		if (sigma)    *sigma = 0.0;
	} else {
		if (ngoodpix) *ngoodpix = 0;
	        if (mean)     *mean = 0.;
		if (sigma)    *sigma = 0.;
	}	    
	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnMeanSigma_float
       (float *array,       /*  2 dimensional array of image pixels */
        long npix,          /* number of pixels in the image */
	int nullcheck,      /* check for null values, if true */
	float nullvalue,    /* value of null pixels, if nullcheck is true */

   /* returned parameters */
   
	long *ngoodpix,     /* number of non-null pixels in the image */
	double *mean,       /* returned mean value of all non-null pixels */
	double *sigma,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */

/*
Compute mean and RMS sigma of the non-null pixels in the input array.
*/
{
	long ii, ngood = 0;
	float *value;
	double sum = 0., sum2 = 0., xtemp;

	value = array;
	    
	if (nullcheck) {
	        for (ii = 0; ii < npix; ii++, value++) {
		    if (*value != nullvalue) {
		        ngood++;
		        xtemp = (double) *value;
		        sum += xtemp;
		        sum2 += (xtemp * xtemp);
		    }
		}
	} else {
	        ngood = npix;
	        for (ii = 0; ii < npix; ii++, value++) {
		        xtemp = (double) *value;
		        sum += xtemp;
		        sum2 += (xtemp * xtemp);
		}
	}

	if (ngood > 1) {
		if (ngoodpix) *ngoodpix = ngood;
		xtemp = sum / ngood;
		if (mean)     *mean = xtemp;
		if (sigma)    *sigma = sqrt((sum2 / ngood) - (xtemp * xtemp));
	} else if (ngood == 1){
		if (ngoodpix) *ngoodpix = 1;
		if (mean)     *mean = sum;
		if (sigma)    *sigma = 0.0;
	} else {
		if (ngoodpix) *ngoodpix = 0;
	        if (mean)     *mean = 0.;
		if (sigma)    *sigma = 0.;
	}	    
	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnMeanSigma_double
       (double *array,       /*  2 dimensional array of image pixels */
        long npix,          /* number of pixels in the image */
	int nullcheck,      /* check for null values, if true */
	double nullvalue,    /* value of null pixels, if nullcheck is true */

   /* returned parameters */
   
	long *ngoodpix,     /* number of non-null pixels in the image */
	double *mean,       /* returned mean value of all non-null pixels */
	double *sigma,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */

/*
Compute mean and RMS sigma of the non-null pixels in the input array.
*/
{
	long ii, ngood = 0;
	double *value;
	double sum = 0., sum2 = 0., xtemp;

	value = array;
	    
	if (nullcheck) {
	        for (ii = 0; ii < npix; ii++, value++) {
		    if (*value != nullvalue) {
		        ngood++;
		        xtemp = *value;
		        sum += xtemp;
		        sum2 += (xtemp * xtemp);
		    }
		}
	} else {
	        ngood = npix;
	        for (ii = 0; ii < npix; ii++, value++) {
		        xtemp = *value;
		        sum += xtemp;
		        sum2 += (xtemp * xtemp);
		}
	}

	if (ngood > 1) {
		if (ngoodpix) *ngoodpix = ngood;
		xtemp = sum / ngood;
		if (mean)     *mean = xtemp;
		if (sigma)    *sigma = sqrt((sum2 / ngood) - (xtemp * xtemp));
	} else if (ngood == 1){
		if (ngoodpix) *ngoodpix = 1;
		if (mean)     *mean = sum;
		if (sigma)    *sigma = 0.0;
	} else {
		if (ngoodpix) *ngoodpix = 0;
	        if (mean)     *mean = 0.;
		if (sigma)    *sigma = 0.;
	}	    
	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise5_short
       (short *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	short nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	long *ngood,        /* number of good, non-null pixels? */
	short *minval,    /* minimum non-null value */
	short *maxval,    /* maximum non-null value */
	double *noise2,      /* returned 2nd order MAD of all non-null pixels */
	double *noise3,      /* returned 3rd order MAD of all non-null pixels */
	double *noise5,      /* returned 5th order MAD of all non-null pixels */
	int *status)        /* error status */

/*
Estimate the median and background noise in the input image using 2nd, 3rd and 5th
order Median Absolute Differences.

The noise in the background of the image is calculated using the MAD algorithms 
developed for deriving the signal to noise ratio in spectra
(see issue #42 of the ST-ECF newsletter, http://www.stecf.org/documents/newsletter/)

3rd order:  noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) - flux(i+2)))

The returned estimates are the median of the values that are computed for each 
row of the image.
*/
{
	long ii, jj, nrows = 0, nrows2 = 0, nvals, nvals2, ngoodpix = 0;
	int *differences2, *differences3, *differences5;
	short *rowpix, v1, v2, v3, v4, v5, v6, v7, v8, v9;
	short xminval = SHRT_MAX, xmaxval = SHRT_MIN;
	int do_range = 0;
	double *diffs2, *diffs3, *diffs5; 
	double xnoise2 = 0, xnoise3 = 0, xnoise5 = 0;
	
	if (nx < 5) {
		/* treat entire array as an image with a single row */
		nx = nx * ny;
		ny = 1;
	}

	/* rows must have at least 9 pixels */
	if (nx < 9) {

		for (ii = 0; ii < nx; ii++) {
		    if (nullcheck && array[ii] == nullvalue)
		        continue;
		    else {
			if (array[ii] < xminval) xminval = array[ii];
			if (array[ii] > xmaxval) xmaxval = array[ii];
			ngoodpix++;
		    }
		}
		if (minval) *minval = xminval;
		if (maxval) *maxval = xmaxval;
		if (ngood) *ngood = ngoodpix;
		if (noise2) *noise2 = 0.;
		if (noise3) *noise3 = 0.;
		if (noise5) *noise5 = 0.;
		return(*status);
	}

	/* do we need to compute the min and max value? */
	if (minval || maxval) do_range = 1;
	
        /* allocate arrays used to compute the median and noise estimates */
	differences2 = calloc(nx, sizeof(int));
	if (!differences2) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}
	differences3 = calloc(nx, sizeof(int));
	if (!differences3) {
		free(differences2);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}
	differences5 = calloc(nx, sizeof(int));
	if (!differences5) {
		free(differences2);
		free(differences3);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs2 = calloc(ny, sizeof(double));
	if (!diffs2) {
		free(differences2);
		free(differences3);
		free(differences5);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs3 = calloc(ny, sizeof(double));
	if (!diffs3) {
		free(differences2);
		free(differences3);
		free(differences5);
		free(diffs2);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs5 = calloc(ny, sizeof(double));
	if (!diffs5) {
		free(differences2);
		free(differences3);
		free(differences5);
		free(diffs2);
		free(diffs3);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v1 < xminval) xminval = v1;
			if (v1 > xmaxval) xmaxval = v1;
		}

		/***** find the 2nd valid pixel in row (which we will skip over) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v2 = rowpix[ii];  /* store the good pixel value */
		
		if (do_range) {
			if (v2 < xminval) xminval = v2;
			if (v2 > xmaxval) xmaxval = v2;
		}

		/***** find the 3rd valid pixel in row */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v3 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v3 < xminval) xminval = v3;
			if (v3 > xmaxval) xmaxval = v3;
		}
				
		/* find the 4nd valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v4 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v4 < xminval) xminval = v4;
			if (v4 > xmaxval) xmaxval = v4;
		}
			
		/* find the 5th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v5 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v5 < xminval) xminval = v5;
			if (v5 > xmaxval) xmaxval = v5;
		}
				
		/* find the 6th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v6 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v6 < xminval) xminval = v6;
			if (v6 > xmaxval) xmaxval = v6;
		}
				
		/* find the 7th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v7 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v7 < xminval) xminval = v7;
			if (v7 > xmaxval) xmaxval = v7;
		}
				
		/* find the 8th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v8 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v8 < xminval) xminval = v8;
			if (v8 > xmaxval) xmaxval = v8;
		}
		/* now populate the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		nvals2 = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		    v9 = rowpix[ii];  /* store the good pixel value */

		    if (do_range) {
			if (v9 < xminval) xminval = v9;
			if (v9 > xmaxval) xmaxval = v9;
		    }

		    /* construct array of absolute differences */

		    if (!(v5 == v6 && v6 == v7) ) {
		        differences2[nvals2] =  abs((int) v5 - (int) v7);
			nvals2++;
		    }

		    if (!(v3 == v4 && v4 == v5 && v5 == v6 && v6 == v7) ) {
		        differences3[nvals] =  abs((2 * (int) v5) - (int) v3 - (int) v7);
		        differences5[nvals] =  abs((6 * (int) v5) - (4 * (int) v3) - (4 * (int) v7) + (int) v1 + (int) v9);
		        nvals++;  
		    } else {
		        /* ignore constant background regions */
			ngoodpix++;
		    }

		    /* shift over 1 pixel */
		    v1 = v2;
		    v2 = v3;
		    v3 = v4;
		    v4 = v5;
		    v5 = v6;
		    v6 = v7;
		    v7 = v8;
		    v8 = v9;
	        }  /* end of loop over pixels in the row */

		/* compute the median diffs */
		/* Note that there are 8 more pixel values than there are diffs values. */
		ngoodpix += (nvals + 8);

		if (nvals == 0) {
		    continue;  /* cannot compute medians on this row */
		} else if (nvals == 1) {
		    if (nvals2 == 1) {
		        diffs2[nrows2] = differences2[0];
			nrows2++;
		    }
		        
		    diffs3[nrows] = differences3[0];
		    diffs5[nrows] = differences5[0];
		} else {
                    /* quick_select returns the median MUCH faster than using qsort */
		    if (nvals2 > 1) {
                        diffs2[nrows2] = quick_select_int(differences2, nvals);
			nrows2++;
		    }

                    diffs3[nrows] = quick_select_int(differences3, nvals);
                    diffs5[nrows] = quick_select_int(differences5, nvals);
		}

		nrows++;
	}  /* end of loop over rows */

	    /* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise3 = 0;
	       xnoise5 = 0;
	} else if (nrows == 1) {
	       xnoise3 = diffs3[0];
	       xnoise5 = diffs5[0];
	} else {	    
	       qsort(diffs3, nrows, sizeof(double), FnCompare_double);
	       qsort(diffs5, nrows, sizeof(double), FnCompare_double);
	       xnoise3 =  (diffs3[(nrows - 1)/2] + diffs3[nrows/2]) / 2.;
	       xnoise5 =  (diffs5[(nrows - 1)/2] + diffs5[nrows/2]) / 2.;
	}

	if (nrows2 == 0) { 
	       xnoise2 = 0;
	} else if (nrows2 == 1) {
	       xnoise2 = diffs2[0];
	} else {	    
	       qsort(diffs2, nrows2, sizeof(double), FnCompare_double);
	       xnoise2 =  (diffs2[(nrows2 - 1)/2] + diffs2[nrows2/2]) / 2.;
	}

	if (ngood)  *ngood  = ngoodpix;
	if (minval) *minval = xminval;
	if (maxval) *maxval = xmaxval;
	if (noise2)  *noise2  = 1.0483579 * xnoise2;
	if (noise3)  *noise3  = 0.6052697 * xnoise3;
	if (noise5)  *noise5  = 0.1772048 * xnoise5;

	free(diffs5);
	free(diffs3);
	free(diffs2);
	free(differences5);
	free(differences3);
	free(differences2);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise5_int
       (int *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	int nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	long *ngood,        /* number of good, non-null pixels? */
	int *minval,    /* minimum non-null value */
	int *maxval,    /* maximum non-null value */
	double *noise2,      /* returned 2nd order MAD of all non-null pixels */
	double *noise3,      /* returned 3rd order MAD of all non-null pixels */
	double *noise5,      /* returned 5th order MAD of all non-null pixels */
	int *status)        /* error status */

/*
Estimate the median and background noise in the input image using 2nd, 3rd and 5th
order Median Absolute Differences.

The noise in the background of the image is calculated using the MAD algorithms 
developed for deriving the signal to noise ratio in spectra
(see issue #42 of the ST-ECF newsletter, http://www.stecf.org/documents/newsletter/)

3rd order:  noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) - flux(i+2)))

The returned estimates are the median of the values that are computed for each 
row of the image.
*/
{
	long ii, jj, nrows = 0, nrows2 = 0, nvals, nvals2, ngoodpix = 0;
	LONGLONG *differences2, *differences3, *differences5, tdiff;
	int *rowpix, v1, v2, v3, v4, v5, v6, v7, v8, v9;
	int xminval = INT_MAX, xmaxval = INT_MIN;
	int do_range = 0;
	double *diffs2, *diffs3, *diffs5; 
	double xnoise2 = 0, xnoise3 = 0, xnoise5 = 0;
	
	if (nx < 5) {
		/* treat entire array as an image with a single row */
		nx = nx * ny;
		ny = 1;
	}

	/* rows must have at least 9 pixels */
	if (nx < 9) {

		for (ii = 0; ii < nx; ii++) {
		    if (nullcheck && array[ii] == nullvalue)
		        continue;
		    else {
			if (array[ii] < xminval) xminval = array[ii];
			if (array[ii] > xmaxval) xmaxval = array[ii];
			ngoodpix++;
		    }
		}
		if (minval) *minval = xminval;
		if (maxval) *maxval = xmaxval;
		if (ngood) *ngood = ngoodpix;
		if (noise2) *noise2 = 0.;
		if (noise3) *noise3 = 0.;
		if (noise5) *noise5 = 0.;
		return(*status);
	}

	/* do we need to compute the min and max value? */
	if (minval || maxval) do_range = 1;
	
        /* allocate arrays used to compute the median and noise estimates */
	differences2 = calloc(nx, sizeof(LONGLONG));
	if (!differences2) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}
	differences3 = calloc(nx, sizeof(LONGLONG));
	if (!differences3) {
		free(differences2);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}
	differences5 = calloc(nx, sizeof(LONGLONG));
	if (!differences5) {
		free(differences2);
		free(differences3);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs2 = calloc(ny, sizeof(double));
	if (!diffs2) {
		free(differences2);
		free(differences3);
		free(differences5);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs3 = calloc(ny, sizeof(double));
	if (!diffs3) {
		free(differences2);
		free(differences3);
		free(differences5);
		free(diffs2);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs5 = calloc(ny, sizeof(double));
	if (!diffs5) {
		free(differences2);
		free(differences3);
		free(differences5);
		free(diffs2);
		free(diffs3);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v1 < xminval) xminval = v1;
			if (v1 > xmaxval) xmaxval = v1;
		}

		/***** find the 2nd valid pixel in row (which we will skip over) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v2 = rowpix[ii];  /* store the good pixel value */
		
		if (do_range) {
			if (v2 < xminval) xminval = v2;
			if (v2 > xmaxval) xmaxval = v2;
		}

		/***** find the 3rd valid pixel in row */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v3 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v3 < xminval) xminval = v3;
			if (v3 > xmaxval) xmaxval = v3;
		}
				
		/* find the 4nd valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v4 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v4 < xminval) xminval = v4;
			if (v4 > xmaxval) xmaxval = v4;
		}
			
		/* find the 5th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v5 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v5 < xminval) xminval = v5;
			if (v5 > xmaxval) xmaxval = v5;
		}
				
		/* find the 6th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v6 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v6 < xminval) xminval = v6;
			if (v6 > xmaxval) xmaxval = v6;
		}
				
		/* find the 7th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v7 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v7 < xminval) xminval = v7;
			if (v7 > xmaxval) xmaxval = v7;
		}
				
		/* find the 8th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v8 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v8 < xminval) xminval = v8;
			if (v8 > xmaxval) xmaxval = v8;
		}
		/* now populate the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		nvals2 = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		    v9 = rowpix[ii];  /* store the good pixel value */

		    if (do_range) {
			if (v9 < xminval) xminval = v9;
			if (v9 > xmaxval) xmaxval = v9;
		    }

		    /* construct array of absolute differences */

		    if (!(v5 == v6 && v6 == v7) ) {
		        tdiff =  (LONGLONG) v5 - (LONGLONG) v7;
			if (tdiff < 0)
		            differences2[nvals2] =  -1 * tdiff;
			else
		            differences2[nvals2] =  tdiff;

			nvals2++;
		    }

		    if (!(v3 == v4 && v4 == v5 && v5 == v6 && v6 == v7) ) {
		        tdiff =  (2 * (LONGLONG) v5) - (LONGLONG) v3 - (LONGLONG) v7;
			if (tdiff < 0)
		            differences3[nvals] =  -1 * tdiff;
			else
		            differences3[nvals] =  tdiff;

		        tdiff =  (6 * (LONGLONG) v5) - (4 * (LONGLONG) v3) - (4 * (LONGLONG) v7) + (LONGLONG) v1 + (LONGLONG) v9;
			if (tdiff < 0)
		            differences5[nvals] =  -1 * tdiff;
			else
		            differences5[nvals] =  tdiff;

		        nvals++;  
		    } else {
		        /* ignore constant background regions */
			ngoodpix++;
		    }

		    /* shift over 1 pixel */
		    v1 = v2;
		    v2 = v3;
		    v3 = v4;
		    v4 = v5;
		    v5 = v6;
		    v6 = v7;
		    v7 = v8;
		    v8 = v9;
	        }  /* end of loop over pixels in the row */

		/* compute the median diffs */
		/* Note that there are 8 more pixel values than there are diffs values. */
		ngoodpix += (nvals + 8);

		if (nvals == 0) {
		    continue;  /* cannot compute medians on this row */
		} else if (nvals == 1) {
		    if (nvals2 == 1) {
		        diffs2[nrows2] = (double) differences2[0];
			nrows2++;
		    }
		        
		    diffs3[nrows] = (double) differences3[0];
		    diffs5[nrows] = (double) differences5[0];
		} else {
                    /* quick_select returns the median MUCH faster than using qsort */
		    if (nvals2 > 1) {
                        diffs2[nrows2] = (double) quick_select_longlong(differences2, nvals);
			nrows2++;
		    }

                    diffs3[nrows] = (double) quick_select_longlong(differences3, nvals);
                    diffs5[nrows] = (double) quick_select_longlong(differences5, nvals);
		}

		nrows++;
	}  /* end of loop over rows */

	    /* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise3 = 0;
	       xnoise5 = 0;
	} else if (nrows == 1) {
	       xnoise3 = diffs3[0];
	       xnoise5 = diffs5[0];
	} else {	    
	       qsort(diffs3, nrows, sizeof(double), FnCompare_double);
	       qsort(diffs5, nrows, sizeof(double), FnCompare_double);
	       xnoise3 =  (diffs3[(nrows - 1)/2] + diffs3[nrows/2]) / 2.;
	       xnoise5 =  (diffs5[(nrows - 1)/2] + diffs5[nrows/2]) / 2.;
	}

	if (nrows2 == 0) { 
	       xnoise2 = 0;
	} else if (nrows2 == 1) {
	       xnoise2 = diffs2[0];
	} else {	    
	       qsort(diffs2, nrows2, sizeof(double), FnCompare_double);
	       xnoise2 =  (diffs2[(nrows2 - 1)/2] + diffs2[nrows2/2]) / 2.;
	}

	if (ngood)  *ngood  = ngoodpix;
	if (minval) *minval = xminval;
	if (maxval) *maxval = xmaxval;
	if (noise2)  *noise2  = 1.0483579 * xnoise2;
	if (noise3)  *noise3  = 0.6052697 * xnoise3;
	if (noise5)  *noise5  = 0.1772048 * xnoise5;

	free(diffs5);
	free(diffs3);
	free(diffs2);
	free(differences5);
	free(differences3);
	free(differences2);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise5_float
       (float *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	float nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	long *ngood,        /* number of good, non-null pixels? */
	float *minval,    /* minimum non-null value */
	float *maxval,    /* maximum non-null value */
	double *noise2,      /* returned 2nd order MAD of all non-null pixels */
	double *noise3,      /* returned 3rd order MAD of all non-null pixels */
	double *noise5,      /* returned 5th order MAD of all non-null pixels */
	int *status)        /* error status */

/*
Estimate the median and background noise in the input image using 2nd, 3rd and 5th
order Median Absolute Differences.

The noise in the background of the image is calculated using the MAD algorithms 
developed for deriving the signal to noise ratio in spectra
(see issue #42 of the ST-ECF newsletter, http://www.stecf.org/documents/newsletter/)

3rd order:  noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) - flux(i+2)))

The returned estimates are the median of the values that are computed for each 
row of the image.
*/
{
	long ii, jj, nrows = 0, nrows2 = 0, nvals, nvals2, ngoodpix = 0;
	float *differences2, *differences3, *differences5;
	float *rowpix, v1, v2, v3, v4, v5, v6, v7, v8, v9;
	float xminval = FLT_MAX, xmaxval = -FLT_MAX;
	int do_range = 0;
	double *diffs2, *diffs3, *diffs5; 
	double xnoise2 = 0, xnoise3 = 0, xnoise5 = 0;
	
	if (nx < 5) {
		/* treat entire array as an image with a single row */
		nx = nx * ny;
		ny = 1;
	}

	/* rows must have at least 9 pixels */
	if (nx < 9) {

		for (ii = 0; ii < nx; ii++) {
		    if (nullcheck && array[ii] == nullvalue)
		        continue;
		    else {
			if (array[ii] < xminval) xminval = array[ii];
			if (array[ii] > xmaxval) xmaxval = array[ii];
			ngoodpix++;
		    }
		}
		if (minval) *minval = xminval;
		if (maxval) *maxval = xmaxval;
		if (ngood) *ngood = ngoodpix;
		if (noise2) *noise2 = 0.;
		if (noise3) *noise3 = 0.;
		if (noise5) *noise5 = 0.;
		return(*status);
	}

	/* do we need to compute the min and max value? */
	if (minval || maxval) do_range = 1;
	
        /* allocate arrays used to compute the median and noise estimates */
	differences2 = calloc(nx, sizeof(float));
	if (!differences2) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}
	differences3 = calloc(nx, sizeof(float));
	if (!differences3) {
		free(differences2);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}
	differences5 = calloc(nx, sizeof(float));
	if (!differences5) {
		free(differences2);
		free(differences3);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs2 = calloc(ny, sizeof(double));
	if (!diffs2) {
		free(differences2);
		free(differences3);
		free(differences5);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs3 = calloc(ny, sizeof(double));
	if (!diffs3) {
		free(differences2);
		free(differences3);
		free(differences5);
		free(diffs2);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs5 = calloc(ny, sizeof(double));
	if (!diffs5) {
		free(differences2);
		free(differences3);
		free(differences5);
		free(diffs2);
		free(diffs3);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v1 < xminval) xminval = v1;
			if (v1 > xmaxval) xmaxval = v1;
		}

		/***** find the 2nd valid pixel in row (which we will skip over) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v2 = rowpix[ii];  /* store the good pixel value */
		
		if (do_range) {
			if (v2 < xminval) xminval = v2;
			if (v2 > xmaxval) xmaxval = v2;
		}

		/***** find the 3rd valid pixel in row */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v3 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v3 < xminval) xminval = v3;
			if (v3 > xmaxval) xmaxval = v3;
		}
				
		/* find the 4nd valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v4 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v4 < xminval) xminval = v4;
			if (v4 > xmaxval) xmaxval = v4;
		}
			
		/* find the 5th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v5 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v5 < xminval) xminval = v5;
			if (v5 > xmaxval) xmaxval = v5;
		}
				
		/* find the 6th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v6 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v6 < xminval) xminval = v6;
			if (v6 > xmaxval) xmaxval = v6;
		}
				
		/* find the 7th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v7 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v7 < xminval) xminval = v7;
			if (v7 > xmaxval) xmaxval = v7;
		}
				
		/* find the 8th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v8 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v8 < xminval) xminval = v8;
			if (v8 > xmaxval) xmaxval = v8;
		}
		/* now populate the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		nvals2 = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		    v9 = rowpix[ii];  /* store the good pixel value */

		    if (do_range) {
			if (v9 < xminval) xminval = v9;
			if (v9 > xmaxval) xmaxval = v9;
		    }

		    /* construct array of absolute differences */

		    if (!(v5 == v6 && v6 == v7) ) {
		        differences2[nvals2] = (float) fabs(v5 - v7);
			nvals2++;
		    }

		    if (!(v3 == v4 && v4 == v5 && v5 == v6 && v6 == v7) ) {
		        differences3[nvals] = (float) fabs((2 * v5) - v3 - v7);
		        differences5[nvals] = (float) fabs((6 * v5) - (4 * v3) - (4 * v7) + v1 + v9);
		        nvals++;  
		    } else {
		        /* ignore constant background regions */
			ngoodpix++;
		    }

		    /* shift over 1 pixel */
		    v1 = v2;
		    v2 = v3;
		    v3 = v4;
		    v4 = v5;
		    v5 = v6;
		    v6 = v7;
		    v7 = v8;
		    v8 = v9;
	        }  /* end of loop over pixels in the row */

		/* compute the median diffs */
		/* Note that there are 8 more pixel values than there are diffs values. */
		ngoodpix += (nvals + 8);

		if (nvals == 0) {
		    continue;  /* cannot compute medians on this row */
		} else if (nvals == 1) {
		    if (nvals2 == 1) {
		        diffs2[nrows2] = differences2[0];
			nrows2++;
		    }
		        
		    diffs3[nrows] = differences3[0];
		    diffs5[nrows] = differences5[0];
		} else {
                    /* quick_select returns the median MUCH faster than using qsort */
		    if (nvals2 > 1) {
                        diffs2[nrows2] = quick_select_float(differences2, nvals);
			nrows2++;
		    }

                    diffs3[nrows] = quick_select_float(differences3, nvals);
                    diffs5[nrows] = quick_select_float(differences5, nvals);
		}

		nrows++;
	}  /* end of loop over rows */

	    /* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise3 = 0;
	       xnoise5 = 0;
	} else if (nrows == 1) {
	       xnoise3 = diffs3[0];
	       xnoise5 = diffs5[0];
	} else {	    
	       qsort(diffs3, nrows, sizeof(double), FnCompare_double);
	       qsort(diffs5, nrows, sizeof(double), FnCompare_double);
	       xnoise3 =  (diffs3[(nrows - 1)/2] + diffs3[nrows/2]) / 2.;
	       xnoise5 =  (diffs5[(nrows - 1)/2] + diffs5[nrows/2]) / 2.;
	}

	if (nrows2 == 0) { 
	       xnoise2 = 0;
	} else if (nrows2 == 1) {
	       xnoise2 = diffs2[0];
	} else {	    
	       qsort(diffs2, nrows2, sizeof(double), FnCompare_double);
	       xnoise2 =  (diffs2[(nrows2 - 1)/2] + diffs2[nrows2/2]) / 2.;
	}

	if (ngood)  *ngood  = ngoodpix;
	if (minval) *minval = xminval;
	if (maxval) *maxval = xmaxval;
	if (noise2)  *noise2  = 1.0483579 * xnoise2;
	if (noise3)  *noise3  = 0.6052697 * xnoise3;
	if (noise5)  *noise5  = 0.1772048 * xnoise5;

	free(diffs5);
	free(diffs3);
	free(diffs2);
	free(differences5);
	free(differences3);
	free(differences2);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise5_double
       (double *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	double nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	long *ngood,        /* number of good, non-null pixels? */
	double *minval,    /* minimum non-null value */
	double *maxval,    /* maximum non-null value */
	double *noise2,      /* returned 2nd order MAD of all non-null pixels */
	double *noise3,      /* returned 3rd order MAD of all non-null pixels */
	double *noise5,      /* returned 5th order MAD of all non-null pixels */
	int *status)        /* error status */

/*
Estimate the median and background noise in the input image using 2nd, 3rd and 5th
order Median Absolute Differences.

The noise in the background of the image is calculated using the MAD algorithms 
developed for deriving the signal to noise ratio in spectra
(see issue #42 of the ST-ECF newsletter, http://www.stecf.org/documents/newsletter/)

3rd order:  noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) - flux(i+2)))

The returned estimates are the median of the values that are computed for each 
row of the image.
*/
{
	long ii, jj, nrows = 0, nrows2 = 0, nvals, nvals2, ngoodpix = 0;
	double *differences2, *differences3, *differences5;
	double *rowpix, v1, v2, v3, v4, v5, v6, v7, v8, v9;
	double xminval = DBL_MAX, xmaxval = -DBL_MAX;
	int do_range = 0;
	double *diffs2, *diffs3, *diffs5; 
	double xnoise2 = 0, xnoise3 = 0, xnoise5 = 0;
	
	if (nx < 5) {
		/* treat entire array as an image with a single row */
		nx = nx * ny;
		ny = 1;
	}

	/* rows must have at least 9 pixels */
	if (nx < 9) {

		for (ii = 0; ii < nx; ii++) {
		    if (nullcheck && array[ii] == nullvalue)
		        continue;
		    else {
			if (array[ii] < xminval) xminval = array[ii];
			if (array[ii] > xmaxval) xmaxval = array[ii];
			ngoodpix++;
		    }
		}
		if (minval) *minval = xminval;
		if (maxval) *maxval = xmaxval;
		if (ngood) *ngood = ngoodpix;
		if (noise2) *noise2 = 0.;
		if (noise3) *noise3 = 0.;
		if (noise5) *noise5 = 0.;
		return(*status);
	}

	/* do we need to compute the min and max value? */
	if (minval || maxval) do_range = 1;
	
        /* allocate arrays used to compute the median and noise estimates */
	differences2 = calloc(nx, sizeof(double));
	if (!differences2) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}
	differences3 = calloc(nx, sizeof(double));
	if (!differences3) {
		free(differences2);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}
	differences5 = calloc(nx, sizeof(double));
	if (!differences5) {
		free(differences2);
		free(differences3);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs2 = calloc(ny, sizeof(double));
	if (!diffs2) {
		free(differences2);
		free(differences3);
		free(differences5);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs3 = calloc(ny, sizeof(double));
	if (!diffs3) {
		free(differences2);
		free(differences3);
		free(differences5);
		free(diffs2);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs5 = calloc(ny, sizeof(double));
	if (!diffs5) {
		free(differences2);
		free(differences3);
		free(differences5);
		free(diffs2);
		free(diffs3);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v1 < xminval) xminval = v1;
			if (v1 > xmaxval) xmaxval = v1;
		}

		/***** find the 2nd valid pixel in row (which we will skip over) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v2 = rowpix[ii];  /* store the good pixel value */
		
		if (do_range) {
			if (v2 < xminval) xminval = v2;
			if (v2 > xmaxval) xmaxval = v2;
		}

		/***** find the 3rd valid pixel in row */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v3 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v3 < xminval) xminval = v3;
			if (v3 > xmaxval) xmaxval = v3;
		}
				
		/* find the 4nd valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v4 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v4 < xminval) xminval = v4;
			if (v4 > xmaxval) xmaxval = v4;
		}
			
		/* find the 5th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v5 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v5 < xminval) xminval = v5;
			if (v5 > xmaxval) xmaxval = v5;
		}
				
		/* find the 6th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v6 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v6 < xminval) xminval = v6;
			if (v6 > xmaxval) xmaxval = v6;
		}
				
		/* find the 7th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v7 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v7 < xminval) xminval = v7;
			if (v7 > xmaxval) xmaxval = v7;
		}
				
		/* find the 8th valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v8 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v8 < xminval) xminval = v8;
			if (v8 > xmaxval) xmaxval = v8;
		}
		/* now populate the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		nvals2 = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		    v9 = rowpix[ii];  /* store the good pixel value */

		    if (do_range) {
			if (v9 < xminval) xminval = v9;
			if (v9 > xmaxval) xmaxval = v9;
		    }

		    /* construct array of absolute differences */

		    if (!(v5 == v6 && v6 == v7) ) {
		        differences2[nvals2] =  fabs(v5 - v7);
			nvals2++;
		    }

		    if (!(v3 == v4 && v4 == v5 && v5 == v6 && v6 == v7) ) {
		        differences3[nvals] =  fabs((2 * v5) - v3 - v7);
		        differences5[nvals] =  fabs((6 * v5) - (4 * v3) - (4 * v7) + v1 + v9);
		        nvals++;  
		    } else {
		        /* ignore constant background regions */
			ngoodpix++;
		    }

		    /* shift over 1 pixel */
		    v1 = v2;
		    v2 = v3;
		    v3 = v4;
		    v4 = v5;
		    v5 = v6;
		    v6 = v7;
		    v7 = v8;
		    v8 = v9;
	        }  /* end of loop over pixels in the row */

		/* compute the median diffs */
		/* Note that there are 8 more pixel values than there are diffs values. */
		ngoodpix += (nvals + 8);

		if (nvals == 0) {
		    continue;  /* cannot compute medians on this row */
		} else if (nvals == 1) {
		    if (nvals2 == 1) {
		        diffs2[nrows2] = differences2[0];
			nrows2++;
		    }
		        
		    diffs3[nrows] = differences3[0];
		    diffs5[nrows] = differences5[0];
		} else {
                    /* quick_select returns the median MUCH faster than using qsort */
		    if (nvals2 > 1) {
                        diffs2[nrows2] = quick_select_double(differences2, nvals);
			nrows2++;
		    }

                    diffs3[nrows] = quick_select_double(differences3, nvals);
                    diffs5[nrows] = quick_select_double(differences5, nvals);
		}

		nrows++;
	}  /* end of loop over rows */

	    /* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise3 = 0;
	       xnoise5 = 0;
	} else if (nrows == 1) {
	       xnoise3 = diffs3[0];
	       xnoise5 = diffs5[0];
	} else {	    
	       qsort(diffs3, nrows, sizeof(double), FnCompare_double);
	       qsort(diffs5, nrows, sizeof(double), FnCompare_double);
	       xnoise3 =  (diffs3[(nrows - 1)/2] + diffs3[nrows/2]) / 2.;
	       xnoise5 =  (diffs5[(nrows - 1)/2] + diffs5[nrows/2]) / 2.;
	}

	if (nrows2 == 0) { 
	       xnoise2 = 0;
	} else if (nrows2 == 1) {
	       xnoise2 = diffs2[0];
	} else {	    
	       qsort(diffs2, nrows2, sizeof(double), FnCompare_double);
	       xnoise2 =  (diffs2[(nrows2 - 1)/2] + diffs2[nrows2/2]) / 2.;
	}

	if (ngood)  *ngood  = ngoodpix;
	if (minval) *minval = xminval;
	if (maxval) *maxval = xmaxval;
	if (noise2)  *noise2  = 1.0483579 * xnoise2;
	if (noise3)  *noise3  = 0.6052697 * xnoise3;
	if (noise5)  *noise5  = 0.1772048 * xnoise5;

	free(diffs5);
	free(diffs3);
	free(diffs2);
	free(differences5);
	free(differences3);
	free(differences2);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise3_short
       (short *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	short nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	long *ngood,        /* number of good, non-null pixels? */
	short *minval,    /* minimum non-null value */
	short *maxval,    /* maximum non-null value */
	double *noise,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */

/*
Estimate the median and background noise in the input image using 3rd order differences.

The noise in the background of the image is calculated using the 3rd order algorithm 
developed for deriving the signal to noise ratio in spectra
(see issue #42 of the ST-ECF newsletter, http://www.stecf.org/documents/newsletter/)

  noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) - flux(i+2)))

The returned estimates are the median of the values that are computed for each 
row of the image.
*/
{
	long ii, jj, nrows = 0, nvals, ngoodpix = 0;
	short *differences, *rowpix, v1, v2, v3, v4, v5;
	short xminval = SHRT_MAX, xmaxval = SHRT_MIN, do_range = 0;
	double *diffs, xnoise = 0, sigma;

	if (nx < 5) {
		/* treat entire array as an image with a single row */
		nx = nx * ny;
		ny = 1;
	}

	/* rows must have at least 5 pixels */
	if (nx < 5) {

		for (ii = 0; ii < nx; ii++) {
		    if (nullcheck && array[ii] == nullvalue)
		        continue;
		    else {
			if (array[ii] < xminval) xminval = array[ii];
			if (array[ii] > xmaxval) xmaxval = array[ii];
			ngoodpix++;
		    }
		}
		if (minval) *minval = xminval;
		if (maxval) *maxval = xmaxval;
		if (ngood) *ngood = ngoodpix;
		if (noise) *noise = 0.;
		return(*status);
	}

	/* do we need to compute the min and max value? */
	if (minval || maxval) do_range = 1;
	
        /* allocate arrays used to compute the median and noise estimates */
	differences = calloc(nx, sizeof(short));
	if (!differences) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs = calloc(ny, sizeof(double));
	if (!diffs) {
		free(differences);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v1 < xminval) xminval = v1;
			if (v1 > xmaxval) xmaxval = v1;
		}

		/***** find the 2nd valid pixel in row (which we will skip over) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v2 = rowpix[ii];  /* store the good pixel value */
		
		if (do_range) {
			if (v2 < xminval) xminval = v2;
			if (v2 > xmaxval) xmaxval = v2;
		}

		/***** find the 3rd valid pixel in row */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v3 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v3 < xminval) xminval = v3;
			if (v3 > xmaxval) xmaxval = v3;
		}
				
		/* find the 4nd valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v4 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v4 < xminval) xminval = v4;
			if (v4 > xmaxval) xmaxval = v4;
		}
		
		/* now populate the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		    v5 = rowpix[ii];  /* store the good pixel value */

		    if (do_range) {
			if (v5 < xminval) xminval = v5;
			if (v5 > xmaxval) xmaxval = v5;
		    }

		    /* construct array of 3rd order absolute differences */
		    if (!(v1 == v2 && v2 == v3 && v3 == v4 && v4 == v5)) {
		        differences[nvals] = abs((2 * v3) - v1 - v5);
		        nvals++;  
		    } else {
		        /* ignore constant background regions */
			ngoodpix++;
		    }


		    /* shift over 1 pixel */
		    v1 = v2;
		    v2 = v3;
		    v3 = v4;
		    v4 = v5;
	        }  /* end of loop over pixels in the row */

		/* compute the 3rd order diffs */
		/* Note that there are 4 more pixel values than there are diffs values. */
		ngoodpix += (nvals + 4);

		if (nvals == 0) {
		    continue;  /* cannot compute medians on this row */
		} else if (nvals == 1) {
		    diffs[nrows] = differences[0];
		} else {
                    /* quick_select returns the median MUCH faster than using qsort */
                    diffs[nrows] = quick_select_short(differences, nvals);
		}

		nrows++;
	}  /* end of loop over rows */

	    /* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise = 0;
	} else if (nrows == 1) {
	       xnoise = diffs[0];
	} else {	    


	       qsort(diffs, nrows, sizeof(double), FnCompare_double);
	       xnoise =  (diffs[(nrows - 1)/2] + diffs[nrows/2]) / 2.;

              FnMeanSigma_double(diffs, nrows, 0, 0.0, 0, &xnoise, &sigma, status); 

	      /* do a 4.5 sigma rejection of outliers */
	      jj = 0;
	      sigma = 4.5 * sigma;
	      for (ii = 0; ii < nrows; ii++) {
		if ( fabs(diffs[ii] - xnoise) <= sigma)	 {
		   if (jj != ii)
		       diffs[jj] = diffs[ii];
		   jj++;
	        } 
	      }
	      if (ii != jj)
                FnMeanSigma_double(diffs, jj, 0, 0.0, 0, &xnoise, &sigma, status); 
	}

	if (ngood)  *ngood  = ngoodpix;
	if (minval) *minval = xminval;
	if (maxval) *maxval = xmaxval;
	if (noise)  *noise  = 0.6052697 * xnoise;

	free(diffs);
	free(differences);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise3_int
       (int *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	int nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	long *ngood,        /* number of good, non-null pixels? */
	int *minval,    /* minimum non-null value */
	int *maxval,    /* maximum non-null value */
	double *noise,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */

/*
Estimate the background noise in the input image using 3rd order differences.

The noise in the background of the image is calculated using the 3rd order algorithm 
developed for deriving the signal to noise ratio in spectra
(see issue #42 of the ST-ECF newsletter, http://www.stecf.org/documents/newsletter/)

  noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) - flux(i+2)))

The returned estimates are the median of the values that are computed for each 
row of the image.
*/
{
	long ii, jj, nrows = 0, nvals, ngoodpix = 0;
	int *differences, *rowpix, v1, v2, v3, v4, v5;
	int xminval = INT_MAX, xmaxval = INT_MIN, do_range = 0;
	double *diffs, xnoise = 0, sigma;
	
	if (nx < 5) {
		/* treat entire array as an image with a single row */
		nx = nx * ny;
		ny = 1;
	}

	/* rows must have at least 5 pixels */
	if (nx < 5) {

		for (ii = 0; ii < nx; ii++) {
		    if (nullcheck && array[ii] == nullvalue)
		        continue;
		    else {
			if (array[ii] < xminval) xminval = array[ii];
			if (array[ii] > xmaxval) xmaxval = array[ii];
			ngoodpix++;
		    }
		}
		if (minval) *minval = xminval;
		if (maxval) *maxval = xmaxval;
		if (ngood) *ngood = ngoodpix;
		if (noise) *noise = 0.;
		return(*status);
	}

	/* do we need to compute the min and max value? */
	if (minval || maxval) do_range = 1;
	
        /* allocate arrays used to compute the median and noise estimates */
	differences = calloc(nx, sizeof(int));
	if (!differences) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs = calloc(ny, sizeof(double));
	if (!diffs) {
		free(differences);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v1 < xminval) xminval = v1;
			if (v1 > xmaxval) xmaxval = v1;
		}

		/***** find the 2nd valid pixel in row (which we will skip over) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v2 = rowpix[ii];  /* store the good pixel value */
		
		if (do_range) {
			if (v2 < xminval) xminval = v2;
			if (v2 > xmaxval) xmaxval = v2;
		}

		/***** find the 3rd valid pixel in row */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v3 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v3 < xminval) xminval = v3;
			if (v3 > xmaxval) xmaxval = v3;
		}
				
		/* find the 4nd valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v4 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v4 < xminval) xminval = v4;
			if (v4 > xmaxval) xmaxval = v4;
		}
		
		/* now populate the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		    v5 = rowpix[ii];  /* store the good pixel value */

		    if (do_range) {
			if (v5 < xminval) xminval = v5;
			if (v5 > xmaxval) xmaxval = v5;
		    }

		    /* construct array of 3rd order absolute differences */
		    if (!(v1 == v2 && v2 == v3 && v3 == v4 && v4 == v5)) {
		        differences[nvals] = abs((2 * v3) - v1 - v5);
		        nvals++;  
		    } else {
		        /* ignore constant background regions */
			ngoodpix++;
		    }

		    /* shift over 1 pixel */
		    v1 = v2;
		    v2 = v3;
		    v3 = v4;
		    v4 = v5;
	        }  /* end of loop over pixels in the row */

		/* compute the 3rd order diffs */
		/* Note that there are 4 more pixel values than there are diffs values. */
		ngoodpix += (nvals + 4);

		if (nvals == 0) {
		    continue;  /* cannot compute medians on this row */
		} else if (nvals == 1) {
		    diffs[nrows] = differences[0];
		} else {
                    /* quick_select returns the median MUCH faster than using qsort */
                    diffs[nrows] = quick_select_int(differences, nvals);
		}

		nrows++;
	}  /* end of loop over rows */

	    /* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise = 0;
	} else if (nrows == 1) {
	       xnoise = diffs[0];
	} else {	    

	       qsort(diffs, nrows, sizeof(double), FnCompare_double);
	       xnoise =  (diffs[(nrows - 1)/2] + diffs[nrows/2]) / 2.;

              FnMeanSigma_double(diffs, nrows, 0, 0.0, 0, &xnoise, &sigma, status); 

	      /* do a 4.5 sigma rejection of outliers */
	      jj = 0;
	      sigma = 4.5 * sigma;
	      for (ii = 0; ii < nrows; ii++) {
		if ( fabs(diffs[ii] - xnoise) <= sigma)	 {
		   if (jj != ii)
		       diffs[jj] = diffs[ii];
		   jj++;
	        }
	      }
	      if (ii != jj)
                FnMeanSigma_double(diffs, jj, 0, 0.0, 0, &xnoise, &sigma, status); 
	}

	if (ngood)  *ngood  = ngoodpix;
	if (minval) *minval = xminval;
	if (maxval) *maxval = xmaxval;
	if (noise)  *noise  = 0.6052697 * xnoise;

	free(diffs);
	free(differences);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise3_float
       (float *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	float nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	long *ngood,        /* number of good, non-null pixels? */
	float *minval,    /* minimum non-null value */
	float *maxval,    /* maximum non-null value */
	double *noise,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */

/*
Estimate the median and background noise in the input image using 3rd order differences.

The noise in the background of the image is calculated using the 3rd order algorithm 
developed for deriving the signal to noise ratio in spectra
(see issue #42 of the ST-ECF newsletter, http://www.stecf.org/documents/newsletter/)

  noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) - flux(i+2)))

The returned estimates are the median of the values that are computed for each 
row of the image.
*/
{
	long ii, jj, nrows = 0, nvals, ngoodpix = 0;
	float *differences, *rowpix, v1, v2, v3, v4, v5;
	float xminval = FLT_MAX, xmaxval = -FLT_MAX;
	int do_range = 0;
	double *diffs, xnoise = 0;

	if (nx < 5) {
		/* treat entire array as an image with a single row */
		nx = nx * ny;
		ny = 1;
	}

	/* rows must have at least 5 pixels to calc noise, so just calc min, max, ngood */
	if (nx < 5) {

		for (ii = 0; ii < nx; ii++) {
		    if (nullcheck && array[ii] == nullvalue)
		        continue;
		    else {
			if (array[ii] < xminval) xminval = array[ii];
			if (array[ii] > xmaxval) xmaxval = array[ii];
			ngoodpix++;
		    }
		}
		if (minval) *minval = xminval;
		if (maxval) *maxval = xmaxval;
		if (ngood) *ngood = ngoodpix;
		if (noise) *noise = 0.;
		return(*status);
	}

	/* do we need to compute the min and max value? */
	if (minval || maxval) do_range = 1;
	
        /* allocate arrays used to compute the median and noise estimates */
	if (noise) {
	    differences = calloc(nx, sizeof(float));
	    if (!differences) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	    }

	    diffs = calloc(ny, sizeof(double));
	    if (!diffs) {
		free(differences);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	    }
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v1 < xminval) xminval = v1;
			if (v1 > xmaxval) xmaxval = v1;
		}

		/***** find the 2nd valid pixel in row (which we will skip over) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v2 = rowpix[ii];  /* store the good pixel value */
		
		if (do_range) {
			if (v2 < xminval) xminval = v2;
			if (v2 > xmaxval) xmaxval = v2;
		}

		/***** find the 3rd valid pixel in row */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v3 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v3 < xminval) xminval = v3;
			if (v3 > xmaxval) xmaxval = v3;
		}
				
		/* find the 4nd valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v4 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v4 < xminval) xminval = v4;
			if (v4 > xmaxval) xmaxval = v4;
		}
		
		/* now populate the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) {
			  ii++;
		        }
			
		    if (ii == nx) break;  /* hit end of row */
		    v5 = rowpix[ii];  /* store the good pixel value */

		    if (do_range) {
			if (v5 < xminval) xminval = v5;
			if (v5 > xmaxval) xmaxval = v5;
		    }

		    /* construct array of 3rd order absolute differences */
		    if (noise) {
		        if (!(v1 == v2 && v2 == v3 && v3 == v4 && v4 == v5)) {

		            differences[nvals] = (float) fabs((2. * v3) - v1 - v5);
		            nvals++;  
		       } else {
		            /* ignore constant background regions */
			    ngoodpix++;
		       }
		    } else {
		       /* just increment the number of non-null pixels */
		       ngoodpix++;
		    }

		    /* shift over 1 pixel */
		    v1 = v2;
		    v2 = v3;
		    v3 = v4;
		    v4 = v5;
	        }  /* end of loop over pixels in the row */

		/* compute the 3rd order diffs */
		/* Note that there are 4 more pixel values than there are diffs values. */
		ngoodpix += (nvals + 4);

		if (noise) {
		    if (nvals == 0) {
		        continue;  /* cannot compute medians on this row */
		    } else if (nvals == 1) {
		        diffs[nrows] = differences[0];
		    } else {
                        /* quick_select returns the median MUCH faster than using qsort */
                        diffs[nrows] = quick_select_float(differences, nvals);
		    }
		}
		nrows++;
	}  /* end of loop over rows */

	    /* compute median of the values for each row */
	if (noise) {
	    if (nrows == 0) { 
	       xnoise = 0;
	    } else if (nrows == 1) {
	       xnoise = diffs[0];
	    } else {	    
	       qsort(diffs, nrows, sizeof(double), FnCompare_double);
	       xnoise =  (diffs[(nrows - 1)/2] + diffs[nrows/2]) / 2.;
	    }
	}

	if (ngood)  *ngood  = ngoodpix;
	if (minval) *minval = xminval;
	if (maxval) *maxval = xmaxval;
	if (noise) {
		*noise  = 0.6052697 * xnoise;
		free(diffs);
		free(differences);
	}

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise3_double
       (double *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	double nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	long *ngood,        /* number of good, non-null pixels? */
	double *minval,    /* minimum non-null value */
	double *maxval,    /* maximum non-null value */
	double *noise,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */

/*
Estimate the median and background noise in the input image using 3rd order differences.

The noise in the background of the image is calculated using the 3rd order algorithm 
developed for deriving the signal to noise ratio in spectra
(see issue #42 of the ST-ECF newsletter, http://www.stecf.org/documents/newsletter/)

  noise = 1.482602 / sqrt(6) * median (abs(2*flux(i) - flux(i-2) - flux(i+2)))

The returned estimates are the median of the values that are computed for each 
row of the image.
*/
{
	long ii, jj, nrows = 0, nvals, ngoodpix = 0;
	double *differences, *rowpix, v1, v2, v3, v4, v5;
	double xminval = DBL_MAX, xmaxval = -DBL_MAX;
	int do_range = 0;
	double *diffs, xnoise = 0;
	
	if (nx < 5) {
		/* treat entire array as an image with a single row */
		nx = nx * ny;
		ny = 1;
	}

	/* rows must have at least 5 pixels */
	if (nx < 5) {

		for (ii = 0; ii < nx; ii++) {
		    if (nullcheck && array[ii] == nullvalue)
		        continue;
		    else {
			if (array[ii] < xminval) xminval = array[ii];
			if (array[ii] > xmaxval) xmaxval = array[ii];
			ngoodpix++;
		    }
		}
		if (minval) *minval = xminval;
		if (maxval) *maxval = xmaxval;
		if (ngood) *ngood = ngoodpix;
		if (noise) *noise = 0.;
		return(*status);
	}

	/* do we need to compute the min and max value? */
	if (minval || maxval) do_range = 1;
	
        /* allocate arrays used to compute the median and noise estimates */
	if (noise) {
	    differences = calloc(nx, sizeof(double));
	    if (!differences) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	    }

	    diffs = calloc(ny, sizeof(double));
	    if (!diffs) {
		free(differences);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	    }
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v1 < xminval) xminval = v1;
			if (v1 > xmaxval) xmaxval = v1;
		}

		/***** find the 2nd valid pixel in row (which we will skip over) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v2 = rowpix[ii];  /* store the good pixel value */
		
		if (do_range) {
			if (v2 < xminval) xminval = v2;
			if (v2 > xmaxval) xmaxval = v2;
		}

		/***** find the 3rd valid pixel in row */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v3 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v3 < xminval) xminval = v3;
			if (v3 > xmaxval) xmaxval = v3;
		}
				
		/* find the 4nd valid pixel in row (to be skipped) */
		ii++;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v4 = rowpix[ii];  /* store the good pixel value */

		if (do_range) {
			if (v4 < xminval) xminval = v4;
			if (v4 > xmaxval) xmaxval = v4;
		}
		
		/* now populate the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		    v5 = rowpix[ii];  /* store the good pixel value */

		    if (do_range) {
			if (v5 < xminval) xminval = v5;
			if (v5 > xmaxval) xmaxval = v5;
		    }

		    /* construct array of 3rd order absolute differences */
		    if (noise) {
		        if (!(v1 == v2 && v2 == v3 && v3 == v4 && v4 == v5)) {

		            differences[nvals] = fabs((2. * v3) - v1 - v5);
		            nvals++;  
		        } else {
		            /* ignore constant background regions */
			    ngoodpix++;
		        }
		    } else {
		       /* just increment the number of non-null pixels */
		       ngoodpix++;
		    }

		    /* shift over 1 pixel */
		    v1 = v2;
		    v2 = v3;
		    v3 = v4;
		    v4 = v5;
	        }  /* end of loop over pixels in the row */

		/* compute the 3rd order diffs */
		/* Note that there are 4 more pixel values than there are diffs values. */
		ngoodpix += (nvals + 4);

		if (noise) {
		    if (nvals == 0) {
		        continue;  /* cannot compute medians on this row */
		    } else if (nvals == 1) {
		        diffs[nrows] = differences[0];
		    } else {
                        /* quick_select returns the median MUCH faster than using qsort */
                        diffs[nrows] = quick_select_double(differences, nvals);
		    }
		}
		nrows++;
	}  /* end of loop over rows */

	    /* compute median of the values for each row */
	if (noise) {
	    if (nrows == 0) { 
	       xnoise = 0;
	    } else if (nrows == 1) {
	       xnoise = diffs[0];
	    } else {	    
	       qsort(diffs, nrows, sizeof(double), FnCompare_double);
	       xnoise =  (diffs[(nrows - 1)/2] + diffs[nrows/2]) / 2.;
	    }
	}

	if (ngood)  *ngood  = ngoodpix;
	if (minval) *minval = xminval;
	if (maxval) *maxval = xmaxval;
	if (noise) {
		*noise  = 0.6052697 * xnoise;
		free(diffs);
		free(differences);
	}

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise1_short
       (short *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	short nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	double *noise,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */
/*
Estimate the background noise in the input image using sigma of 1st order differences.

  noise = 1.0 / sqrt(2) * rms of (flux[i] - flux[i-1])

The returned estimate is the median of the values that are computed for each 
row of the image.
*/
{
	int iter;
	long ii, jj, kk, nrows = 0, nvals;
	short *differences, *rowpix, v1;
	double  *diffs, xnoise, mean, stdev;

	/* rows must have at least 3 pixels to estimate noise */
	if (nx < 3) {
		*noise = 0;
		return(*status);
	}
	
        /* allocate arrays used to compute the median and noise estimates */
	differences = calloc(nx, sizeof(short));
	if (!differences) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs = calloc(ny, sizeof(double));
	if (!diffs) {
		free(differences);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		/* now continue populating the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		
		    /* construct array of 1st order differences */
		    differences[nvals] = v1 - rowpix[ii];

		    nvals++;  
		    /* shift over 1 pixel */
		    v1 = rowpix[ii];
	        }  /* end of loop over pixels in the row */

		if (nvals < 2)
		   continue;
		else {

		    FnMeanSigma_short(differences, nvals, 0, 0, 0, &mean, &stdev, status);

		    if (stdev > 0.) {
		        for (iter = 0;  iter < NITER;  iter++) {
		            kk = 0;
		            for (ii = 0;  ii < nvals;  ii++) {
		                if (fabs (differences[ii] - mean) < SIGMA_CLIP * stdev) {
			            if (kk < ii)
			                differences[kk] = differences[ii];
			            kk++;
		                }
		            }
		            if (kk == nvals) break;

		            nvals = kk;
		            FnMeanSigma_short(differences, nvals, 0, 0, 0, &mean, &stdev, status);
	              }
		   }

		   diffs[nrows] = stdev;
		   nrows++;
		}
	}  /* end of loop over rows */

	/* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise = 0;
	} else if (nrows == 1) {
	       xnoise = diffs[0];
	} else {
	       qsort(diffs, nrows, sizeof(double), FnCompare_double);
	       xnoise =  (diffs[(nrows - 1)/2] + diffs[nrows/2]) / 2.;
	}

	*noise = .70710678 * xnoise;

	free(diffs);
	free(differences);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise1_int
       (int *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	int nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	double *noise,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */
/*
Estimate the background noise in the input image using sigma of 1st order differences.

  noise = 1.0 / sqrt(2) * rms of (flux[i] - flux[i-1])

The returned estimate is the median of the values that are computed for each 
row of the image.
*/
{
	int iter;
	long ii, jj, kk, nrows = 0, nvals;
	int *differences, *rowpix, v1;
	double  *diffs, xnoise, mean, stdev;

	/* rows must have at least 3 pixels to estimate noise */
	if (nx < 3) {
		*noise = 0;
		return(*status);
	}
	
        /* allocate arrays used to compute the median and noise estimates */
	differences = calloc(nx, sizeof(int));
	if (!differences) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs = calloc(ny, sizeof(double));
	if (!diffs) {
		free(differences);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		/* now continue populating the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		
		    /* construct array of 1st order differences */
		    differences[nvals] = v1 - rowpix[ii];

		    nvals++;  
		    /* shift over 1 pixel */
		    v1 = rowpix[ii];
	        }  /* end of loop over pixels in the row */

		if (nvals < 2)
		   continue;
		else {

		    FnMeanSigma_int(differences, nvals, 0, 0, 0, &mean, &stdev, status);

		    if (stdev > 0.) {
		        for (iter = 0;  iter < NITER;  iter++) {
		            kk = 0;
		            for (ii = 0;  ii < nvals;  ii++) {
		                if (fabs (differences[ii] - mean) < SIGMA_CLIP * stdev) {
			            if (kk < ii)
			                differences[kk] = differences[ii];
			            kk++;
		                }
		            }
		            if (kk == nvals) break;

		            nvals = kk;
		            FnMeanSigma_int(differences, nvals, 0, 0, 0, &mean, &stdev, status);
	              }
		   }

		   diffs[nrows] = stdev;
		   nrows++;
		}
	}  /* end of loop over rows */

	/* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise = 0;
	} else if (nrows == 1) {
	       xnoise = diffs[0];
	} else {
	       qsort(diffs, nrows, sizeof(double), FnCompare_double);
	       xnoise =  (diffs[(nrows - 1)/2] + diffs[nrows/2]) / 2.;
	}

	*noise = .70710678 * xnoise;

	free(diffs);
	free(differences);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise1_float
       (float *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	float nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	double *noise,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */
/*
Estimate the background noise in the input image using sigma of 1st order differences.

  noise = 1.0 / sqrt(2) * rms of (flux[i] - flux[i-1])

The returned estimate is the median of the values that are computed for each 
row of the image.
*/
{
	int iter;
	long ii, jj, kk, nrows = 0, nvals;
	float *differences, *rowpix, v1;
	double  *diffs, xnoise, mean, stdev;

	/* rows must have at least 3 pixels to estimate noise */
	if (nx < 3) {
		*noise = 0;
		return(*status);
	}
	
        /* allocate arrays used to compute the median and noise estimates */
	differences = calloc(nx, sizeof(float));
	if (!differences) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs = calloc(ny, sizeof(double));
	if (!diffs) {
		free(differences);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		/* now continue populating the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		
		    /* construct array of 1st order differences */
		    differences[nvals] = v1 - rowpix[ii];

		    nvals++;  
		    /* shift over 1 pixel */
		    v1 = rowpix[ii];
	        }  /* end of loop over pixels in the row */

		if (nvals < 2)
		   continue;
		else {

		    FnMeanSigma_float(differences, nvals, 0, 0, 0, &mean, &stdev, status);

		    if (stdev > 0.) {
		        for (iter = 0;  iter < NITER;  iter++) {
		            kk = 0;
		            for (ii = 0;  ii < nvals;  ii++) {
		                if (fabs (differences[ii] - mean) < SIGMA_CLIP * stdev) {
			            if (kk < ii)
			                differences[kk] = differences[ii];
			            kk++;
		                }
		            }
		            if (kk == nvals) break;

		            nvals = kk;
		            FnMeanSigma_float(differences, nvals, 0, 0, 0, &mean, &stdev, status);
	              }
		   }

		   diffs[nrows] = stdev;
		   nrows++;
		}
	}  /* end of loop over rows */

	/* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise = 0;
	} else if (nrows == 1) {
	       xnoise = diffs[0];
	} else {
	       qsort(diffs, nrows, sizeof(double), FnCompare_double);
	       xnoise =  (diffs[(nrows - 1)/2] + diffs[nrows/2]) / 2.;
	}

	*noise = .70710678 * xnoise;

	free(diffs);
	free(differences);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnNoise1_double
       (double *array,       /*  2 dimensional array of image pixels */
        long nx,            /* number of pixels in each row of the image */
        long ny,            /* number of rows in the image */
	int nullcheck,      /* check for null values, if true */
	double nullvalue,    /* value of null pixels, if nullcheck is true */
   /* returned parameters */   
	double *noise,      /* returned R.M.S. value of all non-null pixels */
	int *status)        /* error status */
/*
Estimate the background noise in the input image using sigma of 1st order differences.

  noise = 1.0 / sqrt(2) * rms of (flux[i] - flux[i-1])

The returned estimate is the median of the values that are computed for each 
row of the image.
*/
{
	int iter;
	long ii, jj, kk, nrows = 0, nvals;
	double *differences, *rowpix, v1;
	double  *diffs, xnoise, mean, stdev;

	/* rows must have at least 3 pixels to estimate noise */
	if (nx < 3) {
		*noise = 0;
		return(*status);
	}
	
        /* allocate arrays used to compute the median and noise estimates */
	differences = calloc(nx, sizeof(double));
	if (!differences) {
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	diffs = calloc(ny, sizeof(double));
	if (!diffs) {
		free(differences);
        	*status = MEMORY_ALLOCATION;
		return(*status);
	}

	/* loop over each row of the image */
	for (jj=0; jj < ny; jj++) {

                rowpix = array + (jj * nx); /* point to first pixel in the row */

		/***** find the first valid pixel in row */
		ii = 0;
		if (nullcheck)
		    while (ii < nx && rowpix[ii] == nullvalue) ii++;

		if (ii == nx) continue;  /* hit end of row */
		v1 = rowpix[ii];  /* store the good pixel value */

		/* now continue populating the differences arrays */
		/* for the remaining pixels in the row */
		nvals = 0;
		for (ii++; ii < nx; ii++) {

		    /* find the next valid pixel in row */
                    if (nullcheck)
		        while (ii < nx && rowpix[ii] == nullvalue) ii++;
		     
		    if (ii == nx) break;  /* hit end of row */
		
		    /* construct array of 1st order differences */
		    differences[nvals] = v1 - rowpix[ii];

		    nvals++;  
		    /* shift over 1 pixel */
		    v1 = rowpix[ii];
	        }  /* end of loop over pixels in the row */

		if (nvals < 2)
		   continue;
		else {

		    FnMeanSigma_double(differences, nvals, 0, 0, 0, &mean, &stdev, status);

		    if (stdev > 0.) {
		        for (iter = 0;  iter < NITER;  iter++) {
		            kk = 0;
		            for (ii = 0;  ii < nvals;  ii++) {
		                if (fabs (differences[ii] - mean) < SIGMA_CLIP * stdev) {
			            if (kk < ii)
			                differences[kk] = differences[ii];
			            kk++;
		                }
		            }
		            if (kk == nvals) break;

		            nvals = kk;
		            FnMeanSigma_double(differences, nvals, 0, 0, 0, &mean, &stdev, status);
	              }
		   }

		   diffs[nrows] = stdev;
		   nrows++;
		}
	}  /* end of loop over rows */

	/* compute median of the values for each row */
	if (nrows == 0) { 
	       xnoise = 0;
	} else if (nrows == 1) {
	       xnoise = diffs[0];
	} else {
	       qsort(diffs, nrows, sizeof(double), FnCompare_double);
	       xnoise =  (diffs[(nrows - 1)/2] + diffs[nrows/2]) / 2.;
	}

	*noise = .70710678 * xnoise;

	free(diffs);
	free(differences);

	return(*status);
}
/*--------------------------------------------------------------------------*/
static int FnCompare_short(const void *v1, const void *v2)
{
   const short *i1 = v1;
   const short *i2 = v2;
   
   if (*i1 < *i2)
     return(-1);
   else if (*i1 > *i2)
     return(1);
   else
     return(0);
}
/*--------------------------------------------------------------------------*/
static int FnCompare_int(const void *v1, const void *v2)
{
   const int *i1 = v1;
   const int *i2 = v2;
   
   if (*i1 < *i2)
     return(-1);
   else if (*i1 > *i2)
     return(1);
   else
     return(0);
}
/*--------------------------------------------------------------------------*/
static int FnCompare_float(const void *v1, const void *v2)
{
   const float *i1 = v1;
   const float *i2 = v2;
   
   if (*i1 < *i2)
     return(-1);
   else if (*i1 > *i2)
     return(1);
   else
     return(0);
}
/*--------------------------------------------------------------------------*/
static int FnCompare_double(const void *v1, const void *v2)
{
   const double *i1 = v1;
   const double *i2 = v2;
   
   if (*i1 < *i2)
     return(-1);
   else if (*i1 > *i2)
     return(1);
   else
     return(0);
}
/*--------------------------------------------------------------------------*/

/*
 *  These Quickselect routines are based on the algorithm described in
 *  "Numerical recipes in C", Second Edition,
 *  Cambridge University Press, 1992, Section 8.5, ISBN 0-521-43108-5
 *  This code by Nicolas Devillard - 1998. Public domain.
 */

/*--------------------------------------------------------------------------*/

#define ELEM_SWAP(a,b) { register float t=(a);(a)=(b);(b)=t; }

static float quick_select_float(float arr[], int n) 
{
    int low, high ;
    int median;
    int middle, ll, hh;

    low = 0 ; high = n-1 ; median = (low + high) / 2;
    for (;;) {
        if (high <= low) /* One element only */
            return arr[median] ;

        if (high == low + 1) {  /* Two elements only */
            if (arr[low] > arr[high])
                ELEM_SWAP(arr[low], arr[high]) ;
            return arr[median] ;
        }

    /* Find median of low, middle and high items; swap into position low */
    middle = (low + high) / 2;
    if (arr[middle] > arr[high])    ELEM_SWAP(arr[middle], arr[high]) ;
    if (arr[low] > arr[high])       ELEM_SWAP(arr[low], arr[high]) ;
    if (arr[middle] > arr[low])     ELEM_SWAP(arr[middle], arr[low]) ;

    /* Swap low item (now in position middle) into position (low+1) */
    ELEM_SWAP(arr[middle], arr[low+1]) ;

    /* Nibble from each end towards middle, swapping items when stuck */
    ll = low + 1;
    hh = high;
    for (;;) {
        do ll++; while (arr[low] > arr[ll]) ;
        do hh--; while (arr[hh]  > arr[low]) ;

        if (hh < ll)
        break;

        ELEM_SWAP(arr[ll], arr[hh]) ;
    }

    /* Swap middle item (in position low) back into correct position */
    ELEM_SWAP(arr[low], arr[hh]) ;

    /* Re-set active partition */
    if (hh <= median)
        low = ll;
        if (hh >= median)
        high = hh - 1;
    }
}

#undef ELEM_SWAP

/*--------------------------------------------------------------------------*/

#define ELEM_SWAP(a,b) { register short t=(a);(a)=(b);(b)=t; }

static short quick_select_short(short arr[], int n) 
{
    int low, high ;
    int median;
    int middle, ll, hh;

    low = 0 ; high = n-1 ; median = (low + high) / 2;
    for (;;) {
        if (high <= low) /* One element only */
            return arr[median] ;

        if (high == low + 1) {  /* Two elements only */
            if (arr[low] > arr[high])
                ELEM_SWAP(arr[low], arr[high]) ;
            return arr[median] ;
        }

    /* Find median of low, middle and high items; swap into position low */
    middle = (low + high) / 2;
    if (arr[middle] > arr[high])    ELEM_SWAP(arr[middle], arr[high]) ;
    if (arr[low] > arr[high])       ELEM_SWAP(arr[low], arr[high]) ;
    if (arr[middle] > arr[low])     ELEM_SWAP(arr[middle], arr[low]) ;

    /* Swap low item (now in position middle) into position (low+1) */
    ELEM_SWAP(arr[middle], arr[low+1]) ;

    /* Nibble from each end towards middle, swapping items when stuck */
    ll = low + 1;
    hh = high;
    for (;;) {
        do ll++; while (arr[low] > arr[ll]) ;
        do hh--; while (arr[hh]  > arr[low]) ;

        if (hh < ll)
        break;

        ELEM_SWAP(arr[ll], arr[hh]) ;
    }

    /* Swap middle item (in position low) back into correct position */
    ELEM_SWAP(arr[low], arr[hh]) ;

    /* Re-set active partition */
    if (hh <= median)
        low = ll;
        if (hh >= median)
        high = hh - 1;
    }
}

#undef ELEM_SWAP

/*--------------------------------------------------------------------------*/

#define ELEM_SWAP(a,b) { register int t=(a);(a)=(b);(b)=t; }

static int quick_select_int(int arr[], int n) 
{
    int low, high ;
    int median;
    int middle, ll, hh;

    low = 0 ; high = n-1 ; median = (low + high) / 2;
    for (;;) {
        if (high <= low) /* One element only */
            return arr[median] ;

        if (high == low + 1) {  /* Two elements only */
            if (arr[low] > arr[high])
                ELEM_SWAP(arr[low], arr[high]) ;
            return arr[median] ;
        }

    /* Find median of low, middle and high items; swap into position low */
    middle = (low + high) / 2;
    if (arr[middle] > arr[high])    ELEM_SWAP(arr[middle], arr[high]) ;
    if (arr[low] > arr[high])       ELEM_SWAP(arr[low], arr[high]) ;
    if (arr[middle] > arr[low])     ELEM_SWAP(arr[middle], arr[low]) ;

    /* Swap low item (now in position middle) into position (low+1) */
    ELEM_SWAP(arr[middle], arr[low+1]) ;

    /* Nibble from each end towards middle, swapping items when stuck */
    ll = low + 1;
    hh = high;
    for (;;) {
        do ll++; while (arr[low] > arr[ll]) ;
        do hh--; while (arr[hh]  > arr[low]) ;

        if (hh < ll)
        break;

        ELEM_SWAP(arr[ll], arr[hh]) ;
    }

    /* Swap middle item (in position low) back into correct position */
    ELEM_SWAP(arr[low], arr[hh]) ;

    /* Re-set active partition */
    if (hh <= median)
        low = ll;
        if (hh >= median)
        high = hh - 1;
    }
}

#undef ELEM_SWAP

/*--------------------------------------------------------------------------*/

#define ELEM_SWAP(a,b) { register LONGLONG  t=(a);(a)=(b);(b)=t; }

static LONGLONG quick_select_longlong(LONGLONG arr[], int n) 
{
    int low, high ;
    int median;
    int middle, ll, hh;

    low = 0 ; high = n-1 ; median = (low + high) / 2;
    for (;;) {
        if (high <= low) /* One element only */
            return arr[median] ;

        if (high == low + 1) {  /* Two elements only */
            if (arr[low] > arr[high])
                ELEM_SWAP(arr[low], arr[high]) ;
            return arr[median] ;
        }

    /* Find median of low, middle and high items; swap into position low */
    middle = (low + high) / 2;
    if (arr[middle] > arr[high])    ELEM_SWAP(arr[middle], arr[high]) ;
    if (arr[low] > arr[high])       ELEM_SWAP(arr[low], arr[high]) ;
    if (arr[middle] > arr[low])     ELEM_SWAP(arr[middle], arr[low]) ;

    /* Swap low item (now in position middle) into position (low+1) */
    ELEM_SWAP(arr[middle], arr[low+1]) ;

    /* Nibble from each end towards middle, swapping items when stuck */
    ll = low + 1;
    hh = high;
    for (;;) {
        do ll++; while (arr[low] > arr[ll]) ;
        do hh--; while (arr[hh]  > arr[low]) ;

        if (hh < ll)
        break;

        ELEM_SWAP(arr[ll], arr[hh]) ;
    }

    /* Swap middle item (in position low) back into correct position */
    ELEM_SWAP(arr[low], arr[hh]) ;

    /* Re-set active partition */
    if (hh <= median)
        low = ll;
        if (hh >= median)
        high = hh - 1;
    }
}

#undef ELEM_SWAP

/*--------------------------------------------------------------------------*/

#define ELEM_SWAP(a,b) { register double t=(a);(a)=(b);(b)=t; }

static double quick_select_double(double arr[], int n) 
{
    int low, high ;
    int median;
    int middle, ll, hh;

    low = 0 ; high = n-1 ; median = (low + high) / 2;
    for (;;) {
        if (high <= low) /* One element only */
            return arr[median] ;

        if (high == low + 1) {  /* Two elements only */
            if (arr[low] > arr[high])
                ELEM_SWAP(arr[low], arr[high]) ;
            return arr[median] ;
        }

    /* Find median of low, middle and high items; swap into position low */
    middle = (low + high) / 2;
    if (arr[middle] > arr[high])    ELEM_SWAP(arr[middle], arr[high]) ;
    if (arr[low] > arr[high])       ELEM_SWAP(arr[low], arr[high]) ;
    if (arr[middle] > arr[low])     ELEM_SWAP(arr[middle], arr[low]) ;

    /* Swap low item (now in position middle) into position (low+1) */
    ELEM_SWAP(arr[middle], arr[low+1]) ;

    /* Nibble from each end towards middle, swapping items when stuck */
    ll = low + 1;
    hh = high;
    for (;;) {
        do ll++; while (arr[low] > arr[ll]) ;
        do hh--; while (arr[hh]  > arr[low]) ;

        if (hh < ll)
        break;

        ELEM_SWAP(arr[ll], arr[hh]) ;
    }

    /* Swap middle item (in position low) back into correct position */
    ELEM_SWAP(arr[low], arr[hh]) ;

    /* Re-set active partition */
    if (hh <= median)
        low = ll;
        if (hh >= median)
        high = hh - 1;
    }
}

#undef ELEM_SWAP


healpy-1.10.3/cfitsio/region.c0000664000175000017500000015446513010375005016426 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include 
#include 
#include "fitsio2.h"
#include "region.h"
static int Pt_in_Poly( double x, double y, int nPts, double *Pts );

/*---------------------------------------------------------------------------*/
int fits_read_rgnfile( const char *filename,
            WCSdata    *wcs,
            SAORegion  **Rgn,
            int        *status )
/*  Read regions from either a FITS or ASCII region file and return the information     */
/*  in the "SAORegion" structure.  If it is nonNULL, use wcs to convert the  */
/*  region coordinates to pixels.  Return an error if region is in degrees   */
/*  but no WCS data is provided.                                             */
/*---------------------------------------------------------------------------*/
{
  fitsfile *fptr;
  int tstatus = 0;

  if( *status ) return( *status );

  /* try to open as a FITS file - if that doesn't work treat as an ASCII file */

  fits_write_errmark();
  if ( ffopen(&fptr, filename, READONLY, &tstatus) ) {
    fits_clear_errmark();
    fits_read_ascii_region(filename, wcs, Rgn, status);
  } else {
    fits_read_fits_region(fptr, wcs, Rgn, status);
  }

  return(*status);

}
/*---------------------------------------------------------------------------*/
int fits_read_ascii_region( const char *filename,
			    WCSdata    *wcs,
			    SAORegion  **Rgn,
			    int        *status )
/*  Read regions from a SAO-style region file and return the information     */
/*  in the "SAORegion" structure.  If it is nonNULL, use wcs to convert the  */
/*  region coordinates to pixels.  Return an error if region is in degrees   */
/*  but no WCS data is provided.                                             */
/*---------------------------------------------------------------------------*/
{
   char     *currLine;
   char     *namePtr, *paramPtr, *currLoc;
   char     *pX, *pY, *endp;
   long     allocLen, lineLen, hh, mm, dd;
   double   *coords, X, Y, x, y, ss, div, xsave= 0., ysave= 0.;
   int      nParams, nCoords, negdec;
   int      i, done;
   FILE     *rgnFile;
   coordFmt cFmt;
   SAORegion *aRgn;
   RgnShape *newShape, *tmpShape;

   if( *status ) return( *status );

   aRgn = (SAORegion *)malloc( sizeof(SAORegion) );
   if( ! aRgn ) {
      ffpmsg("Couldn't allocate memory to hold Region file contents.");
      return(*status = MEMORY_ALLOCATION );
   }
   aRgn->nShapes    =    0;
   aRgn->Shapes     = NULL;
   if( wcs && wcs->exists )
      aRgn->wcs = *wcs;
   else
      aRgn->wcs.exists = 0;

   cFmt = pixel_fmt; /* set default format */

   /*  Allocate Line Buffer  */

   allocLen = 512;
   currLine = (char *)malloc( allocLen * sizeof(char) );
   if( !currLine ) {
      free( aRgn );
      ffpmsg("Couldn't allocate memory to hold Region file contents.");
      return(*status = MEMORY_ALLOCATION );
   }

   /*  Open Region File  */

   if( (rgnFile = fopen( filename, "r" ))==NULL ) {
      sprintf(currLine,"Could not open Region file %s.",filename);
      ffpmsg( currLine );
      free( currLine );
      free( aRgn );
      return( *status = FILE_NOT_OPENED );
   }
   
   /*  Read in file, line by line  */
   /*  First, set error status in case file is empty */ 
   *status = FILE_NOT_OPENED;

   while( fgets(currLine,allocLen,rgnFile) != NULL ) {

      /* reset status if we got here */
      *status = 0;

      /*  Make sure we have a full line of text  */

      lineLen = strlen(currLine);
      while( lineLen==allocLen-1 && currLine[lineLen-1]!='\n' ) {
         currLoc = (char *)realloc( currLine, 2 * allocLen * sizeof(char) );
         if( !currLoc ) {
            ffpmsg("Couldn't allocate memory to hold Region file contents.");
            *status = MEMORY_ALLOCATION;
            goto error;
         } else {
            currLine = currLoc;
         }
         fgets( currLine+lineLen, allocLen+1, rgnFile );
         allocLen += allocLen;
         lineLen  += strlen(currLine+lineLen);
      }

      currLoc = currLine;
      if( *currLoc == '#' ) {

         /*  Look to see if it is followed by a format statement...  */
         /*  if not skip line                                        */

         currLoc++;
         while( isspace(*currLoc) ) currLoc++;
         if( !strncasecmp( currLoc, "format:", 7 ) ) {
            if( aRgn->nShapes ) {
               ffpmsg("Format code encountered after reading 1 or more shapes.");
               *status = PARSE_SYNTAX_ERR;
               goto error;
            }
            currLoc += 7;
            while( isspace(*currLoc) ) currLoc++;
            if( !strncasecmp( currLoc, "pixel", 5 ) ) {
               cFmt = pixel_fmt;
            } else if( !strncasecmp( currLoc, "degree", 6 ) ) {
               cFmt = degree_fmt;
            } else if( !strncasecmp( currLoc, "hhmmss", 6 ) ) {
               cFmt = hhmmss_fmt;
            } else if( !strncasecmp( currLoc, "hms", 3 ) ) {
               cFmt = hhmmss_fmt;
            } else {
               ffpmsg("Unknown format code encountered in region file.");
               *status = PARSE_SYNTAX_ERR;
               goto error;
            }
         }

      } else if( !strncasecmp( currLoc, "glob", 4 ) ) {
		  /* skip lines that begin with the word 'global' */

      } else {

         while( *currLoc != '\0' ) {

            namePtr  = currLoc;
            paramPtr = NULL;
            nParams  = 1;

            /*  Search for closing parenthesis  */

            done = 0;
            while( !done && !*status && *currLoc ) {
               switch (*currLoc) {
               case '(':
                  *currLoc = '\0';
                  currLoc++;
                  if( paramPtr )   /* Can't have two '(' in a region! */
                     *status = 1;
                  else
                     paramPtr = currLoc;
                  break;
               case ')':
                  *currLoc = '\0';
                  currLoc++;
                  if( !paramPtr )  /* Can't have a ')' without a '(' first */
                     *status = 1;
                  else
                     done = 1;
                  break;
               case '#':
               case '\n':
                  *currLoc = '\0';
                  if( !paramPtr )  /* Allow for a blank line */
                     done = 1;
                  break;
               case ':':  
                  currLoc++;
                  if ( paramPtr ) cFmt = hhmmss_fmt; /* set format if parameter has : */
                  break;
               case 'd':
                  currLoc++;
                  if ( paramPtr ) cFmt = degree_fmt; /* set format if parameter has d */  
                  break;
               case ',':
                  nParams++;  /* Fall through to default */
               default:
                  currLoc++;
                  break;
               }
            }
            if( *status || !done ) {
               ffpmsg( "Error reading Region file" );
               *status = PARSE_SYNTAX_ERR;
               goto error;
            }

            /*  Skip white space in region name  */

            while( isspace(*namePtr) ) namePtr++;

            /*  Was this a blank line? Or the end of the current one  */

            if( ! *namePtr && ! paramPtr ) continue;

            /*  Check for format code at beginning of the line */

            if( !strncasecmp( namePtr, "image;", 6 ) ) {
				namePtr += 6;
				cFmt = pixel_fmt;
            } else if( !strncasecmp( namePtr, "physical;", 9 ) ) {
                                namePtr += 9;
                                cFmt = pixel_fmt;
            } else if( !strncasecmp( namePtr, "linear;", 7 ) ) {
                                namePtr += 7;
                                cFmt = pixel_fmt;
            } else if( !strncasecmp( namePtr, "fk4;", 4 ) ) {
				namePtr += 4;
				cFmt = degree_fmt;
            } else if( !strncasecmp( namePtr, "fk5;", 4 ) ) {
				namePtr += 4;
				cFmt = degree_fmt;
            } else if( !strncasecmp( namePtr, "icrs;", 5 ) ) {
				namePtr += 5;
				cFmt = degree_fmt;

            /* the following 5 cases support region files created by POW 
	       (or ds9 Version 4.x) which
               may have lines containing  only a format code, not followed
               by a ';' (and with no region specifier on the line).  We use
               the 'continue' statement to jump to the end of the loop and
               then continue reading the next line of the region file. */

            } else if( !strncasecmp( namePtr, "fk5", 3 ) ) {
				cFmt = degree_fmt;
                                continue;  /* supports POW region file format */
            } else if( !strncasecmp( namePtr, "fk4", 3 ) ) {
				cFmt = degree_fmt;
                                continue;  /* supports POW region file format */
            } else if( !strncasecmp( namePtr, "icrs", 4 ) ) {
				cFmt = degree_fmt;
                                continue;  /* supports POW region file format */
            } else if( !strncasecmp( namePtr, "image", 5 ) ) {
				cFmt = pixel_fmt;
                                continue;  /* supports POW region file format */
            } else if( !strncasecmp( namePtr, "physical", 8 ) ) {
				cFmt = pixel_fmt;
                                continue;  /* supports POW region file format */


            } else if( !strncasecmp( namePtr, "galactic;", 9 ) ) {
               ffpmsg( "Galactic region coordinates not supported" );
               ffpmsg( namePtr );
               *status = PARSE_SYNTAX_ERR;
               goto error;
            } else if( !strncasecmp( namePtr, "ecliptic;", 9 ) ) {
               ffpmsg( "ecliptic region coordinates not supported" );
               ffpmsg( namePtr );
               *status = PARSE_SYNTAX_ERR;
               goto error;
            }

            /**************************************************/
            /*  We've apparently found a region... Set it up  */
            /**************************************************/

            if( !(aRgn->nShapes % 10) ) {
               if( aRgn->Shapes )
                  tmpShape = (RgnShape *)realloc( aRgn->Shapes,
                                                  (10+aRgn->nShapes)
                                                  * sizeof(RgnShape) );
               else
                  tmpShape = (RgnShape *) malloc( 10 * sizeof(RgnShape) );
               if( tmpShape ) {
                  aRgn->Shapes = tmpShape;
               } else {
                  ffpmsg( "Failed to allocate memory for Region data");
                  *status = MEMORY_ALLOCATION;
                  goto error;
               }

            }
            newShape        = &aRgn->Shapes[aRgn->nShapes++];
            newShape->sign  = 1;
            newShape->shape = point_rgn;
	    for (i=0; i<8; i++) newShape->param.gen.p[i] = 0.0;
	    newShape->param.gen.a = 0.0;
	    newShape->param.gen.b = 0.0;
	    newShape->param.gen.sinT = 0.0;
	    newShape->param.gen.cosT = 0.0;

            while( isspace(*namePtr) ) namePtr++;
            
			/*  Check for the shape's sign  */

            if( *namePtr=='+' ) {
               namePtr++;
            } else if( *namePtr=='-' ) {
               namePtr++;
               newShape->sign = 0;
            }

            /* Skip white space in region name */

            while( isspace(*namePtr) ) namePtr++;
            if( *namePtr=='\0' ) {
               ffpmsg( "Error reading Region file" );
               *status = PARSE_SYNTAX_ERR;
               goto error;
            }
            lineLen = strlen( namePtr ) - 1;
            while( isspace(namePtr[lineLen]) ) namePtr[lineLen--] = '\0';

            /*  Now identify the region  */

            if(        !strcasecmp( namePtr, "circle"  ) ) {
               newShape->shape = circle_rgn;
               if( nParams != 3 )
                  *status = PARSE_SYNTAX_ERR;
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "annulus" ) ) {
               newShape->shape = annulus_rgn;
               if( nParams != 4 )
                  *status = PARSE_SYNTAX_ERR;
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "ellipse" ) ) {
               if( nParams < 4 || nParams > 8 ) {
                  *status = PARSE_SYNTAX_ERR;
	       } else if ( nParams < 6 ) {
		 newShape->shape = ellipse_rgn;
		 newShape->param.gen.p[4] = 0.0;
	       } else {
		 newShape->shape = elliptannulus_rgn;
		 newShape->param.gen.p[6] = 0.0;
		 newShape->param.gen.p[7] = 0.0;
	       }
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "elliptannulus" ) ) {
               newShape->shape = elliptannulus_rgn;
               if( !( nParams==8 || nParams==6 ) )
                  *status = PARSE_SYNTAX_ERR;
               newShape->param.gen.p[6] = 0.0;
               newShape->param.gen.p[7] = 0.0;
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "box"    ) 
                    || !strcasecmp( namePtr, "rotbox" ) ) {
	       if( nParams < 4 || nParams > 8 ) {
		 *status = PARSE_SYNTAX_ERR;
	       } else if ( nParams < 6 ) {
		 newShape->shape = box_rgn;
		 newShape->param.gen.p[4] = 0.0;
	       } else {
		  newShape->shape = boxannulus_rgn;
		  newShape->param.gen.p[6] = 0.0;
		  newShape->param.gen.p[7] = 0.0;
	       }
	       nCoords = 2;
            } else if( !strcasecmp( namePtr, "rectangle"    )
                    || !strcasecmp( namePtr, "rotrectangle" ) ) {
               newShape->shape = rectangle_rgn;
               if( nParams < 4 || nParams > 5 )
                  *status = PARSE_SYNTAX_ERR;
               newShape->param.gen.p[4] = 0.0;
               nCoords = 4;
            } else if( !strcasecmp( namePtr, "diamond"    )
                    || !strcasecmp( namePtr, "rotdiamond" )
                    || !strcasecmp( namePtr, "rhombus"    )
                    || !strcasecmp( namePtr, "rotrhombus" ) ) {
               newShape->shape = diamond_rgn;
               if( nParams < 4 || nParams > 5 )
                  *status = PARSE_SYNTAX_ERR;
               newShape->param.gen.p[4] = 0.0;
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "sector"  )
                    || !strcasecmp( namePtr, "pie"     ) ) {
               newShape->shape = sector_rgn;
               if( nParams != 4 )
                  *status = PARSE_SYNTAX_ERR;
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "point"   ) ) {
               newShape->shape = point_rgn;
               if( nParams != 2 )
                  *status = PARSE_SYNTAX_ERR;
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "line"    ) ) {
               newShape->shape = line_rgn;
               if( nParams != 4 )
                  *status = PARSE_SYNTAX_ERR;
               nCoords = 4;
            } else if( !strcasecmp( namePtr, "polygon" ) ) {
               newShape->shape = poly_rgn;
               if( nParams < 6 || (nParams&1) )
                  *status = PARSE_SYNTAX_ERR;
               nCoords = nParams;
            } else if( !strcasecmp( namePtr, "panda" ) ) {
               newShape->shape = panda_rgn;
               if( nParams != 8 )
                  *status = PARSE_SYNTAX_ERR;
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "epanda" ) ) {
               newShape->shape = epanda_rgn;
               if( nParams < 10 || nParams > 11 )
                  *status = PARSE_SYNTAX_ERR;
               newShape->param.gen.p[10] = 0.0;
               nCoords = 2;
            } else if( !strcasecmp( namePtr, "bpanda" ) ) {
               newShape->shape = bpanda_rgn;
               if( nParams < 10 || nParams > 11 )
                  *status = PARSE_SYNTAX_ERR;
               newShape->param.gen.p[10] = 0.0;
               nCoords = 2;
            } else {
               ffpmsg( "Unrecognized region found in region file:" );
               ffpmsg( namePtr );
               *status = PARSE_SYNTAX_ERR;
               goto error;
            }
            if( *status ) {
               ffpmsg( "Wrong number of parameters found for region" );
               ffpmsg( namePtr );
               goto error;
            }

            /*  Parse Parameter string... convert to pixels if necessary  */

            if( newShape->shape==poly_rgn ) {
               newShape->param.poly.Pts = (double *)malloc( nParams
                                                            * sizeof(double) );
               if( !newShape->param.poly.Pts ) {
                  ffpmsg(
                      "Could not allocate memory to hold polygon parameters" );
                  *status = MEMORY_ALLOCATION;
                  goto error;
               }
               newShape->param.poly.nPts = nParams;
               coords = newShape->param.poly.Pts;
            } else
               coords = newShape->param.gen.p;

            /*  Parse the initial "WCS?" coordinates  */
            for( i=0; iexists ) {
                     ffpmsg("WCS information needed to convert region coordinates.");
                     *status = NO_WCS_KEY;
                     goto error;
                  }
                  
                  if( ffxypx(  X,  Y, wcs->xrefval, wcs->yrefval,
                                      wcs->xrefpix, wcs->yrefpix,
                                      wcs->xinc,    wcs->yinc,
                                      wcs->rot,     wcs->type,
                              &x, &y, status ) ) {
                     ffpmsg("Error converting region to pixel coordinates.");
                     goto error;
                  }
                  X = x; Y = y;
               }
               coords[i]   = X;
               coords[i+1] = Y;

            }

            /*  Read in remaining parameters...  */

            for( ; ixrefval, wcs->yrefval,
			       wcs->xrefpix, wcs->yrefpix,
			       wcs->xinc,    wcs->yinc,
			       wcs->rot,     wcs->type,
                               &x, &y, status ) ) {
		     ffpmsg("Error converting region to pixel coordinates.");
		     goto error;
		  }
		 
		  coords[i] = sqrt( pow(x-coords[0],2) + pow(y-coords[1],2) );

               }
            }

	    /* special case for elliptannulus and boxannulus if only one angle
	       was given */

	    if ( (newShape->shape == elliptannulus_rgn || 
		  newShape->shape == boxannulus_rgn ) && nParams == 7 ) {
	      coords[7] = coords[6];
	    }

            /* Also, correct the position angle for any WCS rotation:  */
            /*    If regions are specified in WCS coordintes, then the angles */
            /*    are relative to the WCS system, not the pixel X,Y system */

	    if( cFmt!=pixel_fmt ) {	    
	      switch( newShape->shape ) {
	      case sector_rgn:
	      case panda_rgn:
		coords[2] += (wcs->rot);
		coords[3] += (wcs->rot);
		break;
	      case box_rgn:
	      case rectangle_rgn:
	      case diamond_rgn:
	      case ellipse_rgn:
		coords[4] += (wcs->rot);
		break;
	      case boxannulus_rgn:
	      case elliptannulus_rgn:
		coords[6] += (wcs->rot);
		coords[7] += (wcs->rot);
		break;
	      case epanda_rgn:
	      case bpanda_rgn:
		coords[2] += (wcs->rot);
		coords[3] += (wcs->rot);
		coords[10] += (wcs->rot);
              default:
                break;
	      }
	    }

	    /* do some precalculations to speed up tests */

	    fits_setup_shape(newShape);

         }  /* End of while( *currLoc ) */
/*
  if (coords)printf("%.8f %.8f %.8f %.8f %.8f\n",
   coords[0],coords[1],coords[2],coords[3],coords[4]); 
*/
      }  /* End of if...else parse line */
   }   /* End of while( fgets(rgnFile) ) */

   /* set up component numbers */

   fits_set_region_components( aRgn );

error:

   if( *status ) {
      fits_free_region( aRgn );
   } else {
      *Rgn = aRgn;
   }

   fclose( rgnFile );
   free( currLine );

   return( *status );
}

/*---------------------------------------------------------------------------*/
int fits_in_region( double    X,
            double    Y,
            SAORegion *Rgn )
/*  Test if the given point is within the region described by Rgn.  X and    */
/*  Y are in pixel coordinates.                                              */
/*---------------------------------------------------------------------------*/
{
   double x, y, dx, dy, xprime, yprime, r, th;
   RgnShape *Shapes;
   int i, cur_comp;
   int result, comp_result;

   Shapes = Rgn->Shapes;

   result = 0;
   comp_result = 0;
   cur_comp = Rgn->Shapes[0].comp;

   for( i=0; inShapes; i++, Shapes++ ) {

     /* if this region has a different component number to the last one  */
     /*	then replace the accumulated selection logical with the union of */
     /*	the current logical and the total logical. Reinitialize the      */
     /* temporary logical.                                               */

     if ( i==0 || Shapes->comp != cur_comp ) {
       result = result || comp_result;
       cur_comp = Shapes->comp;
       /* if an excluded region is given first, then implicitly   */
       /* assume a previous shape that includes the entire image. */
       comp_result = !Shapes->sign;
     }

    /* only need to test if  */
    /*   the point is not already included and this is an include region, */
    /* or the point is included and this is an excluded region */

    if ( (!comp_result && Shapes->sign) || (comp_result && !Shapes->sign) ) { 

      comp_result = 1;

      switch( Shapes->shape ) {

      case box_rgn:
         /*  Shift origin to center of region  */
         xprime = X - Shapes->param.gen.p[0];
         yprime = Y - Shapes->param.gen.p[1];

         /*  Rotate point to region's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;

         dx = 0.5 * Shapes->param.gen.p[2];
         dy = 0.5 * Shapes->param.gen.p[3];
         if( (x < -dx) || (x > dx) || (y < -dy) || (y > dy) )
            comp_result = 0;
         break;

      case boxannulus_rgn:
         /*  Shift origin to center of region  */
         xprime = X - Shapes->param.gen.p[0];
         yprime = Y - Shapes->param.gen.p[1];

         /*  Rotate point to region's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;

         dx = 0.5 * Shapes->param.gen.p[4];
         dy = 0.5 * Shapes->param.gen.p[5];
         if( (x < -dx) || (x > dx) || (y < -dy) || (y > dy) ) {
	   comp_result = 0;
	 } else {
	   /* Repeat test for inner box */
	   x =  xprime * Shapes->param.gen.b + yprime * Shapes->param.gen.a;
	   y = -xprime * Shapes->param.gen.a + yprime * Shapes->param.gen.b;
	   
	   dx = 0.5 * Shapes->param.gen.p[2];
	   dy = 0.5 * Shapes->param.gen.p[3];
	   if( (x >= -dx) && (x <= dx) && (y >= -dy) && (y <= dy) )
	     comp_result = 0;
	 }
         break;

      case rectangle_rgn:
         /*  Shift origin to center of region  */
         xprime = X - Shapes->param.gen.p[5];
         yprime = Y - Shapes->param.gen.p[6];

         /*  Rotate point to region's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;

         dx = Shapes->param.gen.a;
         dy = Shapes->param.gen.b;
         if( (x < -dx) || (x > dx) || (y < -dy) || (y > dy) )
            comp_result = 0;
         break;

      case diamond_rgn:
         /*  Shift origin to center of region  */
         xprime = X - Shapes->param.gen.p[0];
         yprime = Y - Shapes->param.gen.p[1];

         /*  Rotate point to region's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;

         dx = 0.5 * Shapes->param.gen.p[2];
         dy = 0.5 * Shapes->param.gen.p[3];
         r  = fabs(x/dx) + fabs(y/dy);
         if( r > 1 )
            comp_result = 0;
         break;

      case circle_rgn:
         /*  Shift origin to center of region  */
         x = X - Shapes->param.gen.p[0];
         y = Y - Shapes->param.gen.p[1];

         r  = x*x + y*y;
         if ( r > Shapes->param.gen.a )
            comp_result = 0;
         break;

      case annulus_rgn:
         /*  Shift origin to center of region  */
         x = X - Shapes->param.gen.p[0];
         y = Y - Shapes->param.gen.p[1];

         r = x*x + y*y;
         if ( r < Shapes->param.gen.a || r > Shapes->param.gen.b )
            comp_result = 0;
         break;

      case sector_rgn:
         /*  Shift origin to center of region  */
         x = X - Shapes->param.gen.p[0];
         y = Y - Shapes->param.gen.p[1];

         if( x || y ) {
            r = atan2( y, x ) * RadToDeg;
            if( Shapes->param.gen.p[2] <= Shapes->param.gen.p[3] ) {
               if( r < Shapes->param.gen.p[2] || r > Shapes->param.gen.p[3] )
                  comp_result = 0;
            } else {
               if( r < Shapes->param.gen.p[2] && r > Shapes->param.gen.p[3] )
                  comp_result = 0;
            }
         }
         break;

      case ellipse_rgn:
         /*  Shift origin to center of region  */
         xprime = X - Shapes->param.gen.p[0];
         yprime = Y - Shapes->param.gen.p[1];

         /*  Rotate point to region's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;

         x /= Shapes->param.gen.p[2];
         y /= Shapes->param.gen.p[3];
         r = x*x + y*y;
         if( r>1.0 )
            comp_result = 0;
         break;

      case elliptannulus_rgn:
         /*  Shift origin to center of region  */
         xprime = X - Shapes->param.gen.p[0];
         yprime = Y - Shapes->param.gen.p[1];

         /*  Rotate point to outer ellipse's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;

         x /= Shapes->param.gen.p[4];
         y /= Shapes->param.gen.p[5];
         r = x*x + y*y;
         if( r>1.0 )
            comp_result = 0;
         else {
            /*  Repeat test for inner ellipse  */
            x =  xprime * Shapes->param.gen.b + yprime * Shapes->param.gen.a;
            y = -xprime * Shapes->param.gen.a + yprime * Shapes->param.gen.b;

            x /= Shapes->param.gen.p[2];
            y /= Shapes->param.gen.p[3];
            r = x*x + y*y;
            if( r<1.0 )
               comp_result = 0;
         }
         break;

      case line_rgn:
         /*  Shift origin to first point of line  */
         xprime = X - Shapes->param.gen.p[0];
         yprime = Y - Shapes->param.gen.p[1];

         /*  Rotate point to line's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;

         if( (y < -0.5) || (y >= 0.5) || (x < -0.5)
             || (x >= Shapes->param.gen.a) )
            comp_result = 0;
         break;

      case point_rgn:
         /*  Shift origin to center of region  */
         x = X - Shapes->param.gen.p[0];
         y = Y - Shapes->param.gen.p[1];

         if ( (x<-0.5) || (x>=0.5) || (y<-0.5) || (y>=0.5) )
            comp_result = 0;
         break;

      case poly_rgn:
         if( Xxmin || X>Shapes->xmax
             || Yymin || Y>Shapes->ymax )
            comp_result = 0;
         else
            comp_result = Pt_in_Poly( X, Y, Shapes->param.poly.nPts,
                                       Shapes->param.poly.Pts );
         break;

      case panda_rgn:
         /*  Shift origin to center of region  */
         x = X - Shapes->param.gen.p[0];
         y = Y - Shapes->param.gen.p[1];

         r = x*x + y*y;
         if ( r < Shapes->param.gen.a || r > Shapes->param.gen.b ) {
	   comp_result = 0;
	 } else {
	   if( x || y ) {
	     th = atan2( y, x ) * RadToDeg;
	     if( Shapes->param.gen.p[2] <= Shapes->param.gen.p[3] ) {
               if( th < Shapes->param.gen.p[2] || th > Shapes->param.gen.p[3] )
		 comp_result = 0;
	     } else {
               if( th < Shapes->param.gen.p[2] && th > Shapes->param.gen.p[3] )
		 comp_result = 0;
	     }
	   }
         }
         break;

      case epanda_rgn:
         /*  Shift origin to center of region  */
         xprime = X - Shapes->param.gen.p[0];
         yprime = Y - Shapes->param.gen.p[1];

         /*  Rotate point to region's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;
	 xprime = x;
	 yprime = y;

	 /* outer region test */
         x = xprime/Shapes->param.gen.p[7];
         y = yprime/Shapes->param.gen.p[8];
         r = x*x + y*y;
	 if ( r>1.0 )
	   comp_result = 0;
	 else {
	   /* inner region test */
	   x = xprime/Shapes->param.gen.p[5];
	   y = yprime/Shapes->param.gen.p[6];
	   r = x*x + y*y;
	   if ( r<1.0 )
	     comp_result = 0;
	   else {
	     /* angle test */
	     if( xprime || yprime ) {
	       th = atan2( yprime, xprime ) * RadToDeg;
	       if( Shapes->param.gen.p[2] <= Shapes->param.gen.p[3] ) {
		 if( th < Shapes->param.gen.p[2] || th > Shapes->param.gen.p[3] )
		   comp_result = 0;
	       } else {
		 if( th < Shapes->param.gen.p[2] && th > Shapes->param.gen.p[3] )
		   comp_result = 0;
	       }
	     }
	   }
	 }
         break;

      case bpanda_rgn:
         /*  Shift origin to center of region  */
         xprime = X - Shapes->param.gen.p[0];
         yprime = Y - Shapes->param.gen.p[1];

         /*  Rotate point to region's orientation  */
         x =  xprime * Shapes->param.gen.cosT + yprime * Shapes->param.gen.sinT;
         y = -xprime * Shapes->param.gen.sinT + yprime * Shapes->param.gen.cosT;

	 /* outer box test */
         dx = 0.5 * Shapes->param.gen.p[7];
         dy = 0.5 * Shapes->param.gen.p[8];
         if( (x < -dx) || (x > dx) || (y < -dy) || (y > dy) )
	   comp_result = 0;
	 else {
	   /* inner box test */
	   dx = 0.5 * Shapes->param.gen.p[5];
	   dy = 0.5 * Shapes->param.gen.p[6];
	   if( (x >= -dx) && (x <= dx) && (y >= -dy) && (y <= dy) )
	     comp_result = 0;
	   else {
	     /* angle test */
	     if( x || y ) {
	       th = atan2( y, x ) * RadToDeg;
	       if( Shapes->param.gen.p[2] <= Shapes->param.gen.p[3] ) {
		 if( th < Shapes->param.gen.p[2] || th > Shapes->param.gen.p[3] )
		   comp_result = 0;
	       } else {
		 if( th < Shapes->param.gen.p[2] && th > Shapes->param.gen.p[3] )
		   comp_result = 0;
	       }
	     }
	   }
	 }
         break;
      }

      if( !Shapes->sign ) comp_result = !comp_result;

     } 

   }

   result = result || comp_result;
   
   return( result );
}

/*---------------------------------------------------------------------------*/
void fits_free_region( SAORegion *Rgn )
/*   Free up memory allocated to hold the region data.                       */
/*---------------------------------------------------------------------------*/
{
   int i;

   for( i=0; inShapes; i++ )
      if( Rgn->Shapes[i].shape == poly_rgn )
         free( Rgn->Shapes[i].param.poly.Pts );
   if( Rgn->Shapes )
      free( Rgn->Shapes );
   free( Rgn );
}

/*---------------------------------------------------------------------------*/
static int Pt_in_Poly( double x,
                       double y,
                       int nPts,
                       double *Pts )
/*  Internal routine for testing whether the coordinate x,y is within the    */
/*  polygon region traced out by the array Pts.                              */
/*---------------------------------------------------------------------------*/
{
   int i, j, flag=0;
   double prevX, prevY;
   double nextX, nextY;
   double dx, dy, Dy;

   nextX = Pts[nPts-2];
   nextY = Pts[nPts-1];

   for( i=0; iprevY && y>=nextY) || (yprevX && x>=nextX) )
         continue;
      
      /* Check to see if x,y lies right on the segment */

      if( x>=prevX || x>nextX ) {
         dy = y - prevY;
         Dy = nextY - prevY;

         if( fabs(Dy)<1e-10 ) {
            if( fabs(dy)<1e-10 )
               return( 1 );
            else
               continue;
         }

         dx = prevX + ( (nextX-prevX)/(Dy) ) * dy - x;
         if( dx < -1e-10 )
            continue;
         if( dx <  1e-10 )
            return( 1 );
      }

      /* There is an intersection! Make sure it isn't a V point.  */

      if( y != prevY ) {
         flag = 1 - flag;
      } else {
         j = i+1;  /* Point to Y component */
         do {
            if( j>1 )
               j -= 2;
            else
               j = nPts-1;
         } while( y == Pts[j] );

         if( (nextY-y)*(y-Pts[j]) > 0 )
            flag = 1-flag;
      }

   }
   return( flag );
}
/*---------------------------------------------------------------------------*/
void fits_set_region_components ( SAORegion *aRgn )
{
/* 
   Internal routine to turn a collection of regions read from an ascii file into
   the more complex structure that is allowed by the FITS REGION extension with
   multiple components. Regions are anded within components and ored between them
   ie for a pixel to be selected it must be selected by at least one component
   and to be selected by a component it must be selected by all that component's
   shapes.

   The algorithm is to replicate every exclude region after every include
   region before it in the list. eg reg1, reg2, -reg3, reg4, -reg5 becomes
   (reg1, -reg3, -reg5), (reg2, -reg5, -reg3), (reg4, -reg5) where the
   parentheses designate components.
*/

  int i, j, k, icomp;

/* loop round shapes */

  i = 0;
  while ( inShapes ) {

    /* first do the case of an exclude region */

    if ( !aRgn->Shapes[i].sign ) {

      /* we need to run back through the list copying the current shape as
	 required. start by findin the first include shape before this exclude */

      j = i-1;
      while ( j > 0 && !aRgn->Shapes[j].sign ) j--;

      /* then go back one more shape */

      j--;

      /* and loop back through the regions */

      while ( j >= 0 ) {

	/* if this is an include region then insert a copy of the exclude
	   region immediately after it */

	if ( aRgn->Shapes[j].sign ) {

	  aRgn->Shapes = (RgnShape *) realloc (aRgn->Shapes,(1+aRgn->nShapes)*sizeof(RgnShape));
	  aRgn->nShapes++;
	  for (k=aRgn->nShapes-1; k>j+1; k--) aRgn->Shapes[k] = aRgn->Shapes[k-1];

	  i++;
	  aRgn->Shapes[j+1] = aRgn->Shapes[i];

	}

	j--;

      }

    }

    i++;

  }

  /* now set the component numbers */

  icomp = 0;
  for ( i=0; inShapes; i++ ) {
    if ( aRgn->Shapes[i].sign ) icomp++;
    aRgn->Shapes[i].comp = icomp;

    /*
    printf("i = %d, shape = %d, sign = %d, comp = %d\n", i, aRgn->Shapes[i].shape, aRgn->Shapes[i].sign, aRgn->Shapes[i].comp);
    */

  }

  return;

}

/*---------------------------------------------------------------------------*/
void fits_setup_shape ( RgnShape *newShape)
{
/* Perform some useful calculations now to speed up filter later             */

  double X, Y, R;
  double *coords;
  int i;

  if ( newShape->shape == poly_rgn ) {
    coords = newShape->param.poly.Pts;
  } else {
    coords = newShape->param.gen.p;
  }

  switch( newShape->shape ) {
  case circle_rgn:
    newShape->param.gen.a = coords[2] * coords[2];
    break;
  case annulus_rgn:
    newShape->param.gen.a = coords[2] * coords[2];
    newShape->param.gen.b = coords[3] * coords[3];
    break;
  case sector_rgn:
    while( coords[2]> 180.0 ) coords[2] -= 360.0;
    while( coords[2]<=-180.0 ) coords[2] += 360.0;
    while( coords[3]> 180.0 ) coords[3] -= 360.0;
    while( coords[3]<=-180.0 ) coords[3] += 360.0;
    break;
  case ellipse_rgn:
    newShape->param.gen.sinT = sin( myPI * (coords[4] / 180.0) );
    newShape->param.gen.cosT = cos( myPI * (coords[4] / 180.0) );
    break;
  case elliptannulus_rgn:
    newShape->param.gen.a    = sin( myPI * (coords[6] / 180.0) );
    newShape->param.gen.b    = cos( myPI * (coords[6] / 180.0) );
    newShape->param.gen.sinT = sin( myPI * (coords[7] / 180.0) );
    newShape->param.gen.cosT = cos( myPI * (coords[7] / 180.0) );
    break;
  case box_rgn:
    newShape->param.gen.sinT = sin( myPI * (coords[4] / 180.0) );
    newShape->param.gen.cosT = cos( myPI * (coords[4] / 180.0) );
    break;
  case boxannulus_rgn:
    newShape->param.gen.a    = sin( myPI * (coords[6] / 180.0) );
    newShape->param.gen.b    = cos( myPI * (coords[6] / 180.0) );
    newShape->param.gen.sinT = sin( myPI * (coords[7] / 180.0) );
    newShape->param.gen.cosT = cos( myPI * (coords[7] / 180.0) );
    break;
  case rectangle_rgn:
    newShape->param.gen.sinT = sin( myPI * (coords[4] / 180.0) );
    newShape->param.gen.cosT = cos( myPI * (coords[4] / 180.0) );
    X = 0.5 * ( coords[2]-coords[0] );
    Y = 0.5 * ( coords[3]-coords[1] );
    newShape->param.gen.a = fabs( X * newShape->param.gen.cosT
				  + Y * newShape->param.gen.sinT );
    newShape->param.gen.b = fabs( Y * newShape->param.gen.cosT
				  - X * newShape->param.gen.sinT );
    newShape->param.gen.p[5] = 0.5 * ( coords[2]+coords[0] );
    newShape->param.gen.p[6] = 0.5 * ( coords[3]+coords[1] );
    break;
  case diamond_rgn:
    newShape->param.gen.sinT = sin( myPI * (coords[4] / 180.0) );
    newShape->param.gen.cosT = cos( myPI * (coords[4] / 180.0) );
    break;
  case line_rgn:
    X = coords[2] - coords[0];
    Y = coords[3] - coords[1];
    R = sqrt( X*X + Y*Y );
    newShape->param.gen.sinT = ( R ? Y/R : 0.0 );
    newShape->param.gen.cosT = ( R ? X/R : 1.0 );
    newShape->param.gen.a    = R + 0.5;
    break;
  case panda_rgn:
    while( coords[2]> 180.0 ) coords[2] -= 360.0;
    while( coords[2]<=-180.0 ) coords[2] += 360.0;
    while( coords[3]> 180.0 ) coords[3] -= 360.0;
    while( coords[3]<=-180.0 ) coords[3] += 360.0;
    newShape->param.gen.a = newShape->param.gen.p[5]*newShape->param.gen.p[5];
    newShape->param.gen.b = newShape->param.gen.p[6]*newShape->param.gen.p[6];
    break;
  case epanda_rgn:
  case bpanda_rgn:
    while( coords[2]> 180.0 ) coords[2] -= 360.0;
    while( coords[2]<=-180.0 ) coords[2] += 360.0;
    while( coords[3]> 180.0 ) coords[3] -= 360.0;
    while( coords[3]<=-180.0 ) coords[3] += 360.0;
    newShape->param.gen.sinT = sin( myPI * (coords[10] / 180.0) );
    newShape->param.gen.cosT = cos( myPI * (coords[10] / 180.0) );
    break;
  default:
    break;
  }

  /*  Set the xmin, xmax, ymin, ymax elements of the RgnShape structure */

  /* For everything which has first two parameters as center position just */
  /* find a circle that encompasses the region and use it to set the       */
  /* bounding box                                                          */

  R = -1.0;

  switch ( newShape->shape ) {

  case circle_rgn:
    R = coords[2];
    break;

  case annulus_rgn:
    R = coords[3];
    break;

  case ellipse_rgn:
    if ( coords[2] > coords[3] ) {
      R = coords[2];
    } else {
      R = coords[3];
    }
    break;

  case elliptannulus_rgn:
    if ( coords[4] > coords[5] ) {
      R = coords[4];
    } else {
      R = coords[5];
    }
    break;

  case box_rgn:
    R = sqrt(coords[2]*coords[2]+
	     coords[3]*coords[3])/2.0;
    break;

  case boxannulus_rgn:
    R = sqrt(coords[4]*coords[5]+
	     coords[4]*coords[5])/2.0;
    break;

  case diamond_rgn:
    if ( coords[2] > coords[3] ) {
      R = coords[2]/2.0;
    } else {
      R = coords[3]/2.0;
    }
    break;
    
  case point_rgn:
    R = 1.0;
    break;

  case panda_rgn:
    R = coords[6];
    break;

  case epanda_rgn:
    if ( coords[7] > coords[8] ) {
      R = coords[7];
    } else {
      R = coords[8];
    }
    break;

  case bpanda_rgn:
    R = sqrt(coords[7]*coords[8]+
	     coords[7]*coords[8])/2.0;
    break;

  default:
    break;
  }

  if ( R > 0.0 ) {

    newShape->xmin = coords[0] - R;
    newShape->xmax = coords[0] + R;
    newShape->ymin = coords[1] - R;
    newShape->ymax = coords[1] + R;

    return;

  }

  /* Now do the rest of the shapes that require individual methods */

  switch ( newShape->shape ) {

  case rectangle_rgn:
    R = sqrt((coords[5]-coords[0])*(coords[5]-coords[0])+
	     (coords[6]-coords[1])*(coords[6]-coords[1]));
    newShape->xmin = coords[5] - R;
    newShape->xmax = coords[5] + R;
    newShape->ymin = coords[6] - R;
    newShape->ymax = coords[6] + R;
    break;

  case poly_rgn:
    newShape->xmin = coords[0];
    newShape->xmax = coords[0];
    newShape->ymin = coords[1];
    newShape->ymax = coords[1];
    for( i=2; i < newShape->param.poly.nPts; ) {
      if( newShape->xmin > coords[i] ) /* Min X */
	newShape->xmin = coords[i];
      if( newShape->xmax < coords[i] ) /* Max X */
	newShape->xmax = coords[i];
      i++;
      if( newShape->ymin > coords[i] ) /* Min Y */
	newShape->ymin = coords[i];
      if( newShape->ymax < coords[i] ) /* Max Y */
	newShape->ymax = coords[i];
      i++;
    }
    break;

  case line_rgn:
    if ( coords[0] > coords[2] ) {
      newShape->xmin = coords[2];
      newShape->xmax = coords[0];
    } else {
      newShape->xmin = coords[0];
      newShape->xmax = coords[2];
    }
    if ( coords[1] > coords[3] ) {
      newShape->ymin = coords[3];
      newShape->ymax = coords[1];
    } else {
      newShape->ymin = coords[1];
      newShape->ymax = coords[3];
    }

    break;

    /* sector doesn't have min and max so indicate by setting max < min */

  case sector_rgn:
    newShape->xmin = 1.0;
    newShape->xmax = -1.0;
    newShape->ymin = 1.0;
    newShape->ymax = -1.0;
    break;

  default:
    break;
  }

  return;

}

/*---------------------------------------------------------------------------*/
int fits_read_fits_region ( fitsfile *fptr, 
			    WCSdata *wcs, 
			    SAORegion **Rgn, 
			    int *status)
/*  Read regions from a FITS region extension and return the information     */
/*  in the "SAORegion" structure.  If it is nonNULL, use wcs to convert the  */
/*  region coordinates to pixels.  Return an error if region is in degrees   */
/*  but no WCS data is provided.                                             */
/*---------------------------------------------------------------------------*/
{

  int i, j, icol[6], idum, anynul, npos;
  int dotransform, got_component = 1, tstatus;
  long icsize[6];
  double X, Y, Theta, Xsave = 0, Ysave = 0, Xpos, Ypos;
  double *coords;
  char *cvalue, *cvalue2;
  char comment[FLEN_COMMENT];
  char colname[6][FLEN_VALUE] = {"X", "Y", "SHAPE", "R", "ROTANG", "COMPONENT"};
  char shapename[17][FLEN_VALUE] = {"POINT","CIRCLE","ELLIPSE","ANNULUS",
				    "ELLIPTANNULUS","BOX","ROTBOX","BOXANNULUS",
				    "RECTANGLE","ROTRECTANGLE","POLYGON","PIE",
				    "SECTOR","DIAMOND","RHOMBUS","ROTDIAMOND",
				    "ROTRHOMBUS"};
  int shapetype[17] = {point_rgn, circle_rgn, ellipse_rgn, annulus_rgn, 
		       elliptannulus_rgn, box_rgn, box_rgn, boxannulus_rgn, 
		       rectangle_rgn, rectangle_rgn, poly_rgn, sector_rgn, 
		       sector_rgn, diamond_rgn, diamond_rgn, diamond_rgn, 
		       diamond_rgn};
  SAORegion *aRgn;
  RgnShape *newShape;
  WCSdata *regwcs = 0;

  if ( *status ) return( *status );

  aRgn = (SAORegion *)malloc( sizeof(SAORegion) );
  if( ! aRgn ) {
    ffpmsg("Couldn't allocate memory to hold Region file contents.");
    return(*status = MEMORY_ALLOCATION );
  }
  aRgn->nShapes    =    0;
  aRgn->Shapes     = NULL;
  if( wcs && wcs->exists )
    aRgn->wcs = *wcs;
  else
    aRgn->wcs.exists = 0;

  /* See if we are already positioned to a region extension, else */
  /* move to the REGION extension (file is already open). */

  tstatus = 0;
  for (i=0; i<5; i++) {
    ffgcno(fptr, CASEINSEN, colname[i], &icol[i], &tstatus);
  }

  if (tstatus) {
    /* couldn't find the required columns, so search for "REGION" extension */
    if ( ffmnhd(fptr, BINARY_TBL, "REGION", 1, status) ) {
      ffpmsg("Could not move to REGION extension.");
      goto error;
    }
  }

  /* get the number of shapes and allocate memory */

  if ( ffgky(fptr, TINT, "NAXIS2", &aRgn->nShapes, comment, status) ) {
    ffpmsg("Could not read NAXIS2 keyword.");
    goto error;
  }

  aRgn->Shapes = (RgnShape *) malloc(aRgn->nShapes * sizeof(RgnShape));
  if ( !aRgn->Shapes ) {
    ffpmsg( "Failed to allocate memory for Region data");
    *status = MEMORY_ALLOCATION;
    goto error;
  }

  /* get the required column numbers */

  for (i=0; i<5; i++) {
    if ( ffgcno(fptr, CASEINSEN, colname[i], &icol[i], status) ) {
      ffpmsg("Could not find column.");
      goto error;
    }
  }

  /* try to get the optional column numbers */

  if ( ffgcno(fptr, CASEINSEN, colname[5], &icol[5], status) ) {
       got_component = 0;
  }

  /* if there was input WCS then read the WCS info for the region in case they */
  /* are different and we have to transform */

  dotransform = 0;
  if ( aRgn->wcs.exists ) {
    regwcs = (WCSdata *) malloc ( sizeof(WCSdata) );
    if ( !regwcs ) {
      ffpmsg( "Failed to allocate memory for Region WCS data");
      *status = MEMORY_ALLOCATION;
      goto error;
    }

    regwcs->exists = 1;
    if ( ffgtcs(fptr, icol[0], icol[1], ®wcs->xrefval,  ®wcs->yrefval,
		®wcs->xrefpix, ®wcs->yrefpix, ®wcs->xinc, ®wcs->yinc,
		®wcs->rot, regwcs->type, status) ) {
      regwcs->exists = 0;
      *status = 0;
    }

    if ( regwcs->exists && wcs->exists ) {
      if ( fabs(regwcs->xrefval-wcs->xrefval) > 1.0e-6 ||
	   fabs(regwcs->yrefval-wcs->yrefval) > 1.0e-6 ||
	   fabs(regwcs->xrefpix-wcs->xrefpix) > 1.0e-6 ||
	   fabs(regwcs->yrefpix-wcs->yrefpix) > 1.0e-6 ||
	   fabs(regwcs->xinc-wcs->xinc) > 1.0e-6 ||
	   fabs(regwcs->yinc-wcs->yinc) > 1.0e-6 ||
	   fabs(regwcs->rot-wcs->rot) > 1.0e-6 ||
	   !strcmp(regwcs->type,wcs->type) ) dotransform = 1;
    }
  }

  /* get the sizes of the X, Y, R, and ROTANG vectors */

  for (i=0; i<6; i++) {
    if ( ffgtdm(fptr, icol[i], 1, &idum, &icsize[i], status) ) {
      ffpmsg("Could not find vector size of column.");
      goto error;
    }
  }

  cvalue = (char *) malloc ((FLEN_VALUE+1)*sizeof(char));

  /* loop over the shapes - note 1-based counting for rows in FITS files */

  for (i=1; i<=aRgn->nShapes; i++) {

    newShape = &aRgn->Shapes[i-1];
    for (j=0; j<8; j++) newShape->param.gen.p[j] = 0.0;
    newShape->param.gen.a = 0.0;
    newShape->param.gen.b = 0.0;
    newShape->param.gen.sinT = 0.0;
    newShape->param.gen.cosT = 0.0;

    /* get the shape */

    if ( ffgcvs(fptr, icol[2], i, 1, 1, " ", &cvalue, &anynul, status) ) {
      ffpmsg("Could not read shape.");
      goto error;
    }

    /* set include or exclude */

    newShape->sign = 1;
    cvalue2 = cvalue;
    if ( !strncmp(cvalue,"!",1) ) {
      newShape->sign = 0;
      cvalue2++;
    }

    /* set the shape type */

    for (j=0; j<9; j++) {
      if ( !strcmp(cvalue2, shapename[j]) ) newShape->shape = shapetype[j];
    }

    /* allocate memory for polygon case and set coords pointer */

    if ( newShape->shape == poly_rgn ) {
      newShape->param.poly.Pts = (double *) calloc (2*icsize[0], sizeof(double));
      if ( !newShape->param.poly.Pts ) {
	ffpmsg("Could not allocate memory to hold polygon parameters" );
	*status = MEMORY_ALLOCATION;
	goto error;
      }
      newShape->param.poly.nPts = 2*icsize[0];
      coords = newShape->param.poly.Pts;
    } else {
      coords = newShape->param.gen.p;
    }


  /* read X and Y. Polygon and Rectangle require special cases */

    npos = 1;
    if ( newShape->shape == poly_rgn ) npos = newShape->param.poly.nPts/2;
    if ( newShape->shape == rectangle_rgn ) npos = 2;

    for (j=0; jparam.poly.nPts = npos * 2;
	break;
      }
      coords++;
      
      if ( ffgcvd(fptr, icol[1], i, j+1, 1, DOUBLENULLVALUE, coords, &anynul, status) ) {
	ffpmsg("Failed to read Y column for polygon region");
	goto error;
      }
      if (*coords == DOUBLENULLVALUE) { /* check for null value end of array marker */
        npos = j;
	newShape->param.poly.nPts = npos * 2;
        coords--;
	break;
      }
      coords++;
 
      if (j == 0) {  /* save the first X and Y coordinate */
        Xsave = *(coords - 2);
	Ysave = *(coords - 1);
      } else if ((Xsave == *(coords - 2)) && (Ysave == *(coords - 1)) ) {
        /* if point has same coordinate as first point, this marks the end of the array */
        npos = j + 1;
	newShape->param.poly.nPts = npos * 2;
	break;
      }
    }

    /* transform positions if the region and input wcs differ */

    if ( dotransform ) {

      coords -= npos*2;
      Xsave = coords[0];
      Ysave = coords[1];
      for (j=0; jxrefval, regwcs->yrefval, regwcs->xrefpix,
	       regwcs->yrefpix, regwcs->xinc, regwcs->yinc, regwcs->rot,
	       regwcs->type, &Xpos, &Ypos, status);
	ffxypx(Xpos, Ypos, wcs->xrefval, wcs->yrefval, wcs->xrefpix,
	       wcs->yrefpix, wcs->xinc, wcs->yinc, wcs->rot,
	       wcs->type, &coords[2*j], &coords[2*j+1], status);
	if ( *status ) {
	  ffpmsg("Failed to transform coordinates");
	  goto error;
	}
      }
      coords += npos*2;
    }

  /* read R. Circle requires one number; Box, Diamond, Ellipse, Annulus, Sector 
     and Panda two; Boxannulus and Elliptannulus four; Point, Rectangle and 
     Polygon none. */

    npos = 0;
    switch ( newShape->shape ) {
    case circle_rgn: 
      npos = 1;
      break;
    case box_rgn:
    case diamond_rgn:
    case ellipse_rgn:
    case annulus_rgn:
    case sector_rgn:
      npos = 2;
      break;
    case boxannulus_rgn:
    case elliptannulus_rgn:
      npos = 4;
      break;
    default:
      break;
    }

    if ( npos > 0 ) {
      if ( ffgcvd(fptr, icol[3], i, 1, npos, 0.0, coords, &anynul, status) ) {
	ffpmsg("Failed to read R column for region");
	goto error;
      }

    /* transform lengths if the region and input wcs differ */

      if ( dotransform ) {
	for (j=0; jxrefval, regwcs->yrefval, regwcs->xrefpix,
		 regwcs->yrefpix, regwcs->xinc, regwcs->yinc, regwcs->rot,
		 regwcs->type, &Xpos, &Ypos, status);
	  ffxypx(Xpos, Ypos, wcs->xrefval, wcs->yrefval, wcs->xrefpix,
		 wcs->yrefpix, wcs->xinc, wcs->yinc, wcs->rot,
		 wcs->type, &X, &Y, status);
	  if ( *status ) {
	    ffpmsg("Failed to transform coordinates");
	    goto error;
	  }
	  *(coords++) = sqrt(pow(X-newShape->param.gen.p[0],2)+pow(Y-newShape->param.gen.p[1],2));
	}
      } else {
	coords += npos;
      }
    }

  /* read ROTANG. Requires two values for Boxannulus, Elliptannulus, Sector, 
     Panda; one for Box, Diamond, Ellipse; and none for Circle, Point, Annulus, 
     Rectangle, Polygon */

    npos = 0;
    switch ( newShape->shape ) {
    case box_rgn:
    case diamond_rgn:
    case ellipse_rgn:
      npos = 1;
      break;
    case boxannulus_rgn:
    case elliptannulus_rgn:
    case sector_rgn:
      npos = 2;
      break;
    default:
     break;
    }

    if ( npos > 0 ) {
      if ( ffgcvd(fptr, icol[4], i, 1, npos, 0.0, coords, &anynul, status) ) {
	ffpmsg("Failed to read ROTANG column for region");
	goto error;
      }

    /* transform angles if the region and input wcs differ */

      if ( dotransform ) {
	Theta = (wcs->rot) - (regwcs->rot);
	for (j=0; jcomp, &anynul, status) ) {
        ffpmsg("Failed to read COMPONENT column for region");
        goto error;
      }
    } else {
      newShape->comp = 1;
    }


    /* do some precalculations to speed up tests */

    fits_setup_shape(newShape);

    /* end loop over shapes */

  }

error:

   if( *status )
      fits_free_region( aRgn );
   else
      *Rgn = aRgn;

   ffclos(fptr, status);

   return( *status );
}

healpy-1.10.3/cfitsio/region.h0000664000175000017500000000415513010375005016421 0ustar  zoncazonca00000000000000/***************************************************************/
/*                   REGION STUFF                              */
/***************************************************************/

#include "fitsio.h"
#define myPI  3.1415926535897932385
#define RadToDeg 180.0/myPI

typedef struct {
   int    exists;
   double xrefval, yrefval;
   double xrefpix, yrefpix;
   double xinc,    yinc;
   double rot;
   char   type[6];
} WCSdata;

typedef enum {
   point_rgn,
   line_rgn,
   circle_rgn,
   annulus_rgn,
   ellipse_rgn,
   elliptannulus_rgn,
   box_rgn,
   boxannulus_rgn,
   rectangle_rgn,
   diamond_rgn,
   sector_rgn,
   poly_rgn,
   panda_rgn,
   epanda_rgn,
   bpanda_rgn
} shapeType;

typedef enum { pixel_fmt, degree_fmt, hhmmss_fmt } coordFmt;
   
typedef struct {
   char      sign;        /*  Include or exclude?        */
   shapeType shape;       /*  Shape of this region       */
   int       comp;        /*  Component number for this region */

   double xmin,xmax;       /*  bounding box    */
   double ymin,ymax;

   union {                /*  Parameters - In pixels     */

      /****   Generic Shape Data   ****/

      struct {
	 double p[11];       /*  Region parameters       */
	 double sinT, cosT;  /*  For rotated shapes      */
	 double a, b;        /*  Extra scratch area      */
      } gen;

      /****      Polygon Data      ****/

      struct {
         int    nPts;        /*  Number of Polygon pts   */
         double *Pts;        /*  Polygon points          */
      } poly;

   } param;

} RgnShape;

typedef struct {
   int       nShapes;
   RgnShape  *Shapes;
   WCSdata   wcs;
} SAORegion;

/*  SAO region file routines */
int  fits_read_rgnfile( const char *filename, WCSdata *wcs, SAORegion **Rgn, int *status );
int  fits_in_region( double X, double Y, SAORegion *Rgn );
void fits_free_region( SAORegion *Rgn );
void fits_set_region_components ( SAORegion *Rgn );
void fits_setup_shape ( RgnShape *shape);
int fits_read_fits_region ( fitsfile *fptr, WCSdata * wcs, SAORegion **Rgn, int *status);
int fits_read_ascii_region ( const char *filename, WCSdata * wcs, SAORegion **Rgn, int *status);


healpy-1.10.3/cfitsio/ricecomp.c0000664000175000017500000010462213010375005016732 0ustar  zoncazonca00000000000000/*
  The following code was written by Richard White at STScI and made
  available for use in CFITSIO in July 1999.  These routines were
  originally contained in 2 source files: rcomp.c and rdecomp.c,
  and the 'include' file now called ricecomp.h was originally called buffer.h.
*/

/*----------------------------------------------------------*/
/*                                                          */
/*    START OF SOURCE FILE ORIGINALLY CALLED rcomp.c        */
/*                                                          */
/*----------------------------------------------------------*/
/* @(#) rcomp.c 1.5 99/03/01 12:40:27 */
/* rcomp.c	Compress image line using
 *		(1) Difference of adjacent pixels
 *		(2) Rice algorithm coding
 *
 * Returns number of bytes written to code buffer or
 * -1 on failure
 */

#include 
#include 
#include 

/*
 * nonzero_count is lookup table giving number of bits in 8-bit values not including
 * leading zeros used in fits_rdecomp, fits_rdecomp_short and fits_rdecomp_byte
 */
static const int nonzero_count[256] = {
0, 
1, 
2, 2, 
3, 3, 3, 3, 
4, 4, 4, 4, 4, 4, 4, 4, 
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8};

typedef unsigned char Buffer_t;

typedef struct {
	int bitbuffer;		/* bit buffer			*/
	int bits_to_go;		/* bits to go in buffer		*/
	Buffer_t *start;	/* start of buffer		*/
	Buffer_t *current;	/* current position in buffer	*/
	Buffer_t *end;		/* end of buffer		*/
} Buffer;

#define putcbuf(c,mf) 	((*(mf->current)++ = c), 0)

#include "fitsio2.h"

static void start_outputing_bits(Buffer *buffer);
static int done_outputing_bits(Buffer *buffer);
static int output_nbits(Buffer *buffer, int bits, int n);

/*  only used for diagnoistics
static int case1, case2, case3;
int fits_get_case(int *c1, int*c2, int*c3) {

  *c1 = case1;
  *c2 = case2;
  *c3 = case3;
  return(0);
}
*/

/* this routine used to be called 'rcomp'  (WDP)  */
/*---------------------------------------------------------------------------*/

int fits_rcomp(int a[],		/* input array			*/
	  int nx,		/* number of input pixels	*/
	  unsigned char *c,	/* output buffer		*/
	  int clen,		/* max length of output		*/
	  int nblock)		/* coding block size		*/
{
Buffer bufmem, *buffer = &bufmem;
/* int bsize;  */
int i, j, thisblock;
int lastpix, nextpix, pdiff;
int v, fs, fsmask, top, fsmax, fsbits, bbits;
int lbitbuffer, lbits_to_go;
unsigned int psum;
double pixelsum, dpsum;
unsigned int *diff;

    /*
     * Original size of each pixel (bsize, bytes) and coding block
     * size (nblock, pixels)
     * Could make bsize a parameter to allow more efficient
     * compression of short & byte images.
     */
/*    bsize = 4;   */

/*    nblock = 32; now an input parameter*/
    /*
     * From bsize derive:
     * FSBITS = # bits required to store FS
     * FSMAX = maximum value for FS
     * BBITS = bits/pixel for direct coding
     */

/*
    switch (bsize) {
    case 1:
	fsbits = 3;
	fsmax = 6;
	break;
    case 2:
	fsbits = 4;
	fsmax = 14;
	break;
    case 4:
	fsbits = 5;
	fsmax = 25;
	break;
    default:
        ffpmsg("rdecomp: bsize must be 1, 2, or 4 bytes");
	return(-1);
    }
*/

    /* move out of switch block, to tweak performance */
    fsbits = 5;
    fsmax = 25;

    bbits = 1<start = c;
    buffer->current = c;
    buffer->end = c+clen;
    buffer->bits_to_go = 8;
    /*
     * array for differences mapped to non-negative values
     */
    diff = (unsigned int *) malloc(nblock*sizeof(unsigned int));
    if (diff == (unsigned int *) NULL) {
        ffpmsg("fits_rcomp: insufficient memory");
	return(-1);
    }
    /*
     * Code in blocks of nblock pixels
     */
    start_outputing_bits(buffer);

    /* write out first int value to the first 4 bytes of the buffer */
    if (output_nbits(buffer, a[0], 32) == EOF) {
        ffpmsg("rice_encode: end of buffer");
        free(diff);
        return(-1);
    }

    lastpix = a[0];  /* the first difference will always be zero */

    thisblock = nblock;
    for (i=0; i> 1;
	for (fs = 0; psum>0; fs++) psum >>= 1;

	/*
	 * write the codes
	 * fsbits ID bits used to indicate split level
	 */
	if (fs >= fsmax) {
	    /* Special high entropy case when FS >= fsmax
	     * Just write pixel difference values directly, no Rice coding at all.
	     */
	    if (output_nbits(buffer, fsmax+1, fsbits) == EOF) {
                ffpmsg("rice_encode: end of buffer");
                free(diff);
		return(-1);
	    }
	    for (j=0; jbitbuffer;
	    lbits_to_go = buffer->bits_to_go;
	    for (j=0; j> fs;
		/*
		 * top is coded by top zeros + 1
		 */
		if (lbits_to_go >= top+1) {
		    lbitbuffer <<= top+1;
		    lbitbuffer |= 1;
		    lbits_to_go -= top+1;
		} else {
		    lbitbuffer <<= lbits_to_go;
		    putcbuf(lbitbuffer & 0xff,buffer);

		    for (top -= lbits_to_go; top>=8; top -= 8) {
			putcbuf(0, buffer);
		    }
		    lbitbuffer = 1;
		    lbits_to_go = 7-top;
		}
		/*
		 * bottom FS bits are written without coding
		 * code is output_nbits, moved into this routine to reduce overheads
		 * This code potentially breaks if FS>24, so I am limiting
		 * FS to 24 by choice of FSMAX above.
		 */
		if (fs > 0) {
		    lbitbuffer <<= fs;
		    lbitbuffer |= v & fsmask;
		    lbits_to_go -= fs;
		    while (lbits_to_go <= 0) {
			putcbuf((lbitbuffer>>(-lbits_to_go)) & 0xff,buffer);
			lbits_to_go += 8;
		    }
		}
	    }

	    /* check if overflowed output buffer */
	    if (buffer->current > buffer->end) {
                 ffpmsg("rice_encode: end of buffer");
                 free(diff);
		 return(-1);
	    }
	    buffer->bitbuffer = lbitbuffer;
	    buffer->bits_to_go = lbits_to_go;
	}
    }
    done_outputing_bits(buffer);
    free(diff);
    /*
     * return number of bytes used
     */
    return(buffer->current - buffer->start);
}
/*---------------------------------------------------------------------------*/

int fits_rcomp_short(
	  short a[],		/* input array			*/
	  int nx,		/* number of input pixels	*/
	  unsigned char *c,	/* output buffer		*/
	  int clen,		/* max length of output		*/
	  int nblock)		/* coding block size		*/
{
Buffer bufmem, *buffer = &bufmem;
/* int bsize;  */
int i, j, thisblock;

/* 
NOTE: in principle, the following 2 variable could be declared as 'short'
but in fact the code runs faster (on 32-bit Linux at least) as 'int'
*/
int lastpix, nextpix;
/* int pdiff; */
short pdiff; 
int v, fs, fsmask, top, fsmax, fsbits, bbits;
int lbitbuffer, lbits_to_go;
/* unsigned int psum; */
unsigned short psum;
double pixelsum, dpsum;
unsigned int *diff;

    /*
     * Original size of each pixel (bsize, bytes) and coding block
     * size (nblock, pixels)
     * Could make bsize a parameter to allow more efficient
     * compression of short & byte images.
     */
/*    bsize = 2; */

/*    nblock = 32; now an input parameter */
    /*
     * From bsize derive:
     * FSBITS = # bits required to store FS
     * FSMAX = maximum value for FS
     * BBITS = bits/pixel for direct coding
     */

/*
    switch (bsize) {
    case 1:
	fsbits = 3;
	fsmax = 6;
	break;
    case 2:
	fsbits = 4;
	fsmax = 14;
	break;
    case 4:
	fsbits = 5;
	fsmax = 25;
	break;
    default:
        ffpmsg("rdecomp: bsize must be 1, 2, or 4 bytes");
	return(-1);
    }
*/

    /* move these out of switch block to further tweak performance */
    fsbits = 4;
    fsmax = 14;
    
    bbits = 1<start = c;
    buffer->current = c;
    buffer->end = c+clen;
    buffer->bits_to_go = 8;
    /*
     * array for differences mapped to non-negative values
     */
    diff = (unsigned int *) malloc(nblock*sizeof(unsigned int));
    if (diff == (unsigned int *) NULL) {
        ffpmsg("fits_rcomp: insufficient memory");
	return(-1);
    }
    /*
     * Code in blocks of nblock pixels
     */
    start_outputing_bits(buffer);

    /* write out first short value to the first 2 bytes of the buffer */
    if (output_nbits(buffer, a[0], 16) == EOF) {
        ffpmsg("rice_encode: end of buffer");
        free(diff);
        return(-1);
    }

    lastpix = a[0];  /* the first difference will always be zero */

    thisblock = nblock;
    for (i=0; i> 1; */
	psum = ((unsigned short) dpsum ) >> 1;
	for (fs = 0; psum>0; fs++) psum >>= 1;

	/*
	 * write the codes
	 * fsbits ID bits used to indicate split level
	 */
	if (fs >= fsmax) {
/* case3++; */
	    /* Special high entropy case when FS >= fsmax
	     * Just write pixel difference values directly, no Rice coding at all.
	     */
	    if (output_nbits(buffer, fsmax+1, fsbits) == EOF) {
                ffpmsg("rice_encode: end of buffer");
                free(diff);
		return(-1);
	    }
	    for (j=0; jbitbuffer;
	    lbits_to_go = buffer->bits_to_go;
	    for (j=0; j> fs;
		/*
		 * top is coded by top zeros + 1
		 */
		if (lbits_to_go >= top+1) {
		    lbitbuffer <<= top+1;
		    lbitbuffer |= 1;
		    lbits_to_go -= top+1;
		} else {
		    lbitbuffer <<= lbits_to_go;
		    putcbuf(lbitbuffer & 0xff,buffer);
		    for (top -= lbits_to_go; top>=8; top -= 8) {
			putcbuf(0, buffer);
		    }
		    lbitbuffer = 1;
		    lbits_to_go = 7-top;
		}
		/*
		 * bottom FS bits are written without coding
		 * code is output_nbits, moved into this routine to reduce overheads
		 * This code potentially breaks if FS>24, so I am limiting
		 * FS to 24 by choice of FSMAX above.
		 */
		if (fs > 0) {
		    lbitbuffer <<= fs;
		    lbitbuffer |= v & fsmask;
		    lbits_to_go -= fs;
		    while (lbits_to_go <= 0) {
			putcbuf((lbitbuffer>>(-lbits_to_go)) & 0xff,buffer);
			lbits_to_go += 8;
		    }
		}
	    }
	    /* check if overflowed output buffer */
	    if (buffer->current > buffer->end) {
                 ffpmsg("rice_encode: end of buffer");
                 free(diff);
		 return(-1);
	    }
	    buffer->bitbuffer = lbitbuffer;
	    buffer->bits_to_go = lbits_to_go;
	}
    }
    done_outputing_bits(buffer);
    free(diff);
    /*
     * return number of bytes used
     */
    return(buffer->current - buffer->start);
}
/*---------------------------------------------------------------------------*/

int fits_rcomp_byte(
	  signed char a[],		/* input array			*/
	  int nx,		/* number of input pixels	*/
	  unsigned char *c,	/* output buffer		*/
	  int clen,		/* max length of output		*/
	  int nblock)		/* coding block size		*/
{
Buffer bufmem, *buffer = &bufmem;
/* int bsize; */
int i, j, thisblock;

/* 
NOTE: in principle, the following 2 variable could be declared as 'short'
but in fact the code runs faster (on 32-bit Linux at least) as 'int'
*/
int lastpix, nextpix;
/* int pdiff; */
signed char pdiff; 
int v, fs, fsmask, top, fsmax, fsbits, bbits;
int lbitbuffer, lbits_to_go;
/* unsigned int psum; */
unsigned char psum;
double pixelsum, dpsum;
unsigned int *diff;

    /*
     * Original size of each pixel (bsize, bytes) and coding block
     * size (nblock, pixels)
     * Could make bsize a parameter to allow more efficient
     * compression of short & byte images.
     */
/*    bsize = 1;  */

/*    nblock = 32; now an input parameter */
    /*
     * From bsize derive:
     * FSBITS = # bits required to store FS
     * FSMAX = maximum value for FS
     * BBITS = bits/pixel for direct coding
     */

/*
    switch (bsize) {
    case 1:
	fsbits = 3;
	fsmax = 6;
	break;
    case 2:
	fsbits = 4;
	fsmax = 14;
	break;
    case 4:
	fsbits = 5;
	fsmax = 25;
	break;
    default:
        ffpmsg("rdecomp: bsize must be 1, 2, or 4 bytes");
	return(-1);
    }
*/

    /* move these out of switch block to further tweak performance */
    fsbits = 3;
    fsmax = 6;
    bbits = 1<start = c;
    buffer->current = c;
    buffer->end = c+clen;
    buffer->bits_to_go = 8;
    /*
     * array for differences mapped to non-negative values
     */
    diff = (unsigned int *) malloc(nblock*sizeof(unsigned int));
    if (diff == (unsigned int *) NULL) {
        ffpmsg("fits_rcomp: insufficient memory");
	return(-1);
    }
    /*
     * Code in blocks of nblock pixels
     */
    start_outputing_bits(buffer);

    /* write out first byte value to the first  byte of the buffer */
    if (output_nbits(buffer, a[0], 8) == EOF) {
        ffpmsg("rice_encode: end of buffer");
        free(diff);
        return(-1);
    }

    lastpix = a[0];  /* the first difference will always be zero */

    thisblock = nblock;
    for (i=0; i> 1; */
	psum = ((unsigned char) dpsum ) >> 1;
	for (fs = 0; psum>0; fs++) psum >>= 1;

	/*
	 * write the codes
	 * fsbits ID bits used to indicate split level
	 */
	if (fs >= fsmax) {
	    /* Special high entropy case when FS >= fsmax
	     * Just write pixel difference values directly, no Rice coding at all.
	     */
	    if (output_nbits(buffer, fsmax+1, fsbits) == EOF) {
                ffpmsg("rice_encode: end of buffer");
                free(diff);
		return(-1);
	    }
	    for (j=0; jbitbuffer;
	    lbits_to_go = buffer->bits_to_go;
	    for (j=0; j> fs;
		/*
		 * top is coded by top zeros + 1
		 */
		if (lbits_to_go >= top+1) {
		    lbitbuffer <<= top+1;
		    lbitbuffer |= 1;
		    lbits_to_go -= top+1;
		} else {
		    lbitbuffer <<= lbits_to_go;
		    putcbuf(lbitbuffer & 0xff,buffer);
		    for (top -= lbits_to_go; top>=8; top -= 8) {
			putcbuf(0, buffer);
		    }
		    lbitbuffer = 1;
		    lbits_to_go = 7-top;
		}
		/*
		 * bottom FS bits are written without coding
		 * code is output_nbits, moved into this routine to reduce overheads
		 * This code potentially breaks if FS>24, so I am limiting
		 * FS to 24 by choice of FSMAX above.
		 */
		if (fs > 0) {
		    lbitbuffer <<= fs;
		    lbitbuffer |= v & fsmask;
		    lbits_to_go -= fs;
		    while (lbits_to_go <= 0) {
			putcbuf((lbitbuffer>>(-lbits_to_go)) & 0xff,buffer);
			lbits_to_go += 8;
		    }
		}
	    }
	    /* check if overflowed output buffer */
	    if (buffer->current > buffer->end) {
                 ffpmsg("rice_encode: end of buffer");
                 free(diff);
		 return(-1);
	    }
	    buffer->bitbuffer = lbitbuffer;
	    buffer->bits_to_go = lbits_to_go;
	}
    }
    done_outputing_bits(buffer);
    free(diff);
    /*
     * return number of bytes used
     */
    return(buffer->current - buffer->start);
}
/*---------------------------------------------------------------------------*/
/* bit_output.c
 *
 * Bit output routines
 * Procedures return zero on success, EOF on end-of-buffer
 *
 * Programmer: R. White     Date: 20 July 1998
 */

/* Initialize for bit output */

static void start_outputing_bits(Buffer *buffer)
{
    /*
     * Buffer is empty to start with
     */
    buffer->bitbuffer = 0;
    buffer->bits_to_go = 8;
}

/*---------------------------------------------------------------------------*/
/* Output N bits (N must be <= 32) */

static int output_nbits(Buffer *buffer, int bits, int n)
{
/* local copies */
int lbitbuffer;
int lbits_to_go;
    /* AND mask for the right-most n bits */
    static unsigned int mask[33] = 
         {0,
	  0x1,       0x3,       0x7,       0xf,       0x1f,       0x3f,       0x7f,       0xff,
	  0x1ff,     0x3ff,     0x7ff,     0xfff,     0x1fff,     0x3fff,     0x7fff,     0xffff,
	  0x1ffff,   0x3ffff,   0x7ffff,   0xfffff,   0x1fffff,   0x3fffff,   0x7fffff,   0xffffff,
	  0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff};

    /*
     * insert bits at end of bitbuffer
     */
    lbitbuffer = buffer->bitbuffer;
    lbits_to_go = buffer->bits_to_go;
    if (lbits_to_go+n > 32) {
	/*
	 * special case for large n: put out the top lbits_to_go bits first
	 * note that 0 < lbits_to_go <= 8
	 */
	lbitbuffer <<= lbits_to_go;
/*	lbitbuffer |= (bits>>(n-lbits_to_go)) & ((1<>(n-lbits_to_go)) & *(mask+lbits_to_go);
	putcbuf(lbitbuffer & 0xff,buffer);
	n -= lbits_to_go;
	lbits_to_go = 8;
    }
    lbitbuffer <<= n;
/*    lbitbuffer |= ( bits & ((1<>(-lbits_to_go)) & 0xff,buffer);
	lbits_to_go += 8;
    }
    buffer->bitbuffer = lbitbuffer;
    buffer->bits_to_go = lbits_to_go;
    return(0);
}
/*---------------------------------------------------------------------------*/
/* Flush out the last bits */

static int done_outputing_bits(Buffer *buffer)
{
    if(buffer->bits_to_go < 8) {
	putcbuf(buffer->bitbuffer<bits_to_go,buffer);
	
/*	if (putcbuf(buffer->bitbuffer<bits_to_go,buffer) == EOF)
	    return(EOF);
*/
    }
    return(0);
}
/*---------------------------------------------------------------------------*/
/*----------------------------------------------------------*/
/*                                                          */
/*    START OF SOURCE FILE ORIGINALLY CALLED rdecomp.c      */
/*                                                          */
/*----------------------------------------------------------*/

/* @(#) rdecomp.c 1.4 99/03/01 12:38:41 */
/* rdecomp.c	Decompress image line using
 *		(1) Difference of adjacent pixels
 *		(2) Rice algorithm coding
 *
 * Returns 0 on success or 1 on failure
 */

/*    moved these 'includes' to the beginning of the file (WDP)
#include 
#include 
*/

/*---------------------------------------------------------------------------*/
/* this routine used to be called 'rdecomp'  (WDP)  */

int fits_rdecomp (unsigned char *c,		/* input buffer			*/
	     int clen,			/* length of input		*/
	     unsigned int array[],	/* output array			*/
	     int nx,			/* number of output pixels	*/
	     int nblock)		/* coding block size		*/
{
/* int bsize;  */
int i, k, imax;
int nbits, nzero, fs;
unsigned char *cend, bytevalue;
unsigned int b, diff, lastpix;
int fsmax, fsbits, bbits;
extern const int nonzero_count[];

   /*
     * Original size of each pixel (bsize, bytes) and coding block
     * size (nblock, pixels)
     * Could make bsize a parameter to allow more efficient
     * compression of short & byte images.
     */
/*    bsize = 4; */

/*    nblock = 32; now an input parameter */
    /*
     * From bsize derive:
     * FSBITS = # bits required to store FS
     * FSMAX = maximum value for FS
     * BBITS = bits/pixel for direct coding
     */

/*
    switch (bsize) {
    case 1:
	fsbits = 3;
	fsmax = 6;
	break;
    case 2:
	fsbits = 4;
	fsmax = 14;
	break;
    case 4:
	fsbits = 5;
	fsmax = 25;
	break;
    default:
        ffpmsg("rdecomp: bsize must be 1, 2, or 4 bytes");
	return 1;
    }
*/

    /* move out of switch block, to tweak performance */
    fsbits = 5;
    fsmax = 25;

    bbits = 1<> nbits) - 1;

	b &= (1< nx) imax = nx;
	if (fs<0) {
	    /* low-entropy case, all zero differences */
	    for ( ; i= 0; k -= 8) {
		    b = *c++;
		    diff |= b<0) {
		    b = *c++;
		    diff |= b>>(-k);
		    b &= (1<>1;
		} else {
		    diff = ~(diff>>1);
		}
		array[i] = diff+lastpix;
		lastpix = array[i];
	    }
	} else {
	    /* normal case, Rice coding */
	    for ( ; i>nbits);
		b &= (1<>1;
		} else {
		    diff = ~(diff>>1);
		}
		array[i] = diff+lastpix;
		lastpix = array[i];
	    }
	}
	if (c > cend) {
            ffpmsg("decompression error: hit end of compressed byte stream");
	    return 1;
	}
    }
    if (c < cend) {
        ffpmsg("decompression warning: unused bytes at end of compressed buffer");
    }
    return 0;
}
/*---------------------------------------------------------------------------*/
/* this routine used to be called 'rdecomp'  (WDP)  */

int fits_rdecomp_short (unsigned char *c,		/* input buffer			*/
	     int clen,			/* length of input		*/
	     unsigned short array[],  	/* output array			*/
	     int nx,			/* number of output pixels	*/
	     int nblock)		/* coding block size		*/
{
int i, imax;
/* int bsize; */
int k;
int nbits, nzero, fs;
unsigned char *cend, bytevalue;
unsigned int b, diff, lastpix;
int fsmax, fsbits, bbits;
extern const int nonzero_count[];

   /*
     * Original size of each pixel (bsize, bytes) and coding block
     * size (nblock, pixels)
     * Could make bsize a parameter to allow more efficient
     * compression of short & byte images.
     */

/*    bsize = 2; */
    
/*    nblock = 32; now an input parameter */
    /*
     * From bsize derive:
     * FSBITS = # bits required to store FS
     * FSMAX = maximum value for FS
     * BBITS = bits/pixel for direct coding
     */

/*
    switch (bsize) {
    case 1:
	fsbits = 3;
	fsmax = 6;
	break;
    case 2:
	fsbits = 4;
	fsmax = 14;
	break;
    case 4:
	fsbits = 5;
	fsmax = 25;
	break;
    default:
        ffpmsg("rdecomp: bsize must be 1, 2, or 4 bytes");
	return 1;
    }
*/

    /* move out of switch block, to tweak performance */
    fsbits = 4;
    fsmax = 14;

    bbits = 1<> nbits) - 1;

	b &= (1< nx) imax = nx;
	if (fs<0) {
	    /* low-entropy case, all zero differences */
	    for ( ; i= 0; k -= 8) {
		    b = *c++;
		    diff |= b<0) {
		    b = *c++;
		    diff |= b>>(-k);
		    b &= (1<>1;
		} else {
		    diff = ~(diff>>1);
		}
		array[i] = diff+lastpix;
		lastpix = array[i];
	    }
	} else {
	    /* normal case, Rice coding */
	    for ( ; i>nbits);
		b &= (1<>1;
		} else {
		    diff = ~(diff>>1);
		}
		array[i] = diff+lastpix;
		lastpix = array[i];
	    }
	}
	if (c > cend) {
            ffpmsg("decompression error: hit end of compressed byte stream");
	    return 1;
	}
    }
    if (c < cend) {
        ffpmsg("decompression warning: unused bytes at end of compressed buffer");
    }
    return 0;
}
/*---------------------------------------------------------------------------*/
/* this routine used to be called 'rdecomp'  (WDP)  */

int fits_rdecomp_byte (unsigned char *c,		/* input buffer			*/
	     int clen,			/* length of input		*/
	     unsigned char array[],  	/* output array			*/
	     int nx,			/* number of output pixels	*/
	     int nblock)		/* coding block size		*/
{
int i, imax;
/* int bsize; */
int k;
int nbits, nzero, fs;
unsigned char *cend;
unsigned int b, diff, lastpix;
int fsmax, fsbits, bbits;
extern const int nonzero_count[];

   /*
     * Original size of each pixel (bsize, bytes) and coding block
     * size (nblock, pixels)
     * Could make bsize a parameter to allow more efficient
     * compression of short & byte images.
     */

/*    bsize = 1; */
    
/*    nblock = 32; now an input parameter */
    /*
     * From bsize derive:
     * FSBITS = # bits required to store FS
     * FSMAX = maximum value for FS
     * BBITS = bits/pixel for direct coding
     */

/*
    switch (bsize) {
    case 1:
	fsbits = 3;
	fsmax = 6;
	break;
    case 2:
	fsbits = 4;
	fsmax = 14;
	break;
    case 4:
	fsbits = 5;
	fsmax = 25;
	break;
    default:
        ffpmsg("rdecomp: bsize must be 1, 2, or 4 bytes");
	return 1;
    }
*/

    /* move out of switch block, to tweak performance */
    fsbits = 3;
    fsmax = 6;

    bbits = 1<> nbits) - 1;

	b &= (1< nx) imax = nx;
	if (fs<0) {
	    /* low-entropy case, all zero differences */
	    for ( ; i= 0; k -= 8) {
		    b = *c++;
		    diff |= b<0) {
		    b = *c++;
		    diff |= b>>(-k);
		    b &= (1<>1;
		} else {
		    diff = ~(diff>>1);
		}
		array[i] = diff+lastpix;
		lastpix = array[i];
	    }
	} else {
	    /* normal case, Rice coding */
	    for ( ; i>nbits);
		b &= (1<>1;
		} else {
		    diff = ~(diff>>1);
		}
		array[i] = diff+lastpix;
		lastpix = array[i];
	    }
	}
	if (c > cend) {
            ffpmsg("decompression error: hit end of compressed byte stream");
	    return 1;
	}
    }
    if (c < cend) {
        ffpmsg("decompression warning: unused bytes at end of compressed buffer");
    }
    return 0;
}
healpy-1.10.3/cfitsio/sample.tpl0000664000175000017500000000677513010375005017001 0ustar  zoncazonca00000000000000# sample template - create 9 HDUs in one FITS file

# syntax :

# everything which starts with a hashmark is ignored
# the same for empty lines

# one can use \include filename to include other files
# equal sign after keyword name is optional
# \group must be terminated by \end
# xtension is terminated by \group, xtension or EOF
# First HDU of type image may be defined using "SIMPLE T"
# group may contain other groups and xtensions
# keywords may be indented, but indentation is limited to max 7chars.

# template parser processes all keywords, makes substitutions
# when necessary (hashmarks -> index), converts keyword names
# to uppercase and writes keywords to file.
# For string keywords, parser uses CFITSIO long string routines
# to store string values longer than 72 characters. Parser can
# read/process lines of any length, as long as there is enough memory.
# For a very limited set of keywords (like NAXIS1 for binary tables)
# template parser ignores values specified in template file
# (one should not specify NAXIS1 for binary tables) and computes and
# writes values respective to table structure.
# number of rows in binary/ascii tables can be specified with NAXIS2

# if the 1st HDU is not defined with "SIMPLE T" and is defined with
# xtension image/asciitable/bintable then dummy primary HDU is
# created by parser.

simple	t
 bitpix		16
 naxis		1
 naxis1		10
COMMENT
 comment  
 sdsdf / keyword without value (null type)
        if line begins with 8+ spaces everything is a comment

xtension image
 bitpix		16
 naxis		1
 naxis1		10
 QWERW		F / dfg dfgsd fg - boolean keyword
 FFFSDS45	3454345 /integer_or_real keyword
 SSSDFS34	32345.453   / real keyword
 adsfd34	(234234.34,2342342.3) / complex keyword - no space between ()
 SDFDF#		adfasdfasdfdfcvxccvzxcvcvcxv / autoindexed keyword, here idx=1
 SDFD#		'asf dfa dfad df dfad f ad fadfdaf dfdfa df loooooong keyyywoooord - reaaalllly verrrrrrrrrryy loooooooooong' / comment is max 80 chars
 history        history record, spaces (all but 1st) after keyname are copied
 SDFDF#		strg_value_without_spaces / autoindexed keyword, here idx=2
 comment        comment record, spaces (all but 1st) after keyname are copied
 strg45		'sdfasdfadfffdfasdfasdfasdf &'
 continue   'sdfsdfsdfsd fsdf' / 3 spaces must follow CONTINUE keyword


xtension image
 bitpix		16
 naxis		1
 naxis1		10

\group
 
 xtension image
  bitpix	16
  naxis		1
  naxis1	10

# create group inside group

 \group

# one can specify additional columns in group HDU. The first column
# specified will have index 7 however, since the first 6 columns are occupied
# by grouping table itself.
# Please note, that it is not allowed to specify EXTNAME keyword as an
# additional keyword for group HDU, since parser automatically writes
# EXTNAME = GROUPING keyword.

  TFORM#	13A
  TTYPE#	ADDIT_COL_IN_GRP_HDU
  TFORM#	1E
  TTYPE#	REAL_COLUMN
  COMMENT sure, there is always place for comments

# the following specifies empty ascii table (0 cols / 0 rows)

  xtension asciitable

 \end
 
\end

# one do not have to specify all NAXISn keywords. If not specified
# NAXISn equals zero.

xtension image
 bitpix	16
 naxis	1
# naxis1	10

# the following tells how to set number of rows in binary table
# note also that the last line in template file does not have to
# have LineFeed character as the last one.

xtension bintable
naxis2	 10
EXTNAME	asdjfhsdkf
TTYPE#   MEMBER_XTENSION
TFORM#   8A
TTYPE#   MEMBER_2
TFORM#   8U
TTYPE#   MEMBER_3
TFORM#   8V
TTYPE#   MEMBER_NAME
TFORM#   32A
TDIM#	 '(8,4)'
TTYPE#   MEMBER_VERSION
TFORM#   1J
TNULL#   0healpy-1.10.3/cfitsio/scalnull.c0000664000175000017500000002141513010375005016744 0ustar  zoncazonca00000000000000/*  This file, scalnull.c, contains the FITSIO routines used to define     */
/*  the starting heap address, the value scaling and the null values.      */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

#include 
#include "fitsio2.h"
/*--------------------------------------------------------------------------*/
int ffpthp(fitsfile *fptr,      /* I - FITS file pointer */
           long theap,          /* I - starting addrss for the heap */
           int *status)         /* IO - error status     */
/*
  Define the starting address for the heap for a binary table.
  The default address is NAXIS1 * NAXIS2.  It is in units of
  bytes relative to the beginning of the regular binary table data.
  This routine also writes the appropriate THEAP keyword to the
  FITS header.
*/
{
    if (*status > 0 || theap < 1)
        return(*status);

    /* reset position to the correct HDU if necessary */
    if (fptr->HDUposition != (fptr->Fptr)->curhdu)
        ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);

    (fptr->Fptr)->heapstart = theap;

    ffukyj(fptr, "THEAP", theap, "byte offset to heap area", status);

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpscl(fitsfile *fptr,      /* I - FITS file pointer               */
           double scale,        /* I - scaling factor: value of BSCALE */
           double zero,         /* I - zero point: value of BZERO      */
           int *status)         /* IO - error status                   */
/*
  Define the linear scaling factor for the primary array or image extension
  pixel values. This routine overrides the scaling values given by the
  BSCALE and BZERO keywords if present.  Note that this routine does not
  write or modify the BSCALE and BZERO keywords, but instead only modifies
  the values temporarily in the internal buffer.  Thus, a subsequent call to
  the ffrdef routine will reset the scaling back to the BSCALE and BZERO
  keyword values (or 1. and 0. respectively if the keywords are not present).
*/
{
    tcolumn *colptr;
    int hdutype;

    if (*status > 0)
        return(*status);

    if (scale == 0)
        return(*status = ZERO_SCALE);  /* zero scale value is illegal */

    if (ffghdt(fptr, &hdutype, status) > 0)  /* get HDU type */
        return(*status);

    if (hdutype != IMAGE_HDU)
        return(*status = NOT_IMAGE);         /* not proper HDU type */

    if (fits_is_compressed_image(fptr, status)) /* compressed images */
    {
        (fptr->Fptr)->cn_bscale = scale;
        (fptr->Fptr)->cn_bzero  = zero;
        return(*status);
    }

    /* set pointer to the first 'column' (contains group parameters if any) */
    colptr = (fptr->Fptr)->tableptr; 

    colptr++;   /* increment to the 2nd 'column' pointer  (the image itself) */

    colptr->tscale = scale;
    colptr->tzero = zero;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpnul(fitsfile *fptr,      /* I - FITS file pointer                */
           LONGLONG nulvalue,   /* I - null pixel value: value of BLANK */
           int *status)         /* IO - error status                    */
/*
  Define the value used to represent undefined pixels in the primary array or
  image extension. This only applies to integer image pixel (i.e. BITPIX > 0).
  This routine overrides the null pixel value given by the BLANK keyword
  if present.  Note that this routine does not write or modify the BLANK
  keyword, but instead only modifies the value temporarily in the internal
  buffer. Thus, a subsequent call to the ffrdef routine will reset the null
  value back to the BLANK  keyword value (or not defined if the keyword is not
  present).
*/
{
    tcolumn *colptr;
    int hdutype;

    if (*status > 0)
        return(*status);

    if (ffghdt(fptr, &hdutype, status) > 0)  /* get HDU type */
        return(*status);

    if (hdutype != IMAGE_HDU)
        return(*status = NOT_IMAGE);         /* not proper HDU type */

    if (fits_is_compressed_image(fptr, status)) /* ignore compressed images */
        return(*status);

    /* set pointer to the first 'column' (contains group parameters if any) */
    colptr = (fptr->Fptr)->tableptr; 

    colptr++;   /* increment to the 2nd 'column' pointer  (the image itself) */

    colptr->tnull = nulvalue;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fftscl(fitsfile *fptr,      /* I - FITS file pointer */
           int colnum,          /* I - column number to apply scaling to */
           double scale,        /* I - scaling factor: value of TSCALn   */
           double zero,         /* I - zero point: value of TZEROn       */
           int *status)         /* IO - error status     */
/*
  Define the linear scaling factor for the TABLE or BINTABLE extension
  column values. This routine overrides the scaling values given by the
  TSCALn and TZEROn keywords if present.  Note that this routine does not
  write or modify the TSCALn and TZEROn keywords, but instead only modifies
  the values temporarily in the internal buffer.  Thus, a subsequent call to
  the ffrdef routine will reset the scaling back to the TSCALn and TZEROn
  keyword values (or 1. and 0. respectively if the keywords are not present).
*/
{
    tcolumn *colptr;
    int hdutype;

    if (*status > 0)
        return(*status);

    if (scale == 0)
        return(*status = ZERO_SCALE);  /* zero scale value is illegal */

    if (ffghdt(fptr, &hdutype, status) > 0)  /* get HDU type */
        return(*status);

    if (hdutype == IMAGE_HDU)
        return(*status = NOT_TABLE);         /* not proper HDU type */

    colptr = (fptr->Fptr)->tableptr;   /* set pointer to the first column */
    colptr += (colnum - 1);     /* increment to the correct column */

    colptr->tscale = scale;
    colptr->tzero = zero;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int fftnul(fitsfile *fptr,      /* I - FITS file pointer                  */
           int colnum,          /* I - column number to apply nulvalue to */
           LONGLONG nulvalue,   /* I - null pixel value: value of TNULLn  */
           int *status)         /* IO - error status                      */
/*
  Define the value used to represent undefined pixels in the BINTABLE column.
  This only applies to integer datatype columns (TFORM = B, I, or J).
  This routine overrides the null pixel value given by the TNULLn keyword
  if present.  Note that this routine does not write or modify the TNULLn
  keyword, but instead only modifies the value temporarily in the internal
  buffer. Thus, a subsequent call to the ffrdef routine will reset the null
  value back to the TNULLn  keyword value (or not defined if the keyword is not
  present).
*/
{
    tcolumn *colptr;
    int hdutype;

    if (*status > 0)
        return(*status);

    if (ffghdt(fptr, &hdutype, status) > 0)  /* get HDU type */
        return(*status);

    if (hdutype != BINARY_TBL)
        return(*status = NOT_BTABLE);        /* not proper HDU type */
 
    colptr = (fptr->Fptr)->tableptr;   /* set pointer to the first column */
    colptr += (colnum - 1);    /* increment to the correct column */

    colptr->tnull = nulvalue;

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffsnul(fitsfile *fptr,      /* I - FITS file pointer                  */
           int colnum,          /* I - column number to apply nulvalue to */
           char *nulstring,     /* I - null pixel value: value of TNULLn  */
           int *status)         /* IO - error status                      */
/*
  Define the string used to represent undefined pixels in the ASCII TABLE
  column. This routine overrides the null  value given by the TNULLn keyword
  if present.  Note that this routine does not write or modify the TNULLn
  keyword, but instead only modifies the value temporarily in the internal
  buffer. Thus, a subsequent call to the ffrdef routine will reset the null
  value back to the TNULLn keyword value (or not defined if the keyword is not
  present).
*/
{
    tcolumn *colptr;
    int hdutype;

    if (*status > 0)
        return(*status);

    if (ffghdt(fptr, &hdutype, status) > 0)  /* get HDU type */
        return(*status);

    if (hdutype != ASCII_TBL)
        return(*status = NOT_ATABLE);        /* not proper HDU type */
 
    colptr = (fptr->Fptr)->tableptr;   /* set pointer to the first column */
    colptr += (colnum - 1);    /* increment to the correct column */

    colptr->strnull[0] = '\0';
    strncat(colptr->strnull, nulstring, 19);  /* limit string to 19 chars */

    return(*status);
}
healpy-1.10.3/cfitsio/smem.c0000664000175000017500000000500413010375005016064 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#ifdef __APPLE__
#include 
#else
#include 
#endif
#include "fitsio.h"     /* needed to define LONGLONG */
#include "drvrsmem.h"   /* uses LONGLONG */

int	main(int argc, char **argv)
{ int cmdok, listmode, longlistmode, recovermode, deletemode, id;
int status;
char *address;

listmode = longlistmode = recovermode = deletemode = 0;
id = -1;
cmdok = 1;

switch (argc)
 { case 1:	listmode = 1;
		break;
   case 2:
		if (0 == strcmp("-l", argv[1])) longlistmode = 1;
		else if (0 == strcmp("-r", argv[1])) recovermode = 1;
		else if (0 == strcmp("-d", argv[1])) deletemode = 1;
		else cmdok = 0;
		break;
   case 3:
		if (0 == strcmp("-r", argv[1])) recovermode = 1;
		else if (0 == strcmp("-d", argv[1])) deletemode = 1;
		else
		 { cmdok = 0;		/* signal invalid cmd line syntax */
		   break;
		 }
		if (1 != sscanf(argv[2], "%d", &id)) cmdok = 0;
		break;
   default:
		cmdok = 0;
		break;
 }

if (0 == cmdok)
  { printf("usage :\n\n");
    printf("smem            - list all shared memory segments\n");
    printf("\t!\tcouldn't obtain RDONLY lock - info unreliable\n");
    printf("\tIdx\thandle of shared memory segment (visible by application)\n");
    printf("\tKey\tcurrent system key of shared memory segment. Key\n");
    printf("\t\tchanges whenever shmem segment is reallocated. Use\n");
    printf("\t\tipcs (or ipcs -a) to view all shmem segments\n");
    printf("\tNproc\tnumber of processes attached to segment\n");
    printf("\tSize\tsize of shmem segment in bytes\n");
    printf("\tFlags\tRESIZABLE - realloc allowed, PERSIST - segment is not\n");
    printf("\t\tdeleted after shared_free called by last process attached\n");
    printf("\t\tto it.\n");
    printf("smem -d         - delete all shared memory segments (may block)\n");
    printf("smem -d id      - delete specific shared memory segment (may block)\n");
    printf("smem -r         - unconditionally reset all shared memory segments\n\t\t(does not block, recovers zombie handles left by kill -9)\n");
    printf("smem -r id      - unconditionally reset specific shared memory segment\n");
  }

if (shared_init(0))
  { printf("couldn't initialize shared memory, aborting ...\n");
    return(10);
  }

if (listmode) shared_list(id);
else if (recovermode) shared_recover(id);
else if (deletemode) shared_uncond_delete(id);

for (id = 0; id <16; id++) {
  status = shared_getaddr(id, &address);
  if (!status)printf("id, status, address %d %d %ld %.30s\n", id, status, address, address);
}
return(0);
}
healpy-1.10.3/cfitsio/speed.c0000664000175000017500000003622713010375005016236 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include 
#include 

/*
  Every program which uses the CFITSIO interface must include the
  the fitsio.h header file.  This contains the prototypes for all
  the routines and defines the error status values and other symbolic
  constants used in the interface.  
*/
#include "fitsio.h"

#define minvalue(A,B) ((A) < (B) ? (A) : (B))

/* size of the image */
#define XSIZE 3000
#define YSIZE 3000

/* size of data buffer */
#define SHTSIZE 20000
static long sarray[ SHTSIZE ] = {SHTSIZE * 0};

/* no. of rows in binary table */
#define BROWS 2500000

/* no. of rows in ASCII table */
#define AROWS 400000

/*  CLOCKS_PER_SEC should be defined by most compilers */
#if defined(CLOCKS_PER_SEC)
#define CLOCKTICKS CLOCKS_PER_SEC
#else
/* on SUN OS machine, CLOCKS_PER_SEC is not defined, so set its value */
#define CLOCKTICKS 1000000
#define difftime(A,B) ((double) A - (double) B)
#endif

/* define variables for measuring elapsed time */
clock_t scpu, ecpu;
time_t start, finish;
long startsec;   /* start of elapsed time interval */
int startmilli;  /* start of elapsed time interval */

int writeimage(fitsfile *fptr, int *status);
int writebintable(fitsfile *fptr, int *status);
int writeasctable(fitsfile *fptr, int *status);
int readimage(fitsfile *fptr, int *status);
int readatable(fitsfile *fptr, int *status);
int readbtable(fitsfile *fptr, int *status);
void printerror( int status);
int marktime(int *status);
int gettime(double *elapse, float *elapscpu, int *status);
int main(void);

int main()
{
/*************************************************************************
    This program tests the speed of writing/reading FITS files with cfitsio
**************************************************************************/

    FILE *diskfile;
    fitsfile *fptr;        /* pointer to the FITS file, defined in fitsio.h */
    int status, ii;
    long rawloop;
    char filename[] = "speedcc.fit";           /* name for new FITS file */
    char buffer[2880] = {2880 * 0};
    time_t tbegin, tend;
    float rate, size, elapcpu, cpufrac;
    double elapse;

    tbegin = time(0);

    remove(filename);               /* Delete old file if it already exists */

    diskfile =  fopen(filename,"w+b");
    rawloop = XSIZE * YSIZE / 720;

    printf("                                                ");
    printf(" SIZE / ELAPSE(%%CPU) = RATE\n");
    printf("RAW fwrite (2880 bytes/loop)...                 ");
    marktime(&status);

    for (ii = 0; ii < rawloop; ii++)
      if (fwrite(buffer, 1, 2880, diskfile) != 2880)
        printf("write error \n");

    gettime(&elapse, &elapcpu, &status);

    cpufrac = elapcpu / elapse * 100.;
    size = 2880. * rawloop / 1000000.;
    rate = size / elapse;
    printf(" %4.1fMB/%6.3fs(%3.0f) = %5.2fMB/s\n", size, elapse, cpufrac,rate);

    /* read back the binary records */
    fseek(diskfile, 0, 0);

    printf("RAW fread  (2880 bytes/loop)...                 ");
    marktime(&status);

    for (ii = 0; ii < rawloop; ii++)
      if (fread(buffer, 1, 2880, diskfile) != 2880)
        printf("read error \n");

    gettime(&elapse, &elapcpu, &status);

    cpufrac = elapcpu / elapse * 100.;
    size = 2880. * rawloop / 1000000.;
    rate = size / elapse;
    printf(" %4.1fMB/%6.3fs(%3.0f) = %5.2fMB/s\n", size, elapse, cpufrac,rate);

    fclose(diskfile);
    remove(filename);

    status = 0;     
    fptr = 0;

    if (fits_create_file(&fptr, filename, &status)) /* create new FITS file */
       printerror( status);          
   
    if (writeimage(fptr, &status))
       printerror( status);     

    if (writebintable(fptr, &status))
       printerror( status);     

    if (writeasctable(fptr, &status))
       printerror( status);     

    if (readimage(fptr, &status))
       printerror( status);     

    if (readbtable(fptr, &status))
       printerror( status);     

    if (readatable(fptr, &status))
       printerror( status);     

    if (fits_close_file(fptr, &status))     
         printerror( status );

    tend = time(0);
    elapse = difftime(tend, tbegin) + 0.5;
    printf("Total elapsed time = %.3fs, status = %d\n",elapse, status);
    return(0);
}
/*--------------------------------------------------------------------------*/
int writeimage(fitsfile *fptr, int *status)

    /**************************************************/
    /* write the primary array containing a 2-D image */
    /**************************************************/
{
    long  nremain, ii;
    float rate, size, elapcpu, cpufrac;
    double elapse;

    /* initialize FITS image parameters */
    int bitpix   =  32;   /* 32-bit  signed integer pixel values       */
    long naxis    =   2;  /* 2-dimensional image                            */    
    long naxes[2] = {XSIZE, YSIZE }; /* image size */

    /* write the required keywords for the primary array image */
    if ( fits_create_img(fptr, bitpix, naxis, naxes, status) )
         printerror( *status );          

    printf("\nWrite %dx%d I*4 image, %d pixels/loop:   ",XSIZE,YSIZE,SHTSIZE);
    marktime(status);

    nremain = XSIZE * YSIZE;
    for (ii = 1; ii <= nremain; ii += SHTSIZE)
    {
      ffpprj(fptr, 0, ii, SHTSIZE, sarray, status);
    }

    ffflus(fptr, status);  /* flush all buffers to disk */

    gettime(&elapse, &elapcpu, status);

    cpufrac = elapcpu / elapse * 100.;
    size = XSIZE * 4. * YSIZE / 1000000.;
    rate = size / elapse;
    printf(" %4.1fMB/%6.3fs(%3.0f) = %5.2fMB/s\n", size, elapse, cpufrac,rate);

    return( *status );
}
/*--------------------------------------------------------------------------*/
int writebintable (fitsfile *fptr, int *status)

    /*********************************************************/
    /* Create a binary table extension containing 3 columns  */
    /*********************************************************/
{
    int tfields = 2;
    long nremain, ntodo, firstrow = 1, firstelem = 1, nrows;
    float rate, size, elapcpu, cpufrac;
    double elapse;

    char extname[] = "Speed_Test";           /* extension name */

    /* define the name, datatype, and physical units for the columns */
    char *ttype[] = { "first", "second" };
    char *tform[] = {"1J",       "1J"   };
    char *tunit[] = { " ",       " "    };

    /* append a new empty binary table onto the FITS file */

    if ( fits_create_tbl( fptr, BINARY_TBL, BROWS, tfields, ttype, tform,
                tunit, extname, status) )
         printerror( *status );

    /* get table row size and optimum number of rows to write per loop */
    fits_get_rowsize(fptr, &nrows, status);
    nrows = minvalue(nrows, SHTSIZE);
    nremain = BROWS;

    printf("Write %7drow x %dcol bintable %4ld rows/loop:", BROWS, tfields,
       nrows);
    marktime(status);

    while(nremain)
    {
      ntodo = minvalue(nrows, nremain);
      ffpclj(fptr, 1, firstrow, firstelem, ntodo, sarray, status);
      ffpclj(fptr, 2, firstrow, firstelem, ntodo, sarray, status);
      firstrow += ntodo;
      nremain -= ntodo;
    }

    ffflus(fptr, status);  /* flush all buffers to disk */

    gettime(&elapse, &elapcpu, status);

    cpufrac = elapcpu / elapse * 100.;
    size = BROWS * 8. / 1000000.;
    rate = size / elapse;
    printf(" %4.1fMB/%6.3fs(%3.0f) = %5.2fMB/s\n", size, elapse, cpufrac,rate);

    return( *status );
}
/*--------------------------------------------------------------------------*/
int writeasctable (fitsfile *fptr, int *status)

    /*********************************************************/
    /* Create an ASCII table extension containing 2 columns  */
    /*********************************************************/
{
    int tfields = 2;
    long nremain, ntodo, firstrow = 1, firstelem = 1;
    long nrows;
    float rate, size, elapcpu, cpufrac;
    double elapse;

    char extname[] = "Speed_Test";           /* extension name */

    /* define the name, datatype, and physical units for the columns */
    char *ttype[] = { "first", "second" };
    char *tform[] = {"I6",       "I6"   };
    char *tunit[] = { " ",      " "     };

    /* append a new empty ASCII table onto the FITS file */
    if ( fits_create_tbl( fptr, ASCII_TBL, AROWS, tfields, ttype, tform,
                tunit, extname, status) )
         printerror( *status );

    /* get table row size and optimum number of rows to write per loop */
    fits_get_rowsize(fptr, &nrows, status);
    nrows = minvalue(nrows, SHTSIZE);
    nremain = AROWS;

    printf("Write %7drow x %dcol asctable %4ld rows/loop:", AROWS, tfields,
           nrows);
    marktime(status);

    while(nremain)
    {
      ntodo = minvalue(nrows, nremain);
      ffpclj(fptr, 1, firstrow, firstelem, ntodo, sarray, status);
      ffpclj(fptr, 2, firstrow, firstelem, ntodo, sarray, status);
      firstrow += ntodo;
      nremain -= ntodo;
    }

    ffflus(fptr, status);  /* flush all buffers to disk */

    gettime(&elapse, &elapcpu, status);

    cpufrac = elapcpu / elapse * 100.;
    size = AROWS * 13. / 1000000.;
    rate = size / elapse;
    printf(" %4.1fMB/%6.3fs(%3.0f) = %5.2fMB/s\n", size, elapse, cpufrac,rate);

    return( *status );
}
/*--------------------------------------------------------------------------*/
int readimage( fitsfile *fptr, int *status )

    /*********************/
    /* Read a FITS image */
    /*********************/
{
    int anynull, hdutype;
    long nremain, ii;
    long longnull = 0;
    float rate, size, elapcpu, cpufrac;
    double elapse;

    /* move to the primary array */
    if ( fits_movabs_hdu(fptr, 1, &hdutype, status) ) 
         printerror( *status );

    printf("\nRead back image                                 ");
    marktime(status);

    nremain = XSIZE * YSIZE;
    for (ii=1; ii <= nremain; ii += SHTSIZE)
    {
      ffgpvj(fptr, 0, ii, SHTSIZE, longnull, sarray, &anynull, status);
    }

    gettime(&elapse, &elapcpu, status);

    cpufrac = elapcpu / elapse * 100.;
    size = XSIZE * 4. * YSIZE / 1000000.;
    rate = size / elapse;
    printf(" %4.1fMB/%6.3fs(%3.0f) = %5.2fMB/s\n", size, elapse, cpufrac,rate);

    return( *status );
}
/*--------------------------------------------------------------------------*/
int readbtable( fitsfile *fptr, int *status )

    /************************************************************/
    /* read and print data values from the binary table */
    /************************************************************/
{
    int hdutype, anynull;
    long nremain, ntodo, firstrow = 1, firstelem = 1;
    long nrows;
    long lnull = 0;
    float rate, size, elapcpu, cpufrac;
    double elapse;

    /* move to the table */
    if ( fits_movrel_hdu(fptr, 1, &hdutype, status) ) 
           printerror( *status );

    /* get table row size and optimum number of rows to read per loop */
    fits_get_rowsize(fptr, &nrows, status);
    nrows = minvalue(nrows, SHTSIZE);
    
    /*  read the columns */  
    nremain = BROWS;

    printf("Read back BINTABLE                              ");
    marktime(status);

    while(nremain)
    {
      ntodo = minvalue(nrows, nremain);
      ffgcvj(fptr, 1, firstrow, firstelem, ntodo,
                     lnull, sarray, &anynull, status);
      ffgcvj(fptr, 2, firstrow, firstelem, ntodo,
                     lnull, sarray, &anynull, status);
      firstrow += ntodo; 
      nremain  -= ntodo;
    }

    gettime(&elapse, &elapcpu, status);

    cpufrac = elapcpu / elapse * 100.;
    size = BROWS * 8. / 1000000.;
    rate = size / elapse;
    printf(" %4.1fMB/%6.3fs(%3.0f) = %5.2fMB/s\n", size, elapse, cpufrac,rate);

    return( *status );
}
/*--------------------------------------------------------------------------*/
int readatable( fitsfile *fptr, int *status )

    /************************************************************/
    /* read and print data values from an ASCII or binary table */
    /************************************************************/
{
    int hdutype, anynull;
    long nremain, ntodo, firstrow = 1, firstelem = 1;
    long nrows;
    long lnull = 0;
    float rate, size, elapcpu, cpufrac;
    double elapse;

    /* move to the table */
    if ( fits_movrel_hdu(fptr, 1, &hdutype, status) ) 
           printerror( *status );

    /* get table row size and optimum number of rows to read per loop */
    fits_get_rowsize(fptr, &nrows, status);
    nrows = minvalue(nrows, SHTSIZE);
 
    /*  read the columns */  
    nremain = AROWS;

    printf("Read back ASCII Table                           ");
    marktime(status);

    while(nremain)
    {
      ntodo = minvalue(nrows, nremain);
      ffgcvj(fptr, 1, firstrow, firstelem, ntodo,
                     lnull, sarray, &anynull, status);
      ffgcvj(fptr, 2, firstrow, firstelem, ntodo,
                     lnull, sarray, &anynull, status);
      firstrow += ntodo;
      nremain  -= ntodo;
    }

    gettime(&elapse, &elapcpu, status);

    cpufrac = elapcpu / elapse * 100.;
    size = AROWS * 13. / 1000000.;
    rate = size / elapse;
    printf(" %4.1fMB/%6.3fs(%3.0f) = %5.2fMB/s\n", size, elapse, cpufrac,rate);

    return( *status );
}
/*--------------------------------------------------------------------------*/
void printerror( int status)
{
    /*****************************************************/
    /* Print out cfitsio error messages and exit program */
    /*****************************************************/

    char status_str[FLEN_STATUS], errmsg[FLEN_ERRMSG];
  
    if (status)
      fprintf(stderr, "\n*** Error occurred during program execution ***\n");

    fits_get_errstatus(status, status_str);   /* get the error description */
    fprintf(stderr, "\nstatus = %d: %s\n", status, status_str);

    /* get first message; null if stack is empty */
    if ( fits_read_errmsg(errmsg) ) 
    {
         fprintf(stderr, "\nError message stack:\n");
         fprintf(stderr, " %s\n", errmsg);

         while ( fits_read_errmsg(errmsg) )  /* get remaining messages */
             fprintf(stderr, " %s\n", errmsg);
    }

    exit( status );       /* terminate the program, returning error status */
}
/*--------------------------------------------------------------------------*/
int marktime( int *status)
{
    double telapse;
    time_t temp;
    struct  timeval tv;
    struct  timezone tz;

    temp = time(0);

    /* Since elapsed time is only measured to the nearest second */
    /* keep getting the time until the seconds tick just changes. */
    /* This provides more consistent timing measurements since the */
    /* intervals all start on an integer seconds. */

    telapse = 0.;

        scpu = clock();
        start = time(0);
/*
    while (telapse == 0.)
    {
        scpu = clock();
        start = time(0);
        telapse = difftime( start, temp );
    }
*/
        gettimeofday (&tv, &tz);

	startsec = tv.tv_sec;
        startmilli = tv.tv_usec/1000;

    return( *status );
}
/*--------------------------------------------------------------------------*/
int gettime(double *elapse, float *elapscpu, int *status)
{
        struct  timeval tv;
        struct  timezone tz;
	int stopmilli;
	long stopsec;


        gettimeofday (&tv, &tz);
    ecpu = clock();
    finish = time(0);

        stopmilli = tv.tv_usec/1000;
	stopsec = tv.tv_sec;
	

	*elapse = (stopsec - startsec) + (stopmilli - startmilli)/1000.;

/*    *elapse = difftime(finish, start) + 0.5; */
    *elapscpu = (ecpu - scpu) * 1.0 / CLOCKTICKS;

    return( *status );
}
healpy-1.10.3/cfitsio/swapproc.c0000664000175000017500000001702713010375005016771 0ustar  zoncazonca00000000000000/*  This file, swapproc.c, contains general utility routines that are      */
/*  used by other FITSIO routines to swap bytes.                           */

/*  The FITSIO software was written by William Pence at the High Energy    */
/*  Astrophysic Science Archive Research Center (HEASARC) at the NASA      */
/*  Goddard Space Flight Center.                                           */

/* The fast SSE2 and SSSE3 functions were provided by Julian Taylor, ESO */

#include 
#include 
#include "fitsio2.h"

/* bswap builtin is available since GCC 4.3 */
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
#define HAVE_BSWAP
#endif

#ifdef __SSSE3__
#include 
/* swap 16 bytes according to mask, values must be 16 byte aligned */
static inline void swap_ssse3(char * values, __m128i mask)
{
    __m128i v = _mm_load_si128((__m128i *)values);
    __m128i s = _mm_shuffle_epi8(v, mask);
    _mm_store_si128((__m128i*)values, s);
}
#endif
#ifdef __SSE2__
#include 
/* swap 8 shorts, values must be 16 byte aligned
 * faster than ssse3 variant for shorts */
static inline void swap2_sse2(char * values)
{
    __m128i r1 = _mm_load_si128((__m128i *)values);
    __m128i r2 = r1;
    r1 = _mm_srli_epi16(r1, 8);
    r2 = _mm_slli_epi16(r2, 8);
    r1 = _mm_or_si128(r1, r2);
    _mm_store_si128((__m128i*)values, r1);
}
/* the three shuffles required for 4 and 8 byte variants make
 * SSE2 slower than bswap */


/* get number of elements to peel to reach alignment */
static inline size_t get_peel(void * addr, size_t esize, size_t nvals,
                              size_t alignment)
{
    const size_t offset = (size_t)addr % alignment;
    size_t peel = offset ? (alignment - offset) / esize : 0;
    peel = nvals < peel ? nvals : peel;
    return peel;
}
#endif

/*--------------------------------------------------------------------------*/
static void ffswap2_slow(short *svalues, long nvals)
{
    register long ii;
    unsigned short * usvalues;

    usvalues = (unsigned short *) svalues;

    for (ii = 0; ii < nvals; ii++)
    {
        usvalues[ii] = (usvalues[ii]>>8) | (usvalues[ii]<<8);
    }
}
/*--------------------------------------------------------------------------*/
#if __SSE2__
void ffswap2(short *svalues,  /* IO - pointer to shorts to be swapped    */
             long nvals)     /* I  - number of shorts to be swapped     */
/*
  swap the bytes in the input short integers: ( 0 1 -> 1 0 )
*/
{
    if ((long)svalues % 2 != 0) { /* should not happen */
        ffswap2_slow(svalues, nvals);
        return;
    }

    long ii;
    size_t peel = get_peel((void*)&svalues[0], sizeof(svalues[0]), nvals, 16);

    ffswap2_slow(svalues, peel);
    for (ii = peel; ii < (nvals - peel - (nvals - peel) % 8); ii+=8) {
        swap2_sse2((char*)&svalues[ii]);
    }
    ffswap2_slow(&svalues[ii], nvals - ii);
}
#else
void ffswap2(short *svalues,  /* IO - pointer to shorts to be swapped    */
             long nvals)     /* I  - number of shorts to be swapped     */
/*
  swap the bytes in the input 4-byte integer: ( 0 1 2 3 -> 3 2 1 0 )
*/
{
    ffswap2_slow(svalues, nvals);
}
#endif
/*--------------------------------------------------------------------------*/
static void ffswap4_slow(INT32BIT *ivalues, long nvals)
{
    register long ii;

#if defined(HAVE_BSWAP)
    for (ii = 0; ii < nvals; ii++)
    {
        ivalues[ii] = __builtin_bswap32(ivalues[ii]);
    }
#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
    /* intrinsic byte swapping function in Microsoft Visual C++ 8.0 and later */
    unsigned int* uivalues = (unsigned int *) ivalues;

    /* intrinsic byte swapping function in Microsoft Visual C++ */
    for (ii = 0; ii < nvals; ii++)
    {
        uivalues[ii] = _byteswap_ulong(uivalues[ii]);
    }
#else
    char *cvalues, tmp;

    for (ii = 0; ii < nvals; ii++)
    {
        cvalues = (char *)&ivalues[ii];
        tmp = cvalues[0];
        cvalues[0] = cvalues[3];
        cvalues[3] = tmp;
        tmp = cvalues[1];
        cvalues[1] = cvalues[2];
        cvalues[2] = tmp;
    }
#endif
}
/*--------------------------------------------------------------------------*/
#ifdef __SSSE3__
void ffswap4(INT32BIT *ivalues,  /* IO - pointer to INT*4 to be swapped    */
                 long nvals)     /* I  - number of floats to be swapped     */
/*
  swap the bytes in the input 4-byte integer: ( 0 1 2 3 -> 3 2 1 0 )
*/
{
    if ((long)ivalues % 4 != 0) { /* should not happen */
        ffswap4_slow(ivalues, nvals);
        return;
    }

    long ii;
    const __m128i cmask4 = _mm_set_epi8(12, 13, 14, 15,
                                        8, 9, 10, 11,
                                        4, 5, 6, 7,
                                        0, 1, 2 ,3);
    size_t peel = get_peel((void*)&ivalues[0], sizeof(ivalues[0]), nvals, 16);
    ffswap4_slow(ivalues, peel);
    for (ii = peel; ii < (nvals - peel - (nvals - peel) % 4); ii+=4) {
        swap_ssse3((char*)&ivalues[ii], cmask4);
    }
    ffswap4_slow(&ivalues[ii], nvals - ii);
}
#else
void ffswap4(INT32BIT *ivalues,  /* IO - pointer to INT*4 to be swapped    */
                 long nvals)     /* I  - number of floats to be swapped     */
/*
  swap the bytes in the input 4-byte integer: ( 0 1 2 3 -> 3 2 1 0 )
*/
{
    ffswap4_slow(ivalues, nvals);
}
#endif
/*--------------------------------------------------------------------------*/
static void ffswap8_slow(double *dvalues, long nvals)
{
    register long ii;
#ifdef HAVE_BSWAP
    LONGLONG * llvalues = (LONGLONG*)dvalues;

    for (ii = 0; ii < nvals; ii++) {
        llvalues[ii] = __builtin_bswap64(llvalues[ii]);
    }
#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
    /* intrinsic byte swapping function in Microsoft Visual C++ 8.0 and later */
    unsigned __int64 * llvalues = (unsigned __int64 *) dvalues;

    for (ii = 0; ii < nvals; ii++)
    {
        llvalues[ii] = _byteswap_uint64(llvalues[ii]);
    }
#else
    register char *cvalues;
    register char temp;

    cvalues = (char *) dvalues;      /* copy the pointer value */

    for (ii = 0; ii < nvals*8; ii += 8)
    {
        temp = cvalues[ii];
        cvalues[ii] = cvalues[ii+7];
        cvalues[ii+7] = temp;

        temp = cvalues[ii+1];
        cvalues[ii+1] = cvalues[ii+6];
        cvalues[ii+6] = temp;

        temp = cvalues[ii+2];
        cvalues[ii+2] = cvalues[ii+5];
        cvalues[ii+5] = temp;

        temp = cvalues[ii+3];
        cvalues[ii+3] = cvalues[ii+4];
        cvalues[ii+4] = temp;
    }
#endif
}
/*--------------------------------------------------------------------------*/
#ifdef __SSSE3__
void ffswap8(double *dvalues,  /* IO - pointer to doubles to be swapped     */
             long nvals)       /* I  - number of doubles to be swapped      */
/*
  swap the bytes in the input doubles: ( 01234567  -> 76543210 )
*/
{
    if ((long)dvalues % 8 != 0) { /* should not happen on amd64 */
        ffswap8_slow(dvalues, nvals);
        return;
    }

    long ii;
    const __m128i cmask8 = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15,
                                        0, 1, 2 ,3, 4, 5, 6, 7);
    size_t peel = get_peel((void*)&dvalues[0], sizeof(dvalues[0]), nvals, 16);
    ffswap8_slow(dvalues, peel);
    for (ii = peel; ii < (nvals - peel - (nvals - peel) % 2); ii+=2) {
        swap_ssse3((char*)&dvalues[ii], cmask8);
    }
    ffswap8_slow(&dvalues[ii], nvals - ii);
}
#else
void ffswap8(double *dvalues,  /* IO - pointer to doubles to be swapped     */
             long nvals)       /* I  - number of doubles to be swapped      */
/*
  swap the bytes in the input doubles: ( 01234567  -> 76543210 )
*/
{
    ffswap8_slow(dvalues, nvals);
}
#endif
healpy-1.10.3/cfitsio/testf77.f0000664000175000017500000023441413010375005016442 0ustar  zoncazonca00000000000000C     This is a big and complicated program that tests most of
C     the fitsio routines.  This code does not represent
C     the most efficient method of reading or writing FITS files 
C     because this code is primarily designed to stress the fitsio
C     library routines.

      character asciisum*17
      character*3 cval
      character*1 xinarray(21), binarray(21), boutarray(21), bnul
      character colname*70, tdisp*40, nulstr*40
      character oskey*15
      character iskey*21
      character lstr*200   
      character  comm*73
      character*30 inskey(21)
      character*30 onskey(3)
      character filename*40, card*78, card2*78
      character keyword*8
      character value*68, comment*72
      character uchars*78
      character*15 ttype(10), tform(10), tunit(10)
      character*15 tblname
      character*15 binname
      character errmsg*75
      character*8  inclist(2),exclist(2)
      character*8 xctype,yctype,ctype
      character*18 kunit

      logical simple,extend,larray(42), larray2(42)
      logical olkey, ilkey, onlkey(3), inlkey(3), anynull

      integer*2 imgarray(19,30), imgarray2(10,20)
      integer*2         iinarray(21), ioutarray(21), inul

      integer naxes(3), pcount, gcount, npixels, nrows, rowlen
      integer existkeys, morekeys, keynum
      integer datastatus, hdustatus
      integer status, bitpix, naxis, block
      integer ii, jj, jjj, hdutype, hdunum, tfields
      integer nkeys, nfound, colnum, typecode, signval,nmsg
      integer repeat, offset, width, jnulval
      integer kinarray(21), koutarray(21), knul
      integer jinarray(21), joutarray(21), jnul
      integer ojkey, ijkey, otint
      integer onjkey(3), injkey(3)
      integer tbcol(5)
      integer iunit, tmpunit
      integer fpixels(2), lpixels(2), inc(2)

      real estatus, vers
      real einarray(21), eoutarray(21), enul, cinarray(42)
      real ofkey, oekey, iekey, onfkey(3),onekey(3), inekey(3)

      double precision dinarray(21),doutarray(21),dnul, minarray(42)
      double precision scale, zero
      double precision ogkey, odkey, idkey, otfrac, ongkey(3)
      double precision ondkey(3), indkey(3)
      double precision checksum, datsum
      double precision xrval,yrval,xrpix,yrpix,xinc,yinc,rot
      double precision xpos,ypos,xpix,ypix

      tblname = 'Test-ASCII'
      binname = 'Test-BINTABLE'
      onskey(1) = 'first string'
      onskey(2) = 'second string'
      onskey(3) = '        '
      oskey = 'value_string'
      inclist(1)='key*'
      inclist(2)='newikys'
      exclist(1)='key_pr*'
      exclist(2)='key_pkls'
      xctype='RA---TAN'
      yctype='DEC--TAN'

      olkey = .true.
      ojkey = 11
      otint = 12345678
      ofkey = 12.121212
      oekey = 13.131313
      ogkey = 14.1414141414141414D+00
      odkey = 15.1515151515151515D+00
      otfrac = .1234567890123456D+00
      onlkey(1) = .true.
      onlkey(2) = .false.
      onlkey(3) = .true.
      onjkey(1) = 11
      onjkey(2) = 12
      onjkey(3) = 13
      onfkey(1) = 12.121212
      onfkey(2) = 13.131313
      onfkey(3) = 14.141414
      onekey(1) = 13.131313
      onekey(2) = 14.141414
      onekey(3) = 15.151515
      ongkey(1) = 14.1414141414141414D+00
      ongkey(2) = 15.1515151515151515D+00
      ongkey(3) = 16.1616161616161616D+00
      ondkey(1) = 15.1515151515151515D+00
      ondkey(2) = 16.1616161616161616D+00
      ondkey(3) = 17.1717171717171717D+00

      tbcol(1) = 1
      tbcol(2) =  17
      tbcol(3) =  28
      tbcol(4) =  43
      tbcol(5) =  56
      status = 0

      call ftvers(vers)
      write(*,'(1x,A)') 'FITSIO TESTPROG'
      write(*, '(1x,A)')' '

      iunit = 15
      tmpunit = 16

      write(*,'(1x,A)') 'Try opening then closing a nonexistent file: '
      call ftopen(iunit, 'tq123x.kjl', 1, block, status)
      write(*,'(1x,A,2i4)')'  ftopen iunit, status (expect an error) ='
     & ,iunit, status
      call ftclos(iunit, status)
      write(*,'(1x,A,i4)')'  ftclos status = ', status
      write(*,'(1x,A)')' '

      call ftcmsg
      status = 0

      filename = 'testf77.fit'

C delete previous version of the file, if it exists 

      call ftopen(iunit, filename, 1, block, status)
      if (status .eq. 0)then
         call ftdelt(iunit, status)
      else
C        clear the error message stack
         call ftcmsg
      end if

      status = 0

C
C        #####################
C        #  create FITS file #
C        #####################
      

      call ftinit(iunit, filename, 1, status)
      write(*,'(1x,A,i4)')'ftinit create new file status = ', status
      write(*,'(1x,A)')' '

      if (status .ne. 0)go to 999

      simple = .true.
      bitpix = 32
      naxis = 2
      naxes(1) = 10
      naxes(2) = 2
      npixels = 20
      pcount = 0
      gcount = 1
      extend = .true.
      
C        ############################
C        #  write single keywords   #
C        ############################
      
      call ftphpr(iunit,simple, bitpix, naxis, naxes, 
     & 0,1,extend,status)

      call ftprec(iunit, 
     &'key_prec= ''This keyword was written by fxprec'' / '//
     & 'comment goes here',  status)

      write(*,'(1x,A)') 'test writing of long string keywords: '
      card = '1234567890123456789012345678901234567890'//
     & '12345678901234567890123456789012345'
      call ftpkys(iunit, 'card1', card, ' ', status)
      call ftgkey(iunit, 'card1', card2, comment, status)

      write(*,'(1x,A)') card
      write(*,'(1x,A)') card2
      
      card = '1234567890123456789012345678901234567890'//
     &  '123456789012345678901234''6789012345'
      call ftpkys(iunit, 'card2', card, ' ', status)
      call ftgkey(iunit, 'card2', card2, comment, status)
      write(*,'(1x,A)') card
      write(*,'(1x,A)') card2
      
      card = '1234567890123456789012345678901234567890'//
     &  '123456789012345678901234''''789012345'
      call ftpkys(iunit, 'card3', card, ' ', status)
      call ftgkey(iunit, 'card3', card2, comment, status)
      write(*,'(1x,A)') card
      write(*,'(1x,A)') card2
      
      card = '1234567890123456789012345678901234567890'//
     & '123456789012345678901234567''9012345'
      call ftpkys(iunit, 'card4', card, ' ', status)
      call ftgkey(iunit, 'card4', card2, comment, status)
      write(*,'(1x,A)') card
      write(*,'(1x,A)') card2

      call ftpkys(iunit, 'key_pkys', oskey, 'fxpkys comment', status)
      call ftpkyl(iunit, 'key_pkyl', olkey, 'fxpkyl comment', status)
      call ftpkyj(iunit, 'key_pkyj', ojkey, 'fxpkyj comment', status)
      call ftpkyf(iunit,'key_pkyf',ofkey,5, 'fxpkyf comment', status)
      call ftpkye(iunit,'key_pkye',oekey,6, 'fxpkye comment', status)
      call ftpkyg(iunit,'key_pkyg',ogkey,14, 'fxpkyg comment',status)
      call ftpkyd(iunit,'key_pkyd',odkey,14, 'fxpkyd comment',status)

      lstr='This is a very long string '//
     &   'value that is continued over more than one keyword.'

      call ftpkls(iunit,'key_pkls',lstr,'fxpkls comment',status)

      call ftplsw(iunit, status)
      call ftpkyt(iunit,'key_pkyt',otint,otfrac,'fxpkyt comment',
     & status)
      call ftpcom(iunit, 'This keyword was written by fxpcom.',
     &  status)
      call ftphis(iunit, 
     &'  This keyword written by fxphis (w/ 2 leading spaces).',
     &    status)

      call ftpdat(iunit, status)
      
      if (status .gt. 0)go to 999   

C
C        ###############################
C        #  write arrays of keywords   #
C        ###############################
      
      nkeys = 3

      comm = 'fxpkns comment&'
      call ftpkns(iunit, 'ky_pkns', 1, nkeys, onskey, comm, status)
      comm = 'fxpknl comment&'
      call ftpknl(iunit, 'ky_pknl', 1, nkeys, onlkey, comm, status)

      comm = 'fxpknj comment&'
      call ftpknj(iunit, 'ky_pknj', 1, nkeys, onjkey, comm, status)

      comm = 'fxpknf comment&'
      call ftpknf(iunit, 'ky_pknf', 1, nkeys, onfkey,5,comm,status)

      comm = 'fxpkne comment&'
      call ftpkne(iunit, 'ky_pkne', 1, nkeys, onekey,6,comm,status)

      comm = 'fxpkng comment&'
      call ftpkng(iunit, 'ky_pkng', 1, nkeys, ongkey,13,comm,status)

      comm = 'fxpknd comment&'
      call ftpknd(iunit, 'ky_pknd', 1, nkeys, ondkey,14,comm,status)
      
      if (status .gt. 0)go to 999
      
C        ############################
C        #  write generic keywords  #
C        ############################
      

      oskey = '1'
      call ftpkys(iunit, 'tstring', oskey, 'tstring comment',status)

      olkey = .true.
      call ftpkyl(iunit, 'tlogical', olkey, 'tlogical comment',
     &    status)

      ojkey = 11
      call ftpkyj(iunit, 'tbyte', ojkey, 'tbyte comment', status)

      ojkey = 21
      call ftpkyj(iunit, 'tshort', ojkey, 'tshort comment', status)

      ojkey = 31
      call ftpkyj(iunit, 'tint', ojkey, 'tint comment', status)

      ojkey = 41
      call ftpkyj(iunit, 'tlong', ojkey, 'tlong comment', status)

      oekey = 42
      call ftpkye(iunit, 'tfloat', oekey, 6,'tfloat comment', status)

      odkey = 82.D+00
      call ftpkyd(iunit, 'tdouble', odkey, 14, 'tdouble comment',
     &          status)

      if (status .gt. 0)go to 999
      write(*,'(1x,A)') 'Wrote all Keywords successfully '


C        ############################
C        #  write data              #
C        ############################
      
      
C define the null value (must do this before writing any data) 
      call ftpkyj(iunit,'BLANK',-99,
     & 'value to use for undefined pixels',   status)
      
C initialize arrays of values to write to primary array 
      do ii = 1, npixels
          boutarray(ii) = char(ii)
          ioutarray(ii) = ii
          joutarray(ii) = ii
          eoutarray(ii) = ii
          doutarray(ii) = ii
      end do      

C write a few pixels with each datatype 
C set the last value in each group of 4 as undefined 
      call ftpprb(iunit, 1,  1, 2, boutarray(1),  status)
      call ftppri(iunit, 1,  5, 2, ioutarray(5),  status)
      call ftpprj(iunit, 1,  9, 2, joutarray(9),  status)
      call ftppre(iunit, 1, 13, 2, eoutarray(13), status)
      call ftpprd(iunit, 1, 17, 2, doutarray(17), status)
      bnul = char(4)
      call ftppnb(iunit, 1,  3, 2, boutarray(3),   bnul, status)
      inul = 8
      call ftppni(iunit, 1,  7, 2, ioutarray(7),  inul, status)
      call ftppnj(iunit, 1, 11, 2, joutarray(11),  12, status)
      call ftppne(iunit, 1, 15, 2, eoutarray(15), 16., status)
      dnul = 20.
      call ftppnd(iunit, 1, 19, 2, doutarray(19), dnul, status)
      call ftppru(iunit, 1, 1, 1, status)

      if (status .gt. 0)then
          write(*,'(1x,A,I4)')'ftppnx status = ', status
          goto 999
      end if

      call ftflus(iunit, status)   
C flush all data to the disk file  
      write(*,'(1x,A,I4)')'ftflus status = ', status
      write(*,'(1x,A)')' '

      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)')'HDU number = ', hdunum

C        ############################
C        #  read data               #
C        ############################
      
     
C read back the data, setting null values = 99 
      write(*,'(1x,A)')
     &   'Values read back from primary array (99 = null pixel)'
      write(*,'(1x,A)') 
     &  'The 1st, and every 4th pixel should be undefined: '

      anynull = .false.
      bnul = char(99)
      call ftgpvb(iunit, 1,  1, 10, bnul, binarray, anynull, status)
      call ftgpvb(iunit, 1, 11, 10, bnul, binarray(11),anynull,status)

      do ii = 1,npixels
           iinarray(ii) = ichar(binarray(ii))
      end do

      write(*,1101) (iinarray(ii), ii = 1, npixels), anynull,
     &  ' (ftgpvb) '
1101  format(1x,20i3,l3,a)

      inul = 99
      call ftgpvi(iunit, 1, 1, npixels, inul, iinarray,anynull,status)

      write(*,1101) (iinarray(ii), ii = 1, npixels), anynull,
     &  ' (ftgpvi) '

      call ftgpvj(iunit, 1, 1, npixels, 99,  jinarray,anynull,status)

      write(*,1101) (jinarray(ii), ii = 1, npixels), anynull,
     &  ' (ftgpvj) '

      call ftgpve(iunit, 1, 1, npixels, 99., einarray,anynull,status)

      write(*,1102) (einarray(ii), ii = 1, npixels), anynull,
     &  ' (ftgpve) '

1102  format(2x,20f3.0,l2,a)

      dnul = 99.
      call ftgpvd(iunit, 1,  1, 10, dnul,  dinarray, anynull, status)
      call ftgpvd(iunit, 1, 11, 10, dnul,dinarray(11),anynull,status)

      write(*,1102) (dinarray(ii), ii = 1, npixels), anynull,
     &  ' (ftgpvd) '

      if (status .gt. 0)then
          write(*,'(1x,A,I4)')'ERROR: ftgpv_ status = ', status
          goto 999
      end if
      
      if (.not. anynull)then
         write(*,'(1x,A)') 'ERROR: ftgpv_ did not detect null values '
         go to 999
      end if
      
C reset the output null value to the expected input value 

      do ii = 4, npixels, 4      
          boutarray(ii) = char(99)
          ioutarray(ii) = 99
          joutarray(ii) = 99
          eoutarray(ii) = 99.
          doutarray(ii) = 99.
      end do

          ii = 1
          boutarray(ii) = char(99)
          ioutarray(ii) = 99
          joutarray(ii) = 99
          eoutarray(ii) = 99.
          doutarray(ii) = 99.

      
C compare the output with the input flag any differences 
      do ii = 1, npixels
     
         if (boutarray(ii) .ne. binarray(ii))then
             write(*,'(1x,A,2A2)') 'bout != bin ', boutarray(ii), 
     &      binarray(ii)
         end if

         if (ioutarray(ii) .ne. iinarray(ii))then
             write(*,'(1x,A,2I8)') 'bout != bin ', ioutarray(ii), 
     &      iinarray(ii)
         end if

         if (joutarray(ii) .ne. jinarray(ii))then
             write(*,'(1x,A,2I12)') 'bout != bin ', joutarray(ii), 
     &       jinarray(ii)
         end if

         if (eoutarray(ii) .ne. einarray(ii))then
             write(*,'(1x,A,2E15.3)') 'bout != bin ', eoutarray(ii),
     &       einarray(ii)
         end if
    
         if (doutarray(ii) .ne. dinarray(ii))then
             write(*,'(1x,A,2D20.6)') 'bout != bin ', doutarray(ii), 
     &       dinarray(ii)
         end if
      end do

      do ii = 1, npixels
        binarray(ii) = char(0)
        iinarray(ii) = 0
        jinarray(ii) = 0
        einarray(ii) = 0.
        dinarray(ii) = 0.
      end do      

      anynull = .false.
      call ftgpfb(iunit, 1,  1, 10, binarray, larray, anynull,status)
      call ftgpfb(iunit, 1, 11, 10, binarray(11), larray(11),
     & anynull, status)

      do ii = 1, npixels
        if (larray(ii))binarray(ii) = char(0)
      end do

      do ii = 1,npixels
           iinarray(ii) = ichar(binarray(ii))
      end do

      write(*,1101)(iinarray(ii),ii = 1,npixels),anynull,' (ftgpfb)'

      call ftgpfi(iunit, 1, 1, npixels, iinarray, larray, anynull,
     & status)

      do ii = 1, npixels
        if (larray(ii))iinarray(ii) = 0
      end do

      write(*,1101)(iinarray(ii),ii = 1,npixels),anynull,' (ftgpfi)'

      call ftgpfj(iunit, 1, 1, npixels, jinarray, larray, anynull,
     & status)

      do ii = 1, npixels
        if (larray(ii))jinarray(ii) = 0
      end do

      write(*,1101)(jinarray(ii),ii = 1,npixels),anynull,' (ftgpfj)'

      call ftgpfe(iunit, 1, 1, npixels, einarray, larray, anynull,
     & status)

      do ii = 1, npixels
        if (larray(ii))einarray(ii) = 0.
      end do

      write(*,1102)(einarray(ii),ii = 1,npixels),anynull,' (ftgpfe)'

      call ftgpfd(iunit, 1,  1, 10, dinarray, larray, anynull,status)
      call ftgpfd(iunit, 1, 11, 10, dinarray(11), larray(11),
     & anynull, status)

      do ii = 1, npixels
        if (larray(ii))dinarray(ii) = 0.
      end do

      write(*,1102)(dinarray(ii),ii = 1,npixels),anynull,' (ftgpfd)'

      if (status .gt. 0)then
          write(*,'(1x,A,I4)')'ERROR: ftgpf_ status = ', status
          go to 999
      end if

      if (.not. anynull)then
         write(*,'(1x,A)') 'ERROR: ftgpf_ did not detect null values'
         go to 999
      end if


C        ##########################################
C        #  close and reopen file multiple times  #
C        ##########################################
      

      do ii = 1, 10
         call ftclos(iunit, status)
        
         if (status .gt. 0)then
            write(*,'(1x,A,I4)')'ERROR in ftclos (1) = ', status
            go to 999
         end if

         call ftopen(iunit, filename, 1, block, status)

         if (status .gt. 0)then
            write(*,'(1x,A,I4)')'ERROR: ftopen open file status = ',
     &      status
            go to 999
         end if
      end do
      
      write(*,'(1x,A)') ' '
      write(*,'(1x,A)') 'Closed then reopened the FITS file 10 times.'
      write(*,'(1x,A)')' '

      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)')'HDU number = ', hdunum


C        ############################
C        #  read single keywords    #
C        ############################
      

      simple = .false.
      bitpix = 0
      naxis = 0
      naxes(1) = 0
      naxes(2) = 0
      pcount = -99
      gcount =  -99
      extend = .false.
      write(*,'(1x,A)') 'Read back keywords: '
      call ftghpr(iunit, 3, simple, bitpix, naxis, naxes, pcount,
     &       gcount, extend, status)
      write(*,'(1x,A,L4,4I4)')'simple, bitpix, naxis, naxes = ',
     &       simple, bitpix, naxis, naxes(1), naxes(2)
      write(*,'(1x,A,2I4,L4)')'  pcount, gcount, extend = ',
     &           pcount, gcount, extend

      call ftgrec(iunit, 9, card, status)
      write(*,'(1x,A)') card
      if (card(1:15) .ne. 'KEY_PREC= ''This')
     &    write(*,'(1x,A)') 'ERROR in ftgrec '

      call ftgkyn(iunit, 9, keyword, value, comment, status)
      write(*,'(1x,5A)') keyword,' ', value(1:35),' ', comment(1:20)

      if (keyword(1:8) .ne. 'KEY_PREC' )
     &    write(*,'(1x,2A)') 'ERROR in ftgkyn: ', keyword

      call ftgcrd(iunit, keyword, card, status)
      write(*,'(1x,A)') card

      if (keyword(1:8) .ne.  card(1:8) )
     &    write(*,'(1x,2A)') 'ERROR in ftgcrd: ', keyword

      call ftgkey(iunit, 'KY_PKNS1', value, comment, status)
      write(*,'(1x,5A)') 'KY_PKNS1 ',':', value(1:15),':', comment(1:16)

      if (value(1:14) .ne. '''first string''')
     &  write(*,'(1x,2A)') 'ERROR in ftgkey: ', value

      call ftgkys(iunit, 'key_pkys', iskey, comment, status)
      write(*,'(1x,5A,I4)')'KEY_PKYS ',':',iskey,':',comment(1:16),
     & status

      call ftgkyl(iunit, 'key_pkyl', ilkey, comment, status)
      write(*,'(1x,2A,L4,2A,I4)') 'KEY_PKYL ',':', ilkey,':', 
     &comment(1:16), status

      call ftgkyj(iunit, 'KEY_PKYJ', ijkey, comment, status)
      write(*,'(1x,2A,I4,2A,I4)') 'KEY_PKYJ ',':',ijkey,':', 
     &  comment(1:16), status

      call ftgkye(iunit, 'KEY_PKYJ', iekey, comment, status)
      write(*,'(1x,2A,f12.5,2A,I4)') 'KEY_PKYE ',':',iekey,':',
     & comment(1:16), status

      call ftgkyd(iunit, 'KEY_PKYJ', idkey, comment, status)
      write(*,'(1x,2A,F12.5,2A,I4)') 'KEY_PKYD ',':',idkey,':', 
     & comment(1:16), status

      if (ijkey .ne. 11 .or. iekey .ne. 11. .or. idkey .ne. 11.)
     &   write(*,'(1x,A,I4,2F5.1)') 'ERROR in ftgky(jed): ',
     & ijkey, iekey, idkey

      iskey= ' '
      call ftgkys(iunit, 'key_pkys', iskey, comment, status)
      write(*,'(1x,5A,I4)') 'KEY_PKYS ',':', iskey,':', comment(1:16),
     &  status

      ilkey = .false.
      call ftgkyl(iunit, 'key_pkyl', ilkey, comment, status)
      write(*,'(1x,2A,L4,2A,I4)') 'KEY_PKYL ',':', ilkey,':',
     &  comment(1:16), status

      ijkey = 0
      call ftgkyj(iunit, 'KEY_PKYJ', ijkey, comment, status)
      write(*,'(1x,2A,I4,2A,I4)') 'KEY_PKYJ ',':',ijkey,':', 
     & comment(1:16), status

      iekey = 0
      call ftgkye(iunit, 'KEY_PKYE', iekey, comment, status)
      write(*,'(1x,2A,f12.5,2A,I4)') 'KEY_PKYE ',':',iekey,':', 
     & comment(1:16), status

      idkey = 0
      call ftgkyd(iunit, 'KEY_PKYD', idkey, comment, status)
      write(*,'(1x,2A,F12.5,2A,I4)') 'KEY_PKYD ',':',idkey,':',
     & comment(1:16), status

      iekey = 0
      call ftgkye(iunit, 'KEY_PKYF', iekey, comment, status)
      write(*,'(1x,2A,f12.5,2A,I4)') 'KEY_PKYF ',':',iekey,':',
     & comment(1:16), status

      iekey = 0
      call ftgkye(iunit, 'KEY_PKYE', iekey, comment, status)
      write(*,'(1x,2A,f12.5,2A,I4)') 'KEY_PKYE ',':',iekey,':', 
     & comment(1:16), status

      idkey = 0
      call ftgkyd(iunit, 'KEY_PKYG', idkey, comment, status)
      write(*,'(1x,2A,f16.12,2A,I4)') 'KEY_PKYG ',':',idkey,':',
     & comment(1:16), status

      idkey = 0
      call ftgkyd(iunit, 'KEY_PKYD', idkey, comment, status)
      write(*,'(1x,2A,f16.12,2A,I4)') 'KEY_PKYD ',':',idkey,':', 
     & comment(1:16), status

      call ftgkyt(iunit, 'KEY_PKYT', ijkey, idkey, comment, status)
      write(*,'(1x,2A,i10,A,f16.14,A,I4)') 'KEY_PKYT  ',':',
     & ijkey,':', idkey, comment(1:16), status

      call ftpunt(iunit, 'KEY_PKYJ', 'km/s/Mpc', status)
      ijkey = 0
      call ftgkyj(iunit, 'KEY_PKYJ', ijkey, comment, status)
      write(*,'(1x,2A,I4,2A,I4)') 'KEY_PKYJ ',':',ijkey,':', 
     & comment(1:38), status
      call ftgunt(iunit,'KEY_PKYJ',kunit,status)
      write(*,'(1x,2A)') 'keyword unit=', kunit

      call ftpunt(iunit, 'KEY_PKYJ', ' ', status)
      ijkey = 0
      call ftgkyj(iunit, 'KEY_PKYJ', ijkey, comment, status)
      write(*,'(1x,2A,I4,2A,I4)') 'KEY_PKYJ ',':',ijkey,':', 
     & comment(1:38), status
      call ftgunt(iunit,'KEY_PKYJ',kunit,status)
      write(*,'(1x,2A)') 'keyword unit=', kunit

      call ftpunt(iunit, 'KEY_PKYJ', 'feet/second/second', status)
      ijkey = 0
      call ftgkyj(iunit, 'KEY_PKYJ', ijkey, comment, status)
      write(*,'(1x,2A,I4,2A,I4)') 'KEY_PKYJ ',':',ijkey,':', 
     & comment(1:38), status
      call ftgunt(iunit,'KEY_PKYJ',kunit,status)
      write(*,'(1x,2A)') 'keyword unit=', kunit

      call ftgkys(iunit, 'key_pkls', lstr, comment, status)
      write(*,'(1x,2A)') 'KEY_PKLS long string value = ', lstr(1:50)
      write(*,'(1x,A)')lstr(51:120)

C get size and position in header 
      call ftghps(iunit, existkeys, keynum, status)
      write(*,'(1x,A,I4,A,I4)') 'header contains ', existkeys,
     & ' keywords; located at keyword ', keynum

C        ############################
C        #  read array keywords     #
C        ############################
      
      call ftgkns(iunit, 'ky_pkns', 1, 3, inskey, nfound, status)
      write(*,'(1x,4A)') 'ftgkns: ', inskey(1)(1:14), inskey(2)(1:14),
     &  inskey(3)(1:14)
      if (nfound .ne. 3 .or. status .gt. 0)
     &   write(*,'(1x,A,2I4)') ' ERROR in ftgkns ', nfound, status

      call ftgknl(iunit, 'ky_pknl', 1, 3, inlkey, nfound, status)
      write(*,'(1x,A,3L4)') 'ftgknl: ', inlkey(1), inlkey(2), inlkey(3)
      if (nfound .ne. 3 .or. status .gt. 0)
     &   write(*,'(1x,A,2I4)') ' ERROR in ftgknl ', nfound, status

      call ftgknj(iunit, 'ky_pknj', 1, 3, injkey, nfound, status)
      write(*,'(1x,A,3I4)') 'ftgknj: ', injkey(1), injkey(2), injkey(3)
      if (nfound .ne. 3 .or. status .gt. 0)
     &   write(*,'(1x,A,2I4)') ' ERROR in ftgknj ', nfound, status

      call ftgkne(iunit, 'ky_pkne', 1, 3, inekey, nfound, status)
      write(*,'(1x,A,3F10.5)') 'ftgkne: ',inekey(1),inekey(2),inekey(3)
      if (nfound .ne. 3 .or. status .gt. 0)
     &   write(*,'(1x,A,2I4)') ' ERROR in ftgkne ', nfound, status

      call ftgknd(iunit, 'ky_pknd', 1, 3, indkey, nfound, status)
      write(*,'(1x,A,3F10.5)') 'ftgknd: ',indkey(1),indkey(2),indkey(3)
      if (nfound .ne. 3 .or. status .gt. 0)
     &   write(*,'(1x,A,2I4)') ' ERROR in ftgknd ', nfound, status

      write(*,'(1x,A)')' '
      write(*,'(1x,A)')
     & 'Before deleting the HISTORY and DATE keywords...'
      do ii = 29, 32     
          call ftgrec(iunit, ii, card, status)
          write(*,'(1x,A)') card(1:8)
      end do

C don't print date value, so that 
C the output will always be the same 
      

C        ############################
C        #  delete keywords         #
C        ############################
      

      call ftdrec(iunit, 30, status)
      call ftdkey(iunit, 'DATE', status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'After deleting the keywords... '
      do ii = 29, 30            
          call ftgrec(iunit, ii, card, status)
          write(*,'(1x,A)') card
      end do      

      if (status .gt. 0)
     &   write(*,'(1x,A)') ' ERROR deleting keywords '
      

C        ############################
C        #  insert keywords         #
C        ############################
      
      call ftirec(iunit,26,
     & 'KY_IREC = ''This keyword inserted by fxirec''',
     &   status)
      call ftikys(iunit, 'KY_IKYS', 'insert_value_string',
     &  'ikys comment', status)
      call ftikyj(iunit, 'KY_IKYJ', 49, 'ikyj comment', status)
      call ftikyl(iunit, 'KY_IKYL', .true., 'ikyl comment', status)
      call ftikye(iunit, 'KY_IKYE',12.3456,4,'ikye comment',status)
      odkey = 12.345678901234567D+00
      call ftikyd(iunit, 'KY_IKYD', odkey, 14,
     &  'ikyd comment', status)
      call ftikyf(iunit, 'KY_IKYF', 12.3456, 4, 'ikyf comment',
     & status)
      call ftikyg(iunit, 'KY_IKYG', odkey, 13,
     & 'ikyg comment', status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'After inserting the keywords... '
      do ii = 25, 34
          call ftgrec(iunit, ii, card, status)
          write(*,'(1x,A)') card
      end do

      if (status .gt. 0)
     &   write(*,'(1x,A)') ' ERROR inserting keywords '
      

C        ############################
C        #  modify keywords         #
C        ############################
      
      call ftmrec(iunit, 25,
     & 'COMMENT   This keyword was modified by fxmrec', status)
      call ftmcrd(iunit, 'KY_IREC', 
     & 'KY_MREC = ''This keyword was modified by fxmcrd''', status)
      call ftmnam(iunit, 'KY_IKYS', 'NEWIKYS', status)

      call ftmcom(iunit,'KY_IKYJ','This is a modified comment',
     & status)
      call ftmkyj(iunit, 'KY_IKYJ', 50, '&', status)
      call ftmkyl(iunit, 'KY_IKYL', .false., '&', status)
      call ftmkys(iunit, 'NEWIKYS', 'modified_string', '&', status)
      call ftmkye(iunit, 'KY_IKYE', -12.3456, 4, '&', status)
      odkey = -12.345678901234567D+00

      call ftmkyd(iunit, 'KY_IKYD', odkey, 14, 
     & 'modified comment', status)
      call ftmkyf(iunit, 'KY_IKYF', -12.3456, 4, '&', status)
      call ftmkyg(iunit,'KY_IKYG', odkey,13,'&',status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'After modifying the keywords... '
      do ii = 25, 34
          call ftgrec(iunit, ii, card, status)
          write(*,'(1x,A)') card
      end do
      
      if (status .gt. 0)then
         write(*,'(1x,A)') ' ERROR modifying keywords '
         go to 999
      end if
      
C        ############################
C        #  update keywords         #
C        ############################
      
      call ftucrd(iunit, 'KY_MREC', 
     & 'KY_UCRD = ''This keyword was updated by fxucrd''',
     &         status)

      call ftukyj(iunit, 'KY_IKYJ', 51, '&', status)
      call ftukyl(iunit, 'KY_IKYL', .true., '&', status)
      call ftukys(iunit, 'NEWIKYS', 'updated_string', '&', status)
      call ftukye(iunit, 'KY_IKYE', -13.3456, 4, '&', status)
      odkey = -13.345678901234567D+00

      call ftukyd(iunit, 'KY_IKYD',odkey , 14, 
     & 'modified comment', status)
      call ftukyf(iunit, 'KY_IKYF', -13.3456, 4, '&', status)
      call ftukyg(iunit, 'KY_IKYG', odkey, 13, '&', status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'After updating the keywords... '
      do ii = 25, 34
          call ftgrec(iunit, ii, card, status)
          write(*,'(1x,A)') card
      end do

      if (status .gt. 0)then
         write(*,'(1x,A)') ' ERROR modifying keywords '
         go to 999
      end if

C     move to top of header and find keywords using wild cards 
      call ftgrec(iunit, 0, card, status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)')
     &  'Keywords found using wildcard search (should be 9)...'
      nfound = -1
91    nfound = nfound +1
      call ftgnxk(iunit, inclist, 2, exclist, 2, card, status)
      if (status .eq. 0)then
          write(*,'(1x,A)') card
          go to 91
      end if

      if (nfound .ne. 9)then
          write(*,'(1x,A)')
     &    'ERROR reading keywords using wildcards (ftgnxk)'
         go to 999
      end if
      status = 0

C        ############################
C        #  create binary table     #
C        ############################
      
      tform(1) = '15A'
      tform(2) = '1L'
      tform(3) = '16X'
      tform(4) = '1B'
      tform(5) = '1I'
      tform(6) = '1J'
      tform(7) = '1E'
      tform(8) = '1D'
      tform(9) = '1C'
      tform(10)= '1M'

      ttype(1) = 'Avalue'
      ttype(2) = 'Lvalue'
      ttype(3) = 'Xvalue'
      ttype(4) = 'Bvalue'
      ttype(5) = 'Ivalue'
      ttype(6) = 'Jvalue'
      ttype(7) = 'Evalue'
      ttype(8) = 'Dvalue'
      ttype(9) = 'Cvalue'
      ttype(10)= 'Mvalue'

      tunit(1) = ' '
      tunit(2) = 'm**2'
      tunit(3) = 'cm'
      tunit(4) = 'erg/s'
      tunit(5) = 'km/s'
      tunit(6) = ' '
      tunit(7) = ' '
      tunit(8) = ' '
      tunit(9) = ' '
      tunit(10)= ' '

      nrows = 21
      tfields = 10
      pcount = 0

      call ftibin(iunit, nrows, tfields, ttype, tform, tunit, 
     & binname, pcount, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)') 'ftibin status = ', status
      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)') 'HDU number = ', hdunum

C get size and position in header, and reserve space for more keywords 
      call ftghps(iunit, existkeys, keynum, status)
      write(*,'(1x,A,I4,A,I4)') 'header contains ',existkeys,
     & ' keywords located at keyword ', keynum

      morekeys = 40
      call fthdef(iunit, morekeys, status)
      call ftghsp(iunit, existkeys, morekeys, status)
      write(*,'(1x,A,I4,A,I4,A)') 'header contains ', existkeys,
     &' keywords with room for ', morekeys,' more'

C define null value for int cols 
      call fttnul(iunit, 4, 99, status)   
      call fttnul(iunit, 5, 99, status)
      call fttnul(iunit, 6, 99, status)

      call ftpkyj(iunit, 'TNULL4', 99, 'value for undefined pixels',
     &  status)
      call ftpkyj(iunit, 'TNULL5', 99, 'value for undefined pixels',
     &  status)
      call ftpkyj(iunit, 'TNULL6', 99, 'value for undefined pixels',
     & status)

      naxis = 3
      naxes(1) = 1
      naxes(2) = 2
      naxes(3) = 8
      call ftptdm(iunit, 3, naxis, naxes, status)

      naxis = 0
      naxes(1) = 0
      naxes(2) = 0
      naxes(3) = 0
      call ftgtdm(iunit, 3, 3, naxis, naxes, status)
      call ftgkys(iunit, 'TDIM3', iskey, comment, status)
      write(*,'(1x,2A,4I4)') 'TDIM3 = ', iskey, naxis, naxes(1),
     &      naxes(2), naxes(3)

C force header to be scanned (not required) 
      call ftrdef(iunit, status)  
    
C        ############################
C        #  write data to columns   #
C        ############################
         
C initialize arrays of values to write to table 
      signval = -1
      do ii = 1, 21
          signval = signval * (-1)
          boutarray(ii) = char(ii)
          ioutarray(ii) = (ii) * signval
          joutarray(ii) = (ii) * signval
          koutarray(ii) = (ii) * signval
          eoutarray(ii) = (ii) * signval
          doutarray(ii) = (ii) * signval
      end do

      call ftpcls(iunit, 1, 1, 1, 3, onskey, status)  
C write string values 
      call ftpclu(iunit, 1, 4, 1, 1, status)  
C write null value 

      larray(1) = .false.
      larray(2) =.true.
      larray(3) = .false.
      larray(4) = .false.
      larray(5) =.true.
      larray(6) =.true.
      larray(7) = .false.
      larray(8) = .false.
      larray(9) = .false.
      larray(10) =.true.
      larray(11) =.true.
      larray(12) = .true.
      larray(13) = .false.
      larray(14) = .false.
      larray(15) =.false.
      larray(16) =.false.
      larray(17) = .true.
      larray(18) = .true.
      larray(19) = .true.
      larray(20) = .true.
      larray(21) =.false.
      larray(22) =.false.
      larray(23) =.false.
      larray(24) =.false.
      larray(25) =.false.
      larray(26) = .true.
      larray(27) = .true.
      larray(28) = .true.
      larray(29) = .true.
      larray(30) = .true.
      larray(31) =.false.
      larray(32) =.false.
      larray(33) =.false.
      larray(34) =.false.
      larray(35) =.false.
      larray(36) =.false.

C write bits
      call ftpclx(iunit, 3, 1, 1, 36, larray, status) 

C loop over cols 4 - 8 
      do ii = 4, 8   
          call ftpclb(iunit, ii, 1, 1, 2, boutarray, status)
          if (status .eq. 412) status = 0

          call ftpcli(iunit, ii, 3, 1, 2, ioutarray(3), status) 
          if (status .eq. 412) status = 0

          call ftpclj(iunit, ii, 5, 1, 2, koutarray(5), status) 
          if (status .eq. 412) status = 0

          call ftpcle(iunit, ii, 7, 1, 2, eoutarray(7), status)
          if (status .eq. 412)status = 0

          call ftpcld(iunit, ii, 9, 1, 2, doutarray(9), status)
          if (status .eq. 412)status = 0

C write null value 
          call ftpclu(iunit, ii, 11, 1, 1, status)  
      end do

      call ftpclc(iunit,  9, 1, 1, 10, eoutarray, status)
      call ftpclm(iunit, 10, 1, 1, 10, doutarray, status)

C loop over cols 4 - 8 
      do ii = 4, 8
          bnul = char(13)
          call ftpcnb(iunit, ii, 12, 1, 2, boutarray(12),bnul,status)
          if (status .eq. 412) status = 0
          inul=15
          call ftpcni(iunit, ii, 14, 1, 2, ioutarray(14),inul,status) 
          if (status .eq. 412) status = 0
          call ftpcnj(iunit, ii, 16, 1, 2, koutarray(16), 17, status) 
          if (status .eq. 412) status = 0
          call ftpcne(iunit, ii, 18, 1, 2, eoutarray(18), 19.,status)
          if (status .eq. 412) status = 0
          dnul = 21.
          call ftpcnd(iunit, ii, 20, 1, 2, doutarray(20),dnul,status)
          if (status .eq. 412) status = 0
      end do
      
C write logicals
      call ftpcll(iunit, 2, 1, 1, 21, larray, status) 
C write null value 
      call ftpclu(iunit, 2, 11, 1, 1, status)  
      write(*,'(1x,A,I4)') 'ftpcl_ status = ', status
      if (status .gt. 0)go to 999
      
C        #########################################
C        #  get information about the columns    #
C        #########################################
      
      write(*,'(1x,A)')' '
      write(*,'(1x,A)')
     & 'Find the column numbers a returned status value'//
     & ' of 237 is'
      write(*,'(1x,A)') 
     & 'expected and indicates that more than one column'//
     & ' name matches'
      write(*,'(1x,A)')'the input column name template.'//
     & '  Status = 219 indicates that'
      write(*,'(1x,A)') 'there was no matching column name.'

      call ftgcno(iunit, 0, 'Xvalue', colnum, status)
      write(*,'(1x,A,I4,A,I4)') 'Column Xvalue is number', colnum,
     &' status =',status

219   continue
      if (status .ne. 219)then
        call ftgcnn(iunit, 1, '*ue', colname, colnum, status)
        write(*,'(1x,3A,I4,A,I4)') 'Column ',colname(1:6),' is number', 
     &   colnum,' status = ',  status
        go to 219
      end if

      status = 0

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Information about each column: '

      do ii = 1, tfields
        call ftgtcl(iunit, ii, typecode, repeat, width, status)
        call ftgbcl(iunit,ii,ttype,tunit,cval,repeat,scale,
     &        zero, jnulval, tdisp, status)

        write(*,'(1x,A,3I4,5A,2F8.2,I12,A)')
     &  tform(ii)(1:3), typecode, repeat, width,' ',
     &  ttype(1)(1:6),' ',tunit(1)(1:6), cval, scale, zero, jnulval,
     &  tdisp(1:8)
      end do

      write(*,'(1x,A)') ' '

C        ###############################################
C        #  insert ASCII table before the binary table #
C        ###############################################

      call ftmrhd(iunit, -1, hdutype, status)
      if (status .gt. 0)goto 999

      tform(1) = 'A15'
      tform(2) = 'I10'
      tform(3) = 'F14.6'
      tform(4) = 'E12.5'
      tform(5) = 'D21.14'

      ttype(1) = 'Name'
      ttype(2) = 'Ivalue'
      ttype(3) = 'Fvalue'
      ttype(4) = 'Evalue'
      ttype(5) = 'Dvalue'

      tunit(1) = ' '
      tunit(2) = 'm**2'
      tunit(3) = 'cm'
      tunit(4) = 'erg/s'
      tunit(5) = 'km/s'

      rowlen = 76
      nrows = 11
      tfields = 5

      call ftitab(iunit, rowlen, nrows, tfields, ttype, tbcol, 
     & tform, tunit, tblname, status)
      write(*,'(1x,A,I4)') 'ftitab status = ', status
      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)') 'HDU number = ', hdunum

C define null value for int cols 
      call ftsnul(iunit, 1, 'null1', status)   
      call ftsnul(iunit, 2, 'null2', status)
      call ftsnul(iunit, 3, 'null3', status)
      call ftsnul(iunit, 4, 'null4', status)
      call ftsnul(iunit, 5, 'null5', status)
 
      call ftpkys(iunit, 'TNULL1', 'null1',
     & 'value for undefined pixels', status)
      call ftpkys(iunit, 'TNULL2', 'null2',
     & 'value for undefined pixels', status)
      call ftpkys(iunit, 'TNULL3', 'null3',
     & 'value for undefined pixels', status)
      call ftpkys(iunit, 'TNULL4', 'null4',
     & 'value for undefined pixels', status)
      call ftpkys(iunit, 'TNULL5', 'null5',
     & 'value for undefined pixels', status)

      if (status .gt. 0) goto 999
      
C        ############################
C        #  write data to columns   #
C        ############################
           
C initialize arrays of values to write to table 
      do ii = 1,21     
          boutarray(ii) = char(ii)
          ioutarray(ii) = ii
          joutarray(ii) = ii
          eoutarray(ii) = ii
          doutarray(ii) = ii
      end do      

C write string values 
      call ftpcls(iunit, 1, 1, 1, 3, onskey, status)  
C write null value 
      call ftpclu(iunit, 1, 4, 1, 1, status)  

      do ii = 2,5 
C loop over cols 2 - 5       
          call ftpclb(iunit, ii, 1, 1, 2, boutarray, status)  
C char array 
          if (status .eq. 412) status = 0
             
          call ftpcli(iunit, ii, 3, 1, 2, ioutarray(3), status)  
C short array 
          if (status .eq. 412) status = 0
             
          call ftpclj(iunit, ii, 5, 1, 2, joutarray(5), status)  
C long array 
          if (status .eq. 412)status = 0
              
          call ftpcle(iunit, ii, 7, 1, 2, eoutarray(7), status)  
C float array 
          if (status .eq. 412) status = 0
             
          call ftpcld(iunit, ii, 9, 1, 2, doutarray(9), status)  
C double array 
          if (status .eq. 412) status = 0

          call ftpclu(iunit, ii, 11, 1, 1, status)  
C write null value 
      end do
      write(*,'(1x,A,I4)') 'ftpcl_ status = ', status
      write(*,'(1x,A)')' '

C        ################################
C        #  read data from ASCII table  #
C        ################################
      
      call ftghtb(iunit, 99, rowlen, nrows, tfields, ttype, tbcol, 
     &       tform, tunit, tblname, status)

      write(*,'(1x,A,3I3,2A)')
     & 'ASCII table: rowlen, nrows, tfields, extname:',
     & rowlen, nrows, tfields,' ',tblname

      do ii = 1,tfields
        write(*,'(1x,A,I4,3A)') 
     & ttype(ii)(1:7), tbcol(ii),' ',tform(ii)(1:7), tunit(ii)(1:7)
      end do

      nrows = 11
      call ftgcvs(iunit, 1, 1, 1, nrows, 'UNDEFINED', inskey,
     &   anynull, status)
      bnul = char(99)
      call ftgcvb(iunit, 2, 1, 1, nrows, bnul, binarray,
     & anynull, status)
      inul = 99
      call ftgcvi(iunit, 2, 1, 1, nrows, inul, iinarray,
     & anynull, status)
      call ftgcvj(iunit, 3, 1, 1, nrows, 99, jinarray,
     & anynull, status)
      call ftgcve(iunit, 4, 1, 1, nrows, 99., einarray,
     & anynull, status)
      dnul = 99.
      call ftgcvd(iunit, 5, 1, 1, nrows, dnul, dinarray,
     & anynull, status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Data values read from ASCII table: '
      do ii = 1, nrows
        jj = ichar(binarray(ii))
        write(*,1011) inskey(ii), jj,
     &   iinarray(ii), jinarray(ii), einarray(ii), dinarray(ii)
1011    format(1x,a15,3i3,1x,2f3.0)
      end do

      call ftgtbs(iunit, 1, 20, 78, uchars, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A)') uchars
      call ftptbs(iunit, 1, 20, 78, uchars, status)
      
C        #########################################
C        #  get information about the columns    #
C        #########################################

      call ftgcno(iunit, 0, 'name', colnum, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4,A,I4)')
     &  'Column name is number',colnum,' status = ', status

2190  continue
      if (status .ne. 219)then
        if (status .gt. 0 .and. status .ne. 237)go to 999

        call ftgcnn(iunit, 1, '*ue', colname, colnum, status)
        write(*,'(1x,3A,I4,A,I4)')
     & 'Column ',colname(1:6),' is number',colnum,' status = ',status
        go to 2190
      end if
   
      status = 0

      do ii = 1, tfields       
        call ftgtcl(iunit, ii, typecode, repeat, width, status)
        call ftgacl(iunit, ii, ttype, tbcol,tunit,tform, 
     &   scale,zero, nulstr, tdisp, status)

        write(*,'(1x,A,3I4,2A,I4,2A,2F10.2,3A)')
     & tform(ii)(1:7), typecode, repeat, width,' ',
     &  ttype(1)(1:6), tbcol(1), ' ',tunit(1)(1:5),
     &  scale, zero, ' ', nulstr(1:6), tdisp(1:2)

      end do

      write(*,'(1x,A)') ' '

C        ###############################################
C        #  test the insert/delete row/column routines #
C        ###############################################
      
      call ftirow(iunit, 2, 3, status)
      if (status .gt. 0) goto 999

      nrows = 14
      call ftgcvs(iunit, 1, 1, 1, nrows, 'UNDEFINED',
     & inskey,   anynull, status)
      call ftgcvb(iunit, 2, 1, 1, nrows, bnul, binarray,
     & anynull, status)
      call ftgcvi(iunit, 2, 1, 1, nrows, inul, iinarray,
     & anynull, status)
      call ftgcvj(iunit, 3, 1, 1, nrows, 99, jinarray,
     & anynull, status)
      call ftgcve(iunit, 4, 1, 1, nrows, 99., einarray,
     & anynull, status)
      call ftgcvd(iunit, 5, 1, 1, nrows, dnul, dinarray,
     & anynull, status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)')'Data values after inserting 3 rows after row 2:'
      do ii = 1, nrows     
        jj = ichar(binarray(ii))
        write(*,1011) inskey(ii), jj,
     &   iinarray(ii), jinarray(ii), einarray(ii), dinarray(ii)
      end do

      call ftdrow(iunit, 10, 2, status)

      nrows = 12
      call ftgcvs(iunit, 1, 1, 1, nrows, 'UNDEFINED', inskey,  
     & anynull, status)
      call ftgcvb(iunit, 2, 1, 1, nrows, bnul, binarray, anynull,
     & status)
      call ftgcvi(iunit, 2, 1, 1, nrows, inul, iinarray, anynull,
     & status)
      call ftgcvj(iunit, 3, 1, 1, nrows, 99, jinarray, anynull,
     & status)
      call ftgcve(iunit, 4, 1, 1, nrows, 99., einarray, anynull,
     & status)
      call ftgcvd(iunit, 5, 1, 1, nrows, dnul, dinarray, anynull,
     & status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Data values after deleting 2 rows at row 10: '
      do ii = 1, nrows    
        jj = ichar(binarray(ii))
        write(*,1011)  inskey(ii), jj,
     &       iinarray(ii), jinarray(ii), einarray(ii), dinarray(ii)
      end do
      call ftdcol(iunit, 3, status)

      call ftgcvs(iunit, 1, 1, 1, nrows, 'UNDEFINED', inskey, 
     &  anynull, status)
      call ftgcvb(iunit, 2, 1, 1, nrows, bnul, binarray, anynull,
     & status)
      call ftgcvi(iunit, 2, 1, 1, nrows, inul, iinarray, anynull,
     & status)
      call ftgcve(iunit, 3, 1, 1, nrows, 99., einarray, anynull,
     & status)
      call ftgcvd(iunit, 4, 1, 1, nrows, dnul, dinarray, anynull,
     & status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Data values after deleting column 3: '
      do ii = 1,nrows
        jj = ichar(binarray(ii))
        write(*,1012) inskey(ii), jj,
     &       iinarray(ii), einarray(ii), dinarray(ii)
1012    format(1x,a15,2i3,1x,2f3.0)

      end do

      call fticol(iunit, 5, 'INSERT_COL', 'F14.6', status)

      call ftgcvs(iunit, 1, 1, 1, nrows, 'UNDEFINED', inskey,
     &   anynull, status)
      call ftgcvb(iunit, 2, 1, 1, nrows, bnul, binarray, anynull,
     & status)
      call ftgcvi(iunit, 2, 1, 1, nrows, inul, iinarray, anynull,
     & status)
      call ftgcve(iunit, 3, 1, 1, nrows, 99., einarray, anynull,
     & status)
      call ftgcvd(iunit, 4, 1, 1, nrows, dnul, dinarray, anynull,
     & status)
      call ftgcvj(iunit, 5, 1, 1, nrows, 99, jinarray, anynull,
     & status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') ' Data values after inserting column 5: '
      do ii = 1, nrows
        jj = ichar(binarray(ii))
        write(*,1013) inskey(ii), jj,
     &       iinarray(ii), einarray(ii), dinarray(ii) , jinarray(ii)
1013    format(1x,a15,2i3,1x,2f3.0,i2)

      end do

C        ################################
C        #  read data from binary table #
C        ################################
      

      call ftmrhd(iunit, 1, hdutype, status)
      if (status .gt. 0)go to 999
      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)') 'HDU number = ', hdunum

      call ftghsp(iunit, existkeys, morekeys, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A)')'Moved to binary table'
      write(*,'(1x,A,I4,A,I4,A)') 'header contains ',existkeys,
     & ' keywords with room for ',morekeys,' more '

      call ftghbn(iunit, 99, nrows, tfields, ttype, 
     &        tform, tunit, binname, pcount, status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A,2I4,A,I4)') 
     & 'Binary table: nrows, tfields, extname, pcount:',
     &        nrows, tfields, binname, pcount

      do ii = 1,tfields
        write(*,'(1x,3A)') ttype(ii), tform(ii), tunit(ii)
      end do

      do ii = 1, 40
          larray(ii) = .false.
      end do

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Data values read from binary table: '
      write(*,'(1x,A)') ' Bit column (X) data values:   '

      call ftgcx(iunit, 3, 1, 1, 36, larray, status)
      write(*,1014) (larray(ii), ii = 1,40)
1014  format(1x,8l1,' ',8l1,' ',8l1,' ',8l1,' ',8l1)

      nrows = 21
      do ii = 1, nrows
        larray(ii) = .false.
        xinarray(ii) = ' '
        binarray(ii) = ' '
        iinarray(ii) = 0 
        kinarray(ii) = 0
        einarray(ii) = 0. 
        dinarray(ii) = 0.
        cinarray(ii * 2 -1) = 0. 
        minarray(ii * 2 -1) = 0.
        cinarray(ii * 2 ) = 0. 
        minarray(ii * 2 ) = 0.
      end do      

      write(*,'(1x,A)') '  '
      call ftgcvs(iunit, 1, 4, 1, 1, ' ',  inskey,   anynull,status)
      if (ichar(inskey(1)(1:1)) .eq. 0)inskey(1)=' '
      write(*,'(1x,2A)') 'null string column value (should be blank):',
     &        inskey(1)

      call ftgcvs(iunit, 1, 1, 1, nrows, 'NOT DEFINED',  inskey,
     &   anynull, status)
      call ftgcl( iunit, 2, 1, 1, nrows, larray, status)
      bnul = char(98)
      call ftgcvb(iunit, 3, 1, 1,nrows,bnul, xinarray,anynull,status)
      call ftgcvb(iunit, 4, 1, 1,nrows,bnul, binarray,anynull,status)
      inul = 98
      call ftgcvi(iunit, 5, 1, 1,nrows,inul, iinarray,anynull,status)
      call ftgcvj(iunit, 6, 1, 1, nrows, 98, kinarray,anynull,status)
      call ftgcve(iunit, 7, 1, 1, nrows, 98.,einarray,anynull,status)
      dnul = 98.
      call ftgcvd(iunit, 8, 1, 1, nrows,dnul,dinarray,anynull,status)
      call ftgcvc(iunit, 9, 1, 1, nrows, 98.,cinarray,anynull,status)
      call ftgcvm(iunit,10, 1, 1, nrows,dnul,minarray,anynull,status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Read columns with ftgcv_: '
      do ii = 1,nrows
        jj = ichar(xinarray(ii))
        jjj = ichar(binarray(ii))
      write(*,1201)inskey(ii),larray(ii),jj,jjj,iinarray(ii),
     & kinarray(ii), einarray(ii), dinarray(ii), cinarray(ii * 2 -1), 
     &cinarray(ii * 2 ), minarray(ii * 2 -1), minarray(ii * 2 )
      end do
1201  format(1x,a14,l4,4i4,6f5.0)

      do ii = 1, nrows
        larray(ii) = .false.
        xinarray(ii) = ' '
        binarray(ii) = ' '
        iinarray(ii) = 0 
        kinarray(ii) = 0
        einarray(ii) = 0. 
        dinarray(ii) = 0.
        cinarray(ii * 2 -1) = 0. 
        minarray(ii * 2 -1) = 0.
        cinarray(ii * 2 ) = 0. 
        minarray(ii * 2 ) = 0.
      end do      

      call ftgcfs(iunit, 1, 1, 1, nrows, inskey,   larray2, anynull,
     & status)
C     put blanks in strings if they are undefined.  (contain nulls)
      do ii = 1, nrows
         if (larray2(ii))inskey(ii) = ' '
      end do

      call ftgcfl(iunit, 2, 1, 1, nrows, larray,   larray2, anynull,
     & status)
      call ftgcfb(iunit, 3, 1, 1, nrows, xinarray, larray2, anynull,
     & status)
      call ftgcfb(iunit, 4, 1, 1, nrows, binarray, larray2, anynull,
     & status)
      call ftgcfi(iunit, 5, 1, 1, nrows, iinarray, larray2, anynull,
     & status)
      call ftgcfj(iunit, 6, 1, 1, nrows, kinarray, larray2, anynull,
     & status)
      call ftgcfe(iunit, 7, 1, 1, nrows, einarray, larray2, anynull,
     & status)
      call ftgcfd(iunit, 8, 1, 1, nrows, dinarray, larray2, anynull,
     & status)
      call ftgcfc(iunit, 9, 1, 1, nrows, cinarray, larray2, anynull,
     & status)
      call ftgcfm(iunit, 10,1, 1, nrows, minarray, larray2, anynull,
     & status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') ' Read columns with ftgcf_: '
      do ii = 1, 10
        jj = ichar(xinarray(ii))
        jjj = ichar(binarray(ii))
      write(*,1201)
     & inskey(ii),larray(ii),jj,jjj,iinarray(ii),
     & kinarray(ii), einarray(ii), dinarray(ii), cinarray(ii * 2 -1), 
     & cinarray(ii * 2 ), minarray(ii * 2 -1), minarray(ii * 2)
      end do

      do ii = 11, 21
C don't try to print the NaN values 
        jj = ichar(xinarray(ii))
        jjj = ichar(binarray(ii))
        write(*,1201) inskey(ii), larray(ii), jj,
     &    jjj, iinarray(ii)
      end do
      
      call ftprec(iunit,'key_prec= '// 
     &'''This keyword was written by f_prec'' / comment here',
     & status)

C        ###############################################
C        #  test the insert/delete row/column routines #
C        ###############################################
      
      call ftirow(iunit, 2, 3, status)
         if (status .gt. 0) go to 999

      nrows = 14
      call ftgcvs(iunit, 1, 1, 1, nrows, 'NOT DEFINED',  inskey,
     & anynull, status)
      call ftgcvb(iunit, 4, 1, 1, nrows,bnul,binarray,anynull,status)
      call ftgcvi(iunit, 5, 1, 1, nrows,inul,iinarray,anynull,status)
      call ftgcvj(iunit, 6, 1, 1, nrows, 98, jinarray,anynull,status)
      call ftgcve(iunit, 7, 1, 1, nrows, 98.,einarray,anynull,status)
      call ftgcvd(iunit, 8, 1, 1, nrows,dnul,dinarray,anynull,status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)')'Data values after inserting 3 rows after row 2:'
      do ii = 1, nrows
        jj = ichar(binarray(ii))
        write(*,1202)  inskey(ii), jj,
     &      iinarray(ii), jinarray(ii), einarray(ii), dinarray(ii)
      end do      
1202  format(1x,a14,3i4,2f5.0)

      call ftdrow(iunit, 10, 2, status)
          if (status .gt. 0)goto 999

      nrows = 12
      call ftgcvs(iunit, 1, 1, 1, nrows, 'NOT DEFINED',  inskey,
     &   anynull, status)
      call ftgcvb(iunit, 4, 1, 1, nrows,bnul,binarray,anynull,status)
      call ftgcvi(iunit, 5, 1, 1, nrows,inul,iinarray,anynull,status)
      call ftgcvj(iunit, 6, 1, 1, nrows, 98,jinarray,anynull,status)
      call ftgcve(iunit, 7, 1, 1, nrows, 98.,einarray,anynull,status)
      call ftgcvd(iunit, 8, 1, 1, nrows,dnul,dinarray,anynull,status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Data values after deleting 2 rows at row 10: '
      do ii = 1, nrows
        jj = ichar(binarray(ii))
        write(*,1202) inskey(ii), jj,
     &       iinarray(ii), jinarray(ii), einarray(ii), dinarray(ii)
      end do

      call ftdcol(iunit, 6, status)

      call ftgcvs(iunit, 1, 1, 1, nrows, 'NOT DEFINED',  inskey,
     &   anynull, status)
      call ftgcvb(iunit, 4, 1, 1, nrows,bnul,binarray,anynull,status)
      call ftgcvi(iunit, 5, 1, 1, nrows,inul,iinarray,anynull,status)
      call ftgcve(iunit, 6, 1, 1, nrows, 98.,einarray,anynull,status)
      call ftgcvd(iunit, 7, 1, 1, nrows,dnul,dinarray,anynull,status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Data values after deleting column 6: '
      do ii = 1, nrows
        jj = ichar(binarray(ii))      
        write(*,1203) inskey(ii), jj,
     &       iinarray(ii), einarray(ii), dinarray(ii)
1203  format(1x,a14,2i4,2f5.0)

      end do
      call fticol(iunit, 8, 'INSERT_COL', '1E', status)

      call ftgcvs(iunit, 1, 1, 1, nrows, 'NOT DEFINED',  inskey,
     &   anynull, status)
      call ftgcvb(iunit, 4, 1, 1, nrows,bnul,binarray,anynull,status)
      call ftgcvi(iunit, 5, 1, 1, nrows,inul,iinarray,anynull,status)
      call ftgcve(iunit, 6, 1, 1, nrows, 98.,einarray,anynull,status)
      call ftgcvd(iunit, 7, 1, 1, nrows,dnul,dinarray,anynull,status)
      call ftgcvj(iunit, 8, 1, 1, nrows, 98,jinarray,anynull,status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 'Data values after inserting column 8: '
      do ii = 1, nrows
        jj = ichar(binarray(ii))
        write(*,1204) inskey(ii), jj,
     &    iinarray(ii), einarray(ii), dinarray(ii) , jinarray(ii)
1204  format(1x,a14,2i4,2f5.0,i3)
      end do
      call ftpclu(iunit, 8, 1, 1, 10, status)

      call ftgcvs(iunit, 1, 1, 1, nrows, 'NOT DEFINED',  inskey,
     &   anynull, status)
      call ftgcvb(iunit, 4,1,1,nrows,bnul,binarray,anynull,status)
      call ftgcvi(iunit, 5,1,1,nrows,inul,iinarray,anynull,status)
      call ftgcve(iunit, 6,1,1,nrows,98., einarray,anynull,status)
      call ftgcvd(iunit, 7,1,1,nrows,dnul, dinarray,anynull,status)
      call ftgcvj(iunit, 8,1,1,nrows,98, jinarray,anynull, status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)') 
     &  'Values after setting 1st 10 elements in column 8 = null: '
      do ii = 1, nrows
        jj = ichar(binarray(ii))
        write(*,1204) inskey(ii), jj,
     &      iinarray(ii), einarray(ii), dinarray(ii) , jinarray(ii)
      end do      

C        ####################################################
C        #  insert binary table following the primary array #
C        ####################################################
   
      call ftmahd(iunit,  1, hdutype, status)

      tform(1) = '15A'
      tform(2) = '1L'
      tform(3) = '16X'
      tform(4) = '1B'
      tform(5) = '1I'
      tform(6) = '1J'
      tform(7) = '1E'
      tform(8) = '1D'
      tform(9) = '1C'
      tform(10)= '1M'

      ttype(1) = 'Avalue'
      ttype(2) = 'Lvalue'
      ttype(3) = 'Xvalue'
      ttype(4) = 'Bvalue'
      ttype(5) = 'Ivalue'
      ttype(6) = 'Jvalue'
      ttype(7) = 'Evalue'
      ttype(8) = 'Dvalue'
      ttype(9) = 'Cvalue'
      ttype(10)= 'Mvalue'

      tunit(1)= ' '
      tunit(2)= 'm**2'
      tunit(3)= 'cm'
      tunit(4)= 'erg/s'
      tunit(5)= 'km/s'
      tunit(6)= ' '
      tunit(7)= ' '
      tunit(8)= ' '
      tunit(9)= ' '
      tunit(10)= ' '

      nrows = 20
      tfields = 10
      pcount = 0

      call ftibin(iunit, nrows, tfields, ttype, tform, tunit, 
     & binname, pcount, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)') 'ftibin status = ', status
      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)') 'HDU number = ', hdunum

      call ftpkyj(iunit, 'TNULL4', 77, 
     & 'value for undefined pixels', status)
      call ftpkyj(iunit, 'TNULL5', 77, 
     & 'value for undefined pixels', status)
      call ftpkyj(iunit, 'TNULL6', 77, 
     & 'value for undefined pixels', status)

      call ftpkyj(iunit, 'TSCAL4', 1000, 'scaling factor', status)
      call ftpkyj(iunit, 'TSCAL5', 1, 'scaling factor', status)
      call ftpkyj(iunit, 'TSCAL6', 100, 'scaling factor', status)

      call ftpkyj(iunit, 'TZERO4', 0, 'scaling offset', status)
      call ftpkyj(iunit, 'TZERO5', 32768, 'scaling offset', status)
      call ftpkyj(iunit, 'TZERO6', 100, 'scaling offset', status)

      call fttnul(iunit, 4, 77, status)   
C define null value for int cols 
      call fttnul(iunit, 5, 77, status)
      call fttnul(iunit, 6, 77, status)
      
C set scaling 
      scale=1000.
      zero = 0.
      call fttscl(iunit, 4, scale, zero, status)   
      scale=1.
      zero = 32768.
      call fttscl(iunit, 5, scale, zero, status)
      scale=100.
      zero = 100.
      call fttscl(iunit, 6, scale, zero, status)

C  for some reason, it is still necessary to call ftrdef at this point
      call ftrdef(iunit,status)

C        ############################
C        #  write data to columns   #
C        ############################
           
C initialize arrays of values to write to table 
 
      joutarray(1) = 0
      joutarray(2) = 1000
      joutarray(3) = 10000
      joutarray(4) = 32768
      joutarray(5) = 65535


      do ii = 4,6
      
          call ftpclj(iunit, ii, 1, 1, 5, joutarray, status) 
          if (status .eq. 412)then
              write(*,'(1x,A,I4)') 'Overflow writing to column  ', ii
              status = 0
          end if

          call ftpclu(iunit, ii, 6, 1, 1, status)  
C write null value 
      end do

      do jj = 4,6  
        call ftgcvj(iunit, jj, 1,1,6, -999,jinarray,anynull,status)
        write(*,'(1x,6I6)') (jinarray(ii), ii=1,6)
      end do

      write(*,'(1x,A)') ' '
      
C turn off scaling, and read the unscaled values 
      scale = 1.
      zero = 0.
      call fttscl(iunit, 4, scale, zero, status)   
      call fttscl(iunit, 5, scale, zero, status)
      call fttscl(iunit, 6, scale, zero, status)

      do jj = 4,6
        call ftgcvj(iunit, jj,1,1,6,-999,jinarray,anynull,status)       
            write(*,'(1x,6I6)') (jinarray(ii), ii = 1,6)
      end do

      if (status .gt. 0)go to 999

C        ######################################################
C        #  insert image extension following the binary table #
C        ######################################################
      
      bitpix = -32
      naxis = 2
      naxes(1) = 15
      naxes(2) = 25
      call ftiimg(iunit, bitpix, naxis, naxes, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)') 
     & ' Create image extension: ftiimg status = ', status
      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)') 'HDU number = ', hdunum

      do jj = 0,29
        do ii = 0,18
          imgarray(ii+1,jj+1) = (jj * 10) + ii
        end do
      end do

      call ftp2di(iunit, 1, 19, naxes(1),naxes(2),imgarray,status)
      write(*,'(1x,A)') ' '
      write(*,'(1x,A,I4)')'Wrote whole 2D array: ftp2di status =',
     &      status

      do jj =1, 30
        do ii = 1, 19
          imgarray(ii,jj) = 0
        end do        
      end do
      
      call ftg2di(iunit,1,0,19,naxes(1),naxes(2),imgarray,anynull,
     &       status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)')'Read whole 2D array: ftg2di status =',status

      do jj =1, 30
        write (*,1301)(imgarray(ii,jj),ii=1,19)
1301    format(1x,19I4)
      end do

        write(*,'(1x,A)') ' '
      

      do jj =1, 30
        do ii = 1, 19
          imgarray(ii,jj) = 0
        end do        
      end do
      
      do jj =0, 19
        do ii = 0, 9
          imgarray2(ii+1,jj+1) = (jj * (-10)) - ii
        end do        
      end do

      fpixels(1) = 5
      fpixels(2) = 5
      lpixels(1) = 14
      lpixels(2) = 14
      call ftpssi(iunit, 1, naxis, naxes, fpixels, lpixels, 
     &     imgarray2, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)')'Wrote subset 2D array: ftpssi status =',
     & status

      call ftg2di(iunit,1,0,19,naxes(1), naxes(2),imgarray,anynull,
     &        status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)')'Read whole 2D array: ftg2di status =',status

      do jj =1, 30
        write (*,1301)(imgarray(ii,jj),ii=1,19)
      end do
      write(*,'(1x,A)') ' '


      fpixels(1) = 2
      fpixels(2) = 5
      lpixels(1) = 10
      lpixels(2) = 8
      inc(1) = 2
      inc(2) = 3

      do jj = 1,30    
        do ii = 1, 19
          imgarray(ii,jj) = 0
        end do
      end do
      
      call ftgsvi(iunit, 1, naxis, naxes, fpixels, lpixels, inc, 0,
     &       imgarray, anynull, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)')
     & 'Read subset of 2D array: ftgsvi status = ',status

      write(*,'(1x,10I5)')(imgarray(ii,1),ii = 1,10)

      
C        ###########################################################
C        #  insert another image extension                         #
C        #  copy the image extension to primary array of tmp file. #
C        #  then delete the tmp file, and the image extension      #
C        ###########################################################
      
      bitpix = 16
      naxis = 2
      naxes(1) = 15
      naxes(2) = 25
      call ftiimg(iunit, bitpix, naxis, naxes, status)
      write(*,'(1x,A)') ' '
      write(*,'(1x,A,I4)')'Create image extension: ftiimg status =',
     &   status
      call ftrdef(iunit, status)
      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)') 'HDU number = ', hdunum


      filename = 't1q2s3v4.tmp'
      call ftinit(tmpunit, filename, 1, status)
      write(*,'(1x,A,I4)')'Create temporary file: ftinit status = ',
     & status

      call ftcopy(iunit, tmpunit, 0, status)
      write(*,'(1x,A)') 
     &  'Copy image extension to primary array of tmp file.'
      write(*,'(1x,A,I4)')'ftcopy status = ',status


      call ftgrec(tmpunit, 1, card, status)
      write(*,'(1x,A)')  card
      call ftgrec(tmpunit, 2, card, status)
      write(*,'(1x,A)')  card
      call ftgrec(tmpunit, 3, card, status)
      write(*,'(1x,A)')  card
      call ftgrec(tmpunit, 4, card, status)
      write(*,'(1x,A)')  card
      call ftgrec(tmpunit, 5, card, status)
      write(*,'(1x,A)')  card
      call ftgrec(tmpunit, 6, card, status)
      write(*,'(1x,A)')  card

      call ftdelt(tmpunit, status)
      write(*,'(1x,A,I4)')'Delete the tmp file: ftdelt status =',status
      call ftdhdu(iunit, hdutype, status)
      write(*,'(1x,A,2I4)')
     &  'Delete the image extension hdutype, status =',
     &         hdutype, status
      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)') 'HDU number = ', hdunum

      
C        ###########################################################
C        #  append bintable extension with variable length columns #
C        ###########################################################
      
      call ftcrhd(iunit, status)
      write(*,'(1x,A,I4)') 'ftcrhd status = ', status

      tform(1)= '1PA'
      tform(2)= '1PL'
      tform(3)= '1PB' 
C Fortran FITSIO doesn't support  1PX 
      tform(4)= '1PB'
      tform(5)= '1PI'
      tform(6)= '1PJ'
      tform(7)= '1PE'
      tform(8)= '1PD'
      tform(9)= '1PC'
      tform(10)= '1PM'

      ttype(1)= 'Avalue'
      ttype(2)= 'Lvalue'
      ttype(3)= 'Xvalue'
      ttype(4)= 'Bvalue'
      ttype(5)= 'Ivalue'
      ttype(6)= 'Jvalue'
      ttype(7)= 'Evalue'
      ttype(8)= 'Dvalue'
      ttype(9)= 'Cvalue'
      ttype(10)= 'Mvalue'

      tunit(1)= ' '
      tunit(2)= 'm**2'
      tunit(3)= 'cm'
      tunit(4)= 'erg/s'
      tunit(5)= 'km/s'
      tunit(6)= ' '
      tunit(7)= ' '
      tunit(8)= ' '
      tunit(9)= ' '
      tunit(10)= ' '

      nrows = 20
      tfields = 10
      pcount = 0

      call ftphbn(iunit, nrows, tfields, ttype, tform, 
     & tunit, binname, pcount, status)
      write(*,'(1x,A,I4)')'Variable length arrays: ftphbn status =',
     & status
      call ftpkyj(iunit, 'TNULL4', 88, 'value for undefined pixels',
     & status)
      call ftpkyj(iunit, 'TNULL5', 88, 'value for undefined pixels',
     & status)
      call ftpkyj(iunit, 'TNULL6', 88, 'value for undefined pixels',
     & status)

C        ############################
C        #  write data to columns   #
C        ############################
            
C initialize arrays of values to write to table 
      iskey='abcdefghijklmnopqrst'

      do ii = 1, 20
      
          boutarray(ii) = char(ii)
          ioutarray(ii) = ii
          joutarray(ii) = ii
          eoutarray(ii) = ii
          doutarray(ii) = ii
      end do

      larray(1) = .false.
      larray(2) = .true.
      larray(3) = .false.
      larray(4) = .false.
      larray(5) = .true.
      larray(6) = .true.
      larray(7) = .false.
      larray(8) = .false.
      larray(9) = .false.
      larray(10) = .true.
      larray(11) = .true.
      larray(12) = .true.
      larray(13) = .false.
      larray(14) = .false.
      larray(15) = .false.
      larray(16) = .false.
      larray(17) = .true.
      larray(18) = .true.
      larray(19) = .true.
      larray(20) = .true.

C      inskey(1) = iskey(1:1)
      inskey(1) = ' '

        call ftpcls(iunit, 1, 1, 1, 1, inskey, status)  
C write string values 
        call ftpcll(iunit, 2, 1, 1, 1, larray, status)  
C write logicals 
        call ftpclx(iunit, 3, 1, 1, 1, larray, status)  
C write bits 
        call ftpclb(iunit, 4, 1, 1, 1, boutarray, status)
        call ftpcli(iunit, 5, 1, 1, 1, ioutarray, status) 
        call ftpclj(iunit, 6, 1, 1, 1, joutarray, status) 
        call ftpcle(iunit, 7, 1, 1, 1, eoutarray, status)
        call ftpcld(iunit, 8, 1, 1, 1, doutarray, status)

      do ii = 2, 20   
C loop over rows 1 - 20 
      
        inskey(1) =  iskey(1:ii)
        call ftpcls(iunit, 1, ii, 1, ii, inskey, status)  
C write string values 

        call ftpcll(iunit, 2, ii, 1, ii, larray, status)  
C write logicals 
        call ftpclu(iunit, 2, ii, ii-1, 1, status)

        call ftpclx(iunit, 3, ii, 1, ii, larray, status)  
C write bits 

        call ftpclb(iunit, 4, ii, 1, ii, boutarray, status)
        call ftpclu(iunit, 4, ii, ii-1, 1, status)

        call ftpcli(iunit, 5, ii, 1, ii, ioutarray, status) 
        call ftpclu(iunit, 5, ii, ii-1, 1, status)

        call ftpclj(iunit, 6, ii, 1, ii, joutarray, status) 
        call ftpclu(iunit, 6, ii, ii-1, 1, status)

        call ftpcle(iunit, 7, ii, 1, ii, eoutarray, status)
        call ftpclu(iunit, 7, ii, ii-1, 1, status)

        call ftpcld(iunit, 8, ii, 1, ii, doutarray, status)
        call ftpclu(iunit, 8, ii, ii-1, 1, status)
      end do

C     it is no longer necessary to update the PCOUNT keyword;
C     FITSIO now does this automatically when the HDU is closed.
C     call ftmkyj(iunit,'PCOUNT',4446, '&',status)
      write(*,'(1x,A,I4)') 'ftpcl_ status = ', status

C        #################################
C        #  close then reopen this HDU   #
C        #################################

       call ftmrhd(iunit, -1, hdutype, status)
       call ftmrhd(iunit,  1, hdutype, status)

C        #############################
C        #  read data from columns   #
C        #############################
      

      call ftgkyj(iunit, 'PCOUNT', pcount, comm, status)
      write(*,'(1x,A,I4)') 'PCOUNT = ', pcount
      
C initialize the variables to be read 
      inskey(1) =' '
      iskey = ' '

      do jj = 1, ii
          larray(jj) = .false.
          boutarray(jj) = char(0)
          ioutarray(jj) = 0
          joutarray(jj) = 0
          eoutarray(jj) = 0
          doutarray(jj) = 0
      end do      

      call ftghdn(iunit, hdunum)
      write(*,'(1x,A,I4)') 'HDU number = ', hdunum

      do ii = 1, 20   
C loop over rows 1 - 20 
      
        do jj = 1, ii
          larray(jj) = .false.
          boutarray(jj) = char(0)
          ioutarray(jj) = 0
          joutarray(jj) = 0
          eoutarray(jj) = 0
          doutarray(jj) = 0
        end do      

        call ftgcvs(iunit, 1, ii, 1,1,iskey,inskey,anynull,status)
        write(*,'(1x,2A,I4)') 'A  ', inskey(1), status

        call ftgcl( iunit, 2, ii, 1, ii, larray, status) 
        write(*,1400)'L',status,(larray(jj),jj=1,ii)
1400    format(1x,a1,i3,20l3)
1401    format(1x,a1,21i3)

        call ftgcx(iunit, 3, ii, 1, ii, larray, status)
        write(*,1400)'X',status,(larray(jj),jj=1,ii)

        bnul = char(99)
        call ftgcvb(iunit, 4, ii, 1,ii,bnul,boutarray,anynull,status)
        do jj = 1,ii
          jinarray(jj) = ichar(boutarray(jj))
        end do
        write(*,1401)'B',(jinarray(jj),jj=1,ii),status

        inul = 99
        call ftgcvi(iunit, 5, ii, 1,ii,inul,ioutarray,anynull,status)
        write(*,1401)'I',(ioutarray(jj),jj=1,ii),status

        call ftgcvj(iunit, 6, ii, 1, ii,99,joutarray,anynull,status)
        write(*,1401)'J',(joutarray(jj),jj=1,ii),status

        call ftgcve(iunit, 7, ii, 1,ii,99.,eoutarray,anynull,status)
        estatus=status
        write(*,1402)'E',(eoutarray(jj),jj=1,ii),estatus
1402    format(1x,a1,1x,21f3.0)

        dnul = 99.
        call ftgcvd(iunit, 8, ii,1,ii,dnul,doutarray,anynull,status)
        estatus=status
        write(*,1402)'D',(doutarray(jj),jj=1,ii),estatus

        call ftgdes(iunit, 8, ii, repeat, offset, status)
        write(*,'(1x,A,2I5)')'Column 8 repeat and offset =',
     &       repeat,offset
      end do

C        #####################################
C        #  create another image extension   #
C        #####################################
      

      bitpix = 32
      naxis = 2
      naxes(1) = 10
      naxes(2) = 2
      npixels = 20
 
      call ftiimg(iunit, bitpix, naxis, naxes, status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)')'Create image extension: ftiimg status =',
     &       status
      
C initialize arrays of values to write to primary array 
      do ii = 1, npixels
          boutarray(ii) = char(ii * 2 -2)
          ioutarray(ii) = ii * 2 -2
          joutarray(ii) = ii * 2 -2
          koutarray(ii) = ii * 2 -2
          eoutarray(ii) = ii * 2 -2
          doutarray(ii) = ii * 2 -2
      end do      

C write a few pixels with each datatype 
      call ftpprb(iunit, 1, 1,  2, boutarray(1),  status)
      call ftppri(iunit, 1, 3,  2, ioutarray(3),  status)
      call ftpprj(iunit, 1, 5,  2, koutarray(5),  status)
      call ftppri(iunit, 1, 7,  2, ioutarray(7),  status)
      call ftpprj(iunit, 1, 9,  2, joutarray(9),  status)
      call ftppre(iunit, 1, 11, 2, eoutarray(11), status)
      call ftpprd(iunit, 1, 13, 2, doutarray(13), status)
      write(*,'(1x,A,I4)') 'ftppr status = ', status

      
C read back the pixels with each datatype 
      bnul = char(0)
      inul = 0
      knul = 0
      jnul = 0
      enul = 0.
      dnul = 0.

      call ftgpvb(iunit, 1,  1,  14, bnul, binarray, anynull, status)
      call ftgpvi(iunit, 1,  1,  14, inul, iinarray, anynull, status)
      call ftgpvj(iunit, 1,  1,  14, knul, kinarray, anynull, status)
      call ftgpvj(iunit, 1,  1,  14, jnul, jinarray, anynull, status)
      call ftgpve(iunit, 1,  1,  14, enul, einarray, anynull, status)
      call ftgpvd(iunit, 1,  1,  14, dnul, dinarray, anynull, status)

      write(*,'(1x,A)')' '
      write(*,'(1x,A)')
     &   'Image values written with ftppr and read with ftgpv:'
      npixels = 14
      do jj = 1,ii
          joutarray(jj) = ichar(binarray(jj))
      end do

      write(*,1501)(joutarray(ii),ii=1,npixels),anynull,'(byte)'
1501  format(1x,14i3,l3,1x,a)
      write(*,1501)(iinarray(ii),ii=1,npixels),anynull,'(short)'
      write(*,1501)(kinarray(ii),ii=1,npixels),anynull,'(int)'
      write(*,1501)(jinarray(ii),ii=1,npixels),anynull,'(long)'
      write(*,1502)(einarray(ii),ii=1,npixels),anynull,'(float)'
      write(*,1502)(dinarray(ii),ii=1,npixels),anynull,'(double)'
1502  format(2x,14f3.0,l2,1x,a)

C      ##########################################
C      #  test world coordinate system routines #
C      ##########################################

      xrval = 45.83D+00
      yrval =  63.57D+00
      xrpix =  256.D+00
      yrpix =  257.D+00
      xinc =   -.00277777D+00
      yinc =   .00277777D+00

C     write the WCS keywords 
C     use example values from the latest WCS document 
      call ftpkyd(iunit, 'CRVAL1', xrval, 10, 'comment', status)
      call ftpkyd(iunit, 'CRVAL2', yrval, 10, 'comment', status)
      call ftpkyd(iunit, 'CRPIX1', xrpix, 10, 'comment', status)
      call ftpkyd(iunit, 'CRPIX2', yrpix, 10, 'comment', status)
      call ftpkyd(iunit, 'CDELT1', xinc, 10, 'comment', status)
      call ftpkyd(iunit, 'CDELT2', yinc, 10, 'comment', status)
C     call ftpkyd(iunit, 'CROTA2', rot, 10, 'comment', status) 
      call ftpkys(iunit, 'CTYPE1', xctype, 'comment', status)
      call ftpkys(iunit, 'CTYPE2', yctype, 'comment', status)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4)')'Wrote WCS keywords status =', status

C     reset value, to make sure they are reread correctly
      xrval =  0.D+00
      yrval =  0.D+00
      xrpix =  0.D+00
      yrpix =  0.D+00
      xinc =   0.D+00
      yinc =   0.D+00
      rot =    67.D+00

      call ftgics(iunit, xrval, yrval, xrpix,
     &      yrpix, xinc, yinc, rot, ctype, status)
      write(*,'(1x,A,I4)')'Read WCS keywords with ftgics status =',
     &  status

      xpix = 0.5D+00
      ypix = 0.5D+00

      call ftwldp(xpix,ypix,xrval,yrval,xrpix,yrpix,xinc,yinc,
     &     rot,ctype, xpos, ypos,status)

      write(*,'(1x,A,2f8.3)')'  CRVAL1, CRVAL2 =', xrval,yrval
      write(*,'(1x,A,2f8.3)')'  CRPIX1, CRPIX2 =', xrpix,yrpix
      write(*,'(1x,A,2f12.8)')'  CDELT1, CDELT2 =', xinc,yinc
      write(*,'(1x,A,f8.3,2A)')'  Rotation =',rot,' CTYPE =',ctype
      write(*,'(1x,A,I4)')'Calculated sky coord. with ftwldp status =',
     &   status
      write(*,6501)xpix,ypix,xpos,ypos
6501  format('  Pixels (',f10.6,f10.6,') --> (',f10.6,f10.6,') Sky')

      call ftxypx(xpos,ypos,xrval,yrval,xrpix,yrpix,xinc,yinc,
     &     rot,ctype, xpix, ypix,status)
      write(*,'(1x,A,I4)')
     & 'Calculated pixel coord. with ftxypx status =', status
      write(*,6502)xpos,ypos,xpix,ypix
6502  format('  Sky (',f10.6,f10.6,') --> (',f10.6,f10.6,') Pixels')

     
C        ######################################
C        #  append another ASCII table        #
C        ######################################
      

      tform(1)= 'A15'
      tform(2)= 'I11'
      tform(3)= 'F15.6'
      tform(4)= 'E13.5'
      tform(5)= 'D22.14'

      tbcol(1)= 1
      tbcol(2)= 17
      tbcol(3)= 29
      tbcol(4)= 45
      tbcol(5)= 59
      rowlen = 80

      ttype(1)= 'Name'
      ttype(2)= 'Ivalue'
      ttype(3)= 'Fvalue'
      ttype(4)= 'Evalue'
      ttype(5)= 'Dvalue'

      tunit(1)= ' '
      tunit(2)= 'm**2'
      tunit(3)= 'cm'
      tunit(4)= 'erg/s'
      tunit(5)= 'km/s'

      nrows = 11
      tfields = 5
      tblname = 'new_table'

      call ftitab(iunit, rowlen, nrows, tfields, ttype, tbcol, 
     & tform, tunit, tblname, status)
      write(*,'(1x,A)') ' '
      write(*,'(1x,A,I4)') 'ftitab status = ', status

      call ftpcls(iunit, 1, 1, 1, 3, onskey, status)  
C write string values 

C initialize arrays of values to write to primary array 
      
      do ii = 1,npixels
          boutarray(ii) = char(ii * 3 -3)
          ioutarray(ii) = ii * 3 -3
          joutarray(ii) = ii * 3 -3
          koutarray(ii) = ii * 3 -3
          eoutarray(ii) = ii * 3 -3
          doutarray(ii) = ii * 3 -3
      end do

      do ii = 2,5 
C loop over cols 2 - 5 
      
          call ftpclb(iunit,  ii, 1, 1, 2, boutarray,  status) 
          call ftpcli(iunit,  ii, 3, 1, 2,ioutarray(3),status)
          call ftpclj(iunit,  ii, 5, 1, 2,joutarray(5),status)
          call ftpcle(iunit,  ii, 7, 1, 2,eoutarray(7),status)
          call ftpcld(iunit,  ii, 9, 1, 2,doutarray(9),status)
      end do
      write(*,'(1x,A,I4)') 'ftpcl status = ', status
      
C read back the pixels with each datatype 
      call ftgcvb(iunit,   2, 1, 1, 10, bnul, binarray,anynull,
     & status)
      call ftgcvi(iunit,  2, 1, 1, 10, inul, iinarray,anynull,
     & status)
      call ftgcvj(iunit,    3, 1, 1, 10, knul, kinarray,anynull,
     & status)
      call ftgcvj(iunit,    3, 1, 1, 10, jnul, jinarray,anynull,
     & status)
      call ftgcve(iunit,   4, 1, 1, 10, enul, einarray,anynull,
     & status)
      call ftgcvd(iunit, 5, 1, 1, 10, dnul, dinarray,anynull,
     & status)

      write(*,'(1x,A)') 
     &'Column values written with ftpcl and read with ftgcl: '
      npixels = 10
      do ii = 1,npixels
         joutarray(ii) = ichar(binarray(ii))
      end do
      write(*,1601)(joutarray(ii),ii = 1, npixels),anynull,'(byte) '
      write(*,1601)(iinarray(ii),ii = 1, npixels),anynull,'(short) '
      write(*,1601)(kinarray(ii),ii = 1, npixels),anynull,'(int) '
      write(*,1601)(jinarray(ii),ii = 1, npixels),anynull,'(long) '
      write(*,1602)(einarray(ii),ii = 1, npixels),anynull,'(float) '
      write(*,1602)(dinarray(ii),ii = 1, npixels),anynull,'(double) '
1601  format(1x,10i3,l3,1x,a)
1602  format(2x,10f3.0,l2,1x,a)
      
C        ###########################################################
C        #  perform stress test by cycling thru all the extensions #
C        ###########################################################
      write(*,'(1x,A)')' '
      write(*,'(1x,A)')'Repeatedly move to the 1st 4 HDUs of the file: '

      do ii = 1,10
        call ftmahd(iunit,  1, hdutype, status)
        call ftghdn(iunit, hdunum)
        call ftmrhd(iunit,  1, hdutype, status)
        call ftghdn(iunit, hdunum)
        call ftmrhd(iunit,  1, hdutype, status)
        call ftghdn(iunit, hdunum)
        call ftmrhd(iunit,  1, hdutype, status)
        call ftghdn(iunit, hdunum)
        call ftmrhd(iunit, -1, hdutype, status)
        call ftghdn(iunit, hdunum)
        if (status .gt. 0) go to 999
      end do
      
      write(*,'(1x,A)') ' '

      checksum = 1234567890.D+00
      call ftesum(checksum, .false., asciisum)
      write(*,'(1x,A,F13.1,2A)')'Encode checksum: ',checksum,' -> ',
     &  asciisum
      checksum = 0
      call ftdsum(asciisum, 0, checksum)
      write(*,'(1x,3A,F13.1)') 'Decode checksum: ',asciisum,' -> ',
     & checksum

      call ftpcks(iunit, status)

C         don't print the CHECKSUM value because it is different every day
C         because the current date is in the comment field.

         call ftgcrd(iunit, 'CHECKSUM', card, status)
C         write(*,'(1x,A)') card

      call ftgcrd(iunit, 'DATASUM', card, status)
      write(*,'(1x,A)') card(1:22)

      call ftgcks(iunit, datsum, checksum, status)
      write(*,'(1x,A,F13.1,I4)') 'ftgcks data checksum, status = ',
     &         datsum, status

      call ftvcks(iunit, datastatus, hdustatus, status) 
      write(*,'(1x,A,3I4)')'ftvcks datastatus, hdustatus, status =  ',
     &          datastatus, hdustatus, status
 
      call ftprec(iunit,
     & 'new_key = ''written by fxprec'' / to change checksum',status)
      call ftucks(iunit, status)
      write(*,'(1x,A,I4)') 'ftupck status = ', status

      call ftgcrd(iunit, 'DATASUM', card, status)
      write(*,'(1x,A)') card(1:22)
      call ftvcks(iunit, datastatus, hdustatus, status) 
      write(*,'(1x,A,3I4)') 'ftvcks datastatus, hdustatus, status =  ',
     &          datastatus, hdustatus, status
 
C        delete the checksum keywords, so that the FITS file is always
C        the same, regardless of the date of when testprog is run.
      
      call ftdkey(iunit, 'CHECKSUM', status)
      call ftdkey(iunit, 'DATASUM',  status)


C        ############################
C        #  close file and quit     #
C        ############################
      

999   continue  
C jump here on error 

      call ftclos(iunit, status) 
      write(*,'(1x,A,I4)') 'ftclos status = ', status
      write(*,'(1x,A)')' '

      write(*,'(1x,A)')
     &  'Normally, there should be 8 error messages on the'
      write(*,'(1x,A)') 'stack all regarding ''numerical overflows'':'

      call ftgmsg(errmsg)
      nmsg = 0

998   continue
      if (errmsg .ne. ' ')then      
          write(*,'(1x,A)') errmsg
          nmsg = nmsg + 1
          call ftgmsg(errmsg)
          go to 998
      end if

      if (nmsg .ne. 8)write(*,'(1x,A)')
     & ' WARNING: Did not find the expected 8 error messages!'

      call ftgerr(status, errmsg)
      write(*,'(1x,A)')' '
      write(*,'(1x,A,I4,2A)') 'Status =', status,': ', errmsg(1:50)
      end
healpy-1.10.3/cfitsio/testf77.out0000664000175000017500000010122313010375005017013 0ustar  zoncazonca00000000000000 FITSIO TESTPROG
  
 Try opening then closing a nonexistent file: 
   ftopen iunit, status (expect an error) =  15 104
   ftclos status =  104
  
 ftinit create new file status =    0
  
 test writing of long string keywords: 
 123456789012345678901234567890123456789012345678901234567890123456789012345   
 '12345678901234567890123456789012345678901234567890123456789012345678'        
 1234567890123456789012345678901234567890123456789012345678901234'6789012345   
 '1234567890123456789012345678901234567890123456789012345678901234''67'        
 1234567890123456789012345678901234567890123456789012345678901234''789012345   
 '1234567890123456789012345678901234567890123456789012345678901234'''''        
 1234567890123456789012345678901234567890123456789012345678901234567'9012345   
 '1234567890123456789012345678901234567890123456789012345678901234567'         
 Wrote all Keywords successfully 
 ftflus status =    0
  
 HDU number =    1
 Values read back from primary array (99 = null pixel)
 The 1st, and every 4th pixel should be undefined: 
  99  2  3 99  5  6  7 99  9 10 11 99 13 14 15 99 17 18 19 99  T (ftgpvb) 
  99  2  3 99  5  6  7 99  9 10 11 99 13 14 15 99 17 18 19 99  T (ftgpvi) 
  99  2  3 99  5  6  7 99  9 10 11 99 13 14 15 99 17 18 19 99  T (ftgpvj) 
  99. 2. 3.99. 5. 6. 7.99. 9.10.11.99.13.14.15.99.17.18.19.99. T (ftgpve) 
  99. 2. 3.99. 5. 6. 7.99. 9.10.11.99.13.14.15.99.17.18.19.99. T (ftgpvd) 
   0  2  3  0  5  6  7  0  9 10 11  0 13 14 15  0 17 18 19  0  T (ftgpfb)
   0  2  3  0  5  6  7  0  9 10 11  0 13 14 15  0 17 18 19  0  T (ftgpfi)
   0  2  3  0  5  6  7  0  9 10 11  0 13 14 15  0 17 18 19  0  T (ftgpfj)
   0. 2. 3. 0. 5. 6. 7. 0. 9.10.11. 0.13.14.15. 0.17.18.19. 0. T (ftgpfe)
   0. 2. 3. 0. 5. 6. 7. 0. 9.10.11. 0.13.14.15. 0.17.18.19. 0. T (ftgpfd)
  
 Closed then reopened the FITS file 10 times.
  
 HDU number =    1
 Read back keywords: 
 simple, bitpix, naxis, naxes =    T  32   2  10   2
   pcount, gcount, extend =    0   1   T
 KEY_PREC= 'This keyword was written by fxprec' / comment goes here            
 KEY_PREC 'This keyword was written by fxprec comment goes here   
 KEY_PREC= 'This keyword was written by fxprec' / comment goes here            
 KY_PKNS1 :'first string' :fxpkns comment  
 KEY_PKYS :value_string         :fxpkys comment     0
 KEY_PKYL :   T:fxpkyl comment     0
 KEY_PKYJ :  11:fxpkyj comment     0
 KEY_PKYE :    11.00000:fxpkyj comment     0
 KEY_PKYD :    11.00000:fxpkyj comment     0
 KEY_PKYS :value_string         :fxpkys comment     0
 KEY_PKYL :   T:fxpkyl comment     0
 KEY_PKYJ :  11:fxpkyj comment     0
 KEY_PKYE :    13.13131:fxpkye comment     0
 KEY_PKYD :    15.15152:fxpkyd comment     0
 KEY_PKYF :    12.12121:fxpkyf comment     0
 KEY_PKYE :    13.13131:fxpkye comment     0
 KEY_PKYG : 14.141414141414:fxpkyg comment     0
 KEY_PKYD : 15.151515151515:fxpkyd comment     0
 KEY_PKYT  :  12345678:0.12345678901235fxpkyt comment     0
 KEY_PKYJ :  11:[km/s/Mpc] fxpkyj comment                0
 keyword unit=km/s/Mpc          
 KEY_PKYJ :  11:fxpkyj comment                           0
 keyword unit=                  
 KEY_PKYJ :  11:[feet/second/second] fxpkyj comment      0
 keyword unit=feet/second/second
 KEY_PKLS long string value = This is a very long string value that is continued
  over more than one keyword.                                          
 header contains   61 keywords; located at keyword   23
 ftgkns: first string  second string               
 ftgknl:    T   F   T
 ftgknj:   11  12  13
 ftgkne:   13.13131  14.14141  15.15152
 ftgknd:   15.15152  16.16162  17.17172
  
 Before deleting the HISTORY and DATE keywords...
 COMMENT 
 HISTORY 
 DATE    
 KY_PKNS1
  
 After deleting the keywords... 
 COMMENT This keyword was written by fxpcom.                                   
 KY_PKNS1= 'first string'       / fxpkns comment                               
  
 After inserting the keywords... 
 COMMENT   continued over multiple keywords.  The HEASARC convention uses the &
 KY_IREC = 'This keyword inserted by fxirec'                                   
 KY_IKYS = 'insert_value_string' / ikys comment                                
 KY_IKYJ =                   49 / ikyj comment                                 
 KY_IKYL =                    T / ikyl comment                                 
 KY_IKYE =           1.2346E+01 / ikye comment                                 
 KY_IKYD = 1.23456789012346E+01 / ikyd comment                                 
 KY_IKYF =              12.3456 / ikyf comment                                 
 KY_IKYG =     12.3456789012346 / ikyg comment                                 
 COMMENT   character at the end of each substring which is then continued      
  
 After modifying the keywords... 
 COMMENT   This keyword was modified by fxmrec                                 
 KY_MREC = 'This keyword was modified by fxmcrd'                               
 NEWIKYS = 'modified_string'    / ikys comment                                 
 KY_IKYJ =                   50 / This is a modified comment                   
 KY_IKYL =                    F / ikyl comment                                 
 KY_IKYE =          -1.2346E+01 / ikye comment                                 
 KY_IKYD = -1.23456789012346E+01 / modified comment                            
 KY_IKYF =             -12.3456 / ikyf comment                                 
 KY_IKYG =    -12.3456789012346 / ikyg comment                                 
 COMMENT   character at the end of each substring which is then continued      
  
 After updating the keywords... 
 COMMENT   This keyword was modified by fxmrec                                 
 KY_UCRD = 'This keyword was updated by fxucrd'                                
 NEWIKYS = 'updated_string'     / ikys comment                                 
 KY_IKYJ =                   51 / This is a modified comment                   
 KY_IKYL =                    T / ikyl comment                                 
 KY_IKYE =          -1.3346E+01 / ikye comment                                 
 KY_IKYD = -1.33456789012346E+01 / modified comment                            
 KY_IKYF =             -13.3456 / ikyf comment                                 
 KY_IKYG =    -13.3456789012346 / ikyg comment                                 
 COMMENT   character at the end of each substring which is then continued      
  
 Keywords found using wildcard search (should be 9)...
 KEY_PKYS= 'value_string'       / fxpkys comment                               
 KEY_PKYL=                    T / fxpkyl comment                               
 KEY_PKYJ=                   11 / [feet/second/second] fxpkyj comment          
 KEY_PKYF=             12.12121 / fxpkyf comment                               
 KEY_PKYE=         1.313131E+01 / fxpkye comment                               
 KEY_PKYG=    14.14141414141414 / fxpkyg comment                               
 KEY_PKYD= 1.51515151515152E+01 / fxpkyd comment                               
 NEWIKYS = 'updated_string'     / ikys comment                                 
 KEY_PKYT= 12345678.1234567890123456 / fxpkyt comment                          
  
 ftibin status =    0
 HDU number =    2
 header contains   33 keywords located at keyword    1
 header contains   33 keywords with room for   74 more
 TDIM3 = (1,2,8)                 3   1   2   8
 ftpcl_ status =    0
  
 Find the column numbers a returned status value of 237 is
 expected and indicates that more than one column name matches
 the input column name template.  Status = 219 indicates that
 there was no matching column name.
 Column Xvalue is number   3 status =   0
 Column Avalue is number   1 status =  237
 Column Lvalue is number   2 status =  237
 Column Xvalue is number   3 status =  237
 Column Bvalue is number   4 status =  237
 Column Ivalue is number   5 status =  237
 Column Jvalue is number   6 status =  237
 Column Evalue is number   7 status =  237
 Column Dvalue is number   8 status =  237
 Column Cvalue is number   9 status =  237
 Column Mvalue is number  10 status =  237
 Column        is number   0 status =  219
  
 Information about each column: 
 15A  16  15  15 Avalue       A      1.00    0.00  1234554321        
 1L   14   1   1 Lvalue m**2  L      1.00    0.00  1234554321        
 16X   1  16   1 Xvalue cm    X      1.00    0.00  1234554321        
 1B   11   1   1 Bvalue erg/s B      1.00    0.00          99        
 1I   21   1   2 Ivalue km/s  I      1.00    0.00          99        
 1J   41   1   4 Jvalue       J      1.00    0.00          99        
 1E   42   1   4 Evalue       E      1.00    0.00  1234554321        
 1D   82   1   8 Dvalue       D      1.00    0.00  1234554321        
 1C   83   1   8 Cvalue       C      1.00    0.00  1234554321        
 1M  163   1  16 Mvalue       M      1.00    0.00  1234554321        
  
 ftitab status =    0
 HDU number =    2
 ftpcl_ status =    0
  
 ASCII table: rowlen, nrows, tfields, extname: 76 11  5 Test-ASCII     
 Name      1 A15           
 Ivalue   17 I10    m**2   
 Fvalue   28 F14.6  cm     
 Evalue   43 E12.5  erg/s  
 Dvalue   56 D21.14 km/s   
  
 Data values read from ASCII table: 
 first string     1  1  1  1. 1.
 second string    2  2  2  2. 2.
                  3  3  3  3. 3.
 UNDEFINED        4  4  4  4. 4.
                  5  5  5  5. 5.
                  6  6  6  6. 6.
                  7  7  7  7. 7.
                  8  8  8  8. 8.
                  9  9  9  9. 9.
                 10 10 10 10.10.
                 99 99 99 99.99.
  
       1       1.000000  1.00000E+00  1.00000000000000E+00second string        
  
 Column name is number   1 status =    0
 Column Ivalue is number   2 status =  237
 Column Fvalue is number   3 status =  237
 Column Evalue is number   4 status =  237
 Column Dvalue is number   5 status =  237
 Column        is number   0 status =  219
 A15      16   1  15 Name     1            1.00      0.00 null1   
 I10      41   1  10 Ivalue  17 m**2       1.00      0.00 null2   
 F14.6    82   1  14 Fvalue  28 cm         1.00      0.00 null3   
 E12.5    42   1  12 Evalue  43 erg/s      1.00      0.00 null4   
 D21.14   82   1  21 Dvalue  56 km/s       1.00      0.00 null5   
  
  
 Data values after inserting 3 rows after row 2:
 first string     1  1  1  1. 1.
 second string    2  2  2  2. 2.
                  0  0  0  0. 0.
                  0  0  0  0. 0.
                  0  0  0  0. 0.
                  3  3  3  3. 3.
 UNDEFINED        4  4  4  4. 4.
                  5  5  5  5. 5.
                  6  6  6  6. 6.
                  7  7  7  7. 7.
                  8  8  8  8. 8.
                  9  9  9  9. 9.
                 10 10 10 10.10.
                 99 99 99 99.99.
  
 Data values after deleting 2 rows at row 10: 
 first string     1  1  1  1. 1.
 second string    2  2  2  2. 2.
                  0  0  0  0. 0.
                  0  0  0  0. 0.
                  0  0  0  0. 0.
                  3  3  3  3. 3.
 UNDEFINED        4  4  4  4. 4.
                  5  5  5  5. 5.
                  6  6  6  6. 6.
                  9  9  9  9. 9.
                 10 10 10 10.10.
                 99 99 99 99.99.
  
 Data values after deleting column 3: 
 first string     1  1  1. 1.
 second string    2  2  2. 2.
                  0  0  0. 0.
                  0  0  0. 0.
                  0  0  0. 0.
                  3  3  3. 3.
 UNDEFINED        4  4  4. 4.
                  5  5  5. 5.
                  6  6  6. 6.
                  9  9  9. 9.
                 10 10 10.10.
                 99 99 99.99.
  
  Data values after inserting column 5: 
 first string     1  1  1. 1. 0
 second string    2  2  2. 2. 0
                  0  0  0. 0. 0
                  0  0  0. 0. 0
                  0  0  0. 0. 0
                  3  3  3. 3. 0
 UNDEFINED        4  4  4. 4. 0
                  5  5  5. 5. 0
                  6  6  6. 6. 0
                  9  9  9. 9. 0
                 10 10 10.10. 0
                 99 99 99.99. 0
 HDU number =    3
  
 Moved to binary table
 header contains   37 keywords with room for   70 more 
  
 Binary table: nrows, tfields, extname, pcount:  21  10Test-BINTABLE     0
 Avalue         15A                           
 Lvalue         1L             m**2           
 Xvalue         16X            cm             
 Bvalue         1B             erg/s          
 Ivalue         1I             km/s           
 Jvalue         1J                            
 Evalue         1E                            
 Dvalue         1D                            
 Cvalue         1C                            
 Mvalue         1M                            
  
 Data values read from binary table: 
  Bit column (X) data values:   
 FTFFTTFF FTTTFFFF TTTTFFFF FTTTTTFF FFFFFFFF
   
 null string column value (should be blank):                              
  
 Read columns with ftgcv_: 
 first string     F  76   1   1   1   1.   1.   1.  -2.   1.  -2.
 second string    T 112   2   2   2   2.   2.   3.  -4.   3.  -4.
                  F 240   3   3   3   3.   3.   5.  -6.   5.  -6.
 NOT DEFINED      F 124   0  -4  -4  -4.  -4.   7.  -8.   7.  -8.
 NOT DEFINED      T   0   5   5   5   5.   5.   9. -10.   9. -10.
 NOT DEFINED      T   0   0  -6  -6  -6.  -6.  11. -12.  11. -12.
 NOT DEFINED      F   0   7   7   7   7.   7.  13. -14.  13. -14.
 NOT DEFINED      F   0   0  -8  -8  -8.  -8.  15. -16.  15. -16.
 NOT DEFINED      F   0   9   9   9   9.   9.  17. -18.  17. -18.
 NOT DEFINED      T   0   0 -10 -10 -10. -10.  19. -20.  19. -20.
 NOT DEFINED      F   0  98  98  98  98.  98.   0.   0.   0.   0.
 NOT DEFINED      T   0  12  12  12  12.  12.   0.   0.   0.   0.
 NOT DEFINED      F   0  98  98  98  98.  98.   0.   0.   0.   0.
 NOT DEFINED      F   0   0 -14 -14 -14. -14.   0.   0.   0.   0.
 NOT DEFINED      F   0  98  98  98  98.  98.   0.   0.   0.   0.
 NOT DEFINED      F   0   0 -16 -16 -16. -16.   0.   0.   0.   0.
 NOT DEFINED      T   0  98  98  98  98.  98.   0.   0.   0.   0.
 NOT DEFINED      T   0   0 -18 -18 -18. -18.   0.   0.   0.   0.
 NOT DEFINED      T   0  98  98  98  98.  98.   0.   0.   0.   0.
 NOT DEFINED      T   0   0 -20 -20 -20. -20.   0.   0.   0.   0.
 NOT DEFINED      F   0  98  98  98  98.  98.   0.   0.   0.   0.
  
  Read columns with ftgcf_: 
 first string     F  76   1   1   1   1.   1.   1.  -2.   1.  -2.
 second string    T 112   2   2   2   2.   2.   3.  -4.   3.  -4.
                  F 240   3   3   3   3.   3.   5.  -6.   5.  -6.
                  F 124   0  -4  -4  -4.  -4.   7.  -8.   7.  -8.
                  T   0   5   5   5   5.   5.   9. -10.   9. -10.
                  T   0   0  -6  -6  -6.  -6.  11. -12.  11. -12.
                  F   0   7   7   7   7.   7.  13. -14.  13. -14.
                  F   0   0  -8  -8  -8.  -8.  15. -16.  15. -16.
                  F   0   9   9   9   9.   9.  17. -18.  17. -18.
                  T   0   0 -10 -10 -10. -10.  19. -20.  19. -20.
                  F   0  99  99
                  T   0  12  12
                  F   0  99  99
                  F   0   0 -14
                  F   0  99  99
                  F   0   0 -16
                  T   0  99  99
                  T   0   0 -18
                  T   0  99  99
                  T   0   0 -20
                  F   0  99  99
  
 Data values after inserting 3 rows after row 2:
 first string     1   1   1   1.   1.
 second string    2   2   2   2.   2.
 NOT DEFINED      0   0   0   0.   0.
 NOT DEFINED      0   0   0   0.   0.
 NOT DEFINED      0   0   0   0.   0.
                  3   3   3   3.   3.
 NOT DEFINED      0  -4  -4  -4.  -4.
 NOT DEFINED      5   5   5   5.   5.
 NOT DEFINED      0  -6  -6  -6.  -6.
 NOT DEFINED      7   7   7   7.   7.
 NOT DEFINED      0  -8  -8  -8.  -8.
 NOT DEFINED      9   9   9   9.   9.
 NOT DEFINED      0 -10 -10 -10. -10.
 NOT DEFINED     98  98  98  98.  98.
  
 Data values after deleting 2 rows at row 10: 
 first string     1   1   1   1.   1.
 second string    2   2   2   2.   2.
 NOT DEFINED      0   0   0   0.   0.
 NOT DEFINED      0   0   0   0.   0.
 NOT DEFINED      0   0   0   0.   0.
                  3   3   3   3.   3.
 NOT DEFINED      0  -4  -4  -4.  -4.
 NOT DEFINED      5   5   5   5.   5.
 NOT DEFINED      0  -6  -6  -6.  -6.
 NOT DEFINED      9   9   9   9.   9.
 NOT DEFINED      0 -10 -10 -10. -10.
 NOT DEFINED     98  98  98  98.  98.
  
 Data values after deleting column 6: 
 first string     1   1   1.   1.
 second string    2   2   2.   2.
 NOT DEFINED      0   0   0.   0.
 NOT DEFINED      0   0   0.   0.
 NOT DEFINED      0   0   0.   0.
                  3   3   3.   3.
 NOT DEFINED      0  -4  -4.  -4.
 NOT DEFINED      5   5   5.   5.
 NOT DEFINED      0  -6  -6.  -6.
 NOT DEFINED      9   9   9.   9.
 NOT DEFINED      0 -10 -10. -10.
 NOT DEFINED     98  98  98.  98.
  
 Data values after inserting column 8: 
 first string     1   1   1.   1.  0
 second string    2   2   2.   2.  0
 NOT DEFINED      0   0   0.   0.  0
 NOT DEFINED      0   0   0.   0.  0
 NOT DEFINED      0   0   0.   0.  0
                  3   3   3.   3.  0
 NOT DEFINED      0  -4  -4.  -4.  0
 NOT DEFINED      5   5   5.   5.  0
 NOT DEFINED      0  -6  -6.  -6.  0
 NOT DEFINED      9   9   9.   9.  0
 NOT DEFINED      0 -10 -10. -10.  0
 NOT DEFINED     98  98  98.  98.  0
  
 Values after setting 1st 10 elements in column 8 = null: 
 first string     1   1   1.   1. 98
 second string    2   2   2.   2. 98
 NOT DEFINED      0   0   0.   0. 98
 NOT DEFINED      0   0   0.   0. 98
 NOT DEFINED      0   0   0.   0. 98
                  3   3   3.   3. 98
 NOT DEFINED      0  -4  -4.  -4. 98
 NOT DEFINED      5   5   5.   5. 98
 NOT DEFINED      0  -6  -6.  -6. 98
 NOT DEFINED      9   9   9.   9. 98
 NOT DEFINED      0 -10 -10. -10.  0
 NOT DEFINED     98  98  98.  98.  0
  
 ftibin status =    0
 HDU number =    2
      0  1000 10000 33000 66000  -999
      0  1000 10000 32768 65535  -999
      0  1000 10000 32800 65500  -999
  
      0     1    10    33    66  -999
 -32768-31768-22768     0 32767  -999
     -1     9    99   327   654  -999
  
  Create image extension: ftiimg status =    0
 HDU number =    3
  
 Wrote whole 2D array: ftp2di status =   0
  
 Read whole 2D array: ftg2di status =   0
    0   1   2   3   4   5   6   7   8   9  10  11  12  13  14   0   0   0   0
   10  11  12  13  14  15  16  17  18  19  20  21  22  23  24   0   0   0   0
   20  21  22  23  24  25  26  27  28  29  30  31  32  33  34   0   0   0   0
   30  31  32  33  34  35  36  37  38  39  40  41  42  43  44   0   0   0   0
   40  41  42  43  44  45  46  47  48  49  50  51  52  53  54   0   0   0   0
   50  51  52  53  54  55  56  57  58  59  60  61  62  63  64   0   0   0   0
   60  61  62  63  64  65  66  67  68  69  70  71  72  73  74   0   0   0   0
   70  71  72  73  74  75  76  77  78  79  80  81  82  83  84   0   0   0   0
   80  81  82  83  84  85  86  87  88  89  90  91  92  93  94   0   0   0   0
   90  91  92  93  94  95  96  97  98  99 100 101 102 103 104   0   0   0   0
  100 101 102 103 104 105 106 107 108 109 110 111 112 113 114   0   0   0   0
  110 111 112 113 114 115 116 117 118 119 120 121 122 123 124   0   0   0   0
  120 121 122 123 124 125 126 127 128 129 130 131 132 133 134   0   0   0   0
  130 131 132 133 134 135 136 137 138 139 140 141 142 143 144   0   0   0   0
  140 141 142 143 144 145 146 147 148 149 150 151 152 153 154   0   0   0   0
  150 151 152 153 154 155 156 157 158 159 160 161 162 163 164   0   0   0   0
  160 161 162 163 164 165 166 167 168 169 170 171 172 173 174   0   0   0   0
  170 171 172 173 174 175 176 177 178 179 180 181 182 183 184   0   0   0   0
  180 181 182 183 184 185 186 187 188 189 190 191 192 193 194   0   0   0   0
  190 191 192 193 194 195 196 197 198 199 200 201 202 203 204   0   0   0   0
  200 201 202 203 204 205 206 207 208 209 210 211 212 213 214   0   0   0   0
  210 211 212 213 214 215 216 217 218 219 220 221 222 223 224   0   0   0   0
  220 221 222 223 224 225 226 227 228 229 230 231 232 233 234   0   0   0   0
  230 231 232 233 234 235 236 237 238 239 240 241 242 243 244   0   0   0   0
  240 241 242 243 244 245 246 247 248 249 250 251 252 253 254   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
  
  
 Wrote subset 2D array: ftpssi status =   0
  
 Read whole 2D array: ftg2di status =   0
    0   1   2   3   4   5   6   7   8   9  10  11  12  13  14   0   0   0   0
   10  11  12  13  14  15  16  17  18  19  20  21  22  23  24   0   0   0   0
   20  21  22  23  24  25  26  27  28  29  30  31  32  33  34   0   0   0   0
   30  31  32  33  34  35  36  37  38  39  40  41  42  43  44   0   0   0   0
   40  41  42  43   0  -1  -2  -3  -4  -5  -6  -7  -8  -9  54   0   0   0   0
   50  51  52  53 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19  64   0   0   0   0
   60  61  62  63 -20 -21 -22 -23 -24 -25 -26 -27 -28 -29  74   0   0   0   0
   70  71  72  73 -30 -31 -32 -33 -34 -35 -36 -37 -38 -39  84   0   0   0   0
   80  81  82  83 -40 -41 -42 -43 -44 -45 -46 -47 -48 -49  94   0   0   0   0
   90  91  92  93 -50 -51 -52 -53 -54 -55 -56 -57 -58 -59 104   0   0   0   0
  100 101 102 103 -60 -61 -62 -63 -64 -65 -66 -67 -68 -69 114   0   0   0   0
  110 111 112 113 -70 -71 -72 -73 -74 -75 -76 -77 -78 -79 124   0   0   0   0
  120 121 122 123 -80 -81 -82 -83 -84 -85 -86 -87 -88 -89 134   0   0   0   0
  130 131 132 133 -90 -91 -92 -93 -94 -95 -96 -97 -98 -99 144   0   0   0   0
  140 141 142 143 144 145 146 147 148 149 150 151 152 153 154   0   0   0   0
  150 151 152 153 154 155 156 157 158 159 160 161 162 163 164   0   0   0   0
  160 161 162 163 164 165 166 167 168 169 170 171 172 173 174   0   0   0   0
  170 171 172 173 174 175 176 177 178 179 180 181 182 183 184   0   0   0   0
  180 181 182 183 184 185 186 187 188 189 190 191 192 193 194   0   0   0   0
  190 191 192 193 194 195 196 197 198 199 200 201 202 203 204   0   0   0   0
  200 201 202 203 204 205 206 207 208 209 210 211 212 213 214   0   0   0   0
  210 211 212 213 214 215 216 217 218 219 220 221 222 223 224   0   0   0   0
  220 221 222 223 224 225 226 227 228 229 230 231 232 233 234   0   0   0   0
  230 231 232 233 234 235 236 237 238 239 240 241 242 243 244   0   0   0   0
  240 241 242 243 244 245 246 247 248 249 250 251 252 253 254   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
  
  
 Read subset of 2D array: ftgsvi status =    0
    41   43   -1   -3   -5   71   73  -31  -33  -35
  
 Create image extension: ftiimg status =   0
 HDU number =    4
 Create temporary file: ftinit status =    0
 Copy image extension to primary array of tmp file.
 ftcopy status =    0
 SIMPLE  =                    T / file does conform to FITS standard           
 BITPIX  =                   16 / number of bits per data pixel                
 NAXIS   =                    2 / number of data axes                          
 NAXIS1  =                   15 / length of data axis 1                        
 NAXIS2  =                   25 / length of data axis 2                        
 EXTEND  =                    T / FITS dataset may contain extensions          
 Delete the tmp file: ftdelt status =   0
 Delete the image extension hdutype, status =   1   0
 HDU number =    4
 ftcrhd status =    0
 Variable length arrays: ftphbn status =   0
 ftpcl_ status =    0
 PCOUNT = 4446
 HDU number =    6
 A                                   0
 L  0  F
 X  0  F
 B  1  0
 I  1  0
 J  1  0
 E  1. 0.
 D  1. 0.
 Column 8 repeat and offset =    1   14
 A  ab                               0
 L  0  F  T
 X  0  F  T
 B 99  2  0
 I 99  2  0
 J 99  2  0
 E 99. 2. 0.
 D 99. 2. 0.
 Column 8 repeat and offset =    2   49
 A  abc                              0
 L  0  F  F  F
 X  0  F  T  F
 B  1 99  3  0
 I  1 99  3  0
 J  1 99  3  0
 E  1.99. 3. 0.
 D  1.99. 3. 0.
 Column 8 repeat and offset =    3  105
 A  abcd                             0
 L  0  F  T  F  F
 X  0  F  T  F  F
 B  1  2 99  4  0
 I  1  2 99  4  0
 J  1  2 99  4  0
 E  1. 2.99. 4. 0.
 D  1. 2.99. 4. 0.
 Column 8 repeat and offset =    4  182
 A  abcde                            0
 L  0  F  T  F  F  T
 X  0  F  T  F  F  T
 B  1  2  3 99  5  0
 I  1  2  3 99  5  0
 J  1  2  3 99  5  0
 E  1. 2. 3.99. 5. 0.
 D  1. 2. 3.99. 5. 0.
 Column 8 repeat and offset =    5  280
 A  abcdef                           0
 L  0  F  T  F  F  F  T
 X  0  F  T  F  F  T  T
 B  1  2  3  4 99  6  0
 I  1  2  3  4 99  6  0
 J  1  2  3  4 99  6  0
 E  1. 2. 3. 4.99. 6. 0.
 D  1. 2. 3. 4.99. 6. 0.
 Column 8 repeat and offset =    6  399
 A  abcdefg                          0
 L  0  F  T  F  F  T  F  F
 X  0  F  T  F  F  T  T  F
 B  1  2  3  4  5 99  7  0
 I  1  2  3  4  5 99  7  0
 J  1  2  3  4  5 99  7  0
 E  1. 2. 3. 4. 5.99. 7. 0.
 D  1. 2. 3. 4. 5.99. 7. 0.
 Column 8 repeat and offset =    7  539
 A  abcdefgh                         0
 L  0  F  T  F  F  T  T  F  F
 X  0  F  T  F  F  T  T  F  F
 B  1  2  3  4  5  6 99  8  0
 I  1  2  3  4  5  6 99  8  0
 J  1  2  3  4  5  6 99  8  0
 E  1. 2. 3. 4. 5. 6.99. 8. 0.
 D  1. 2. 3. 4. 5. 6.99. 8. 0.
 Column 8 repeat and offset =    8  700
 A  abcdefghi                        0
 L  0  F  T  F  F  T  T  F  F  F
 X  0  F  T  F  F  T  T  F  F  F
 B  1  2  3  4  5  6  7 99  9  0
 I  1  2  3  4  5  6  7 99  9  0
 J  1  2  3  4  5  6  7 99  9  0
 E  1. 2. 3. 4. 5. 6. 7.99. 9. 0.
 D  1. 2. 3. 4. 5. 6. 7.99. 9. 0.
 Column 8 repeat and offset =    9  883
 A  abcdefghij                       0
 L  0  F  T  F  F  T  T  F  F  F  T
 X  0  F  T  F  F  T  T  F  F  F  T
 B  1  2  3  4  5  6  7  8 99 10  0
 I  1  2  3  4  5  6  7  8 99 10  0
 J  1  2  3  4  5  6  7  8 99 10  0
 E  1. 2. 3. 4. 5. 6. 7. 8.99.10. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8.99.10. 0.
 Column 8 repeat and offset =   10 1087
 A  abcdefghijk                      0
 L  0  F  T  F  F  T  T  F  F  F  F  T
 X  0  F  T  F  F  T  T  F  F  F  T  T
 B  1  2  3  4  5  6  7  8  9 99 11  0
 I  1  2  3  4  5  6  7  8  9 99 11  0
 J  1  2  3  4  5  6  7  8  9 99 11  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.99.11. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.99.11. 0.
 Column 8 repeat and offset =   11 1312
 A  abcdefghijkl                     0
 L  0  F  T  F  F  T  T  F  F  F  T  F  T
 X  0  F  T  F  F  T  T  F  F  F  T  T  T
 B  1  2  3  4  5  6  7  8  9 10 99 12  0
 I  1  2  3  4  5  6  7  8  9 10 99 12  0
 J  1  2  3  4  5  6  7  8  9 10 99 12  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.99.12. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.99.12. 0.
 Column 8 repeat and offset =   12 1558
 A  abcdefghijklm                    0
 L  0  F  T  F  F  T  T  F  F  F  T  T  F  F
 X  0  F  T  F  F  T  T  F  F  F  T  T  T  F
 B  1  2  3  4  5  6  7  8  9 10 11 99 13  0
 I  1  2  3  4  5  6  7  8  9 10 11 99 13  0
 J  1  2  3  4  5  6  7  8  9 10 11 99 13  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.99.13. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.99.13. 0.
 Column 8 repeat and offset =   13 1825
 A  abcdefghijklmn                   0
 L  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F
 X  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F
 B  1  2  3  4  5  6  7  8  9 10 11 12 99 14  0
 I  1  2  3  4  5  6  7  8  9 10 11 12 99 14  0
 J  1  2  3  4  5  6  7  8  9 10 11 12 99 14  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.99.14. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.99.14. 0.
 Column 8 repeat and offset =   14 2113
 A  abcdefghijklmno                  0
 L  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F
 X  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F
 B  1  2  3  4  5  6  7  8  9 10 11 12 13 99 15  0
 I  1  2  3  4  5  6  7  8  9 10 11 12 13 99 15  0
 J  1  2  3  4  5  6  7  8  9 10 11 12 13 99 15  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.99.15. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.99.15. 0.
 Column 8 repeat and offset =   15 2422
 A  abcdefghijklmnop                 0
 L  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F
 X  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F
 B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 99 16  0
 I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 99 16  0
 J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 99 16  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.99.16. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.99.16. 0.
 Column 8 repeat and offset =   16 2752
 A  abcdefghijklmnopq                0
 L  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F  T
 X  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F  T
 B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 99 17  0
 I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 99 17  0
 J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 99 17  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.15.99.17. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.15.99.17. 0.
 Column 8 repeat and offset =   17 3104
 A  abcdefghijklmnopqr               0
 L  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F  F  T
 X  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F  T  T
 B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 99 18  0
 I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 99 18  0
 J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 99 18  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.15.16.99.18. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.15.16.99.18. 0.
 Column 8 repeat and offset =   18 3477
 A  abcdefghijklmnopqrs              0
 L  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F  T  F  T
 X  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F  T  T  T
 B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 99 19  0
 I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 99 19  0
 J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 99 19  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.15.16.17.99.19. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.15.16.17.99.19. 0.
 Column 8 repeat and offset =   19 3871
 A  abcdefghijklmnopqrst             0
 L  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F  T  T  F  T
 X  0  F  T  F  F  T  T  F  F  F  T  T  T  F  F  F  F  T  T  T  T
 B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 99 20  0
 I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 99 20  0
 J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 99 20  0
 E  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.15.16.17.18.99.20. 0.
 D  1. 2. 3. 4. 5. 6. 7. 8. 9.10.11.12.13.14.15.16.17.18.99.20. 0.
 Column 8 repeat and offset =   20 4286
  
 Create image extension: ftiimg status =   0
 ftppr status =    0
  
 Image values written with ftppr and read with ftgpv:
   0  2  4  6  8 10 12 14 16 18 20 22 24 26  F (byte)
   0  2  4  6  8 10 12 14 16 18 20 22 24 26  F (short)
   0  2  4  6  8 10 12 14 16 18 20 22 24 26  F (int)
   0  2  4  6  8 10 12 14 16 18 20 22 24 26  F (long)
   0. 2. 4. 6. 8.10.12.14.16.18.20.22.24.26. F (float)
   0. 2. 4. 6. 8.10.12.14.16.18.20.22.24.26. F (double)
  
 Wrote WCS keywords status =   0
 Read WCS keywords with ftgics status =   0
   CRVAL1, CRVAL2 =  45.830  63.570
   CRPIX1, CRPIX2 = 256.000 257.000
   CDELT1, CDELT2 = -0.00277777  0.00277777
   Rotation =   0.000 CTYPE =-TAN    
 Calculated sky coord. with ftwldp status =   0
  Pixels (  0.500000  0.500000) --> ( 47.385204 62.848968) Sky
 Calculated pixel coord. with ftxypx status =   0
  Sky ( 47.385204 62.848968) --> (  0.500000  0.500000) Pixels
  
 ftitab status =    0
 ftpcl status =    0
 Column values written with ftpcl and read with ftgcl: 
   0  3  6  9 12 15 18 21 24 27  F (byte) 
   0  3  6  9 12 15 18 21 24 27  F (short) 
   0  3  6  9 12 15 18 21 24 27  F (int) 
   0  3  6  9 12 15 18 21 24 27  F (long) 
   0. 3. 6. 9.12.15.18.21.24.27. F (float) 
   0. 3. 6. 9.12.15.18.21.24.27. F (double) 
  
 Repeatedly move to the 1st 4 HDUs of the file: 
  
 Encode checksum:  1234567890.0 -> dCW2fBU0dBU0dBU0 
 Decode checksum: dCW2fBU0dBU0dBU0  ->  1234567890.0
 DATASUM = '2338390162'
 ftgcks data checksum, status =  2338390162.0   0
 ftvcks datastatus, hdustatus, status =     1   1   0
 ftupck status =    0
 DATASUM = '2338390162'
 ftvcks datastatus, hdustatus, status =     1   1   0
 ftclos status =    0
  
 Normally, there should be 8 error messages on the
 stack all regarding 'numerical overflows':
 Numerical overflow during type conversion while writing FITS data.         
 Numerical overflow during type conversion while writing FITS data.         
 Numerical overflow during type conversion while writing FITS data.         
 Numerical overflow during type conversion while writing FITS data.         
 Numerical overflow during type conversion while writing FITS data.         
 Numerical overflow during type conversion while writing FITS data.         
 Numerical overflow during type conversion while writing FITS data.         
 Numerical overflow during type conversion while writing FITS data.         
  
 Status =   0: OK - no error                                     
healpy-1.10.3/cfitsio/testf77.std0000664000175000017500000020130013010375005016773 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    2 / number of data axes                            NAXIS1  =                   10 / length of data axis 1                          NAXIS2  =                    2 / length of data axis 2                          EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H KEY_PREC= 'This keyword was written by fxprec' / comment goes here              CARD1   = '12345678901234567890123456789012345678901234567890123456789012345678'CARD2   = '1234567890123456789012345678901234567890123456789012345678901234''67'CARD3   = '1234567890123456789012345678901234567890123456789012345678901234'''''CARD4   = '1234567890123456789012345678901234567890123456789012345678901234567' KEY_PKYS= 'value_string'       / fxpkys comment                                 KEY_PKYL=                    T / fxpkyl comment                                 KEY_PKYJ=                   11 / [feet/second/second] fxpkyj comment            KEY_PKYF=             12.12121 / fxpkyf comment                                 KEY_PKYE=         1.313131E+01 / fxpkye comment                                 KEY_PKYG=    14.14141414141414 / fxpkyg comment                                 KEY_PKYD= 1.51515151515152E+01 / fxpkyd comment                                 KEY_PKLS= 'This is a very long string value that is continued over more than o&'CONTINUE  'ne keyword.'        / fxpkls comment                                 LONGSTRN= 'OGIP 1.0'           / The HEASARC Long String Convention may be used.COMMENT   This FITS file may contain long string keyword values that are        COMMENT   This keyword was modified by fxmrec                                   KY_UCRD = 'This keyword was updated by fxucrd'                                  NEWIKYS = 'updated_string'     / ikys comment                                   KY_IKYJ =                   51 / This is a modified comment                     KY_IKYL =                    T / ikyl comment                                   KY_IKYE =          -1.3346E+01 / ikye comment                                   KY_IKYD = -1.33456789012346E+01 / modified comment                              KY_IKYF =             -13.3456 / ikyf comment                                   KY_IKYG =    -13.3456789012346 / ikyg comment                                   COMMENT   character at the end of each substring which is then continued        COMMENT   on the next keyword which has the name CONTINUE.                      KEY_PKYT= 12345678.1234567890123456 / fxpkyt comment                            COMMENT This keyword was written by fxpcom.                                     KY_PKNS1= 'first string'       / fxpkns comment                                 KY_PKNS2= 'second string'      / fxpkns comment                                 KY_PKNS3= '        '           / fxpkns comment                                 KY_PKNL1=                    T / fxpknl comment                                 KY_PKNL2=                    F / fxpknl comment                                 KY_PKNL3=                    T / fxpknl comment                                 KY_PKNJ1=                   11 / fxpknj comment                                 KY_PKNJ2=                   12 / fxpknj comment                                 KY_PKNJ3=                   13 / fxpknj comment                                 KY_PKNF1=             12.12121 / fxpknf comment                                 KY_PKNF2=             13.13131 / fxpknf comment                                 KY_PKNF3=             14.14141 / fxpknf comment                                 KY_PKNE1=         1.313131E+01 / fxpkne comment                                 KY_PKNE2=         1.414141E+01 / fxpkne comment                                 KY_PKNE3=         1.515152E+01 / fxpkne comment                                 KY_PKNG1=     14.1414141414141 / fxpkng comment                                 KY_PKNG2=     15.1515151515152 / fxpkng comment                                 KY_PKNG3=     16.1616161616162 / fxpkng comment                                 KY_PKND1= 1.51515151515152E+01 / fxpknd comment                                 KY_PKND2= 1.61616161616162E+01 / fxpknd comment                                 KY_PKND3= 1.71717171717172E+01 / fxpknd comment                                 TSTRING = '1       '           / tstring comment                                TLOGICAL=                    T / tlogical comment                               TBYTE   =                   11 / tbyte comment                                  TSHORT  =                   21 / tshort comment                                 TINT    =                   31 / tint comment                                   TLONG   =                   41 / tlong comment                                  TFLOAT  =         4.200000E+01 / tfloat comment                                 TDOUBLE = 8.20000000000000E+01 / tdouble comment                                BLANK   =                  -99 / value to use for undefined pixels              END                                                                                                                                                                                                                                                                                                                                                                                                             	

XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   61 / width of table in bytes                        NAXIS2  =                   20 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                   10 / number of fields in each row                   TTYPE1  = 'Avalue  '           / label for field   1                            TFORM1  = '15A     '           / data format of field: ASCII Character          TTYPE2  = 'Lvalue  '           / label for field   2                            TFORM2  = '1L      '           / data format of field: 1-byte LOGICAL           TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Xvalue  '           / label for field   3                            TFORM3  = '16X     '           / data format of field: BIT                      TUNIT3  = 'cm      '           / physical unit of field                         TTYPE4  = 'Bvalue  '           / label for field   4                            TFORM4  = '1B      '           / data format of field: BYTE                     TUNIT4  = 'erg/s   '           / physical unit of field                         TTYPE5  = 'Ivalue  '           / label for field   5                            TFORM5  = '1I      '           / data format of field: 2-byte INTEGER           TUNIT5  = 'km/s    '           / physical unit of field                         TTYPE6  = 'Jvalue  '           / label for field   6                            TFORM6  = '1J      '           / data format of field: 4-byte INTEGER           TTYPE7  = 'Evalue  '           / label for field   7                            TFORM7  = '1E      '           / data format of field: 4-byte REAL              TTYPE8  = 'Dvalue  '           / label for field   8                            TFORM8  = '1D      '           / data format of field: 8-byte DOUBLE            TTYPE9  = 'Cvalue  '           / label for field   9                            TFORM9  = '1C      '           / data format of field: COMPLEX                  TTYPE10 = 'Mvalue  '           / label for field  10                            TFORM10 = '1M      '           / data format of field: DOUBLE COMPLEX           EXTNAME = 'Test-BINTABLE'      / name of this binary table extension            TNULL4  =                   77 / value for undefined pixels                     TNULL5  =                   77 / value for undefined pixels                     TNULL6  =                   77 / value for undefined pixels                     TSCAL4  =                 1000 / scaling factor                                 TSCAL5  =                    1 / scaling factor                                 TSCAL6  =                  100 / scaling factor                                 TZERO4  =                    0 / scaling offset                                 TZERO5  =                32768 / scaling offset                                 TZERO6  =                  100 / scaling offset                                 END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             	
c!GBMMMXTENSION= 'IMAGE   '           / IMAGE extension                                BITPIX  =                  -32 / number of bits per data pixel                  NAXIS   =                    2 / number of data axes                            NAXIS1  =                   15 / length of data axis 1                          NAXIS2  =                   25 / length of data axis 2                          PCOUNT  =                    0 / required keyword; must = 0                     GCOUNT  =                    1 / required keyword; must = 1                     NEW_KEY = 'written by fxprec' / to change checksum                              END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?@@@@@@@AAA A0A@APA`A A0A@APA`ApAAAAAAAAAAAAAAAAAAAAABBBAABBBBBBBBB B$B(B,B0B B$B(B,@BXBHBLBPBT 0@P`pBBpBtBxB|BBBBBBBBBB $(,048<@DBBBBBHLPTX\`dhlBBBBBptx|€‚„†ˆŠBBBBBŒŽ’”–˜šœžBBBBB ¢¤¦¨ª¬®°²CCCCC´¶¸º¼¾CCC
CCCCCCCCCCCCCCCCCCCCCCCC C!C"C#C$C C!C"C#C$C%C&C'C(C)C*C+C,C-C.C*C+C,C-C.C/C0C1C2C3C4C5C6C7C8C4C5C6C7C8C9C:C;C<C=C>C?C@CACBC>C?C@CACBCCCDCECFCGCHCICJCKCLCHCICJCKCLCMCNCOCPCQCRCSCTCUCVCRCSCTCUCVCWCXCYCZC[C\C]C^C_C`C\C]C^C_C`CaCbCcCdCeCfCgChCiCjCfCgChCiCjCkClCmCnCoCpCqCrCsCtCpCqCrCsCtCuCvCwCxCyCzC{C|C}C~XTENSION= 'TABLE   '           / ASCII table extension                          BITPIX  =                    8 / 8-bit ASCII characters                         NAXIS   =                    2 / 2-dimensional ASCII table                      NAXIS1  =                   76 / width of table in characters                   NAXIS2  =                   12 / number of rows in table                        PCOUNT  =                    0 / no group parameters (required keyword)         GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    5 / number of fields in each row                   TTYPE1  = 'Name    '           / label for field   1                            TBCOL1  =                    1 / beginning column of field   1                  TFORM1  = 'A15     '           / Fortran-77 format of field                     TTYPE2  = 'Ivalue  '           / label for field   2                            TBCOL2  =                   17 / beginning column of field   2                  TFORM2  = 'I10     '           / Fortran-77 format of field                     TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Evalue  '           / label for field   4                            TBCOL3  =                   28 / beginning column of field   4                  TFORM3  = 'E12.5   '           / Fortran-77 format of field                     TUNIT3  = 'erg/s   '           / physical unit of field                         TTYPE4  = 'Dvalue  '           / label for field   5                            TBCOL4  =                   41 / beginning column of field   5                  TFORM4  = 'D21.14  '           / Fortran-77 format of field                     TUNIT4  = 'km/s    '           / physical unit of field                         EXTNAME = 'Test-ASCII'         / name of this ASCII table extension             TNULL1  = 'null1   '           / value for undefined pixels                     TNULL2  = 'null2   '           / value for undefined pixels                     TNULL3  = 'null4   '           / value for undefined pixels                     TNULL4  = 'null5   '           / value for undefined pixels                     TTYPE5  = 'INSERT_COL'         / label for field                                TFORM5  = 'F14.6   '           / format of field                                TBCOL5  =                   63 / beginning column of field                      END                                                                                                                                                                                                                                                                                                                                                                                                             first string             1  1.00000E+00  1.00000000000000E+00               second string            2  2.00000E+00  2.00000000000000E+00                                                                                                                                                                                                                                                                            3  3.00000E+00  3.00000000000000E+00               null1                    4  4.00000E+00  4.00000000000000E+00                                        5  5.00000E+00  5.00000000000000E+00                                        6  6.00000E+00  6.00000000000000E+00                                        9  9.00000E+00  9.00000000000000E+00                                       10  1.00000E+01  1.00000000000000E+01                               null2      null4        null5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   61 / width of table in bytes                        NAXIS2  =                   22 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                   10 / number of fields in each row                   TTYPE1  = 'Avalue  '           / label for field   1                            TFORM1  = '15A     '           / data format of field: ASCII Character          TTYPE2  = 'Lvalue  '           / label for field   2                            TFORM2  = '1L      '           / data format of field: 1-byte LOGICAL           TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Xvalue  '           / label for field   3                            TFORM3  = '16X     '           / data format of field: BIT                      TUNIT3  = 'cm      '           / physical unit of field                         TTYPE4  = 'Bvalue  '           / label for field   4                            TFORM4  = '1B      '           / data format of field: BYTE                     TUNIT4  = 'erg/s   '           / physical unit of field                         TTYPE5  = 'Ivalue  '           / label for field   5                            TFORM5  = '1I      '           / data format of field: 2-byte INTEGER           TUNIT5  = 'km/s    '           / physical unit of field                         TTYPE6  = 'Evalue  '           / label for field   7                            TFORM6  = '1E      '           / data format of field: 4-byte REAL              TTYPE7  = 'Dvalue  '           / label for field   8                            TFORM7  = '1D      '           / data format of field: 8-byte DOUBLE            TTYPE9  = 'Cvalue  '           / label for field   9                            TFORM9  = '1C      '           / data format of field: COMPLEX                  TTYPE10 = 'Mvalue  '           / label for field  10                            TFORM10 = '1M      '           / data format of field: DOUBLE COMPLEX           EXTNAME = 'Test-BINTABLE'      / name of this binary table extension            TNULL4  =                   99 / value for undefined pixels                     TNULL5  =                   99 / value for undefined pixels                     TDIM3   = '(1,2,8) '           / size of the multidimensional array             KEY_PREC= 'This keyword was written by f_prec' / comment here                   TTYPE8  = 'INSERT_COL'         / label for field                                TFORM8  = '1E      '           / format of field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             first string   FLp????second string  T|@@@@@               F@@@@@              F@@ T@@A @"$TA0@@&(F		A@"A@12T $A@34ccTA@@(FccF`,FccF0TccT2TccT4FccXTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   80 / width of table in bytes                        NAXIS2  =                   20 / number of rows in table                        PCOUNT  =                 4446 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                   10 / number of fields in each row                   TTYPE1  = 'Avalue  '           / label for field   1                            TFORM1  = '1PA(20) '           / data format of field: variable length array    TTYPE2  = 'Lvalue  '           / label for field   2                            TFORM2  = '1PL(20) '           / data format of field: variable length array    TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Xvalue  '           / label for field   3                            TFORM3  = '1PB(3)  '           / data format of field: variable length array    TUNIT3  = 'cm      '           / physical unit of field                         TTYPE4  = 'Bvalue  '           / label for field   4                            TFORM4  = '1PB(20) '           / data format of field: variable length array    TUNIT4  = 'erg/s   '           / physical unit of field                         TTYPE5  = 'Ivalue  '           / label for field   5                            TFORM5  = '1PI(20) '           / data format of field: variable length array    TUNIT5  = 'km/s    '           / physical unit of field                         TTYPE6  = 'Jvalue  '           / label for field   6                            TFORM6  = '1PJ(20) '           / data format of field: variable length array    TTYPE7  = 'Evalue  '           / label for field   7                            TFORM7  = '1PE(20) '           / data format of field: variable length array    TTYPE8  = 'Dvalue  '           / label for field   8                            TFORM8  = '1PD(20) '           / data format of field: variable length array    TTYPE9  = 'Cvalue  '           / label for field   9                            TFORM9  = '1PC(0)  '           / data format of field: variable length array    TTYPE10 = 'Mvalue  '           / label for field  10                            TFORM10 = '1PM(0)  '           / data format of field: variable length array    EXTNAME = 'Test-BINTABLE'      / name of this binary table extension            TNULL4  =                   88 / value for undefined pixels                     TNULL5  =                   88 / value for undefined pixels                     TNULL6  =                   88 / value for undefined pixels                     END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
!)1ADGHKQ]i@FLMS_wS[cdl|					+	O	s






? x
v





!	A	:	v		


 
@

@Qbev 

M
%8KNanF??abT@XXX@@abcFF@XXX?@@?@abcdFTF@XXX?@@?@@abcdeFTFTHXXX?@@@@?@@@abcdefFTFFTLXXX?@@@@@?@@@@abcdefgFTFFTFLXXX?@@@@@@?@@@@@abcdefghFTFFTTFLXXX?@@@@@@A?@@@@@@ abcdefghiFTFFTTFFLX	X	X	?@@@@@@@A?@@@@@@@"abcdefghijFTFFTTFFTL@X
X
X
?@@@@@@@AA ?@@@@@@@ @$abcdefghijkFTFFTTFFFTL`	X	X	X?@@@@@@@AAA0?@@@@@@@ @"@&abcdefghijklFTFFTTFFFTTLp	
X	
X	
X?@@@@@@@AAA A@?@@@@@@@ @"@$@(abcdefghijklmFTFFTTFFFTTFLp	
X
	
X
	
X
?@@@@@@@AAA A0AP?@@@@@@@ @"@$@&@*abcdefghijklmnFTFFTTFFFTTTFLp	
X	
X	
X?@@@@@@@AAA A0A@A`?@@@@@@@ @"@$@&@(@,abcdefghijklmnoFTFFTTFFFTTTFFLp	

X	

X	

X?@@@@@@@AAA A0A@APAp?@@@@@@@ @"@$@&@(@*@.abcdefghijklmnopFTFFTTFFFTTTFFFLp	

X	

X	

X?@@@@@@@AAA A0A@APA`A?@@@@@@@ @"@$@&@(@*@,@0abcdefghijklmnopqFTFFTTFFFTTTFFFTLp	

X	

X	

X?@@@@@@@AAA A0A@APA`ApA?@@@@@@@ @"@$@&@(@*@,@.@1abcdefghijklmnopqrFTFFTTFFFTTTFFFFTLp	

X	

X	

X?@@@@@@@AAA A0A@APA`ApAA?@@@@@@@ @"@$@&@(@*@,@.@0@2abcdefghijklmnopqrsFTFFTTFFFTTTFFFFTTLp	

X	

X	

X?@@@@@@@AAA A0A@APA`ApAAA?@@@@@@@ @"@$@&@(@*@,@.@0@1@3abcdefghijklmnopqrstFTFFTTFFFTTTFFFFTTTLp	

X	

X	

X?@@@@@@@AAA A0A@APA`ApAAAA?@@@@@@@ @"@$@&@(@*@,@.@0@1@2@4XTENSION= 'IMAGE   '           / IMAGE extension                                BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    2 / number of data axes                            NAXIS1  =                   10 / length of data axis 1                          NAXIS2  =                    2 / length of data axis 2                          PCOUNT  =                    0 / required keyword; must = 0                     GCOUNT  =                    1 / required keyword; must = 1                     CRVAL1  =     4.5830000000E+01 / comment                                        CRVAL2  =     6.3570000000E+01 / comment                                        CRPIX1  =     2.5600000000E+02 / comment                                        CRPIX2  =     2.5700000000E+02 / comment                                        CDELT1  =    -2.7777700000E-03 / comment                                        CDELT2  =     2.7777700000E-03 / comment                                        CTYPE1  = 'RA---TAN'           / comment                                        CTYPE2  = 'DEC--TAN'           / comment                                        END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
XTENSION= 'TABLE   '           / ASCII table extension                          BITPIX  =                    8 / 8-bit ASCII characters                         NAXIS   =                    2 / 2-dimensional ASCII table                      NAXIS1  =                   80 / width of table in characters                   NAXIS2  =                   11 / number of rows in table                        PCOUNT  =                    0 / no group parameters (required keyword)         GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    5 / number of fields in each row                   TTYPE1  = 'Name    '           / label for field   1                            TBCOL1  =                    1 / beginning column of field   1                  TFORM1  = 'A15     '           / Fortran-77 format of field                     TTYPE2  = 'Ivalue  '           / label for field   2                            TBCOL2  =                   17 / beginning column of field   2                  TFORM2  = 'I11     '           / Fortran-77 format of field                     TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Fvalue  '           / label for field   3                            TBCOL3  =                   29 / beginning column of field   3                  TFORM3  = 'F15.6   '           / Fortran-77 format of field                     TUNIT3  = 'cm      '           / physical unit of field                         TTYPE4  = 'Evalue  '           / label for field   4                            TBCOL4  =                   45 / beginning column of field   4                  TFORM4  = 'E13.5   '           / Fortran-77 format of field                     TUNIT4  = 'erg/s   '           / physical unit of field                         TTYPE5  = 'Dvalue  '           / label for field   5                            TBCOL5  =                   59 / beginning column of field   5                  TFORM5  = 'D22.14  '           / Fortran-77 format of field                     TUNIT5  = 'km/s    '           / physical unit of field                         EXTNAME = 'new_table'          / name of this ASCII table extension             END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             first string              0        0.000000   0.00000E+00   0.00000000000000E+00second string             3        3.000000   3.00000E+00   3.00000000000000E+00                          6        6.000000   6.00000E+00   6.00000000000000E+00                          9        9.000000   9.00000E+00   9.00000000000000E+00                         12       12.000000   1.20000E+01   1.20000000000000E+01                         15       15.000000   1.50000E+01   1.50000000000000E+01                         18       18.000000   1.80000E+01   1.80000000000000E+01                         21       21.000000   2.10000E+01   2.10000000000000E+01                         24       24.000000   2.40000E+01   2.40000000000000E+01                         27       27.000000   2.70000E+01   2.70000000000000E+01                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                healpy-1.10.3/cfitsio/testprog.c0000664000175000017500000024765613010375005017017 0ustar  zoncazonca00000000000000#include 
#include 
#include "fitsio.h"
int main(void);

int main()
{
/*  
    This is a big and complicated program that tests most of
    the cfitsio routines.  This code does not represent
    the most efficient method of reading or writing FITS files 
    because this code is primarily designed to stress the cfitsio
    library routines.
*/
    char asciisum[17];
    unsigned long checksum, datsum;
    int datastatus, hdustatus, filemode;
    int status, simple, bitpix, naxis, extend, hdutype, hdunum, tfields;
    long ii, jj, extvers;
    int nkeys, nfound, colnum, typecode, signval,nmsg;
    char cval, cvalstr[2];
    long repeat, offset, width, jnulval;
    int anynull;
/*    float vers;   */
    unsigned char xinarray[21], binarray[21], boutarray[21], bnul;
    short         iinarray[21], ioutarray[21], inul;
    int           kinarray[21], koutarray[21], knul;
    long          jinarray[21], joutarray[21], jnul;
    float         einarray[21], eoutarray[21], enul, cinarray[42];
    double        dinarray[21], doutarray[21], dnul, minarray[42];
    double scale, zero;
    long naxes[3], pcount, gcount, npixels, nrows, rowlen, firstpix[3];
    int existkeys, morekeys, keynum;

    char larray[42], larray2[42], colname[70], tdisp[40], nulstr[40];
    char oskey[] = "value_string";
    char iskey[21];
    int olkey = 1;
    int ilkey;
    short oshtkey, ishtkey;
    long ojkey = 11, ijkey;
    long otint = 12345678;
    float ofkey = 12.121212f;
    float oekey = 13.131313f, iekey;
    double ogkey = 14.1414141414141414;
    double odkey = 15.1515151515151515, idkey;
    double otfrac = .1234567890123456;

    double xrval,yrval,xrpix,yrpix,xinc,yinc,rot,xpos,ypos,xpix,ypix;
    char xcoordtype[] = "RA---TAN";
    char ycoordtype[] = "DEC--TAN";
    char ctype[5];

    char *lsptr;    /* pointer to long string value */
    char  comm[73];
    char *comms[3];
    char *inskey[21];
    char *onskey[3] = {"first string", "second string", "        "};
    char *inclist[2] = {"key*", "newikys"};
    char *exclist[2] = {"key_pr*", "key_pkls"};

    int   onlkey[3] = {1, 0, 1}, inlkey[3];
    long  onjkey[3] = {11, 12, 13}, injkey[3];
    float onfkey[3] = {12.121212f, 13.131313f, 14.141414f};
    float onekey[3] = {13.131313f, 14.141414f, 15.151515f}, inekey[3];
    double ongkey[3] = {14.1414141414141414, 15.1515151515151515,
           16.1616161616161616};
    double ondkey[3] = {15.1515151515151515, 16.1616161616161616,
           17.1717171717171717}, indkey[3];

    long tbcol[5] = {1, 17, 28, 43, 56};

    char filename[40], card[FLEN_CARD], card2[FLEN_CARD];
    char keyword[FLEN_KEYWORD];
    char value[FLEN_VALUE], comment[FLEN_COMMENT];
    unsigned char uchars[80];

    fitsfile *fptr, *tmpfptr;
    char *ttype[10], *tform[10], *tunit[10];
    char tblname[40];
    char binname[] = "Test-BINTABLE";
    char templt[] = "testprog.tpt";
    char errmsg[FLEN_ERRMSG];
    short imgarray[30][19], imgarray2[20][10];
    long fpixels[2], lpixels[2], inc[2];

    status = 0;
    strcpy(tblname, "Test-ASCII");

/*    ffvers(&vers); 
    printf("CFITSIO TESTPROG, v%.3f\n\n",vers);
*/
    printf("CFITSIO TESTPROG\n\n");
    printf("Try opening then closing a nonexistent file:\n");
    fits_open_file(&fptr, "tq123x.kjl", READWRITE, &status);
    printf("  ffopen fptr, status  = %lu %d (expect an error)\n", 
           (unsigned long) fptr, status);
    ffclos(fptr, &status);
    printf("  ffclos status = %d\n\n", status);
    ffcmsg();
    status = 0;

    for (ii = 0; ii < 21; ii++)  /* allocate space for string column value */
        inskey[ii] = (char *) malloc(21);   

    for (ii = 0; ii < 10; ii++)
    {
      ttype[ii] = (char *) malloc(20);
      tform[ii] = (char *) malloc(20);
      tunit[ii] = (char *) malloc(20);
    }

    comms[0] = comm;

    /* delete previous version of the file, if it exists (with ! prefix) */
    strcpy(filename, "!testprog.fit");

    status = 0;

    /*
      #####################
      #  create FITS file #
      #####################
    */

    ffinit(&fptr, filename, &status);
    printf("ffinit create new file status = %d\n", status);
    if (status)
        goto errstatus;

    filename[0] = '\0';
    ffflnm(fptr, filename, &status);

    ffflmd(fptr, &filemode, &status);
    printf("Name of file = %s, I/O mode = %d\n", filename, filemode);
    simple = 1;
    bitpix = 32;
    naxis = 2;
    naxes[0] = 10;
    naxes[1] = 2;
    npixels = 20;
    pcount = 0;
    gcount = 1;
    extend = 1;
    /*
      ############################
      #  write single keywords   #
      ############################
    */

    if (ffphps(fptr, bitpix, naxis, naxes, &status) > 0)
        printf("ffphps status = %d\n", status);

    if (ffprec(fptr, 
    "key_prec= 'This keyword was written by fxprec' / comment goes here", 
     &status) > 0 )
        printf("ffprec status = %d\n", status);

    printf("\ntest writing of long string keywords:\n");
    strcpy(card, "1234567890123456789012345678901234567890");
    strcat(card, "12345678901234567890123456789012345");
    ffpkys(fptr, "card1", card, "", &status);
    ffgkey(fptr, "card1", card2, comment, &status);
    printf(" %s\n%s\n", card, card2);
    
    strcpy(card, "1234567890123456789012345678901234567890");
    strcat(card, "123456789012345678901234'6789012345");
    ffpkys(fptr, "card2", card, "", &status);
    ffgkey(fptr, "card2", card2, comment, &status);
    printf(" %s\n%s\n", card, card2);
    
    strcpy(card, "1234567890123456789012345678901234567890");
    strcat(card, "123456789012345678901234''789012345");
    ffpkys(fptr, "card3", card, "", &status);
    ffgkey(fptr, "card3", card2, comment, &status);
    printf(" %s\n%s\n", card, card2);
    
    strcpy(card, "1234567890123456789012345678901234567890");
    strcat(card, "123456789012345678901234567'9012345");
    ffpkys(fptr, "card4", card, "", &status);
    ffgkey(fptr, "card4", card2, comment, &status);
    printf(" %s\n%s\n", card, card2);
    
    if (ffpkys(fptr, "key_pkys", oskey, "fxpkys comment", &status) > 0)
        printf("ffpkys status = %d\n", status);

    if (ffpkyl(fptr, "key_pkyl", olkey, "fxpkyl comment", &status) > 0)
        printf("ffpkyl status = %d\n", status);

    if (ffpkyj(fptr, "key_pkyj", ojkey, "fxpkyj comment", &status) > 0)
        printf("ffpkyj status = %d\n", status);

    if (ffpkyf(fptr, "key_pkyf", ofkey, 5, "fxpkyf comment", &status) > 0)
        printf("ffpkyf status = %d\n", status);

    if (ffpkye(fptr, "key_pkye", oekey, 6, "fxpkye comment", &status) > 0)
        printf("ffpkye status = %d\n", status);

    if (ffpkyg(fptr, "key_pkyg", ogkey, 14, "fxpkyg comment", &status) > 0)
        printf("ffpkyg status = %d\n", status);

    if (ffpkyd(fptr, "key_pkyd", odkey, 14, "fxpkyd comment", &status) > 0)
        printf("ffpkyd status = %d\n", status);

    if (ffpkyc(fptr, "key_pkyc", onekey, 6, "fxpkyc comment", &status) > 0)
        printf("ffpkyc status = %d\n", status);

    if (ffpkym(fptr, "key_pkym", ondkey, 14, "fxpkym comment", &status) > 0)
        printf("ffpkym status = %d\n", status);

    if (ffpkfc(fptr, "key_pkfc", onekey, 6, "fxpkfc comment", &status) > 0)
        printf("ffpkfc status = %d\n", status);

    if (ffpkfm(fptr, "key_pkfm", ondkey, 14, "fxpkfm comment", &status) > 0)
        printf("ffpkfm status = %d\n", status);

    if (ffpkls(fptr, "key_pkls", 
"This is a very long string value that is continued over more than one keyword.",
     "fxpkls comment", &status) > 0)
        printf("ffpkls status = %d\n", status);

    if (ffplsw(fptr, &status) > 0 )
        printf("ffplsw status = %d\n", status);

    if (ffpkyt(fptr, "key_pkyt", otint, otfrac, "fxpkyt comment", &status) > 0)
        printf("ffpkyt status = %d\n", status);

    if (ffpcom(fptr, "  This keyword was written by fxpcom.", &status) > 0)
        printf("ffpcom status = %d\n", status);

    if (ffphis(fptr, "    This keyword written by fxphis (w/ 2 leading spaces).",
        &status) > 0)
        printf("ffphis status = %d\n", status);

    if (ffpdat(fptr, &status) > 0)
    {
        printf("ffpdat status = %d\n", status);
        goto errstatus;
    }

    /*
      ###############################
      #  write arrays of keywords   #
      ###############################
    */
    nkeys = 3;

    comms[0] = comm;  /* use the inskey array of pointers for the comments */

    strcpy(comm, "fxpkns comment&");
    if (ffpkns(fptr, "ky_pkns", 1, nkeys, onskey, comms, &status) > 0)
        printf("ffpkns status = %d\n", status);

    strcpy(comm, "fxpknl comment&");
    if (ffpknl(fptr, "ky_pknl", 1, nkeys, onlkey, comms, &status) > 0)
        printf("ffpknl status = %d\n", status);

    strcpy(comm, "fxpknj comment&");
    if (ffpknj(fptr, "ky_pknj", 1, nkeys, onjkey, comms, &status) > 0)
        printf("ffpknj status = %d\n", status);

    strcpy(comm, "fxpknf comment&");
    if (ffpknf(fptr, "ky_pknf", 1, nkeys, onfkey, 5, comms, &status) > 0)
        printf("ffpknf status = %d\n", status);

    strcpy(comm, "fxpkne comment&");
    if (ffpkne(fptr, "ky_pkne", 1, nkeys, onekey, 6, comms, &status) > 0)
        printf("ffpkne status = %d\n", status);

    strcpy(comm, "fxpkng comment&");
    if (ffpkng(fptr, "ky_pkng", 1, nkeys, ongkey, 13, comms, &status) > 0)
        printf("ffpkng status = %d\n", status);

    strcpy(comm, "fxpknd comment&");
    if (ffpknd(fptr, "ky_pknd", 1, nkeys, ondkey, 14, comms, &status) > 0)
    {
        printf("ffpknd status = %d\n", status);
        goto errstatus;
    }
    /*
      ############################
      #  write generic keywords  #
      ############################
    */

    strcpy(oskey, "1");
    if (ffpky(fptr, TSTRING, "tstring", oskey, "tstring comment", &status) > 0)
        printf("ffpky status = %d\n", status);

    olkey = TLOGICAL;
    if (ffpky(fptr, TLOGICAL, "tlogical", &olkey, "tlogical comment",
        &status) > 0)
        printf("ffpky status = %d\n", status);

    cval = TBYTE;
    if (ffpky(fptr, TBYTE, "tbyte", &cval, "tbyte comment", &status) > 0)
        printf("ffpky status = %d\n", status);

    oshtkey = TSHORT;
    if (ffpky(fptr, TSHORT, "tshort", &oshtkey, "tshort comment", &status) > 0)
        printf("ffpky status = %d\n", status);

    olkey = TINT;
    if (ffpky(fptr, TINT, "tint", &olkey, "tint comment", &status) > 0)
        printf("ffpky status = %d\n", status);

    ojkey = TLONG;
    if (ffpky(fptr, TLONG, "tlong", &ojkey, "tlong comment", &status) > 0)
        printf("ffpky status = %d\n", status);

    oekey = TFLOAT;
    if (ffpky(fptr, TFLOAT, "tfloat", &oekey, "tfloat comment", &status) > 0)
        printf("ffpky status = %d\n", status);

    odkey = TDOUBLE;
    if (ffpky(fptr, TDOUBLE, "tdouble", &odkey, "tdouble comment",
              &status) > 0)
        printf("ffpky status = %d\n", status);

    /*
      ############################
      #  write data              #
      ############################
    */
    /* define the null value (must do this before writing any data) */
    if (ffpkyj(fptr, "BLANK", -99, "value to use for undefined pixels",
       &status) > 0)
        printf("BLANK keyword status = %d\n", status);

    /* initialize arrays of values to write to primary array */
    for (ii = 0; ii < npixels; ii++)
    {
        boutarray[ii] = (unsigned char) (ii + 1);
        ioutarray[ii] = (short) (ii + 1);
        joutarray[ii] = ii + 1;
        eoutarray[ii] = (float) (ii + 1);
        doutarray[ii] = ii + 1;
    }

    /* write a few pixels with each datatype */
    /* set the last value in each group of 4 as undefined */

/*
    ffpprb(fptr, 1,  1, 2, &boutarray[0],  &status);
    ffppri(fptr, 1,  5, 2, &ioutarray[4],  &status);
    ffpprj(fptr, 1,  9, 2, &joutarray[8],  &status);
    ffppre(fptr, 1, 13, 2, &eoutarray[12], &status);
    ffpprd(fptr, 1, 17, 2, &doutarray[16], &status);
*/

/*  test the newer ffpx routine, instead of the older ffppr_ routines */
    firstpix[0]=1;
    firstpix[1]=1;
    ffppx(fptr, TBYTE, firstpix, 2, &boutarray[0],  &status);
    firstpix[0]=5;
    ffppx(fptr, TSHORT, firstpix, 2, &ioutarray[4],  &status);
    firstpix[0]=9;
    ffppx(fptr, TLONG, firstpix, 2, &joutarray[8],  &status);
    firstpix[0]=3;
    firstpix[1]=2;
    ffppx(fptr, TFLOAT, firstpix, 2, &eoutarray[12],  &status);
    firstpix[0]=7;
    ffppx(fptr, TDOUBLE, firstpix, 2, &doutarray[16],  &status);

/*
    ffppnb(fptr, 1,  3, 2, &boutarray[2],   4, &status);
    ffppni(fptr, 1,  7, 2, &ioutarray[6],   8, &status);
    ffppnj(fptr, 1, 11, 2, &joutarray[10],  12, &status);
    ffppne(fptr, 1, 15, 2, &eoutarray[14], 16., &status);
    ffppnd(fptr, 1, 19, 2, &doutarray[18], 20., &status);
*/
    firstpix[0]=3;
    firstpix[1]=1;
    bnul = 4;
    ffppxn(fptr, TBYTE, firstpix, 2, &boutarray[2], &bnul,  &status);
    firstpix[0]=7;
    inul = 8;
    ffppxn(fptr, TSHORT, firstpix, 2, &ioutarray[6], &inul, &status);
    firstpix[0]=1;
    firstpix[1]=2;
    jnul = 12;
    ffppxn(fptr, TLONG, firstpix, 2, &joutarray[10], &jnul, &status);
    firstpix[0]=5;
    enul = 16.;
    ffppxn(fptr, TFLOAT, firstpix, 2, &eoutarray[14], &enul,  &status);
    firstpix[0]=9;
    dnul = 20.;
    ffppxn(fptr, TDOUBLE, firstpix, 2, &doutarray[18], &dnul, &status);

    ffppru(fptr, 1, 1, 1, &status);


    if (status > 0)
    {
        printf("ffppnx status = %d\n", status);
        goto errstatus;
    }

    ffflus(fptr, &status);   /* flush all data to the disk file */ 
    printf("ffflus status = %d\n", status);
    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    /*
      ############################
      #  read data               #
      ############################
    */
    /* read back the data, setting null values = 99 */
    printf("\nValues read back from primary array (99 = null pixel)\n");
    printf("The 1st, and every 4th pixel should be undefined:\n");

    anynull = 0;
    ffgpvb(fptr, 1,  1, 10, 99, binarray, &anynull, &status); 

    ffgpvb(fptr, 1, 11, 10, 99, &binarray[10], &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
        printf(" %2d", binarray[ii]);
    printf("  %d (ffgpvb)\n", anynull);  

    ffgpvi(fptr, 1, 1, npixels, 99,   iinarray, &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
        printf(" %2d", iinarray[ii]);
    printf("  %d (ffgpvi)\n", anynull);  

    ffgpvj(fptr, 1, 1, npixels, 99,  jinarray, &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
        printf(" %2ld", jinarray[ii]);
    printf("  %d (ffgpvj)\n", anynull);  

    ffgpve(fptr, 1, 1, npixels, 99., einarray, &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
        printf(" %2.0f", einarray[ii]);
    printf("  %d (ffgpve)\n", anynull);  

    ffgpvd(fptr, 1,  1, 10, 99.,  dinarray, &anynull, &status);
    ffgpvd(fptr, 1, 11, 10, 99.,  &dinarray[10], &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
        printf(" %2.0f", dinarray[ii]);
    printf("  %d (ffgpvd)\n", anynull);  

    if (status > 0)
    {
        printf("ERROR: ffgpv_ status = %d\n", status);
        goto errstatus;
    }
    if (anynull == 0)
       printf("ERROR: ffgpv_ did not detect null values\n");

    /* reset the output null value to the expected input value */
    for (ii = 3; ii < npixels; ii += 4)
    {
        boutarray[ii] = 99;
        ioutarray[ii] = 99;
        joutarray[ii] = 99;
        eoutarray[ii] = 99.;
        doutarray[ii] = 99.;
    }
        ii = 0;
        boutarray[ii] = 99;
        ioutarray[ii] = 99;
        joutarray[ii] = 99;
        eoutarray[ii] = 99.;
        doutarray[ii] = 99.;

    /* compare the output with the input; flag any differences */
    for (ii = 0; ii < npixels; ii++)
    {
       if (boutarray[ii] != binarray[ii])
           printf("bout != bin = %u %u \n", boutarray[ii], binarray[ii]);

       if (ioutarray[ii] != iinarray[ii])
           printf("iout != iin = %d %d \n", ioutarray[ii], iinarray[ii]);

       if (joutarray[ii] != jinarray[ii])
           printf("jout != jin = %ld %ld \n", joutarray[ii], jinarray[ii]);

       if (eoutarray[ii] != einarray[ii])
           printf("eout != ein = %f %f \n", eoutarray[ii], einarray[ii]);

       if (doutarray[ii] != dinarray[ii])
           printf("dout != din = %f %f \n", doutarray[ii], dinarray[ii]);
    }

    for (ii = 0; ii < npixels; ii++)
    {
      binarray[ii] = 0;
      iinarray[ii] = 0;
      jinarray[ii] = 0;
      einarray[ii] = 0.;
      dinarray[ii] = 0.;
    }

    anynull = 0;
    ffgpfb(fptr, 1,  1, 10, binarray, larray, &anynull, &status);
    ffgpfb(fptr, 1, 11, 10, &binarray[10], &larray[10], &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
      if (larray[ii])
        printf("  *");
      else
        printf(" %2d", binarray[ii]);
    printf("  %d (ffgpfb)\n", anynull);  

    ffgpfi(fptr, 1, 1, npixels, iinarray, larray, &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
      if (larray[ii])
        printf("  *");
      else
        printf(" %2d", iinarray[ii]);
    printf("  %d (ffgpfi)\n", anynull);  

    ffgpfj(fptr, 1, 1, npixels, jinarray, larray, &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
      if (larray[ii])
        printf("  *");
      else
        printf(" %2ld", jinarray[ii]);
    printf("  %d (ffgpfj)\n", anynull);  

    ffgpfe(fptr, 1, 1, npixels, einarray, larray, &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
      if (larray[ii])
        printf("  *");
      else
        printf(" %2.0f", einarray[ii]);
    printf("  %d (ffgpfe)\n", anynull);  

    ffgpfd(fptr, 1,  1, 10, dinarray, larray, &anynull, &status);
    ffgpfd(fptr, 1, 11, 10, &dinarray[10], &larray[10], &anynull, &status);

    for (ii = 0; ii < npixels; ii++)
      if (larray[ii])
        printf("  *");
      else
        printf(" %2.0f", dinarray[ii]);
    printf("  %d (ffgpfd)\n", anynull);  

    if (status > 0)
    {
        printf("ERROR: ffgpf_ status = %d\n", status);
        goto errstatus;
    }
    if (anynull == 0)
       printf("ERROR: ffgpf_ did not detect null values\n");


    /*
      ##########################################
      #  close and reopen file multiple times  #
      ##########################################
    */

    for (ii = 0; ii < 10; ii++)
    {
      if (ffclos(fptr, &status) > 0)
      {
        printf("ERROR in ftclos (1) = %d", status);
        goto errstatus;
      }

      if (fits_open_file(&fptr, filename, READWRITE, &status) > 0)
      {
        printf("ERROR: ffopen open file status = %d\n", status);
        goto errstatus;
      }
    }
    printf("\nClosed then reopened the FITS file 10 times.\n");
    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    filename[0] = '\0';
    ffflnm(fptr, filename, &status);

    ffflmd(fptr, &filemode, &status);
    printf("Name of file = %s, I/O mode = %d\n", filename, filemode);

    /*
      ############################
      #  read single keywords    #
      ############################
    */

    simple = 0;
    bitpix = 0;
    naxis = 0;
    naxes[0] = 0;
    naxes[1] = 0;
    pcount = -99;
    gcount =  -99;
    extend = -99;
    printf("\nRead back keywords:\n");
    ffghpr(fptr, 99, &simple, &bitpix, &naxis, naxes, &pcount,
           &gcount, &extend, &status);
    printf("simple = %d, bitpix = %d, naxis = %d, naxes = (%ld, %ld)\n",
           simple, bitpix, naxis, naxes[0], naxes[1]);
    printf("  pcount = %ld, gcount = %ld, extend = %d\n",
               pcount, gcount, extend);

    ffgrec(fptr, 9, card, &status);
    printf("%s\n", card);
    if (strncmp(card, "KEY_PREC= 'This", 15) )
       printf("ERROR in ffgrec\n");

    ffgkyn(fptr, 9, keyword, value, comment, &status);
    printf("%s : %s : %s :\n",keyword, value, comment);
    if (strncmp(keyword, "KEY_PREC", 8) )
       printf("ERROR in ffgkyn: %s\n", keyword);

    ffgcrd(fptr, keyword, card, &status);
    printf("%s\n", card);

    if (strncmp(keyword, card, 8) )
       printf("ERROR in ffgcrd: %s\n", keyword);

    ffgkey(fptr, "KY_PKNS1", value, comment, &status);
    printf("KY_PKNS1 : %s : %s :\n", value, comment);

    if (strncmp(value, "'first string'", 14) )
       printf("ERROR in ffgkey: %s\n", value);

    ffgkys(fptr, "key_pkys", iskey, comment, &status);
    printf("KEY_PKYS %s %s %d\n", iskey, comment, status);

    ffgkyl(fptr, "key_pkyl", &ilkey, comment, &status);
    printf("KEY_PKYL %d %s %d\n", ilkey, comment, status);

    ffgkyj(fptr, "KEY_PKYJ", &ijkey, comment, &status);
    printf("KEY_PKYJ %ld %s %d\n",ijkey, comment, status);

    ffgkye(fptr, "KEY_PKYJ", &iekey, comment, &status);
    printf("KEY_PKYJ %f %s %d\n",iekey, comment, status);

    ffgkyd(fptr, "KEY_PKYJ", &idkey, comment, &status);
    printf("KEY_PKYJ %f %s %d\n",idkey, comment, status);

    if (ijkey != 11 || iekey != 11. || idkey != 11.)
       printf("ERROR in ffgky[jed]: %ld, %f, %f\n",ijkey, iekey, idkey);

    iskey[0] = '\0';
    ffgky(fptr, TSTRING, "key_pkys", iskey, comment, &status);
    printf("KEY_PKY S %s %s %d\n", iskey, comment, status);

    ilkey = 0;
    ffgky(fptr, TLOGICAL, "key_pkyl", &ilkey, comment, &status);
    printf("KEY_PKY L %d %s %d\n", ilkey, comment, status);

    ffgky(fptr, TBYTE, "KEY_PKYJ", &cval, comment, &status);
    printf("KEY_PKY BYTE %d %s %d\n",cval, comment, status);

    ffgky(fptr, TSHORT, "KEY_PKYJ", &ishtkey, comment, &status);
    printf("KEY_PKY SHORT %d %s %d\n",ishtkey, comment, status);

    ffgky(fptr, TINT, "KEY_PKYJ", &ilkey, comment, &status);
    printf("KEY_PKY INT %d %s %d\n",ilkey, comment, status);

    ijkey = 0;
    ffgky(fptr, TLONG, "KEY_PKYJ", &ijkey, comment, &status);
    printf("KEY_PKY J %ld %s %d\n",ijkey, comment, status);

    iekey = 0;
    ffgky(fptr, TFLOAT, "KEY_PKYE", &iekey, comment, &status);
    printf("KEY_PKY E %f %s %d\n",iekey, comment, status);

    idkey = 0;
    ffgky(fptr, TDOUBLE, "KEY_PKYD", &idkey, comment, &status);
    printf("KEY_PKY D %f %s %d\n",idkey, comment, status);

    ffgkyd(fptr, "KEY_PKYF", &idkey, comment, &status);
    printf("KEY_PKYF %f %s %d\n",idkey, comment, status);

    ffgkyd(fptr, "KEY_PKYE", &idkey, comment, &status);
    printf("KEY_PKYE %f %s %d\n",idkey, comment, status);

    ffgkyd(fptr, "KEY_PKYG", &idkey, comment, &status);
    printf("KEY_PKYG %.14f %s %d\n",idkey, comment, status);

    ffgkyd(fptr, "KEY_PKYD", &idkey, comment, &status);
    printf("KEY_PKYD %.14f %s %d\n",idkey, comment, status);

    ffgkyc(fptr, "KEY_PKYC", inekey, comment, &status);
    printf("KEY_PKYC %f %f %s %d\n",inekey[0], inekey[1], comment, status);

    ffgkyc(fptr, "KEY_PKFC", inekey, comment, &status);
    printf("KEY_PKFC %f %f %s %d\n",inekey[0], inekey[1], comment, status);

    ffgkym(fptr, "KEY_PKYM", indkey, comment, &status);
    printf("KEY_PKYM %f %f %s %d\n",indkey[0], indkey[1], comment, status);

    ffgkym(fptr, "KEY_PKFM", indkey, comment, &status);
    printf("KEY_PKFM %f %f %s %d\n",indkey[0], indkey[1], comment, status);

    ffgkyt(fptr, "KEY_PKYT", &ijkey, &idkey, comment, &status);
    printf("KEY_PKYT %ld %.14f %s %d\n",ijkey, idkey, comment, status);

    ffpunt(fptr, "KEY_PKYJ", "km/s/Mpc", &status);
    ijkey = 0;
    ffgky(fptr, TLONG, "KEY_PKYJ", &ijkey, comment, &status);
    printf("KEY_PKY J %ld %s %d\n",ijkey, comment, status);
    ffgunt(fptr,"KEY_PKYJ", comment, &status);
    printf("KEY_PKY units = %s\n",comment);

    ffpunt(fptr, "KEY_PKYJ", "", &status);
    ijkey = 0;
    ffgky(fptr, TLONG, "KEY_PKYJ", &ijkey, comment, &status);
    printf("KEY_PKY J %ld %s %d\n",ijkey, comment, status);
    ffgunt(fptr,"KEY_PKYJ", comment, &status);
    printf("KEY_PKY units = %s\n",comment);

    ffpunt(fptr, "KEY_PKYJ", "feet/second/second", &status);
    ijkey = 0;
    ffgky(fptr, TLONG, "KEY_PKYJ", &ijkey, comment, &status);
    printf("KEY_PKY J %ld %s %d\n",ijkey, comment, status);
    ffgunt(fptr,"KEY_PKYJ", comment, &status);
    printf("KEY_PKY units = %s\n",comment);

    ffgkls(fptr, "key_pkls", &lsptr, comment, &status);
    printf("KEY_PKLS long string value = \n%s\n", lsptr);

    /* free the memory for the long string value */
    fits_free_memory(lsptr, &status);

    /* get size and position in header */
    ffghps(fptr, &existkeys, &keynum, &status);
    printf("header contains %d keywords; located at keyword %d \n",existkeys,
            keynum);

    /*
      ############################
      #  read array keywords     #
      ############################
    */
    ffgkns(fptr, "ky_pkns", 1, 3, inskey, &nfound, &status);
    printf("ffgkns:  %s, %s, %s\n", inskey[0], inskey[1], inskey[2]);
    if (nfound != 3 || status > 0)
       printf("\nERROR in ffgkns %d, %d\n", nfound, status);

    ffgknl(fptr, "ky_pknl", 1, 3, inlkey, &nfound, &status);
    printf("ffgknl:  %d, %d, %d\n", inlkey[0], inlkey[1], inlkey[2]);
    if (nfound != 3 || status > 0)
       printf("\nERROR in ffgknl %d, %d\n", nfound, status);

    ffgknj(fptr, "ky_pknj", 1, 3, injkey, &nfound, &status);
    printf("ffgknj:  %ld, %ld, %ld\n", injkey[0], injkey[1], injkey[2]);
    if (nfound != 3 || status > 0)
       printf("\nERROR in ffgknj %d, %d\n", nfound, status);

    ffgkne(fptr, "ky_pkne", 1, 3, inekey, &nfound, &status);
    printf("ffgkne:  %f, %f, %f\n", inekey[0], inekey[1], inekey[2]);
    if (nfound != 3 || status > 0)
       printf("\nERROR in ffgkne %d, %d\n", nfound, status);

    ffgknd(fptr, "ky_pknd", 1, 3, indkey, &nfound, &status);
    printf("ffgknd:  %f, %f, %f\n", indkey[0], indkey[1], indkey[2]);
    if (nfound != 3 || status > 0)
       printf("\nERROR in ffgknd %d, %d\n", nfound, status);

    /* get position of HISTORY keyword for subsequent deletes and inserts */
    ffgcrd(fptr, "HISTORY", card, &status);
    ffghps(fptr, &existkeys, &keynum, &status);
    keynum -= 2;

    printf("\nBefore deleting the HISTORY and DATE keywords...\n");
    for (ii = keynum; ii <= keynum + 3; ii++)
    {
        ffgrec(fptr, ii, card, &status);
        printf("%.8s\n", card);  /* don't print date value, so that */
    }                            /* the output will always be the same */
    /*
      ############################
      #  delete keywords         #
      ############################
    */

    ffdrec(fptr, keynum + 1, &status);
    ffdkey(fptr, "DATE", &status);

    printf("\nAfter deleting the keywords...\n");
    for (ii = keynum; ii <= keynum + 1; ii++)
    {
        ffgrec(fptr, ii, card, &status);
        printf("%s\n", card);
    }

    if (status > 0)
       printf("\nERROR deleting keywords\n");
    /*
      ############################
      #  insert keywords         #
      ############################
    */
    keynum += 4;
    ffirec(fptr, keynum - 3, "KY_IREC = 'This keyword inserted by fxirec'",
           &status);
    ffikys(fptr, "KY_IKYS", "insert_value_string", "ikys comment", &status);
    ffikyj(fptr, "KY_IKYJ", 49, "ikyj comment", &status);
    ffikyl(fptr, "KY_IKYL", 1, "ikyl comment", &status);
    ffikye(fptr, "KY_IKYE", 12.3456f, 4, "ikye comment", &status);
    ffikyd(fptr, "KY_IKYD", 12.345678901234567, 14, "ikyd comment", &status);
    ffikyf(fptr, "KY_IKYF", 12.3456f, 4, "ikyf comment", &status);
    ffikyg(fptr, "KY_IKYG", 12.345678901234567, 13, "ikyg comment", &status);

    printf("\nAfter inserting the keywords...\n");
    for (ii = keynum - 4; ii <= keynum + 5; ii++)
    {
        ffgrec(fptr, ii, card, &status);
        printf("%s\n", card);
    }

    if (status > 0)
       printf("\nERROR inserting keywords\n");
    /*
      ############################
      #  modify keywords         #
      ############################
    */
    ffmrec(fptr, keynum - 4, "COMMENT   This keyword was modified by fxmrec", &status);
    ffmcrd(fptr, "KY_IREC", "KY_MREC = 'This keyword was modified by fxmcrd'",
            &status);
    ffmnam(fptr, "KY_IKYS", "NEWIKYS", &status);

    ffmcom(fptr, "KY_IKYJ","This is a modified comment", &status);
    ffmkyj(fptr, "KY_IKYJ", 50, "&", &status);
    ffmkyl(fptr, "KY_IKYL", 0, "&", &status);
    ffmkys(fptr, "NEWIKYS", "modified_string", "&", &status);
    ffmkye(fptr, "KY_IKYE", -12.3456f, 4, "&", &status);
    ffmkyd(fptr, "KY_IKYD", -12.345678901234567, 14, "modified comment",
            &status);
    ffmkyf(fptr, "KY_IKYF", -12.3456f, 4, "&", &status);
    ffmkyg(fptr, "KY_IKYG", -12.345678901234567, 13, "&", &status);

    printf("\nAfter modifying the keywords...\n");
    for (ii = keynum - 4; ii <= keynum + 5; ii++)
    {
        ffgrec(fptr, ii, card, &status);
        printf("%s\n", card);
    }
    if (status > 0)
       printf("\nERROR modifying keywords\n");

    /*
      ############################
      #  update keywords         #
      ############################
    */
    ffucrd(fptr, "KY_MREC", "KY_UCRD = 'This keyword was updated by fxucrd'",
            &status);

    ffukyj(fptr, "KY_IKYJ", 51, "&", &status);
    ffukyl(fptr, "KY_IKYL", 1, "&", &status);
    ffukys(fptr, "NEWIKYS", "updated_string", "&", &status);
    ffukye(fptr, "KY_IKYE", -13.3456f, 4, "&", &status);
    ffukyd(fptr, "KY_IKYD", -13.345678901234567, 14, "modified comment",
            &status);
    ffukyf(fptr, "KY_IKYF", -13.3456f, 4, "&", &status);
    ffukyg(fptr, "KY_IKYG", -13.345678901234567, 13, "&", &status);

    printf("\nAfter updating the keywords...\n");
    for (ii = keynum - 4; ii <= keynum + 5; ii++)
    {
        ffgrec(fptr, ii, card, &status);
        printf("%s\n", card);
    }
    if (status > 0)
       printf("\nERROR modifying keywords\n");

    /* move to top of header and find keywords using wild cards */
    ffgrec(fptr, 0, card, &status);

    printf("\nKeywords found using wildcard search (should be 13)...\n");
    nfound = 0;
    while (!ffgnxk(fptr,inclist, 2, exclist, 2, card, &status))
    {
        nfound++;
        printf("%s\n", card);
    }
    if (nfound != 13)
    {
       printf("\nERROR reading keywords using wildcards (ffgnxk)\n");
       goto errstatus;
    }
    status = 0;

    /*
      ############################
      #  copy index keyword      #
      ############################
    */
    ffcpky(fptr, fptr, 1, 4, "KY_PKNE", &status);
    ffgkne(fptr, "ky_pkne", 2, 4, inekey, &nfound, &status);
    printf("\nCopied keyword: ffgkne:  %f, %f, %f\n", inekey[0], inekey[1],
           inekey[2]);

    if (status > 0)
    {
       printf("\nERROR in ffgkne %d, %d\n", nfound, status);
       goto errstatus;
    }

    /*
      ######################################
      #  modify header using template file #
      ######################################
    */
    if (ffpktp(fptr, templt, &status))
    {
       printf("\nERROR returned by ffpktp:\n");
       printf("Could not open or process the file 'testprog.tpt'.\n");
       printf("  This file is included with the CFITSIO distribution\n");
       printf("  and should be copied into the current directory\n");
       printf("  before running the testprog program.\n");
       status = 0;
    }
    printf("Updated header using template file (ffpktp)\n");
    /*
      ############################
      #  create binary table     #
      ############################
    */

    strcpy(tform[0], "15A");
    strcpy(tform[1], "1L");
    strcpy(tform[2], "16X");
    strcpy(tform[3], "1B");
    strcpy(tform[4], "1I");
    strcpy(tform[5], "1J");
    strcpy(tform[6], "1E");
    strcpy(tform[7], "1D");
    strcpy(tform[8], "1C");
    strcpy(tform[9], "1M");

    strcpy(ttype[0], "Avalue");
    strcpy(ttype[1], "Lvalue");
    strcpy(ttype[2], "Xvalue");
    strcpy(ttype[3], "Bvalue");
    strcpy(ttype[4], "Ivalue");
    strcpy(ttype[5], "Jvalue");
    strcpy(ttype[6], "Evalue");
    strcpy(ttype[7], "Dvalue");
    strcpy(ttype[8], "Cvalue");
    strcpy(ttype[9], "Mvalue");

    strcpy(tunit[0], "");
    strcpy(tunit[1], "m**2");
    strcpy(tunit[2], "cm");
    strcpy(tunit[3], "erg/s");
    strcpy(tunit[4], "km/s");
    strcpy(tunit[5], "");
    strcpy(tunit[6], "");
    strcpy(tunit[7], "");
    strcpy(tunit[8], "");
    strcpy(tunit[9], "");

    nrows = 21;
    tfields = 10;
    pcount = 0;

/*
    ffcrtb(fptr, BINARY_TBL, nrows, tfields, ttype, tform, tunit, binname,
            &status);
*/
    ffibin(fptr, nrows, tfields, ttype, tform, tunit, binname, 0L,
            &status);

    printf("\nffibin status = %d\n", status);
    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    /* get size and position in header, and reserve space for more keywords */
    ffghps(fptr, &existkeys, &keynum, &status);
    printf("header contains %d keywords; located at keyword %d \n",existkeys,
            keynum);

    morekeys = 40;
    ffhdef(fptr, morekeys, &status);
    ffghsp(fptr, &existkeys, &morekeys, &status);
    printf("header contains %d keywords with room for %d more\n",existkeys,
            morekeys);

    fftnul(fptr, 4, 99, &status);   /* define null value for int cols */
    fftnul(fptr, 5, 99, &status);
    fftnul(fptr, 6, 99, &status);

    extvers = 1;
    ffpkyj(fptr, "EXTVER", extvers, "extension version number", &status);
    ffpkyj(fptr, "TNULL4", 99, "value for undefined pixels", &status);
    ffpkyj(fptr, "TNULL5", 99, "value for undefined pixels", &status);
    ffpkyj(fptr, "TNULL6", 99, "value for undefined pixels", &status);

    naxis = 3;
    naxes[0] = 1;
    naxes[1] = 2;
    naxes[2] = 8;
    ffptdm(fptr, 3, naxis, naxes, &status);

    naxis = 0;
    naxes[0] = 0;
    naxes[1] = 0;
    naxes[2] = 0;
    ffgtdm(fptr, 3, 3, &naxis, naxes, &status);
    ffgkys(fptr, "TDIM3", iskey, comment, &status);
    printf("TDIM3 = %s, %d, %ld, %ld, %ld\n", iskey, naxis, naxes[0],
         naxes[1], naxes[2]);

    ffrdef(fptr, &status);  /* force header to be scanned (not required) */

    /*
      ############################
      #  write data to columns   #
      ############################
    */

    /* initialize arrays of values to write to table */
    signval = -1;
    for (ii = 0; ii < 21; ii++)
    {
        signval *= -1;
        boutarray[ii] = (unsigned char) (ii + 1);
        ioutarray[ii] = (short) ((ii + 1) * signval);
        joutarray[ii] = (ii + 1) * signval;
        koutarray[ii] = (ii + 1) * signval;
        eoutarray[ii] = (float) ((ii + 1) * signval);
        doutarray[ii] = (ii + 1) * signval;
    }

    ffpcls(fptr, 1, 1, 1, 3, onskey, &status);  /* write string values */
    ffpclu(fptr, 1, 4, 1, 1, &status);  /* write null value */

    larray[0] = 0;
    larray[1] = 1;
    larray[2] = 0;
    larray[3] = 0;
    larray[4] = 1;
    larray[5] = 1;
    larray[6] = 0;
    larray[7] = 0;
    larray[8] = 0;
    larray[9] = 1;
    larray[10] = 1;
    larray[11] = 1;
    larray[12] = 0;
    larray[13] = 0;
    larray[14] = 0;
    larray[15] = 0;
    larray[16] = 1;
    larray[17] = 1;
    larray[18] = 1;
    larray[19] = 1;
    larray[20] = 0;
    larray[21] = 0;
    larray[22] = 0;
    larray[23] = 0;
    larray[24] = 0;
    larray[25] = 1;
    larray[26] = 1;
    larray[27] = 1;
    larray[28] = 1;
    larray[29] = 1;
    larray[30] = 0;
    larray[31] = 0;
    larray[32] = 0;
    larray[33] = 0;
    larray[34] = 0;
    larray[35] = 0;


    ffpclx(fptr, 3, 1, 1, 36, larray, &status); /*write bits*/

    for (ii = 4; ii < 9; ii++)   /* loop over cols 4 - 8 */
    {
        ffpclb(fptr, ii, 1, 1, 2, boutarray, &status);
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcli(fptr, ii, 3, 1, 2, &ioutarray[2], &status); 
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpclk(fptr, ii, 5, 1, 2, &koutarray[4], &status); 
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcle(fptr, ii, 7, 1, 2, &eoutarray[6], &status);
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcld(fptr, ii, 9, 1, 2, &doutarray[8], &status);
        if (status == NUM_OVERFLOW)
            status = 0;

        ffpclu(fptr, ii, 11, 1, 1, &status);  /* write null value */
    }

    ffpclc(fptr, 9, 1, 1, 10, eoutarray, &status);
    ffpclm(fptr, 10, 1, 1, 10, doutarray, &status);

    for (ii = 4; ii < 9; ii++)   /* loop over cols 4 - 8 */
    {
        ffpcnb(fptr, ii, 12, 1, 2, &boutarray[11], 13, &status);
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcni(fptr, ii, 14, 1, 2, &ioutarray[13], 15, &status); 
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcnk(fptr, ii, 16, 1, 2, &koutarray[15], 17, &status); 
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcne(fptr, ii, 18, 1, 2, &eoutarray[17], 19., &status);
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcnd(fptr, ii, 20, 1, 2, &doutarray[19], 21., &status);
        if (status == NUM_OVERFLOW)
            status = 0;

    }
    ffpcll(fptr, 2, 1, 1, 21, larray, &status); /*write logicals*/
    ffpclu(fptr, 2, 11, 1, 1, &status);  /* write null value */
    printf("ffpcl_ status = %d\n", status);

    /*
      #########################################
      #  get information about the columns    #
      #########################################
    */

    printf("\nFind the column numbers; a returned status value of 237 is");
    printf("\nexpected and indicates that more than one column name matches");
    printf("\nthe input column name template.  Status = 219 indicates that");
    printf("\nthere was no matching column name.");

    ffgcno(fptr, 0, "Xvalue", &colnum, &status);
    printf("\nColumn Xvalue is number %d; status = %d.\n", colnum, status);

    while (status != COL_NOT_FOUND)
    {
      ffgcnn(fptr, 1, "*ue", colname, &colnum, &status);
      printf("Column %s is number %d; status = %d.\n", 
           colname, colnum, status);
    }
    status = 0;

    printf("\nInformation about each column:\n");

    for (ii = 0; ii < tfields; ii++)
    {
      ffgtcl(fptr, ii + 1, &typecode, &repeat, &width, &status);
      printf("%4s %3d %2ld %2ld", tform[ii], typecode, repeat, width);
      ffgbcl(fptr, ii + 1, ttype[0], tunit[0], cvalstr, &repeat, &scale,
           &zero, &jnulval, tdisp, &status);
      printf(" %s, %s, %c, %ld, %f, %f, %ld, %s.\n",
         ttype[0], tunit[0], cvalstr[0], repeat, scale, zero, jnulval, tdisp);
    }

    printf("\n");

    /*
      ###############################################
      #  insert ASCII table before the binary table #
      ###############################################
    */

    if (ffmrhd(fptr, -1, &hdutype, &status) > 0)
        goto errstatus;

    strcpy(tform[0], "A15");
    strcpy(tform[1], "I10");
    strcpy(tform[2], "F14.6");
    strcpy(tform[3], "E12.5");
    strcpy(tform[4], "D21.14");

    strcpy(ttype[0], "Name");
    strcpy(ttype[1], "Ivalue");
    strcpy(ttype[2], "Fvalue");
    strcpy(ttype[3], "Evalue");
    strcpy(ttype[4], "Dvalue");

    strcpy(tunit[0], "");
    strcpy(tunit[1], "m**2");
    strcpy(tunit[2], "cm");
    strcpy(tunit[3], "erg/s");
    strcpy(tunit[4], "km/s");

    rowlen = 76;
    nrows = 11;
    tfields = 5;

    ffitab(fptr, rowlen, nrows, tfields, ttype, tbcol, tform, tunit, tblname,
            &status);
    printf("ffitab status = %d\n", status);
    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    ffsnul(fptr, 1, "null1", &status);   /* define null value for int cols */
    ffsnul(fptr, 2, "null2", &status);
    ffsnul(fptr, 3, "null3", &status);
    ffsnul(fptr, 4, "null4", &status);
    ffsnul(fptr, 5, "null5", &status);
 
    extvers = 2;
    ffpkyj(fptr, "EXTVER", extvers, "extension version number", &status);

    ffpkys(fptr, "TNULL1", "null1", "value for undefined pixels", &status);
    ffpkys(fptr, "TNULL2", "null2", "value for undefined pixels", &status);
    ffpkys(fptr, "TNULL3", "null3", "value for undefined pixels", &status);
    ffpkys(fptr, "TNULL4", "null4", "value for undefined pixels", &status);
    ffpkys(fptr, "TNULL5", "null5", "value for undefined pixels", &status);

    if (status > 0)
        goto errstatus;

    /*
      ############################
      #  write data to columns   #
      ############################
    */

    /* initialize arrays of values to write to table */
    for (ii = 0; ii < 21; ii++)
    {
        boutarray[ii] = (unsigned char) (ii + 1);
        ioutarray[ii] = (short) (ii + 1);
        joutarray[ii] = ii + 1;
        eoutarray[ii] = (float) (ii + 1);
        doutarray[ii] = ii + 1;
    }

    ffpcls(fptr, 1, 1, 1, 3, onskey, &status);  /* write string values */
    ffpclu(fptr, 1, 4, 1, 1, &status);  /* write null value */

    for (ii = 2; ii < 6; ii++)   /* loop over cols 2 - 5 */
    {
        ffpclb(fptr, ii, 1, 1, 2, boutarray, &status);  /* char array */
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcli(fptr, ii, 3, 1, 2, &ioutarray[2], &status);  /* short array */
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpclj(fptr, ii, 5, 1, 2, &joutarray[4], &status);  /* long array */
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcle(fptr, ii, 7, 1, 2, &eoutarray[6], &status);  /* float array */
        if (status == NUM_OVERFLOW)
            status = 0;
        ffpcld(fptr, ii, 9, 1, 2, &doutarray[8], &status);  /* double array */
        if (status == NUM_OVERFLOW)
            status = 0;

        ffpclu(fptr, ii, 11, 1, 1, &status);  /* write null value */
    }
    printf("ffpcl_ status = %d\n", status);

    /*
      ################################
      #  read data from ASCII table  #
      ################################
    */
    ffghtb(fptr, 99, &rowlen, &nrows, &tfields, ttype, tbcol, 
           tform, tunit, tblname, &status);

    printf("\nASCII table: rowlen, nrows, tfields, extname: %ld %ld %d %s\n",
           rowlen, nrows, tfields, tblname);

    for (ii = 0; ii < tfields; ii++)
      printf("%8s %3ld %8s %8s \n", ttype[ii], tbcol[ii], 
                                   tform[ii], tunit[ii]);

    nrows = 11;
    ffgcvs(fptr, 1, 1, 1, nrows, "UNDEFINED", inskey,   &anynull, &status);
    ffgcvb(fptr, 2, 1, 1, nrows, 99, binarray, &anynull, &status);
    ffgcvi(fptr, 2, 1, 1, nrows, 99, iinarray, &anynull, &status);
    ffgcvj(fptr, 3, 1, 1, nrows, 99, jinarray, &anynull, &status);
    ffgcve(fptr, 4, 1, 1, nrows, 99., einarray, &anynull, &status);
    ffgcvd(fptr, 5, 1, 1, nrows, 99., dinarray, &anynull, &status);

    printf("\nData values read from ASCII table:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %2d %2ld %4.1f %4.1f\n", inskey[ii], binarray[ii],
           iinarray[ii], jinarray[ii], einarray[ii], dinarray[ii]); 
    }

    ffgtbb(fptr, 1, 20, 78, uchars, &status);
    uchars[78] = '\0';
    printf("\n%s\n", uchars);
    ffptbb(fptr, 1, 20, 78, uchars, &status);

    /*
      #########################################
      #  get information about the columns    #
      #########################################
    */

    ffgcno(fptr, 0, "name", &colnum, &status);
    printf("\nColumn name is number %d; status = %d.\n", colnum, status);

    while (status != COL_NOT_FOUND)
    {
      ffgcnn(fptr, 1, "*ue", colname, &colnum, &status);
      printf("Column %s is number %d; status = %d.\n", 
           colname, colnum, status);
    }
    status = 0;

    for (ii = 0; ii < tfields; ii++)
    {
      ffgtcl(fptr, ii + 1, &typecode, &repeat, &width, &status);
      printf("%4s %3d %2ld %2ld", tform[ii], typecode, repeat, width);
      ffgacl(fptr, ii + 1, ttype[0], tbcol, tunit[0], tform[0], &scale,
           &zero, nulstr, tdisp, &status);
      printf(" %s, %ld, %s, %s, %f, %f, %s, %s.\n",
         ttype[0], tbcol[0], tunit[0], tform[0], scale, zero,
         nulstr, tdisp);
    }

    printf("\n");

    /*
      ###############################################
      #  test the insert/delete row/column routines #
      ###############################################
    */

    if (ffirow(fptr, 2, 3, &status) > 0)
        goto errstatus;

    nrows = 14;
    ffgcvs(fptr, 1, 1, 1, nrows, "UNDEFINED", inskey,   &anynull, &status);
    ffgcvb(fptr, 2, 1, 1, nrows, 99, binarray, &anynull, &status);
    ffgcvi(fptr, 2, 1, 1, nrows, 99, iinarray, &anynull, &status);
    ffgcvj(fptr, 3, 1, 1, nrows, 99, jinarray, &anynull, &status);
    ffgcve(fptr, 4, 1, 1, nrows, 99., einarray, &anynull, &status);
    ffgcvd(fptr, 5, 1, 1, nrows, 99., dinarray, &anynull, &status);


    printf("\nData values after inserting 3 rows after row 2:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %2d %2ld %4.1f %4.1f\n",  inskey[ii], binarray[ii],
          iinarray[ii], jinarray[ii], einarray[ii], dinarray[ii]);
    }

    if (ffdrow(fptr, 10, 2, &status) > 0)
        goto errstatus;

    nrows = 12;
    ffgcvs(fptr, 1, 1, 1, nrows, "UNDEFINED", inskey,   &anynull, &status);
    ffgcvb(fptr, 2, 1, 1, nrows, 99, binarray, &anynull, &status);
    ffgcvi(fptr, 2, 1, 1, nrows, 99, iinarray, &anynull, &status);
    ffgcvj(fptr, 3, 1, 1, nrows, 99, jinarray, &anynull, &status);
    ffgcve(fptr, 4, 1, 1, nrows, 99., einarray, &anynull, &status);
    ffgcvd(fptr, 5, 1, 1, nrows, 99., dinarray, &anynull, &status);

    printf("\nData values after deleting 2 rows at row 10:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %2d %2ld %4.1f %4.1f\n",  inskey[ii], binarray[ii],
          iinarray[ii], jinarray[ii], einarray[ii], dinarray[ii]);
    }
    if (ffdcol(fptr, 3, &status) > 0)
        goto errstatus;

    ffgcvs(fptr, 1, 1, 1, nrows, "UNDEFINED", inskey,   &anynull, &status);
    ffgcvb(fptr, 2, 1, 1, nrows, 99, binarray, &anynull, &status);
    ffgcvi(fptr, 2, 1, 1, nrows, 99, iinarray, &anynull, &status);
    ffgcve(fptr, 3, 1, 1, nrows, 99., einarray, &anynull, &status);
    ffgcvd(fptr, 4, 1, 1, nrows, 99., dinarray, &anynull, &status);

    printf("\nData values after deleting column 3:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %2d %4.1f %4.1f\n", inskey[ii], binarray[ii],
          iinarray[ii], einarray[ii], dinarray[ii]);
    }

    if (fficol(fptr, 5, "INSERT_COL", "F14.6", &status) > 0)
        goto errstatus;

    ffgcvs(fptr, 1, 1, 1, nrows, "UNDEFINED", inskey,   &anynull, &status);
    ffgcvb(fptr, 2, 1, 1, nrows, 99, binarray, &anynull, &status);
    ffgcvi(fptr, 2, 1, 1, nrows, 99, iinarray, &anynull, &status);
    ffgcve(fptr, 3, 1, 1, nrows, 99., einarray, &anynull, &status);
    ffgcvd(fptr, 4, 1, 1, nrows, 99., dinarray, &anynull, &status);
    ffgcvj(fptr, 5, 1, 1, nrows, 99, jinarray, &anynull, &status);

    printf("\nData values after inserting column 5:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %2d %4.1f %4.1f %ld\n", inskey[ii], binarray[ii],
          iinarray[ii], einarray[ii], dinarray[ii] , jinarray[ii]);
    }

    /*
      ############################################################
      #  create a temporary file and copy the ASCII table to it, #
      #  column by column.                                       #
      ############################################################
    */
    bitpix = 16;
    naxis = 0;

    strcpy(filename, "!t1q2s3v6.tmp");
    ffinit(&tmpfptr, filename, &status);
    printf("Create temporary file: ffinit status = %d\n", status);

    ffiimg(tmpfptr, bitpix, naxis, naxes, &status);
    printf("\nCreate null primary array: ffiimg status = %d\n", status);

    /* create an empty table with 12 rows and 0 columns */
    nrows = 12;
    tfields = 0;
    rowlen = 0;
    ffitab(tmpfptr, rowlen, nrows, tfields, ttype, tbcol, tform, tunit,
           tblname, &status);
    printf("\nCreate ASCII table with 0 columns: ffitab status = %d\n",
           status);

    /* copy columns from one table to the other */
    ffcpcl(fptr, tmpfptr, 4, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 3, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 2, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 1, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);

    /* now repeat by copying ASCII input to Binary output table */
    ffibin(tmpfptr, nrows, tfields, ttype, tform, tunit,
           tblname,  0L, &status);
    printf("\nCreate Binary table with 0 columns: ffibin status = %d\n",
           status);

    /* copy columns from one table to the other */
    ffcpcl(fptr, tmpfptr, 4, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 3, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 2, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 1, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);


/*
    ffclos(tmpfptr, &status);
    printf("Close the tmp file: ffclos status = %d\n", status);
*/

    ffdelt(tmpfptr, &status);  
    printf("Delete the tmp file: ffdelt status = %d\n", status);

    if (status > 0)
    {
        goto errstatus;
    }

    /*
      ################################
      #  read data from binary table #
      ################################
    */

    if (ffmrhd(fptr, 1, &hdutype, &status) > 0)
        goto errstatus;

    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    ffghsp(fptr, &existkeys, &morekeys, &status);
    printf("header contains %d keywords with room for %d more\n",existkeys,
            morekeys);

    ffghbn(fptr, 99, &nrows, &tfields, ttype, 
           tform, tunit, binname, &pcount, &status);

    printf("\nBinary table: nrows, tfields, extname, pcount: %ld %d %s %ld\n",
           nrows, tfields, binname, pcount);

    for (ii = 0; ii < tfields; ii++)
      printf("%8s %8s %8s \n", ttype[ii], tform[ii], tunit[ii]);

    for (ii = 0; ii < 40; ii++)
        larray[ii] = 0;

    printf("\nData values read from binary table:\n");
    printf("  Bit column (X) data values: \n\n");

    ffgcx(fptr, 3, 1, 1, 36, larray, &status);
    for (jj = 0; jj < 5; jj++)
    {
      for (ii = 0; ii < 8; ii++)
        printf("%1d",larray[jj * 8 + ii]);
      printf(" ");
    }

    for (ii = 0; ii < nrows; ii++)
    {
      larray[ii] = 0;
      xinarray[ii] = 0;
      binarray[ii] = 0;
      iinarray[ii] = 0; 
      kinarray[ii] = 0;
      einarray[ii] = 0.; 
      dinarray[ii] = 0.;
      cinarray[ii * 2] = 0.; 
      minarray[ii * 2] = 0.;
      cinarray[ii * 2 + 1] = 0.; 
      minarray[ii * 2 + 1] = 0.;
    }

    printf("\n\n");
    ffgcvs(fptr, 1, 4, 1, 1, "",  inskey,   &anynull, &status);
    printf("null string column value = -%s- (should be --)\n",inskey[0]);

    nrows = 21;
    ffgcvs(fptr, 1, 1, 1, nrows, "NOT DEFINED",  inskey,   &anynull, &status);
    ffgcl( fptr, 2, 1, 1, nrows, larray, &status);
    ffgcvb(fptr, 3, 1, 1, nrows, 98, xinarray, &anynull, &status);
    ffgcvb(fptr, 4, 1, 1, nrows, 98, binarray, &anynull, &status);
    ffgcvi(fptr, 5, 1, 1, nrows, 98, iinarray, &anynull, &status);
    ffgcvk(fptr, 6, 1, 1, nrows, 98, kinarray, &anynull, &status);
    ffgcve(fptr, 7, 1, 1, nrows, 98., einarray, &anynull, &status);
    ffgcvd(fptr, 8, 1, 1, nrows, 98., dinarray, &anynull, &status);
    ffgcvc(fptr, 9, 1, 1, nrows, 98., cinarray, &anynull, &status);
    ffgcvm(fptr, 10, 1, 1, nrows, 98., minarray, &anynull, &status);

    printf("\nRead columns with ffgcv_:\n");
    for (ii = 0; ii < nrows; ii++)
    {
  printf("%15s %d %3d %2d %3d %3d %5.1f %5.1f (%5.1f,%5.1f) (%5.1f,%5.1f) \n",
        inskey[ii], larray[ii], xinarray[ii], binarray[ii], iinarray[ii], 
        kinarray[ii], einarray[ii], dinarray[ii], cinarray[ii * 2], 
        cinarray[ii * 2 + 1], minarray[ii * 2], minarray[ii * 2 + 1]);
    }

    for (ii = 0; ii < nrows; ii++)
    {
      larray[ii] = 0;
      xinarray[ii] = 0;
      binarray[ii] = 0;
      iinarray[ii] = 0; 
      kinarray[ii] = 0;
      einarray[ii] = 0.; 
      dinarray[ii] = 0.;
      cinarray[ii * 2] = 0.; 
      minarray[ii * 2] = 0.;
      cinarray[ii * 2 + 1] = 0.; 
      minarray[ii * 2 + 1] = 0.;
    }

    ffgcfs(fptr, 1, 1, 1, nrows, inskey,   larray2, &anynull, &status);
    ffgcfl(fptr, 2, 1, 1, nrows, larray,   larray2, &anynull, &status);
    ffgcfb(fptr, 3, 1, 1, nrows, xinarray, larray2, &anynull, &status);
    ffgcfb(fptr, 4, 1, 1, nrows, binarray, larray2, &anynull, &status);
    ffgcfi(fptr, 5, 1, 1, nrows, iinarray, larray2, &anynull, &status);
    ffgcfk(fptr, 6, 1, 1, nrows, kinarray, larray2, &anynull, &status);
    ffgcfe(fptr, 7, 1, 1, nrows, einarray, larray2, &anynull, &status);
    ffgcfd(fptr, 8, 1, 1, nrows, dinarray, larray2, &anynull, &status);
    ffgcfc(fptr, 9, 1, 1, nrows, cinarray, larray2, &anynull, &status);
    ffgcfm(fptr, 10, 1, 1, nrows, minarray, larray2, &anynull, &status);

    printf("\nRead columns with ffgcf_:\n");
    for (ii = 0; ii < 10; ii++)
    {
    
    printf("%15s %d %3d %2d %3d %3d %5.1f %5.1f (%5.1f,%5.1f) (%5.1f,%5.1f)\n",
        inskey[ii], larray[ii], xinarray[ii], binarray[ii], iinarray[ii], 
        kinarray[ii], einarray[ii], dinarray[ii], cinarray[ii * 2], 
        cinarray[ii * 2 + 1], minarray[ii * 2], minarray[ii * 2 + 1]);
    }
    for (ii = 10; ii < nrows; ii++)
    {
      /* don't try to print the NaN values */
      printf("%15s %d %3d %2d %3d \n",
        inskey[ii], larray[ii], xinarray[ii], binarray[ii], iinarray[ii]);
    }
    ffprec(fptr, 
    "key_prec= 'This keyword was written by f_prec' / comment here", &status);

    /*
      ###############################################
      #  test the insert/delete row/column routines #
      ###############################################
    */
    if (ffirow(fptr, 2, 3, &status) > 0)
        goto errstatus;

    nrows = 14;
    ffgcvs(fptr, 1, 1, 1, nrows, "NOT DEFINED",  inskey,   &anynull, &status);
    ffgcvb(fptr, 4, 1, 1, nrows, 98, binarray, &anynull, &status);
    ffgcvi(fptr, 5, 1, 1, nrows, 98, iinarray, &anynull, &status);
    ffgcvj(fptr, 6, 1, 1, nrows, 98, jinarray, &anynull, &status);
    ffgcve(fptr, 7, 1, 1, nrows, 98., einarray, &anynull, &status);
    ffgcvd(fptr, 8, 1, 1, nrows, 98., dinarray, &anynull, &status);

    printf("\nData values after inserting 3 rows after row 2:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %3d %3ld %5.1f %5.1f\n",  inskey[ii], binarray[ii],
          iinarray[ii], jinarray[ii], einarray[ii], dinarray[ii]);
    }

    if (ffdrow(fptr, 10, 2, &status) > 0)
        goto errstatus;

    nrows = 12;
    ffgcvs(fptr, 1, 1, 1, nrows, "NOT DEFINED",  inskey,   &anynull, &status);
    ffgcvb(fptr, 4, 1, 1, nrows, 98, binarray, &anynull, &status);
    ffgcvi(fptr, 5, 1, 1, nrows, 98, iinarray, &anynull, &status);
    ffgcvj(fptr, 6, 1, 1, nrows, 98, jinarray, &anynull, &status);
    ffgcve(fptr, 7, 1, 1, nrows, 98., einarray, &anynull, &status);
    ffgcvd(fptr, 8, 1, 1, nrows, 98., dinarray, &anynull, &status);

    printf("\nData values after deleting 2 rows at row 10:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %3d %3ld %5.1f %5.1f\n",  inskey[ii], binarray[ii],
          iinarray[ii], jinarray[ii], einarray[ii], dinarray[ii]);
    }

    if (ffdcol(fptr, 6, &status) > 0)
        goto errstatus;

    ffgcvs(fptr, 1, 1, 1, nrows, "NOT DEFINED",  inskey,   &anynull, &status);
    ffgcvb(fptr, 4, 1, 1, nrows, 98, binarray, &anynull, &status);
    ffgcvi(fptr, 5, 1, 1, nrows, 98, iinarray, &anynull, &status);
    ffgcve(fptr, 6, 1, 1, nrows, 98., einarray, &anynull, &status);
    ffgcvd(fptr, 7, 1, 1, nrows, 98., dinarray, &anynull, &status);

    printf("\nData values after deleting column 6:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %3d %5.1f %5.1f\n", inskey[ii], binarray[ii],
          iinarray[ii], einarray[ii], dinarray[ii]);
    }

    if (fficol(fptr, 8, "INSERT_COL", "1E", &status) > 0)
        goto errstatus;

    ffgcvs(fptr, 1, 1, 1, nrows, "NOT DEFINED",  inskey,   &anynull, &status);
    ffgcvb(fptr, 4, 1, 1, nrows, 98, binarray, &anynull, &status);
    ffgcvi(fptr, 5, 1, 1, nrows, 98, iinarray, &anynull, &status);
    ffgcve(fptr, 6, 1, 1, nrows, 98., einarray, &anynull, &status);
    ffgcvd(fptr, 7, 1, 1, nrows, 98., dinarray, &anynull, &status);
    ffgcvj(fptr, 8, 1, 1, nrows, 98, jinarray, &anynull, &status);

    printf("\nData values after inserting column 8:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %3d %5.1f %5.1f %ld\n", inskey[ii], binarray[ii],
          iinarray[ii], einarray[ii], dinarray[ii] , jinarray[ii]);
    }

    ffpclu(fptr, 8, 1, 1, 10, &status);

    ffgcvs(fptr, 1, 1, 1, nrows, "NOT DEFINED",  inskey,   &anynull, &status);
    ffgcvb(fptr, 4, 1, 1, nrows, 98, binarray, &anynull, &status);
    ffgcvi(fptr, 5, 1, 1, nrows, 98, iinarray, &anynull, &status);
    ffgcve(fptr, 6, 1, 1, nrows, 98., einarray, &anynull, &status);
    ffgcvd(fptr, 7, 1, 1, nrows, 98., dinarray, &anynull, &status);
    ffgcvj(fptr, 8, 1, 1, nrows, 98, jinarray, &anynull, &status);

    printf("\nValues after setting 1st 10 elements in column 8 = null:\n");
    for (ii = 0; ii < nrows; ii++)
    {
      printf("%15s %2d %3d %5.1f %5.1f %ld\n", inskey[ii], binarray[ii],
          iinarray[ii], einarray[ii], dinarray[ii] , jinarray[ii]);
    }

    /*
      ############################################################
      #  create a temporary file and copy the binary table to it,#
      #  column by column.                                       #
      ############################################################
    */
    bitpix = 16;
    naxis = 0;

    strcpy(filename, "!t1q2s3v5.tmp");
    ffinit(&tmpfptr, filename, &status);
    printf("Create temporary file: ffinit status = %d\n", status);

    ffiimg(tmpfptr, bitpix, naxis, naxes, &status);
    printf("\nCreate null primary array: ffiimg status = %d\n", status);

    /* create an empty table with 22 rows and 0 columns */
    nrows = 22;
    tfields = 0;
    ffibin(tmpfptr, nrows, tfields, ttype, tform, tunit, binname, 0L,
            &status);
    printf("\nCreate binary table with 0 columns: ffibin status = %d\n",
           status);

    /* copy columns from one table to the other */
    ffcpcl(fptr, tmpfptr, 7, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 6, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 5, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 4, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 3, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 2, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);
    ffcpcl(fptr, tmpfptr, 1, 1, TRUE, &status);
    printf("copy column, ffcpcl status = %d\n", status);

/*
    ffclos(tmpfptr, &status);
    printf("Close the tmp file: ffclos status = %d\n", status);
*/

    ffdelt(tmpfptr, &status);
    printf("Delete the tmp file: ffdelt status = %d\n", status);
    if (status > 0)
    {
        goto errstatus;
    }
    /*
      ####################################################
      #  insert binary table following the primary array #
      ####################################################
    */

    ffmahd(fptr,  1, &hdutype, &status);

    strcpy(tform[0], "15A");
    strcpy(tform[1], "1L");
    strcpy(tform[2], "16X");
    strcpy(tform[3], "1B");
    strcpy(tform[4], "1I");
    strcpy(tform[5], "1J");
    strcpy(tform[6], "1E");
    strcpy(tform[7], "1D");
    strcpy(tform[8], "1C");
    strcpy(tform[9], "1M");

    strcpy(ttype[0], "Avalue");
    strcpy(ttype[1], "Lvalue");
    strcpy(ttype[2], "Xvalue");
    strcpy(ttype[3], "Bvalue");
    strcpy(ttype[4], "Ivalue");
    strcpy(ttype[5], "Jvalue");
    strcpy(ttype[6], "Evalue");
    strcpy(ttype[7], "Dvalue");
    strcpy(ttype[8], "Cvalue");
    strcpy(ttype[9], "Mvalue");

    strcpy(tunit[0], "");
    strcpy(tunit[1], "m**2");
    strcpy(tunit[2], "cm");
    strcpy(tunit[3], "erg/s");
    strcpy(tunit[4], "km/s");
    strcpy(tunit[5], "");
    strcpy(tunit[6], "");
    strcpy(tunit[7], "");
    strcpy(tunit[8], "");
    strcpy(tunit[9], "");

    nrows = 20;
    tfields = 10;
    pcount = 0;

    ffibin(fptr, nrows, tfields, ttype, tform, tunit, binname, pcount,
            &status);
    printf("ffibin status = %d\n", status);
    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    extvers = 3;
    ffpkyj(fptr, "EXTVER", extvers, "extension version number", &status);


    ffpkyj(fptr, "TNULL4", 77, "value for undefined pixels", &status);
    ffpkyj(fptr, "TNULL5", 77, "value for undefined pixels", &status);
    ffpkyj(fptr, "TNULL6", 77, "value for undefined pixels", &status);

    ffpkyj(fptr, "TSCAL4", 1000, "scaling factor", &status);
    ffpkyj(fptr, "TSCAL5", 1, "scaling factor", &status);
    ffpkyj(fptr, "TSCAL6", 100, "scaling factor", &status);

    ffpkyj(fptr, "TZERO4", 0, "scaling offset", &status);
    ffpkyj(fptr, "TZERO5", 32768, "scaling offset", &status);
    ffpkyj(fptr, "TZERO6", 100, "scaling offset", &status);

    fftnul(fptr, 4, 77, &status);   /* define null value for int cols */
    fftnul(fptr, 5, 77, &status);
    fftnul(fptr, 6, 77, &status);
    /* set scaling */
    fftscl(fptr, 4, 1000., 0., &status);   
    fftscl(fptr, 5, 1., 32768., &status);
    fftscl(fptr, 6, 100., 100., &status);

    /*
      ############################
      #  write data to columns   #
      ############################
    */

    /* initialize arrays of values to write to table */
 
    joutarray[0] = 0;
    joutarray[1] = 1000;
    joutarray[2] = 10000;
    joutarray[3] = 32768;
    joutarray[4] = 65535;


    for (ii = 4; ii < 7; ii++)
    {
        ffpclj(fptr, ii, 1, 1, 5, joutarray, &status); 
        if (status == NUM_OVERFLOW)
        {
            printf("Overflow writing to column %ld\n", ii);
            status = 0;
        }

        ffpclu(fptr, ii, 6, 1, 1, &status);  /* write null value */
    }

    for (jj = 4; jj < 7; jj++)
    {
      ffgcvj(fptr, jj, 1, 1, 6, -999, jinarray, &anynull, &status);
      for (ii = 0; ii < 6; ii++)
      {
        printf(" %6ld", jinarray[ii]);
      }
      printf("\n");
    }

    printf("\n");
    /* turn off scaling, and read the unscaled values */
    fftscl(fptr, 4, 1., 0., &status);   
    fftscl(fptr, 5, 1., 0., &status);
    fftscl(fptr, 6, 1., 0., &status);

    for (jj = 4; jj < 7; jj++)
    {
      ffgcvj(fptr, jj, 1, 1, 6, -999, jinarray, &anynull, &status);
      for (ii = 0; ii < 6; ii++)
      {
        printf(" %6ld", jinarray[ii]);
      }
      printf("\n");
    }
    /*
      ######################################################
      #  insert image extension following the binary table #
      ######################################################
    */

    bitpix = -32;
    naxis = 2;
    naxes[0] = 15;
    naxes[1] = 25;
    ffiimg(fptr, bitpix, naxis, naxes, &status);
    printf("\nCreate image extension: ffiimg status = %d\n", status);
    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    for (jj = 0; jj < 30; jj++)
    {
      for (ii = 0; ii < 19; ii++)
      {
        imgarray[jj][ii] = (short) ((jj * 10) + ii);
      }
    }

    ffp2di(fptr, 1, 19, naxes[0], naxes[1], imgarray[0], &status);
    printf("\nWrote whole 2D array: ffp2di status = %d\n", status);

    for (jj = 0; jj < 30; jj++)
    {
      for (ii = 0; ii < 19; ii++)
      {
        imgarray[jj][ii] = 0;
      }
    }
    
    ffg2di(fptr, 1, 0, 19, naxes[0], naxes[1], imgarray[0], &anynull,
           &status);
    printf("\nRead whole 2D array: ffg2di status = %d\n", status);

    for (jj = 0; jj < 30; jj++)
    {
      for (ii = 0; ii < 19; ii++)
      {
        printf(" %3d", imgarray[jj][ii]);
      }
      printf("\n");
    }

    for (jj = 0; jj < 30; jj++)
    {
      for (ii = 0; ii < 19; ii++)
      {
        imgarray[jj][ii] = 0;
      }
    }
    
    for (jj = 0; jj < 20; jj++)
    {
      for (ii = 0; ii < 10; ii++)
      {
        imgarray2[jj][ii] = (short) ((jj * -10) - ii);
      }
    }

    fpixels[0] = 5;
    fpixels[1] = 5;
    lpixels[0] = 14;
    lpixels[1] = 14;
    ffpssi(fptr, 1, naxis, naxes, fpixels, lpixels, 
         imgarray2[0], &status);
    printf("\nWrote subset 2D array: ffpssi status = %d\n", status);

    ffg2di(fptr, 1, 0, 19, naxes[0], naxes[1], imgarray[0], &anynull,
           &status);
    printf("\nRead whole 2D array: ffg2di status = %d\n", status);

    for (jj = 0; jj < 30; jj++)
    {
      for (ii = 0; ii < 19; ii++)
      {
        printf(" %3d", imgarray[jj][ii]);
      }
      printf("\n");
    }

    fpixels[0] = 2;
    fpixels[1] = 5;
    lpixels[0] = 10;
    lpixels[1] = 8;
    inc[0] = 2;
    inc[1] = 3;

    for (jj = 0; jj < 30; jj++)
    {
      for (ii = 0; ii < 19; ii++)
      {
        imgarray[jj][ii] = 0;
      }
    }
    
    ffgsvi(fptr, 1, naxis, naxes, fpixels, lpixels, inc, 0,
          imgarray[0], &anynull, &status);
    printf("\nRead subset of 2D array: ffgsvi status = %d\n", status);

    for (ii = 0; ii < 10; ii++)
    {
        printf(" %3d", imgarray[0][ii]);
    }
    printf("\n");

    /*
      ###########################################################
      #  insert another image extension                         #
      #  copy the image extension to primary array of tmp file. #
      #  then delete the tmp file, and the image extension      #
      ###########################################################
    */
    bitpix = 16;
    naxis = 2;
    naxes[0] = 15;
    naxes[1] = 25;
    ffiimg(fptr, bitpix, naxis, naxes, &status);
    printf("\nCreate image extension: ffiimg status = %d\n", status);
    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    strcpy(filename, "t1q2s3v4.tmp");
    ffinit(&tmpfptr, filename, &status);
    printf("Create temporary file: ffinit status = %d\n", status);

    ffcopy(fptr, tmpfptr, 0, &status);
    printf("Copy image extension to primary array of tmp file.\n");
    printf("ffcopy status = %d\n", status);

    ffgrec(tmpfptr, 1, card, &status);
    printf("%s\n", card);
    ffgrec(tmpfptr, 2, card, &status);
    printf("%s\n", card);
    ffgrec(tmpfptr, 3, card, &status);
    printf("%s\n", card);
    ffgrec(tmpfptr, 4, card, &status);
    printf("%s\n", card);
    ffgrec(tmpfptr, 5, card, &status);
    printf("%s\n", card);
    ffgrec(tmpfptr, 6, card, &status);
    printf("%s\n", card);

    ffdelt(tmpfptr, &status);
    printf("Delete the tmp file: ffdelt status = %d\n", status);

    ffdhdu(fptr, &hdutype, &status);
    printf("Delete the image extension; hdutype, status = %d %d\n",
             hdutype, status);
    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));

    /*
      ###########################################################
      #  append bintable extension with variable length columns #
      ###########################################################
    */

    ffcrhd(fptr, &status);
    printf("ffcrhd status = %d\n", status);

    strcpy(tform[0], "1PA");
    strcpy(tform[1], "1PL");
    strcpy(tform[2], "1PB"); /* Fortran FITSIO doesn't support  1PX */
    strcpy(tform[3], "1PB");
    strcpy(tform[4], "1PI");
    strcpy(tform[5], "1PJ");
    strcpy(tform[6], "1PE");
    strcpy(tform[7], "1PD");
    strcpy(tform[8], "1PC");
    strcpy(tform[9], "1PM");

    strcpy(ttype[0], "Avalue");
    strcpy(ttype[1], "Lvalue");
    strcpy(ttype[2], "Xvalue");
    strcpy(ttype[3], "Bvalue");
    strcpy(ttype[4], "Ivalue");
    strcpy(ttype[5], "Jvalue");
    strcpy(ttype[6], "Evalue");
    strcpy(ttype[7], "Dvalue");
    strcpy(ttype[8], "Cvalue");
    strcpy(ttype[9], "Mvalue");

    strcpy(tunit[0], "");
    strcpy(tunit[1], "m**2");
    strcpy(tunit[2], "cm");
    strcpy(tunit[3], "erg/s");
    strcpy(tunit[4], "km/s");
    strcpy(tunit[5], "");
    strcpy(tunit[6], "");
    strcpy(tunit[7], "");
    strcpy(tunit[8], "");
    strcpy(tunit[9], "");

    nrows = 20;
    tfields = 10;
    pcount = 0;

    ffphbn(fptr, nrows, tfields, ttype, tform, tunit, binname, pcount,
            &status);
    printf("Variable length arrays: ffphbn status = %d\n", status);


    extvers = 4;
    ffpkyj(fptr, "EXTVER", extvers, "extension version number", &status);

    ffpkyj(fptr, "TNULL4", 88, "value for undefined pixels", &status);
    ffpkyj(fptr, "TNULL5", 88, "value for undefined pixels", &status);
    ffpkyj(fptr, "TNULL6", 88, "value for undefined pixels", &status);

    /*
      ############################
      #  write data to columns   #
      ############################
    */

    /* initialize arrays of values to write to table */
    strcpy(iskey,"abcdefghijklmnopqrst");

    for (ii = 0; ii < 20; ii++)
    {
        boutarray[ii] = (unsigned char) (ii + 1);
        ioutarray[ii] = (short) (ii + 1);
        joutarray[ii] = ii + 1;
        eoutarray[ii] = (float) (ii + 1);
        doutarray[ii] = ii + 1;
    }

    larray[0] = 0;
    larray[1] = 1;
    larray[2] = 0;
    larray[3] = 0;
    larray[4] = 1;
    larray[5] = 1;
    larray[6] = 0;
    larray[7] = 0;
    larray[8] = 0;
    larray[9] = 1;
    larray[10] = 1;
    larray[11] = 1;
    larray[12] = 0;
    larray[13] = 0;
    larray[14] = 0;
    larray[15] = 0;
    larray[16] = 1;
    larray[17] = 1;
    larray[18] = 1;
    larray[19] = 1;

    /* write values in 1st row */
    /*  strncpy(inskey[0], iskey, 1); */
      inskey[0][0] = '\0';  /* write a null string (i.e., a blank) */
      ffpcls(fptr, 1, 1, 1, 1, inskey, &status);  /* write string values */
      ffpcll(fptr, 2, 1, 1, 1, larray, &status);  /* write logicals */
      ffpclx(fptr, 3, 1, 1, 1, larray, &status);  /* write bits */
      ffpclb(fptr, 4, 1, 1, 1, boutarray, &status);
      ffpcli(fptr, 5, 1, 1, 1, ioutarray, &status); 
      ffpclj(fptr, 6, 1, 1, 1, joutarray, &status); 
      ffpcle(fptr, 7, 1, 1, 1, eoutarray, &status);
      ffpcld(fptr, 8, 1, 1, 1, doutarray, &status);

    for (ii = 2; ii <= 20; ii++)   /* loop over rows 1 - 20 */
    {
      strncpy(inskey[0], iskey, ii);
      inskey[0][ii] = '\0';
      ffpcls(fptr, 1, ii, 1, 1, inskey, &status);  /* write string values */

      ffpcll(fptr, 2, ii, 1, ii, larray, &status);  /* write logicals */
      ffpclu(fptr, 2, ii, ii-1, 1, &status);

      ffpclx(fptr, 3, ii, 1, ii, larray, &status);  /* write bits */

      ffpclb(fptr, 4, ii, 1, ii, boutarray, &status);
      ffpclu(fptr, 4, ii, ii-1, 1, &status);

      ffpcli(fptr, 5, ii, 1, ii, ioutarray, &status); 
      ffpclu(fptr, 5, ii, ii-1, 1, &status);

      ffpclj(fptr, 6, ii, 1, ii, joutarray, &status); 
      ffpclu(fptr, 6, ii, ii-1, 1, &status);

      ffpcle(fptr, 7, ii, 1, ii, eoutarray, &status);
      ffpclu(fptr, 7, ii, ii-1, 1, &status);

      ffpcld(fptr, 8, ii, 1, ii, doutarray, &status);
      ffpclu(fptr, 8, ii, ii-1, 1, &status);
    }
    printf("ffpcl_ status = %d\n", status);

    /*
      #################################
      #  close then reopen this HDU   #
      #################################
    */


     ffmrhd(fptr, -1, &hdutype, &status);
     ffmrhd(fptr,  1, &hdutype, &status);

    /*
      #############################
      #  read data from columns   #
      #############################
    */

    ffgkyj(fptr, "PCOUNT", &pcount, comm, &status);
    printf("PCOUNT = %ld\n", pcount);

    /* initialize the variables to be read */
    strcpy(inskey[0]," ");
    strcpy(iskey," ");


    printf("HDU number = %d\n", ffghdn(fptr, &hdunum));
    for (ii = 1; ii <= 20; ii++)   /* loop over rows 1 - 20 */
    {
      for (jj = 0; jj < ii; jj++)
      {
        larray[jj] = 0;
        boutarray[jj] = 0;
        ioutarray[jj] = 0;
        joutarray[jj] = 0;
        eoutarray[jj] = 0;
        doutarray[jj] = 0;
      }

      ffgcvs(fptr, 1, ii, 1, 1, iskey, inskey, &anynull, &status);  
      printf("A %s %d\nL", inskey[0], status);

      ffgcl( fptr, 2, ii, 1, ii, larray, &status); 
      for (jj = 0; jj < ii; jj++)
        printf(" %2d", larray[jj]);
      printf(" %d\nX", status);

      ffgcx(fptr, 3, ii, 1, ii, larray, &status);
      for (jj = 0; jj < ii; jj++)
        printf(" %2d", larray[jj]);
      printf(" %d\nB", status);

      ffgcvb(fptr, 4, ii, 1, ii, 99, boutarray, &anynull, &status);
      for (jj = 0; jj < ii; jj++)
        printf(" %2d", boutarray[jj]);
      printf(" %d\nI", status);

      ffgcvi(fptr, 5, ii, 1, ii, 99, ioutarray, &anynull, &status); 
      for (jj = 0; jj < ii; jj++)
        printf(" %2d", ioutarray[jj]);
      printf(" %d\nJ", status);

      ffgcvj(fptr, 6, ii, 1, ii, 99, joutarray, &anynull, &status); 
      for (jj = 0; jj < ii; jj++)
        printf(" %2ld", joutarray[jj]);
      printf(" %d\nE", status);

      ffgcve(fptr, 7, ii, 1, ii, 99., eoutarray, &anynull, &status);
      for (jj = 0; jj < ii; jj++)
        printf(" %2.0f", eoutarray[jj]);
      printf(" %d\nD", status);

      ffgcvd(fptr, 8, ii, 1, ii, 99., doutarray, &anynull, &status);
      for (jj = 0; jj < ii; jj++)
        printf(" %2.0f", doutarray[jj]);
      printf(" %d\n", status);

      ffgdes(fptr, 8, ii, &repeat, &offset, &status);
      printf("Column 8 repeat and offset = %ld %ld\n", repeat, offset);
    }

    /*
      #####################################
      #  create another image extension   #
      #####################################
    */

    bitpix = 32;
    naxis = 2;
    naxes[0] = 10;
    naxes[1] = 2;
    npixels = 20;
 
/*    ffcrim(fptr, bitpix, naxis, naxes, &status); */
    ffiimg(fptr, bitpix, naxis, naxes, &status);
    printf("\nffcrim status = %d\n", status);

    /* initialize arrays of values to write to primary array */
    for (ii = 0; ii < npixels; ii++)
    {
        boutarray[ii] = (unsigned char) (ii * 2);
        ioutarray[ii] = (short) (ii * 2);
        joutarray[ii] = ii * 2;
        koutarray[ii] = ii * 2;
        eoutarray[ii] = (float) (ii * 2);
        doutarray[ii] = ii * 2;
    }

    /* write a few pixels with each datatype */
    ffppr(fptr, TBYTE,   1,  2, &boutarray[0],  &status);
    ffppr(fptr, TSHORT,  3,  2, &ioutarray[2],  &status);
    ffppr(fptr, TINT,    5,  2, &koutarray[4],  &status);
    ffppr(fptr, TSHORT,  7,  2, &ioutarray[6],  &status);
    ffppr(fptr, TLONG,   9,  2, &joutarray[8],  &status);
    ffppr(fptr, TFLOAT,  11, 2, &eoutarray[10], &status);
    ffppr(fptr, TDOUBLE, 13, 2, &doutarray[12], &status);
    printf("ffppr status = %d\n", status);

    /* read back the pixels with each datatype */
    bnul = 0;
    inul = 0;
    knul = 0;
    jnul = 0;
    enul = 0.;
    dnul = 0.;

    ffgpv(fptr, TBYTE,   1,  14, &bnul, binarray, &anynull, &status);
    ffgpv(fptr, TSHORT,  1,  14, &inul, iinarray, &anynull, &status);
    ffgpv(fptr, TINT,    1,  14, &knul, kinarray, &anynull, &status);
    ffgpv(fptr, TLONG,   1,  14, &jnul, jinarray, &anynull, &status);
    ffgpv(fptr, TFLOAT,  1,  14, &enul, einarray, &anynull, &status);
    ffgpv(fptr, TDOUBLE, 1,  14, &dnul, dinarray, &anynull, &status);

    printf("\nImage values written with ffppr and read with ffgpv:\n");
    npixels = 14;
    for (ii = 0; ii < npixels; ii++)
        printf(" %2d", binarray[ii]);
    printf("  %d (byte)\n", anynull);  
    for (ii = 0; ii < npixels; ii++)
        printf(" %2d", iinarray[ii]);
    printf("  %d (short)\n", anynull);  
    for (ii = 0; ii < npixels; ii++)
        printf(" %2d", kinarray[ii]);
    printf("  %d (int)\n", anynull); 
    for (ii = 0; ii < npixels; ii++)
        printf(" %2ld", jinarray[ii]);
    printf("  %d (long)\n", anynull); 
    for (ii = 0; ii < npixels; ii++)
        printf(" %2.0f", einarray[ii]);
    printf("  %d (float)\n", anynull);
    for (ii = 0; ii < npixels; ii++)
        printf(" %2.0f", dinarray[ii]);
    printf("  %d (double)\n", anynull);

    /*
      ##########################################
      #  test world coordinate system routines #
      ##########################################
    */

    xrval = 45.83;
    yrval =  63.57;
    xrpix =  256.;
    yrpix =  257.;
    xinc =   -.00277777;
    yinc =   .00277777;

    /* write the WCS keywords */
    /* use example values from the latest WCS document */
    ffpkyd(fptr, "CRVAL1", xrval, 10, "comment", &status);
    ffpkyd(fptr, "CRVAL2", yrval, 10, "comment", &status);
    ffpkyd(fptr, "CRPIX1", xrpix, 10, "comment", &status);
    ffpkyd(fptr, "CRPIX2", yrpix, 10, "comment", &status);
    ffpkyd(fptr, "CDELT1", xinc, 10, "comment", &status);
    ffpkyd(fptr, "CDELT2", yinc, 10, "comment", &status);
 /*   ffpkyd(fptr, "CROTA2", rot, 10, "comment", &status); */
    ffpkys(fptr, "CTYPE1", xcoordtype, "comment", &status);
    ffpkys(fptr, "CTYPE2", ycoordtype, "comment", &status);
    printf("\nWrote WCS keywords status = %d\n",status);

    xrval =  0.;
    yrval =  0.;
    xrpix =  0.;
    yrpix =  0.;
    xinc =   0.;
    yinc =   0.;
    rot =    0.;

    ffgics(fptr, &xrval, &yrval, &xrpix,
           &yrpix, &xinc, &yinc, &rot, ctype, &status);
    printf("Read WCS keywords with ffgics status = %d\n",status);

    xpix = 0.5;
    ypix = 0.5;

    ffwldp(xpix,ypix,xrval,yrval,xrpix,yrpix,xinc,yinc,rot,ctype,
           &xpos, &ypos,&status);

    printf("  CRVAL1, CRVAL2 = %16.12f, %16.12f\n", xrval,yrval);
    printf("  CRPIX1, CRPIX2 = %16.12f, %16.12f\n", xrpix,yrpix);
    printf("  CDELT1, CDELT2 = %16.12f, %16.12f\n", xinc,yinc);
    printf("  Rotation = %10.3f, CTYPE = %s\n", rot, ctype);
    printf("Calculated sky coordinate with ffwldp status = %d\n",status);
    printf("  Pixels (%8.4f,%8.4f) --> (%11.6f, %11.6f) Sky\n",
            xpix,ypix,xpos,ypos);
    ffxypx(xpos,ypos,xrval,yrval,xrpix,yrpix,xinc,yinc,rot,ctype,
           &xpix, &ypix,&status);
    printf("Calculated pixel coordinate with ffxypx status = %d\n",status);
    printf("  Sky (%11.6f, %11.6f) --> (%8.4f,%8.4f) Pixels\n",
            xpos,ypos,xpix,ypix);
    /*
      ######################################
      #  append another ASCII table        #
      ######################################
    */

    strcpy(tform[0], "A15");
    strcpy(tform[1], "I11");
    strcpy(tform[2], "F15.6");
    strcpy(tform[3], "E13.5");
    strcpy(tform[4], "D22.14");

    strcpy(ttype[0], "Name");
    strcpy(ttype[1], "Ivalue");
    strcpy(ttype[2], "Fvalue");
    strcpy(ttype[3], "Evalue");
    strcpy(ttype[4], "Dvalue");

    strcpy(tunit[0], "");
    strcpy(tunit[1], "m**2");
    strcpy(tunit[2], "cm");
    strcpy(tunit[3], "erg/s");
    strcpy(tunit[4], "km/s");

    nrows = 11;
    tfields = 5;
    strcpy(tblname, "new_table");

    ffcrtb(fptr, ASCII_TBL, nrows, tfields, ttype, tform, tunit, tblname,
            &status);
    printf("\nffcrtb status = %d\n", status);

    extvers = 5;
    ffpkyj(fptr, "EXTVER", extvers, "extension version number", &status);

    ffpcl(fptr, TSTRING, 1, 1, 1, 3, onskey, &status);  /* write string values */

    /* initialize arrays of values to write */
    
    for (ii = 0; ii < npixels; ii++)
    {
        boutarray[ii] = (unsigned char) (ii * 3);
        ioutarray[ii] = (short) (ii * 3);
        joutarray[ii] = ii * 3;
        koutarray[ii] = ii * 3;
        eoutarray[ii] = (float) (ii * 3);
        doutarray[ii] = ii * 3;
    }

    for (ii = 2; ii < 6; ii++)   /* loop over cols 2 - 5 */
    {
        ffpcl(fptr, TBYTE,   ii, 1, 1, 2, boutarray,     &status); 
        ffpcl(fptr, TSHORT,  ii, 3, 1, 2, &ioutarray[2], &status);  
        ffpcl(fptr, TLONG,   ii, 5, 1, 2, &joutarray[4], &status);  
        ffpcl(fptr, TFLOAT,  ii, 7, 1, 2, &eoutarray[6], &status);
        ffpcl(fptr, TDOUBLE, ii, 9, 1, 2, &doutarray[8], &status); 
    }
    printf("ffpcl status = %d\n", status);

    /* read back the pixels with each datatype */
    ffgcv(fptr, TBYTE,   2, 1, 1, 10, &bnul, binarray, &anynull, &status);
    ffgcv(fptr, TSHORT,  2, 1, 1, 10, &inul, iinarray, &anynull, &status);
    ffgcv(fptr, TINT,    3, 1, 1, 10, &knul, kinarray, &anynull, &status);
    ffgcv(fptr, TLONG,   3, 1, 1, 10, &jnul, jinarray, &anynull, &status);
    ffgcv(fptr, TFLOAT,  4, 1, 1, 10, &enul, einarray, &anynull, &status);
    ffgcv(fptr, TDOUBLE, 5, 1, 1, 10, &dnul, dinarray, &anynull, &status);

    printf("\nColumn values written with ffpcl and read with ffgcl:\n");
    npixels = 10;
    for (ii = 0; ii < npixels; ii++)
        printf(" %2d", binarray[ii]);
    printf("  %d (byte)\n", anynull);  
    for (ii = 0; ii < npixels; ii++)
        printf(" %2d", iinarray[ii]);
    printf("  %d (short)\n", anynull);

    for (ii = 0; ii < npixels; ii++)
        printf(" %2d", kinarray[ii]);
    printf("  %d (int)\n", anynull); 

    for (ii = 0; ii < npixels; ii++)
        printf(" %2ld", jinarray[ii]);
    printf("  %d (long)\n", anynull); 
    for (ii = 0; ii < npixels; ii++)
        printf(" %2.0f", einarray[ii]);
    printf("  %d (float)\n", anynull);
    for (ii = 0; ii < npixels; ii++)
        printf(" %2.0f", dinarray[ii]);
    printf("  %d (double)\n", anynull);

    /*
      ###########################################################
      #  perform stress test by cycling thru all the extensions #
      ###########################################################
    */
    printf("\nRepeatedly move to the 1st 4 HDUs of the file:\n");
    for (ii = 0; ii < 10; ii++)
    {
      ffmahd(fptr,  1, &hdutype, &status);
      printf("%d", ffghdn(fptr, &hdunum));
      ffmrhd(fptr,  1, &hdutype, &status);
      printf("%d", ffghdn(fptr, &hdunum));
      ffmrhd(fptr,  1, &hdutype, &status);
      printf("%d", ffghdn(fptr, &hdunum));
      ffmrhd(fptr,  1, &hdutype, &status);
      printf("%d", ffghdn(fptr, &hdunum));
      ffmrhd(fptr, -1, &hdutype, &status);
      printf("%d", ffghdn(fptr, &hdunum));
      if (status > 0)
         break;
    }
    printf("\n");

    printf("Move to extensions by name and version number: (ffmnhd)\n");
    extvers = 1;
    ffmnhd(fptr, ANY_HDU, binname, (int) extvers, &status);
    ffghdn(fptr, &hdunum);
    printf(" %s, %ld = hdu %d, %d\n", binname, extvers, hdunum, status);
    extvers = 3;
    ffmnhd(fptr, ANY_HDU, binname, (int) extvers, &status);
    ffghdn(fptr, &hdunum);
    printf(" %s, %ld = hdu %d, %d\n", binname, extvers, hdunum, status);
    extvers = 4;
    ffmnhd(fptr, ANY_HDU, binname, (int) extvers, &status);
    ffghdn(fptr, &hdunum);
    printf(" %s, %ld = hdu %d, %d\n", binname, extvers, hdunum, status);


    strcpy(tblname, "Test-ASCII");
    extvers = 2;
    ffmnhd(fptr, ANY_HDU, tblname, (int) extvers, &status);
    ffghdn(fptr, &hdunum);
    printf(" %s, %ld = hdu %d, %d\n", tblname, extvers, hdunum, status);

    strcpy(tblname, "new_table");
    extvers = 5;
    ffmnhd(fptr, ANY_HDU, tblname, (int) extvers, &status);
    ffghdn(fptr, &hdunum);
    printf(" %s, %ld = hdu %d, %d\n", tblname, extvers, hdunum, status);
    extvers = 0;
    ffmnhd(fptr, ANY_HDU, binname, (int) extvers, &status);
    ffghdn(fptr, &hdunum);
    printf(" %s, %ld = hdu %d, %d\n", binname, extvers, hdunum, status);
    extvers = 17;
    ffmnhd(fptr, ANY_HDU, binname, (int) extvers, &status);
    ffghdn(fptr, &hdunum);
    printf(" %s, %ld = hdu %d, %d", binname, extvers, hdunum, status);
    printf (" (expect a 301 error status here)\n");
    status = 0;

    ffthdu(fptr, &hdunum, &status);
    printf("Total number of HDUs in the file = %d\n", hdunum);
    /*
      ########################
      #  checksum tests      #
      ########################
    */
    checksum = 1234567890;
    ffesum(checksum, 0, asciisum);
    printf("\nEncode checksum: %lu -> %s\n", checksum, asciisum);
    checksum = 0;
    ffdsum(asciisum, 0, &checksum);
    printf("Decode checksum: %s -> %lu\n", asciisum, checksum);

    ffpcks(fptr, &status);

    /*
       don't print the CHECKSUM value because it is different every day
       because the current date is in the comment field.

       ffgcrd(fptr, "CHECKSUM", card, &status);
       printf("%s\n", card);
    */

    ffgcrd(fptr, "DATASUM", card, &status);
    printf("%.30s\n", card);

    ffgcks(fptr, &datsum, &checksum, &status);
    printf("ffgcks data checksum, status = %lu, %d\n",
            datsum, status);

    ffvcks(fptr, &datastatus, &hdustatus, &status); 
    printf("ffvcks datastatus, hdustatus, status = %d %d %d\n",
              datastatus, hdustatus, status);
 
    ffprec(fptr,
    "new_key = 'written by fxprec' / to change checksum", &status);
    ffupck(fptr, &status);
    printf("ffupck status = %d\n", status);

    ffgcrd(fptr, "DATASUM", card, &status);
    printf("%.30s\n", card);
    ffvcks(fptr, &datastatus, &hdustatus, &status); 
    printf("ffvcks datastatus, hdustatus, status = %d %d %d\n",
              datastatus, hdustatus, status);
 
    /*
      delete the checksum keywords, so that the FITS file is always
      the same, regardless of the date of when testprog is run.
    */

    ffdkey(fptr, "CHECKSUM", &status);
    ffdkey(fptr, "DATASUM",  &status);

    /*
      ############################
      #  close file and quit     #
      ############################
    */

 errstatus:  /* jump here on error */

    ffclos(fptr, &status); 
    printf("ffclos status = %d\n", status);

    printf("\nNormally, there should be 8 error messages on the stack\n");
    printf("all regarding 'numerical overflows':\n");

    ffgmsg(errmsg);
    nmsg = 0;

    while (errmsg[0])
    {
        printf(" %s\n", errmsg);
        nmsg++;
        ffgmsg(errmsg);
    }

    if (nmsg != 8)
        printf("\nWARNING: Did not find the expected 8 error messages!\n");

    ffgerr(status, errmsg);
    printf("\nStatus = %d: %s\n", status, errmsg);

    /* free the allocated memory */
    for (ii = 0; ii < 21; ii++) 
        free(inskey[ii]);   
    for (ii = 0; ii < 10; ii++)
    {
      free(ttype[ii]);
      free(tform[ii]);
      free(tunit[ii]);
    }

    return(status);
}

healpy-1.10.3/cfitsio/testprog.out0000664000175000017500000007673713010375005017404 0ustar  zoncazonca00000000000000CFITSIO TESTPROG

Try opening then closing a nonexistent file:
  ffopen fptr, status  = 0 104 (expect an error)
  ffclos status = 115

ffinit create new file status = 0
Name of file = testprog.fit, I/O mode = 1

test writing of long string keywords:
 123456789012345678901234567890123456789012345678901234567890123456789012345
'12345678901234567890123456789012345678901234567890123456789012345678'
 1234567890123456789012345678901234567890123456789012345678901234'6789012345
'1234567890123456789012345678901234567890123456789012345678901234''67'
 1234567890123456789012345678901234567890123456789012345678901234''789012345
'1234567890123456789012345678901234567890123456789012345678901234'''''
 1234567890123456789012345678901234567890123456789012345678901234567'9012345
'1234567890123456789012345678901234567890123456789012345678901234567'
ffflus status = 0
HDU number = 1

Values read back from primary array (99 = null pixel)
The 1st, and every 4th pixel should be undefined:
 99  2  3 99  5  6  7 99  9 10 11 99 13 14 15 99 17 18 19 99  1 (ffgpvb)
 99  2  3 99  5  6  7 99  9 10 11 99 13 14 15 99 17 18 19 99  1 (ffgpvi)
 99  2  3 99  5  6  7 99  9 10 11 99 13 14 15 99 17 18 19 99  1 (ffgpvj)
 99  2  3 99  5  6  7 99  9 10 11 99 13 14 15 99 17 18 19 99  1 (ffgpve)
 99  2  3 99  5  6  7 99  9 10 11 99 13 14 15 99 17 18 19 99  1 (ffgpvd)
  *  2  3  *  5  6  7  *  9 10 11  * 13 14 15  * 17 18 19  *  1 (ffgpfb)
  *  2  3  *  5  6  7  *  9 10 11  * 13 14 15  * 17 18 19  *  1 (ffgpfi)
  *  2  3  *  5  6  7  *  9 10 11  * 13 14 15  * 17 18 19  *  1 (ffgpfj)
  *  2  3  *  5  6  7  *  9 10 11  * 13 14 15  * 17 18 19  *  1 (ffgpfe)
  *  2  3  *  5  6  7  *  9 10 11  * 13 14 15  * 17 18 19  *  1 (ffgpfd)

Closed then reopened the FITS file 10 times.
HDU number = 1
Name of file = testprog.fit, I/O mode = 1

Read back keywords:
simple = 1, bitpix = 32, naxis = 2, naxes = (10, 2)
  pcount = 0, gcount = 1, extend = 1
KEY_PREC= 'This keyword was written by fxprec' / comment goes here
KEY_PREC : 'This keyword was written by fxprec' : comment goes here :
KEY_PREC= 'This keyword was written by fxprec' / comment goes here
KY_PKNS1 : 'first string' : fxpkns comment :
KEY_PKYS value_string fxpkys comment 0
KEY_PKYL 1 fxpkyl comment 0
KEY_PKYJ 11 fxpkyj comment 0
KEY_PKYJ 11.000000 fxpkyj comment 0
KEY_PKYJ 11.000000 fxpkyj comment 0
KEY_PKY S value_string fxpkys comment 0
KEY_PKY L 1 fxpkyl comment 0
KEY_PKY BYTE 11 fxpkyj comment 0
KEY_PKY SHORT 11 fxpkyj comment 0
KEY_PKY INT 11 fxpkyj comment 0
KEY_PKY J 11 fxpkyj comment 0
KEY_PKY E 13.131310 fxpkye comment 0
KEY_PKY D 15.151515 fxpkyd comment 0
KEY_PKYF 12.121210 fxpkyf comment 0
KEY_PKYE 13.131310 fxpkye comment 0
KEY_PKYG 14.14141414141414 fxpkyg comment 0
KEY_PKYD 15.15151515151520 fxpkyd comment 0
KEY_PKYC 13.131310 14.141410 fxpkyc comment 0
KEY_PKFC 13.131313 14.141414 fxpkfc comment 0
KEY_PKYM 15.151515 16.161616 fxpkym comment 0
KEY_PKFM 15.151515 16.161616 fxpkfm comment 0
KEY_PKYT 12345678 0.12345678901235 fxpkyt comment 0
KEY_PKY J 11 [km/s/Mpc] fxpkyj comment 0
KEY_PKY units = km/s/Mpc
KEY_PKY J 11 fxpkyj comment 0
KEY_PKY units = 
KEY_PKY J 11 [feet/second/second] fxpkyj comment 0
KEY_PKY units = feet/second/second
KEY_PKLS long string value = 
This is a very long string value that is continued over more than one keyword.
header contains 65 keywords; located at keyword 27 
ffgkns:  first string, second string, 
ffgknl:  1, 0, 1
ffgknj:  11, 12, 13
ffgkne:  13.131310, 14.141410, 15.151520
ffgknd:  15.151515, 16.161616, 17.171717

Before deleting the HISTORY and DATE keywords...
COMMENT 
HISTORY 
DATE    
KY_PKNS1

After deleting the keywords...
COMMENT   This keyword was written by fxpcom.
KY_PKNS1= 'first string'       / fxpkns comment

After inserting the keywords...
COMMENT   This keyword was written by fxpcom.
KY_IREC = 'This keyword inserted by fxirec'
KY_IKYS = 'insert_value_string' / ikys comment
KY_IKYJ =                   49 / ikyj comment
KY_IKYL =                    T / ikyl comment
KY_IKYE =           1.2346E+01 / ikye comment
KY_IKYD = 1.23456789012346E+01 / ikyd comment
KY_IKYF =              12.3456 / ikyf comment
KY_IKYG =     12.3456789012346 / ikyg comment
KY_PKNS1= 'first string'       / fxpkns comment

After modifying the keywords...
COMMENT   This keyword was modified by fxmrec
KY_MREC = 'This keyword was modified by fxmcrd'
NEWIKYS = 'modified_string'    / ikys comment
KY_IKYJ =                   50 / This is a modified comment
KY_IKYL =                    F / ikyl comment
KY_IKYE =          -1.2346E+01 / ikye comment
KY_IKYD = -1.23456789012346E+01 / modified comment
KY_IKYF =             -12.3456 / ikyf comment
KY_IKYG =    -12.3456789012346 / ikyg comment
KY_PKNS1= 'first string'       / fxpkns comment

After updating the keywords...
COMMENT   This keyword was modified by fxmrec
KY_UCRD = 'This keyword was updated by fxucrd'
NEWIKYS = 'updated_string'     / ikys comment
KY_IKYJ =                   51 / This is a modified comment
KY_IKYL =                    T / ikyl comment
KY_IKYE =          -1.3346E+01 / ikye comment
KY_IKYD = -1.33456789012346E+01 / modified comment
KY_IKYF =             -13.3456 / ikyf comment
KY_IKYG =    -13.3456789012346 / ikyg comment
KY_PKNS1= 'first string'       / fxpkns comment

Keywords found using wildcard search (should be 13)...
KEY_PKYS= 'value_string'       / fxpkys comment
KEY_PKYL=                    T / fxpkyl comment
KEY_PKYJ=                   11 / [feet/second/second] fxpkyj comment
KEY_PKYF=             12.12121 / fxpkyf comment
KEY_PKYE=         1.313131E+01 / fxpkye comment
KEY_PKYG=    14.14141414141414 / fxpkyg comment
KEY_PKYD= 1.51515151515152E+01 / fxpkyd comment
KEY_PKYC= (1.313131E+01, 1.414141E+01) / fxpkyc comment
KEY_PKYM= (1.51515151515152E+01, 1.61616161616162E+01) / fxpkym comment
KEY_PKFC= (13.131313, 14.141414) / fxpkfc comment
KEY_PKFM= (15.15151515151515, 16.16161616161616) / fxpkfm comment
KEY_PKYT= 12345678.1234567890123456 / fxpkyt comment
NEWIKYS = 'updated_string'     / ikys comment

Copied keyword: ffgkne:  14.141410, 15.151520, 13.131310
Updated header using template file (ffpktp)

ffibin status = 0
HDU number = 2
header contains 33 keywords; located at keyword 1 
header contains 33 keywords with room for 74 more
TDIM3 = (1,2,8), 3, 1, 2, 8
ffpcl_ status = 0

Find the column numbers; a returned status value of 237 is
expected and indicates that more than one column name matches
the input column name template.  Status = 219 indicates that
there was no matching column name.
Column Xvalue is number 3; status = 0.
Column Avalue is number 1; status = 237.
Column Lvalue is number 2; status = 237.
Column Xvalue is number 3; status = 237.
Column Bvalue is number 4; status = 237.
Column Ivalue is number 5; status = 237.
Column Jvalue is number 6; status = 237.
Column Evalue is number 7; status = 237.
Column Dvalue is number 8; status = 237.
Column Cvalue is number 9; status = 237.
Column Mvalue is number 10; status = 237.
Column  is number 0; status = 219.

Information about each column:
 15A  16 15 15 Avalue, , A, 15, 1.000000, 0.000000, 1234554321, .
  1L  14  1  1 Lvalue, m**2, L, 1, 1.000000, 0.000000, 1234554321, .
 16X   1 16  1 Xvalue, cm, X, 16, 1.000000, 0.000000, 1234554321, .
  1B  11  1  1 Bvalue, erg/s, B, 1, 1.000000, 0.000000, 99, .
  1I  21  1  2 Ivalue, km/s, I, 1, 1.000000, 0.000000, 99, .
  1J  41  1  4 Jvalue, , J, 1, 1.000000, 0.000000, 99, .
  1E  42  1  4 Evalue, , E, 1, 1.000000, 0.000000, 1234554321, .
  1D  82  1  8 Dvalue, , D, 1, 1.000000, 0.000000, 1234554321, .
  1C  83  1  8 Cvalue, , C, 1, 1.000000, 0.000000, 1234554321, .
  1M 163  1 16 Mvalue, , M, 1, 1.000000, 0.000000, 1234554321, .

ffitab status = 0
HDU number = 2
ffpcl_ status = 0

ASCII table: rowlen, nrows, tfields, extname: 76 11 5 Test-ASCII
    Name   1      A15          
  Ivalue  17      I10     m**2 
  Fvalue  28    F14.6       cm 
  Evalue  43    E12.5    erg/s 
  Dvalue  56   D21.14     km/s 

Data values read from ASCII table:
   first string  1  1  1  1.0  1.0
  second string  2  2  2  2.0  2.0
                 3  3  3  3.0  3.0
      UNDEFINED  4  4  4  4.0  4.0
                 5  5  5  5.0  5.0
                 6  6  6  6.0  6.0
                 7  7  7  7.0  7.0
                 8  8  8  8.0  8.0
                 9  9  9  9.0  9.0
                10 10 10 10.0 10.0
                99 99 99 99.0 99.0

      1       1.000000  1.00000E+00  1.00000000000000E+00second string        

Column name is number 1; status = 0.
Column Ivalue is number 2; status = 237.
Column Fvalue is number 3; status = 237.
Column Evalue is number 4; status = 237.
Column Dvalue is number 5; status = 237.
Column  is number 0; status = 219.
 A15  16  1 15 Name, 1, , A15, 1.000000, 0.000000, null1, .
 I10  41  1 10 Ivalue, 17, m**2, I10, 1.000000, 0.000000, null2, .
F14.6  82  1 14 Fvalue, 28, cm, F14.6, 1.000000, 0.000000, null3, .
E12.5  42  1 12 Evalue, 43, erg/s, E12.5, 1.000000, 0.000000, null4, .
D21.14  82  1 21 Dvalue, 56, km/s, D21.14, 1.000000, 0.000000, null5, .


Data values after inserting 3 rows after row 2:
   first string  1  1  1  1.0  1.0
  second string  2  2  2  2.0  2.0
                 0  0  0  0.0  0.0
                 0  0  0  0.0  0.0
                 0  0  0  0.0  0.0
                 3  3  3  3.0  3.0
      UNDEFINED  4  4  4  4.0  4.0
                 5  5  5  5.0  5.0
                 6  6  6  6.0  6.0
                 7  7  7  7.0  7.0
                 8  8  8  8.0  8.0
                 9  9  9  9.0  9.0
                10 10 10 10.0 10.0
                99 99 99 99.0 99.0

Data values after deleting 2 rows at row 10:
   first string  1  1  1  1.0  1.0
  second string  2  2  2  2.0  2.0
                 0  0  0  0.0  0.0
                 0  0  0  0.0  0.0
                 0  0  0  0.0  0.0
                 3  3  3  3.0  3.0
      UNDEFINED  4  4  4  4.0  4.0
                 5  5  5  5.0  5.0
                 6  6  6  6.0  6.0
                 9  9  9  9.0  9.0
                10 10 10 10.0 10.0
                99 99 99 99.0 99.0

Data values after deleting column 3:
   first string  1  1  1.0  1.0
  second string  2  2  2.0  2.0
                 0  0  0.0  0.0
                 0  0  0.0  0.0
                 0  0  0.0  0.0
                 3  3  3.0  3.0
      UNDEFINED  4  4  4.0  4.0
                 5  5  5.0  5.0
                 6  6  6.0  6.0
                 9  9  9.0  9.0
                10 10 10.0 10.0
                99 99 99.0 99.0

Data values after inserting column 5:
   first string  1  1  1.0  1.0 0
  second string  2  2  2.0  2.0 0
                 0  0  0.0  0.0 0
                 0  0  0.0  0.0 0
                 0  0  0.0  0.0 0
                 3  3  3.0  3.0 0
      UNDEFINED  4  4  4.0  4.0 0
                 5  5  5.0  5.0 0
                 6  6  6.0  6.0 0
                 9  9  9.0  9.0 0
                10 10 10.0 10.0 0
                99 99 99.0 99.0 0
Create temporary file: ffinit status = 0

Create null primary array: ffiimg status = 0

Create ASCII table with 0 columns: ffitab status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0

Create Binary table with 0 columns: ffibin status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
Delete the tmp file: ffdelt status = 0
HDU number = 3
header contains 38 keywords with room for 69 more

Binary table: nrows, tfields, extname, pcount: 21 10 Test-BINTABLE 0
  Avalue      15A          
  Lvalue       1L     m**2 
  Xvalue      16X       cm 
  Bvalue       1B    erg/s 
  Ivalue       1I     km/s 
  Jvalue       1J          
  Evalue       1E          
  Dvalue       1D          
  Cvalue       1C          
  Mvalue       1M          

Data values read from binary table:
  Bit column (X) data values: 

01001100 01110000 11110000 01111100 00000000 

null string column value = -- (should be --)

Read columns with ffgcv_:
   first string 0  76  1   1   1   1.0   1.0 (  1.0, -2.0) (  1.0, -2.0) 
  second string 1 112  2   2   2   2.0   2.0 (  3.0, -4.0) (  3.0, -4.0) 
                0 240  3   3   3   3.0   3.0 (  5.0, -6.0) (  5.0, -6.0) 
    NOT DEFINED 0 124  0  -4  -4  -4.0  -4.0 (  7.0, -8.0) (  7.0, -8.0) 
    NOT DEFINED 1   0  5   5   5   5.0   5.0 (  9.0,-10.0) (  9.0,-10.0) 
    NOT DEFINED 1   0  0  -6  -6  -6.0  -6.0 ( 11.0,-12.0) ( 11.0,-12.0) 
    NOT DEFINED 0   0  7   7   7   7.0   7.0 ( 13.0,-14.0) ( 13.0,-14.0) 
    NOT DEFINED 0   0  0  -8  -8  -8.0  -8.0 ( 15.0,-16.0) ( 15.0,-16.0) 
    NOT DEFINED 0   0  9   9   9   9.0   9.0 ( 17.0,-18.0) ( 17.0,-18.0) 
    NOT DEFINED 1   0  0 -10 -10 -10.0 -10.0 ( 19.0,-20.0) ( 19.0,-20.0) 
    NOT DEFINED 0   0 98  98  98  98.0  98.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 1   0 12  12  12  12.0  12.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 0   0 98  98  98  98.0  98.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 0   0  0 -14 -14 -14.0 -14.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 0   0 98  98  98  98.0  98.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 0   0  0 -16 -16 -16.0 -16.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 1   0 98  98  98  98.0  98.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 1   0  0 -18 -18 -18.0 -18.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 1   0 98  98  98  98.0  98.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 1   0  0 -20 -20 -20.0 -20.0 (  0.0,  0.0) (  0.0,  0.0) 
    NOT DEFINED 0   0 98  98  98  98.0  98.0 (  0.0,  0.0) (  0.0,  0.0) 

Read columns with ffgcf_:
   first string 0  76  1   1   1   1.0   1.0 (  1.0, -2.0) (  1.0, -2.0)
  second string 1 112  2   2   2   2.0   2.0 (  3.0, -4.0) (  3.0, -4.0)
                0 240  3   3   3   3.0   3.0 (  5.0, -6.0) (  5.0, -6.0)
                0 124  0  -4  -4  -4.0  -4.0 (  7.0, -8.0) (  7.0, -8.0)
                1   0  5   5   5   5.0   5.0 (  9.0,-10.0) (  9.0,-10.0)
                1   0  0  -6  -6  -6.0  -6.0 ( 11.0,-12.0) ( 11.0,-12.0)
                0   0  7   7   7   7.0   7.0 ( 13.0,-14.0) ( 13.0,-14.0)
                0   0  0  -8  -8  -8.0  -8.0 ( 15.0,-16.0) ( 15.0,-16.0)
                0   0  9   9   9   9.0   9.0 ( 17.0,-18.0) ( 17.0,-18.0)
                1   0  0 -10 -10 -10.0 -10.0 ( 19.0,-20.0) ( 19.0,-20.0)
                0   0 99  99 
                1   0 12  12 
                0   0 99  99 
                0   0  0 -14 
                0   0 99  99 
                0   0  0 -16 
                1   0 99  99 
                1   0  0 -18 
                1   0 99  99 
                1   0  0 -20 
                0   0 99  99 

Data values after inserting 3 rows after row 2:
   first string  1   1   1   1.0   1.0
  second string  2   2   2   2.0   2.0
    NOT DEFINED  0   0   0   0.0   0.0
    NOT DEFINED  0   0   0   0.0   0.0
    NOT DEFINED  0   0   0   0.0   0.0
                 3   3   3   3.0   3.0
    NOT DEFINED  0  -4  -4  -4.0  -4.0
    NOT DEFINED  5   5   5   5.0   5.0
    NOT DEFINED  0  -6  -6  -6.0  -6.0
    NOT DEFINED  7   7   7   7.0   7.0
    NOT DEFINED  0  -8  -8  -8.0  -8.0
    NOT DEFINED  9   9   9   9.0   9.0
    NOT DEFINED  0 -10 -10 -10.0 -10.0
    NOT DEFINED 98  98  98  98.0  98.0

Data values after deleting 2 rows at row 10:
   first string  1   1   1   1.0   1.0
  second string  2   2   2   2.0   2.0
    NOT DEFINED  0   0   0   0.0   0.0
    NOT DEFINED  0   0   0   0.0   0.0
    NOT DEFINED  0   0   0   0.0   0.0
                 3   3   3   3.0   3.0
    NOT DEFINED  0  -4  -4  -4.0  -4.0
    NOT DEFINED  5   5   5   5.0   5.0
    NOT DEFINED  0  -6  -6  -6.0  -6.0
    NOT DEFINED  9   9   9   9.0   9.0
    NOT DEFINED  0 -10 -10 -10.0 -10.0
    NOT DEFINED 98  98  98  98.0  98.0

Data values after deleting column 6:
   first string  1   1   1.0   1.0
  second string  2   2   2.0   2.0
    NOT DEFINED  0   0   0.0   0.0
    NOT DEFINED  0   0   0.0   0.0
    NOT DEFINED  0   0   0.0   0.0
                 3   3   3.0   3.0
    NOT DEFINED  0  -4  -4.0  -4.0
    NOT DEFINED  5   5   5.0   5.0
    NOT DEFINED  0  -6  -6.0  -6.0
    NOT DEFINED  9   9   9.0   9.0
    NOT DEFINED  0 -10 -10.0 -10.0
    NOT DEFINED 98  98  98.0  98.0

Data values after inserting column 8:
   first string  1   1   1.0   1.0 0
  second string  2   2   2.0   2.0 0
    NOT DEFINED  0   0   0.0   0.0 0
    NOT DEFINED  0   0   0.0   0.0 0
    NOT DEFINED  0   0   0.0   0.0 0
                 3   3   3.0   3.0 0
    NOT DEFINED  0  -4  -4.0  -4.0 0
    NOT DEFINED  5   5   5.0   5.0 0
    NOT DEFINED  0  -6  -6.0  -6.0 0
    NOT DEFINED  9   9   9.0   9.0 0
    NOT DEFINED  0 -10 -10.0 -10.0 0
    NOT DEFINED 98  98  98.0  98.0 0

Values after setting 1st 10 elements in column 8 = null:
   first string  1   1   1.0   1.0 98
  second string  2   2   2.0   2.0 98
    NOT DEFINED  0   0   0.0   0.0 98
    NOT DEFINED  0   0   0.0   0.0 98
    NOT DEFINED  0   0   0.0   0.0 98
                 3   3   3.0   3.0 98
    NOT DEFINED  0  -4  -4.0  -4.0 98
    NOT DEFINED  5   5   5.0   5.0 98
    NOT DEFINED  0  -6  -6.0  -6.0 98
    NOT DEFINED  9   9   9.0   9.0 98
    NOT DEFINED  0 -10 -10.0 -10.0 0
    NOT DEFINED 98  98  98.0  98.0 0
Create temporary file: ffinit status = 0

Create null primary array: ffiimg status = 0

Create binary table with 0 columns: ffibin status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
copy column, ffcpcl status = 0
Delete the tmp file: ffdelt status = 0
ffibin status = 0
HDU number = 2
      0   1000  10000  33000  66000   -999
      0   1000  10000  32768  65535   -999
      0   1000  10000  32800  65500   -999

      0      1     10     33     66   -999
 -32768 -31768 -22768      0  32767   -999
     -1      9     99    327    654   -999

Create image extension: ffiimg status = 0
HDU number = 3

Wrote whole 2D array: ffp2di status = 0

Read whole 2D array: ffg2di status = 0
   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14   0   0   0   0
  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24   0   0   0   0
  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34   0   0   0   0
  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44   0   0   0   0
  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54   0   0   0   0
  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64   0   0   0   0
  60  61  62  63  64  65  66  67  68  69  70  71  72  73  74   0   0   0   0
  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84   0   0   0   0
  80  81  82  83  84  85  86  87  88  89  90  91  92  93  94   0   0   0   0
  90  91  92  93  94  95  96  97  98  99 100 101 102 103 104   0   0   0   0
 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114   0   0   0   0
 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124   0   0   0   0
 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134   0   0   0   0
 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144   0   0   0   0
 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154   0   0   0   0
 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164   0   0   0   0
 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174   0   0   0   0
 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184   0   0   0   0
 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194   0   0   0   0
 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204   0   0   0   0
 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214   0   0   0   0
 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224   0   0   0   0
 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234   0   0   0   0
 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244   0   0   0   0
 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0

Wrote subset 2D array: ffpssi status = 0

Read whole 2D array: ffg2di status = 0
   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14   0   0   0   0
  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24   0   0   0   0
  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34   0   0   0   0
  30  31  32  33  34  35  36  37  38  39  40  41  42  43  44   0   0   0   0
  40  41  42  43   0  -1  -2  -3  -4  -5  -6  -7  -8  -9  54   0   0   0   0
  50  51  52  53 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19  64   0   0   0   0
  60  61  62  63 -20 -21 -22 -23 -24 -25 -26 -27 -28 -29  74   0   0   0   0
  70  71  72  73 -30 -31 -32 -33 -34 -35 -36 -37 -38 -39  84   0   0   0   0
  80  81  82  83 -40 -41 -42 -43 -44 -45 -46 -47 -48 -49  94   0   0   0   0
  90  91  92  93 -50 -51 -52 -53 -54 -55 -56 -57 -58 -59 104   0   0   0   0
 100 101 102 103 -60 -61 -62 -63 -64 -65 -66 -67 -68 -69 114   0   0   0   0
 110 111 112 113 -70 -71 -72 -73 -74 -75 -76 -77 -78 -79 124   0   0   0   0
 120 121 122 123 -80 -81 -82 -83 -84 -85 -86 -87 -88 -89 134   0   0   0   0
 130 131 132 133 -90 -91 -92 -93 -94 -95 -96 -97 -98 -99 144   0   0   0   0
 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154   0   0   0   0
 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164   0   0   0   0
 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174   0   0   0   0
 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184   0   0   0   0
 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194   0   0   0   0
 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204   0   0   0   0
 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214   0   0   0   0
 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224   0   0   0   0
 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234   0   0   0   0
 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244   0   0   0   0
 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0

Read subset of 2D array: ffgsvi status = 0
  41  43  -1  -3  -5  71  73 -31 -33 -35

Create image extension: ffiimg status = 0
HDU number = 4
Create temporary file: ffinit status = 0
Copy image extension to primary array of tmp file.
ffcopy status = 0
SIMPLE  =                    T / file does conform to FITS standard
BITPIX  =                   16 / number of bits per data pixel
NAXIS   =                    2 / number of data axes
NAXIS1  =                   15 / length of data axis 1
NAXIS2  =                   25 / length of data axis 2
EXTEND  =                    T / FITS dataset may contain extensions
Delete the tmp file: ffdelt status = 0
Delete the image extension; hdutype, status = 1 0
HDU number = 4
ffcrhd status = 0
Variable length arrays: ffphbn status = 0
ffpcl_ status = 0
PCOUNT = 4446
HDU number = 6
A   0
L  0 0
X  0 0
B  1 0
I  1 0
J  1 0
E  1 0
D  1 0
Column 8 repeat and offset = 1 14
A ab 0
L  0  1 0
X  0  1 0
B 99  2 0
I 99  2 0
J 99  2 0
E 99  2 0
D 99  2 0
Column 8 repeat and offset = 2 49
A abc 0
L  0  0  0 0
X  0  1  0 0
B  1 99  3 0
I  1 99  3 0
J  1 99  3 0
E  1 99  3 0
D  1 99  3 0
Column 8 repeat and offset = 3 105
A abcd 0
L  0  1  0  0 0
X  0  1  0  0 0
B  1  2 99  4 0
I  1  2 99  4 0
J  1  2 99  4 0
E  1  2 99  4 0
D  1  2 99  4 0
Column 8 repeat and offset = 4 182
A abcde 0
L  0  1  0  0  1 0
X  0  1  0  0  1 0
B  1  2  3 99  5 0
I  1  2  3 99  5 0
J  1  2  3 99  5 0
E  1  2  3 99  5 0
D  1  2  3 99  5 0
Column 8 repeat and offset = 5 280
A abcdef 0
L  0  1  0  0  0  1 0
X  0  1  0  0  1  1 0
B  1  2  3  4 99  6 0
I  1  2  3  4 99  6 0
J  1  2  3  4 99  6 0
E  1  2  3  4 99  6 0
D  1  2  3  4 99  6 0
Column 8 repeat and offset = 6 399
A abcdefg 0
L  0  1  0  0  1  0  0 0
X  0  1  0  0  1  1  0 0
B  1  2  3  4  5 99  7 0
I  1  2  3  4  5 99  7 0
J  1  2  3  4  5 99  7 0
E  1  2  3  4  5 99  7 0
D  1  2  3  4  5 99  7 0
Column 8 repeat and offset = 7 539
A abcdefgh 0
L  0  1  0  0  1  1  0  0 0
X  0  1  0  0  1  1  0  0 0
B  1  2  3  4  5  6 99  8 0
I  1  2  3  4  5  6 99  8 0
J  1  2  3  4  5  6 99  8 0
E  1  2  3  4  5  6 99  8 0
D  1  2  3  4  5  6 99  8 0
Column 8 repeat and offset = 8 700
A abcdefghi 0
L  0  1  0  0  1  1  0  0  0 0
X  0  1  0  0  1  1  0  0  0 0
B  1  2  3  4  5  6  7 99  9 0
I  1  2  3  4  5  6  7 99  9 0
J  1  2  3  4  5  6  7 99  9 0
E  1  2  3  4  5  6  7 99  9 0
D  1  2  3  4  5  6  7 99  9 0
Column 8 repeat and offset = 9 883
A abcdefghij 0
L  0  1  0  0  1  1  0  0  0  1 0
X  0  1  0  0  1  1  0  0  0  1 0
B  1  2  3  4  5  6  7  8 99 10 0
I  1  2  3  4  5  6  7  8 99 10 0
J  1  2  3  4  5  6  7  8 99 10 0
E  1  2  3  4  5  6  7  8 99 10 0
D  1  2  3  4  5  6  7  8 99 10 0
Column 8 repeat and offset = 10 1087
A abcdefghijk 0
L  0  1  0  0  1  1  0  0  0  0  1 0
X  0  1  0  0  1  1  0  0  0  1  1 0
B  1  2  3  4  5  6  7  8  9 99 11 0
I  1  2  3  4  5  6  7  8  9 99 11 0
J  1  2  3  4  5  6  7  8  9 99 11 0
E  1  2  3  4  5  6  7  8  9 99 11 0
D  1  2  3  4  5  6  7  8  9 99 11 0
Column 8 repeat and offset = 11 1312
A abcdefghijkl 0
L  0  1  0  0  1  1  0  0  0  1  0  1 0
X  0  1  0  0  1  1  0  0  0  1  1  1 0
B  1  2  3  4  5  6  7  8  9 10 99 12 0
I  1  2  3  4  5  6  7  8  9 10 99 12 0
J  1  2  3  4  5  6  7  8  9 10 99 12 0
E  1  2  3  4  5  6  7  8  9 10 99 12 0
D  1  2  3  4  5  6  7  8  9 10 99 12 0
Column 8 repeat and offset = 12 1558
A abcdefghijklm 0
L  0  1  0  0  1  1  0  0  0  1  1  0  0 0
X  0  1  0  0  1  1  0  0  0  1  1  1  0 0
B  1  2  3  4  5  6  7  8  9 10 11 99 13 0
I  1  2  3  4  5  6  7  8  9 10 11 99 13 0
J  1  2  3  4  5  6  7  8  9 10 11 99 13 0
E  1  2  3  4  5  6  7  8  9 10 11 99 13 0
D  1  2  3  4  5  6  7  8  9 10 11 99 13 0
Column 8 repeat and offset = 13 1825
A abcdefghijklmn 0
L  0  1  0  0  1  1  0  0  0  1  1  1  0  0 0
X  0  1  0  0  1  1  0  0  0  1  1  1  0  0 0
B  1  2  3  4  5  6  7  8  9 10 11 12 99 14 0
I  1  2  3  4  5  6  7  8  9 10 11 12 99 14 0
J  1  2  3  4  5  6  7  8  9 10 11 12 99 14 0
E  1  2  3  4  5  6  7  8  9 10 11 12 99 14 0
D  1  2  3  4  5  6  7  8  9 10 11 12 99 14 0
Column 8 repeat and offset = 14 2113
A abcdefghijklmno 0
L  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0 0
X  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0 0
B  1  2  3  4  5  6  7  8  9 10 11 12 13 99 15 0
I  1  2  3  4  5  6  7  8  9 10 11 12 13 99 15 0
J  1  2  3  4  5  6  7  8  9 10 11 12 13 99 15 0
E  1  2  3  4  5  6  7  8  9 10 11 12 13 99 15 0
D  1  2  3  4  5  6  7  8  9 10 11 12 13 99 15 0
Column 8 repeat and offset = 15 2422
A abcdefghijklmnop 0
L  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0 0
X  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0 0
B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 99 16 0
I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 99 16 0
J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 99 16 0
E  1  2  3  4  5  6  7  8  9 10 11 12 13 14 99 16 0
D  1  2  3  4  5  6  7  8  9 10 11 12 13 14 99 16 0
Column 8 repeat and offset = 16 2752
A abcdefghijklmnopq 0
L  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0  1 0
X  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0  1 0
B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 99 17 0
I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 99 17 0
J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 99 17 0
E  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 99 17 0
D  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 99 17 0
Column 8 repeat and offset = 17 3104
A abcdefghijklmnopqr 0
L  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0  0  1 0
X  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0  1  1 0
B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 99 18 0
I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 99 18 0
J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 99 18 0
E  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 99 18 0
D  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 99 18 0
Column 8 repeat and offset = 18 3477
A abcdefghijklmnopqrs 0
L  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0  1  0  1 0
X  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0  1  1  1 0
B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 99 19 0
I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 99 19 0
J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 99 19 0
E  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 99 19 0
D  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 99 19 0
Column 8 repeat and offset = 19 3871
A abcdefghijklmnopqrst 0
L  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0  1  1  0  1 0
X  0  1  0  0  1  1  0  0  0  1  1  1  0  0  0  0  1  1  1  1 0
B  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 99 20 0
I  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 99 20 0
J  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 99 20 0
E  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 99 20 0
D  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 99 20 0
Column 8 repeat and offset = 20 4286

ffcrim status = 0
ffppr status = 0

Image values written with ffppr and read with ffgpv:
  0  2  4  6  8 10 12 14 16 18 20 22 24 26  0 (byte)
  0  2  4  6  8 10 12 14 16 18 20 22 24 26  0 (short)
  0  2  4  6  8 10 12 14 16 18 20 22 24 26  0 (int)
  0  2  4  6  8 10 12 14 16 18 20 22 24 26  0 (long)
  0  2  4  6  8 10 12 14 16 18 20 22 24 26  0 (float)
  0  2  4  6  8 10 12 14 16 18 20 22 24 26  0 (double)

Wrote WCS keywords status = 0
Read WCS keywords with ffgics status = 0
  CRVAL1, CRVAL2 =  45.830000000000,  63.570000000000
  CRPIX1, CRPIX2 = 256.000000000000, 257.000000000000
  CDELT1, CDELT2 =  -0.002777770000,   0.002777770000
  Rotation =      0.000, CTYPE = -TAN
Calculated sky coordinate with ffwldp status = 0
  Pixels (  0.5000,  0.5000) --> (  47.385204,   62.848968) Sky
Calculated pixel coordinate with ffxypx status = 0
  Sky (  47.385204,   62.848968) --> (  0.5000,  0.5000) Pixels

ffcrtb status = 0
ffpcl status = 0

Column values written with ffpcl and read with ffgcl:
  0  3  6  9 12 15 18 21 24 27  0 (byte)
  0  3  6  9 12 15 18 21 24 27  0 (short)
  0  3  6  9 12 15 18 21 24 27  0 (int)
  0  3  6  9 12 15 18 21 24 27  0 (long)
  0  3  6  9 12 15 18 21 24 27  0 (float)
  0  3  6  9 12 15 18 21 24 27  0 (double)

Repeatedly move to the 1st 4 HDUs of the file:
12343123431234312343123431234312343123431234312343
Move to extensions by name and version number: (ffmnhd)
 Test-BINTABLE, 1 = hdu 5, 0
 Test-BINTABLE, 3 = hdu 2, 0
 Test-BINTABLE, 4 = hdu 6, 0
 Test-ASCII, 2 = hdu 4, 0
 new_table, 5 = hdu 8, 0
 Test-BINTABLE, 0 = hdu 2, 0
 Test-BINTABLE, 17 = hdu 2, 301 (expect a 301 error status here)
Total number of HDUs in the file = 8

Encode checksum: 1234567890 -> dCW2fBU0dBU0dBU0
Decode checksum: dCW2fBU0dBU0dBU0 -> 1234567890
DATASUM = '475248536'         
ffgcks data checksum, status = 475248536, 0
ffvcks datastatus, hdustatus, status = 1 1 0
ffupck status = 0
DATASUM = '475248536'         
ffvcks datastatus, hdustatus, status = 1 1 0
ffclos status = 0

Normally, there should be 8 error messages on the stack
all regarding 'numerical overflows':
 Numerical overflow during type conversion while writing FITS data.
 Numerical overflow during type conversion while writing FITS data.
 Numerical overflow during type conversion while writing FITS data.
 Numerical overflow during type conversion while writing FITS data.
 Numerical overflow during type conversion while writing FITS data.
 Numerical overflow during type conversion while writing FITS data.
 Numerical overflow during type conversion while writing FITS data.
 Numerical overflow during type conversion while writing FITS data.

Status = 0: OK - no error
healpy-1.10.3/cfitsio/testprog.std0000664000175000017500000020700013010375005017342 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    2 / number of data axes                            NAXIS1  =                   10 / length of data axis 1                          NAXIS2  =                    2 / length of data axis 2                          EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H KEY_PREC= 'This keyword was written by fxprec' / comment goes here              CARD1   = '12345678901234567890123456789012345678901234567890123456789012345678'CARD2   = '1234567890123456789012345678901234567890123456789012345678901234''67'CARD3   = '1234567890123456789012345678901234567890123456789012345678901234'''''CARD4   = '1234567890123456789012345678901234567890123456789012345678901234567' KEY_PKYS= 'value_string'       / fxpkys comment                                 KEY_PKYL=                    T / fxpkyl comment                                 KEY_PKYJ=                   11 / [feet/second/second] fxpkyj comment            KEY_PKYF=             12.12121 / fxpkyf comment                                 KEY_PKYE=         1.313131E+01 / fxpkye comment                                 KEY_PKYG=    14.14141414141414 / fxpkyg comment                                 KEY_PKYD= 1.51515151515152E+01 / fxpkyd comment                                 KEY_PKYC= (1.313131E+01, 1.414141E+01) / fxpkyc comment                         KEY_PKYM= (1.51515151515152E+01, 1.61616161616162E+01) / fxpkym comment         KEY_PKFC= (13.131313, 14.141414) / fxpkfc comment                               KEY_PKFM= (15.15151515151515, 16.16161616161616) / fxpkfm comment               KEY_PKLS= 'This is a very long string value that is continued over more than o&'CONTINUE  'ne keyword.'        / fxpkls comment                                 LONGSTRN= 'OGIP 1.0'           / The HEASARC Long String Convention may be used.COMMENT   This FITS file may contain long string keyword values that are        COMMENT   continued over multiple keywords.  The HEASARC convention uses the &  COMMENT   character at the end of each substring which is then continued        COMMENT   on the next keyword which has the name CONTINUE.                      KEY_PKYT= 12345678.1234567890123456 / fxpkyt comment                            COMMENT   This keyword was modified by fxmrec                                   KY_UCRD = 'This keyword was updated by fxucrd'                                  NEWIKYS = 'updated_string'     / ikys comment                                   KY_IKYJ =                   51 / This is a modified comment                     KY_IKYL =                    T / ikyl comment                                   KY_IKYE =          -1.3346E+01 / ikye comment                                   KY_IKYD = -1.33456789012346E+01 / modified comment                              KY_IKYF =             -13.3456 / ikyf comment                                   KY_IKYG =    -13.3456789012346 / ikyg comment                                   KY_PKNS1= 'first string'       / fxpkns comment                                 KY_PKNS2= 'second string'      / fxpkns comment                                 KY_PKNS3= '        '           / fxpkns comment                                 KY_PKNL1=                    T / fxpknl comment                                 KY_PKNL2=                    F / fxpknl comment                                 KY_PKNL3=                    T / fxpknl comment                                 KY_PKNJ1=                   11 / fxpknj comment                                 KY_PKNJ2=                   12 / fxpknj comment                                 KY_PKNJ3=                   13 / fxpknj comment                                 KY_PKNF1=             12.12121 / fxpknf comment                                 KY_PKNF2=             13.13131 / fxpknf comment                                 KY_PKNF3=             14.14141 / fxpknf comment                                 KY_PKNE1=         1.313131E+01 / fxpkne comment                                 KY_PKNE2=         1.414141E+01 / fxpkne comment                                 KY_PKNE3=         1.515152E+01 / fxpkne comment                                 KY_PKNG1=     14.1414141414141 / fxpkng comment                                 KY_PKNG2=     15.1515151515152 / fxpkng comment                                 KY_PKNG3=     16.1616161616162 / fxpkng comment                                 KY_PKND1= 1.51515151515152E+01 / fxpknd comment                                 KY_PKND2= 1.61616161616162E+01 / fxpknd comment                                 KY_PKND3= 1.71717171717172E+01 / fxpknd comment                                 TSTRING = '1       '           / tstring comment                                TLOGICAL=                    T / tlogical comment                               TBYTE   =                   11 / tbyte comment                                  TSHORT  =                   21 / tshort comment                                 TINT    =                   31 / tint comment                                   TLONG   =                   41 / tlong comment                                  TFLOAT  =                  42. / tfloat comment                                 TDOUBLE =                  82. / tdouble comment                                BLANK   =                  -99 / value to use for undefined pixels              KY_PKNE4=         1.313131E+01 / fxpkne comment                                 TMPCARDA=                 1001 / this is the 1st template card                  TMPCARD2= 'ABCD    '           / this is the 2nd template card                  TMPCARD3=              1001.23 / this is the 3rd template card                  COMMENT this is the 5th template card                                           HISTORY this is the 6th template card                                           TMPCARD7=                      / comment for null keyword                       END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             	

XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   61 / width of table in bytes                        NAXIS2  =                   20 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                   10 / number of fields in each row                   TTYPE1  = 'Avalue  '           / label for field   1                            TFORM1  = '15A     '           / data format of field: ASCII Character          TTYPE2  = 'Lvalue  '           / label for field   2                            TFORM2  = '1L      '           / data format of field: 1-byte LOGICAL           TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Xvalue  '           / label for field   3                            TFORM3  = '16X     '           / data format of field: BIT                      TUNIT3  = 'cm      '           / physical unit of field                         TTYPE4  = 'Bvalue  '           / label for field   4                            TFORM4  = '1B      '           / data format of field: BYTE                     TUNIT4  = 'erg/s   '           / physical unit of field                         TTYPE5  = 'Ivalue  '           / label for field   5                            TFORM5  = '1I      '           / data format of field: 2-byte INTEGER           TUNIT5  = 'km/s    '           / physical unit of field                         TTYPE6  = 'Jvalue  '           / label for field   6                            TFORM6  = '1J      '           / data format of field: 4-byte INTEGER           TTYPE7  = 'Evalue  '           / label for field   7                            TFORM7  = '1E      '           / data format of field: 4-byte REAL              TTYPE8  = 'Dvalue  '           / label for field   8                            TFORM8  = '1D      '           / data format of field: 8-byte DOUBLE            TTYPE9  = 'Cvalue  '           / label for field   9                            TFORM9  = '1C      '           / data format of field: COMPLEX                  TTYPE10 = 'Mvalue  '           / label for field  10                            TFORM10 = '1M      '           / data format of field: DOUBLE COMPLEX           EXTNAME = 'Test-BINTABLE'      / name of this binary table extension            EXTVER  =                    3 / extension version number                       TNULL4  =                   77 / value for undefined pixels                     TNULL5  =                   77 / value for undefined pixels                     TNULL6  =                   77 / value for undefined pixels                     TSCAL4  =                 1000 / scaling factor                                 TSCAL5  =                    1 / scaling factor                                 TSCAL6  =                  100 / scaling factor                                 TZERO4  =                    0 / scaling offset                                 TZERO5  =                32768 / scaling offset                                 TZERO6  =                  100 / scaling offset                                 NEW_KEY = 'written by fxprec' / to change checksum                              END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             	
c!GBMMMXTENSION= 'IMAGE   '           / IMAGE extension                                BITPIX  =                  -32 / number of bits per data pixel                  NAXIS   =                    2 / number of data axes                            NAXIS1  =                   15 / length of data axis 1                          NAXIS2  =                   25 / length of data axis 2                          PCOUNT  =                    0 / required keyword; must = 0                     GCOUNT  =                    1 / required keyword; must = 1                     END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?@@@@@@@AAA A0A@APA`A A0A@APA`ApAAAAAAAAAAAAAAAAAAAAABBBAABBBBBBBBB B$B(B,B0B B$B(B,@BXBHBLBPBT 0@P`pBBpBtBxB|BBBBBBBBBB $(,048<@DBBBBBHLPTX\`dhlBBBBBptx|€‚„†ˆŠBBBBBŒŽ’”–˜šœžBBBBB ¢¤¦¨ª¬®°²CCCCC´¶¸º¼¾CCC
CCCCCCCCCCCCCCCCCCCCCCCC C!C"C#C$C C!C"C#C$C%C&C'C(C)C*C+C,C-C.C*C+C,C-C.C/C0C1C2C3C4C5C6C7C8C4C5C6C7C8C9C:C;C<C=C>C?C@CACBC>C?C@CACBCCCDCECFCGCHCICJCKCLCHCICJCKCLCMCNCOCPCQCRCSCTCUCVCRCSCTCUCVCWCXCYCZC[C\C]C^C_C`C\C]C^C_C`CaCbCcCdCeCfCgChCiCjCfCgChCiCjCkClCmCnCoCpCqCrCsCtCpCqCrCsCtCuCvCwCxCyCzC{C|C}C~XTENSION= 'TABLE   '           / ASCII table extension                          BITPIX  =                    8 / 8-bit ASCII characters                         NAXIS   =                    2 / 2-dimensional ASCII table                      NAXIS1  =                   76 / width of table in characters                   NAXIS2  =                   12 / number of rows in table                        PCOUNT  =                    0 / no group parameters (required keyword)         GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    5 / number of fields in each row                   TTYPE1  = 'Name    '           / label for field   1                            TBCOL1  =                    1 / beginning column of field   1                  TFORM1  = 'A15     '           / Fortran-77 format of field                     TTYPE2  = 'Ivalue  '           / label for field   2                            TBCOL2  =                   17 / beginning column of field   2                  TFORM2  = 'I10     '           / Fortran-77 format of field                     TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Evalue  '           / label for field   4                            TBCOL3  =                   28 / beginning column of field   4                  TFORM3  = 'E12.5   '           / Fortran-77 format of field                     TUNIT3  = 'erg/s   '           / physical unit of field                         TTYPE4  = 'Dvalue  '           / label for field   5                            TBCOL4  =                   41 / beginning column of field   5                  TFORM4  = 'D21.14  '           / Fortran-77 format of field                     TUNIT4  = 'km/s    '           / physical unit of field                         EXTNAME = 'Test-ASCII'         / name of this ASCII table extension             EXTVER  =                    2 / extension version number                       TNULL1  = 'null1   '           / value for undefined pixels                     TNULL2  = 'null2   '           / value for undefined pixels                     TNULL3  = 'null4   '           / value for undefined pixels                     TNULL4  = 'null5   '           / value for undefined pixels                     TTYPE5  = 'INSERT_COL'         / label for field                                TFORM5  = 'F14.6   '           / format of field                                TBCOL5  =                   63 / beginning column of field                      END                                                                                                                                                                                                                                                                                                                             first string             1  1.00000E+00  1.00000000000000E+00               second string            2  2.00000E+00  2.00000000000000E+00                                                                                                                                                                                                                                                                            3  3.00000E+00  3.00000000000000E+00               null1                    4  4.00000E+00  4.00000000000000E+00                                        5  5.00000E+00  5.00000000000000E+00                                        6  6.00000E+00  6.00000000000000E+00                                        9  9.00000E+00  9.00000000000000E+00                                       10  1.00000E+01  1.00000000000000E+01                               null2      null4        null5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   61 / width of table in bytes                        NAXIS2  =                   22 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                   10 / number of fields in each row                   TTYPE1  = 'Avalue  '           / label for field   1                            TFORM1  = '15A     '           / data format of field: ASCII Character          TTYPE2  = 'Lvalue  '           / label for field   2                            TFORM2  = '1L      '           / data format of field: 1-byte LOGICAL           TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Xvalue  '           / label for field   3                            TFORM3  = '16X     '           / data format of field: BIT                      TUNIT3  = 'cm      '           / physical unit of field                         TTYPE4  = 'Bvalue  '           / label for field   4                            TFORM4  = '1B      '           / data format of field: BYTE                     TUNIT4  = 'erg/s   '           / physical unit of field                         TTYPE5  = 'Ivalue  '           / label for field   5                            TFORM5  = '1I      '           / data format of field: 2-byte INTEGER           TUNIT5  = 'km/s    '           / physical unit of field                         TTYPE6  = 'Evalue  '           / label for field   7                            TFORM6  = '1E      '           / data format of field: 4-byte REAL              TTYPE7  = 'Dvalue  '           / label for field   8                            TFORM7  = '1D      '           / data format of field: 8-byte DOUBLE            TTYPE9  = 'Cvalue  '           / label for field   9                            TFORM9  = '1C      '           / data format of field: COMPLEX                  TTYPE10 = 'Mvalue  '           / label for field  10                            TFORM10 = '1M      '           / data format of field: DOUBLE COMPLEX           EXTNAME = 'Test-BINTABLE'      / name of this binary table extension            EXTVER  =                    1 / extension version number                       TNULL4  =                   99 / value for undefined pixels                     TNULL5  =                   99 / value for undefined pixels                     TDIM3   = '(1,2,8) '           / size of the multidimensional array             KEY_PREC= 'This keyword was written by f_prec' / comment here                   TTYPE8  = 'INSERT_COL'         / label for field                                TFORM8  = '1E      '           / format of field                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             first string   FLp????second string  T|@@@@@               F@@@@@              F@@ T@@A @"$TA0@@&(F		A@"A@12T $A@34ccTA@@(FccF`,FccF0TccT2TccT4FccXTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   80 / width of table in bytes                        NAXIS2  =                   20 / number of rows in table                        PCOUNT  =                 4446 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                   10 / number of fields in each row                   TTYPE1  = 'Avalue  '           / label for field   1                            TFORM1  = '1PA(20) '           / data format of field: variable length array    TTYPE2  = 'Lvalue  '           / label for field   2                            TFORM2  = '1PL(20) '           / data format of field: variable length array    TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Xvalue  '           / label for field   3                            TFORM3  = '1PB(3)  '           / data format of field: variable length array    TUNIT3  = 'cm      '           / physical unit of field                         TTYPE4  = 'Bvalue  '           / label for field   4                            TFORM4  = '1PB(20) '           / data format of field: variable length array    TUNIT4  = 'erg/s   '           / physical unit of field                         TTYPE5  = 'Ivalue  '           / label for field   5                            TFORM5  = '1PI(20) '           / data format of field: variable length array    TUNIT5  = 'km/s    '           / physical unit of field                         TTYPE6  = 'Jvalue  '           / label for field   6                            TFORM6  = '1PJ(20) '           / data format of field: variable length array    TTYPE7  = 'Evalue  '           / label for field   7                            TFORM7  = '1PE(20) '           / data format of field: variable length array    TTYPE8  = 'Dvalue  '           / label for field   8                            TFORM8  = '1PD(20) '           / data format of field: variable length array    TTYPE9  = 'Cvalue  '           / label for field   9                            TFORM9  = '1PC(0)  '           / data format of field: variable length array    TTYPE10 = 'Mvalue  '           / label for field  10                            TFORM10 = '1PM(0)  '           / data format of field: variable length array    EXTNAME = 'Test-BINTABLE'      / name of this binary table extension            EXTVER  =                    4 / extension version number                       TNULL4  =                   88 / value for undefined pixels                     TNULL5  =                   88 / value for undefined pixels                     TNULL6  =                   88 / value for undefined pixels                     END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
!)1ADGHKQ]i@FLMS_wS[cdl|					+	O	s






? x
v





!	A	:	v		


 
@

@Qbev 

M
%8KNanF??abT@XXX@@abcFF@XXX?@@?@abcdFTF@XXX?@@?@@abcdeFTFTHXXX?@@@@?@@@abcdefFTFFTLXXX?@@@@@?@@@@abcdefgFTFFTFLXXX?@@@@@@?@@@@@abcdefghFTFFTTFLXXX?@@@@@@A?@@@@@@ abcdefghiFTFFTTFFLX	X	X	?@@@@@@@A?@@@@@@@"abcdefghijFTFFTTFFTL@X
X
X
?@@@@@@@AA ?@@@@@@@ @$abcdefghijkFTFFTTFFFTL`	X	X	X?@@@@@@@AAA0?@@@@@@@ @"@&abcdefghijklFTFFTTFFFTTLp	
X	
X	
X?@@@@@@@AAA A@?@@@@@@@ @"@$@(abcdefghijklmFTFFTTFFFTTFLp	
X
	
X
	
X
?@@@@@@@AAA A0AP?@@@@@@@ @"@$@&@*abcdefghijklmnFTFFTTFFFTTTFLp	
X	
X	
X?@@@@@@@AAA A0A@A`?@@@@@@@ @"@$@&@(@,abcdefghijklmnoFTFFTTFFFTTTFFLp	

X	

X	

X?@@@@@@@AAA A0A@APAp?@@@@@@@ @"@$@&@(@*@.abcdefghijklmnopFTFFTTFFFTTTFFFLp	

X	

X	

X?@@@@@@@AAA A0A@APA`A?@@@@@@@ @"@$@&@(@*@,@0abcdefghijklmnopqFTFFTTFFFTTTFFFTLp	

X	

X	

X?@@@@@@@AAA A0A@APA`ApA?@@@@@@@ @"@$@&@(@*@,@.@1abcdefghijklmnopqrFTFFTTFFFTTTFFFFTLp	

X	

X	

X?@@@@@@@AAA A0A@APA`ApAA?@@@@@@@ @"@$@&@(@*@,@.@0@2abcdefghijklmnopqrsFTFFTTFFFTTTFFFFTTLp	

X	

X	

X?@@@@@@@AAA A0A@APA`ApAAA?@@@@@@@ @"@$@&@(@*@,@.@0@1@3abcdefghijklmnopqrstFTFFTTFFFTTTFFFFTTTLp	

X	

X	

X?@@@@@@@AAA A0A@APA`ApAAAA?@@@@@@@ @"@$@&@(@*@,@.@0@1@2@4XTENSION= 'IMAGE   '           / IMAGE extension                                BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    2 / number of data axes                            NAXIS1  =                   10 / length of data axis 1                          NAXIS2  =                    2 / length of data axis 2                          PCOUNT  =                    0 / required keyword; must = 0                     GCOUNT  =                    1 / required keyword; must = 1                     CRVAL1  =     4.5830000000E+01 / comment                                        CRVAL2  =     6.3570000000E+01 / comment                                        CRPIX1  =     2.5600000000E+02 / comment                                        CRPIX2  =     2.5700000000E+02 / comment                                        CDELT1  =    -2.7777700000E-03 / comment                                        CDELT2  =     2.7777700000E-03 / comment                                        CTYPE1  = 'RA---TAN'           / comment                                        CTYPE2  = 'DEC--TAN'           / comment                                        END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
XTENSION= 'TABLE   '           / ASCII table extension                          BITPIX  =                    8 / 8-bit ASCII characters                         NAXIS   =                    2 / 2-dimensional ASCII table                      NAXIS1  =                   80 / width of table in characters                   NAXIS2  =                   11 / number of rows in table                        PCOUNT  =                    0 / no group parameters (required keyword)         GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    5 / number of fields in each row                   TTYPE1  = 'Name    '           / label for field   1                            TBCOL1  =                    1 / beginning column of field   1                  TFORM1  = 'A15     '           / Fortran-77 format of field                     TTYPE2  = 'Ivalue  '           / label for field   2                            TBCOL2  =                   17 / beginning column of field   2                  TFORM2  = 'I11     '           / Fortran-77 format of field                     TUNIT2  = 'm**2    '           / physical unit of field                         TTYPE3  = 'Fvalue  '           / label for field   3                            TBCOL3  =                   29 / beginning column of field   3                  TFORM3  = 'F15.6   '           / Fortran-77 format of field                     TUNIT3  = 'cm      '           / physical unit of field                         TTYPE4  = 'Evalue  '           / label for field   4                            TBCOL4  =                   45 / beginning column of field   4                  TFORM4  = 'E13.5   '           / Fortran-77 format of field                     TUNIT4  = 'erg/s   '           / physical unit of field                         TTYPE5  = 'Dvalue  '           / label for field   5                            TBCOL5  =                   59 / beginning column of field   5                  TFORM5  = 'D22.14  '           / Fortran-77 format of field                     TUNIT5  = 'km/s    '           / physical unit of field                         EXTNAME = 'new_table'          / name of this ASCII table extension             EXTVER  =                    5 / extension version number                       END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             first string              0        0.000000   0.00000E+00   0.00000000000000E+00second string             3        3.000000   3.00000E+00   3.00000000000000E+00                          6        6.000000   6.00000E+00   6.00000000000000E+00                          9        9.000000   9.00000E+00   9.00000000000000E+00                         12       12.000000   1.20000E+01   1.20000000000000E+01                         15       15.000000   1.50000E+01   1.50000000000000E+01                         18       18.000000   1.80000E+01   1.80000000000000E+01                         21       21.000000   2.10000E+01   2.10000000000000E+01                         24       24.000000   2.40000E+01   2.40000000000000E+01                         27       27.000000   2.70000E+01   2.70000000000000E+01                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                healpy-1.10.3/cfitsio/testprog.tpt0000664000175000017500000000061413010375005017361 0ustar  zoncazonca00000000000000tmpcard1  1001 this is the 1st template card 
tmpcard2  ABCD this is the 2nd template card
tmpcard3  1001.23 this is the 3rd template card
tmpcard4  1001.45 this is the 4rd template card
comment this is the 5th template card
history this is the 6th template card
tmpcard7 =            / comment for null keyword
-tmpcard1 tmpcarda  change the name of tmpcard1
-tmpcard4
end

junk will be ignored
healpy-1.10.3/cfitsio/vmsieee.c0000664000175000017500000000730613010375005016567 0ustar  zoncazonca00000000000000#include 
#include 

unsigned long CVT$CONVERT_FLOAT();

/* IEEVPAKR -- Pack a native floating point vector into an IEEE one.
*/
void ieevpr (unsigned int *native, unsigned int *ieee, int *nelem)
{
        unsigned long status;
        unsigned long options;
        unsigned int *unanval;
        int nanval = -1;
        int     i,n;

        unanval = (unsigned int *) &nanval;
        options = CVT$M_BIG_ENDIAN;
        
        n = *nelem;
        status = CVT$_NORMAL;

        for (i = 0; i < n ; i++) {

            status = CVT$CONVERT_FLOAT (&native[i], CVT$K_VAX_F,
                                        &ieee[i], CVT$K_IEEE_S, 
                                        options);
           if (status != CVT$_NORMAL) {
                 ieee[i] = *unanval;
           }
        }       

}
/* IEEVPAKD -- Pack a native double floating point vector into an IEEE one.
*/
void ieevpd (unsigned long *native, unsigned long *ieee, int *nelem)
{
        unsigned long status;
        unsigned long options;
        unsigned long *unanval;
        long nanval = -1;
        int     i,n;

        unanval = (unsigned long *) &nanval;
        options = CVT$M_BIG_ENDIAN;
        
        n = *nelem * 2;
        status = CVT$_NORMAL;

        for (i = 0; i < n ; i=i+2) {

            status = CVT$CONVERT_FLOAT (&native[i], CVT$K_VAX_D,
                                        &ieee[i], CVT$K_IEEE_T, 
                                        options);
           if (status != CVT$_NORMAL) {
                 ieee[i]   = *unanval;
                 ieee[i+1] = *unanval;
           }
        }       

}
/* IEEVUPKR -- Unpack an ieee vector into native single floating point vector.
*/
void ieevur (unsigned int *ieee, unsigned int *native, int *nelem)
{
        unsigned long status;
        unsigned long options;
        unsigned int *unanval;
        int nanval = -1;
        int     j,n;

        unanval = (unsigned int *) &nanval;
        options = CVT$M_ERR_UNDERFLOW+CVT$M_BIG_ENDIAN;
        
        n = *nelem;

        status = CVT$_NORMAL;

        for (j = 0; j < n ; j++) {
           status = CVT$CONVERT_FLOAT (&ieee[j], CVT$K_IEEE_S,
                                        &native[j], CVT$K_VAX_F, 
                                        options);
           if (status != CVT$_NORMAL)
              switch(status) {
              case CVT$_INVVAL:
              case CVT$_NEGINF:
              case CVT$_OVERFLOW:
              case CVT$_POSINF:
                 native[j]   = *unanval;
                 break;
              default:
                 native[j] = 0;             
              }
        }
}
/* IEEVUPKD -- Unpack an ieee vector into native double floating point vector.
*/
void ieevud (unsigned long *ieee, unsigned long *native, int *nelem)
{
        unsigned long status;
        unsigned long options;
        unsigned long *unanval;
        long nanval = -1;
        int     j,n;

        unanval = (unsigned long *) &nanval;
        options = CVT$M_BIG_ENDIAN + CVT$M_ERR_UNDERFLOW; 
        
        n = *nelem * 2;

        status = CVT$_NORMAL;

        for (j = 0; j < n ; j=j+2) {
           status = CVT$CONVERT_FLOAT (&ieee[j], CVT$K_IEEE_T,
                                        &native[j], CVT$K_VAX_D, 
                                        options);
           if (status != CVT$_NORMAL)
              switch(status) {
              case CVT$_INVVAL:
              case CVT$_NEGINF:
              case CVT$_OVERFLOW:
              case CVT$_POSINF:
                 native[j]   = *unanval;
                 native[j+1] = *unanval;
                 break;
              default:
                 native[j]   = 0;             
                 native[j+1] = 0;             
              }
        }
}
healpy-1.10.3/cfitsio/wcssub.c0000664000175000017500000010470313010375005016437 0ustar  zoncazonca00000000000000#include 
#include 
#include 
#include "fitsio2.h"

/*--------------------------------------------------------------------------*/
int fits_read_wcstab(
   fitsfile   *fptr, /* I - FITS file pointer           */
   int  nwtb,        /* Number of arrays to be read from the binary table(s) */
   wtbarr *wtb,      /* Address of the first element of an array of wtbarr
                         typedefs.  This wtbarr typedef is defined below to
                         match the wtbarr struct defined in WCSLIB.  An array
                         of such structs returned by the WCSLIB function
                         wcstab(). */
   int  *status)

/*
*   Author: Mark Calabretta, Australia Telescope National Facility
*   http://www.atnf.csiro.au/~mcalabre/index.html
*
*   fits_read_wcstab() extracts arrays from a binary table required in
*   constructing -TAB coordinates.  This helper routine is intended for
*   use by routines in the WCSLIB library when dealing with the -TAB table
*   look up WCS convention.
*/

{
   int  anynul, colnum, hdunum, iwtb, m, naxis, nostat;
   long *naxes = 0, nelem;
   wtbarr *wtbp;


   if (*status) return *status;

   if (fptr == 0) {
      return (*status = NULL_INPUT_PTR);
   }

   if (nwtb == 0) return 0;

   /* Zero the array pointers. */
   wtbp = wtb;
   for (iwtb = 0; iwtb < nwtb; iwtb++, wtbp++) {
     *wtbp->arrayp = 0x0;
   }

   /* Save HDU number so that we can move back to it later. */
   fits_get_hdu_num(fptr, &hdunum);

   wtbp = wtb;
   for (iwtb = 0; iwtb < nwtb; iwtb++, wtbp++) {
      /* Move to the required binary table extension. */
      if (fits_movnam_hdu(fptr, BINARY_TBL, (char *)(wtbp->extnam),
          wtbp->extver, status)) {
         goto cleanup;
      }

      /* Locate the table column. */
      if (fits_get_colnum(fptr, CASEINSEN, (char *)(wtbp->ttype), &colnum,
          status)) {
         goto cleanup;
      }

      /* Get the array dimensions and check for consistency. */
      if (wtbp->ndim < 1) {
         *status = NEG_AXIS;
         goto cleanup;
      }

      if (!(naxes = calloc(wtbp->ndim, sizeof(long)))) {
         *status = MEMORY_ALLOCATION;
         goto cleanup;
      }

      if (fits_read_tdim(fptr, colnum, wtbp->ndim, &naxis, naxes, status)) {
         goto cleanup;
      }

      if (naxis != wtbp->ndim) {
         if (wtbp->kind == 'c' && wtbp->ndim == 2) {
            /* Allow TDIMn to be omitted for degenerate coordinate arrays. */
            naxis = 2;
            naxes[1] = naxes[0];
            naxes[0] = 1;
         } else {
            *status = BAD_TDIM;
            goto cleanup;
         }
      }

      if (wtbp->kind == 'c') {
         /* Coordinate array; calculate the array size. */
         nelem = naxes[0];
         for (m = 0; m < naxis-1; m++) {
            *(wtbp->dimlen + m) = naxes[m+1];
            nelem *= naxes[m+1];
         }
      } else {
         /* Index vector; check length. */
         if ((nelem = naxes[0]) != *(wtbp->dimlen)) {
            /* N.B. coordinate array precedes the index vectors. */
            *status = BAD_TDIM;
            goto cleanup;
         }
      }

      free(naxes);
      naxes = 0;

      /* Allocate memory for the array. */
      if (!(*wtbp->arrayp = calloc((size_t)nelem, sizeof(double)))) {
         *status = MEMORY_ALLOCATION;
         goto cleanup;
      }

      /* Read the array from the table. */
      if (fits_read_col_dbl(fptr, colnum, wtbp->row, 1L, nelem, 0.0,
          *wtbp->arrayp, &anynul, status)) {
         goto cleanup;
      }
   }

cleanup:
   /* Move back to the starting HDU. */
   nostat = 0;
   fits_movabs_hdu(fptr, hdunum, 0, &nostat);

   /* Release allocated memory. */
   if (naxes) free(naxes);
   if (*status) {
      wtbp = wtb;
      for (iwtb = 0; iwtb < nwtb; iwtb++, wtbp++) {
         if (*wtbp->arrayp) free(*wtbp->arrayp);
      }
   }

   return *status;
}
/*--------------------------------------------------------------------------*/
int ffgiwcs(fitsfile *fptr,  /* I - FITS file pointer                    */
           char **header,   /* O - pointer to the WCS related keywords  */
           int *status)     /* IO - error status                        */
/*
  int fits_get_image_wcs_keys 
  return a string containing all the image WCS header keywords.
  This string is then used as input to the wcsinit WCSlib routine.
  
  THIS ROUTINE IS DEPRECATED. USE fits_hdr2str INSTEAD
*/
{
    int hdutype;

    if (*status > 0)
        return(*status);

    fits_get_hdu_type(fptr, &hdutype, status);
    if (hdutype != IMAGE_HDU)
    {
      ffpmsg(
     "Error in ffgiwcs. This HDU is not an image. Can't read WCS keywords");
      return(*status = NOT_IMAGE);
    }

    /* read header keywords into a long string of chars */
    if (ffh2st(fptr, header, status) > 0)
    {
        ffpmsg("error creating string of image WCS keywords (ffgiwcs)");
        return(*status);
    }

    return(*status);
}

/*--------------------------------------------------------------------------*/
int ffgics(fitsfile *fptr,    /* I - FITS file pointer           */
           double *xrval,     /* O - X reference value           */
           double *yrval,     /* O - Y reference value           */
           double *xrpix,     /* O - X reference pixel           */
           double *yrpix,     /* O - Y reference pixel           */
           double *xinc,      /* O - X increment per pixel       */
           double *yinc,      /* O - Y increment per pixel       */
           double *rot,       /* O - rotation angle (degrees)    */
           char *type,        /* O - type of projection ('-tan') */
           int *status)       /* IO - error status               */
/*
       read the values of the celestial coordinate system keywords.
       These values may be used as input to the subroutines that
       calculate celestial coordinates. (ffxypx, ffwldp)

       Modified in Nov 1999 to convert the CD matrix keywords back
       to the old CDELTn form, and to swap the axes if the dec-like
       axis is given first, and to assume default values if any of the
       keywords are not present.
*/
{
    int tstat = 0, cd_exists = 0, pc_exists = 0;
    char ctype[FLEN_VALUE];
    double cd11 = 0.0, cd21 = 0.0, cd22 = 0.0, cd12 = 0.0;
    double pc11 = 1.0, pc21 = 0.0, pc22 = 1.0, pc12 = 0.0;
    double pi =  3.1415926535897932;
    double phia, phib, temp;
    double toler = .0002;  /* tolerance for angles to agree (radians) */
                           /*   (= approximately 0.01 degrees) */

    if (*status > 0)
       return(*status);

    tstat = 0;
    if (ffgkyd(fptr, "CRVAL1", xrval, NULL, &tstat))
       *xrval = 0.;

    tstat = 0;
    if (ffgkyd(fptr, "CRVAL2", yrval, NULL, &tstat))
       *yrval = 0.;

    tstat = 0;
    if (ffgkyd(fptr, "CRPIX1", xrpix, NULL, &tstat))
        *xrpix = 0.;

    tstat = 0;
    if (ffgkyd(fptr, "CRPIX2", yrpix, NULL, &tstat))
        *yrpix = 0.;

    /* look for CDELTn first, then CDi_j keywords */
    tstat = 0;
    if (ffgkyd(fptr, "CDELT1", xinc, NULL, &tstat))
    {
        /* CASE 1: no CDELTn keyword, so look for the CD matrix */
        tstat = 0;
        if (ffgkyd(fptr, "CD1_1", &cd11, NULL, &tstat))
            tstat = 0;  /* reset keyword not found error */
        else
            cd_exists = 1;  /* found at least 1 CD_ keyword */

        if (ffgkyd(fptr, "CD2_1", &cd21, NULL, &tstat))
            tstat = 0;  /* reset keyword not found error */
        else
            cd_exists = 1;  /* found at least 1 CD_ keyword */

        if (ffgkyd(fptr, "CD1_2", &cd12, NULL, &tstat))
            tstat = 0;  /* reset keyword not found error */
        else
            cd_exists = 1;  /* found at least 1 CD_ keyword */

        if (ffgkyd(fptr, "CD2_2", &cd22, NULL, &tstat))
            tstat = 0;  /* reset keyword not found error */
        else
            cd_exists = 1;  /* found at least 1 CD_ keyword */

        if (cd_exists)  /* convert CDi_j back to CDELTn */
        {
            /* there are 2 ways to compute the angle: */
            phia = atan2( cd21, cd11);
            phib = atan2(-cd12, cd22);

            /* ensure that phia <= phib */
            temp = minvalue(phia, phib);
            phib = maxvalue(phia, phib);
            phia = temp;

            /* there is a possible 180 degree ambiguity in the angles */
            /* so add 180 degress to the smaller value if the values  */
            /* differ by more than 90 degrees = pi/2 radians.         */
            /* (Later, we may decide to take the other solution by    */
            /* subtracting 180 degrees from the larger value).        */

            if ((phib - phia) > (pi / 2.))
               phia += pi;

            if (fabs(phia - phib) > toler) 
            {
               /* angles don't agree, so looks like there is some skewness */
               /* between the axes.  Return with an error to be safe. */
               *status = APPROX_WCS_KEY;
            }
      
            phia = (phia + phib) /2.;  /* use the average of the 2 values */
            *xinc = cd11 / cos(phia);
            *yinc = cd22 / cos(phia);
            *rot = phia * 180. / pi;

            /* common usage is to have a positive yinc value.  If it is */
            /* negative, then subtract 180 degrees from rot and negate  */
            /* both xinc and yinc.  */

            if (*yinc < 0)
            {
                *xinc = -(*xinc);
                *yinc = -(*yinc);
                *rot = *rot - 180.;
            }
        }
        else   /* no CD matrix keywords either */
        {
            *xinc = 1.;

            /* there was no CDELT1 keyword, but check for CDELT2 just in case */
            tstat = 0;
            if (ffgkyd(fptr, "CDELT2", yinc, NULL, &tstat))
                *yinc = 1.;

            tstat = 0;
            if (ffgkyd(fptr, "CROTA2", rot, NULL, &tstat))
                *rot=0.;
        }
    }
    else  /* Case 2: CDELTn + optional PC matrix */
    {
        if (ffgkyd(fptr, "CDELT2", yinc, NULL, &tstat))
            *yinc = 1.;

        tstat = 0;
        if (ffgkyd(fptr, "CROTA2", rot, NULL, &tstat))
        {
            *rot=0.;

            /* no CROTA2 keyword, so look for the PC matrix */
            tstat = 0;
            if (ffgkyd(fptr, "PC1_1", &pc11, NULL, &tstat))
                tstat = 0;  /* reset keyword not found error */
            else
                pc_exists = 1;  /* found at least 1 PC_ keyword */

            if (ffgkyd(fptr, "PC2_1", &pc21, NULL, &tstat))
                tstat = 0;  /* reset keyword not found error */
            else
                pc_exists = 1;  /* found at least 1 PC_ keyword */

            if (ffgkyd(fptr, "PC1_2", &pc12, NULL, &tstat))
                tstat = 0;  /* reset keyword not found error */
            else
                pc_exists = 1;  /* found at least 1 PC_ keyword */

            if (ffgkyd(fptr, "PC2_2", &pc22, NULL, &tstat))
                tstat = 0;  /* reset keyword not found error */
            else
                pc_exists = 1;  /* found at least 1 PC_ keyword */

            if (pc_exists)  /* convert PCi_j back to CDELTn */
            {
                /* there are 2 ways to compute the angle: */
                phia = atan2( pc21, pc11);
                phib = atan2(-pc12, pc22);

                /* ensure that phia <= phib */
                temp = minvalue(phia, phib);
                phib = maxvalue(phia, phib);
                phia = temp;

                /* there is a possible 180 degree ambiguity in the angles */
                /* so add 180 degress to the smaller value if the values  */
                /* differ by more than 90 degrees = pi/2 radians.         */
                /* (Later, we may decide to take the other solution by    */
                /* subtracting 180 degrees from the larger value).        */

                if ((phib - phia) > (pi / 2.))
                   phia += pi;

                if (fabs(phia - phib) > toler) 
                {
                  /* angles don't agree, so looks like there is some skewness */
                  /* between the axes.  Return with an error to be safe. */
                  *status = APPROX_WCS_KEY;
                }
      
                phia = (phia + phib) /2.;  /* use the average of the 2 values */
                *rot = phia * 180. / pi;
            }
        }
    }

    /* get the type of projection, if any */
    tstat = 0;
    if (ffgkys(fptr, "CTYPE1", ctype, NULL, &tstat))
         type[0] = '\0';
    else
    {
        /* copy the projection type string */
        strncpy(type, &ctype[4], 4);
        type[4] = '\0';

        /* check if RA and DEC are inverted */
        if (!strncmp(ctype, "DEC-", 4) || !strncmp(ctype+1, "LAT", 3))
        {
            /* the latitudinal axis is given first, so swap them */

/*
 this case was removed on 12/9.  Apparently not correct.

            if ((*xinc / *yinc) < 0. )  
                *rot = -90. - (*rot);
            else
*/
            *rot = 90. - (*rot);

            /* Empirical tests with ds9 show the y-axis sign must be negated */
            /* and the xinc and yinc values must NOT be swapped. */
            *yinc = -(*yinc);

            temp = *xrval;
            *xrval = *yrval;
            *yrval = temp;
        }   
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgicsa(fitsfile *fptr,    /* I - FITS file pointer           */
           char version,      /* I - character code of desired version */
	                      /*     A - Z or blank */
           double *xrval,     /* O - X reference value           */
           double *yrval,     /* O - Y reference value           */
           double *xrpix,     /* O - X reference pixel           */
           double *yrpix,     /* O - Y reference pixel           */
           double *xinc,      /* O - X increment per pixel       */
           double *yinc,      /* O - Y increment per pixel       */
           double *rot,       /* O - rotation angle (degrees)    */
           char *type,        /* O - type of projection ('-tan') */
           int *status)       /* IO - error status               */
/*
       read the values of the celestial coordinate system keywords.
       These values may be used as input to the subroutines that
       calculate celestial coordinates. (ffxypx, ffwldp)

       Modified in Nov 1999 to convert the CD matrix keywords back
       to the old CDELTn form, and to swap the axes if the dec-like
       axis is given first, and to assume default values if any of the
       keywords are not present.
*/
{
    int tstat = 0, cd_exists = 0, pc_exists = 0;
    char ctype[FLEN_VALUE], keyname[FLEN_VALUE], alt[2];
    double cd11 = 0.0, cd21 = 0.0, cd22 = 0.0, cd12 = 0.0;
    double pc11 = 1.0, pc21 = 0.0, pc22 = 1.0, pc12 = 0.0;
    double pi =  3.1415926535897932;
    double phia, phib, temp;
    double toler = .0002;  /* tolerance for angles to agree (radians) */
                           /*   (= approximately 0.01 degrees) */

    if (*status > 0)
       return(*status);

    if (version == ' ') {
      ffgics(fptr, xrval, yrval, xrpix, yrpix, xinc, yinc, rot, type, status);
      return (*status);
    }

    if (version > 'Z' || version < 'A') {
      ffpmsg("ffgicsa: illegal WCS version code (must be A - Z or blank)");
      return(*status = WCS_ERROR);
    }

    alt[0] = version;
    alt[1] = '\0';
    
    tstat = 0;
    strcpy(keyname, "CRVAL1");
    strcat(keyname, alt);
    if (ffgkyd(fptr, keyname, xrval, NULL, &tstat))
       *xrval = 0.;

    tstat = 0;
    strcpy(keyname, "CRVAL2");
    strcat(keyname, alt);
    if (ffgkyd(fptr, keyname, yrval, NULL, &tstat))
       *yrval = 0.;

    tstat = 0;
    strcpy(keyname, "CRPIX1");
    strcat(keyname, alt);
    if (ffgkyd(fptr, keyname, xrpix, NULL, &tstat))
        *xrpix = 0.;

    tstat = 0;
    strcpy(keyname, "CRPIX2");
    strcat(keyname, alt);
     if (ffgkyd(fptr, keyname, yrpix, NULL, &tstat))
        *yrpix = 0.;

    /* look for CDELTn first, then CDi_j keywords */
    tstat = 0;
    strcpy(keyname, "CDELT1");
    strcat(keyname, alt);
    if (ffgkyd(fptr, keyname, xinc, NULL, &tstat))
    {
        /* CASE 1: no CDELTn keyword, so look for the CD matrix */
        tstat = 0;
        strcpy(keyname, "CD1_1");
        strcat(keyname, alt);
        if (ffgkyd(fptr, keyname, &cd11, NULL, &tstat))
            tstat = 0;  /* reset keyword not found error */
        else
            cd_exists = 1;  /* found at least 1 CD_ keyword */

        strcpy(keyname, "CD2_1");
        strcat(keyname, alt);
        if (ffgkyd(fptr, keyname, &cd21, NULL, &tstat))
            tstat = 0;  /* reset keyword not found error */
        else
            cd_exists = 1;  /* found at least 1 CD_ keyword */

        strcpy(keyname, "CD1_2");
        strcat(keyname, alt);
        if (ffgkyd(fptr, keyname, &cd12, NULL, &tstat))
            tstat = 0;  /* reset keyword not found error */
        else
            cd_exists = 1;  /* found at least 1 CD_ keyword */

        strcpy(keyname, "CD2_2");
        strcat(keyname, alt);
        if (ffgkyd(fptr, keyname, &cd22, NULL, &tstat))
            tstat = 0;  /* reset keyword not found error */
        else
            cd_exists = 1;  /* found at least 1 CD_ keyword */

        if (cd_exists)  /* convert CDi_j back to CDELTn */
        {
            /* there are 2 ways to compute the angle: */
            phia = atan2( cd21, cd11);
            phib = atan2(-cd12, cd22);

            /* ensure that phia <= phib */
            temp = minvalue(phia, phib);
            phib = maxvalue(phia, phib);
            phia = temp;

            /* there is a possible 180 degree ambiguity in the angles */
            /* so add 180 degress to the smaller value if the values  */
            /* differ by more than 90 degrees = pi/2 radians.         */
            /* (Later, we may decide to take the other solution by    */
            /* subtracting 180 degrees from the larger value).        */

            if ((phib - phia) > (pi / 2.))
               phia += pi;

            if (fabs(phia - phib) > toler) 
            {
               /* angles don't agree, so looks like there is some skewness */
               /* between the axes.  Return with an error to be safe. */
               *status = APPROX_WCS_KEY;
            }
      
            phia = (phia + phib) /2.;  /* use the average of the 2 values */
            *xinc = cd11 / cos(phia);
            *yinc = cd22 / cos(phia);
            *rot = phia * 180. / pi;

            /* common usage is to have a positive yinc value.  If it is */
            /* negative, then subtract 180 degrees from rot and negate  */
            /* both xinc and yinc.  */

            if (*yinc < 0)
            {
                *xinc = -(*xinc);
                *yinc = -(*yinc);
                *rot = *rot - 180.;
            }
        }
        else   /* no CD matrix keywords either */
        {
            *xinc = 1.;

            /* there was no CDELT1 keyword, but check for CDELT2 just in case */
            tstat = 0;
            strcpy(keyname, "CDELT2");
            strcat(keyname, alt);
            if (ffgkyd(fptr, keyname, yinc, NULL, &tstat))
                *yinc = 1.;

            tstat = 0;
            strcpy(keyname, "CROTA2");
            strcat(keyname, alt);
            if (ffgkyd(fptr, keyname, rot, NULL, &tstat))
                *rot=0.;
        }
    }
    else  /* Case 2: CDELTn + optional PC matrix */
    {
        strcpy(keyname, "CDELT2");
        strcat(keyname, alt);
        if (ffgkyd(fptr, keyname, yinc, NULL, &tstat))
            *yinc = 1.;

        tstat = 0;
        strcpy(keyname, "CROTA2");
        strcat(keyname, alt);
        if (ffgkyd(fptr, keyname, rot, NULL, &tstat))
        {
            *rot=0.;

            /* no CROTA2 keyword, so look for the PC matrix */
            tstat = 0;
            strcpy(keyname, "PC1_1");
            strcat(keyname, alt);
            if (ffgkyd(fptr, keyname, &pc11, NULL, &tstat))
                tstat = 0;  /* reset keyword not found error */
            else
                pc_exists = 1;  /* found at least 1 PC_ keyword */

            strcpy(keyname, "PC2_1");
            strcat(keyname, alt);
            if (ffgkyd(fptr, keyname, &pc21, NULL, &tstat))
                tstat = 0;  /* reset keyword not found error */
            else
                pc_exists = 1;  /* found at least 1 PC_ keyword */

            strcpy(keyname, "PC1_2");
            strcat(keyname, alt);
            if (ffgkyd(fptr, keyname, &pc12, NULL, &tstat))
                tstat = 0;  /* reset keyword not found error */
            else
                pc_exists = 1;  /* found at least 1 PC_ keyword */

            strcpy(keyname, "PC2_2");
            strcat(keyname, alt);
            if (ffgkyd(fptr, keyname, &pc22, NULL, &tstat))
                tstat = 0;  /* reset keyword not found error */
            else
                pc_exists = 1;  /* found at least 1 PC_ keyword */

            if (pc_exists)  /* convert PCi_j back to CDELTn */
            {
                /* there are 2 ways to compute the angle: */
                phia = atan2( pc21, pc11);
                phib = atan2(-pc12, pc22);

                /* ensure that phia <= phib */
                temp = minvalue(phia, phib);
                phib = maxvalue(phia, phib);
                phia = temp;

                /* there is a possible 180 degree ambiguity in the angles */
                /* so add 180 degress to the smaller value if the values  */
                /* differ by more than 90 degrees = pi/2 radians.         */
                /* (Later, we may decide to take the other solution by    */
                /* subtracting 180 degrees from the larger value).        */

                if ((phib - phia) > (pi / 2.))
                   phia += pi;

                if (fabs(phia - phib) > toler) 
                {
                  /* angles don't agree, so looks like there is some skewness */
                  /* between the axes.  Return with an error to be safe. */
                  *status = APPROX_WCS_KEY;
                }
      
                phia = (phia + phib) /2.;  /* use the average of the 2 values */
                *rot = phia * 180. / pi;
            }
        }
    }

    /* get the type of projection, if any */
    tstat = 0;
    strcpy(keyname, "CTYPE1");
    strcat(keyname, alt);
    if (ffgkys(fptr, keyname, ctype, NULL, &tstat))
         type[0] = '\0';
    else
    {
        /* copy the projection type string */
        strncpy(type, &ctype[4], 4);
        type[4] = '\0';

        /* check if RA and DEC are inverted */
        if (!strncmp(ctype, "DEC-", 4) || !strncmp(ctype+1, "LAT", 3))
        {
            /* the latitudinal axis is given first, so swap them */

            *rot = 90. - (*rot);

            /* Empirical tests with ds9 show the y-axis sign must be negated */
            /* and the xinc and yinc values must NOT be swapped. */
            *yinc = -(*yinc);

            temp = *xrval;
            *xrval = *yrval;
            *yrval = temp;
        }   
    }

    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgtcs(fitsfile *fptr,    /* I - FITS file pointer           */
           int xcol,          /* I - column containing the RA coordinate  */
           int ycol,          /* I - column containing the DEC coordinate */
           double *xrval,     /* O - X reference value           */
           double *yrval,     /* O - Y reference value           */
           double *xrpix,     /* O - X reference pixel           */
           double *yrpix,     /* O - Y reference pixel           */
           double *xinc,      /* O - X increment per pixel       */
           double *yinc,      /* O - Y increment per pixel       */
           double *rot,       /* O - rotation angle (degrees)    */
           char *type,        /* O - type of projection ('-sin') */
           int *status)       /* IO - error status               */
/*
       read the values of the celestial coordinate system keywords
       from a FITS table where the X and Y or RA and DEC coordinates
       are stored in separate column.  Do this by converting the
       table to a temporary FITS image, then reading the keywords
       from the image file.
       These values may be used as input to the subroutines that
       calculate celestial coordinates. (ffxypx, ffwldp)
*/
{
    int colnum[2];
    long naxes[2];
    fitsfile *tptr;

    if (*status > 0)
       return(*status);

    colnum[0] = xcol;
    colnum[1] = ycol;
    naxes[0] = 10;
    naxes[1] = 10;

    /* create temporary  FITS file, in memory */
    ffinit(&tptr, "mem://", status);
    
    /* create a temporary image; the datatype and size are not important */
    ffcrim(tptr, 32, 2, naxes, status);
    
    /* now copy the relevant keywords from the table to the image */
    fits_copy_pixlist2image(fptr, tptr, 9, 2, colnum, status);

    /* write default WCS keywords, if they are not present */
    fits_write_keys_histo(fptr, tptr, 2, colnum, status);

    if (*status > 0)
       return(*status);
         
    /* read the WCS keyword values from the temporary image */
    ffgics(tptr, xrval, yrval, xrpix, yrpix, xinc, yinc, rot, type, status); 

    if (*status > 0)
    {
      ffpmsg
      ("ffgtcs could not find all the celestial coordinate keywords");
      return(*status = NO_WCS_KEY); 
    }

    /* delete the temporary file */
    fits_delete_file(tptr, status);
    
    return(*status);
}
/*--------------------------------------------------------------------------*/
int ffgtwcs(fitsfile *fptr,  /* I - FITS file pointer              */
           int xcol,        /* I - column number for the X column  */
           int ycol,        /* I - column number for the Y column  */
           char **header,   /* O - string of all the WCS keywords  */
           int *status)     /* IO - error status                   */
/*
  int fits_get_table_wcs_keys
  Return string containing all the WCS keywords appropriate for the 
  pair of X and Y columns containing the coordinate
  of each event in an event list table.  This string may then be passed
  to Doug Mink's WCS library wcsinit routine, to create and initialize the
  WCS structure.  The calling routine must free the header character string
  when it is no longer needed. 

  THIS ROUTINE IS DEPRECATED. USE fits_hdr2str INSTEAD
*/
{
    int hdutype, ncols, tstatus, length;
    int naxis1 = 1, naxis2 = 1;
    long tlmin, tlmax;
    char keyname[FLEN_KEYWORD];
    char valstring[FLEN_VALUE];
    char comm[2];
    char *cptr;
    /*  construct a string of 80 blanks, for adding fill to the keywords */
                 /*  12345678901234567890123456789012345678901234567890123456789012345678901234567890 */
    char blanks[] = "                                                                                ";

    if (*status > 0)
        return(*status);

    fits_get_hdu_type(fptr, &hdutype, status);
    if (hdutype == IMAGE_HDU)
    {
        ffpmsg("Can't read table WSC keywords. This HDU is not a table");
        return(*status = NOT_TABLE);
    }

    fits_get_num_cols(fptr, &ncols, status);
    
    if (xcol < 1 || xcol > ncols)
    {
        ffpmsg("illegal X axis column number in fftwcs");
        return(*status = BAD_COL_NUM);
    }

    if (ycol < 1 || ycol > ncols)
    {
        ffpmsg("illegal Y axis column number in fftwcs");
        return(*status = BAD_COL_NUM);
    }

    /* allocate character string for all the WCS keywords */
    *header = calloc(1, 2401);  /* room for up to 30 keywords */
    if (*header == 0)
    {
        ffpmsg("error allocating memory for WCS header keywords (fftwcs)");
        return(*status = MEMORY_ALLOCATION);
    }

    cptr = *header;
    comm[0] = '\0';
    
    tstatus = 0;
    ffkeyn("TLMIN",xcol,keyname,status);
    ffgkyj(fptr,keyname, &tlmin,NULL,&tstatus);

    if (!tstatus)
    {
        ffkeyn("TLMAX",xcol,keyname,status);
        ffgkyj(fptr,keyname, &tlmax,NULL,&tstatus);
    }

    if (!tstatus)
    {
        naxis1 = tlmax - tlmin + 1;
    }

    tstatus = 0;
    ffkeyn("TLMIN",ycol,keyname,status);
    ffgkyj(fptr,keyname, &tlmin,NULL,&tstatus);

    if (!tstatus)
    {
        ffkeyn("TLMAX",ycol,keyname,status);
        ffgkyj(fptr,keyname, &tlmax,NULL,&tstatus);
    }

    if (!tstatus)
    {
        naxis2 = tlmax - tlmin + 1;
    }

    /*            123456789012345678901234567890    */
    strcat(cptr, "NAXIS   =                    2");
    strncat(cptr, blanks, 50);
    cptr += 80;

    ffi2c(naxis1, valstring, status);   /* convert to formatted string */
    ffmkky("NAXIS1", valstring, comm, cptr, status);  /* construct the keyword*/
    strncat(cptr, blanks, 50);  /* pad with blanks */
    cptr += 80;

    strcpy(keyname, "NAXIS2");
    ffi2c(naxis2, valstring, status);   /* convert to formatted string */
    ffmkky(keyname, valstring, comm, cptr, status);  /* construct the keyword*/
    strncat(cptr, blanks, 50);  /* pad with blanks */
    cptr += 80;

    /* read the required header keywords (use defaults if not found) */

    /*  CTYPE1 keyword */
    tstatus = 0;
    ffkeyn("TCTYP",xcol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) )
       valstring[0] =  '\0';
    ffmkky("CTYPE1", valstring, comm, cptr, status);  /* construct the keyword*/
    length = strlen(cptr);
    strncat(cptr, blanks, 80 - length);  /* pad with blanks */
    cptr += 80;

    /*  CTYPE2 keyword */
    tstatus = 0;
    ffkeyn("TCTYP",ycol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) )
       valstring[0] =  '\0';
    ffmkky("CTYPE2", valstring, comm, cptr, status);  /* construct the keyword*/
    length = strlen(cptr);
    strncat(cptr, blanks, 80 - length);  /* pad with blanks */
    cptr += 80;

    /*  CRPIX1 keyword */
    tstatus = 0;
    ffkeyn("TCRPX",xcol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) )
       strcpy(valstring, "1");
    ffmkky("CRPIX1", valstring, comm, cptr, status);  /* construct the keyword*/
    strncat(cptr, blanks, 50);  /* pad with blanks */
    cptr += 80;

    /*  CRPIX2 keyword */
    tstatus = 0;
    ffkeyn("TCRPX",ycol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) )
       strcpy(valstring, "1");
    ffmkky("CRPIX2", valstring, comm, cptr, status);  /* construct the keyword*/
    strncat(cptr, blanks, 50);  /* pad with blanks */
    cptr += 80;

    /*  CRVAL1 keyword */
    tstatus = 0;
    ffkeyn("TCRVL",xcol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) )
       strcpy(valstring, "1");
    ffmkky("CRVAL1", valstring, comm, cptr, status);  /* construct the keyword*/
    strncat(cptr, blanks, 50);  /* pad with blanks */
    cptr += 80;

    /*  CRVAL2 keyword */
    tstatus = 0;
    ffkeyn("TCRVL",ycol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) )
       strcpy(valstring, "1");
    ffmkky("CRVAL2", valstring, comm, cptr, status);  /* construct the keyword*/
    strncat(cptr, blanks, 50);  /* pad with blanks */
    cptr += 80;

    /*  CDELT1 keyword */
    tstatus = 0;
    ffkeyn("TCDLT",xcol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) )
       strcpy(valstring, "1");
    ffmkky("CDELT1", valstring, comm, cptr, status);  /* construct the keyword*/
    strncat(cptr, blanks, 50);  /* pad with blanks */
    cptr += 80;

    /*  CDELT2 keyword */
    tstatus = 0;
    ffkeyn("TCDLT",ycol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) )
       strcpy(valstring, "1");
    ffmkky("CDELT2", valstring, comm, cptr, status);  /* construct the keyword*/
    strncat(cptr, blanks, 50);  /* pad with blanks */
    cptr += 80;

    /* the following keywords may not exist */

    /*  CROTA2 keyword */
    tstatus = 0;
    ffkeyn("TCROT",ycol,keyname,status);
    if (ffgkey(fptr, keyname, valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("CROTA2", valstring, comm, cptr, status);  /* construct keyword*/
        strncat(cptr, blanks, 50);  /* pad with blanks */
        cptr += 80;
    }

    /*  EPOCH keyword */
    tstatus = 0;
    if (ffgkey(fptr, "EPOCH", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("EPOCH", valstring, comm, cptr, status);  /* construct keyword*/
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    /*  EQUINOX keyword */
    tstatus = 0;
    if (ffgkey(fptr, "EQUINOX", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("EQUINOX", valstring, comm, cptr, status); /* construct keyword*/
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    /*  RADECSYS keyword */
    tstatus = 0;
    if (ffgkey(fptr, "RADECSYS", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("RADECSYS", valstring, comm, cptr, status); /*construct keyword*/
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    /*  TELESCOPE keyword */
    tstatus = 0;
    if (ffgkey(fptr, "TELESCOP", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("TELESCOP", valstring, comm, cptr, status); 
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    /*  INSTRUME keyword */
    tstatus = 0;
    if (ffgkey(fptr, "INSTRUME", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("INSTRUME", valstring, comm, cptr, status);  
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    /*  DETECTOR keyword */
    tstatus = 0;
    if (ffgkey(fptr, "DETECTOR", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("DETECTOR", valstring, comm, cptr, status);  
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    /*  MJD-OBS keyword */
    tstatus = 0;
    if (ffgkey(fptr, "MJD-OBS", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("MJD-OBS", valstring, comm, cptr, status);  
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    /*  DATE-OBS keyword */
    tstatus = 0;
    if (ffgkey(fptr, "DATE-OBS", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("DATE-OBS", valstring, comm, cptr, status);  
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    /*  DATE keyword */
    tstatus = 0;
    if (ffgkey(fptr, "DATE", valstring, NULL, &tstatus) == 0 )
    {
        ffmkky("DATE", valstring, comm, cptr, status);  
        length = strlen(cptr);
        strncat(cptr, blanks, 80 - length);  /* pad with blanks */
        cptr += 80;
    }

    strcat(cptr, "END");
    strncat(cptr, blanks, 77);

    return(*status);
}
healpy-1.10.3/cfitsio/wcsutil.c0000664000175000017500000004060113010375005016617 0ustar  zoncazonca00000000000000#include 
#include "fitsio2.h"
#define D2R 0.01745329252
#define TWOPI 6.28318530717959

/*--------------------------------------------------------------------------*/
int ffwldp(double xpix, double ypix, double xref, double yref,
      double xrefpix, double yrefpix, double xinc, double yinc, double rot,
      char *type, double *xpos, double *ypos, int *status)

/* This routine is based on the classic AIPS WCS routine. 

   It converts from pixel location to RA,Dec for 9 projective geometries:
   "-CAR", "-SIN", "-TAN", "-ARC", "-NCP", "-GLS", "-MER", "-AIT" and "-STG".
*/

/*-----------------------------------------------------------------------*/
/* routine to determine accurate position for pixel coordinates          */
/* returns 0 if successful otherwise:                                    */
/* 501 = angle too large for projection;                                 */
/* does: -CAR, -SIN, -TAN, -ARC, -NCP, -GLS, -MER, -AIT  -STG projections*/
/* Input:                                                                */
/*   f   xpix    x pixel number  (RA or long without rotation)           */
/*   f   ypiy    y pixel number  (dec or lat without rotation)           */
/*   d   xref    x reference coordinate value (deg)                      */
/*   d   yref    y reference coordinate value (deg)                      */
/*   f   xrefpix x reference pixel                                       */
/*   f   yrefpix y reference pixel                                       */
/*   f   xinc    x coordinate increment (deg)                            */
/*   f   yinc    y coordinate increment (deg)                            */
/*   f   rot     rotation (deg)  (from N through E)                      */
/*   c  *type    projection type code e.g. "-SIN";                       */
/* Output:                                                               */
/*   d   *xpos   x (RA) coordinate (deg)                                 */
/*   d   *ypos   y (dec) coordinate (deg)                                */
/*-----------------------------------------------------------------------*/
 {double cosr, sinr, dx, dy, dz, temp, x, y, z;
  double sins, coss, dect, rat, dt, l, m, mg, da, dd, cos0, sin0;
  double dec0, ra0;
  double geo1, geo2, geo3;
  double deps = 1.0e-5;
  char *cptr;
  
  if (*status > 0)
     return(*status);

/*   Offset from ref pixel  */
  dx = (xpix-xrefpix) * xinc;
  dy = (ypix-yrefpix) * yinc;

/*   Take out rotation  */
  cosr = cos(rot * D2R);
  sinr = sin(rot * D2R);
  if (rot != 0.0) {
     temp = dx * cosr - dy * sinr;
     dy = dy * cosr + dx * sinr;
     dx = temp;
  }

/* convert to radians  */
  ra0 = xref * D2R;
  dec0 = yref * D2R;

  l = dx * D2R;
  m = dy * D2R;
  sins = l*l + m*m;
  cos0 = cos(dec0);
  sin0 = sin(dec0);

  if (*type != '-') {  /* unrecognized projection code */
     return(*status = 504);
  }

    cptr = type + 1;

    if (*cptr == 'C') { /* linear -CAR */
      if (*(cptr + 1) != 'A' ||  *(cptr + 2) != 'R') {
         return(*status = 504);
      }
      rat =  ra0 + l;
      dect = dec0 + m;

    } else if (*cptr == 'T') {  /* -TAN */
      if (*(cptr + 1) != 'A' ||  *(cptr + 2) != 'N') {
         return(*status = 504);
      }
      x = cos0*cos(ra0) - l*sin(ra0) - m*cos(ra0)*sin0;
      y = cos0*sin(ra0) + l*cos(ra0) - m*sin(ra0)*sin0;
      z = sin0                       + m*         cos0;
      rat  = atan2( y, x );
      dect = atan ( z / sqrt(x*x+y*y) );

    } else if (*cptr == 'S') {

      if (*(cptr + 1) == 'I' &&  *(cptr + 2) == 'N') { /* -SIN */
          if (sins>1.0)
	    return(*status = 501);
          coss = sqrt (1.0 - sins);
          dt = sin0 * coss + cos0 * m;
          if ((dt>1.0) || (dt<-1.0))
	    return(*status = 501);
          dect = asin (dt);
          rat = cos0 * coss - sin0 * m;
          if ((rat==0.0) && (l==0.0))
	    return(*status = 501);
          rat = atan2 (l, rat) + ra0;

       } else if (*(cptr + 1) == 'T' &&  *(cptr + 2) == 'G') {  /* -STG Sterographic*/
          dz = (4.0 - sins) / (4.0 + sins);
          if (fabs(dz)>1.0)
	    return(*status = 501);
          dect = dz * sin0 + m * cos0 * (1.0+dz) / 2.0;
          if (fabs(dect)>1.0)
	    return(*status = 501);
          dect = asin (dect);
          rat = cos(dect);
          if (fabs(rat)1.0)
	    return(*status = 501);
          rat = asin (rat);
          mg = 1.0 + sin(dect) * sin0 + cos(dect) * cos0 * cos(rat);
          if (fabs(mg)deps)
	    rat = TWOPI /2.0 - rat;
          rat = ra0 + rat;
        } else  {
          return(*status = 504);
        }
 
    } else if (*cptr == 'A') {

      if (*(cptr + 1) == 'R' &&  *(cptr + 2) == 'C') { /* ARC */
          if (sins>=TWOPI*TWOPI/4.0)
	    return(*status = 501);
          sins = sqrt(sins);
          coss = cos (sins);
          if (sins!=0.0)
	    sins = sin (sins) / sins;
          else
	    sins = 1.0;
          dt = m * cos0 * sins + sin0 * coss;
          if ((dt>1.0) || (dt<-1.0))
	    return(*status = 501);
          dect = asin (dt);
          da = coss - dt * sin0;
          dt = l * sins * cos0;
          if ((da==0.0) && (dt==0.0))
	    return(*status = 501);
          rat = ra0 + atan2 (dt, da);

      } else if (*(cptr + 1) == 'I' &&  *(cptr + 2) == 'T') {  /* -AIT Aitoff */
          dt = yinc*cosr + xinc*sinr;
          if (dt==0.0)
	    dt = 1.0;
          dt = dt * D2R;
          dy = yref * D2R;
          dx = sin(dy+dt)/sqrt((1.0+cos(dy+dt))/2.0) -
	      sin(dy)/sqrt((1.0+cos(dy))/2.0);
          if (dx==0.0)
	    dx = 1.0;
          geo2 = dt / dx;
          dt = xinc*cosr - yinc* sinr;
          if (dt==0.0)
	    dt = 1.0;
          dt = dt * D2R;
          dx = 2.0 * cos(dy) * sin(dt/2.0);
          if (dx==0.0) dx = 1.0;
          geo1 = dt * sqrt((1.0+cos(dy)*cos(dt/2.0))/2.0) / dx;
          geo3 = geo2 * sin(dy) / sqrt((1.0+cos(dy))/2.0);
          rat = ra0;
          dect = dec0;
          if ((l != 0.0) || (m != 0.0)) {
            dz = 4.0 - l*l/(4.0*geo1*geo1) - ((m+geo3)/geo2)*((m+geo3)/geo2) ;
            if ((dz>4.0) || (dz<2.0)) return(*status = 501);
            dz = 0.5 * sqrt (dz);
            dd = (m+geo3) * dz / geo2;
            if (fabs(dd)>1.0) return(*status = 501);
            dd = asin (dd);
            if (fabs(cos(dd))1.0) return(*status = 501);
            da = asin (da);
            rat = ra0 + 2.0 * da;
            dect = dd;
          }
        } else  {
          return(*status = 504);
        }
 
    } else if (*cptr == 'N') { /* -NCP North celestial pole*/
      if (*(cptr + 1) != 'C' ||  *(cptr + 2) != 'P') {
         return(*status = 504);
      }
      dect = cos0 - m * sin0;
      if (dect==0.0)
        return(*status = 501);
      rat = ra0 + atan2 (l, dect);
      dt = cos (rat-ra0);
      if (dt==0.0)
        return(*status = 501);
      dect = dect / dt;
      if ((dect>1.0) || (dect<-1.0))
        return(*status = 501);
      dect = acos (dect);
      if (dec0<0.0) dect = -dect;

    } else if (*cptr == 'G') {   /* -GLS global sinusoid */
      if (*(cptr + 1) != 'L' ||  *(cptr + 2) != 'S') {
         return(*status = 504);
      }
      dect = dec0 + m;
      if (fabs(dect)>TWOPI/4.0)
        return(*status = 501);
      coss = cos (dect);
      if (fabs(l)>TWOPI*coss/2.0)
        return(*status = 501);
      rat = ra0;
      if (coss>deps) rat = rat + l / coss;

    } else if (*cptr == 'M') {  /* -MER mercator*/
      if (*(cptr + 1) != 'E' ||  *(cptr + 2) != 'R') {
         return(*status = 504);
      }
      dt = yinc * cosr + xinc * sinr;
      if (dt==0.0) dt = 1.0;
      dy = (yref/2.0 + 45.0) * D2R;
      dx = dy + dt / 2.0 * D2R;
      dy = log (tan (dy));
      dx = log (tan (dx));
      geo2 = dt * D2R / (dx - dy);
      geo3 = geo2 * dy;
      geo1 = cos (yref*D2R);
      if (geo1<=0.0) geo1 = 1.0;
      rat = l / geo1 + ra0;
      if (fabs(rat - ra0) > TWOPI)
        return(*status = 501);
      dt = 0.0;
      if (geo2!=0.0) dt = (m + geo3) / geo2;
      dt = exp (dt);
      dect = 2.0 * atan (dt) - TWOPI / 4.0;

    } else  {
      return(*status = 504);
    }

  /*  correct for RA rollover  */
  if (rat-ra0>TWOPI/2.0) rat = rat - TWOPI;
  if (rat-ra0<-TWOPI/2.0) rat = rat + TWOPI;
  if (rat < 0.0) rat += TWOPI;

  /*  convert to degrees  */
  *xpos  = rat  / D2R;
  *ypos  = dect  / D2R;
  return(*status);
} 
/*--------------------------------------------------------------------------*/
int ffxypx(double xpos, double ypos, double xref, double yref, 
      double xrefpix, double yrefpix, double xinc, double yinc, double rot,
      char *type, double *xpix, double *ypix, int *status)

/* This routine is based on the classic AIPS WCS routine. 

   It converts from RA,Dec to pixel location to for 9 projective geometries:
   "-CAR", "-SIN", "-TAN", "-ARC", "-NCP", "-GLS", "-MER", "-AIT" and "-STG".
*/
/*-----------------------------------------------------------------------*/
/* routine to determine accurate pixel coordinates for an RA and Dec     */
/* returns 0 if successful otherwise:                                    */
/* 501 = angle too large for projection;                                 */
/* 502 = bad values                                                      */
/* does: -SIN, -TAN, -ARC, -NCP, -GLS, -MER, -AIT projections            */
/* anything else is linear                                               */
/* Input:                                                                */
/*   d   xpos    x (RA) coordinate (deg)                                 */
/*   d   ypos    y (dec) coordinate (deg)                                */
/*   d   xref    x reference coordinate value (deg)                      */
/*   d   yref    y reference coordinate value (deg)                      */
/*   f   xrefpix x reference pixel                                       */
/*   f   yrefpix y reference pixel                                       */
/*   f   xinc    x coordinate increment (deg)                            */
/*   f   yinc    y coordinate increment (deg)                            */
/*   f   rot     rotation (deg)  (from N through E)                      */
/*   c  *type    projection type code e.g. "-SIN";                       */
/* Output:                                                               */
/*   f  *xpix    x pixel number  (RA or long without rotation)           */
/*   f  *ypiy    y pixel number  (dec or lat without rotation)           */
/*-----------------------------------------------------------------------*/
 {
  double dx, dy, dz, r, ra0, dec0, ra, dec, coss, sins, dt, da, dd, sint;
  double l, m, geo1, geo2, geo3, sinr, cosr, cos0, sin0;
  double deps=1.0e-5;
  char *cptr;

  if (*type != '-') {  /* unrecognized projection code */
     return(*status = 504);
  }

  cptr = type + 1;

  dt = (xpos - xref);
  if (dt >  180) xpos -= 360;
  if (dt < -180) xpos += 360;
  /* NOTE: changing input argument xpos is OK (call-by-value in C!) */

  /* default values - linear */
  dx = xpos - xref;
  dy = ypos - yref;

  /*  Correct for rotation */
  r = rot * D2R;
  cosr = cos (r);
  sinr = sin (r);
  dz = dx*cosr + dy*sinr;
  dy = dy*cosr - dx*sinr;
  dx = dz;

  /*     check axis increments - bail out if either 0 */
  if ((xinc==0.0) || (yinc==0.0)) {*xpix=0.0; *ypix=0.0;
    return(*status = 502);}

  /*     convert to pixels  */
  *xpix = dx / xinc + xrefpix;
  *ypix = dy / yinc + yrefpix;

  if (*cptr == 'C') { /* linear -CAR */
      if (*(cptr + 1) != 'A' ||  *(cptr + 2) != 'R') {
         return(*status = 504);
      }

      return(*status);  /* done if linear */
  }

  /* Non linear position */
  ra0 = xref * D2R;
  dec0 = yref * D2R;
  ra = xpos * D2R;
  dec = ypos * D2R;

  /* compute direction cosine */
  coss = cos (dec);
  sins = sin (dec);
  cos0 = cos (dec0);
  sin0 = sin (dec0);
  l = sin(ra-ra0) * coss;
  sint = sins * sin0 + coss * cos0 * cos(ra-ra0);

    /* process by case  */
    if (*cptr == 'T') {  /* -TAN tan */
         if (*(cptr + 1) != 'A' ||  *(cptr + 2) != 'N') {
           return(*status = 504);
         }

         if (sint<=0.0)
	   return(*status = 501);
         if( cos0<0.001 ) {
            /* Do a first order expansion around pole */
            m = (coss * cos(ra-ra0)) / (sins * sin0);
            m = (-m + cos0 * (1.0 + m*m)) / sin0;
         } else {
            m = ( sins/sint - sin0 ) / cos0;
         }
	 if( fabs(sin(ra0)) < 0.3 ) {
	    l  = coss*sin(ra)/sint - cos0*sin(ra0) + m*sin(ra0)*sin0;
	    l /= cos(ra0);
	 } else {
	    l  = coss*cos(ra)/sint - cos0*cos(ra0) + m*cos(ra0)*sin0;
	    l /= -sin(ra0);
	 }

    } else if (*cptr == 'S') {

      if (*(cptr + 1) == 'I' &&  *(cptr + 2) == 'N') { /* -SIN */
         if (sint<0.0)
	   return(*status = 501);
         m = sins * cos(dec0) - coss * sin(dec0) * cos(ra-ra0);

      } else if (*(cptr + 1) == 'T' &&  *(cptr + 2) == 'G') {  /* -STG Sterographic*/
         da = ra - ra0;
         if (fabs(dec)>TWOPI/4.0)
	   return(*status = 501);
         dd = 1.0 + sins * sin(dec0) + coss * cos(dec0) * cos(da);
         if (fabs(dd)1.0) m = 1.0;
         m = acos (m);
         if (m!=0) 
            m = m / sin(m);
         else
            m = 1.0;
         l = l * m;
         m = (sins * cos(dec0) - coss * sin(dec0) * cos(ra-ra0)) * m;

      } else if (*(cptr + 1) == 'I' &&  *(cptr + 2) == 'T') {  /* -AIT Aitoff */
         da = (ra - ra0) / 2.0;
         if (fabs(da)>TWOPI/4.0)
	     return(*status = 501);
         dt = yinc*cosr + xinc*sinr;
         if (dt==0.0) dt = 1.0;
         dt = dt * D2R;
         dy = yref * D2R;
         dx = sin(dy+dt)/sqrt((1.0+cos(dy+dt))/2.0) -
             sin(dy)/sqrt((1.0+cos(dy))/2.0);
         if (dx==0.0) dx = 1.0;
         geo2 = dt / dx;
         dt = xinc*cosr - yinc* sinr;
         if (dt==0.0) dt = 1.0;
         dt = dt * D2R;
         dx = 2.0 * cos(dy) * sin(dt/2.0);
         if (dx==0.0) dx = 1.0;
         geo1 = dt * sqrt((1.0+cos(dy)*cos(dt/2.0))/2.0) / dx;
         geo3 = geo2 * sin(dy) / sqrt((1.0+cos(dy))/2.0);
         dt = sqrt ((1.0 + cos(dec) * cos(da))/2.0);
         if (fabs(dt)TWOPI/4.0)
	   return(*status = 501);
         if (fabs(dec0)>TWOPI/4.0)
	   return(*status = 501);
         m = dec - dec0;
         l = dt * coss;

    } else if (*cptr == 'M') {  /* -MER mercator*/
         if (*(cptr + 1) != 'E' ||  *(cptr + 2) != 'R') {
             return(*status = 504);
         }

         dt = yinc * cosr + xinc * sinr;
         if (dt==0.0) dt = 1.0;
         dy = (yref/2.0 + 45.0) * D2R;
         dx = dy + dt / 2.0 * D2R;
         dy = log (tan (dy));
         dx = log (tan (dx));
         geo2 = dt * D2R / (dx - dy);
         geo3 = geo2 * dy;
         geo1 = cos (yref*D2R);
         if (geo1<=0.0) geo1 = 1.0;
         dt = ra - ra0;
         l = geo1 * dt;
         dt = dec / 2.0 + TWOPI / 8.0;
         dt = tan (dt);
         if (dt
#include 
#include 
#include 

#ifdef _ALPHA_
#define e_magic_number IMAGE_FILE_MACHINE_ALPHA
#else
#define e_magic_number IMAGE_FILE_MACHINE_I386
#endif

/*
 *----------------------------------------------------------------------
 * GetArgcArgv --
 * 
 *	Break up a line into argc argv
 *----------------------------------------------------------------------
 */
int
GetArgcArgv(char *s, char **argv)
{
    int quote = 0;
    int argc = 0;
    char *bp;

    bp = s;
    while (1) {
	while (isspace(*bp)) {
	    bp++;
	}
	if (*bp == '\n' || *bp == '\0') {
	    *bp = '\0';
	    return argc;
	}
	if (*bp == '\"') {
	    quote = 1;
	    bp++;
	}
	argv[argc++] = bp;

	while (*bp != '\0') {
	    if (quote) {
		if (*bp == '\"') {
		    quote = 0;
		    *bp = '\0';
		    bp++;
		    break;
		}
		bp++;
		continue;
	    }
	    if (isspace(*bp)) {
		*bp = '\0';
		bp++;
		break;
	    }
	    bp++;
	}
    }
}

/*
 *  The names of the first group of possible symbol table storage classes
 */
char * SzStorageClass1[] = {
    "NULL","AUTOMATIC","EXTERNAL","STATIC","REGISTER","EXTERNAL_DEF","LABEL",
    "UNDEFINED_LABEL","MEMBER_OF_STRUCT","ARGUMENT","STRUCT_TAG",
    "MEMBER_OF_UNION","UNION_TAG","TYPE_DEFINITION","UNDEFINED_STATIC",
    "ENUM_TAG","MEMBER_OF_ENUM","REGISTER_PARAM","BIT_FIELD"
};

/*
 * The names of the second group of possible symbol table storage classes
 */
char * SzStorageClass2[] = {
    "BLOCK","FUNCTION","END_OF_STRUCT","FILE","SECTION","WEAK_EXTERNAL"
};

/*
 *----------------------------------------------------------------------
 * GetSZStorageClass --
 *
 *	Given a symbol storage class value, return a descriptive
 *	ASCII string
 *----------------------------------------------------------------------
 */
PSTR
GetSZStorageClass(BYTE storageClass)
{
	if ( storageClass <= IMAGE_SYM_CLASS_BIT_FIELD )
		return SzStorageClass1[storageClass];
	else if ( (storageClass >= IMAGE_SYM_CLASS_BLOCK)
		      && (storageClass <= IMAGE_SYM_CLASS_WEAK_EXTERNAL) )
		return SzStorageClass2[storageClass-IMAGE_SYM_CLASS_BLOCK];
	else
		return "???";
}

/*
 *----------------------------------------------------------------------
 * GetSectionName --
 *
 *	Used by DumpSymbolTable, it gives meaningful names to
 *	the non-normal section number.
 *
 * Results:
 *	A name is returned in buffer
 *----------------------------------------------------------------------
 */
void
GetSectionName(WORD section, PSTR buffer, unsigned cbBuffer)
{
    char tempbuffer[10];
	
    switch ( (SHORT)section )
    {
      case IMAGE_SYM_UNDEFINED: strcpy(tempbuffer, "UNDEF"); break;
      case IMAGE_SYM_ABSOLUTE:  strcpy(tempbuffer, "ABS  "); break;
      case IMAGE_SYM_DEBUG:	  strcpy(tempbuffer, "DEBUG"); break;
      default: wsprintf(tempbuffer, "%-5X", section);
    }
	
    strncpy(buffer, tempbuffer, cbBuffer-1);
}

/*
 *----------------------------------------------------------------------
 * DumpSymbolTable --
 *
 *	Dumps a COFF symbol table from an EXE or OBJ.  We only use
 *	it to dump tables from OBJs.
 *----------------------------------------------------------------------
 */
void
DumpSymbolTable(PIMAGE_SYMBOL pSymbolTable, FILE *fout, unsigned cSymbols)
{
    unsigned i;
    PSTR stringTable;
    char sectionName[10];
	
    fprintf(fout, "Symbol Table - %X entries  (* = auxillary symbol)\n",
	    cSymbols);

    fprintf(fout, 
     "Indx Name                 Value    Section    cAux  Type    Storage\n"
     "---- -------------------- -------- ---------- ----- ------- --------\n");

    /*
     * The string table apparently starts right after the symbol table
     */
    stringTable = (PSTR)&pSymbolTable[cSymbols]; 
		
    for ( i=0; i < cSymbols; i++ ) {
	fprintf(fout, "%04X ", i);
	if ( pSymbolTable->N.Name.Short != 0 )
	    fprintf(fout, "%-20.8s", pSymbolTable->N.ShortName);
	else
	    fprintf(fout, "%-20s", stringTable + pSymbolTable->N.Name.Long);

	fprintf(fout, " %08X", pSymbolTable->Value);

	GetSectionName(pSymbolTable->SectionNumber, sectionName,
		       sizeof(sectionName));
	fprintf(fout, " sect:%s aux:%X type:%02X st:%s\n",
	       sectionName,
	       pSymbolTable->NumberOfAuxSymbols,
	       pSymbolTable->Type,
	       GetSZStorageClass(pSymbolTable->StorageClass) );
#if 0
	if ( pSymbolTable->NumberOfAuxSymbols )
	    DumpAuxSymbols(pSymbolTable);
#endif

	/*
	 * Take into account any aux symbols
	 */
	i += pSymbolTable->NumberOfAuxSymbols;
	pSymbolTable += pSymbolTable->NumberOfAuxSymbols;
	pSymbolTable++;
    }
}

/*
 *----------------------------------------------------------------------
 * DumpExternals --
 *
 *	Dumps a COFF symbol table from an EXE or OBJ.  We only use
 *	it to dump tables from OBJs.
 *----------------------------------------------------------------------
 */
void
DumpExternals(PIMAGE_SYMBOL pSymbolTable, FILE *fout, unsigned cSymbols)
{
    unsigned i;
    PSTR stringTable;
    char *s, *f;
    char symbol[1024];
	
    /*
     * The string table apparently starts right after the symbol table
     */
    stringTable = (PSTR)&pSymbolTable[cSymbols]; 
		
    for ( i=0; i < cSymbols; i++ ) {
	if (pSymbolTable->SectionNumber > 0 && pSymbolTable->Type == 0x20) {
	    if (pSymbolTable->StorageClass == IMAGE_SYM_CLASS_EXTERNAL) {
		if (pSymbolTable->N.Name.Short != 0) {
		    strncpy(symbol, pSymbolTable->N.ShortName, 8);
		    symbol[8] = 0;
		} else {
		    s = stringTable + pSymbolTable->N.Name.Long;
		    strcpy(symbol, s);
		}
		s = symbol;
		f = strchr(s, '@');
		if (f) {
		    *f = 0;
		}
#if defined(_MSC_VER) && defined(_X86_)
		if (symbol[0] == '_') {
		    s = &symbol[1];
		}
#endif
		if ((stricmp(s, "DllEntryPoint") != 0) 
			&& (stricmp(s, "DllMain") != 0)) {
		    fprintf(fout, "\t%s\n", s);
		}
	    }
	}

	/*
	 * Take into account any aux symbols
	 */
	i += pSymbolTable->NumberOfAuxSymbols;
	pSymbolTable += pSymbolTable->NumberOfAuxSymbols;
	pSymbolTable++;
    }
}

/*
 *----------------------------------------------------------------------
 * DumpObjFile --
 *
 *	Dump an object file--either a full listing or just the exported
 *	symbols.
 *----------------------------------------------------------------------
 */
void
DumpObjFile(PIMAGE_FILE_HEADER pImageFileHeader, FILE *fout, int full)
{
    PIMAGE_SYMBOL PCOFFSymbolTable;
    DWORD COFFSymbolCount;
    
    PCOFFSymbolTable = (PIMAGE_SYMBOL)
	((DWORD)pImageFileHeader + pImageFileHeader->PointerToSymbolTable);
    COFFSymbolCount = pImageFileHeader->NumberOfSymbols;

    if (full) {
	DumpSymbolTable(PCOFFSymbolTable, fout, COFFSymbolCount);
    } else {
	DumpExternals(PCOFFSymbolTable, fout, COFFSymbolCount);
    }
}

/*
 *----------------------------------------------------------------------
 * SkipToNextRecord --
 *
 *	Skip over the current ROMF record and return the type of the
 *	next record.
 *----------------------------------------------------------------------
 */

BYTE
SkipToNextRecord(BYTE **ppBuffer)
{
    int length;
    (*ppBuffer)++;		/* Skip over the type.*/
    length = *((WORD*)(*ppBuffer))++; /* Retrieve the length. */
    *ppBuffer += length;	/* Skip over the rest. */
    return **ppBuffer;		/* Return the type. */
}

/*
 *----------------------------------------------------------------------
 * DumpROMFObjFile --
 *
 *	Dump a Relocatable Object Module Format file, displaying only
 *	the exported symbols.
 *----------------------------------------------------------------------
 */
void
DumpROMFObjFile(LPVOID pBuffer, FILE *fout)
{
    BYTE type, length;
    char symbol[1024], *s;

    while (1) {
	type = SkipToNextRecord(&(BYTE*)pBuffer);
	if (type == 0x90) {	/* PUBDEF */
	    if (((BYTE*)pBuffer)[4] != 0) {
		length = ((BYTE*)pBuffer)[5];
		strncpy(symbol, ((char*)pBuffer) + 6, length);
		symbol[length] = '\0';
		s = symbol;
		if ((stricmp(s, "DllEntryPoint") != 0) 
			&& (stricmp(s, "DllMain") != 0)) {
		    if (s[0] == '_') {
			s++;
			fprintf(fout, "\t_%s\n\t%s=_%s\n", s, s, s);
		    } else {
			fprintf(fout, "\t%s\n", s);
		    }
		}
	    }
	} else if (type == 0x8B || type == 0x8A) { /* MODEND */
	    break;
	}
    }
}

/*
 *----------------------------------------------------------------------
 * DumpFile --
 *
 *	Open up a file, memory map it, and call the appropriate
 *	dumping routine
 *----------------------------------------------------------------------
 */
void
DumpFile(LPSTR filename, FILE *fout, int full)
{
    HANDLE hFile;
    HANDLE hFileMapping;
    LPVOID lpFileBase;
    PIMAGE_DOS_HEADER dosHeader;
	
    hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
		       OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
					
    if (hFile == INVALID_HANDLE_VALUE) {
	fprintf(stderr, "Couldn't open file with CreateFile()\n");
	return;
    }

    hFileMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
    if (hFileMapping == 0) {
	CloseHandle(hFile);
	fprintf(stderr, "Couldn't open file mapping with CreateFileMapping()\n");
	return;
    }

    lpFileBase = MapViewOfFile(hFileMapping, FILE_MAP_READ, 0, 0, 0);
    if (lpFileBase == 0) {
	CloseHandle(hFileMapping);
	CloseHandle(hFile);
	fprintf(stderr, "Couldn't map view of file with MapViewOfFile()\n");
	return;
    }

    dosHeader = (PIMAGE_DOS_HEADER)lpFileBase;
    if (dosHeader->e_magic == IMAGE_DOS_SIGNATURE) {
#if 0
	DumpExeFile( dosHeader );
#else
	fprintf(stderr, "File is an executable.  I don't dump those.\n");
	return;
#endif
    }
    /* Does it look like a i386 COFF OBJ file??? */
    else if ((dosHeader->e_magic == e_magic_number)
	    && (dosHeader->e_sp == 0)) {
	/*
	 * The two tests above aren't what they look like.  They're
	 * really checking for IMAGE_FILE_HEADER.Machine == i386 (0x14C)
	 * and IMAGE_FILE_HEADER.SizeOfOptionalHeader == 0;
	 */
	DumpObjFile((PIMAGE_FILE_HEADER) lpFileBase, fout, full);
    } else if (*((BYTE *)lpFileBase) == 0x80) {
	/*
	 * This file looks like it might be a ROMF file.
	 */
	DumpROMFObjFile(lpFileBase, fout);
    } else {
	printf("unrecognized file format\n");
    }
    UnmapViewOfFile(lpFileBase);
    CloseHandle(hFileMapping);
    CloseHandle(hFile);
}

void
main(int argc, char **argv)
{
    char *fargv[1000];
    char cmdline[10000];
    int i, arg;
    FILE *fout;
    int pos;
    int full = 0;
    char *outfile = NULL;

    if (argc < 3) {
      Usage:
	fprintf(stderr, "Usage: %s ?-o outfile? ?-f(ull)?   ..\n", argv[0]);
	exit(1);
    }

    arg = 1;
    while (argv[arg][0] == '-') {
	if (strcmp(argv[arg], "--") == 0) {
	    arg++;
	    break;
	} else if (strcmp(argv[arg], "-f") == 0) {
	    full = 1;
	} else if (strcmp(argv[arg], "-o") == 0) {
	    arg++;
	    if (arg == argc) {
		goto Usage;
	    }
	    outfile = argv[arg];
	}
	arg++;
    }
    if (arg == argc) {
	goto Usage;
    }

    if (outfile) {
	fout = fopen(outfile, "w+");
	if (fout == NULL) {
	    fprintf(stderr, "Unable to open \'%s\' for writing:\n",
		    argv[arg]);
	    perror("");
	    exit(1);
	}
    } else {
	fout = stdout;
    }
    
    if (! full) {
	char *dllname = argv[arg];
	arg++;
	if (arg == argc) {
	    goto Usage;
	}
	fprintf(fout, "LIBRARY    %s\n", dllname);
	fprintf(fout, "EXETYPE WINDOWS\n");
	fprintf(fout, "CODE PRELOAD MOVEABLE DISCARDABLE\n");
	fprintf(fout, "DATA PRELOAD MOVEABLE MULTIPLE\n\n");
	fprintf(fout, "EXPORTS\n");
    }

    for (; arg < argc; arg++) {
	if (argv[arg][0] == '@') {
	    FILE *fargs = fopen(&argv[arg][1], "r");
	    if (fargs == NULL) {
		fprintf(stderr, "Unable to open \'%s\' for reading:\n",
			argv[arg]);
		perror("");
		exit(1);
	    }
	    pos = 0;
	    for (i = 0; i < arg; i++) {
		strcpy(&cmdline[pos], argv[i]);
		pos += strlen(&cmdline[pos]) + 1;
		fargv[i] = argv[i];
	    }
	    fgets(&cmdline[pos], sizeof(cmdline), fargs);
	    fprintf(stderr, "%s\n", &cmdline[pos]);
	    fclose(fargs);
	    i += GetArgcArgv(&cmdline[pos], &fargv[i]);
	    argc = i;
	    argv = fargv;
	}
	DumpFile(argv[arg], fout, full);
    }
    exit(0);
}
healpy-1.10.3/healpixsubmodule/0000775000175000017500000000000013031130324016666 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/0000775000175000017500000000000013031130324017455 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/cxx/0000775000175000017500000000000013031130324020257 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/cxx/autotools/0000775000175000017500000000000013031130324022310 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/0000775000175000017500000000000013031130324024564 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/Healpix_cxx.dox0000664000175000017500000001364613010375061027574 0ustar  zoncazonca00000000000000/*! \mainpage HEALPix C++ documentation
  
    
  
  • \ref components "Programming interface"
  
  • \ref uselib "How to use the library in your own codes"
  
  • \ref facilities "Facilities"
  

 */

/*! \page components Code components

  Classes:
   - Healpix_Base contains all functionality related to the HEALPix
     pixelisation which does not require actual map data.
   - Healpix_Base2 is analogous to Healpix_Base, but allows for much
     higher resolutions.
   - Healpix_Map is derived from Healpix_Base and implements
     additional functionality like change of the ordering scheme, up- and
     degrading and interpolation.
   - Alm is used to store spherical harmonic coefficients.
   - PowSpec is used to store \f$C_l\f$ coefficients.

  Conversions between different data types:
   - \ref alm_healpix_group "HEALPix maps <-> a_lm".
   - \ref alm_ps_group "power spectra <-> a_lm".

  FITS I/O:
   - for \ref healpix_map_fitsio_group "HEALPix Maps"
   - for \ref alm_fitsio_group "spherical harmonic coefficients"
   - for \ref powspec_fitsio_group "power spectra"
*/

/*! \page uselib Using Healpix C++ in your own codes

  In order to use the Healpix library in your own C++ codes, you have to do two
  things:
   - \c #include the appropriate header files in your sources. From this
     documentation it should be evident which ones you have to include for a
     specific task.
   - Specify the required libraries when linking your executable. For this
     release of the software, this should be (order is important!):
     \verbatim-lhealpix_cxx -lcxxsupport -lsharp -lfftpack -lc_utils -lcfitsio\endverbatim
*/

/*! \page facilities HEALPix C++ facilities

  \section syn_alm_cxx
    This program reads a set of \f$C_l\f$ from disk and converts it to
    a set of \f$a_{lm}\f$.

    \verbinclude syn_alm_cxx.par.txt

  \section alm2map_cxx
    This program reads a set of \f$a_{lm}\f$ from disk and converts them to
    a HEALPix map.

    \verbinclude alm2map_cxx.par.txt

  \section anafast_cxx
    This program performs harmonic analysis of a HEALPix map up to a
    user-specified maximum spherical harmonic order \f$l_{\mbox{max}}\f$.
    The integrals are computed on the whole sphere.
    Scalar, or scalar and tensor, spherical harmonic coefficients are evaluated
    from the map(s) if the input provides, respectively, only the temperature,
    or temperature and polarisation maps.
    The total operation count scales as  \f${\cal {O}}(N_{\mbox{pix}}^{3/2})\f$
    with a prefactor depending on \f$l_{\mbox{max}}\f$.

    Anafast_cxx reads a file containing the map(s) and produces a file
    containing the temperature power spectrum \f$C^T_l\f$ and, if requested,
    also the polarisation power spectra \f$C^E_l\f$, \f$C^B_l\f$ and
    \f$C^{T\times E}_l\f$. The \f$a_{lm}\f$ coefficients computed during the
    execution also can be written to a file if requested.

    Anafast_cxx executes an approximate, discrete point-set quadrature on
    a sphere sampled at the HEALPix pixel centers.
    Spherical harmonic transforms are computed using recurrence relations for
    Legendre polynomials on co-latitude (\f$\vartheta\f$) and Fast Fourier
    transforms on longitude (\f$\varphi\f$).

    Anafast permits two execution options which allow a significant
    improvement of accuracy of the approximate quadrature performed by
    this facility:

    - An improved analysis using the provided ring weights, which correct the
      quadrature on latitude, and/or
    - An iterative scheme using in succession several backward and forward
      harmonic transforms of the maps.

    \verbinclude anafast_cxx.par.txt

  \section map2tga
    This program reads in a HEALPix sky map in FITS format and generates an
    image in TGA format. map2tga allows the selection of the projection
    scheme (Mollweide or Gnomonic for small patches of the sky), color
    table, color bar inclusion, linear or log scaling, maximum and
    minimum range for the plot and plot-title. The facility provides
    a command-line interface, but can also read a parameter file.

    \verbinclude map2tga.par.txt

  \section rotalm_cxx
    Performs a coordinate transformation on a set of \f$a_{lm}\f$.

    \verbatim
Usage: rotalm_cxx    
Transform 1: Equatorial (2000) -> Galactic   (2000)
          2: Galactic   (2000) -> Equatorial (2000)
          3: Equatorial (2000) -> Ecliptic   (2000)
          4: Ecliptic   (2000) -> Equatorial (2000)
          5: Ecliptic   (2000) -> Galactic   (2000)
          6: Galactic   (2000) -> Ecliptic   (2000)
          7: Equatorial (1950) -> Galactic   (1950)
          8: Galactic   (1950) -> Equatorial (1950)
          9: Equatorial (1950) -> Ecliptic   (1950)
         10: Ecliptic   (1950) -> Equatorial (1950)
         11: Ecliptic   (1950) -> Galactic   (1950)
         12: Galactic   (1950) -> Ecliptic   (1950)
    \endverbatim

  \section mult_alm
    This program reads a set of (unpolarised or polarised) \f$a_{lm}\f$,
    removes pixel window functions and/or Gaussian beams, applies different
    pixel window functions or Gaussian beams, and outputs the result.

    \verbinclude mult_alm.par.txt

  \section smoothing_cxx
    This program reads a (unpolarised or polarised) HEALPix map, converts it
    to \f$a_{lm}\f$, performs a smoothing operation with a Gaussian beam,
    converts the \f$a_{lm}\f$ back to a map and outputs the result.

    \verbinclude smoothing_cxx.par.txt

  \section calc_powspec
    This program reads one or two sets of \f$a_{lm}\f$, extracts the
    (unpolarised or polarised) power spectrum or the unpolarised cross power
    spectrum, and outputs the result.

    \verbatim Usage: calc_powspec  [] \endverbatim 

  \section median_filter_cxx
    This program inputs a HEALPix map, runs a median filter with the desired
    radius on it and saves the result to another file.

    \verbatim Usage: median_filter_cxx   \endverbatim
*/
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm.cc0000664000175000017500000000275613010375061025664 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file alm.cc
 *  Class for storing spherical harmonic coefficients.
 *
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#include "alm.h"

using namespace std;

//static
tsize Alm_Base::Num_Alms (int l, int m)
  {
  planck_assert(m<=l,"mmax must not be larger than lmax");
  return ((m+1)*(m+2))/2 + (m+1)*(l-m);
  }

void Alm_Base::swap (Alm_Base &other)
  {
  std::swap(lmax, other.lmax);
  std::swap(mmax, other.mmax);
  std::swap(tval, other.tval);
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm.h0000664000175000017500000001320313010375061025513 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file alm.h
 *  Class for storing spherical harmonic coefficients.
 *
 *  Copyright (C) 2003-2012 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_ALM_H
#define PLANCK_ALM_H

#include "arr.h"

/*! Base class for calculating the storage layout of spherical harmonic
    coefficients. */
class Alm_Base
  {
  protected:
    int lmax, mmax, tval;

  public:
    /*! Returns the total number of coefficients for maximum quantum numbers
        \a l and \a m. */
    static tsize Num_Alms (int l, int m);

    /*! Constructs an Alm_Base object with given \a lmax and \a mmax. */
    Alm_Base (int lmax_=0, int mmax_=0)
      : lmax(lmax_), mmax(mmax_), tval(2*lmax+1) {}

    /*! Changes the object's maximum quantum numbers to \a lmax and \a mmax. */
    void Set (int lmax_, int mmax_)
      {
      lmax=lmax_;
      mmax=mmax_;
      tval=2*lmax+1;
      }

    /*! Returns the maximum \a l */
    int Lmax() const { return lmax; }
    /*! Returns the maximum \a m */
    int Mmax() const { return mmax; }

    /*! Returns an array index for a given m, from which the index of a_lm
        can be obtained by adding l. */
    int index_l0 (int m) const
      { return ((m*(tval-m))>>1); }

    /*! Returns the array index of the specified coefficient. */
    int index (int l, int m) const
      { return index_l0(m) + l; }

    /*! Returns \a true, if both objects have the same \a lmax and \a mmax,
        else  \a false. */
    bool conformable (const Alm_Base &other) const
      { return ((lmax==other.lmax) && (mmax==other.mmax)); }

    /*! Swaps the contents of two Alm_Base objects. */
    void swap (Alm_Base &other);
  };

/*! Class for storing spherical harmonic coefficients. */
template class Alm: public Alm_Base
  {
  private:
    arr alm;

  public:
    /*! Constructs an Alm object with given \a lmax and \a mmax. */
    Alm (int lmax_=0, int mmax_=0)
      : Alm_Base(lmax_,mmax_), alm (Num_Alms(lmax,mmax)) {}

    /*! Deletes the old coefficients and allocates storage according to
        \a lmax and \a mmax. */
    void Set (int lmax_, int mmax_)
      {
      Alm_Base::Set(lmax_, mmax_);
      alm.alloc(Num_Alms(lmax,mmax));
      }

    /*! Deallocates the old coefficients and uses the content of \a data
        for storage. \a data is deallocated during the call. */
    void Set (arr &data, int lmax_, int mmax_)
      {
      planck_assert (Num_Alms(lmax_,mmax_)==data.size(),"wrong array size");
      Alm_Base::Set(lmax_, mmax_);
      alm.transfer(data);
      }

    /*! Sets all coefficients to zero. */
    void SetToZero ()
      { alm.fill (0); }

    /*! Multiplies all coefficients by \a factor. */
    template void Scale (const T2 &factor)
      { for (tsize m=0; m void ScaleL (const arr &factor)
      {
      planck_assert(factor.size()>tsize(lmax),
        "alm.ScaleL: factor array too short");
      for (int m=0; m<=mmax; ++m)
        for (int l=m; l<=lmax; ++l)
          operator()(l,m)*=factor[l];
      }
    /*! \a a(l,m) *= \a factor[m] for all \a l,m. */
    template void ScaleM (const arr &factor)
      {
      planck_assert(factor.size()>tsize(mmax),
        "alm.ScaleM: factor array too short");
      for (int m=0; m<=mmax; ++m)
        for (int l=m; l<=lmax; ++l)
          operator()(l,m)*=factor[m];
      }
    /*! Adds \a num to a_00. */
    template void Add (const T2 &num)
      { alm[0]+=num; }

    /*! Returns a reference to the specified coefficient. */
    T &operator() (int l, int m)
      { return alm[index(l,m)]; }
    /*! Returns a constant reference to the specified coefficient. */
    const T &operator() (int l, int m) const
      { return alm[index(l,m)]; }

    /*! Returns a pointer for a given m, from which the address of a_lm
        can be obtained by adding l. */
    T *mstart (int m)
      { return &alm[index_l0(m)]; }
    /*! Returns a pointer for a given m, from which the address of a_lm
        can be obtained by adding l. */
    const T *mstart (int m) const
      { return &alm[index_l0(m)]; }

    /*! Returns a constant reference to the a_lm data. */
    const arr &Alms () const { return alm; }

    /*! Swaps the contents of two Alm objects. */
    void swap (Alm &other)
      {
      Alm_Base::swap(other);
      alm.swap(other.alm);
      }

    /*! Adds all coefficients from \a other to the own coefficients. */
    void Add (const Alm &other)
      {
      planck_assert (conformable(other), "A_lm are not conformable");
      for (tsize m=0; m void alm2map_cxx (paramfile ¶ms)
  {
  int nlmax = params.template find("nlmax");
  int nmmax = params.template find("nmmax",nlmax);
  planck_assert(nmmax<=nlmax,"nmmax must not be larger than nlmax");
  string infile = params.template find("infile");
  string outfile = params.template find("outfile");
  int nside = params.template find("nside");
  double fwhm = arcmin2rad*params.template find("fwhm_arcmin",0);
  int cw_lmin=-1, cw_lmax=-1;
  if (params.param_present("cw_lmin"))
    {
    cw_lmin = params.template find("cw_lmin");
    cw_lmax = params.template find("cw_lmax");
    }

  arr temp, pol;
  get_pixwin (params,nlmax,nside,temp,pol);

  bool deriv = params.template find("derivatives",false);
  if (deriv)
    {
    Alm > alm;
    read_Alm_from_fits(infile,alm,nlmax,nmmax,2);
    if (fwhm>0) smoothWithGauss (alm, fwhm);
    if (cw_lmin>=0) applyCosineWindow(alm, cw_lmin, cw_lmax);
    Healpix_Map map(nside,RING,SET_NSIDE),
                   mapdth(nside,RING,SET_NSIDE),
                   mapdph(nside,RING,SET_NSIDE);
    alm.ScaleL(temp);

    double offset = alm(0,0).real()/sqrt(fourpi);
    alm(0,0) = 0;
    alm2map_der1(alm,map,mapdth,mapdph);
    map.Add(T(offset));
    write_Healpix_map_to_fits (outfile,map,mapdth,mapdph,planckType());
    return;
    }

  bool polarisation = params.template find("polarisation");
  bool do_regnoise = params.param_present("regnoiseT");
  if (!polarisation)
    {
    Alm > alm;
    read_Alm_from_fits(infile,alm,nlmax,nmmax,2);
    if (fwhm>0) smoothWithGauss (alm, fwhm);
    if (cw_lmin>=0) applyCosineWindow(alm, cw_lmin, cw_lmax);
    Healpix_Map map(nside,RING,SET_NSIDE);
    alm.ScaleL(temp);

    double offset = alm(0,0).real()/sqrt(fourpi);
    alm(0,0) = 0;
    alm2map(alm,map);
    map.Add(T(offset));
    if (do_regnoise)
      {
      planck_rng rng(params.template find("rand_seed",42));
      double rms = params.template find("regnoiseT");
      for (int i=0; i());
    }
  else
    {
    Alm > almT, almG, almC;
    read_Alm_from_fits(infile,almT,almG,almC,nlmax,nmmax,2);
    if (fwhm>0) smoothWithGauss (almT, almG, almC, fwhm);
    if (cw_lmin>=0) applyCosineWindow(almT, almG, almC, cw_lmin, cw_lmax);
    Healpix_Map mapT(nside,RING,SET_NSIDE), mapQ(nside,RING,SET_NSIDE),
                   mapU(nside,RING,SET_NSIDE);
    almT.ScaleL(temp);
    almG.ScaleL(pol); almC.ScaleL(pol);

    double offset = almT(0,0).real()/sqrt(fourpi);
    almT(0,0) = 0;
    alm2map_pol(almT,almG,almC,mapT,mapQ,mapU);
    mapT.Add(T(offset));
    if (do_regnoise)
      {
      planck_rng rng(params.template find("rand_seed",42));
      double rmsT  = params.template find("regnoiseT"),
             rmsQU = params.template find("regnoiseQU");
      for (int i=0; i());
    }
  }

} // unnamed namespace

int alm2map_cxx_module (int argc, const char **argv)
  {
  module_startup ("alm2map_cxx", argc, argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  bool dp = params.find ("double_precision",false);
  dp ? alm2map_cxx(params) : alm2map_cxx(params);
  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_fitsio.cc0000664000175000017500000001604013010375061027230 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include "alm_fitsio.h"
#include "alm.h"
#include "fitshandle.h"
#include "xcomplex.h"
#include "safe_cast.h"
#include "share_utils.h"

using namespace std;

void get_almsize(fitshandle &inp, int &lmax, int &mmax)
  {
  if (inp.key_present("MAX-LPOL") && inp.key_present("MAX-MPOL"))
    {
    inp.get_key ("MAX-LPOL",lmax);
    inp.get_key ("MAX-MPOL",mmax);
    return;
    }

  int n_alms = safe_cast(inp.nelems(1));
  arr index;
  lmax=mmax=-1;
  chunkMaker cm(n_alms,inp.efficientChunkSize(1));
  uint64 offset,ppix;
  while(cm.getNext(offset,ppix))
    {
    index.alloc(ppix);
    inp.read_column(1,index,offset);

    for (tsize i=0; ilmax) lmax=l;
      if (m>mmax) mmax=m;
      }
    }
  }

void get_almsize(const string &filename, int &lmax, int &mmax, int hdunum)
  {
  fitshandle inp;
  inp.open (filename);
  inp.goto_hdu(hdunum);
  get_almsize (inp, lmax, mmax);
  }

void get_almsize_pol(const string &filename, int &lmax, int &mmax)
  {
  int tlmax, tmmax;
  fitshandle inp;
  inp.open (filename);
  lmax=mmax=0;
  for (int hdu=2; hdu<=4; ++hdu)
    {
    inp.goto_hdu(hdu);
    get_almsize (inp,tlmax,tmmax);
    if (tlmax>lmax) lmax=tlmax;
    if (tmmax>mmax) mmax=tmmax;
    }
  }

template void read_Alm_from_fits
  (fitshandle &inp, Alm >&alms, int lmax, int mmax)
  {
  int n_alms = safe_cast(inp.nelems(1));
  arr index;
  arr re, im;

  alms.Set(lmax, mmax);
  alms.SetToZero();
  int max_index = lmax*lmax + lmax + mmax + 1;
  chunkMaker cm(n_alms,inp.efficientChunkSize(1));
  uint64 offset,ppix;
  while(cm.getNext(offset,ppix))
    {
    index.alloc(ppix);
    re.alloc(ppix); im.alloc(ppix);
    inp.read_column(1,index,offset);
    inp.read_column(2,re,offset);
    inp.read_column(3,im,offset);

    for (tsize i=0; imax_index) continue;

      int l = isqrt(index[i]-1);
      int m = index[i] - l*l - l - 1;
      planck_assert(m>=0,"negative m encountered");
      planck_assert(l>=m, "wrong l,m combination");
      if ((l<=lmax) && (m<=mmax))
        alms(l,m) = xcomplex (re[i], im[i]);
      }
    }
  }

template void read_Alm_from_fits (fitshandle &inp,
  Alm > &alms, int lmax, int mmax);
template void read_Alm_from_fits (fitshandle &inp,
  Alm > &alms, int lmax, int mmax);


template void read_Alm_from_fits
  (const string &filename, Alm >&alms, int lmax, int mmax,
  int hdunum)
  {
  fitshandle inp;
  inp.open (filename);
  inp.goto_hdu(hdunum);
  read_Alm_from_fits(inp,alms,lmax,mmax);
  }

template void read_Alm_from_fits (const string &filename,
  Alm > &alms, int lmax, int mmax, int hdunum);
template void read_Alm_from_fits (const string &filename,
  Alm > &alms, int lmax, int mmax, int hdunum);


template void write_Alm_to_fits
  (fitshandle &out, const Alm > &alms, int lmax, int mmax,
  PDT datatype)
  {
  vector cols;
  cols.push_back (fitscolumn("index","l*l+l+m+1",1,PLANCK_INT32));
  cols.push_back (fitscolumn("real","unknown",1,datatype));
  cols.push_back (fitscolumn("imag","unknown",1,datatype));
  out.insert_bintab(cols);
  arr index;
  arr re, im;

  int lm=alms.Lmax(), mm=alms.Mmax();
  int n_alms = ((mmax+1)*(mmax+2))/2 + (mmax+1)*(lmax-mmax);

  int l=0, m=0;
  chunkMaker cm(n_alms,out.efficientChunkSize(1));
  uint64 offset,ppix;
  while(cm.getNext(offset,ppix))
    {
    index.alloc(ppix);
    re.alloc(ppix); im.alloc(ppix);
    for (tsize i=0; il) || (m>mmax)) { ++l; m=0; }
      }
    out.write_column(1,index,offset);
    out.write_column(2,re,offset);
    out.write_column(3,im,offset);
    }
  out.set_key("MAX-LPOL",lmax,"highest l in the table");
  out.set_key("MAX-MPOL",mmax,"highest m in the table");
  }

template void write_Alm_to_fits
  (fitshandle &out, const Alm > &alms, int lmax,
   int mmax, PDT datatype);
template void write_Alm_to_fits
  (fitshandle &out, const Alm > &alms, int lmax,
   int mmax, PDT datatype);


template void write_compressed_Alm_to_fits
  (fitshandle &out, const Alm > &alms, int lmax, int mmax,
  PDT datatype)
  {
  vector cols;
  cols.push_back (fitscolumn("index","l*l+l+m+1",1,PLANCK_INT32));
  cols.push_back (fitscolumn("real","unknown",1,datatype));
  cols.push_back (fitscolumn("imag","unknown",1,datatype));
  out.insert_bintab(cols);
  arr index;
  arr re, im;

  int n_alms = 0;
  for (int m=0; m<=mmax; ++m)
    for (int l=m; l<=lmax; ++l)
      if (norm(alms(l,m))>0) ++n_alms;

  int l=0, m=0;
  int real_lmax=0, real_mmax=0;
  chunkMaker cm(n_alms,out.efficientChunkSize(1));
  uint64 offset,ppix;
  while(cm.getNext(offset,ppix))
    {
    index.alloc(ppix);
    re.alloc(ppix); im.alloc(ppix);
    for (tsize i=0; il) || (m>mmax)) { ++l; m=0; }
        }
      index[i] = l*l + l + m + 1;
      re[i] = alms(l,m).real();
      im[i] = alms(l,m).imag();
      if (l>real_lmax) real_lmax=l;
      if (m>real_mmax) real_mmax=m;
      ++m;
      if ((m>l) || (m>mmax)) { ++l; m=0; }
      }
    out.write_column(1,index,offset);
    out.write_column(2,re,offset);
    out.write_column(3,im,offset);
    }
  out.set_key("MAX-LPOL",real_lmax,"highest l in the table");
  out.set_key("MAX-MPOL",real_mmax,"highest m in the table");
  }

template void write_compressed_Alm_to_fits
  (fitshandle &out, const Alm > &alms, int lmax,
   int mmax, PDT datatype);
template void write_compressed_Alm_to_fits
  (fitshandle &out, const Alm > &alms, int lmax,
   int mmax, PDT datatype);
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_fitsio.h0000664000175000017500000001140213010375061027067 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file alm_fitsio.h
 *  FITS I/O for spherical harmonic coefficients
 *
 *  Copyright (C) 2003-2010 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_ALM_FITSIO_H
#define PLANCK_ALM_FITSIO_H

#include 
#include "xcomplex.h"
#include "datatypes.h"
#include "fitshandle.h"

template class Alm;

/*! \defgroup alm_fitsio_group FITS-based I/O of a_lm */
/*! \{ */

/*! Returns the maximum \a l and \a m multipole moments found in the FITS HDU
    pointed to be \a inp in \a lmax and \a mmax. */
void get_almsize(fitshandle &inp, int &lmax, int &mmax);
/*! Returns the maximum \a l and \a m multipole moments found in the HDU
    \a hdunum of file \a filename in \a lmax and \a mmax. */
void get_almsize(const std::string &filename, int &lmax, int &mmax,
  int hdunum=2);
/*! Returns the maximum \a l and \a m multipole moments found in the HDUs
    2, 3 and 4 of file \a filename in \a lmax and \a mmax. */
void get_almsize_pol(const std::string &filename, int &lmax, int &mmax);

/*! Reads the a_lm of the FITS binary table pointed to by \a inp into
    \a alms. \a alms is reallocated with the parameters \a lmax and \a mmax.
    Values not present in the FITS table are set to zero; values outside
    the requested (l,m) range are ignored. */
template void read_Alm_from_fits
  (fitshandle &inp, Alm > &alms, int lmax, int mmax);
/*! Opens the FITS file \a filename, jumps to the HDU \a hdunum, then reads
    the a_lm from the FITS binary table there into \a alms. \a alms is
    reallocated with the parameters \a lmax and \a mmax.
    Values not present in the FITS table are set to zero; values outside
    the requested \a (l,m) range are ignored. */
template void read_Alm_from_fits
  (const std::string &filename, Alm > &alms,
   int lmax, int mmax, int hdunum=2);

template inline void read_Alm_from_fits
  (const std::string &filename, Alm > &almT,
   Alm > &almG, Alm > &almC,
   int lmax, int mmax, int firsthdu=2)
  {
  read_Alm_from_fits (filename, almT, lmax, mmax, firsthdu);
  read_Alm_from_fits (filename, almG, lmax, mmax, firsthdu+1);
  read_Alm_from_fits (filename, almC, lmax, mmax, firsthdu+2);
  }

/*! Inserts a new binary table into \a out, which contains three columns
    of type PLANCK_INT32, \a datatype and \a datatype, respectively.
    The data in \a alms is written into this table; values outside
    the requested (\a lmax, \a mmax) range are omitted. */
template void write_Alm_to_fits
  (fitshandle &out, const Alm > &alms,
   int lmax, int mmax, PDT datatype);

template inline void write_Alm_to_fits
  (const std::string &outfile, const Alm > &alms,
   int lmax, int mmax, PDT datatype)
  {
  fitshandle out;
  out.create(outfile);
  write_Alm_to_fits (out, alms, lmax, mmax, datatype);
  }

template inline void write_Alm_to_fits
  (const std::string &outfile, const Alm > &almT,
   const Alm > &almG, const Alm > &almC,
   int lmax, int mmax, PDT datatype)
  {
  fitshandle out;
  out.create(outfile);
  write_Alm_to_fits (out, almT, lmax, mmax, datatype);
  write_Alm_to_fits (out, almG, lmax, mmax, datatype);
  write_Alm_to_fits (out, almC, lmax, mmax, datatype);
  }

/*! Inserts a new binary table into \a out, which contains three columns
    of type PLANCK_INT32, \a datatype and \a datatype, respectively.
    The data in \a alms is written into this table; values outside
    the requested (\a lmax, \a mmax) range are omitted. Values with an absolute
    magnitude of zero are not written. */
template void write_compressed_Alm_to_fits
  (fitshandle &out, const Alm > &alms,
   int lmax, int mmax, PDT datatype);

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_healpix_tools.cc0000664000175000017500000003535713010375061030621 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "alm_healpix_tools.h"
#include "alm.h"
#include "healpix_map.h"
#include "xcomplex.h"
#include "sharp_cxx.h"

using namespace std;

namespace {

void checkLmaxNside(tsize lmax, tsize nside)
  {
  if (lmax>4*nside)
    cout << "\nWARNING: map analysis requested with lmax>4*nside...\n"
            "is this really what you want?\n\n";
  }

}

template void map2alm (const Healpix_Map &map,
  Alm > &alm, const arr &weight, bool add_alm)
  {
  planck_assert (map.Scheme()==RING, "map2alm: map must be in RING scheme");
  planck_assert (int(weight.size())>=2*map.Nside(),
    "map2alm: weight array has too few entries");
  planck_assert (map.fullyDefined(),"map contains undefined pixels");
  checkLmaxNside(alm.Lmax(), map.Nside());

  sharp_cxxjob job;
  job.set_weighted_Healpix_geometry (map.Nside(),&weight[0]);
  job.set_triangular_alm_info (alm.Lmax(), alm.Mmax());
  job.map2alm(&map[0], &alm(0,0), add_alm);
  }

template void map2alm (const Healpix_Map &map,
  Alm > &alm, const arr &weight,
  bool add_alm);
template void map2alm (const Healpix_Map &map,
  Alm > &alm, const arr &weight,
  bool add_alm);

template void map2alm_iter (const Healpix_Map &map,
  Alm > &alm, int num_iter, const arr &weight)
  {
  map2alm(map,alm,weight);
  for (int iter=1; iter<=num_iter; ++iter)
    {
    Healpix_Map map2(map.Nside(),map.Scheme(),SET_NSIDE);
    alm2map(alm,map2);
    for (int m=0; m &map,
  Alm > &alm, int num_iter,
  const arr &weight);
template void map2alm_iter (const Healpix_Map &map,
  Alm > &alm, int num_iter,
  const arr &weight);

template void map2alm_iter2 (const Healpix_Map &map,
  Alm > &alm, double err_abs, double err_rel)
  {
  double x_err_abs=1./err_abs, x_err_rel=1./err_rel;
  arr wgt(2*map.Nside());
  wgt.fill(1);
  Healpix_Map map2(map);
  alm.SetToZero();
  while(true)
    {
    map2alm(map2,alm,wgt,true);
    alm2map(alm,map2);
    double errmeasure=0;
    for (int m=0; m &map,
  Alm > &alm, double err_abs, double err_rel);


template void map2alm_spin
  (const Healpix_Map &map1, const Healpix_Map &map2,
   Alm > &alm1, Alm > &alm2,
   int spin, const arr &weight, bool add_alm)
  {
  planck_assert (map1.Scheme()==RING,
    "map2alm_spin: maps must be in RING scheme");
  planck_assert (map1.conformable(map2),
    "map2alm_spin: maps are not conformable");
  planck_assert (alm1.conformable(alm1),
    "map2alm_spin: a_lm are not conformable");
  planck_assert (int(weight.size())>=2*map1.Nside(),
    "map2alm_spin: weight array has too few entries");
  planck_assert (map1.fullyDefined()&&map2.fullyDefined(),
    "map contains undefined pixels");
  checkLmaxNside(alm1.Lmax(), map1.Nside());

  sharp_cxxjob job;
  job.set_weighted_Healpix_geometry (map1.Nside(),&weight[0]);
  job.set_triangular_alm_info (alm1.Lmax(), alm1.Mmax());
  job.map2alm_spin(&map1[0],&map2[0],&alm1(0,0),&alm2(0,0),spin,add_alm);
  }

template void map2alm_spin
  (const Healpix_Map &map1, const Healpix_Map &map2,
   Alm > &alm1, Alm > &alm2,
   int spin, const arr &weight, bool add_alm);
template void map2alm_spin
  (const Healpix_Map &map1, const Healpix_Map &map2,
   Alm > &alm1, Alm > &alm2,
   int spin, const arr &weight, bool add_alm);

template void map2alm_spin_iter2
  (const Healpix_Map &map1, const Healpix_Map &map2,
   Alm > &alm1, Alm > &alm2,
   int spin, double err_abs, double err_rel)
  {
  arr wgt(2*map1.Nside());
  wgt.fill(1);
  Healpix_Map map1b(map1), map2b(map2);
  alm1.SetToZero(); alm2.SetToZero();
  while(true)
    {
    map2alm_spin(map1b,map2b,alm1,alm2,spin,wgt,true);
    alm2map_spin(alm1,alm2,map1b,map2b,spin);
    double errmeasure=0;
    for (int m=0; m &map1, const Healpix_Map &map2,
   Alm > &alm1, Alm > &alm2,
   int spin, double err_abs, double err_rel);

template void map2alm_pol
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   const arr &weight,
   bool add_alm)
  {
  planck_assert (mapT.Scheme()==RING,
    "map2alm_pol: maps must be in RING scheme");
  planck_assert (mapT.conformable(mapQ) && mapT.conformable(mapU),
    "map2alm_pol: maps are not conformable");
  planck_assert (almT.conformable(almG) && almT.conformable(almC),
    "map2alm_pol: a_lm are not conformable");
  planck_assert (int(weight.size())>=2*mapT.Nside(),
    "map2alm_pol: weight array has too few entries");
  planck_assert (mapT.fullyDefined()&&mapQ.fullyDefined()&&mapU.fullyDefined(),
    "map contains undefined pixels");
  checkLmaxNside(almT.Lmax(), mapT.Nside());

  sharp_cxxjob job;
  job.set_weighted_Healpix_geometry (mapT.Nside(),&weight[0]);
  job.set_triangular_alm_info (almT.Lmax(), almT.Mmax());
  job.map2alm(&mapT[0], &almT(0,0), add_alm);
  job.map2alm_spin(&mapQ[0],&mapU[0],&almG(0,0),&almC(0,0),2,add_alm);
  }

template void map2alm_pol
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   const arr &weight,
   bool add_alm);
template void map2alm_pol
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   const arr &weight,
   bool add_alm);


template void map2alm_pol_iter
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   int num_iter,
   const arr &weight)
  {
  map2alm_pol(mapT,mapQ,mapU,almT,almG,almC,weight);
  for (int iter=1; iter<=num_iter; ++iter)
    {
    Healpix_Map mapT2(mapT.Nside(),mapT.Scheme(),SET_NSIDE),
                   mapQ2(mapT.Nside(),mapT.Scheme(),SET_NSIDE),
                   mapU2(mapT.Nside(),mapT.Scheme(),SET_NSIDE);

    alm2map_pol(almT,almG,almC,mapT2,mapQ2,mapU2);
    for (int m=0; m &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   int num_iter,
   const arr &weight);
template void map2alm_pol_iter
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   int num_iter,
   const arr &weight);

template void map2alm_pol_iter2
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   double err_abs, double err_rel)
  {
  arr wgt(2*mapT.Nside());
  wgt.fill(1);
  Healpix_Map mapT2(mapT), mapQ2(mapQ), mapU2(mapU);
  almT.SetToZero(); almG.SetToZero(); almC.SetToZero();
  while(true)
    {
    map2alm_pol(mapT2,mapQ2,mapU2,almT,almG,almC,wgt,true);
    alm2map_pol(almT,almG,almC,mapT2,mapQ2,mapU2);
    double errmeasure=0;
    for (int m=0; m &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   double err_abs, double err_rel);


template void alm2map (const Alm > &alm,
  Healpix_Map &map)
  {
  planck_assert (map.Scheme()==RING, "alm2map: map must be in RING scheme");

  sharp_cxxjob job;
  job.set_Healpix_geometry (map.Nside());
  job.set_triangular_alm_info (alm.Lmax(), alm.Mmax());
  job.alm2map(&alm(0,0), &map[0], false);
  }

template void alm2map (const Alm > &alm,
  Healpix_Map &map);
template void alm2map (const Alm > &alm,
  Healpix_Map &map);

template void alm2map_spin
  (const Alm > &alm1, const Alm > &alm2,
   Healpix_Map &map1, Healpix_Map &map2, int spin)
  {
  planck_assert (map1.Scheme()==RING,
    "alm2map_spin: maps must be in RING scheme");
  planck_assert (map1.conformable(map2),
    "alm2map_spin: maps are not conformable");
  planck_assert (alm1.conformable(alm2),
    "alm2map_spin: a_lm are not conformable");

  sharp_cxxjob job;
  job.set_Healpix_geometry (map1.Nside());
  job.set_triangular_alm_info (alm1.Lmax(), alm1.Mmax());
  job.alm2map_spin(&alm1(0,0),&alm2(0,0),&map1[0],&map2[0],spin,false);
  }

template void alm2map_spin
  (const Alm > &alm1, const Alm > &alm2,
   Healpix_Map &map, Healpix_Map &map2, int spin);
template void alm2map_spin
  (const Alm > &alm1, const Alm > &alm2,
   Healpix_Map &map, Healpix_Map &map2, int spin);


template void alm2map_pol
  (const Alm > &almT,
   const Alm > &almG,
   const Alm > &almC,
   Healpix_Map &mapT,
   Healpix_Map &mapQ,
   Healpix_Map &mapU)
  {
  planck_assert (mapT.Scheme()==RING,
    "alm2map_pol: maps must be in RING scheme");
  planck_assert (mapT.conformable(mapQ) && mapT.conformable(mapU),
    "alm2map_pol: maps are not conformable");
  planck_assert (almT.conformable(almG) && almT.conformable(almC),
    "alm2map_pol: a_lm are not conformable");

  sharp_cxxjob job;
  job.set_Healpix_geometry (mapT.Nside());
  job.set_triangular_alm_info (almT.Lmax(), almT.Mmax());
  job.alm2map(&almT(0,0), &mapT[0], false);
  job.alm2map_spin(&almG(0,0), &almC(0,0), &mapQ[0], &mapU[0], 2, false);
  }

template void alm2map_pol (const Alm > &almT,
                           const Alm > &almG,
                           const Alm > &almC,
                           Healpix_Map &mapT,
                           Healpix_Map &mapQ,
                           Healpix_Map &mapU);

template void alm2map_pol (const Alm > &almT,
                           const Alm > &almG,
                           const Alm > &almC,
                           Healpix_Map &mapT,
                           Healpix_Map &mapQ,
                           Healpix_Map &mapU);


template void alm2map_der1
  (const Alm > &alm,
   Healpix_Map &map,
   Healpix_Map &mapdth,
   Healpix_Map &mapdph)
  {
  planck_assert (map.Scheme()==RING,
    "alm2map_der1: maps must be in RING scheme");
  planck_assert (map.conformable(mapdth) && map.conformable(mapdph),
    "alm2map_der1: maps are not conformable");

  sharp_cxxjob job;
  job.set_Healpix_geometry (map.Nside());
  job.set_triangular_alm_info (alm.Lmax(), alm.Mmax());
  job.alm2map(&alm(0,0), &map[0], false);
  job.alm2map_der1(&alm(0,0), &mapdth[0], &mapdph[0], false);
  }

template void alm2map_der1 (const Alm > &alm,
                            Healpix_Map &map,
                            Healpix_Map &map_dth,
                            Healpix_Map &map_dph);

template void alm2map_der1 (const Alm > &alm,
                            Healpix_Map &map,
                            Healpix_Map &map_dth,
                            Healpix_Map &map_dph);
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_healpix_tools.h0000664000175000017500000001720113010375061030447 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file alm_healpix_tools.h
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef HEALPIX_ALM_HEALPIX_TOOLS_H
#define HEALPIX_ALM_HEALPIX_TOOLS_H

#include "xcomplex.h"
#include "arr.h"

template class Alm;
template class Healpix_Map;

/*! \defgroup alm_healpix_group Conversions between a_lm and HEALPix maps */
/*! \{ */

/*! Converts a Healpix map to a set of a_lms.
    \param map the input map, which must have RING ordering
    \param alm the output a_lms. l_max and m_max of the conversion are
           determined from this object.
    \param weight array containing the weights for the individual rings of
           the map. It must have at least 2*\a map.Nside() entries.
    \param add_alm If this is \a true, then the computed a_lm are added
           to the values already residing in \a alm. */
template void map2alm (const Healpix_Map &map,
  Alm > &alm, const arr &weight,
    bool add_alm=false);

/*! Converts a Healpix map to a set of a_lms, using an iterative scheme
    which is more accurate than plain map2alm().
    \param map the input map, which must have RING ordering.
    \param alm the output a_lms. l_max and m_max of the conversion are
           determined from this object.
    \param num_iter the number of iterations (0 is identical to map2alm()).
    \param weight array containing the weights for the individual rings of
           the map. It must have at least 2*\a map.Nside() entries. */
template void map2alm_iter (const Healpix_Map &map,
  Alm > &alm, int num_iter, const arr &weight);

template inline void map2alm_iter (const Healpix_Map &map,
  Alm > &alm, int num_iter)
  {
  arr wgt(2*map.Nside(),1.);
  map2alm_iter(map,alm,num_iter,wgt);
  }

template void map2alm_iter2 (const Healpix_Map &map,
  Alm > &alm, double err_abs, double err_rel);

template void map2alm_spin
  (const Healpix_Map &map1, const Healpix_Map &map2,
   Alm > &alm1, Alm > &alm2,
   int spin, const arr &weight, bool add_alm);

template void map2alm_spin_iter2
  (const Healpix_Map &map1, const Healpix_Map &map2,
   Alm > &alm1, Alm > &alm2,
   int spin, double err_abs, double err_rel);

/*! Converts Healpix maps containing the I, Q and U Stokes parameters
    to sets of a_lms.
    \param mapT the I-Stokes parameter input map
    \param mapQ the Q-Stokes parameter input map
    \param mapU the U-Stokes parameter input map
    \note All maps must have the same nside, and must be in RING scheme.
    \param almT the output temperature a_lms
    \param almG the output gradient a_lms
    \param almC the output curl a_lms
    \note all a_lm sets must have the the same lmax and mmax.
    \param weight ring weights for the maps.
    \param add_alm If this is \a true, then the computed a_lm are added
           to the values already residing in \a alm.
    \note The weight array must have at least 2*\a mapT.Nside() entries. */
template void map2alm_pol
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   const arr &weight,
   bool add_alm=false);
/*! Converts Healpix maps containing the I, Q and U Stokes parameters
    to sets of a_lms, using an iterative scheme which is more accurate than
    plain map2alm_pol().
    \param mapT the I-Stokes parameter input map
    \param mapQ the Q-Stokes parameter input map
    \param mapU the U-Stokes parameter input map
    \note All maps must have the same nside, and must be in RING scheme.
    \param almT the output temperature a_lms
    \param almG the output gradient a_lms
    \param almC the output curl a_lms
    \note all a_lm sets must have the the same lmax and mmax.
    \param num_iter the number of iterations (0 is identical to map2alm_pol()).
    \param weight ring weights for the maps.
    \note The weight array must have at least 2*\a mapT.Nside() entries. */
template void map2alm_pol_iter
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   int num_iter,
   const arr &weight);

template inline void map2alm_pol_iter
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   int num_iter)
  {
  arr wgt(2*mapT.Nside(),1.);
  map2alm_pol_iter(mapT,mapQ,mapU,almT,almG,almC,num_iter,wgt);
  }

template void map2alm_pol_iter2
  (const Healpix_Map &mapT,
   const Healpix_Map &mapQ,
   const Healpix_Map &mapU,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   double err_abs, double err_rel);

/*! Converts a a set of a_lm to a HEALPix map.
    \param alm the input a_lms. l_max and m_max of the conversion are
           determined from this object.
    \param map the output map, which must have RING ordering. */
template void alm2map (const Alm > &alm,
  Healpix_Map &map);

template void alm2map_spin
  (const Alm > &alm1, const Alm > &alm2,
   Healpix_Map &map1, Healpix_Map &map2, int spin);

/*! Converts a a set of polarised a_lm to a HEALPix map.
    \param almT the input temperature a_lms
    \param almG the input gradient a_lms
    \param almC the input curl a_lms
    \param mapT the I-Stokes parameter output map
    \param mapQ the Q-Stokes parameter output map
    \param mapU the U-Stokes parameter output map */
template void alm2map_pol
  (const Alm > &almT,
   const Alm > &almG,
   const Alm > &almC,
   Healpix_Map &mapT,
   Healpix_Map &mapQ,
   Healpix_Map &mapU);

/*! Converts a a set of a_lm to a HEALPix map and its first derivatives.
    \param alm the input a_lms. l_max and m_max of the conversion are
           determined from this object.
    \param map the output map, which must have RING ordering.
    \param mapdth an output map containing \f$d (\mbox{map})/d\vartheta\f$,
           which must have RING ordering.
    \param mapdph an output map containing
           \f$(\sin\vartheta)^{-1}d(\mbox{map})/d\varphi\f$,
           which must have RING ordering. */
template void alm2map_der1
  (const Alm > &alm,
   Healpix_Map &map,
   Healpix_Map &mapdth,
   Healpix_Map &mapdph);

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_powspec_tools.cc0000664000175000017500000003537713010375061030651 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "alm_powspec_tools.h"
#include "string_utils.h"
#include "alm.h"
#include "planck_rng.h"
#include "powspec.h"
#include "xcomplex.h"
#include "rotmatrix.h"
#include "openmp_support.h"
#include "wigner.h"
#include "lsconstants.h"

using namespace std;
template void create_alm
  (const PowSpec &powspec, Alm > &alm, planck_rng &rng)
  {
  int lmax = alm.Lmax();
  int mmax = alm.Mmax();
  const double hsqrt2 = 1/sqrt(2.);

  for (int l=0; l<=lmax; ++l)
    {
    double rms_tt = sqrt(powspec.tt(l));
    double zeta1_r = rng.rand_gauss();
    alm(l,0) = T(zeta1_r * rms_tt);
    for (int m=1; m<=min(l,mmax); ++m)
      {
      zeta1_r = rng.rand_gauss()*hsqrt2;
      double zeta1_i = rng.rand_gauss()*hsqrt2;
      alm(l,m) = xcomplex(T(zeta1_r*rms_tt), T(zeta1_i*rms_tt));
      }
    }
  }

template void create_alm (const PowSpec &powspec,
  Alm > &alm, planck_rng &rng);
template void create_alm (const PowSpec &powspec,
  Alm > &alm, planck_rng &rng);


template void create_alm_pol
  (const PowSpec &ps,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   planck_rng &rng)
  {
  int lmax = almT.Lmax();
  int mmax = almT.Mmax();
  const double hsqrt2 = 1/sqrt(2.);

  bool full = ps.Num_specs()==6;

  for (int l=0; l<=lmax; ++l)
    {
    double rms_tt=0, rms_g1=0, rms_c1=0;
    if (ps.tt(l) > 0)
      {
      rms_tt = sqrt(ps.tt(l));
      rms_g1 = ps.tg(l)/rms_tt;
      if (full) rms_c1 = ps.tc(l)/rms_tt;
      }

    double zeta1_r = rng.rand_gauss();
    almT(l,0) = T(zeta1_r * rms_tt);
    almG(l,0) = T(zeta1_r * rms_g1);
    almC(l,0) = T(zeta1_r * rms_c1);
    for (int m=1; m<=min(l,mmax); ++m)
      {
      zeta1_r = rng.rand_gauss()*hsqrt2;
      double zeta1_i = rng.rand_gauss()*hsqrt2;
      almT(l,m) = xcomplex(T(zeta1_r*rms_tt), T(zeta1_i*rms_tt));
      almG(l,m) = xcomplex(T(zeta1_r*rms_g1), T(zeta1_i*rms_g1));
      almC(l,m) = xcomplex(T(zeta1_r*rms_c1), T(zeta1_i*rms_c1));
      }
    }

  for (int l=0; l<=lmax; ++l)
    {
    double rms_g2=0, rms_c2=0, rms_c3=0;
    if (ps.tt(l) > 0)
      {
      rms_g2 = ps.gg(l) - (ps.tg(l)/ps.tt(l))*ps.tg(l);
      if (rms_g2<=0)
        {
        planck_assert (abs(rms_g2) <= 1e-8*abs(ps.gg(l)),
          "Inconsistent TT, GG and TG spectra at l="+dataToString(l));
        rms_g2 = 0;
        }
      double rms_c1 = full ? (ps.tc(l) / sqrt(ps.tt(l))) : 0.;
      if (rms_g2>0)
        {
        rms_g2 = sqrt(rms_g2);
        if (full) rms_c2 = (ps.gc(l) - ps.tc(l) * (ps.tg(l)/ps.tt(l))) / rms_g2;
        }
      rms_c3 = ps.cc(l) - rms_c1*rms_c1 - rms_c2*rms_c2; 
      if (rms_c3<=0)
        {
        planck_assert (abs(rms_c3) <= 1e-8*abs(ps.cc(l)),
          "Inconsistent spectra at l="+dataToString(l));
        rms_c3 = 0;
        }
      rms_c3 = sqrt(rms_c3);
      }
    double zeta2_r = rng.rand_gauss();
    double zeta3_r = rng.rand_gauss();
    almG(l,0) += T(zeta2_r*rms_g2);
    almC(l,0) += T(zeta3_r*rms_c3 + zeta2_r*rms_c2);

    for (int m=1; m<=min(l,mmax); ++m)
      {
      zeta2_r = rng.rand_gauss()*hsqrt2;
      double zeta2_i = rng.rand_gauss()*hsqrt2;
      zeta3_r = rng.rand_gauss()*hsqrt2;
      double zeta3_i = rng.rand_gauss()*hsqrt2;

      almG(l,m) += xcomplex (T(zeta2_r*rms_g2),T(zeta2_i*rms_g2));
      almC(l,m) += xcomplex (T(zeta3_r*rms_c3),T(zeta3_i*rms_c3))
                  +xcomplex (T(zeta2_r*rms_c2),T(zeta2_i*rms_c2));
      }
    }
  }

template void create_alm_pol
  (const PowSpec &powspec,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   planck_rng &rng);
template void create_alm_pol
  (const PowSpec &powspec,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   planck_rng &rng);


template void extract_crosspowspec
  (const Alm > &alm1,
   const Alm > &alm2,PowSpec &powspec)
  {
  planck_assert (alm1.conformable(alm2), "a_lm are not conformable");
  arr tt(alm1.Lmax()+1);
  for (int l=0; l<=alm1.Lmax(); ++l)
    {
    tt[l] = alm1(l,0).real()*alm2(l,0).real();
    int limit = min(l,alm1.Mmax());
    for (int m=1; m<=limit; ++m)
      tt[l] += 2 * (alm1(l,m).real()*alm2(l,m).real()
                  + alm1(l,m).imag()*alm2(l,m).imag());
    tt[l] /= (2*l+1);
    }
  powspec.Set(tt);
  }

template void extract_crosspowspec
  (const Alm > &alm1,
   const Alm > &alm2, PowSpec &powspec);
template void extract_crosspowspec
  (const Alm > &alm1,
   const Alm > &alm2, PowSpec &powspec);


template void extract_powspec
  (const Alm > &alm, PowSpec &powspec)
  { extract_crosspowspec (alm,alm,powspec); }

template void extract_powspec
  (const Alm > &alm, PowSpec &powspec);
template void extract_powspec
  (const Alm > &alm, PowSpec &powspec);

namespace {

template void extract_crosspowspec
  (const Alm > &almT1,
   const Alm > &almG1,
   const Alm > &almC1,
   const Alm > &almT2,
   const Alm > &almG2,
   const Alm > &almC2,
   PowSpec &powspec)
  {
  planck_assert (almT1.conformable(almG1) && almT1.conformable(almC1) &&
                 almT1.conformable(almT2) && almT1.conformable(almG2) &&
                 almT1.conformable(almC2), "a_lm are not conformable");

  int lmax = almT1.Lmax();
  arr tt(lmax+1), gg(lmax+1), cc(lmax+1), tg(lmax+1),
              tc(lmax+1), gc(lmax+1);
  for (int l=0; l<=lmax; ++l)
    {
    tt[l] = almT1(l,0).real()*almT2(l,0).real();
    gg[l] = almG1(l,0).real()*almG2(l,0).real();
    cc[l] = almC1(l,0).real()*almC2(l,0).real();
    tg[l] = almT1(l,0).real()*almG2(l,0).real();
    tc[l] = almT1(l,0).real()*almC2(l,0).real();
    gc[l] = almG1(l,0).real()*almC2(l,0).real();
    int limit = min(l,almT1.Mmax());
    for (int m=1; m<=limit; ++m)
      {
      tt[l] += 2 * (almT1(l,m).real()*almT2(l,m).real()
                  + almT1(l,m).imag()*almT2(l,m).imag());
      gg[l] += 2 * (almG1(l,m).real()*almG2(l,m).real()
                  + almG1(l,m).imag()*almG2(l,m).imag());
      cc[l] += 2 * (almC1(l,m).real()*almC2(l,m).real()
                  + almC1(l,m).imag()*almC2(l,m).imag());
      tg[l] += 2 * (almT1(l,m).real()*almG2(l,m).real()
                  + almT1(l,m).imag()*almG2(l,m).imag());
      tc[l] += 2 * (almT1(l,m).real()*almC2(l,m).real()
                  + almT1(l,m).imag()*almC2(l,m).imag());
      gc[l] += 2 * (almG1(l,m).real()*almC2(l,m).real()
                  + almG1(l,m).imag()*almC2(l,m).imag());
      }
    tt[l] /= (2*l+1);
    gg[l] /= (2*l+1);
    cc[l] /= (2*l+1);
    tg[l] /= (2*l+1);
    tc[l] /= (2*l+1);
    gc[l] /= (2*l+1);
    }
  powspec.Set(tt,gg,cc,tg,tc,gc);
  }

} // unnamed namespace

template void extract_powspec
  (const Alm > &almT,
   const Alm > &almG,
   const Alm > &almC,
   PowSpec &powspec)
  { extract_crosspowspec(almT,almG,almC,almT,almG,almC,powspec); }

template void extract_powspec
  (const Alm > &almT,
   const Alm > &almG,
   const Alm > &almC,
   PowSpec &powspec);
template void extract_powspec
  (const Alm > &almT,
   const Alm > &almG,
   const Alm > &almC,
   PowSpec &powspec);


template void smoothWithGauss
  (Alm > &alm, double fwhm)
  {
  int fct = (fwhm>=0) ? 1 : -1;
  double sigma = fwhm*fwhm2sigma;
  arr gb(alm.Lmax()+1);
  for (int l=0; l<=alm.Lmax(); ++l)
    gb[l] = exp(-.5*fct*l*(l+1)*sigma*sigma);
  alm.ScaleL(gb);
  }

template void smoothWithGauss
  (Alm > &alm, double fwhm);
template void smoothWithGauss
  (Alm > &alm, double fwhm);


template void smoothWithGauss
  (Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   double fwhm)
  {
  int fct = (fwhm>=0) ? 1 : -1;
  double sigma = fwhm*fwhm2sigma;
  double fact_pol = exp(2*fct*sigma*sigma);
  arr gb(almT.Lmax()+1);
  for (int l=0; l<=almT.Lmax(); ++l)
    gb[l] = exp(-.5*fct*l*(l+1)*sigma*sigma);
  almT.ScaleL(gb);
  for (int l=0; l<=almT.Lmax(); ++l)
    gb[l] *= fact_pol;
  almG.ScaleL(gb); almC.ScaleL(gb);
  }

template void applyCosineWindow
  (Alm > &alm, int lmin, int lmax)
  {
  planck_assert((lmin>=0)&&(lmax>lmin),"bad lmin/lmax");
  arr cw(alm.Lmax()+1);
  for (int i=0; i > &alm, int lmin, int lmax);
template void applyCosineWindow
  (Alm > &alm, int lmin, int lmax);

template void smoothWithGauss
  (Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   double fwhm);
template void smoothWithGauss
  (Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   double fwhm);

template void rotate_alm (Alm > &alm,
  double psi, double theta, double phi)
  {
  planck_assert (alm.Lmax()==alm.Mmax(),
    "rotate_alm: lmax must be equal to mmax");
  int lmax=alm.Lmax();
  arr > exppsi(lmax+1), expphi(lmax+1);
  for (int m=0; m<=lmax; ++m)
    {
    exppsi[m] = dcomplex(cos(psi*m),-sin(psi*m));
    expphi[m] = dcomplex(cos(phi*m),-sin(phi*m));
    }

  wigner_d_risbo_openmp rec(lmax,theta);

  arr > almtmp(lmax+1);

  for (int l=0; l<=lmax; ++l)
    {
    const arr2 &d(rec.recurse());

    for (int m=0; m<=l; ++m)
      almtmp[m] = xcomplex(alm(l,0))*d[l][l+m];

#pragma omp parallel
{
    int64 lo,hi;
    openmp_calc_share(0,l+1,lo,hi);

    bool flip = true;
    for (int mm=1; mm<=l; ++mm)
      {
      dcomplex t1 = dcomplex(alm(l,mm))*exppsi[mm];
      bool flip2 = ((mm+lo)&1) ? true : false;
      for (int m=lo; m(almtmp[m]*expphi[m]);
    }
  }

template void rotate_alm (Alm > &alm,
  double psi, double theta, double phi);
template void rotate_alm (Alm > &alm,
  double psi, double theta, double phi);

template void rotate_alm (Alm > &almT,
  Alm > &almG, Alm > &almC,
  double psi, double theta, double phi)
  {
  planck_assert (almT.Lmax()==almT.Mmax(),
    "rotate_alm: lmax must be equal to mmax");
  planck_assert (almG.conformable(almT) && almC.conformable(almT),
    "rotate_alm: a_lm are not conformable");
  int lmax=almT.Lmax();
  arr > exppsi(lmax+1), expphi(lmax+1);
  for (int m=0; m<=lmax; ++m)
    {
    exppsi[m] = dcomplex(cos(psi*m),-sin(psi*m));
    expphi[m] = dcomplex(cos(phi*m),-sin(phi*m));
    }

  wigner_d_risbo_openmp rec(lmax,theta);

  arr > almtmpT(lmax+1), almtmpG(lmax+1), almtmpC(lmax+1);

  for (int l=0; l<=lmax; ++l)
    {
    const arr2 &d(rec.recurse());

    for (int m=0; m<=l; ++m)
      {
      almtmpT[m] = xcomplex(almT(l,0))*d[l][m+l];
      almtmpG[m] = xcomplex(almG(l,0))*d[l][m+l];
      almtmpC[m] = xcomplex(almC(l,0))*d[l][m+l];
      }

#pragma omp parallel
{
    int64 lo,hi;
    openmp_calc_share(0,l+1,lo,hi);

    bool flip = true;
    for (int mm=1; mm<=l; ++mm)
      {
      dcomplex t1T = dcomplex(almT(l,mm))*exppsi[mm];
      dcomplex t1G = dcomplex(almG(l,mm))*exppsi[mm];
      dcomplex t1C = dcomplex(almC(l,mm))*exppsi[mm];
      bool flip2 = ((mm+lo)&1) ? true : false;
      for (int m=lo; m(almtmpT[m]*expphi[m]);
      almG(l,m) = xcomplex(almtmpG[m]*expphi[m]);
      almC(l,m) = xcomplex(almtmpC[m]*expphi[m]);
      }
    }
  }

template void rotate_alm (Alm > &almT,
  Alm > &almG, Alm > &almC,
  double psi, double theta, double phi);
template void rotate_alm (Alm > &almT,
  Alm > &almG, Alm > &almC,
  double psi, double theta, double phi);


template void rotate_alm (Alm > &alm,
  const rotmatrix &mat)
  {
  double a1, a2, a3;
  mat.Extract_CPAC_Euler_Angles (a1, a2, a3);
  rotate_alm (alm, a3, a2, a1);
  }

template void rotate_alm (Alm > &alm, const rotmatrix &mat);
template void rotate_alm (Alm > &alm, const rotmatrix &mat);

template void rotate_alm (Alm > &almT,
  Alm > &almG, Alm > &almC,
  const rotmatrix &mat)
  {
  double a1, a2, a3;
  mat.Extract_CPAC_Euler_Angles (a1, a2, a3);
  rotate_alm (almT, almG, almC, a3, a2, a1);
  }

template void rotate_alm (Alm > &almT,
  Alm > &almG, Alm > &almC,
  const rotmatrix &mat);
template void rotate_alm (Alm > &almT,
  Alm > &almG, Alm > &almC,
  const rotmatrix &mat);
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_powspec_tools.h0000664000175000017500000001216513010375061030501 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file alm_powspec_tools.h
 *  Copyright (C) 2003-2014 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_ALM_POWSPEC_TOOLS_H
#define PLANCK_ALM_POWSPEC_TOOLS_H

#include "xcomplex.h"

template class Alm;
class PowSpec;
class planck_rng;
class rotmatrix;

/*! \defgroup alm_ps_group Conversions between a_lm and power spectra */
/*! \{ */

/*! Creates a Gaussian realisation of the input power spectrum \a powspec,
    using the random number generator \a rng, and returns the result
    in \a alm. */
template void create_alm (const PowSpec &powspec,
  Alm > &alm, planck_rng &rng);

/*! Creates a Gaussian realisation of the polarised input power spectrum
    \a powspec, using the random number generator \a rng, and returns the
    result in \a almT, \a almG and \a almC. */
template void create_alm_pol
  (const PowSpec &powspec,
   Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   planck_rng &rng);

/*! Returns the unpolarised power spectrum of \a alm in \a powspec. */
template void extract_powspec
  (const Alm > &alm, PowSpec &powspec);
/*! Returns the cross power spectrum of \a alm1 and \a alm2 in \a powspec. */
template void extract_crosspowspec
  (const Alm > &alm1,
   const Alm > &alm2, PowSpec &powspec);
/*! Returns the polarised power spectrum of \a almT, \a almG and \a almC
    in \a powspec. */
template void extract_powspec
  (const Alm > &almT,
   const Alm > &almG,
   const Alm > &almC,
   PowSpec &powspec);

/*! \} */

/*! Applies a convolution with a Gaussian beam with an FWHM of
    \a fwhm (in radian) to \a alm.
    \note If \a fwhm<0, a deconvolution with \a -fwhm is performed.
    \relates Alm */
template void smoothWithGauss
  (Alm > &alm, double fwhm);
/*! Applies a convolution with a Gaussian beam with an FWHM of
    \a fwhm (in radian) to \a almT, \a almG and \a almC.
    \note If \a fwhm<0, a deconvolution with \a -fwhm is performed.
    \relates Alm */
template void smoothWithGauss
  (Alm > &almT,
   Alm > &almG,
   Alm > &almC,
   double fwhm);

/*! Applies a function to \a alm that is 1 for all \c l<=lmin, 0 for all
    \c l>=lmax, and \c 0.5*(1+cos((l-lmin)/(lmax-lmin)*pi)) in between.
    \relates Alm  */
template void applyCosineWindow
  (Alm > &alm, int lmin, int lmax);

template inline void applyCosineWindow
  (Alm > &almT, Alm > &almG, Alm > &almC,
  int lmin, int lmax)
  {
  applyCosineWindow(almT,lmin,lmax);
  applyCosineWindow(almG,lmin,lmax);
  applyCosineWindow(almC,lmin,lmax);
  }

/*! Rotates \a alm through the Euler angles \a psi, \a theta and \a phi.
    The Euler angle convention  is right handed, rotations are active.
    - \a psi is the first rotation about the z-axis (vertical)
    - then \a theta about the ORIGINAL (unrotated) y-axis
    - then \a phi  about the ORIGINAL (unrotated) z-axis (vertical)
    \relates Alm */
template void rotate_alm (Alm > &alm,
  double psi, double theta, double phi);

/*! Rotates \a almT, \a almG and \a almC through the Euler angles
    \a psi, \a theta and \a phi.
    The Euler angle convention  is right handed, rotations are active.
    - \a psi is the first rotation about the z-axis (vertical)
    - then \a theta about the ORIGINAL (unrotated) y-axis
    - then \a phi  about the ORIGINAL (unrotated) z-axis (vertical)
    \relates Alm */
template void rotate_alm (Alm > &almT,
  Alm > &almG, Alm > &almC,
  double psi, double theta, double phi);

/*! Rotates \a alm through the rotation matrix \a mat.
    \relates Alm */
template void rotate_alm (Alm > &alm,
  const rotmatrix &mat);

/*! Rotates \a almT, \a almG and \a almC through the rotation matrix \a mat.
    \relates Alm */
template void rotate_alm (Alm > &almT,
  Alm > &almG, Alm > &almC,
  const rotmatrix &mat);

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/anafast_cxx.cc0000664000175000017500000000027613010375061027405 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  anafast_cxx_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/anafast_cxx.par.txt0000664000175000017500000000244213010375061030415 0ustar  zoncazonca00000000000000Parameters read by anafast_cxx:

nlmax (integer):
  maximum order of l

nmmax (integer):
  maximum order of m (must not be larger than nlmax, default=nlmax)

infile (string):
  input file containing the Healpix map

outfile (string, default=""):
  output file name for power spectrum; if empty, no spectrum is written

outfile_alms (string, default=""):
  output file name for the a_lm; if empty, no a_lm are written

polarisation (bool):
  if false, only the intensity a_lm are generated,
  if true, a_lm for T, G and C component are generated

weighted (bool, default=false):
  if true, weighted quadrature is used

if (weighted)
  healpix_data (string):
    directory containing the Healpix data files
endif

iter_order (integer, default=0)
  number of iterations for the analysis (0: standard analysis)

double_precision (bool, default=false):
  if false, maps and a_lm are read/written in single precision,
  otherwise in double precision.

if (polarisation==true && outfile!="")
  full_powerspectrum (bool, default=false):
    if true, write a 6-column power spectrum;
    if false, write a 4-column power spectrum.
endif

remove_monopole (bool, default=false):
  if true, subtract the average pixel value from the temperature map, and add
  the corresponding value to almT(0,0) after the map2alm transform.
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/anafast_cxx_module.cc0000664000175000017500000001104713010375061030750 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "xcomplex.h"
#include "paramfile.h"
#include "healpix_data_io.h"
#include "alm.h"
#include "alm_fitsio.h"
#include "healpix_map.h"
#include "healpix_map_fitsio.h"
#include "powspec.h"
#include "powspec_fitsio.h"
#include "alm_healpix_tools.h"
#include "alm_powspec_tools.h"
#include "fitshandle.h"
#include "levels_facilities.h"
#include "lsconstants.h"
#include "announce.h"

using namespace std;

namespace {

template void anafast_cxx (paramfile ¶ms)
  {
  int nlmax = params.template find("nlmax");
  int nmmax = params.template find("nmmax",nlmax);
  string infile = params.template find("infile");
  string outfile = params.template find("outfile","");
  string outfile_alms = params.template find("outfile_alms","");
  planck_assert ((outfile!="") || (outfile_alms!=""),
    "no output specified, nothing done");
  bool polarisation = params.template find("polarisation");
  int num_iter = params.template find("iter_order",0);
  bool remove_mono = params.template find("remove_monopole",false);

  if (!polarisation)
    {
    Healpix_Map map;
    read_Healpix_map_from_fits(infile,map,1,2);

    tsize nmod = map.replaceUndefWith0();
    if (nmod!=0)
      cout << "WARNING: replaced " << nmod <<
              " undefined map pixels with a value of 0" << endl;

    double avg=0.;
    if (remove_mono)
      {
      avg=map.average();
      map.Add(T(-avg));
      }

    arr weight;
    get_ring_weights (params,map.Nside(),weight);

    Alm > alm(nlmax,nmmax);
    if (map.Scheme()==NEST) map.swap_scheme();
    map2alm_iter(map,alm,num_iter,weight);

    alm(0,0) += T(avg*sqrt(fourpi));

    if (outfile!="")
      {
      PowSpec powspec;
      extract_powspec (alm,powspec);
      write_powspec_to_fits (outfile,powspec,1);
      }
    if (outfile_alms!="")
      write_Alm_to_fits(outfile_alms,alm,nlmax,nmmax,planckType());
    }
  else
    {
    Healpix_Map mapT, mapQ, mapU;
    read_Healpix_map_from_fits(infile,mapT,mapQ,mapU,2);

    tsize nmod = mapT.replaceUndefWith0()+mapQ.replaceUndefWith0()
                +mapU.replaceUndefWith0();
    if (nmod!=0)
      cout << "WARNING: replaced " << nmod <<
              " undefined map pixels with a value of 0" << endl;

    double avg=0.;
    if (remove_mono)
      {
      avg=mapT.average();
      mapT.Add(T(-avg));
      }

    arr weight;
    get_ring_weights (params,mapT.Nside(),weight);

    Alm > almT(nlmax,nmmax), almG(nlmax,nmmax), almC(nlmax,nmmax);
    if (mapT.Scheme()==NEST) mapT.swap_scheme();
    if (mapQ.Scheme()==NEST) mapQ.swap_scheme();
    if (mapU.Scheme()==NEST) mapU.swap_scheme();
    map2alm_pol_iter
      (mapT,mapQ,mapU,almT,almG,almC,num_iter,weight);

    almT(0,0) += T(avg*sqrt(fourpi));

    if (outfile!="")
      {
      PowSpec powspec;
      extract_powspec (almT,almG,almC,powspec);
      params.template find("full_powerspectrum",false) ?
        write_powspec_to_fits (outfile,powspec,6) :
        write_powspec_to_fits (outfile,powspec,4);
      }
    if (outfile_alms!="")
      write_Alm_to_fits (outfile_alms,almT,almG,almC,nlmax,nmmax,planckType());
    }
  }

} // unamed namespace

int anafast_cxx_module (int argc, const char **argv)
  {
  module_startup ("anafast_cxx", argc, argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  bool dp = params.find ("double_precision",false);
  dp ? anafast_cxx(params) : anafast_cxx(params);
  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/calc_powspec.cc0000664000175000017500000000027713010375061027551 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  calc_powspec_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/calc_powspec_module.cc0000664000175000017500000000507713010375061031121 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2004-2011 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "fitshandle.h"
#include "paramfile.h"
#include "alm.h"
#include "alm_fitsio.h"
#include "powspec.h"
#include "powspec_fitsio.h"
#include "alm_powspec_tools.h"
#include "levels_facilities.h"
#include "announce.h"

using namespace std;

int calc_powspec_module (int argc, const char **argv)
  {
  module_startup ("calc_powspec",argc,argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  bool pol=params.find("pol",false);
  string alm1=params.find("alm1");
  string ps=params.find("ps");

  if (!params.param_present("alm2"))
    {
    int lmax,mmax;
    pol ? get_almsize_pol(alm1,lmax,mmax)
        : get_almsize    (alm1,lmax,mmax);
    Alm > almT, almG, almC;
    pol ? read_Alm_from_fits (alm1,almT,almG,almC,lmax,mmax)
        : read_Alm_from_fits (alm1,almT,lmax,mmax);
    PowSpec powspec;
    pol ? extract_powspec (almT,almG,almC,powspec)
        : extract_powspec (almT,powspec);
    write_powspec_to_fits (ps,powspec,pol ? 6 : 1);
    }
  else
    {
    planck_assert(!pol, "polarisation not supported for cross-powerspectra");
    int lmax,mmax;
    get_almsize(alm1,lmax,mmax);
    Alm > Alm1;
    read_Alm_from_fits (alm1,Alm1,lmax,mmax);
    string alm2=params.find("alm2");
    get_almsize(alm2,lmax,mmax);
    Alm > Alm2;
    read_Alm_from_fits (alm2,Alm2,lmax,mmax);
    PowSpec powspec;
    extract_crosspowspec (Alm1,Alm2,powspec);
    write_powspec_to_fits (ps,powspec,1);
    }

  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_base.cc0000664000175000017500000011634613010375061027540 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "healpix_base.h"
#include "geom_utils.h"
#include "lsconstants.h"

using namespace std;

template int T_Healpix_Base::nside2order (I nside)
  {
  planck_assert (nside>I(0), "invalid value for Nside");
  return ((nside)&(nside-1)) ? -1 : ilog2(nside);
  }
template I T_Healpix_Base::npix2nside (I npix)
  {
  I res=isqrt(npix/I(12));
  planck_assert (npix==res*res*I(12), "invalid value for npix");
  return res;
  }

template I T_Healpix_Base::ring_above (double z) const
  {
  double az=abs(z);
  if (az<=twothird) // equatorial region
    return I(nside_*(2-1.5*z));
  I iring = I(nside_*sqrt(3*(1-az)));
  return (z>0) ? iring : 4*nside_-iring-1;
  }

namespace {

/* Short note on the "zone":
   zone = 0: pixel lies completely outside the queried shape
          1: pixel may overlap with the shape, pixel center is outside
          2: pixel center is inside the shape, but maybe not the complete pixel
          3: pixel lies completely inside the shape */

template inline void check_pixel (int o, int order_,
  int omax, int zone, rangeset &pixset, I pix, vector > &stk,
  bool inclusive, int &stacktop)
  {
  if (zone==0) return;

  if (o=3)
      {
      int sdist=2*(order_-o); // the "bit-shift distance" between map orders
      pixset.append(pix<order_) // this implies that inclusive==true
    {
    if (zone>=2) // pixel center in shape
      {
      pixset.append(pix>>(2*(o-order_))); // output the parent pixel at order_
      stk.resize(stacktop); // unwind the stack
      }
    else // (zone==1): pixel center in safety range
      {
      if (o>(2*(o-order_))); // output the parent pixel at order_
        stk.resize(stacktop); // unwind the stack
        }
      }
    }
  else // o==order_
    {
    if (zone>=2)
      pixset.append(pix);
    else if (inclusive) // and (zone>=1)
      {
      if (order_ bool check_pixel_ring (const T_Healpix_Base &b1,
  const T_Healpix_Base &b2, I pix, I nr, I ipix1, int fct,
  double cz, double cphi, double cosrp2, I cpix)
  {
  if (pix>=nr) pix-=nr;
  if (pix<0) pix+=nr;
  pix+=ipix1;
  if (pix==cpix) return false; // disk center in pixel => overlap
  int px,py,pf;
  b1.pix2xyf(pix,px,py,pf);
  for (int i=0; icosrp2) // overlap
      return false;
    b2.pix2zphi(b2.xyf2pix(ox+fct-1,oy+i,pf),pz,pphi);
    if (cosdist_zphi(pz,pphi,cz,cphi)>cosrp2) // overlap
      return false;
    b2.pix2zphi(b2.xyf2pix(ox+fct-1-i,oy+fct-1,pf),pz,pphi);
    if (cosdist_zphi(pz,pphi,cz,cphi)>cosrp2) // overlap
      return false;
    b2.pix2zphi(b2.xyf2pix(ox,oy+fct-1-i,pf),pz,pphi);
    if (cosdist_zphi(pz,pphi,cz,cphi)>cosrp2) // overlap
      return false;
    }
  return true;
  }

} // unnamed namespace

template template
  void T_Healpix_Base::query_disc_internal
  (pointing ptg, double radius, int fact, rangeset &pixset) const
  {
  bool inclusive = (fact!=0);
  pixset.clear();
  ptg.normalize();

  if (scheme_==RING)
    {
    I fct=1;
    if (inclusive)
      {
      planck_assert (((I(1)<=fact,
        "invalid oversampling factor");
      fct = fact;
      }
    T_Healpix_Base b2;
    double rsmall, rbig;
    if (fct>1)
      {
      b2.SetNside(fct*nside_,RING);
      rsmall = radius+b2.max_pixrad();
      rbig = radius+max_pixrad();
      }
    else
      rsmall = rbig = inclusive ? radius+max_pixrad() : radius;

    if (rsmall>=pi)
      { pixset.append(0,npix_); return; }

    rbig = min(pi,rbig);

    double cosrsmall = cos(rsmall);
    double cosrbig = cos(rbig);

    double z0 = cos(ptg.theta);
    double xa = 1./sqrt((1-z0)*(1+z0));

    I cpix=zphi2pix(z0,ptg.phi);

    double rlat1 = ptg.theta - rsmall;
    double zmax = cos(rlat1);
    I irmin = ring_above (zmax)+1;

    if ((rlat1<=0) && (irmin>1)) // north pole in the disk
      {
      I sp,rp; bool dummy;
      get_ring_info_small(irmin-1,sp,rp,dummy);
      pixset.append(0,sp+rp);
      }

    if ((fct>1) && (rlat1>0)) irmin=max(I(1),irmin-1);

    double rlat2 = ptg.theta + rsmall;
    double zmin = cos(rlat2);
    I irmax = ring_above (zmin);

    if ((fct>1) && (rlat20)
        {
        I nr, ipix1;
        bool shifted;
        get_ring_info_small(iz,ipix1,nr,shifted);
        double shift = shifted ? 0.5 : 0.;

        I ipix2 = ipix1 + nr - 1; // highest pixel number in the ring

        I ip_lo = ifloor(nr*inv_twopi*(ptg.phi-dphi) - shift)+1;
        I ip_hi = ifloor(nr*inv_twopi*(ptg.phi+dphi) - shift);

        if (fct>1)
          {
          while ((ip_lo<=ip_hi) && check_pixel_ring
                (*this,b2,ip_lo,nr,ipix1,fct,z0,ptg.phi,cosrsmall,cpix))
            ++ip_lo;
          while ((ip_hi>ip_lo) && check_pixel_ring
                (*this,b2,ip_hi,nr,ipix1,fct,z0,ptg.phi,cosrsmall,cpix))
            --ip_hi;
          }

        if (ip_lo<=ip_hi)
          {
          if (ip_hi>=nr)
            { ip_lo-=nr; ip_hi-=nr; }
          if (ip_lo<0)
            {
            pixset.append(ipix1,ipix1+ip_hi+1);
            pixset.append(ipix1+ip_lo+nr,ipix2+1);
            }
          else
            pixset.append(ipix1+ip_lo,ipix1+ip_hi+1);
          }
        }
      }
    if ((rlat2>=pi) && (irmax+1<4*nside_)) // south pole in the disk
      {
      I sp,rp; bool dummy;
      get_ring_info_small(irmax+1,sp,rp,dummy);
      pixset.append(sp,npix_);
      }
    }
  else // scheme_==NEST
    {
    if (radius>=pi) // disk covers the whole sphere
      { pixset.append(0,npix_); return; }

    int oplus = 0;
    if (inclusive)
      {
      planck_assert ((I(1)<<(order_max-order_))>=fact,
        "invalid oversampling factor");
      planck_assert ((fact&(fact-1))==0,
        "oversampling factor must be a power of 2");
      oplus=ilog2(fact);
      }
    int omax=order_+oplus; // the order up to which we test

    vec3 vptg(ptg);
    arr > base(omax+1);
    arr crpdr(omax+1), crmdr(omax+1);
    double cosrad=cos(radius);
    for (int o=0; o<=omax; ++o) // prepare data at the required orders
      {
      base[o].Set(o,NEST);
      double dr=base[o].max_pixrad(); // safety distance
      crpdr[o] = (radius+dr>pi) ? -1. : cos(radius+dr);
      crmdr[o] = (radius-dr<0.) ?  1. : cos(radius-dr);
      }
    vector > stk; // stack for pixel numbers and their orders
    stk.reserve(12+3*omax); // reserve maximum size to avoid reallocation
    for (int i=0; i<12; ++i) // insert the 12 base pixels in reverse order
      stk.push_back(make_pair(I(11-i),0));

    int stacktop=0; // a place to save a stack position

    while (!stk.empty()) // as long as there are pixels on the stack
      {
      // pop current pixel number and order from the stack
      I pix=stk.back().first;
      int o=stk.back().second;
      stk.pop_back();

      double z,phi;
      base[o].pix2zphi(pix,z,phi);
      // cosine of angular distance between pixel center and disk center
      double cangdist=cosdist_zphi(vptg.z,ptg.phi,z,phi);

      if (cangdist>crpdr[o])
        {
        int zone = (cangdist void T_Healpix_Base::query_disc
  (pointing ptg, double radius, rangeset &pixset) const
  {
  query_disc_internal (ptg, radius, 0, pixset);
  }

template void T_Healpix_Base::query_disc_inclusive
  (pointing ptg, double radius, rangeset &pixset, int fact) const
  {
  planck_assert(fact>0,"fact must be a positive integer");
  if ((sizeof(I)<8) && (((I(1)< base2(nside_,scheme_,SET_NSIDE);
    base2.query_disc_internal(ptg,radius,fact,pixset);
    return;
    }
  query_disc_internal (ptg, radius, fact, pixset);
  }

template template
  void T_Healpix_Base::query_multidisc (const arr &norm,
  const arr &rad, int fact, rangeset &pixset) const
  {
  bool inclusive = (fact!=0);
  tsize nv=norm.size();
  planck_assert(nv==rad.size(),"inconsistent input arrays");
  pixset.clear();

  if (scheme_==RING)
    {
    I fct=1;
    if (inclusive)
      {
      planck_assert (((I(1)<=fact,
        "invalid oversampling factor");
      fct = fact;
      }
    T_Healpix_Base b2;
    double rpsmall, rpbig;
    if (fct>1)
      {
      b2.SetNside(fct*nside_,RING);
      rpsmall = b2.max_pixrad();
      rpbig = max_pixrad();
      }
    else
      rpsmall = rpbig = inclusive ? max_pixrad() : 0;

    I irmin=1, irmax=4*nside_-1;
    vector z0,xa,cosrsmall,cosrbig;
    vector ptg;
    vector cpix;
    for (tsize i=0; i1) cpix.push_back(zphi2pix(cth,pnt.phi));
        xa.push_back(1./sqrt((1-cth)*(1+cth)));
        ptg.push_back(pnt);

        double rlat1 = pnt.theta - rsmall;
        double zmax = cos(rlat1);
        I irmin_t = (rlat1<=0) ? 1 : ring_above (zmax)+1;

        if ((fct>1) && (rlat1>0)) irmin_t=max(I(1),irmin_t-1);

        double rlat2 = pnt.theta + rsmall;
        double zmin = cos(rlat2);
        I irmax_t = (rlat2>=pi) ? 4*nside_-1 : ring_above (zmin);

        if ((fct>1) && (rlat2 irmin) irmin=irmin_t;
        }
      }

    for (I iz=irmin; iz<=irmax; ++iz)
      {
      double z=ring2z(iz);
      I ipix1,nr;
      bool shifted;
      get_ring_info_small(iz,ipix1,nr,shifted);
      double shift = shifted ? 0.5 : 0.;
      rangeset tr;
      tr.append(ipix1,ipix1+nr);
      for (tsize j=0; j(nr*inv_twopi*(ptg[j].phi-dphi) - shift)+1;
        I ip_hi = ifloor(nr*inv_twopi*(ptg[j].phi+dphi) - shift);
        if (fct>1)
          {
          while ((ip_lo<=ip_hi) && check_pixel_ring
            (*this,b2,ip_lo,nr,ipix1,fct,z0[j],ptg[j].phi,cosrsmall[j],cpix[j]))
            ++ip_lo;
          while ((ip_hi>ip_lo) && check_pixel_ring
            (*this,b2,ip_hi,nr,ipix1,fct,z0[j],ptg[j].phi,cosrsmall[j],cpix[j]))
            --ip_hi;
          }
        if (ip_hi>=nr)
          { ip_lo-=nr; ip_hi-=nr;}
        if (ip_lo<0)
          tr.remove(ipix1+ip_hi+1,ipix1+ip_lo+nr);
        else
          tr.intersect(ipix1+ip_lo,ipix1+ip_hi+1);
        }
      pixset.append(tr);
      }
    }
  else // scheme_ == NEST
    {
    int oplus = 0;
    if (inclusive)
      {
      planck_assert ((I(1)<<(order_max-order_))>=fact,
        "invalid oversampling factor");
      planck_assert ((fact&(fact-1))==0,
        "oversampling factor must be a power of 2");
      oplus=ilog2(fact);
      }
    int omax=order_+oplus; // the order up to which we test

    // TODO: ignore all disks with radius>=pi

    arr > base(omax+1);
    arr3 crlimit(omax+1,nv,3);
    for (int o=0; o<=omax; ++o) // prepare data at the required orders
      {
      base[o].Set(o,NEST);
      double dr=base[o].max_pixrad(); // safety distance
      for (tsize i=0; ipi) ? -1. : cos(rad[i]+dr);
        crlimit(o,i,1) = (o==0) ? cos(rad[i]) : crlimit(0,i,1);
        crlimit(o,i,2) = (rad[i]-dr<0.) ?  1. : cos(rad[i]-dr);
        }
      }

    vector > stk; // stack for pixel numbers and their orders
    stk.reserve(12+3*omax); // reserve maximum size to avoid reallocation
    for (int i=0; i<12; ++i) // insert the 12 base pixels in reverse order
      stk.push_back(make_pair(I(11-i),0));

    int stacktop=0; // a place to save a stack position

    while (!stk.empty()) // as long as there are pixels on the stack
      {
      // pop current pixel number and order from the stack
      I pix=stk.back().first;
      int o=stk.back().second;
      stk.pop_back();

      vec3 pv(base[o].pix2vec(pix));

      tsize zone=3;
      for (tsize i=0; i void T_Healpix_Base::query_multidisc_general
  (const arr &norm, const arr &rad, bool inclusive,
  const vector &cmds, rangeset &pixset) const
  {
  tsize nv=norm.size();
  planck_assert(nv==rad.size(),"inconsistent input arrays");
  pixset.clear();

  if (scheme_==RING)
    {
    planck_fail ("not yet implemented");
    }
  else // scheme_ == NEST
    {
    int oplus=inclusive ? 2 : 0;
    int omax=min(order_max,order_+oplus); // the order up to which we test

    // TODO: ignore all disks with radius>=pi

    arr > base(omax+1);
    arr3 crlimit(omax+1,nv,3);
    for (int o=0; o<=omax; ++o) // prepare data at the required orders
      {
      base[o].Set(o,NEST);
      double dr=base[o].max_pixrad(); // safety distance
      for (tsize i=0; ipi) ? -1. : cos(rad[i]+dr);
        crlimit(o,i,1) = (o==0) ? cos(rad[i]) : crlimit(0,i,1);
        crlimit(o,i,2) = (rad[i]-dr<0.) ?  1. : cos(rad[i]-dr);
        }
      }

    vector > stk; // stack for pixel numbers and their orders
    stk.reserve(12+3*omax); // reserve maximum size to avoid reallocation
    for (int i=0; i<12; ++i) // insert the 12 base pixels in reverse order
      stk.push_back(make_pair(I(11-i),0));

    int stacktop=0; // a place to save a stack position
    arr zone(nv);

    vector zstk; zstk.reserve(cmds.size());

    while (!stk.empty()) // as long as there are pixels on the stack
      {
      // pop current pixel number and order from the stack
      I pix=stk.back().first;
      int o=stk.back().second;
      stk.pop_back();

      vec3 pv(base[o].pix2vec(pix));

      for (tsize i=0; i inline int T_Healpix_Base::spread_bits (int v) const
  { return utab[v&0xff] | (utab[(v>>8)&0xff]<<16); }
template<> inline int64 T_Healpix_Base::spread_bits (int v) const
  {
  return  int64(utab[ v     &0xff])      | (int64(utab[(v>> 8)&0xff])<<16)
       | (int64(utab[(v>>16)&0xff])<<32) | (int64(utab[(v>>24)&0xff])<<48);
  }

template<> inline int T_Healpix_Base::compress_bits (int v) const
  {
  int raw = (v&0x5555) | ((v&0x55550000)>>15);
  return ctab[raw&0xff] | (ctab[raw>>8]<<4);
  }
template<> inline int T_Healpix_Base::compress_bits (int64 v) const
  {
  int64 raw = v&0x5555555555555555ull;
  raw|=raw>>15;
  return ctab[ raw     &0xff]      | (ctab[(raw>> 8)&0xff]<< 4)
      | (ctab[(raw>>32)&0xff]<<16) | (ctab[(raw>>40)&0xff]<<20);
  }

template inline void T_Healpix_Base::nest2xyf (I pix, int &ix,
  int &iy, int &face_num) const
  {
  face_num = pix>>(2*order_);
  pix &= (npface_-1);
  ix = compress_bits(pix);
  iy = compress_bits(pix>>1);
  }

template inline I T_Healpix_Base::xyf2nest (int ix, int iy,
  int face_num) const
  { return (I(face_num)<<(2*order_)) + spread_bits(ix) + (spread_bits(iy)<<1); }

template void T_Healpix_Base::ring2xyf (I pix, int &ix, int &iy,
  int &face_num) const
  {
  I iring, iphi, kshift, nr;
  I nl2 = 2*nside_;

  if (pix>1; //counted from North pole
    iphi  = (pix+1) - 2*iring*(iring-1);
    kshift = 0;
    nr = iring;
    face_num=(iphi-1)/nr;
    }
  else if (pix<(npix_-ncap_)) // Equatorial region
    {
    I ip = pix - ncap_;
    I tmp = (order_>=0) ? ip>>(order_+2) : ip/(4*nside_);
    iring = tmp+nside_;
    iphi = ip-tmp*4*nside_ + 1;
    kshift = (iring+nside_)&1;
    nr = nside_;
    I ire = iring-nside_+1,
      irm = nl2+2-ire;
    I ifm = iphi - ire/2 + nside_ -1,
      ifp = iphi - irm/2 + nside_ -1;
    if (order_>=0)
      { ifm >>= order_; ifp >>= order_; }
    else
      { ifm /= nside_; ifp /= nside_; }
    face_num = (ifp==ifm) ? (ifp|4) : ((ifp>1; //counted from South pole
    iphi  = 4*iring + 1 - (ip - 2*iring*(iring-1));
    kshift = 0;
    nr = iring;
    iring = 2*nl2-iring;
    face_num = 8 + (iphi-1)/nr;
    }

  I irt = iring - (jrll[face_num]*nside_) + 1;
  I ipt = 2*iphi- jpll[face_num]*nr - kshift -1;
  if (ipt>=nl2) ipt-=8*nside_;

  ix =  (ipt-irt) >>1;
  iy = (-ipt-irt) >>1;
  }

template I T_Healpix_Base::xyf2ring (int ix, int iy,
  int face_num) const
  {
  I nl4 = 4*nside_;
  I jr = (jrll[face_num]*nside_) - ix - iy  - 1;

  I nr, kshift, n_before;

  bool shifted;
  get_ring_info_small(jr,n_before,nr,shifted);
  nr>>=2;
  kshift=1-shifted;
  I jp = (jpll[face_num]*nr + ix - iy + 1 + kshift) / 2;
  planck_assert(jp<=4*nr,"must not happen");
  if (jp<1) jp+=nl4; // assumption: if this triggers, then nl4==4*nr

  return n_before + jp - 1;
  }

template T_Healpix_Base::T_Healpix_Base ()
  : order_(-1), nside_(0), npface_(0), ncap_(0), npix_(0),
    fact1_(0), fact2_(0), scheme_(RING) {}

template void T_Healpix_Base::Set (int order,
  Healpix_Ordering_Scheme scheme)
  {
  planck_assert ((order>=0)&&(order<=order_max), "bad order");
  order_  = order;
  nside_  = I(1)< void T_Healpix_Base::SetNside (I nside,
  Healpix_Ordering_Scheme scheme)
  {
  order_  = nside2order(nside);
  planck_assert ((scheme!=NEST) || (order_>=0),
    "SetNside: nside must be power of 2 for nested maps");
  nside_  = nside;
  npface_ = nside_*nside_;
  ncap_   = (npface_-nside_)<<1;
  npix_   = 12*npface_;
  fact2_  = 4./npix_;
  fact1_  = (nside_<<1)*fact2_;
  scheme_ = scheme;
  }

template double T_Healpix_Base::ring2z (I ring) const
  {
  if (ring I T_Healpix_Base::pix2ring (I pix) const
  {
  if (scheme_==RING)
    {
    if (pix>1; // counted from North pole
    else if (pix<(npix_-ncap_)) // Equatorial region
      return (pix-ncap_)/(4*nside_) + nside_; // counted from North pole
    else // South Polar cap
      return 4*nside_-((1+I(isqrt(2*(npix_-pix)-1)))>>1);
    }
  else
    {
    int face_num, ix, iy;
    nest2xyf(pix,ix,iy,face_num);
    return (I(jrll[face_num])< I T_Healpix_Base::nest2ring (I pix) const
  {
  planck_assert(order_>=0, "hierarchical map required");
  int ix, iy, face_num;
  nest2xyf (pix, ix, iy, face_num);
  return xyf2ring (ix, iy, face_num);
  }

template I T_Healpix_Base::ring2nest (I pix) const
  {
  planck_assert(order_>=0, "hierarchical map required");
  int ix, iy, face_num;
  ring2xyf (pix, ix, iy, face_num);
  return xyf2nest (ix, iy, face_num);
  }

template inline I T_Healpix_Base::nest_peano_helper
  (I pix, int dir) const
  {
  int face = (pix>>(2*order_));
  I result = 0;
  int state = ((peano_face2path[dir][face]<<4))|(dir<<7);
  int shift=2*order_-4;
  for (; shift>=0; shift-=4)
    {
    state=peano_arr2[(state&0xF0) | ((pix>>shift)&0xF)];
    result = (result<<4) | (state&0xF);
    }
  if (shift==-2)
    {
    state=peano_arr[((state>>2)&0xFC) | (pix&0x3)];
    result = (result<<2) | (state&0x3);
    }

  return result + (I(peano_face2face[dir][face])<<(2*order_));
  }

template I T_Healpix_Base::nest2peano (I pix) const
  { return nest_peano_helper(pix,0); }

template I T_Healpix_Base::peano2nest (I pix) const
  { return nest_peano_helper(pix,1); }

template I T_Healpix_Base::loc2pix (double z, double phi,
  double sth, bool have_sth) const
  {
  double za = abs(z);
  double tt = fmodulo(phi*inv_halfpi,4.0); // in [0,4)

  if (scheme_==RING)
    {
    if (za<=twothird) // Equatorial region
      {
      I nl4 = 4*nside_;
      double temp1 = nside_*(0.5+tt);
      double temp2 = nside_*z*0.75;
      I jp = I(temp1-temp2); // index of  ascending edge line
      I jm = I(temp1+temp2); // index of descending edge line

      // ring number counted from z=2/3
      I ir = nside_ + 1 + jp - jm; // in {1,2n+1}
      I kshift = 1-(ir&1); // kshift=1 if ir even, 0 otherwise

      I t1 = jp+jm-nside_+kshift+1+nl4+nl4;
      I ip = (order_>0) ?
        (t1>>1)&(nl4-1) : ((t1>>1)%nl4); // in {0,4n-1}

      return ncap_ + (ir-1)*nl4 + ip;
      }
    else  // North & South polar caps
      {
      double tp = tt-I(tt);
      double tmp = ((za<0.99)||(!have_sth)) ?
                   nside_*sqrt(3*(1-za)) :
                   nside_*sth/sqrt((1.+za)/3.);

      I jp = I(tp*tmp); // increasing edge line index
      I jm = I((1.0-tp)*tmp); // decreasing edge line index

      I ir = jp+jm+1; // ring number counted from the closest pole
      I ip = I(tt*ir); // in {0,4*ir-1}
      planck_assert((ip>=0)&&(ip<4*ir),"must not happen");
      //ip %= 4*ir;

      return (z>0)  ?  2*ir*(ir-1) + ip  :  npix_ - 2*ir*(ir+1) + ip;
      }
    }
  else // scheme_ == NEST
    {
    if (za<=twothird) // Equatorial region
      {
      double temp1 = nside_*(0.5+tt);
      double temp2 = nside_*(z*0.75);
      I jp = I(temp1-temp2); // index of  ascending edge line
      I jm = I(temp1+temp2); // index of descending edge line
      I ifp = jp >> order_;  // in {0,4}
      I ifm = jm >> order_;
      int face_num = (ifp==ifm) ? (ifp|4) : ((ifp 2/3
      {
      int ntt = min(3,int(tt));
      double tp = tt-ntt;
      double tmp = ((za<0.99)||(!have_sth)) ?
                   nside_*sqrt(3*(1-za)) :
                   nside_*sth/sqrt((1.+za)/3.);

      I jp = I(tp*tmp); // increasing edge line index
      I jm = I((1.0-tp)*tmp); // decreasing edge line index
      jp=min(jp,nside_-1); // for points too close to the boundary
      jm=min(jm,nside_-1);
      return (z>=0) ?
        xyf2nest(nside_-jm -1,nside_-jp-1,ntt) : xyf2nest(jp,jm,ntt+8);
      }
    }
  }

template void T_Healpix_Base::pix2loc (I pix, double &z,
  double &phi, double &sth, bool &have_sth) const
  {
  have_sth=false;
  if (scheme_==RING)
    {
    if (pix>1; // counted from North pole
      I iphi  = (pix+1) - 2*iring*(iring-1);

      double tmp=(iring*iring)*fact2_;
      z = 1.0 - tmp;
      if (z>0.99) { sth=sqrt(tmp*(2.-tmp)); have_sth=true; }
      phi = (iphi-0.5) * halfpi/iring;
      }
    else if (pix<(npix_-ncap_)) // Equatorial region
      {
      I nl4 = 4*nside_;
      I ip  = pix - ncap_;
      I tmp = (order_>=0) ? ip>>(order_+2) : ip/nl4;
      I iring = tmp + nside_,
        iphi = ip-nl4*tmp+1;
      // 1 if iring+nside is odd, 1/2 otherwise
      double fodd = ((iring+nside_)&1) ? 1 : 0.5;

      z = (2*nside_-iring)*fact1_;
      phi = (iphi-fodd) * pi*0.75*fact1_;
      }
    else // South Polar cap
      {
      I ip = npix_ - pix;
      I iring = (1+I(isqrt(2*ip-1)))>>1; // counted from South pole
      I iphi  = 4*iring + 1 - (ip - 2*iring*(iring-1));

      double tmp=(iring*iring)*fact2_;
      z = tmp - 1.0;
      if (z<-0.99) { sth=sqrt(tmp*(2.-tmp)); have_sth=true; }
      phi = (iphi-0.5) * halfpi/iring;
      }
    }
  else
    {
    int face_num, ix, iy;
    nest2xyf(pix,ix,iy,face_num);

    I jr = (I(jrll[face_num])<0.99) { sth=sqrt(tmp*(2.-tmp)); have_sth=true; }
      }
    else if (jr > 3*nside_)
      {
      nr = nside_*4-jr;
      double tmp=(nr*nr)*fact2_;
      z = tmp - 1;
      if (z<-0.99) { sth=sqrt(tmp*(2.-tmp)); have_sth=true; }
      }
    else
      {
      nr = nside_;
      z = (2*nside_-jr)*fact1_;
      }

    I tmp=I(jpll[face_num])*nr+ix-iy;
    planck_assert(tmp<8*nr,"must not happen");
    if (tmp<0) tmp+=8*nr;
    phi = (nr==nside_) ? 0.75*halfpi*tmp*fact1_ :
                         (0.5*halfpi*tmp)/nr;
    }
  }

template template
  void T_Healpix_Base::query_polygon_internal
  (const vector &vertex, int fact, rangeset &pixset) const
  {
  bool inclusive = (fact!=0);
  tsize nv=vertex.size();
  tsize ncirc = inclusive ? nv+1 : nv;
  planck_assert(nv>=3,"not enough vertices in polygon");
  arr vv(nv);
  for (tsize i=0; i normal(ncirc);
  int flip=0;
  for (tsize i=0; i1e-10,"degenerate corner");
    if (i==0)
      flip = (hnd<0.) ? -1 : 1;
    else
      planck_assert(flip*hnd>0,"polygon is not convex");
    normal[i]*=flip;
    }
  arr rad(ncirc,halfpi);
  if (inclusive)
    {
    double cosrad;
    find_enclosing_circle (vv, normal[nv], cosrad);
    rad[nv]=acos(cosrad);
    }
  query_multidisc(normal,rad,fact,pixset);
  }

template void T_Healpix_Base::query_polygon
  (const vector &vertex, rangeset &pixset) const
  {
  query_polygon_internal(vertex, 0, pixset);
  }

template void T_Healpix_Base::query_polygon_inclusive
  (const vector &vertex, rangeset &pixset, int fact) const
  {
  planck_assert(fact>0,"fact must be a positive integer");
  if ((sizeof(I)<8) && (((I(1)< base2(nside_,scheme_,SET_NSIDE);
    base2.query_polygon_internal(vertex,fact,pixset);
    return;
    }
  query_polygon_internal(vertex, fact, pixset);
  }

template void T_Healpix_Base::query_strip_internal
  (double theta1, double theta2, bool inclusive, rangeset &pixset) const
  {
  if (scheme_==RING)
    {
    I ring1 = max(I(1),1+ring_above(cos(theta1))),
      ring2 = min(4*nside_-1,ring_above(cos(theta2)));
    if (inclusive)
      {
      ring1 = max(I(1),ring1-1);
      ring2 = min(4*nside_-1,ring2+1);
      }

    I sp1,rp1,sp2,rp2;
    bool dummy;
    get_ring_info_small(ring1,sp1,rp1,dummy);
    get_ring_info_small(ring2,sp2,rp2,dummy);
    I pix1 = sp1,
      pix2 = sp2+rp2;
    if (pix1<=pix2) pixset.append(pix1,pix2);
    }
  else
    planck_fail("query_strip not yet implemented for NESTED");
  }

template void T_Healpix_Base::query_strip (double theta1,
  double theta2, bool inclusive, rangeset &pixset) const
  {
  pixset.clear();

  if (theta1 ps2;
    query_strip_internal(theta1,pi,inclusive,ps2);
    pixset.append(ps2);
    }
  }

template inline void T_Healpix_Base::get_ring_info_small
  (I ring, I &startpix, I &ringpix, bool &shifted) const
  {
  if (ring < nside_)
    {
    shifted = true;
    ringpix = 4*ring;
    startpix = 2*ring*(ring-1);
    }
  else if (ring < 3*nside_)
    {
    shifted = ((ring-nside_) & 1) == 0;
    ringpix = 4*nside_;
    startpix = ncap_ + (ring-nside_)*ringpix;
    }
  else
    {
    shifted = true;
    I nr= 4*nside_-ring;
    ringpix = 4*nr;
    startpix = npix_-2*nr*(nr+1);
    }
  }

template void T_Healpix_Base::get_ring_info (I ring, I &startpix,
  I &ringpix, double &costheta, double &sintheta, bool &shifted) const
  {
  I northring = (ring>2*nside_) ? 4*nside_-ring : ring;
  if (northring < nside_)
    {
    double tmp = northring*northring*fact2_;
    costheta = 1 - tmp;
    sintheta = sqrt(tmp*(2-tmp));
    ringpix = 4*northring;
    shifted = true;
    startpix = 2*northring*(northring-1);
    }
  else
    {
    costheta = (2*nside_-northring)*fact1_;
    sintheta = sqrt((1+costheta)*(1-costheta));
    ringpix = 4*nside_;
    shifted = ((northring-nside_) & 1) == 0;
    startpix = ncap_ + (northring-nside_)*ringpix;
    }
  if (northring != ring) // southern hemisphere
    {
    costheta = -costheta;
    startpix = npix_ - startpix - ringpix;
    }
  }
template void T_Healpix_Base::get_ring_info2 (I ring,
  I &startpix, I &ringpix, double &theta, bool &shifted) const
  {
  I northring = (ring>2*nside_) ? 4*nside_-ring : ring;
  if (northring < nside_)
    {
    double tmp = northring*northring*fact2_;
    double costheta = 1 - tmp;
    double sintheta = sqrt(tmp*(2-tmp));
    theta = atan2(sintheta,costheta);
    ringpix = 4*northring;
    shifted = true;
    startpix = 2*northring*(northring-1);
    }
  else
    {
    theta = acos((2*nside_-northring)*fact1_);
    ringpix = 4*nside_;
    shifted = ((northring-nside_) & 1) == 0;
    startpix = ncap_ + (northring-nside_)*ringpix;
    }
  if (northring != ring) // southern hemisphere
    {
    theta = pi-theta;
    startpix = npix_ - startpix - ringpix;
    }
  }

template void T_Healpix_Base::neighbors (I pix,
  fix_arr &result) const
  {
  int ix, iy, face_num;
  (scheme_==RING) ?
    ring2xyf(pix,ix,iy,face_num) : nest2xyf(pix,ix,iy,face_num);

  const I nsm1 = nside_-1;
  if ((ix>0)&&(ix0)&&(iy=nside_)
        { x-=nside_; nbnum+=1; }
      if (y<0)
        { y+=nside_; nbnum-=3; }
      else if (y>=nside_)
        { y-=nside_; nbnum+=3; }

      int f = nb_facearray[nbnum][face_num];
      if (f>=0)
        {
        int bits = nb_swaparray[nbnum][face_num>>2];
        if (bits&1) x=nside_-x-1;
        if (bits&2) y=nside_-y-1;
        if (bits&4) std::swap(x,y);
        result[i] = (scheme_==RING) ? xyf2ring(x,y,f) : xyf2nest(x,y,f);
        }
      else
        result[i] = -1;
      }
    }
  }

template void T_Healpix_Base::get_interpol (const pointing &ptg,
  fix_arr &pix, fix_arr &wgt) const
  {
  planck_assert((ptg.theta>=0)&&(ptg.theta<=pi),"invalid theta value");
  double z = cos (ptg.theta);
  I ir1 = ring_above(z);
  I ir2 = ir1+1;
  double theta1, theta2, w1, tmp, dphi;
  I sp,nr;
  bool shift;
  I i1,i2;
  if (ir1>0)
    {
    get_ring_info2 (ir1, sp, nr, theta1, shift);
    dphi = twopi/nr;
    tmp = (ptg.phi/dphi - .5*shift);
    i1 = (tmp<0) ? I(tmp)-1 : I(tmp);
    w1 = (ptg.phi-(i1+.5*shift)*dphi)/dphi;
    i2 = i1+1;
    if (i1<0) i1 +=nr;
    if (i2>=nr) i2 -=nr;
    pix[0] = sp+i1; pix[1] = sp+i2;
    wgt[0] = 1-w1; wgt[1] = w1;
    }
  if (ir2<(4*nside_))
    {
    get_ring_info2 (ir2, sp, nr, theta2, shift);
    dphi = twopi/nr;
    tmp = (ptg.phi/dphi - .5*shift);
    i1 = (tmp<0) ? I(tmp)-1 : I(tmp);
    w1 = (ptg.phi-(i1+.5*shift)*dphi)/dphi;
    i2 = i1+1;
    if (i1<0) i1 +=nr;
    if (i2>=nr) i2 -=nr;
    pix[2] = sp+i1; pix[3] = sp+i2;
    wgt[2] = 1-w1; wgt[3] = w1;
    }

  if (ir1==0)
    {
    double wtheta = ptg.theta/theta2;
    wgt[2] *= wtheta; wgt[3] *= wtheta;
    double fac = (1-wtheta)*0.25;
    wgt[0] = fac; wgt[1] = fac; wgt[2] += fac; wgt[3] +=fac;
    pix[0] = (pix[2]+2)&3;
    pix[1] = (pix[3]+2)&3;
    }
  else if (ir2==4*nside_)
    {
    double wtheta = (ptg.theta-theta1)/(pi-theta1);
    wgt[0] *= (1-wtheta); wgt[1] *= (1-wtheta);
    double fac = wtheta*0.25;
    wgt[0] += fac; wgt[1] += fac; wgt[2] = fac; wgt[3] =fac;
    pix[2] = ((pix[0]+2)&3)+npix_-4;
    pix[3] = ((pix[1]+2)&3)+npix_-4;
    }
  else
    {
    double wtheta = (ptg.theta-theta1)/(theta2-theta1);
    wgt[0] *= (1-wtheta); wgt[1] *= (1-wtheta);
    wgt[2] *= wtheta; wgt[3] *= wtheta;
    }

  if (scheme_==NEST)
    for (tsize m=0; m void T_Healpix_Base::swap (T_Healpix_Base &other)
  {
  std::swap(order_,other.order_);
  std::swap(nside_,other.nside_);
  std::swap(npface_,other.npface_);
  std::swap(ncap_,other.ncap_);
  std::swap(npix_,other.npix_);
  std::swap(fact1_,other.fact1_);
  std::swap(fact2_,other.fact2_);
  std::swap(scheme_,other.scheme_);
  }

template double T_Healpix_Base::max_pixrad() const
  {
  vec3 va,vb;
  va.set_z_phi (2./3., pi/(4*nside_));
  double t1 = 1.-1./nside_;
  t1*=t1;
  vb.set_z_phi (1-t1/3, 0);
  return v_angle(va,vb);
  }

template double T_Healpix_Base::max_pixrad(I ring) const
  {
  if (ring>=2*nside_) ring=4*nside_-ring;
  double z=ring2z(ring), z_up=ring2z(ring-1);
  vec3 mypos, uppos;
  uppos.set_z_phi(z_up,0);
  if (ring<=nside_)
    {
    mypos.set_z_phi(z,pi/(4*ring));
    double v1=v_angle(mypos,uppos);
    if (ring!=1) return v1;
    uppos.set_z_phi(ring2z(ring+1),pi/(4*(min(nside_,ring+1))));
    return max(v1,v_angle(mypos,uppos));
    }
  mypos.set_z_phi(z,0);
  double vdist=v_angle(mypos,uppos);
  double hdist=sqrt(1.-z*z)*pi/(4*nside_);
  return max(hdist,vdist);
  }

template void T_Healpix_Base::xyf2loc (double x, double y,
  int face, double &z, double &phi, double &sth, bool &have_sth) const
  {
  have_sth = false;
  double jr = jrll[face] - x - y;
  double nr;
  if (jr<1)
    {
    nr = jr;
    double tmp = nr*nr/3.;
    z = 1 - tmp;
    if (z > 0.99)
      {
      sth = std::sqrt(tmp*(2.0-tmp));
      have_sth = true;
      }
    }
  else if (jr>3)
    {
    nr = 4-jr;
    double tmp = nr*nr/3.;
    z = tmp - 1;
    if (z<-0.99)
      {
      sth = std::sqrt(tmp*(2.-tmp));
      have_sth = true;
      }
    }
  else
    {
    nr = 1;
    z = (2-jr)*2./3.;
    }

  double tmp=jpll[face]*nr+x-y;
  if (tmp<0) tmp+=8;
  if (tmp>=8) tmp-=8;
  phi = (nr<1e-15) ? 0 : (0.5*halfpi*tmp)/nr;
  }

namespace {

vec3 locToVec3 (double z, double phi, double sth, bool have_sth)
  {
  if (have_sth)
    return vec3(sth*cos(phi),sth*sin(phi),z);
  else
    {
    vec3 res;
    res.set_z_phi (z, phi);
    return res;
    }
  }

} // unnamed namespace

template void T_Healpix_Base::boundaries(I pix, tsize step,
  vector &out) const
  {
  out.resize(4*step);
  int ix, iy, face;
  pix2xyf(pix, ix, iy, face);
  double dc = 0.5 / nside_;
  double xc = (ix + 0.5)/nside_, yc = (iy + 0.5)/nside_;
  double d = 1.0/(step*nside_);
  for (tsize i=0; i arr T_Healpix_Base::swap_cycles() const
  {
  planck_assert(order_>=0, "need hierarchical map");
  planck_assert(order_<=13, "map too large");
  arr result(swap_clen[order_]);
  tsize ofs=0;
  for (int m=0; m;
template class T_Healpix_Base;
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_base.h0000664000175000017500000004116413010375061027375 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file healpix_base.h
 *  Copyright (C) 2003-2014 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef HEALPIX_BASE_H
#define HEALPIX_BASE_H

#include 
#include "healpix_tables.h"
#include "pointing.h"
#include "arr.h"
#include "rangeset.h"

template struct Orderhelper__ {};
template<> struct Orderhelper__ {enum{omax=13};};
template<> struct Orderhelper__ {enum{omax=29};};

/*! Functionality related to the HEALPix pixelisation. */
template class T_Healpix_Base: public Healpix_Tables
  {
  protected:
    /*! The order of the map; -1 for nonhierarchical map. */
    int order_;
    /*! The N_side parameter of the map; 0 if not allocated. */
    I nside_;
    I npface_, ncap_, npix_;
    double fact1_, fact2_;
    /*! The map's ordering scheme. */
    Healpix_Ordering_Scheme scheme_;

    /*! Returns the number of the next ring to the north of \a z=cos(theta).
        It may return 0; in this case \a z lies north of all rings. */
    inline I ring_above (double z) const;
    void in_ring (I iz, double phi0, double dphi, rangeset &pixset) const;

    template void query_multidisc (const arr &norm,
      const arr &rad, int fact, rangeset &pixset) const;

    void query_multidisc_general (const arr &norm, const arr &rad,
      bool inclusive, const std::vector &cmds, rangeset &pixset) const;

    void query_strip_internal (double theta1, double theta2, bool inclusive,
      rangeset &pixset) const;

    inline I spread_bits (int v) const;
    inline int compress_bits (I v) const;

    I xyf2nest(int ix, int iy, int face_num) const;
    void nest2xyf(I pix, int &ix, int &iy, int &face_num) const;
    I xyf2ring(int ix, int iy, int face_num) const;
    void ring2xyf(I pix, int &ix, int &iy, int &face_num) const;

    I loc2pix (double z, double phi, double sth, bool have_sth) const;
    void pix2loc (I pix, double &z, double &phi, double &sth, bool &have_sth)
      const;

    void xyf2loc(double x, double y, int face, double &z, double &ph,
      double &sth, bool &have_sth) const;

    I nest_peano_helper (I pix, int dir) const;

    typedef I (T_Healpix_Base::*swapfunc)(I pix) const;

  public:
    enum {order_max=Orderhelper__::omax};

    /*! Calculates the map order from its \a N_side parameter.
        Returns -1 if \a nside is not a power of 2.
        \param nside the \a N_side parameter */
    static int nside2order (I nside);
    /*! Calculates the \a N_side parameter from the number of pixels.
        \param npix the number of pixels */
    static I npix2nside (I npix);
    /*! Constructs an unallocated object. */
    T_Healpix_Base ();
    /*! Constructs an object with a given \a order and the ordering
        scheme \a scheme. */
    T_Healpix_Base (int order, Healpix_Ordering_Scheme scheme)
      { Set (order, scheme); }
    /*! Constructs an object with a given \a nside and the ordering
        scheme \a scheme. The \a nside_dummy parameter must be set to
        SET_NSIDE. */
    T_Healpix_Base (I nside, Healpix_Ordering_Scheme scheme, const nside_dummy)
      { SetNside (nside, scheme); }

    /*! Adjusts the object to \a order and \a scheme. */
    void Set (int order, Healpix_Ordering_Scheme scheme);
    /*! Adjusts the object to \a nside and \a scheme. */
    void SetNside (I nside, Healpix_Ordering_Scheme scheme);

    /*! Returns the z-coordinate of the ring \a ring. This also works
        for the (not really existing) rings 0 and 4*nside. */
    double ring2z (I ring) const;
    /*! Returns the number of the ring in which \a pix lies. */
    I pix2ring (I pix) const;

    I xyf2pix(int ix, int iy, int face_num) const
      {
      return (scheme_==RING) ?
        xyf2ring(ix,iy,face_num) : xyf2nest(ix,iy,face_num);
      }
    void pix2xyf(I pix, int &ix, int &iy, int &face_num) const
      {
      (scheme_==RING) ?
        ring2xyf(pix,ix,iy,face_num) : nest2xyf(pix,ix,iy,face_num);
      }

    /*! Translates a pixel number from NEST to RING. */
    I nest2ring (I pix) const;
    /*! Translates a pixel number from RING to NEST. */
    I ring2nest (I pix) const;
    /*! Translates a pixel number from NEST to its Peano index. */
    I nest2peano (I pix) const;
    /*! Translates a pixel number from its Peano index to NEST. */
    I peano2nest (I pix) const;

    /*! Returns the number of the pixel which contains the angular coordinates
        (\a z:=cos(theta), \a phi).
        \note This method is inaccurate near the poles at high resolutions. */
    I zphi2pix (double z, double phi) const
      { return loc2pix(z,phi,0.,false); }

    /*! Returns the number of the pixel which contains the angular coordinates
        \a ang. */
    I ang2pix (const pointing &ang) const
      {
      const double pi_=3.141592653589793238462643383279502884197;
      planck_assert((ang.theta>=0)&&(ang.theta<=pi_),"invalid theta value");
      return ((ang.theta<0.01) || (ang.theta > 3.14159-0.01)) ?
        loc2pix(cos(ang.theta),ang.phi,sin(ang.theta),true) :
        loc2pix(cos(ang.theta),ang.phi,0.,false);
      }
    /*! Returns the number of the pixel which contains the vector \a vec
        (\a vec is normalized if necessary). */
    I vec2pix (const vec3 &vec) const
      {
      double xl = 1./vec.Length();
      double phi = safe_atan2(vec.y,vec.x);
      double nz = vec.z*xl;
      if (std::abs(nz)>0.99)
        return loc2pix (nz,phi,sqrt(vec.x*vec.x+vec.y*vec.y)*xl,true);
      else
        return loc2pix (nz,phi,0,false);
      }

    /*! Returns the angular coordinates (\a z:=cos(theta), \a phi) of the center
        of the pixel with number \a pix.
        \note This method is inaccurate near the poles at high resolutions. */
    void pix2zphi (I pix, double &z, double &phi) const
      {
      bool dum_b;
      double dum_d;
      pix2loc(pix,z,phi,dum_d,dum_b);
      }

    /*! Returns the angular coordinates of the center of the pixel with
        number \a pix. */
    pointing pix2ang (I pix) const
      {
      double z, phi, sth;
      bool have_sth;
      pix2loc (pix,z,phi,sth,have_sth);
      return have_sth ? pointing(atan2(sth,z),phi) : pointing(acos(z),phi);
      }
    /*! Returns the vector to the center of the pixel with number \a pix. */
    vec3 pix2vec (I pix) const
      {
      double z, phi, sth;
      bool have_sth;
      pix2loc (pix,z,phi,sth,have_sth);
      if (have_sth)
        return vec3(sth*cos(phi),sth*sin(phi),z);
      else
        {
        vec3 res;
        res.set_z_phi (z, phi);
        return res;
        }
      }
    /*! Returns the pixel number for this T_Healpix_Base corresponding to the
        pixel number \a pix in \a b.
        \note \a b.Nside()\%Nside() must be 0. */
    I pixel_import (I pix, const T_Healpix_Base &b) const
      {
      I ratio = b.nside_/nside_;
      planck_assert(nside_*ratio==b.nside_,"bad nside ratio");
      int x, y, f;
      b.pix2xyf(pix, x, y, f);
      x/=ratio; y/=ratio;
      return xyf2pix(x, y, f);
      }

    template void query_disc_internal (pointing ptg, double radius,
      int fact, rangeset &pixset) const;

    /*! Returns the range set of all pixels whose centers lie within the disk
        defined by \a dir and \a radius.
        \param dir the angular coordinates of the disk center
        \param radius the radius (in radians) of the disk
        \param pixset a \a rangeset object containing the indices of all pixels
           whose centers lie inside the disk
        \note This method is more efficient in the RING scheme. */
    void query_disc (pointing ptg, double radius, rangeset &pixset) const;
    /*! Returns the range set of all pixels which overlap with the disk
        defined by \a dir and \a radius.
        \param dir the angular coordinates of the disk center
        \param radius the radius (in radians) of the disk
        \param pixset a \a rangeset object containing the indices of all pixels
           overlapping with the disk.
        \param fact The overlapping test will be done at the resolution
           \a fact*nside. For NESTED ordering, \a fact must be a power of 2,
           else it can be any positive integer. A typical choice would be 4.
        \note This method may return some pixels which don't overlap with
           the disk at all. The higher \a fact is chosen, the fewer false
           positives are returned, at the cost of increased run time.
        \note This method is more efficient in the RING scheme. */
    void query_disc_inclusive (pointing ptg, double radius, rangeset &pixset,
      int fact=1) const;

    /*! \deprecated Please use the version based on \a rangeset */
    void query_disc (const pointing &dir, double radius,
      std::vector &listpix) const
      {
      rangeset pixset;
      query_disc(dir,radius,pixset);
      pixset.toVector(listpix);
      }
    /*! \deprecated Please use the version based on \a rangeset */
    void query_disc_inclusive (const pointing &dir, double radius,
      std::vector &listpix, int fact=1) const
      {
      rangeset pixset;
      query_disc_inclusive(dir,radius,pixset,fact);
      pixset.toVector(listpix);
      }

    template void query_polygon_internal
      (const std::vector &vertex, int fact,
      rangeset &pixset) const;

    /*! Returns a range set of pixels whose centers lie within the convex
        polygon defined by the \a vertex array.
        \param vertex array containing the vertices of the polygon.
        \param pixset a \a rangeset object containing the indices of all pixels
           whose centers lie inside the polygon
        \note This method is more efficient in the RING scheme. */
    void query_polygon (const std::vector &vertex,
      rangeset &pixset) const;

    /*! Returns a range set of pixels which overlap with the convex
        polygon defined by the \a vertex array.
        \param vertex array containing the vertices of the polygon.
        \param pixset a \a rangeset object containing the indices of all pixels
           overlapping with the polygon.
        \param fact The overlapping test will be done at the resolution
           \a fact*nside. For NESTED ordering, \a fact must be a power of 2,
           else it can be any positive integer. A typical choice would be 4.
        \note This method may return some pixels which don't overlap with
           the polygon at all. The higher \a fact is chosen, the fewer false
           positives are returned, at the cost of increased run time.
        \note This method is more efficient in the RING scheme. */
    void query_polygon_inclusive (const std::vector &vertex,
      rangeset &pixset, int fact=1) const;

    /*! Returns a range set of pixels whose centers lie within the colatitude
        range defined by \a theta1 and \a theta2 (if \a inclusive==false), or
        which overlap with this region (if \a inclusive==true). If
        \a theta1 &pixset) const;

    /*! Returns useful information about a given ring of the map.
        \param ring the ring number (the number of the first ring is 1)
        \param startpix the number of the first pixel in the ring
               (NOTE: this is always given in the RING numbering scheme!)
        \param ringpix the number of pixels in the ring
        \param costheta the cosine of the colatitude of the ring
        \param sintheta the sine of the colatitude of the ring
        \param shifted if \a true, the center of the first pixel is not at
               \a phi=0 */
    void get_ring_info (I ring, I &startpix, I &ringpix,
      double &costheta, double &sintheta, bool &shifted) const;
    /*! Returns useful information about a given ring of the map.
        \param ring the ring number (the number of the first ring is 1)
        \param startpix the number of the first pixel in the ring
               (NOTE: this is always given in the RING numbering scheme!)
        \param ringpix the number of pixels in the ring
        \param theta the colatitude (in radians) of the ring
        \param shifted if \a true, the center of the first pixel is not at
               \a phi=0 */
    void get_ring_info2 (I ring, I &startpix, I &ringpix,
      double &theta, bool &shifted) const;
    /*! Returns useful information about a given ring of the map.
        \param ring the ring number (the number of the first ring is 1)
        \param startpix the number of the first pixel in the ring
               (NOTE: this is always given in the RING numbering scheme!)
        \param ringpix the number of pixels in the ring
        \param shifted if \a true, the center of the first pixel is not at
               \a phi=0 */
    void get_ring_info_small (I ring, I &startpix, I &ringpix,
        bool &shifted) const;
    /*! Returns the neighboring pixels of \a pix in \a result.
        On exit, \a result contains (in this order)
        the pixel numbers of the SW, W, NW, N, NE, E, SE and S neighbor
        of \a pix. If a neighbor does not exist (this can only be the case
        for the W, N, E and S neighbors), its entry is set to -1.

        \note This method works in both RING and NEST schemes, but is
          considerably faster in the NEST scheme. */
    void neighbors (I pix, fix_arr &result) const;
    /*! Returns interpolation information for the direction \a ptg.
        The surrounding pixels are returned in \a pix, their corresponding
        weights in \a wgt.
        \note This method works in both RING and NEST schemes, but is
          considerably faster in the RING scheme. */
    void get_interpol (const pointing &ptg, fix_arr &pix,
                       fix_arr &wgt) const;

    /*! Returns the order parameter of the object. */
    int Order() const { return order_; }
    /*! Returns the \a N_side parameter of the object. */
    I Nside() const { return nside_; }
    /*! Returns the number of pixels of the object. */
    I Npix() const { return npix_; }
    /*! Returns the ordering scheme of the object. */
    Healpix_Ordering_Scheme Scheme() const { return scheme_; }

    /*! Returns \a true, if both objects have the same nside and scheme,
        else \a false. */
    bool conformable (const T_Healpix_Base &other) const
      { return ((nside_==other.nside_) && (scheme_==other.scheme_)); }

    /*! Swaps the contents of two Healpix_Base objects. */
    void swap (T_Healpix_Base &other);

    /*! Returns the maximum angular distance (in radian) between any pixel
        center and its corners. */
    double max_pixrad() const;

    /*! Returns the maximum angular distance (in radian) between any pixel
        center and its corners in a given ring. */
    double max_pixrad(I ring) const;

    /*! Returns a set of points along the boundary of the given pixel.
        \a step=1 gives 4 points on the corners. The first point corresponds
        to the northernmost corner, the subsequent points follow the pixel
        boundary through west, south and east corners.
        \param pix pixel index number
        \param step the number of returned points is 4*step. */
    void boundaries (I pix, tsize step, std::vector &out) const;

    arr swap_cycles() const;
  };

/*! T_Healpix_Base for Nside up to 2^13. */
typedef T_Healpix_Base Healpix_Base;
/*! T_Healpix_Base for Nside up to 2^29. */
typedef T_Healpix_Base Healpix_Base2;

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_data_io.cc0000664000175000017500000000625713010375061030225 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003, 2005, 2009 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "healpix_data_io.h"
#include "arr.h"
#include "fitshandle.h"
#include "paramfile.h"
#include "string_utils.h"

using namespace std;

void read_weight_ring (const string &dir, int nside, arr &weight)
  {
  fitshandle inp;
  inp.open(dir+"/weight_ring_n"+intToString(nside,5)+".fits");
  inp.goto_hdu(2);
  weight.alloc (2*nside);
  inp.read_column(1,weight);
  }

void get_ring_weights (paramfile ¶ms, int nside, arr &weight)
  {
  bool weighted = params.find("weighted",false);
  weight.alloc (2*nside);
  if (weighted)
    {
    string datadir = params.find("healpix_data");
    read_weight_ring (datadir, nside, weight);
    for (tsize m=0; m &temp)
  {
  fitshandle inp;
  inp.open(dir+"/pixel_window_n"+intToString(nside,4)+".fits");
  inp.goto_hdu(2);
  if (temp.size()==0)
    inp.read_entire_column(1,temp);
  else
    inp.read_column(1,temp);
  }
void read_pixwin (const string &dir, int nside, arr &temp,
  arr &pol)
  {
  fitshandle inp;
  inp.open(dir+"/pixel_window_n"+intToString(nside,4)+".fits");
  inp.goto_hdu(2);
  if (temp.size()==0)
    inp.read_entire_column(1,temp);
  else
    inp.read_column(1,temp);
  if (pol.size()==0)
    inp.read_entire_column(2,pol);
  else
    inp.read_column(2,pol);
  }

void get_pixwin (paramfile ¶ms, int lmax, int nside, arr &pixwin)
  {
  bool do_pixwin = params.find("pixel_window",false);
  pixwin.alloc(lmax+1);
  pixwin.fill(1);
  if (do_pixwin)
    {
    string datadir = params.find("healpix_data");
    read_pixwin (datadir,nside,pixwin);
    }
  }
void get_pixwin (paramfile ¶ms, int lmax, int nside, arr &pixwin,
  arr &pixwin_pol)
  {
  bool do_pixwin = params.find("pixel_window",false);
  pixwin.alloc(lmax+1);
  pixwin.fill(1);
  pixwin_pol.alloc(lmax+1);
  pixwin_pol.fill(1);
  if (do_pixwin)
    {
    string datadir = params.find("healpix_data");
    read_pixwin (datadir,nside,pixwin,pixwin_pol);
    }
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_data_io.h0000664000175000017500000000332513010375061030060 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003, 2005 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#ifndef HEALPIX_DATA_IO_H
#define HEALPIX_DATA_IO_H

#include 

class paramfile;
template class arr;

void read_weight_ring (const std::string &dir, int nside, arr &weight);
void get_ring_weights (paramfile ¶ms, int nside, arr &weight);

void read_pixwin (const std::string &dir, int nside, arr &temp);
void read_pixwin (const std::string &dir, int nside, arr &temp,
  arr &pol);

void get_pixwin (paramfile ¶ms, int lmax, int nside, arr &pixwin);
void get_pixwin (paramfile ¶ms, int lmax, int nside, arr &pixwin,
  arr &pixwin_pol);

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_map.cc0000664000175000017500000000525013010375061027372 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2013 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "healpix_map.h"

using namespace std;

template void Healpix_Map::Import_degrade
  (const Healpix_Map &orig, bool pessimistic)
  {
  planck_assert(nside_ adder;
    for (int j=fact*y; j(orig.map[opix],Healpix_undef))
          {
          ++hits;
          adder.add(orig.map[opix]);
          }
        }
    map[m] = T((hits::Import_degrade
  (const Healpix_Map &orig, bool pessimistic);
template void Healpix_Map::Import_degrade
  (const Healpix_Map &orig, bool pessimistic);

template void Healpix_Map::minmax (T &Min, T &Max) const
  {
  Min = T(1e30); Max = T(-1e30);
  for (int m=0; m(val,Healpix_undef))
      {
      if (val>Max) Max=val;
      if (val::minmax (float &Min, float &Max) const;
template void Healpix_Map::minmax (double &Min, double &Max) const;
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_map.h0000664000175000017500000002431113010375061027233 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file healpix_map.h
 *  Copyright (C) 2003-2013 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef HEALPIX_MAP_H
#define HEALPIX_MAP_H

#include "arr.h"
#include "healpix_base.h"

//! Healpix value representing "undefined"
const double Healpix_undef=-1.6375e30;

/*! A HEALPix map of a given datatype */
template class Healpix_Map: public Healpix_Base
  {
  private:
    arr map;

  public:
    /*! Constructs an unallocated map. */
    Healpix_Map () {}
    /*! Constructs a map with a given \a order and the ordering
        scheme \a scheme. */
    Healpix_Map (int order, Healpix_Ordering_Scheme scheme)
      : Healpix_Base (order, scheme), map(npix_) {}
    /*! Constructs a map with a given \a nside and the ordering
        scheme \a scheme. */
    Healpix_Map (int nside, Healpix_Ordering_Scheme scheme, const nside_dummy)
      : Healpix_Base (nside, scheme, SET_NSIDE), map(npix_) {}
    /*! Constructs a map from the contents of \a data and sets the ordering
        scheme to \a Scheme. The size of \a data must be a valid HEALPix
        map size. */
    Healpix_Map (const arr &data, Healpix_Ordering_Scheme scheme)
      : Healpix_Base (npix2nside(data.size()), scheme, SET_NSIDE), map(data) {}

    /*! Deletes the old map, creates a map from the contents of \a data and
        sets the ordering scheme to \a scheme. The size of \a data must be a
        valid HEALPix map size.
        \note On exit, \a data is zero-sized! */
    void Set (arr &data, Healpix_Ordering_Scheme scheme)
      {
      Healpix_Base::SetNside(npix2nside (data.size()), scheme);
      map.transfer(data);
      }

    /*! Deletes the old map and creates a new map  with a given \a order
        and the ordering scheme \a scheme. */
    void Set (int order, Healpix_Ordering_Scheme scheme)
      {
      Healpix_Base::Set(order, scheme);
      map.alloc(npix_);
      }
    /*! Deletes the old map and creates a new map  with a given \a nside
        and the ordering scheme \a scheme. */
    void SetNside (int nside, Healpix_Ordering_Scheme scheme)
      {
      Healpix_Base::SetNside(nside, scheme);
      map.alloc(npix_);
      }

    /*! Fills the map with \a val. */
    void fill (const T &val)
      { map.fill(val); }

    /*! Imports the map \a orig into the current map, adjusting the
        ordering scheme. \a orig must have the same resolution as the
        current map. */
    void Import_nograde (const Healpix_Map &orig)
      {
      planck_assert (nside_==orig.nside_,
        "Import_nograde: maps have different nside");
      if (orig.scheme_ == scheme_)
        for (int m=0; m*swapper)(m)] = orig.map[m];
}
        }
      }

    /*! Imports the map \a orig into the current map, adjusting the
        ordering scheme and the map resolution. \a orig must have lower
        resolution than the current map, and \a this->Nside() must be an
        integer multiple of \a orig.Nside(). */
    void Import_upgrade (const Healpix_Map &orig)
      {
      planck_assert(nside_>orig.nside_,"Import_upgrade: this is no upgrade");
      int fact = nside_/orig.nside_;
      planck_assert (nside_==orig.nside_*fact,
        "the larger Nside must be a multiple of the smaller one");

#pragma omp parallel
{
      int m;
#pragma omp for schedule (dynamic,5000)
      for (m=0; mNside().
        \a pessimistic determines whether or not
        pixels are set to \a Healpix_undef when not all of the corresponding
        high-resolution pixels are defined.

        This method is instantiated for \a float and \a double only. */
    void Import_degrade (const Healpix_Map &orig, bool pessimistic=false);

    /*! Imports the map \a orig into the current map, adjusting the
        ordering scheme and the map resolution if necessary.
        When downgrading, \a pessimistic determines whether or not
        pixels are set to \a Healpix_undef when not all of the corresponding
        high-resolution pixels are defined.

        This method is instantiated for \a float and \a double only. */
    void Import (const Healpix_Map &orig, bool pessimistic=false)
      {
      if (orig.nside_ == nside_) // no up/degrading
        Import_nograde(orig);
      else if (orig.nside_ < nside_) // upgrading
        Import_upgrade(orig);
      else
        Import_degrade(orig,pessimistic);
      }

    /*! Returns a constant reference to the pixel with the number \a pix. */
    const T &operator[] (int pix) const { return map[pix]; }
    /*! Returns a reference to the pixel with the number \a pix. */
    T &operator[] (int pix) { return map[pix]; }

    /*! Swaps the map ordering from RING to NEST and vice versa.
        This is done in-place (i.e. with negligible space overhead). */
    void swap_scheme()
      {
      swapfunc swapper = (scheme_ == NEST) ?
        &Healpix_Base::ring2nest : &Healpix_Base::nest2ring;

      arr cycle=swap_cycles();

      for (tsize m=0; m*swapper)(istart);
        while (inew != istart)
          {
          map[iold] = map[inew];
          iold = inew;
          inew = (this->*swapper)(inew);
          }
        map[iold] = pixbuf;
        }
      scheme_ = (scheme_==RING) ? NEST : RING;
      }

    /*! performs the actual interpolation using \a pix and \a wgt. */
    T interpolation (const fix_arr &pix,
      const fix_arr &wgt) const
      {
      double wtot=0;
      T res=T(0);
      for (tsize i=0; i<4; ++i)
        {
        T val=map[pix[i]];
        if (!approx(val,Healpix_undef))
          { res+=T(val*wgt[i]); wtot+=wgt[i]; }
        }
      return (wtot==0.) ? T(Healpix_undef) : T(res/wtot);
      }
    /*! Returns the interpolated map value at \a ptg */
    T interpolated_value (const pointing &ptg) const
      {
      fix_arr pix;
      fix_arr wgt;
      get_interpol (ptg, pix, wgt);
      return interpolation (pix, wgt);
      }

    /*! Returns a constant reference to the map data. */
    const arr &Map() const { return map; }

    /*! Returns the minimum and maximum value of the map in
        \a Min and \a Max.

        This method is instantiated for \a float and \a double only. */
    void minmax (T &Min, T &Max) const;

    /*! Swaps the contents of two Healpix_Map objects. */
    void swap (Healpix_Map &other)
      {
      Healpix_Base::swap(other);
      map.swap(other.map);
      }

    /*! Returns the average of all defined map pixels. */
    double average() const
      {
      kahan_adder adder;
      int pix=0;
      for (int m=0; m(map[m],Healpix_undef))
          { ++pix; adder.add(map[m]); }
      return (pix>0) ? adder.result()/pix : Healpix_undef;
      }

    /*! Adds \a val to all defined map pixels. */
    void Add (T val)
      {
      for (int m=0; m(map[m],Healpix_undef))
          { map[m]+=val; }
      }

    /*! Multiplies all defined map pixels by \a val. */
    void Scale (T val)
      {
      for (int m=0; m(map[m],Healpix_undef))
          { map[m]*=val; }
      }

    /*! Returns the root mean square of the map, not counting undefined
        pixels. */
    double rms() const
      {
      using namespace std;

      double result=0;
      int pix=0;
      for (int m=0; m(map[m],Healpix_undef))
          { ++pix; result+=map[m]*map[m]; }
      return (pix>0) ? sqrt(result/pix) : Healpix_undef;
      }
    /*! Returns the maximum absolute value in the map, ignoring undefined
        pixels. */
    T absmax() const
      {
      using namespace std;

      T result=0;
      for (int m=0; m(map[m],Healpix_undef))
          { result = max(result,abs(map[m])); }
      return result;
      }
    /*! Returns \a true, if no pixel has the value \a Healpix_undef,
        else \a false. */
    bool fullyDefined() const
      {
      for (int m=0; m(map[m],Healpix_undef))
          return false;
      return true;
      }
    /*! Sets all pixels with the value \a Healpix_undef to 0, and returns
        the number of modified pixels. */
    tsize replaceUndefWith0()
      {
      tsize res=0;
      for (int m=0; m(map[m],Healpix_undef))
          { map[m]=0.; ++res; }
      return res;
      }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_map_fitsio.cc0000664000175000017500000001546513010375061030760 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "healpix_map_fitsio.h"
#include "healpix_map.h"
#include "fitshandle.h"
#include "share_utils.h"
#include "string_utils.h"

using namespace std;

namespace {

unsigned int healpix_repcount (tsize npix)
  {
  if (npix<1024) return 1;
  if ((npix%1024)==0) return 1024;
  return isqrt (npix/12);
  }

} // unnamed namespace

template void read_Healpix_map_from_fits
  (fitshandle &inp, Healpix_Map &map, int colnum)
  {
  arr myarr;
  inp.read_entire_column (colnum, myarr);
  int64 nside = inp.get_key("NSIDE");
  planck_assert (int64(myarr.size())==12*nside*nside,
    string("mismatch between number of map pixels ("
    +dataToString(myarr.size())+") and Nside ("+dataToString(nside)+")"));
  map.Set (myarr, string2HealpixScheme(inp.get_key("ORDERING")));
  }

template void read_Healpix_map_from_fits (fitshandle &inp,
  Healpix_Map &map, int colnum);
template void read_Healpix_map_from_fits (fitshandle &inp,
  Healpix_Map &map, int colnum);
template void read_Healpix_map_from_fits (fitshandle &inp,
  Healpix_Map &map, int colnum);


template void read_Healpix_map_from_fits
  (const string &filename, Healpix_Map &map, int colnum, int hdunum)
  {
  fitshandle inp;
  inp.open (filename);
  inp.goto_hdu (hdunum);
  read_Healpix_map_from_fits (inp,map,colnum);
  }

template void read_Healpix_map_from_fits (const string &filename,
  Healpix_Map &map, int colnum, int hdunum);
template void read_Healpix_map_from_fits (const string &filename,
  Healpix_Map &map, int colnum, int hdunum);
template void read_Healpix_map_from_fits (const string &filename,
  Healpix_Map &map, int colnum, int hdunum);

template void read_Healpix_map_from_fits
  (fitshandle &inp, Healpix_Map &mapT, Healpix_Map &mapQ,
  Healpix_Map &mapU)
  {
  int64 nside = inp.get_key("NSIDE");
  Healpix_Ordering_Scheme scheme
    = string2HealpixScheme(inp.get_key("ORDERING"));
  mapT.SetNside(nside,scheme);
  mapQ.SetNside(nside,scheme);
  mapU.SetNside(nside,scheme);
  planck_assert (multiequal(int64(mapT.Npix()),inp.nelems(1),inp.nelems(2),
    inp.nelems(3)), "mismatch between number of map pixels and Nside");
  chunkMaker cm(mapT.Npix(),inp.efficientChunkSize(1));
  uint64 offset,ppix;
  while(cm.getNext(offset,ppix))
    {
    inp.read_column_raw(1,&mapT[offset],ppix,offset);
    inp.read_column_raw(2,&mapQ[offset],ppix,offset);
    inp.read_column_raw(3,&mapU[offset],ppix,offset);
    }
  }

template void read_Healpix_map_from_fits (fitshandle &inp,
  Healpix_Map &mapT, Healpix_Map &mapQ,
  Healpix_Map &mapU);
template void read_Healpix_map_from_fits (fitshandle &inp,
  Healpix_Map &mapT, Healpix_Map &mapQ,
  Healpix_Map &mapU);

template void read_Healpix_map_from_fits
  (const string &filename, Healpix_Map &mapT, Healpix_Map &mapQ,
  Healpix_Map &mapU, int hdunum)
  {
  fitshandle inp;
  inp.open(filename);
  inp.goto_hdu(hdunum);
  read_Healpix_map_from_fits (inp,mapT,mapQ,mapU);
  }

template void read_Healpix_map_from_fits (const string &filename,
  Healpix_Map &mapT, Healpix_Map &mapQ,
  Healpix_Map &mapU, int hdunum);
template void read_Healpix_map_from_fits (const string &filename,
  Healpix_Map &mapT, Healpix_Map &mapQ,
  Healpix_Map &mapU, int hdunum);

void prepare_Healpix_fitsmap
  (fitshandle &out, const Healpix_Base &base, PDT datatype,
  const arr &colname)
  {
  vector cols;
  int repcount = healpix_repcount (base.Npix());
  for (tsize m=0; m void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &map, PDT datatype)
  {
  arr colname(1);
  colname[0] = "signal";
  prepare_Healpix_fitsmap (out, map, datatype, colname);
  out.write_column(1,map.Map());
  }

template void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &map, PDT datatype);
template void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &map, PDT datatype);
template void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &map, PDT datatype);


template void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &mapT,
   const Healpix_Map &mapQ, const Healpix_Map &mapU, PDT datatype)
  {
  arr colname(3);
  colname[0] = "signal";
  colname[1] = "Q-pol";
  colname[2] = "U-pol";
  prepare_Healpix_fitsmap (out, mapT, datatype, colname);
  chunkMaker cm(mapT.Npix(),out.efficientChunkSize(1));
  uint64 offset,ppix;
  while(cm.getNext(offset,ppix))
    {
    out.write_column_raw(1,&mapT[offset],ppix,offset);
    out.write_column_raw(2,&mapQ[offset],ppix,offset);
    out.write_column_raw(3,&mapU[offset],ppix,offset);
    }
  }

template void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &mapT,
   const Healpix_Map &mapQ, const Healpix_Map &mapU,
   PDT datatype);
template void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &mapT,
   const Healpix_Map &mapQ, const Healpix_Map &mapU,
   PDT datatype);
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_map_fitsio.h0000664000175000017500000001001713010375061030606 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file healpix_map_fitsio.h
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef HEALPIX_MAP_FITSIO_H
#define HEALPIX_MAP_FITSIO_H

#include 
#include "datatypes.h"
#include "fitshandle.h"
#include "healpix_base.h"

template class arr;
template class Healpix_Map;

/*! \defgroup healpix_map_fitsio_group FITS-based I/O of HEALPix maps */
/*! \{ */

/*! Reads the map stored in column \a colnum of the FITS binary table
    pointed to by \a inp into \a map. */
template void read_Healpix_map_from_fits
  (fitshandle &inp, Healpix_Map &map, int colnum=1);
/*! Opens the FITS file \a filename, jumps to the HDU \a hdunum,
    and reads the column \a colnum into \a map. */
template void read_Healpix_map_from_fits
  (const std::string &filename, Healpix_Map &map, int colnum=1,
  int hdunum=2);

template void read_Healpix_map_from_fits
  (fitshandle &inp, Healpix_Map &mapT, Healpix_Map &mapQ,
  Healpix_Map &mapU);
template void read_Healpix_map_from_fits
  (const std::string &filename, Healpix_Map &mapT, Healpix_Map &mapQ,
  Healpix_Map &mapU, int hdunum=2);

/*! Inserts a new binary table into \a out, which contains one column
    of Planck type \a datatype with the name \a name, and writes all HEALPix
    specific keywords based on the information in \a base. */
void prepare_Healpix_fitsmap
  (fitshandle &out, const Healpix_Base &base, PDT datatype,
  const arr &colname);

/*! Inserts a new binary table into \a out, which contains one column
    of Planck type \a datatype, and stores \a map into this column. */
template void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &map, PDT datatype);
/*! Inserts a new binary table into \a out, which contains three columns
    of Planck type \a datatype, and stores \a mapT, \a mapQ and \a mapU
    into these columns. */
template void write_Healpix_map_to_fits
  (fitshandle &out, const Healpix_Map &mapT,
   const Healpix_Map &mapQ, const Healpix_Map &mapU, PDT datatype);

/*! Creates a new FITS file with the name \a outfile, with a binary table in
    HDU 2, which contains one column of Planck type \a datatype, and stores
    \a map into this column. */
template inline void write_Healpix_map_to_fits
  (const std::string &outfile, const Healpix_Map &map, PDT datatype)
  {
  fitshandle out;
  out.create (outfile);
  write_Healpix_map_to_fits (out,map,datatype);
  }
/*! Creates a new FITS file with the name \a outfile, with a binary table in
    HDU 2, which contains three columns of Planck type \a datatype, and stores
    \a mapT, \a mapQ and \a mapU into this column. */
template inline void write_Healpix_map_to_fits
  (const std::string &outfile, const Healpix_Map &mapT,
   const Healpix_Map &mapQ, const Healpix_Map &mapU, PDT datatype)
  {
  fitshandle out;
  out.create (outfile);
  write_Healpix_map_to_fits (out,mapT,mapQ,mapU,datatype);
  }

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_tables.cc0000664000175000017500000001325613010375061030074 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2011-2014 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "healpix_tables.h"
#include "string_utils.h"

using namespace std;

const nside_dummy SET_NSIDE=nside_dummy();

Healpix_Ordering_Scheme string2HealpixScheme (const string &inp)
  {
  string tmp=trim(inp);
  if (equal_nocase(tmp,"RING")) return RING;
  if (equal_nocase(tmp,"NESTED")) return NEST;
  planck_fail ("bad Healpix ordering scheme '"+tmp+
               "': expected 'RING' or 'NESTED'");
  }

const uint16 Healpix_Tables::utab[] = {
#define Z(a) 0x##a##0, 0x##a##1, 0x##a##4, 0x##a##5
#define Y(a) Z(a##0), Z(a##1), Z(a##4), Z(a##5)
#define X(a) Y(a##0), Y(a##1), Y(a##4), Y(a##5)
X(0),X(1),X(4),X(5)
#undef X
#undef Y
#undef Z
};

const uint16 Healpix_Tables::ctab[] = {
#define Z(a) a,a+1,a+256,a+257
#define Y(a) Z(a),Z(a+2),Z(a+512),Z(a+514)
#define X(a) Y(a),Y(a+4),Y(a+1024),Y(a+1028)
X(0),X(8),X(2048),X(2056)
#undef X
#undef Y
#undef Z
};

const int Healpix_Tables::jrll[] = { 2,2,2,2,3,3,3,3,4,4,4,4 },
          Healpix_Tables::jpll[] = { 1,3,5,7,0,2,4,6,1,3,5,7 };

const uint8 Healpix_Tables::peano_arr2[] = {
        0, 35, 65, 66, 68,  5,103,  6,110,109, 15, 44, 72,  9,107, 10,
       31,126, 60,125, 81, 16, 82, 51,123, 88, 26, 25,119, 84, 22, 21,
       42, 75, 41,104, 12, 47, 77, 78, 38, 71, 37,100, 98, 97,  3, 32,
       53, 54,116, 87, 57, 58,120, 91, 19,114, 48,113, 93, 28, 94, 63,
       64,  1, 99,  2, 46, 79, 45,108,  4, 39, 69, 70,  8, 43, 73, 74,
       85, 20, 86, 55,115, 80, 18, 17, 89, 24, 90, 59, 61, 62,124, 95,
      106,105, 11, 40,102,101,  7, 36, 76, 13,111, 14, 34, 67, 33, 96,
      127, 92, 30, 29, 27,122, 56,121, 49, 50,112, 83, 23,118, 52,117,

      128,194,195,161,196,133,135,230,204,141,143,238,171,233,232,138,
      149,212,214,183,221,159,158,252,217,155,154,248,178,243,241,144,
      175,237,236,142,235,170,168,201,227,162,160,193,132,198,199,165,
      186,251,249,152,242,176,177,211,246,180,181,215,157,220,222,191,
      192,129,131,226,136,202,203,169,140,206,207,173,231,166,164,197,
      213,151,150,244,145,208,210,179,153,216,218,187,254,188,189,223,
      239,174,172,205,167,229,228,134,163,225,224,130,200,137,139,234,
      250,184,185,219,190,255,253,156,182,247,245,148,209,147,146,240 };
const uint8 Healpix_Tables::peano_arr[] =
      { 16, 1,27, 2,31,20, 6, 5,10,19, 9,24,13,14,28,23,
         0,11,17,18,21, 4,22,15,26,25, 3, 8, 7,30,12,29,
        48,33,35,58,53,39,38,60,59,42,40,49,62,44,45,55,
        32,50,51,41,37,52,54,47,43,57,56,34,46,63,61,36 };
const uint8 Healpix_Tables::peano_face2path[2][12] =
  { { 2,5,2,5,3,6,3,6,2,3,2,3 }, { 2,6,2,3,3,5,2,6,2,3,3,5 } };
const uint8 Healpix_Tables::peano_face2face[2][12] =
  { { 0,5,6,11,10,1,4,7,2,3,8,9 }, { 0,5,8,9,6,1,2,7,10,11,4,3 } };

const int Healpix_Tables::nb_xoffset[] = { -1,-1, 0, 1, 1, 1, 0,-1 },
          Healpix_Tables::nb_yoffset[] = {  0, 1, 1, 1, 0,-1,-1,-1 };
const int Healpix_Tables::nb_facearray[][12] =
  { {  8, 9,10,11,-1,-1,-1,-1,10,11, 8, 9 },   // S
    {  5, 6, 7, 4, 8, 9,10,11, 9,10,11, 8 },   // SE
    { -1,-1,-1,-1, 5, 6, 7, 4,-1,-1,-1,-1 },   // E
    {  4, 5, 6, 7,11, 8, 9,10,11, 8, 9,10 },   // SW
    {  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11 },   // center
    {  1, 2, 3, 0, 0, 1, 2, 3, 5, 6, 7, 4 },   // NE
    { -1,-1,-1,-1, 7, 4, 5, 6,-1,-1,-1,-1 },   // W
    {  3, 0, 1, 2, 3, 0, 1, 2, 4, 5, 6, 7 },   // NW
    {  2, 3, 0, 1,-1,-1,-1,-1, 0, 1, 2, 3 } }; // N
const int Healpix_Tables::nb_swaparray[][3] =
  { { 0,0,3 },   // S
    { 0,0,6 },   // SE
    { 0,0,0 },   // E
    { 0,0,5 },   // SW
    { 0,0,0 },   // center
    { 5,0,0 },   // NE
    { 0,0,0 },   // W
    { 6,0,0 },   // NW
    { 3,0,0 } }; // N

const int Healpix_Tables::swap_clen[] =
  { 0,7,5,4,12,10,13,18,14,19,18,17,27,21 };
const int Healpix_Tables::swap_cycle[] =
  { 0,1,8,12,16,21,40,
    0,1,2,40,114,
    0,4,160,263,
    0,4,30,49,51,87,526,1027,1105,1387,1807,2637,
    0,8,10,18,39,74,146,307,452,4737,
    0,1,2,7,9,17,80,410,1526,1921,32859,33566,38931,
    0,5,6,10,12,24,27,95,372,494,924,1409,3492,4248,9137,66043,103369,156899,
    0,1,2,3,4,45,125,351,697,24337,102940,266194,341855,419857,
    0,1,2,3,9,16,1705,2082,2126,8177,12753,15410,52642,80493,83235,88387,99444,
      1675361,2495125,
    0,2,6,8,9,11,20,50,93,152,183,2137,13671,44794,486954,741908,4803258,
      5692573,
    0,1,5,6,44,53,470,2847,3433,4906,13654,14710,400447,1797382,2744492,
      18775974,23541521,
    0,4,9,10,16,33,83,117,318,451,5759,10015,128975,171834,211256,347608,
      1278690,2154097,2590798,3427694,5581717,21012301,27023976,72522811,
      95032729,139166747,171822389,
    0,5,10,267,344,363,2968,3159,9083,18437,76602,147614,1246902,1593138,
      2035574,6529391,9511830,11340287,29565945,281666026,677946848 };
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_tables.h0000664000175000017500000000364513010375061027737 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file healpix_tables.h
 *  Copyright (C) 2011-2014 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef HEALPIX_TABLES_H
#define HEALPIX_TABLES_H

#include "datatypes.h"

/*! The two possible ordering schemes of a HEALPix map. */
enum Healpix_Ordering_Scheme { RING, /*!< RING scheme */
                               NEST  /*!< NESTED scheme */
                             };

Healpix_Ordering_Scheme string2HealpixScheme (const std::string &inp);

class nside_dummy {};
extern const nside_dummy SET_NSIDE;

class Healpix_Tables
  {
  protected:
    static const uint16 ctab[], utab[];

    static const int jrll[], jpll[];

    static const uint8 peano_face2path[2][12], peano_face2face[2][12],
                       peano_arr[],peano_arr2[];

    static const int nb_xoffset[], nb_yoffset[],
                     nb_facearray[][12], nb_swaparray[][3];

    static const int swap_clen[], swap_cycle[];
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/hotspots_cxx.cc0000664000175000017500000000027713010375061027654 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  hotspots_cxx_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/hotspots_cxx_module.cc0000664000175000017500000000601313010375061031213 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2010 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include "paramfile.h"
#include "healpix_map.h"
#include "healpix_map_fitsio.h"
#include "fitshandle.h"
#include "levels_facilities.h"
#include "announce.h"

using namespace std;

int hotspots_cxx_module (int argc, const char **argv)
  {
  module_startup ("hotspots_cxx", argc, argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  string infile = params.find("infile");
  string mapfile = params.find("outmap","");
  bool have_mapfile = mapfile!="";
  string minfile = params.find("minfile","");
  bool have_minfile = minfile!="";
  string maxfile = params.find("maxfile","");
  bool have_maxfile = maxfile!="";
  planck_assert (have_mapfile || have_minfile || have_maxfile,
    "no output file specified");

  Healpix_Map inmap;
  read_Healpix_map_from_fits(infile,inmap,1,2);
  Healpix_Map outmap;
  if (have_mapfile) outmap.Set(inmap.Order(),inmap.Scheme());

  ofstream minout, maxout;
  if (have_minfile) minout.open(minfile.c_str());
  if (have_maxfile) maxout.open(maxfile.c_str());

  fix_arr nb;
// FIXME: This should be parallelized
  for (int m=0; m(value, Healpix_undef))
      {
      inmap.neighbors(m,nb);
      bool ismax=true, ismin=true;
      for (tsize n=0; n=0)
          {
          float nbval = inmap[nb[n]];
          if (!approx(nbval, Healpix_undef))
            {
            if (nbval>=value) ismax=false;
            if (nbval<=value) ismin=false;
            }
          }
        }
      if (have_mapfile)
        outmap[m] = float((ismax||ismin) ? value : Healpix_undef);
      if (have_minfile && ismin) minout << m << " " << value << endl;
      if (have_maxfile && ismax) maxout << m << " " << value << endl;
      }
    }
  if (have_mapfile)
    write_Healpix_map_to_fits (mapfile,outmap,PLANCK_FLOAT32);

  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/hpxtest.cc0000664000175000017500000012657313010375061026616 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2004-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

/*

Candidates for testing the validity of the Healpix routines:

- done: ang2pix(pix2ang(i)) = i for all Healpix_Bases
- done: pix2ang(ang2pix(ptg)) dot ptg > 1-delta for all Healpix_Bases
- done: ring2nest(nest2ring(i)) = i for all hierarchical Healpix_Bases
- done: downgrade(upgrade(map)) = map for all maps
- done: map and downgraded map should have same average
- done: alm2map(map2alm(map)) approx map (same for pol)
- partly done: neighbor tests
- powspec -> alm -> powspec (should produce similar powspecs, also for pol)
- done: two swap_schemes() should produce original map
- done: query_disc tests (dot products etc.)
- a_lms: test Set(), Scale(), Add(), alm(l,m) = alm.mstart(m)[l], etc.

*/

#include 
#include "healpix_base.h"
#include "healpix_map.h"
#include "arr.h"
#include "planck_rng.h"
#include "lsconstants.h"
#include "alm.h"
#include "alm_healpix_tools.h"
#include "alm_powspec_tools.h"
#include "geom_utils.h"
#include "walltimer.h"
#include "announce.h"
#include "compress_utils.h"
#include "moc.h"
#include "moc_fitsio.h"

using namespace std;

#define UNITTESTS

#ifdef UNITTESTS
int errcount=0;
#define FAIL(a) {a; if (++errcount>100) planck_fail("unit test errors");}
#else
#define FAIL(a) a;
#endif

const int nsamples = 1000000;

planck_rng rng;

namespace {

void random_dir (pointing &ptg)
  {
  ptg.theta = acos(rng.rand_uni()*2-1);
  ptg.phi = rng.rand_uni()*twopi;
  }
void random_zphi (double &z, double &phi)
  {
  z = rng.rand_uni()*2-1;
  phi = rng.rand_uni()*twopi;
  }

template string bname()
  { return string("(basetype: ")+type2typename()+")"; }


template rangeset randomRangeSet(int num, I start, int dist)
  {
  rangeset rs;
  I curval=start;
  for (int i=0; i Moc randomMoc(int num, I start, int dist)
  {
  Moc moc;
  I curval=start+(I(1)<<(2*Moc::maxorder));
  for (int i=0; i::maxorder,v1,v2);
    curval=v2;
    }
  return moc;
  }

template rangeset makeRS(const string &input)
  {
  istringstream is(input);
  rangeset res;
  I a,b;
  while (is)
    {
    is>>a>>b;
    planck_assert (is||is.eof(),"aargh");
    if (is) res.append(a,b);
    }
  return res;
  }
template void rsOps(const rangeset &a, const rangeset &b)
  {
  planck_assert(!b.overlaps(a.op_andnot(b)),"error");
  planck_assert(a.op_or(b).nval()>=a.nval(),"error");
  planck_assert(a.op_or(b).nval()>=b.nval(),"error");
  planck_assert(a.op_and(b).nval()<=a.nval(),"error");
  planck_assert(a.op_and(b).nval()<=b.nval(),"error");
  planck_assert(a.op_or(b).contains(a),"error");
  planck_assert(a.op_or(b).contains(b),"error");
  planck_assert(!a.op_andnot(b).overlaps(b),"error");
  planck_assert(!b.op_andnot(a).overlaps(a),"error");
  planck_assert(a.op_or(b).nval()==a.nval()+b.nval()-a.op_and(b).nval(),
    "error");
  planck_assert(a.op_or(b).op_andnot(a.op_and(b)).nval()==
                a.op_or(b).nval()-a.op_and(b).nval(),"error");
  planck_assert(a.op_xor(b)==a.op_andnot(b).op_or(b.op_andnot(a)),"error");
  }
template void check_rangeset()
  {
  cout << "testing rangeset " << bname() << endl;
  {
  rangeset b;
  b.append(1,11);
  planck_assert(b==makeRS("1 11"),"mismatch");
  b.append(10,15);
  planck_assert(b==makeRS("1 15"),"mismatch");
  b.append(1,15);
  planck_assert(b==makeRS("1 15"),"mismatch");
  b.append(7,15);
  planck_assert(b==makeRS("1 15"),"mismatch");
  b.append(30,41);
#if 0
  planck_assert(b==makeRS("1 15 30 41"),"mismatch");
  try
    {
    b.append(29,31);
    planck_fail("Should have raised an IllegalArgumentException");
    }
  catch (PlanckError E) {}
#endif
  }
  {
  rangeset b=makeRS("1 11 30 41");
  planck_assert(!b.contains(0),"error");
  planck_assert(b.contains(1),"error");
  planck_assert(b.contains(5),"error");
  planck_assert(b.contains(10),"error");
  planck_assert(!b.contains(11),"error");
  planck_assert(!b.contains(29),"error");
  planck_assert(b.contains(30),"error");
  planck_assert(b.contains(35),"error");
  planck_assert(b.contains(40),"error");
  planck_assert(!b.contains(41),"errror");
  }
  {
  rangeset b;
  b.add(5, 11);
  planck_assert(b==makeRS("5 11"),"error");
  b.add(1, 7);
  planck_assert(b==makeRS("1 11"),"error");
  b.add(1, 11);
  planck_assert(b==makeRS("1 11"),"error");
  b.add(30, 41);
  planck_assert(b==makeRS("1 11 30 41"),"error");
  b.add(1, 11);
  planck_assert(b==makeRS("1 11 30 41"),"error");
  b.add(-1,0);
  planck_assert(b==makeRS("-1 0 1 11 30 41"),"error");
  b.add(-2,-1);
  planck_assert(b==makeRS("-2 0 1 11 30 41"),"error");
  b.add(-2,-1);
  planck_assert(b==makeRS("-2 0 1 11 30 41"),"error");
  b.add(2, 11);
  planck_assert(b==makeRS("-2 0 1 11 30 41"),"error");
  b.add(1, 10);
  planck_assert(b==makeRS("-2 0 1 11 30 41"),"error");
  b.add(15, 21);
  planck_assert(b==makeRS("-2 0 1 11 15 21 30 41"),"error");
  }
  {
  rangeset b = makeRS("0 11 20 31");
  b.remove(5,25);
  planck_assert(b==makeRS("0 5 25 31"),"error");
  b.remove(31,32);
  planck_assert(b==makeRS("0 5 25 31"),"error");
  b.remove(35,38);
  planck_assert(b==makeRS("0 5 25 31"),"error");
  b.remove(-90,-80);
  planck_assert(b==makeRS("0 5 25 31"),"error");
  b.remove(27,29);
  planck_assert(b==makeRS("0 5 25 27 29 31"),"error");
  b.remove(25,26);
  planck_assert(b==makeRS("0 5 26 27 29 31"),"error");
  b.remove(4,6);
  planck_assert(b==makeRS("0 4 26 27 29 31"),"error");
  b.remove(-20,40);
  planck_assert(b==makeRS(""),"error");
  b.remove(-20,40);
  planck_assert(b==makeRS(""),"error");
  }
  {
  rangeset b = makeRS("0 11 20 31");
  b.intersect(2,29);
  planck_assert(b==makeRS("2 11 20 29"),"error");
  b.intersect(-8,50);
  planck_assert(b==makeRS("2 11 20 29"),"error");
  b.intersect(2,50);
  planck_assert(b==makeRS("2 11 20 29"),"error");
  b.intersect(2,29);
  planck_assert(b==makeRS("2 11 20 29"),"error");
  b.intersect(-18,29);
  planck_assert(b==makeRS("2 11 20 29"),"error");
  b.intersect(3,11);
  planck_assert(b==makeRS("3 11"),"error");
  b = makeRS("0 11 20 31");
  b.intersect(3,15);
  planck_assert(b==makeRS("3 11"),"error");
  b = makeRS("0 11 20 31");
  b.intersect(17,30);
  planck_assert(b==makeRS("20 30"),"error");
  b = makeRS("0 11 20 31");
  b.intersect(11,20);
  planck_assert(b==makeRS(""),"error");
  b = makeRS("0 11 20 31");
  b.intersect(-8,-7);
  planck_assert(b==makeRS(""),"error");
  b = makeRS("0 11 20 31");
  b.intersect(31,35);
  planck_assert(b==makeRS(""),"error");
  }
  {
  planck_assert(makeRS("1 11 20 31 40 56")==
                makeRS("20 31 40 51").op_or
                (makeRS("1 11 45 56")),"error");
  planck_assert(makeRS("1 11 45 56")==
                makeRS("").op_or
                (makeRS("1 11 45 56")),"error");
  planck_assert(makeRS("1 11 45 56")==
                makeRS("1 11 45 56").op_or
                (makeRS("")),"error");
  }
  {
  planck_assert(makeRS("22 24 45 51")==
                makeRS("20 31 40 51").op_and
                (makeRS("1 11 22 24 45 56")),"error");
  planck_assert(makeRS("20 31 40 51 90 101 110 121 200 201")==
                makeRS("10 101 110 121 200 221").op_and
                (makeRS("20 31 40 51 90 201")),"error");
  planck_assert(makeRS("")==
                makeRS("20 31 40 51").op_and
                (makeRS("")),"error");
  planck_assert(makeRS("")==
                makeRS("").op_and
                (makeRS("20 31 40 51")),"error");
  }
  {
  planck_assert(makeRS("20 31 40 45")==
                makeRS("20 31 40 51").op_andnot
                (makeRS("1 11 45 56")),"error");
  planck_assert(makeRS("")==
                makeRS("").op_andnot
                (makeRS("1 11 45 56")),"error");
  planck_assert(makeRS("1 11 45 56")==
                makeRS("1 11 45 56").op_andnot
                (makeRS("")),"error");
  }
  {
  rangeset b = makeRS("20 31 40 51");

  planck_assert(!b.contains(0,11),"error");
  planck_assert(!b.contains(10,21),"error");
  planck_assert(!b.contains(19,20),"error");
  planck_assert(b.contains(20,21),"error");
  planck_assert(b.contains(21,22),"error");
  planck_assert(b.contains(20,31),"error");
  planck_assert(!b.contains(25,36),"error");
  planck_assert(b.contains(30,31),"error");
  planck_assert(!b.contains(31,32),"error");
  planck_assert(!b.contains(35,38),"error");
  planck_assert(!b.contains(35,46),"error");
  planck_assert(b.contains(40,41),"error");
  planck_assert(!b.contains(45,56),"error");
  planck_assert(!b.contains(60,71),"error");
  }
  {
  rangeset b = makeRS("20 31 40 51");

  planck_assert(b.contains(makeRS("20 31 40 51")),"error");
  planck_assert(b.contains(makeRS("20 21")),"error");
  planck_assert(b.contains(makeRS("50 51")),"error");
  planck_assert(!b.contains(makeRS("19 31 40 51")),"error");
  planck_assert(!b.contains(makeRS("20 31 40 52")),"error");
  planck_assert(!b.contains(makeRS("20 51")),"error");
  planck_assert(!b.contains(makeRS("0 1")),"error");
  planck_assert(!b.contains(makeRS("0 20 31 40 51 100")),"error");
  }
  {
  rangeset b = makeRS("20 31 40 51");

  planck_assert(!b.overlaps(0,11),"error");
  planck_assert(b.overlaps(10,21),"error");
  planck_assert(!b.overlaps(19,20),"error");
  planck_assert(b.overlaps(20,21),"error");
  planck_assert(b.overlaps(21,22),"error");
  planck_assert(b.overlaps(20,31),"error");
  planck_assert(b.overlaps(25,36),"error");
  planck_assert(b.overlaps(30,37),"error");
  planck_assert(!b.overlaps(31,32),"error");
  planck_assert(!b.overlaps(35,38),"error");
  planck_assert(b.overlaps(35,46),"error");
  planck_assert(b.overlaps(40,41),"error");
  planck_assert(b.overlaps(45,56),"error");
  planck_assert(!b.overlaps(60,71),"error");
  }
  {
  rangeset b = makeRS("20 31 40 51");

  planck_assert(b.overlaps(makeRS("20 31 40 51")),"error");
  planck_assert(b.overlaps(makeRS("20 21")),"error");
  planck_assert(b.overlaps(makeRS("50 51")),"error");
  planck_assert(b.overlaps(makeRS("19 31 40 51")),"error");
  planck_assert(b.overlaps(makeRS("20 31 40 52")),"error");
  planck_assert(b.overlaps(makeRS("20 51")),"error");
  planck_assert(!b.overlaps(makeRS("0 1")),"error");
  planck_assert(!b.overlaps(makeRS("0 20 31 40 51 100")),"error");
  }
  {
  const int niter = 1000;
  for (int iter=0; iter a = randomRangeSet(1000, 0, 100);
    rangeset b = randomRangeSet(1000, 0, 100);
    rangeset c = randomRangeSet(10, 10000, 100);
    rsOps(a,b);
    rsOps(a,c);
    rsOps(c,a);
    }
  }
  }
template void check_Moc()
  {
  cout << "testing MOC " << bname() << endl;
  Moc moc;
  moc.addPixelRange(0,4,5);
  moc.addPixelRange(0,6,7);
  moc.addPixelRange(2,4,17);
  moc.addPixelRange(10,3000000,3000001);

  planck_assert(moc==moc.complement().complement(),"error");
  planck_assert(moc==Moc::fromUniq(moc.toUniq()),"error");
  planck_assert(moc.maxOrder()==10,"error");
  Moc xtmp = moc.degradedToOrder(8,false);
  planck_assert(moc.contains(xtmp),"error");
  planck_assert(!xtmp.contains(moc),"error");
  planck_assert(xtmp.overlaps(moc),"error");
  xtmp=moc.degradedToOrder(8,true);
  planck_assert(!moc.contains(xtmp),"error");
  planck_assert(xtmp.contains(moc),"error");
  planck_assert(xtmp.overlaps(moc),"error");
  planck_assert(moc==Moc::fromCompressed(moc.toCompressed()),"error");
#if 0
  assertEquals("inconsistency",moc,MocUtil.mocFromString(" 0/4, 6 2/ \t 4 -16 10/3000000 \t\n "));
  assertEquals("inconsistency",moc,MocUtil.mocFromString("0/6 2/ 5 2/4 2/6- 16 0/4  10/3000000"));
  assertEquals("inconsistency",moc,MocUtil.mocFromString
    ("{\"0\":[6] , \"2\": [5 ], \"2\":[  4,6,7,8,9,10,11,12,13,14,15,16], \"0\":[4],  \"10\":[3000000]}"));
  assertEquals("inconsistency",moc,MocUtil.mocFromString(MocUtil.mocToStringASCII(moc)));
  assertEquals("inconsistency",moc,MocUtil.mocFromString(MocUtil.mocToStringJSON(moc)));
  ByteArrayOutputStream out= new ByteArrayOutputStream();
  MocUtil.mocToFits(moc,out);
  ByteArrayInputStream inp = new ByteArrayInputStream(out.toByteArray());
  assertEquals("inconsistency",moc,MocUtil.mocFromFits(inp));
#endif
  {
  tsize niter = 100;
  Moc full; full.addPixelRange(0,0,12);
  Moc empty;
  for (tsize iter=0; iter a = randomMoc(1000, 0, 100);
    planck_assert(a.complement().complement()==a,"error");
    planck_assert(!a.overlaps(a.complement()),"error");
    planck_assert(a.op_or(a.complement())==full,"error");
    planck_assert(a.op_and(a.complement())==empty,"error");
#if 0
    write_Moc_to_fits("!healpixtestmoctmp",a);
    Moc b;
    read_Moc_from_fits("healpixtestmoctmp",b);
    planck_assert(a==b,"FITS problem");
#endif
    }
  }
  }
template void check_compress()
  {
  cout << "testing interpolation coding " << bname() << endl;
  planck_assert(trailingZeros(4)==2,"error");
  planck_assert(trailingZeros(5)==0,"error");
  planck_assert(trailingZeros(int64(1)<<48)==48,"error");
  for (tsize x=0; x<100; ++x)
    {
    rangeset a = randomRangeSet(1000, 0, 100);
    rangeset b;
    for (tsize i=0; i &v=b.data();
    obitstream obs;
    interpol_encode(v.begin(),v.end(),obs);
    vector comp=obs.state();
    vector v2;
    ibitstream ibs(comp);
    interpol_decode(v2,ibs);
    planck_assert(v==v2,"data mismatch");
    }
  }

template void check_ringnestring()
  {
  cout << "testing ring2nest(nest2ring(m))==m " << bname() << endl;
  for (int order=0; order<=T_Healpix_Base::order_max; ++order)
    {
    T_Healpix_Base base (order,RING);
    for (int m=0; m() << endl;
  for (int order=0; order<=T_Healpix_Base::order_max; ++order)
    {
    T_Healpix_Base base (order,NEST);
    for (int m=0; m() << endl;
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base1 (order,RING), base2 (order,NEST);
    for (int m=0; m() << endl;
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base1 (order,NEST), base2 (order,RING);
    double mincos = min (cos(base1.max_pixrad()),0.999999999999999);
    for (int m=0; m base (nside,RING,SET_NSIDE);
    double mincos = min (cos(base.max_pixrad()),0.999999999999999);
    for (int m=0; m void check_pixangpix()
  {
  cout << "testing ang2pix(pix2ang(m))==m " << bname() << endl;
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base1 (order,RING), base2 (order,NEST);
    for (int m=0; m() << endl;
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,NEST), base2(order,RING);
    double maxang = 2.01*base.max_pixrad();
    for (int m=0; m nb,nb2;
      vec3 pixpt = base.pix2vec(pix);
      base.neighbors(pix,nb);
      base2.neighbors(base.nest2ring(pix),nb2);
      for (int n=0; n<8; ++n)
        if (nb[n]<0)
          planck_assert(nb2[n]<0,"neighbor inconsistency");
        else
          planck_assert(base.nest2ring(nb[n])==nb2[n],"neighbor inconsistency");
      sort(&nb[0],&nb[0]+8);
      int check=0;
      for (int n=0; n<8; ++n)
        {
        if (nb[n]<0)
          ++check;
        else
          {
          if (v_angle(base.pix2vec(nb[n]),pixpt)>maxang)
            FAIL(cout<<"  PROBLEM: order = "< base (nside,RING,SET_NSIDE);
    double maxang = 2.01*base.max_pixrad();
    for (int m=0; m nb;
      vec3 pixpt = base.pix2vec(pix);
      base.neighbors(pix,nb);
      for (int n=0; n<8; ++n)
        if ((nb[n]>=0) && (v_angle(base.pix2vec(nb[n]),pixpt)>maxang))
          FAIL(cout<<"  PROBLEM: nside = "< map(order,NEST);
    for (int m=0; m map (order,scheme);
  map.fill(false);
  Healpix_Map vmap(order,scheme);
  for (int m=0; m pixset;
  pointing ptg(halfpi-0.1,0);
  double rad=0.1;
  map.query_disc(ptg,rad,pixset);
  vec3 vptg=ptg;
  double cosrad=cos(rad);
  for (tsize j=0; jcosrad;
    if (inside^map[i])
      FAIL(cout << "  PROBLEM: issue 229" << endl)
    }
  }

void check_query_disc_strict (Healpix_Ordering_Scheme scheme)
  {
  cout << "testing whether all pixels found by query_disc() really" << endl
       << "lie inside the disk (and vice versa)" << endl;
  cout << "Ordering scheme: " << (scheme==RING ? "RING" : "NEST") << endl;
  rng.seed(42);
  for (int order=0; order<=5; ++order)
    {
    Healpix_Map map (order,scheme);
    map.fill(false);
    Healpix_Map vmap(order,scheme);
    for (int m=0; m pixset;
    for (int m=0; m<100000; ++m)
      {
      pointing ptg;
      random_dir (ptg);
      double rad = pi/1 * rng.rand_uni();
      map.query_disc(ptg,rad,pixset);
      vec3 vptg=ptg;
      double cosrad=cos(rad);
      for (tsize j=0; jcosrad;
        if (inside^map[i])
          FAIL(cout<<"  PROBLEM: order = "<() << endl;
  rng.seed(48);
  int omax=min(20,T_Healpix_Base::order_max);
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base rbase (order,RING), nbase (order,NEST);
    rangeset pixset;
    int niter=max(1,min(1000,100000>>order));
    for (int m=0; m pslast=pixset;
      for (tsize fct=5; fct>0; --fct)
        {
        rangeset psi;
        rbase.query_disc_inclusive(ptg,rad,psi,fct);
        if (!psi.contains(pslast))
          cout << "  Potential problem: RING pixel sets inconsistent" << endl;
        swap(pslast,psi);
        }
      I nval = pixset.nval();
      nbase.query_disc(ptg,rad,pixset);
      pslast=pixset;
      for (tsize fct=8; fct>0; fct>>=1)
        {
        rangeset psi;
        nbase.query_disc_inclusive(ptg,rad,psi,fct);
        if (!psi.contains(pslast))
          FAIL(cout << "  PROBLEM: NEST pixel sets inconsistent" << endl)
        swap(pslast,psi);
        }
      if (nval!=pixset.nval())
        FAIL(cout << "  PROBLEM: number of pixels different: "
                  << nval << " vs. " << pixset.nval() << endl)
      }
    }
  }
templatevoid check_query_polygon()
  {
  cout << "checking query_polygon() " << bname() << endl;
  rng.seed(42);
  int omax=min(20,T_Healpix_Base::order_max);
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base rbase (order,RING), nbase (order,NEST);
    rangeset pixset;
    int niter=max(1,min(1000,100000>>order));
    for (int m=0; m corner(3);
      random_dir(corner[0]); random_dir(corner[1]); random_dir(corner[2]);
      rbase.query_polygon(corner,pixset);
      I nval = pixset.nval();
      nbase.query_polygon(corner,pixset);
      if (nval!=pixset.nval())
        FAIL(cout << "  PROBLEM: number of pixels different: "
                  << nval << " vs. " << pixset.nval() << endl)
      rbase.query_polygon_inclusive(corner,pixset,4);
      I nv1=pixset.nval();
      nbase.query_polygon_inclusive(corner,pixset,4);
      I nv2=pixset.nval();
      if (nv1 map (order,RING), map2 (order,NEST), map3 (order,RING);
  for (int m=0; m map (order,RING), map2(1,RING);
    for (int m=0; m map (nside,RING,SET_NSIDE), map2(1,RING,SET_NSIDE);
    for (int m=0; m >&almT, Alm >&almG,
  Alm >&almC, int lmax, int mmax)
  {
  almT.Set(lmax,mmax); almG.Set(lmax,mmax); almC.Set(lmax,mmax);

  for (int l=0; l<=lmax; ++l)
    {
    almT(l,0)=dcomplex(rng.rand_gauss(),0.);
    almG(l,0)=dcomplex(rng.rand_gauss(),0.);
    almC(l,0)=dcomplex(rng.rand_gauss(),0.);
    }

  for (int m=1; m<=mmax; ++m)
    for (int l=m; l<=lmax; ++l)
      {
      double t1,t2;
      t1=rng.rand_gauss(); t2=rng.rand_gauss();
      almT(l,m)=xcomplex(t1,t2);
      t1=rng.rand_gauss(); t2=rng.rand_gauss();
      almG(l,m)=xcomplex(t1,t2);
      t1=rng.rand_gauss(); t2=rng.rand_gauss();
      almC(l,m)=xcomplex(t1,t2);
      }
  almG(0,0)=almC(0,0)=almG(1,0)=almC(1,0)=almG(1,1)=almC(1,1)=0;
  }

void random_alm (Alm >&alm, int lmax, int mmax)
  {
  alm.Set(lmax,mmax);

  for (int l=0; l<=lmax; ++l)
    { alm(l,0)=dcomplex(rng.rand_gauss(),0.); }

  for (int m=1; m<=mmax; ++m)
    for (int l=m; l<=lmax; ++l)
      {
      double t1,t2;
      t1=rng.rand_gauss(); t2=rng.rand_gauss();
      alm(l,m)=xcomplex(t1,t2);
      }
  }

void check_alm (const Alm >&oalm,
  const Alm >&alm, double epsilon)
  {
  for (int m=0; m<=alm.Mmax(); ++m)
    for (int l=m; l<=alm.Lmax(); ++l)
      {
      if (!abs_approx(oalm(l,m).real(),alm(l,m).real(),epsilon))
        FAIL(cout << "Problemr " << l << " " << m << endl)
      if (!abs_approx(oalm(l,m).imag(),alm(l,m).imag(),epsilon))
        FAIL(cout << "Problemi " << l << " " << m <<  endl)
      }
  }

void check_alm2map2alm (int lmax, int mmax, int nside)
  {
  cout << "testing whether a_lm->map->a_lm returns original a_lm" << endl;
  cout << "lmax=" << lmax <<", mmax=" << mmax << ", nside=" << nside << endl;
  const double epsilon = 1e-8;
  Alm > oalmT(lmax,mmax),almT(lmax,mmax),
    oalmG(lmax,mmax),almG(lmax,mmax),oalmC(lmax,mmax),almC(lmax,mmax);
  Healpix_Map mapT(nside,RING,SET_NSIDE), mapQ(nside,RING,SET_NSIDE),
    mapU(nside,RING,SET_NSIDE);

  random_alm(oalmT,oalmG,oalmC,lmax,mmax);
  alm2map(oalmT,mapT);
  map2alm_iter2(mapT,almT,1e-12,1e-12);
  check_alm (oalmT, almT, epsilon);

  alm2map_spin(oalmG,oalmC,mapQ,mapU,1);
  map2alm_spin_iter2(mapQ,mapU,almG,almC,1,1e-12,1e-12);
  check_alm (oalmG, almG, epsilon);
  check_alm (oalmC, almC, epsilon);

  alm2map_pol(oalmT,oalmG,oalmC,mapT,mapQ,mapU);
  map2alm_pol_iter2(mapT,mapQ,mapU,almT,almG,almC,1e-12,1e-12);
  check_alm (oalmT, almT, epsilon);
  check_alm (oalmG, almG, epsilon);
  check_alm (oalmC, almC, epsilon);
  }

void check_smooth_alm ()
  {
  cout << "testing whether unsmooth(smooth(a_lm)) returns a_lm" << endl;
  const double epsilon = 1e-14;
  const double fwhm = 100.*arcmin2rad;
  const int lmax=300, mmax=300;
  Alm > oalmT(lmax,mmax),almT(lmax,mmax),
    oalmG(lmax,mmax),almG(lmax,mmax),oalmC(lmax,mmax),almC(lmax,mmax);

  random_alm(oalmT,oalmG,oalmC,lmax,mmax);

  almT=oalmT; almG=oalmG; almC=oalmC;
  smoothWithGauss (almT, fwhm);
  smoothWithGauss (almT, -fwhm);
  check_alm (oalmT, almT, epsilon);
  almT=oalmT;
  smoothWithGauss (almT, almG, almC, fwhm);
  smoothWithGauss (almT, almG, almC, -fwhm);
  check_alm (oalmT, almT, epsilon);
  check_alm (oalmG, almG, epsilon);
  check_alm (oalmC, almC, epsilon);
  }

void check_rot_alm ()
  {
  cout << "testing whether rot^-1(rot(a_lm)) returns a_lm" << endl;
  const double epsilon = 2e-13;
  const int lmax=300;
  Alm > oalm(lmax,lmax),alm(lmax,lmax);

  random_alm(oalm,lmax,lmax);

  alm=oalm;
  rotate_alm (alm,3,4,5);
  rotate_alm (alm,-5,-4,-3);
  check_alm (oalm, alm, epsilon);
  }

void check_isqrt()
  {
  cout << "testing whether isqrt() works reliably" << endl;
  uint64 val=uint64(0xF234)<<16, valsq=val*val;
  if (isqrt(valsq)!=val) FAIL(cout << "PROBLEM1" << endl)
  if (isqrt(valsq-1)!=val-1) FAIL(cout << "PROBLEM2" << endl)
  }

void check_pix2ang_acc()
  {
  cout << "testing accuracy of pix2ang at the poles" << endl;
  for (int m=0; m<=29;++m)
    {
    Healpix_Base2 base(m,RING);
    if (base.pix2ang(1).theta==0.)
      FAIL(cout << "PROBLEM: order " << m << endl)
    }
  }

const int nsteps=1000000;

templatevoid perf_neighbors(const string &name,
  Healpix_Ordering_Scheme scheme)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,scheme);
    I dpix=max(base.Npix()/nsteps,I(1));
    fix_arr nres;
    for (I pix=0; pixvoid perf_pix2ang(const string &name,
  Healpix_Ordering_Scheme scheme, double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,scheme);
    I dpix=max(base.Npix()/nsteps,I(1));
    for (I pix=0; pixvoid perf_pix2vec(const string &name,
  Healpix_Ordering_Scheme scheme, double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,scheme);
    I dpix=max(base.Npix()/nsteps,I(1));
    for (I pix=0; pixvoid perf_pix2zphi(const string &name,
  Healpix_Ordering_Scheme scheme, double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,scheme);
    I dpix=max(base.Npix()/nsteps,I(1));
    double z,phi;
    for (I pix=0; pixvoid perf_zphi2pix(const string &name,
  Healpix_Ordering_Scheme scheme, double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  double dz=2./sqrt(nsteps);
  double dph=twopi/sqrt(nsteps);
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,scheme);
    for (double z=-1; z<1; z+=dz)
      for (double phi=0; phivoid perf_ang2pix(const string &name,
  Healpix_Ordering_Scheme scheme, double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  double dth=pi/sqrt(nsteps);
  double dph=twopi/sqrt(nsteps);
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,scheme);
    for (double theta=0; thetavoid perf_ring2nest(const string &name,double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,RING);
    I dpix=max(base.Npix()/nsteps,I(1));
    for (I pix=0; pixvoid perf_nest2ring(const string &name,double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,RING);
    I dpix=max(base.Npix()/nsteps,I(1));
    for (I pix=0; pixvoid perf_peano2nest(const string &name,double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,NEST);
    I dpix=max(base.Npix()/nsteps,I(1));
    for (I pix=0; pixvoid perf_nest2peano(const string &name,double &dummy)
  {
  tsize cnt=0;
  wallTimers.start(name);
  int omax=T_Healpix_Base::order_max;
  for (int order=0; order<=omax; ++order)
    {
    T_Healpix_Base base (order,NEST);
    I dpix=max(base.Npix()/nsteps,I(1));
    for (I pix=0; pixvoid perf_query_disc(const string &name,
  Healpix_Ordering_Scheme scheme, double &dummy)
  {
  tsize cnt=0;
  T_Healpix_Base base(1024,scheme,SET_NSIDE);
  wallTimers.start(name);
  for (int m=0; m<1000; ++m)
    {
    rangeset pix;
    base.query_disc(vec3(1,0,0),halfpi/9,pix);
    dummy+=pix.nranges();
    ++cnt;
    }
  wallTimers.stop(name);
  cout << name << ": " << cnt/wallTimers.acc(name)*1e-3 << "kOps/s" << endl;
  }
templatevoid perf_query_triangle(const string &name,
  Healpix_Ordering_Scheme scheme, double &dummy)
  {
  tsize cnt=0;
  T_Healpix_Base base(1024,scheme,SET_NSIDE);
  vector corner;
  corner.push_back(vec3(1,0.01,0.01));
  corner.push_back(vec3(0.01,1,0.01));
  corner.push_back(vec3(0.01,0.01,1));
  wallTimers.start(name);
  for (int m=0; m<1000; ++m)
    {
    rangeset pix;
    base.query_polygon(corner,pix);
    dummy+=pix.nranges();
    ++cnt;
    }
  wallTimers.stop(name);
  cout << name << ": " << cnt/wallTimers.acc(name)*1e-3 << "kOps/s" << endl;
  }
templatevoid perf_query_polygon(const string &name,
  Healpix_Ordering_Scheme scheme, double &dummy)
  {
  tsize cnt=0;
  T_Healpix_Base base(1024,scheme,SET_NSIDE);
  vector corner;
  corner.push_back(vec3(1,0.01,0.01));
  corner.push_back(vec3(1,1,-0.3));
  corner.push_back(vec3(0.01,1,0.01));
  corner.push_back(vec3(0.01,0.01,1));
  wallTimers.start(name);
  for (int m=0; m<1000; ++m)
    {
    rangeset pix;
    base.query_polygon(corner,pix);
    dummy+=pix.nranges();
    ++cnt;
    }
  wallTimers.stop(name);
  cout << name << ": " << cnt/wallTimers.acc(name)*1e-3 << "kOps/s" << endl;
  }

void perftest()
  {
  double dummy=0;
  cout << "Measuring performance of Healpix_Base methods." << endl;
  perf_pix2zphi   ("pix2zphi (RING):int  ",RING,dummy);
  perf_pix2zphi   ("pix2zphi (NEST):int  ",NEST,dummy);
  perf_pix2zphi ("pix2zphi (RING):int64",RING,dummy);
  perf_pix2zphi ("pix2zphi (NEST):int64",NEST,dummy);
  perf_zphi2pix   ("zphi2pix (RING):int  ",RING,dummy);
  perf_zphi2pix   ("zphi2pix (NEST):int  ",NEST,dummy);
  perf_zphi2pix ("zphi2pix (RING):int64",RING,dummy);
  perf_zphi2pix ("zphi2pix (NEST):int64",NEST,dummy);
  perf_pix2ang    ("pix2ang  (RING):int  ",RING,dummy);
  perf_pix2ang    ("pix2ang  (NEST):int  ",NEST,dummy);
  perf_pix2ang  ("pix2ang  (RING):int64",RING,dummy);
  perf_pix2ang  ("pix2ang  (NEST):int64",NEST,dummy);
  perf_ang2pix    ("ang2pix  (RING):int  ",RING,dummy);
  perf_ang2pix    ("ang2pix  (NEST):int  ",NEST,dummy);
  perf_ang2pix  ("ang2pix  (RING):int64",RING,dummy);
  perf_ang2pix  ("ang2pix  (NEST):int64",NEST,dummy);
  perf_pix2vec    ("pix2vec  (RING):int  ",RING,dummy);
  perf_pix2vec    ("pix2vec  (NEST):int  ",NEST,dummy);
  perf_pix2vec  ("pix2vec  (RING):int64",RING,dummy);
  perf_pix2vec  ("pix2vec  (NEST):int64",NEST,dummy);
  perf_neighbors  ("neighbors(NEST):int  ",NEST);
  perf_neighbors  ("neighbors(RING):int  ",RING);
  perf_neighbors("neighbors(NEST):int64",NEST);
  perf_neighbors("neighbors(RING):int64",RING);
  perf_ring2nest  ("ring2nest      :int  ",dummy);
  perf_ring2nest("ring2nest      :int64",dummy);
  perf_nest2ring  ("nest2ring      :int  ",dummy);
  perf_nest2ring("nest2ring      :int64",dummy);
  perf_peano2nest  ("peano2nest     :int  ",dummy);
  perf_peano2nest("peano2nest     :int64",dummy);
  perf_nest2peano  ("nest2peano     :int  ",dummy);
  perf_nest2peano("nest2peano     :int64",dummy);
  perf_query_disc      ("query_disc    (RING):int  ",RING,dummy);
  perf_query_disc      ("query_disc    (NEST):int  ",NEST,dummy);
  perf_query_disc    ("query_disc    (RING):int64",RING,dummy);
  perf_query_disc    ("query_disc    (NEST):int64",NEST,dummy);
  perf_query_triangle  ("query_triangle(RING):int  ",RING,dummy);
  perf_query_triangle  ("query_triangle(NEST):int  ",NEST,dummy);
  perf_query_triangle("query_triangle(RING):int64",RING,dummy);
  perf_query_triangle("query_triangle(NEST):int64",NEST,dummy);
  perf_query_polygon   ("query_polygon (RING):int  ",RING,dummy);
  perf_query_polygon   ("query_polygon (NEST):int  ",NEST,dummy);
  perf_query_polygon ("query_polygon (RING):int64",RING,dummy);
  perf_query_polygon ("query_polygon (NEST):int64",NEST,dummy);

  if (dummy<0) cout << dummy << endl;
  }

} // unnamed namespace

int main(int argc, const char **argv)
  {
  module_startup ("hpxtest",argc,argv,1,"");
  perftest();
  check_compress();
  check_compress();
  check_compress();
  check_compress();
  check_Moc();
  check_Moc();
  check_rangeset();
  check_rangeset();
  check_isqrt();
  check_pix2ang_acc();
  check_smooth_alm();
  check_rot_alm();
  check_alm2map2alm(620,620,256);
  check_alm2map2alm(620,2,256);
  check_average();
  check_import();
  check_ringnestring();
  check_ringnestring();
  check_nestpeanonest();
  check_nestpeanonest();
  check_pixzphipix();
  check_pixzphipix();
  check_zphipixzphi();
  check_zphipixzphi();
  check_pixangpix();
  check_pixangpix();
  check_neighbors();
  check_neighbors();
  check_swap_scheme();
  check_query_disc_strict(RING);
  check_query_disc_strict(NEST);
  check_issue_229(RING);
  check_issue_229(NEST);
  check_query_disc();
  check_query_disc();
  check_query_polygon();
  check_query_polygon();
#ifdef UNITTESTS
  if (errcount>0) planck_fail("unit test errors");
#endif
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/map2tga.cc0000664000175000017500000000027213010375061026435 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  map2tga_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/map2tga.par.txt0000664000175000017500000000377413010375061027462 0ustar  zoncazonca00000000000000Usage:
  map2tga 

or:
  map2tga   [-sig ] [-pal ]
    [-xsz ] [-bar] [-log] [-asinh] [-lon ] [-lat ]
    [-mul ] [-add ] [-min ] [-max ]
    [-res ] [-title ] [-flippal] [-gnomonic]
    [-interpol] [-equalize] [-viewer ]


Parameters read by map2tga:

infile (string):
  input file containing the Healpix map

outfile (string):
  output TGA file

sig (integer, default=1):
  column number of the requested Healpix map

pal (integer, default=4):
  number of the color palette

flippal (bool, default=false):
  whether the palette should be flipped

xsz (integer, default=1024):
  number of image pixels in x direction

bar (logical, default=false):
  whether a color bar should be added to the image

log (logical, default=false):
  whether the logarithm of the map values should be displayed

equalize (logical, default=false):
  whether histogram equalisation should be performed

asinh (logical, default=false):
  whether the hyperbolic arcsine of the map values should be displayed

lon (double, default=0):
  the longitude (in degrees) of the image center

lat (double, default=0):
  the latitude (in degrees) of the image center

mul (double, default=1):
  scale factor applied to the data

add (double, default=0):
  offset added to the data (before multiplication)

min (double, optional):
  if specified, this value is used as minimum of the color scale

max (double, optional):
  if specified, this value is used as maximum of the color scale

res (double, default=1):
  only for gnomonic projection: the size (in arcmin) of an image pixel

title (string, optional):
  if specified, this value is used as the image title

viewer (string, optional):
  if specified, this executable is used to show the resulting image

pro (string, default="mollw"):
  if this is equal to "gno", gnomonic projection is used, else Mollweide

interpol (bool, default=false):
  false: no interpolation
  true : bilinear interpolation
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/map2tga_module.cc0000664000175000017500000002321413010375061030003 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include 
#include 
#include "safe_ptr.h"
#include "healpix_map.h"
#include "healpix_map_fitsio.h"
#include "rotmatrix.h"
#include "pointing.h"
#include "ls_image.h"
#include "paramfile.h"
#include "levels_facilities.h"
#include "lsconstants.h"
#include "announce.h"
#include "string_utils.h"

using namespace std;

namespace {

void histo_eq (arr2 &img, float &minv, float &maxv, arr &newpos)
  {
  const int nbins=100;
  arr bincnt (nbins);
  bincnt.fill(0);
  int pixels=0;

  double fact = 1./(maxv-minv);
  for (tsize i=0; i-1e30)
        {
        img[i][j] = float((img[i][j]-minv)*fact);
        int idx = int(img[i][j]*nbins);
        idx=max(0,min(idx,nbins-1));
        ++bincnt[idx];
        ++pixels;
        }

  newpos.alloc(nbins+1);
  int accu=0;
  for (int m=0; m-1e30)
        {
        int idx = int(img[i][j]*nbins);
        idx=max(0,min(idx,nbins-1));
        double frac = nbins*img[i][j] - idx;
        img[i][j] = float((1-frac)*newpos[idx] + frac*newpos[idx+1]);
        img[i][j] = float(minv+(maxv-minv)*img[i][j]);
        }
  }

void pro_mollw (const Healpix_Map &map, double lon0, double lat0,
  int xsize, arr2 &img, float &minv, float &maxv, bool smooth)
  {
  int ysize=xsize/2;
  img.alloc(xsize,ysize);
  img.fill(-1e35);
  double xc=(xsize-1)/2., yc=(ysize-1)/2.;

  rotmatrix rot;
  rot.Make_CPAC_Euler_Matrix(lon0,-lat0,0);

  minv=1e30;
  maxv=-1e30;
  for (tsize i=0; i(img[i][j],Healpix_undef))
          {
          if (img[i][j]maxv) maxv=img[i][j];
          }
        }
      }
  }

void pro_gno (const Healpix_Map &map, double lon0, double lat0,
  int xsize, double delta, arr2 &img, float &minv, float &maxv,
  bool smooth)
  {
  rotmatrix rot;
  rot.Make_CPAC_Euler_Matrix(lon0,-lat0,0);

  double start=-(xsize/2.)*delta;
  img.alloc(xsize,xsize);
  minv=1e30;
  maxv=-1e30;
  for (tsize i=0; i(img[i][j],Healpix_undef))
        {
        if (img[i][j]maxv) maxv=img[i][j];
        }
      }
  }

void colorbar (LS_Image &img, const Palette &pal, int xmin, int xmax,
  int ymin, int ymax, bool flippal, const arr &newpos)
  {
  int nbins = newpos.size()-1;
  for (int i=xmin; i<=xmax; ++i)
    {
    double val = (double(i)-xmin)/(xmax-xmin);
    if (nbins>0)
      {
      int idx = int(val*nbins);
      idx=max(0,min(idx,nbins-1));
      double frac = nbins*val - idx;
      val = (1-frac)*newpos[idx] + frac*newpos[idx+1];
      }
    if (flippal) val=1-val;
    Colour c = pal.Get_Colour(float(val));
    for (int j=ymin; j<=ymax; ++j)
      img.put_pixel(i,j,c);
    }
  }

string conv (double val)
  {
  ostringstream os;
  if (abs(val)>100 || abs(val)<0.01)
    {
    os << setw(10) << setprecision(3) << scientific << val;
    return os.str();
    }
  os << setw(10) << setprecision(6) << fixed << val;
  return trim(os.str());
  }

} // unnamed namespace

int map2tga_module (int argc, const char **argv)
  {
  module_startup ("map2tga",argc>=2,
    "\nUsage:\n"
    "  map2tga \n\n"
    "or:\n"
    "  map2tga   [-sig ] [-pal ]\n"
    "    [-xsz ] [-bar] [-log] [-asinh] [-lon ] [-lat ]\n"
    "    [-mul ] [-add ] [-min ] [-max ]\n"
    "    [-res ] [-title ] [-flippal] [-gnomonic]\n"
    "    [-interpol] [-equalize] [-viewer ]\n\n");

  safe_ptr params;
  if (argc>2)
    {
    vector leading;
    map dict;
    leading.push_back("infile");
    leading.push_back("outfile");
    parse_cmdline_classic (argc,argv,leading,dict);
    if (dict.find("gnomonic")!=dict.end())
      {
      dict["pro"]="gno";
      dict.erase("gnomonic");
      }
    params.reset(new paramfile(dict,false));
    }
  else
    params.reset(new paramfile(argv[1]));

  string infile = params->find("infile");
  string outfile = params->find("outfile");
  int colnum = params->find("sig",1);
  int palnr = params->find("pal",4);
  bool flippal = params->find("flippal",false);
  int xres = params->find("xsz",1024);
  bool bar = params->find("bar",false);
  bool logflag = params->find("log",false);
  bool eqflag = params->find("equalize",false);
  bool asinhflag = params->find("asinh",false);
  double lon0 = degr2rad*params->find("lon",0);
  double lat0 = degr2rad*params->find("lat",0);
  double factor = params->find("mul",1);
  double offset = params->find("add",0);
  float usermin = params->find("min", -1e30);
  bool min_supplied = (usermin>-1e29);
  float usermax = params->find("max", 1e30);
  bool max_supplied = (usermax<1e29);
  double res = arcmin2rad*params->find("res",1);
  string title = params->find("title","");
  string viewer = params->find("viewer","");
  bool mollpro = (params->find("pro","")!="gno");
  bool interpol = params->find("interpol",false);

  Healpix_Map map(0,RING);
  read_Healpix_map_from_fits(infile,map,colnum,2);
  for (int m=0; m(map[m],Healpix_undef))
      {
      map[m] = float((map[m]+offset)*factor);
      if (logflag)
        map[m] = (map[m]<=0) ? float(Healpix_undef)
                             : float(log(double(map[m]))/ln10);
      if (asinhflag)
        map[m] = (map[m]>=0) ?
          float( log(double( map[m]+sqrt(map[m]*map[m]+1)))) :
          float(-log(double(-map[m]+sqrt(map[m]*map[m]+1))));
      if (min_supplied) if (map[m] < usermin) map[m] = usermin;
      if (max_supplied) if (map[m] > usermax) map[m] = usermax;
      }
    }

  arr2 imgarr;
  float minv, maxv;
  mollpro ? pro_mollw (map,lon0,lat0,xres,imgarr,minv,maxv,interpol) :
            pro_gno (map,lon0,lat0,xres,res,imgarr,minv,maxv,interpol);

  arr newpos;
  if (eqflag) histo_eq(imgarr,minv,maxv,newpos);

  if (min_supplied) minv = usermin;
  if (max_supplied) maxv = usermax;
  if (maxv==minv) maxv=minv+1e-10f;

  int xsz=imgarr.size1();
  int ysz=imgarr.size2();
  int yofs=ysz;
  int scale = max(1,xsz/800);
  if (bar) ysz+=60*scale;
  if (title != "") { ysz+=50*scale; yofs+=50*scale; }
  LS_Image img(xsz,ysz);
  img.fill(Colour(1,1,1));
  img.set_font (giant_font);
  Palette pal;
  pal.setPredefined(palnr);
  if (title != "")
    img.annotate_centered(xsz/2,25*scale,Colour(0,0,0),title,scale);
  for (tsize i=0; i-1e32)
        {
        Colour c(0.5,0.5,0.5);
        if (!approx(imgarr[i][j],Healpix_undef))
          {
          int col = int((imgarr[i][j]-minv)/(maxv-minv)*256);
          col = min(255,max(col,0));
          float colfrac = (imgarr[i][j]-minv)/(maxv-minv);
          if (flippal) colfrac = 1-colfrac;
          c = pal.Get_Colour(colfrac);
          }
        img.put_pixel(i,yofs-j-1,c);
        }
      }

  if (bar)
    {
    colorbar (img,pal,xsz/10,(xsz*9)/10,ysz-40*scale,ysz-20*scale,flippal,
      newpos);
    img.set_font (medium_bold_font);
    img.annotate_centered (xsz/20,ysz-30*scale,Colour(0,0,0),conv(minv),scale);
    img.annotate_centered ((xsz*19)/20,ysz-30*scale,Colour(0,0,0),conv(maxv),
      scale);
    }
  img.write_TGA(outfile);

  if (viewer!="")
    {
    int retcode = system((viewer+" "+outfile).c_str());
    if (retcode != 0)
      cout << "Warning: viewer return code was " << retcode << endl;
    }

  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/median_filter_cxx.cc0000664000175000017500000000030413010375061030562 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  median_filter_cxx_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/median_filter_cxx_module.cc0000664000175000017500000000514113010375061032133 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2005-2012 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "healpix_map.h"
#include "healpix_map_fitsio.h"
#include "fitshandle.h"
#include "levels_facilities.h"
#include "lsconstants.h"
#include "announce.h"
#include "string_utils.h"

using namespace std;

namespace {

template typename iterator_traits::value_type
  median(Iterator first, Iterator last)
  {
  Iterator mid = first+(last-first-1)/2;
  nth_element(first,mid,last);
  if ((last-first)&1) return *mid;
  return typename iterator_traits::value_type
    (0.5*((*mid)+(*min_element(mid+1,last))));
  }

} // unnamed namespace

int median_filter_cxx_module (int argc, const char **argv)
  {
  module_startup ("median_filter_cxx", argc, argv, 4,
                  "  ");

  double radius = stringToData(argv[3])*arcmin2rad;

  Healpix_Map inmap;
  read_Healpix_map_from_fits(argv[1],inmap,1,2);
  Healpix_Map outmap (inmap.Nside(), inmap.Scheme(), SET_NSIDE);

  rangeset pixset;
  vector list;
  for (int m=0; m0) ? median(list.begin(),list.begin()+cnt)
                        : Healpix_undef;
    }

  write_Healpix_map_to_fits (argv[2],outmap,PLANCK_FLOAT32);

  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc.h0000664000175000017500000001603013010375061025521 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file moc.h
 *  Copyright (C) 2014-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef HEALPIX_MOC_H
#define HEALPIX_MOC_H

#include "healpix_base.h"
#include "compress_utils.h"

template class Moc
  {
  public:
    enum{maxorder=T_Healpix_Base::order_max};

  private:
    rangeset rs;

    static Moc fromNewRangeSet(const rangeset &rngset)
      {
      Moc res;
      res.rs = rngset;
      return res;
      }

  public:
    const rangeset &Rs() { return rs; }
    tsize maxOrder() const
      {
      I combo=0;
      for (tsize i=0; i>1);
      }
    Moc degradedToOrder (int order, bool keepPartialCells) const
      {
      int shift=2*(maxorder-order);
      I ofs=(I(1)< rs2;
      for (tsize i=0; ia) rs2.append(a,b);
        }
      return fromNewRangeSet(rs2);
      }
    void addPixelRange (int order, I p1, I p2)
      {
      int shift=2*(maxorder-order);
      rs.add(p1< full; full.append(I(0),I(12)*(I(1)<<(2*maxorder)));
      return fromNewRangeSet(full.op_andnot(rs));
      }
    /** Returns \c true if \a other is a subset of this Moc, else \c false. */
    bool contains(const Moc &other) const
      { return rs.contains(other.rs); }
    /** Returns \c true if the intersection of this Moc and \a other is not
        empty. */
    bool overlaps(const Moc &other) const
      { return rs.overlaps(other.rs); }

    /** Returns a vector containing all HEALPix pixels (in ascending NUNIQ
        order) covered by this Moc. The result is well-formed in the sense that
        every pixel is given at its lowest possible HEALPix order. */
    std::vector toUniq() const
      {
      std::vector res;
      std::vector > buf(maxorder+1);
      for (tsize i=0; i(maxorder,trailingZeros(start)>>1);
          logstep=std::min(logstep,ilog2(end-start)>>1);
          buf[maxorder-logstep].push_back(start);
          start+=I(1)<<(2*logstep);
          }
        }
      for (int o=0; o<=maxorder; ++o)
        {
        I ofs=I(1)<<(2*o+2);
        int shift=2*(maxorder-o);
        for (tsize j=0; j>shift)+ofs);
        }
      return res;
      }

    static Moc fromUniq (const std::vector &vu)
      {
      rangeset r, rtmp;
      int lastorder=0;
      int shift=2*maxorder;
      for (tsize i=0; i>2)>>1;
        if (order!=lastorder)
          {
          r=r.op_or(rtmp);
          rtmp.clear();
          lastorder=order;
          shift=2*(maxorder-order);
          }
        I pix = vu[i]-(I(1)<<(2*order+2));
        rtmp.append (pix< &vu)
      {
      using namespace std;
      if (vu.empty()) return;

      tsize start=0;
      int order=-1;
      T_Healpix_Base base;
      I offset=0;
      for (tsize j=0; j>2)>>1;
        if (neworder>order)
          {
          sort(vu.begin()+start,vu.begin()+j);
          order=neworder;
          start=j;
          base.Set(order,NEST);
          offset=I(1)<<(2*order+2);
          }
        vu[j]=base.nest2peano(vu[j]-offset)+offset;
        }
      sort(vu.begin()+start,vu.end());
      }
    static void uniq_peano2nest(std::vector &vu)
      {
      using namespace std;
      if (vu.empty()) return;

      tsize start=0;
      int order=-1;
      T_Healpix_Base base;
      I offset=0;
      for (tsize j=0; j>2)>>1;
        if (neworder>order)
          {
          sort(vu.begin()+start,vu.begin()+j);
          order=neworder;
          start=j;
          base.Set(order,NEST);
          offset=I(1)<<(2*order+2);
          }
        vu[j]=base.peano2nest(vu[j]-offset)+offset;
        }
      sort(vu.begin()+start,vu.end());
      }

    std::vector toCompressed() const
      {
      obitstream obs;
      interpol_encode(rs.data().begin(),rs.data().end(),obs);
      return obs.state();
      }
    static Moc fromCompressed(const std::vector &data)
      {
      ibitstream ibs(data);
      std::vector v;
      interpol_decode(v,ibs);
      Moc out;
      out.rs.setData(v);
      return out;
      }

    bool operator==(const Moc &other) const
      {
      if (this == &other)
        return true;
      return rs==other.rs;
      }

    tsize nranges() const
      { return rs.nranges(); }
    I nval() const
      { return rs.nval(); }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc_fitsio.cc0000664000175000017500000000520213010375061027233 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2014-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "moc_fitsio.h"
#include "fitshandle.h"

using namespace std;

template void read_Moc_from_fits
  (const std::string &filename, Moc &moc, bool peano)
  {
  fitshandle inp;
  inp.open (filename);
  inp.goto_hdu (2);
  vector data;
  inp.read_entire_column(1,data);
  if (peano)
    Moc::uniq_nest2peano(data);
  moc=Moc::fromUniq(data);
  }

template void read_Moc_from_fits
  (const std::string &filename, Moc &moc, bool peano);
template void read_Moc_from_fits
  (const std::string &filename, Moc &moc, bool peano);

template void write_Moc_to_fits
  (const std::string &outfile, const Moc &moc, bool peano)
  {
  PDT outtype=PLANCK_INT16;
  vector data=moc.toUniq();
  if (peano)
    Moc::uniq_peano2nest(data);
  if (data.size()>0)
    {
    if (data.back()>0x7fff) outtype=PLANCK_INT32;
    if (data.back()>0x7fffffffLL) outtype=PLANCK_INT64;
    }
  fitshandle out;
  out.create(outfile);
  vector cols;
  cols.push_back (fitscolumn ("PIXEL","",1,outtype));
  out.insert_bintab(cols);
  out.set_key("PIXTYPE", string("HEALPIX"), "HEALPix magic value");
  out.set_key("ORDERING", string("NUNIQ"), "NUNIQ coding method");
  out.set_key("COORDSYS", string("C"), "mandated by MOC standard");
  out.set_key("MOCORDER", moc.maxOrder(), "MOC resolution (best order)");
  out.write_column(1,data);
  }
  
template void write_Moc_to_fits
  (const std::string &outfile, const Moc &moc, bool peano);
template void write_Moc_to_fits
  (const std::string &outfile, const Moc &moc, bool peano);
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc_fitsio.h0000664000175000017500000000306413010375061027101 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file moc_fitsio.h
 *  FITS I/O for multi-order coverage information
 *
 *  Copyright (C) 2014 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_MOC_FITSIO_H
#define PLANCK_MOC_FITSIO_H

#include 
#include "moc.h"

/*! \defgroup moc_fitsio_group FITS-based I/O of MOC objects */
/*! \{ */

template void read_Moc_from_fits
  (const std::string &filename, Moc &moc, bool peano=false);

template void write_Moc_to_fits
  (const std::string &outfile, const Moc &moc, bool peano=false);

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc_query.cc0000664000175000017500000002763713010375061027123 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file moc_query.cc
 *  Copyright (C) 2014-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#include "moc_query.h"
#include "geom_utils.h"
#include "lsconstants.h"

using namespace std;

namespace {

template class queryHelper
  {
  private:
    int order, omax;
    bool inclusive;
    vector comp;
    vector > base;
    vector shortcut;
    arr cr;
    arr2 crmin;
    arr2 crmax;

    vector > stk; // stack for pixel numbers and their orders
    I pix;
    int o;
    int stacktop; // a place to save a stack position
    vec3 pv;

    void check_pixel (int zone, Moc &pixset)
      {
      if (zone==0) return;
      if (o=3)
          pixset.appendPixel(o,pix); // output all subpixels
        else // (zone>=1)
          for (int i=0; i<4; ++i)
            stk.push_back(make_pair(4*pix+3-i,o+1)); // add children
        }
      else if (o>order) // this implies that inclusive==true
        {
        if (zone>=2) // pixel center in shape
          {
          pixset.appendPixel(order,pix>>(2*(o-order))); // output parent pixel
          stk.resize(stacktop); // unwind the stack
          }
        else // (zone>=1): pixel center in safety range
          {
          if (o>(2*(o-order))); // output parent pixel
            stk.resize(stacktop); // unwind the stack
            }
          }
        }
      else // o==order
        {
        if (zone>=2)
          pixset.appendPixel(order,pix);
        else if (inclusive) // and (zone>=1)
          {
          if (order=0)&&(myloc=0)&&(myloc &comp_)
      : order(order_), omax(omax_), inclusive(inclusive_), comp(comp_),
        base(omax+1), shortcut(comp.size()), cr(comp.size()),
        crmin(omax+1,comp.size()), crmax(omax+1,comp.size())
      {
      planck_assert(comp.size()>=1,"bad query component vector");
      planck_assert(order<=omax,"order>omax");
      if (!inclusive) planck_assert(order==omax,"inconsistency");
      planck_assert(omax<=T_Healpix_Base::order_max,"omax too high");

      for (tsize i=0; i=pi) ? -1.01:cos(comp[i].radius+dr);
            crmin(o,i) = (comp[i].radius-dr<=0.) ?  1.01:cos(comp[i].radius-dr);
            }
        }

      for (tsize i=0; i result()
      {
      Moc pixset;
      stk.reserve(12+3*omax); // reserve maximum size to avoid reallocation
      for (int i=0; i<12; ++i) // insert the 12 base pixels in reverse order
        stk.push_back(make_pair(I(11-i),0));

      stacktop=0; // a place to save a stack position

      while (!stk.empty()) // as long as there are pixels on the stack
        {
        // pop current pixel number and order from the stack
        pix=stk.back().first;
        o=stk.back().second;
        stk.pop_back();
        pv = base[o].pix2vec(pix);

        int loc=comp.size()-1;
        tsize zone=getZone(loc,0,3);
        check_pixel (zone, pixset);
        planck_assert(loc==-1,"stack not used up");
        }
      return pixset;
      }
  };

double isLeft (const vec3 &a, const vec3 &b, const vec3 &c)
  { return dotprod(crossprod(a,b),c); }

// adapted from code available at http://geomalgorithms.com/a12-_hull-3.html
// Original copyright notice follows:
// Copyright 2001 softSurfer, 2012 Dan Sunday
// This code may be freely used and modified for any purpose
// providing that this copyright notice is included with it.
// SoftSurfer makes no warranty for this code, and cannot be held
// liable for any real or imagined damage resulting from its use.
// Users of this code must verify correctness for their application.
vector getHull (const vector &vert, const vector &P)
  {
  // initialize a deque D[] from bottom to top so that the
  // 1st three vertices of P[] are a ccw triangle
  int n = P.size();
  arr D(2*n+1);
  int bot = n-2, top = bot+3;    // initial bottom and top deque indices
  D[bot] = D[top] = P[2];      // 3rd vertex is at both bot and top
  if (isLeft(vert[P[0]], vert[P[1]], vert[P[2]]) > 0)
    {
    D[bot+1] = P[0];
    D[bot+2] = P[1];           // ccw vertices are: 2,0,1,2
    }
  else
    {
    D[bot+1] = P[1];
    D[bot+2] = P[0];           // ccw vertices are: 2,1,0,2
    }

  // compute the hull on the deque D[]
  for (int i=3; i 0) &&
        (isLeft(vert[D[top-1]], vert[D[top]], vert[P[i]]) > 0) )
      continue;         // skip an interior vertex

    // incrementally add an exterior vertex to the deque hull
    // get the rightmost tangent at the deque bot
    while (isLeft(vert[D[bot]], vert[D[bot+1]], vert[P[i]]) <= 0)
      ++bot;                 // remove bot of deque
    D[--bot] = P[i];         // insert P[i] at bot of deque

    // get the leftmost tangent at the deque top
    while (isLeft(vert[D[top-1]], vert[D[top]], vert[P[i]]) <= 0)
      --top;                 // pop top of deque
    D[++top] = P[i];         // push P[i] onto top of deque
    }

  // transcribe deque D[] to the output hull array H[]
  int nout = top-bot;
  vector res(nout);
  for (int h=0; h &vv, const vector &P,
  vector &comp, bool doLast)
  {
  vector hull=getHull(vv,P);
  vector addHull(hull.size());

  // sync both sequences at the first point of the convex hull
  int ihull=0, ipoly=0, nhull=hull.size(), npoly=P.size();
  while (hull[ihull]!=P[ipoly]) ++ipoly;

  // iterate over the pockets between the polygon and its convex hull
  int npockets=0;
  if (P.size()==3) // really P.size(), not vv.size()?
    for (int i=0; i<3; i++) addHull[i]=true;
  else
    {
    do
      {
      int ihull_next = (ihull+1)%nhull,
          ipoly_next = (ipoly+1)%npoly;
      if (hull[ihull_next]==P[ipoly_next]) // no pocket found
        { addHull[ihull]=true; ihull=ihull_next; ipoly=ipoly_next; }
      else // query pocket
        {
        int nvpocket=2; // number of vertices for this pocket
        while (P[ipoly_next]!=hull[ihull_next])
          {
          ipoly_next = (ipoly_next+1)%npoly;
          ++nvpocket;
          }
        vector ppocket(nvpocket);
        int idx=0;
        int ipoly_bw=ipoly_next;
        while (P[ipoly_bw]!=hull[ihull])
          {
          ppocket[idx++]=P[ipoly_bw];
          ipoly_bw=(ipoly_bw+npoly-1)%npoly;
          }
        ppocket[idx]=hull[ihull];
        // process pocket recursively
        ++npockets;
        prepPolyHelper (vv, ppocket, comp, false);
        ihull=ihull_next;
        ipoly=ipoly_next;
        }
      } while (ihull!=0);
    }
  if (npockets>1) 
    comp.push_back(MocQueryComponent(OR,npockets));
  if (npockets>0) 
    comp.push_back(MocQueryComponent(NOT));

  if (!doLast)
    addHull.back()=false;

  // add convex hull
  for (tsize i=0; i0) ++num_and;
  if (num_and>1) 
    comp.push_back(MocQueryComponent(AND,num_and));
  }

} // unnamed namespace

template Moc mocQuery (int order,
  const vector &comp)
  { return queryHelper(order,order,false,comp).result(); }
template Moc mocQuery (int order, const vector &comp);
template Moc mocQuery (int order, const vector &comp);

template Moc mocQueryInclusive (int order, int omax,
  const vector &comp)
  { return queryHelper(order,omax,true,comp).result(); }
template Moc mocQueryInclusive (int order, int omax,
  const vector &comp);
template Moc mocQueryInclusive (int order, int omax,
  const vector &comp);

vector prepPolygon (const vector &vertex)
  {
  planck_assert(vertex.size()>=3,"not enough vertices in polygon");
  vector vv(vertex.size());
  for (tsize i=0; i P(vv.size());
  for (tsize i=0; i comp;
  prepPolyHelper(vv,P,comp,true);
  return comp;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc_query.h0000664000175000017500000000554613010375061026760 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file moc_query.h
 *  Copyright (C) 2014-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef MOC_QUERY_H
#define MOC_QUERY_H

#include "vec3.h"
#include "moc.h"

enum MocQueryOp { AND,OR,XOR,NOT,NONE };

class MocQueryComponent
  {
  public:
    MocQueryOp op;
    int nops;
    vec3 center;
    double radius;
    MocQueryComponent(MocQueryOp op_)
      : op(op_)
      {
      planck_assert(op_!=NONE,"bad operator");
      switch (op)
        {
        case AND:
        case OR:
        case XOR:
          nops=2;
          break;
        case NOT:
          nops=1;
          break;
        case NONE:
          nops=0;
          break;
        }
      }
    MocQueryComponent(MocQueryOp op_, int nops_)
      {
      op= op_;
      nops=nops_;
      switch (op)
        {
        case AND:
        case OR:
          planck_assert(nops>=2,"bad nops");
          break;
        case XOR:
          planck_assert(nops==2,"bad nops");
          break;
        case NOT:
          planck_assert(nops==1,"bad nops");
          break;
        case NONE:
          planck_fail("bad operator");
          break;
        }
      }
    MocQueryComponent(const vec3 &cnt, double rad)
      : op (NONE), nops(0), center(cnt.Norm()), radius(rad) {}
  };

template Moc mocQuery (int order,
  const std::vector &comp);

template Moc mocQueryInclusive (int order, int omax,
  const std::vector &comp);

std::vector prepPolygon (const std::vector &vertex);

template inline Moc mocQuery (int order,
  const std::vector &vertex)
  { return mocQuery(order, prepPolygon(vertex)); }

template inline Moc mocQueryInclusive (int order, int omax,
  const std::vector &vertex)
  { return mocQueryInclusive(order, omax, prepPolygon(vertex)); }

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/mult_alm.cc0000664000175000017500000000027313010375061026715 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  mult_alm_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/mult_alm.par.txt0000664000175000017500000000256613010375061027737 0ustar  zoncazonca00000000000000Parameters read by mult_alm:

infile (string):
  input file containing the a_lm

outfile (string):
  output file name for the calculated a_lm

fwhm_arcmin_in (real, default=0):
  FWHM (in arcmin) of a Gaussian beam, which will be _removed_ from the
  input a_lm

fwhm_arcmin_out (real, default=0):
  FWHM (in arcmin) of a Gaussian beam, which will be used to smoothe the
  output a_lm

nside_pixwin_in (integer, default=0):
  If this is different from 0, the corresponding pixel window function
  will be _removed_ from the input a_lm

nside_pixwin_out (integer, default=0):
  If this is different from 0, the corresponding pixel window function
  will be applied to the output a_lm

if ((nside_pixwin_in>0)||(nside_pixwin_out>0))
  healpix_data (string):
    directory containing the Healpix data files
endif

cl_in (string, default=""):
  if supplied, the power spectrum from this file will be _removed_
  from the input a_lm
  NOTE: currently only supported for unpolarised a_lm

cl_out (string, default=""):
  if supplied, the power pectrum from this file will be applied
  to the output a_lm
  NOTE: currently only supported for unpolarised a_lm

polarisation (bool):
  if false, only the intensity a_lm are generated,
  if true, T, G and C a_lm are generated

double_precision (bool, default=false):
  if false, the a_lm are read/written in single precision,
  otherwise in double precision.
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/mult_alm_module.cc0000664000175000017500000001221013010375061030254 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2014 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "xcomplex.h"
#include "paramfile.h"
#include "healpix_data_io.h"
#include "powspec.h"
#include "powspec_fitsio.h"
#include "alm.h"
#include "alm_fitsio.h"
#include "alm_powspec_tools.h"
#include "fitshandle.h"
#include "levels_facilities.h"
#include "lsconstants.h"
#include "announce.h"

using namespace std;

namespace {

template void mult_alm (paramfile ¶ms)
  {
  string infile = params.template find("infile");
  string outfile = params.template find("outfile");
  int nside_pixwin_in = params.template find("nside_pixwin_in",0);
  planck_assert (nside_pixwin_in>=0,"nside_pixwin_in must be >= 0");
  int nside_pixwin_out = params.template find("nside_pixwin_out",0);
  planck_assert (nside_pixwin_out>=0,"nside_pixwin_out must be >= 0");
  string cl_in = params.template find("cl_in","");
  string cl_out = params.template find("cl_out","");
  double fwhm_in = arcmin2rad*params.template find("fwhm_arcmin_in",0);
  planck_assert (fwhm_in>=0,"fwhm_arcmin_in must be >= 0");
  double fwhm_out = arcmin2rad*params.template find("fwhm_arcmin_out",0);
  planck_assert (fwhm_out>=0,"fwhm_arcmin_out must be >= 0");
  int cw_lmin=-1, cw_lmax=-1;
  if (params.param_present("cw_lmin"))
    {
    cw_lmin = params.template find("cw_lmin");
    cw_lmax = params.template find("cw_lmax");
    }

  string datadir;
  if ((nside_pixwin_in>0) || (nside_pixwin_out>0))
    datadir = params.template find("healpix_data");

  bool polarisation = params.template find("polarisation");
  if (!polarisation)
    {
    int nlmax, nmmax;
    get_almsize(infile, nlmax, nmmax, 2);
    Alm > alm;
    read_Alm_from_fits(infile,alm,nlmax,nmmax,2);
    if (fwhm_in>0) smoothWithGauss (alm, -fwhm_in);
    arr temp(nlmax+1);
    PowSpec tps;
    if (nside_pixwin_in>0)
      {
      read_pixwin(datadir,nside_pixwin_in,temp);
      for (int l=0; l<=nlmax; ++l)
        temp[l] = 1/temp[l];
      alm.ScaleL (temp);
      }
    if (cl_in!="")
      {
      read_powspec_from_fits (cl_in,tps,1,alm.Lmax());
      for (int l=0; l<=nlmax; ++l)
        temp[l] = 1./sqrt(tps.tt(l));
      alm.ScaleL (temp);
      }
    if (nside_pixwin_out>0)
      {
      read_pixwin(datadir,nside_pixwin_out,temp);
      alm.ScaleL (temp);
      }
    if (cl_out!="")
      {
      read_powspec_from_fits (cl_out,tps,1,alm.Lmax());
      for (int l=0; l<=nlmax; ++l)
        temp[l] = sqrt(tps.tt(l));
      alm.ScaleL (temp);
      }
    if (fwhm_out>0) smoothWithGauss (alm, fwhm_out);
    if (cw_lmin>=0) applyCosineWindow(alm, cw_lmin, cw_lmax);
    write_Alm_to_fits (outfile,alm,nlmax,nmmax,planckType());
    }
  else
    {
    int nlmax, nmmax;
    get_almsize_pol(infile, nlmax, nmmax);
    Alm > almT, almG, almC;
    read_Alm_from_fits(infile,almT,almG,almC,nlmax,nmmax,2);
    if (fwhm_in>0) smoothWithGauss (almT, almG, almC, -fwhm_in);
    arr temp(nlmax+1), pol(nlmax+1);
    if (nside_pixwin_in>0)
      {
      read_pixwin(datadir,nside_pixwin_in,temp,pol);
      for (int l=0; l<=nlmax; ++l)
        { temp[l] = 1/temp[l]; if (pol[l]!=0.) pol[l] = 1/pol[l]; }
      almT.ScaleL(temp); almG.ScaleL(pol); almC.ScaleL(pol);
      }
    if (cl_in!="")
      planck_fail ("power spectra not (yet) supported with polarisation");
    if (nside_pixwin_out>0)
      {
      read_pixwin(datadir,nside_pixwin_out,temp,pol);
      almT.ScaleL(temp); almG.ScaleL(pol); almC.ScaleL(pol);
      }
    if (cl_out!="")
      planck_fail ("power spectra not (yet) supported with polarisation");
    if (fwhm_out>0) smoothWithGauss (almT, almG, almC, fwhm_out);
    if (cw_lmin>=0) applyCosineWindow(almT, almG, almC, cw_lmin, cw_lmax);
    write_Alm_to_fits (outfile,almT,almG,almC,nlmax,nmmax,planckType());
    }
  }

} // unnamed namespace

int mult_alm_module (int argc, const char **argv)
  {
  module_startup ("mult_alm", argc, argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  bool dp = params.find ("double_precision",false);
  dp ? mult_alm(params) : mult_alm(params);

  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/planck.make0000664000175000017500000000250713010375061026705 0ustar  zoncazonca00000000000000PKG:=Healpix_cxx

SD:=$(SRCROOT)/$(PKG)
OD:=$(BLDROOT)/$(PKG)

FULL_INCLUDE+= -I$(SD)

HDR_$(PKG):=$(SD)/*.h
LIB_$(PKG):=$(LIBDIR)/libhealpix_cxx.a
CXXBIN:=syn_alm_cxx alm2map_cxx anafast_cxx map2tga udgrade_cxx udgrade_harmonic_cxx hotspots_cxx calc_powspec median_filter_cxx hpxtest smoothing_cxx mult_alm rotalm_cxx
SPHERE_OBJ:=  powspec.o alm.o alm_powspec_tools.o
HEALPIX_OBJ:= healpix_tables.o healpix_base.o healpix_map.o alm_healpix_tools.o moc_query.o
IO_OBJ:= alm_fitsio.o powspec_fitsio.o healpix_data_io.o healpix_map_fitsio.o moc_fitsio.o
MOD_OBJ:= syn_alm_cxx_module.o anafast_cxx_module.o alm2map_cxx_module.o map2tga_module.o udgrade_cxx_module.o udgrade_harmonic_cxx_module.o smoothing_cxx_module.o hotspots_cxx_module.o calc_powspec_module.o median_filter_cxx_module.o mult_alm_module.o
LIBOBJ:= $(SPHERE_OBJ) $(HEALPIX_OBJ) $(IO_OBJ) $(MOD_OBJ)
ALLOBJ:=$(LIBOBJ) $(CXXBIN:%=%.o)
LIBOBJ:=$(LIBOBJ:%=$(OD)/%)
ALLOBJ:=$(ALLOBJ:%=$(OD)/%)

ODEP:=$(HDR_$(PKG)) $(HDR_cxxsupport) $(HDR_libsharp) $(HDR_libfftpack) $(HDR_c_utils)
BDEP:=$(LIB_$(PKG)) $(LIB_cxxsupport) $(LIB_libsharp) $(LIB_libfftpack) $(LIB_c_utils) $(LIB_libcfitsio)

$(LIB_$(PKG)): $(LIBOBJ)

$(ALLOBJ): $(ODEP) | $(OD)_mkdir
CXXBIN:=$(CXXBIN:%=$(BINDIR)/%)
$(CXXBIN): $(BINDIR)/% : $(OD)/%.o $(BDEP)

all_hdr+=$(HDR_$(PKG))
all_lib+=$(LIB_$(PKG))
all_cxxbin+=$(CXXBIN)
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/powspec.cc0000664000175000017500000001022713010375061026563 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "powspec.h"
#include "lsconstants.h"

using namespace std;

void PowSpec::dealloc()
  {
  tt_.dealloc();
  gg_.dealloc();
  cc_.dealloc();
  tg_.dealloc();
  tc_.dealloc();
  gc_.dealloc();
  }

PowSpec::PowSpec(int nspec, int lmax)
  { Set(nspec,lmax); }

PowSpec::~PowSpec()
  {}

void PowSpec::assertArraySizes() const
  {
  planck_assert((num_specs==1) || (num_specs==4) || (num_specs==6),
    "incorrect number of spectral components");
  if (num_specs==1)
    planck_assert(multiequal(tsize(0),gg_.size(),cc_.size(),tg_.size(),
      tc_.size(),gc_.size()), "incorrect array sizes");
  if (num_specs==4)
    {
    planck_assert(multiequal(tt_.size(),gg_.size(),cc_.size(),tg_.size()),
      "incorrect array sizes");
    planck_assert(multiequal(tsize(0),tc_.size(),gc_.size()),
      "incorrect array sizes");
    }
  if (num_specs==6)
    planck_assert(multiequal(tt_.size(),gg_.size(),cc_.size(),tg_.size(),
      tc_.size(),gc_.size()), "incorrect array sizes");
  }

bool PowSpec::consistentAutoPowspec() const
  {
  for (tsize l=0; l=4)
    for (tsize l=0; lsqrt(tt_[l]*gg_[l])) return false;
      }
  if (num_specs==6)
    for (tsize l=0; lsqrt(tt_[l]*cc_[l])) return false;
      if (abs(gc_[l])>sqrt(gg_[l]*cc_[l])) return false;
      }
  return true;
  }

void PowSpec::Set(int nspec, int lmax)
  {
  num_specs=nspec;
  planck_assert ((num_specs==1) || (num_specs==4) || (num_specs==6),
    "wrong number of spectrums");
  tt_.alloc(lmax+1);
  if (num_specs>1)
    {
    gg_.alloc(lmax+1);
    cc_.alloc(lmax+1);
    tg_.alloc(lmax+1);
    }
  if (num_specs>4)
    {
    tc_.alloc(lmax+1);
    gc_.alloc(lmax+1);
    }
  }

void PowSpec::Set(arr &tt_new)
  {
  dealloc();
  num_specs = 1;
  tt_.transfer(tt_new);
//FIXME: temporarily relaxed to allow cross-spectra
  if (!consistentAutoPowspec())
    cerr << "Warning: negative values in TT spectrum" << endl;
  }

void PowSpec::Set(arr &tt_new, arr &gg_new,
  arr &cc_new, arr &tg_new)
  {
  dealloc();
  num_specs = 4;
  tt_.transfer(tt_new); gg_.transfer(gg_new);
  cc_.transfer(cc_new); tg_.transfer(tg_new);
  assertArraySizes();
  }

void PowSpec::Set(arr &tt_new, arr &gg_new, arr &cc_new,
  arr &tg_new, arr &tc_new, arr &gc_new)
  {
  Set (tt_new, gg_new, cc_new, tg_new);
  num_specs = 6;
  tc_.transfer(tc_new); gc_.transfer(gc_new);
  assertArraySizes();
  }

void PowSpec::smoothWithGauss (double fwhm)
  {
  double sigma = fwhm*fwhm2sigma;
  double fact_pol = exp(2*sigma*sigma);
  for (tsize l=0; l1)
      {
      gg_[l] *= f2*f2;
      cc_[l] *= f2*f2;
      tg_[l] *= f1*f2;
      if (num_specs>4)
        {
        tc_[l] *= f1*f2;
        gc_[l] *= f2*f2;
        }
      }
    }
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/powspec.h0000664000175000017500000001073313010375061026427 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#ifndef POWSPEC_H
#define POWSPEC_H

#include "arr.h"

/*! Class for storing unpolarised and polarised power spectra. */
class PowSpec
  {
  private:
    arr tt_, gg_, cc_, tg_, tc_, gc_;
    int num_specs;

    void dealloc();

  public:
    /*! */
    PowSpec() {}
    /*! Constructs a \a PowSpec with \a nspec components and a maximum
        multipole of \a lmax. \a nspec can be 1 (TT), 4 (TT,GG,CC,TG) or
        6 (TT,GG,CC,TG,TC,GC). */
    PowSpec(int nspec, int lmax);

    ~PowSpec();

    /*! Ensures that the internal array sizes are consistent with the
        \a num_specs variable. */
    void assertArraySizes() const;

    /*! Checks whether the object can be an auto power spectrum. If this
        is not the case, an exception is thrown. */
    bool consistentAutoPowspec() const;

    /*! Returns the number of spectral components. */
    int Num_specs() const { return num_specs; }
    /*! Returns the maximum \a l. */
    int Lmax() const { return tt_.size()-1; }
    /*! Returns the TT array (read-only). */
    const arr &tt() const { return tt_; }
    /*! Returns the GG array (read-only). */
    const arr &gg() const { return gg_; }
    /*! Returns the CC array (read-only). */
    const arr &cc() const { return cc_; }
    /*! Returns the TG array (read-only). */
    const arr &tg() const { return tg_; }
    /*! Returns the TC array (read-only). */
    const arr &tc() const { return tc_; }
    /*! Returns the GC array (read-only). */
    const arr &gc() const { return gc_; }
    /*! Returns TT(l) (read-write). */
    double &tt (int l) { return tt_[l]; }
    /*! Returns GG(l) (read-write). */
    double &gg (int l) { return gg_[l]; }
    /*! Returns CC(l) (read-write). */
    double &cc (int l) { return cc_[l]; }
    /*! Returns TG(l) (read-write). */
    double &tg (int l) { return tg_[l]; }
    /*! Returns TC(l) (read-write). */
    double &tc (int l) { return tc_[l]; }
    /*! Returns GC(l) (read-write). */
    double &gc (int l) { return gc_[l]; }
    /*! Returns TT(l) (read-only). */
    const double &tt (int l) const { return tt_[l]; }
    /*! Returns GG(l) (read-only). */
    const double &gg (int l) const { return gg_[l]; }
    /*! Returns CC(l) (read-only). */
    const double &cc (int l) const { return cc_[l]; }
    /*! Returns TG(l) (read-only). */
    const double &tg (int l) const { return tg_[l]; }
    /*! Returns TC(l) (read-only). */
    const double &tc (int l) const { return tc_[l]; }
    /*! Returns GC(l) (read-only). */
    const double &gc (int l) const { return gc_[l]; }

    /*! Re-allocates the object */
    void Set(int nspec, int lmax);

    /*! Sets the whole TT array.
        \note On exit, \a tt_new is zero-sized! */
    void Set(arr &tt_new);
    /*! Sets the four first components.
        \note On exit, all arguments are zero-sized! */
    void Set(arr &tt_new, arr &gg_new,
             arr &cc_new, arr &tg_new);
    /*! Sets all components.
        \note On exit, all arguments are zero-sized! */
    void Set(arr &tt_new, arr &gg_new,
             arr &cc_new, arr &tg_new,
             arr &tc_new, arr &gc_new);
    /*! Smooths the spectrum with a Gaussian beam.
       \a fwhm is given in radian.
       \note This is only implememted for 1 and 4 spectra so far. */
    void smoothWithGauss (double fwhm);
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/powspec_fitsio.cc0000664000175000017500000000705613010375061030146 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2013 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "powspec_fitsio.h"
#include "powspec.h"
#include "fitshandle.h"

using namespace std;

void read_powspec_from_fits (fitshandle &inp, PowSpec &powspec, int nspecs,
  int lmax)
  {
  planck_assert ((nspecs==1)||(nspecs==4)||(nspecs==6),
    "wrong number of spectra");

  arr tt(lmax+1,0),gg(lmax+1,0),cc(lmax+1,0),tg(lmax+1,0),
              tc(lmax+1,0),gc(lmax+1,0);

  int lmax_file = safe_cast(inp.nelems(1)-1);
  if (lmax_file=4)
    {
    inp.read_column_raw (2,&gg[0],lmax_read+1);
    inp.read_column_raw (3,&cc[0],lmax_read+1);
    inp.read_column_raw (4,&tg[0],lmax_read+1);
    }
  if (nspecs==6)
    {
    inp.read_column_raw (5,&tc[0],lmax_read+1);
    inp.read_column_raw (6,&gc[0],lmax_read+1);
    }

  if (nspecs==1) powspec.Set(tt);
  if (nspecs==4) powspec.Set(tt,gg,cc,tg);
  if (nspecs==6) powspec.Set(tt,gg,cc,tg,tc,gc);
  }

void read_powspec_from_fits (const string &infile, PowSpec &powspec,
  int nspecs, int lmax, int hdunum)
  {
  fitshandle inp;
  inp.open(infile);
  inp.goto_hdu(hdunum);

  read_powspec_from_fits (inp,powspec,nspecs,lmax);
  }

void write_powspec_to_fits (fitshandle &out,
  const PowSpec &powspec, int nspecs)
  {
  planck_assert ((nspecs==1)||(nspecs==4)||(nspecs==6),
    "incorrect number of spectra");
  vector cols;
  cols.push_back(fitscolumn("Temperature C_l","unknown",1,PLANCK_FLOAT64));
  if (nspecs>1)
    {
    cols.push_back(fitscolumn("E-mode C_l","unknown",1,PLANCK_FLOAT64));
    cols.push_back(fitscolumn("B-mode C_l","unknown",1,PLANCK_FLOAT64));
    cols.push_back(fitscolumn("T-E cross-corr.","unknown",1,
      PLANCK_FLOAT64));
    }
  if (nspecs>4)
    {
    cols.push_back(fitscolumn("T-B cross-corr.","unknown",1,PLANCK_FLOAT64));
    cols.push_back(fitscolumn("E-B cross-corr.","unknown",1,PLANCK_FLOAT64));
    }
  out.insert_bintab(cols);
  out.write_column(1,powspec.tt());
  if (nspecs>1)
    {
    out.write_column(2,powspec.gg());
    out.write_column(3,powspec.cc());
    out.write_column(4,powspec.tg());
    }
  if (nspecs>4)
    {
    out.write_column(5,powspec.tc());
    out.write_column(6,powspec.gc());
    }
  }

void write_powspec_to_fits (const string &outfile,
  const PowSpec &powspec, int nspecs)
  {
  fitshandle out;
  out.create(outfile);
  write_powspec_to_fits(out,powspec,nspecs);
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/powspec_fitsio.h0000664000175000017500000000450613010375061030005 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file powspec_fitsio.h
 *  Copyright (C) 2003-2013 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef POWSPEC_FITSIO_H
#define POWSPEC_FITSIO_H

#include 

class fitshandle;
class PowSpec;

/*! \defgroup powspec_fitsio_group FITS-based I/O of power spectra */
/*! \{ */

/*! Reads the power spectrum stored in the FITS binary table pointed to by
    \a inp into \a powspec. */
void read_powspec_from_fits (fitshandle &inp, PowSpec &powspec, int nspecs,
  int lmax);
/*! Opens the FITS file \a filename, jumps to HDU \a hdunum, and reads \a nspecs
    columns into \a powspec. \a nspecs must be 1, 4, or 6. */
void read_powspec_from_fits (const std::string &infile,
  PowSpec &powspec, int nspecs, int lmax, int hdunum=2);

/*! Inserts a new binary table into \a out, which contains \a nspecs columns
    of FITS type TDOUBLE, and writes the components of \a powspec into it.
    \a nspecs must be 1, 4, or 6. */
void write_powspec_to_fits (fitshandle &out,
  const PowSpec &powspec, int nspecs);
/*! Creates a new FITS file called \a outfile, inserts a binary table,
    which contains \a nspecs columns of FITS type TDOUBLE, and writes the
    components of \a powspec into it. \a nspecs must be 1, 4, or 6. */
void write_powspec_to_fits (const std::string &outfile,
  const PowSpec &powspec, int nspecs);

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/rotalm_cxx.cc0000664000175000017500000001030513010375061027260 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2005-2011 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "alm.h"
#include "alm_fitsio.h"
#include "fitshandle.h"
#include "alm_powspec_tools.h"
#include "trafos.h"
#include "announce.h"
#include "string_utils.h"
#include "lsconstants.h"

using namespace std;

namespace {

Trafo maketrafo (int num)
  {
  switch (num)
    {
    case  1: return Trafo(2000,2000,Equatorial,Galactic);
    case  2: return Trafo(2000,2000,Galactic,Equatorial);
    case  3: return Trafo(2000,2000,Equatorial,Ecliptic);
    case  4: return Trafo(2000,2000,Ecliptic,Equatorial);
    case  5: return Trafo(2000,2000,Ecliptic,Galactic);
    case  6: return Trafo(2000,2000,Galactic,Ecliptic);
    case  7: return Trafo(1950,1950,Equatorial,Galactic);
    case  8: return Trafo(1950,1950,Galactic,Equatorial);
    case  9: return Trafo(1950,1950,Equatorial,Ecliptic);
    case 10: return Trafo(1950,1950,Ecliptic,Equatorial);
    case 11: return Trafo(1950,1950,Ecliptic,Galactic);
    case 12: return Trafo(1950,1950,Galactic,Ecliptic);
    default: planck_fail("Unsupported transformation "+dataToString(num));
    }
  }

} // unnamed namespace

int main(int argc, const char **argv)
  {
PLANCK_DIAGNOSIS_BEGIN
  module_startup("rotalm_cxx", (argc==5)||(argc==7),
    "Usage: rotalm_cxx    \n"
    "or   : rotalm_cxx      \n\n"
    "itransform: 1: Equatorial (2000) -> Galactic   (2000)\n"
    "            2: Galactic   (2000) -> Equatorial (2000)\n"
    "            3: Equatorial (2000) -> Ecliptic   (2000)\n"
    "            4: Ecliptic   (2000) -> Equatorial (2000)\n"
    "            5: Ecliptic   (2000) -> Galactic   (2000)\n"
    "            6: Galactic   (2000) -> Ecliptic   (2000)\n"
    "            7: Equatorial (1950) -> Galactic   (1950)\n"
    "            8: Galactic   (1950) -> Equatorial (1950)\n"
    "            9: Equatorial (1950) -> Ecliptic   (1950)\n"
    "           10: Ecliptic   (1950) -> Equatorial (1950)\n"
    "           11: Ecliptic   (1950) -> Galactic   (1950)\n"
    "           12: Galactic   (1950) -> Ecliptic   (1950)\n\n"
    "psi, theta, phi: Euler angles (in degrees)\n\n"
    "pol: T or F\n");

  string infile  = argv[1];
  string outfile = argv[2];
  bool polarisation = stringToData(argv[argc-1]);
  rotmatrix rm;
  if (argc==5)
    {
    int trafo = stringToData(argv[3]);
    Trafo tr(maketrafo(trafo));
    rm=tr.Matrix();
    }
  else
    {
    rm.Make_CPAC_Euler_Matrix(degr2rad*stringToData(argv[5]),
                              degr2rad*stringToData(argv[4]),
                              degr2rad*stringToData(argv[3]));
    }

  Alm > almT,almG,almC;

  if (!polarisation)
    {
    int lmax, dummy;
    get_almsize (infile,lmax,dummy);
    read_Alm_from_fits (infile, almT, lmax, lmax);
    rotate_alm(almT,rm);
    write_Alm_to_fits (outfile,almT,lmax,lmax,PLANCK_FLOAT32);
    }
  else
    {
    int lmax, dummy;
    get_almsize_pol (infile,lmax,dummy);
    read_Alm_from_fits (infile, almT, almG, almC, lmax, lmax);
    rotate_alm(almT,almG,almC,rm);
    write_Alm_to_fits (outfile,almT,almG,almC,lmax,lmax,PLANCK_FLOAT32);
    }

PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/smoothing_cxx.cc0000664000175000017500000000030013010375061027763 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  smoothing_cxx_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/smoothing_cxx.par.txt0000664000175000017500000000161713010375061031012 0ustar  zoncazonca00000000000000Parameters read by smoothing_cxx:

fwhm_arcmin (double):
  FWHM (in arcmin) of the Gaussian beam used for smoothing. If the value
  is negative, the smoothing of a Gaussian beam with an FWHM of -fwhm_arcmin
  will be _removed_ from the input map.

nlmax (integer):
  maximum order of l

infile (string):
  input file containing the Healpix map

outfile (string, default=""):
  output file for the smoothed Healpix map

polarisation (bool):
  if false, only an intensity map is smoothed
  if true, an IQU map is smoothed

weighted (bool, default=false):
  if true, weighted quadrature is used

if (weighted)
  healpix_data (string):
    directory containing the Healpix data files
endif

iter_order (integer, default=0)
  number of iterations for the analysis (0: standard analysis)

double_precision (bool, default=false):
  if false, a_lm are read/written in single precision, otherwise in
  double precision.
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/smoothing_cxx_module.cc0000664000175000017500000000757413010375061031354 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2005-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "xcomplex.h"
#include "paramfile.h"
#include "healpix_data_io.h"
#include "alm.h"
#include "healpix_map.h"
#include "healpix_map_fitsio.h"
#include "alm_healpix_tools.h"
#include "alm_powspec_tools.h"
#include "fitshandle.h"
#include "levels_facilities.h"
#include "lsconstants.h"
#include "announce.h"

using namespace std;

namespace {

template void smoothing_cxx (paramfile ¶ms)
  {
  int nlmax = params.template find("nlmax");
  string infile = params.template find("infile");
  string outfile = params.template find("outfile");
  bool polarisation = params.template find("polarisation");
  int num_iter = params.template find("iter_order",0);
  double fwhm = arcmin2rad*params.template find("fwhm_arcmin");
  if (fwhm<0)
    cout << "NOTE: negative FWHM supplied, doing a deconvolution..." << endl;

  if (!polarisation)
    {
    Healpix_Map map;
    read_Healpix_map_from_fits(infile,map,1,2);

    tsize nmod = map.replaceUndefWith0();
    if (nmod!=0)
      cout << "WARNING: replaced " << nmod <<
              " undefined map pixels with a value of 0" << endl;

    double avg=map.average();
    map.Add(T(-avg));

    arr weight;
    get_ring_weights (params,map.Nside(),weight);

    Alm > alm(nlmax,nlmax);
    if (map.Scheme()==NEST) map.swap_scheme();

    map2alm_iter(map,alm,num_iter,weight);
    smoothWithGauss (alm, fwhm);
    alm2map(alm,map);

    map.Add(T(avg));
    write_Healpix_map_to_fits (outfile,map,planckType());
    }
  else
    {
    Healpix_Map mapT, mapQ, mapU;
    read_Healpix_map_from_fits(infile,mapT,mapQ,mapU);

    tsize nmod = mapT.replaceUndefWith0()+mapQ.replaceUndefWith0()
                +mapU.replaceUndefWith0();
    if (nmod!=0)
      cout << "WARNING: replaced " << nmod <<
              " undefined map pixels with a value of 0" << endl;

    double avg=mapT.average();
    mapT.Add(T(-avg));

    arr weight;
    get_ring_weights (params,mapT.Nside(),weight);

    Alm > almT(nlmax,nlmax), almG(nlmax,nlmax), almC(nlmax,nlmax);
    if (mapT.Scheme()==NEST) mapT.swap_scheme();
    if (mapQ.Scheme()==NEST) mapQ.swap_scheme();
    if (mapU.Scheme()==NEST) mapU.swap_scheme();

    map2alm_pol_iter
      (mapT,mapQ,mapU,almT,almG,almC,num_iter,weight);
    smoothWithGauss (almT, almG, almC, fwhm);
    alm2map_pol(almT,almG,almC,mapT,mapQ,mapU);

    mapT.Add(T(avg));
    write_Healpix_map_to_fits (outfile,mapT,mapQ,mapU,planckType());
    }
  }

} // unnamed namespace

int smoothing_cxx_module (int argc, const char **argv)
  {
  module_startup ("smoothing_cxx", argc, argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  bool dp = params.find ("double_precision",false);
  dp ? smoothing_cxx(params) : smoothing_cxx(params);

  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/syn_alm_cxx.cc0000664000175000017500000000027613010375061027432 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  syn_alm_cxx_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/syn_alm_cxx.par.txt0000664000175000017500000000154513010375061030445 0ustar  zoncazonca00000000000000Parameters read by syn_alm_cxx:

nlmax (integer):
  maximum order of l

nmmax (integer):
  maximum order of m (must not be larger than nlmax, default=nlmax)

infile (string):
  input file containing the CMB power spectrum

outfile (string):
  output file name for the calculated a_lm

rand_seed (integer):
  random-number seed

fwhm_arcmin (real):
  FWHM (in arcmin) of a Gaussian beam, which is used to smooth the
  resulting sky a_lm (default=0)

polarisation (bool):
  if false, only the intensity a_lm are generated,
  if true, T, G and C a_lm are generated

if (polarisation)
  full_ps (bool, default=false):
    if false, only TT, GG, CC and TG components of the spectrum are used
    if true, also TC and GC components are used
endif

double_precision (bool, default=false):
  if false, the a_lm are created in single precision,
  otherwise in double precision.
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/syn_alm_cxx_module.cc0000664000175000017500000000565013010375061031000 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "xcomplex.h"
#include "paramfile.h"
#include "planck_rng.h"
#include "alm.h"
#include "alm_fitsio.h"
#include "powspec.h"
#include "powspec_fitsio.h"
#include "alm_powspec_tools.h"
#include "fitshandle.h"
#include "levels_facilities.h"
#include "lsconstants.h"
#include "announce.h"

using namespace std;

namespace {

template void syn_alm_cxx (paramfile ¶ms)
  {
  int nlmax = params.template find("nlmax");
  int nmmax = params.template find("nmmax",nlmax);
  planck_assert(nmmax<=nlmax,"nmmax must not be larger than nlmax");
  string infile = params.template find("infile");
  string outfile = params.template find("outfile");
  int rand_seed = params.template find("rand_seed");
  double fwhm = arcmin2rad*params.template find("fwhm_arcmin",0.);
  bool polarisation = params.template find("polarisation");
  bool full_ps = params.template find("full_ps",false);

  PowSpec powspec;
  int nspecs = polarisation ? (full_ps ? 6 : 4 ) : 1;
  read_powspec_from_fits (infile, powspec, nspecs, nlmax);
  powspec.smoothWithGauss(fwhm);

  planck_rng rng(rand_seed);

  if (polarisation)
    {
    Alm >
      almT(nlmax,nmmax), almG(nlmax,nmmax), almC(nlmax,nmmax);
    create_alm_pol (powspec, almT, almG, almC, rng);
    write_Alm_to_fits(outfile,almT,almG,almC,nlmax,nmmax,planckType());
    }
  else
    {
    Alm > almT(nlmax,nmmax);
    create_alm (powspec, almT, rng);
    write_Alm_to_fits(outfile,almT,nlmax,nmmax,planckType());
    }
  }

} // unnamed namespace

int syn_alm_cxx_module (int argc, const char **argv)
  {
  module_startup ("syn_alm_cxx", argc, argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  bool dp = params.find ("double_precision",false);
  dp ? syn_alm_cxx(params) : syn_alm_cxx(params);
  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/udgrade_cxx.cc0000664000175000017500000000027613010375061027403 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  udgrade_cxx_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/udgrade_cxx_module.cc0000664000175000017500000001156413010375061030752 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2003-2012 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "paramfile.h"
#include "healpix_map.h"
#include "healpix_map_fitsio.h"
#include "fitshandle.h"
#include "levels_facilities.h"
#include "geom_utils.h"
#include "xcomplex.h"
#include "announce.h"

using namespace std;

namespace {

double alpha (const pointing &p1, const pointing &p2)
  {
  vec3 v1(p1), v2(p2);
  vec3 dir(v2-v1);
  return orientation (v2, dir) - orientation (v1,dir);
  }

template void degrade_pol (const Healpix_Map &q1,
  const Healpix_Map &u1, Healpix_Map &q2, Healpix_Map &u2,
  bool pessimistic)
  {
  planck_assert(q1.conformable(u1) && q2.conformable(u2), "map mismatch");
  planck_assert(q2.Nside() sum = 0;
    for (int j=fact*y; j(q1[opix],Healpix_undef)
            ||approx(u1[opix],Healpix_undef)))
          {
          ++hits;
          xcomplex val(q1[opix],u1[opix]);
          double ang=alpha(q2.pix2ang(m),q1.pix2ang(opix));
          xcomplex mul(cos(2*ang),sin(2*ang));
          sum += val*mul;
          }
        }
    q2[m] = T((hits void udgrade_cxx (paramfile ¶ms)
  {
  string infile = params.template find("infile");
  string outfile = params.template find("outfile");
  int nside = params.template find("nside");
  bool polarisation = params.template find("polarisation",false);
  bool pessimistic = params.template find("pessimistic",false);

  if (!polarisation)
    {
    Healpix_Map inmap;
    read_Healpix_map_from_fits(infile,inmap,1,2);
    Healpix_Map outmap (nside,inmap.Scheme(),SET_NSIDE);

    outmap.Import(inmap,pessimistic);
    write_Healpix_map_to_fits (outfile,outmap,planckType());
    }
  else
    {
    Healpix_Map inmap;
    read_Healpix_map_from_fits(infile,inmap,1,2);
    Healpix_Map outmapT (nside,inmap.Scheme(),SET_NSIDE),
                   outmapQ (nside,inmap.Scheme(),SET_NSIDE),
                   outmapU (nside,inmap.Scheme(),SET_NSIDE);
//    planck_assert(inmap.Nside()<=outmapT.Nside(),
//      "degrading not supported for polarised maps");

    outmapT.Import(inmap,pessimistic);
    if ((outmapQ.Nside()("parallel_transport",true))
      {
cout << "Experimental: polarised degrade with parallel transport" << endl;
      read_Healpix_map_from_fits(infile,inmap,2,2);
      Healpix_Map inmap2;
      read_Healpix_map_from_fits(infile,inmap2,3,2);
      degrade_pol (inmap, inmap2, outmapQ, outmapU, pessimistic);
      }
    else
      {
cout << "WARNING: polarised degrade without parallel transport" << endl;
      read_Healpix_map_from_fits(infile,inmap,2,2);
      outmapQ.Import(inmap,pessimistic);
      read_Healpix_map_from_fits(infile,inmap,3,2);
      outmapU.Import(inmap,pessimistic);
      }
    write_Healpix_map_to_fits (outfile,outmapT,outmapQ,outmapU,planckType());
    }
  }

} // unnamed namespace

int udgrade_cxx_module (int argc, const char **argv)
  {
  module_startup ("udgrade_cxx", argc, argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  bool dp = params.find ("double_precision",false);
  dp ? udgrade_cxx(params) : udgrade_cxx(params);

  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/udgrade_harmonic_cxx.cc0000664000175000017500000000030713010375061031256 0ustar  zoncazonca00000000000000#include "levels_facilities.h"
#include "error_handling.h"

int main (int argc, const char **argv)
  {
  PLANCK_DIAGNOSIS_BEGIN
  udgrade_harmonic_cxx_module (argc, argv);
  PLANCK_DIAGNOSIS_END
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Healpix_cxx/udgrade_harmonic_cxx_module.cc0000664000175000017500000001120113010375061032616 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpix_cxx.
 *
 *  Healpix_cxx is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpix_cxx is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpix_cxx; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about HEALPix, see http://healpix.sourceforge.sourceforge.net
 */

/*
 *  Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2012-2013 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "paramfile.h"
#include "alm.h"
#include "xcomplex.h"
#include "healpix_data_io.h"
#include "healpix_map.h"
#include "healpix_map_fitsio.h"
#include "alm_healpix_tools.h"
#include "levels_facilities.h"
#include "announce.h"
#include "lsconstants.h"

using namespace std;

namespace {

template void udgrade_harmonic_cxx (paramfile ¶ms)
  {
  string infile = params.template find("infile");
  string outfile = params.template find("outfile");
  int nlmax = params.template find("nlmax");
  int nside = params.template find("nside");
  int nside_pixwin_in = params.template find("nside_pixwin_in",0);
  planck_assert (nside_pixwin_in>=0,"nside_pixwin_in must be >= 0");
  int nside_pixwin_out = params.template find("nside_pixwin_out",0);
  planck_assert (nside_pixwin_out>=0,"nside_pixwin_out must be >= 0");
  int num_iter = params.template find("iter_order",0);
  bool polarisation = params.template find("polarisation",false);

  string datadir;
  if ((nside_pixwin_in>0) || (nside_pixwin_out>0))
    datadir = params.template find("healpix_data");

  if (!polarisation)
    {
    Healpix_Map map;
    read_Healpix_map_from_fits(infile,map,1,2);

    double avg=map.average();
    map.Add(T(-avg));

    arr weight;
    get_ring_weights (params,map.Nside(),weight);

    Alm > alm(nlmax,nlmax);
    if (map.Scheme()==NEST) map.swap_scheme();
    map2alm_iter(map,alm,num_iter,weight);

    arr temp(nlmax+1);
    if (nside_pixwin_in>0)
      {
      read_pixwin(datadir,nside_pixwin_in,temp);
      for (int l=0; l<=nlmax; ++l)
        temp[l] = 1/temp[l];
      alm.ScaleL (temp);
      }
    if (nside_pixwin_out>0)
      {
      read_pixwin(datadir,nside_pixwin_out,temp);
      alm.ScaleL (temp);
      }

    alm(0,0) += T(avg*sqrt(fourpi));
    map.SetNside(nside,RING);
    alm2map (alm,map);

    write_Healpix_map_to_fits (outfile,map,planckType());
    }
  else
    {
    Healpix_Map mapT, mapQ, mapU;
    read_Healpix_map_from_fits(infile,mapT,mapQ,mapU,2);

    double avg=mapT.average();
    mapT.Add(T(-avg));

    arr weight;
    get_ring_weights (params,mapT.Nside(),weight);

    Alm > almT(nlmax,nlmax), almG(nlmax,nlmax), almC(nlmax,nlmax);
    if (mapT.Scheme()==NEST) mapT.swap_scheme();
    if (mapQ.Scheme()==NEST) mapQ.swap_scheme();
    if (mapU.Scheme()==NEST) mapU.swap_scheme();
    map2alm_pol_iter
      (mapT,mapQ,mapU,almT,almG,almC,num_iter,weight);

    arr temp(nlmax+1), pol(nlmax+1);
    if (nside_pixwin_in>0)
      {
      read_pixwin(datadir,nside_pixwin_in,temp,pol);
      for (int l=0; l<=nlmax; ++l)
        { temp[l] = 1/temp[l]; if (pol[l]!=0.) pol[l] = 1/pol[l]; }
      almT.ScaleL(temp); almG.ScaleL(pol); almC.ScaleL(pol);
      }
    if (nside_pixwin_out>0)
      {
      read_pixwin(datadir,nside_pixwin_out,temp,pol);
      almT.ScaleL(temp); almG.ScaleL(pol); almC.ScaleL(pol);
      }

    almT(0,0) += T(avg*sqrt(fourpi));
    mapT.SetNside(nside,RING);
    mapQ.SetNside(nside,RING);
    mapU.SetNside(nside,RING);
    alm2map_pol (almT,almG,almC,mapT,mapQ,mapU);

    write_Healpix_map_to_fits (outfile,mapT,mapQ,mapU,planckType());
    }
  }

} // unnamed namespace

int udgrade_harmonic_cxx_module (int argc, const char **argv)
  {
  module_startup ("udgrade_harmonic_cxx", argc, argv);
  paramfile params (getParamsFromCmdline(argc,argv));

  bool dp = params.find ("double_precision",false);
  dp ? udgrade_harmonic_cxx(params)
     : udgrade_harmonic_cxx (params);

  return 0;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/c_utils/0000775000175000017500000000000013031130324023752 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/cxx/autotools/c_utils/c_utils.c0000664000175000017500000000471513010375061025575 0ustar  zoncazonca00000000000000/*
 *  This file is part of libc_utils.
 *
 *  libc_utils is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libc_utils is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libc_utils; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libc_utils is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Convenience functions
 *
 *  Copyright (C) 2008-2013 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include "c_utils.h"

void util_fail_ (const char *file, int line, const char *func, const char *msg)
  {
  fprintf(stderr,"%s, %i (%s):\n%s\n",file,line,func,msg);
  exit(1);
  }
void util_warn_ (const char *file, int line, const char *func, const char *msg)
  {
  fprintf(stderr,"%s, %i (%s):\n%s\n",file,line,func,msg);
  }

/* This function tries to avoid allocations with a total size close to a high
   power of two (called the "critical stride" here), by adding a few more bytes
   if necssary. This lowers the probability that two arrays differ by a multiple
   of the critical stride in their starting address, which in turn lowers the
   risk of cache line contention. */
static size_t manipsize(size_t sz)
  {
  const size_t critical_stride=4096, cacheline=64, overhead=32;
  if (sz < (critical_stride/2)) return sz;
  if (((sz+overhead)%critical_stride)>(2*cacheline)) return sz;
  return sz+2*cacheline;
  }

#ifdef __SSE__
#include 
void *util_malloc_ (size_t sz)
  {
  void *res;
  if (sz==0) return NULL;
  res = _mm_malloc(manipsize(sz),16);
  UTIL_ASSERT(res,"_mm_malloc() failed");
  return res;
  }
void util_free_ (void *ptr)
  { if ((ptr)!=NULL) _mm_free(ptr); }
#else
void *util_malloc_ (size_t sz)
  {
  void *res;
  if (sz==0) return NULL;
  res = malloc(manipsize(sz));
  UTIL_ASSERT(res,"malloc() failed");
  return res;
  }
void util_free_ (void *ptr)
  { if ((ptr)!=NULL) free(ptr); }
#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/c_utils/c_utils.h0000664000175000017500000001137413010375061025601 0ustar  zoncazonca00000000000000/*
 *  This file is part of libc_utils.
 *
 *  libc_utils is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libc_utils is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libc_utils; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libc_utils is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file c_utils.h
 *  Convenience functions
 *
 *  Copyright (C) 2008-2013 Max-Planck-Society
 *  \author Martin Reinecke
 *  \note This file should only be included from .c files, NOT from .h files.
 */

#ifndef PLANCK_C_UTILS_H
#define PLANCK_C_UTILS_H

#include 
#include 
#include 

#ifdef __cplusplus
extern "C" {
#endif

void util_fail_ (const char *file, int line, const char *func, const char *msg);
void util_warn_ (const char *file, int line, const char *func, const char *msg);
void *util_malloc_ (size_t sz);
void util_free_ (void *ptr);

#if defined (__GNUC__)
#define UTIL_FUNC_NAME__ __func__
#else
#define UTIL_FUNC_NAME__ "unknown"
#endif

/*! \def UTIL_ASSERT(cond,msg)
    If \a cond is false, print an error message containing function name,
    source file name and line number of the call, as well as \a msg;
    then exit the program with an error status. */
#define UTIL_ASSERT(cond,msg) \
  if(!(cond)) util_fail_(__FILE__,__LINE__,UTIL_FUNC_NAME__,msg)
/*! \def UTIL_WARN(cond,msg)
    If \a cond is false, print an warning containing function name,
    source file name and line number of the call, as well as \a msg. */
#define UTIL_WARN(cond,msg) \
  if(!(cond)) util_warn_(__FILE__,__LINE__,UTIL_FUNC_NAME__,msg)
/*! \def UTIL_FAIL(msg)
    Print an error message containing function name,
    source file name and line number of the call, as well as \a msg;
    then exit the program with an error status. */
#define UTIL_FAIL(msg) \
  util_fail_(__FILE__,__LINE__,UTIL_FUNC_NAME__,msg)

/*! \def ALLOC(ptr,type,num)
    Allocate space for \a num objects of type \a type. Make sure that the
    allocation succeeded, else stop the program with an error. Return the
    resulting pointer in \a ptr. */
#define ALLOC(ptr,type,num) \
  do { (ptr)=(type *)util_malloc_((num)*sizeof(type)); } while (0)
/*! \def RALLOC(type,num)
    Allocate space for \a num objects of type \a type. Make sure that the
    allocation succeeded, else stop the program with an error. Cast the
    resulting pointer to \a (type*). */
#define RALLOC(type,num) \
  ((type *)util_malloc_((num)*sizeof(type)))
/*! \def DEALLOC(ptr)
    Deallocate \a ptr. It must have been allocated using \a ALLOC or
    \a RALLOC. */
#define DEALLOC(ptr) \
  do { util_free_(ptr); (ptr)=NULL; } while(0)
#define RESIZE(ptr,type,num) \
  do { util_free_(ptr); ALLOC(ptr,type,num); } while(0)
#define GROW(ptr,type,sz_old,sz_new) \
  do { \
    if ((sz_new)>(sz_old)) \
      { RESIZE(ptr,type,2*(sz_new));sz_old=2*(sz_new); } \
  } while(0)
/*! \def SET_ARRAY(ptr,i1,i2,val)
    Set the entries \a ptr[i1] ... \a ptr[i2-1] to \a val. */
#define SET_ARRAY(ptr,i1,i2,val) \
  do { \
    ptrdiff_t cnt_; \
    for (cnt_=(i1);cnt_<(i2);++cnt_) (ptr)[cnt_]=(val); \
    } while(0)
/*! \def COPY_ARRAY(src,dest,i1,i2)
    Copy the entries \a src[i1] ... \a src[i2-1] to
    \a dest[i1] ... \a dest[i2-1]. */
#define COPY_ARRAY(src,dest,i1,i2) \
  do { \
    ptrdiff_t cnt_; \
    for (cnt_=(i1);cnt_<(i2);++cnt_) (dest)[cnt_]=(src)[cnt_]; \
    } while(0)

#define ALLOC2D(ptr,type,num1,num2) \
  do { \
    size_t cnt_, num1_=(num1), num2_=(num2); \
    ALLOC((ptr),type *,num1_); \
    ALLOC((ptr)[0],type,num1_*num2_); \
    for (cnt_=1; cnt_(b)) ? (a) : (b))
#define IMIN(a,b) \
  (((a)<(b)) ? (a) : (b))

#define SWAP(a,b,type) \
  do { type tmp_=(a); (a)=(b); (b)=tmp_; } while(0)

#define CHECK_STACK_ALIGN(align) \
  do { \
    double foo; \
    UTIL_WARN((((size_t)(&foo))&(align-1))==0, \
      "WARNING: stack not sufficiently aligned!"); \
    } while(0)

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/c_utils/planck.make0000664000175000017500000000045113010375061026067 0ustar  zoncazonca00000000000000PKG:=c_utils

SD:=$(SRCROOT)/$(PKG)
OD:=$(BLDROOT)/$(PKG)

FULL_INCLUDE+= -I$(SD)

HDR_$(PKG):=$(SD)/*.h
LIB_$(PKG):=$(LIBDIR)/libc_utils.a

OBJ:=c_utils.o walltime_c.o
OBJ:=$(OBJ:%=$(OD)/%)

$(OBJ): $(HDR_$(PKG)) | $(OD)_mkdir
$(LIB_$(PKG)): $(OBJ)

all_hdr+=$(HDR_$(PKG))
all_lib+=$(LIB_$(PKG))
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/c_utils/sse_utils.h0000664000175000017500000000546613010375061026156 0ustar  zoncazonca00000000000000/*
 *  This file is part of libc_utils.
 *
 *  libc_utils is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libc_utils is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libc_utils; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libc_utils is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sse_utils.h
 *  SSE/SSE2/SSE3-related functionality
 *
 *  Copyright (C) 2010,2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SSE_UTILS_H
#define PLANCK_SSE_UTILS_H

#if (defined(__SSE__))

#include 

#ifdef __cplusplus
extern "C" {
#endif

typedef __m128 v4sf; /* vector of 4 floats (SSE1) */

typedef union {
  float f[4];
  v4sf v;
} V4SF;

static inline v4sf build_v4sf (float a, float b, float c, float d)
  { return _mm_set_ps(d,c,b,a); }
static inline void read_v4sf (v4sf v, float *a, float *b, float *c, float *d)
  {
  V4SF tmp;
  tmp.v = v;
  if (a) *a=tmp.f[0];
  if (b) *b=tmp.f[1];
  if (c) *c=tmp.f[2];
  if (d) *d=tmp.f[3];
  }

#ifdef __cplusplus
}
#endif

#endif

#if (defined(__SSE2__))

#include 

#ifdef __cplusplus
extern "C" {
#endif

typedef __m128d v2df; /* vector of 2 doubles (SSE2) */

typedef union {
  double d[2];
  v2df v;
} V2DF;

typedef struct {
  v2df a,b;
} v2df2;
typedef struct {
  V2DF a,b;
} V2DF2;

#define V2DF_SIGNMASK _mm_set1_pd(-0.0)

static inline v2df build_v2df (double a, double b)
  { return _mm_set_pd(b,a); }
static inline void read_v2df (v2df v, double *a, double *b)
  { _mm_store_sd(a,v); _mm_storeh_pd(b,v); }

static inline int v2df_any_gt (v2df a, v2df b)
  {
  return (_mm_movemask_pd(_mm_cmpgt_pd(_mm_andnot_pd(V2DF_SIGNMASK,a),b))!=0);
  }
static inline int v2df_all_ge (v2df a, v2df b)
  {
  return (_mm_movemask_pd(_mm_cmplt_pd(_mm_andnot_pd(V2DF_SIGNMASK,a),b))==0);
  }
static inline V2DF to_V2DF (v2df x)
  { V2DF X; X.v=x; return X; }
static inline V2DF2 to_V2DF2 (v2df2 x)
  { V2DF2 X; X.a.v=x.a; X.b.v=x.b; return X; }
static inline v2df2 to_v2df2 (V2DF2 X)
  { v2df2 x; x.a=X.a.v; x.b=X.b.v; return x; }
static inline v2df2 zero_v2df2(void)
  { v2df2 x; x.a=x.b=_mm_setzero_pd(); return x; }

#ifdef __cplusplus
}
#endif

#endif

#if (defined(__SSE3__))

#include 

#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/c_utils/walltime_c.c0000664000175000017500000000266113010375061026251 0ustar  zoncazonca00000000000000/*
 *  This file is part of libc_utils.
 *
 *  libc_utils is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libc_utils is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libc_utils; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libc_utils is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Functionality for reading wall clock time
 *
 *  Copyright (C) 2010, 2011 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#if defined (_OPENMP)
#include 
#elif defined (USE_MPI)
#include "mpi.h"
#else
#include 
#include 
#endif

#include "walltime_c.h"

double wallTime(void)
  {
#if defined (_OPENMP)
  return omp_get_wtime();
#elif defined (USE_MPI)
  return MPI_Wtime();
#else
  struct timeval t;
  gettimeofday(&t, NULL);
  return t.tv_sec + 1e-6*t.tv_usec;
#endif
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/c_utils/walltime_c.h0000664000175000017500000000320213010375061026246 0ustar  zoncazonca00000000000000/*
 *  This file is part of libc_utils.
 *
 *  libc_utils is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libc_utils is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libc_utils; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libc_utils is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file walltime_c.h
 *  Functionality for reading wall clock time
 *
 *  Copyright (C) 2010 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_WALLTIME_C_H
#define PLANCK_WALLTIME_C_H

#ifdef __cplusplus
extern "C" {
#endif

/*! Returns an approximation of the current wall time (in seconds).
    The first available of the following timers will be used:
    
    
    
  •  \a omp_get_wtime(), if OpenMP is available
    
  •  \a MPI_Wtime(), if MPI is available
    
  •  \a gettimeofday() otherwise
    

    \note Only useful for measuring time differences.
    \note This function has an execution time between 10 and 100 nanoseconds. */
double wallTime(void);

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/0000775000175000017500000000000013031130324024547 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/alloc_utils.h0000664000175000017500000000515513010375061027246 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file alloc_utils.h
 *  Classes providing raw memory allocation and deallocation support.
 *
 *  Copyright (C) 2011-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_ALLOC_UTILS_H
#define PLANCK_ALLOC_UTILS_H

#include 
#include 
#include "datatypes.h"

template  class normalAlloc__
  {
  public:
    static T *alloc(tsize sz) { return (sz>0) ? new T[sz] : 0; }
    static void dealloc (T *ptr) { delete[] ptr; }
  };

template  class alignAlloc__
  {
  private:
//#if (__cplusplus>=201103L)
//    enum { max_nat_align = alignof(std::max_align_t) };
//#else
    enum { max_nat_align = sizeof(void *) };
//#endif

  public:
    static T *alloc(tsize sz)
      {
      using namespace std;
      if (sz==0) return 0;
      planck_assert((align&(align-1))==0,"alignment must be power of 2");
      void *res;
      if (align<=max_nat_align)
        {
        res=malloc(sz*sizeof(T));
        planck_assert(res!=0,"error in malloc()");
        }
      else
        {
        tsize overhead=align-1+sizeof(void*);
        void *ptr=malloc(sz*sizeof(T)+overhead);
        planck_assert(ptr!=0,"error in malloc()");
        tsize sptr=reinterpret_cast(ptr);
        sptr = (sptr+overhead) & ~(align-1);
        void **ptr2 = reinterpret_cast(sptr);
        ptr2[-1]=ptr;
        res=ptr2;
        }
      return static_cast(res);
      }
    static void dealloc(T *ptr)
      {
      using namespace std;
      if (align<=max_nat_align)
        free(ptr);
      else
        {
        if (ptr==0) return;
        void **ptr2 = reinterpret_cast(ptr);
        free (ptr2[-1]);
        }
      }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/announce.cc0000664000175000017500000000631613010375061026700 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  This file contains the implementation of various convenience functions
 *  used by the Planck LevelS package.
 *
 *  Copyright (C) 2002-2011 Max-Planck-Society
 *  Authors: Martin Reinecke, Reinhard Hell
 */

// if we are using g++, check for version 4.0 or higher
#ifdef __GNUC__
#if (__GNUC__<4)
#error your C++ compiler is too old. g++ version 4.0 or higher is required.
#endif
#endif

#include 
#include "announce.h"
#include "openmp_support.h"

using namespace std;

namespace {

void openmp_status()
  {
#ifndef _OPENMP
  cout << "OpenMP: not supported by this binary" << endl;
#else
  int threads = openmp_max_threads();
  if (threads>1)
    cout << "OpenMP active: max. " << threads << " threads." << endl;
  else
    cout << "OpenMP active, but running with 1 thread only." << endl;
#endif
  }

void vec_status()
  {
  cout << "Vector math: ";
#if(defined(__AVX__))
  cout << "AVX" << endl;
#elif(defined(__SSE2__))
  cout << "SSE2" << endl;
#elif(defined(__SSE__))
  cout << "SSE" << endl;
#else
  cout << "not supported by this binary" << endl;
#endif
  }

} //unnamed namespace

void announce (const string &name)
  {
#ifndef VERSION
#define VERSION "?.?"
#endif
  string version = "v" VERSION;
  string name2 = name+" "+version;
  cout << endl << "+-";
  for (tsize m=0; m=2,
    string("Usage:\n  ")+name+" \nor:\n  "
                        +name+" par1=val1 par2=val2 ...", verbose);
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/announce.h0000664000175000017500000000420613010375061026536 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file announce.h
 *  Functions for printing information at startup.
 *
 *  Copyright (C) 2002-2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_ANNOUNCE_H
#define PLANCK_ANNOUNCE_H

#include 

/*! Prints a banner containing \a name, as well as some information about the
    source code and the parallelisation techniques enabled. */
void announce (const std::string &name);

/*! Prints a banner containing \a name and checks if \a argc_valid is true.
    If not, the string \a usage is printed and the program is terminated. */
void module_startup (const std::string &name, bool argc_valid,
  const std::string &usage, bool verbose=true);

/*! Prints a banner containing \a name and checks if \a argc==argc_expected.
    If not, a usage description is given and the program is terminated. */
void module_startup (const std::string &name, int argc, const char **argv,
  int argc_expected, const std::string &argv_expected, bool verbose=true);

/*! Prints a banner containing \a name and checks if \a argc>=2.
    If not, a usage description is given and the program is terminated. */
void module_startup (const std::string &name, int argc, const char **argv,
  bool verbose=true);

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/arr.h0000664000175000017500000005660313010375061025524 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file arr.h
 *  Various high-performance array classes used by the Planck LevelS package.
 *
 *  Copyright (C) 2002-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_ARR_H
#define PLANCK_ARR_H

#include 
#include 
#include 
#include "alloc_utils.h"
#include "datatypes.h"
#include "math_utils.h"

/*! \defgroup arraygroup Array classes */
/*! \{ */

/*! View of a 1D array */
template  class arr_ref
  {
  protected:
    tsize s;
    T *d;

  public:
    /*! Constructs an \a arr_ref of size \a s_, starting at \a d_. */
    arr_ref(T *d_, tsize s_) : s(s_),d(d_) {}

    /*! Returns the current array size. */
    tsize size() const { return s; }

    /*! Writes \a val into every element of the array. */
    void fill (const T &val)
      { for (tsize m=0; m T &operator[] (T2 n) {return d[n];}
    /*! Returns a constant reference to element \a n */
    template const T &operator[] (T2 n) const {return d[n];}

    /*! Returns a pointer to the first array element, or NULL if the array
        is zero-sized. */
    T *begin() { return d; }
    /*! Returns a pointer to the one-past-last array element, or NULL if the
        array is zero-sized. */
    T *end() { return d+s; }
    /*! Returns a constant pointer to the first array element, or NULL if the
        array is zero-sized. */
    const T *begin() const { return d; }
    /*! Returns a constant pointer to the one-past-last array element, or NULL
        if the array is zero-sized. */
    const T *end() const { return d+s; }

    /*! Copies all array elements to \a ptr. */
    template void copyToPtr (T *ptr) const
      { for (tsize m=0; m void sort(Comp comp)
      { std::sort (d,d+s,comp); }

    /*! Helper function for linear interpolation (or extrapolation).
        \a idx and \a val are computed such that
        \a val=d[idx]+frac*(d[idx+1]-d[idx]). If \a vald[s-1], frac will be larger than 1. In all other
        cases \a 0<=frac<=1.

        The array must be ordered in ascending order; no two values may be
        equal. */
    void interpol_helper (const T &val, tsize &idx, double &frac) const
      { ::interpol_helper (d, d+s, val, idx, frac); }

    /*! Helper function for linear interpolation (or extrapolation).
        \a idx and \a val are computed such that
        \a val=d[idx]+frac*(d[idx+1]-d[idx]). If \a comp(val,d[0])==true,
        \a frac will be negative, if \a comp(val,d[s-1])==false, frac will be
        larger than 1. In all other cases \a 0<=frac<=1.

        The array must be ordered such that \a comp(d[i],d[j])==true
        for \a i void interpol_helper (const T &val, Comp comp,
      tsize &idx, double &frac) const
      { ::interpol_helper (d, d+s, val, comp, idx, frac); }

    /*! Returns the minimum and maximum entry in \a minv and \a maxv,
        respectively. Throws an exception if the array is zero-sized. */
    void minmax (T &minv, T &maxv) const
      {
      planck_assert(s>0,"trying to find min and max of a zero-sized array");
      minv=maxv=d[0];
      for (tsize m=1; mmaxv) maxv=d[m];
        }
      }

    /*! Returns \a true, if \a val is found in the array, else \a false. */
    bool contains (const T &val) const
      {
      for (tsize m=0; m class fix_arr
  {
  private:
    T d[sz];

  public:
    /*! Returns the size of the array. */
    tsize size() const { return sz; }

    /*! Returns a reference to element \a n */
    template T &operator[] (T2 n) {return d[n];}
    /*! Returns a constant reference to element \a n */
    template const T &operator[] (T2 n) const {return d[n];}
  };


/*! One-dimensional array type, with selectable storage management. */
template  class arrT: public arr_ref
  {
  private:
    bool own;

    void reset()
      { this->d=0; this->s=0; own=true; }

  public:
    /*! Creates a zero-sized array. */
    arrT() : arr_ref(0,0), own(true) {}
    /*! Creates an array with \a sz entries. */
    explicit arrT(tsize sz) : arr_ref(stm::alloc(sz),sz), own(true) {}
    /*! Creates an array with \a sz entries, and initializes them with
        \a inival. */
    arrT(tsize sz, const T &inival) : arr_ref(stm::alloc(sz),sz), own(true)
      { this->fill(inival); }
    /*! Creates an array with \a sz entries, which uses the memory pointed
        to by \a ptr.
        \note \a ptr will not be deallocated by the destructor.
        \warning Only use this if you REALLY know what you are doing.
        In particular, this is only safely usable if
          
    
          
  • \a T is a POD type
    • 
          
  • \a ptr survives during the lifetime of the array object
    • 
          
  • \a ptr is not subject to garbage collection
    • 
          

        Other restrictions may apply. You have been warned. */
    arrT (T *ptr, tsize sz): arr_ref(ptr,sz), own(false) {}
    /*! Creates an array which is a copy of \a orig. The data in \a orig
        is duplicated. */
    arrT (const arrT &orig): arr_ref(stm::alloc(orig.s),orig.s), own(true)
      { for (tsize m=0; ms; ++m) this->d[m] = orig.d[m]; }
    /*! Frees the memory allocated by the object. */
    ~arrT() { if (own) stm::dealloc(this->d); }

    /*! Allocates space for \a sz elements. The content of the array is
        undefined on exit. \a sz can be 0. If \a sz is the
        same as the current size, no reallocation is performed. */
    void alloc (tsize sz)
      {
      if (sz==this->s) return;
      if (own) stm::dealloc(this->d);
      this->s = sz;
      this->d = stm::alloc(sz);
      own = true;
      }
    /*! Allocates space for \a sz elements. If \a sz is the
        same as the current size, no reallocation is performed.
        All elements are set to \a inival. */
    void allocAndFill (tsize sz, const T &inival)
      { alloc(sz); this->fill(inival); }
    /*! Deallocates the memory held by the array, and sets the array size
        to 0. */
    void dealloc() {if (own) stm::dealloc(this->d); reset();}
    /*! Resizes the array to hold \a sz elements. The existing content of the
        array is copied over to the new array to the extent possible.
        \a sz can be 0. If \a sz is the same as the current size, no
        reallocation is performed. */
    void resize (tsize sz)
      {
      using namespace std;
      if (sz==this->s) return;
      T *tmp = stm::alloc(sz);
      for (tsize m=0; ms); ++m)
        tmp[m]=this->d[m];
      if (own) stm::dealloc(this->d);
      this->s = sz;
      this->d = tmp;
      own = true;
      }

    /*! Changes the array to be a copy of \a orig. */
    arrT &operator= (const arrT &orig)
      {
      if (this==&orig) return *this;
      alloc (orig.s);
      for (tsize m=0; ms; ++m) this->d[m] = orig.d[m];
      return *this;
      }

    /*! Changes the array to be a copy of the std::vector \a orig. */
    template void copyFrom (const std::vector &orig)
      {
      alloc (orig.size());
      for (tsize m=0; ms; ++m) this->d[m] = orig[m];
      }
    /*! Changes the std::vector \a vec to be a copy of the object. */
    template void copyTo (std::vector &vec) const
      {
      vec.clear(); vec.reserve(this->s);
      for (tsize m=0; ms; ++m) vec.push_back(this->d[m]);
      }

    /*! Reserves space for \a sz elements, then copies \a sz elements
        from \a ptr into the array. */
    template void copyFromPtr (const T2 *ptr, tsize sz)
      {
      alloc(sz);
      for (tsize m=0; ms; ++m) this->d[m]=ptr[m];
      }

    /*! Assigns the contents and size of \a other to the array.
        \note On exit, \a other is zero-sized! */
    void transfer (arrT &other)
      {
      if (own) stm::dealloc(this->d);
      this->d=other.d;
      this->s=other.s;
      own=other.own;
      other.reset();
      }
    /*! Swaps contents and size with \a other. */
    void swap (arrT &other)
      {
      std::swap(this->d,other.d);
      std::swap(this->s,other.s);
      std::swap(own,other.own);
      }
  };

/*! One-dimensional array type. */
template 
  class arr: public arrT >
  {
  public:
    /*! Creates a zero-sized array. */
    arr() : arrT >() {}
    /*! Creates an array with \a sz entries. */
    explicit arr(tsize sz) : arrT >(sz) {}
    /*! Creates an array with \a sz entries, and initializes them with
        \a inival. */
    arr(tsize sz, const T &inival) : arrT >(sz,inival) {}
    /*! Creates an array with \a sz entries, which uses the memory pointed
        to by \a ptr.
        \note \a ptr will not be deallocated by the destructor.
        \warning Only use this if you REALLY know what you are doing.
        In particular, this is only safely usable if
          
    
          
  • \a T is a POD type
    • 
          
  • \a ptr survives during the lifetime of the array object
    • 
          
  • \a ptr is not subject to garbage collection
    • 
          

        Other restrictions may apply. You have been warned. */
    arr (T *ptr, tsize sz): arrT >(ptr,sz) {}
    /*! Creates an array which is a copy of \a orig. The data in \a orig
        is duplicated. */
    arr (const arr &orig): arrT >(orig) {}
  };

/*! One-dimensional array type, with selectable storage alignment. */
template 
  class arr_align: public arrT >
  {
  public:
    /*! Creates a zero-sized array. */
    arr_align() : arrT >() {}
    /*! Creates an array with \a sz entries. */
    explicit arr_align(tsize sz) : arrT >(sz) {}
    /*! Creates an array with \a sz entries, and initializes them with
        \a inival. */
    arr_align(tsize sz, const T &inival)
      : arrT >(sz,inival) {}
  };


/*! Two-dimensional array type, with selectable storage management.
    The storage ordering is the same as in C.
    An entry is located by address arithmetic, not by double dereferencing.
    The indices start at zero. */
template  class arr2T
  {
  private:
    tsize s1, s2;
    arrT d;

  public:
    /*! Creates a zero-sized array. */
    arr2T() : s1(0), s2(0) {}
    /*! Creates an array with the dimensions \a sz1 and \a sz2. */
    arr2T(tsize sz1, tsize sz2)
      : s1(sz1), s2(sz2), d(s1*s2) {}
    /*! Creates an array with the dimensions  \a sz1 and \a sz2
        and initializes them with \a inival. */
    /*! Creates an array with the dimensions \a sz1 and \a sz2 from existing
        pointer. */
    arr2T(T* p, tsize sz1, tsize sz2)
      : s1(sz1), s2(sz2), d(p, s1*s2) {}
    arr2T(tsize sz1, tsize sz2, const T &inival)
      : s1(sz1), s2(sz2), d (s1*s2)
      { fill(inival); }
    /*! Creates the array as a copy of \a orig. */
    arr2T(const arr2T &orig)
      : s1(orig.s1), s2(orig.s2), d(orig.d) {}
    /*! Frees the memory associated with the array. */
    ~arr2T() {}

    /*! Returns the first array dimension. */
    tsize size1() const { return s1; }
    /*! Returns the second array dimension. */
    tsize size2() const { return s2; }
    /*! Returns the total array size, i.e. the product of both dimensions. */
    tsize size () const { return s1*s2; }

    /*! Allocates space for an array with \a sz1*sz2 elements.
        The content of the array is undefined on exit.
        \a sz1 or \a sz2 can be 0. If \a sz1*sz2 is the same as the
        currently allocated space, no reallocation is performed. */
    void alloc (tsize sz1, tsize sz2)
      {
      if (sz1*sz2 != d.size())
        d.alloc(sz1*sz2);
      s1=sz1; s2=sz2;
      }
    /*! Allocates space for an array with \a sz1*sz2 elements.
        All elements are set to \a inival.
        \a sz1 or \a sz2 can be 0. If \a sz1*sz2 is the same as the
        currently allocated space, no reallocation is performed. */
    void allocAndFill (tsize sz1, tsize sz2, const T &inival)
      { alloc(sz1,sz2); fill(inival); }
    /*! Allocates space for an array with \a sz1*sz2 elements.
        The content of the array is undefined on exit.
        \a sz1 or \a sz2 can be 0. If \a sz1*sz2 is smaller than the
        currently allocated space, no reallocation is performed. */
    void fast_alloc (tsize sz1, tsize sz2)
      {
      if (sz1*sz2<=d.size())
        { s1=sz1; s2=sz2; }
      else
        alloc(sz1,sz2);
      }
    /*! Deallocates the space and makes the array zero-sized. */
    void dealloc () {d.dealloc(); s1=0; s2=0;}

    /*! Sets all array elements to \a val. */
    void fill (const T &val)
      { for (tsize m=0; m T *operator[] (T2 n) {return &d[n*s2];}
    /*! Returns a constant pointer to the beginning of slice \a n. */
    template const T *operator[] (T2 n) const {return &d[n*s2];}

    /*! Returns a reference to the element with the indices \a n1 and \a n2. */
    template T &operator() (T2 n1, T3 n2)
      {return d[n1*s2 + n2];}
    /*! Returns a constant reference to the element with the indices
        \a n1 and \a n2. */
    template const T &operator() (T2 n1, T3 n2) const
      {return d[n1*s2 + n2];}

    /*! Returns the minimum and maximum entry in \a minv and \a maxv,
        respectively. Throws an exception if the array is zero-sized. */
    void minmax (T &minv, T &maxv) const
      {
      planck_assert(s1*s2>0,
        "trying to find min and max of a zero-sized array");
      minv=maxv=d[0];
      for (tsize m=1; mmaxv) maxv=d[m];
        }
      }

    /*! Swaps contents and sizes with \a other. */
    void swap (arr2T &other)
      {
      d.swap(other.d);
      std::swap(s1,other.s1);
      std::swap(s2,other.s2);
      }

    /*! Returns \c true if the array and \a other have the same dimensions,
        else \c false. */
    template bool conformable
      (const arr2T &other) const
      { return (other.size1()==s1) && (other.size2()==s2); }
  };

/*! Two-dimensional array type. The storage ordering is the same as in C.
    An entry is located by address arithmetic, not by double dereferencing.
    The indices start at zero. */
template 
  class arr2: public arr2T >
  {
  public:
    /*! Creates a zero-sized array. */
    arr2() : arr2T > () {}
    /*! Creates an array with the dimensions \a sz1 and \a sz2. */
    arr2(tsize sz1, tsize sz2) : arr2T > (sz1,sz2) {}
    /*! Creates an array with the dimensions \a sz1 and \a sz2 from existing
        pointer. */
    arr2(T* p, tsize sz1, tsize sz2) : arr2T > (p,sz1,sz2) {}
    /*! Creates an array with the dimensions  \a sz1 and \a sz2
        and initializes them with \a inival. */
    arr2(tsize sz1, tsize sz2, const T &inival)
      : arr2T > (sz1,sz2,inival) {}
  };

/*! Two-dimensional array type, with selectable storage alignment.
    The storage ordering is the same as in C.
    An entry is located by address arithmetic, not by double dereferencing.
    The indices start at zero. */
template 
  class arr2_align: public arr2T >
  {
  public:
    /*! Creates a zero-sized array. */
    arr2_align() : arr2T > () {}
    /*! Creates an array with the dimensions \a sz1 and \a sz2. */
    arr2_align(tsize sz1, tsize sz2)
      : arr2T > (sz1,sz2) {}
    /*! Creates an array with the dimensions  \a sz1 and \a sz2
        and initializes them with \a inival. */
    arr2_align(tsize sz1, tsize sz2, const T &inival)
      : arr2T > (sz1,sz2,inival) {}
  };

/*! Two-dimensional array type. An entry is located by double dereferencing,
    i.e. via an array of pointers. The indices start at zero. */
template  class arr2b
  {
  private:
    tsize s1, s2;
    arr d;
    arr d1;

    void fill_d1()
      { for (tsize m=0; m T *operator[] (T2 n) {return d1[n];}
    /*! Returns a constant pointer to the beginning of slice \a n. */
    template const T *operator[] (T2 n) const {return d1[n];}

    /*! Returns a pointer to the beginning of the pointer array. */
    T **p0() {return &d1[0];}
  };


/*! Three-dimensional array type. The storage ordering is the same as in C.
    An entry is located by address arithmetic, not by multiple dereferencing.
    The indices start at zero. */
template  class arr3
  {
  private:
    tsize s1, s2, s3, s2s3;
    arr d;

  public:
    /*! Creates a zero-sized array. */
    arr3() : s1(0), s2(0), s3(0), s2s3(0), d(0) {}
    /*! Creates an array with the dimensions \a sz1, \a sz2 and \a sz3. */
    arr3(tsize sz1, tsize sz2, tsize sz3)
      : s1(sz1), s2(sz2), s3(sz3), s2s3(s2*s3), d(s1*s2*s3) {}
    /*! Creates the array as a copy of \a orig. */
    arr3(const arr3 &orig)
      : s1(orig.s1), s2(orig.s2), s3(orig.s3), s2s3(orig.s2s3), d(orig.d) {}
    /*! Frees the memory associated with the array. */
    ~arr3() {}

    /*! Returns the first array dimension. */
    tsize size1() const { return s1; }
    /*! Returns the second array dimension. */
    tsize size2() const { return s2; }
    /*! Returns the third array dimension. */
    tsize size3() const { return s3; }
    /*! Returns the total array size, i.e. the product of all dimensions. */
    tsize size () const { return s1*s2*s3; }

    /*! Allocates space for an array with \a sz1*sz2*sz3 elements.
        The content of the array is undefined on exit. */
    void alloc (tsize sz1, tsize sz2, tsize sz3)
      {
      d.alloc(sz1*sz2*sz3);
      s1=sz1; s2=sz2; s3=sz3; s2s3=s2*s3;
      }
    /*! Deallocates the space and makes the array zero-sized. */
    void dealloc () {d.dealloc(); s1=0; s2=0; s3=0; s2s3=0;}

    /*! Sets all array elements to \a val. */
    void fill (const T &val)
      { d.fill(val); }

    /*! Changes the array to be a copy of \a orig. */
    arr3 &operator= (const arr3 &orig)
      {
      if (this==&orig) return *this;
      alloc (orig.s1, orig.s2, orig.s3);
      d = orig.d;
      return *this;
      }

    /*! Returns a reference to the element with the indices
        \a n1, \a n2 and \a n3. */
    template T &operator()
      (T2 n1, T3 n2, T4 n3)
      {return d[n1*s2s3 + n2*s3 + n3];}
    /*! Returns a constant reference to the element with the indices
        \a n1, \a n2 and \a n3. */
    template const T &operator()
      (T2 n1, T3 n2, T4 n3) const
      {return d[n1*s2s3 + n2*s3 + n3];}

    /*! Swaps contents and sizes with \a other. */
    void swap (arr3 &other)
      {
      d.swap(other.d);
      std::swap(s1,other.s1);
      std::swap(s2,other.s2);
      std::swap(s3,other.s3);
      std::swap(s2s3,other.s2s3);
      }

    /*! Returns \c true if the array and \a other have the same dimensions,
        else \c false. */
    template bool conformable (const arr3 &other) const
      { return (other.size1()==s1)&&(other.size2()==s2)&&(other.size3()==s3); }
  };

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/bstream.h0000664000175000017500000001654613010375061026377 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file bstream.h
 *  Classes for binary I/O with streams
 *
 *  Copyright (C) 2010 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_BSTREAM_H
#define PLANCK_BSTREAM_H

#include 
#include 
#include 
#include "datatypes.h"

/*! An object of this class can be cast to a \a bool, which indicates whether
    the computer architecture is big-endian (true) or little-endian (false). */
class EndianTest__
  {
  private:
    bool big_end;

  public:
    EndianTest__()
      {
      union { uint16 i16; uint8 i8; } tmp;
      tmp.i16 = 1;
      big_end = (tmp.i8==0);
      }
    operator bool() const { return big_end; }
  };

const EndianTest__ big_endian;

template inline void byteswap_helper__ (char *);
template<> inline void byteswap_helper__<1> (char *)
  {}
template<> inline void byteswap_helper__<2> (char *val)
  {
  using namespace std; 
  swap (val[0],val[1]);
  }
template<> inline void byteswap_helper__<4> (char *val)
  {
  using namespace std;
  swap (val[0],val[3]); swap (val[1],val[2]);
  }
template<> inline void byteswap_helper__<8> (char *val)
  {
  using namespace std;
  swap (val[0],val[7]); swap (val[1],val[6]);
  swap (val[2],val[5]); swap (val[3],val[4]);
  }

/*! Performs an endianness conversion on \a val.
    \note \a T must be a primitive data type! */
template inline void byteswap (T &val)
  { byteswap_helper__ (reinterpret_cast (&val)); }

const bool file_is_lsb=big_endian, file_is_msb=!big_endian,
           file_is_natural=false;

/*! Class for writing binary data to a stream. */
class bostream
  {
  private:
    std::ostream &s;
    bool doswap;

  public:
    /*! Creates a new object which is attached to \a s_ and performs
        endianness conversion if \a doswap_==true. */
    bostream (std::ostream &s_, bool doswap_=false)
      : s(s_), doswap(doswap_) {}

    /*! Writes a binary representation of \a num objects of type \a T
        (stored in \a data) to the attached stream. Endianness conversion
        is performed if requested in the constructor.
        \note \a T must be a primitive data type! */
    template bostream &put (const T *data, size_t num)
      {
      if ((sizeof(T)>1) && doswap)
        for (size_t m=0; m (&tmp), sizeof(T));
          }
      else
        s.write (reinterpret_cast (data), num*sizeof(T));
      return *this;
      }
    /*! Writes a binary representation of \a data to the attached stream.
        Endianness conversion is performed if requested in the constructor.
        \note \a T must be a primitive data type! */
    template bostream &operator<< (const T &data)
      {
      put(&data,1);
      return *this;
      }

    bool getSwap() const
      { return doswap; }
    void setSwap(bool newswap)
      { doswap=newswap; }
    void flipSwap()
      { doswap=!doswap; }
  };

/*! Class for reading binary data from a stream. */
class bistream
  {
  private:
    std::istream &s;
    bool doswap;

  public:
    /*! Creates a new object which is attached to \a s_ and performs
        endianness conversion if \a doswap_==true. */
    bistream (std::istream &s_, bool doswap_=false)
      : s(s_), doswap(doswap_) {}

    /*! Reads a binary representation of \a num objects of type \a T
        from the attached stream and stores them in \a data. Endianness
        conversion is performed if requested in the constructor.
        \note \a T must be a primitive data type! */
    template bistream &get (T *data, size_t num)
      {
      s.read (reinterpret_cast (data), num*sizeof(T));
      if ((sizeof(T)>1) && doswap)
        for (size_t m=0; m bistream &operator>> (T &data)
      {
      get (&data,1);
      return *this;
      }

    bool getSwap() const
      { return doswap; }
    void setSwap(bool newswap)
      { doswap=newswap; }
    void flipSwap()
      { doswap=!doswap; }
  };

class bofstream: public std::ofstream
  {
  private:
    bool doswap;

  public:
    /*! */
    bofstream (const char *fname, bool doswap_)
      : std::ofstream(fname,std::ios::binary), doswap(doswap_) {}

    template bofstream &operator<< (const T &data)
      {
      if (doswap)
        {
        T tmp = data;
        byteswap (tmp);
        write (reinterpret_cast (&tmp), sizeof(T));
        }
      else
        write (reinterpret_cast (&data), sizeof(T));
      return *this;
      }
    template bofstream &put (const T *data, size_t num)
      {
      if (doswap)
        for (size_t m=0; m (&tmp), sizeof(T));
          }
      else
        write (reinterpret_cast (data), num*sizeof(T));
      return *this;
      }

    bool getSwap() const
      { return doswap; }
    void setSwap(bool newswap)
      { doswap=newswap; }
    void flipSwap()
      { doswap=!doswap; }
  };

class bifstream: public std::ifstream
  {
  private:
    bool doswap;

  public:
    /*! */
    bifstream ()
      : doswap(false) {}
    bifstream (const char *fname, bool doswap_)
      : std::ifstream(fname,std::ios::binary), doswap(doswap_) {}

    void open (const char *fname, bool doswap_)
      {
      doswap=doswap_;
      std::ifstream::open(fname,std::ios::binary);
      }

    template bifstream &operator>> (T &data)
      {
      read (reinterpret_cast (&data), sizeof(T));
      if (doswap) byteswap (data);
      return *this;
      }
    template bifstream &get (T *data, size_t num)
      {
      read (reinterpret_cast (data), num*sizeof(T));
      if (doswap)
        for (size_t m=0; m

template class RGB_tuple
  {
  public:
    T r, g, b;

    RGB_tuple () {}
    RGB_tuple (T rv, T gv, T bv)
      : r (rv), g (gv), b (bv) {}
    template explicit RGB_tuple (const RGB_tuple &orig)
      : r(orig.r), g(orig.g), b(orig.b) {}

    const RGB_tuple &operator= (const RGB_tuple &Col2)
      { r=Col2.r; g=Col2.g; b=Col2.b; return *this; }
    const RGB_tuple &operator+= (const RGB_tuple &Col2)
      { r+=Col2.r; g+=Col2.g; b+=Col2.b; return *this; }
    const RGB_tuple &operator*= (T fac)
      { r*=fac; g*=fac; b*=fac; return *this; }
    RGB_tuple operator+ (const RGB_tuple &Col2) const
      { return RGB_tuple (r+Col2.r, g+Col2.g, b+Col2.b); }
    RGB_tuple operator- (const RGB_tuple &Col2) const
      { return RGB_tuple (r-Col2.r, g-Col2.g, b-Col2.b); }
    template RGB_tuple operator* (T2 factor) const
      { return RGB_tuple (r*factor, g*factor, b*factor); }
    template friend inline RGB_tuple operator* (T2 factor,
      const RGB_tuple &Col)
      { return RGB_tuple (Col.r*factor, Col.g*factor, Col.b*factor); }

    void Set (T r2, T g2, T b2)
      { r=r2; g=g2; b=b2; }

    friend std::ostream &operator<< (std::ostream &os, const RGB_tuple &c)
      {
      os << "(" << c.r << ", " << c.g << ", " << c.b << ")";
      return os;
      }
  };

typedef RGB_tuple Colour;

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/compress_utils.h0000664000175000017500000001372413010375061030010 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file compress_utils.h
 *  Support for compression of integer arrays.
 *
 *  Copyright (C) 2013-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_COMPRESS_UTILS_H
#define PLANCK_COMPRESS_UTILS_H

#include 
#include 
#include 

#include "datatypes.h"
#include "error_handling.h"
#include "math_utils.h"

class obitstream
  {
  private:
    std::vector data;
    tsize bitpos;

    template void put_internal (const T &val, uint8 bits)
      {
      int bitsleft = 8-(bitpos&7);
      if (bitsleft==8) data.push_back(0);
      if (bits<=bitsleft) // wbits==bits
        {
        data.back() |= ((val&((T(1)<>(bits-bitsleft))&((1< void put (const T &val, uint8 bits)
      {
      if (bits==0) return;
      planck_assert(bits<=(sizeof(T)<<3),"too many bits for this data type");
//      planck_assert(val-(val&((T(1)< &state() const
      { return data; }
  };

class ibitstream
  {
  private:
    const std::vector data;
    tsize bitpos;

    template void get_internal (T &val, int bits)
      {
      int bitsleft = 8-(bitpos&7);
      if (bits<=bitsleft)
        {
        val |= ((data[bitpos>>3]>>(bitsleft-bits))&((1<>3])&((1< &indata) : data(indata), bitpos(0) {}

    template T get (uint8 bits)
      {
      if (bits==0) return T(0);
      planck_assert(bits<=(sizeof(T)<<3),"too many bits for this data type");
      planck_assert((bitpos+bits)<=8*data.size(),"reading past end of stream");
      T res=T(0);
      get_internal(res,bits);
      return res;
      }
  };

template struct notNegativeHelper__
  { notNegativeHelper__(const T &) {} };
template struct notNegativeHelper__
  {
  notNegativeHelper__(const T &val)
    { planck_assert(val>=T(0),"numbers must be nonnegative");}
  };
template void assertNotNegative(const T &val)
  { notNegativeHelper__::is_signed> dummy(val); }

template void interpol_encode2 (Iter l, Iter r, obitstream &obs,
  int shift)
  {
  if (r-l<=1) return;
  typedef std::iterator_traits traits;
  typedef typename traits::value_type T;

  Iter m=l+(r-l)/2;
  T nval = ((*r-*l)>>shift) - (r-l) + 1;
  if (nval<=1) return;

  uint8 nb = 1+ilog2(nval-1);
  T val = ((*m)>>shift)-(((*l)>>shift)+(m-l));
  T nshort=(T(1)<>1);
  if (val>=nrot)
    val-=nrot;
  else
    val+=(nval-nrot);
#endif
  if (val void interpol_encode (Iter l, Iter r, obitstream &obs)
  {
  typedef std::iterator_traits traits;
  typedef typename traits::value_type T;

  if (l==r) // empty range
    { obs.put(0,8); return; }

  assertNotNegative(*l);

  T combo=*l;
  for (Iter i=l+1; i!=r; ++i)
    {
    planck_assert(*i>*(i-1),"numbers not strictly increasing");
    combo|=*i;
    }
  int shift = trailingZeros(combo);
  T maxnum=(*(r-1))>>shift;
  if (T(r-l)>maxnum) maxnum=T(r-l);
  uint8 maxbits=1+ilog2(maxnum);
  obs.put(maxbits,8);
  obs.put(shift,8);
  obs.put(r-l,maxbits);
  obs.put((*l)>>shift,maxbits);
  if (r-l==1) return;
  obs.put((*(r-1))>>shift,maxbits);
  interpol_encode2(l,r-1,obs,shift);
  }

template void interpol_decode2 (Iter l, Iter r, ibitstream &ibs,
  int shift)
  {
  if (r-l<=1) return;
  typedef std::iterator_traits traits;
  typedef typename traits::value_type T;

  Iter m=l+(r-l)/2;
  T nval = ((*r-*l)>>shift) - (r-l) + 1;
  T val=0;

  if (nval>1)
    {
    uint8 nb = 1+ilog2(nval-1);
    T nshort=(T(1)<(nb-1);
    if (val>=nshort)
      val=(val<<1)+ ibs.get(1) - nshort;
#if 0
    // optional rotation
    T nrot=nval-(nshort>>1);
    if (val<(nval-nrot))
      val+=nrot;
    else
      val-=(nval-nrot);
#endif
    }
  *m=*l+(((m-l)+val)< void interpol_decode (std::vector &v, ibitstream &ibs)
  {
  uint8 maxbits=ibs.get(8);
  if (maxbits==0) { v.clear(); return; }
  int shift = ibs.get(8);
  v.resize(ibs.get(maxbits));
  v[0]=ibs.get(maxbits)<(maxbits)<Modules page for an overview
  of the supplied functionality.
 */
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/datatypes.h0000664000175000017500000002564113010375061026734 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file datatypes.h
 *  This file defines various platform-independent data types.
 *  If any of the requested types is not available, compilation aborts
 *  with an error (unfortunately a rather obscure one).
 *
 *  Copyright (C) 2004-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_DATATYPES_H
#define PLANCK_DATATYPES_H

#include 
#include 
#include "xcomplex.h"
#include "error_handling.h"

// Template magic to select the proper data types. These templates
// should not be used outside this file.

template  struct sizeChooserHelper__
  { typedef void TYPE; };

template  struct sizeChooserHelper__
  { typedef T TYPE; };

template  struct sizeChooserHelper2__
  { typedef T1 TYPE; };

template  struct sizeChooserHelper2__ 
  { typedef T2 TYPE; };

template  struct sizeChooserHelper2__ 
  { typedef T3 TYPE; };

template <> struct sizeChooserHelper2__ 
  { };

template 
  struct sizeChooser__
  {
  typedef typename sizeChooserHelper2__
    ::TYPE,
     typename sizeChooserHelper__::TYPE,
     typename sizeChooserHelper__::TYPE >::TYPE TYPE;
  };

#if (__cplusplus>=201103L)

#include 

typedef int8_t int8;
typedef uint8_t uint8;

typedef int16_t int16;
typedef uint16_t uint16;

typedef int32_t int32;
typedef uint32_t uint32;

typedef int64_t int64;
typedef uint64_t uint64;

#else

typedef signed char int8;
typedef unsigned char uint8;

typedef sizeChooser__<2, short, int>::TYPE
  int16;
typedef sizeChooser__<2, unsigned short, unsigned int>::TYPE
  uint16;

typedef sizeChooser__<4, int, long, short>::TYPE
  int32;
typedef sizeChooser__<4, unsigned int, unsigned long, unsigned short>::TYPE
  uint32;

typedef sizeChooser__<8, long, long long>::TYPE
  int64;
typedef sizeChooser__<8, unsigned long, unsigned long long>::TYPE
  uint64;

#endif

typedef sizeChooser__<4, float, double>::TYPE
  float32;
typedef sizeChooser__<8, double, long double>::TYPE
  float64;

/*! unsigned integer type which should be used for array sizes */
typedef std::size_t tsize;
/*! signed integer type which should be used for relative array indices */
typedef std::ptrdiff_t tdiff;

/*! mapping of Planck data types to integer constants */
enum PDT {
       PLANCK_INT8    =  0,
       PLANCK_UINT8   =  1,
       PLANCK_INT16   =  2,
       PLANCK_UINT16  =  3,
       PLANCK_INT32   =  4,
       PLANCK_UINT32  =  5,
       PLANCK_INT64   =  6,
       PLANCK_UINT64  =  7,
       PLANCK_FLOAT32 =  8,
       PLANCK_FLOAT64 =  9,
       PLANCK_BOOL    = 10,
       PLANCK_STRING  = 11,
       PLANCK_INVALID = -1 };

/*! Returns the \a PDT constant associated with \a T. */
template inline PDT planckType()
  { planck_fail(T::UNSUPPORTED_DATA_TYPE); }
template<> inline PDT planckType       () { return PLANCK_INT8;   }
template<> inline PDT planckType      () { return PLANCK_UINT8;  }
template<> inline PDT planckType      () { return PLANCK_INT16;  }
template<> inline PDT planckType     () { return PLANCK_UINT16; }
template<> inline PDT planckType      () { return PLANCK_INT32;  }
template<> inline PDT planckType     () { return PLANCK_UINT32; }
template<> inline PDT planckType      () { return PLANCK_INT64;  }
template<> inline PDT planckType     () { return PLANCK_UINT64; }
template<> inline PDT planckType    () { return PLANCK_FLOAT32;}
template<> inline PDT planckType    () { return PLANCK_FLOAT64;}
template<> inline PDT planckType       () { return PLANCK_BOOL;   }
template<> inline PDT planckType() { return PLANCK_STRING; }

/*! Returns the size (in bytes) of the Planck data type \a type. */
inline int type2size (PDT type)
  {
  switch (type)
    {
    case PLANCK_INT8   :
    case PLANCK_UINT8  :
    case PLANCK_BOOL   :
    case PLANCK_STRING : return 1;
    case PLANCK_INT16  :
    case PLANCK_UINT16 : return 2;
    case PLANCK_INT32  :
    case PLANCK_UINT32 :
    case PLANCK_FLOAT32: return 4;
    case PLANCK_INT64  :
    case PLANCK_UINT64 :
    case PLANCK_FLOAT64: return 8;
    default:
      planck_fail ("type2size: unsupported data type");
    }
  }

/*! Converts the string \a type to a \a PDT. */
inline PDT string2type(const std::string &type)
  {
  if (type=="FLOAT64") return PLANCK_FLOAT64;
  if (type=="FLOAT32") return PLANCK_FLOAT32;
  if (type=="INT8")    return PLANCK_INT8;
  if (type=="UINT8")   return PLANCK_UINT8;
  if (type=="INT16")   return PLANCK_INT16;
  if (type=="UINT16")  return PLANCK_UINT16;
  if (type=="INT32")   return PLANCK_INT32;
  if (type=="UINT32")  return PLANCK_UINT32;
  if (type=="INT64")   return PLANCK_INT64;
  if (type=="UINT64")  return PLANCK_UINT64;
  if (type=="BOOL")    return PLANCK_BOOL;
  if (type=="STRING")  return PLANCK_STRING;
  planck_fail ("string2type: unknown data type '"+type+"'");
  }

/*! Converts the Planck data type \a type to a C string. */
inline const char *type2string (PDT type)
  {
  switch (type)
    {
    case PLANCK_INT8   : return "INT8";
    case PLANCK_UINT8  : return "UINT8";
    case PLANCK_INT16  : return "INT16";
    case PLANCK_UINT16 : return "UINT16";
    case PLANCK_INT32  : return "INT32";
    case PLANCK_UINT32 : return "UINT32";
    case PLANCK_INT64  : return "INT64";
    case PLANCK_UINT64 : return "UINT64";
    case PLANCK_FLOAT32: return "FLOAT32";
    case PLANCK_FLOAT64: return "FLOAT64";
    case PLANCK_BOOL   : return "BOOL";
    case PLANCK_STRING : return "STRING";
    default:
      planck_fail ("type2string: unsupported data type");
    }
  }

/*! Returns a C string describing the data type \a T. */
template inline const char *type2typename ()
  { planck_fail(T::UNSUPPORTED_DATA_TYPE); }
template<> inline const char *type2typename ()
  { return "signed char"; }
template<> inline const char *type2typename ()
  { return "unsigned char"; }
template<> inline const char *type2typename ()
  { return "short"; }
template<> inline const char *type2typename ()
  { return "unsigned short"; }
template<> inline const char *type2typename ()
  { return "int"; }
template<> inline const char *type2typename ()
  { return "unsigned int"; }
template<> inline const char *type2typename ()
  { return "long"; }
template<> inline const char *type2typename ()
  { return "unsigned long"; }
template<> inline const char *type2typename ()
  { return "long long"; }
template<> inline const char *type2typename ()
  { return "unsigned long long"; }
template<> inline const char *type2typename ()
  { return "float"; }
template<> inline const char *type2typename ()
  { return "double"; }
template<> inline const char *type2typename ()
  { return "long double"; }
template<> inline const char *type2typename ()
  { return "bool"; }
template<> inline const char *type2typename ()
  { return "std::string"; }

/*! mapping of "native" data types to integer constants */
enum NDT {
       NAT_CHAR,
       NAT_SCHAR,
       NAT_UCHAR,
       NAT_SHORT,
       NAT_USHORT,
       NAT_INT,
       NAT_UINT,
       NAT_LONG,
       NAT_ULONG,
       NAT_LONGLONG,
       NAT_ULONGLONG,
       NAT_FLOAT,
       NAT_DOUBLE,
       NAT_LONGDOUBLE,
       NAT_FCMPLX,
       NAT_DCMPLX,
       NAT_BOOL,
       NAT_STRING };

/*! Returns the \a NDT constant associated with \a T. */
template inline NDT nativeType()
  { planck_fail(T::UNSUPPORTED_DATA_TYPE); }
template<> inline NDT nativeType              () { return NAT_CHAR;      }
template<> inline NDT nativeType       () { return NAT_SCHAR;     }
template<> inline NDT nativeType     () { return NAT_UCHAR;     }
template<> inline NDT nativeType             () { return NAT_SHORT;     }
template<> inline NDT nativeType    () { return NAT_USHORT;    }
template<> inline NDT nativeType               () { return NAT_INT;       }
template<> inline NDT nativeType      () { return NAT_UINT;      }
template<> inline NDT nativeType              () { return NAT_LONG;      }
template<> inline NDT nativeType     () { return NAT_ULONG;     }
template<> inline NDT nativeType         () { return NAT_LONGLONG;  }
template<> inline NDT nativeType() { return NAT_ULONGLONG; }
template<> inline NDT nativeType             () { return NAT_FLOAT;     }
template<> inline NDT nativeType            () { return NAT_DOUBLE;    }
template<> inline NDT nativeType       () { return NAT_LONGDOUBLE;}
template<> inline NDT nativeType          () { return NAT_FCMPLX;    }
template<> inline NDT nativeType          () { return NAT_DCMPLX;    }
template<> inline NDT nativeType              () { return NAT_BOOL;      }
template<> inline NDT nativeType       () { return NAT_STRING;    }

/*! Returns the size (in bytes) of the native data type \a type. */
inline int ndt2size (NDT type)
  {
  switch (type)
    {
    case NAT_CHAR      :
    case NAT_SCHAR     :
    case NAT_UCHAR     : return sizeof(char);
    case NAT_SHORT     :
    case NAT_USHORT    : return sizeof(short);
    case NAT_INT       :
    case NAT_UINT      : return sizeof(int);
    case NAT_LONG      :
    case NAT_ULONG     : return sizeof(long);
    case NAT_LONGLONG  :
    case NAT_ULONGLONG : return sizeof(long long);
    case NAT_FLOAT     : return sizeof(float);
    case NAT_DOUBLE    : return sizeof(double);
    case NAT_LONGDOUBLE: return sizeof(long double);
    case NAT_FCMPLX    : return sizeof(fcomplex);
    case NAT_DCMPLX    : return sizeof(dcomplex);
    case NAT_BOOL      : return sizeof(bool);
    default:
      planck_fail ("ndt2size: unsupported data type");
    }
  }

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/error_handling.cc0000664000175000017500000000334313010375061030064 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Utilities for error reporting
 *
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include "error_handling.h"

using namespace std;

PlanckError::PlanckError(const string &message) : msg (message) {}
PlanckError::PlanckError(const char *message) : msg (message) {}

//virtual
PlanckError::~PlanckError() {}

void planck_failure__(const char *file, int line, const char *func,
  const string &msg)
  {
  cerr << "Error encountered at " << file << ", line " << line << endl;
  if (func) cerr << "(function " << func << ")" << endl;
  if (msg!="") cerr << endl << msg << endl;
  cerr << endl;
  }

void planck_failure__(const char *file, int line, const char *func,
  const char *msg)
  { planck_failure__ (file,line,func,string(msg)); }

void killjob__()
  { throw; }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/error_handling.h0000664000175000017500000000605713010375061027733 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file error_handling.h
 *  Utilities for error reporting
 *
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  Authors: Reinhard Hell, Martin Reinecke
 */

#ifndef PLANCK_ERROR_HANDLING_H
#define PLANCK_ERROR_HANDLING_H

#include 
#include 

#if defined (__GNUC__)
#define PLANCK_FUNC_NAME__ __PRETTY_FUNCTION__
#else
#define PLANCK_FUNC_NAME__ 0
#endif

void planck_failure__(const char *file, int line, const char *func,
  const std::string &msg);
void planck_failure__(const char *file, int line, const char *func,
  const char *msg);
void killjob__();

class PlanckError
  {
  private:
    std::string msg;

  public:
    explicit PlanckError(const std::string &message);
    explicit PlanckError(const char *message);

    virtual const char* what() const
      { return msg.c_str(); }

    virtual ~PlanckError();
  };

/*! \defgroup errorgroup Error handling */
/*! \{ */

/*! Writes diagnostic output and exits with an error status. */
#define planck_fail(msg) \
do { planck_failure__(__FILE__,__LINE__,PLANCK_FUNC_NAME__,msg); \
throw PlanckError(msg); } while(0)

/*! Throws a PlanckError without diagnostic message. */
#define planck_fail_quietly(msg) \
do { throw PlanckError(msg); } while(0)

/*! Writes diagnostic output and exits with an error status if \a testval
    is \a false. */
#define planck_assert(testval,msg) \
do { if (testval); else planck_fail(msg); } while(0)

/*! Macro for improving error diagnostics. Should be placed immediately
    after the opening brace of \c main(). Must be used in conjunction with
    \c PLANCK_DIAGNOSIS_END. */
#define PLANCK_DIAGNOSIS_BEGIN try {
/*! Macro for improving error diagnostics. Should be placed immediately
    before the closing brace of \c main(). Must be used in conjunction with
    \c PLANCK_DIAGNOSIS_BEGIN. */
#define PLANCK_DIAGNOSIS_END \
} \
catch (PlanckError &) \
  { killjob__(); /* no need for further diagnostics; they were shown already */ } \
catch (std::exception &e) \
  { std::cerr << "std::exception: " << e.what() << std::endl; killjob__(); } \
catch (...) \
  { std::cerr << "Unknown exception" << std::endl; killjob__(); }

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/fftpack_support.h0000664000175000017500000000736613010375061030154 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2004-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_FFTPACK_SUPPORT_H
#define PLANCK_FFTPACK_SUPPORT_H

#include "ls_fft.h"
#include "arr.h"
#include "xcomplex.h"

class cfft
  {
  private:
    tsize n;
    complex_plan plan;

  public:
    cfft () : n(0), plan(0) {}
    cfft (tsize size_)
      : n(size_), plan(make_complex_plan(size_)) {}
    cfft (const cfft &orig)
      : n(orig.n), plan(copy_complex_plan(orig.plan)) {}
    ~cfft ()
      { if (plan!=0) kill_complex_plan (plan); }
    cfft &operator=(const cfft &orig)
      {
      if (n!=orig.n)
        {
        if (plan!=0) kill_complex_plan (plan);
        n=orig.n;
        plan = copy_complex_plan(orig.plan);
        }
      return *this;
      }
    void Set (tsize size_)
      {
      if (n==size_) return;
      if (plan!=0) kill_complex_plan (plan);
      n=size_;
      plan=make_complex_plan(size_);
      }

    tsize size() const
      { return n; }

    void forward (double *data)
      { complex_plan_forward(plan,data); }
    void backward (double *data)
      { complex_plan_backward(plan,data); }
    void forward (dcomplex *data)
      { complex_plan_forward(plan,reinterpret_cast(data)); }
    void backward (dcomplex *data)
      { complex_plan_backward(plan,reinterpret_cast(data)); }
    void forward (arr &data)
      { forward(reinterpret_cast(&data[0])); }
    void backward (arr &data)
      { backward(reinterpret_cast(&data[0])); }
  };

class rfft
  {
  private:
    tsize n;
    real_plan plan;

  public:
    rfft () : n(0), plan(0) {}
    rfft (const rfft &orig)
      : n(orig.n), plan(copy_real_plan(orig.plan)) {}
    rfft (tsize size_)
      : n(size_), plan(make_real_plan(size_)) {}
    ~rfft ()
      { if (plan!=0) kill_real_plan (plan); }
    rfft &operator=(const rfft &orig)
      {
      if (n!=orig.n)
        {
        if (plan!=0) kill_real_plan (plan);
        n=orig.n;
        plan = copy_real_plan(orig.plan);
        }
      return *this;
      }
    void Set (tsize size_)
      {
      if (n==size_) return;
      if (plan!=0) kill_real_plan (plan);
      n=size_;
      plan=make_real_plan(size_);
      }

    tsize size() const
      { return n; }

    void forward_fftpack (double *data)
      { real_plan_forward_fftpack(plan,data); }
    void backward_fftpack (double *data)
      { real_plan_backward_fftpack(plan,data); }
    void forward_fftpack (arr &data)
      { forward_fftpack(&(data[0])); }
    void backward_fftpack (arr &data)
      { backward_fftpack(&(data[0])); }
    void forward_c (arr &data)
      { real_plan_forward_c(plan,reinterpret_cast(&data[0])); }
    void backward_c (arr &data)
      { real_plan_backward_c(plan,reinterpret_cast(&data[0])); }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/fitshandle.cc0000664000175000017500000005526013010375061027215 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  This file contains the implementation of the FITS I/O helper class
 *  used by the Planck LevelS package.
 *
 *  Copyright (C) 2002-2011 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include 
#include 
#include "fitsio.h"
#include "fitshandle.h"
#include "string_utils.h"

#define FPTR (static_cast (fptr))
#define OFPTR (static_cast (orig.fptr))

using namespace std;

namespace {

template inline int fitsType();
template<> inline int fitsType () { return TFLOAT;  }
template<> inline int fitsType() { return TDOUBLE; }

int type2bitpix (PDT type)
  {
  switch (type)
    {
    case PLANCK_FLOAT32: return FLOAT_IMG;
    case PLANCK_FLOAT64: return DOUBLE_IMG;
    default: planck_fail ("unsupported component type");
    }
  }

/*! Converts a FITS type code (i.e. the data type of a FITS column) to the
    corresponding Planck type code. */
PDT ftc2type (int ftc)
  {
  switch (ftc)
    {
    case TLOGICAL : return PLANCK_BOOL;
    case TBYTE    : return PLANCK_INT8;
    case TSHORT   : return PLANCK_INT16;
    case TINT     :
    case TINT32BIT: return PLANCK_INT32;
    case TLONGLONG: return PLANCK_INT64;
    case TFLOAT   : return PLANCK_FLOAT32;
    case TDOUBLE  : return PLANCK_FLOAT64;
    case TSTRING  : return PLANCK_STRING;
    default: planck_fail ("unsupported component type");
    }
  }

/*! Converts a Planck type code to the corresponding FITS type code
    (i.e. the data type of a FITS column). */
int type2ftc (PDT type)
  {
  switch (type)
    {
    case PLANCK_BOOL   : return TLOGICAL;
    case PLANCK_INT8   :
    case PLANCK_UINT8  : return TBYTE;
    case PLANCK_INT16  : return TSHORT;
    case PLANCK_INT32  : return TINT;
    case PLANCK_INT64  : return TLONGLONG;
    case PLANCK_FLOAT32: return TFLOAT;
    case PLANCK_FLOAT64: return TDOUBLE;
    case PLANCK_STRING : return TSTRING;
    default: planck_fail ("unsupported component type");
    }
  }

const char *type2fitschar (PDT type)
  {
  switch (type)
    {
    case PLANCK_BOOL   : return "L";
    case PLANCK_FLOAT32: return "E";
    case PLANCK_FLOAT64: return "D";
    case PLANCK_INT8   :
    case PLANCK_UINT8  : return "B";
    case PLANCK_INT16  : return "I";
    case PLANCK_INT32  : return "J";
    case PLANCK_INT64  : return "K";
    case PLANCK_STRING : return "A";
    default:
      planck_fail(string("unknown data type ")+type2string(type));
    }
  }

const char *type2asciiform (PDT type)
  {
  switch (type)
    {
    case PLANCK_FLOAT32: return "E14.7";
    case PLANCK_FLOAT64: return "D23.15";
    case PLANCK_UINT8  : return "I3";
    case PLANCK_INT8   : return "I4";
    case PLANCK_INT16  : return "I6";
    case PLANCK_INT32  : return "I11";
    case PLANCK_INT64  : return "I22";
    default:
      planck_fail(string("unknown data type ")+type2string(type));
    }
  }

string fixkey (const string &key)
  {
  for (tsize m=0; mcolumns_.size())) return false;
  return true;
  }
bool fitshandle::image_hdu () const
  { return hdutype_==IMAGE_HDU; }

void fitshandle::init_image()
  {
  int naxis;
  fits_get_img_type (FPTR, &bitpix_, &status);
  fits_get_img_dim (FPTR, &naxis, &status);
  check_errors();
  arr naxes(naxis);
  fits_get_img_sizell (FPTR, naxis, &naxes[0], &status);
  for (long m=0; m(data), &status);
  nrows_ = max(nrows_,offset+ndata);
  check_errors();
  }

void fitshandle::getKeyHelper(const string &name) const
  {
  if (status==KEY_NO_EXIST)
    {
    fits_clear_errmsg();
    status=0;
    planck_fail("fitshandle::get_key(): key '"+name+"' not found");
    }
  check_errors();
  }

fitshandle::fitshandle ()
  : status(0), fptr(0), hdutype_(INVALID), bitpix_(INVALID), nrows_(0) {}

fitshandle::~fitshandle()
  { clean_all(); }

void fitshandle::open (const string &fname)
  {
  clean_all();
  fitsfile *ptr;
  fits_open_file(&ptr, fname.c_str(), READONLY, &status);
  fptr=ptr;
  check_errors();
  init_data();
  }

void fitshandle::create (const string &fname)
  {
  clean_all();
  fitsfile *ptr;
  fits_create_file(&ptr, fname.c_str(), &status);
  fptr=ptr;
  fits_write_imghdr(FPTR, 8, 0, 0, &status); // insert empty PHDU
  fits_write_date(FPTR, &status);
  check_errors();
  init_data();
  }

// static
void fitshandle::delete_file (const string &name)
  {
  fitsfile *ptr;
  int stat = 0;
  fits_open_file(&ptr, name.c_str(), READWRITE, &stat);
  fits_delete_file(ptr, &stat);
  if (stat==0) return;

  char msg[81];
  fits_get_errstatus (stat, msg);
  cerr << msg << endl;
  while (fits_read_errmsg(msg)) cerr << msg << endl;
  planck_fail("FITS error");
  }

string fitshandle::fileName() const
  {
  planck_assert(connected(),"handle not connected to a file");
  char *fname = new char[2048];
  fits_file_name(FPTR, fname, &status);
  check_errors();
  string result(fname);
  delete[] fname;
  return result;
  }

void fitshandle::goto_hdu (int hdu)
  {
  int curhdu;
  fits_get_hdu_num(FPTR,&curhdu);
  if (curhdu!=hdu)
    {
    fits_movabs_hdu(FPTR, hdu, &hdutype_, &status);
    check_errors();
    init_data();
    }
  }

int fitshandle::num_hdus () const
  {
  int result;
  fits_get_num_hdus (FPTR, &result, &status);
  check_errors();
  return result;
  }

void fitshandle::insert_bintab (const vector &cols,
  const string &extname)
  {
  clean_data();
  int ncol=cols.size();
  arr2b ttype(ncol,81), tform(ncol,81), tunit(ncol,81);

  for (long m=0; m(extname.c_str()), 0, &status);
  check_errors();
  init_data();
  }

void fitshandle::insert_asctab (const vector &cols,
  const string &extname)
  {
  clean_data();
  int ncol=cols.size();
  arr2b ttype(ncol,81), tform(ncol,81), tunit(ncol,81);

  for (long m=0; m(extname.c_str()), &status);
  check_errors();
  init_data();
  }

void fitshandle::insert_image (PDT type, const vector &Axes)
  {
  clean_data();
  arr tmpax(Axes.size());
  for (long m=0; m
  void fitshandle::insert_image (PDT type, const arr2 &data)
  {
  clean_data();
  arr tmpax(2);
  tmpax[0] = data.size2(); tmpax[1] = data.size1();
  fits_insert_imgll (FPTR, type2bitpix(type), 2, &tmpax[0], &status);
  arr2 &tmparr = const_cast &> (data);
  fits_write_img (FPTR, fitsType(), 1, tmpax[0]*tmpax[1],
    &tmparr[0][0], &status);
  check_errors();
  init_data();
  }

template void fitshandle::insert_image (PDT type, const arr2 &data);
template void fitshandle::insert_image (PDT type, const arr2 &data);

void fitshandle::write_checksum()
  {
  planck_assert(connected(),"handle not connected to a file");
  fits_write_chksum (FPTR, &status);
  check_errors();
  }

const vector &fitshandle::axes() const
  {
  planck_assert(image_hdu(),"not connected to an image");
  return axes_;
  }
const string &fitshandle::colname(int i) const
  {
  planck_assert(table_hdu(i),"incorrect FITS table access");
  return columns_[i-1].name();
  }
const string &fitshandle::colunit(int i) const
  {
  planck_assert(table_hdu(i),"incorrect FITS table access");
  return columns_[i-1].unit();
  }
int64 fitshandle::repcount(int i) const
  {
  planck_assert(table_hdu(i),"incorrect FITS table access");
  return columns_[i-1].repcount();
  }
PDT fitshandle::coltype(int i) const
  {
  planck_assert(table_hdu(i),"incorrect FITS table access");
  return columns_[i-1].type();
  }
int fitshandle::ncols() const
  {
  planck_assert(table_hdu(1),"incorrect FITS table access");
  return columns_.size();
  }
int64 fitshandle::nrows() const
  {
  planck_assert(table_hdu(1),"incorrect FITS table access");
  return nrows_;
  }
int64 fitshandle::nelems(int i) const
  {
  planck_assert(table_hdu(i),"incorrect FITS table access");
  if (columns_[i-1].type()==PLANCK_STRING) return nrows_;
  return nrows_*columns_[i-1].repcount();
  }
int64 fitshandle::efficientChunkSize(int i) const
  {
  planck_assert(table_hdu(1),"incorrect FITS table access");
  long int res;
  fits_get_rowsize(FPTR, &res, &status);
  planck_assert(res>=1,"bad recommended FITS chunk size");
  check_errors();
  return res*columns_[i-1].repcount();
  }

void fitshandle::get_all_keys(vector &keys) const
  {
  keys.clear();
  char card[81];
  const char *inclist[] = { "*" };
  planck_assert(connected(),"handle not connected to a file");
  fits_read_record (FPTR, 0, card, &status);
  check_errors();
  while (true)
    {
    fits_find_nextkey (FPTR, const_cast(inclist), 1,
      0, 0, card, &status);
    if (status!=0) break;
    if (fits_get_keyclass(card)==TYP_USER_KEY)
      {
      char keyname[80];
      int dummy;
      fits_get_keyname(card, keyname, &dummy, &status);
      check_errors();
      keys.push_back(trim(keyname));
      }
    check_errors();
    }
  if (status==KEY_NO_EXIST) { fits_clear_errmsg(); status=0; }
  check_errors();
  }

void fitshandle::set_key_void (const string &key, const void *value,
  PDT type, const string &comment)
  {
  planck_assert(connected(),"handle not connected to a file");
  string key2 = fixkey(key);
  switch (type)
    {
    case PLANCK_INT8:
    case PLANCK_UINT8:
    case PLANCK_INT16:
    case PLANCK_INT32:
    case PLANCK_INT64:
    case PLANCK_FLOAT32:
    case PLANCK_FLOAT64:
      fits_update_key (FPTR, type2ftc(type), const_cast(key2.c_str()),
        const_cast(value), const_cast(comment.c_str()),
        &status);
      break;
    case PLANCK_BOOL:
      {
      int val = *(static_cast(value));
      fits_update_key (FPTR, TLOGICAL, const_cast(key2.c_str()),
        &val, const_cast(comment.c_str()), &status);
      break;
      }
    case PLANCK_STRING:
      {
      string val = *(static_cast(value));
      fits_update_key_longstr (FPTR, const_cast(key2.c_str()),
        const_cast(val.c_str()), const_cast(comment.c_str()),
        &status);
      break;
      }
    default:
      planck_fail ("unsupported data type in set_key_void()");
    }
  check_errors();
  }

void fitshandle::get_key_void (const string &name, void *value, PDT type) const
  {
  planck_assert(connected(),"handle not connected to a file");
  switch (type)
    {
    case PLANCK_INT8:
    case PLANCK_UINT8:
    case PLANCK_INT16:
    case PLANCK_INT32:
    case PLANCK_INT64:
    case PLANCK_FLOAT32:
    case PLANCK_FLOAT64:
      fits_read_key (FPTR, type2ftc(type), const_cast(name.c_str()),
        value, 0, &status);
      getKeyHelper(name);
      break;
    case PLANCK_BOOL:
      {
      int val;
      fits_read_key (FPTR, TLOGICAL, const_cast(name.c_str()), &val, 0,
        &status);
      getKeyHelper(name);
      *(static_cast(value))=val;
      break;
      }
    case PLANCK_STRING:
      {
      char *tmp=0;
      fits_read_key_longstr (FPTR, const_cast(name.c_str()), &tmp, 0,
        &status);
      getKeyHelper(name);
      *(static_cast(value))=tmp;
      if (tmp) free(tmp);
      break;
      }
    default:
      planck_fail ("unsupported data type in get_key_void()");
    }
  check_errors();
  }

void fitshandle::delete_key (const string &name)
  {
  planck_assert(connected(),"handle not connected to a file");
  fits_delete_key (FPTR, const_cast(name.c_str()), &status);
  check_errors();
  }

void fitshandle::add_comment(const string &comment)
  {
  planck_assert(connected(),"handle not connected to a file");
  fits_write_comment(FPTR,const_cast(comment.c_str()),&status);
  check_errors();
  }

bool fitshandle::key_present(const string &name) const
  {
  char card[81];
  planck_assert(connected(),"handle not connected to a file");
  fits_read_card(FPTR, const_cast(name.c_str()), card, &status);
  if (status==KEY_NO_EXIST)
    { fits_clear_errmsg(); status=0; return false; }
  check_errors();
  return true;
  }

void fitshandle::assert_pdmtype (const string &pdmtype) const
  {
  string type;
  get_key("PDMTYPE",type);
  if (pdmtype==type) return;
  cerr << "PDMTYPE " << pdmtype << " expected, but found " << type << endl;
  }

void fitshandle::read_column_raw_void
  (int colnum, void *data, PDT type, int64 num, int64 offset) const
  {
  switch (type)
    {
    case PLANCK_INT8:
    case PLANCK_UINT8:
    case PLANCK_INT16:
    case PLANCK_INT32:
    case PLANCK_INT64:
    case PLANCK_FLOAT32:
    case PLANCK_FLOAT64:
    case PLANCK_BOOL:
      read_col (colnum, data, num, type, offset); break;
    case PLANCK_STRING:
      {
      string *data2 = static_cast (data);
      planck_assert(table_hdu(colnum),"incorrect FITS table access");
      planck_assert (num<=(nrows_-offset),
        "read_column(): array too large");
      arr2b tdata(safe_cast(num),
                        safe_cast(columns_[colnum-1].repcount()+1));
      int dispwidth;
      fits_get_col_display_width(FPTR, colnum, &dispwidth, &status);
      planck_assert(dispwidth<=columns_[colnum-1].repcount(),"column too wide");
      fits_read_col (FPTR, TSTRING, colnum, offset+1, 1, num,
        0, tdata.p0(), 0, &status);
      check_errors();
      for (long m=0;m (data);
      planck_assert(table_hdu(colnum),"incorrect FITS table access");
      tsize stringlen = safe_cast(columns_[colnum-1].repcount()+1);
      arr2b tdata(safe_cast(num), stringlen);
      for (long m=0;m(data), &status);
  check_errors();
  }

void fitshandle::write_subimage_void (const void *data, PDT type, tsize sz,
  int64 offset)
  {
  planck_assert(image_hdu(),"not connected to an image");
  fits_write_img (FPTR, type2ftc(type), 1+offset, sz, const_cast(data),
    &status);
  check_errors();
  }

template void fitshandle::read_image (arr2 &data) const
  {
  planck_assert(image_hdu(),"not connected to an image");
  planck_assert (axes_.size()==2, "wrong number of dimensions");
  data.alloc(safe_cast(axes_[0]), safe_cast(axes_[1]));
  fits_read_img (FPTR, fitsType(), 1, axes_[0]*axes_[1], 0, &data[0][0], 0,
    &status);
  check_errors();
  }

template void fitshandle::read_image (arr2 &data) const;
template void fitshandle::read_image (arr2 &data) const;

template void fitshandle::read_image (arr3 &data) const
  {
  planck_assert(image_hdu(),"not connected to an image");
  planck_assert (axes_.size()==3, "wrong number of dimensions");
  data.alloc(safe_cast(axes_[0]), safe_cast(axes_[1]),
    safe_cast(axes_[2]));
  fits_read_img (FPTR, fitsType(), 1, axes_[0]*axes_[1]*axes_[2],
    0, &data(0,0,0), 0, &status);
  check_errors();
  }

template void fitshandle::read_image (arr3 &data) const;
template void fitshandle::read_image (arr3 &data) const;

template void fitshandle::read_subimage
  (arr2 &data, int xl, int yl) const
  {
  planck_assert(image_hdu(),"not connected to an image");
  planck_assert (axes_.size()==2, "wrong number of dimensions");
  for (tsize m=0; m(), (xl+m)*axes_[1]+yl+1,
      data.size2(), 0, &data[m][0], 0, &status);
  check_errors();
  }

template void fitshandle::read_subimage
  (arr2 &data, int xl, int yl) const;
template void fitshandle::read_subimage
  (arr2 &data, int xl, int yl) const;

void fitshandle::read_subimage_void (void *data, PDT type, tsize ndata,
  int64 offset) const
  {
  planck_assert(image_hdu(),"not connected to an image");
  fits_read_img (FPTR, type2ftc(type), 1+offset, ndata, 0, data, 0, &status);
  check_errors();
  }

namespace {

class cfitsio_checker
  {
  public:
    cfitsio_checker()
      {
      float fitsversion;
      planck_assert(fits_get_version(&fitsversion),
        "error calling fits_get_version()");
      int v_header  = nearest(1000.*CFITSIO_VERSION),
          v_library = nearest(1000.*fitsversion);
      if (v_header!=v_library)
        cerr << endl << "WARNING: version mismatch between CFITSIO header (v"
             << dataToString(v_header*0.001) << ") and linked library (v"
             << dataToString(v_library*0.001) << ")." << endl << endl;
      }
  };

cfitsio_checker Cfitsio_Checker;

} // unnamed namespace
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/fitshandle.h0000664000175000017500000003036113010375061027052 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file fitshandle.h
 *  Declaration of the FITS I/O helper class used by LevelS
 *
 *  Copyright (C) 2002-2014 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_FITSHANDLE_H
#define PLANCK_FITSHANDLE_H

#include 
#include 
#include "arr.h"
#include "datatypes.h"
#include "safe_cast.h"

/*! \defgroup fitsgroup FITS-related functionality */
/*! \{ */

/*! Class containing information about a single column in a FITS table. */
class fitscolumn
  {
  private:
    std::string name_, unit_;
    int64 repcount_;
    PDT type_;

  public:
    fitscolumn();
    /*! Creates a \a fitscolumn with name \a nm, unit \a un, a repetition
        count of \a rc, and a Planck type of \a tp. */
    fitscolumn (const std::string &nm, const std::string &un, int64 rc, PDT tp);
    ~fitscolumn();

    /*! Returns the column name. */
    const std::string &name() const {return name_;}
    /*! Returns the column unit string. */
    const std::string &unit() const {return unit_;}
    /*! Returns the repetition count of the column. */
    int64 repcount() const {return repcount_;}
    /*! Returns the Planck type of the column. */
    PDT type() const {return type_;}
  };

/*! Class for performing I/O from/to FITS files. */
class fitshandle
  {
  private:
    enum { INVALID = -4711 };

    mutable int status;
    void *fptr;
    int hdutype_, bitpix_;
    std::vector axes_;
    std::vector columns_;
    int64 nrows_;

    void check_errors() const;

    void clean_data();
    void clean_all();

    bool connected() const { return (hdutype_!=INVALID); }
    bool table_hdu (tsize col) const;
    bool image_hdu () const;

    void init_image();
    void init_asciitab();
    void init_bintab();
    void init_data();

    void read_col (int colnum, void *data, int64 ndata, PDT type,
                   int64 offset) const;
    void write_col (int colnum, const void *data, int64 ndata, PDT type,
                   int64 offset);

    void getKeyHelper(const std::string &name) const;

  public:
    /*! the list of modes in which a \a fitshandle can be opened. */
    enum openmethod { CREATE, /*!< the file must not yet exist */
                      OPEN    /*!< the file must already exist */
                    };

    /*! \name File-level access and manipulation. */
    /*! \{ */

    /*! Creates an unconnected \a fitshandle. */
    fitshandle ();
    /*! Performs all necessary cleanups. */
    ~fitshandle();

    /*! Connects to the file \a fname. */
    void open (const std::string &fname);
    /*! Creates the file \a fname and connects to it. */
    void create (const std::string &fname);
    /*! Closes the current file. */
    void close () { clean_all(); }
    /*! Deletes the file with name \a name. */
    static void delete_file (const std::string &name);
    /*! Returns the name of the connected file. */
    std::string fileName() const;
    /*! Jumps to the HDU with the absolute number \a hdu. */
    void goto_hdu (int hdu);
    /*! Returns the number of HDUs in the file. */
    int num_hdus () const;
    /*! Asserts that the PDMTYPE of the current HDU is \a pdmtype. */
    void assert_pdmtype (const std::string &pdmtype) const;
    /*! Inserts a binary table described by \a cols.
        The HDU has the name \a extname. */
    void insert_bintab (const std::vector &cols,
      const std::string &extname="xtension");
    /*! Inserts an ASCII table described by \a cols. The width of the
        columns is chosen automatically, in a way that avoids truncation.
        The HDU has the name \a extname. */
    void insert_asctab (const std::vector &cols,
      const std::string &extname="xtension");
    /*! Inserts a FITS image with the type given by \a type and dimensions
        given by \a Axes. */
    void insert_image (PDT type, const std::vector &Axes);
    /*! Inserts a 2D FITS image with the type given by \a type, whose
        contents are given in \a data. */
    template
      void insert_image (PDT type, const arr2 &data);

    /*! Computes the checksum for the current HDU and writes it into the
        header. */
    void write_checksum();

    /*! \} */

    /*! \name Information about the current HDU */
    /*! \{ */

    /*! Returns the dimensions of the current image. */
    const std::vector &axes() const;
    /*! Returns the name of column \a #i. */
    const std::string &colname(int i) const;
    /*! Returns the unit of column \a #i. */
    const std::string &colunit(int i) const;
    /*! Returns repetition count of column \a #i. */
    int64 repcount(int i) const;
    /*! Returns the Planck type for column \a #i. */
    PDT coltype(int i) const;
    /*! Returns the number of columns in the current table. */
    int ncols() const;
    /*! Returns the number of rows in the current table. */
    int64 nrows() const;
    /*! Returns the total number of elements (nrows*repcount)
        in column \a #i. */
    int64 nelems(int i) const;
    /*! Returns the number of elements that should be read/written in a single
        call for optimum performance. This depends on the current HDU. */
    int64 efficientChunkSize(int i) const;

    /*! \} */

    /*! \name Keyword-handling methods */
    /*! \{ */

    /*! Returns a list of all user-defined keys in the current HDU
        in \a keys. */
    void get_all_keys (std::vector &keys) const;

    void set_key_void (const std::string &key, const void *value, PDT type,
      const std::string &comment="");
    /*! Updates \a key with \a value and \a comment. */
    template void set_key (const std::string &name,
      const T &value, const std::string &comment="")
      { set_key_void (name, &value, planckType(), comment); }
    /*! Deletes \a key from the header. */
    void delete_key (const std::string &name);
    /*! Adds \a comment as a comment line. */
    void add_comment (const std::string &comment);
    void get_key_void (const std::string &key, void *value, PDT type) const;
    /*! Reads the value belonging to \a key and returns it in \a value. */
    template void get_key (const std::string &name, T &value) const
      { get_key_void (name,&value,planckType()); }
    /*! Returms the value belonging to \a key. */
    template T get_key (const std::string &name) const
      { T tmp; get_key(name, tmp); return tmp; }
    /*! Returns \a true if \a key is present, else \a false. */
    bool key_present (const std::string &name) const;

    /*! \} */

    /*! \name Methods for table data I/O */
    /*! \{ */

    void read_column_raw_void
      (int colnum, void *data, PDT type, int64 num, int64 offset=0) const;
    /*! Copies \a num elements from column \a colnum to the memory pointed
        to by \a data, starting at offset \a offset in the column. */
    template void read_column_raw
      (int colnum, T *data, int64 num, int64 offset=0) const
      { read_column_raw_void (colnum, data, planckType(), num, offset); }
    /*! Fills \a data with elements from column \a colnum,
        starting at offset \a offset in the column. */
    template void read_column
      (int colnum, arr &data, int64 offset=0) const
      { read_column_raw (colnum, &(data[0]), data.size(), offset); }
    /*! Fills \a data with elements from column \a colnum,
        starting at offset \a offset in the column. */
    template void read_column
      (int colnum, std::vector &data, int64 offset=0) const
      { read_column_raw (colnum, &(data[0]), data.size(), offset); }
    /*! Reads the element \a #offset from column \a colnum into \a data. */
    template void read_column
      (int colnum, T &data, int64 offset=0) const
      { read_column_raw (colnum, &data, 1, offset); }
    /*! Reads the whole column \a colnum into \a data (which is resized
       accordingly). */
    template void read_entire_column
      (int colnum, arr &data) const
      {
      data.alloc(safe_cast(nelems(colnum)));
      read_column (colnum, data);
      }
    /*! Reads the whole column \a colnum into \a data (which is resized
       accordingly). */
    template void read_entire_column
      (int colnum, std::vector &data) const
      {
      data.resize(safe_cast(nelems(colnum)));
      read_column (colnum, data);
      }

    void write_column_raw_void
      (int colnum, const void *data, PDT type, int64 num, int64 offset=0);
    /*! Copies \a num elements from the memory pointed to by \a data to the
        column \a colnum, starting at offset \a offset in the column. */
    template void write_column_raw
      (int colnum, const T *data, int64 num, int64 offset=0)
      { write_column_raw_void (colnum, data, planckType(), num, offset); }
    /*! Copies all elements from \a data to the
        column \a colnum, starting at offset \a offset in the column. */
    template void write_column
      (int colnum, const arr &data, int64 offset=0)
      { write_column_raw (colnum, &(data[0]), data.size(), offset); }
    /*! Copies all elements from \a data to the
        column \a colnum, starting at offset \a offset in the column. */
    template void write_column
      (int colnum, const std::vector &data, int64 offset=0)
      { write_column_raw (colnum, &(data[0]), data.size(), offset); }
    /*! Copies \a data to the column \a colnum, at the position \a offset. */
    template void write_column
      (int colnum, const T &data, int64 offset=0)
      { write_column_raw (colnum, &data, 1, offset); }

    /*! \} */

    /*! \name Methods for image data I/O */
    /*! \{ */

    /*! Reads the current image into \a data, which is resized accordingly. */
    template void read_image (arr2 &data) const;
    /*! Reads the current image into \a data, which is resized accordingly. */
    template void read_image (arr3 &data) const;
    /*! Reads a partial image, whose dimensions are given by the dimensions
        of \a data, into data. The starting pixel indices are given by
        \a xl and \a yl. */
    template void read_subimage
      (arr2 &data, int xl, int yl) const;
    void read_subimage_void (void *data, PDT type, tsize ndata, int64 offset=0)
      const;
    /*! Fills \a data with values from the image, starting at the offset
        \a offset in the image. The image is treated as a one-dimensional
        array. */
    template void read_subimage (arr &data, int64 offset=0)
      const
      { read_subimage_void (&data[0],planckType(),data.size(),offset); }

    void write_image2D_void (const void *data, PDT type, tsize s1,
      tsize s2);
    /*! Writes \a data into the current image. \a data must have the same
        dimensions as specified in the HDU. */
    template void write_image (const arr2 &data)
      {
      write_image2D_void (&data[0][0],planckType(),data.size1(),
                          data.size2());
      }

    void write_subimage_void (const void *data, PDT type, tsize sz,
      int64 offset);
    /*! Copies \a data to the image, starting at the offset
        \a offset in the image. The image is treated as a one-dimensional
        array. */
    template void write_subimage (const arr &data,
      int64 offset=0)
      { write_subimage_void(&data[0],planckType(),data.size(),offset); }

    /*! \} */
  };

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/font_data.inc0000664000175000017500000011620713010375061027216 0ustar  zoncazonca00000000000000#ifndef PLANCK_FONT_DATA_INC
#define PLANCK_FONT_DATA_INC

const char *medium_bold_font_data=
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"  XX   "
" XXXX  "
"XXXXXX "
" XXXX  "
"  XX   "
"       "
"       "
"       "

"       "
"       "
"       "
"XX  XX "
"XX  XX "
"  XX   "
"XX  XX "
"XX  XX "
"  XX   "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"XX XX  "
"XX XX  "
"XXXXX  "
"XX XX  "
"XX XX  "
"       "
"  XXXX "
"   XX  "
"   XX  "
"   XX  "
"   XX  "
"       "

"       "
"XXXX   "
"XX     "
"XXX    "
"XX     "
"XX     "
"       "
"  XXXX "
"  XX   "
"  XXX  "
"  XX   "
"  XX   "
"       "

"       "
" XXX   "
"XX     "
"XX     "
"XX     "
" XXX   "
"       "
"  XXX  "
"  XX X "
"  XXX  "
"  XX X "
"  XX X "
"       "

"       "
"XX     "
"XX     "
"XX     "
"XX     "
"XXXX   "
"       "
"  XXXX "
"  XX   "
"  XXX  "
"  XX   "
"  XX   "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
" XXXX  "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"  XX   "
"  XX   "
"XXXXXX "
"XXXXXX "
"  XX   "
"  XX   "
"       "
"XXXXXX "
"XXXXXX "
"       "
"       "

"       "
"XX  XX "
"XXX XX "
"XXXXXX "
"XX XXX "
"XX  XX "
"       "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XXXX "
"       "

"       "
"XX  XX "
"XX  XX "
" X  X  "
" XXXX  "
"  XX   "
"       "
"  XXXX "
"   XX  "
"   XX  "
"   XX  "
"   XX  "
"       "

"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"XXXX   "
"XXXX   "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"XXXX   "
"XXXX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "

"       "
"       "
"       "
"       "
"       "
"       "
"  XXXXX"
"  XXXXX"
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "

"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XXXXX"
"  XXXXX"
"       "
"       "
"       "
"       "
"       "

"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"XXXXXXX"
"XXXXXXX"
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "

"       "
"       "
"XXXXXXX"
"XXXXXXX"
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"XXXXXXX"
"XXXXXXX"
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"XXXXXXX"
"XXXXXXX"
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"XXXXXXX"
"XXXXXXX"
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"XXXXXXX"
"XXXXXXX"
"       "

"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XXXXX"
"  XXXXX"
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "

"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"XXXX   "
"XXXX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "

"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"XXXXXXX"
"XXXXXXX"
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"XXXXXXX"
"XXXXXXX"
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "

"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "

"       "
"       "
"    XX "
"   XX  "
" XX    "
"XX     "
" XX    "
"   XX  "
"    XX "
"XXXXXX "
"XXXXXX "
"       "
"       "

"       "
"       "
"XX     "
" XX    "
"   XX  "
"    XX "
"   XX  "
" XX    "
"XX     "
"XXXXXX "
"XXXXXX "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XXXXXX "
" XX XX "
" XX XX "
" XX XX "
"XXX XX "
"XX  XX "
"       "
"       "

"       "
"       "
"     X "
"    XX "
"XXXXXX "
"XXXXXX "
"  XX   "
"XXXXXX "
"XXXXXX "
"XX     "
"X      "
"       "
"       "

"       "
"       "
"  XXX  "
" XX XX "
" XX    "
" XX    "
"XXXX   "
" XX    "
" XX    "
" XX XX "
"X XXX  "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"  XX   "
"  XX   "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"       "
"  XX   "
"  XX   "
"       "
"       "

"       "
"       "
" XX XX "
" XX XX "
" XX XX "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"  X X  "
"  X X  "
" XXXXX "
" XXXXX "
"  X X  "
" XXXXX "
" XXXXX "
"  X X  "
"  X X  "
"       "
"       "

"       "
"       "
"  XX   "
" XXXX  "
"X XX X "
"X XX   "
" XXXX  "
"  XX X "
"X XX X "
" XXXX  "
"  XX   "
"       "
"       "

"       "
"       "
"XXX  X "
"X X XX "
"XXX X  "
"   XX  "
"  XX   "
" XX    "
" X XXX "
"XX X X "
"X  XXX "
"       "
"       "

"       "
"       "
" XXX   "
"XX XX  "
"XX XX  "
"XX XX  "
" XXX   "
"XX X X "
"XX XXX "
"XX XX  "
" XXX X "
"       "
"       "

"       "
"       "
"  XXX  "
"  XXX  "
"  XX   "
" XX    "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"   XX  "
"  XX   "
"  XX   "
" XX    "
" XX    "
" XX    "
"  XX   "
"  XX   "
"   XX  "
"       "
"       "

"       "
"       "
" XX    "
"  XX   "
"  XX   "
"   XX  "
"   XX  "
"   XX  "
"  XX   "
"  XX   "
" XX    "
"       "
"       "

"       "
"       "
"       "
"       "
" X  X  "
"  XX   "
"XXXXXX "
"XXXXXX "
"  XX   "
" X  X  "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"  XX   "
"  XX   "
"XXXXXX "
"XXXXXX "
"  XX   "
"  XX   "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"  XXX  "
"  XXX  "
"  XX   "
" XX    "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"XXXXXX "
"XXXXXX "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"  XX   "
" XXXX  "
"  XX   "
"       "

"       "
"       "
"    XX "
"    XX "
"   XX  "
"   XX  "
"  XX   "
" XX    "
" XX    "
"XX     "
"XX     "
"       "
"       "

"       "
"       "
"  XX   "
" X  X  "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
" X  X  "
"  XX   "
"       "
"       "

"       "
"       "
"  XX   "
" XXX   "
"X XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"XXXXXX "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
"    XX "
"  XXX  "
" XX    "
"XX     "
"XX     "
"XXXXXX "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"    XX "
"    XX "
"  XXX  "
"    XX "
"    XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"    XX "
"   XXX "
"  XXXX "
" XX XX "
"XX  XX "
"XX  XX "
"XXXXXX "
"    XX "
"    XX "
"       "
"       "

"       "
"       "
"XXXXXX "
"XX     "
"XX     "
"XXXXX  "
"XX  XX "
"    XX "
"    XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX     "
"XX     "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"XXXXXX "
"    XX "
"    XX "
"   XX  "
"   XX  "
"  XX   "
"  XX   "
" XX    "
" XX    "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXXX "
"    XX "
"    XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"       "
"       "
"  XX   "
" XXXX  "
"  XX   "
"       "
"       "
"  XX   "
" XXXX  "
"  XX   "
"       "

"       "
"       "
"       "
"       "
"  XX   "
" XXXX  "
"  XX   "
"       "
"  XXX  "
"  XXX  "
"  XX   "
" XX    "
"       "

"       "
"       "
"    XX "
"   XX  "
"  XX   "
" XX    "
"XX     "
" XX    "
"  XX   "
"   XX  "
"    XX "
"       "
"       "

"       "
"       "
"       "
"       "
"XXXXXX "
"XXXXXX "
"       "
"XXXXXX "
"XXXXXX "
"       "
"       "
"       "
"       "

"       "
"       "
"XX     "
" XX    "
"  XX   "
"   XX  "
"    XX "
"   XX  "
"  XX   "
" XX    "
"XX     "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
"    XX "
"  XXX  "
"  XX   "
"       "
"  XX   "
"  XX   "
"       "
"       "

"       "
"       "
" XXXX  "
"X   XX "
"X   XX "
"X XXXX "
"X X XX "
"X XXXX "
"X      "
"X   XX "
" XXXX  "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXXX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"       "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXX  "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX     "
"XX     "
"XX     "
"XX     "
"XX     "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXX  "
"       "
"       "

"       "
"       "
"XXXXXX "
"XX     "
"XX     "
"XX     "
"XXXXX  "
"XX     "
"XX     "
"XX     "
"XXXXXX "
"       "
"       "

"       "
"       "
"XXXXXX "
"XX     "
"XX     "
"XX     "
"XXXXX  "
"XX     "
"XX     "
"XX     "
"XX     "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX     "
"XX     "
"XX XXX "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXXX "
"       "
"       "

"       "
"       "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXXX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"       "
"XXXXXX "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"XXXXXX "
"       "
"       "

"       "
"       "
"    XX "
"    XX "
"    XX "
"    XX "
"    XX "
"    XX "
"    XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"XX   X "
"XX  XX "
"XX XX  "
"XXXX   "
"XXX    "
"XXXX   "
"XX XX  "
"XX  XX "
"XX   X "
"       "
"       "

"       "
"       "
"XX     "
"XX     "
"XX     "
"XX     "
"XX     "
"XX     "
"XX     "
"XX     "
"XXXXXX "
"       "
"       "

"       "
"       "
"X    X "
"XX  XX "
"XXXXXX "
"XXXXXX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"       "
"XX  XX "
"XX  XX "
"XXX XX "
"XXX XX "
"XXXXXX "
"XX XXX "
"XX XXX "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXX  "
"XX     "
"XX     "
"XX     "
"XX     "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XXX XX "
"XX XXX "
" XXXX  "
"    XX "
"       "

"       "
"       "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXX  "
"XXXX   "
"XX XX  "
"XX  XX "
"XX   X "
"       "
"       "

"       "
"       "
" XXXX  "
"XX  XX "
"XX     "
"XX     "
" XXXX  "
"    XX "
"    XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"XXXXXX "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"       "
"       "

"       "
"       "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"XX  XX "
"XX  XX "
"XX  XX "
" X  X  "
" X  X  "
" XXXX  "
"  XX   "
"  XX   "
"  XX   "
"       "
"       "

"       "
"       "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXXX "
"XXXXXX "
"XX  XX "
"X    X "
"       "
"       "

"       "
"       "
"X    X "
"XX  XX "
" X  X  "
" XXXX  "
"  XX   "
" XXXX  "
" X  X  "
"XX  XX "
"X    X "
"       "
"       "

"       "
"       "
"XX  XX "
"XX  XX "
" XXXX  "
" XXXX  "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"       "
"       "

"       "
"       "
"XXXXXX "
"    XX "
"    XX "
"   XX  "
"  XX   "
" XX    "
"XX     "
"XX     "
"XXXXXX "
"       "
"       "

"       "
"       "
" XXXX  "
" XX    "
" XX    "
" XX    "
" XX    "
" XX    "
" XX    "
" XX    "
" XXXX  "
"       "
"       "

"       "
"       "
"XX     "
"XX     "
" XX    "
" XX    "
"  XX   "
"   XX  "
"   XX  "
"    XX "
"    XX "
"       "
"       "

"       "
"       "
" XXXX  "
"   XX  "
"   XX  "
"   XX  "
"   XX  "
"   XX  "
"   XX  "
"   XX  "
" XXXX  "
"       "
"       "

"       "
"       "
"  XX   "
" XXXX  "
"XX  XX "
"X    X "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"XXXXXX "
"XXXXXX "
"       "

"       "
"       "
" XXX   "
" XXX   "
"  XX   "
"   XX  "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
" XXXX  "
"    XX "
" XXXXX "
"XX  XX "
"XX  XX "
" XXXXX "
"       "
"       "

"       "
"       "
"XX     "
"XX     "
"XX     "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXX  "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
" XXXX  "
"XX  XX "
"XX     "
"XX     "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"    XX "
"    XX "
"    XX "
" XXXXX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXXX "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
" XXXX  "
"XX  XX "
"XXXXXX "
"XX     "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"  XXX  "
" XX XX "
" XX    "
" XX    "
"XXXX   "
" XX    "
" XX    "
" XX    "
" XX    "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
" XXX X "
"XX  XX "
"XX  XX "
" XXXX  "
"XX     "
" XXXX  "
"XX  XX "
" XXXX  "

"       "
"       "
"XX     "
"XX     "
"XX     "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"       "
"  XX   "
"  XX   "
"       "
" XXX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"XXXXXX "
"       "
"       "

"       "
"       "
"    XX "
"    XX "
"       "
"    XX "
"    XX "
"    XX "
"    XX "
"    XX "
"    XX "
"XX  XX "
" XXXX  "

"       "
"       "
"XX     "
"XX     "
"XX     "
"XX  XX "
"XX XX  "
"XXXX   "
"XXXX   "
"XX XX  "
"XX  XX "
"       "
"       "

"       "
"       "
" XXX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"XXXXXX "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XX XX  "
"XXXXXX "
"XXXXXX "
"XX  XX "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
" XXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XXXXX  "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXX  "
"XX     "
"XX     "
"XX     "

"       "
"       "
"       "
"       "
"       "
" XXXXX "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXXX "
"    XX "
"    XX "
"    XX "

"       "
"       "
"       "
"       "
"       "
"XXXXX  "
"XX  XX "
"XX     "
"XX     "
"XX     "
"XX     "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
" XXXX  "
"XX  XX "
" XX    "
"   XX  "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"       "
"XX     "
"XX     "
"XXXX   "
"XX     "
"XX     "
"XX     "
"XX  XX "
" XXXX  "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXXX "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXX  "
" XXXX  "
"  XX   "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XX  XX "
"XX  XX "
"XX  XX "
"XXXXXX "
"XXXXXX "
" X  X  "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XX  XX "
"XX  XX "
" XXXX  "
" XXXX  "
"XX  XX "
"XX  XX "
"       "
"       "

"       "
"       "
"       "
"       "
"       "
"XX  XX "
"XX  XX "
"XX  XX "
"XX  XX "
" XXXXX "
"    XX "
"XX  XX "
" XXXX  "

"       "
"       "
"       "
"       "
"       "
"XXXXXX "
"    XX "
"   XX  "
" XX    "
"XX     "
"XXXXXX "
"       "
"       "

"       "
"       "
"  XXX  "
" XX    "
" XX    "
"  XX   "
" XX    "
"  XX   "
" XX    "
" XX    "
"  XXX  "
"       "
"       "

"       "
"       "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"  XX   "
"       "
"       "

"       "
"       "
" XXX   "
"   XX  "
"   XX  "
"  XX   "
"   XX  "
"  XX   "
"   XX  "
"   XX  "
" XXX   "
"       "
"       "

"       "
"       "
" XX  X "
"XXXXXX "
"X  XX  "
"       "
"       "
"       "
"       "
"       "
"       "
"       "
"       "

" X X X "
"  X X  "
" X X X "
"  X X  "
" X X X "
"  X X  "
" X X X "
"  X X  "
" X X X "
"  X X  "
" X X X "
"  X X  "
" X X X "
;

const char *giant_font_data =
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"    XX   "
"   XXXX  "
"  XXXXXX "
" XXXXXXXX"
"  XXXXXX "
"   XXXX  "
"    XX   "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XX XX XX"
"  XX  XX "
" XX XX XX"
"  XX  XX "
" XX XX XX"
"  XX  XX "
" XX XX XX"
"         "
"         "
"         "

"         "
"         "
"         "
" XX  XX  "
" XX  XX  "
" XXXXXX  "
" XX  XX  "
" XX  XX  "
"         "
"   XXXXXX"
"     XX  "
"     XX  "
"     XX  "
"     XX  "
"         "

"         "
"         "
"         "
" XXXXX   "
" XX      "
" XXXX    "
" XX      "
" XX      "
"         "
"    XXXXX"
"    XX   "
"    XXXX "
"    XX   "
"    XX   "
"         "

"         "
"         "
"         "
"  XXXXX  "
" XX   X  "
" XX      "
" XX   X  "
"  XXXXX  "
"         "
"   XXXXX "
"   XX  XX"
"   XXXXX "
"   XX  XX"
"   XX  XX"
"         "

"         "
"         "
"         "
" XX      "
" XX      "
" XX      "
" XX      "
" XXXXX   "
"         "
"    XXXXX"
"    XX   "
"    XXXX "
"    XX   "
"    XX   "
"         "

"         "
"         "
"         "
"         "
"         "
"   XXXX  "
"  XX  XX "
"  XX  XX "
"   XXXX  "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"    XX   "
"    XX   "
"    XX   "
" XXXXXXXX"
" XXXXXXXX"
"    XX   "
"    XX   "
"    XX   "
"         "
" XXXXXXXX"
" XXXXXXXX"
"         "
"         "

"         "
"         "
"         "
" XX  XX  "
" XXX XX  "
" XXXXXX  "
" XX XXX  "
" XX  XX  "
"         "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XXXXX"
"         "

"         "
"         "
"         "
" XX  XX  "
" XX  XX  "
" XX  XX  "
"  XXXX   "
"   XX    "
"         "
"   XXXXXX"
"     XX  "
"     XX  "
"     XX  "
"     XX  "
"         "

"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"XXXXXX   "
"XXXXXX   "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"XXXXXX   "
"XXXXXX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"    XXXXX"
"    XXXXX"
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "

"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XXXXX"
"    XXXXX"
"         "
"         "
"         "
"         "
"         "
"         "

"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"XXXXXXXXX"
"XXXXXXXXX"
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "

"         "
"         "
"         "
"XXXXXXXXX"
"XXXXXXXXX"
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"XXXXXXXXX"
"XXXXXXXXX"
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"XXXXXXXXX"
"XXXXXXXXX"
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"XXXXXXXXX"
"XXXXXXXXX"
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"XXXXXXXXX"
"XXXXXXXXX"
"         "
"         "

"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XXXXX"
"    XXXXX"
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "

"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"XXXXXX   "
"XXXXXX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "

"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"XXXXXXXXX"
"XXXXXXXXX"
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"XXXXXXXXX"
"XXXXXXXXX"
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "

"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "

"         "
"         "
"         "
"      XXX"
"    XXX  "
"  XXX    "
" XX      "
"  XXX    "
"    XXX  "
"      XXX"
"         "
" XXXXXXXX"
" XXXXXXXX"
"         "
"         "

"         "
"         "
"         "
" XXX     "
"   XXX   "
"     XXX "
"       XX"
"     XXX "
"   XXX   "
" XXX     "
"         "
" XXXXXXXX"
" XXXXXXXX"
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XXXXXXXX"
" XXXXXXXX"
"   X  XX "
"   X  XX "
"   X  XX "
" XXX  XX "
" XXX  XX "
"         "
"         "
"         "

"         "
"         "
"         "
"       XX"
"      XX "
" XXXXXXXX"
" XXXXXXXX"
"    XX   "
" XXXXXXXX"
" XXXXXXXX"
"  XX     "
" XX      "
"         "
"         "
"         "

"         "
"         "
"         "
"    XXXX "
"   XX  XX"
"   XX    "
"   XX    "
"  XXXXXX "
"   XX    "
"   XX    "
" XXXXX   "
" X XXXXXX"
" XXX     "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"    XX   "
"    XX   "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"         "
"    XX   "
"         "
"         "
"         "

"         "
"         "
"   XX XX "
"   XX XX "
"   XX XX "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"  XX XX  "
"  XX XX  "
" XXXXXXX "
"  XX XX  "
"  XX XX  "
" XXXXXXX "
"  XX XX  "
"  XX XX  "
"         "
"         "
"         "
"         "

"         "
"         "
"     X   "
"   XXXXX "
"  XX X XX"
"  XX X   "
"  XXXX   "
"   XXXXX "
"     XXXX"
"     X XX"
"  XX X XX"
"   XXXXX "
"     X   "
"         "
"         "

"         "
"         "
"  XX   XX"
" XXXX XX "
" XXXX XX "
"  XX XX  "
"    XX   "
"    XX   "
"   XX XX "
"  XX XXXX"
"  XX XXXX"
" XX   XX "
"         "
"         "
"         "

"         "
"         "
"  XXXX   "
" XX  XX  "
" XX  XX  "
" XX  XX  "
"  XXXX   "
" XX  XX  "
" XX  XXXX"
" XX   XX "
" XX  XXX "
"  XXXX XX"
"         "
"         "
"         "

"         "
"         "
"    XXXX "
"    XXX  "
"   XX    "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"     XX  "
"    XX   "
"   XX    "
"   XX    "
"  XX     "
"  XX     "
"  XX     "
"  XX     "
"   XX    "
"   XX    "
"    XX   "
"     XX  "
"         "
"         "

"         "
"  XX     "
"   XX    "
"    XX   "
"    XX   "
"     XX  "
"     XX  "
"     XX  "
"     XX  "
"    XX   "
"    XX   "
"   XX    "
"  XX     "
"         "
"         "

"         "
"         "
"         "
"    X    "
" XX X XX "
"  XXXXX  "
"   XXX   "
" XXX XXX "
"   XXX   "
"  XXXXX  "
" XX X XX "
"    X    "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"    XX   "
"    XX   "
"    XX   "
" XXXXXXXX"
"    XX   "
"    XX   "
"    XX   "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"   XXXX  "
"   XXX   "
"  XX     "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
" XXXXXXXX"
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"    XX   "
"   XXXX  "
"    XX   "
"         "
"         "

"         "
"         "
"       XX"
"      XX "
"      XX "
"     XX  "
"    XX   "
"    XX   "
"   XX    "
"  XX     "
"  XX     "
" XX      "
"         "
"         "
"         "

"         "
"         "
"   XXXX  "
"  XX  XX "
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
"  XX  XX "
"   XXXX  "
"         "
"         "
"         "

"         "
"         "
"    XX   "
"   XXX   "
"  XXXX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
"       XX"
"      XX "
"     XX  "
"   XXX   "
"  XX     "
" XX      "
" XXXXXXXX"
"         "
"         "
"         "

"         "
"         "
" XXXXXXXX"
"       XX"
"      XX "
"     XX  "
"    XXXX "
"       XX"
"       XX"
"       XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"      XX "
"     XXX "
"    XXXX "
"   XX XX "
"  XX  XX "
" XX   XX "
" XXXXXXXX"
"      XX "
"      XX "
"      XX "
"         "
"         "
"         "

"         "
"         "
" XXXXXXXX"
" XX      "
" XX      "
" XXXXXXX "
" XXX   XX"
"       XX"
"       XX"
"       XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"   XXXXX "
"  XX     "
" XX      "
" XX      "
" XXXXXXX "
" XXX   XX"
" XX    XX"
" XX    XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
" XXXXXXXX"
"       XX"
"       XX"
"      XX "
"     XX  "
"    XX   "
"   XX    "
"   XX    "
"  XX     "
"  XX     "
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
" XX    XX"
"  XXXXXX "
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
" XX    XX"
" XX   XXX"
"  XXXXXXX"
"       XX"
"       XX"
"      XX "
"  XXXXX  "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"    XX   "
"   XXXX  "
"    XX   "
"         "
"         "
"    XX   "
"   XXXX  "
"    XX   "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"    XX   "
"   XXXX  "
"    XX   "
"         "
"         "
"   XXXX  "
"   XXX   "
"  XX     "
"         "
"         "

"         "
"         "
"      XX "
"     XX  "
"    XX   "
"   XX    "
"  XX     "
"  XX     "
"   XX    "
"    XX   "
"     XX  "
"      XX "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
" XXXXXXXX"
"         "
"         "
" XXXXXXXX"
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"  XX     "
"   XX    "
"    XX   "
"     XX  "
"      XX "
"      XX "
"     XX  "
"    XX   "
"   XX    "
"  XX     "
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
"       XX"
"      XX "
"     XX  "
"    XX   "
"    XX   "
"         "
"    XX   "
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
" XX XXXXX"
" XXXX  XX"
" XXXX XXX"
" XX XXXXX"
" XX      "
" XX      "
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"    XX   "
"   XXXX  "
"  XX  XX "
" XX    XX"
" XX    XX"
" XX    XX"
" XXXXXXXX"
" XX    XX"
" XX    XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
" XXXXXXX "
"  XX   XX"
"  XX   XX"
"  XX   XX"
"  XXXXXX "
"  XX   XX"
"  XX   XX"
"  XX   XX"
"  XX   XX"
" XXXXXXX "
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX      "
" XX      "
" XX      "
" XX      "
" XX      "
" XX      "
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
" XXXXXXX "
"  XX   XX"
"  XX   XX"
"  XX   XX"
"  XX   XX"
"  XX   XX"
"  XX   XX"
"  XX   XX"
"  XX   XX"
" XXXXXXX "
"         "
"         "
"         "

"         "
"         "
" XXXXXXXX"
"  XX     "
"  XX     "
"  XX     "
"  XXXXX  "
"  XX     "
"  XX     "
"  XX     "
"  XX     "
" XXXXXXXX"
"         "
"         "
"         "

"         "
"         "
" XXXXXXXX"
"  XX     "
"  XX     "
"  XX     "
"  XXXXX  "
"  XX     "
"  XX     "
"  XX     "
"  XX     "
"  XX     "
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX      "
" XX      "
" XX      "
" XX  XXXX"
" XX    XX"
" XX    XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XXXXXXXX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"    XXXXX"
"      XX "
"      XX "
"      XX "
"      XX "
"      XX "
"      XX "
"      XX "
" XX   XX "
"  XXXXX  "
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX   XX "
" XX  XX  "
" XX XX   "
" XXXX    "
" XXXX    "
" XX XX   "
" XX  XX  "
" XX   XX "
" XX    XX"
"         "
"         "
"         "

"         "
"         "
" XX      "
" XX      "
" XX      "
" XX      "
" XX      "
" XX      "
" XX      "
" XX      "
" XX      "
" XXXXXXXX"
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX    XX"
" XXX  XXX"
" XXXXXXXX"
" XXXXXXXX"
" XX XX XX"
" XX XX XX"
" XX    XX"
" XX    XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX    XX"
" XXX   XX"
" XXXX  XX"
" XX XX XX"
" XX  XXXX"
" XX   XXX"
" XX    XX"
" XX    XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
" XXXXXXX "
" XX    XX"
" XX    XX"
" XX    XX"
" XXXXXXX "
" XX      "
" XX      "
" XX      "
" XX      "
" XX      "
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX XX XX"
" XX  XXXX"
"  XXXXXX "
"       XX"
"         "
"         "

"         "
"         "
" XXXXXXX "
" XX    XX"
" XX    XX"
" XX    XX"
" XXXXXXX "
" XX XX   "
" XX  XX  "
" XX   XX "
" XX    XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
"  XXXXXX "
" XX    XX"
" XX      "
" XX      "
"  XXXXXX "
"       XX"
"       XX"
"       XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
" XXXXXXXX"
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX    XX"
" XX    XX"
"  XX  XX "
"  XX  XX "
"  XX  XX "
"   XXXX  "
"   XXXX  "
"   XXXX  "
"    XX   "
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX XX XX"
" XX XX XX"
" XX XX XX"
" XX XX XX"
" XXXXXXXX"
"  XX  XX "
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX    XX"
"  XX  XX "
"   XXXX  "
"    XX   "
"    XX   "
"   XXXX  "
"  XX  XX "
" XX    XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
" XX    XX"
" XX    XX"
"  XX  XX "
"   XXXX  "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"         "
"         "
"         "

"         "
"         "
" XXXXXXXX"
"       XX"
"      XX "
"     XX  "
"    XX   "
"   XX    "
"  XX     "
" XX      "
" XX      "
" XXXXXXXX"
"         "
"         "
"         "

"         "
"         "
"   XXXXX "
"   XX    "
"   XX    "
"   XX    "
"   XX    "
"   XX    "
"   XX    "
"   XX    "
"   XX    "
"   XXXXX "
"         "
"         "
"         "

"         "
"         "
" XX      "
"  XX     "
"  XX     "
"   XX    "
"    XX   "
"    XX   "
"     XX  "
"      XX "
"      XX "
"       XX"
"         "
"         "
"         "

"         "
"         "
"  XXXXX  "
"     XX  "
"     XX  "
"     XX  "
"     XX  "
"     XX  "
"     XX  "
"     XX  "
"     XX  "
"  XXXXX  "
"         "
"         "
"         "

"         "
"         "
"    XX   "
"   XXXX  "
"  XX  XX "
" XX    XX"
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"XXXXXXXXX"
"         "
"         "

"         "
"         "
"  XXXX   "
"   XXX   "
"     XX  "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"  XXXXXX "
"       XX"
"       XX"
"  XXXXXXX"
" XX    XX"
" XX   XXX"
"  XXXXXXX"
"         "
"         "
"         "

"         "
"         "
" XX      "
" XX      "
" XX      "
" XXXXXXX "
" XXX   XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XXX   XX"
" XXXXXXX "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"  XXXXXX "
" XX    XX"
" XX      "
" XX      "
" XX      "
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"       XX"
"       XX"
"       XX"
"  XXXXXXX"
" XX   XXX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX   XXX"
"  XXXXXXX"
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
" XXXXXXXX"
" XX      "
" XX      "
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"    XXXX "
"   XX  XX"
"   XX  XX"
"   XX    "
"   XX    "
" XXXXXX  "
"   XX    "
"   XX    "
"   XX    "
"   XX    "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"  XXXXXXX"
" XX   XX "
" XX   XX "
" XX   XX "
"  XXXXX  "
" XX      "
"  XXXXXX "
" XX    XX"
" XX    XX"
"  XXXXXX "

"         "
"         "
" XX      "
" XX      "
" XX      "
" XXXXXXX "
" XXX   XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
"         "
"    XX   "
"         "
"   XXX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"         "
"      XX "
"         "
"    XXXX "
"      XX "
"      XX "
"      XX "
"      XX "
"      XX "
" XX   XX "
" XX   XX "
" XX   XX "
"  XXXXX  "

"         "
"         "
" XX      "
" XX      "
" XX      "
" XX    XX"
" XX  XXX "
" XXXXX   "
" XXX     "
" XXXXX   "
" XX  XXX "
" XX    XX"
"         "
"         "
"         "

"         "
"         "
"   XXX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XXXXXXX "
" XX XX XX"
" XX XX XX"
" XX XX XX"
" XX XX XX"
" XX XX XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XXXXXXX "
" XXX   XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"  XXXXXX "
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XXXXXXX "
" XXX   XX"
" XX    XX"
" XX    XX"
" XX    XX"
" XXX   XX"
" XXXXXXX "
" XX      "
" XX      "
" XX      "

"         "
"         "
"         "
"         "
"         "
"  XXXXXXX"
" XX   XXX"
" XX    XX"
" XX    XX"
" XX    XX"
" XX   XXX"
"  XXXXXXX"
"       XX"
"       XX"
"       XX"

"         "
"         "
"         "
"         "
"         "
" XX XXXX "
"  XXX  XX"
"  XX   XX"
"  XX     "
"  XX     "
"  XX     "
"  XX     "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"  XXXXXX "
" XX    XX"
" XX      "
"  XXXXXX "
"       XX"
" XX    XX"
"  XXXXXX "
"         "
"         "
"         "

"         "
"         "
"         "
"   XX    "
"   XX    "
" XXXXXXX "
"   XX    "
"   XX    "
"   XX    "
"   XX    "
"   XX  XX"
"    XXXX "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XX   XX "
" XX   XX "
" XX   XX "
" XX   XX "
" XX   XX "
" XX   XX "
"  XXXXXXX"
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XX    XX"
" XX    XX"
"  XX  XX "
"  XX  XX "
"   XXXX  "
"   XXXX  "
"    XX   "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XX    XX"
" XX    XX"
" XX XX XX"
" XX XX XX"
" XX XX XX"
" XXXXXXXX"
"  XX  XX "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XX    XX"
"  XX  XX "
"   XXXX  "
"    XX   "
"   XXXX  "
"  XX  XX "
" XX    XX"
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
" XX   XX "
" XX   XX "
" XX   XX "
" XX   XX "
" XX   XX "
" XX  XXX "
"  XXXXXX "
"      XX "
" XX   XX "
"  XXXXX  "

"         "
"         "
"         "
"         "
"         "
" XXXXXXXX"
"      XX "
"     XX  "
"    XX   "
"   XX    "
"  XX     "
" XXXXXXXX"
"         "
"         "
"         "

"         "
"         "
"     XXXX"
"    XX   "
"    XX   "
"     XX  "
"   XXX   "
"   XXX   "
"     XX  "
"    XX   "
"    XX   "
"     XXXX"
"         "
"         "
"         "

"         "
"         "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"    XX   "
"         "
"         "
"         "

"         "
"         "
" XXXX    "
"    XX   "
"    XX   "
"   XX    "
"    XXX  "
"    XXX  "
"   XX    "
"    XX   "
"    XX   "
" XXXX    "
"         "
"         "
"         "

"         "
"         "
"  XXX  XX"
" XX XX XX"
" XX  XXX "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "

"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
"         "
;

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/geom_utils.cc0000664000175000017500000000441113010375061027233 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2011-2014 Max-Planck-Society
 *  \author Martin Reinecke
 */

#include "geom_utils.h"
#include "arr.h"

using namespace std;

namespace {

void get_circle (const arr &point, tsize q1, tsize q2, vec3 ¢er,
  double &cosrad)
  {
  center = (point[q1]+point[q2]).Norm();
  cosrad = dotprod(point[q1],center);
  for (tsize i=0; i &point, tsize q, vec3 ¢er,
  double &cosrad)
  {
  center = (point[0]+point[q]).Norm();
  cosrad = dotprod(point[0],center);
  for (tsize i=1; i &point, vec3 ¢er,
  double &cosrad)
  {
  tsize np=point.size();
  planck_assert(np>=2,"too few points");
  center = (point[0]+point[1]).Norm();
  cosrad = dotprod(point[0],center);
  for (tsize i=2; i class arr;

/*! Returns the orientation when looking from point \a loc on the unit
    sphere in the direction \a dir. \a loc must be normalized. The result
    ranges from -pi to pi, is 0 for North and pi/2 for West, i.e. the angle
    is given in mathematically positive sense.

    If \a loc is the North or South pole, the returned angle is
    \a atan2(dir.y,dir.x). */
inline double orientation (const vec3 &loc, const vec3 &dir)
  {
// FIXME: here is still optimization potential
  if (loc.x==0 && loc.y==0)
    return (loc.z>0) ? safe_atan2(dir.y,-dir.x) : safe_atan2(dir.y,dir.x);
  vec3 east (-loc.y, loc.x, 0);
  vec3 north = crossprod(loc,east);
  return safe_atan2(-dotprod(dir,east),dotprod(dir,north));
  }

/*! Returns the angle between \a v1 and \a v2 in radians. */
inline double v_angle (const vec3 &v1, const vec3 &v2)
  {
  using namespace std;
  return atan2 (crossprod(v1,v2).Length(), dotprod(v1,v2));
  }

/*! Returns the cosine of the angle between the two points on the sphere defined
    by (\a z1, \a phi1) and (\a z2, \a phi2), respectively. \a z is the cosine
    of the colatitude, and \a phi is the longitude. */
inline double cosdist_zphi (double z1, double phi1, double z2, double phi2)
  {
  using namespace std;
  return z1*z2+cos(phi1-phi2)*sqrt((1.-z1*z1)*(1.-z2*z2));
  }

/*! Finds the smallest enclosing cone for a point set on the sphere according to
    Barequet & Elber: Information Processing Letters 93(2005), p.83.
    All points are expected to be passed as unit vectors.
    The enclosing cone must have an opening angle  &point, vec3 ¢er,
  double &cosrad);

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/levels_facilities.h0000664000175000017500000000123713010375061030417 0ustar  zoncazonca00000000000000#ifndef LEVELS_FACILITIES_H
#define LEVELS_FACILITIES_H

int syn_alm_cxx_module (int argc, const char **argv);
int alm2map_cxx_module (int argc, const char **argv);
int anafast_cxx_module (int argc, const char **argv);
int calc_powspec_module (int argc, const char **argv);
int hotspots_cxx_module (int argc, const char **argv);
int map2tga_module (int argc, const char **argv);
int median_filter_cxx_module (int argc, const char **argv);
int mult_alm_module (int argc, const char **argv);
int smoothing_cxx_module (int argc, const char **argv);
int udgrade_cxx_module (int argc, const char **argv);
int udgrade_harmonic_cxx_module (int argc, const char **argv);

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/linear_map.h0000664000175000017500000000510513010375061027036 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file linear_map.h
 *  Simple class for 1D mapping with linear interpolation.
 *  Adapted from RAY++ source code.
 *
 *  Copyright (C) 2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_LINEAR_MAP_H
#define PLANCK_LINEAR_MAP_H

#include 
#include "colour.h"
#include "sort_utils.h"
#include "math_utils.h"

template class linearMap
  {
  private:
    bool sorted;
    std::vector x;
    std::vector y;

  public:
    void addVal (double x_, const T &val)
      {
      sorted=x.empty()||(x_>x.back());
      x.push_back(x_);
      y.push_back(val);
      }

    void sortMap()
      {
      if (sorted) return;
      std::vector idx;
      buildIndex(x.begin(),x.end(),idx);
      sortByIndex(x.begin(),x.end(),idx);
      sortByIndex(y.begin(),y.end(),idx);
      sorted = true;
      }

    void clear()
      {
      x.clear(); y.clear(); sorted=true;
      }

    T getVal_const (double x_) const
      {
      planck_assert(x.size()>0,"trying to access an empty map");
      planck_assert(sorted,"map must be sorted");
      if (x.size()==1) return y[0];
      if (x_>=x.back())
        return y.back();
      if (x_<=x[0])
        return y[0];
      tsize index;
      double frac;
      interpol_helper (x.begin(), x.end(), x_, index, frac);
      return (1.-frac)*y[index]+frac*y[index+1];
      }
    T getVal (double x_)
      {
      if (!sorted) sortMap();
      return getVal_const(x_);
      }

    size_t size() const { return x.size(); }
    double getX (size_t idx) { if (!sorted) sortMap(); return x[idx]; }
    T getY (size_t idx) { if (!sorted) sortMap(); return y[idx]; }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/ls_image.cc0000664000175000017500000001711213010375061026646 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Classes for creation and output of image files
 *
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include 
#include "ls_image.h"
#include "bstream.h"
#include "font_data.inc"
#include "string_utils.h"
#include "share_utils.h"

using namespace std;

const MP_Font medium_bold_font = { 0, 128, 7, 13, medium_bold_font_data };
const MP_Font giant_font = { 0, 128, 9, 15, giant_font_data };

void Palette::setPredefined (int num)
  {
  clear();
  switch(num)
    {
    case 0:
      add(0,Colour(0,0,0));
      add(1,Colour(1,1,1));
      break;
    case 1:
      add(0,Colour(0,0,0));
      add(0.4f,Colour(0,0,0.5f));
      add(0.75f,Colour(0,0.6f,1));
      add(1,Colour(1,1,1));
      break;
    case 4:
      add(0,Colour(0,0,.5f));
      add(0.15f,Colour(0,0,1));
      add(0.4f,Colour(0,1,1));
      add(0.7f,Colour(1,1,0));
      add(0.9f,Colour(1,.33f,0));
      add(1,Colour(.5f,0,0));
      break;
    case 10: // Planck colours 1
      addb(  0,  0,  0,255);
      addb( 42,  0,112,255);
      addb( 85,  0,221,255);
      addb(127,255,237,217);
      addb(170,255,180,  0);
      addb(212,255, 75,  0);
      addb(255,100,  0,  0);
      break;
    case 11: // Planck colours 2
      addb(  0,  0,  0,255);
      addb( 13, 10, 20,255);
      addb( 26, 30,184,255);
      addb( 38, 80,235,255);
      addb( 52,191,239,250);
      addb( 65,228,240,245);
      addb( 76,241,241,212);
      addb( 77,241,241,212);
      addb( 88,245,240,175);
      addb(101,248,235,130);
      addb(114,250,204, 38);
      addb(127,243,153, 13);
      addb(140,204, 77,  0);
      addb(153,165, 32, 32);
      addb(166,114,  0, 32);
      addb(179,128,128,153);
      addb(192,179,179,204);
      addb(205,204,204,230);
      addb(218,230,230,242);
      addb(231,242,242,250);
      addb(255,252,252,255);
      break;
    default:
      planck_fail("Palette #"+dataToString(num)+" not yet supported.");
    }
  }

void LS_Image::write_char (int xpos, int ypos, const Colour &col, char c,
  int scale)
  {
  planck_assert ((c>=font.offset) && (c line(3*xres);
  for (tsize j=0; j &px, tsize begin, tsize end,
  vector &buf)
  {
  chunkMaker cm (end-begin,128);
  uint64 cbeg, csz;
  while (cm.getNext(cbeg,csz))
    {
    buf.push_back(uint8(csz-1+128));
    buf.push_back(px[begin].b);
    buf.push_back(px[begin].g);
    buf.push_back(px[begin].r);
    }
  }
void write_unequal_range (const arr &px, tsize begin, tsize end,
  vector &buf)
  {
  chunkMaker cm (end-begin,128);
  uint64 cbeg, csz;
  while (cm.getNext(cbeg,csz))
    {
    buf.push_back(uint8(csz-1));
    for (tsize cnt=begin+cbeg; cnt< begin+cbeg+csz; ++cnt)
      {
      buf.push_back(px[cnt].b);
      buf.push_back(px[cnt].g);
      buf.push_back(px[cnt].r);
      }
    }
  }

} // unnamed namespace

void LS_Image::write_TGA_rle(const string &file) const
  {
  ofstream out(file.c_str(), ios_base::out | ios_base::binary);
  planck_assert(out, "could not create file '" + file + "'");

  tsize xres=pixel.size1(), yres=pixel.size2();

  bostream bo(out);
  const uint8 header[18] = { 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    uint8(xres%256), uint8(xres/256), uint8(yres%256), uint8(yres/256), 24, 32};

  bo.put(header,18);
  vector buf;
  arr px(xres);
  for (tsize y=0; y line(3*xres);
  for (tsize j=0; j
#include 
#include 
#include 
#include "arr.h"
#include "datatypes.h"
#include "colour.h"
#include "linear_map.h"

/*! \defgroup imagegroup Image creation */
/*! \{ */

/*! A class for mapping floting-point values into colours. */
class Palette: public linearMap
  {
  public:
    /*! Adds a new data point \a f, with the corresponding colour \a c.
        The additions must be done in the order of ascending \a f. */
    void add (float f, const Colour &c)
      { addVal (f, c); }
    void addb (uint8 f, uint8 r,uint8 g, uint8 b)
      { addVal (f, Colour(r/255.,g/255.,b/255.)); }
    /*! Sets the palette to the predefined palette \a num. */
    void setPredefined(int num);
    /*! Returns the colour corresponding to the value \a f. The colour is
        determined by linear interpolation between neighbouring data points. */
    Colour Get_Colour (float f) const
      { return getVal_const(f); }
  };

class Colour8
  {
  private:
    void import (const Colour &col)
      {
      using namespace std;
      r = uint8(max(0,min(255,int(col.r*256))));
      g = uint8(max(0,min(255,int(col.g*256))));
      b = uint8(max(0,min(255,int(col.b*256))));
      }

  public:
    uint8 r,g,b;

    Colour8() {}
    Colour8 (uint8 R, uint8 G, uint8 B)
      : r(R), g(G), b(B) {}
    Colour8 (const Colour &col)
      { import (col); }
    const Colour8 &operator= (const Colour &col)
      { import (col); return *this; }
    bool operator== (const Colour8 &that)
      { return (r == that.r) && (g == that.g) && (b == that.b); }
    bool operator!= (const Colour8 &that)
      { return (r != that.r) || (g != that.g) || (b != that.b); }
  };

class MP_Font
  {
  public:
    int offset, num_chars, xpix, ypix;
    const char *data;
  };

extern const MP_Font medium_bold_font;
extern const MP_Font giant_font;

/*! Class for creating and storing image files. */
class LS_Image
  {
  private:
    MP_Font font;
    arr2 pixel;

    void write_char (int xpos, int ypos, const Colour &col, char c,
                     int scale=1);

  public:
    /*! */
    LS_Image ();
    /*! Creates an image object with a resolution of \a xres by \a yres. */
    LS_Image (int xres, int yres);
    /*! */
    ~LS_Image () {}

    /*! Fills the entire image with colour \a col. */
    void fill (const Colour &col) { pixel.fill(col); }
    /*! Sets the font used for annotations to \a fnt. */
    void set_font (const MP_Font &fnt);
    /*! Outputs the string \a text in colour \a col.
        \a xpos, \a ypos is the lower left corner;
        the font is scaled by \a scale. */
    void annotate (int xpos, int ypos, const Colour &col,
      const std::string &text, int scale=1);
    /*! Outputs the string \a text centered at position \a xpos, \a ypos
        in colour \a col. The font is scaled by \a scale. */
    void annotate_centered (int xpos, int ypos, const Colour &col,
      const std::string &text, int scale=1);
    /*! Sets the pixel \a i, \a j, to the colour \a col. */
    void put_pixel (tsize i, tsize j, const Colour &col)
      {
      if ((i
#include 
#include "datatypes.h"

/*! \defgroup mathutilsgroup Mathematical helper functions */
/*! \{ */

/*! Returns \e true if | \a a-b | <= \a epsilon * | \a b |, else \e false. */
template inline bool approx (F a, F b, F epsilon=1e-5)
  {
  using namespace std;
  return abs(a-b) <= (epsilon*abs(b));
  }

/*! Returns \e true if | \a a-b | <= \a epsilon, else \e false. */
template inline bool abs_approx (F a, F b, F epsilon=1e-5)
  {
  using namespace std;
  return abs(a-b) <= epsilon;
  }

/*! Returns the largest integer which is smaller than (or equal to) \a arg. */
template inline I ifloor (F arg)
  {
  using namespace std;
  return I(floor(arg));
  }

/*! Returns the integer which is nearest to \a arg. */
template inline I nearest (F arg)
  { return ifloor(arg+0.5); }

/*! Returns the remainder of the division \a v1/v2.
    The result is non-negative.
    \a v1 can be positive or negative; \a v2 must be positive. */
inline double fmodulo (double v1, double v2)
  {
  using namespace std;
  if (v1>=0)
    return (v1=0) ? ((v1 inline I imodulo (I v1, I v2)
  { I v=v1%v2; return (v>=0) ? v : v+v2; }

/*! Returns -1 if \a signvalue is negative, else +1. */
template inline T sign (const T& signvalue)
  { return (signvalue>=0) ? 1 : -1; }

/*! Returns \a val*pow(-1,m) */
template inline T xpow (I m, T val)
  { return (m&1) ? -val : val; }

template struct isqrt_helper__
  {};
template struct isqrt_helper__ 
  {
  static uint32 isqrt (I arg)
    {
    using namespace std;
    return uint32 (sqrt(arg+0.5));
    }
  };
template struct isqrt_helper__ 
  {
  static uint32 isqrt (I arg)
    {
    using namespace std;
    I res = sqrt(double(arg)+0.5);
    if (arg<(int64(1)<<50)) return uint32(res);
    if (res*res>arg)
      --res;
    else if ((res+1)*(res+1)<=arg)
      ++res;
    return uint32(res);
    }
  };

/*! Returns the integer \a n, which fulfills \a n*n<=arg<(n+1)*(n+1). */
template inline uint32 isqrt (I arg)
  { return isqrt_helper__4)>::isqrt(arg); }

/*! Returns the largest integer \a n that fulfills \a 2^n<=arg. */
template inline int ilog2 (I arg)
  {
#ifdef __GNUC__
  if (arg==0) return 0;
  if (sizeof(I)==sizeof(int))
    return 8*sizeof(int)-1-__builtin_clz(arg);
  if (sizeof(I)==sizeof(long))
    return 8*sizeof(long)-1-__builtin_clzl(arg);
  if (sizeof(I)==sizeof(long long))
    return 8*sizeof(long long)-1-__builtin_clzll(arg);
#endif
  int res=0;
  while (arg > 0xFFFF) { res+=16; arg>>=16; }
  if (arg > 0x00FF) { res|=8; arg>>=8; }
  if (arg > 0x000F) { res|=4; arg>>=4; }
  if (arg > 0x0003) { res|=2; arg>>=2; }
  if (arg > 0x0001) { res|=1; }
  return res;
  }

template inline int ilog2_nonnull (I arg)
  {
#ifdef __GNUC__
  if (sizeof(I)<=sizeof(int))
    return 8*sizeof(int)-1-__builtin_clz(arg);
  if (sizeof(I)==sizeof(long))
    return 8*sizeof(long)-1-__builtin_clzl(arg);
  if (sizeof(I)==sizeof(long long))
    return 8*sizeof(long long)-1-__builtin_clzll(arg);
#endif
  return ilog2 (arg);
  }

template inline int trailingZeros(I arg)
  {
  if (arg==0) return sizeof(I)<<3;
#ifdef __GNUC__
  if (sizeof(I)<=sizeof(int))
    return __builtin_ctz(arg);
  if (sizeof(I)==sizeof(long))
    return __builtin_ctzl(arg);
  if (sizeof(I)==sizeof(long long))
    return __builtin_ctzll(arg);
#endif
  int res=0;
  while ((arg&0xFFFF)==0) { res+=16; arg>>=16; }
  if ((arg&0x00FF)==0) { res|=8; arg>>=8; }
  if ((arg&0x000F)==0) { res|=4; arg>>=4; }
  if ((arg&0x0003)==0) { res|=2; arg>>=2; }
  if ((arg&0x0001)==0) { res|=1; }
  return res;
  }

/*! Returns \a atan2(y,x) if \a x!=0 or \a y!=0; else returns 0. */
inline double safe_atan2 (double y, double x)
  {
  using namespace std;
  return ((x==0.) && (y==0.)) ? 0.0 : atan2(y,x);
  }

/*! Helper function for linear interpolation (or extrapolation).
    The array must be ordered in ascending order; no two values may be equal. */
template inline void interpol_helper
  (const Iter &begin, const Iter &end, const T &val, Comp comp, tsize &idx,
  T &frac)
  {
  using namespace std;
  planck_assert((end-begin)>1,"sequence too small for interpolation");
  idx = lower_bound(begin,end,val,comp)-begin;
  if (idx>0) --idx;
  idx = min(tsize(end-begin-2),idx);
  frac = (val-begin[idx])/(begin[idx+1]-begin[idx]);
  }

/*! Helper function for linear interpolation (or extrapolation).
    The array must be ordered in ascending order; no two values may be equal. */
template inline void interpol_helper
  (const Iter &begin, const Iter &end, const T &val, tsize &idx, T &frac)
  { interpol_helper (begin,end,val,std::less(),idx,frac); }

/*! \} */

#if (__cplusplus>=201103L)

template
inline bool multiequal (const T &a, const T &b)
  { return (a==b); }

template
inline bool multiequal (const T &a, const T &b, Args... args)
  { return (a==b) && multiequal (a, args...); }

#else

template inline bool multiequal (const T &a, const T &b)
  { return (a==b); }

template inline bool multiequal (const T &a, const T &b, const T &c)
  { return (a==b) && (a==c); }

template inline bool multiequal (const T &a, const T &b, const T &c,
  const T &d)
  { return (a==b) && (a==c) && (a==d); }

template inline bool multiequal (const T &a, const T &b, const T &c,
  const T &d, const T &e)
  { return (a==b) && (a==c) && (a==d) && (a==e); }

template inline bool multiequal (const T &a, const T &b, const T &c,
  const T &d, const T &e, const T &f)
  { return (a==b) && (a==c) && (a==d) && (a==e) && (a==f); }

#endif

template class kahan_adder
  {
  private:
    T sum, c;
  public:
    kahan_adder(): sum(0), c(0) {}

    void add (const T &val)
      {
      volatile T tc=c; // volatile to disable over-eager optimizers
      volatile T y=val-tc;
      volatile T t=sum+y;
      tc=(t-sum)-y;
      sum=t;
      c=tc;
      }
    T result() const { return sum; }
  };

template bool checkNan (Iter begin, Iter end)
  {
  while (begin!=end)
    {
    if (*begin != *begin) return true;
    ++begin;
    }
  return false;
  }

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/openmp_support.h0000664000175000017500000000415013010375061030020 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file openmp_support.h
 *  Various OpenMP-related convenience functions
 *
 *  Copyright (C) 2005-2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_OPENMP_SUPPORT_H
#define PLANCK_OPENMP_SUPPORT_H

#ifdef _OPENMP
#include 
#endif

#include "share_utils.h"

inline bool openmp_enabled()
  {
#ifdef _OPENMP
  return true;
#else
  return false;
#endif
  }

inline int openmp_max_threads ()
  {
#ifdef _OPENMP
  return omp_get_max_threads();
#else
  return 1;
#endif
  }

inline int openmp_num_threads ()
  {
#ifdef _OPENMP
  return omp_get_num_threads();
#else
  return 1;
#endif
  }

inline int openmp_thread_num ()
  {
#ifdef _OPENMP
  return omp_get_thread_num();
#else
  return 0;
#endif
  }

/*! Calculates the range of indices between \a glo and \a ghi which
    must be processed by this thread and returns it in \a lo and \a hi.

    The indices \a ghi and \a hi are "one past the last real index",
    in analogy to the STL iterators. */
inline void openmp_calc_share (int64 glo, int64 ghi, int64 &lo, int64 &hi)
  {
#ifdef _OPENMP
  calcShareGeneral (glo,ghi,omp_get_num_threads(),omp_get_thread_num(),lo,hi);
#else
  lo=glo; hi=ghi;
#endif
  }

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/paramfile.cc0000664000175000017500000001332513010375061027030 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Class for parsing parameter files
 *
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  Authors: Martin Reinecke, Reinhard Hell
 */

#include 
#include "paramfile.h"
#include "string_utils.h"

using namespace std;

string paramfile::get_valstr(const string &key) const
  {
  params_type::const_iterator loc=params.find(key);
  if (loc!=params.end()) return loc->second;
  planck_fail ("Cannot find the key '" + key + "'.");
  }

bool paramfile::param_unread (const string &key) const
  { return (read_params.find(key)==read_params.end()); }

paramfile::paramfile (const string &filename, bool verbose_)
  : verbose(verbose_)
  { parse_file (filename, params); }

paramfile::paramfile (const params_type &par, bool verbose_)
  : params (par), verbose(verbose_)
  {}

paramfile::~paramfile()
  {
  if (verbose)
    for (params_type::const_iterator loc=params.begin();
      loc!=params.end(); ++loc)
      if (param_unread(loc->first))
      cout << "Parser warning: unused parameter '"
           << loc->first << "'" << endl;
  }

bool paramfile::param_present(const string &key) const
  { return (params.find(key)!=params.end()); }

void paramfile::findhelper (const string &key, const string &value, NDT type,
  bool deflt) const
  {
  string output = value;
  if (type==NAT_STRING) output = "'"+output+"'";
  if (verbose && param_unread(key))
    cout << "Parser: " << key << " = " << output
         << (deflt ? " " : "") << endl;
  read_params.insert(key);
  }

template T paramfile::find (const string &key) const
  {
  T result = stringToData(get_valstr(key));
  findhelper (key, dataToString(result), nativeType(), false);
  return result;
  }

template unsigned char paramfile::find (const string &key) const;
template signed char paramfile::find (const string &key) const;
template unsigned short paramfile::find (const string &key) const;
template short paramfile::find (const string &key) const;
template unsigned int paramfile::find (const string &key) const;
template int paramfile::find (const string &key) const;
template unsigned long paramfile::find (const string &key) const;
template long paramfile::find (const string &key) const;
template unsigned long long paramfile::find (const string &key) const;
template long long paramfile::find (const string &key) const;
template float paramfile::find (const string &key) const;
template double paramfile::find (const string &key) const;
template long double paramfile::find (const string &key) const;
template bool paramfile::find (const string &key) const;
template string paramfile::find (const string &key) const;

template T paramfile::find (const string &key, const T &deflt)
  {
  if (param_present(key)) return find(key);
  string sdeflt=dataToString(deflt);
  findhelper (key, sdeflt, nativeType(), true);
  params[key]=sdeflt;
  return deflt;
  }

template unsigned char paramfile::find (const string &key,
  const unsigned char &deflt);
template signed char paramfile::find (const string &key,
  const signed char &deflt);
template unsigned short paramfile::find (const string &key,
  const unsigned short &deflt);
template short paramfile::find (const string &key, const short &deflt);
template unsigned int paramfile::find (const string &key,
  const unsigned int &deflt);
template int paramfile::find (const string &key, const int &deflt);
template unsigned long paramfile::find (const string &key,
  const unsigned long &deflt);
template long paramfile::find (const string &key, const long &deflt);
template unsigned long long paramfile::find (const string &key,
  const unsigned long long &deflt);
template long long paramfile::find (const string &key, const long long &deflt);
template float paramfile::find (const string &key, const float &deflt);
template double paramfile::find (const string &key, const double &deflt);
template long double paramfile::find (const string &key,
  const long double &deflt);
template bool paramfile::find (const string &key, const bool &deflt);
template string paramfile::find (const string &key, const string &deflt);

void paramfile::setParamString (const string &key, const string &value)
  {
  if (param_present(key))
    {
    if (params[key]!=value)
      {
      if (verbose)
        cout << "Parser: altering value of key '"<=2,"incorrect command line format");
  if ((argc==2) && (string(argv[1]).find("=")==string::npos))
    return paramfile(argv[1],verbose);
  map pmap;
  parse_cmdline_equalsign(argc,argv,pmap);
  return paramfile(pmap,verbose);
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/paramfile.h0000664000175000017500000001010113010375061026657 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file paramfile.h
 *  Class for parsing parameter files
 *
 *  Copyright (C) 2003-2014 Max-Planck-Society
 *  Authors: Martin Reinecke
 */

#ifndef PLANCK_PARAMFILE_H
#define PLANCK_PARAMFILE_H

#include 
#include 
#include 
#include "datatypes.h"
#include "string_utils.h"

/*! Class for storing and querying key/value pairs. The name is historical;
    the parameters can actually be obtained from othersources as well
    (e.g. the command line). */
class paramfile
  {
  private:
    typedef std::map params_type;
    params_type params;
    mutable std::set read_params;
    bool verbose;

    std::string get_valstr(const std::string &key) const;
    bool param_unread (const std::string &key) const;
    void findhelper (const std::string &key, const std::string &value, NDT type,
      bool deflt) const;
    void setParamString (const std::string &key, const std::string &value);

  public:
    paramfile() : verbose(true) {}
    /*! Constructs a paramfile object from the contents of \a filename.
        If  \a verbose_==true, diagnostic output is generated when calling
        methods on this object, otherwise not. */
    paramfile (const std::string &filename, bool verbose_=true);
    /*! Constructs a paramfile object from the contents of \a par.
        If  \a verbose_==true, diagnostic output is generated when calling
        methods on this object, otherwise not. */
    paramfile (const params_type &par, bool verbose_=true);
    ~paramfile();

    /*! Allows adjusting the verbosity. */
    void setVerbosity (bool verbose_)
      { verbose = verbose_; }

    /*! Returns the verbosity setting of the object. */
    bool getVerbosity () const
      { return verbose; }

    /*! Returns \c true, if a paremeter called \a key is stored in the object,
        else \c false. */
    bool param_present(const std::string &key) const;

    /*! Returns the value stored for the parameter name \a key, after converting
        it to the requested type. If \a key is not present, an exception is
        thrown. */
    template T find (const std::string &key) const;
    /*! Returns the value stored for the parameter name \a key, after converting
        it to the requested type. If \a key is not present, \a deflt is returned
        instead, and is also entered into the parameter set. */
    template T find
      (const std::string &key, const T &deflt);

    /*! Returns the entire set of currently stored parameters. */
    const params_type &getParams() const
      { return params; }

    /*! Sets the parameter with the name \a key to \a value. */
    template void setParam (const std::string &key, const T &value)
      { setParamString(key,dataToString(value)); }
  };

/*! Tries to build a \a paramfile object from the contents of a command line.
    If \a argc==2 and \a argv[1] does not contain the character "=", the
    function tries to input parameters from the file \a argv[1]. Otherwise
    the function interprets each command line argument as a "key=value"
    statement. */
paramfile getParamsFromCmdline (int argc, const char **argv,
  bool verbose=true);

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/planck.make0000664000175000017500000000111213010375061026657 0ustar  zoncazonca00000000000000PKG:=cxxsupport

SD:=$(SRCROOT)/$(PKG)
OD:=$(BLDROOT)/$(PKG)

FULL_INCLUDE+= -I$(SD)

HDR_$(PKG):=$(SD)/*.h
LIB_$(PKG):=$(LIBDIR)/libcxxsupport.a
SUPPORT_OBJ:= error_handling.o string_utils.o paramfile.o walltimer.o ls_image.o
MATH_OBJ:= rotmatrix.o trafos.o wigner.o pointing.o geom_utils.o
FITS_OBJ:= fitshandle.o
OBJ:=$(SUPPORT_OBJ) $(MATH_OBJ) $(FITS_OBJ) announce.o
OBJ:=$(OBJ:%=$(OD)/%)

ODEP:=$(HDR_$(PKG)) $(HDR_libfftpack) $(HDR_c_utils)

$(OBJ): $(ODEP) | $(OD)_mkdir
$(LIB_$(PKG)): $(OBJ)

$(OD)/ls_image.o: $(SD)/font_data.inc

all_hdr+=$(HDR_$(PKG))
all_lib+=$(LIB_$(PKG))
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/planck_rng.h0000664000175000017500000001014513010375061027045 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file planck_rng.h
 *  This file contains the random number generator
 *  used by the Planck LevelS package.
 *  The generator is a C++ port of the xorshift generator xor128() described
 *  in Marsaglia, Journal of Statistical Software 2003, vol 8.
 *  It has a period of 2^128 - 1.
 *
 *  Copyright (C) 2003, 2004, 2005 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_RNG_H
#define PLANCK_RNG_H

#include 
#include "error_handling.h"

/*! C++ port of the xorshift generator xor128() described in Marsaglia,
    Journal of Statistical Software 2003, vol 8.
    It has a period of 2^128 - 1. */
class planck_rng
  {
  private:
    unsigned int x,y,z,w;
    double small, gset;
    bool empty;

    void twiddle (unsigned int &v)
      {
      for (int i=0; i<9; ++i)
        {
        v ^= v<<13;
        v ^= v>>17;
        v ^= v<<5;
        }
      }

    void init_rng ()
      {
      // avoid zero seeds
      if (x==0) x = 123456789;
      if (y==0) y = 362436069;
      if (z==0) z = 521288629;
      if (w==0) w = 88675123;

      // shuffle the bits of the seeds
      twiddle(x); twiddle(y); twiddle(z); twiddle(w);

      // burn in the RNG
      for (int i=0; i<16; ++i)
        int_rand_uni();
      }

  public:
    /*! Initializes the generator with 0 to 4 seed values. */
    planck_rng (unsigned int x1=123456789, unsigned int y1=362436069,
                unsigned int z1=521288629, unsigned int w1=88675123)
      : x(x1), y(y1), z(z1), w(w1),
        small(1./(1.+double(0xFFFFFFFF))), gset(0.), empty(true)
      {
      planck_assert (sizeof(unsigned int)==4, "wrong integer size for RNG");
      init_rng();
      }

    /*! Re-initializes the generator with 0 to 4 seed values. */
    void seed (unsigned int x1=123456789, unsigned int y1=362436069,
      unsigned int z1=521288629, unsigned int w1=88675123)
      {
      x = x1; y = y1; z = z1; w = w1;
      empty = true;
      init_rng();
      }

    /*! Returns uniformly distributed random integer numbers from the
        interval [0;0xFFFFFFFF]. */
    unsigned int int_rand_uni()
      {
      unsigned int t = x^(x<<11);
      x = y;
      y = z;
      z = w;

      return w=(w^(w>>19))^(t^(t>>8));
      }

    //! Returns uniformly distributed random numbers from the interval [0;1[.
    double rand_uni()
      {
      return small*int_rand_uni();
      }

    //! Returns random numbers with Gaussian distribution (mean=0, sigma=1).
    /*! Uses rand_uni() internally. */
    double rand_gauss()
      {
      using namespace std;
      if (empty)
        {
        double v1,v2,rsq;
        do
          {
          v1=2*rand_uni()-1.;
          v2=2*rand_uni()-1.;
          rsq=v1*v1+v2*v2;
          }
        while ((rsq>=1) || (rsq==0));
        double fac=sqrt(-2*log(rsq)/rsq);
        gset=v1*fac;
        empty=false;
        return v2*fac;
        }
      else
        {
        empty=true;
        return gset;
        }
      }

    //! Returns exponentially distributed random numbers (mean=1, nonnegative)
    /*! Uses rand_uni() internally. */
    double rand_exp()
      {
      using namespace std;
      double val=rand_uni();
      if (val==0.) val=1.;
      return -log(val);
      }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/pointing.cc0000664000175000017500000000344413010375061026720 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file pointing.cc
 *  Class representing a direction in 3D space
 *
 *  Copyright (C) 2003-2012 Max-Planck-Society
 *  \author Martin Reinecke
 */

#include "pointing.h"
#include "lsconstants.h"
#include "math_utils.h"

using namespace std;

vec3 pointing::to_vec3() const
  {
  double st=sin(theta);
  return vec3 (st*cos(phi), st*sin(phi), cos(theta));
  }
void pointing::from_vec3 (const vec3 &inp)
  {
  theta = atan2(sqrt(inp.x*inp.x+inp.y*inp.y),inp.z);
  phi = safe_atan2 (inp.y,inp.x);
  if (phi<0.) phi += twopi;
  }
void pointing::normalize_theta()
  {
  theta=fmodulo(theta,twopi);
  if (theta>pi)
    {
    phi+=pi;
    theta=twopi-theta;
    }
  }
void pointing::normalize()
  {
  normalize_theta();
  phi=fmodulo(phi,twopi);
  }

ostream &operator<< (ostream &os, const pointing &p)
  {
  os << p.theta << ", " << p.phi << std::endl;
  return os;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/pointing.h0000664000175000017500000000511713010375061026561 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file pointing.h
 *  Class representing a direction in 3D space
 *
 *  Copyright (C) 2003-2012 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_POINTING_H
#define PLANCK_POINTING_H

#include 
#include "vec3.h"

/*! \defgroup pointinggroup Pointings */
/*! \{ */

/*! Class representing a direction in 3D space or a location on the
    unit sphere. All angles in radians. */
class pointing
  {
  public:
    /*! Colatitude of the pointing (i.e. the North pole is at \a theta=0). */
    double theta;
    /*! Longitude of the pointing. */
    double phi;

    /*! Default constructor. \a theta and \a phi are not initialized. */
    pointing() {}
    /*! Creates a pointing with \a Theta and \a Phi. */
    pointing (double Theta, double Phi) : theta(Theta), phi(Phi) {}

// FIXME: should become "explicit" some time
    /*! Creates a pointing from the vector \a inp. \a inp need not be
        normalized. */
    pointing (const vec3 &inp)
      { from_vec3(inp); }
// FIXME: should be removed some time
    /*! Returns a normalized vector pointing in the same direction. */
    operator vec3() const
      { return to_vec3(); }
    /*! Returns a normalized vector pointing in the same direction. */
    vec3 to_vec3() const;
    /*! Converts \a inp to \a ptg. \a inp need not be normalized. */
    void from_vec3 (const vec3 &inp);
    /*! Changes the angles so that \a 0<=theta<=pi. */
    void normalize_theta();
    /*! Changes the angles so that \a 0<=theta<=pi and \a 0<=phi<2*pi. */
    void normalize();
  };

/*! Writes \a p to \a os.
    \relates pointing */
std::ostream &operator<< (std::ostream &os, const pointing &p);

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/rangeset.h0000664000175000017500000003426113010375061026544 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file rangeset.h
 *  Class for storing sets of ranges of integer numbers
 *
 *  Copyright (C) 2011-2014 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_RANGESET_H
#define PLANCK_RANGESET_H

#include 
#include 
#include 
#include 
#include "datatypes.h"
#include "error_handling.h"

/*! Class for storing sets of ranges of integer numbers */
template class rangeset
  {
  private:
    typedef std::vector rtype;
    typedef typename rtype::iterator iterator;
    typedef typename rtype::const_iterator c_iterator;
    rtype r;

    /*! Returns the index of the last number in \c r which is <= \a val.
        If \a val is smaller than all numbers in \c r, returns -1. */
    tdiff iiv (const T &val) const
      { return tdiff(std::upper_bound(r.begin(),r.end(),val)-r.begin())-1; }

    void addRemove (T a, T b, tdiff v)
      {
      tdiff pos1=iiv(a), pos2=iiv(b);
      if ((pos1>=0) && (r[pos1]==a)) --pos1;
      // first to delete is at pos1+1; last is at pos2
      bool insert_a = (pos1&1)==v;
      bool insert_b = (pos2&1)==v;
      tdiff rmstart=pos1+1+(insert_a ? 1 : 0);
      tdiff rmend  =pos2-(insert_b ? 1 : 0);

      planck_assert((rmend-rmstart)&1,"cannot happen");

      if (insert_a && insert_b && (pos1+1>pos2)) // insert
        {
        r.insert(r.begin()+pos1+1,2,a);
        r[pos1+2]=b;
        }
      else
        {
        if (insert_a) r[pos1+1]=a;
        if (insert_b) r[pos2]=b;
        r.erase(r.begin()+rmstart,r.begin()+rmend+1);
        }
      }

    /*! Estimate a good strategy for set operations involving two rangesets. */
    static int strategy (tsize sza, tsize szb)
      {
      const double fct1 = 1.;
      const double fct2 = 1.;
      tsize slo = sza-1) && (!state_b)) r.push_back(a.r[iva]);
        while((ivba.r[asz-1])) return false; }
        else
          {
          tdiff ivb=b.iiv(a.r[iva]);
          if ((ivb!=bsz-1)&&(b.r[ivb+1]>1; }
    tsize size() const { return nranges(); }
    bool empty() const { return r.empty(); }
    /*! Returns the current vector of ranges. */
    const rtype &data() const { return r; }
    void checkConsistency() const
      {
      planck_assert((r.size()&1)==0,"invalid number of entries");
      for (tsize i=1; ir[i-1],"inconsistent entries");
      }
    void setData (const rtype &inp)
      {
      r=inp;
      checkConsistency();
      }

    /*! Returns the first value of range \a i. */
    const T &ivbegin (tdiff i) const { return r[2*i]; }
    /*! Returns the one-past-last value of range \a i. */
    const T &ivend (tdiff i) const { return r[2*i+1]; }
    /*! Returns the length of range \a i. */
    T ivlen (tdiff i) const { return r[2*i+1]-r[2*i]; }

    /*! Appends \a [v1;v2[ to the rangeset. \a v1 must be larger
        than the minimum of the last range in the rangeset. */
    void append(const T &v1, const T &v2)
      {
      if (v2<=v1) return;
      if ((!r.empty()) && (v1<=r.back()))
        {
        planck_assert (v1>=r[r.size()-2],"bad append operation");
        if (v2>r.back()) r.back()=v2;
        }
      else
        { r.push_back(v1); r.push_back(v2); }
      }
    /*! Appends \a [v;v+1[ to the rangeset. \a v must be larger
        than the minimum of the last range in the rangeset. */
    void append(const T &v)
      { append(v,v+1); }

    /*! Appends \a other to the rangeset. All values in \a other must be larger
        than the minimum of the last range in the rangeset. */
    void append (const rangeset &other)
      {
      for (tsize j=0; j=r[r.size()-2])) append(v1,v2);
      addRemove(v1,v2,1);
      }
    /*! After this operation, the rangeset contains the union of itself
        with \a [v;v+1[. */
    void add(const T &v) { add(v,v+1); }

    /*! Removes all values within \a [v1;v2[ from the rangeset. */
    void remove(const T &v1, const T &v2)
      {
      if (v2<=v1) return;
      if (r.empty()) return;
      if ((v2<=r[0])||(v1>=r.back())) return;
      if ((v1<=r[0]) && (v2>=r.back())) { r.clear(); return; }
      addRemove(v1,v2,0);
      }
    /*! Removes the value \a v from the rangeset. */
    void remove(const T &v) { remove(v,v+1); }

    /*! Removes all values not within \a [a;b[ from the rangeset. */
    void intersect (const T &a, const T &b)
      {
      if (r.empty()) return; // nothing to remove
      if ((b<=r[0]) || (a>=r.back())) { r.clear(); return; } // no overlap
      if ((a<=r[0]) && (b>=r.back())) return; // full rangeset in interval

      tdiff pos2=iiv(b);
      if ((pos2>=0) && (r[pos2]==b)) --pos2;
      bool insert_b = (pos2&1)==0;
      r.erase(r.begin()+pos2+1,r.end());
      if (insert_b) r.push_back(b);

      tdiff pos1=iiv(a);
      bool insert_a = (pos1&1)==0;
      if (insert_a) r[pos1--]=a;
      if (pos1>=0)
        r.erase(r.begin(),r.begin()+pos1+1);
      }

    /*! Returns the total number of elements in the rangeset. */
    T nval() const
      {
      T result=T(0);
      for (tsize i=0; i &res) const
      {
      res.clear();
      res.reserve(nval());
      for (tsize i=0; i toVector() const
      {
      std::vector res;
      toVector(res);
      return res;
      }

    /*! Returns the union of this rangeset and \a other. */
    rangeset op_or (const rangeset &other) const
      {
      rangeset res;
      res.generalUnion (*this,other,false,false);
      return res;
      }
    /*! Returns the intersection of this rangeset and \a other. */
    rangeset op_and (const rangeset &other) const
      {
      rangeset res;
      res.generalUnion (*this,other,true,true);
      return res;
      }
    /*! Returns the part of this rangeset which is not in \a other. */
    rangeset op_andnot (const rangeset &other) const
      {
      rangeset res;
      res.generalUnion (*this,other,true,false);
      return res;
      }
    /*! Returns the parts of this rangeset and \a other, which are not in
        both rangesets. */
    rangeset op_xor (const rangeset &other) const
      {
      rangeset res;
      res.generalXor (*this,other);
      return res;
      }

    /*! Returns the index of the interval containing \a v; if no such interval
        exists, -1 is returned. */
    tdiff findInterval (const T &v) const
      {
      tdiff res = iiv(v);
      return (res&1) ? -1 : res>>1;
      }

    /*! Returns \a true if the rangeset is identical to \a other, else \a false.
        */
    bool operator== (const rangeset &other) const
      { return r==other.r; }

    /*! Returns \a true if the rangeset contains all values in the range
        \a [a;b[, else \a false. */
    bool contains (T a,T b) const
      {
      tdiff res=iiv(a);
      if (res&1) return false;
      return (b<=r[res+1]);
      }
    /*! Returns \a true if the rangeset contains the value \a v,
        else \a false. */
    bool contains (T v) const
      { return !(iiv(v)&1); }
    /*! Returns \a true if the rangeset contains all values stored in \a other,
        else \a false. */
    bool contains (const rangeset &other) const
      { return generalAllOrNothing(*this,other,false,true); }
    /** Returns true if any of the numbers [a;b[ are contained in the set,
        else false. */
    bool overlaps (T a,T b) const
      {
      tdiff res=iiv(a);
      if ((res&1)==0) return true;
      if (res==tdiff(r.size())-1) return false; // beyond the end of the set
      return (r[res+1] inline std::ostream &operator<< (std::ostream &os,
  const rangeset &rs)
  {
  os << "{ ";
  for (tsize i=0; i
#include "rotmatrix.h"
#include "lsconstants.h"

using namespace std;

rotmatrix::rotmatrix (const vec3 &a, const vec3 &b, const vec3 &c)
  {
  entry[0][0]=a.x; entry[0][1]=b.x; entry[0][2]=c.x;
  entry[1][0]=a.y; entry[1][1]=b.y; entry[1][2]=c.y;
  entry[2][0]=a.z; entry[2][1]=b.z; entry[2][2]=c.z;
  }

void rotmatrix::SetToIdentity ()
  {
  entry[0][0] = entry[1][1] = entry[2][2] = 1.;
  entry[0][1] = entry[1][0] = entry[0][2] =
  entry[2][0] = entry[1][2] = entry[2][1] = 0.;
  }

void rotmatrix::SetToZero ()
  {
  for (int m=0; m<3; ++m)
    entry[m][0] = entry[m][1] = entry[m][2] = 0;
  }

void rotmatrix::Transpose ()
  {
  swap(entry[0][1], entry[1][0]);
  swap(entry[0][2], entry[2][0]);
  swap(entry[1][2], entry[2][1]);
  }

void rotmatrix::toAxisAngle (vec3 &axis, double &angle) const
  {
  double c2 = entry[0][0] + entry[1][1] + entry[2][2] - 1;
  axis.x = entry[2][1] - entry[1][2];
  axis.y = entry[0][2] - entry[2][0];
  axis.z = entry[1][0] - entry[0][1];

  double s2 = axis.Length();

  if (s2>0)
    {
    angle = atan2(s2,c2);
    axis *= 1/s2;
    return;
    }

  if (c2>=2) // angle is 0
    {
    axis = vec3(1,0,0);
    angle = 0;
    return;
    }

  angle = pi;

  int choice = 0; // assume entry[0][0] is the largest
  if ((entry[1][1]>entry[0][0]) && (entry[1][1]>entry[2][2])) choice=1;
  if ((entry[2][2]>entry[0][0]) && (entry[2][2]>entry[1][1])) choice=2;

  if (choice==0)
    {
    axis.x = 0.5*sqrt(entry[0][0]-entry[1][1]-entry[2][2]+1);
    double half_inv = 0.5/axis.x;
    axis.y = half_inv*entry[0][1];
    axis.z = half_inv*entry[0][2];
    return;
    }
  if (choice==1)
    {
    axis.y = 0.5*sqrt(entry[1][1]-entry[0][0]-entry[2][2]+1);
    double half_inv = 0.5/axis.y;
    axis.x = half_inv*entry[0][1];
    axis.z = half_inv*entry[1][2];
    return;
    }

  axis.z = 0.5*sqrt(entry[2][2]-entry[0][0]-entry[1][1]+1);
  double half_inv = 0.5/axis.z;
  axis.x = half_inv*entry[0][2];
  axis.y = half_inv*entry[1][2];
  }

void rotmatrix::Make_Axis_Rotation_Transform (const vec3 &axis, double angle)
  {
  double sa=sin(angle), ca=cos(angle);
  double ica=1-ca;
  entry[0][0] = axis.x*axis.x*ica + ca;
  entry[1][1] = axis.y*axis.y*ica + ca;
  entry[2][2] = axis.z*axis.z*ica + ca;
  double t1 = axis.x*axis.y*ica, t2 = axis.z*sa;
  entry[1][0] = t1 + t2;
  entry[0][1] = t1 - t2;
  t1 = axis.x*axis.z*ica; t2 = axis.y*sa;
  entry[2][0] = t1 - t2;
  entry[0][2] = t1 + t2;
  t1 = axis.y*axis.z*ica; t2 = axis.x*sa;
  entry[1][2] = t1 - t2;
  entry[2][1] = t1 + t2;
  }

void rotmatrix::Make_CPAC_Euler_Matrix
  (double alpha, double beta, double gamma)
  {
  double ca=cos(alpha), cb=cos(beta), cg=cos(gamma);
  double sa=sin(alpha), sb=sin(beta), sg=sin(gamma);

  entry[0][0]= ca*cb*cg-sa*sg; entry[0][1]=-ca*cb*sg-sa*cg; entry[0][2]= ca*sb;
  entry[1][0]= sa*cb*cg+ca*sg; entry[1][1]=-sa*cb*sg+ca*cg; entry[1][2]= sa*sb;
  entry[2][0]=-sb*cg;          entry[2][1]= sb*sg;          entry[2][2]= cb;
  }

void rotmatrix::Extract_CPAC_Euler_Angles
  (double &alpha, double &beta, double &gamma) const
  {
  double cb = entry[2][2];
  double sb = sqrt(entry[0][2]*entry[0][2] + entry[1][2]*entry[1][2]);
  beta=atan2(sb,cb);
  if (abs(sb)<=1e-6)
    {
    alpha=0;
    if (cb>0)
      gamma=atan2(entry[1][0],entry[0][0]);
    else
      gamma=atan2(entry[0][1],-entry[0][0]);
    }
  else
    {
    alpha=atan2(entry[1][2],entry[0][2]);
    gamma=atan2(entry[2][1],-entry[2][0]);
    }
  }

rotmatrix operator* (const rotmatrix &a, const rotmatrix &b)
  {
  rotmatrix res;
  for (int i=0; i<3; ++i)
    for (int j=0; j<3; ++j)
      res.entry[i][j] = a.entry[i][0] * b.entry[0][j]
                      + a.entry[i][1] * b.entry[1][j]
                      + a.entry[i][2] * b.entry[2][j];
  return res;
  }

void matmult (const rotmatrix &a, const rotmatrix &b, rotmatrix &res)
  {
  for (int i=0; i<3; ++i)
    for (int j=0; j<3; ++j)
      res.entry[i][j] = a.entry[i][0] * b.entry[0][j]
                      + a.entry[i][1] * b.entry[1][j]
                      + a.entry[i][2] * b.entry[2][j];
  }

void TransposeTimes (const rotmatrix &a, const rotmatrix &b, rotmatrix &res)
  {
  for (int i=0; i<3; ++i)
    for (int j=0; j<3; ++j)
      res.entry[i][j] = a.entry[0][i] * b.entry[0][j]
                      + a.entry[1][i] * b.entry[1][j]
                      + a.entry[2][i] * b.entry[2][j];
  }

ostream &operator<< (ostream &os, const rotmatrix &mat)
  {
  for (int i=0;i<3;++i)
    os << mat.entry[i][0] << ' '
       << mat.entry[i][1] << ' '
       << mat.entry[i][2] << endl;
  return os;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/rotmatrix.h0000664000175000017500000001127413010375061026764 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file rotmatrix.h
 *  Class for rotation transforms in 3D space
 *
 *  Copyright (C) 2003-2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_ROTMATRIX_H
#define PLANCK_ROTMATRIX_H

#include 
#include "vec3.h"

/*! \defgroup rotmatrixgroup Rotation matrices */
/*! \{ */

/*! Class for rotation transforms in 3D space */
class rotmatrix
  {
  public:
    double entry[3][3];

    rotmatrix () {}

    /*! Constructs a rotation matrix from its nine entries */
    rotmatrix (double a00, double a01, double a02,
               double a10, double a11, double a12,
               double a20, double a21, double a22)
      {
      entry[0][0]=a00; entry[0][1]=a01; entry[0][2]=a02;
      entry[1][0]=a10; entry[1][1]=a11; entry[1][2]=a12;
      entry[2][0]=a20; entry[2][1]=a21; entry[2][2]=a22;
      }

    /*! Constructs a rotation matrix so that \a a is the first column,
        \a b is the second column and \a c is the third column.
        \note The vectors \a a, \a b and \a c must form an orthonormal system!
     */
    rotmatrix (const vec3 &a, const vec3 &b, const vec3 &c);

    /*! Sets the matrix to the identity matrix. */
    void SetToIdentity ();
    /*! Sets all matrix elements to zero. */
    void SetToZero ();
    /*! Transposes the matrix. */
    void Transpose ();

    /*! Extracts a unit-length rotation axis \a axis and a rotation angle
        \a angle (in radian) from the matrix. */
    void toAxisAngle (vec3 &axis, double &angle) const;

    /*! Constructs a matrix which causes a rotation by \a angle radians around
        \a axis. \a axis must have unit length. */
    void Make_Axis_Rotation_Transform (const vec3 &axis, double angle);

    /*! Creates a rotation matrix \a A, which performs the following operations
        on a vector \a v, when \a Av is calculated:
        -# rotate \a v around the z-axis by \a gamma,
        -# rotate \a v' around the y-axis by \a beta,
        -# rotate \a v'' around the z-axis by \a alpha.

        \note \a alpha, \a beta and \a gamma are given in radians,
              the rotations are right handed.

        \note This transformation rotates the \e vectors, not the coordinate
              axes! */
    void Make_CPAC_Euler_Matrix (double alpha, double beta, double gamma);

    /*! Extracts the Euler angles \a alpha, \a beta and \a gamma from the
        matrix. For their definition see Make_CPAC_Euler_Matrix().

        \note In case of ambiguity \a alpha will be 0. */
    void Extract_CPAC_Euler_Angles
      (double &alpha, double &beta, double &gamma) const;

    /*! Returns the vector \a vec, transformed by the matrix. */
    vec3 Transform (const vec3 &vec) const
      {
      return vec3
        (vec.x*entry[0][0] + vec.y*entry[0][1] + vec.z*entry[0][2],
         vec.x*entry[1][0] + vec.y*entry[1][1] + vec.z*entry[1][2],
         vec.x*entry[2][0] + vec.y*entry[2][1] + vec.z*entry[2][2]);
      }
    /*! Returns the vector \a vec, transformed by the matrix, in \a vec2. */
    void Transform (const vec3 &vec, vec3 &vec2) const
      {
      vec2.x = vec.x*entry[0][0] + vec.y*entry[0][1] + vec.z*entry[0][2];
      vec2.y = vec.x*entry[1][0] + vec.y*entry[1][1] + vec.z*entry[1][2];
      vec2.z = vec.x*entry[2][0] + vec.y*entry[2][1] + vec.z*entry[2][2];
      }
  };

/*! Returns \a a * \a b.
    \relates rotmatrix */
rotmatrix operator* (const rotmatrix &a, const rotmatrix &b);
/*! Returns \a a * \a b in \a res.
    \relates rotmatrix */
void matmult (const rotmatrix &a, const rotmatrix &b, rotmatrix &res);

/*! Returns \a a^T * \a b in \a res.
    \relates rotmatrix */
void TransposeTimes (const rotmatrix &a, const rotmatrix &b, rotmatrix &res);

/*! Writes \a mat to \a os.
    \relates rotmatrix */
std::ostream &operator<< (std::ostream &os, const rotmatrix &mat);

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/safe_cast.h0000664000175000017500000000530513010375061026661 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file safe_cast.h
 *  Numerical cast operator with additional checks that the value is preserved.
 *
 *  Copyright (C) 2009 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#ifndef PLANCK_SAFE_CAST_H
#define PLANCK_SAFE_CAST_H

#include 
#include "error_handling.h"

template struct safe_cast_helper__
  {};

template struct safe_cast_helper__ 
  {
  static T1 cast (const T2 &arg)
    {
    T1 res = T1(arg);
    planck_assert(T2(res)==arg, "safe_cast: value changed during cast");
    return res;
    }
  };

template struct safe_cast_helper__ 
  {
  static T1 cast (const T2 &arg)
    {
    T1 res = T1(arg);
    planck_assert(T2(res)==arg, "safe_cast: value changed during cast");
    return res;
    }
  };

template struct safe_cast_helper__ 
  {
  static T1 cast (const T2 &arg)
    {
    T1 res = T1(arg);
    planck_assert((res>=0) && (T2(res)==arg),
      "safe_cast: value changed during cast");
    return res;
    }
  };

template struct safe_cast_helper__ 
  {
  static T1 cast (const T2 &arg)
    {
    T1 res = T1(arg);
    planck_assert((arg>=0) && (T2(res)==arg),
      "safe_cast: value changed during cast");
    return res;
    }
  };

/*! Tries to cast \a arg from its type to a variable of type \c T1.
    If this conversion leads to a change of the actual value (e.g. due to
    overflow or truncation), an exception is thrown. */
template inline T1 safe_cast(const T2 &arg)
  {
  return safe_cast_helper__::is_signed,
    std::numeric_limits::is_signed>::cast(arg);
  }

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/safe_ptr.h0000664000175000017500000000410213010375061026526 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file safe_ptr.h
 *  Pointer wrapper for better exception safety and leakage prevention
 *
 *  Copyright (C) 2005-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SAFE_PTR_H
#define PLANCK_SAFE_PTR_H

#if (__cplusplus>=201103L)

#include 
template using safe_ptr = std::unique_ptr;

#else

#include "error_handling.h"

template  class safe_ptr
  {
  private:
    T *p;
    bool set;

    // forbid copying of safe_ptrs, at least until we know how to do it
    safe_ptr (const safe_ptr &) {}
    safe_ptr &operator= (const safe_ptr &) { return *this; }

  public:
    safe_ptr() : p(0), set(false) {}
    safe_ptr (T *p2) : p(p2), set(true) {}
    ~safe_ptr() { delete p; }

    void reset (T *p2)
      {
      planck_assert (!set, "safe_ptr: already set");
      set = true;
      p=p2;
      }

    void reset()
      {
      delete p;
      p=0;
      set=false;
      }

    T * get() const
      { return p; }

    operator T*() { return p; }
    operator const T*() const { return p; }
    T *operator->() { return p; }
    const T *operator->() const { return p; }
  };

#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/share_utils.h0000664000175000017500000000567213010375061027262 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file share_utils.h
 *  Various convenience functions for subdividing tasks into chunks
 *
 *  Copyright (C) 2002-2014 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SHARE_UTILS_H
#define PLANCK_SHARE_UTILS_H

#include "datatypes.h"

/*! Divides the index range [\a glo; \a ghi) into \a nshares approximately
    equal parts, and returns the sub-range [\a lo; \a hi) of the
    part with the number \a myshare (first part has index 0). */
inline void calcShareGeneral (int64 glo, int64 ghi, int64 nshares,
  int64 myshare, int64 &lo, int64 &hi)
  {
  int64 nwork = ghi-glo;
  int64 nbase = nwork/nshares;
  int64 additional = nwork%nshares;
  lo = glo+myshare*nbase + ((myshare=s_full) return false;
      start=offset;
      size=min(s_chunk,s_full-offset);
      offset+=s_chunk;
      return true;
      }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/sort_utils.h0000664000175000017500000001002013010375061027126 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sort_utils.h
 *  Various helper functions for sorting sequences.
 *
 *  Copyright (C) 2002-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SORT_UTILS_H
#define PLANCK_SORT_UTILS_H

#include 
#include 
#include 

template class IdxComp__
  {
  private:
    It begin;
    Comp comp;
  public:
    IdxComp__ (It begin_, Comp comp_): begin(begin_), comp(comp_) {}
    bool operator() (std::size_t a, std::size_t b) const
      { return comp(*(begin+a),*(begin+b)); }
  };

/*! Performs an indirect sort on the supplied iterator range and returns in
    \a idx a \a vector containing the indices of the smallest, second smallest,
    third smallest, etc. element, according to \a comp. */
template
  inline void buildIndex (It begin, It end, std::vector &idx, Comp comp)
  {
  using namespace std;
  T2 num=end-begin;
  idx.resize(num);
  for (T2 i=0; i(begin,comp));
  }

/*! Performs an indirect sort on the supplied iterator range and returns in
    \a idx a \a vector containing the indices of the smallest, second smallest,
    third smallest, etc. element. */
template inline void buildIndex (It begin, It end,
  std::vector &idx)
  {
  using namespace std;
  typedef typename iterator_traits::value_type T;
  buildIndex(begin,end,idx,less());
  }

/*! Sorts the supplied iterator range according to the order given by \a idx.
    The operation is done out of place and requires temporary extra storage. */
template inline void sortByIndex (It begin, It end,
  const std::vector &idx)
  {
  using namespace std;
  typedef typename iterator_traits::value_type T;
  T2 num=end-begin;
  T *tmp= new T[num];
  for (T2 i=0; i inline void sortByIndex_inplace
  (It begin, It end, const std::vector &idx)
  {
  using namespace std;
  typedef typename iterator_traits::value_type T;
  T2 num=end-begin;
  vector done(num,false);
  T2 cnt=0;
  while (cnt inline void indirectSort (It begin, It end,
  Comp comp)
  {
  using namespace std;
  vector idx;
  buildIndex (begin,end,idx,comp);
  sortByIndex (begin,end,idx);
  }

template inline void indirectSort (It begin, It end)
  {
  using namespace std;
  typedef typename iterator_traits::value_type T;
  indirectSort(begin,end,less());
  }

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/sse_utils_cxx.h0000664000175000017500000003122313010375061027623 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sse_utils_cxx.h
 *  SSE/SSE2/SSE3-related functionality for C++
 *
 *  Copyright (C) 2011, 2012 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SSE_UTILS_CXX_H
#define PLANCK_SSE_UTILS_CXX_H

template class svec;

#if (defined(__SSE2__))

#include 
#include 

template<> class svec
  {
  public:
    typedef int Ts;
    typedef __m128i Tv;
    typedef union { Tv v; Ts d[4]; } Tu;
    Tv v;

    svec () {}
    svec (const svec &b) : v(b.v) {}
    svec (const Tv &b) : v(b) {}
    svec (const Ts &val) : v(_mm_set1_epi32(val)) {}
    svec (const Ts &val1, const Ts &val2, const Ts &val3, const Ts &val4)
      : v(_mm_set_epi32(val4,val3,val2,val1)) {}

    const svec &operator= (const Ts &val)
      { v=_mm_set1_epi32(val); return *this; }
    const svec &operator= (const svec &b)
      { v=b.v; return *this; }

    Ts operator[] (int p) const
      { Tu u; u.v=v; return u.d[p]; }
    void set (int p, Ts val)
      { Tu u; u.v=v; u.d[p]=val; v=u.v; }

    const svec &operator+= (const svec &b)
      { v=_mm_add_epi32(v,b.v); return *this; }
    const svec &operator-= (const svec &b)
      { v=_mm_sub_epi32(v,b.v); return *this; }
    svec operator+ (const svec &b) const
      { return svec(_mm_add_epi32(v,b.v)); }
    svec operator- (const svec &b) const
      { return svec(_mm_sub_epi32(v,b.v)); }

    const svec &operator&= (const svec &b)
      { v=_mm_and_si128(v,b.v); return *this; }
    const svec &operator|= (const svec &b)
      { v=_mm_or_si128(v,b.v); return *this; }
    const svec &operator^= (const svec &b)
      { v=_mm_xor_si128(v,b.v); return *this; }
    svec operator& (const svec &b) const
      { return svec(_mm_and_si128(v,b.v)); }
    svec operator| (const svec &b) const
      { return svec(_mm_or_si128(v,b.v)); }
    svec operator^ (const svec &b) const
      { return svec(_mm_xor_si128(v,b.v)); }
    svec andnot (const svec &b) const
      { return svec(_mm_andnot_si128(v,b.v)); }

    const svec &operator<<= (int b)
      { v=_mm_slli_epi32(v,b); return *this; }
    svec operator<< (int b) const
      { return svec(_mm_slli_epi32(v,b)); }
    const svec &operator>>= (int b)
      { v=_mm_srai_epi32(v,b); return *this; }
    svec operator>> (int b) const
      { return svec(_mm_srai_epi32(v,b)); }

    svec eq (const svec &b) const
      { return svec(_mm_cmpeq_epi32(v,b.v)); }
    svec gt (const svec &b) const
      { return svec(_mm_cmpgt_epi32(v,b.v)); }
    svec lt (const svec &b) const
      { return svec(_mm_cmplt_epi32(v,b.v)); }
  };

typedef svec V4si;

#if 0
template<> class svec
  {
  public:
    typedef long long Ts;
    typedef __m128i Tv;
    typedef union { Tv v; Ts d[2]; } Tu;
    Tv v;

    svec () {}
    svec (const svec &b) : v(b.v) {}
    svec (const Tv &b) : v(b) {}
    svec (const Ts &val) : v(_mm_set1_epi64x(val)) {}
    svec (const Ts &val1, const Ts &val2)
      : v(_mm_set_epi64x(val2,val1)) {}

    const svec &operator= (const Ts &val)
      { v=_mm_set1_epi64x(val); return *this; }
    const svec &operator= (const svec &b)
      { v=b.v; return *this; }

    int operator[] (int p) const
      { Tu u; u.v=v; return u.d[p]; }
    void set (int p, int val)
      { Tu u; u.v=v; u.d[p]=val; v=u.v; }

    const svec &operator+= (const svec &b)
      { v=_mm_add_epi64(v,b.v); return *this; }
    const svec &operator-= (const svec &b)
      { v=_mm_sub_epi64(v,b.v); return *this; }
    svec operator+ (const svec &b) const
      { return svec(_mm_add_epi64(v,b.v)); }
    svec operator- (const svec &b) const
      { return svec(_mm_sub_epi64(v,b.v)); }

    const svec &operator&= (const svec &b)
      { v=_mm_and_si128(v,b.v); return *this; }
    const svec &operator|= (const svec &b)
      { v=_mm_or_si128(v,b.v); return *this; }
    const svec &operator^= (const svec &b)
      { v=_mm_xor_si128(v,b.v); return *this; }
    svec operator& (const svec &b) const
      { return svec(_mm_and_si128(v,b.v)); }
    svec operator| (const svec &b) const
      { return svec(_mm_or_si128(v,b.v)); }
    svec operator^ (const svec &b) const
      { return svec(_mm_xor_si128(v,b.v)); }
    svec andnot (const svec &b) const
      { return svec(_mm_andnot_si128(v,b.v)); }

    const svec &operator<<= (int b)
      { v=_mm_slli_epi64(v,b); return *this; }
    svec operator<< (int b) const
      { return svec(_mm_slli_epi64(v,b)); }
  };

typedef svec V2di;
#endif

template<> class svec
  {
  public:
    typedef float Ts;
    typedef __m128 Tv;
    typedef union { Tv v; Ts d[4]; } Tu;
    Tv v;

    svec () {}
    svec (const svec &b) : v(b.v) {}
    svec (const Tv &b) : v(b) {}
    svec (const Ts &val) : v(_mm_set1_ps(val)) {}
    svec (Ts val1, Ts val2, Ts val3, Ts val4)
      : v(_mm_set_ps(val4,val3,val2,val1)) {}
    explicit svec (const svec &b) : v(_mm_cvtepi32_ps(b.v)) {}

    operator svec() const
      { return svec (_mm_cvtps_epi32(v)); }
    const svec &operator= (const Ts &val)
      { v=_mm_set1_ps(val); return *this; }
    const svec &operator= (const svec &b)
      { v=b.v; return *this; }

    Ts operator[] (int p) const
      { Tu u; u.v=v; return u.d[p]; }
    void set (int p, Ts val)
      { Tu u; u.v=v; u.d[p]=val; v=u.v; }

    const svec &operator+= (const svec &b)
      { v=_mm_add_ps(v,b.v); return *this; }
    const svec &operator-= (const svec &b)
      { v=_mm_sub_ps(v,b.v); return *this; }
    const svec &operator*= (const svec &b)
      { v=_mm_mul_ps(v,b.v); return *this; }
    const svec &operator/= (const svec &b)
      { v=_mm_div_ps(v,b.v); return *this; }

    svec operator+ (const svec &b) const
      { return svec(_mm_add_ps(v,b.v)); }
    svec operator- (const svec &b) const
      { return svec(_mm_sub_ps(v,b.v)); }
    svec operator* (const svec &b) const
      { return svec(_mm_mul_ps(v,b.v)); }
    svec operator/ (const svec &b) const
      { return svec(_mm_div_ps(v,b.v)); }

    const svec &operator&= (const svec &b)
      { v=_mm_and_ps(v,b.v); return *this; }
    const svec &operator|= (const svec &b)
      { v=_mm_or_ps(v,b.v); return *this; }
    const svec &operator^= (const svec &b)
      { v=_mm_xor_ps(v,b.v); return *this; }
    svec operator& (const svec &b) const
      { return svec(_mm_and_ps(v,b.v)); }
    svec andnot (const svec &b) const
      { return svec(_mm_andnot_ps(v,b.v)); }
    svec operator| (const svec &b) const
      { return svec(_mm_or_ps(v,b.v)); }
    svec operator^ (const svec &b) const
      { return svec(_mm_xor_ps(v,b.v)); }

    svec operator- () const
      { return svec(_mm_xor_ps(_mm_set1_ps(-0.),v)); }

    svec eq (const svec &b) const
      { return svec(_mm_cmpeq_ps(v,b.v)); }
    svec neq (const svec &b) const
      { return svec(_mm_cmpneq_ps(v,b.v)); }
    svec lt (const svec &b) const
      { return svec(_mm_cmplt_ps(v,b.v)); }
    svec le (const svec &b) const
      { return svec(_mm_cmple_ps(v,b.v)); }
    svec gt (const svec &b) const
      { return svec(_mm_cmpgt_ps(v,b.v)); }
    svec ge (const svec &b) const
      { return svec(_mm_cmpge_ps(v,b.v)); }

    void writeTo (Ts *val) const
      { _mm_storeu_ps (val, v); }
    void writeTo (Ts &a, Ts &b, Ts &c, Ts &d) const
      { Tu u; u.v=v; a=u.d[0]; b=u.d[1]; c=u.d[2]; d=u.d[3]; }
    void readFrom (const Ts *val)
      { v=_mm_loadu_ps(val); }
    void readFrom (Ts a, Ts b, Ts c, Ts d)
      { v=_mm_set_ps(d,c,b,a); }
  };

typedef svec V4sf;

inline V4sf sqrt(const V4sf &v)
  { return V4sf(_mm_sqrt_ps(v.v)); }
inline V4sf abs(const V4sf &v)
  { return V4sf(_mm_andnot_ps(_mm_set1_ps(-0.),v.v)); }
inline V4sf blend(const V4sf &mask, const V4sf &a, const V4sf &b)
  { return (mask&a)|(mask.andnot(b)); }
inline bool any (const V4sf &a)
  { return _mm_movemask_ps(a.v)!=0; }
inline bool all (const V4sf &a)
  { return _mm_movemask_ps(a.v)==15; }
inline bool none (const V4sf &a)
  { return _mm_movemask_ps(a.v)==0; }
inline V4sf min (const V4sf &a, const V4sf &b)
  { return _mm_min_ps(a.v,b.v); }
inline V4sf max (const V4sf &a, const V4sf &b)
  { return _mm_max_ps(a.v,b.v); }

template<> class svec
  {
  public:
    typedef double Ts;
    typedef __m128d Tv;
    typedef union { Tv v; Ts d[2]; } Tu;
    Tv v;

    svec () {}
    svec (const svec &b) : v(b.v) {}
    svec (const Tv &b) : v(b) {}
    svec (const Ts &val) : v(_mm_set1_pd(val)) {}
    svec (const Ts &val1, const Ts &val2)
      : v(_mm_set_pd(val2,val1)) {}
    explicit svec (const svec &b) : v(_mm_cvtepi32_pd(b.v)) {}

    operator svec() const
      { return svec (_mm_cvtpd_epi32(v)); }
    const svec &operator= (const Ts &val)
      { v=_mm_set1_pd(val); return *this; }
    const svec &operator= (const svec &b)
      { v=b.v; return *this; }

    Ts operator[] (int p) const
      { Tu u; u.v=v; return u.d[p]; }
    void set (int p, Ts val)
      { Tu u; u.v=v; u.d[p]=val; v=u.v; }

    const svec &operator+= (const svec &b)
      { v=_mm_add_pd(v,b.v); return *this; }
    const svec &operator-= (const svec &b)
      { v=_mm_sub_pd(v,b.v); return *this; }
    const svec &operator*= (const svec &b)
      { v=_mm_mul_pd(v,b.v); return *this; }
    const svec &operator/= (const svec &b)
      { v=_mm_div_pd(v,b.v); return *this; }

    svec operator+ (const svec &b) const
      { return svec(_mm_add_pd(v,b.v)); }
    svec operator- (const svec &b) const
      { return svec(_mm_sub_pd(v,b.v)); }
    svec operator* (const svec &b) const
      { return svec(_mm_mul_pd(v,b.v)); }
    svec operator/ (const svec &b) const
      { return svec(_mm_div_pd(v,b.v)); }

    const svec &operator&= (const svec &b)
      { v=_mm_and_pd(v,b.v); return *this; }
    const svec &operator|= (const svec &b)
      { v=_mm_or_pd(v,b.v); return *this; }
    const svec &operator^= (const svec &b)
      { v=_mm_xor_pd(v,b.v); return *this; }
    svec operator& (const svec &b) const
      { return svec(_mm_and_pd(v,b.v)); }
    svec operator| (const svec &b) const
      { return svec(_mm_or_pd(v,b.v)); }
    svec operator^ (const svec &b) const
      { return svec(_mm_xor_pd(v,b.v)); }

    svec operator- () const
      { return svec(_mm_xor_pd(_mm_set1_pd(-0.),v)); }

    svec eq (const svec &b) const
      { return svec(_mm_cmpeq_pd(v,b.v)); }
    svec neq (const svec &b) const
      { return svec(_mm_cmpneq_pd(v,b.v)); }
    svec lt (const svec &b) const
      { return svec(_mm_cmplt_pd(v,b.v)); }
    svec le (const svec &b) const
      { return svec(_mm_cmple_pd(v,b.v)); }
    svec gt (const svec &b) const
      { return svec(_mm_cmpgt_pd(v,b.v)); }
    svec ge (const svec &b) const
      { return svec(_mm_cmpge_pd(v,b.v)); }

    void writeTo (Ts *val) const
      { _mm_storeu_pd (val, v); }
    void writeTo (Ts &a, Ts &b) const
      { _mm_store_sd(&a,v); _mm_storeh_pd(&b,v); }
    void readFrom (const Ts *val)
      { v=_mm_loadu_pd(val); }
    void readFrom (const Ts &a, const Ts &b)
      { v=_mm_set_pd(b,a); }
  };

typedef svec V2df;

inline V2df sqrt(const V2df &v)
  { return V2df(_mm_sqrt_pd(v.v)); }
inline V2df abs(const V2df &v)
  { return V2df(_mm_andnot_pd(_mm_set1_pd(-0.),v.v)); }
inline V2df blend(const V2df &mask, const V2df &a, const V2df &b)
  { return V2df(_mm_or_pd(_mm_and_pd(a.v,mask.v),_mm_andnot_pd(mask.v,b.v))); }
inline bool any (const V2df &a)
  { return _mm_movemask_pd(a.v)!=0; }
inline bool all (const V2df &a)
  { return _mm_movemask_pd(a.v)==3; }
inline bool none (const V2df &a)
  { return _mm_movemask_pd(a.v)==0; }

template inline T vcast(const V4si &a);
template inline T vcast(const V4sf &a);
template inline T vcast(const V2df &a);

template<> inline V4si vcast (const V4sf &a)
  { return V4si (_mm_castps_si128(a.v)); }
template<> inline V4sf vcast (const V4si &a)
  { return V4sf (_mm_castsi128_ps(a.v)); }
template<> inline V2df vcast (const V4si &a)
  { return V2df (_mm_castsi128_pd(a.v)); }

#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/string_utils.cc0000664000175000017500000002362413010375061027621 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  This file contains the implementation of various convenience functions
 *  used by the Planck LevelS package.
 *
 *  Copyright (C) 2002-2014 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "string_utils.h"

using namespace std;

string trim (const string &orig)
  {
  string::size_type p1=orig.find_first_not_of(" \t");
  if (p1==string::npos) return "";
  string::size_type p2=orig.find_last_not_of(" \t");
  return orig.substr(p1,p2-p1+1);
  }

template string dataToString (const T &x)
  {
  ostringstream strstrm;
  strstrm << x;
  return trim(strstrm.str());
  }

template<> string dataToString (const bool &x)
  { return x ? "T" : "F"; }
template<> string dataToString (const string &x)
  { return trim(x); }
template<> string dataToString (const float &x)
  {
  ostringstream strstrm;
  strstrm << setprecision(8) << x;
  return trim(strstrm.str());
  }
template<> string dataToString (const double &x)
  {
  ostringstream strstrm;
  strstrm << setprecision(16) << x;
  return trim(strstrm.str());
  }
template<> string dataToString (const long double &x)
  {
  ostringstream strstrm;
  strstrm << setprecision(25) << x;
  return trim(strstrm.str());
  }

template string dataToString (const signed char &x);
template string dataToString (const unsigned char &x);
template string dataToString (const short &x);
template string dataToString (const unsigned short &x);
template string dataToString (const int &x);
template string dataToString (const unsigned int &x);
template string dataToString (const long &x);
template string dataToString (const unsigned long &x);
template string dataToString (const long long &x);
template string dataToString (const unsigned long long &x);

string intToString(int64 x, tsize width)
  {
  ostringstream strstrm;
  (x>=0) ? strstrm << setw(width) << setfill('0') << x
         : strstrm << "-" << setw(width-1) << setfill('0') << -x;
  string res = strstrm.str();
  planck_assert(res.size()==width,"number too large");
  return trim(res);
  }

namespace {

void end_stringToData (const string &x, const char *tn, istringstream &strstrm)
  {
  string error = string("conversion error in stringToData<")+tn+">(\""+x+"\")";
  planck_assert (strstrm,error);
  string rest;
  strstrm >> rest;
//  rest=trim(rest);
  planck_assert (rest.length()==0,error);
  }

} // unnamed namespace

template void stringToData (const string &x, T &value)
  {
  istringstream strstrm(x);
  strstrm >> value;
  end_stringToData (x,type2typename(),strstrm);
  }

template<> void stringToData (const string &x, string &value)
  { value = trim(x); }

template<> void stringToData (const string &x, bool &value)
  {
  const char *fval[] = {"f","n","false",".false."};
  const char *tval[] = {"t","y","true",".true."};
  for (tsize i=0; i< sizeof(fval)/sizeof(fval[0]); ++i)
    if (equal_nocase(x,fval[i])) { value=false; return; }
  for (tsize i=0; i< sizeof(tval)/sizeof(tval[0]); ++i)
    if (equal_nocase(x,tval[i])) { value=true; return; }
  planck_fail("conversion error in stringToData(\""+x+"\")");
  }

template void stringToData (const string &x, signed char &value);
template void stringToData (const string &x, unsigned char &value);
template void stringToData (const string &x, short &value);
template void stringToData (const string &x, unsigned short &value);
template void stringToData (const string &x, int &value);
template void stringToData (const string &x, unsigned int &value);
template void stringToData (const string &x, long &value);
template void stringToData (const string &x, unsigned long &value);
template void stringToData (const string &x, long long &value);
template void stringToData (const string &x, unsigned long long &value);
template void stringToData (const string &x, float &value);
template void stringToData (const string &x, double &value);
template void stringToData (const string &x, long double &value);

bool equal_nocase (const string &a, const string &b)
  {
  if (a.size()!=b.size()) return false;
  for (tsize m=0; m &dict)
  {
  int lineno=0;
  dict.clear();
  ifstream inp(filename.c_str());
  planck_assert (inp,"Could not open parameter file '"+filename+"'.");
  while (inp)
    {
    string line;
    getline(inp, line);
    ++lineno;
    // remove potential carriage returns at the end of the line
    line=line.substr(0,line.find("\r"));
    line=line.substr(0,line.find("#"));
    line=trim(line);
    if (line.size()>0)
      {
      string::size_type eqpos=line.find("=");
      if (eqpos!=string::npos)
        {
        string key=trim(line.substr(0,eqpos)),
               value=trim(line.substr(eqpos+1,string::npos));
        if (key=="")
          cerr << "Warning: empty key in '" << filename << "', line "
               << lineno << endl;
        else
          {
          if (dict.find(key)!=dict.end())
            cerr << "Warning: key '" << key << "' multiply defined in '"
                 << filename << "', line " << lineno << endl;
          dict[key]=value;
          }
        }
      else
        cerr << "Warning: unrecognized format in '" << filename << "', line "
             << lineno << ":\n" << line << endl;
      }
    }
  }

namespace {

bool isParam (const string &s)
  {
  if (s.size()<2) return false;
  if (s[0]!='-') return false;
  return !(isdigit(s[1]) || (s[1]=='.'));
  }

} // unnamed namespace

void parse_cmdline_classic (int argc, const char **argv,
  const vector &leading_args, map &dict)
  {
  dict.clear();
  planck_assert(tsize(argc)>leading_args.size(),"not enough arguments");
  for (tsize i=0; i &dict)
  { parse_cmdline_classic (argc, argv, vector(), dict); }

void parse_cmdline_equalsign (int argc, const char **argv,
  const vector &leading_args, map &dict)
  {
  dict.clear();
  planck_assert(tsize(argc)>leading_args.size(),"not enough arguments");
  for (tsize i=0; i0)
      {
      string::size_type eqpos=arg.find("=");
      if (eqpos!=string::npos)
        {
        string key=trim(arg.substr(0,eqpos)),
               value=trim(arg.substr(eqpos+1,string::npos));
        if (key=="")
          cerr << "Warning: empty key in argument'" << arg << "'" << endl;
        else
          {
          if (dict.find(key)!=dict.end())
            cerr << "Warning: key '" << key << "' multiply defined" << endl;
          dict[key]=value;
          }
        }
      else
        cerr << "Warning: unrecognized format in argument '" << arg << "'"
             << endl;
      }
    }
  }

void parse_cmdline_equalsign (int argc, const char **argv,
  map &dict)
  { parse_cmdline_equalsign (argc, argv, vector(), dict); }

namespace {

template void split (istream &stream, vector &list)
  {
  list.clear();
  while (stream)
    {
    string word;
    stream >> word;
    planck_assert (stream||stream.eof(),
      string("error while splitting stream into ") + type2typename()
      + "components");
    if (stream) list.push_back(stringToData(word));
    }
  }

} // unnamed namespace

template void split (const string &inp, vector &list)
  {
  istringstream stream(inp);
  split (stream,list);
  }

template void split (const string &inp, vector &list);
template void split (const string &inp, vector &list);
template void split (const string &inp, vector &list);
template void split (const string &inp, vector &list);
template void split (const string &inp, vector &list);

void tokenize (const string &inp, char delim, vector &list)
  {
  istringstream stream(inp);
  string token;
  list.clear();
  while (getline(stream,token,delim))
    list.push_back(token);
  }

void parse_words_from_file (const string &filename, vector &words)
  {
  words.clear();
  ifstream inp(filename.c_str());
  planck_assert (inp,"Could not open file '"+filename+"'.");
  while (inp)
    {
    string word;
    inp>>word;
    word=trim(word);
    if (word!="") words.push_back(word);
    }
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/string_utils.h0000664000175000017500000000777013010375061027467 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file string_utils.h
 *  Various functions for manipulating strings.
 *
 *  Copyright (C) 2002-2012 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_STRING_UTILS_H
#define PLANCK_STRING_UTILS_H

#include 
#include 
#include "datatypes.h"

/*! \defgroup stringutilsgroup String handling helper functions */
/*! \{ */

/*! Returns the string \a orig without leading and trailing whitespace. */
std::string trim (const std::string &orig);

/*! Returns a string containing the text representation of \a x.
    Care is taken that no information is lost in the conversion. */
template std::string dataToString(const T &x);
template<> std::string dataToString (const bool &x);
template<> std::string dataToString (const std::string &x);
template<> std::string dataToString (const float &x);
template<> std::string dataToString (const double &x);
template<> std::string dataToString (const long double &x);

/*! Returns a string containing the text representation of \a x, padded
    with leading zeroes to \a width characters. */
std::string intToString(int64 x, tsize width);

/*! Reads a value of a given datatype from a string */
template void stringToData (const std::string &x, T &value);
template<> void stringToData (const std::string &x, std::string &value);
template<> void stringToData (const std::string &x, bool &value);

/*! Reads a value of a given datatype from a string */
template inline T stringToData (const std::string &x)
  { T result; stringToData(x,result); return result; }

/*! Parses the file \a filename and returns the key/value pairs in \a dict. */
void parse_file (const std::string &filename,
  std::map &dict);

void parse_cmdline_classic (int argc, const char **argv,
  const std::vector &leading_args,
  std::map &dict);

void parse_cmdline_classic (int argc, const char **argv,
  std::map &dict);

void parse_cmdline_equalsign (int argc, const char **argv,
  const std::vector &leading_args,
  std::map &dict);

void parse_cmdline_equalsign (int argc, const char **argv,
  std::map &dict);

/*! Case-insensitive string comparison
    Returns \a true, if \a a and \a b differ only in capitalisation,
    else \a false. */
bool equal_nocase (const std::string &a, const std::string &b);

/*! Returns lowercase version of \a input. */
std::string tolower(const std::string &input);

/*! Tries to split \a inp into a white-space separated list of values of
    type \a T, and appends them to \a list. */
template void split (const std::string &inp, std::vector &list);

/*! Breaks the string \a inp into tokens separated by \a delim, and returns them
    in \a list. */
void tokenize (const std::string &inp, char delim,
  std::vector &list);

/*! Reads all white-space separated strings from \a filename, and returns
    them in \a words. */
void parse_words_from_file (const std::string &filename,
  std::vector &words);

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/trafos.cc0000664000175000017500000001436013010375061026366 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file trafos.cc
 *  Celestial coordinate transformations.
 *
 *  Copyright (C) 2005-2011 Max-Planck-Society
 * \author Martin Reinecke
 */

#include "trafos.h"
#include "geom_utils.h"
#include "lsconstants.h"

using namespace std;

vec3 Trafo::xcc_dp_precess (const vec3 &iv, double iepoch,
  double oepoch)
  {
  // Z-axis rotation by OBL_LONG:
  double Tm = ((oepoch+iepoch)*0.5 - 1900.) *0.01;
  double gp_long  = degr2rad * ((oepoch-iepoch) * (50.2564+0.0222*Tm) / 3600.);
  double obl_long =
    degr2rad * (180. - (173. + (57.06+54.77*Tm) / 60.)) + gp_long*0.5;
  double dco = cos(obl_long), dso = sin(obl_long);
  vec3 ov (iv.x*dco-iv.y*dso, iv.x*dso+iv.y*dco, iv.z);

  // X-axis rotation by dE:
  double dE = degr2rad * ((oepoch-iepoch) * (0.4711-0.0007*Tm) / 3600.);
  double dce = cos(dE), dse = sin(dE);
  double temp = ov.y*dce - ov.z*dse;
  ov.z = ov.y*dse + ov.z*dce;
  ov.y = temp;

  // Z-axis rotation by GP_LONG - OBL_LONG:
  double dL = gp_long - obl_long;
  double dcl = cos(dL), dsl = sin(dL);
  temp = ov.x*dcl - ov.y*dsl;
  ov.y = ov.x*dsl + ov.y*dcl;
  ov.x = temp;

  return ov;
  }

double Trafo::get_epsilon (double epoch)
  {
  double T = (epoch - 1900.) * 0.01; 
  return
    degr2rad * (23.452294 - 0.0130125*T - 1.63889e-6*T*T + 5.02778e-7*T*T*T);
  }

/*! Routine to convert from ecliptic coordinates to equatorial (celestial)
    coordinates at the given epoch.  Adapted from the COBLIB routine by Dr.
    E. Wright. */
vec3 Trafo::xcc_dp_e_to_q (const vec3 &iv, double epoch)
  {
  double epsilon=get_epsilon(epoch);
  double dc = cos(epsilon), ds = sin(epsilon);
  return vec3 (iv.x, dc*iv.y-ds*iv.z, dc*iv.z+ds*iv.y);
  }

vec3 Trafo::xcc_dp_q_to_e (const vec3 &iv, double epoch)
  {
  double epsilon=-get_epsilon(epoch);
  double dc = cos(epsilon), ds = sin(epsilon);
  return vec3 (iv.x, dc*iv.y-ds*iv.z, dc*iv.z+ds*iv.y);
  }

/*! Routine to convert galactic coordinates to ecliptic (celestial) 
    coordinates at the given epoch.  First the conversion to ecliptic 
    2000 is done, then if necessary the results are precessed. */
vec3 Trafo::xcc_dp_g_to_e (const vec3 &iv, double epoch)
  {
  static const rotmatrix T (-0.054882486,  0.494116468, -0.867661702,
                            -0.993821033, -0.110993846, -0.000346354,
                            -0.096476249,  0.862281440,  0.497154957);
  vec3 hv=T.Transform(iv);

  if (!approx(epoch,2000.))
    hv=xcc_dp_precess(hv,2000.,epoch);

  return hv;
  }

/*! Routine to convert ecliptic (celestial) coordinates at the given
    epoch to galactic coordinates.  The ecliptic coordinates are first
    precessed to 2000.0, then converted. */
vec3 Trafo::xcc_dp_e_to_g (const vec3 &iv, double epoch)
  {
  static const rotmatrix T (-0.054882486, -0.993821033, -0.096476249,
                             0.494116468, -0.110993846,  0.862281440,
                            -0.867661702, -0.000346354,  0.497154957);
  vec3 hv=iv;
  if (!approx(epoch,2000.))
    hv=xcc_dp_precess(hv,epoch,2000.);

  return T.Transform(hv);
  }

/*! Function to convert between standard coordinate systems, including
    precession. */
vec3 Trafo::xcc_v_convert(const vec3 &iv, double iepoch, double oepoch,
  coordsys isys,coordsys osys)
  {
  vec3 xv;
  if (isys == Ecliptic)
    xv=iv;
  else if (isys == Equatorial)
    xv = xcc_dp_q_to_e(iv,iepoch);
  else if (isys == Galactic)
    xv = xcc_dp_g_to_e(iv,iepoch);
  else
    planck_fail("Unsupported input coordinate system");

  vec3 yv = approx(iepoch,oepoch) ? xv : xcc_dp_precess(xv,iepoch,oepoch);

  vec3 ov;
  if (osys == Ecliptic)
    ov = yv;
  else if (osys == Equatorial)
    ov = xcc_dp_e_to_q(yv,oepoch);
  else if (osys == Galactic)
    ov = xcc_dp_e_to_g(yv,oepoch);
  else
    planck_fail("Unsupported output coordinate system");

  return ov;
  }

void Trafo::coordsys2matrix (double iepoch, double oepoch,
  coordsys isys, coordsys osys, rotmatrix &matrix)
  {
  vec3 v1p = xcc_v_convert(vec3(1,0,0),iepoch,oepoch,isys,osys),
       v2p = xcc_v_convert(vec3(0,1,0),iepoch,oepoch,isys,osys),
       v3p = xcc_v_convert(vec3(0,0,1),iepoch,oepoch,isys,osys);
  v1p.Normalize(); v2p.Normalize(); v3p.Normalize();
  matrix=rotmatrix(v1p,v2p,v3p);
  }

Trafo::Trafo (double iepoch, double oepoch, coordsys isys, coordsys osys)
  { coordsys2matrix (iepoch, oepoch, isys, osys, mat); }

pointing Trafo::operator() (const pointing &ptg) const
  { return pointing(operator()(vec3(ptg))); }

void Trafo::rotatefull (const pointing &ptg, pointing &newptg,
  double &delta_psi) const
  {
  vec3 vec (ptg);
  vec3 east (-vec.y,vec.x,0.);
  vec3 newvec = operator()(vec);
  vec3 neweast = operator()(east);
  delta_psi = orientation(newvec,neweast)+halfpi;
  newptg = newvec;
  }

void Trafo::rotatefull (pointing &ptg, double &psi) const
  {
  vec3 vec (ptg);
  vec3 east (-vec.y,vec.x,0.);
  vec3 newvec = operator()(vec);
  vec3 neweast = operator()(east);
  psi += orientation(newvec,neweast)+halfpi;
  ptg = newvec;
  }

void Trafo::rotatefull (const vec3 &vec, vec3 &newvec, double &delta_psi) const
  {
  vec3 east (-vec.y,vec.x,0.);
  newvec = operator()(vec);
  vec3 neweast = operator()(east);
  delta_psi = orientation(newvec,neweast)+halfpi;
  }

void Trafo::rotatefull (vec3 &vec, double &psi) const
  {
  vec3 east (-vec.y,vec.x,0.);
  vec3 newvec = operator()(vec);
  vec3 neweast = operator()(east);
  psi += orientation(newvec,neweast)+halfpi;
  vec = newvec;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/trafos.h0000664000175000017500000000626413010375061026234 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file trafos.h
 *  Celestial coordinate transformations.
 *
 *  Copyright (C) 2005-2011 Max-Planck-Society
 * \author Martin Reinecke
 */
#ifndef PLANCK_TRAFOS_H
#define PLANCK_TRAFOS_H

#include "vec3.h"
#include "pointing.h"
#include "rotmatrix.h"

enum coordsys { Ecliptic, Equatorial, Galactic };

/*! Class for celestial coordinate transformations. */
class Trafo
  {
  private:
    rotmatrix mat;

    static vec3 xcc_dp_precess (const vec3 &iv, double iepoch, double oepoch);
    static double get_epsilon (double epoch);
    static vec3 xcc_dp_e_to_q (const vec3 &iv, double epoch);
    static vec3 xcc_dp_q_to_e (const vec3 &iv, double epoch);
    static vec3 xcc_dp_g_to_e (const vec3 &iv, double epoch);
    static vec3 xcc_dp_e_to_g (const vec3 &iv, double epoch);
    static vec3 xcc_v_convert(const vec3 &iv, double iepoch, double oepoch,
      coordsys isys,coordsys osys);
    static void coordsys2matrix (double iepoch, double oepoch, coordsys isys,
      coordsys osys, rotmatrix &matrix);

  public:
    /*! Creates a \a Trafo for transformation from \a iepoch and \a isys
        to \a oepoch and \a osys. */
    Trafo (double iepoch, double oepoch, coordsys isys, coordsys osys);

    /*! Transforms the vector \a vec and returns the result. */
    vec3 operator() (const vec3 &vec) const
      { return mat.Transform(vec); }

    /*! Transforms the pointing \a ptg and returns the result. */
    pointing operator() (const pointing &ptg) const;

    /*! Transforms the pointing \a ptg and returns it in \a newptg.
        On exit, \a delta_psi holds the change in orientation. */
    void rotatefull (const pointing &ptg, pointing &newptg,
      double &delta_psi) const;

    /*! Transforms the pointing \a ptg and adjusts \a psi accordingly. */
    void rotatefull (pointing &ptg, double &psi) const;

    /*! Transforms the vector \a vec and returns it in \a newvec.
        On exit, \a delta_psi holds the change in orientation. */
    void rotatefull (const vec3 &vec, vec3 &newvec, double &delta_psi) const;

    /*! Transforms the vector \a vec and adjusts \a psi accordingly. */
    void rotatefull (vec3 &vec, double &psi) const;

    /*! Returns the internally used rotation matrix. */
    const rotmatrix &Matrix() const
      { return mat; }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/vec3.h0000664000175000017500000001132113010375061025564 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file vec3.h
 *  Class representing 3D cartesian vectors
 *
 *  Copyright (C) 2003, 2006 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_VEC3_H
#define PLANCK_VEC3_H

#include 
#include 
#include "datatypes.h"

/*! \defgroup vec3group 3D vectors */
/*! \{ */

/*! Class representing a 3D cartesian vector. */
templateclass vec3_t
  {
  public:
    T x, /*!< x-coordinate */
      y, /*!< y-coordinate */
      z; /*!< z-coordinate */

    /*! Default constructor. Does not initialize \a x, \a y, and \a z. */
    vec3_t () {}
    /*! Creates a vector with the coordinates \a xc, \a yc, and \a zc. */
    vec3_t (T xc, T yc, T zc)
      : x(xc), y(yc), z(zc) {}
    template explicit vec3_t (const vec3_t &orig)
      : x(orig.x), y(orig.y), z(orig.z) {}

    /*! Sets the vector components to \a xc, \a yc, and \a zc. */
    void Set (T xc, T yc, T zc)
      { x=xc; y=yc; z=zc; }
    /*! Creates a unit vector from a z coordinate and an azimuthal angle. */
    void set_z_phi (T z_, T phi)
      {
      using namespace std;
      T sintheta = sqrt((T(1)-z_)*(T(1)+z_));
      x = sintheta*cos(phi);
      y = sintheta*sin(phi);
      z = z_;
      }

    /*! Normalizes the vector to length 1. */
    void Normalize ()
      {
      using namespace std;
      T l = T(1)/sqrt (x*x + y*y + z*z);
      x*=l; y*=l; z*=l;
      }

    vec3_t Norm() const
      {
      vec3_t res(*this);
      res.Normalize();
      return res;
      }

    /*! Returns the length of the vector. */
    T Length () const
      { return sqrt (x*x + y*y + z*z); }

    /*! Returns the squared length of the vector. */
    T SquaredLength () const
      { return (x*x + y*y + z*z); }
    /*! Returns the vector with the signs of all coordinates flipped. */
    const vec3_t operator- () const
      { return vec3_t (-x, -y, -z); }
    /*! Flips the signs of all coordinates. */
    void Flip ()
      { x=-x; y=-y; z=-z; }
    /*! Returns (\a *this + \a vec). */
    const vec3_t operator+ (const vec3_t &vec) const
      { return vec3_t (x+vec.x, y+vec.y, z+vec.z); }
    /*! Adds \a vec to \a *this. */
    vec3_t &operator+= (const vec3_t &vec)
      { x+=vec.x; y+=vec.y; z+=vec.z; return *this; }
    /*! Returns (\a *this - \a vec). */
    const vec3_t operator- (const vec3_t &vec) const
      { return vec3_t (x-vec.x, y-vec.y, z-vec.z); }
    /*! Subtracts \a vec from \a *this. */
    vec3_t &operator-= (const vec3_t &vec)
      { x-=vec.x; y-=vec.y; z-=vec.z; return *this; }
    /*! Returns the vector scaled by \a fact. */
    const vec3_t operator* (T fact) const
      { return vec3_t (x*fact, y*fact, z*fact); }
    /*! Returns the vector scaled by \a 1/fact. */
    const vec3_t operator/ (T fact) const
      { T xfact = T(1)/fact; return vec3_t (x*xfact, y*xfact, z*xfact); }
    /*! Scales the vector by \a fact. */
    vec3_t &operator*= (T fact)
      { x*=fact; y*=fact; z*=fact; return *this; }
  };

/*! Returns the dot product of \a v1 and \a v2.
    \relates vec3_t */
template inline T dotprod(const vec3_t &v1, const vec3_t &v2)
  { return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; }

/*! Returns the cross product of \a a and \a b.
    \relates vec3_t */
template inline vec3_t crossprod
  (const vec3_t &a, const vec3_t &b)
  { return vec3_t(a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x); }

/*! Writes \a v to \a os.
    \relates vec3_t */
template inline std::ostream &operator<<
  (std::ostream &os, const vec3_t &v)
  {
  os << v.x << ", " << v.y << ", " << v.z << std::endl;
  return os;
  }

/*! Specialisation of vec3_t for 64-bit floating point components */
typedef vec3_t vec3;
/*! Specialisation of vec3_t for 32-bit floating point components */
typedef vec3_t vec3f;

/*! \} */

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/walltimer.cc0000664000175000017500000001461613010375061027074 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  This file contains functionality related to wall-clock timers
 *
 *  Copyright (C) 2010, 2011, 2012 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include 
#include 
#include 
#include 
#include "walltimer.h"
#include "walltime_c.h"
#include "error_handling.h"

using namespace std;

void wallTimer::start()
  { start(wallTime()); }
void wallTimer::stop()
  { stop(wallTime()); }
double wallTimer::acc() const
  { return acc(wallTime()); }

int wallTimerSet::getIndex(const string &name)
  {
  maptype::const_iterator it = lut.find(name);
  if (it!=lut.end())
    return it->second;
  timer.push_back(wallTimer());
  lut[name]=timer.size()-1;
  return timer.size()-1;
  }

void wallTimerSet::start(int index)
  { timer[index].start(); }
void wallTimerSet::stop(int index)
  { timer[index].stop(); }
void wallTimerSet::stopstart(int index1, int index2)
  { double t=wallTime(); timer[index1].stop(t); timer[index2].start(t); }
void wallTimerSet::reset(int index)
  { timer[index].reset(); }
double wallTimerSet::acc(int index)
  { return timer[index].acc(); }
void wallTimerSet::start(const string &name)
  { start(getIndex(name)); }
void wallTimerSet::stop(const string &name)
  { stop(getIndex(name)); }
void wallTimerSet::stopstart(const string &name1, const string &name2)
  { stopstart(getIndex(name1),getIndex(name2)); }
void wallTimerSet::reset(const string &name)
  { reset(getIndex(name)); }
double wallTimerSet::acc(const string &name)
  { return acc(getIndex(name)); }

void wallTimerSet::report() const
  {
  cout << "\nWall clock timer report:" << endl;
  for (maptype::const_iterator it=lut.begin(); it!=lut.end(); ++it)
    printf("  %-15s: %10.5fs\n", it->first.c_str(), timer[it->second].acc());
  cout << "End wall clock timer report\n" << endl;
  }

wallTimerSet wallTimers;

namespace {

class tstack_node;

typedef map::iterator Ti;
typedef map::const_iterator Tci;
typedef pair Tipair;

class tstack_node
  {
  public:
    tstack_node *parent;
    wallTimer wt;
    string name;
    map child;

    tstack_node(const string &name_, tstack_node *parent_)
      : parent(parent_), name(name_) {}

    int max_namelen() const
      {
      int res=name.length();
      for (Tci it=child.begin(); it!=child.end(); ++it)
        res=max(res,it->second.max_namelen());
      return res;
      }
  };

tstack_node tstack_root("root",0);
tstack_node *curnode=0;
double overhead=0.;

struct timecomp
  {
  bool operator() (const Tipair &a, const Tipair &b) const
    { return a.second>b.second; }
  };

void tstack_report(const tstack_node &node, const string &indent, int twidth,
  int slen)
  {
  double total=node.wt.acc();
  vector tmp;
  for (Tci it=node.child.begin(); it!=node.child.end(); ++it)
    tmp.push_back(make_pair(it,it->second.wt.acc()));

  if (tmp.size()>0)
    {
    sort(tmp.begin(),tmp.end(),timecomp());
    double tsum=0;
    printf("%s|\n", indent.c_str());
    for (unsigned i=0; ifirst).c_str(), 100*tmp[i].second/total,twidth,
        tmp[i].second);
      tstack_report(tmp[i].first->second,indent+"|  ",twidth,slen);
      tsum+=tmp[i].second;
      }
    printf("%s+- %-*s:%6.2f%% (%*.4fs)\n%s\n",indent.c_str(),slen,
      "",100*(total-tsum)/total,twidth,total-tsum,indent.c_str());
    }
  }

} // unnamed namespace

void tstack_push(const string &name)
  {
  double t0=wallTime();
  if (curnode==0) curnode=&tstack_root;
  Ti it=curnode->child.find(name);
  if (it==curnode->child.end())
    it=curnode->child.insert (make_pair(name,tstack_node(name,curnode))).first;
  curnode=&(it->second);
  double t1=wallTime();
  curnode->wt.start(0.5*(t0+t1));
  overhead+=t1-t0;
  }
void tstack_pop(const string &name)
  {
  double t0=wallTime();
  planck_assert(curnode && (curnode->name==name), "invalid tstack operation");
  double t1=wallTime();
  curnode->wt.stop(0.5*(t0+t1));
  curnode=curnode->parent;
  overhead+=t1-t0;
  }
void tstack_pop()
  {
  double t0=wallTime();
  planck_assert(curnode, "invalid tstack operation");
  double t1=wallTime();
  curnode->wt.stop(0.5*(t0+t1));
  curnode=curnode->parent;
  overhead+=t1-t0;
  }
void tstack_replace(const string &name2)
  {
  double t0=wallTime();
  planck_assert(curnode, "invalid tstack operation");
  tstack_node *savenode=curnode;
  curnode=curnode->parent;
  Ti it=curnode->child.find(name2);
  if (it==curnode->child.end())
    it=curnode->child.insert(make_pair(name2,tstack_node(name2,curnode))).first;
  curnode=&(it->second);
  double t1=wallTime();
  double t=0.5*(t0+t1);
  savenode->wt.stop(t);
  curnode->wt.start(t);
  overhead+=t1-t0;
  }
void tstack_replace(const string &name1, const string &name2)
  {
  planck_assert(curnode && (curnode->name==name1), "invalid tstack operation");
  tstack_replace(name2);
  }

void tstack_report(const string &stem)
  {
  const tstack_node *ptr = 0;
  for (Tci it=tstack_root.child.begin(); it!=tstack_root.child.end(); ++it)
    if (it->first==stem) ptr=&(it->second);
  planck_assert(ptr,"invalid stem");
  int slen=string("").size();
  slen = max(slen,ptr->max_namelen());

  double total=ptr->wt.acc();
  printf("\nTotal wall clock time for '%s': %1.4fs\n",stem.c_str(),total);

  int logtime=max(1,int(log10(total)+1));
  tstack_report(*ptr,"",logtime+5,slen);

  printf("\nAccumulated timing overhead: approx. %1.4fs\n",overhead);
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/walltimer.h0000664000175000017500000000531313010375061026730 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file walltimer.h
 *  Functionality related to wall-clock timers
 *
 *  Copyright (C) 2010, 2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_WALLTIMER_H
#define PLANCK_WALLTIMER_H

#include 
#include 
#include 

class wallTimer
  {
  private:
    double t_acc, t_started;
    bool running;

  public:
    wallTimer() : t_acc(0.), t_started(0.), running(false) {}
    void start(double wtime_now)
      { if (!running) { t_started=wtime_now; running=true; } }
    void start();
    void stop(double wtime_now)
      { if (running) { t_acc+=wtime_now-t_started; running=false; } }
    void stop();
    void reset() { t_acc=t_started=0.; running=false;}
    double acc(double wtime_now) const
      { return running ? t_acc+wtime_now-t_started : t_acc; }
    double acc() const;
  };

class wallTimerSet
  {
  public:
    typedef std::map maptype;

  private:
    maptype lut;
    std::vector timer;

  public:
    int getIndex(const std::string &name);
    void start(int index);
    void stop(int index);
    void stopstart(int index1, int index2);
    void reset(int index);
    double acc(int index);
    void start(const std::string &name);
    void stop(const std::string &name);
    void stopstart(const std::string &name1, const std::string &name2);
    void reset(const std::string &name);
    double acc(const std::string &name);

    void report() const;

    const maptype &table() const { return lut; }
  };

extern wallTimerSet wallTimers;

void tstack_push(const std::string &name);
void tstack_pop(const std::string &name);
void tstack_pop();
void tstack_replace(const std::string &name1, const std::string &name2);
void tstack_replace(const std::string &name);
void tstack_report(const std::string &stem);

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/wigner.cc0000664000175000017500000003721313010375061026365 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file wigner.cc
 *  Several C++ classes for calculating Wigner matrices
 *
 *  Copyright (C) 2009-2015 Max-Planck-Society
 *  \author Martin Reinecke and others (see individual classes)
 */

#include "wigner.h"
#include "lsconstants.h"

using namespace std;

void wigner_d_halfpi_risbo_scalar::do_line0 (double *l1, int j)
  {
  double xj = pq/j;
  for (int i=n; i>=1; --i)
    l1[i] = xj*sqt[j]*(sqt[j-i]*l1[i] - sqt[i]*l1[i-1]);
  l1[0] = pq*l1[0];
  }
void wigner_d_halfpi_risbo_scalar::do_line (const double *l1, double *l2,
  int j, int k)
  {
  double xj = pq/j;
  double t1 = xj*sqt[j-k];
  double t2 = xj*sqt[k];
  for (int i=n; i>=1; --i)
    l2[i] = t1 * (sqt[j-i]*l2[i] - sqt[i]*l2[i-1])
            +t2 * (sqt[j-i]*l1[i] + sqt[i]*l1[i-1]);
  l2[0] = sqt[j] * (t2*l1[0]+t1*l2[0]);
  }

wigner_d_halfpi_risbo_scalar::wigner_d_halfpi_risbo_scalar(int lmax)
  : pq(.5*sqrt(2.)), sqt(2*lmax+1), d(lmax+2,lmax+2), n(-1)
  { for (tsize m=0; m &wigner_d_halfpi_risbo_scalar::recurse ()
  {
  ++n;
  if (n==0)
    d[0][0] = 1;
  else if (n==1)
    {
    d[0][0] = .5; d[0][1] =-pq;
    d[1][0] = pq; d[1][1] = 0.;
    }
  else
    {
//padding
    int flip = 1;
    for (int i=0; i=2; --k)
      {
      do_line (d[k-2],d[k-1],2*n-1,k-1);
      do_line (d[k-1],d[k],2*n,k);
      }
    do_line0 (d[0],2*n-1);
    do_line (d[0],d[1],2*n,1);
    do_line0 (d[0],2*n);
    }
  return d;
  }

void wigner_d_risbo_scalar::do_line0 (double *l1, int j)
  {
  double xj = 1./j;
  l1[j] = -p*l1[j-1];
  for (int i=j-1; i>=1; --i)
    l1[i] = xj*sqt[j]*(q*sqt[j-i]*l1[i] - p*sqt[i]*l1[i-1]);
  l1[0] = q*l1[0];
  }
void wigner_d_risbo_scalar::do_line (const double *l1, double *l2, int j, int k)
  {
  double xj = 1./j;
  double t1 = xj*sqt[j-k]*q, t2 = xj*sqt[j-k]*p;
  double t3 = xj*sqt[k]*p,   t4 = xj*sqt[k]*q;
  l2[j] = sqt[j] * (t4*l1[j-1]-t2*l2[j-1]);
  for (int i=j-1; i>=1; --i)
    l2[i] = t1*sqt[j-i]*l2[i] - t2*sqt[i]*l2[i-1]
            +t3*sqt[j-i]*l1[i] + t4*sqt[i]*l1[i-1];
  l2[0] = sqt[j] * (t3*l1[0]+t1*l2[0]);
  }

wigner_d_risbo_scalar::wigner_d_risbo_scalar(int lmax, double ang)
  : p(sin(ang/2)), q(cos(ang/2)), sqt(2*lmax+1),
    d(lmax+1,2*lmax+1), n(-1)
  { for (tsize m=0; m &wigner_d_risbo_scalar::recurse ()
  {
  ++n;
  if (n==0)
    d[0][0] = 1;
  else if (n==1)
    {
    d[0][0] = q*q; d[0][1] = -p*q*sqt[2]; d[0][2] = p*p;
    d[1][0] = -d[0][1]; d[1][1] = q*q-p*p; d[1][2] = d[0][1];
    }
  else
    {
    // padding
    int sign = (n&1)? -1 : 1;
    for (int i=0; i<=2*n-2; ++i)
      {
      d[n][i] = sign*d[n-2][2*n-2-i];
      sign=-sign;
      }
    do_line (d[n-1],d[n],2*n-1,n);
    for (int k=n; k>=2; --k)
      {
      do_line (d[k-2],d[k-1],2*n-1,k-1);
      do_line (d[k-1],d[k],2*n,k);
      }
    do_line0 (d[0],2*n-1);
    do_line (d[0],d[1],2*n,1);
    do_line0 (d[0],2*n);
    }
  return d;
  }

wigner_d_halfpi_risbo_openmp::wigner_d_halfpi_risbo_openmp(int lmax)
  : pq(.5*sqrt(2.)), sqt(2*lmax+1), d(lmax+2,lmax+2),
    dd(lmax+2,lmax+2), n(-1)
  { for (tsize m=0; m &wigner_d_halfpi_risbo_openmp::recurse ()
  {
  ++n;
  if (n==0)
    d[0][0] = 1;
  else if (n==1)
    {
    d.fast_alloc(3,3);
    d[0][0] = .5; d[0][1] =-pq;
    d[1][0] = pq; d[1][1] = 0.;
    }
  else
    {
//padding
    int flip = 1;
    for (int i=0; i &wigner_d_risbo_openmp::recurse ()
  {
  ++n;
  if (n==0)
    d[0][0] = 1;
  else if (n==1)
    {
    d[0][0] = q*q; d[0][1] = -p*q*sqt[2]; d[0][2] = p*p;
    d[1][0] = -d[0][1]; d[1][1] = q*q-p*p; d[1][2] = d[0][1];
    }
  else
    {
    // padding
    int sign = (n&1)? -1 : 1;
    for (int i=0; i<=2*n-2; ++i)
      {
      d[n][i] = sign*d[n-2][2*n-2-i];
      sign=-sign;
      }
    for (int j=2*n-1; j<=2*n; ++j)
      {
      double xj = 1./j;
      dd[0][0] = q*d[0][0];
      for (int i=1;i &thetas,
  double epsilon)
  : eps(epsilon), lmax(lmax_),
    logsum(2*lmax+1), lc05(thetas.size()), ls05(thetas.size()),
    flm1(2*lmax+1), flm2(2*lmax+1),
    cf(maxscale+1-minscale), costh(thetas.size()), xl(lmax+1),
    thetaflip(thetas.size()),
    m1(-1234567890), m2(-1234567890), am1(-1234567890), am2(-1234567890),
    mlo(-1234567890), mhi(-1234567890),
    fx(lmax+2), result(lmax+1)
  {
  planck_assert(lmax>=0,"lmax too small");
  logsum[0] = 0.;
  for (tsize m=1; m(m));
  for (tsize lm=0; lmpi) theta-=twopi;
    thetaflip[i]=(theta<0);
    theta=abs(theta); // now theta is in (0; pi)
    // tiny adjustments to make sure cos and sin (theta/2) are positive
    if (theta==0.) theta=1e-16;
    if (abs_approx(theta,pi,1e-15)) theta=pi-1e-15;
    costh[i]=cos(theta);
    lc05[i]=log(cos(0.5L*theta));
    ls05[i]=log(sin(0.5L*theta));
    }
  xl[0]=0;
  for (tsize l=1; l=0)
      { swap(cosPow, sinPow); preMinus=((mhi-m2)&1); }
    }
  else
    {
    cosPow = mhi+m1; sinPow = mhi-m1;
    if (m2<0)
      { swap(cosPow, sinPow); preMinus=((mhi+m1)&1); }
    }
  }

const arr &wignergen_scalar::calc (int nth, int &firstl)
  {
  calc(nth, firstl, result);
  return result;
  }

void wignergen_scalar::calc (int nth, int &firstl, arr &resx) const
  {
  int l=mhi;
  const dbl3 *fy = &fx[0];
  const double cth = costh[nth];
  double *res = &resx[0];
  long double logval = prefactor + lc05[nth]*cosPow + ls05[nth]*sinPow;
  logval *= inv_ln2;
  int scale = int (logval/large_exponent2)-minscale;
  double rec1 = 0.;
  double rec2 = double(exp(ln2*(logval-(scale+minscale)*large_exponent2)));
  if (preMinus ^ (thetaflip[nth] && ((am1+am2)&1))) rec2 = -rec2;

  while(scale<0) // iterate until we reach the realm of IEEE numbers
    {
    if (++l>lmax) break;
    rec1 = (cth - fy[l][1])*fy[l][0]*rec2 - fy[l][2]*rec1;
    if (++l>lmax) break;
    rec2 = (cth - fy[l][1])*fy[l][0]*rec1 - fy[l][2]*rec2;

    while (abs(rec2)>fbig)
      {
      rec1 *= fsmall;
      rec2 *= fsmall;
      ++scale;
      }
    }

  if (scale<0) { firstl=lmax+1; return; }
  rec1 *= cf[scale];
  rec2 *= cf[scale];

  for (;leps) break;
    rec1 = (cth - fy[l+1][1])*fy[l+1][0]*rec2 - fy[l+1][2]*rec1;
    if (abs(rec1)>eps) { swap(rec1,rec2); ++l; break; }
    rec2 = (cth - fy[l+2][1])*fy[l+2][0]*rec1 - fy[l+2][2]*rec2;
    }
  if ((abs(rec2)<=eps) && (++l<=lmax))
    {
    rec1 = (cth - fy[l][1])*fy[l][0]*rec2 - fy[l][2]*rec1;
    swap (rec1,rec2);
    }

  firstl = l;
  if (l>lmax) return;

  res[l]=rec2;

  for (;llmax) break;
    res[l] = rec1 = (cth - fy[l][1])*fy[l][0]*rec2 - fy[l][2]*rec1;
    if (++l>lmax) break;
    res[l] = rec2 = (cth - fy[l][1])*fy[l][0]*rec1 - fy[l][2]*rec2;
    }
  }

#ifdef __SSE2__

#define RENORMALIZE \
  do \
    { \
    double rec1a, rec1b, rec2a, rec2b, cfa, cfb; \
    rec1.writeTo(rec1a,rec1b); rec2.writeTo(rec2a,rec2b); \
    corfac.writeTo(cfa,cfb); \
    while (abs(rec2a)>fbig) \
      { \
      rec1a*=fsmall; rec2a*=fsmall; ++scale1; \
      cfa = (scale1<0) ? 0. : cf[scale1]; \
      } \
    while (abs(rec2b)>fbig) \
      { \
      rec1b*=fsmall; rec2b*=fsmall; ++scale2; \
      cfb = (scale2<0) ? 0. : cf[scale2]; \
      } \
    rec1.readFrom(rec1a,rec1b); rec2.readFrom(rec2a,rec2b); \
    corfac.readFrom(cfa,cfb); \
    } \
  while(0)

#define GETPRE(prea,preb,lv) \
  prea=(cth-fy[lv][1])*fy[lv][0]; \
  preb=fy[lv][2];

#define NEXTSTEP(prea,preb,prec,pred,reca,recb,lv) \
  { \
  prec = fy[lv][1]; \
  preb *= reca; \
  prea *= recb; \
  V2df t0 (fy[lv][0]); \
  prec = cth-prec; \
  pred = fy[lv][2]; \
  reca = prea-preb; \
  prec *= t0; \
  }

const arr_align &wignergen::calc (int nth1, int nth2, int &firstl)
  {
  calc(nth1, nth2, firstl, result2);
  return result2;
  }

void wignergen::calc (int nth1, int nth2, int &firstl,
  arr_align &resx) const
  {
  int l=mhi;
  const dbl3 *fy = &fx[0];
  const V2df cth(costh[nth1],costh[nth2]);
  V2df *res = &resx[0];
  long double logval1 = prefactor + lc05[nth1]*cosPow + ls05[nth1]*sinPow,
              logval2 = prefactor + lc05[nth2]*cosPow + ls05[nth2]*sinPow;
  logval1 *= inv_ln2;
  logval2 *= inv_ln2;
  int scale1 = int (logval1/large_exponent2)-minscale,
      scale2 = int (logval2/large_exponent2)-minscale;
  V2df rec1(0.);
  double tr1 = double(exp(ln2*(logval1-(scale1+minscale)*large_exponent2))),
         tr2 = double(exp(ln2*(logval2-(scale2+minscale)*large_exponent2)));
  if (preMinus ^ (thetaflip[nth1] && ((am1+am2)&1))) tr1 = -tr1;
  if (preMinus ^ (thetaflip[nth2] && ((am1+am2)&1))) tr2 = -tr2;
  V2df rec2(tr1,tr2);
  V2df corfac ((scale1<0) ? 0. : cf[scale1], (scale2<0) ? 0. : cf[scale2]);

  V2df eps2(eps);
  V2df fbig2(fbig);

  V2df pre0,pre1,pre2,pre3;

  GETPRE(pre0,pre1,l+1)
  if ((scale1<0) && (scale2<0))
    {
    while (true)
      {
      if (++l>lmax) break;
      NEXTSTEP(pre0,pre1,pre2,pre3,rec1,rec2,l+1)
      if (++l>lmax) break;
      NEXTSTEP(pre2,pre3,pre0,pre1,rec2,rec1,l+1)
      if (any(abs(rec2).gt(fbig2)))
        {
        RENORMALIZE;
        if ((scale1>=0) || (scale2>=0)) break;
        }
      }
    }

  if (l<=lmax)
    {
    GETPRE(pre0,pre1,l+1)
    while (true)
      {
      V2df t1;
      res[l]=t1=rec2*corfac;
      if (any(abs(t1).gt(eps2)))
        break;

      if (++l>lmax) break;
      NEXTSTEP(pre0,pre1,pre2,pre3,rec1,rec2,l+1)

      res[l]=t1=rec1*corfac;
      if (any(abs(t1).gt(eps2)))
        { swap(rec1,rec2); break; }

      if (++l>lmax) break;
      NEXTSTEP(pre2,pre3,pre0,pre1,rec2,rec1,l+1)

      if (any(abs(rec2).gt(fbig2)))
        RENORMALIZE;
      }
    }
  firstl=l;
  if (l>lmax) return;

  GETPRE(pre0,pre1,l+1)
  while (true)
    {
    V2df t1;
    res[l]=t1=rec2*corfac;
    if (all(abs(t1).ge(eps2)))
      break;

    if (++l>lmax) break;
    NEXTSTEP(pre0,pre1,pre2,pre3,rec1,rec2,l+1)

    res[l]=t1=rec1*corfac;
    if (all(abs(t1).ge(eps2)))
      { swap(rec1,rec2); break; }

    if (++l>lmax) break;
    NEXTSTEP(pre2,pre3,pre0,pre1,rec2,rec1,l+1)

    if (any(abs(rec2).gt(fbig2)))
      RENORMALIZE;
    }

  if (l>lmax) return;
  rec1*=corfac;
  rec2*=corfac;

  GETPRE(pre0,pre1,l+1)
  for (;l1.); // close to a pole
  return (((sqrt(delta)-epsPow)*cosm1m2/abs(sth)) > lmax);
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/wigner.h0000664000175000017500000001353613010375061026231 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file wigner.h
 *  Several C++ classes for calculating Wigner matrices
 *
 *  Copyright (C) 2009-2011 Max-Planck-Society
 *  \author Martin Reinecke and others (see individual classes)
 */

#ifndef PLANCK_WIGNER_H
#define PLANCK_WIGNER_H

#include 
#include "arr.h"

#include "sse_utils_cxx.h"

/*! Class for calculation of the Wigner matrix at pi/2, using Risbo recursion
    in a way that cannot easily be parallelised, but is fairly efficient on
    scalar machines. */
class wigner_d_halfpi_risbo_scalar
  {
  private:
    double pq;
    arr sqt;
    arr2 d;
    int n;

    void do_line0 (double *l1, int j);
    void do_line (const double *l1, double *l2, int j, int k);

  public:
    wigner_d_halfpi_risbo_scalar(int lmax);

    const arr2 &recurse ();
  };

/*! Class for calculation of the Wigner matrix at arbitrary angles, using Risbo
    recursion in a way that cannot easily be parallelised, but is fairly
    efficient on scalar machines. */
class wigner_d_risbo_scalar
  {
  private:
    double p,q;
    arr sqt;
    arr2 d;
    int n;

    void do_line0 (double *l1, int j);
    void do_line (const double *l1, double *l2, int j, int k);

  public:
    wigner_d_risbo_scalar(int lmax, double ang);

    const arr2 &recurse ();
  };

/*! Class for calculation of the Wigner matrix at pi/2, using Risbo recursion
    in a way that can be OpenMP-parallelised. This approach uses more memory
    and is slightly slower than wigner_d_halfpi_risbo_scalar. */
class wigner_d_halfpi_risbo_openmp
  {
  private:
    double pq;
    arr sqt;
    arr2 d,dd;
    int n;

  public:
    wigner_d_halfpi_risbo_openmp(int lmax);

    const arr2 &recurse ();
  };

/*! Class for calculation of the Wigner matrix at arbitrary angles, using Risbo
    recursion in a way that can be OpenMP-parallelised. This approach uses more
    memory and is slightly slower than wigner_d_risbo_scalar. */
class wigner_d_risbo_openmp
  {
  private:
    double p,q;
    arr sqt;
    arr2 d, dd;
    int n;

  public:
    wigner_d_risbo_openmp(int lmax, double ang);

    const arr2 &recurse ();
  };

/*! Class for calculation of the Wigner matrix elements by l-recursion.
    For details, see Prezeau & Reinecke 2010, http://arxiv.org/pdf/1002.1050 */
class wignergen_scalar
  {
  protected:
    typedef double dbl3[3];

    // members set in the constructor and kept fixed afterwards
    double fsmall, fbig, eps;
    int lmax;
    arr logsum, lc05, ls05;
    arr flm1, flm2, cf, costh, xl;
    arr thetaflip;

    // members depending on m and m'
    int m1, m2, am1, am2, mlo, mhi, cosPow, sinPow;
    long double prefactor;
    arr fx;
    bool preMinus;

    // members depending on theta
    arr result;

    enum { large_exponent2=90, minscale=-4, maxscale=14 };

  public:
    /*! Constructs an object that can compute Wigner matrix elements up
        to a maximum \a l value of \a lmax_, at the colatitudes provided
        in \a thetas. The generator will be allowed to regard values with
        absolute magnitudes smaller than \a epsilon as zero; a typical value
        is 1e-30. */
    wignergen_scalar (int lmax_, const arr &thetas, double epsilon);

    /*! Prepares the object to produce Wigner matrix elements with \a m=m1_
        and \a m'=m2_ in subsequent calls to calc(). This operation is not cheap
        so it is recommended to use calc() for many different colatitudes after
        every call to prepare(), if possible. */
    void prepare (int m1_, int m2_);

    /*! Computes the Wigner matrix elements for the values of \a m and \a m'
        set by the preceding call to prepare(), for all \a l up to \a lmax
        (set in the constructor), and for the \a nth colatitude passed to the
        constructor. On return, \a firstl contains the index of the first
        matrix element larger than \a epsilon; all values with smaller indices
        in the result array are undefined. */
    const arr &calc (int nth, int &firstl);
    void calc (int nth, int &firstl, arr &resx) const;
  };

class wignergen: public wignergen_scalar
  {
#ifdef __SSE2__
  private:
    arr_align result2;

  public:
    wignergen (int lmax_, const arr &thetas, double epsilon)
      : wignergen_scalar (lmax_,thetas,epsilon), result2(lmax_+1) {}

    using wignergen_scalar::calc;
    const arr_align &calc (int nth1, int nth2, int &firstl);
    void calc (int nth1, int nth2, int &firstl, arr_align &resx) const;
#else
  public:
    wignergen (int lmax_, const arr &thetas, double epsilon)
      : wignergen_scalar (lmax_,thetas,epsilon) {}
#endif
  };

class wigner_estimator
  {
  private:
    int lmax, m1, m2, mbig;
    double xlmax, epsPow, cosm1m2;

  public:
    wigner_estimator (int lmax_, double epsPow_);

    void prepare_m (int m1_, int m2_);
    bool canSkip (double theta) const;
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/cxxsupport/xcomplex.h0000664000175000017500000000257313010375061026574 0ustar  zoncazonca00000000000000/*
 *  This file is part of libcxxsupport.
 *
 *  libcxxsupport is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libcxxsupport is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libcxxsupport; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libcxxsupport is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file xcomplex.h
 *  convenience additions for std::complex
 *
 *  Copyright (C) 2003-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_XCOMPLEX_H
#define PLANCK_XCOMPLEX_H

#include 

#define xcomplex std::complex
typedef xcomplex  fcomplex;
typedef xcomplex dcomplex;

template inline xcomplex times_i(xcomplex inp)
  { return xcomplex(-inp.imag(),inp.real()); }

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libfftpack/0000775000175000017500000000000013031130324024415 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libfftpack/README0000664000175000017500000000314513010375061025306 0ustar  zoncazonca00000000000000ls_fft description:

This package is intended to calculate one-dimensional real or complex FFTs
with high accuracy and good efficiency even for lengths containing large
prime factors.
The code is written in C, but a Fortran wrapper exists as well.

Before any FFT is executed, a plan must be generated for it. Plan creation
is designed to be fast, so that there is no significant overhead if the
plan is only used once or a few times.

The main component of the code is based on Paul N. Swarztrauber's FFTPACK in the
double precision incarnation by Hugh C. Pumphrey
(http://www.netlib.org/fftpack/dp.tgz).

I replaced the iterative sine and cosine calculations in radfg() and radbg()
by an exact calculation, which slightly improves the transform accuracy for
real FFTs with lengths containing large prime factors.

Since FFTPACK becomes quite slow for FFT lengths with large prime factors
(in the worst case of prime lengths it reaches O(n*n) complexity), I
implemented Bluestein's algorithm, which computes a FFT of length n by
several FFTs of length n2>=2*n-1 and a convolution. Since n2 can be chosen
to be highly composite, this algorithm is more efficient if n has large
prime factors. The longer FFTs themselves are then computed using the FFTPACK
routines.
Bluestein's algorithm was implemented according to the description at
http://en.wikipedia.org/wiki/Bluestein's_FFT_algorithm.

Thread-safety:
All routines can be called concurrently; all information needed by ls_fft
is stored in the plan variable. However, using the same plan variable on
multiple threads simultaneously is not supported and will lead to data
corruption.
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libfftpack/bluestein.c0000664000175000017500000001027613010375061026567 0ustar  zoncazonca00000000000000/*
 *  This file is part of libfftpack.
 *
 *  libfftpack is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libfftpack is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libfftpack; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libfftpack is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2005-2008 Max-Planck-Society
 *  \author Martin Reinecke
 */

#include 
#include 
#include "fftpack.h"
#include "bluestein.h"

/* returns the sum of all prime factors of n */
size_t prime_factor_sum (size_t n)
  {
  size_t result=0,x,limit,tmp;
  while (((tmp=(n>>1))<<1)==n)
    { result+=2; n=tmp; }

  limit=(size_t)sqrt(n+0.01);
  for (x=3; x<=limit; x+=2)
  while ((tmp=(n/x))*x==n)
    {
    result+=x;
    n=tmp;
    limit=(size_t)sqrt(n+0.01);
    }
  if (n>1) result+=n;

  return result;
  }

/* returns the smallest composite of 2, 3 and 5 which is >= n */
static size_t good_size(size_t n)
  {
  size_t f2, f23, f235, bestfac=2*n;
  if (n<=6) return n;

  for (f2=1; f2=n) bestfac=f235;
  return bestfac;
  }

void bluestein_i (size_t n, double **tstorage, size_t *worksize)
  {
  static const double pi=3.14159265358979323846;
  size_t n2=good_size(n*2-1);
  size_t m, coeff;
  double angle, xn2;
  double *bk, *bkf, *work;
  double pibyn=pi/n;
  *worksize=2+2*n+8*n2+16;
  *tstorage = RALLOC(double,2+2*n+8*n2+16);
  ((size_t *)(*tstorage))[0]=n2;
  bk  = *tstorage+2;
  bkf = *tstorage+2+2*n;
  work= *tstorage+2+2*(n+n2);

/* initialize b_k */
  bk[0] = 1;
  bk[1] = 0;

  coeff=0;
  for (m=1; m=2*n) coeff-=2*n;
    angle = pibyn*coeff;
    bk[2*m] = cos(angle);
    bk[2*m+1] = sin(angle);
    }

/* initialize the zero-padded, Fourier transformed b_k. Add normalisation. */
  xn2 = 1./n2;
  bkf[0] = bk[0]*xn2;
  bkf[1] = bk[1]*xn2;
  for (m=2; m<2*n; m+=2)
    {
    bkf[m]   = bkf[2*n2-m]   = bk[m]   *xn2;
    bkf[m+1] = bkf[2*n2-m+1] = bk[m+1] *xn2;
    }
  for (m=2*n;m<=(2*n2-2*n+1);++m)
    bkf[m]=0.;
  cffti (n2,work);
  cfftf (n2,bkf,work);
  }

void bluestein (size_t n, double *data, double *tstorage, int isign)
  {
  size_t n2=*((size_t *)tstorage);
  size_t m;
  double *bk, *bkf, *akf, *work;
  bk  = tstorage+2;
  bkf = tstorage+2+2*n;
  work= tstorage+2+2*(n+n2);
  akf = tstorage+2+2*n+6*n2+16;

/* initialize a_k and FFT it */
  if (isign>0)
    for (m=0; m<2*n; m+=2)
      {
      akf[m]   = data[m]*bk[m]   - data[m+1]*bk[m+1];
      akf[m+1] = data[m]*bk[m+1] + data[m+1]*bk[m];
      }
  else
    for (m=0; m<2*n; m+=2)
      {
      akf[m]   = data[m]*bk[m]   + data[m+1]*bk[m+1];
      akf[m+1] =-data[m]*bk[m+1] + data[m+1]*bk[m];
      }
  for (m=2*n; m<2*n2; ++m)
    akf[m]=0;

  cfftf (n2,akf,work);

/* do the convolution */
  if (isign>0)
    for (m=0; m<2*n2; m+=2)
      {
      double im = -akf[m]*bkf[m+1] + akf[m+1]*bkf[m];
      akf[m  ]  =  akf[m]*bkf[m]   + akf[m+1]*bkf[m+1];
      akf[m+1]  = im;
      }
  else
    for (m=0; m<2*n2; m+=2)
      {
      double im = akf[m]*bkf[m+1] + akf[m+1]*bkf[m];
      akf[m  ]  = akf[m]*bkf[m]   - akf[m+1]*bkf[m+1];
      akf[m+1]  = im;
      }


/* inverse FFT */
  cfftb (n2,akf,work);

/* multiply by b_k* */
  if (isign>0)
    for (m=0; m<2*n; m+=2)
      {
      data[m]   = bk[m]  *akf[m] - bk[m+1]*akf[m+1];
      data[m+1] = bk[m+1]*akf[m] + bk[m]  *akf[m+1];
      }
  else
    for (m=0; m<2*n; m+=2)
      {
      data[m]   = bk[m]  *akf[m] + bk[m+1]*akf[m+1];
      data[m+1] =-bk[m+1]*akf[m] + bk[m]  *akf[m+1];
      }
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libfftpack/bluestein.h0000664000175000017500000000260513010375061026571 0ustar  zoncazonca00000000000000/*
 *  This file is part of libfftpack.
 *
 *  libfftpack is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libfftpack is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libfftpack; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libfftpack is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file bluestein.h
 *  Interface for the Bluestein algorithm
 *
 *  Copyright (C) 2005 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_BLUESTEIN_H
#define PLANCK_BLUESTEIN_H

#include "c_utils.h"

#ifdef __cplusplus
extern "C" {
#endif

size_t prime_factor_sum (size_t n);

void bluestein_i (size_t n, double **tstorage, size_t *worksize);
void bluestein (size_t n, double *data, double *tstorage, int isign);

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libfftpack/fftpack.c0000664000175000017500000005333313010375061026214 0ustar  zoncazonca00000000000000/*
 *  This file is part of libfftpack.
 *
 *  libfftpack is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libfftpack is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libfftpack; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libfftpack is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
  fftpack.c : A set of FFT routines in C.
  Algorithmically based on Fortran-77 FFTPACK by Paul N. Swarztrauber
  (Version 4, 1985).

  C port by Martin Reinecke (2010)
 */

#include 
#include 
#include 
#include "fftpack.h"

#define WA(x,i) wa[(i)+(x)*ido]
#define CH(a,b,c) ch[(a)+ido*((b)+l1*(c))]
#define CC(a,b,c) cc[(a)+ido*((b)+cdim*(c))]
#define PM(a,b,c,d) { a=c+d; b=c-d; }
#define PMC(a,b,c,d) { a.r=c.r+d.r; a.i=c.i+d.i; b.r=c.r-d.r; b.i=c.i-d.i; }
#define ADDC(a,b,c) { a.r=b.r+c.r; a.i=b.i+c.i; }
#define SCALEC(a,b) { a.r*=b; a.i*=b; }
#define CONJFLIPC(a) { double tmp_=a.r; a.r=-a.i; a.i=tmp_; }
/* (a+ib) = conj(c+id) * (e+if) */
#define MULPM(a,b,c,d,e,f) { a=c*e+d*f; b=c*f-d*e; }

typedef struct {
  double r,i;
} cmplx;

#define CONCAT(a,b) a ## b

#define X(arg) CONCAT(passb,arg)
#define BACKWARD
#include "fftpack_inc.c"
#undef BACKWARD
#undef X

#define X(arg) CONCAT(passf,arg)
#include "fftpack_inc.c"
#undef X

#undef CC
#undef CH
#define CC(a,b,c) cc[(a)+ido*((b)+l1*(c))]
#define CH(a,b,c) ch[(a)+ido*((b)+cdim*(c))]

static void radf2 (size_t ido, size_t l1, const double *cc, double *ch,
  const double *wa)
  {
  const size_t cdim=2;
  size_t i, k, ic;
  double ti2, tr2;

  for (k=0; k=2*ip) aidx-=2*ip;
      ar2=csarr[aidx];
      ai2=csarr[aidx+1];
      for(ik=0; ik=2*ip) aidx-=2*ip;
      ar2=csarr[aidx];
      ai2=csarr[aidx+1];
      for(ik=0; ik0) ? passb4(ido, l1, p1, p2, wa+iw)
                : passf4(ido, l1, p1, p2, wa+iw);
    else if(ip==2)
      (isign>0) ? passb2(ido, l1, p1, p2, wa+iw)
                : passf2(ido, l1, p1, p2, wa+iw);
    else if(ip==3)
      (isign>0) ? passb3(ido, l1, p1, p2, wa+iw)
                : passf3(ido, l1, p1, p2, wa+iw);
    else if(ip==5)
      (isign>0) ? passb5(ido, l1, p1, p2, wa+iw)
                : passf5(ido, l1, p1, p2, wa+iw);
    else if(ip==6)
      (isign>0) ? passb6(ido, l1, p1, p2, wa+iw)
                : passf6(ido, l1, p1, p2, wa+iw);
    else
      (isign>0) ? passbg(ido, ip, l1, p1, p2, wa+iw)
                : passfg(ido, ip, l1, p1, p2, wa+iw);
    SWAP(p1,p2,cmplx *);
    l1=l2;
    iw+=(ip-1)*ido;
    }
  if (p1!=c)
    memcpy (c,p1,n*sizeof(cmplx));
  }

void cfftf(size_t n, double c[], double wsave[])
  {
  if (n!=1)
    cfft1(n, (cmplx*)c, (cmplx*)wsave, (cmplx*)(wsave+2*n),
          (size_t*)(wsave+4*n),-1);
  }

void cfftb(size_t n, double c[], double wsave[])
  {
  if (n!=1)
    cfft1(n, (cmplx*)c, (cmplx*)wsave, (cmplx*)(wsave+2*n),
          (size_t*)(wsave+4*n),+1);
  }

static void factorize (size_t n, const size_t *pf, size_t npf, size_t *ifac)
  {
  size_t nl=n, nf=0, ntry=0, j=0, i;

startloop:
  j++;
  ntry = (j<=npf) ? pf[j-1] : ntry+2;
  do
    {
    size_t nq=nl / ntry;
    size_t nr=nl-ntry*nq;
    if (nr!=0)
      goto startloop;
    nf++;
    ifac[nf+1]=ntry;
    nl=nq;
    if ((ntry==2) && (nf!=1))
      {
      for (i=nf+1; i>2; --i)
        ifac[i]=ifac[i-1];
      ifac[2]=2;
      }
    }
  while(nl!=1);
  ifac[0]=n;
  ifac[1]=nf;
  }

static void cffti1(size_t n, double wa[], size_t ifac[])
  {
  static const size_t ntryh[5]={4,6,3,2,5};
  static const double twopi=6.28318530717958647692;
  size_t j, k, fi;

  double argh=twopi/n;
  size_t i=0, l1=1;
  factorize (n,ntryh,5,ifac);
  for(k=1; k<=ifac[1]; k++)
    {
    size_t ip=ifac[k+1];
    size_t ido=n/(l1*ip);
    for(j=1; j6)
        {
        wa[is  ]=wa[i  ];
        wa[is+1]=wa[i+1];
        }
      }
    l1*=ip;
    }
  }

void cffti(size_t n, double wsave[])
  { if (n!=1) cffti1(n, wsave+2*n,(size_t*)(wsave+4*n)); }


/*----------------------------------------------------------------------
   rfftf1, rfftb1, rfftf, rfftb, rffti1, rffti. Real FFTs.
  ----------------------------------------------------------------------*/

static void rfftf1(size_t n, double c[], double ch[], const double wa[],
  const size_t ifac[])
  {
  size_t k1, l1=n, nf=ifac[1], iw=n-1;
  double *p1=ch, *p2=c;

  for(k1=1; k1<=nf;++k1)
    {
    size_t ip=ifac[nf-k1+2];
    size_t ido=n / l1;
    l1 /= ip;
    iw-=(ip-1)*ido;
    SWAP (p1,p2,double *);
    if(ip==4)
      radf4(ido, l1, p1, p2, wa+iw);
    else if(ip==2)
      radf2(ido, l1, p1, p2, wa+iw);
    else if(ip==3)
      radf3(ido, l1, p1, p2, wa+iw);
    else if(ip==5)
      radf5(ido, l1, p1, p2, wa+iw);
    else
      {
      if (ido==1)
        SWAP (p1,p2,double *);
      radfg(ido, ip, l1, ido*l1, p1, p2, wa+iw);
      SWAP (p1,p2,double *);
      }
    }
  if (p1==c)
    memcpy (c,ch,n*sizeof(double));
  }

static void rfftb1(size_t n, double c[], double ch[], const double wa[],
  const size_t ifac[])
  {
  size_t k1, l1=1, nf=ifac[1], iw=0;
  double *p1=c, *p2=ch;

  for(k1=1; k1<=nf; k1++)
    {
    size_t ip = ifac[k1+1],
           ido= n/(ip*l1);
    if(ip==4)
      radb4(ido, l1, p1, p2, wa+iw);
    else if(ip==2)
      radb2(ido, l1, p1, p2, wa+iw);
    else if(ip==3)
      radb3(ido, l1, p1, p2, wa+iw);
    else if(ip==5)
      radb5(ido, l1, p1, p2, wa+iw);
    else
      {
      radbg(ido, ip, l1, ido*l1, p1, p2, wa+iw);
      if (ido!=1)
        SWAP (p1,p2,double *);
      }
    SWAP (p1,p2,double *);
    l1*=ip;
    iw+=(ip-1)*ido;
    }
  if (p1!=c)
    memcpy (c,ch,n*sizeof(double));
  }

void rfftf(size_t n, double r[], double wsave[])
  { if(n!=1) rfftf1(n, r, wsave, wsave+n,(size_t*)(wsave+2*n)); }

void rfftb(size_t n, double r[], double wsave[])
  { if(n!=1) rfftb1(n, r, wsave, wsave+n,(size_t*)(wsave+2*n)); }

static void rffti1(size_t n, double wa[], size_t ifac[])
  {
  static const size_t ntryh[4]={4,2,3,5};
  static const double twopi=6.28318530717958647692;
  size_t i, j, k, fi;

  double argh=twopi/n;
  size_t is=0, l1=1;
  factorize (n,ntryh,4,ifac);
  for (k=1; kip) iang-=ip;
          abr.r += ccl[l ].r*wal[iang].r;
          abr.i += ccl[l ].i*wal[iang].r;
          abi.r += ccl[lc].r*wal[iang].i;
          abi.i += ccl[lc].i*wal[iang].i;
          }
#ifndef BACKWARD
          { abi.i=-abi.i; abi.r=-abi.r; }
#endif
        CONJFLIPC(abi)
        PMC(CH(i,k,j),CH(i,k,jc),abr,abi)
        }
      }

  DEALLOC(tarr);

  if (ido==1) return;

  for (j=1; j
  
  • \ref fftgroup "Programming interface"
  
 */
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libfftpack/ls_fft.c0000664000175000017500000001546613010375061026060 0ustar  zoncazonca00000000000000/*
 *  This file is part of libfftpack.
 *
 *  libfftpack is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libfftpack is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libfftpack; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libfftpack is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Copyright (C) 2005 Max-Planck-Society
 *  \author Martin Reinecke
 */

#include 
#include 
#include 
#include "bluestein.h"
#include "fftpack.h"
#include "ls_fft.h"

complex_plan make_complex_plan (size_t length)
  {
  complex_plan plan = RALLOC(complex_plan_i,1);
  size_t pfsum = prime_factor_sum(length);
  double comp1 = (double)(length*pfsum);
  double comp2 = 2*3*length*log(3.*length);
  comp2*=3.; /* fudge factor that appears to give good overall performance */
  plan->length=length;
  plan->bluestein = (comp2bluestein)
    bluestein_i (length,&(plan->work),&(plan->worksize));
  else
    {
    plan->worksize=4*length+15;
    plan->work=RALLOC(double,4*length+15);
    cffti(length, plan->work);
    }
  return plan;
  }

complex_plan copy_complex_plan (complex_plan plan)
  {
  if (!plan) return NULL;
  {
  complex_plan newplan = RALLOC(complex_plan_i,1);
  *newplan = *plan;
  newplan->work=RALLOC(double,newplan->worksize);
  memcpy(newplan->work,plan->work,sizeof(double)*newplan->worksize);
  return newplan;
  }
  }

void kill_complex_plan (complex_plan plan)
  {
  DEALLOC(plan->work);
  DEALLOC(plan);
  }

void complex_plan_forward (complex_plan plan, double *data)
  {
  if (plan->bluestein)
    bluestein (plan->length, data, plan->work, -1);
  else
    cfftf (plan->length, data, plan->work);
  }

void complex_plan_backward (complex_plan plan, double *data)
  {
  if (plan->bluestein)
    bluestein (plan->length, data, plan->work, 1);
  else
    cfftb (plan->length, data, plan->work);
  }


real_plan make_real_plan (size_t length)
  {
  real_plan plan = RALLOC(real_plan_i,1);
  size_t pfsum = prime_factor_sum(length);
  double comp1 = .5*length*pfsum;
  double comp2 = 2*3*length*log(3.*length);
  comp2*=3; /* fudge factor that appears to give good overall performance */
  plan->length=length;
  plan->bluestein = (comp2bluestein)
    bluestein_i (length,&(plan->work),&(plan->worksize));
  else
    {
    plan->worksize=2*length+15;
    plan->work=RALLOC(double,2*length+15);
    rffti(length, plan->work);
    }
  return plan;
  }

real_plan copy_real_plan (real_plan plan)
  {
  if (!plan) return NULL;
  {
  real_plan newplan = RALLOC(real_plan_i,1);
  *newplan = *plan;
  newplan->work=RALLOC(double,newplan->worksize);
  memcpy(newplan->work,plan->work,sizeof(double)*newplan->worksize);
  return newplan;
  }
  }

void kill_real_plan (real_plan plan)
  {
  DEALLOC(plan->work);
  DEALLOC(plan);
  }

void real_plan_forward_fftpack (real_plan plan, double *data)
  {
  if (plan->bluestein)
    {
    size_t m;
    size_t n=plan->length;
    double *tmp = RALLOC(double,2*n);
    for (m=0; mwork,-1);
    data[0] = tmp[0];
    memcpy (data+1, tmp+2, (n-1)*sizeof(double));
    DEALLOC(tmp);
    }
  else
    rfftf (plan->length, data, plan->work);
  }

static void fftpack2halfcomplex (double *data, size_t n)
  {
  size_t m;
  double *tmp = RALLOC(double,n);
  tmp[0]=data[0];
  for (m=1; m<(n+1)/2; ++m)
    {
    tmp[m]=data[2*m-1];
    tmp[n-m]=data[2*m];
    }
  if (!(n&1))
    tmp[n/2]=data[n-1];
  memcpy (data,tmp,n*sizeof(double));
  DEALLOC(tmp);
  }

static void halfcomplex2fftpack (double *data, size_t n)
  {
  size_t m;
  double *tmp = RALLOC(double,n);
  tmp[0]=data[0];
  for (m=1; m<(n+1)/2; ++m)
    {
    tmp[2*m-1]=data[m];
    tmp[2*m]=data[n-m];
    }
  if (!(n&1))
    tmp[n-1]=data[n/2];
  memcpy (data,tmp,n*sizeof(double));
  DEALLOC(tmp);
  }

void real_plan_forward_fftw (real_plan plan, double *data)
  {
  real_plan_forward_fftpack (plan, data);
  fftpack2halfcomplex (data,plan->length);
  }

void real_plan_backward_fftpack (real_plan plan, double *data)
  {
  if (plan->bluestein)
    {
    size_t m;
    size_t n=plan->length;
    double *tmp = RALLOC(double,2*n);
    tmp[0]=data[0];
    tmp[1]=0.;
    memcpy (tmp+2,data+1, (n-1)*sizeof(double));
    if ((n&1)==0) tmp[n+1]=0.;
    for (m=2; mwork, 1);
    for (m=0; mlength, data, plan->work);
  }

void real_plan_backward_fftw (real_plan plan, double *data)
  {
  halfcomplex2fftpack (data,plan->length);
  real_plan_backward_fftpack (plan, data);
  }

void real_plan_forward_c (real_plan plan, double *data)
  {
  size_t m;
  size_t n=plan->length;

  if (plan->bluestein)
    {
    for (m=1; m<2*n; m+=2)
      data[m]=0;
    bluestein (plan->length, data, plan->work, -1);
    data[1]=0;
    for (m=2; mwork);
    data[0] = data[1];
    data[1] = 0;
    for (m=2; mlength;

  if (plan->bluestein)
    {
    size_t m;
    data[1]=0;
    for (m=2; mlength, data, plan->work, 1);
    for (m=1; m<2*n; m+=2)
      data[m]=0;
    }
  else
    {
    ptrdiff_t m;
    data[1] = data[0];
    rfftb (n, data+1, plan->work);
    for (m=n-1; m>=0; --m)
      {
      data[2*m]   = data[m+1];
      data[2*m+1] = 0.;
      }
    }
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libfftpack/ls_fft.h0000664000175000017500000001442313010375061026055 0ustar  zoncazonca00000000000000/*
 *  This file is part of libfftpack.
 *
 *  libfftpack is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libfftpack is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libfftpack; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libfftpack is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file ls_fft.h
 *  Interface for the LevelS FFT package.
 *
 *  Copyright (C) 2004 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_LS_FFT_H
#define PLANCK_LS_FFT_H

#include "c_utils.h"

#ifdef __cplusplus
extern "C" {
#endif

/*!\defgroup fftgroup FFT interface
This package is intended to calculate one-dimensional real or complex FFTs
with high accuracy and good efficiency even for lengths containing large
prime factors.
The code is written in C, but a Fortran wrapper exists as well.

Before any FFT is executed, a plan must be generated for it. Plan creation
is designed to be fast, so that there is no significant overhead if the
plan is only used once or a few times.

The main component of the code is based on Paul N. Swarztrauber's FFTPACK in the
double precision incarnation by Hugh C. Pumphrey
(http://www.netlib.org/fftpack/dp.tgz).

I replaced the iterative sine and cosine calculations in radfg() and radbg()
by an exact calculation, which slightly improves the transform accuracy for
real FFTs with lengths containing large prime factors.

Since FFTPACK becomes quite slow for FFT lengths with large prime factors
(in the worst case of prime lengths it reaches \f$\mathcal{O}(n^2)\f$
complexity), I implemented Bluestein's algorithm, which computes a FFT of length
\f$n\f$ by several FFTs of length \f$n_2\ge 2n-1\f$ and a convolution. Since
\f$n_2\f$ can be chosen to be highly composite, this algorithm is more efficient
if \f$n\f$ has large prime factors. The longer FFTs themselves are then computed
using the FFTPACK routines.
Bluestein's algorithm was implemented according to the description on Wikipedia
(
http://en.wikipedia.org/wiki/Bluestein%27s_FFT_algorithm).

\b Thread-safety:
All routines can be called concurrently; all information needed by
ls_fft is stored in the plan variable. However, using the same plan
variable on multiple threads simultaneously is not supported and will lead to
data corruption.
*/
/*! \{ */

typedef struct
  {
  double *work;
  size_t length, worksize;
  int bluestein;
  } complex_plan_i;

/*! The opaque handle type for complex-FFT plans. */
typedef complex_plan_i * complex_plan;

/*! Returns a plan for a complex FFT with \a length elements. */
complex_plan make_complex_plan (size_t length);
/*! Constructs a copy of \a plan. */
complex_plan copy_complex_plan (complex_plan plan);
/*! Destroys a plan for a complex FFT. */
void kill_complex_plan (complex_plan plan);
/*! Computes a complex forward FFT on \a data, using \a plan.
    \a Data has the form r0, i0, r1, i1, ...,
    r[length-1], i[length-1]. */
void complex_plan_forward (complex_plan plan, double *data);
/*! Computes a complex backward FFT on \a data, using \a plan.
    \a Data has the form r0, i0, r1, i1, ...,
    r[length-1], i[length-1]. */
void complex_plan_backward (complex_plan plan, double *data);

typedef struct
  {
  double *work;
  size_t length, worksize;
  int bluestein;
  } real_plan_i;

/*! The opaque handle type for real-FFT plans. */
typedef real_plan_i * real_plan;

/*! Returns a plan for a real FFT with \a length elements. */
real_plan make_real_plan (size_t length);
/*! Constructs a copy of \a plan. */
real_plan copy_real_plan (real_plan plan);
/*! Destroys a plan for a real FFT. */
void kill_real_plan (real_plan plan);
/*! Computes a real forward FFT on \a data, using \a plan
    and assuming the FFTPACK storage scheme:
    - on entry, \a data has the form r0, r1, ..., r[length-1];
    - on exit, it has the form r0, r1, i1, r2, i2, ...
      (a total of \a length values). */
void real_plan_forward_fftpack (real_plan plan, double *data);
/*! Computes a real backward FFT on \a data, using \a plan
    and assuming the FFTPACK storage scheme:
    - on entry, \a data has the form r0, r1, i1, r2, i2, ...
    (a total of \a length values);
    - on exit, it has the form r0, r1, ..., r[length-1]. */
void real_plan_backward_fftpack (real_plan plan, double *data);
/*! Computes a real forward FFT on \a data, using \a plan
    and assuming the FFTW halfcomplex storage scheme:
    - on entry, \a data has the form r0, r1, ..., r[length-1];
    - on exit, it has the form r0, r1, r2, ..., i2, i1. */
void real_plan_forward_fftw (real_plan plan, double *data);
/*! Computes a real backward FFT on \a data, using \a plan
    and assuming the FFTW halfcomplex storage scheme:
    - on entry, \a data has the form r0, r1, r2, ..., i2, i1.
    - on exit, it has the form r0, r1, ..., r[length-1]. */
void real_plan_backward_fftw (real_plan plan, double *data);
/*! Computes a real forward FFT on \a data, using \a plan
    and assuming a full-complex storage scheme:
    - on entry, \a data has the form r0, [ignored], r1, [ignored], ...,
      r[length-1], [ignored];
    - on exit, it has the form r0, i0, r1, i1, ...,
      r[length-1], i[length-1]. */
void real_plan_forward_c (real_plan plan, double *data);
/*! Computes a real backward FFT on \a data, using \a plan
    and assuming a full-complex storage scheme:
    - on entry, \a data has the form r0, i0, r1, i1, ...,
      r[length-1], i[length-1];
    - on exit, it has the form r0, 0, r1, 0, ..., r[length-1], 0. */
void real_plan_backward_c (real_plan plan, double *data);

/*! \} */

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libfftpack/planck.make0000664000175000017500000000056713010375061026542 0ustar  zoncazonca00000000000000PKG:=libfftpack

SD:=$(SRCROOT)/$(PKG)
OD:=$(BLDROOT)/$(PKG)

FULL_INCLUDE+= -I$(SD)

HDR_$(PKG):=$(SD)/*.h
LIB_$(PKG):=$(LIBDIR)/libfftpack.a
OBJ:=fftpack.o bluestein.o ls_fft.o
OBJ:=$(OBJ:%=$(OD)/%)

ODEP:=$(HDR_$(PKG)) $(HDR_c_utils)

$(OD)/fftpack.o: $(SD)/fftpack_inc.c

$(OBJ): $(ODEP) | $(OD)_mkdir
$(LIB_$(PKG)): $(OBJ)

all_hdr+=$(HDR_$(PKG))
all_lib+=$(LIB_$(PKG))
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/0000775000175000017500000000000013031130324024114 5ustar  zoncazonca00000000000000healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/libsharp.dox0000664000175000017500000000726413010375061026453 0ustar  zoncazonca00000000000000/*! \mainpage libsharp documentation
  
 */

/*! \page introduction Introduction to libsharp

  "SHARP" is an acronym for Spherical HARmonic Package.
  All user-visible data types and functions in this library start with
  the prefix "sharp_" to avoid pollution of the global C namespace.

  libsharp's main functionality is the conversion between maps
  on the sphere and spherical harmonic coefficients (or a_lm).
  A map is defined as a set of rings, which in turn consist of
  individual pixels that
  
      
  
    • all have the same colatitude and
      • 
  
    • are uniformly spaced in azimuthal direction.
      • 
  
    
  Consequently, a ring is completely defined by
  
      
  
    • its colatitute (in radians)
      • 
  
    • the number of pixels it contains
      • 
  
    • the azimuth (in radians) of the first pixel in the ring
      • 
  
    • the weight that must be multiplied to every pixel during a map
      analysis (typically the solid angle of a pixel in the ring) 
      • 
  
    • the offset of the first ring pixel in the map array
      • 
  
    • the stride between consecutive pixels in the ring.
      • 
  
    
  The map array is a one-dimensional array of type float or
  double, which contains the values of all map pixels. It is assumed
  that the pixels of every ring are stored inside this array in order of
  increasing azimuth and with the specified stride. Note however that the rings
  themselves can be stored in any order inside the array.

  The a_lm array is a one-dimensional array of type complex float or
  complex double, which contains all spherical harmonic coefficients
  for a full or partial set of m quantum numbers with 0<=m<=mmax and m<=l<=lmax.
  There is only one constraint on the internal structure of the array, which is:

  Index[a_l+1,m] = Index[a_l,m] + stride

  That means that coefficients with identical m but different l
  can be interpreted as a one-dimensional array in l with a unique
  stride.

  Several functions are provided for efficient index computation in this array;
  they are documented \ref almgroup "here".

  Information about a pixelisation of the sphere is stored in objects of
  type sharp_geom_info. It is possible to create such an object for any
  supported pixelisation by using the function sharp_make_geometry_info();
  however, several easier-to-use functions are \ref geominfogroup "supplied"
  for generating often-used pixelisations like ECP grids, Gaussian grids,
  and Healpix grids.

  Currently, libsharp supports the following kinds of transforms:
  
      
  
    • scalar a_lm to map
      • 
  
    • scalar map to a_lm
      • 

  
    • spin a_lm to map
      • 
  
    • spin map to a_lm
      • 
  
    • scalar a_lm to maps of first derivatives
      • 
  
    

  libsharp supports shared-memory parallelisation via OpenMP; this feature will
  be automatically enabled if the compiler supports it.

  Libsharp will also make use of SSE2 and AVX instructions when compiled for a
  platform known to support them.

  Support for MPI-parallel transforms is also available; in this mode,
  every MPI task must provide a unique subset of the map and a_lm coefficients.

  The spherical harmonic transforms can be executed on double-precision and
  single-precision maps and a_lm, but for accuracy reasons the computations
  will always be performed in double precision. As a consequence,
  single-precision transforms will most likely not be faster than their
  double-precision counterparts, but they will require significantly less
  memory.
*/
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/planck.make0000664000175000017500000000077513010375061026242 0ustar  zoncazonca00000000000000PKG:=libsharp

SD:=$(SRCROOT)/$(PKG)
OD:=$(BLDROOT)/$(PKG)

FULL_INCLUDE+= -I$(SD)

HDR_$(PKG):=$(SD)/*.h
LIB_$(PKG):=$(LIBDIR)/libsharp.a
LIBOBJ:=sharp_ylmgen_c.o sharp.o sharp_geomhelpers.o sharp_almhelpers.o sharp_core.o
LIBOBJ:=$(LIBOBJ:%=$(OD)/%)

ODEP:=$(HDR_$(PKG)) $(HDR_libfftpack) $(HDR_c_utils)
$(OD)/sharp_core.o: $(SD)/sharp_core_inchelper.c $(SD)/sharp_core_inc.c $(SD)/sharp_core_inc2.c

$(LIB_$(PKG)): $(LIBOBJ)

$(LIBOBJ): $(ODEP) | $(OD)_mkdir

all_hdr+=$(HDR_$(PKG))
all_lib+=$(LIB_$(PKG))
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp.c0000664000175000017500000006722013010375061025412 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp.c
 *  Spherical transform library
 *
 *  Copyright (C) 2006-2013 Max-Planck-Society
 *  \author Martin Reinecke \author Dag Sverre Seljebotn
 */

#include 
#include "ls_fft.h"
#include "sharp_ylmgen_c.h"
#include "sharp_internal.h"
#include "c_utils.h"
#include "sharp_core.h"
#include "sharp_vecutil.h"
#include "walltime_c.h"
#include "sharp_almhelpers.h"
#include "sharp_geomhelpers.h"

typedef complex double dcmplx;
typedef complex float  fcmplx;

static const double sqrt_one_half = 0.707106781186547572737310929369;
static const double sqrt_two = 1.414213562373095145474621858739;

static int chunksize_min=500, nchunks_max=10;

static void get_chunk_info (int ndata, int nmult, int *nchunks, int *chunksize)
  {
  *chunksize = (ndata+nchunks_max-1)/nchunks_max;
  if (*chunksize>=chunksize_min) // use max number of chunks
    *chunksize = ((*chunksize+nmult-1)/nmult)*nmult;
  else // need to adjust chunksize and nchunks
    {
    *nchunks = (ndata+chunksize_min-1)/chunksize_min;
    *chunksize = (ndata+(*nchunks)-1)/(*nchunks);
    if (*nchunks>1)
      *chunksize = ((*chunksize+nmult-1)/nmult)*nmult;
    }
  *nchunks = (ndata+(*chunksize)-1)/(*chunksize);
  }

int sharp_get_mlim (int lmax, int spin, double sth, double cth)
  {
  double ofs=lmax*0.01;
  if (ofs<100.) ofs=100.;
  double b = -2*spin*fabs(cth);
  double t1 = lmax*sth+ofs;
  double c = (double)spin*spin-t1*t1;
  double discr = b*b-4*c;
  if (discr<=0) return lmax;
  double res=(-b+sqrt(discr))/2.;
  if (res>lmax) res=lmax;
  return (int)(res+0.5);
  }

typedef struct
  {
  double phi0_;
  dcmplx *shiftarr;
  int s_shift;
  real_plan plan;
  int norot;
  } ringhelper;

static void ringhelper_init (ringhelper *self)
  {
  static ringhelper rh_null = { 0, NULL, 0, NULL, 0 };
  *self = rh_null;
  }

static void ringhelper_destroy (ringhelper *self)
  {
  if (self->plan) kill_real_plan(self->plan);
  DEALLOC(self->shiftarr);
  ringhelper_init(self);
  }

static void ringhelper_update (ringhelper *self, int nph, int mmax, double phi0)
  {
  self->norot = (fabs(phi0)<1e-14);
  if (!(self->norot))
    if ((mmax!=self->s_shift-1) || (!FAPPROX(phi0,self->phi0_,1e-12)))
      {
      RESIZE (self->shiftarr,dcmplx,mmax+1);
      self->s_shift = mmax+1;
      self->phi0_ = phi0;
      for (int m=0; m<=mmax; ++m)
        self->shiftarr[m] = cos(m*phi0) + _Complex_I*sin(m*phi0);
      }
  if (!self->plan) self->plan=make_real_plan(nph);
  if (nph!=(int)self->plan->length)
    {
    kill_real_plan(self->plan);
    self->plan=make_real_plan(nph);
    }
  }

static int ringinfo_compare (const void *xa, const void *xb)
  {
  const sharp_ringinfo *a=xa, *b=xb;
  return (a->sth < b->sth) ? -1 : (a->sth > b->sth) ? 1 : 0;
  }
static int ringpair_compare (const void *xa, const void *xb)
  {
  const sharp_ringpair *a=xa, *b=xb;
  if (a->r1.nph==b->r1.nph)
    return (a->r1.phi0 < b->r1.phi0) ? -1 :
      ((a->r1.phi0 > b->r1.phi0) ? 1 :
        (a->r1.cth>b->r1.cth ? -1 : 1));
  return (a->r1.nphr1.nph) ? -1 : 1;
  }

void sharp_make_general_alm_info (int lmax, int nm, int stride, const int *mval,
  const ptrdiff_t *mstart, int flags, sharp_alm_info **alm_info)
  {
  sharp_alm_info *info = RALLOC(sharp_alm_info,1);
  info->lmax = lmax;
  info->nm = nm;
  info->mval = RALLOC(int,nm);
  info->mvstart = RALLOC(ptrdiff_t,nm);
  info->stride = stride;
  info->flags = flags;
  for (int mi=0; mimval[mi] = mval[mi];
    info->mvstart[mi] = mstart[mi];
    }
  *alm_info = info;
  }

void sharp_make_alm_info (int lmax, int mmax, int stride,
  const ptrdiff_t *mstart, sharp_alm_info **alm_info)
  {
  int *mval=RALLOC(int,mmax+1);
  for (int i=0; i<=mmax; ++i)
    mval[i]=i;
  sharp_make_general_alm_info (lmax, mmax+1, stride, mval, mstart, 0, alm_info);
  DEALLOC(mval);
  }

ptrdiff_t sharp_alm_index (const sharp_alm_info *self, int l, int mi)
  {
  UTIL_ASSERT(!(self->flags & SHARP_PACKED),
              "sharp_alm_index not applicable with SHARP_PACKED alms");
  return self->mvstart[mi]+self->stride*l;
  }

void sharp_destroy_alm_info (sharp_alm_info *info)
  {
  DEALLOC (info->mval);
  DEALLOC (info->mvstart);
  DEALLOC (info);
  }

void sharp_make_geom_info (int nrings, const int *nph, const ptrdiff_t *ofs,
  const int *stride, const double *phi0, const double *theta,
  const double *wgt, sharp_geom_info **geom_info)
  {
  sharp_geom_info *info = RALLOC(sharp_geom_info,1);
  sharp_ringinfo *infos = RALLOC(sharp_ringinfo,nrings);

  int pos=0;
  info->pair=RALLOC(sharp_ringpair,nrings);
  info->npairs=0;
  info->nphmax=0;
  *geom_info = info;

  for (int m=0; mnphmaxnphmax=nph[m];
    }
  qsort(infos,nrings,sizeof(sharp_ringinfo),ringinfo_compare);
  while (pospair[info->npairs].r1=infos[pos];
    if ((pos0)  // make sure northern ring is in r1
        info->pair[info->npairs].r2=infos[pos+1];
      else
        {
        info->pair[info->npairs].r1=infos[pos+1];
        info->pair[info->npairs].r2=infos[pos];
        }
      ++pos;
      }
    else
      info->pair[info->npairs].r2.nph=-1;
    ++pos;
    ++info->npairs;
    }
  DEALLOC(infos);

  qsort(info->pair,info->npairs,sizeof(sharp_ringpair),ringpair_compare);
  }

void sharp_destroy_geom_info (sharp_geom_info *geom_info)
  {
  DEALLOC (geom_info->pair);
  DEALLOC (geom_info);
  }

/* This currently requires all m values from 0 to nm-1 to be present.
   It might be worthwhile to relax this criterion such that holes in the m
   distribution are permissible. */
static int sharp_get_mmax (int *mval, int nm)
  {
  int *mcheck=RALLOC(int,nm);
  SET_ARRAY(mcheck,0,nm,0);
  for (int i=0; i=0) && (m_curnph;

  ringhelper_update (self, nph, mmax, info->phi0);

  double wgt = (flags&SHARP_USE_WEIGHTS) ? info->weight : 1.;
  if (flags&SHARP_REAL_HARMONICS)
    wgt *= sqrt_one_half;

  if (nph>=2*mmax+1)
    {
    for (int m=0; m<=mmax; ++m)
      {
      dcmplx tmp = phase[m*pstride]*wgt;
      if(!self->norot) tmp*=self->shiftarr[m];
      data[2*m]=creal(tmp);
      data[2*m+1]=cimag(tmp);
      }
    for (int m=2*(mmax+1); mnorot) tmp*=self->shiftarr[m];
      if (idx1<(nph+2)/2)
        {
        data[2*idx1]+=creal(tmp);
        data[2*idx1+1]+=cimag(tmp);
        }
      if (idx2<(nph+2)/2)
        {
        data[2*idx2]+=creal(tmp);
        data[2*idx2+1]-=cimag(tmp);
        }
      if (++idx1>=nph) idx1=0;
      if (--idx2<0) idx2=nph-1;
      }
    }
  data[1]=data[0];
  real_plan_backward_fftpack (self->plan, &(data[1]));
  }

static void ringhelper_ring2phase (ringhelper *self,
  const sharp_ringinfo *info, double *data, int mmax, dcmplx *phase,
  int pstride, int flags)
  {
  int nph = info->nph;
#if 1
  int maxidx = mmax; /* Enable this for traditional Healpix compatibility */
#else
  int maxidx = IMIN(nph-1,mmax);
#endif

  ringhelper_update (self, nph, mmax, -info->phi0);
  double wgt = (flags&SHARP_USE_WEIGHTS) ? info->weight : 1;
  if (flags&SHARP_REAL_HARMONICS)
    wgt *= sqrt_two;

  real_plan_forward_fftpack (self->plan, &(data[1]));
  data[0]=data[1];
  data[1]=data[nph+1]=0.;

  if (maxidx<=nph/2)
    {
    if (self->norot)
      for (int m=0; m<=maxidx; ++m)
        phase[m*pstride] = (data[2*m] + _Complex_I*data[2*m+1]) * wgt;
    else
      for (int m=0; m<=maxidx; ++m)
        phase[m*pstride] =
          (data[2*m] + _Complex_I*data[2*m+1]) * self->shiftarr[m] * wgt;
    }
  else
    {
    for (int m=0; m<=maxidx; ++m)
      {
      int idx=m%nph;
      dcmplx val;
      if (idx<(nph-idx))
        val = (data[2*idx] + _Complex_I*data[2*idx+1]) * wgt;
      else
        val = (data[2*(nph-idx)] - _Complex_I*data[2*(nph-idx)+1]) * wgt;
      if (!self->norot)
        val *= self->shiftarr[m];
      phase[m*pstride]=val;
      }
    }

  for (int m=maxidx+1;m<=mmax; ++m)
    phase[m*pstride]=0.;
  }

static void fill_map (const sharp_geom_info *ginfo, void *map, double value,
  int flags)
  {
  if (flags & SHARP_NO_FFT)
    {
    for (int j=0;jnpairs;++j)
      {
      if (flags&SHARP_DP)
        {
        for (ptrdiff_t i=0;ipair[j].r1.nph;++i)
          ((dcmplx *)map)[ginfo->pair[j].r1.ofs+i*ginfo->pair[j].r1.stride]
            =value;
        for (ptrdiff_t i=0;ipair[j].r2.nph;++i)
          ((dcmplx *)map)[ginfo->pair[j].r2.ofs+i*ginfo->pair[j].r2.stride]
            =value;
        }
      else
        {
        for (ptrdiff_t i=0;ipair[j].r1.nph;++i)
          ((fcmplx *)map)[ginfo->pair[j].r1.ofs+i*ginfo->pair[j].r1.stride]
            =(float)value;
        for (ptrdiff_t i=0;ipair[j].r2.nph;++i)
          ((fcmplx *)map)[ginfo->pair[j].r2.ofs+i*ginfo->pair[j].r2.stride]
            =(float)value;
        }
      }
    }
  else
    {
    for (int j=0;jnpairs;++j)
      {
      if (flags&SHARP_DP)
        {
        for (ptrdiff_t i=0;ipair[j].r1.nph;++i)
          ((double *)map)[ginfo->pair[j].r1.ofs+i*ginfo->pair[j].r1.stride]
            =value;
        for (ptrdiff_t i=0;ipair[j].r2.nph;++i)
          ((double *)map)[ginfo->pair[j].r2.ofs+i*ginfo->pair[j].r2.stride]
            =value;
        }
      else
        {
        for (ptrdiff_t i=0;ipair[j].r1.nph;++i)
          ((float *)map)[ginfo->pair[j].r1.ofs+i*ginfo->pair[j].r1.stride]
            =(float)value;
        for (ptrdiff_t i=0;ipair[j].r2.nph;++i)
          ((float *)map)[ginfo->pair[j].r2.ofs+i*ginfo->pair[j].r2.stride]
            =(float)value;
        }
      }
    }
  }

static void clear_alm (const sharp_alm_info *ainfo, void *alm, int flags)
  {
#define CLEARLOOP(real_t,body)             \
      {                                    \
        real_t *talm = (real_t *)alm;      \
          for (int l=m;l<=ainfo->lmax;++l) \
            body                           \
      }

  for (int mi=0;minm;++mi)
    {
      int m=ainfo->mval[mi];
      ptrdiff_t mvstart = ainfo->mvstart[mi];
      ptrdiff_t stride = ainfo->stride;
      if (!(ainfo->flags&SHARP_PACKED))
        mvstart*=2;
      if ((ainfo->flags&SHARP_PACKED)&&(m==0))
        {
        if (flags&SHARP_DP)
          CLEARLOOP(double, talm[mvstart+l*stride] = 0.;)
        else
          CLEARLOOP(float, talm[mvstart+l*stride] = 0.;)
        }
      else
        {
        stride*=2;
        if (flags&SHARP_DP)
          CLEARLOOP(double,talm[mvstart+l*stride]=talm[mvstart+l*stride+1]=0.;)
        else
          CLEARLOOP(float,talm[mvstart+l*stride]=talm[mvstart+l*stride+1]=0.;)
        }

#undef CLEARLOOP
    }
  }

static void init_output (sharp_job *job)
  {
  if (job->flags&SHARP_ADD) return;
  if (job->type == SHARP_MAP2ALM)
    for (int i=0; intrans*job->nalm; ++i)
      clear_alm (job->ainfo,job->alm[i],job->flags);
  else
    for (int i=0; intrans*job->nmaps; ++i)
      fill_map (job->ginfo,job->map[i],0.,job->flags);
  }

static void alloc_phase (sharp_job *job, int nm, int ntheta)
  {
  if (job->type==SHARP_MAP2ALM)
    {
    if ((nm&1023)==0) nm+=3; // hack to avoid critical strides
    job->s_m=2*job->ntrans*job->nmaps;
    job->s_th=job->s_m*nm;
    }
  else
    {
    if ((ntheta&1023)==0) ntheta+=3; // hack to avoid critical strides
    job->s_th=2*job->ntrans*job->nmaps;
    job->s_m=job->s_th*ntheta;
    }
  job->phase=RALLOC(dcmplx,2*job->ntrans*job->nmaps*nm*ntheta);
  }

static void dealloc_phase (sharp_job *job)
  { DEALLOC(job->phase); }

static void alloc_almtmp (sharp_job *job, int lmax)
  { job->almtmp=RALLOC(dcmplx,job->ntrans*job->nalm*(lmax+1)); }

static void dealloc_almtmp (sharp_job *job)
  { DEALLOC(job->almtmp); }

static void alm2almtmp (sharp_job *job, int lmax, int mi)
  {

#define COPY_LOOP(real_t, source_t, expr_of_x)                      \
  for (int l=job->ainfo->mval[mi]; l<=lmax; ++l)            \
    for (int i=0; intrans*job->nalm; ++i)             \
      {                                                     \
        source_t x = *(source_t *)(((real_t *)job->alm[i])+ofs+l*stride); \
        job->almtmp[job->ntrans*job->nalm*l+i] = expr_of_x; \
      }

  if (job->type!=SHARP_MAP2ALM)
    {
    ptrdiff_t ofs=job->ainfo->mvstart[mi];
    int stride=job->ainfo->stride;
    int m=job->ainfo->mval[mi];
    /* in the case of SHARP_REAL_HARMONICS, phase2ring scales all the
       coefficients by sqrt_one_half; here we must compensate to avoid scaling
       m=0 */
    double norm_m0=(job->flags&SHARP_REAL_HARMONICS) ? sqrt_two : 1.;
    if (!(job->ainfo->flags&SHARP_PACKED))
      ofs *= 2;
    if (!((job->ainfo->flags&SHARP_PACKED)&&(m==0)))
      stride *= 2;
    if (job->spin==0)
      {
      if (m==0)
        {
        if (job->flags&SHARP_DP)
          COPY_LOOP(double, double, x*norm_m0)
        else
          COPY_LOOP(float, float, x*norm_m0)
        }
      else
        {
        if (job->flags&SHARP_DP)
          COPY_LOOP(double, dcmplx, x)
        else
          COPY_LOOP(float, fcmplx, x)
        }
      }
    else
      {
      if (m==0)
        {
        if (job->flags&SHARP_DP)
          COPY_LOOP(double, double, x*job->norm_l[l]*norm_m0)
        else
          COPY_LOOP(float, float, x*job->norm_l[l]*norm_m0)
        }
      else
        {
        if (job->flags&SHARP_DP)
          COPY_LOOP(double, dcmplx, x*job->norm_l[l])
        else
          COPY_LOOP(float, fcmplx, x*job->norm_l[l])
        }
      }
    }
  else
    SET_ARRAY(job->almtmp,job->ntrans*job->nalm*job->ainfo->mval[mi],
              job->ntrans*job->nalm*(lmax+1),0.);

#undef COPY_LOOP
  }

static void almtmp2alm (sharp_job *job, int lmax, int mi)
  {

#define COPY_LOOP(real_t, target_t, expr_of_x)               \
  for (int l=job->ainfo->mval[mi]; l<=lmax; ++l)             \
    for (int i=0; intrans*job->nalm; ++i)              \
      {                                                      \
        dcmplx x = job->almtmp[job->ntrans*job->nalm*l+i];   \
        *(target_t *)(((real_t *)job->alm[i])+ofs+l*stride) += expr_of_x; \
      }

  if (job->type != SHARP_MAP2ALM) return;
  ptrdiff_t ofs=job->ainfo->mvstart[mi];
  int stride=job->ainfo->stride;
  int m=job->ainfo->mval[mi];
  /* in the case of SHARP_REAL_HARMONICS, ring2phase scales all the
     coefficients by sqrt_two; here we must compensate to avoid scaling
     m=0 */
  double norm_m0=(job->flags&SHARP_REAL_HARMONICS) ? sqrt_one_half : 1.;
  if (!(job->ainfo->flags&SHARP_PACKED))
    ofs *= 2;
  if (!((job->ainfo->flags&SHARP_PACKED)&&(m==0)))
    stride *= 2;
  if (job->spin==0)
    {
    if (m==0)
      {
      if (job->flags&SHARP_DP)
        COPY_LOOP(double, double, creal(x)*norm_m0)
      else
        COPY_LOOP(float, float, crealf(x)*norm_m0)
      }
    else
      {
      if (job->flags&SHARP_DP)
        COPY_LOOP(double, dcmplx, x)
      else
        COPY_LOOP(float, fcmplx, (fcmplx)x)
      }
    }
  else
    {
    if (m==0)
      {
      if (job->flags&SHARP_DP)
        COPY_LOOP(double, double, creal(x)*job->norm_l[l]*norm_m0)
      else
        COPY_LOOP(float, fcmplx, (float)(creal(x)*job->norm_l[l]*norm_m0))
      }
    else
      {
      if (job->flags&SHARP_DP)
        COPY_LOOP(double, dcmplx, x*job->norm_l[l])
      else
        COPY_LOOP(float, fcmplx, (fcmplx)(x*job->norm_l[l]))
      }
    }

#undef COPY_LOOP
  }

static void ringtmp2ring (sharp_job *job, sharp_ringinfo *ri, double *ringtmp,
  int rstride)
  {
  double **dmap = (double **)job->map;
  float  **fmap = (float  **)job->map;
  for (int i=0; intrans*job->nmaps; ++i)
    for (int m=0; mnph; ++m)
      if (job->flags & SHARP_DP)
        dmap[i][ri->ofs+m*ri->stride] += ringtmp[i*rstride+m+1];
      else
        fmap[i][ri->ofs+m*ri->stride] += (float)ringtmp[i*rstride+m+1];
  }

static void ring2ringtmp (sharp_job *job, sharp_ringinfo *ri, double *ringtmp,
  int rstride)
  {
  for (int i=0; intrans*job->nmaps; ++i)
    for (int m=0; mnph; ++m)
      ringtmp[i*rstride+m+1] = (job->flags & SHARP_DP) ?
        ((double *)(job->map[i]))[ri->ofs+m*ri->stride] :
        ((float  *)(job->map[i]))[ri->ofs+m*ri->stride];
  }

static void ring2phase_direct (sharp_job *job, sharp_ringinfo *ri, int mmax,
  dcmplx *phase)
  {
  if (ri->nph<0)
    {
    for (int i=0; intrans*job->nmaps; ++i)
      for (int m=0; m<=mmax; ++m)
        phase[2*i+job->s_m*m]=0.;
    }
  else
    {
    UTIL_ASSERT(ri->nph==mmax+1,"bad ring size");
    double wgt = (job->flags&SHARP_USE_WEIGHTS) ? (ri->nph*ri->weight) : 1.;
    if (job->flags&SHARP_REAL_HARMONICS)
      wgt *= sqrt_two;
    for (int i=0; intrans*job->nmaps; ++i)
      for (int m=0; m<=mmax; ++m)
        phase[2*i+job->s_m*m]= (job->flags & SHARP_DP) ?
          ((dcmplx *)(job->map[i]))[ri->ofs+m*ri->stride]*wgt :
          ((fcmplx *)(job->map[i]))[ri->ofs+m*ri->stride]*wgt;
    }
  }
static void phase2ring_direct (sharp_job *job, sharp_ringinfo *ri, int mmax,
  dcmplx *phase)
  {
  if (ri->nph<0) return;
  UTIL_ASSERT(ri->nph==mmax+1,"bad ring size");
  dcmplx **dmap = (dcmplx **)job->map;
  fcmplx **fmap = (fcmplx **)job->map;
  double wgt = (job->flags&SHARP_USE_WEIGHTS) ? (ri->nph*ri->weight) : 1.;
  if (job->flags&SHARP_REAL_HARMONICS)
    wgt *= sqrt_one_half;
  for (int i=0; intrans*job->nmaps; ++i)
    for (int m=0; m<=mmax; ++m)
      if (job->flags & SHARP_DP)
        dmap[i][ri->ofs+m*ri->stride] += wgt*phase[2*i+job->s_m*m];
      else
        fmap[i][ri->ofs+m*ri->stride] += (fcmplx)(wgt*phase[2*i+job->s_m*m]);
  }

//FIXME: set phase to zero if not SHARP_MAP2ALM?
static void map2phase (sharp_job *job, int mmax, int llim, int ulim)
  {
  if (job->type != SHARP_MAP2ALM) return;
  int pstride = job->s_m;
  if (job->flags & SHARP_NO_FFT)
    {
    for (int ith=llim; iths_th*(ith-llim);
      ring2phase_direct(job,&(job->ginfo->pair[ith].r1),mmax,
        &(job->phase[dim2]));
      ring2phase_direct(job,&(job->ginfo->pair[ith].r2),mmax,
        &(job->phase[dim2+1]));
      }
    }
  else
    {
#pragma omp parallel if ((job->flags&SHARP_NO_OPENMP)==0)
{
    ringhelper helper;
    ringhelper_init(&helper);
    int rstride=job->ginfo->nphmax+2;
    double *ringtmp=RALLOC(double,job->ntrans*job->nmaps*rstride);
#pragma omp for schedule(dynamic,1)
    for (int ith=llim; iths_th*(ith-llim);
      ring2ringtmp(job,&(job->ginfo->pair[ith].r1),ringtmp,rstride);
      for (int i=0; intrans*job->nmaps; ++i)
        ringhelper_ring2phase (&helper,&(job->ginfo->pair[ith].r1),
          &ringtmp[i*rstride],mmax,&job->phase[dim2+2*i],pstride,job->flags);
      if (job->ginfo->pair[ith].r2.nph>0)
        {
        ring2ringtmp(job,&(job->ginfo->pair[ith].r2),ringtmp,rstride);
        for (int i=0; intrans*job->nmaps; ++i)
          ringhelper_ring2phase (&helper,&(job->ginfo->pair[ith].r2),
           &ringtmp[i*rstride],mmax,&job->phase[dim2+2*i+1],pstride,job->flags);
        }
      }
    DEALLOC(ringtmp);
    ringhelper_destroy(&helper);
} /* end of parallel region */
    }
  }

static void phase2map (sharp_job *job, int mmax, int llim, int ulim)
  {
  if (job->type == SHARP_MAP2ALM) return;
  int pstride = job->s_m;
  if (job->flags & SHARP_NO_FFT)
    {
    for (int ith=llim; iths_th*(ith-llim);
      phase2ring_direct(job,&(job->ginfo->pair[ith].r1),mmax,
        &(job->phase[dim2]));
      phase2ring_direct(job,&(job->ginfo->pair[ith].r2),mmax,
        &(job->phase[dim2+1]));
      }
    }
  else
    {
#pragma omp parallel if ((job->flags&SHARP_NO_OPENMP)==0)
{
    ringhelper helper;
    ringhelper_init(&helper);
    int rstride=job->ginfo->nphmax+2;
    double *ringtmp=RALLOC(double,job->ntrans*job->nmaps*rstride);
#pragma omp for schedule(dynamic,1)
    for (int ith=llim; iths_th*(ith-llim);
      for (int i=0; intrans*job->nmaps; ++i)
        ringhelper_phase2ring (&helper,&(job->ginfo->pair[ith].r1),
          &ringtmp[i*rstride],mmax,&job->phase[dim2+2*i],pstride,job->flags);
      ringtmp2ring(job,&(job->ginfo->pair[ith].r1),ringtmp,rstride);
      if (job->ginfo->pair[ith].r2.nph>0)
        {
        for (int i=0; intrans*job->nmaps; ++i)
          ringhelper_phase2ring (&helper,&(job->ginfo->pair[ith].r2),
            &ringtmp[i*rstride],mmax,&job->phase[dim2+2*i+1],pstride,job->flags);
        ringtmp2ring(job,&(job->ginfo->pair[ith].r2),ringtmp,rstride);
        }
      }
    DEALLOC(ringtmp);
    ringhelper_destroy(&helper);
} /* end of parallel region */
    }
  }

static void sharp_execute_job (sharp_job *job)
  {
  double timer=wallTime();
  job->opcnt=0;
  int lmax = job->ainfo->lmax,
      mmax=sharp_get_mmax(job->ainfo->mval, job->ainfo->nm);

  job->norm_l = (job->type==SHARP_ALM2MAP_DERIV1) ?
     sharp_Ylmgen_get_d1norm (lmax) :
     sharp_Ylmgen_get_norm (lmax, job->spin);

/* clear output arrays if requested */
  init_output (job);

  int nchunks, chunksize;
  get_chunk_info(job->ginfo->npairs,(job->flags&SHARP_NVMAX)*VLEN,&nchunks,
    &chunksize);
  alloc_phase (job,mmax+1,chunksize);

/* chunk loop */
  for (int chunk=0; chunkginfo->npairs);
    int *ispair = RALLOC(int,ulim-llim);
    int *mlim = RALLOC(int,ulim-llim);
    double *cth = RALLOC(double,ulim-llim), *sth = RALLOC(double,ulim-llim);
    for (int i=0; iginfo->pair[i+llim].r2.nph>0;
      cth[i] = job->ginfo->pair[i+llim].r1.cth;
      sth[i] = job->ginfo->pair[i+llim].r1.sth;
      mlim[i] = sharp_get_mlim(lmax, job->spin, sth[i], cth[i]);
      }

/* map->phase where necessary */
    map2phase (job, mmax, llim, ulim);

#pragma omp parallel if ((job->flags&SHARP_NO_OPENMP)==0)
{
    sharp_job ljob = *job;
    ljob.opcnt=0;
    sharp_Ylmgen_C generator;
    sharp_Ylmgen_init (&generator,lmax,mmax,ljob.spin);
    alloc_almtmp(&ljob,lmax);

#pragma omp for schedule(dynamic,1)
    for (int mi=0; miainfo->nm; ++mi)
      {
/* alm->alm_tmp where necessary */
      alm2almtmp (&ljob, lmax, mi);

      inner_loop (&ljob, ispair, cth, sth, llim, ulim, &generator, mi, mlim);

/* alm_tmp->alm where necessary */
      almtmp2alm (&ljob, lmax, mi);
      }

    sharp_Ylmgen_destroy(&generator);
    dealloc_almtmp(&ljob);

#pragma omp critical
    job->opcnt+=ljob.opcnt;
} /* end of parallel region */

/* phase->map where necessary */
    phase2map (job, mmax, llim, ulim);

    DEALLOC(ispair);
    DEALLOC(mlim);
    DEALLOC(cth);
    DEALLOC(sth);
    } /* end of chunk loop */

  DEALLOC(job->norm_l);
  dealloc_phase (job);
  job->time=wallTime()-timer;
  }

static void sharp_build_job_common (sharp_job *job, sharp_jobtype type,
  int spin, void *alm, void *map, const sharp_geom_info *geom_info,
  const sharp_alm_info *alm_info, int ntrans, int flags)
  {
  UTIL_ASSERT((ntrans>0)&&(ntrans<=SHARP_MAXTRANS),
    "bad number of simultaneous transforms");
  if (type==SHARP_ALM2MAP_DERIV1) spin=1;
  if (type==SHARP_MAP2ALM) flags|=SHARP_USE_WEIGHTS;
  if (type==SHARP_Yt) type=SHARP_MAP2ALM;
  if (type==SHARP_WY) { type=SHARP_ALM2MAP; flags|=SHARP_USE_WEIGHTS; }

  UTIL_ASSERT((spin>=0)&&(spin<=alm_info->lmax), "bad spin");
  job->type = type;
  job->spin = spin;
  job->norm_l = NULL;
  job->nmaps = (type==SHARP_ALM2MAP_DERIV1) ? 2 : ((spin>0) ? 2 : 1);
  job->nalm = (type==SHARP_ALM2MAP_DERIV1) ? 1 : ((spin>0) ? 2 : 1);
  job->ginfo = geom_info;
  job->ainfo = alm_info;
  job->flags = flags;
  if ((job->flags&SHARP_NVMAX)==0)
    job->flags|=sharp_nv_oracle (type, spin, ntrans);
  job->time = 0.;
  job->opcnt = 0;
  job->ntrans = ntrans;
  job->alm=alm;
  job->map=map;
  }

void sharp_execute (sharp_jobtype type, int spin, void *alm, void *map,
  const sharp_geom_info *geom_info, const sharp_alm_info *alm_info, int ntrans,
  int flags, double *time, unsigned long long *opcnt)
  {
  sharp_job job;
  sharp_build_job_common (&job, type, spin, alm, map, geom_info, alm_info,
    ntrans, flags);

  sharp_execute_job (&job);
  if (time!=NULL) *time = job.time;
  if (opcnt!=NULL) *opcnt = job.opcnt;
  }

void sharp_set_chunksize_min(int new_chunksize_min)
  { chunksize_min=new_chunksize_min; }
void sharp_set_nchunks_max(int new_nchunks_max)
  { nchunks_max=new_nchunks_max; }

int sharp_get_nv_max (void)
{ return 6; }

static int sharp_oracle (sharp_jobtype type, int spin, int ntrans)
  {
  int lmax=511;
  int mmax=(lmax+1)/2;
  int nrings=(lmax+1)/4;
  int ppring=1;

  spin = (spin!=0) ? 2 : 0;

  ptrdiff_t npix=(ptrdiff_t)nrings*ppring;
  sharp_geom_info *tinfo;
  sharp_make_gauss_geom_info (nrings, ppring, 0., 1, ppring, &tinfo);

  ptrdiff_t nalms = ((mmax+1)*(mmax+2))/2 + (mmax+1)*(lmax-mmax);
  int ncomp = ntrans*((spin==0) ? 1 : 2);

  double **map;
  ALLOC2D(map,double,ncomp,npix);
  SET_ARRAY(map[0],0,npix*ncomp,0.);

  sharp_alm_info *alms;
  sharp_make_triangular_alm_info(lmax,mmax,1,&alms);

  dcmplx **alm;
  ALLOC2D(alm,dcmplx,ncomp,nalms);
  SET_ARRAY(alm[0],0,nalms*ncomp,0.);

  double time=1e30;
  int nvbest=-1;

  for (int nv=1; nv<=sharp_get_nv_max(); ++nv)
    {
    double time_acc=0.;
    double jtime;
    int ntries=0;
    do
      {
      sharp_execute(type,spin,&alm[0],&map[0],tinfo,alms,ntrans,
        nv|SHARP_DP|SHARP_NO_OPENMP,&jtime,NULL);

      if (jtime0),"bad number of simultaneous transforms");
  UTIL_ASSERT(spin>=0, "bad spin");
  ntrans=IMIN(ntrans,maxtr);

  if (nv_opt[ntrans-1][spin!=0][type]==0)
    nv_opt[ntrans-1][spin!=0][type]=sharp_oracle(type,spin,ntrans);
  return nv_opt[ntrans-1][spin!=0][type];
  }

#ifdef USE_MPI
#include "sharp_mpi.c"
#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp.h0000664000175000017500000000240313010375061025407 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp.h
 *  Interface for the spherical transform library.
 *
 *  Copyright (C) 2006-2012 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SHARP_H
#define PLANCK_SHARP_H

#ifdef __cplusplus
#error This header file cannot be included from C++, only from C
#endif

#include 

#include "sharp_lowlevel.h"

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_almhelpers.c0000664000175000017500000000403613010375061027622 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_almhelpers.c
 *  Spherical transform library
 *
 *  Copyright (C) 2008-2013 Max-Planck-Society
 *  \author Martin Reinecke
 */

#include "sharp_almhelpers.h"
#include "c_utils.h"

void sharp_make_triangular_alm_info (int lmax, int mmax, int stride,
  sharp_alm_info **alm_info)
  {
  sharp_alm_info *info = RALLOC(sharp_alm_info,1);
  info->lmax = lmax;
  info->nm = mmax+1;
  info->mval = RALLOC(int,mmax+1);
  info->mvstart = RALLOC(ptrdiff_t,mmax+1);
  info->stride = stride;
  info->flags = 0;
  ptrdiff_t tval = 2*lmax+1;
  for (ptrdiff_t m=0; m<=mmax; ++m)
    {
    info->mval[m] = m;
    info->mvstart[m] = stride*((m*(tval-m))>>1);
    }
  *alm_info = info;
  }

void sharp_make_rectangular_alm_info (int lmax, int mmax, int stride,
  sharp_alm_info **alm_info)
  {
  sharp_alm_info *info = RALLOC(sharp_alm_info,1);
  info->lmax = lmax;
  info->nm = mmax+1;
  info->mval = RALLOC(int,mmax+1);
  info->mvstart = RALLOC(ptrdiff_t,mmax+1);
  info->stride = stride;
  info->flags = 0;
  for (ptrdiff_t m=0; m<=mmax; ++m)
    {
    info->mval[m] = m;
    info->mvstart[m] = stride*m*(lmax+1);
    }
  *alm_info = info;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_almhelpers.h0000664000175000017500000000326513010375061027632 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_almhelpers.h
 *  SHARP helper function for the creation of a_lm data structures
 *
 *  Copyright (C) 2008-2011 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SHARP_ALMHELPERS_H
#define PLANCK_SHARP_ALMHELPERS_H

#include "sharp_lowlevel.h"

#ifdef __cplusplus
extern "C" {
#endif

/*! Initialises an a_lm data structure according to the scheme used by
    Healpix_cxx.
    \ingroup almgroup */
void sharp_make_triangular_alm_info (int lmax, int mmax, int stride,
  sharp_alm_info **alm_info);

/*! Initialises an a_lm data structure according to the scheme used by
    Fortran Healpix
    \ingroup almgroup */
void sharp_make_rectangular_alm_info (int lmax, int mmax, int stride,
  sharp_alm_info **alm_info);

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_complex_hacks.h0000664000175000017500000000740713010375061030320 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*  \file sharp_complex_hacks.h
 *  support for converting vector types and complex numbers
 *
 *  Copyright (C) 2012 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#ifndef SHARP_COMPLEX_HACKS_H
#define SHARP_COMPLEX_HACKS_H

#ifdef __cplusplus
#error This header file cannot be included from C++, only from C
#endif

#include 
#include 
#include "sharp_vecsupport.h"

#define UNSAFE_CODE

#if (VLEN==1)

static inline complex double vhsum_cmplx(Tv a, Tv b)
  { return a+_Complex_I*b; }

static inline void vhsum_cmplx2 (Tv a, Tv b, Tv c, Tv d,
  complex double * restrict c1, complex double * restrict c2)
  { *c1 += a+_Complex_I*b; *c2 += c+_Complex_I*d; }

#endif

#if (VLEN==2)

static inline complex double vhsum_cmplx (Tv a, Tv b)
  {
#if defined(__SSE3__)
  Tv tmp = _mm_hadd_pd(a,b);
#else
  Tv tmp = vadd(_mm_shuffle_pd(a,b,_MM_SHUFFLE2(0,1)),
                _mm_shuffle_pd(a,b,_MM_SHUFFLE2(1,0)));
#endif
  union {Tv v; complex double c; } u;
  u.v=tmp; return u.c;
  }

static inline void vhsum_cmplx2 (Tv a, Tv b, Tv c,
  Tv d, complex double * restrict c1, complex double * restrict c2)
  {
#ifdef UNSAFE_CODE
#if defined(__SSE3__)
  vaddeq(*((__m128d *)c1),_mm_hadd_pd(a,b));
  vaddeq(*((__m128d *)c2),_mm_hadd_pd(c,d));
#else
  vaddeq(*((__m128d *)c1),vadd(_mm_shuffle_pd(a,b,_MM_SHUFFLE2(0,1)),
                               _mm_shuffle_pd(a,b,_MM_SHUFFLE2(1,0))));
  vaddeq(*((__m128d *)c2),vadd(_mm_shuffle_pd(c,d,_MM_SHUFFLE2(0,1)),
                               _mm_shuffle_pd(c,d,_MM_SHUFFLE2(1,0))));
#endif
#else
  union {Tv v; complex double c; } u1, u2;
#if defined(__SSE3__)
  u1.v = _mm_hadd_pd(a,b); u2.v=_mm_hadd_pd(c,d);
#else
  u1.v = vadd(_mm_shuffle_pd(a,b,_MM_SHUFFLE2(0,1)),
              _mm_shuffle_pd(a,b,_MM_SHUFFLE2(1,0)));
  u2.v = vadd(_mm_shuffle_pd(c,d,_MM_SHUFFLE2(0,1)),
              _mm_shuffle_pd(c,d,_MM_SHUFFLE2(1,0)));
#endif
  *c1+=u1.c; *c2+=u2.c;
#endif
  }

#endif

#if (VLEN==4)

static inline complex double vhsum_cmplx (Tv a, Tv b)
  {
  Tv tmp=_mm256_hadd_pd(a,b);
  Tv tmp2=_mm256_permute2f128_pd(tmp,tmp,1);
  tmp=_mm256_add_pd(tmp,tmp2);
#ifdef UNSAFE_CODE
  complex double ret;
  *((__m128d *)&ret)=_mm256_extractf128_pd(tmp, 0);
  return ret;
#else
  union {Tv v; complex double c[2]; } u;
  u.v=tmp; return u.c[0];
#endif
  }

static inline void vhsum_cmplx2 (Tv a, Tv b, Tv c, Tv d,
  complex double * restrict c1, complex double * restrict c2)
  {
  Tv tmp1=_mm256_hadd_pd(a,b), tmp2=_mm256_hadd_pd(c,d);
  Tv tmp3=_mm256_permute2f128_pd(tmp1,tmp2,49),
     tmp4=_mm256_permute2f128_pd(tmp1,tmp2,32);
  tmp1=vadd(tmp3,tmp4);
#ifdef UNSAFE_CODE
  *((__m128d *)c1)=_mm_add_pd(*((__m128d *)c1),_mm256_extractf128_pd(tmp1, 0));
  *((__m128d *)c2)=_mm_add_pd(*((__m128d *)c2),_mm256_extractf128_pd(tmp1, 1));
#else
  union {Tv v; complex double c[2]; } u;
  u.v=tmp1;
  *c1+=u.c[0]; *c2+=u.c[1];
#endif
  }

#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_core.c0000664000175000017500000001630613010375061026421 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_core.c
 *  Computational core
 *
 *  Copyright (C) 2012-2013 Max-Planck-Society
 *  \author Martin Reinecke
 */

#include 
#include 
#include 
#include "sharp_vecsupport.h"
#include "sharp_complex_hacks.h"
#include "sharp_ylmgen_c.h"
#include "sharp.h"
#include "sharp_core.h"
#include "c_utils.h"

typedef complex double dcmplx;

// must be in the range [0;6]
#define MAXJOB_SPECIAL 2

#define XCONCAT2(a,b) a##_##b
#define CONCAT2(a,b) XCONCAT2(a,b)
#define XCONCAT3(a,b,c) a##_##b##_##c
#define CONCAT3(a,b,c) XCONCAT3(a,b,c)

#define nvec 1
#include "sharp_core_inchelper.c"
#undef nvec

#define nvec 2
#include "sharp_core_inchelper.c"
#undef nvec

#define nvec 3
#include "sharp_core_inchelper.c"
#undef nvec

#define nvec 4
#include "sharp_core_inchelper.c"
#undef nvec

#define nvec 5
#include "sharp_core_inchelper.c"
#undef nvec

#define nvec 6
#include "sharp_core_inchelper.c"
#undef nvec

void inner_loop (sharp_job *job, const int *ispair,const double *cth,
  const double *sth, int llim, int ulim, sharp_Ylmgen_C *gen, int mi,
  const int *mlim)
  {
  int njobs=job->ntrans, nv=job->flags&SHARP_NVMAX;
  if (njobs<=MAXJOB_SPECIAL)
    {
    switch (njobs*16+nv)
      {
#if ((MAXJOB_SPECIAL>=1)&&(SHARP_MAXTRANS>=1))
      case 0x11:
        CONCAT3(inner_loop,1,1) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x12:
        CONCAT3(inner_loop,2,1) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x13:
        CONCAT3(inner_loop,3,1) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x14:
        CONCAT3(inner_loop,4,1) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x15:
        CONCAT3(inner_loop,5,1) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x16:
        CONCAT3(inner_loop,6,1) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
#endif
#if ((MAXJOB_SPECIAL>=2)&&(SHARP_MAXTRANS>=2))
      case 0x21:
        CONCAT3(inner_loop,1,2) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x22:
        CONCAT3(inner_loop,2,2) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x23:
        CONCAT3(inner_loop,3,2) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x24:
        CONCAT3(inner_loop,4,2) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x25:
        CONCAT3(inner_loop,5,2) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x26:
        CONCAT3(inner_loop,6,2) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
#endif
#if ((MAXJOB_SPECIAL>=3)&&(SHARP_MAXTRANS>=3))
      case 0x31:
        CONCAT3(inner_loop,1,3) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x32:
        CONCAT3(inner_loop,2,3) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x33:
        CONCAT3(inner_loop,3,3) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x34:
        CONCAT3(inner_loop,4,3) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x35:
        CONCAT3(inner_loop,5,3) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x36:
        CONCAT3(inner_loop,6,3) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
#endif
#if ((MAXJOB_SPECIAL>=4)&&(SHARP_MAXTRANS>=4))
      case 0x41:
        CONCAT3(inner_loop,1,4) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x42:
        CONCAT3(inner_loop,2,4) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x43:
        CONCAT3(inner_loop,3,4) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x44:
        CONCAT3(inner_loop,4,4) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x45:
        CONCAT3(inner_loop,5,4) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x46:
        CONCAT3(inner_loop,6,4) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
#endif
#if ((MAXJOB_SPECIAL>=5)&&(SHARP_MAXTRANS>=5))
      case 0x51:
        CONCAT3(inner_loop,1,5) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x52:
        CONCAT3(inner_loop,2,5) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x53:
        CONCAT3(inner_loop,3,5) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x54:
        CONCAT3(inner_loop,4,5) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x55:
        CONCAT3(inner_loop,5,5) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x56:
        CONCAT3(inner_loop,6,5) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
#endif
#if ((MAXJOB_SPECIAL>=6)&&(SHARP_MAXTRANS>=6))
      case 0x61:
        CONCAT3(inner_loop,1,6) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x62:
        CONCAT3(inner_loop,2,6) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x63:
        CONCAT3(inner_loop,3,6) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x64:
        CONCAT3(inner_loop,4,6) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x65:
        CONCAT3(inner_loop,5,6) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
      case 0x66:
        CONCAT3(inner_loop,6,6) (job, ispair,cth,sth,llim,ulim,gen,mi,mlim);
        return;
#endif
      }
    }
#if (SHARP_MAXTRANS>MAXJOB_SPECIAL)
  else
    {
    switch (nv)
      {
      case 1:
        CONCAT2(inner_loop,1)
          (job, ispair,cth,sth,llim,ulim,gen,mi,mlim,job->ntrans);
        return;
      case 2:
        CONCAT2(inner_loop,2)
          (job, ispair,cth,sth,llim,ulim,gen,mi,mlim,job->ntrans);
        return;
      case 3:
        CONCAT2(inner_loop,3)
          (job, ispair,cth,sth,llim,ulim,gen,mi,mlim,job->ntrans);
        return;
      case 4:
        CONCAT2(inner_loop,4)
          (job, ispair,cth,sth,llim,ulim,gen,mi,mlim,job->ntrans);
        return;
      case 5:
        CONCAT2(inner_loop,5)
          (job, ispair,cth,sth,llim,ulim,gen,mi,mlim,job->ntrans);
        return;
      case 6:
        CONCAT2(inner_loop,6)
          (job, ispair,cth,sth,llim,ulim,gen,mi,mlim,job->ntrans);
        return;
      }
    }
#endif
  UTIL_FAIL("Incorrect vector parameters");
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_core.h0000664000175000017500000000263013010375061026421 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_core.h
 *  Interface for the computational core
 *
 *  Copyright (C) 2012-2013 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SHARP_CORE_H
#define PLANCK_SHARP_CORE_H

#include "sharp_internal.h"
#include "sharp_ylmgen_c.h"

#ifdef __cplusplus
extern "C" {
#endif

void inner_loop (sharp_job *job, const int *ispair,const double *cth,
  const double *sth, int llim, int ulim, sharp_Ylmgen_C *gen, int mi,
  const int *mlim);

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_core_inc.c0000664000175000017500000002112113010375061027241 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_core_inc.c
 *  Type-dependent code for the computational core
 *
 *  Copyright (C) 2012 Max-Planck-Society
 *  \author Martin Reinecke
 */

typedef struct
  { Tv v[nvec]; } Tb;

typedef union
  { Tb b; double s[VLEN*nvec]; } Y(Tbu);

typedef struct
  { Tb r, i; } Y(Tbri);

typedef struct
  { Tb qr, qi, ur, ui; } Y(Tbqu);

typedef struct
  { double r[VLEN*nvec], i[VLEN*nvec]; } Y(Tsri);

typedef struct
  { double qr[VLEN*nvec],qi[VLEN*nvec],ur[VLEN*nvec],ui[VLEN*nvec]; } Y(Tsqu);

typedef union
  { Y(Tbri) b; Y(Tsri)s; } Y(Tburi);

typedef union
  { Y(Tbqu) b; Y(Tsqu)s; } Y(Tbuqu);

static inline Tb Y(Tbconst)(double val)
  {
  Tv v=vload(val);
  Tb res;
  for (int i=0; iv[i],v); }

static inline Tb Y(Tbprod)(Tb a, Tb b)
  { Tb r; for (int i=0; iv[i],b.v[i]); }

static void Y(Tbnormalize) (Tb * restrict val, Tb * restrict scale,
  double maxval)
  {
  const Tv vfsmall=vload(sharp_fsmall), vfbig=vload(sharp_fbig);
  const Tv vfmin=vload(sharp_fsmall*maxval), vfmax=vload(maxval);
  for (int i=0;iv[i]),vfmax);
    while (vanyTrue(mask))
      {
      vmuleq(val->v[i],vblend(mask,vfsmall,vone));
      vaddeq(scale->v[i],vblend(mask,vone,vzero));
      mask = vgt(vabs(val->v[i]),vfmax);
      }
    mask = vand(vlt(vabs(val->v[i]),vfmin),vne(val->v[i],vzero));
    while (vanyTrue(mask))
      {
      vmuleq(val->v[i],vblend(mask,vfbig,vone));
      vsubeq(scale->v[i],vblend(mask,vone,vzero));
      mask = vand(vlt(vabs(val->v[i]),vfmin),vne(val->v[i],vzero));
      }
    }
  }

static void Y(mypow) (Tb val, int npow, Tb * restrict resd,
  Tb * restrict ress)
  {
  Tb scale=Y(Tbconst)(0.), scaleint=Y(Tbconst)(0.), res=Y(Tbconst)(1.);

  Y(Tbnormalize)(&val,&scaleint,sharp_fbighalf);

  do
    {
    if (npow&1)
      {
      for (int i=0; i>=1);

  *resd=res;
  *ress=scale;
  }

static inline int Y(rescale) (Tb * restrict lam1, Tb * restrict lam2,
  Tb * restrict scale)
  {
  int did_scale=0;
  for (int i=0;iv[i]),vload(sharp_ftol));
    if (vanyTrue(mask))
      {
      did_scale=1;
      Tv fact = vblend(mask,vload(sharp_fsmall),vone);
      vmuleq(lam1->v[i],fact); vmuleq(lam2->v[i],fact);
      vaddeq(scale->v[i],vblend(mask,vone,vzero));
      }
    }
  return did_scale;
  }

static inline int Y(TballLt)(Tb a,double b)
  {
  Tv vb=vload(b);
  Tv res=vlt(a.v[0],vb);
  for (int i=1; im;
  Tb lam_1=Y(Tbconst)(0.), lam_2, scale;
  Y(mypow) (sth,l,&lam_2,&scale);
  Y(Tbmuleq1) (&lam_2,(gen->m&1) ? -gen->mfac[gen->m]:gen->mfac[gen->m]);
  Y(Tbnormalize)(&lam_2,&scale,sharp_ftol);

  int below_limit = Y(TballLt)(scale,sharp_limscale);
  while (below_limit)
    {
    if (l+2>gen->lmax) {*l_=gen->lmax+1;return;}
    Tv r0=vload(gen->rf[l].f[0]),r1=vload(gen->rf[l].f[1]);
    for (int i=0; irf[l+1].f[0]); r1=vload(gen->rf[l+1].f[1]);
    for (int i=0; iv[i] = vsub(vmul(vsub(cth.v[i],fx1),vmul(fx0,ryp->v[i])),
                vmul(fx2,rxp->v[i]));
    rxm->v[i] = vsub(vmul(vadd(cth.v[i],fx1),vmul(fx0,rym->v[i])),
                vmul(fx2,rxm->v[i]));
    }
  }

static void Y(iter_to_ieee_spin) (const Tb cth, const Tb sth, int *l_,
  Tb * rec1p_, Tb * rec1m_, Tb * rec2p_, Tb * rec2m_,
  Tb * scalep_, Tb * scalem_, const sharp_Ylmgen_C * restrict gen)
  {
  const sharp_ylmgen_dbl3 * restrict fx = gen->fx;
  Tb cth2, sth2;
  for (int i=0; icosPow,&ccp,&ccps); Y(mypow)(sth2,gen->sinPow,&ssp,&ssps);
  Y(mypow)(cth2,gen->sinPow,&csp,&csps); Y(mypow)(sth2,gen->cosPow,&scp,&scps);

  Tb rec2p, rec2m, scalep, scalem;
  Tb rec1p=Y(Tbconst)(0.), rec1m=Y(Tbconst)(0.);
  Tv prefac=vload(gen->prefac[gen->m]),
     prescale=vload(gen->fscale[gen->m]);
  for (int i=0; ipreMinus_p)
      rec2p.v[i]=vneg(rec2p.v[i]);
    if (gen->preMinus_m)
      rec2m.v[i]=vneg(rec2m.v[i]);
    if (gen->s&1)
      rec2p.v[i]=vneg(rec2p.v[i]);
    }
  Y(Tbnormalize)(&rec2m,&scalem,sharp_ftol);
  Y(Tbnormalize)(&rec2p,&scalep,sharp_ftol);

  int l=gen->mhi;

  int below_limit = Y(TballLt)(scalep,sharp_limscale)
                 && Y(TballLt)(scalem,sharp_limscale);
  while (below_limit)
    {
    if (l+2>gen->lmax) {*l_=gen->lmax+1;return;}
    Y(rec_step)(&rec1p,&rec1m,&rec2p,&rec2m,cth,fx[l+1]);
    Y(rec_step)(&rec2p,&rec2m,&rec1p,&rec1m,cth,fx[l+2]);
    if (Y(rescale)(&rec1p,&rec2p,&scalep) | Y(rescale)(&rec1m,&rec2m,&scalem))
      below_limit = Y(TballLt)(scalep,sharp_limscale)
                 && Y(TballLt)(scalem,sharp_limscale);
    l+=2;
    }

  *l_=l;
  *rec1p_=rec1p; *rec2p_=rec2p; *scalep_=scalep;
  *rec1m_=rec1m; *rec2m_=rec2m; *scalem_=scalem;
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_core_inc2.c0000664000175000017500000006461013010375061027335 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_core_inc2.c
 *  Type-dependent code for the computational core
 *
 *  Copyright (C) 2012-2013 Max-Planck-Society
 *  \author Martin Reinecke
 */

static void Z(alm2map_kernel) (const Tb cth, Y(Tbri) * restrict p1,
  Y(Tbri) * restrict p2, Tb lam_1, Tb lam_2,
  const sharp_ylmgen_dbl2 * restrict rf, const dcmplx * restrict alm,
  int l, int lmax NJ1)
  {
if (njobs>1)
  {
  while (llmax;
  Tb lam_1,lam_2,scale;
  Y(iter_to_ieee) (sth,cth,&l,&lam_1,&lam_2,&scale,gen);
  job->opcnt += (l-gen->m) * 4*VLEN*nvec;
  if (l>lmax) return;
  job->opcnt += (lmax+1-l) * (4+4*njobs)*VLEN*nvec;

  Tb corfac;
  Y(getCorfac)(scale,&corfac,gen->cf);
  const sharp_ylmgen_dbl2 * restrict rf = gen->rf;
  const dcmplx * restrict alm=job->almtmp;
  int full_ieee = Y(TballGe)(scale,sharp_minscale);
  while (!full_ieee)
    {
    for (int j=0; jlmax) break;
    Tv r0=vload(rf[l-1].f[0]),r1=vload(rf[l-1].f[1]);
    for (int i=0; ilmax) break;
    r0=vload(rf[l-1].f[0]); r1=vload(rf[l-1].f[1]);
    for (int i=0; icf);
      full_ieee = Y(TballGe)(scale,sharp_minscale);
      }
    }
  if (l>lmax) return;

  Y(Tbmuleq)(&lam_1,corfac); Y(Tbmuleq)(&lam_2,corfac);
  Z(alm2map_kernel) (cth, p1, p2, lam_1, lam_2, rf, alm, l, lmax NJ2);
  }

static void Z(calc_map2alm) (const Tb cth, const Tb sth,
  const sharp_Ylmgen_C *gen, sharp_job *job, const Y(Tbri) * restrict p1,
  const Y(Tbri) * restrict p2 NJ1)
  {
  int lmax=gen->lmax;
  Tb lam_1,lam_2,scale;
  int l=gen->m;
  Y(iter_to_ieee) (sth,cth,&l,&lam_1,&lam_2,&scale,gen);
  job->opcnt += (l-gen->m) * 4*VLEN*nvec;
  if (l>lmax) return;
  job->opcnt += (lmax+1-l) * (4+4*njobs)*VLEN*nvec;

  const sharp_ylmgen_dbl2 * restrict rf = gen->rf;
  Tb corfac;
  Y(getCorfac)(scale,&corfac,gen->cf);
  dcmplx * restrict alm=job->almtmp;
  int full_ieee = Y(TballGe)(scale,sharp_minscale);
  while (!full_ieee)
    {
    for (int j=0; jlmax) return;
    Tv r0=vload(rf[l-1].f[0]),r1=vload(rf[l-1].f[1]);
    for (int i=0; ilmax) return;
    r0=vload(rf[l-1].f[0]); r1=vload(rf[l-1].f[1]);
    for (int i=0; icf);
      full_ieee = Y(TballGe)(scale,sharp_minscale);
      }
    }

  Y(Tbmuleq)(&lam_1,corfac); Y(Tbmuleq)(&lam_2,corfac);
  Z(map2alm_kernel) (cth, p1, p2, lam_1, lam_2, rf, alm, l, lmax NJ2);
  }

static inline void Z(saddstep) (Y(Tbqu) * restrict px, Y(Tbqu) * restrict py,
  const Tb rxp, const Tb rxm, const dcmplx * restrict alm NJ1)
  {
  for (int j=0; jv[i],rxm->v[i]);
      vfmaeq(agr,px[j].qr.v[i],lw);
      vfmaeq(agi,px[j].qi.v[i],lw);
      vfmaeq(acr,px[j].ur.v[i],lw);
      vfmaeq(aci,px[j].ui.v[i],lw);
      }
    for (int i=0; iv[i],rxp->v[i]);
      vfmseq(agr,py[j].ui.v[i],lx);
      vfmaeq(agi,py[j].ur.v[i],lx);
      vfmaeq(acr,py[j].qi.v[i],lx);
      vfmseq(aci,py[j].qr.v[i],lx);
      }
    vhsum_cmplx2(agr,agi,acr,aci,&alm[2*j],&alm[2*j+1]);
    }
  }

static void Z(alm2map_spin_kernel) (Tb cth, Y(Tbqu) * restrict p1,
  Y(Tbqu) * restrict p2, Tb rec1p, Tb rec1m, Tb rec2p, Tb rec2m,
  const sharp_ylmgen_dbl3 * restrict fx, const dcmplx * restrict alm, int l,
  int lmax NJ1)
  {
  while (llmax;
  Tb rec1p, rec1m, rec2p, rec2m, scalem, scalep;
  Y(iter_to_ieee_spin)
    (cth,sth,&l,&rec1p,&rec1m,&rec2p,&rec2m,&scalep,&scalem,gen);
  job->opcnt += (l-gen->m) * 10*VLEN*nvec;
  if (l>lmax) return;
  job->opcnt += (lmax+1-l) * (12+16*njobs)*VLEN*nvec;

  const sharp_ylmgen_dbl3 * restrict fx = gen->fx;
  Tb corfacp,corfacm;
  Y(getCorfac)(scalep,&corfacp,gen->cf);
  Y(getCorfac)(scalem,&corfacm,gen->cf);
  const dcmplx * restrict alm=job->almtmp;
  int full_ieee = Y(TballGe)(scalep,sharp_minscale)
               && Y(TballGe)(scalem,sharp_minscale);
  while (!full_ieee)
    {
    Z(saddstep)(p1, p2, Y(Tbprod)(rec2p,corfacp), Y(Tbprod)(rec2m,corfacm),
      &alm[2*njobs*l] NJ2);
    if (++l>lmax) break;
    Y(rec_step)(&rec1p,&rec1m,&rec2p,&rec2m,cth,fx[l]);
    Z(saddstep)(p2, p1, Y(Tbprod)(rec1p,corfacp), Y(Tbprod)(rec1m,corfacm),
      &alm[2*njobs*l] NJ2);
    if (++l>lmax) break;
    Y(rec_step)(&rec2p,&rec2m,&rec1p,&rec1m,cth,fx[l]);
    if (Y(rescale)(&rec1p,&rec2p,&scalep) | Y(rescale)(&rec1m,&rec2m,&scalem))
      {
      Y(getCorfac)(scalep,&corfacp,gen->cf);
      Y(getCorfac)(scalem,&corfacm,gen->cf);
      full_ieee = Y(TballGe)(scalep,sharp_minscale)
               && Y(TballGe)(scalem,sharp_minscale);
      }
    }

  if (l>lmax) return;

  Y(Tbmuleq)(&rec1p,corfacp); Y(Tbmuleq)(&rec2p,corfacp);
  Y(Tbmuleq)(&rec1m,corfacm); Y(Tbmuleq)(&rec2m,corfacm);
  Z(alm2map_spin_kernel) (cth, p1, p2, rec1p, rec1m, rec2p, rec2m, fx, alm, l,
    lmax NJ2);
  }

static void Z(calc_map2alm_spin) (Tb cth, Tb sth,
  const sharp_Ylmgen_C * restrict gen, sharp_job *job,
  const Y(Tbqu) * restrict p1, const Y(Tbqu) * restrict p2 NJ1)
  {
  int l, lmax=gen->lmax;
  Tb rec1p, rec1m, rec2p, rec2m, scalem, scalep;
  Y(iter_to_ieee_spin)
    (cth,sth,&l,&rec1p,&rec1m,&rec2p,&rec2m,&scalep,&scalem,gen);
  job->opcnt += (l-gen->m) * 10*VLEN*nvec;
  if (l>lmax) return;
  job->opcnt += (lmax+1-l) * (12+16*njobs)*VLEN*nvec;

  const sharp_ylmgen_dbl3 * restrict fx = gen->fx;
  Tb corfacp,corfacm;
  Y(getCorfac)(scalep,&corfacp,gen->cf);
  Y(getCorfac)(scalem,&corfacm,gen->cf);
  dcmplx * restrict alm=job->almtmp;
  int full_ieee = Y(TballGe)(scalep,sharp_minscale)
               && Y(TballGe)(scalem,sharp_minscale);
  while (!full_ieee)
    {
    Tb t1=Y(Tbprod)(rec2p,corfacp), t2=Y(Tbprod)(rec2m,corfacm);
    Z(saddstep2)(p1, p2, &t1, &t2, &alm[2*njobs*l] NJ2);
    if (++l>lmax) return;
    Y(rec_step)(&rec1p,&rec1m,&rec2p,&rec2m,cth,fx[l]);
    t1=Y(Tbprod)(rec1p,corfacp); t2=Y(Tbprod)(rec1m,corfacm);
    Z(saddstep2)(p2, p1, &t1, &t2, &alm[2*njobs*l] NJ2);
    if (++l>lmax) return;
    Y(rec_step)(&rec2p,&rec2m,&rec1p,&rec1m,cth,fx[l]);
    if (Y(rescale)(&rec1p,&rec2p,&scalep) | Y(rescale)(&rec1m,&rec2m,&scalem))
      {
      Y(getCorfac)(scalep,&corfacp,gen->cf);
      Y(getCorfac)(scalem,&corfacm,gen->cf);
      full_ieee = Y(TballGe)(scalep,sharp_minscale)
               && Y(TballGe)(scalem,sharp_minscale);
      }
    }

  Y(Tbmuleq)(&rec1p,corfacp); Y(Tbmuleq)(&rec2p,corfacp);
  Y(Tbmuleq)(&rec1m,corfacm); Y(Tbmuleq)(&rec2m,corfacm);
  Z(map2alm_spin_kernel)(cth,p1,p2,rec1p,rec1m,rec2p,rec2m,fx,alm,l,lmax NJ2);
  }

static inline void Z(saddstep_d) (Y(Tbqu) * restrict px, Y(Tbqu) * restrict py,
  const Tb rxp, const Tb rxm, const dcmplx * restrict alm NJ1)
  {
  for (int j=0; jlmax;
  Tb rec1p, rec1m, rec2p, rec2m, scalem, scalep;
  Y(iter_to_ieee_spin)
    (cth,sth,&l,&rec1p,&rec1m,&rec2p,&rec2m,&scalep,&scalem,gen);
  job->opcnt += (l-gen->m) * 10*VLEN*nvec;
  if (l>lmax) return;
  job->opcnt += (lmax+1-l) * (12+8*njobs)*VLEN*nvec;

  const sharp_ylmgen_dbl3 * restrict fx = gen->fx;
  Tb corfacp,corfacm;
  Y(getCorfac)(scalep,&corfacp,gen->cf);
  Y(getCorfac)(scalem,&corfacm,gen->cf);
  const dcmplx * restrict alm=job->almtmp;
  int full_ieee = Y(TballGe)(scalep,sharp_minscale)
               && Y(TballGe)(scalem,sharp_minscale);
  while (!full_ieee)
    {
    Z(saddstep_d)(p1, p2, Y(Tbprod)(rec2p,corfacp), Y(Tbprod)(rec2m,corfacm),
      &alm[njobs*l] NJ2);
    if (++l>lmax) break;
    Y(rec_step)(&rec1p,&rec1m,&rec2p,&rec2m,cth,fx[l]);
    Z(saddstep_d)(p2, p1, Y(Tbprod)(rec1p,corfacp), Y(Tbprod)(rec1m,corfacm),
      &alm[njobs*l] NJ2);
    if (++l>lmax) break;
    Y(rec_step)(&rec2p,&rec2m,&rec1p,&rec1m,cth,fx[l]);
    if (Y(rescale)(&rec1p,&rec2p,&scalep) | Y(rescale)(&rec1m,&rec2m,&scalem))
      {
      Y(getCorfac)(scalep,&corfacp,gen->cf);
      Y(getCorfac)(scalem,&corfacm,gen->cf);
      full_ieee = Y(TballGe)(scalep,sharp_minscale)
               && Y(TballGe)(scalem,sharp_minscale);
      }
    }

  if (l>lmax) return;

  Y(Tbmuleq)(&rec1p,corfacp); Y(Tbmuleq)(&rec2p,corfacp);
  Y(Tbmuleq)(&rec1m,corfacm); Y(Tbmuleq)(&rec2m,corfacm);
  Z(alm2map_deriv1_kernel) (cth, p1, p2, rec1p, rec1m, rec2p, rec2m, fx, alm, l,
    lmax NJ2);
  }


#define VZERO(var) do { memset(&(var),0,sizeof(var)); } while(0)

static void Z(inner_loop) (sharp_job *job, const int *ispair,
  const double *cth_, const double *sth_, int llim, int ulim,
  sharp_Ylmgen_C *gen, int mi, const int *mlim NJ1)
  {
  const int nval=nvec*VLEN;
  const int m = job->ainfo->mval[mi];
  sharp_Ylmgen_prepare (gen, m);

  switch (job->type)
    {
    case SHARP_ALM2MAP:
    case SHARP_ALM2MAP_DERIV1:
      {
      if (job->spin==0)
        {
        for (int ith=0; ith=ulim-llim) itot=ulim-llim-1;
            if (mlim[itot]>=m) skip=0;
            cth.s[i]=cth_[itot]; sth.s[i]=sth_[itot];
            }
          if (!skip)
            Z(calc_alm2map) (cth.b,sth.b,gen,job,&p1[0].b,&p2[0].b NJ2);

          for (int i=0; is_th + mi*job->s_m + 2*j;
                complex double r1 = p1[j].s.r[i] + p1[j].s.i[i]*_Complex_I,
                               r2 = p2[j].s.r[i] + p2[j].s.i[i]*_Complex_I;
                job->phase[phas_idx] = r1+r2;
                if (ispair[itot])
                  job->phase[phas_idx+1] = r1-r2;
                }
              }
            }
          }
        }
      else
        {
        for (int ith=0; ith=ulim-llim) itot=ulim-llim-1;
            if (mlim[itot]>=m) skip=0;
            cth.s[i]=cth_[itot]; sth.s[i]=sth_[itot];
            }
          if (!skip)
            (job->type==SHARP_ALM2MAP) ?
              Z(calc_alm2map_spin  )
                (cth.b,sth.b,gen,job,&p1[0].b,&p2[0].b NJ2) :
              Z(calc_alm2map_deriv1)
                (cth.b,sth.b,gen,job,&p1[0].b,&p2[0].b NJ2);

          for (int i=0; is_th + mi*job->s_m + 4*j;
                complex double q1 = p1[j].s.qr[i] + p1[j].s.qi[i]*_Complex_I,
                               q2 = p2[j].s.qr[i] + p2[j].s.qi[i]*_Complex_I,
                               u1 = p1[j].s.ur[i] + p1[j].s.ui[i]*_Complex_I,
                               u2 = p2[j].s.ur[i] + p2[j].s.ui[i]*_Complex_I;
                job->phase[phas_idx] = q1+q2;
                job->phase[phas_idx+2] = u1+u2;
                if (ispair[itot])
                  {
                  dcmplx *phQ = &(job->phase[phas_idx+1]),
                         *phU = &(job->phase[phas_idx+3]);
                  *phQ = q1-q2;
                  *phU = u1-u2;
                  if ((gen->mhi-gen->m+gen->s)&1)
                    { *phQ=-(*phQ); *phU=-(*phU); }
                  }
                }
              }
            }
          }
        }
      break;
      }
    case SHARP_MAP2ALM:
      {
      if (job->spin==0)
        {
        for (int ith=0; ith=ulim-llim) itot=ulim-llim-1;
            if (mlim[itot]>=m) skip=0;
            cth.s[i]=cth_[itot]; sth.s[i]=sth_[itot];
            if ((i+ith=m))
              {
              for (int j=0; js_th + mi*job->s_m + 2*j;
                dcmplx ph1=job->phase[phas_idx];
                dcmplx ph2=ispair[itot] ? job->phase[phas_idx+1] : 0.;
                p1[j].s.r[i]=creal(ph1+ph2); p1[j].s.i[i]=cimag(ph1+ph2);
                p2[j].s.r[i]=creal(ph1-ph2); p2[j].s.i[i]=cimag(ph1-ph2);
                }
              }
            }
          if (!skip)
            Z(calc_map2alm)(cth.b,sth.b,gen,job,&p1[0].b,&p2[0].b NJ2);
          }
        }
      else
        {
        for (int ith=0; ith=ulim-llim) itot=ulim-llim-1;
            if (mlim[itot]>=m) skip=0;
            cth.s[i]=cth_[itot]; sth.s[i]=sth_[itot];
            if (i+iths_th + mi*job->s_m + 4*j;
                dcmplx p1Q=job->phase[phas_idx],
                       p1U=job->phase[phas_idx+2],
                       p2Q=ispair[itot] ? job->phase[phas_idx+1]:0.,
                       p2U=ispair[itot] ? job->phase[phas_idx+3]:0.;
                if ((gen->mhi-gen->m+gen->s)&1)
                  { p2Q=-p2Q; p2U=-p2U; }
                p1[j].s.qr[i]=creal(p1Q+p2Q); p1[j].s.qi[i]=cimag(p1Q+p2Q);
                p1[j].s.ur[i]=creal(p1U+p2U); p1[j].s.ui[i]=cimag(p1U+p2U);
                p2[j].s.qr[i]=creal(p1Q-p2Q); p2[j].s.qi[i]=cimag(p1Q-p2Q);
                p2[j].s.ur[i]=creal(p1U-p2U); p2[j].s.ui[i]=cimag(p1U-p2U);
                }
              }
            }
          if (!skip)
            Z(calc_map2alm_spin) (cth.b,sth.b,gen,job,&p1[0].b,&p2[0].b NJ2);
          }
        }
      break;
      }
    default:
      {
      UTIL_FAIL("must not happen");
      break;
      }
    }
  }

#undef VZERO
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_core_inchelper.c0000664000175000017500000000243013010375061030443 0ustar  zoncazonca00000000000000#define Tb CONCAT2(Tb,nvec)
#define Y(arg) CONCAT2(arg,nvec)
#include "sharp_core_inc.c"

#if (SHARP_MAXTRANS>MAXJOB_SPECIAL)
#define NJ1 , int njobs
#define NJ2 , njobs
#define Z(arg) CONCAT2(arg,nvec)
#include "sharp_core_inc2.c"
#undef Z
#undef NJ1
#undef NJ2
#endif

#define NJ1
#define NJ2

#if ((MAXJOB_SPECIAL>=1)&&(SHARP_MAXTRANS>=1))
#define njobs 1
#define Z(arg) CONCAT3(arg,nvec,njobs)
#include "sharp_core_inc2.c"
#undef Z
#undef njobs
#endif

#if ((MAXJOB_SPECIAL>=2)&&(SHARP_MAXTRANS>=2))
#define njobs 2
#define Z(arg) CONCAT3(arg,nvec,njobs)
#include "sharp_core_inc2.c"
#undef Z
#undef njobs
#endif

#if ((MAXJOB_SPECIAL>=3)&&(SHARP_MAXTRANS>=3))
#define njobs 3
#define Z(arg) CONCAT3(arg,nvec,njobs)
#include "sharp_core_inc2.c"
#undef Z
#undef njobs
#endif

#if ((MAXJOB_SPECIAL>=4)&&(SHARP_MAXTRANS>=4))
#define njobs 4
#define Z(arg) CONCAT3(arg,nvec,njobs)
#include "sharp_core_inc2.c"
#undef Z
#undef njobs
#endif

#if ((MAXJOB_SPECIAL>=5)&&(SHARP_MAXTRANS>=5))
#define njobs 5
#define Z(arg) CONCAT3(arg,nvec,njobs)
#include "sharp_core_inc2.c"
#undef Z
#undef njobs
#endif

#if ((MAXJOB_SPECIAL>=6)&&(SHARP_MAXTRANS>=6))
#define njobs 6
#define Z(arg) CONCAT3(arg,nvec,njobs)
#include "sharp_core_inc2.c"
#undef Z
#undef njobs
#endif

#undef NJ1
#undef NJ2

#undef Y
#undef Tb
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_cxx.h0000664000175000017500000001523513010375061026300 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_cxx.h
 *  Spherical transform library
 *
 *  Copyright (C) 2012-2015 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SHARP_CXX_H
#define PLANCK_SHARP_CXX_H

#include 
#include "sharp_lowlevel.h"
#include "sharp_geomhelpers.h"
#include "sharp_almhelpers.h"

class sharp_base
  {
  protected:
    sharp_alm_info *ainfo;
    sharp_geom_info *ginfo;

  public:
    sharp_base()
      : ainfo(0), ginfo(0) {}
    ~sharp_base()
      {
      sharp_destroy_geom_info(ginfo);
      sharp_destroy_alm_info(ainfo);
      }

    void set_general_geometry (int nrings, const int *nph, const ptrdiff_t *ofs,
      const int *stride, const double *phi0, const double *theta,
      const double *wgt)
      {
      if (ginfo) sharp_destroy_geom_info(ginfo);
      sharp_make_geom_info (nrings, nph, ofs, stride, phi0, theta, wgt, &ginfo);
      }

    void set_ECP_geometry (int nrings, int nphi)
      {
      if (ginfo) sharp_destroy_geom_info(ginfo);
      sharp_make_ecp_geom_info (nrings, nphi, 0., 1, nphi, &ginfo);
      }

    void set_Gauss_geometry (int nrings, int nphi)
      {
      if (ginfo) sharp_destroy_geom_info(ginfo);
      sharp_make_gauss_geom_info (nrings, nphi, 0., 1, nphi, &ginfo);
      }

    void set_Healpix_geometry (int nside)
      {
      if (ginfo) sharp_destroy_geom_info(ginfo);
      sharp_make_healpix_geom_info (nside, 1, &ginfo);
      }

    void set_weighted_Healpix_geometry (int nside, const double *weight)
      {
      if (ginfo) sharp_destroy_geom_info(ginfo);
      sharp_make_weighted_healpix_geom_info (nside, 1, weight, &ginfo);
      }

    void set_triangular_alm_info (int lmax, int mmax)
      {
      if (ainfo) sharp_destroy_alm_info(ainfo);
      sharp_make_triangular_alm_info (lmax, mmax, 1, &ainfo);
      }

    const sharp_geom_info* get_geom_info() const { return ginfo; }
    const sharp_alm_info* get_alm_info() const { return ainfo; }
  };

template struct cxxjobhelper__ {};

template<> struct cxxjobhelper__
  { enum {val=SHARP_DP}; };

template<> struct cxxjobhelper__
  { enum {val=0}; };


template class sharp_cxxjob: public sharp_base
  {
  private:
    static void *conv (T *ptr)
      { return reinterpret_cast(ptr); }
    static void *conv (std::complex *ptr)
      { return reinterpret_cast(ptr); }
    static void *conv (const T *ptr)
      { return const_cast(reinterpret_cast(ptr)); }
    static void *conv (const std::complex *ptr)
      { return const_cast(reinterpret_cast(ptr)); }

  public:
    void alm2map (const T *alm, T *map, bool add)
      {
      void *aptr=conv(alm), *mptr=conv(map);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_ALM2MAP, 0, &aptr, &mptr, ginfo, ainfo, 1,
        flags,0,0);
      }
    void alm2map (const std::complex *alm, T *map, bool add)
      {
      void *aptr=conv(alm), *mptr=conv(map);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_ALM2MAP, 0, &aptr, &mptr, ginfo, ainfo, 1,
        flags,0,0);
      }
    void alm2map_spin (const T *alm1, const T *alm2,
      T *map1, T *map2, int spin, bool add)
      {
      void *aptr[2], *mptr[2];
      aptr[0]=conv(alm1); aptr[1]=conv(alm2);
      mptr[0]=conv(map1); mptr[1]=conv(map2);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_ALM2MAP,spin,aptr,mptr,ginfo,ainfo,1,flags,0,0);
      }
    void alm2map_spin (const std::complex *alm1, const std::complex *alm2,
      T *map1, T *map2, int spin, bool add)
      {
      void *aptr[2], *mptr[2];
      aptr[0]=conv(alm1); aptr[1]=conv(alm2);
      mptr[0]=conv(map1); mptr[1]=conv(map2);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_ALM2MAP,spin,aptr,mptr,ginfo,ainfo,1,flags,0,0);
      }
    void alm2map_der1 (const T *alm, T *map1, T *map2, bool add)
      {
      void *aptr=conv(alm), *mptr[2];
      mptr[0]=conv(map1); mptr[1]=conv(map2);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_ALM2MAP_DERIV1,1,&aptr,mptr,ginfo,ainfo,1,flags,0,0);
      }
    void alm2map_der1 (const std::complex *alm, T *map1, T *map2, bool add)
      {
      void *aptr=conv(alm), *mptr[2];
      mptr[0]=conv(map1); mptr[1]=conv(map2);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_ALM2MAP_DERIV1,1,&aptr,mptr,ginfo,ainfo,1,flags,0,0);
      }
    void map2alm (const T *map, T *alm, bool add)
      {
      void *aptr=conv(alm), *mptr=conv(map);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_MAP2ALM,0,&aptr,&mptr,ginfo,ainfo,1,flags,0,0);
      }
    void map2alm (const T *map, std::complex *alm, bool add)
      {
      void *aptr=conv(alm), *mptr=conv(map);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_MAP2ALM,0,&aptr,&mptr,ginfo,ainfo,1,flags,0,0);
      }
    void map2alm_spin (const T *map1, const T *map2, T *alm1, T *alm2,
      int spin, bool add)
      {
      void *aptr[2], *mptr[2];
      aptr[0]=conv(alm1); aptr[1]=conv(alm2);
      mptr[0]=conv(map1); mptr[1]=conv(map2);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_MAP2ALM,spin,aptr,mptr,ginfo,ainfo,1,flags,0,0);
      }
    void map2alm_spin (const T *map1, const T *map2, std::complex *alm1,
      std::complex *alm2, int spin, bool add)
      {
      void *aptr[2], *mptr[2];
      aptr[0]=conv(alm1); aptr[1]=conv(alm2);
      mptr[0]=conv(map1); mptr[1]=conv(map2);
      int flags=cxxjobhelper__::val | (add ? SHARP_ADD : 0);
      sharp_execute (SHARP_MAP2ALM,spin,aptr,mptr,ginfo,ainfo,1,flags,0,0);
      }
  };

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_geomhelpers.c0000664000175000017500000002430413010375061030000 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_geomhelpers.c
 *  Spherical transform library
 *
 *  Copyright (C) 2006-2012 Max-Planck-Society
    
 *  Copyright (C) 2007-2008 Pavel Holoborodko (for gauss_legendre_tbl)
 *  \author Martin Reinecke \author Pavel Holoborodko
 */

#include 
#include "sharp_geomhelpers.h"
#include "c_utils.h"
#include "ls_fft.h"

void sharp_make_weighted_healpix_geom_info (int nside, int stride,
  const double *weight, sharp_geom_info **geom_info)
  {
  const double pi=3.141592653589793238462643383279502884197;
  ptrdiff_t npix=(ptrdiff_t)nside*nside*12;
  ptrdiff_t ncap=2*(ptrdiff_t)nside*(nside-1);
  int nrings=4*nside-1;

  double *theta=RALLOC(double,nrings);
  double *weight_=RALLOC(double,nrings);
  int *nph=RALLOC(int,nrings);
  double *phi0=RALLOC(double,nrings);
  ptrdiff_t *ofs=RALLOC(ptrdiff_t,nrings);
  int *stride_=RALLOC(int,nrings);
  for (int m=0; m2*nside) ? 4*nside-ring : ring;
    stride_[m] = stride;
    if (northring < nside)
      {
      theta[m] = 2*asin(northring/(sqrt(6.)*nside));
      nph[m] = 4*northring;
      phi0[m] = pi/nph[m];
      ofs[m] = 2*northring*(northring-1)*stride;
      }
    else
      {
      double fact1 = (8.*nside)/npix;
      double costheta = (2*nside-northring)*fact1;
      theta[m] = acos(costheta);
      nph[m] = 4*nside;
      if ((northring-nside) & 1)
        phi0[m] = 0;
      else
        phi0[m] = pi/nph[m];
      ofs[m] = (ncap + (northring-nside)*nph[m])*stride;
      }
    if (northring != ring) /* southern hemisphere */
      {
      theta[m] = pi-theta[m];
      ofs[m] = (npix - nph[m])*stride - ofs[m];
      }
    weight_[m]=4.*pi/npix*((weight==NULL) ? 1. : weight[northring-1]);
    }

  sharp_make_geom_info (nrings, nph, ofs, stride_, phi0, theta, weight_,
    geom_info);

  DEALLOC(theta);
  DEALLOC(weight_);
  DEALLOC(nph);
  DEALLOC(phi0);
  DEALLOC(ofs);
  DEALLOC(stride_);
  }

static inline double one_minus_x2 (double x)
  { return (fabs(x)>0.1) ? (1.+x)*(1.-x) : 1.-x*x; }

/* Function adapted from GNU GSL file glfixed.c
   Original author: Pavel Holoborodko (http://www.holoborodko.com)

   Adjustments by M. Reinecke
    - adjusted interface (keep epsilon internal, return full number of points)
    - removed precomputed tables
    - tweaked Newton iteration to obtain higher accuracy */
static void gauss_legendre_tbl(int n, double *x, double *w)
  {
  const double pi = 3.141592653589793238462643383279502884197;
  const double eps = 3e-14;
  int m = (n+1)>>1;

  double t0 = 1 - (1-1./n) / (8.*n*n);
  double t1 = 1./(4.*n+2.);

#pragma omp parallel
{
  int i;
#pragma omp for schedule(dynamic,100)
  for (i=1; i<=m; ++i)
    {
    double x0 = cos(pi * ((i<<2)-1) * t1) * t0;

    int dobreak=0;
    int j=0;
    double dpdx;
    while(1)
      {
      double P_1 = 1.0;
      double P0 = x0;
      double dx, x1;

      for (int k=2; k<=n; k++)
        {
        double P_2 = P_1;
        P_1 = P0;
//        P0 = ((2*k-1)*x0*P_1-(k-1)*P_2)/k;
        P0 = x0*P_1 + (k-1.)/k * (x0*P_1-P_2);
        }

      dpdx = (P_1 - x0*P0) * n / one_minus_x2(x0);

      /* Newton step */
      x1 = x0 - P0/dpdx;
      dx = x0-x1;
      x0 = x1;
      if (dobreak) break;

      if (fabs(dx)<=eps) dobreak=1;
      UTIL_ASSERT(++j<100,"convergence problem");
      }

    x[i-1] = -x0;
    x[n-i] = x0;
    w[i-1] = w[n-i] = 2. / (one_minus_x2(x0) * dpdx * dpdx);
    }
} // end of parallel region
  }

void sharp_make_gauss_geom_info (int nrings, int nphi, double phi0,
  int stride_lon, int stride_lat, sharp_geom_info **geom_info)
  {
  const double pi=3.141592653589793238462643383279502884197;

  double *theta=RALLOC(double,nrings);
  double *weight=RALLOC(double,nrings);
  int *nph=RALLOC(int,nrings);
  double *phi0_=RALLOC(double,nrings);
  ptrdiff_t *ofs=RALLOC(ptrdiff_t,nrings);
  int *stride_=RALLOC(int,nrings);

  gauss_legendre_tbl(nrings,theta,weight);
  for (int m=0; mpi-1e-15) theta[m]=pi-1e-15;
    nph[m]=ppring;
    phi0_[m]=phi0;
    ofs[m]=(ptrdiff_t)m*stride_lat;
    stride_[m]=stride_lon;
    }

  sharp_make_geom_info (nrings, nph, ofs, stride_, phi0_, theta, NULL,
    geom_info);

  DEALLOC(theta);
  DEALLOC(nph);
  DEALLOC(phi0_);
  DEALLOC(ofs);
  DEALLOC(stride_);
  }
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_geomhelpers.h0000664000175000017500000001447213010375061030012 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_geomhelpers.h
 *  SHARP helper function for the creation of grid geometries
 *
 *  Copyright (C) 2006-2013 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef PLANCK_SHARP_GEOMHELPERS_H
#define PLANCK_SHARP_GEOMHELPERS_H

#include "sharp_lowlevel.h"

#ifdef __cplusplus
extern "C" {
#endif

/*! Creates a geometry information describing a HEALPix map with an
    Nside parameter \a nside. \a weight contains the relative ring
    weights and must have \a 2*nside entries.
    \note if \a weight is a null pointer, all weights are assumed to be 1.
    \ingroup geominfogroup */
void sharp_make_weighted_healpix_geom_info (int nside, int stride,
  const double *weight, sharp_geom_info **geom_info);

/*! Creates a geometry information describing a HEALPix map with an
    Nside parameter \a nside.
    \ingroup geominfogroup */
static inline void sharp_make_healpix_geom_info (int nside, int stride,
  sharp_geom_info **geom_info)
  { sharp_make_weighted_healpix_geom_info (nside, stride, NULL, geom_info); }

/*! Creates a geometry information describing a Gaussian map with \a nrings
    iso-latitude rings and \a nphi pixels per ring. The azimuth of the first
    pixel in each ring is \a phi0 (in radians). The index difference between
    two adjacent pixels in an iso-latitude ring is \a stride_lon, the index
    difference between the two start pixels in consecutive iso-latitude rings
    is \a stride_lat.
    \ingroup geominfogroup */
void sharp_make_gauss_geom_info (int nrings, int nphi, double phi0,
  int stride_lon, int stride_lat, sharp_geom_info **geom_info);

/*! Creates a geometry information describing an ECP map with \a nrings
    iso-latitude rings and \a nphi pixels per ring. The azimuth of the first
    pixel in each ring is \a phi0 (in radians). The index difference between
    two adjacent pixels in an iso-latitude ring is \a stride_lon, the index
    difference between the two start pixels in consecutive iso-latitude rings
    is \a stride_lat.
    \note The spacing of pixel centers is equidistant in colatitude and
      longitude.
    \note The sphere is pixelized in a way that the colatitude of the first ring
      is \a 0.5*(pi/nrings) and the colatitude of the last ring is
      \a pi-0.5*(pi/nrings). There are no pixel centers at the poles.
    \note This grid corresponds to Fejer's first rule.
    \ingroup geominfogroup */
void sharp_make_fejer1_geom_info (int nrings, int nphi, double phi0,
  int stride_lon, int stride_lat, sharp_geom_info **geom_info);

/*! Old name for sharp_make_fejer1_geom_info()
    \ingroup geominfogroup */
static inline void sharp_make_ecp_geom_info (int nrings, int nphi, double phi0,
  int stride_lon, int stride_lat, sharp_geom_info **geom_info)
  {
  sharp_make_fejer1_geom_info (nrings, nphi, phi0, stride_lon, stride_lat,
  geom_info);
  }

/*! Creates a geometry information describing an ECP map with \a nrings
    iso-latitude rings and \a nphi pixels per ring. The azimuth of the first
    pixel in each ring is \a phi0 (in radians). The index difference between
    two adjacent pixels in an iso-latitude ring is \a stride_lon, the index
    difference between the two start pixels in consecutive iso-latitude rings
    is \a stride_lat.
    \note The spacing of pixel centers is equidistant in colatitude and
      longitude.
    \note The sphere is pixelized in a way that the colatitude of the first ring
      is \a 0 and that of the last ring is \a pi.
    \note This grid corresponds to Clenshaw-Curtis integration.
    \ingroup geominfogroup */
void sharp_make_cc_geom_info (int nrings, int ppring, double phi0,
  int stride_lon, int stride_lat, sharp_geom_info **geom_info);

/*! Creates a geometry information describing an ECP map with \a nrings
    iso-latitude rings and \a nphi pixels per ring. The azimuth of the first
    pixel in each ring is \a phi0 (in radians). The index difference between
    two adjacent pixels in an iso-latitude ring is \a stride_lon, the index
    difference between the two start pixels in consecutive iso-latitude rings
    is \a stride_lat.
    \note The spacing of pixel centers is equidistant in colatitude and
      longitude.
    \note The sphere is pixelized in a way that the colatitude of the first ring
      is \a pi/(nrings+1) and that of the last ring is \a pi-pi/(nrings+1).
    \note This grid corresponds to Fejer's second rule.
    \ingroup geominfogroup */
void sharp_make_fejer2_geom_info (int nrings, int ppring, double phi0,
  int stride_lon, int stride_lat, sharp_geom_info **geom_info);

/*! Creates a geometry information describing a map with \a nrings
    iso-latitude rings and \a nphi pixels per ring. The azimuth of the first
    pixel in each ring is \a phi0 (in radians). The index difference between
    two adjacent pixels in an iso-latitude ring is \a stride_lon, the index
    difference between the two start pixels in consecutive iso-latitude rings
    is \a stride_lat.
    \note The spacing of pixel centers is equidistant in colatitude and
      longitude.
    \note The sphere is pixelized in a way that the colatitude of the first ring
      is \a pi/(2*nrings-1) and that of the last ring is \a pi.
    \note This is the grid introduced by McEwen & Wiaux 2011.
    \note This function does \e not define any quadrature weights.
    \ingroup geominfogroup */
void sharp_make_mw_geom_info (int nrings, int ppring, double phi0,
  int stride_lon, int stride_lat, sharp_geom_info **geom_info);

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_internal.h0000664000175000017500000000353613010375061027313 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_internal.h
 *  Internally used functionality for the spherical transform library.
 *
 *  Copyright (C) 2006-2013 Max-Planck-Society
 *  \author Martin Reinecke \author Dag Sverre Seljebotn
 */

#ifndef PLANCK_SHARP_INTERNAL_H
#define PLANCK_SHARP_INTERNAL_H

#ifdef __cplusplus
#error This header file cannot be included from C++, only from C
#endif

#include "sharp.h"

#define SHARP_MAXTRANS 100

typedef struct
  {
  sharp_jobtype type;
  int spin;
  int nmaps, nalm;
  int flags;
  void **map;
  void **alm;
  int s_m, s_th; // strides in m and theta direction
  complex double *phase;
  double *norm_l;
  complex double *almtmp;
  const sharp_geom_info *ginfo;
  const sharp_alm_info *ainfo;
  double time;
  int ntrans;
  unsigned long long opcnt;
  } sharp_job;

int sharp_get_nv_max (void);
int sharp_nv_oracle (sharp_jobtype type, int spin, int ntrans);
int sharp_get_mlim (int lmax, int spin, double sth, double cth);

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_lowlevel.h0000664000175000017500000002305513010375061027326 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_lowlevel.h
 *  Low-level, portable interface for the spherical transform library.
 *
 *  Copyright (C) 2012-2013 Max-Planck-Society
 *  \author Martin Reinecke \author Dag Sverre Seljebotn
 */

#ifndef PLANCK_SHARP_LOWLEVEL_H
#define PLANCK_SHARP_LOWLEVEL_H

#include 

#ifdef __cplusplus
extern "C" {
#endif

/*! \internal
    Helper type containing information about a single ring. */
typedef struct
  {
  double theta, phi0, weight, cth, sth;
  ptrdiff_t ofs;
  int nph, stride;
  } sharp_ringinfo;

/*! \internal
    Helper type containing information about a pair of rings with colatitudes
    symmetric around the equator. */
typedef struct
  {
  sharp_ringinfo r1,r2;
  } sharp_ringpair;

/*! \internal
    Type holding all required information about a map geometry. */
typedef struct
  {
  sharp_ringpair *pair;
  int npairs, nphmax;
  } sharp_geom_info;

/*! \defgroup almgroup Helpers for dealing with a_lm */
/*! \{ */

/*! \internal
    Helper type for index calculation in a_lm arrays. */
typedef struct
  {
  /*! Maximum \a l index of the array */
  int lmax;
  /*! Number of different \a m values in this object */
  int nm;
  /*! Array with \a nm entries containing the individual m values */
  int *mval;
  /*! Combination of flags from sharp_almflags */
  int flags;
  /*! Array with \a nm entries containing the (hypothetical) indices of
      the coefficients with quantum numbers 0,\a mval[i] */
  ptrdiff_t *mvstart;
  /*! Stride between a_lm and a_(l+1),m */
  ptrdiff_t stride;
  } sharp_alm_info;

/*! alm_info flags */
typedef enum { SHARP_PACKED = 1
               /*< m=0-coefficients are packed so that the (zero) imaginary part is
                   not present. mvstart is in units of *real* float/double for all
                   m; stride is in units of reals for m=0 and complex for m!=0 */
             } sharp_almflags;



/*! Creates an a_lm data structure from the following parameters:
    \param lmax maximum \a l quantum number (>=0)
    \param mmax maximum \a m quantum number (0<= \a mmax <= \a lmax)
    \param stride the stride between entries with identical \a m, and \a l
      differing by 1.
    \param mstart the index of the (hypothetical) coefficient with the
      quantum numbers 0,\a m. Must have \a mmax+1 entries.
    \param alm_info will hold a pointer to the newly created data structure
 */
void sharp_make_alm_info (int lmax, int mmax, int stride,
  const ptrdiff_t *mstart, sharp_alm_info **alm_info);
/*! Creates an a_lm data structure which from the following parameters:
    \param lmax maximum \a l quantum number (\a >=0)
    \param nm number of different \a m (\a 0<=nm<=lmax+1)
    \param stride the stride between entries with identical \a m, and \a l
      differing by 1.
    \param mval array with \a nm entries containing the individual m values
    \param mvstart array with \a nm entries containing the (hypothetical)
      indices of the coefficients with the quantum numbers 0,\a mval[i]
    \param flags a combination of sharp_almflags (pass 0 unless you know you need this)
    \param alm_info will hold a pointer to the newly created data structure
 */
void sharp_make_general_alm_info (int lmax, int nm, int stride, const int *mval,
  const ptrdiff_t *mvstart, int flags, sharp_alm_info **alm_info);
/*! Returns the index of the coefficient with quantum numbers \a l,
    \a mval[mi].
    \note for a \a sharp_alm_info generated by sharp_make_alm_info() this is
    the index for the coefficient with the quantum numbers \a l, \a mi. */
ptrdiff_t sharp_alm_index (const sharp_alm_info *self, int l, int mi);
/*! Deallocates the a_lm info object. */
void sharp_destroy_alm_info (sharp_alm_info *info);

/*! \} */

/*! \defgroup geominfogroup Functions for dealing with geometry information */
/*! \{ */

/*! Creates a geometry information from a set of ring descriptions.
    All arrays passed to this function must have \a nrings elements.
    \param nrings the number of rings in the map
    \param nph the number of pixels in each ring
    \param ofs the index of the first pixel in each ring in the map array
    \param stride the stride between consecutive pixels
    \param phi0 the azimuth (in radians) of the first pixel in each ring
    \param theta the colatitude (in radians) of each ring
    \param wgt the pixel weight to be used for the ring in map2alm
      and adjoint map2alm transforms.
      Pass NULL to use 1.0 as weight for all rings.
    \param geom_info will hold a pointer to the newly created data structure
 */
void sharp_make_geom_info (int nrings, const int *nph, const ptrdiff_t *ofs,
  const int *stride, const double *phi0, const double *theta,
  const double *wgt, sharp_geom_info **geom_info);

/*! Deallocates the geometry information in \a info. */
void sharp_destroy_geom_info (sharp_geom_info *info);

/*! \} */

/*! \defgroup lowlevelgroup Low-level libsharp SHT interface */
/*! \{ */

/*! Enumeration of SHARP job types. */
typedef enum { SHARP_YtW=0,               /*!< analysis */
               SHARP_MAP2ALM=SHARP_YtW,   /*!< analysis */
               SHARP_Y=1,                 /*!< synthesis */
               SHARP_ALM2MAP=SHARP_Y,     /*!< synthesis */
               SHARP_Yt=2,                /*!< adjoint synthesis */
               SHARP_WY=3,                /*!< adjoint analysis */
               SHARP_ALM2MAP_DERIV1=4     /*!< synthesis of first derivatives */
             } sharp_jobtype;

/*! Job flags */
typedef enum { SHARP_DP              = 1<<4,
               /*!< map and a_lm are in double precision */
               SHARP_ADD             = 1<<5,
               /*!< results are added to the output arrays, instead of
                    overwriting them */
               SHARP_REAL_HARMONICS  = 1<<6,
               /*!< Use the real spherical harmonic convention. For
                    m==0, the alm are treated exactly the same as in
                    the complex case.  For m!=0, alm[i] represent a
                    pair (+abs(m), -abs(m)) instead of (real, imag),
                    and the coefficients are scaled by a factor of
                    sqrt(2) relative to the complex case.  In other
                    words, (sqrt(.5) * alm[i]) recovers the
                    corresponding complex coefficient (when accessed
                    as complex).
                */
               SHARP_NO_FFT          = 1<<7,

               SHARP_USE_WEIGHTS     = 1<<20,    /* internal use only */
               SHARP_NO_OPENMP       = 1<<21,    /* internal use only */
               SHARP_NVMAX           = (1<<4)-1 /* internal use only */
             } sharp_jobflags;

/*! Performs a libsharp SHT job. The interface deliberately does not use
  the C99 "complex" data type, in order to be callable from C89 and C++.
  \param type the type of SHT
  \param spin the spin of the quantities to be transformed
  \param alm contains pointers to the a_lm coefficients. If \a spin==0,
    alm[0] points to the a_lm of the first SHT, alm[1] to those of the second
    etc. If \a spin>0, alm[0] and alm[1] point to the a_lm of the first SHT,
    alm[2] and alm[3] to those of the second, etc. The exact data type of \a alm
    depends on whether the SHARP_DP flag is set.
  \param map contains pointers to the maps. If \a spin==0,
    map[0] points to the map of the first SHT, map[1] to that of the second
    etc. If \a spin>0, or \a type is SHARP_ALM2MAP_DERIV1, map[0] and map[1]
    point to the maps of the first SHT, map[2] and map[3] to those of the
    second, etc. The exact data type of \a map depends on whether the SHARP_DP
    flag is set.
  \param geom_info A \c sharp_geom_info object compatible with the provided
    \a map arrays.
  \param alm_info A \c sharp_alm_info object compatible with the provided
    \a alm arrays. All \c m values from 0 to some \c mmax<=lmax must be present
    exactly once.
  \param ntrans the number of simultaneous SHTs
  \param flags See sharp_jobflags. In particular, if SHARP_DP is set, then
    \a alm is expected to have the type "complex double **" and \a map is
    expected to have the type "double **"; otherwise, the expected
    types are "complex float **" and "float **", respectively.
  \param time If not NULL, the wall clock time required for this SHT
    (in seconds) will be written here.
  \param opcnt If not NULL, a conservative estimate of the total floating point
    operation count for this SHT will be written here. */
void sharp_execute (sharp_jobtype type, int spin, void *alm, void *map,
  const sharp_geom_info *geom_info, const sharp_alm_info *alm_info, int ntrans,
  int flags, double *time, unsigned long long *opcnt);

void sharp_set_chunksize_min(int new_chunksize_min);
void sharp_set_nchunks_max(int new_nchunks_max);

/*! \} */

#ifdef __cplusplus
}
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_vecsupport.h0000664000175000017500000001227213010375061027706 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*  \file sharp_vecsupport.h
 *  Convenience functions for vector arithmetics
 *
 *  Copyright (C) 2012 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#ifndef SHARP_VECSUPPORT_H
#define SHARP_VECSUPPORT_H

#include 
#include "sharp_vecutil.h"

typedef double Ts;

#if (VLEN==1)

typedef double Tv;

#define vadd(a,b) ((a)+(b))
#define vaddeq(a,b) ((a)+=(b))
#define vsub(a,b) ((a)-(b))
#define vsubeq(a,b) ((a)-=(b))
#define vmul(a,b) ((a)*(b))
#define vmuleq(a,b) ((a)*=(b))
#define vfmaeq(a,b,c) ((a)+=(b)*(c))
#define vfmseq(a,b,c) ((a)-=(b)*(c))
#define vfmaaeq(a,b,c,d,e) ((a)+=(b)*(c)+(d)*(e))
#define vfmaseq(a,b,c,d,e) ((a)+=(b)*(c)-(d)*(e))
#define vneg(a) (-(a))
#define vload(a) (a)
#define vabs(a) fabs(a)
#define vsqrt(a) sqrt(a)
#define vlt(a,b) (((a)<(b))?1.:0.)
#define vgt(a,b) (((a)>(b))?1.:0.)
#define vge(a,b) (((a)>=(b))?1.:0.)
#define vne(a,b) (((a)!=(b))?1.:0.)
#define vand(a,b) ((((a)*(b))!=0.)?1.:0.)
#define vor(a,b) ((((a)+(b))!=0.)?1.:0.)

static inline Tv vmin (Tv a, Tv b) { return (ab) ? a : b; }

#define vanyTrue(a) ((a)!=0.)
#define vallTrue(a) ((a)!=0.)
#define vblend(m,a,b) (((m)!=0.) ? (a) : (b))
#define vzero 0.
#define vone 1.

#endif

#if (VLEN==2)

#include 

#if defined (__SSE3__)
#include 
#endif
#if defined (__SSE4_1__)
#include 
#endif

typedef __m128d Tv;

#define vadd(a,b) _mm_add_pd(a,b)
#define vaddeq(a,b) a=_mm_add_pd(a,b)
#define vsub(a,b) _mm_sub_pd(a,b)
#define vsubeq(a,b) a=_mm_sub_pd(a,b)
#define vmul(a,b) _mm_mul_pd(a,b)
#define vmuleq(a,b) a=_mm_mul_pd(a,b)
#define vfmaeq(a,b,c) a=_mm_add_pd(a,_mm_mul_pd(b,c))
#define vfmseq(a,b,c) a=_mm_sub_pd(a,_mm_mul_pd(b,c))
#define vfmaaeq(a,b,c,d,e) \
  a=_mm_add_pd(a,_mm_add_pd(_mm_mul_pd(b,c),_mm_mul_pd(d,e)))
#define vfmaseq(a,b,c,d,e) \
  a=_mm_add_pd(a,_mm_sub_pd(_mm_mul_pd(b,c),_mm_mul_pd(d,e)))
#define vneg(a) _mm_xor_pd(_mm_set1_pd(-0.),a)
#define vload(a) _mm_set1_pd(a)
#define vabs(a) _mm_andnot_pd(_mm_set1_pd(-0.),a)
#define vsqrt(a) _mm_sqrt_pd(a)
#define vlt(a,b) _mm_cmplt_pd(a,b)
#define vgt(a,b) _mm_cmpgt_pd(a,b)
#define vge(a,b) _mm_cmpge_pd(a,b)
#define vne(a,b) _mm_cmpneq_pd(a,b)
#define vand(a,b) _mm_and_pd(a,b)
#define vor(a,b) _mm_or_pd(a,b)
#define vmin(a,b) _mm_min_pd(a,b)
#define vmax(a,b) _mm_max_pd(a,b);
#define vanyTrue(a) (_mm_movemask_pd(a)!=0)
#define vallTrue(a) (_mm_movemask_pd(a)==3)
#if defined(__SSE4_1__)
#define vblend(m,a,b) _mm_blendv_pd(b,a,m)
#else
static inline Tv vblend(Tv m, Tv a, Tv b)
  { return _mm_or_pd(_mm_and_pd(a,m),_mm_andnot_pd(m,b)); }
#endif
#define vzero _mm_setzero_pd()
#define vone _mm_set1_pd(1.)

#endif

#if (VLEN==4)

#include 
#ifdef __FMA4__
#include 
#endif

typedef __m256d Tv;

#define vadd(a,b) _mm256_add_pd(a,b)
#define vaddeq(a,b) a=_mm256_add_pd(a,b)
#define vsub(a,b) _mm256_sub_pd(a,b)
#define vsubeq(a,b) a=_mm256_sub_pd(a,b)
#define vmul(a,b) _mm256_mul_pd(a,b)
#define vmuleq(a,b) a=_mm256_mul_pd(a,b)
#ifdef __FMA4__
#define vfmaeq(a,b,c) a=_mm256_macc_pd(b,c,a)
#define vfmseq(a,b,c) a=_mm256_nmacc_pd(b,c,a)
#define vfmaaeq(a,b,c,d,e) a=_mm256_macc_pd(d,e,_mm256_macc_pd(b,c,a))
#define vfmaseq(a,b,c,d,e) a=_mm256_nmacc_pd(d,e,_mm256_macc_pd(b,c,a))
#else
#define vfmaeq(a,b,c) a=_mm256_add_pd(a,_mm256_mul_pd(b,c))
#define vfmseq(a,b,c) a=_mm256_sub_pd(a,_mm256_mul_pd(b,c))
#define vfmaaeq(a,b,c,d,e) \
  a=_mm256_add_pd(a,_mm256_add_pd(_mm256_mul_pd(b,c),_mm256_mul_pd(d,e)))
#define vfmaseq(a,b,c,d,e) \
  a=_mm256_add_pd(a,_mm256_sub_pd(_mm256_mul_pd(b,c),_mm256_mul_pd(d,e)))
#endif
#define vneg(a) _mm256_xor_pd(_mm256_set1_pd(-0.),a)
#define vload(a) _mm256_set1_pd(a)
#define vabs(a) _mm256_andnot_pd(_mm256_set1_pd(-0.),a)
#define vsqrt(a) _mm256_sqrt_pd(a)
#define vlt(a,b) _mm256_cmp_pd(a,b,_CMP_LT_OQ)
#define vgt(a,b) _mm256_cmp_pd(a,b,_CMP_GT_OQ)
#define vge(a,b) _mm256_cmp_pd(a,b,_CMP_GE_OQ)
#define vne(a,b) _mm256_cmp_pd(a,b,_CMP_NEQ_OQ)
#define vand(a,b) _mm256_and_pd(a,b)
#define vor(a,b) _mm256_or_pd(a,b)
#define vmin(a,b) _mm256_min_pd(a,b)
#define vmax(a,b) _mm256_max_pd(a,b)
#define vanyTrue(a) (_mm256_movemask_pd(a)!=0)
#define vallTrue(a) (_mm256_movemask_pd(a)==15)
#define vblend(m,a,b) _mm256_blendv_pd(b,a,m)
#define vzero _mm256_setzero_pd()
#define vone _mm256_set1_pd(1.)

#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_vecutil.h0000664000175000017500000000236613010375061027152 0ustar  zoncazonca00000000000000/*
 *  This file is part of libc_utils.
 *
 *  libc_utils is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libc_utils is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libc_utils; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libc_utils is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*! \file sharp_vecutil.h
 *  Functionality related to vector instruction support
 *
 *  Copyright (C) 2012 Max-Planck-Society
 *  \author Martin Reinecke
 */

#ifndef SHARP_VECUTIL_H
#define SHARP_VECUTIL_H

#if (defined (__AVX__))
#define VLEN 4
#elif (defined (__SSE2__))
#define VLEN 2
#else
#define VLEN 1
#endif

#endif
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/libsharp/sharp_ylmgen_c.c0000664000175000017500000001521213010375061027261 0ustar  zoncazonca00000000000000/*
 *  This file is part of libsharp.
 *
 *  libsharp is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  libsharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with libsharp; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*
 *  libsharp is being developed at the Max-Planck-Institut fuer Astrophysik
 *  and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
 *  (DLR).
 */

/*
 *  Helper code for efficient calculation of Y_lm(theta,phi=0)
 *
 *  Copyright (C) 2005-2014 Max-Planck-Society
 *  Author: Martin Reinecke
 */

#include 
#include 
#include "sharp_ylmgen_c.h"
#include "c_utils.h"

static inline void normalize (double *val, int *scale, double xfmax)
  {
  while (fabs(*val)>xfmax) { *val*=sharp_fsmall; ++*scale; }
  if (*val!=0.)
    while (fabs(*val)lmax = l_max;
  gen->mmax = m_max;
  UTIL_ASSERT(spin>=0,"incorrect spin: must be nonnegative");
  UTIL_ASSERT(l_max>=spin,"incorrect l_max: must be >= spin");
  UTIL_ASSERT(l_max>=m_max,"incorrect l_max: must be >= m_max");
  gen->s = spin;
  UTIL_ASSERT((sharp_minscale<=0)&&(sharp_maxscale>0),
    "bad value for min/maxscale");
  gen->cf=RALLOC(double,sharp_maxscale-sharp_minscale+1);
  gen->cf[-sharp_minscale]=1.;
  for (int m=-sharp_minscale-1; m>=0; --m)
    gen->cf[m]=gen->cf[m+1]*sharp_fsmall;
  for (int m=-sharp_minscale+1; m<(sharp_maxscale-sharp_minscale+1); ++m)
    gen->cf[m]=gen->cf[m-1]*sharp_fbig;

  gen->m = -1;
  if (spin==0)
    {
    gen->rf = RALLOC(sharp_ylmgen_dbl2,gen->lmax+1);
    gen->mfac = RALLOC(double,gen->mmax+1);
    gen->mfac[0] = inv_sqrt4pi;
    for (int m=1; m<=gen->mmax; ++m)
      gen->mfac[m] = gen->mfac[m-1]*sqrt((2*m+1.)/(2*m));
    gen->root = RALLOC(double,2*gen->lmax+5);
    gen->iroot = RALLOC(double,2*gen->lmax+5);
    for (int m=0; m<2*gen->lmax+5; ++m)
      {
      gen->root[m] = sqrt(m);
      gen->iroot[m] = (m==0) ? 0. : 1./gen->root[m];
      }
    }
  else
    {
    gen->m=gen->mlo=gen->mhi=-1234567890;
    ALLOC(gen->fx,sharp_ylmgen_dbl3,gen->lmax+2);
    for (int m=0; mlmax+2; ++m)
      gen->fx[m].f[0]=gen->fx[m].f[1]=gen->fx[m].f[2]=0.;
    ALLOC(gen->inv,double,gen->lmax+1);
    gen->inv[0]=0;
    for (int m=1; mlmax+1; ++m) gen->inv[m]=1./m;
    ALLOC(gen->flm1,double,2*gen->lmax+1);
    ALLOC(gen->flm2,double,2*gen->lmax+1);
    for (int m=0; m<2*gen->lmax+1; ++m)
      {
      gen->flm1[m] = sqrt(1./(m+1.));
      gen->flm2[m] = sqrt(m/(m+1.));
      }
    ALLOC(gen->prefac,double,gen->mmax+1);
    ALLOC(gen->fscale,int,gen->mmax+1);
    double *fac = RALLOC(double,2*gen->lmax+1);
    int *facscale = RALLOC(int,2*gen->lmax+1);
    fac[0]=1; facscale[0]=0;
    for (int m=1; m<2*gen->lmax+1; ++m)
      {
      fac[m]=fac[m-1]*sqrt(m);
      facscale[m]=facscale[m-1];
      normalize(&fac[m],&facscale[m],sharp_fbighalf);
      }
    for (int m=0; m<=gen->mmax; ++m)
      {
      int mlo=gen->s, mhi=m;
      if (mhiprefac[m]=tfac;
      gen->fscale[m]=tscale;
      }
    DEALLOC(fac);
    DEALLOC(facscale);
    }
  }

void sharp_Ylmgen_destroy (sharp_Ylmgen_C *gen)
  {
  DEALLOC(gen->cf);
  if (gen->s==0)
    {
    DEALLOC(gen->rf);
    DEALLOC(gen->mfac);
    DEALLOC(gen->root);
    DEALLOC(gen->iroot);
    }
  else
    {
    DEALLOC(gen->fx);
    DEALLOC(gen->prefac);
    DEALLOC(gen->fscale);
    DEALLOC(gen->flm1);
    DEALLOC(gen->flm2);
    DEALLOC(gen->inv);
    }
  }

void sharp_Ylmgen_prepare (sharp_Ylmgen_C *gen, int m)
  {
  if (m==gen->m) return;
  UTIL_ASSERT(m>=0,"incorrect m");
  gen->m = m;

  if (gen->s==0)
    {
    gen->rf[m].f[0] = gen->root[2*m+3];
    gen->rf[m].f[1] = 0.;
    for (int l=m+1; l<=gen->lmax; ++l)
      {
      double tmp=gen->root[2*l+3]*gen->iroot[l+1+m]*gen->iroot[l+1-m];
      gen->rf[l].f[0] = tmp*gen->root[2*l+1];
      gen->rf[l].f[1] = tmp*gen->root[l+m]*gen->root[l-m]*gen->iroot[2*l-1];
      }
    }
  else
    {
    int mlo_=m, mhi_=gen->s;
    if (mhi_mhi==mhi_) && (gen->mlo==mlo_));

    gen->mlo = mlo_; gen->mhi = mhi_;

    if (!ms_similar)
      {
      for (int l=gen->mhi; llmax; ++l)
        {
        double t = gen->flm1[l+gen->m]*gen->flm1[l-gen->m]
                  *gen->flm1[l+gen->s]*gen->flm1[l-gen->s];
        double lt = 2*l+1;
        double l1 = l+1;
        gen->fx[l+1].f[0]=l1*lt*t;
        gen->fx[l+1].f[1]=gen->m*gen->s*gen->inv[l]*gen->inv[l+1];
        t = gen->flm2[l+gen->m]*gen->flm2[l-gen->m]
           *gen->flm2[l+gen->s]*gen->flm2[l-gen->s];
        gen->fx[l+1].f[2]=t*l1*gen->inv[l];
        }
      }

    gen->preMinus_p = gen->preMinus_m = 0;
    if (gen->mhi==gen->m)
      {
      gen->cosPow = gen->mhi+gen->s; gen->sinPow = gen->mhi-gen->s;
      gen->preMinus_p = gen->preMinus_m = ((gen->mhi-gen->s)&1);
      }
    else
      {
      gen->cosPow = gen->mhi+gen->m; gen->sinPow = gen->mhi-gen->m;
      gen->preMinus_m = ((gen->mhi+gen->m)&1);
      }
    }
  }

double *sharp_Ylmgen_get_norm (int lmax, int spin)
  {
  const double pi = 3.141592653589793238462643383279502884197;
  double *res=RALLOC(double,lmax+1);
  /* sign convention for H=1 (LensPix paper) */
#if 1
   double spinsign = (spin>0) ? -1.0 : 1.0;
#else
   double spinsign = 1.0;
#endif

  if (spin==0)
    {
    for (int l=0; l<=lmax; ++l)
      res[l]=1.;
    return res;
    }

  spinsign = (spin&1) ? -spinsign : spinsign;
  for (int l=0; l<=lmax; ++l)
    res[l] = (l='`$ECHO "$" | $SED "$delay_single_quote_subst"`'
m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],
[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
    [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])


# _LT_LIBTOOL_TAGS
# ----------------
# Output comment and list of tags supported by the script
m4_defun([_LT_LIBTOOL_TAGS],
[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
available_tags="_LT_TAGS"dnl
])


# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
# -----------------------------------
# Extract the dictionary values for VARNAME (optionally with TAG) and
# expand to a commented shell variable setting:
#
#    # Some comment about what VAR is for.
#    visible_name=$lt_internal_name
m4_define([_LT_LIBTOOL_DECLARE],
[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
					   [description])))[]dnl
m4_pushdef([_libtool_name],
    m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
    [0], [_libtool_name=[$]$1],
    [1], [_libtool_name=$lt_[]$1],
    [2], [_libtool_name=$lt_[]$1],
    [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
])


# _LT_LIBTOOL_CONFIG_VARS
# -----------------------
# Produce commented declarations of non-tagged libtool config variables
# suitable for insertion in the LIBTOOL CONFIG section of the `libtool'
# script.  Tagged libtool config variables (even for the LIBTOOL CONFIG
# section) are produced by _LT_LIBTOOL_TAG_VARS.
m4_defun([_LT_LIBTOOL_CONFIG_VARS],
[m4_foreach([_lt_var],
    m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])


# _LT_LIBTOOL_TAG_VARS(TAG)
# -------------------------
m4_define([_LT_LIBTOOL_TAG_VARS],
[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])


# _LT_TAGVAR(VARNAME, [TAGNAME])
# ------------------------------
m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])


# _LT_CONFIG_COMMANDS
# -------------------
# Send accumulated output to $CONFIG_STATUS.  Thanks to the lists of
# variables for single and double quote escaping we saved from calls
# to _LT_DECL, we can put quote escaped variables declarations
# into `config.status', and then the shell code to quote escape them in
# for loops in `config.status'.  Finally, any additional code accumulated
# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
m4_defun([_LT_CONFIG_COMMANDS],
[AC_PROVIDE_IFELSE([LT_OUTPUT],
	dnl If the libtool generation code has been placed in $CONFIG_LT,
	dnl instead of duplicating it all over again into config.status,
	dnl then we will have config.status run $CONFIG_LT later, so it
	dnl needs to know what name is stored there:
        [AC_CONFIG_COMMANDS([libtool],
            [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])],
    dnl If the libtool generation code is destined for config.status,
    dnl expand the accumulated commands and init code now:
    [AC_CONFIG_COMMANDS([libtool],
        [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])])
])#_LT_CONFIG_COMMANDS


# Initialize.
m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT],
[

# The HP-UX ksh and POSIX shell print the target directory to stdout
# if CDPATH is set.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

sed_quote_subst='$sed_quote_subst'
double_quote_subst='$double_quote_subst'
delay_variable_subst='$delay_variable_subst'
_LT_CONFIG_STATUS_DECLARATIONS
LTCC='$LTCC'
LTCFLAGS='$LTCFLAGS'
compiler='$compiler_DEFAULT'

# A function that is used when there is no print builtin or printf.
func_fallback_echo ()
{
  eval 'cat <<_LTECHO_EOF
\$[]1
_LTECHO_EOF'
}

# Quote evaled strings.
for var in lt_decl_all_varnames([[ \
]], lt_decl_quote_varnames); do
    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
    *[[\\\\\\\`\\"\\\$]]*)
      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
      ;;
    *)
      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
      ;;
    esac
done

# Double-quote double-evaled strings.
for var in lt_decl_all_varnames([[ \
]], lt_decl_dquote_varnames); do
    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
    *[[\\\\\\\`\\"\\\$]]*)
      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
      ;;
    *)
      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
      ;;
    esac
done

_LT_OUTPUT_LIBTOOL_INIT
])

# _LT_GENERATED_FILE_INIT(FILE, [COMMENT])
# ------------------------------------
# Generate a child script FILE with all initialization necessary to
# reuse the environment learned by the parent script, and make the
# file executable.  If COMMENT is supplied, it is inserted after the
# `#!' sequence but before initialization text begins.  After this
# macro, additional text can be appended to FILE to form the body of
# the child script.  The macro ends with non-zero status if the
# file could not be fully written (such as if the disk is full).
m4_ifdef([AS_INIT_GENERATED],
[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])],
[m4_defun([_LT_GENERATED_FILE_INIT],
[m4_require([AS_PREPARE])]dnl
[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl
[lt_write_fail=0
cat >$1 <<_ASEOF || lt_write_fail=1
#! $SHELL
# Generated by $as_me.
$2
SHELL=\${CONFIG_SHELL-$SHELL}
export SHELL
_ASEOF
cat >>$1 <<\_ASEOF || lt_write_fail=1
AS_SHELL_SANITIZE
_AS_PREPARE
exec AS_MESSAGE_FD>&1
_ASEOF
test $lt_write_fail = 0 && chmod +x $1[]dnl
m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT

# LT_OUTPUT
# ---------
# This macro allows early generation of the libtool script (before
# AC_OUTPUT is called), incase it is used in configure for compilation
# tests.
AC_DEFUN([LT_OUTPUT],
[: ${CONFIG_LT=./config.lt}
AC_MSG_NOTICE([creating $CONFIG_LT])
_LT_GENERATED_FILE_INIT(["$CONFIG_LT"],
[# Run this file to recreate a libtool stub with the current configuration.])

cat >>"$CONFIG_LT" <<\_LTEOF
lt_cl_silent=false
exec AS_MESSAGE_LOG_FD>>config.log
{
  echo
  AS_BOX([Running $as_me.])
} >&AS_MESSAGE_LOG_FD

lt_cl_help="\
\`$as_me' creates a local libtool stub from the current configuration,
for use in further configure time tests before the real libtool is
generated.

Usage: $[0] [[OPTIONS]]

  -h, --help      print this help, then exit
  -V, --version   print version number, then exit
  -q, --quiet     do not print progress messages
  -d, --debug     don't remove temporary files

Report bugs to ."

lt_cl_version="\
m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl
m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])
configured by $[0], generated by m4_PACKAGE_STRING.

Copyright (C) 2011 Free Software Foundation, Inc.
This config.lt script is free software; the Free Software Foundation
gives unlimited permision to copy, distribute and modify it."

while test $[#] != 0
do
  case $[1] in
    --version | --v* | -V )
      echo "$lt_cl_version"; exit 0 ;;
    --help | --h* | -h )
      echo "$lt_cl_help"; exit 0 ;;
    --debug | --d* | -d )
      debug=: ;;
    --quiet | --q* | --silent | --s* | -q )
      lt_cl_silent=: ;;

    -*) AC_MSG_ERROR([unrecognized option: $[1]
Try \`$[0] --help' for more information.]) ;;

    *) AC_MSG_ERROR([unrecognized argument: $[1]
Try \`$[0] --help' for more information.]) ;;
  esac
  shift
done

if $lt_cl_silent; then
  exec AS_MESSAGE_FD>/dev/null
fi
_LTEOF

cat >>"$CONFIG_LT" <<_LTEOF
_LT_OUTPUT_LIBTOOL_COMMANDS_INIT
_LTEOF

cat >>"$CONFIG_LT" <<\_LTEOF
AC_MSG_NOTICE([creating $ofile])
_LT_OUTPUT_LIBTOOL_COMMANDS
AS_EXIT(0)
_LTEOF
chmod +x "$CONFIG_LT"

# configure is writing to config.log, but config.lt does its own redirection,
# appending to config.log, which fails on DOS, as config.log is still kept
# open by configure.  Here we exec the FD to /dev/null, effectively closing
# config.log, so it can be properly (re)opened and appended to by config.lt.
lt_cl_success=:
test "$silent" = yes &&
  lt_config_lt_args="$lt_config_lt_args --quiet"
exec AS_MESSAGE_LOG_FD>/dev/null
$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false
exec AS_MESSAGE_LOG_FD>>config.log
$lt_cl_success || AS_EXIT(1)
])# LT_OUTPUT


# _LT_CONFIG(TAG)
# ---------------
# If TAG is the built-in tag, create an initial libtool script with a
# default configuration from the untagged config vars.  Otherwise add code
# to config.status for appending the configuration named by TAG from the
# matching tagged config vars.
m4_defun([_LT_CONFIG],
[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
_LT_CONFIG_SAVE_COMMANDS([
  m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
  m4_if(_LT_TAG, [C], [
    # See if we are running on zsh, and set the options which allow our
    # commands through without removal of \ escapes.
    if test -n "${ZSH_VERSION+set}" ; then
      setopt NO_GLOB_SUBST
    fi

    cfgfile="${ofile}T"
    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
    $RM "$cfgfile"

    cat <<_LT_EOF >> "$cfgfile"
#! $SHELL

# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
# NOTE: Changes made to this file will be lost: look at ltmain.sh.
#
_LT_COPYING
_LT_LIBTOOL_TAGS

# ### BEGIN LIBTOOL CONFIG
_LT_LIBTOOL_CONFIG_VARS
_LT_LIBTOOL_TAG_VARS
# ### END LIBTOOL CONFIG

_LT_EOF

  case $host_os in
  aix3*)
    cat <<\_LT_EOF >> "$cfgfile"
# AIX sometimes has problems with the GCC collect2 program.  For some
# reason, if we set the COLLECT_NAMES environment variable, the problems
# vanish in a puff of smoke.
if test "X${COLLECT_NAMES+set}" != Xset; then
  COLLECT_NAMES=
  export COLLECT_NAMES
fi
_LT_EOF
    ;;
  esac

  _LT_PROG_LTMAIN

  # We use sed instead of cat because bash on DJGPP gets confused if
  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
  # text mode, it properly converts lines to CR/LF.  This bash problem
  # is reportedly fixed, but why not run on old versions too?
  sed '$q' "$ltmain" >> "$cfgfile" \
     || (rm -f "$cfgfile"; exit 1)

  _LT_PROG_REPLACE_SHELLFNS

   mv -f "$cfgfile" "$ofile" ||
    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
  chmod +x "$ofile"
],
[cat <<_LT_EOF >> "$ofile"

dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
dnl in a comment (ie after a #).
# ### BEGIN LIBTOOL TAG CONFIG: $1
_LT_LIBTOOL_TAG_VARS(_LT_TAG)
# ### END LIBTOOL TAG CONFIG: $1
_LT_EOF
])dnl /m4_if
],
[m4_if([$1], [], [
    PACKAGE='$PACKAGE'
    VERSION='$VERSION'
    TIMESTAMP='$TIMESTAMP'
    RM='$RM'
    ofile='$ofile'], [])
])dnl /_LT_CONFIG_SAVE_COMMANDS
])# _LT_CONFIG


# LT_SUPPORTED_TAG(TAG)
# ---------------------
# Trace this macro to discover what tags are supported by the libtool
# --tag option, using:
#    autoconf --trace 'LT_SUPPORTED_TAG:$1'
AC_DEFUN([LT_SUPPORTED_TAG], [])


# C support is built-in for now
m4_define([_LT_LANG_C_enabled], [])
m4_define([_LT_TAGS], [])


# LT_LANG(LANG)
# -------------
# Enable libtool support for the given language if not already enabled.
AC_DEFUN([LT_LANG],
[AC_BEFORE([$0], [LT_OUTPUT])dnl
m4_case([$1],
  [C],			[_LT_LANG(C)],
  [C++],		[_LT_LANG(CXX)],
  [Go],			[_LT_LANG(GO)],
  [Java],		[_LT_LANG(GCJ)],
  [Fortran 77],		[_LT_LANG(F77)],
  [Fortran],		[_LT_LANG(FC)],
  [Windows Resource],	[_LT_LANG(RC)],
  [m4_ifdef([_LT_LANG_]$1[_CONFIG],
    [_LT_LANG($1)],
    [m4_fatal([$0: unsupported language: "$1"])])])dnl
])# LT_LANG


# _LT_LANG(LANGNAME)
# ------------------
m4_defun([_LT_LANG],
[m4_ifdef([_LT_LANG_]$1[_enabled], [],
  [LT_SUPPORTED_TAG([$1])dnl
  m4_append([_LT_TAGS], [$1 ])dnl
  m4_define([_LT_LANG_]$1[_enabled], [])dnl
  _LT_LANG_$1_CONFIG($1)])dnl
])# _LT_LANG


m4_ifndef([AC_PROG_GO], [
############################################################
# NOTE: This macro has been submitted for inclusion into   #
#  GNU Autoconf as AC_PROG_GO.  When it is available in    #
#  a released version of Autoconf we should remove this    #
#  macro and use it instead.                               #
############################################################
m4_defun([AC_PROG_GO],
[AC_LANG_PUSH(Go)dnl
AC_ARG_VAR([GOC],     [Go compiler command])dnl
AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl
_AC_ARG_VAR_LDFLAGS()dnl
AC_CHECK_TOOL(GOC, gccgo)
if test -z "$GOC"; then
  if test -n "$ac_tool_prefix"; then
    AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo])
  fi
fi
if test -z "$GOC"; then
  AC_CHECK_PROG(GOC, gccgo, gccgo, false)
fi
])#m4_defun
])#m4_ifndef


# _LT_LANG_DEFAULT_CONFIG
# -----------------------
m4_defun([_LT_LANG_DEFAULT_CONFIG],
[AC_PROVIDE_IFELSE([AC_PROG_CXX],
  [LT_LANG(CXX)],
  [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])

AC_PROVIDE_IFELSE([AC_PROG_F77],
  [LT_LANG(F77)],
  [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])

AC_PROVIDE_IFELSE([AC_PROG_FC],
  [LT_LANG(FC)],
  [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])])

dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
dnl pulling things in needlessly.
AC_PROVIDE_IFELSE([AC_PROG_GCJ],
  [LT_LANG(GCJ)],
  [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
    [LT_LANG(GCJ)],
    [AC_PROVIDE_IFELSE([LT_PROG_GCJ],
      [LT_LANG(GCJ)],
      [m4_ifdef([AC_PROG_GCJ],
	[m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
       m4_ifdef([A][M_PROG_GCJ],
	[m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
       m4_ifdef([LT_PROG_GCJ],
	[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])

AC_PROVIDE_IFELSE([AC_PROG_GO],
  [LT_LANG(GO)],
  [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])])

AC_PROVIDE_IFELSE([LT_PROG_RC],
  [LT_LANG(RC)],
  [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
])# _LT_LANG_DEFAULT_CONFIG

# Obsolete macros:
AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])
AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])
AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_CXX], [])
dnl AC_DEFUN([AC_LIBTOOL_F77], [])
dnl AC_DEFUN([AC_LIBTOOL_FC], [])
dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])
dnl AC_DEFUN([AC_LIBTOOL_RC], [])


# _LT_TAG_COMPILER
# ----------------
m4_defun([_LT_TAG_COMPILER],
[AC_REQUIRE([AC_PROG_CC])dnl

_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl
_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl
_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl

# If no C compiler was specified, use CC.
LTCC=${LTCC-"$CC"}

# If no C compiler flags were specified, use CFLAGS.
LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

# Allow CC to be a program name with arguments.
compiler=$CC
])# _LT_TAG_COMPILER


# _LT_COMPILER_BOILERPLATE
# ------------------------
# Check for compiler boilerplate output or warnings with
# the simple compiler test code.
m4_defun([_LT_COMPILER_BOILERPLATE],
[m4_require([_LT_DECL_SED])dnl
ac_outfile=conftest.$ac_objext
echo "$lt_simple_compile_test_code" >conftest.$ac_ext
eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
_lt_compiler_boilerplate=`cat conftest.err`
$RM conftest*
])# _LT_COMPILER_BOILERPLATE


# _LT_LINKER_BOILERPLATE
# ----------------------
# Check for linker boilerplate output or warnings with
# the simple link test code.
m4_defun([_LT_LINKER_BOILERPLATE],
[m4_require([_LT_DECL_SED])dnl
ac_outfile=conftest.$ac_objext
echo "$lt_simple_link_test_code" >conftest.$ac_ext
eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
_lt_linker_boilerplate=`cat conftest.err`
$RM -r conftest*
])# _LT_LINKER_BOILERPLATE

# _LT_REQUIRED_DARWIN_CHECKS
# -------------------------
m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
  case $host_os in
    rhapsody* | darwin*)
    AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])
    AC_CHECK_TOOL([NMEDIT], [nmedit], [:])
    AC_CHECK_TOOL([LIPO], [lipo], [:])
    AC_CHECK_TOOL([OTOOL], [otool], [:])
    AC_CHECK_TOOL([OTOOL64], [otool64], [:])
    _LT_DECL([], [DSYMUTIL], [1],
      [Tool to manipulate archived DWARF debug symbol files on Mac OS X])
    _LT_DECL([], [NMEDIT], [1],
      [Tool to change global to local symbols on Mac OS X])
    _LT_DECL([], [LIPO], [1],
      [Tool to manipulate fat objects and archives on Mac OS X])
    _LT_DECL([], [OTOOL], [1],
      [ldd/readelf like tool for Mach-O binaries on Mac OS X])
    _LT_DECL([], [OTOOL64], [1],
      [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4])

    AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],
      [lt_cv_apple_cc_single_mod=no
      if test -z "${LT_MULTI_MODULE}"; then
	# By default we will add the -single_module flag. You can override
	# by either setting the environment variable LT_MULTI_MODULE
	# non-empty at configure time, or by adding -multi_module to the
	# link flags.
	rm -rf libconftest.dylib*
	echo "int foo(void){return 1;}" > conftest.c
	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD
	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
        _lt_result=$?
	# If there is a non-empty error log, and "single_module"
	# appears in it, assume the flag caused a linker warning
        if test -s conftest.err && $GREP single_module conftest.err; then
	  cat conftest.err >&AS_MESSAGE_LOG_FD
	# Otherwise, if the output was created with a 0 exit code from
	# the compiler, it worked.
	elif test -f libconftest.dylib && test $_lt_result -eq 0; then
	  lt_cv_apple_cc_single_mod=yes
	else
	  cat conftest.err >&AS_MESSAGE_LOG_FD
	fi
	rm -rf libconftest.dylib*
	rm -f conftest.*
      fi])

    AC_CACHE_CHECK([for -exported_symbols_list linker flag],
      [lt_cv_ld_exported_symbols_list],
      [lt_cv_ld_exported_symbols_list=no
      save_LDFLAGS=$LDFLAGS
      echo "_main" > conftest.sym
      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
      AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
	[lt_cv_ld_exported_symbols_list=yes],
	[lt_cv_ld_exported_symbols_list=no])
	LDFLAGS="$save_LDFLAGS"
    ])

    AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load],
      [lt_cv_ld_force_load=no
      cat > conftest.c << _LT_EOF
int forced_loaded() { return 2;}
_LT_EOF
      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD
      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD
      echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
      $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
      echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD
      $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD
      cat > conftest.c << _LT_EOF
int main() { return 0;}
_LT_EOF
      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD
      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
      _lt_result=$?
      if test -s conftest.err && $GREP force_load conftest.err; then
	cat conftest.err >&AS_MESSAGE_LOG_FD
      elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then
	lt_cv_ld_force_load=yes
      else
	cat conftest.err >&AS_MESSAGE_LOG_FD
      fi
        rm -f conftest.err libconftest.a conftest conftest.c
        rm -rf conftest.dSYM
    ])
    case $host_os in
    rhapsody* | darwin1.[[012]])
      _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
    darwin1.*)
      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
    darwin*) # darwin 5.x on
      # if running on 10.5 or later, the deployment target defaults
      # to the OS version, if on x86, and 10.4, the deployment
      # target defaults to 10.4. Don't you love it?
      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
	10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)
	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
	10.[[012]]*)
	  _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
	10.*)
	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
      esac
    ;;
  esac
    if test "$lt_cv_apple_cc_single_mod" = "yes"; then
      _lt_dar_single_mod='$single_module'
    fi
    if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
      _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
    else
      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
    fi
    if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
      _lt_dsymutil='~$DSYMUTIL $lib || :'
    else
      _lt_dsymutil=
    fi
    ;;
  esac
])


# _LT_DARWIN_LINKER_FEATURES([TAG])
# ---------------------------------
# Checks for linker and compiler features on darwin
m4_defun([_LT_DARWIN_LINKER_FEATURES],
[
  m4_require([_LT_REQUIRED_DARWIN_CHECKS])
  _LT_TAGVAR(archive_cmds_need_lc, $1)=no
  _LT_TAGVAR(hardcode_direct, $1)=no
  _LT_TAGVAR(hardcode_automatic, $1)=yes
  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
  if test "$lt_cv_ld_force_load" = "yes"; then
    _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
    m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes],
                  [FC],  [_LT_TAGVAR(compiler_needs_object, $1)=yes])
  else
    _LT_TAGVAR(whole_archive_flag_spec, $1)=''
  fi
  _LT_TAGVAR(link_all_deplibs, $1)=yes
  _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined"
  case $cc_basename in
     ifort*) _lt_dar_can_shared=yes ;;
     *) _lt_dar_can_shared=$GCC ;;
  esac
  if test "$_lt_dar_can_shared" = "yes"; then
    output_verbose_link_cmd=func_echo_all
    _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
    _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
    _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
    _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
    m4_if([$1], [CXX],
[   if test "$lt_cv_apple_cc_single_mod" != "yes"; then
      _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
      _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
    fi
],[])
  else
  _LT_TAGVAR(ld_shlibs, $1)=no
  fi
])

# _LT_SYS_MODULE_PATH_AIX([TAGNAME])
# ----------------------------------
# Links a minimal program and checks the executable
# for the system default hardcoded library path. In most cases,
# this is /usr/lib:/lib, but when the MPI compilers are used
# the location of the communication and MPI libs are included too.
# If we don't find anything, use the default library path according
# to the aix ld manual.
# Store the results from the different compilers for each TAGNAME.
# Allow to override them for all tags through lt_cv_aix_libpath.
m4_defun([_LT_SYS_MODULE_PATH_AIX],
[m4_require([_LT_DECL_SED])dnl
if test "${lt_cv_aix_libpath+set}" = set; then
  aix_libpath=$lt_cv_aix_libpath
else
  AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])],
  [AC_LINK_IFELSE([AC_LANG_PROGRAM],[
  lt_aix_libpath_sed='[
      /Import File Strings/,/^$/ {
	  /^0/ {
	      s/^0  *\([^ ]*\) *$/\1/
	      p
	  }
      }]'
  _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  # Check for a 64-bit object if we didn't find anything.
  if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  fi],[])
  if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib"
  fi
  ])
  aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])
fi
])# _LT_SYS_MODULE_PATH_AIX


# _LT_SHELL_INIT(ARG)
# -------------------
m4_define([_LT_SHELL_INIT],
[m4_divert_text([M4SH-INIT], [$1
])])# _LT_SHELL_INIT



# _LT_PROG_ECHO_BACKSLASH
# -----------------------
# Find how we can fake an echo command that does not interpret backslash.
# In particular, with Autoconf 2.60 or later we add some code to the start
# of the generated configure script which will find a shell with a builtin
# printf (which we can use as an echo command).
m4_defun([_LT_PROG_ECHO_BACKSLASH],
[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO

AC_MSG_CHECKING([how to print strings])
# Test print first, because it will be a builtin if present.
if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
  ECHO='print -r --'
elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
  ECHO='printf %s\n'
else
  # Use this function as a fallback that always works.
  func_fallback_echo ()
  {
    eval 'cat <<_LTECHO_EOF
$[]1
_LTECHO_EOF'
  }
  ECHO='func_fallback_echo'
fi

# func_echo_all arg...
# Invoke $ECHO with all args, space-separated.
func_echo_all ()
{
    $ECHO "$*" 
}

case "$ECHO" in
  printf*) AC_MSG_RESULT([printf]) ;;
  print*) AC_MSG_RESULT([print -r]) ;;
  *) AC_MSG_RESULT([cat]) ;;
esac

m4_ifdef([_AS_DETECT_SUGGESTED],
[_AS_DETECT_SUGGESTED([
  test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || (
    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
    ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
    ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
    PATH=/empty FPATH=/empty; export PATH FPATH
    test "X`printf %s $ECHO`" = "X$ECHO" \
      || test "X`print -r -- $ECHO`" = "X$ECHO" )])])

_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])
])# _LT_PROG_ECHO_BACKSLASH


# _LT_WITH_SYSROOT
# ----------------
AC_DEFUN([_LT_WITH_SYSROOT],
[AC_MSG_CHECKING([for sysroot])
AC_ARG_WITH([sysroot],
[  --with-sysroot[=DIR] Search for dependent libraries within DIR
                        (or the compiler's sysroot if not specified).],
[], [with_sysroot=no])

dnl lt_sysroot will always be passed unquoted.  We quote it here
dnl in case the user passed a directory name.
lt_sysroot=
case ${with_sysroot} in #(
 yes)
   if test "$GCC" = yes; then
     lt_sysroot=`$CC --print-sysroot 2>/dev/null`
   fi
   ;; #(
 /*)
   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
   ;; #(
 no|'')
   ;; #(
 *)
   AC_MSG_RESULT([${with_sysroot}])
   AC_MSG_ERROR([The sysroot must be an absolute path.])
   ;;
esac

 AC_MSG_RESULT([${lt_sysroot:-no}])
_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl
[dependent libraries, and in which our libraries should be installed.])])

# _LT_ENABLE_LOCK
# ---------------
m4_defun([_LT_ENABLE_LOCK],
[AC_ARG_ENABLE([libtool-lock],
  [AS_HELP_STRING([--disable-libtool-lock],
    [avoid locking (might break parallel builds)])])
test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

# Some flags need to be propagated to the compiler or linker for good
# libtool support.
case $host in
ia64-*-hpux*)
  # Find out which ABI we are using.
  echo 'int i;' > conftest.$ac_ext
  if AC_TRY_EVAL(ac_compile); then
    case `/usr/bin/file conftest.$ac_objext` in
      *ELF-32*)
	HPUX_IA64_MODE="32"
	;;
      *ELF-64*)
	HPUX_IA64_MODE="64"
	;;
    esac
  fi
  rm -rf conftest*
  ;;
*-*-irix6*)
  # Find out which ABI we are using.
  echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
  if AC_TRY_EVAL(ac_compile); then
    if test "$lt_cv_prog_gnu_ld" = yes; then
      case `/usr/bin/file conftest.$ac_objext` in
	*32-bit*)
	  LD="${LD-ld} -melf32bsmip"
	  ;;
	*N32*)
	  LD="${LD-ld} -melf32bmipn32"
	  ;;
	*64-bit*)
	  LD="${LD-ld} -melf64bmip"
	;;
      esac
    else
      case `/usr/bin/file conftest.$ac_objext` in
	*32-bit*)
	  LD="${LD-ld} -32"
	  ;;
	*N32*)
	  LD="${LD-ld} -n32"
	  ;;
	*64-bit*)
	  LD="${LD-ld} -64"
	  ;;
      esac
    fi
  fi
  rm -rf conftest*
  ;;

x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
  # Find out which ABI we are using.
  echo 'int i;' > conftest.$ac_ext
  if AC_TRY_EVAL(ac_compile); then
    case `/usr/bin/file conftest.o` in
      *32-bit*)
	case $host in
	  x86_64-*kfreebsd*-gnu)
	    LD="${LD-ld} -m elf_i386_fbsd"
	    ;;
	  x86_64-*linux*)
	    LD="${LD-ld} -m elf_i386"
	    ;;
	  ppc64-*linux*|powerpc64-*linux*)
	    LD="${LD-ld} -m elf32ppclinux"
	    ;;
	  s390x-*linux*)
	    LD="${LD-ld} -m elf_s390"
	    ;;
	  sparc64-*linux*)
	    LD="${LD-ld} -m elf32_sparc"
	    ;;
	esac
	;;
      *64-bit*)
	case $host in
	  x86_64-*kfreebsd*-gnu)
	    LD="${LD-ld} -m elf_x86_64_fbsd"
	    ;;
	  x86_64-*linux*)
	    LD="${LD-ld} -m elf_x86_64"
	    ;;
	  ppc*-*linux*|powerpc*-*linux*)
	    LD="${LD-ld} -m elf64ppc"
	    ;;
	  s390*-*linux*|s390*-*tpf*)
	    LD="${LD-ld} -m elf64_s390"
	    ;;
	  sparc*-*linux*)
	    LD="${LD-ld} -m elf64_sparc"
	    ;;
	esac
	;;
    esac
  fi
  rm -rf conftest*
  ;;

*-*-sco3.2v5*)
  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
  SAVE_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -belf"
  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
    [AC_LANG_PUSH(C)
     AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
     AC_LANG_POP])
  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
    CFLAGS="$SAVE_CFLAGS"
  fi
  ;;
*-*solaris*)
  # Find out which ABI we are using.
  echo 'int i;' > conftest.$ac_ext
  if AC_TRY_EVAL(ac_compile); then
    case `/usr/bin/file conftest.o` in
    *64-bit*)
      case $lt_cv_prog_gnu_ld in
      yes*)
        case $host in
        i?86-*-solaris*)
          LD="${LD-ld} -m elf_x86_64"
          ;;
        sparc*-*-solaris*)
          LD="${LD-ld} -m elf64_sparc"
          ;;
        esac
        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
          LD="${LD-ld}_sol2"
        fi
        ;;
      *)
	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
	  LD="${LD-ld} -64"
	fi
	;;
      esac
      ;;
    esac
  fi
  rm -rf conftest*
  ;;
esac

need_locks="$enable_libtool_lock"
])# _LT_ENABLE_LOCK


# _LT_PROG_AR
# -----------
m4_defun([_LT_PROG_AR],
[AC_CHECK_TOOLS(AR, [ar], false)
: ${AR=ar}
: ${AR_FLAGS=cru}
_LT_DECL([], [AR], [1], [The archiver])
_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive])

AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],
  [lt_cv_ar_at_file=no
   AC_COMPILE_IFELSE([AC_LANG_PROGRAM],
     [echo conftest.$ac_objext > conftest.lst
      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD'
      AC_TRY_EVAL([lt_ar_try])
      if test "$ac_status" -eq 0; then
	# Ensure the archiver fails upon bogus file names.
	rm -f conftest.$ac_objext libconftest.a
	AC_TRY_EVAL([lt_ar_try])
	if test "$ac_status" -ne 0; then
          lt_cv_ar_at_file=@
        fi
      fi
      rm -f conftest.* libconftest.a
     ])
  ])

if test "x$lt_cv_ar_at_file" = xno; then
  archiver_list_spec=
else
  archiver_list_spec=$lt_cv_ar_at_file
fi
_LT_DECL([], [archiver_list_spec], [1],
  [How to feed a file listing to the archiver])
])# _LT_PROG_AR


# _LT_CMD_OLD_ARCHIVE
# -------------------
m4_defun([_LT_CMD_OLD_ARCHIVE],
[_LT_PROG_AR

AC_CHECK_TOOL(STRIP, strip, :)
test -z "$STRIP" && STRIP=:
_LT_DECL([], [STRIP], [1], [A symbol stripping program])

AC_CHECK_TOOL(RANLIB, ranlib, :)
test -z "$RANLIB" && RANLIB=:
_LT_DECL([], [RANLIB], [1],
    [Commands used to install an old-style archive])

# Determine commands to create old-style static archives.
old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
old_postinstall_cmds='chmod 644 $oldlib'
old_postuninstall_cmds=

if test -n "$RANLIB"; then
  case $host_os in
  openbsd*)
    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
    ;;
  *)
    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
    ;;
  esac
  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
fi

case $host_os in
  darwin*)
    lock_old_archive_extraction=yes ;;
  *)
    lock_old_archive_extraction=no ;;
esac
_LT_DECL([], [old_postinstall_cmds], [2])
_LT_DECL([], [old_postuninstall_cmds], [2])
_LT_TAGDECL([], [old_archive_cmds], [2],
    [Commands used to build an old-style archive])
_LT_DECL([], [lock_old_archive_extraction], [0],
    [Whether to use a lock for old archive extraction])
])# _LT_CMD_OLD_ARCHIVE


# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
#		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
# ----------------------------------------------------------------
# Check whether the given compiler option works
AC_DEFUN([_LT_COMPILER_OPTION],
[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
m4_require([_LT_DECL_SED])dnl
AC_CACHE_CHECK([$1], [$2],
  [$2=no
   m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
   lt_compiler_flag="$3"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   # The option is referenced via a variable to avoid confusing sed.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
   (eval "$lt_compile" 2>conftest.err)
   ac_status=$?
   cat conftest.err >&AS_MESSAGE_LOG_FD
   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
   if (exit $ac_status) && test -s "$ac_outfile"; then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings other than the usual output.
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
       $2=yes
     fi
   fi
   $RM conftest*
])

if test x"[$]$2" = xyes; then
    m4_if([$5], , :, [$5])
else
    m4_if([$6], , :, [$6])
fi
])# _LT_COMPILER_OPTION

# Old name:
AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [])


# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
#                  [ACTION-SUCCESS], [ACTION-FAILURE])
# ----------------------------------------------------
# Check whether the given linker option works
AC_DEFUN([_LT_LINKER_OPTION],
[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
m4_require([_LT_DECL_SED])dnl
AC_CACHE_CHECK([$1], [$2],
  [$2=no
   save_LDFLAGS="$LDFLAGS"
   LDFLAGS="$LDFLAGS $3"
   echo "$lt_simple_link_test_code" > conftest.$ac_ext
   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
     # The linker can only warn and ignore the option if not recognized
     # So say no if there are warnings
     if test -s conftest.err; then
       # Append any errors to the config.log.
       cat conftest.err 1>&AS_MESSAGE_LOG_FD
       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
       if diff conftest.exp conftest.er2 >/dev/null; then
         $2=yes
       fi
     else
       $2=yes
     fi
   fi
   $RM -r conftest*
   LDFLAGS="$save_LDFLAGS"
])

if test x"[$]$2" = xyes; then
    m4_if([$4], , :, [$4])
else
    m4_if([$5], , :, [$5])
fi
])# _LT_LINKER_OPTION

# Old name:
AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], [])


# LT_CMD_MAX_LEN
#---------------
AC_DEFUN([LT_CMD_MAX_LEN],
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
# find the maximum length of command line arguments
AC_MSG_CHECKING([the maximum length of command line arguments])
AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
  i=0
  teststring="ABCD"

  case $build_os in
  msdosdjgpp*)
    # On DJGPP, this test can blow up pretty badly due to problems in libc
    # (any single argument exceeding 2000 bytes causes a buffer overrun
    # during glob expansion).  Even if it were fixed, the result of this
    # check would be larger than it should be.
    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
    ;;

  gnu*)
    # Under GNU Hurd, this test is not required because there is
    # no limit to the length of command line arguments.
    # Libtool will interpret -1 as no limit whatsoever
    lt_cv_sys_max_cmd_len=-1;
    ;;

  cygwin* | mingw* | cegcc*)
    # On Win9x/ME, this test blows up -- it succeeds, but takes
    # about 5 minutes as the teststring grows exponentially.
    # Worse, since 9x/ME are not pre-emptively multitasking,
    # you end up with a "frozen" computer, even though with patience
    # the test eventually succeeds (with a max line length of 256k).
    # Instead, let's just punt: use the minimum linelength reported by
    # all of the supported platforms: 8192 (on NT/2K/XP).
    lt_cv_sys_max_cmd_len=8192;
    ;;

  mint*)
    # On MiNT this can take a long time and run out of memory.
    lt_cv_sys_max_cmd_len=8192;
    ;;

  amigaos*)
    # On AmigaOS with pdksh, this test takes hours, literally.
    # So we just punt and use a minimum line length of 8192.
    lt_cv_sys_max_cmd_len=8192;
    ;;

  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
    # This has been around since 386BSD, at least.  Likely further.
    if test -x /sbin/sysctl; then
      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
    elif test -x /usr/sbin/sysctl; then
      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
    else
      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
    fi
    # And add a safety zone
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
    ;;

  interix*)
    # We know the value 262144 and hardcode it with a safety zone (like BSD)
    lt_cv_sys_max_cmd_len=196608
    ;;

  os2*)
    # The test takes a long time on OS/2.
    lt_cv_sys_max_cmd_len=8192
    ;;

  osf*)
    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
    # nice to cause kernel panics so lets avoid the loop below.
    # First set a reasonable default.
    lt_cv_sys_max_cmd_len=16384
    #
    if test -x /sbin/sysconfig; then
      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
        *1*) lt_cv_sys_max_cmd_len=-1 ;;
      esac
    fi
    ;;
  sco3.2v5*)
    lt_cv_sys_max_cmd_len=102400
    ;;
  sysv5* | sco5v6* | sysv4.2uw2*)
    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
    if test -n "$kargmax"; then
      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[	 ]]//'`
    else
      lt_cv_sys_max_cmd_len=32768
    fi
    ;;
  *)
    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
    if test -n "$lt_cv_sys_max_cmd_len"; then
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
    else
      # Make teststring a little bigger before we do anything with it.
      # a 1K string should be a reasonable start.
      for i in 1 2 3 4 5 6 7 8 ; do
        teststring=$teststring$teststring
      done
      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
      # If test is not a shell built-in, we'll probably end up computing a
      # maximum length that is only half of the actual maximum length, but
      # we can't tell.
      while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \
	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
	      test $i != 17 # 1/2 MB should be enough
      do
        i=`expr $i + 1`
        teststring=$teststring$teststring
      done
      # Only check the string length outside the loop.
      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
      teststring=
      # Add a significant safety factor because C++ compilers can tack on
      # massive amounts of additional arguments before passing them to the
      # linker.  It appears as though 1/2 is a usable value.
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
    fi
    ;;
  esac
])
if test -n $lt_cv_sys_max_cmd_len ; then
  AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
else
  AC_MSG_RESULT(none)
fi
max_cmd_len=$lt_cv_sys_max_cmd_len
_LT_DECL([], [max_cmd_len], [0],
    [What is the maximum length of a command?])
])# LT_CMD_MAX_LEN

# Old name:
AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], [])


# _LT_HEADER_DLFCN
# ----------------
m4_defun([_LT_HEADER_DLFCN],
[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl
])# _LT_HEADER_DLFCN


# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
#                      ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
# ----------------------------------------------------------------
m4_defun([_LT_TRY_DLOPEN_SELF],
[m4_require([_LT_HEADER_DLFCN])dnl
if test "$cross_compiling" = yes; then :
  [$4]
else
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
  lt_status=$lt_dlunknown
  cat > conftest.$ac_ext <<_LT_EOF
[#line $LINENO "configure"
#include "confdefs.h"

#if HAVE_DLFCN_H
#include 
#endif

#include 

#ifdef RTLD_GLOBAL
#  define LT_DLGLOBAL		RTLD_GLOBAL
#else
#  ifdef DL_GLOBAL
#    define LT_DLGLOBAL		DL_GLOBAL
#  else
#    define LT_DLGLOBAL		0
#  endif
#endif

/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
   find out it does not work in some platform. */
#ifndef LT_DLLAZY_OR_NOW
#  ifdef RTLD_LAZY
#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
#  else
#    ifdef DL_LAZY
#      define LT_DLLAZY_OR_NOW		DL_LAZY
#    else
#      ifdef RTLD_NOW
#        define LT_DLLAZY_OR_NOW	RTLD_NOW
#      else
#        ifdef DL_NOW
#          define LT_DLLAZY_OR_NOW	DL_NOW
#        else
#          define LT_DLLAZY_OR_NOW	0
#        endif
#      endif
#    endif
#  endif
#endif

/* When -fvisbility=hidden is used, assume the code has been annotated
   correspondingly for the symbols needed.  */
#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
int fnord () __attribute__((visibility("default")));
#endif

int fnord () { return 42; }
int main ()
{
  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
  int status = $lt_dlunknown;

  if (self)
    {
      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
      else
        {
	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
          else puts (dlerror ());
	}
      /* dlclose (self); */
    }
  else
    puts (dlerror ());

  return status;
}]
_LT_EOF
  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
    (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
    lt_status=$?
    case x$lt_status in
      x$lt_dlno_uscore) $1 ;;
      x$lt_dlneed_uscore) $2 ;;
      x$lt_dlunknown|x*) $3 ;;
    esac
  else :
    # compilation failed
    $3
  fi
fi
rm -fr conftest*
])# _LT_TRY_DLOPEN_SELF


# LT_SYS_DLOPEN_SELF
# ------------------
AC_DEFUN([LT_SYS_DLOPEN_SELF],
[m4_require([_LT_HEADER_DLFCN])dnl
if test "x$enable_dlopen" != xyes; then
  enable_dlopen=unknown
  enable_dlopen_self=unknown
  enable_dlopen_self_static=unknown
else
  lt_cv_dlopen=no
  lt_cv_dlopen_libs=

  case $host_os in
  beos*)
    lt_cv_dlopen="load_add_on"
    lt_cv_dlopen_libs=
    lt_cv_dlopen_self=yes
    ;;

  mingw* | pw32* | cegcc*)
    lt_cv_dlopen="LoadLibrary"
    lt_cv_dlopen_libs=
    ;;

  cygwin*)
    lt_cv_dlopen="dlopen"
    lt_cv_dlopen_libs=
    ;;

  darwin*)
  # if libdl is installed we need to link against it
    AC_CHECK_LIB([dl], [dlopen],
		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
    lt_cv_dlopen="dyld"
    lt_cv_dlopen_libs=
    lt_cv_dlopen_self=yes
    ])
    ;;

  *)
    AC_CHECK_FUNC([shl_load],
	  [lt_cv_dlopen="shl_load"],
      [AC_CHECK_LIB([dld], [shl_load],
	    [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"],
	[AC_CHECK_FUNC([dlopen],
	      [lt_cv_dlopen="dlopen"],
	  [AC_CHECK_LIB([dl], [dlopen],
		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
	    [AC_CHECK_LIB([svld], [dlopen],
		  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
	      [AC_CHECK_LIB([dld], [dld_link],
		    [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"])
	      ])
	    ])
	  ])
	])
      ])
    ;;
  esac

  if test "x$lt_cv_dlopen" != xno; then
    enable_dlopen=yes
  else
    enable_dlopen=no
  fi

  case $lt_cv_dlopen in
  dlopen)
    save_CPPFLAGS="$CPPFLAGS"
    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"

    save_LDFLAGS="$LDFLAGS"
    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"

    save_LIBS="$LIBS"
    LIBS="$lt_cv_dlopen_libs $LIBS"

    AC_CACHE_CHECK([whether a program can dlopen itself],
	  lt_cv_dlopen_self, [dnl
	  _LT_TRY_DLOPEN_SELF(
	    lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
	    lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
    ])

    if test "x$lt_cv_dlopen_self" = xyes; then
      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
      AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
	  lt_cv_dlopen_self_static, [dnl
	  _LT_TRY_DLOPEN_SELF(
	    lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
	    lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)
      ])
    fi

    CPPFLAGS="$save_CPPFLAGS"
    LDFLAGS="$save_LDFLAGS"
    LIBS="$save_LIBS"
    ;;
  esac

  case $lt_cv_dlopen_self in
  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
  *) enable_dlopen_self=unknown ;;
  esac

  case $lt_cv_dlopen_self_static in
  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
  *) enable_dlopen_self_static=unknown ;;
  esac
fi
_LT_DECL([dlopen_support], [enable_dlopen], [0],
	 [Whether dlopen is supported])
_LT_DECL([dlopen_self], [enable_dlopen_self], [0],
	 [Whether dlopen of programs is supported])
_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0],
	 [Whether dlopen of statically linked programs is supported])
])# LT_SYS_DLOPEN_SELF

# Old name:
AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], [])


# _LT_COMPILER_C_O([TAGNAME])
# ---------------------------
# Check to see if options -c and -o are simultaneously supported by compiler.
# This macro does not hard code the compiler like AC_PROG_CC_C_O.
m4_defun([_LT_COMPILER_C_O],
[m4_require([_LT_DECL_SED])dnl
m4_require([_LT_FILEUTILS_DEFAULTS])dnl
m4_require([_LT_TAG_COMPILER])dnl
AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
  [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
  [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
   $RM -r conftest 2>/dev/null
   mkdir conftest
   cd conftest
   mkdir out
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext

   lt_compiler_flag="-o out/conftest2.$ac_objext"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
   (eval "$lt_compile" 2>out/conftest.err)
   ac_status=$?
   cat out/conftest.err >&AS_MESSAGE_LOG_FD
   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
   then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
       _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
     fi
   fi
   chmod u+w . 2>&AS_MESSAGE_LOG_FD
   $RM conftest*
   # SGI C++ compiler will create directory out/ii_files/ for
   # template instantiation
   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
   $RM out/* && rmdir out
   cd ..
   $RM -r conftest
   $RM conftest*
])
_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1],
	[Does compiler simultaneously support -c and -o options?])
])# _LT_COMPILER_C_O


# _LT_COMPILER_FILE_LOCKS([TAGNAME])
# ----------------------------------
# Check to see if we can do hard links to lock some files if needed
m4_defun([_LT_COMPILER_FILE_LOCKS],
[m4_require([_LT_ENABLE_LOCK])dnl
m4_require([_LT_FILEUTILS_DEFAULTS])dnl
_LT_COMPILER_C_O([$1])

hard_links="nottested"
if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then
  # do not overwrite the value of need_locks provided by the user
  AC_MSG_CHECKING([if we can lock with hard links])
  hard_links=yes
  $RM conftest*
  ln conftest.a conftest.b 2>/dev/null && hard_links=no
  touch conftest.a
  ln conftest.a conftest.b 2>&5 || hard_links=no
  ln conftest.a conftest.b 2>/dev/null && hard_links=no
  AC_MSG_RESULT([$hard_links])
  if test "$hard_links" = no; then
    AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
    need_locks=warn
  fi
else
  need_locks=no
fi
_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?])
])# _LT_COMPILER_FILE_LOCKS


# _LT_CHECK_OBJDIR
# ----------------
m4_defun([_LT_CHECK_OBJDIR],
[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
[rm -f .libs 2>/dev/null
mkdir .libs 2>/dev/null
if test -d .libs; then
  lt_cv_objdir=.libs
else
  # MS-DOS does not allow filenames that begin with a dot.
  lt_cv_objdir=_libs
fi
rmdir .libs 2>/dev/null])
objdir=$lt_cv_objdir
_LT_DECL([], [objdir], [0],
         [The name of the directory that contains temporary libtool files])dnl
m4_pattern_allow([LT_OBJDIR])dnl
AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/",
  [Define to the sub-directory in which libtool stores uninstalled libraries.])
])# _LT_CHECK_OBJDIR


# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME])
# --------------------------------------
# Check hardcoding attributes.
m4_defun([_LT_LINKER_HARDCODE_LIBPATH],
[AC_MSG_CHECKING([how to hardcode library paths into programs])
_LT_TAGVAR(hardcode_action, $1)=
if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
   test -n "$_LT_TAGVAR(runpath_var, $1)" ||
   test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then

  # We can hardcode non-existent directories.
  if test "$_LT_TAGVAR(hardcode_direct, $1)" != no &&
     # If the only mechanism to avoid hardcoding is shlibpath_var, we
     # have to relink, otherwise we might link with an installed library
     # when we should be linking with a yet-to-be-installed one
     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
     test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then
    # Linking always hardcodes the temporary library directory.
    _LT_TAGVAR(hardcode_action, $1)=relink
  else
    # We can link without hardcoding, and we can hardcode nonexisting dirs.
    _LT_TAGVAR(hardcode_action, $1)=immediate
  fi
else
  # We cannot hardcode anything, or else we can only hardcode existing
  # directories.
  _LT_TAGVAR(hardcode_action, $1)=unsupported
fi
AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)])

if test "$_LT_TAGVAR(hardcode_action, $1)" = relink ||
   test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then
  # Fast installation is not supported
  enable_fast_install=no
elif test "$shlibpath_overrides_runpath" = yes ||
     test "$enable_shared" = no; then
  # Fast installation is not necessary
  enable_fast_install=needless
fi
_LT_TAGDECL([], [hardcode_action], [0],
    [How to hardcode a shared library path into an executable])
])# _LT_LINKER_HARDCODE_LIBPATH


# _LT_CMD_STRIPLIB
# ----------------
m4_defun([_LT_CMD_STRIPLIB],
[m4_require([_LT_DECL_EGREP])
striplib=
old_striplib=
AC_MSG_CHECKING([whether stripping libraries is possible])
if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
  AC_MSG_RESULT([yes])
else
# FIXME - insert some real tests, host_os isn't really good enough
  case $host_os in
  darwin*)
    if test -n "$STRIP" ; then
      striplib="$STRIP -x"
      old_striplib="$STRIP -S"
      AC_MSG_RESULT([yes])
    else
      AC_MSG_RESULT([no])
    fi
    ;;
  *)
    AC_MSG_RESULT([no])
    ;;
  esac
fi
_LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
_LT_DECL([], [striplib], [1])
])# _LT_CMD_STRIPLIB


# _LT_SYS_DYNAMIC_LINKER([TAG])
# -----------------------------
# PORTME Fill in your ld.so characteristics
m4_defun([_LT_SYS_DYNAMIC_LINKER],
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
m4_require([_LT_DECL_EGREP])dnl
m4_require([_LT_FILEUTILS_DEFAULTS])dnl
m4_require([_LT_DECL_OBJDUMP])dnl
m4_require([_LT_DECL_SED])dnl
m4_require([_LT_CHECK_SHELL_FEATURES])dnl
AC_MSG_CHECKING([dynamic linker characteristics])
m4_if([$1],
	[], [
if test "$GCC" = yes; then
  case $host_os in
    darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
    *) lt_awk_arg="/^libraries:/" ;;
  esac
  case $host_os in
    mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;;
    *) lt_sed_strip_eq="s,=/,/,g" ;;
  esac
  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
  case $lt_search_path_spec in
  *\;*)
    # if the path contains ";" then we assume it to be the separator
    # otherwise default to the standard path separator (i.e. ":") - it is
    # assumed that no part of a normal pathname contains ";" but that should
    # okay in the real world where ";" in dirpaths is itself problematic.
    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
    ;;
  *)
    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
    ;;
  esac
  # Ok, now we have the path, separated by spaces, we can step through it
  # and add multilib dir if necessary.
  lt_tmp_lt_search_path_spec=
  lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
  for lt_sys_path in $lt_search_path_spec; do
    if test -d "$lt_sys_path/$lt_multi_os_dir"; then
      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir"
    else
      test -d "$lt_sys_path" && \
	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
    fi
  done
  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
BEGIN {RS=" "; FS="/|\n";} {
  lt_foo="";
  lt_count=0;
  for (lt_i = NF; lt_i > 0; lt_i--) {
    if ($lt_i != "" && $lt_i != ".") {
      if ($lt_i == "..") {
        lt_count++;
      } else {
        if (lt_count == 0) {
          lt_foo="/" $lt_i lt_foo;
        } else {
          lt_count--;
        }
      }
    }
  }
  if (lt_foo != "") { lt_freq[[lt_foo]]++; }
  if (lt_freq[[lt_foo]] == 1) { print lt_foo; }
}'`
  # AWK program above erroneously prepends '/' to C:/dos/paths
  # for these hosts.
  case $host_os in
    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
      $SED 's,/\([[A-Za-z]]:\),\1,g'` ;;
  esac
  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
else
  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
fi])
library_names_spec=
libname_spec='lib$name'
soname_spec=
shrext_cmds=".so"
postinstall_cmds=
postuninstall_cmds=
finish_cmds=
finish_eval=
shlibpath_var=
shlibpath_overrides_runpath=unknown
version_type=none
dynamic_linker="$host_os ld.so"
sys_lib_dlsearch_path_spec="/lib /usr/lib"
need_lib_prefix=unknown
hardcode_into_libs=no

# when you set need_version to no, make sure it does not cause -set_version
# flags to be left without arguments
need_version=unknown

case $host_os in
aix3*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
  shlibpath_var=LIBPATH

  # AIX 3 has no versioning support, so we append a major version to the name.
  soname_spec='${libname}${release}${shared_ext}$major'
  ;;

aix[[4-9]]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  hardcode_into_libs=yes
  if test "$host_cpu" = ia64; then
    # AIX 5 supports IA64
    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
    shlibpath_var=LD_LIBRARY_PATH
  else
    # With GCC up to 2.95.x, collect2 would create an import file
    # for dependence libraries.  The import file would start with
    # the line `#! .'.  This would cause the generated library to
    # depend on `.', always an invalid library.  This was fixed in
    # development snapshots of GCC prior to 3.0.
    case $host_os in
      aix4 | aix4.[[01]] | aix4.[[01]].*)
      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
	   echo ' yes '
	   echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
	:
      else
	can_build_shared=no
      fi
      ;;
    esac
    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
    # soname into executable. Probably we can add versioning support to
    # collect2, so additional links can be useful in future.
    if test "$aix_use_runtimelinking" = yes; then
      # If using run time linking (on AIX 4.2 or later) use lib.so
      # instead of lib.a to let people know that these are not
      # typical AIX shared libraries.
      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    else
      # We preserve .a as extension for shared libraries through AIX4.2
      # and later when we are not doing run time linking.
      library_names_spec='${libname}${release}.a $libname.a'
      soname_spec='${libname}${release}${shared_ext}$major'
    fi
    shlibpath_var=LIBPATH
  fi
  ;;

amigaos*)
  case $host_cpu in
  powerpc)
    # Since July 2007 AmigaOS4 officially supports .so libraries.
    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    ;;
  m68k)
    library_names_spec='$libname.ixlibrary $libname.a'
    # Create ${libname}_ixlibrary.a entries in /sys/libs.
    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
    ;;
  esac
  ;;

beos*)
  library_names_spec='${libname}${shared_ext}'
  dynamic_linker="$host_os ld.so"
  shlibpath_var=LIBRARY_PATH
  ;;

bsdi[[45]]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
  # the default ld.so.conf also contains /usr/contrib/lib and
  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
  # libtool to hard-code these into programs
  ;;

cygwin* | mingw* | pw32* | cegcc*)
  version_type=windows
  shrext_cmds=".dll"
  need_version=no
  need_lib_prefix=no

  case $GCC,$cc_basename in
  yes,*)
    # gcc
    library_names_spec='$libname.dll.a'
    # DLL is installed to $(libdir)/../bin by postinstall_cmds
    postinstall_cmds='base_file=`basename \${file}`~
      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
      dldir=$destdir/`dirname \$dlpath`~
      test -d \$dldir || mkdir -p \$dldir~
      $install_prog $dir/$dlname \$dldir/$dlname~
      chmod a+x \$dldir/$dlname~
      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
      fi'
    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
      dlpath=$dir/\$dldll~
       $RM \$dlpath'
    shlibpath_overrides_runpath=yes

    case $host_os in
    cygwin*)
      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
m4_if([$1], [],[
      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"])
      ;;
    mingw* | cegcc*)
      # MinGW DLLs use traditional 'lib' prefix
      soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
      ;;
    pw32*)
      # pw32 DLLs use 'pw' prefix rather than 'lib'
      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
      ;;
    esac
    dynamic_linker='Win32 ld.exe'
    ;;

  *,cl*)
    # Native MSVC
    libname_spec='$name'
    soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
    library_names_spec='${libname}.dll.lib'

    case $build_os in
    mingw*)
      sys_lib_search_path_spec=
      lt_save_ifs=$IFS
      IFS=';'
      for lt_path in $LIB
      do
        IFS=$lt_save_ifs
        # Let DOS variable expansion print the short 8.3 style file name.
        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
      done
      IFS=$lt_save_ifs
      # Convert to MSYS style.
      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'`
      ;;
    cygwin*)
      # Convert to unix form, then to dos form, then back to unix form
      # but this time dos style (no spaces!) so that the unix form looks
      # like /cygdrive/c/PROGRA~1:/cygdr...
      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
      ;;
    *)
      sys_lib_search_path_spec="$LIB"
      if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
        # It is most probably a Windows format PATH.
        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
      else
        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
      fi
      # FIXME: find the short name or the path components, as spaces are
      # common. (e.g. "Program Files" -> "PROGRA~1")
      ;;
    esac

    # DLL is installed to $(libdir)/../bin by postinstall_cmds
    postinstall_cmds='base_file=`basename \${file}`~
      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
      dldir=$destdir/`dirname \$dlpath`~
      test -d \$dldir || mkdir -p \$dldir~
      $install_prog $dir/$dlname \$dldir/$dlname'
    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
      dlpath=$dir/\$dldll~
       $RM \$dlpath'
    shlibpath_overrides_runpath=yes
    dynamic_linker='Win32 link.exe'
    ;;

  *)
    # Assume MSVC wrapper
    library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
    dynamic_linker='Win32 ld.exe'
    ;;
  esac
  # FIXME: first we should search . and the directory the executable is in
  shlibpath_var=PATH
  ;;

darwin* | rhapsody*)
  dynamic_linker="$host_os dyld"
  version_type=darwin
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
  soname_spec='${libname}${release}${major}$shared_ext'
  shlibpath_overrides_runpath=yes
  shlibpath_var=DYLD_LIBRARY_PATH
  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
m4_if([$1], [],[
  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"])
  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
  ;;

dgux*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  ;;

freebsd* | dragonfly*)
  # DragonFly does not have aout.  When/if they implement a new
  # versioning mechanism, adjust this.
  if test -x /usr/bin/objformat; then
    objformat=`/usr/bin/objformat`
  else
    case $host_os in
    freebsd[[23]].*) objformat=aout ;;
    *) objformat=elf ;;
    esac
  fi
  version_type=freebsd-$objformat
  case $version_type in
    freebsd-elf*)
      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
      need_version=no
      need_lib_prefix=no
      ;;
    freebsd-*)
      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
      need_version=yes
      ;;
  esac
  shlibpath_var=LD_LIBRARY_PATH
  case $host_os in
  freebsd2.*)
    shlibpath_overrides_runpath=yes
    ;;
  freebsd3.[[01]]* | freebsdelf3.[[01]]*)
    shlibpath_overrides_runpath=yes
    hardcode_into_libs=yes
    ;;
  freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \
  freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)
    shlibpath_overrides_runpath=no
    hardcode_into_libs=yes
    ;;
  *) # from 4.6 on, and DragonFly
    shlibpath_overrides_runpath=yes
    hardcode_into_libs=yes
    ;;
  esac
  ;;

gnu*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

haiku*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  dynamic_linker="$host_os runtime_loader"
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
  hardcode_into_libs=yes
  ;;

hpux9* | hpux10* | hpux11*)
  # Give a soname corresponding to the major version so that dld.sl refuses to
  # link against other versions.
  version_type=sunos
  need_lib_prefix=no
  need_version=no
  case $host_cpu in
  ia64*)
    shrext_cmds='.so'
    hardcode_into_libs=yes
    dynamic_linker="$host_os dld.so"
    shlibpath_var=LD_LIBRARY_PATH
    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    if test "X$HPUX_IA64_MODE" = X32; then
      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
    else
      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
    fi
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
    ;;
  hppa*64*)
    shrext_cmds='.sl'
    hardcode_into_libs=yes
    dynamic_linker="$host_os dld.sl"
    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
    ;;
  *)
    shrext_cmds='.sl'
    dynamic_linker="$host_os dld.sl"
    shlibpath_var=SHLIB_PATH
    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    ;;
  esac
  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
  postinstall_cmds='chmod 555 $lib'
  # or fails outright, so override atomically:
  install_override_mode=555
  ;;

interix[[3-9]]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

irix5* | irix6* | nonstopux*)
  case $host_os in
    nonstopux*) version_type=nonstopux ;;
    *)
	if test "$lt_cv_prog_gnu_ld" = yes; then
		version_type=linux # correct to gnu/linux during the next big refactor
	else
		version_type=irix
	fi ;;
  esac
  need_lib_prefix=no
  need_version=no
  soname_spec='${libname}${release}${shared_ext}$major'
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
  case $host_os in
  irix5* | nonstopux*)
    libsuff= shlibsuff=
    ;;
  *)
    case $LD in # libtool.m4 will add one of these switches to LD
    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
      libsuff= shlibsuff= libmagic=32-bit;;
    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
      libsuff=32 shlibsuff=N32 libmagic=N32;;
    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
      libsuff=64 shlibsuff=64 libmagic=64-bit;;
    *) libsuff= shlibsuff= libmagic=never-match;;
    esac
    ;;
  esac
  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
  shlibpath_overrides_runpath=no
  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
  hardcode_into_libs=yes
  ;;

# No shared lib support for Linux oldld, aout, or coff.
linux*oldld* | linux*aout* | linux*coff*)
  dynamic_linker=no
  ;;

# This must be glibc/ELF.
linux* | k*bsd*-gnu | kopensolaris*-gnu)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no

  # Some binutils ld are patched to set DT_RUNPATH
  AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath],
    [lt_cv_shlibpath_overrides_runpath=no
    save_LDFLAGS=$LDFLAGS
    save_libdir=$libdir
    eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \
	 LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\""
    AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
      [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null],
	 [lt_cv_shlibpath_overrides_runpath=yes])])
    LDFLAGS=$save_LDFLAGS
    libdir=$save_libdir
    ])
  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath

  # This implies no fast_install, which is unacceptable.
  # Some rework will be needed to allow for fast_install
  # before this can be enabled.
  hardcode_into_libs=yes

  # Add ABI-specific directories to the system library path.
  sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib"

  # Append ld.so.conf contents to the search path
  if test -f /etc/ld.so.conf; then
    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
    sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra"

  fi

  # We used to test for /lib/ld.so.1 and disable shared libraries on
  # powerpc, because MkLinux only supported shared libraries with the
  # GNU dynamic linker.  Since this was broken with cross compilers,
  # most powerpc-linux boxes support dynamic linking these days and
  # people can always --disable-shared, the test was removed, and we
  # assume the GNU/Linux dynamic linker is in use.
  dynamic_linker='GNU/Linux ld.so'
  ;;

netbsd*)
  version_type=sunos
  need_lib_prefix=no
  need_version=no
  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
    dynamic_linker='NetBSD (a.out) ld.so'
  else
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    dynamic_linker='NetBSD ld.elf_so'
  fi
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  ;;

newsos6)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  ;;

*nto* | *qnx*)
  version_type=qnx
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  dynamic_linker='ldqnx.so'
  ;;

openbsd*)
  version_type=sunos
  sys_lib_dlsearch_path_spec="/usr/lib"
  need_lib_prefix=no
  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
  case $host_os in
    openbsd3.3 | openbsd3.3.*)	need_version=yes ;;
    *)				need_version=no  ;;
  esac
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
    case $host_os in
      openbsd2.[[89]] | openbsd2.[[89]].*)
	shlibpath_overrides_runpath=no
	;;
      *)
	shlibpath_overrides_runpath=yes
	;;
      esac
  else
    shlibpath_overrides_runpath=yes
  fi
  ;;

os2*)
  libname_spec='$name'
  shrext_cmds=".dll"
  need_lib_prefix=no
  library_names_spec='$libname${shared_ext} $libname.a'
  dynamic_linker='OS/2 ld.exe'
  shlibpath_var=LIBPATH
  ;;

osf3* | osf4* | osf5*)
  version_type=osf
  need_lib_prefix=no
  need_version=no
  soname_spec='${libname}${release}${shared_ext}$major'
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
  ;;

rdos*)
  dynamic_linker=no
  ;;

solaris*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  # ldd complains unless libraries are executable
  postinstall_cmds='chmod +x $lib'
  ;;

sunos4*)
  version_type=sunos
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  if test "$with_gnu_ld" = yes; then
    need_lib_prefix=no
  fi
  need_version=yes
  ;;

sysv4 | sysv4.3*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  case $host_vendor in
    sni)
      shlibpath_overrides_runpath=no
      need_lib_prefix=no
      runpath_var=LD_RUN_PATH
      ;;
    siemens)
      need_lib_prefix=no
      ;;
    motorola)
      need_lib_prefix=no
      need_version=no
      shlibpath_overrides_runpath=no
      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
      ;;
  esac
  ;;

sysv4*MP*)
  if test -d /usr/nec ;then
    version_type=linux # correct to gnu/linux during the next big refactor
    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
    soname_spec='$libname${shared_ext}.$major'
    shlibpath_var=LD_LIBRARY_PATH
  fi
  ;;

sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
  version_type=freebsd-elf
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  if test "$with_gnu_ld" = yes; then
    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
  else
    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
    case $host_os in
      sco3.2v5*)
        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
	;;
    esac
  fi
  sys_lib_dlsearch_path_spec='/usr/lib'
  ;;

tpf*)
  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

uts4*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  ;;

*)
  dynamic_linker=no
  ;;
esac
AC_MSG_RESULT([$dynamic_linker])
test "$dynamic_linker" = no && can_build_shared=no

variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
if test "$GCC" = yes; then
  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
fi

if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
  sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
fi
if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
  sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
fi

_LT_DECL([], [variables_saved_for_relink], [1],
    [Variables whose values should be saved in libtool wrapper scripts and
    restored at link time])
_LT_DECL([], [need_lib_prefix], [0],
    [Do we need the "lib" prefix for modules?])
_LT_DECL([], [need_version], [0], [Do we need a version for libraries?])
_LT_DECL([], [version_type], [0], [Library versioning type])
_LT_DECL([], [runpath_var], [0],  [Shared library runtime path variable])
_LT_DECL([], [shlibpath_var], [0],[Shared library path variable])
_LT_DECL([], [shlibpath_overrides_runpath], [0],
    [Is shlibpath searched before the hard-coded library search path?])
_LT_DECL([], [libname_spec], [1], [Format of library name prefix])
_LT_DECL([], [library_names_spec], [1],
    [[List of archive names.  First name is the real one, the rest are links.
    The last name is the one that the linker finds with -lNAME]])
_LT_DECL([], [soname_spec], [1],
    [[The coded name of the library, if different from the real name]])
_LT_DECL([], [install_override_mode], [1],
    [Permission mode override for installation of shared libraries])
_LT_DECL([], [postinstall_cmds], [2],
    [Command to use after installation of a shared archive])
_LT_DECL([], [postuninstall_cmds], [2],
    [Command to use after uninstallation of a shared archive])
_LT_DECL([], [finish_cmds], [2],
    [Commands used to finish a libtool library installation in a directory])
_LT_DECL([], [finish_eval], [1],
    [[As "finish_cmds", except a single script fragment to be evaled but
    not shown]])
_LT_DECL([], [hardcode_into_libs], [0],
    [Whether we should hardcode library paths into libraries])
_LT_DECL([], [sys_lib_search_path_spec], [2],
    [Compile-time system search path for libraries])
_LT_DECL([], [sys_lib_dlsearch_path_spec], [2],
    [Run-time system search path for libraries])
])# _LT_SYS_DYNAMIC_LINKER


# _LT_PATH_TOOL_PREFIX(TOOL)
# --------------------------
# find a file program which can recognize shared library
AC_DEFUN([_LT_PATH_TOOL_PREFIX],
[m4_require([_LT_DECL_EGREP])dnl
AC_MSG_CHECKING([for $1])
AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
[case $MAGIC_CMD in
[[\\/*] |  ?:[\\/]*])
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
  ;;
*)
  lt_save_MAGIC_CMD="$MAGIC_CMD"
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
dnl $ac_dummy forces splitting on constant user-supplied paths.
dnl POSIX.2 word splitting is done only on the output of word expansions,
dnl not every word.  This closes a longstanding sh security hole.
  ac_dummy="m4_if([$2], , $PATH, [$2])"
  for ac_dir in $ac_dummy; do
    IFS="$lt_save_ifs"
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$1; then
      lt_cv_path_MAGIC_CMD="$ac_dir/$1"
      if test -n "$file_magic_test_file"; then
	case $deplibs_check_method in
	"file_magic "*)
	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
	    $EGREP "$file_magic_regex" > /dev/null; then
	    :
	  else
	    cat <<_LT_EOF 1>&2

*** Warning: the command libtool uses to detect shared libraries,
*** $file_magic_cmd, produces output that libtool cannot recognize.
*** The result is that libtool may fail to recognize shared libraries
*** as such.  This will affect the creation of libtool libraries that
*** depend on shared libraries, but programs linked with such libtool
*** libraries will work regardless of this problem.  Nevertheless, you
*** may want to report the problem to your system manager and/or to
*** bug-libtool@gnu.org

_LT_EOF
	  fi ;;
	esac
      fi
      break
    fi
  done
  IFS="$lt_save_ifs"
  MAGIC_CMD="$lt_save_MAGIC_CMD"
  ;;
esac])
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
if test -n "$MAGIC_CMD"; then
  AC_MSG_RESULT($MAGIC_CMD)
else
  AC_MSG_RESULT(no)
fi
_LT_DECL([], [MAGIC_CMD], [0],
	 [Used to examine libraries when file_magic_cmd begins with "file"])dnl
])# _LT_PATH_TOOL_PREFIX

# Old name:
AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], [])


# _LT_PATH_MAGIC
# --------------
# find a file program which can recognize a shared library
m4_defun([_LT_PATH_MAGIC],
[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
if test -z "$lt_cv_path_MAGIC_CMD"; then
  if test -n "$ac_tool_prefix"; then
    _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
  else
    MAGIC_CMD=:
  fi
fi
])# _LT_PATH_MAGIC


# LT_PATH_LD
# ----------
# find the pathname to the GNU or non-GNU linker
AC_DEFUN([LT_PATH_LD],
[AC_REQUIRE([AC_PROG_CC])dnl
AC_REQUIRE([AC_CANONICAL_HOST])dnl
AC_REQUIRE([AC_CANONICAL_BUILD])dnl
m4_require([_LT_DECL_SED])dnl
m4_require([_LT_DECL_EGREP])dnl
m4_require([_LT_PROG_ECHO_BACKSLASH])dnl

AC_ARG_WITH([gnu-ld],
    [AS_HELP_STRING([--with-gnu-ld],
	[assume the C compiler uses GNU ld @<:@default=no@:>@])],
    [test "$withval" = no || with_gnu_ld=yes],
    [with_gnu_ld=no])dnl

ac_prog=ld
if test "$GCC" = yes; then
  # Check if gcc -print-prog-name=ld gives a path.
  AC_MSG_CHECKING([for ld used by $CC])
  case $host in
  *-*-mingw*)
    # gcc leaves a trailing carriage return which upsets mingw
    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
  *)
    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
  esac
  case $ac_prog in
    # Accept absolute paths.
    [[\\/]]* | ?:[[\\/]]*)
      re_direlt='/[[^/]][[^/]]*/\.\./'
      # Canonicalize the pathname of ld
      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
      done
      test -z "$LD" && LD="$ac_prog"
      ;;
  "")
    # If it fails, then pretend we aren't using GCC.
    ac_prog=ld
    ;;
  *)
    # If it is relative, then search for the first ld in PATH.
    with_gnu_ld=unknown
    ;;
  esac
elif test "$with_gnu_ld" = yes; then
  AC_MSG_CHECKING([for GNU ld])
else
  AC_MSG_CHECKING([for non-GNU ld])
fi
AC_CACHE_VAL(lt_cv_path_LD,
[if test -z "$LD"; then
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
  for ac_dir in $PATH; do
    IFS="$lt_save_ifs"
    test -z "$ac_dir" && ac_dir=.
    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
      lt_cv_path_LD="$ac_dir/$ac_prog"
      # Check to see if the program is GNU ld.  I'd rather use --version,
      # but apparently some variants of GNU ld only accept -v.
      # Break only if it was the GNU/non-GNU ld that we prefer.
      case `"$lt_cv_path_LD" -v 2>&1 &1 /dev/null 2>&1; then
    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
    lt_cv_file_magic_cmd='func_win32_libid'
  else
    # Keep this pattern in sync with the one in func_win32_libid.
    lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
    lt_cv_file_magic_cmd='$OBJDUMP -f'
  fi
  ;;

cegcc*)
  # use the weaker test based on 'objdump'. See mingw*.
  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
  lt_cv_file_magic_cmd='$OBJDUMP -f'
  ;;

darwin* | rhapsody*)
  lt_cv_deplibs_check_method=pass_all
  ;;

freebsd* | dragonfly*)
  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
    case $host_cpu in
    i*86 )
      # Not sure whether the presence of OpenBSD here was a mistake.
      # Let's accept both of them until this is cleared up.
      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
      lt_cv_file_magic_cmd=/usr/bin/file
      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
      ;;
    esac
  else
    lt_cv_deplibs_check_method=pass_all
  fi
  ;;

gnu*)
  lt_cv_deplibs_check_method=pass_all
  ;;

haiku*)
  lt_cv_deplibs_check_method=pass_all
  ;;

hpux10.20* | hpux11*)
  lt_cv_file_magic_cmd=/usr/bin/file
  case $host_cpu in
  ia64*)
    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
    ;;
  hppa*64*)
    [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]']
    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
    ;;
  *)
    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library'
    lt_cv_file_magic_test_file=/usr/lib/libc.sl
    ;;
  esac
  ;;

interix[[3-9]]*)
  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
  lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'
  ;;

irix5* | irix6* | nonstopux*)
  case $LD in
  *-32|*"-32 ") libmagic=32-bit;;
  *-n32|*"-n32 ") libmagic=N32;;
  *-64|*"-64 ") libmagic=64-bit;;
  *) libmagic=never-match;;
  esac
  lt_cv_deplibs_check_method=pass_all
  ;;

# This must be glibc/ELF.
linux* | k*bsd*-gnu | kopensolaris*-gnu)
  lt_cv_deplibs_check_method=pass_all
  ;;

netbsd*)
  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
  else
    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
  fi
  ;;

newos6*)
  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
  lt_cv_file_magic_cmd=/usr/bin/file
  lt_cv_file_magic_test_file=/usr/lib/libnls.so
  ;;

*nto* | *qnx*)
  lt_cv_deplibs_check_method=pass_all
  ;;

openbsd*)
  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
  else
    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
  fi
  ;;

osf3* | osf4* | osf5*)
  lt_cv_deplibs_check_method=pass_all
  ;;

rdos*)
  lt_cv_deplibs_check_method=pass_all
  ;;

solaris*)
  lt_cv_deplibs_check_method=pass_all
  ;;

sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
  lt_cv_deplibs_check_method=pass_all
  ;;

sysv4 | sysv4.3*)
  case $host_vendor in
  motorola)
    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
    ;;
  ncr)
    lt_cv_deplibs_check_method=pass_all
    ;;
  sequent)
    lt_cv_file_magic_cmd='/bin/file'
    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
    ;;
  sni)
    lt_cv_file_magic_cmd='/bin/file'
    lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
    lt_cv_file_magic_test_file=/lib/libc.so
    ;;
  siemens)
    lt_cv_deplibs_check_method=pass_all
    ;;
  pc)
    lt_cv_deplibs_check_method=pass_all
    ;;
  esac
  ;;

tpf*)
  lt_cv_deplibs_check_method=pass_all
  ;;
esac
])

file_magic_glob=
want_nocaseglob=no
if test "$build" = "$host"; then
  case $host_os in
  mingw* | pw32*)
    if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
      want_nocaseglob=yes
    else
      file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"`
    fi
    ;;
  esac
fi

file_magic_cmd=$lt_cv_file_magic_cmd
deplibs_check_method=$lt_cv_deplibs_check_method
test -z "$deplibs_check_method" && deplibs_check_method=unknown

_LT_DECL([], [deplibs_check_method], [1],
    [Method to check whether dependent libraries are shared objects])
_LT_DECL([], [file_magic_cmd], [1],
    [Command to use when deplibs_check_method = "file_magic"])
_LT_DECL([], [file_magic_glob], [1],
    [How to find potential files when deplibs_check_method = "file_magic"])
_LT_DECL([], [want_nocaseglob], [1],
    [Find potential files using nocaseglob when deplibs_check_method = "file_magic"])
])# _LT_CHECK_MAGIC_METHOD


# LT_PATH_NM
# ----------
# find the pathname to a BSD- or MS-compatible name lister
AC_DEFUN([LT_PATH_NM],
[AC_REQUIRE([AC_PROG_CC])dnl
AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM,
[if test -n "$NM"; then
  # Let the user override the test.
  lt_cv_path_NM="$NM"
else
  lt_nm_to_check="${ac_tool_prefix}nm"
  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
    lt_nm_to_check="$lt_nm_to_check nm"
  fi
  for lt_tmp_nm in $lt_nm_to_check; do
    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
      IFS="$lt_save_ifs"
      test -z "$ac_dir" && ac_dir=.
      tmp_nm="$ac_dir/$lt_tmp_nm"
      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
	# Check to see if the nm accepts a BSD-compat flag.
	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
	#   nm: unknown option "B" ignored
	# Tru64's nm complains that /dev/null is an invalid object file
	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
	*/dev/null* | *'Invalid file or object type'*)
	  lt_cv_path_NM="$tmp_nm -B"
	  break
	  ;;
	*)
	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
	  */dev/null*)
	    lt_cv_path_NM="$tmp_nm -p"
	    break
	    ;;
	  *)
	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
	    continue # so that we can try to find one that supports BSD flags
	    ;;
	  esac
	  ;;
	esac
      fi
    done
    IFS="$lt_save_ifs"
  done
  : ${lt_cv_path_NM=no}
fi])
if test "$lt_cv_path_NM" != "no"; then
  NM="$lt_cv_path_NM"
else
  # Didn't find any BSD compatible name lister, look for dumpbin.
  if test -n "$DUMPBIN"; then :
    # Let the user override the test.
  else
    AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :)
    case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in
    *COFF*)
      DUMPBIN="$DUMPBIN -symbols"
      ;;
    *)
      DUMPBIN=:
      ;;
    esac
  fi
  AC_SUBST([DUMPBIN])
  if test "$DUMPBIN" != ":"; then
    NM="$DUMPBIN"
  fi
fi
test -z "$NM" && NM=nm
AC_SUBST([NM])
_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl

AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface],
  [lt_cv_nm_interface="BSD nm"
  echo "int some_variable = 0;" > conftest.$ac_ext
  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD)
  (eval "$ac_compile" 2>conftest.err)
  cat conftest.err >&AS_MESSAGE_LOG_FD
  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD)
  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
  cat conftest.err >&AS_MESSAGE_LOG_FD
  (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD)
  cat conftest.out >&AS_MESSAGE_LOG_FD
  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
    lt_cv_nm_interface="MS dumpbin"
  fi
  rm -f conftest*])
])# LT_PATH_NM

# Old names:
AU_ALIAS([AM_PROG_NM], [LT_PATH_NM])
AU_ALIAS([AC_PROG_NM], [LT_PATH_NM])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AM_PROG_NM], [])
dnl AC_DEFUN([AC_PROG_NM], [])

# _LT_CHECK_SHAREDLIB_FROM_LINKLIB
# --------------------------------
# how to determine the name of the shared library
# associated with a specific link library.
#  -- PORTME fill in with the dynamic library characteristics
m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB],
[m4_require([_LT_DECL_EGREP])
m4_require([_LT_DECL_OBJDUMP])
m4_require([_LT_DECL_DLLTOOL])
AC_CACHE_CHECK([how to associate runtime and link libraries],
lt_cv_sharedlib_from_linklib_cmd,
[lt_cv_sharedlib_from_linklib_cmd='unknown'

case $host_os in
cygwin* | mingw* | pw32* | cegcc*)
  # two different shell functions defined in ltmain.sh
  # decide which to use based on capabilities of $DLLTOOL
  case `$DLLTOOL --help 2>&1` in
  *--identify-strict*)
    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
    ;;
  *)
    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
    ;;
  esac
  ;;
*)
  # fallback: assume linklib IS sharedlib
  lt_cv_sharedlib_from_linklib_cmd="$ECHO"
  ;;
esac
])
sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO

_LT_DECL([], [sharedlib_from_linklib_cmd], [1],
    [Command to associate shared and link libraries])
])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB


# _LT_PATH_MANIFEST_TOOL
# ----------------------
# locate the manifest tool
m4_defun([_LT_PATH_MANIFEST_TOOL],
[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :)
test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool],
  [lt_cv_path_mainfest_tool=no
  echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD
  $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
  cat conftest.err >&AS_MESSAGE_LOG_FD
  if $GREP 'Manifest Tool' conftest.out > /dev/null; then
    lt_cv_path_mainfest_tool=yes
  fi
  rm -f conftest*])
if test "x$lt_cv_path_mainfest_tool" != xyes; then
  MANIFEST_TOOL=:
fi
_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl
])# _LT_PATH_MANIFEST_TOOL


# LT_LIB_M
# --------
# check for math library
AC_DEFUN([LT_LIB_M],
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
LIBM=
case $host in
*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*)
  # These system don't have libm, or don't need it
  ;;
*-ncr-sysv4.3*)
  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
  AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
  ;;
*)
  AC_CHECK_LIB(m, cos, LIBM="-lm")
  ;;
esac
AC_SUBST([LIBM])
])# LT_LIB_M

# Old name:
AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_CHECK_LIBM], [])


# _LT_COMPILER_NO_RTTI([TAGNAME])
# -------------------------------
m4_defun([_LT_COMPILER_NO_RTTI],
[m4_require([_LT_TAG_COMPILER])dnl

_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=

if test "$GCC" = yes; then
  case $cc_basename in
  nvcc*)
    _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;;
  *)
    _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;;
  esac

  _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
    lt_cv_prog_compiler_rtti_exceptions,
    [-fno-rtti -fno-exceptions], [],
    [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
fi
_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1],
	[Compiler flag to turn off builtin functions])
])# _LT_COMPILER_NO_RTTI


# _LT_CMD_GLOBAL_SYMBOLS
# ----------------------
m4_defun([_LT_CMD_GLOBAL_SYMBOLS],
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
AC_REQUIRE([AC_PROG_CC])dnl
AC_REQUIRE([AC_PROG_AWK])dnl
AC_REQUIRE([LT_PATH_NM])dnl
AC_REQUIRE([LT_PATH_LD])dnl
m4_require([_LT_DECL_SED])dnl
m4_require([_LT_DECL_EGREP])dnl
m4_require([_LT_TAG_COMPILER])dnl

# Check for command to grab the raw symbol name followed by C symbol from nm.
AC_MSG_CHECKING([command to parse $NM output from $compiler object])
AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
[
# These are sane defaults that work on at least a few old systems.
# [They come from Ultrix.  What could be older than Ultrix?!! ;)]

# Character class describing NM global symbol codes.
symcode='[[BCDEGRST]]'

# Regexp to match symbols that can be accessed directly from C.
sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'

# Define system-specific variables.
case $host_os in
aix*)
  symcode='[[BCDT]]'
  ;;
cygwin* | mingw* | pw32* | cegcc*)
  symcode='[[ABCDGISTW]]'
  ;;
hpux*)
  if test "$host_cpu" = ia64; then
    symcode='[[ABCDEGRST]]'
  fi
  ;;
irix* | nonstopux*)
  symcode='[[BCDEGRST]]'
  ;;
osf*)
  symcode='[[BCDEGQRST]]'
  ;;
solaris*)
  symcode='[[BDRT]]'
  ;;
sco3.2v5*)
  symcode='[[DT]]'
  ;;
sysv4.2uw2*)
  symcode='[[DT]]'
  ;;
sysv5* | sco5v6* | unixware* | OpenUNIX*)
  symcode='[[ABDT]]'
  ;;
sysv4)
  symcode='[[DFNSTU]]'
  ;;
esac

# If we're using GNU nm, then use its standard symbol codes.
case `$NM -V 2>&1` in
*GNU* | *'with BFD'*)
  symcode='[[ABCDGIRSTW]]' ;;
esac

# Transform an extracted symbol line into a proper C declaration.
# Some systems (esp. on ia64) link data and code symbols differently,
# so use this general approach.
lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"

# Transform an extracted symbol line into symbol name and symbol address
lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (void *) \&\2},/p'"
lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/  {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"lib\2\", (void *) \&\2},/p'"

# Handle CRLF in mingw tool chain
opt_cr=
case $build_os in
mingw*)
  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
  ;;
esac

# Try without a prefix underscore, then with it.
for ac_symprfx in "" "_"; do

  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
  symxfrm="\\1 $ac_symprfx\\2 \\2"

  # Write the raw and C identifiers.
  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
    # Fake it for dumpbin and say T for any non-static function
    # and D for any global variable.
    # Also find C++ and __fastcall symbols from MSVC++,
    # which start with @ or ?.
    lt_cv_sys_global_symbol_pipe="$AWK ['"\
"     {last_section=section; section=\$ 3};"\
"     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
"     \$ 0!~/External *\|/{next};"\
"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
"     {if(hide[section]) next};"\
"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
"     ' prfx=^$ac_symprfx]"
  else
    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[	 ]]\($symcode$symcode*\)[[	 ]][[	 ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
  fi
  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"

  # Check to see that the pipe works correctly.
  pipe_works=no

  rm -f conftest*
  cat > conftest.$ac_ext <<_LT_EOF
#ifdef __cplusplus
extern "C" {
#endif
char nm_test_var;
void nm_test_func(void);
void nm_test_func(void){}
#ifdef __cplusplus
}
#endif
int main(){nm_test_var='a';nm_test_func();return(0);}
_LT_EOF

  if AC_TRY_EVAL(ac_compile); then
    # Now try to grab the symbols.
    nlist=conftest.nm
    if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then
      # Try sorting and uniquifying the output.
      if sort "$nlist" | uniq > "$nlist"T; then
	mv -f "$nlist"T "$nlist"
      else
	rm -f "$nlist"T
      fi

      # Make sure that we snagged all the symbols we need.
      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
	  cat <<_LT_EOF > conftest.$ac_ext
/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
/* DATA imports from DLLs on WIN32 con't be const, because runtime
   relocations are performed -- see ld's documentation on pseudo-relocs.  */
# define LT@&t@_DLSYM_CONST
#elif defined(__osf__)
/* This system does not cope well with relocations in const data.  */
# define LT@&t@_DLSYM_CONST
#else
# define LT@&t@_DLSYM_CONST const
#endif

#ifdef __cplusplus
extern "C" {
#endif

_LT_EOF
	  # Now generate the symbol file.
	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'

	  cat <<_LT_EOF >> conftest.$ac_ext

/* The mapping between symbol names and symbols.  */
LT@&t@_DLSYM_CONST struct {
  const char *name;
  void       *address;
}
lt__PROGRAM__LTX_preloaded_symbols[[]] =
{
  { "@PROGRAM@", (void *) 0 },
_LT_EOF
	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
	  cat <<\_LT_EOF >> conftest.$ac_ext
  {0, (void *) 0}
};

/* This works around a problem in FreeBSD linker */
#ifdef FREEBSD_WORKAROUND
static const void *lt_preloaded_setup() {
  return lt__PROGRAM__LTX_preloaded_symbols;
}
#endif

#ifdef __cplusplus
}
#endif
_LT_EOF
	  # Now try linking the two files.
	  mv conftest.$ac_objext conftstm.$ac_objext
	  lt_globsym_save_LIBS=$LIBS
	  lt_globsym_save_CFLAGS=$CFLAGS
	  LIBS="conftstm.$ac_objext"
	  CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
	  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
	    pipe_works=yes
	  fi
	  LIBS=$lt_globsym_save_LIBS
	  CFLAGS=$lt_globsym_save_CFLAGS
	else
	  echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
	fi
      else
	echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
      fi
    else
      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
    fi
  else
    echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
    cat conftest.$ac_ext >&5
  fi
  rm -rf conftest* conftst*

  # Do not use the global_symbol_pipe unless it works.
  if test "$pipe_works" = yes; then
    break
  else
    lt_cv_sys_global_symbol_pipe=
  fi
done
])
if test -z "$lt_cv_sys_global_symbol_pipe"; then
  lt_cv_sys_global_symbol_to_cdecl=
fi
if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
  AC_MSG_RESULT(failed)
else
  AC_MSG_RESULT(ok)
fi

# Response file support.
if test "$lt_cv_nm_interface" = "MS dumpbin"; then
  nm_file_list_spec='@'
elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then
  nm_file_list_spec='@'
fi

_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
    [Take the output of nm and produce a listing of raw symbols and C names])
_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
    [Transform the output of nm in a proper C declaration])
_LT_DECL([global_symbol_to_c_name_address],
    [lt_cv_sys_global_symbol_to_c_name_address], [1],
    [Transform the output of nm in a C name address pair])
_LT_DECL([global_symbol_to_c_name_address_lib_prefix],
    [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1],
    [Transform the output of nm in a C name address pair when lib prefix is needed])
_LT_DECL([], [nm_file_list_spec], [1],
    [Specify filename containing input files for $NM])
]) # _LT_CMD_GLOBAL_SYMBOLS


# _LT_COMPILER_PIC([TAGNAME])
# ---------------------------
m4_defun([_LT_COMPILER_PIC],
[m4_require([_LT_TAG_COMPILER])dnl
_LT_TAGVAR(lt_prog_compiler_wl, $1)=
_LT_TAGVAR(lt_prog_compiler_pic, $1)=
_LT_TAGVAR(lt_prog_compiler_static, $1)=

m4_if([$1], [CXX], [
  # C++ specific cases for pic, static, wl, etc.
  if test "$GXX" = yes; then
    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'

    case $host_os in
    aix*)
      # All AIX code is PIC.
      if test "$host_cpu" = ia64; then
	# AIX 5 now supports IA64 processor
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      fi
      ;;

    amigaos*)
      case $host_cpu in
      powerpc)
            # see comment about AmigaOS4 .so support
            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
        ;;
      m68k)
            # FIXME: we need at least 68020 code to build shared libraries, but
            # adding the `-m68020' flag to GCC prevents building anything better,
            # like `-m68040'.
            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
        ;;
      esac
      ;;

    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
      # PIC is the default for these OSes.
      ;;
    mingw* | cygwin* | os2* | pw32* | cegcc*)
      # This hack is so that the source file can tell whether it is being
      # built for inclusion in a dll (and should export symbols for example).
      # Although the cygwin gcc ignores -fPIC, still need this for old-style
      # (--disable-auto-import) libraries
      m4_if([$1], [GCJ], [],
	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
      ;;
    darwin* | rhapsody*)
      # PIC is the default on this platform
      # Common symbols not allowed in MH_DYLIB files
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
      ;;
    *djgpp*)
      # DJGPP does not support shared libraries at all
      _LT_TAGVAR(lt_prog_compiler_pic, $1)=
      ;;
    haiku*)
      # PIC is the default for Haiku.
      # The "-static" flag exists, but is broken.
      _LT_TAGVAR(lt_prog_compiler_static, $1)=
      ;;
    interix[[3-9]]*)
      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
      # Instead, we relocate shared libraries at runtime.
      ;;
    sysv4*MP*)
      if test -d /usr/nec; then
	_LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
      fi
      ;;
    hpux*)
      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
      # sets the default TLS model and affects inlining.
      case $host_cpu in
      hppa*64*)
	;;
      *)
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
	;;
      esac
      ;;
    *qnx* | *nto*)
      # QNX uses GNU C++, but need to define -shared option too, otherwise
      # it will coredump.
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
      ;;
    *)
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
      ;;
    esac
  else
    case $host_os in
      aix[[4-9]]*)
	# All AIX code is PIC.
	if test "$host_cpu" = ia64; then
	  # AIX 5 now supports IA64 processor
	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	else
	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
	fi
	;;
      chorus*)
	case $cc_basename in
	cxch68*)
	  # Green Hills C++ Compiler
	  # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
	  ;;
	esac
	;;
      mingw* | cygwin* | os2* | pw32* | cegcc*)
	# This hack is so that the source file can tell whether it is being
	# built for inclusion in a dll (and should export symbols for example).
	m4_if([$1], [GCJ], [],
	  [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
	;;
      dgux*)
	case $cc_basename in
	  ec++*)
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	    ;;
	  ghcx*)
	    # Green Hills C++ Compiler
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
	    ;;
	  *)
	    ;;
	esac
	;;
      freebsd* | dragonfly*)
	# FreeBSD uses GNU C++
	;;
      hpux9* | hpux10* | hpux11*)
	case $cc_basename in
	  CC*)
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
	    if test "$host_cpu" != ia64; then
	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
	    fi
	    ;;
	  aCC*)
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
	    case $host_cpu in
	    hppa*64*|ia64*)
	      # +Z the default
	      ;;
	    *)
	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
	      ;;
	    esac
	    ;;
	  *)
	    ;;
	esac
	;;
      interix*)
	# This is c89, which is MS Visual C++ (no shared libs)
	# Anyone wants to do a port?
	;;
      irix5* | irix6* | nonstopux*)
	case $cc_basename in
	  CC*)
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
	    # CC pic flag -KPIC is the default.
	    ;;
	  *)
	    ;;
	esac
	;;
      linux* | k*bsd*-gnu | kopensolaris*-gnu)
	case $cc_basename in
	  KCC*)
	    # KAI C++ Compiler
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
	    ;;
	  ecpc* )
	    # old Intel C++ for x86_64 which still supported -KPIC.
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
	    ;;
	  icpc* )
	    # Intel C++, used to be incompatible with GCC.
	    # ICC 10 doesn't accept -KPIC any more.
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
	    ;;
	  pgCC* | pgcpp*)
	    # Portland Group C++ compiler
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	    ;;
	  cxx*)
	    # Compaq C++
	    # Make sure the PIC flag is empty.  It appears that all Alpha
	    # Linux and Compaq Tru64 Unix objects are PIC.
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
	    ;;
	  xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*)
	    # IBM XL 8.0, 9.0 on PPC and BlueGene
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
	    ;;
	  *)
	    case `$CC -V 2>&1 | sed 5q` in
	    *Sun\ C*)
	      # Sun C++ 5.9
	      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
	      ;;
	    esac
	    ;;
	esac
	;;
      lynxos*)
	;;
      m88k*)
	;;
      mvs*)
	case $cc_basename in
	  cxx*)
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
	    ;;
	  *)
	    ;;
	esac
	;;
      netbsd*)
	;;
      *qnx* | *nto*)
        # QNX uses GNU C++, but need to define -shared option too, otherwise
        # it will coredump.
        _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
        ;;
      osf3* | osf4* | osf5*)
	case $cc_basename in
	  KCC*)
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
	    ;;
	  RCC*)
	    # Rational C++ 2.4.1
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
	    ;;
	  cxx*)
	    # Digital/Compaq C++
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    # Make sure the PIC flag is empty.  It appears that all Alpha
	    # Linux and Compaq Tru64 Unix objects are PIC.
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
	    ;;
	  *)
	    ;;
	esac
	;;
      psos*)
	;;
      solaris*)
	case $cc_basename in
	  CC* | sunCC*)
	    # Sun C++ 4.2, 5.x and Centerline C++
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
	    ;;
	  gcx*)
	    # Green Hills C++ Compiler
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
	    ;;
	  *)
	    ;;
	esac
	;;
      sunos4*)
	case $cc_basename in
	  CC*)
	    # Sun C++ 4.x
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	    ;;
	  lcc*)
	    # Lucid
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
	    ;;
	  *)
	    ;;
	esac
	;;
      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
	case $cc_basename in
	  CC*)
	    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	    _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	    ;;
	esac
	;;
      tandem*)
	case $cc_basename in
	  NCC*)
	    # NonStop-UX NCC 3.20
	    _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	    ;;
	  *)
	    ;;
	esac
	;;
      vxworks*)
	;;
      *)
	_LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
	;;
    esac
  fi
],
[
  if test "$GCC" = yes; then
    _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
    _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'

    case $host_os in
      aix*)
      # All AIX code is PIC.
      if test "$host_cpu" = ia64; then
	# AIX 5 now supports IA64 processor
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      fi
      ;;

    amigaos*)
      case $host_cpu in
      powerpc)
            # see comment about AmigaOS4 .so support
            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
        ;;
      m68k)
            # FIXME: we need at least 68020 code to build shared libraries, but
            # adding the `-m68020' flag to GCC prevents building anything better,
            # like `-m68040'.
            _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
        ;;
      esac
      ;;

    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
      # PIC is the default for these OSes.
      ;;

    mingw* | cygwin* | pw32* | os2* | cegcc*)
      # This hack is so that the source file can tell whether it is being
      # built for inclusion in a dll (and should export symbols for example).
      # Although the cygwin gcc ignores -fPIC, still need this for old-style
      # (--disable-auto-import) libraries
      m4_if([$1], [GCJ], [],
	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
      ;;

    darwin* | rhapsody*)
      # PIC is the default on this platform
      # Common symbols not allowed in MH_DYLIB files
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
      ;;

    haiku*)
      # PIC is the default for Haiku.
      # The "-static" flag exists, but is broken.
      _LT_TAGVAR(lt_prog_compiler_static, $1)=
      ;;

    hpux*)
      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
      # sets the default TLS model and affects inlining.
      case $host_cpu in
      hppa*64*)
	# +Z the default
	;;
      *)
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
	;;
      esac
      ;;

    interix[[3-9]]*)
      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
      # Instead, we relocate shared libraries at runtime.
      ;;

    msdosdjgpp*)
      # Just because we use GCC doesn't mean we suddenly get shared libraries
      # on systems that don't support them.
      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
      enable_shared=no
      ;;

    *nto* | *qnx*)
      # QNX uses GNU C++, but need to define -shared option too, otherwise
      # it will coredump.
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
      ;;

    sysv4*MP*)
      if test -d /usr/nec; then
	_LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
      fi
      ;;

    *)
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
      ;;
    esac

    case $cc_basename in
    nvcc*) # Cuda Compiler Driver 2.2
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker '
      if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
        _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)"
      fi
      ;;
    esac
  else
    # PORTME Check for flag to pass linker flags through the system compiler.
    case $host_os in
    aix*)
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
      if test "$host_cpu" = ia64; then
	# AIX 5 now supports IA64 processor
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      else
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
      fi
      ;;

    mingw* | cygwin* | pw32* | os2* | cegcc*)
      # This hack is so that the source file can tell whether it is being
      # built for inclusion in a dll (and should export symbols for example).
      m4_if([$1], [GCJ], [],
	[_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
      ;;

    hpux9* | hpux10* | hpux11*)
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
      # not for PA HP-UX.
      case $host_cpu in
      hppa*64*|ia64*)
	# +Z the default
	;;
      *)
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
	;;
      esac
      # Is there a better lt_prog_compiler_static that works with the bundled CC?
      _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
      ;;

    irix5* | irix6* | nonstopux*)
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
      # PIC (with -KPIC) is the default.
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
      ;;

    linux* | k*bsd*-gnu | kopensolaris*-gnu)
      case $cc_basename in
      # old Intel for x86_64 which still supported -KPIC.
      ecc*)
	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
        ;;
      # icc used to be incompatible with GCC.
      # ICC 10 doesn't accept -KPIC any more.
      icc* | ifort*)
	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
        ;;
      # Lahey Fortran 8.1.
      lf95*)
	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared'
	_LT_TAGVAR(lt_prog_compiler_static, $1)='--static'
	;;
      nagfor*)
	# NAG Fortran compiler
	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,'
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	;;
      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
        # Portland Group compilers (*not* the Pentium gcc compiler,
	# which looks to be a dead project)
	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
        ;;
      ccc*)
        _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
        # All Alpha code is PIC.
        _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
        ;;
      xl* | bgxl* | bgf* | mpixl*)
	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
	;;
      *)
	case `$CC -V 2>&1 | sed 5q` in
	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*)
	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	  _LT_TAGVAR(lt_prog_compiler_wl, $1)=''
	  ;;
	*Sun\ F* | *Sun*Fortran*)
	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
	  ;;
	*Sun\ C*)
	  # Sun C 5.9
	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	  ;;
        *Intel*\ [[CF]]*Compiler*)
	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
	  ;;
	*Portland\ Group*)
	  _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
	  _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
	  _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
	  ;;
	esac
	;;
      esac
      ;;

    newsos6)
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      ;;

    *nto* | *qnx*)
      # QNX uses GNU C++, but need to define -shared option too, otherwise
      # it will coredump.
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
      ;;

    osf3* | osf4* | osf5*)
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
      # All OSF/1 code is PIC.
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
      ;;

    rdos*)
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
      ;;

    solaris*)
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      case $cc_basename in
      f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;
      *)
	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;
      esac
      ;;

    sunos4*)
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      ;;

    sysv4 | sysv4.2uw2* | sysv4.3*)
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      ;;

    sysv4*MP*)
      if test -d /usr/nec ;then
	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
	_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      fi
      ;;

    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      ;;

    unicos*)
      _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
      ;;

    uts4*)
      _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
      _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
      ;;

    *)
      _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
      ;;
    esac
  fi
])
case $host_os in
  # For platforms which do not support PIC, -DPIC is meaningless:
  *djgpp*)
    _LT_TAGVAR(lt_prog_compiler_pic, $1)=
    ;;
  *)
    _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"
    ;;
esac

AC_CACHE_CHECK([for $compiler option to produce PIC],
  [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)],
  [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)])
_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)

#
# Check to make sure the PIC flag actually works.
#
if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
  _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works],
    [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)],
    [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [],
    [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in
     "" | " "*) ;;
     *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;;
     esac],
    [_LT_TAGVAR(lt_prog_compiler_pic, $1)=
     _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
fi
_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],
	[Additional compiler flags for building library objects])

_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],
	[How to pass a linker flag through the compiler])
#
# Check to make sure the static flag actually works.
#
wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\"
_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],
  _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1),
  $lt_tmp_static_flag,
  [],
  [_LT_TAGVAR(lt_prog_compiler_static, $1)=])
_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1],
	[Compiler flag to prevent dynamic linking])
])# _LT_COMPILER_PIC


# _LT_LINKER_SHLIBS([TAGNAME])
# ----------------------------
# See if the linker supports building shared libraries.
m4_defun([_LT_LINKER_SHLIBS],
[AC_REQUIRE([LT_PATH_LD])dnl
AC_REQUIRE([LT_PATH_NM])dnl
m4_require([_LT_PATH_MANIFEST_TOOL])dnl
m4_require([_LT_FILEUTILS_DEFAULTS])dnl
m4_require([_LT_DECL_EGREP])dnl
m4_require([_LT_DECL_SED])dnl
m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
m4_require([_LT_TAG_COMPILER])dnl
AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
m4_if([$1], [CXX], [
  _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
  _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
  case $host_os in
  aix[[4-9]]*)
    # If we're using GNU nm, then we don't want the "-C" option.
    # -C means demangle to AIX nm, but means don't demangle with GNU nm
    # Also, AIX nm treats weak defined symbols like other global defined
    # symbols, whereas GNU nm marks them as "W".
    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
    else
      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
    fi
    ;;
  pw32*)
    _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
    ;;
  cygwin* | mingw* | cegcc*)
    case $cc_basename in
    cl*)
      _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
      ;;
    *)
      _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
      _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']
      ;;
    esac
    ;;
  *)
    _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
    ;;
  esac
], [
  runpath_var=
  _LT_TAGVAR(allow_undefined_flag, $1)=
  _LT_TAGVAR(always_export_symbols, $1)=no
  _LT_TAGVAR(archive_cmds, $1)=
  _LT_TAGVAR(archive_expsym_cmds, $1)=
  _LT_TAGVAR(compiler_needs_object, $1)=no
  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
  _LT_TAGVAR(export_dynamic_flag_spec, $1)=
  _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
  _LT_TAGVAR(hardcode_automatic, $1)=no
  _LT_TAGVAR(hardcode_direct, $1)=no
  _LT_TAGVAR(hardcode_direct_absolute, $1)=no
  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
  _LT_TAGVAR(hardcode_libdir_separator, $1)=
  _LT_TAGVAR(hardcode_minus_L, $1)=no
  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
  _LT_TAGVAR(inherit_rpath, $1)=no
  _LT_TAGVAR(link_all_deplibs, $1)=unknown
  _LT_TAGVAR(module_cmds, $1)=
  _LT_TAGVAR(module_expsym_cmds, $1)=
  _LT_TAGVAR(old_archive_from_new_cmds, $1)=
  _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)=
  _LT_TAGVAR(thread_safe_flag_spec, $1)=
  _LT_TAGVAR(whole_archive_flag_spec, $1)=
  # include_expsyms should be a list of space-separated symbols to be *always*
  # included in the symbol list
  _LT_TAGVAR(include_expsyms, $1)=
  # exclude_expsyms can be an extended regexp of symbols to exclude
  # it will be wrapped by ` (' and `)$', so one must not match beginning or
  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
  # as well as any symbol that contains `d'.
  _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
  # platforms (ab)use it in PIC code, but their linkers get confused if
  # the symbol is explicitly referenced.  Since portable code cannot
  # rely on this symbol name, it's probably fine to never include it in
  # preloaded symbol tables.
  # Exclude shared library initialization/finalization symbols.
dnl Note also adjust exclude_expsyms for C++ above.
  extract_expsyms_cmds=

  case $host_os in
  cygwin* | mingw* | pw32* | cegcc*)
    # FIXME: the MSVC++ port hasn't been tested in a loooong time
    # When not using gcc, we currently assume that we are using
    # Microsoft Visual C++.
    if test "$GCC" != yes; then
      with_gnu_ld=no
    fi
    ;;
  interix*)
    # we just hope/assume this is gcc and not c89 (= MSVC++)
    with_gnu_ld=yes
    ;;
  openbsd*)
    with_gnu_ld=no
    ;;
  esac

  _LT_TAGVAR(ld_shlibs, $1)=yes

  # On some targets, GNU ld is compatible enough with the native linker
  # that we're better off using the native interface for both.
  lt_use_gnu_ld_interface=no
  if test "$with_gnu_ld" = yes; then
    case $host_os in
      aix*)
	# The AIX port of GNU ld has always aspired to compatibility
	# with the native linker.  However, as the warning in the GNU ld
	# block says, versions before 2.19.5* couldn't really create working
	# shared libraries, regardless of the interface used.
	case `$LD -v 2>&1` in
	  *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
	  *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;;
	  *\ \(GNU\ Binutils\)\ [[3-9]]*) ;;
	  *)
	    lt_use_gnu_ld_interface=yes
	    ;;
	esac
	;;
      *)
	lt_use_gnu_ld_interface=yes
	;;
    esac
  fi

  if test "$lt_use_gnu_ld_interface" = yes; then
    # If archive_cmds runs LD, not CC, wlarc should be empty
    wlarc='${wl}'

    # Set some defaults for GNU ld with shared library support. These
    # are reset later if shared libraries are not supported. Putting them
    # here allows them to be overridden if necessary.
    runpath_var=LD_RUN_PATH
    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
    # ancient GNU ld didn't support --whole-archive et. al.
    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
      _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
    else
      _LT_TAGVAR(whole_archive_flag_spec, $1)=
    fi
    supports_anon_versioning=no
    case `$LD -v 2>&1` in
      *GNU\ gold*) supports_anon_versioning=yes ;;
      *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
      *\ 2.11.*) ;; # other 2.11 versions
      *) supports_anon_versioning=yes ;;
    esac

    # See if GNU ld supports shared libraries.
    case $host_os in
    aix[[3-9]]*)
      # On AIX/PPC, the GNU linker is very broken
      if test "$host_cpu" != ia64; then
	_LT_TAGVAR(ld_shlibs, $1)=no
	cat <<_LT_EOF 1>&2

*** Warning: the GNU linker, at least up to release 2.19, is reported
*** to be unable to reliably create shared libraries on AIX.
*** Therefore, libtool is disabling shared libraries support.  If you
*** really care for shared libraries, you may want to install binutils
*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
*** You will then need to restart the configuration process.

_LT_EOF
      fi
      ;;

    amigaos*)
      case $host_cpu in
      powerpc)
            # see comment about AmigaOS4 .so support
            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
            _LT_TAGVAR(archive_expsym_cmds, $1)=''
        ;;
      m68k)
            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
            _LT_TAGVAR(hardcode_minus_L, $1)=yes
        ;;
      esac
      ;;

    beos*)
      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
	# Joseph Beckenbach  says some releases of gcc
	# support --undefined.  This deserves some investigation.  FIXME
	_LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
      else
	_LT_TAGVAR(ld_shlibs, $1)=no
      fi
      ;;

    cygwin* | mingw* | pw32* | cegcc*)
      # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
      # as there is no search path for DLLs.
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols'
      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
      _LT_TAGVAR(always_export_symbols, $1)=no
      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
      _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
      _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']

      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
	# If the export-symbols file already is a .def file (1st line
	# is EXPORTS), use it as is; otherwise, prepend...
	_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
	  cp $export_symbols $output_objdir/$soname.def;
	else
	  echo EXPORTS > $output_objdir/$soname.def;
	  cat $export_symbols >> $output_objdir/$soname.def;
	fi~
	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
      else
	_LT_TAGVAR(ld_shlibs, $1)=no
      fi
      ;;

    haiku*)
      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
      _LT_TAGVAR(link_all_deplibs, $1)=yes
      ;;

    interix[[3-9]]*)
      _LT_TAGVAR(hardcode_direct, $1)=no
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
      # Instead, shared libraries are loaded at an image base (0x10000000 by
      # default) and relocated if they conflict, which is a slow very memory
      # consuming and fragmenting process.  To avoid this, we pick a random,
      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
      _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
      ;;

    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
      tmp_diet=no
      if test "$host_os" = linux-dietlibc; then
	case $cc_basename in
	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
	esac
      fi
      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
	 && test "$tmp_diet" = no
      then
	tmp_addflag=' $pic_flag'
	tmp_sharedflag='-shared'
	case $cc_basename,$host_cpu in
        pgcc*)				# Portland Group C compiler
	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	  tmp_addflag=' $pic_flag'
	  ;;
	pgf77* | pgf90* | pgf95* | pgfortran*)
					# Portland Group f77 and f90 compilers
	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	  tmp_addflag=' $pic_flag -Mnomain' ;;
	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
	  tmp_addflag=' -i_dynamic' ;;
	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
	  tmp_addflag=' -i_dynamic -nofor_main' ;;
	ifc* | ifort*)			# Intel Fortran compiler
	  tmp_addflag=' -nofor_main' ;;
	lf95*)				# Lahey Fortran 8.1
	  _LT_TAGVAR(whole_archive_flag_spec, $1)=
	  tmp_sharedflag='--shared' ;;
	xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below)
	  tmp_sharedflag='-qmkshrobj'
	  tmp_addflag= ;;
	nvcc*)	# Cuda Compiler Driver 2.2
	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	  _LT_TAGVAR(compiler_needs_object, $1)=yes
	  ;;
	esac
	case `$CC -V 2>&1 | sed 5q` in
	*Sun\ C*)			# Sun C 5.9
	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	  _LT_TAGVAR(compiler_needs_object, $1)=yes
	  tmp_sharedflag='-G' ;;
	*Sun\ F*)			# Sun Fortran 8.3
	  tmp_sharedflag='-G' ;;
	esac
	_LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

        if test "x$supports_anon_versioning" = xyes; then
          _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
	    cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
	    echo "local: *; };" >> $output_objdir/$libname.ver~
	    $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
        fi

	case $cc_basename in
	xlf* | bgf* | bgxlf* | mpixlf*)
	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
	  _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
	  _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
	  if test "x$supports_anon_versioning" = xyes; then
	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
	      cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
	      echo "local: *; };" >> $output_objdir/$libname.ver~
	      $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
	  fi
	  ;;
	esac
      else
        _LT_TAGVAR(ld_shlibs, $1)=no
      fi
      ;;

    netbsd*)
      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
	wlarc=
      else
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
      fi
      ;;

    solaris*)
      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
	_LT_TAGVAR(ld_shlibs, $1)=no
	cat <<_LT_EOF 1>&2

*** Warning: The releases 2.8.* of the GNU linker cannot reliably
*** create shared libraries on Solaris systems.  Therefore, libtool
*** is disabling shared libraries support.  We urge you to upgrade GNU
*** binutils to release 2.9.1 or newer.  Another option is to modify
*** your PATH or compiler configuration so that the native linker is
*** used, and then restart.

_LT_EOF
      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
      else
	_LT_TAGVAR(ld_shlibs, $1)=no
      fi
      ;;

    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
      case `$LD -v 2>&1` in
        *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*)
	_LT_TAGVAR(ld_shlibs, $1)=no
	cat <<_LT_EOF 1>&2

*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
*** reliably create shared libraries on SCO systems.  Therefore, libtool
*** is disabling shared libraries support.  We urge you to upgrade GNU
*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
*** your PATH or compiler configuration so that the native linker is
*** used, and then restart.

_LT_EOF
	;;
	*)
	  # For security reasons, it is highly recommended that you always
	  # use absolute paths for naming shared libraries, and exclude the
	  # DT_RUNPATH tag from executables and libraries.  But doing so
	  # requires that you compile everything twice, which is a pain.
	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
	  else
	    _LT_TAGVAR(ld_shlibs, $1)=no
	  fi
	;;
      esac
      ;;

    sunos4*)
      _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
      wlarc=
      _LT_TAGVAR(hardcode_direct, $1)=yes
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    *)
      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
      else
	_LT_TAGVAR(ld_shlibs, $1)=no
      fi
      ;;
    esac

    if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then
      runpath_var=
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
      _LT_TAGVAR(export_dynamic_flag_spec, $1)=
      _LT_TAGVAR(whole_archive_flag_spec, $1)=
    fi
  else
    # PORTME fill in a description of your system's linker (not GNU ld)
    case $host_os in
    aix3*)
      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
      _LT_TAGVAR(always_export_symbols, $1)=yes
      _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
      # Note: this linker hardcodes the directories in LIBPATH if there
      # are no directories specified by -L.
      _LT_TAGVAR(hardcode_minus_L, $1)=yes
      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
	# Neither direct hardcoding nor static linking is supported with a
	# broken collect2.
	_LT_TAGVAR(hardcode_direct, $1)=unsupported
      fi
      ;;

    aix[[4-9]]*)
      if test "$host_cpu" = ia64; then
	# On IA64, the linker does run time linking by default, so we don't
	# have to do anything special.
	aix_use_runtimelinking=no
	exp_sym_flag='-Bexport'
	no_entry_flag=""
      else
	# If we're using GNU nm, then we don't want the "-C" option.
	# -C means demangle to AIX nm, but means don't demangle with GNU nm
	# Also, AIX nm treats weak defined symbols like other global
	# defined symbols, whereas GNU nm marks them as "W".
	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
	else
	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
	fi
	aix_use_runtimelinking=no

	# Test if we are trying to use run time linking or normal
	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
	# need to do runtime linking.
	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
	  for ld_flag in $LDFLAGS; do
	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
	    aix_use_runtimelinking=yes
	    break
	  fi
	  done
	  ;;
	esac

	exp_sym_flag='-bexport'
	no_entry_flag='-bnoentry'
      fi

      # When large executables or shared objects are built, AIX ld can
      # have problems creating the table of contents.  If linking a library
      # or program results in "error TOC overflow" add -mminimal-toc to
      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

      _LT_TAGVAR(archive_cmds, $1)=''
      _LT_TAGVAR(hardcode_direct, $1)=yes
      _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
      _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
      _LT_TAGVAR(link_all_deplibs, $1)=yes
      _LT_TAGVAR(file_list_spec, $1)='${wl}-f,'

      if test "$GCC" = yes; then
	case $host_os in aix4.[[012]]|aix4.[[012]].*)
	# We only want to do this on AIX 4.2 and lower, the check
	# below for broken collect2 doesn't work under 4.3+
	  collect2name=`${CC} -print-prog-name=collect2`
	  if test -f "$collect2name" &&
	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
	  then
	  # We have reworked collect2
	  :
	  else
	  # We have old collect2
	  _LT_TAGVAR(hardcode_direct, $1)=unsupported
	  # It fails to find uninstalled libraries when the uninstalled
	  # path is not listed in the libpath.  Setting hardcode_minus_L
	  # to unsupported forces relinking
	  _LT_TAGVAR(hardcode_minus_L, $1)=yes
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
	  _LT_TAGVAR(hardcode_libdir_separator, $1)=
	  fi
	  ;;
	esac
	shared_flag='-shared'
	if test "$aix_use_runtimelinking" = yes; then
	  shared_flag="$shared_flag "'${wl}-G'
	fi
      else
	# not using gcc
	if test "$host_cpu" = ia64; then
	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
	# chokes on -Wl,-G. The following line is correct:
	  shared_flag='-G'
	else
	  if test "$aix_use_runtimelinking" = yes; then
	    shared_flag='${wl}-G'
	  else
	    shared_flag='${wl}-bM:SRE'
	  fi
	fi
      fi

      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
      # It seems that -bexpall does not export symbols beginning with
      # underscore (_), so it is better to generate a list of symbols to export.
      _LT_TAGVAR(always_export_symbols, $1)=yes
      if test "$aix_use_runtimelinking" = yes; then
	# Warning - without using the other runtime loading flags (-brtl),
	# -berok will link without error, but may produce a broken library.
	_LT_TAGVAR(allow_undefined_flag, $1)='-berok'
        # Determine the default libpath from the value encoded in an
        # empty executable.
        _LT_SYS_MODULE_PATH_AIX([$1])
        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
      else
	if test "$host_cpu" = ia64; then
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
	  _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
	  _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
	else
	 # Determine the default libpath from the value encoded in an
	 # empty executable.
	 _LT_SYS_MODULE_PATH_AIX([$1])
	 _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
	  # Warning - without using the other run time loading flags,
	  # -berok will link without error, but may produce a broken library.
	  _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
	  _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
	  if test "$with_gnu_ld" = yes; then
	    # We only use this code for GNU lds that support --whole-archive.
	    _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
	  else
	    # Exported symbols can be pulled into shared objects from archives
	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
	  fi
	  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
	  # This is similar to how AIX traditionally builds its shared libraries.
	  _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
	fi
      fi
      ;;

    amigaos*)
      case $host_cpu in
      powerpc)
            # see comment about AmigaOS4 .so support
            _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
            _LT_TAGVAR(archive_expsym_cmds, $1)=''
        ;;
      m68k)
            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
            _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
            _LT_TAGVAR(hardcode_minus_L, $1)=yes
        ;;
      esac
      ;;

    bsdi[[45]]*)
      _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
      ;;

    cygwin* | mingw* | pw32* | cegcc*)
      # When not using gcc, we currently assume that we are using
      # Microsoft Visual C++.
      # hardcode_libdir_flag_spec is actually meaningless, as there is
      # no search path for DLLs.
      case $cc_basename in
      cl*)
	# Native MSVC
	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
	_LT_TAGVAR(always_export_symbols, $1)=yes
	_LT_TAGVAR(file_list_spec, $1)='@'
	# Tell ltmain to make .lib files, not .a files.
	libext=lib
	# Tell ltmain to make .dll files, not .so files.
	shrext_cmds=".dll"
	# FIXME: Setting linknames here is a bad hack.
	_LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
	_LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
	    sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
	  else
	    sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
	  fi~
	  $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
	  linknames='
	# The linker will not automatically build a static lib if we build a DLL.
	# _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
	_LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
	_LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols'
	# Don't use ranlib
	_LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
	_LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
	  lt_tool_outputfile="@TOOL_OUTPUT@"~
	  case $lt_outputfile in
	    *.exe|*.EXE) ;;
	    *)
	      lt_outputfile="$lt_outputfile.exe"
	      lt_tool_outputfile="$lt_tool_outputfile.exe"
	      ;;
	  esac~
	  if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
	    $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
	    $RM "$lt_outputfile.manifest";
	  fi'
	;;
      *)
	# Assume MSVC wrapper
	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
	# Tell ltmain to make .lib files, not .a files.
	libext=lib
	# Tell ltmain to make .dll files, not .so files.
	shrext_cmds=".dll"
	# FIXME: Setting linknames here is a bad hack.
	_LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
	# The linker will automatically build a .lib file if we build a DLL.
	_LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
	# FIXME: Should let the user specify the lib program.
	_LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs'
	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
	;;
      esac
      ;;

    darwin* | rhapsody*)
      _LT_DARWIN_LINKER_FEATURES($1)
      ;;

    dgux*)
      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
    # support.  Future versions do this automatically, but an explicit c++rt0.o
    # does not break anything, and helps significantly (at the cost of a little
    # extra space).
    freebsd2.2*)
      _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
      _LT_TAGVAR(hardcode_direct, $1)=yes
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
    freebsd2.*)
      _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
      _LT_TAGVAR(hardcode_direct, $1)=yes
      _LT_TAGVAR(hardcode_minus_L, $1)=yes
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
    freebsd* | dragonfly*)
      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
      _LT_TAGVAR(hardcode_direct, $1)=yes
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    hpux9*)
      if test "$GCC" = yes; then
	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
      else
	_LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
      fi
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
      _LT_TAGVAR(hardcode_direct, $1)=yes

      # hardcode_minus_L: Not really in the search PATH,
      # but as the default location of the library.
      _LT_TAGVAR(hardcode_minus_L, $1)=yes
      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
      ;;

    hpux10*)
      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
      else
	_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
      fi
      if test "$with_gnu_ld" = no; then
	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
	_LT_TAGVAR(hardcode_libdir_separator, $1)=:
	_LT_TAGVAR(hardcode_direct, $1)=yes
	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
	# hardcode_minus_L: Not really in the search PATH,
	# but as the default location of the library.
	_LT_TAGVAR(hardcode_minus_L, $1)=yes
      fi
      ;;

    hpux11*)
      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
	case $host_cpu in
	hppa*64*)
	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	ia64*)
	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	*)
	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	esac
      else
	case $host_cpu in
	hppa*64*)
	  _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	ia64*)
	  _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	*)
	m4_if($1, [], [
	  # Older versions of the 11.00 compiler do not understand -b yet
	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
	  _LT_LINKER_OPTION([if $CC understands -b],
	    _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b],
	    [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'],
	    [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])],
	  [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'])
	  ;;
	esac
      fi
      if test "$with_gnu_ld" = no; then
	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
	_LT_TAGVAR(hardcode_libdir_separator, $1)=:

	case $host_cpu in
	hppa*64*|ia64*)
	  _LT_TAGVAR(hardcode_direct, $1)=no
	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
	  ;;
	*)
	  _LT_TAGVAR(hardcode_direct, $1)=yes
	  _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'

	  # hardcode_minus_L: Not really in the search PATH,
	  # but as the default location of the library.
	  _LT_TAGVAR(hardcode_minus_L, $1)=yes
	  ;;
	esac
      fi
      ;;

    irix5* | irix6* | nonstopux*)
      if test "$GCC" = yes; then
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
	# Try to use the -exported_symbol ld option, if it does not
	# work, assume that -exports_file does not work either and
	# implicitly export all symbols.
	# This should be the same for all languages, so no per-tag cache variable.
	AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol],
	  [lt_cv_irix_exported_symbol],
	  [save_LDFLAGS="$LDFLAGS"
	   LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
	   AC_LINK_IFELSE(
	     [AC_LANG_SOURCE(
	        [AC_LANG_CASE([C], [[int foo (void) { return 0; }]],
			      [C++], [[int foo (void) { return 0; }]],
			      [Fortran 77], [[
      subroutine foo
      end]],
			      [Fortran], [[
      subroutine foo
      end]])])],
	      [lt_cv_irix_exported_symbol=yes],
	      [lt_cv_irix_exported_symbol=no])
           LDFLAGS="$save_LDFLAGS"])
	if test "$lt_cv_irix_exported_symbol" = yes; then
          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
	fi
      else
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
      fi
      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
      _LT_TAGVAR(inherit_rpath, $1)=yes
      _LT_TAGVAR(link_all_deplibs, $1)=yes
      ;;

    netbsd*)
      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
      else
	_LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
      fi
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
      _LT_TAGVAR(hardcode_direct, $1)=yes
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    newsos6)
      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
      _LT_TAGVAR(hardcode_direct, $1)=yes
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    *nto* | *qnx*)
      ;;

    openbsd*)
      if test -f /usr/libexec/ld.so; then
	_LT_TAGVAR(hardcode_direct, $1)=yes
	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
	_LT_TAGVAR(hardcode_direct_absolute, $1)=yes
	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
	else
	  case $host_os in
	   openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
	     _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
	     _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
	     ;;
	   *)
	     _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
	     _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
	     ;;
	  esac
	fi
      else
	_LT_TAGVAR(ld_shlibs, $1)=no
      fi
      ;;

    os2*)
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
      _LT_TAGVAR(hardcode_minus_L, $1)=yes
      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
      _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
      ;;

    osf3*)
      if test "$GCC" = yes; then
	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
      else
	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
      fi
      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
      ;;

    osf4* | osf5*)	# as osf3* with the addition of -msym flag
      if test "$GCC" = yes; then
	_LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
      else
	_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
	_LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
	$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'

	# Both c and cxx compiler support -rpath directly
	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
      fi
      _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
      _LT_TAGVAR(hardcode_libdir_separator, $1)=:
      ;;

    solaris*)
      _LT_TAGVAR(no_undefined_flag, $1)=' -z defs'
      if test "$GCC" = yes; then
	wlarc='${wl}'
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
	_LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
	  $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
      else
	case `$CC -V 2>&1` in
	*"Compilers 5.0"*)
	  wlarc=''
	  _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
	  _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
	  $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
	  ;;
	*)
	  wlarc='${wl}'
	  _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
	  _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
	  $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
	  ;;
	esac
      fi
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      case $host_os in
      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
      *)
	# The compiler driver will combine and reorder linker options,
	# but understands `-z linker_flag'.  GCC discards it without `$wl',
	# but is careful enough not to reorder.
	# Supported since Solaris 2.6 (maybe 2.5.1?)
	if test "$GCC" = yes; then
	  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
	else
	  _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
	fi
	;;
      esac
      _LT_TAGVAR(link_all_deplibs, $1)=yes
      ;;

    sunos4*)
      if test "x$host_vendor" = xsequent; then
	# Use $CC to link under sequent, because it throws in some extra .o
	# files that make .init and .fini sections work.
	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
      else
	_LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
      fi
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
      _LT_TAGVAR(hardcode_direct, $1)=yes
      _LT_TAGVAR(hardcode_minus_L, $1)=yes
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    sysv4)
      case $host_vendor in
	sni)
	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
	  _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true???
	;;
	siemens)
	  ## LD is ld it makes a PLAMLIB
	  ## CC just makes a GrossModule.
	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
	  _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
	  _LT_TAGVAR(hardcode_direct, $1)=no
        ;;
	motorola)
	  _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
	  _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
	;;
      esac
      runpath_var='LD_RUN_PATH'
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    sysv4.3*)
      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
      ;;

    sysv4*MP*)
      if test -d /usr/nec; then
	_LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
	runpath_var=LD_RUN_PATH
	hardcode_runpath_var=yes
	_LT_TAGVAR(ld_shlibs, $1)=yes
      fi
      ;;

    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      runpath_var='LD_RUN_PATH'

      if test "$GCC" = yes; then
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
      else
	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
      fi
      ;;

    sysv5* | sco3.2v5* | sco5v6*)
      # Note: We can NOT use -z defs as we might desire, because we do not
      # link with -lc, and that would cause any symbols used from libc to
      # always be unresolved, which means just about no library would
      # ever link correctly.  If we're not using GNU ld we use -z text
      # though, which does catch some bad symbols but isn't as heavy-handed
      # as -z defs.
      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
      _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
      _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
      _LT_TAGVAR(link_all_deplibs, $1)=yes
      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
      runpath_var='LD_RUN_PATH'

      if test "$GCC" = yes; then
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
      else
	_LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
      fi
      ;;

    uts4*)
      _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      ;;

    *)
      _LT_TAGVAR(ld_shlibs, $1)=no
      ;;
    esac

    if test x$host_vendor = xsni; then
      case $host in
      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym'
	;;
      esac
    fi
  fi
])
AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no

_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld

_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl
_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl
_LT_DECL([], [extract_expsyms_cmds], [2],
    [The commands to extract the exported symbol list from a shared archive])

#
# Do we need to explicitly link libc?
#
case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in
x|xyes)
  # Assume -lc should be added
  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes

  if test "$enable_shared" = yes && test "$GCC" = yes; then
    case $_LT_TAGVAR(archive_cmds, $1) in
    *'~'*)
      # FIXME: we may have to deal with multi-command sequences.
      ;;
    '$CC '*)
      # Test whether the compiler implicitly links with -lc since on some
      # systems, -lgcc has to come before -lc. If gcc already passes -lc
      # to ld, don't add -lc before -lgcc.
      AC_CACHE_CHECK([whether -lc should be explicitly linked in],
	[lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1),
	[$RM conftest*
	echo "$lt_simple_compile_test_code" > conftest.$ac_ext

	if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
	  soname=conftest
	  lib=conftest
	  libobjs=conftest.$ac_objext
	  deplibs=
	  wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1)
	  pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1)
	  compiler_flags=-v
	  linker_flags=-v
	  verstring=
	  output_objdir=.
	  libname=conftest
	  lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1)
	  _LT_TAGVAR(allow_undefined_flag, $1)=
	  if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)
	  then
	    lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no
	  else
	    lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes
	  fi
	  _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
	else
	  cat conftest.err 1>&5
	fi
	$RM conftest*
	])
      _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)
      ;;
    esac
  fi
  ;;
esac

_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0],
    [Whether or not to add -lc for building shared libraries])
_LT_TAGDECL([allow_libtool_libs_with_static_runtimes],
    [enable_shared_with_static_runtimes], [0],
    [Whether or not to disallow shared libs when runtime libs are static])
_LT_TAGDECL([], [export_dynamic_flag_spec], [1],
    [Compiler flag to allow reflexive dlopens])
_LT_TAGDECL([], [whole_archive_flag_spec], [1],
    [Compiler flag to generate shared objects directly from archives])
_LT_TAGDECL([], [compiler_needs_object], [1],
    [Whether the compiler copes with passing no objects directly])
_LT_TAGDECL([], [old_archive_from_new_cmds], [2],
    [Create an old-style archive from a shared archive])
_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2],
    [Create a temporary old-style archive to link instead of a shared archive])
_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive])
_LT_TAGDECL([], [archive_expsym_cmds], [2])
_LT_TAGDECL([], [module_cmds], [2],
    [Commands used to build a loadable module if different from building
    a shared archive.])
_LT_TAGDECL([], [module_expsym_cmds], [2])
_LT_TAGDECL([], [with_gnu_ld], [1],
    [Whether we are building with GNU ld or not])
_LT_TAGDECL([], [allow_undefined_flag], [1],
    [Flag that allows shared libraries with undefined symbols to be built])
_LT_TAGDECL([], [no_undefined_flag], [1],
    [Flag that enforces no undefined symbols])
_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
    [Flag to hardcode $libdir into a binary during linking.
    This must work even if $libdir does not exist])
_LT_TAGDECL([], [hardcode_libdir_separator], [1],
    [Whether we need a single "-rpath" flag with a separated argument])
_LT_TAGDECL([], [hardcode_direct], [0],
    [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
    DIR into the resulting binary])
_LT_TAGDECL([], [hardcode_direct_absolute], [0],
    [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
    DIR into the resulting binary and the resulting library dependency is
    "absolute", i.e impossible to change by setting ${shlibpath_var} if the
    library is relocated])
_LT_TAGDECL([], [hardcode_minus_L], [0],
    [Set to "yes" if using the -LDIR flag during linking hardcodes DIR
    into the resulting binary])
_LT_TAGDECL([], [hardcode_shlibpath_var], [0],
    [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
    into the resulting binary])
_LT_TAGDECL([], [hardcode_automatic], [0],
    [Set to "yes" if building a shared library automatically hardcodes DIR
    into the library and all subsequent libraries and executables linked
    against it])
_LT_TAGDECL([], [inherit_rpath], [0],
    [Set to yes if linker adds runtime paths of dependent libraries
    to runtime path list])
_LT_TAGDECL([], [link_all_deplibs], [0],
    [Whether libtool must link a program against all its dependency libraries])
_LT_TAGDECL([], [always_export_symbols], [0],
    [Set to "yes" if exported symbols are required])
_LT_TAGDECL([], [export_symbols_cmds], [2],
    [The commands to list exported symbols])
_LT_TAGDECL([], [exclude_expsyms], [1],
    [Symbols that should not be listed in the preloaded symbols])
_LT_TAGDECL([], [include_expsyms], [1],
    [Symbols that must always be exported])
_LT_TAGDECL([], [prelink_cmds], [2],
    [Commands necessary for linking programs (against libraries) with templates])
_LT_TAGDECL([], [postlink_cmds], [2],
    [Commands necessary for finishing linking programs])
_LT_TAGDECL([], [file_list_spec], [1],
    [Specify filename containing input files])
dnl FIXME: Not yet implemented
dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1],
dnl    [Compiler flag to generate thread safe objects])
])# _LT_LINKER_SHLIBS


# _LT_LANG_C_CONFIG([TAG])
# ------------------------
# Ensure that the configuration variables for a C compiler are suitably
# defined.  These variables are subsequently used by _LT_CONFIG to write
# the compiler configuration to `libtool'.
m4_defun([_LT_LANG_C_CONFIG],
[m4_require([_LT_DECL_EGREP])dnl
lt_save_CC="$CC"
AC_LANG_PUSH(C)

# Source file extension for C test sources.
ac_ext=c

# Object file extension for compiled C test sources.
objext=o
_LT_TAGVAR(objext, $1)=$objext

# Code to be used in simple compile tests
lt_simple_compile_test_code="int some_variable = 0;"

# Code to be used in simple link tests
lt_simple_link_test_code='int main(){return(0);}'

_LT_TAG_COMPILER
# Save the default compiler, since it gets overwritten when the other
# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
compiler_DEFAULT=$CC

# save warnings/boilerplate of simple test code
_LT_COMPILER_BOILERPLATE
_LT_LINKER_BOILERPLATE

## CAVEAT EMPTOR:
## There is no encapsulation within the following macros, do not change
## the running order or otherwise move them around unless you know exactly
## what you are doing...
if test -n "$compiler"; then
  _LT_COMPILER_NO_RTTI($1)
  _LT_COMPILER_PIC($1)
  _LT_COMPILER_C_O($1)
  _LT_COMPILER_FILE_LOCKS($1)
  _LT_LINKER_SHLIBS($1)
  _LT_SYS_DYNAMIC_LINKER($1)
  _LT_LINKER_HARDCODE_LIBPATH($1)
  LT_SYS_DLOPEN_SELF
  _LT_CMD_STRIPLIB

  # Report which library types will actually be built
  AC_MSG_CHECKING([if libtool supports shared libraries])
  AC_MSG_RESULT([$can_build_shared])

  AC_MSG_CHECKING([whether to build shared libraries])
  test "$can_build_shared" = "no" && enable_shared=no

  # On AIX, shared libraries and static libraries use the same namespace, and
  # are all built from PIC.
  case $host_os in
  aix3*)
    test "$enable_shared" = yes && enable_static=no
    if test -n "$RANLIB"; then
      archive_cmds="$archive_cmds~\$RANLIB \$lib"
      postinstall_cmds='$RANLIB $lib'
    fi
    ;;

  aix[[4-9]]*)
    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
      test "$enable_shared" = yes && enable_static=no
    fi
    ;;
  esac
  AC_MSG_RESULT([$enable_shared])

  AC_MSG_CHECKING([whether to build static libraries])
  # Make sure either enable_shared or enable_static is yes.
  test "$enable_shared" = yes || enable_static=yes
  AC_MSG_RESULT([$enable_static])

  _LT_CONFIG($1)
fi
AC_LANG_POP
CC="$lt_save_CC"
])# _LT_LANG_C_CONFIG


# _LT_LANG_CXX_CONFIG([TAG])
# --------------------------
# Ensure that the configuration variables for a C++ compiler are suitably
# defined.  These variables are subsequently used by _LT_CONFIG to write
# the compiler configuration to `libtool'.
m4_defun([_LT_LANG_CXX_CONFIG],
[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
m4_require([_LT_DECL_EGREP])dnl
m4_require([_LT_PATH_MANIFEST_TOOL])dnl
if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
    (test "X$CXX" != "Xg++"))) ; then
  AC_PROG_CXXCPP
else
  _lt_caught_CXX_error=yes
fi

AC_LANG_PUSH(C++)
_LT_TAGVAR(archive_cmds_need_lc, $1)=no
_LT_TAGVAR(allow_undefined_flag, $1)=
_LT_TAGVAR(always_export_symbols, $1)=no
_LT_TAGVAR(archive_expsym_cmds, $1)=
_LT_TAGVAR(compiler_needs_object, $1)=no
_LT_TAGVAR(export_dynamic_flag_spec, $1)=
_LT_TAGVAR(hardcode_direct, $1)=no
_LT_TAGVAR(hardcode_direct_absolute, $1)=no
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
_LT_TAGVAR(hardcode_libdir_separator, $1)=
_LT_TAGVAR(hardcode_minus_L, $1)=no
_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
_LT_TAGVAR(hardcode_automatic, $1)=no
_LT_TAGVAR(inherit_rpath, $1)=no
_LT_TAGVAR(module_cmds, $1)=
_LT_TAGVAR(module_expsym_cmds, $1)=
_LT_TAGVAR(link_all_deplibs, $1)=unknown
_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
_LT_TAGVAR(reload_flag, $1)=$reload_flag
_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
_LT_TAGVAR(no_undefined_flag, $1)=
_LT_TAGVAR(whole_archive_flag_spec, $1)=
_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no

# Source file extension for C++ test sources.
ac_ext=cpp

# Object file extension for compiled C++ test sources.
objext=o
_LT_TAGVAR(objext, $1)=$objext

# No sense in running all these tests if we already determined that
# the CXX compiler isn't working.  Some variables (like enable_shared)
# are currently assumed to apply to all compilers on this platform,
# and will be corrupted by setting them based on a non-working compiler.
if test "$_lt_caught_CXX_error" != yes; then
  # Code to be used in simple compile tests
  lt_simple_compile_test_code="int some_variable = 0;"

  # Code to be used in simple link tests
  lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }'

  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
  _LT_TAG_COMPILER

  # save warnings/boilerplate of simple test code
  _LT_COMPILER_BOILERPLATE
  _LT_LINKER_BOILERPLATE

  # Allow CC to be a program name with arguments.
  lt_save_CC=$CC
  lt_save_CFLAGS=$CFLAGS
  lt_save_LD=$LD
  lt_save_GCC=$GCC
  GCC=$GXX
  lt_save_with_gnu_ld=$with_gnu_ld
  lt_save_path_LD=$lt_cv_path_LD
  if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
    lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
  else
    $as_unset lt_cv_prog_gnu_ld
  fi
  if test -n "${lt_cv_path_LDCXX+set}"; then
    lt_cv_path_LD=$lt_cv_path_LDCXX
  else
    $as_unset lt_cv_path_LD
  fi
  test -z "${LDCXX+set}" || LD=$LDCXX
  CC=${CXX-"c++"}
  CFLAGS=$CXXFLAGS
  compiler=$CC
  _LT_TAGVAR(compiler, $1)=$CC
  _LT_CC_BASENAME([$compiler])

  if test -n "$compiler"; then
    # We don't want -fno-exception when compiling C++ code, so set the
    # no_builtin_flag separately
    if test "$GXX" = yes; then
      _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
    else
      _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
    fi

    if test "$GXX" = yes; then
      # Set up default GNU C++ configuration

      LT_PATH_LD

      # Check if GNU C++ uses GNU ld as the underlying linker, since the
      # archiving commands below assume that GNU ld is being used.
      if test "$with_gnu_ld" = yes; then
        _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
        _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

        # If archive_cmds runs LD, not CC, wlarc should be empty
        # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
        #     investigate it a little bit more. (MM)
        wlarc='${wl}'

        # ancient GNU ld didn't support --whole-archive et. al.
        if eval "`$CC -print-prog-name=ld` --help 2>&1" |
	  $GREP 'no-whole-archive' > /dev/null; then
          _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
        else
          _LT_TAGVAR(whole_archive_flag_spec, $1)=
        fi
      else
        with_gnu_ld=no
        wlarc=

        # A generic and very simple default shared library creation
        # command for GNU C++ for the case where it uses the native
        # linker, instead of GNU ld.  If possible, this setting should
        # overridden to take advantage of the native linker features on
        # the platform it is being used on.
        _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
      fi

      # Commands to make compiler produce verbose output that lists
      # what "hidden" libraries, object files and flags are used when
      # linking a shared library.
      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'

    else
      GXX=no
      with_gnu_ld=no
      wlarc=
    fi

    # PORTME: fill in a description of your system's C++ link characteristics
    AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
    _LT_TAGVAR(ld_shlibs, $1)=yes
    case $host_os in
      aix3*)
        # FIXME: insert proper C++ library support
        _LT_TAGVAR(ld_shlibs, $1)=no
        ;;
      aix[[4-9]]*)
        if test "$host_cpu" = ia64; then
          # On IA64, the linker does run time linking by default, so we don't
          # have to do anything special.
          aix_use_runtimelinking=no
          exp_sym_flag='-Bexport'
          no_entry_flag=""
        else
          aix_use_runtimelinking=no

          # Test if we are trying to use run time linking or normal
          # AIX style linking. If -brtl is somewhere in LDFLAGS, we
          # need to do runtime linking.
          case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
	    for ld_flag in $LDFLAGS; do
	      case $ld_flag in
	      *-brtl*)
	        aix_use_runtimelinking=yes
	        break
	        ;;
	      esac
	    done
	    ;;
          esac

          exp_sym_flag='-bexport'
          no_entry_flag='-bnoentry'
        fi

        # When large executables or shared objects are built, AIX ld can
        # have problems creating the table of contents.  If linking a library
        # or program results in "error TOC overflow" add -mminimal-toc to
        # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
        # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

        _LT_TAGVAR(archive_cmds, $1)=''
        _LT_TAGVAR(hardcode_direct, $1)=yes
        _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
        _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
        _LT_TAGVAR(link_all_deplibs, $1)=yes
        _LT_TAGVAR(file_list_spec, $1)='${wl}-f,'

        if test "$GXX" = yes; then
          case $host_os in aix4.[[012]]|aix4.[[012]].*)
          # We only want to do this on AIX 4.2 and lower, the check
          # below for broken collect2 doesn't work under 4.3+
	  collect2name=`${CC} -print-prog-name=collect2`
	  if test -f "$collect2name" &&
	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
	  then
	    # We have reworked collect2
	    :
	  else
	    # We have old collect2
	    _LT_TAGVAR(hardcode_direct, $1)=unsupported
	    # It fails to find uninstalled libraries when the uninstalled
	    # path is not listed in the libpath.  Setting hardcode_minus_L
	    # to unsupported forces relinking
	    _LT_TAGVAR(hardcode_minus_L, $1)=yes
	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
	    _LT_TAGVAR(hardcode_libdir_separator, $1)=
	  fi
          esac
          shared_flag='-shared'
	  if test "$aix_use_runtimelinking" = yes; then
	    shared_flag="$shared_flag "'${wl}-G'
	  fi
        else
          # not using gcc
          if test "$host_cpu" = ia64; then
	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
	  # chokes on -Wl,-G. The following line is correct:
	  shared_flag='-G'
          else
	    if test "$aix_use_runtimelinking" = yes; then
	      shared_flag='${wl}-G'
	    else
	      shared_flag='${wl}-bM:SRE'
	    fi
          fi
        fi

        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
        # It seems that -bexpall does not export symbols beginning with
        # underscore (_), so it is better to generate a list of symbols to
	# export.
        _LT_TAGVAR(always_export_symbols, $1)=yes
        if test "$aix_use_runtimelinking" = yes; then
          # Warning - without using the other runtime loading flags (-brtl),
          # -berok will link without error, but may produce a broken library.
          _LT_TAGVAR(allow_undefined_flag, $1)='-berok'
          # Determine the default libpath from the value encoded in an empty
          # executable.
          _LT_SYS_MODULE_PATH_AIX([$1])
          _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"

          _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
        else
          if test "$host_cpu" = ia64; then
	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
	    _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
	    _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
          else
	    # Determine the default libpath from the value encoded in an
	    # empty executable.
	    _LT_SYS_MODULE_PATH_AIX([$1])
	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
	    # Warning - without using the other run time loading flags,
	    # -berok will link without error, but may produce a broken library.
	    _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
	    _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
	    if test "$with_gnu_ld" = yes; then
	      # We only use this code for GNU lds that support --whole-archive.
	      _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
	    else
	      # Exported symbols can be pulled into shared objects from archives
	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
	    fi
	    _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
	    # This is similar to how AIX traditionally builds its shared
	    # libraries.
	    _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
          fi
        fi
        ;;

      beos*)
	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
	  # Joseph Beckenbach  says some releases of gcc
	  # support --undefined.  This deserves some investigation.  FIXME
	  _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	else
	  _LT_TAGVAR(ld_shlibs, $1)=no
	fi
	;;

      chorus*)
        case $cc_basename in
          *)
	  # FIXME: insert proper C++ library support
	  _LT_TAGVAR(ld_shlibs, $1)=no
	  ;;
        esac
        ;;

      cygwin* | mingw* | pw32* | cegcc*)
	case $GXX,$cc_basename in
	,cl* | no,cl*)
	  # Native MSVC
	  # hardcode_libdir_flag_spec is actually meaningless, as there is
	  # no search path for DLLs.
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
	  _LT_TAGVAR(always_export_symbols, $1)=yes
	  _LT_TAGVAR(file_list_spec, $1)='@'
	  # Tell ltmain to make .lib files, not .a files.
	  libext=lib
	  # Tell ltmain to make .dll files, not .so files.
	  shrext_cmds=".dll"
	  # FIXME: Setting linknames here is a bad hack.
	  _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
	  _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
	      $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
	    else
	      $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
	    fi~
	    $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
	    linknames='
	  # The linker will not automatically build a static lib if we build a DLL.
	  # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
	  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
	  # Don't use ranlib
	  _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
	  _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
	    lt_tool_outputfile="@TOOL_OUTPUT@"~
	    case $lt_outputfile in
	      *.exe|*.EXE) ;;
	      *)
		lt_outputfile="$lt_outputfile.exe"
		lt_tool_outputfile="$lt_tool_outputfile.exe"
		;;
	    esac~
	    func_to_tool_file "$lt_outputfile"~
	    if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
	      $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
	      $RM "$lt_outputfile.manifest";
	    fi'
	  ;;
	*)
	  # g++
	  # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
	  # as there is no search path for DLLs.
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols'
	  _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
	  _LT_TAGVAR(always_export_symbols, $1)=no
	  _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes

	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
	    # If the export-symbols file already is a .def file (1st line
	    # is EXPORTS), use it as is; otherwise, prepend...
	    _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
	      cp $export_symbols $output_objdir/$soname.def;
	    else
	      echo EXPORTS > $output_objdir/$soname.def;
	      cat $export_symbols >> $output_objdir/$soname.def;
	    fi~
	    $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
	  else
	    _LT_TAGVAR(ld_shlibs, $1)=no
	  fi
	  ;;
	esac
	;;
      darwin* | rhapsody*)
        _LT_DARWIN_LINKER_FEATURES($1)
	;;

      dgux*)
        case $cc_basename in
          ec++*)
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
          ghcx*)
	    # Green Hills C++ Compiler
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
          *)
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
        esac
        ;;

      freebsd2.*)
        # C++ shared libraries reported to be fairly broken before
	# switch to ELF
        _LT_TAGVAR(ld_shlibs, $1)=no
        ;;

      freebsd-elf*)
        _LT_TAGVAR(archive_cmds_need_lc, $1)=no
        ;;

      freebsd* | dragonfly*)
        # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
        # conventions
        _LT_TAGVAR(ld_shlibs, $1)=yes
        ;;

      gnu*)
        ;;

      haiku*)
        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
        _LT_TAGVAR(link_all_deplibs, $1)=yes
        ;;

      hpux9*)
        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
        _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
        _LT_TAGVAR(hardcode_direct, $1)=yes
        _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
				             # but as the default
				             # location of the library.

        case $cc_basename in
          CC*)
            # FIXME: insert proper C++ library support
            _LT_TAGVAR(ld_shlibs, $1)=no
            ;;
          aCC*)
            _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
            # Commands to make compiler produce verbose output that lists
            # what "hidden" libraries, object files and flags are used when
            # linking a shared library.
            #
            # There doesn't appear to be a way to prevent this compiler from
            # explicitly linking system object files so we need to strip them
            # from the output so that they don't get included in the library
            # dependencies.
            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
            ;;
          *)
            if test "$GXX" = yes; then
              _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
            else
              # FIXME: insert proper C++ library support
              _LT_TAGVAR(ld_shlibs, $1)=no
            fi
            ;;
        esac
        ;;

      hpux10*|hpux11*)
        if test $with_gnu_ld = no; then
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
	  _LT_TAGVAR(hardcode_libdir_separator, $1)=:

          case $host_cpu in
            hppa*64*|ia64*)
              ;;
            *)
	      _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
              ;;
          esac
        fi
        case $host_cpu in
          hppa*64*|ia64*)
            _LT_TAGVAR(hardcode_direct, $1)=no
            _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
            ;;
          *)
            _LT_TAGVAR(hardcode_direct, $1)=yes
            _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
            _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
					         # but as the default
					         # location of the library.
            ;;
        esac

        case $cc_basename in
          CC*)
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
          aCC*)
	    case $host_cpu in
	      hppa*64*)
	        _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	        ;;
	      ia64*)
	        _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	        ;;
	      *)
	        _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	        ;;
	    esac
	    # Commands to make compiler produce verbose output that lists
	    # what "hidden" libraries, object files and flags are used when
	    # linking a shared library.
	    #
	    # There doesn't appear to be a way to prevent this compiler from
	    # explicitly linking system object files so we need to strip them
	    # from the output so that they don't get included in the library
	    # dependencies.
	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
	    ;;
          *)
	    if test "$GXX" = yes; then
	      if test $with_gnu_ld = no; then
	        case $host_cpu in
	          hppa*64*)
	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	            ;;
	          ia64*)
	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	            ;;
	          *)
	            _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	            ;;
	        esac
	      fi
	    else
	      # FIXME: insert proper C++ library support
	      _LT_TAGVAR(ld_shlibs, $1)=no
	    fi
	    ;;
        esac
        ;;

      interix[[3-9]]*)
	_LT_TAGVAR(hardcode_direct, $1)=no
	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
	# Instead, shared libraries are loaded at an image base (0x10000000 by
	# default) and relocated if they conflict, which is a slow very memory
	# consuming and fragmenting process.  To avoid this, we pick a random,
	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
	_LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
	;;
      irix5* | irix6*)
        case $cc_basename in
          CC*)
	    # SGI C++
	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'

	    # Archives containing C++ object files must be created using
	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
	    # necessary to make sure instantiated templates are included
	    # in the archive.
	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
	    ;;
          *)
	    if test "$GXX" = yes; then
	      if test "$with_gnu_ld" = no; then
	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
	      else
	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib'
	      fi
	    fi
	    _LT_TAGVAR(link_all_deplibs, $1)=yes
	    ;;
        esac
        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
        _LT_TAGVAR(hardcode_libdir_separator, $1)=:
        _LT_TAGVAR(inherit_rpath, $1)=yes
        ;;

      linux* | k*bsd*-gnu | kopensolaris*-gnu)
        case $cc_basename in
          KCC*)
	    # Kuck and Associates, Inc. (KAI) C++ Compiler

	    # KCC will only create a shared library if the output file
	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
	    # to its proper name (with version) after linking.
	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
	    _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
	    # Commands to make compiler produce verbose output that lists
	    # what "hidden" libraries, object files and flags are used when
	    # linking a shared library.
	    #
	    # There doesn't appear to be a way to prevent this compiler from
	    # explicitly linking system object files so we need to strip them
	    # from the output so that they don't get included in the library
	    # dependencies.
	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'

	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

	    # Archives containing C++ object files must be created using
	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
	    ;;
	  icpc* | ecpc* )
	    # Intel C++
	    with_gnu_ld=yes
	    # version 8.0 and above of icpc choke on multiply defined symbols
	    # if we add $predep_objects and $postdep_objects, however 7.1 and
	    # earlier do not add the objects themselves.
	    case `$CC -V 2>&1` in
	      *"Version 7."*)
	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
		;;
	      *)  # Version 8.0 or newer
	        tmp_idyn=
	        case $host_cpu in
		  ia64*) tmp_idyn=' -i_dynamic';;
		esac
	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
		_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
		;;
	    esac
	    _LT_TAGVAR(archive_cmds_need_lc, $1)=no
	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
	    _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
	    ;;
          pgCC* | pgcpp*)
            # Portland Group C++ compiler
	    case `$CC -V` in
	    *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*)
	      _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
		rm -rf $tpldir~
		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
	      _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
		rm -rf $tpldir~
		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
		$RANLIB $oldlib'
	      _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
		rm -rf $tpldir~
		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
	      _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
		rm -rf $tpldir~
		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
	      ;;
	    *) # Version 6 and above use weak symbols
	      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
	      ;;
	    esac

	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
	    _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
            ;;
	  cxx*)
	    # Compaq C++
	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'

	    runpath_var=LD_RUN_PATH
	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:

	    # Commands to make compiler produce verbose output that lists
	    # what "hidden" libraries, object files and flags are used when
	    # linking a shared library.
	    #
	    # There doesn't appear to be a way to prevent this compiler from
	    # explicitly linking system object files so we need to strip them
	    # from the output so that they don't get included in the library
	    # dependencies.
	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
	    ;;
	  xl* | mpixl* | bgxl*)
	    # IBM XL 8.0 on PPC, with GNU ld
	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
	    _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	    if test "x$supports_anon_versioning" = xyes; then
	      _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
		cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
		echo "local: *; };" >> $output_objdir/$libname.ver~
		$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
	    fi
	    ;;
	  *)
	    case `$CC -V 2>&1 | sed 5q` in
	    *Sun\ C*)
	      # Sun C++ 5.9
	      _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
	      _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	      _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'
	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
	      _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	      _LT_TAGVAR(compiler_needs_object, $1)=yes

	      # Not sure whether something based on
	      # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
	      # would be better.
	      output_verbose_link_cmd='func_echo_all'

	      # Archives containing C++ object files must be created using
	      # "CC -xar", where "CC" is the Sun C++ compiler.  This is
	      # necessary to make sure instantiated templates are included
	      # in the archive.
	      _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
	      ;;
	    esac
	    ;;
	esac
	;;

      lynxos*)
        # FIXME: insert proper C++ library support
	_LT_TAGVAR(ld_shlibs, $1)=no
	;;

      m88k*)
        # FIXME: insert proper C++ library support
        _LT_TAGVAR(ld_shlibs, $1)=no
	;;

      mvs*)
        case $cc_basename in
          cxx*)
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
	  *)
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
	esac
	;;

      netbsd*)
        if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
	  _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
	  wlarc=
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
	  _LT_TAGVAR(hardcode_direct, $1)=yes
	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
	fi
	# Workaround some broken pre-1.5 toolchains
	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
	;;

      *nto* | *qnx*)
        _LT_TAGVAR(ld_shlibs, $1)=yes
	;;

      openbsd2*)
        # C++ shared libraries are fairly broken
	_LT_TAGVAR(ld_shlibs, $1)=no
	;;

      openbsd*)
	if test -f /usr/libexec/ld.so; then
	  _LT_TAGVAR(hardcode_direct, $1)=yes
	  _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
	  _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
	  _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
	    _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
	    _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
	  fi
	  output_verbose_link_cmd=func_echo_all
	else
	  _LT_TAGVAR(ld_shlibs, $1)=no
	fi
	;;

      osf3* | osf4* | osf5*)
        case $cc_basename in
          KCC*)
	    # Kuck and Associates, Inc. (KAI) C++ Compiler

	    # KCC will only create a shared library if the output file
	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
	    # to its proper name (with version) after linking.
	    _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:

	    # Archives containing C++ object files must be created using
	    # the KAI C++ compiler.
	    case $host in
	      osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;;
	      *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;;
	    esac
	    ;;
          RCC*)
	    # Rational C++ 2.4.1
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
          cxx*)
	    case $host in
	      osf3*)
	        _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
		;;
	      *)
	        _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
	        _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
	          echo "-hidden">> $lib.exp~
	          $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~
	          $RM $lib.exp'
	        _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
		;;
	    esac

	    _LT_TAGVAR(hardcode_libdir_separator, $1)=:

	    # Commands to make compiler produce verbose output that lists
	    # what "hidden" libraries, object files and flags are used when
	    # linking a shared library.
	    #
	    # There doesn't appear to be a way to prevent this compiler from
	    # explicitly linking system object files so we need to strip them
	    # from the output so that they don't get included in the library
	    # dependencies.
	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
	    ;;
	  *)
	    if test "$GXX" = yes && test "$with_gnu_ld" = no; then
	      _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
	      case $host in
	        osf3*)
	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
		  ;;
	        *)
	          _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
		  ;;
	      esac

	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
	      _LT_TAGVAR(hardcode_libdir_separator, $1)=:

	      # Commands to make compiler produce verbose output that lists
	      # what "hidden" libraries, object files and flags are used when
	      # linking a shared library.
	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'

	    else
	      # FIXME: insert proper C++ library support
	      _LT_TAGVAR(ld_shlibs, $1)=no
	    fi
	    ;;
        esac
        ;;

      psos*)
        # FIXME: insert proper C++ library support
        _LT_TAGVAR(ld_shlibs, $1)=no
        ;;

      sunos4*)
        case $cc_basename in
          CC*)
	    # Sun C++ 4.x
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
          lcc*)
	    # Lucid
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
          *)
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
        esac
        ;;

      solaris*)
        case $cc_basename in
          CC* | sunCC*)
	    # Sun C++ 4.2, 5.x and Centerline C++
            _LT_TAGVAR(archive_cmds_need_lc,$1)=yes
	    _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
	    _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	    _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
	      $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'

	    _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
	    _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
	    case $host_os in
	      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
	      *)
		# The compiler driver will combine and reorder linker options,
		# but understands `-z linker_flag'.
	        # Supported since Solaris 2.6 (maybe 2.5.1?)
		_LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
	        ;;
	    esac
	    _LT_TAGVAR(link_all_deplibs, $1)=yes

	    output_verbose_link_cmd='func_echo_all'

	    # Archives containing C++ object files must be created using
	    # "CC -xar", where "CC" is the Sun C++ compiler.  This is
	    # necessary to make sure instantiated templates are included
	    # in the archive.
	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
	    ;;
          gcx*)
	    # Green Hills C++ Compiler
	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

	    # The C++ compiler must be used to create the archive.
	    _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
	    ;;
          *)
	    # GNU C++ compiler with Solaris linker
	    if test "$GXX" = yes && test "$with_gnu_ld" = no; then
	      _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'
	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
	        _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
	        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
		  $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'

	        # Commands to make compiler produce verbose output that lists
	        # what "hidden" libraries, object files and flags are used when
	        # linking a shared library.
	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
	      else
	        # g++ 2.7 appears to require `-G' NOT `-shared' on this
	        # platform.
	        _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
	        _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
		  $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'

	        # Commands to make compiler produce verbose output that lists
	        # what "hidden" libraries, object files and flags are used when
	        # linking a shared library.
	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
	      fi

	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
	      case $host_os in
		solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
		*)
		  _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
		  ;;
	      esac
	    fi
	    ;;
        esac
        ;;

    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
      _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
      _LT_TAGVAR(archive_cmds_need_lc, $1)=no
      _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
      runpath_var='LD_RUN_PATH'

      case $cc_basename in
        CC*)
	  _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	*)
	  _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	  _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
      esac
      ;;

      sysv5* | sco3.2v5* | sco5v6*)
	# Note: We can NOT use -z defs as we might desire, because we do not
	# link with -lc, and that would cause any symbols used from libc to
	# always be unresolved, which means just about no library would
	# ever link correctly.  If we're not using GNU ld we use -z text
	# though, which does catch some bad symbols but isn't as heavy-handed
	# as -z defs.
	_LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
	_LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
	_LT_TAGVAR(archive_cmds_need_lc, $1)=no
	_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
	_LT_TAGVAR(hardcode_libdir_separator, $1)=':'
	_LT_TAGVAR(link_all_deplibs, $1)=yes
	_LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
	runpath_var='LD_RUN_PATH'

	case $cc_basename in
          CC*)
	    _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	    _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~
	      '"$_LT_TAGVAR(old_archive_cmds, $1)"
	    _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~
	      '"$_LT_TAGVAR(reload_cmds, $1)"
	    ;;
	  *)
	    _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	    _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	    ;;
	esac
      ;;

      tandem*)
        case $cc_basename in
          NCC*)
	    # NonStop-UX NCC 3.20
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
          *)
	    # FIXME: insert proper C++ library support
	    _LT_TAGVAR(ld_shlibs, $1)=no
	    ;;
        esac
        ;;

      vxworks*)
        # FIXME: insert proper C++ library support
        _LT_TAGVAR(ld_shlibs, $1)=no
        ;;

      *)
        # FIXME: insert proper C++ library support
        _LT_TAGVAR(ld_shlibs, $1)=no
        ;;
    esac

    AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
    test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no

    _LT_TAGVAR(GCC, $1)="$GXX"
    _LT_TAGVAR(LD, $1)="$LD"

    ## CAVEAT EMPTOR:
    ## There is no encapsulation within the following macros, do not change
    ## the running order or otherwise move them around unless you know exactly
    ## what you are doing...
    _LT_SYS_HIDDEN_LIBDEPS($1)
    _LT_COMPILER_PIC($1)
    _LT_COMPILER_C_O($1)
    _LT_COMPILER_FILE_LOCKS($1)
    _LT_LINKER_SHLIBS($1)
    _LT_SYS_DYNAMIC_LINKER($1)
    _LT_LINKER_HARDCODE_LIBPATH($1)

    _LT_CONFIG($1)
  fi # test -n "$compiler"

  CC=$lt_save_CC
  CFLAGS=$lt_save_CFLAGS
  LDCXX=$LD
  LD=$lt_save_LD
  GCC=$lt_save_GCC
  with_gnu_ld=$lt_save_with_gnu_ld
  lt_cv_path_LDCXX=$lt_cv_path_LD
  lt_cv_path_LD=$lt_save_path_LD
  lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
  lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
fi # test "$_lt_caught_CXX_error" != yes

AC_LANG_POP
])# _LT_LANG_CXX_CONFIG


# _LT_FUNC_STRIPNAME_CNF
# ----------------------
# func_stripname_cnf prefix suffix name
# strip PREFIX and SUFFIX off of NAME.
# PREFIX and SUFFIX must not contain globbing or regex special
# characters, hashes, percent signs, but SUFFIX may contain a leading
# dot (in which case that matches only a dot).
#
# This function is identical to the (non-XSI) version of func_stripname,
# except this one can be used by m4 code that may be executed by configure,
# rather than the libtool script.
m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl
AC_REQUIRE([_LT_DECL_SED])
AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])
func_stripname_cnf ()
{
  case ${2} in
  .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
  *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
  esac
} # func_stripname_cnf
])# _LT_FUNC_STRIPNAME_CNF

# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME])
# ---------------------------------
# Figure out "hidden" library dependencies from verbose
# compiler output when linking a shared library.
# Parse the compiler output and extract the necessary
# objects, libraries and library flags.
m4_defun([_LT_SYS_HIDDEN_LIBDEPS],
[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl
# Dependencies to place before and after the object being linked:
_LT_TAGVAR(predep_objects, $1)=
_LT_TAGVAR(postdep_objects, $1)=
_LT_TAGVAR(predeps, $1)=
_LT_TAGVAR(postdeps, $1)=
_LT_TAGVAR(compiler_lib_search_path, $1)=

dnl we can't use the lt_simple_compile_test_code here,
dnl because it contains code intended for an executable,
dnl not a library.  It's possible we should let each
dnl tag define a new lt_????_link_test_code variable,
dnl but it's only used here...
m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF
int a;
void foo (void) { a = 0; }
_LT_EOF
], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF
class Foo
{
public:
  Foo (void) { a = 0; }
private:
  int a;
};
_LT_EOF
], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF
      subroutine foo
      implicit none
      integer*4 a
      a=0
      return
      end
_LT_EOF
], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF
      subroutine foo
      implicit none
      integer a
      a=0
      return
      end
_LT_EOF
], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF
public class foo {
  private int a;
  public void bar (void) {
    a = 0;
  }
};
_LT_EOF
], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF
package foo
func foo() {
}
_LT_EOF
])

_lt_libdeps_save_CFLAGS=$CFLAGS
case "$CC $CFLAGS " in #(
*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
esac

dnl Parse the compiler output and extract the necessary
dnl objects, libraries and library flags.
if AC_TRY_EVAL(ac_compile); then
  # Parse the compiler output and extract the necessary
  # objects, libraries and library flags.

  # Sentinel used to keep track of whether or not we are before
  # the conftest object file.
  pre_test_object_deps_done=no

  for p in `eval "$output_verbose_link_cmd"`; do
    case ${prev}${p} in

    -L* | -R* | -l*)
       # Some compilers place space between "-{L,R}" and the path.
       # Remove the space.
       if test $p = "-L" ||
          test $p = "-R"; then
	 prev=$p
	 continue
       fi

       # Expand the sysroot to ease extracting the directories later.
       if test -z "$prev"; then
         case $p in
         -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
         -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
         -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
         esac
       fi
       case $p in
       =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
       esac
       if test "$pre_test_object_deps_done" = no; then
	 case ${prev} in
	 -L | -R)
	   # Internal compiler library paths should come after those
	   # provided the user.  The postdeps already come after the
	   # user supplied libs so there is no need to process them.
	   if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then
	     _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
	   else
	     _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
	   fi
	   ;;
	 # The "-l" case would never come before the object being
	 # linked, so don't bother handling this case.
	 esac
       else
	 if test -z "$_LT_TAGVAR(postdeps, $1)"; then
	   _LT_TAGVAR(postdeps, $1)="${prev}${p}"
	 else
	   _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}"
	 fi
       fi
       prev=
       ;;

    *.lto.$objext) ;; # Ignore GCC LTO objects
    *.$objext)
       # This assumes that the test object file only shows up
       # once in the compiler output.
       if test "$p" = "conftest.$objext"; then
	 pre_test_object_deps_done=yes
	 continue
       fi

       if test "$pre_test_object_deps_done" = no; then
	 if test -z "$_LT_TAGVAR(predep_objects, $1)"; then
	   _LT_TAGVAR(predep_objects, $1)="$p"
	 else
	   _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p"
	 fi
       else
	 if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then
	   _LT_TAGVAR(postdep_objects, $1)="$p"
	 else
	   _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p"
	 fi
       fi
       ;;

    *) ;; # Ignore the rest.

    esac
  done

  # Clean up.
  rm -f a.out a.exe
else
  echo "libtool.m4: error: problem compiling $1 test program"
fi

$RM -f confest.$objext
CFLAGS=$_lt_libdeps_save_CFLAGS

# PORTME: override above test on systems where it is broken
m4_if([$1], [CXX],
[case $host_os in
interix[[3-9]]*)
  # Interix 3.5 installs completely hosed .la files for C++, so rather than
  # hack all around it, let's just trust "g++" to DTRT.
  _LT_TAGVAR(predep_objects,$1)=
  _LT_TAGVAR(postdep_objects,$1)=
  _LT_TAGVAR(postdeps,$1)=
  ;;

linux*)
  case `$CC -V 2>&1 | sed 5q` in
  *Sun\ C*)
    # Sun C++ 5.9

    # The more standards-conforming stlport4 library is
    # incompatible with the Cstd library. Avoid specifying
    # it if it's in CXXFLAGS. Ignore libCrun as
    # -library=stlport4 depends on it.
    case " $CXX $CXXFLAGS " in
    *" -library=stlport4 "*)
      solaris_use_stlport4=yes
      ;;
    esac

    if test "$solaris_use_stlport4" != yes; then
      _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
    fi
    ;;
  esac
  ;;

solaris*)
  case $cc_basename in
  CC* | sunCC*)
    # The more standards-conforming stlport4 library is
    # incompatible with the Cstd library. Avoid specifying
    # it if it's in CXXFLAGS. Ignore libCrun as
    # -library=stlport4 depends on it.
    case " $CXX $CXXFLAGS " in
    *" -library=stlport4 "*)
      solaris_use_stlport4=yes
      ;;
    esac

    # Adding this requires a known-good setup of shared libraries for
    # Sun compiler versions before 5.6, else PIC objects from an old
    # archive will be linked into the output, leading to subtle bugs.
    if test "$solaris_use_stlport4" != yes; then
      _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
    fi
    ;;
  esac
  ;;
esac
])

case " $_LT_TAGVAR(postdeps, $1) " in
*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;;
esac
 _LT_TAGVAR(compiler_lib_search_dirs, $1)=
if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then
 _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'`
fi
_LT_TAGDECL([], [compiler_lib_search_dirs], [1],
    [The directories searched by this compiler when creating a shared library])
_LT_TAGDECL([], [predep_objects], [1],
    [Dependencies to place before and after the objects being linked to
    create a shared library])
_LT_TAGDECL([], [postdep_objects], [1])
_LT_TAGDECL([], [predeps], [1])
_LT_TAGDECL([], [postdeps], [1])
_LT_TAGDECL([], [compiler_lib_search_path], [1],
    [The library search path used internally by the compiler when linking
    a shared library])
])# _LT_SYS_HIDDEN_LIBDEPS


# _LT_LANG_F77_CONFIG([TAG])
# --------------------------
# Ensure that the configuration variables for a Fortran 77 compiler are
# suitably defined.  These variables are subsequently used by _LT_CONFIG
# to write the compiler configuration to `libtool'.
m4_defun([_LT_LANG_F77_CONFIG],
[AC_LANG_PUSH(Fortran 77)
if test -z "$F77" || test "X$F77" = "Xno"; then
  _lt_disable_F77=yes
fi

_LT_TAGVAR(archive_cmds_need_lc, $1)=no
_LT_TAGVAR(allow_undefined_flag, $1)=
_LT_TAGVAR(always_export_symbols, $1)=no
_LT_TAGVAR(archive_expsym_cmds, $1)=
_LT_TAGVAR(export_dynamic_flag_spec, $1)=
_LT_TAGVAR(hardcode_direct, $1)=no
_LT_TAGVAR(hardcode_direct_absolute, $1)=no
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
_LT_TAGVAR(hardcode_libdir_separator, $1)=
_LT_TAGVAR(hardcode_minus_L, $1)=no
_LT_TAGVAR(hardcode_automatic, $1)=no
_LT_TAGVAR(inherit_rpath, $1)=no
_LT_TAGVAR(module_cmds, $1)=
_LT_TAGVAR(module_expsym_cmds, $1)=
_LT_TAGVAR(link_all_deplibs, $1)=unknown
_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
_LT_TAGVAR(reload_flag, $1)=$reload_flag
_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
_LT_TAGVAR(no_undefined_flag, $1)=
_LT_TAGVAR(whole_archive_flag_spec, $1)=
_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no

# Source file extension for f77 test sources.
ac_ext=f

# Object file extension for compiled f77 test sources.
objext=o
_LT_TAGVAR(objext, $1)=$objext

# No sense in running all these tests if we already determined that
# the F77 compiler isn't working.  Some variables (like enable_shared)
# are currently assumed to apply to all compilers on this platform,
# and will be corrupted by setting them based on a non-working compiler.
if test "$_lt_disable_F77" != yes; then
  # Code to be used in simple compile tests
  lt_simple_compile_test_code="\
      subroutine t
      return
      end
"

  # Code to be used in simple link tests
  lt_simple_link_test_code="\
      program t
      end
"

  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
  _LT_TAG_COMPILER

  # save warnings/boilerplate of simple test code
  _LT_COMPILER_BOILERPLATE
  _LT_LINKER_BOILERPLATE

  # Allow CC to be a program name with arguments.
  lt_save_CC="$CC"
  lt_save_GCC=$GCC
  lt_save_CFLAGS=$CFLAGS
  CC=${F77-"f77"}
  CFLAGS=$FFLAGS
  compiler=$CC
  _LT_TAGVAR(compiler, $1)=$CC
  _LT_CC_BASENAME([$compiler])
  GCC=$G77
  if test -n "$compiler"; then
    AC_MSG_CHECKING([if libtool supports shared libraries])
    AC_MSG_RESULT([$can_build_shared])

    AC_MSG_CHECKING([whether to build shared libraries])
    test "$can_build_shared" = "no" && enable_shared=no

    # On AIX, shared libraries and static libraries use the same namespace, and
    # are all built from PIC.
    case $host_os in
      aix3*)
        test "$enable_shared" = yes && enable_static=no
        if test -n "$RANLIB"; then
          archive_cmds="$archive_cmds~\$RANLIB \$lib"
          postinstall_cmds='$RANLIB $lib'
        fi
        ;;
      aix[[4-9]]*)
	if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
	  test "$enable_shared" = yes && enable_static=no
	fi
        ;;
    esac
    AC_MSG_RESULT([$enable_shared])

    AC_MSG_CHECKING([whether to build static libraries])
    # Make sure either enable_shared or enable_static is yes.
    test "$enable_shared" = yes || enable_static=yes
    AC_MSG_RESULT([$enable_static])

    _LT_TAGVAR(GCC, $1)="$G77"
    _LT_TAGVAR(LD, $1)="$LD"

    ## CAVEAT EMPTOR:
    ## There is no encapsulation within the following macros, do not change
    ## the running order or otherwise move them around unless you know exactly
    ## what you are doing...
    _LT_COMPILER_PIC($1)
    _LT_COMPILER_C_O($1)
    _LT_COMPILER_FILE_LOCKS($1)
    _LT_LINKER_SHLIBS($1)
    _LT_SYS_DYNAMIC_LINKER($1)
    _LT_LINKER_HARDCODE_LIBPATH($1)

    _LT_CONFIG($1)
  fi # test -n "$compiler"

  GCC=$lt_save_GCC
  CC="$lt_save_CC"
  CFLAGS="$lt_save_CFLAGS"
fi # test "$_lt_disable_F77" != yes

AC_LANG_POP
])# _LT_LANG_F77_CONFIG


# _LT_LANG_FC_CONFIG([TAG])
# -------------------------
# Ensure that the configuration variables for a Fortran compiler are
# suitably defined.  These variables are subsequently used by _LT_CONFIG
# to write the compiler configuration to `libtool'.
m4_defun([_LT_LANG_FC_CONFIG],
[AC_LANG_PUSH(Fortran)

if test -z "$FC" || test "X$FC" = "Xno"; then
  _lt_disable_FC=yes
fi

_LT_TAGVAR(archive_cmds_need_lc, $1)=no
_LT_TAGVAR(allow_undefined_flag, $1)=
_LT_TAGVAR(always_export_symbols, $1)=no
_LT_TAGVAR(archive_expsym_cmds, $1)=
_LT_TAGVAR(export_dynamic_flag_spec, $1)=
_LT_TAGVAR(hardcode_direct, $1)=no
_LT_TAGVAR(hardcode_direct_absolute, $1)=no
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
_LT_TAGVAR(hardcode_libdir_separator, $1)=
_LT_TAGVAR(hardcode_minus_L, $1)=no
_LT_TAGVAR(hardcode_automatic, $1)=no
_LT_TAGVAR(inherit_rpath, $1)=no
_LT_TAGVAR(module_cmds, $1)=
_LT_TAGVAR(module_expsym_cmds, $1)=
_LT_TAGVAR(link_all_deplibs, $1)=unknown
_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
_LT_TAGVAR(reload_flag, $1)=$reload_flag
_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
_LT_TAGVAR(no_undefined_flag, $1)=
_LT_TAGVAR(whole_archive_flag_spec, $1)=
_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no

# Source file extension for fc test sources.
ac_ext=${ac_fc_srcext-f}

# Object file extension for compiled fc test sources.
objext=o
_LT_TAGVAR(objext, $1)=$objext

# No sense in running all these tests if we already determined that
# the FC compiler isn't working.  Some variables (like enable_shared)
# are currently assumed to apply to all compilers on this platform,
# and will be corrupted by setting them based on a non-working compiler.
if test "$_lt_disable_FC" != yes; then
  # Code to be used in simple compile tests
  lt_simple_compile_test_code="\
      subroutine t
      return
      end
"

  # Code to be used in simple link tests
  lt_simple_link_test_code="\
      program t
      end
"

  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
  _LT_TAG_COMPILER

  # save warnings/boilerplate of simple test code
  _LT_COMPILER_BOILERPLATE
  _LT_LINKER_BOILERPLATE

  # Allow CC to be a program name with arguments.
  lt_save_CC="$CC"
  lt_save_GCC=$GCC
  lt_save_CFLAGS=$CFLAGS
  CC=${FC-"f95"}
  CFLAGS=$FCFLAGS
  compiler=$CC
  GCC=$ac_cv_fc_compiler_gnu

  _LT_TAGVAR(compiler, $1)=$CC
  _LT_CC_BASENAME([$compiler])

  if test -n "$compiler"; then
    AC_MSG_CHECKING([if libtool supports shared libraries])
    AC_MSG_RESULT([$can_build_shared])

    AC_MSG_CHECKING([whether to build shared libraries])
    test "$can_build_shared" = "no" && enable_shared=no

    # On AIX, shared libraries and static libraries use the same namespace, and
    # are all built from PIC.
    case $host_os in
      aix3*)
        test "$enable_shared" = yes && enable_static=no
        if test -n "$RANLIB"; then
          archive_cmds="$archive_cmds~\$RANLIB \$lib"
          postinstall_cmds='$RANLIB $lib'
        fi
        ;;
      aix[[4-9]]*)
	if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
	  test "$enable_shared" = yes && enable_static=no
	fi
        ;;
    esac
    AC_MSG_RESULT([$enable_shared])

    AC_MSG_CHECKING([whether to build static libraries])
    # Make sure either enable_shared or enable_static is yes.
    test "$enable_shared" = yes || enable_static=yes
    AC_MSG_RESULT([$enable_static])

    _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu"
    _LT_TAGVAR(LD, $1)="$LD"

    ## CAVEAT EMPTOR:
    ## There is no encapsulation within the following macros, do not change
    ## the running order or otherwise move them around unless you know exactly
    ## what you are doing...
    _LT_SYS_HIDDEN_LIBDEPS($1)
    _LT_COMPILER_PIC($1)
    _LT_COMPILER_C_O($1)
    _LT_COMPILER_FILE_LOCKS($1)
    _LT_LINKER_SHLIBS($1)
    _LT_SYS_DYNAMIC_LINKER($1)
    _LT_LINKER_HARDCODE_LIBPATH($1)

    _LT_CONFIG($1)
  fi # test -n "$compiler"

  GCC=$lt_save_GCC
  CC=$lt_save_CC
  CFLAGS=$lt_save_CFLAGS
fi # test "$_lt_disable_FC" != yes

AC_LANG_POP
])# _LT_LANG_FC_CONFIG


# _LT_LANG_GCJ_CONFIG([TAG])
# --------------------------
# Ensure that the configuration variables for the GNU Java Compiler compiler
# are suitably defined.  These variables are subsequently used by _LT_CONFIG
# to write the compiler configuration to `libtool'.
m4_defun([_LT_LANG_GCJ_CONFIG],
[AC_REQUIRE([LT_PROG_GCJ])dnl
AC_LANG_SAVE

# Source file extension for Java test sources.
ac_ext=java

# Object file extension for compiled Java test sources.
objext=o
_LT_TAGVAR(objext, $1)=$objext

# Code to be used in simple compile tests
lt_simple_compile_test_code="class foo {}"

# Code to be used in simple link tests
lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }'

# ltmain only uses $CC for tagged configurations so make sure $CC is set.
_LT_TAG_COMPILER

# save warnings/boilerplate of simple test code
_LT_COMPILER_BOILERPLATE
_LT_LINKER_BOILERPLATE

# Allow CC to be a program name with arguments.
lt_save_CC=$CC
lt_save_CFLAGS=$CFLAGS
lt_save_GCC=$GCC
GCC=yes
CC=${GCJ-"gcj"}
CFLAGS=$GCJFLAGS
compiler=$CC
_LT_TAGVAR(compiler, $1)=$CC
_LT_TAGVAR(LD, $1)="$LD"
_LT_CC_BASENAME([$compiler])

# GCJ did not exist at the time GCC didn't implicitly link libc in.
_LT_TAGVAR(archive_cmds_need_lc, $1)=no

_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
_LT_TAGVAR(reload_flag, $1)=$reload_flag
_LT_TAGVAR(reload_cmds, $1)=$reload_cmds

## CAVEAT EMPTOR:
## There is no encapsulation within the following macros, do not change
## the running order or otherwise move them around unless you know exactly
## what you are doing...
if test -n "$compiler"; then
  _LT_COMPILER_NO_RTTI($1)
  _LT_COMPILER_PIC($1)
  _LT_COMPILER_C_O($1)
  _LT_COMPILER_FILE_LOCKS($1)
  _LT_LINKER_SHLIBS($1)
  _LT_LINKER_HARDCODE_LIBPATH($1)

  _LT_CONFIG($1)
fi

AC_LANG_RESTORE

GCC=$lt_save_GCC
CC=$lt_save_CC
CFLAGS=$lt_save_CFLAGS
])# _LT_LANG_GCJ_CONFIG


# _LT_LANG_GO_CONFIG([TAG])
# --------------------------
# Ensure that the configuration variables for the GNU Go compiler
# are suitably defined.  These variables are subsequently used by _LT_CONFIG
# to write the compiler configuration to `libtool'.
m4_defun([_LT_LANG_GO_CONFIG],
[AC_REQUIRE([LT_PROG_GO])dnl
AC_LANG_SAVE

# Source file extension for Go test sources.
ac_ext=go

# Object file extension for compiled Go test sources.
objext=o
_LT_TAGVAR(objext, $1)=$objext

# Code to be used in simple compile tests
lt_simple_compile_test_code="package main; func main() { }"

# Code to be used in simple link tests
lt_simple_link_test_code='package main; func main() { }'

# ltmain only uses $CC for tagged configurations so make sure $CC is set.
_LT_TAG_COMPILER

# save warnings/boilerplate of simple test code
_LT_COMPILER_BOILERPLATE
_LT_LINKER_BOILERPLATE

# Allow CC to be a program name with arguments.
lt_save_CC=$CC
lt_save_CFLAGS=$CFLAGS
lt_save_GCC=$GCC
GCC=yes
CC=${GOC-"gccgo"}
CFLAGS=$GOFLAGS
compiler=$CC
_LT_TAGVAR(compiler, $1)=$CC
_LT_TAGVAR(LD, $1)="$LD"
_LT_CC_BASENAME([$compiler])

# Go did not exist at the time GCC didn't implicitly link libc in.
_LT_TAGVAR(archive_cmds_need_lc, $1)=no

_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
_LT_TAGVAR(reload_flag, $1)=$reload_flag
_LT_TAGVAR(reload_cmds, $1)=$reload_cmds

## CAVEAT EMPTOR:
## There is no encapsulation within the following macros, do not change
## the running order or otherwise move them around unless you know exactly
## what you are doing...
if test -n "$compiler"; then
  _LT_COMPILER_NO_RTTI($1)
  _LT_COMPILER_PIC($1)
  _LT_COMPILER_C_O($1)
  _LT_COMPILER_FILE_LOCKS($1)
  _LT_LINKER_SHLIBS($1)
  _LT_LINKER_HARDCODE_LIBPATH($1)

  _LT_CONFIG($1)
fi

AC_LANG_RESTORE

GCC=$lt_save_GCC
CC=$lt_save_CC
CFLAGS=$lt_save_CFLAGS
])# _LT_LANG_GO_CONFIG


# _LT_LANG_RC_CONFIG([TAG])
# -------------------------
# Ensure that the configuration variables for the Windows resource compiler
# are suitably defined.  These variables are subsequently used by _LT_CONFIG
# to write the compiler configuration to `libtool'.
m4_defun([_LT_LANG_RC_CONFIG],
[AC_REQUIRE([LT_PROG_RC])dnl
AC_LANG_SAVE

# Source file extension for RC test sources.
ac_ext=rc

# Object file extension for compiled RC test sources.
objext=o
_LT_TAGVAR(objext, $1)=$objext

# Code to be used in simple compile tests
lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'

# Code to be used in simple link tests
lt_simple_link_test_code="$lt_simple_compile_test_code"

# ltmain only uses $CC for tagged configurations so make sure $CC is set.
_LT_TAG_COMPILER

# save warnings/boilerplate of simple test code
_LT_COMPILER_BOILERPLATE
_LT_LINKER_BOILERPLATE

# Allow CC to be a program name with arguments.
lt_save_CC="$CC"
lt_save_CFLAGS=$CFLAGS
lt_save_GCC=$GCC
GCC=
CC=${RC-"windres"}
CFLAGS=
compiler=$CC
_LT_TAGVAR(compiler, $1)=$CC
_LT_CC_BASENAME([$compiler])
_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes

if test -n "$compiler"; then
  :
  _LT_CONFIG($1)
fi

GCC=$lt_save_GCC
AC_LANG_RESTORE
CC=$lt_save_CC
CFLAGS=$lt_save_CFLAGS
])# _LT_LANG_RC_CONFIG


# LT_PROG_GCJ
# -----------
AC_DEFUN([LT_PROG_GCJ],
[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
  [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
    [AC_CHECK_TOOL(GCJ, gcj,)
      test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"
      AC_SUBST(GCJFLAGS)])])[]dnl
])

# Old name:
AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([LT_AC_PROG_GCJ], [])


# LT_PROG_GO
# ----------
AC_DEFUN([LT_PROG_GO],
[AC_CHECK_TOOL(GOC, gccgo,)
])


# LT_PROG_RC
# ----------
AC_DEFUN([LT_PROG_RC],
[AC_CHECK_TOOL(RC, windres,)
])

# Old name:
AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([LT_AC_PROG_RC], [])


# _LT_DECL_EGREP
# --------------
# If we don't have a new enough Autoconf to choose the best grep
# available, choose the one first in the user's PATH.
m4_defun([_LT_DECL_EGREP],
[AC_REQUIRE([AC_PROG_EGREP])dnl
AC_REQUIRE([AC_PROG_FGREP])dnl
test -z "$GREP" && GREP=grep
_LT_DECL([], [GREP], [1], [A grep program that handles long lines])
_LT_DECL([], [EGREP], [1], [An ERE matcher])
_LT_DECL([], [FGREP], [1], [A literal string matcher])
dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too
AC_SUBST([GREP])
])


# _LT_DECL_OBJDUMP
# --------------
# If we don't have a new enough Autoconf to choose the best objdump
# available, choose the one first in the user's PATH.
m4_defun([_LT_DECL_OBJDUMP],
[AC_CHECK_TOOL(OBJDUMP, objdump, false)
test -z "$OBJDUMP" && OBJDUMP=objdump
_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper])
AC_SUBST([OBJDUMP])
])

# _LT_DECL_DLLTOOL
# ----------------
# Ensure DLLTOOL variable is set.
m4_defun([_LT_DECL_DLLTOOL],
[AC_CHECK_TOOL(DLLTOOL, dlltool, false)
test -z "$DLLTOOL" && DLLTOOL=dlltool
_LT_DECL([], [DLLTOOL], [1], [DLL creation program])
AC_SUBST([DLLTOOL])
])

# _LT_DECL_SED
# ------------
# Check for a fully-functional sed program, that truncates
# as few characters as possible.  Prefer GNU sed if found.
m4_defun([_LT_DECL_SED],
[AC_PROG_SED
test -z "$SED" && SED=sed
Xsed="$SED -e 1s/^X//"
_LT_DECL([], [SED], [1], [A sed program that does not truncate output])
_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"],
    [Sed that helps us avoid accidentally triggering echo(1) options like -n])
])# _LT_DECL_SED

m4_ifndef([AC_PROG_SED], [
############################################################
# NOTE: This macro has been submitted for inclusion into   #
#  GNU Autoconf as AC_PROG_SED.  When it is available in   #
#  a released version of Autoconf we should remove this    #
#  macro and use it instead.                               #
############################################################

m4_defun([AC_PROG_SED],
[AC_MSG_CHECKING([for a sed that does not truncate output])
AC_CACHE_VAL(lt_cv_path_SED,
[# Loop through the user's path and test for sed and gsed.
# Then use that list of sed's as ones to test for truncation.
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  for lt_ac_prog in sed gsed; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
      fi
    done
  done
done
IFS=$as_save_IFS
lt_ac_max=0
lt_ac_count=0
# Add /usr/xpg4/bin/sed as it is typically found on Solaris
# along with /bin/sed that truncates output.
for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
  test ! -f $lt_ac_sed && continue
  cat /dev/null > conftest.in
  lt_ac_count=0
  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
  # Check for GNU sed and select it if it is found.
  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
    lt_cv_path_SED=$lt_ac_sed
    break
  fi
  while true; do
    cat conftest.in conftest.in >conftest.tmp
    mv conftest.tmp conftest.in
    cp conftest.in conftest.nl
    echo >>conftest.nl
    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
    cmp -s conftest.out conftest.nl || break
    # 10000 chars as input seems more than enough
    test $lt_ac_count -gt 10 && break
    lt_ac_count=`expr $lt_ac_count + 1`
    if test $lt_ac_count -gt $lt_ac_max; then
      lt_ac_max=$lt_ac_count
      lt_cv_path_SED=$lt_ac_sed
    fi
  done
done
])
SED=$lt_cv_path_SED
AC_SUBST([SED])
AC_MSG_RESULT([$SED])
])#AC_PROG_SED
])#m4_ifndef

# Old name:
AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED])
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([LT_AC_PROG_SED], [])


# _LT_CHECK_SHELL_FEATURES
# ------------------------
# Find out whether the shell is Bourne or XSI compatible,
# or has some other useful features.
m4_defun([_LT_CHECK_SHELL_FEATURES],
[AC_MSG_CHECKING([whether the shell understands some XSI constructs])
# Try some XSI features
xsi_shell=no
( _lt_dummy="a/b/c"
  test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \
      = c,a/b,b/c, \
    && eval 'test $(( 1 + 1 )) -eq 2 \
    && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
  && xsi_shell=yes
AC_MSG_RESULT([$xsi_shell])
_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell'])

AC_MSG_CHECKING([whether the shell understands "+="])
lt_shell_append=no
( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \
    >/dev/null 2>&1 \
  && lt_shell_append=yes
AC_MSG_RESULT([$lt_shell_append])
_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append'])

if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  lt_unset=unset
else
  lt_unset=false
fi
_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl

# test EBCDIC or ASCII
case `echo X|tr X '\101'` in
 A) # ASCII based system
    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
  lt_SP2NL='tr \040 \012'
  lt_NL2SP='tr \015\012 \040\040'
  ;;
 *) # EBCDIC based system
  lt_SP2NL='tr \100 \n'
  lt_NL2SP='tr \r\n \100\100'
  ;;
esac
_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl
_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl
])# _LT_CHECK_SHELL_FEATURES


# _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY)
# ------------------------------------------------------
# In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and
# '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY.
m4_defun([_LT_PROG_FUNCTION_REPLACE],
[dnl {
sed -e '/^$1 ()$/,/^} # $1 /c\
$1 ()\
{\
m4_bpatsubsts([$2], [$], [\\], [^\([	 ]\)], [\\\1])
} # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:
])


# _LT_PROG_REPLACE_SHELLFNS
# -------------------------
# Replace existing portable implementations of several shell functions with
# equivalent extended shell implementations where those features are available..
m4_defun([_LT_PROG_REPLACE_SHELLFNS],
[if test x"$xsi_shell" = xyes; then
  _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl
    case ${1} in
      */*) func_dirname_result="${1%/*}${2}" ;;
      *  ) func_dirname_result="${3}" ;;
    esac])

  _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl
    func_basename_result="${1##*/}"])

  _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl
    case ${1} in
      */*) func_dirname_result="${1%/*}${2}" ;;
      *  ) func_dirname_result="${3}" ;;
    esac
    func_basename_result="${1##*/}"])

  _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl
    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
    # positional parameters, so assign one to ordinary parameter first.
    func_stripname_result=${3}
    func_stripname_result=${func_stripname_result#"${1}"}
    func_stripname_result=${func_stripname_result%"${2}"}])

  _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl
    func_split_long_opt_name=${1%%=*}
    func_split_long_opt_arg=${1#*=}])

  _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl
    func_split_short_opt_arg=${1#??}
    func_split_short_opt_name=${1%"$func_split_short_opt_arg"}])

  _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl
    case ${1} in
      *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
      *)    func_lo2o_result=${1} ;;
    esac])

  _LT_PROG_FUNCTION_REPLACE([func_xform], [    func_xform_result=${1%.*}.lo])

  _LT_PROG_FUNCTION_REPLACE([func_arith], [    func_arith_result=$(( $[*] ))])

  _LT_PROG_FUNCTION_REPLACE([func_len], [    func_len_result=${#1}])
fi

if test x"$lt_shell_append" = xyes; then
  _LT_PROG_FUNCTION_REPLACE([func_append], [    eval "${1}+=\\${2}"])

  _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl
    func_quote_for_eval "${2}"
dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \
    eval "${1}+=\\\\ \\$func_quote_for_eval_result"])

  # Save a `func_append' function call where possible by direct use of '+='
  sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \
    && mv -f "$cfgfile.tmp" "$cfgfile" \
      || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
  test 0 -eq $? || _lt_function_replace_fail=:
else
  # Save a `func_append' function call even when '+=' is not available
  sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \
    && mv -f "$cfgfile.tmp" "$cfgfile" \
      || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
  test 0 -eq $? || _lt_function_replace_fail=:
fi

if test x"$_lt_function_replace_fail" = x":"; then
  AC_MSG_WARN([Unable to substitute extended shell functions in $ofile])
fi
])

# _LT_PATH_CONVERSION_FUNCTIONS
# -----------------------------
# Determine which file name conversion functions should be used by
# func_to_host_file (and, implicitly, by func_to_host_path).  These are needed
# for certain cross-compile configurations and native mingw.
m4_defun([_LT_PATH_CONVERSION_FUNCTIONS],
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
AC_REQUIRE([AC_CANONICAL_BUILD])dnl
AC_MSG_CHECKING([how to convert $build file names to $host format])
AC_CACHE_VAL(lt_cv_to_host_file_cmd,
[case $host in
  *-*-mingw* )
    case $build in
      *-*-mingw* ) # actually msys
        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
        ;;
      *-*-cygwin* )
        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
        ;;
      * ) # otherwise, assume *nix
        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
        ;;
    esac
    ;;
  *-*-cygwin* )
    case $build in
      *-*-mingw* ) # actually msys
        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
        ;;
      *-*-cygwin* )
        lt_cv_to_host_file_cmd=func_convert_file_noop
        ;;
      * ) # otherwise, assume *nix
        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
        ;;
    esac
    ;;
  * ) # unhandled hosts (and "normal" native builds)
    lt_cv_to_host_file_cmd=func_convert_file_noop
    ;;
esac
])
to_host_file_cmd=$lt_cv_to_host_file_cmd
AC_MSG_RESULT([$lt_cv_to_host_file_cmd])
_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd],
         [0], [convert $build file names to $host format])dnl

AC_MSG_CHECKING([how to convert $build file names to toolchain format])
AC_CACHE_VAL(lt_cv_to_tool_file_cmd,
[#assume ordinary cross tools, or native build.
lt_cv_to_tool_file_cmd=func_convert_file_noop
case $host in
  *-*-mingw* )
    case $build in
      *-*-mingw* ) # actually msys
        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
        ;;
    esac
    ;;
esac
])
to_tool_file_cmd=$lt_cv_to_tool_file_cmd
AC_MSG_RESULT([$lt_cv_to_tool_file_cmd])
_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd],
         [0], [convert $build files to toolchain format])dnl
])# _LT_PATH_CONVERSION_FUNCTIONS
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/m4/ltoptions.m40000644000175000017500000003007313010376362025141 0ustar  zoncazonca00000000000000# Helper functions for option handling.                    -*- Autoconf -*-
#
#   Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation,
#   Inc.
#   Written by Gary V. Vaughan, 2004
#
# This file is free software; the Free Software Foundation gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.

# serial 7 ltoptions.m4

# This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])


# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
# ------------------------------------------
m4_define([_LT_MANGLE_OPTION],
[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])


# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
# ---------------------------------------
# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
# matching handler defined, dispatch to it.  Other OPTION-NAMEs are
# saved as a flag.
m4_define([_LT_SET_OPTION],
[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
        _LT_MANGLE_DEFUN([$1], [$2]),
    [m4_warning([Unknown $1 option `$2'])])[]dnl
])


# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
# ------------------------------------------------------------
# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
m4_define([_LT_IF_OPTION],
[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])


# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
# -------------------------------------------------------
# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
# are set.
m4_define([_LT_UNLESS_OPTIONS],
[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
	    [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
		      [m4_define([$0_found])])])[]dnl
m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
])[]dnl
])


# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
# ----------------------------------------
# OPTION-LIST is a space-separated list of Libtool options associated
# with MACRO-NAME.  If any OPTION has a matching handler declared with
# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
# the unknown option and exit.
m4_defun([_LT_SET_OPTIONS],
[# Set options
m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
    [_LT_SET_OPTION([$1], _LT_Option)])

m4_if([$1],[LT_INIT],[
  dnl
  dnl Simply set some default values (i.e off) if boolean options were not
  dnl specified:
  _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
  ])
  _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
  ])
  dnl
  dnl If no reference was made to various pairs of opposing options, then
  dnl we run the default mode handler for the pair.  For example, if neither
  dnl `shared' nor `disable-shared' was passed, we enable building of shared
  dnl archives by default:
  _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
  _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
  _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
  _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
  		   [_LT_ENABLE_FAST_INSTALL])
  ])
])# _LT_SET_OPTIONS


## --------------------------------- ##
## Macros to handle LT_INIT options. ##
## --------------------------------- ##

# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
# -----------------------------------------
m4_define([_LT_MANGLE_DEFUN],
[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])


# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
# -----------------------------------------------
m4_define([LT_OPTION_DEFINE],
[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
])# LT_OPTION_DEFINE


# dlopen
# ------
LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
])

AU_DEFUN([AC_LIBTOOL_DLOPEN],
[_LT_SET_OPTION([LT_INIT], [dlopen])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `dlopen' option into LT_INIT's first parameter.])
])

dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])


# win32-dll
# ---------
# Declare package support for building win32 dll's.
LT_OPTION_DEFINE([LT_INIT], [win32-dll],
[enable_win32_dll=yes

case $host in
*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
  AC_CHECK_TOOL(AS, as, false)
  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
  AC_CHECK_TOOL(OBJDUMP, objdump, false)
  ;;
esac

test -z "$AS" && AS=as
_LT_DECL([], [AS],      [1], [Assembler program])dnl

test -z "$DLLTOOL" && DLLTOOL=dlltool
_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl

test -z "$OBJDUMP" && OBJDUMP=objdump
_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl
])# win32-dll

AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
_LT_SET_OPTION([LT_INIT], [win32-dll])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `win32-dll' option into LT_INIT's first parameter.])
])

dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])


# _LT_ENABLE_SHARED([DEFAULT])
# ----------------------------
# implement the --enable-shared flag, and supports the `shared' and
# `disable-shared' LT_INIT options.
# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_SHARED],
[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([shared],
    [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
	[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
    [p=${PACKAGE-default}
    case $enableval in
    yes) enable_shared=yes ;;
    no) enable_shared=no ;;
    *)
      enable_shared=no
      # Look at the argument we got.  We use all the common list separators.
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
      for pkg in $enableval; do
	IFS="$lt_save_ifs"
	if test "X$pkg" = "X$p"; then
	  enable_shared=yes
	fi
      done
      IFS="$lt_save_ifs"
      ;;
    esac],
    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)

    _LT_DECL([build_libtool_libs], [enable_shared], [0],
	[Whether or not to build shared libraries])
])# _LT_ENABLE_SHARED

LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])

# Old names:
AC_DEFUN([AC_ENABLE_SHARED],
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
])

AC_DEFUN([AC_DISABLE_SHARED],
[_LT_SET_OPTION([LT_INIT], [disable-shared])
])

AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])

dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AM_ENABLE_SHARED], [])
dnl AC_DEFUN([AM_DISABLE_SHARED], [])



# _LT_ENABLE_STATIC([DEFAULT])
# ----------------------------
# implement the --enable-static flag, and support the `static' and
# `disable-static' LT_INIT options.
# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_STATIC],
[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([static],
    [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
	[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
    [p=${PACKAGE-default}
    case $enableval in
    yes) enable_static=yes ;;
    no) enable_static=no ;;
    *)
     enable_static=no
      # Look at the argument we got.  We use all the common list separators.
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
      for pkg in $enableval; do
	IFS="$lt_save_ifs"
	if test "X$pkg" = "X$p"; then
	  enable_static=yes
	fi
      done
      IFS="$lt_save_ifs"
      ;;
    esac],
    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)

    _LT_DECL([build_old_libs], [enable_static], [0],
	[Whether or not to build static libraries])
])# _LT_ENABLE_STATIC

LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])

# Old names:
AC_DEFUN([AC_ENABLE_STATIC],
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
])

AC_DEFUN([AC_DISABLE_STATIC],
[_LT_SET_OPTION([LT_INIT], [disable-static])
])

AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])

dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AM_ENABLE_STATIC], [])
dnl AC_DEFUN([AM_DISABLE_STATIC], [])



# _LT_ENABLE_FAST_INSTALL([DEFAULT])
# ----------------------------------
# implement the --enable-fast-install flag, and support the `fast-install'
# and `disable-fast-install' LT_INIT options.
# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
m4_define([_LT_ENABLE_FAST_INSTALL],
[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
AC_ARG_ENABLE([fast-install],
    [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
    [p=${PACKAGE-default}
    case $enableval in
    yes) enable_fast_install=yes ;;
    no) enable_fast_install=no ;;
    *)
      enable_fast_install=no
      # Look at the argument we got.  We use all the common list separators.
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
      for pkg in $enableval; do
	IFS="$lt_save_ifs"
	if test "X$pkg" = "X$p"; then
	  enable_fast_install=yes
	fi
      done
      IFS="$lt_save_ifs"
      ;;
    esac],
    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)

_LT_DECL([fast_install], [enable_fast_install], [0],
	 [Whether or not to optimize for fast installation])dnl
])# _LT_ENABLE_FAST_INSTALL

LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])

# Old names:
AU_DEFUN([AC_ENABLE_FAST_INSTALL],
[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `fast-install' option into LT_INIT's first parameter.])
])

AU_DEFUN([AC_DISABLE_FAST_INSTALL],
[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you put
the `disable-fast-install' option into LT_INIT's first parameter.])
])

dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])


# _LT_WITH_PIC([MODE])
# --------------------
# implement the --with-pic flag, and support the `pic-only' and `no-pic'
# LT_INIT options.
# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
m4_define([_LT_WITH_PIC],
[AC_ARG_WITH([pic],
    [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
    [lt_p=${PACKAGE-default}
    case $withval in
    yes|no) pic_mode=$withval ;;
    *)
      pic_mode=default
      # Look at the argument we got.  We use all the common list separators.
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
      for lt_pkg in $withval; do
	IFS="$lt_save_ifs"
	if test "X$lt_pkg" = "X$lt_p"; then
	  pic_mode=yes
	fi
      done
      IFS="$lt_save_ifs"
      ;;
    esac],
    [pic_mode=default])

test -z "$pic_mode" && pic_mode=m4_default([$1], [default])

_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
])# _LT_WITH_PIC

LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])

# Old name:
AU_DEFUN([AC_LIBTOOL_PICMODE],
[_LT_SET_OPTION([LT_INIT], [pic-only])
AC_DIAGNOSE([obsolete],
[$0: Remove this warning and the call to _LT_SET_OPTION when you
put the `pic-only' option into LT_INIT's first parameter.])
])

dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])

## ----------------- ##
## LTDL_INIT Options ##
## ----------------- ##

m4_define([_LTDL_MODE], [])
LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
		 [m4_define([_LTDL_MODE], [nonrecursive])])
LT_OPTION_DEFINE([LTDL_INIT], [recursive],
		 [m4_define([_LTDL_MODE], [recursive])])
LT_OPTION_DEFINE([LTDL_INIT], [subproject],
		 [m4_define([_LTDL_MODE], [subproject])])

m4_define([_LTDL_TYPE], [])
LT_OPTION_DEFINE([LTDL_INIT], [installable],
		 [m4_define([_LTDL_TYPE], [installable])])
LT_OPTION_DEFINE([LTDL_INIT], [convenience],
		 [m4_define([_LTDL_TYPE], [convenience])])
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/m4/ltsugar.m40000644000175000017500000001042413010376362024565 0ustar  zoncazonca00000000000000# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
#
# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
# Written by Gary V. Vaughan, 2004
#
# This file is free software; the Free Software Foundation gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.

# serial 6 ltsugar.m4

# This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])


# lt_join(SEP, ARG1, [ARG2...])
# -----------------------------
# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
# associated separator.
# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
# versions in m4sugar had bugs.
m4_define([lt_join],
[m4_if([$#], [1], [],
       [$#], [2], [[$2]],
       [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
m4_define([_lt_join],
[m4_if([$#$2], [2], [],
       [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])


# lt_car(LIST)
# lt_cdr(LIST)
# ------------
# Manipulate m4 lists.
# These macros are necessary as long as will still need to support
# Autoconf-2.59 which quotes differently.
m4_define([lt_car], [[$1]])
m4_define([lt_cdr],
[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
       [$#], 1, [],
       [m4_dquote(m4_shift($@))])])
m4_define([lt_unquote], $1)


# lt_append(MACRO-NAME, STRING, [SEPARATOR])
# ------------------------------------------
# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
# Note that neither SEPARATOR nor STRING are expanded; they are appended
# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
# No SEPARATOR is output if MACRO-NAME was previously undefined (different
# than defined and empty).
#
# This macro is needed until we can rely on Autoconf 2.62, since earlier
# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
m4_define([lt_append],
[m4_define([$1],
	   m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])



# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
# ----------------------------------------------------------
# Produce a SEP delimited list of all paired combinations of elements of
# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
# has the form PREFIXmINFIXSUFFIXn.
# Needed until we can rely on m4_combine added in Autoconf 2.62.
m4_define([lt_combine],
[m4_if(m4_eval([$# > 3]), [1],
       [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
[[m4_foreach([_Lt_prefix], [$2],
	     [m4_foreach([_Lt_suffix],
		]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
	[_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])


# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
# -----------------------------------------------------------------------
# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
m4_define([lt_if_append_uniq],
[m4_ifdef([$1],
	  [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
		 [lt_append([$1], [$2], [$3])$4],
		 [$5])],
	  [lt_append([$1], [$2], [$3])$4])])


# lt_dict_add(DICT, KEY, VALUE)
# -----------------------------
m4_define([lt_dict_add],
[m4_define([$1($2)], [$3])])


# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
# --------------------------------------------
m4_define([lt_dict_add_subkey],
[m4_define([$1($2:$3)], [$4])])


# lt_dict_fetch(DICT, KEY, [SUBKEY])
# ----------------------------------
m4_define([lt_dict_fetch],
[m4_ifval([$3],
	m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])


# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
# -----------------------------------------------------------------
m4_define([lt_if_dict_fetch],
[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
	[$5],
    [$6])])


# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
# --------------------------------------------------------------
m4_define([lt_dict_filter],
[m4_if([$5], [], [],
  [lt_join(m4_quote(m4_default([$4], [[, ]])),
           lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
		      [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
])
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/m4/ltversion.m40000644000175000017500000000126213010376362025131 0ustar  zoncazonca00000000000000# ltversion.m4 -- version numbers			-*- Autoconf -*-
#
#   Copyright (C) 2004 Free Software Foundation, Inc.
#   Written by Scott James Remnant, 2004
#
# This file is free software; the Free Software Foundation gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.

# @configure_input@

# serial 3337 ltversion.m4
# This file is part of GNU Libtool

m4_define([LT_PACKAGE_VERSION], [2.4.2])
m4_define([LT_PACKAGE_REVISION], [1.3337])

AC_DEFUN([LTVERSION_VERSION],
[macro_version='2.4.2'
macro_revision='1.3337'
_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
_LT_DECL(, macro_revision, 0)
])
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/m4/lt~obsolete.m40000644000175000017500000001375613010376362025471 0ustar  zoncazonca00000000000000# lt~obsolete.m4 -- aclocal satisfying obsolete definitions.    -*-Autoconf-*-
#
#   Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
#   Written by Scott James Remnant, 2004.
#
# This file is free software; the Free Software Foundation gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.

# serial 5 lt~obsolete.m4

# These exist entirely to fool aclocal when bootstrapping libtool.
#
# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN)
# which have later been changed to m4_define as they aren't part of the
# exported API, or moved to Autoconf or Automake where they belong.
#
# The trouble is, aclocal is a bit thick.  It'll see the old AC_DEFUN
# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
# using a macro with the same name in our local m4/libtool.m4 it'll
# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
# and doesn't know about Autoconf macros at all.)
#
# So we provide this file, which has a silly filename so it's always
# included after everything else.  This provides aclocal with the
# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
# because those macros already exist, or will be overwritten later.
# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. 
#
# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
# Yes, that means every name once taken will need to remain here until
# we give up compatibility with versions before 1.7, at which point
# we need to keep only those names which we still refer to.

# This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])

m4_ifndef([AC_LIBTOOL_LINKER_OPTION],	[AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
m4_ifndef([AC_PROG_EGREP],		[AC_DEFUN([AC_PROG_EGREP])])
m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
m4_ifndef([_LT_AC_SHELL_INIT],		[AC_DEFUN([_LT_AC_SHELL_INIT])])
m4_ifndef([_LT_AC_SYS_LIBPATH_AIX],	[AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
m4_ifndef([_LT_PROG_LTMAIN],		[AC_DEFUN([_LT_PROG_LTMAIN])])
m4_ifndef([_LT_AC_TAGVAR],		[AC_DEFUN([_LT_AC_TAGVAR])])
m4_ifndef([AC_LTDL_ENABLE_INSTALL],	[AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
m4_ifndef([AC_LTDL_PREOPEN],		[AC_DEFUN([AC_LTDL_PREOPEN])])
m4_ifndef([_LT_AC_SYS_COMPILER],	[AC_DEFUN([_LT_AC_SYS_COMPILER])])
m4_ifndef([_LT_AC_LOCK],		[AC_DEFUN([_LT_AC_LOCK])])
m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE],	[AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
m4_ifndef([_LT_AC_TRY_DLOPEN_SELF],	[AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
m4_ifndef([AC_LIBTOOL_PROG_CC_C_O],	[AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
m4_ifndef([AC_LIBTOOL_OBJDIR],		[AC_DEFUN([AC_LIBTOOL_OBJDIR])])
m4_ifndef([AC_LTDL_OBJDIR],		[AC_DEFUN([AC_LTDL_OBJDIR])])
m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP],	[AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
m4_ifndef([AC_PATH_MAGIC],		[AC_DEFUN([AC_PATH_MAGIC])])
m4_ifndef([AC_PROG_LD_GNU],		[AC_DEFUN([AC_PROG_LD_GNU])])
m4_ifndef([AC_PROG_LD_RELOAD_FLAG],	[AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
m4_ifndef([AC_DEPLIBS_CHECK_METHOD],	[AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS],	[AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP],	[AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
m4_ifndef([LT_AC_PROG_EGREP],		[AC_DEFUN([LT_AC_PROG_EGREP])])
m4_ifndef([LT_AC_PROG_SED],		[AC_DEFUN([LT_AC_PROG_SED])])
m4_ifndef([_LT_CC_BASENAME],		[AC_DEFUN([_LT_CC_BASENAME])])
m4_ifndef([_LT_COMPILER_BOILERPLATE],	[AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
m4_ifndef([_LT_LINKER_BOILERPLATE],	[AC_DEFUN([_LT_LINKER_BOILERPLATE])])
m4_ifndef([_AC_PROG_LIBTOOL],		[AC_DEFUN([_AC_PROG_LIBTOOL])])
m4_ifndef([AC_LIBTOOL_SETUP],		[AC_DEFUN([AC_LIBTOOL_SETUP])])
m4_ifndef([_LT_AC_CHECK_DLFCN],		[AC_DEFUN([_LT_AC_CHECK_DLFCN])])
m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER],	[AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
m4_ifndef([_LT_AC_TAGCONFIG],		[AC_DEFUN([_LT_AC_TAGCONFIG])])
m4_ifndef([AC_DISABLE_FAST_INSTALL],	[AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
m4_ifndef([_LT_AC_LANG_CXX],		[AC_DEFUN([_LT_AC_LANG_CXX])])
m4_ifndef([_LT_AC_LANG_F77],		[AC_DEFUN([_LT_AC_LANG_F77])])
m4_ifndef([_LT_AC_LANG_GCJ],		[AC_DEFUN([_LT_AC_LANG_GCJ])])
m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
m4_ifndef([_LT_AC_LANG_C_CONFIG],	[AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
m4_ifndef([_LT_AC_LANG_CXX_CONFIG],	[AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
m4_ifndef([_LT_AC_LANG_F77_CONFIG],	[AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
m4_ifndef([_LT_AC_LANG_GCJ_CONFIG],	[AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG],	[AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
m4_ifndef([_LT_AC_LANG_RC_CONFIG],	[AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
m4_ifndef([AC_LIBTOOL_CONFIG],		[AC_DEFUN([AC_LIBTOOL_CONFIG])])
m4_ifndef([_LT_AC_FILE_LTDLL_C],	[AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS],	[AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])])
m4_ifndef([_LT_AC_PROG_CXXCPP],		[AC_DEFUN([_LT_AC_PROG_CXXCPP])])
m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS],	[AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])])
m4_ifndef([_LT_PROG_ECHO_BACKSLASH],	[AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])])
m4_ifndef([_LT_PROG_F77],		[AC_DEFUN([_LT_PROG_F77])])
m4_ifndef([_LT_PROG_FC],		[AC_DEFUN([_LT_PROG_FC])])
m4_ifndef([_LT_PROG_CXX],		[AC_DEFUN([_LT_PROG_CXX])])
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/m4/m4_ax_create_pkgconfig_info.m40000664000175000017500000003415513010375061030505 0ustar  zoncazonca00000000000000# ============================================================================
#  http://www.gnu.org/software/autoconf-archive/ax_create_pkgconfig_info.html
# ============================================================================
#
# SYNOPSIS
#
#   AX_CREATE_PKGCONFIG_INFO [(outputfile, [requires [,libs [,summary [,cflags [, ldflags]]]]])]
#
# DESCRIPTION
#
#   Defaults:
#
#     $1 = $PACKAGE_NAME.pc
#     $2 = (empty)
#     $3 = $PACKAGE_LIBS $LIBS (as set at that point in configure.ac)
#     $4 = $PACKAGE_SUMMARY (or $1 Library)
#     $5 = $PACKAGE_CFLAGS (as set at the point in configure.ac)
#     $6 = $PACKAGE_LDFLAGS (as set at the point in configure.ac)
#
#     PACKAGE_NAME defaults to $PACKAGE if not set.
#     PACKAGE_LIBS defaults to -l$PACKAGE_NAME if not set.
#
#   The resulting file is called $PACKAGE.pc.in / $PACKAGE.pc
#
#   You will find this macro most useful in conjunction with
#   ax_spec_defaults that can read good initializers from the .spec file. In
#   consequencd, most of the generatable installable stuff can be made from
#   information being updated in a single place for the whole project.
#
# LICENSE
#
#   Copyright (c) 2008 Guido U. Draheim 
#   Copyright (c) 2008 Sven Verdoolaege 
#
#   This program is free software; you can redistribute it and/or modify it
#   under the terms of the GNU General Public License as published by the
#   Free Software Foundation; either version 3 of the License, or (at your
#   option) any later version.
#
#   This program is distributed in the hope that it will be useful, but
#   WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
#   Public License for more details.
#
#   You should have received a copy of the GNU General Public License along
#   with this program. If not, see .
#
#   As a special exception, the respective Autoconf Macro's copyright owner
#   gives unlimited permission to copy, distribute and modify the configure
#   scripts that are the output of Autoconf when processing the Macro. You
#   need not follow the terms of the GNU General Public License when using
#   or distributing such scripts, even though portions of the text of the
#   Macro appear in them. The GNU General Public License (GPL) does govern
#   all other use of the material that constitutes the Autoconf Macro.
#
#   This special exception to the GPL applies to versions of the Autoconf
#   Macro released by the Autoconf Archive. When you make and distribute a
#   modified version of the Autoconf Macro, you may extend this special
#   exception to the GPL to apply to your modified version as well.

#serial 12

AC_DEFUN([AX_CREATE_PKGCONFIG_INFO],[dnl
AS_VAR_PUSHDEF([PKGCONFIG_suffix],[ax_create_pkgconfig_suffix])dnl
AS_VAR_PUSHDEF([PKGCONFIG_libdir],[ax_create_pkgconfig_libdir])dnl
AS_VAR_PUSHDEF([PKGCONFIG_libfile],[ax_create_pkgconfig_libfile])dnl
AS_VAR_PUSHDEF([PKGCONFIG_libname],[ax_create_pkgconfig_libname])dnl
AS_VAR_PUSHDEF([PKGCONFIG_version],[ax_create_pkgconfig_version])dnl
AS_VAR_PUSHDEF([PKGCONFIG_description],[ax_create_pkgconfig_description])dnl
AS_VAR_PUSHDEF([PKGCONFIG_requires],[ax_create_pkgconfig_requires])dnl
AS_VAR_PUSHDEF([PKGCONFIG_pkglibs],[ax_create_pkgconfig_pkglibs])dnl
AS_VAR_PUSHDEF([PKGCONFIG_libs],[ax_create_pkgconfig_libs])dnl
AS_VAR_PUSHDEF([PKGCONFIG_ldflags],[ax_create_pkgconfig_ldflags])dnl
AS_VAR_PUSHDEF([PKGCONFIG_cppflags],[ax_create_pkgconfig_cppflags])dnl
AS_VAR_PUSHDEF([PKGCONFIG_generate],[ax_create_pkgconfig_generate])dnl
AS_VAR_PUSHDEF([PKGCONFIG_src_libdir],[ax_create_pkgconfig_src_libdir])dnl
AS_VAR_PUSHDEF([PKGCONFIG_src_headers],[ax_create_pkgconfig_src_headers])dnl

# we need the expanded forms...
test "x$prefix" = xNONE && prefix=$ac_default_prefix
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

AC_MSG_CHECKING(our pkgconfig libname)
test ".$PKGCONFIG_libname" != "." || \
PKGCONFIG_libname="ifelse($1,,${PACKAGE_NAME},`basename $1 .pc`)"
test ".$PKGCONFIG_libname" != "." || \
PKGCONFIG_libname="$PACKAGE"
PKGCONFIG_libname=`eval echo "$PKGCONFIG_libname"`
PKGCONFIG_libname=`eval echo "$PKGCONFIG_libname"`
AC_MSG_RESULT($PKGCONFIG_libname)

AC_MSG_CHECKING(our pkgconfig version)
test ".$PKGCONFIG_version" != "." || \
PKGCONFIG_version="${PACKAGE_VERSION}"
test ".$PKGCONFIG_version" != "." || \
PKGCONFIG_version="$VERSION"
PKGCONFIG_version=`eval echo "$PKGCONFIG_version"`
PKGCONFIG_version=`eval echo "$PKGCONFIG_version"`
AC_MSG_RESULT($PKGCONFIG_version)

AC_MSG_CHECKING(our pkgconfig_libdir)
test ".$pkgconfig_libdir" = "." && \
pkgconfig_libdir='${libdir}/pkgconfig'
PKGCONFIG_libdir=`eval echo "$pkgconfig_libdir"`
PKGCONFIG_libdir=`eval echo "$PKGCONFIG_libdir"`
PKGCONFIG_libdir=`eval echo "$PKGCONFIG_libdir"`
AC_MSG_RESULT($pkgconfig_libdir)
test "$pkgconfig_libdir" != "$PKGCONFIG_libdir" && (
AC_MSG_RESULT(expanded our pkgconfig_libdir... $PKGCONFIG_libdir))
AC_SUBST([pkgconfig_libdir])

AC_MSG_CHECKING(our pkgconfig_libfile)
test ".$pkgconfig_libfile" != "." || \
pkgconfig_libfile="ifelse($1,,$PKGCONFIG_libname.pc,`basename $1`)"
PKGCONFIG_libfile=`eval echo "$pkgconfig_libfile"`
PKGCONFIG_libfile=`eval echo "$PKGCONFIG_libfile"`
AC_MSG_RESULT($pkgconfig_libfile)
test "$pkgconfig_libfile" != "$PKGCONFIG_libfile" && (
AC_MSG_RESULT(expanded our pkgconfig_libfile... $PKGCONFIG_libfile))
AC_SUBST([pkgconfig_libfile])

AC_MSG_CHECKING(our package / suffix)
PKGCONFIG_suffix="$program_suffix"
test ".$PKGCONFIG_suffix" != .NONE || PKGCONFIG_suffix=""
AC_MSG_RESULT(${PACKAGE_NAME} / ${PKGCONFIG_suffix})

AC_MSG_CHECKING(our pkgconfig description)
PKGCONFIG_description="ifelse($4,,$PACKAGE_SUMMARY,$4)"
test ".$PKGCONFIG_description" != "." || \
PKGCONFIG_description="$PKGCONFIG_libname Library"
PKGCONFIG_description=`eval echo "$PKGCONFIG_description"`
PKGCONFIG_description=`eval echo "$PKGCONFIG_description"`
AC_MSG_RESULT($PKGCONFIG_description)

AC_MSG_CHECKING(our pkgconfig requires)
PKGCONFIG_requires="ifelse($2,,$PACKAGE_REQUIRES,$2)"
PKGCONFIG_requires=`eval echo "$PKGCONFIG_requires"`
PKGCONFIG_requires=`eval echo "$PKGCONFIG_requires"`
AC_MSG_RESULT($PKGCONFIG_requires)

AC_MSG_CHECKING(our pkgconfig ext libs)
PKGCONFIG_pkglibs="$PACKAGE_LIBS"
test ".$PKGCONFIG_pkglibs" != "." || PKGCONFIG_pkglibs="-l$PKGCONFIG_libname"
PKGCONFIG_libs="ifelse($3,,$PKGCONFIG_pkglibs $LIBS,$3)"
PKGCONFIG_libs=`eval echo "$PKGCONFIG_libs"`
PKGCONFIG_libs=`eval echo "$PKGCONFIG_libs"`
AC_MSG_RESULT($PKGCONFIG_libs)

AC_MSG_CHECKING(our pkgconfig cppflags)
PKGCONFIG_cppflags="ifelse($5,,$PACKAGE_CFLAGS,$5)"
PKGCONFIG_cppflags=`eval echo "$PKGCONFIG_cppflags"`
PKGCONFIG_cppflags=`eval echo "$PKGCONFIG_cppflags"`
AC_MSG_RESULT($PKGCONFIG_cppflags)

AC_MSG_CHECKING(our pkgconfig ldflags)
PKGCONFIG_ldflags="ifelse($6,,$PACKAGE_LDFLAGS,$5)"
PKGCONFIG_ldflags=`eval echo "$PKGCONFIG_ldflags"`
PKGCONFIG_ldflags=`eval echo "$PKGCONFIG_ldflags"`
AC_MSG_RESULT($PKGCONFIG_ldflags)

test ".$PKGCONFIG_generate" != "." || \
PKGCONFIG_generate="ifelse($1,,$PKGCONFIG_libname.pc,$1)"
PKGCONFIG_generate=`eval echo "$PKGCONFIG_generate"`
PKGCONFIG_generate=`eval echo "$PKGCONFIG_generate"`
test "$pkgconfig_libfile" != "$PKGCONFIG_generate" && (
AC_MSG_RESULT(generate the pkgconfig later... $PKGCONFIG_generate))

if test ".$PKGCONFIG_src_libdir" = "." ; then
PKGCONFIG_src_libdir=`pwd`
PKGCONFIG_src_libdir=`AS_DIRNAME("$PKGCONFIG_src_libdir/$PKGCONFIG_generate")`
test ! -d $PKGCONFIG_src_libdir/src || \
PKGCONFIG_src_libdir="$PKGCONFIG_src_libdir/src"
case ".$objdir" in
*libs) PKGCONFIG_src_libdir="$PKGCONFIG_src_libdir/$objdir" ;; esac
AC_MSG_RESULT(noninstalled pkgconfig -L $PKGCONFIG_src_libdir)
fi

if test ".$PKGCONFIG_src_headers" = "." ; then
PKGCONFIG_src_headers=`pwd`
v="$ac_top_srcdir" ;
test ".$v" != "." || v="$ax_spec_dir"
test ".$v" != "." || v="$srcdir"
case "$v" in /*) PKGCONFIG_src_headers="" ;; esac
PKGCONFIG_src_headers=`AS_DIRNAME("$PKGCONFIG_src_headers/$v/x")`
test ! -d $PKGCONFIG_src_headers/incl[]ude || \
PKGCONFIG_src_headers="$PKGCONFIG_src_headers/incl[]ude"
AC_MSG_RESULT(noninstalled pkgconfig -I $PKGCONFIG_src_headers)
fi


dnl AC_CONFIG_COMMANDS crap disallows to use $PKGCONFIG_libfile here...
AC_CONFIG_COMMANDS([$ax_create_pkgconfig_generate],[
pkgconfig_generate="$ax_create_pkgconfig_generate"
if test ! -f "$pkgconfig_generate.in"
then generate="true"
elif grep ' generated by configure ' $pkgconfig_generate.in >/dev/null
then generate="true"
else generate="false";
fi
if $generate ; then
AC_MSG_NOTICE(creating $pkgconfig_generate.in)
cat > $pkgconfig_generate.in <conftest.sed < $pkgconfig_generate
if test ! -s $pkgconfig_generate ; then
    AC_MSG_ERROR([$pkgconfig_generate is empty])
fi ; rm conftest.sed # DONE generate $pkgconfig_generate
pkgconfig_uninstalled=`echo $pkgconfig_generate |sed 's/.pc$/-uninstalled.pc/'`
AC_MSG_NOTICE(creating $pkgconfig_uninstalled)
cat >conftest.sed < $pkgconfig_uninstalled
if test ! -s $pkgconfig_uninstalled ; then
    AC_MSG_ERROR([$pkgconfig_uninstalled is empty])
fi ; rm conftest.sed # DONE generate $pkgconfig_uninstalled
           pkgconfig_requires_add=`echo ${pkgconfig_requires}`
if test ".$pkgconfig_requires_add" != "." ; then
           pkgconfig_requires_add="pkg-config $pkgconfig_requires_add"
    else   pkgconfig_requires_add=":" ; fi
pkgconfig_uninstalled=`echo $pkgconfig_generate |sed 's/.pc$/-uninstalled.sh/'`
AC_MSG_NOTICE(creating $pkgconfig_uninstalled)
cat >conftest.sed <Name:>for option\\; do case \"\$option\" in --list-all|--name) echo >
s>Description: *>\\;\\; --help) pkg-config --help \\; echo Buildscript Of >
s>Version: *>\\;\\; --modversion|--version) echo >
s>Requires:>\\;\\; --requires) echo $pkgconfig_requires_add>
s>Libs: *>\\;\\; --libs) echo >
s>Cflags: *>\\;\\; --cflags) echo >
/--libs)/a\\
       $pkgconfig_requires_add
/--cflags)/a\\
       $pkgconfig_requires_add\\
;; --variable=*) eval echo '\$'\`echo \$option | sed -e 's/.*=//'\`\\
;; --uninstalled) exit 0 \\
;; *) ;; esac done
AXEOF
sed -f conftest.sed  $pkgconfig_generate.in > $pkgconfig_uninstalled
if test ! -s $pkgconfig_uninstalled ; then
    AC_MSG_ERROR([$pkgconfig_uninstalled is empty])
fi ; rm conftest.sed # DONE generate $pkgconfig_uninstalled
],[
dnl AC_CONFIG_COMMANDS crap, the AS_PUSHVAR defines are invalid here...
ax_create_pkgconfig_generate="$ax_create_pkgconfig_generate"
pkgconfig_prefix='$prefix'
pkgconfig_execprefix='$exec_prefix'
pkgconfig_bindir='$bindir'
pkgconfig_libdir='$libdir'
pkgconfig_includedir='$includedir'
pkgconfig_datarootdir='$datarootdir'
pkgconfig_datadir='$datadir'
pkgconfig_sysconfdir='$sysconfdir'
pkgconfig_suffix='$ax_create_pkgconfig_suffix'
pkgconfig_package='$PACKAGE_NAME'
pkgconfig_libname='$ax_create_pkgconfig_libname'
pkgconfig_description='$ax_create_pkgconfig_description'
pkgconfig_version='$ax_create_pkgconfig_version'
pkgconfig_requires='$ax_create_pkgconfig_requires'
pkgconfig_libs='$ax_create_pkgconfig_libs'
pkgconfig_ldflags='$ax_create_pkgconfig_ldflags'
pkgconfig_cppflags='$ax_create_pkgconfig_cppflags'
pkgconfig_src_libdir='$ax_create_pkgconfig_src_libdir'
pkgconfig_src_headers='$ax_create_pkgconfig_src_headers'
])dnl
AS_VAR_POPDEF([PKGCONFIG_suffix])dnl
AS_VAR_POPDEF([PKGCONFIG_libdir])dnl
AS_VAR_POPDEF([PKGCONFIG_libfile])dnl
AS_VAR_POPDEF([PKGCONFIG_libname])dnl
AS_VAR_POPDEF([PKGCONFIG_version])dnl
AS_VAR_POPDEF([PKGCONFIG_description])dnl
AS_VAR_POPDEF([PKGCONFIG_requires])dnl
AS_VAR_POPDEF([PKGCONFIG_pkglibs])dnl
AS_VAR_POPDEF([PKGCONFIG_libs])dnl
AS_VAR_POPDEF([PKGCONFIG_ldflags])dnl
AS_VAR_POPDEF([PKGCONFIG_cppflags])dnl
AS_VAR_POPDEF([PKGCONFIG_generate])dnl
AS_VAR_POPDEF([PKGCONFIG_src_libdir])dnl
AS_VAR_POPDEF([PKGCONFIG_src_headers])dnl
])
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Makefile.am0000664000175000017500000001543313010375061024360 0ustar  zoncazonca00000000000000ACLOCAL_AMFLAGS = -I m4

lib_LTLIBRARIES = libhealpix_cxx.la

src_c_utils = \
  c_utils/c_utils.c \
  c_utils/c_utils.h \
  c_utils/walltime_c.c \
  c_utils/walltime_c.h
src_libfftpack = \
  libfftpack/bluestein.h \
  libfftpack/bluestein.c \
  libfftpack/fftpack.h \
  libfftpack/fftpack.c \
  libfftpack/ls_fft.h \
  libfftpack/ls_fft.c
src_libsharp = \
  libsharp/sharp.c \
  libsharp/sharp.h \
  libsharp/sharp_cxx.h \
  libsharp/sharp_almhelpers.c \
  libsharp/sharp_almhelpers.h \
  libsharp/sharp_complex_hacks.h \
  libsharp/sharp_core.c \
  libsharp/sharp_core.h \
  libsharp/sharp_geomhelpers.c \
  libsharp/sharp_geomhelpers.h \
  libsharp/sharp_internal.h \
  libsharp/sharp_lowlevel.h \
  libsharp/sharp_vecsupport.h \
  libsharp/sharp_vecutil.h \
  libsharp/sharp_ylmgen_c.c \
  libsharp/sharp_ylmgen_c.h
src_cxxsupport = \
  cxxsupport/announce.cc \
  cxxsupport/fitshandle.cc \
  cxxsupport/geom_utils.cc \
  cxxsupport/string_utils.cc \
  cxxsupport/ls_image.cc \
  cxxsupport/paramfile.cc \
  cxxsupport/pointing.cc \
  cxxsupport/rotmatrix.cc \
  cxxsupport/trafos.cc \
  cxxsupport/walltimer.cc \
  cxxsupport/wigner.cc \
  cxxsupport/error_handling.cc \
  cxxsupport/alloc_utils.h \
  cxxsupport/announce.h \
  cxxsupport/arr.h \
  cxxsupport/bstream.h \
  cxxsupport/datatypes.h \
  cxxsupport/error_handling.h \
  cxxsupport/fftpack_support.h \
  cxxsupport/fitshandle.h \
  cxxsupport/geom_utils.h \
  cxxsupport/levels_facilities.h \
  cxxsupport/ls_image.h \
  cxxsupport/lsconstants.h \
  cxxsupport/math_utils.h \
  cxxsupport/openmp_support.h \
  cxxsupport/paramfile.h \
  cxxsupport/planck_rng.h \
  cxxsupport/pointing.h \
  cxxsupport/rangeset.h \
  cxxsupport/rotmatrix.h \
  cxxsupport/safe_cast.h \
  cxxsupport/safe_ptr.h \
  cxxsupport/share_utils.h \
  cxxsupport/sse_utils_cxx.h \
  cxxsupport/string_utils.h \
  cxxsupport/trafos.h \
  cxxsupport/vec3.h \
  cxxsupport/walltimer.h \
  cxxsupport/wigner.h \
  cxxsupport/xcomplex.h \
  cxxsupport/compress_utils.h \
  cxxsupport/colour.h \
  cxxsupport/linear_map.h \
  cxxsupport/sort_utils.h
src_healpix_cxx= \
  Healpix_cxx/alm.cc \
  Healpix_cxx/alm.h \
  Healpix_cxx/alm2map_cxx_module.cc \
  Healpix_cxx/alm_fitsio.cc \
  Healpix_cxx/alm_fitsio.h \
  Healpix_cxx/alm_healpix_tools.cc \
  Healpix_cxx/alm_healpix_tools.h \
  Healpix_cxx/alm_powspec_tools.cc \
  Healpix_cxx/alm_powspec_tools.h \
  Healpix_cxx/anafast_cxx_module.cc \
  Healpix_cxx/calc_powspec_module.cc \
  Healpix_cxx/healpix_base.cc \
  Healpix_cxx/healpix_base.h \
  Healpix_cxx/healpix_data_io.cc \
  Healpix_cxx/healpix_data_io.h \
  Healpix_cxx/healpix_map.cc \
  Healpix_cxx/healpix_map.h \
  Healpix_cxx/healpix_map_fitsio.cc \
  Healpix_cxx/healpix_map_fitsio.h \
  Healpix_cxx/healpix_tables.cc \
  Healpix_cxx/healpix_tables.h \
  Healpix_cxx/hotspots_cxx_module.cc \
  Healpix_cxx/map2tga_module.cc \
  Healpix_cxx/median_filter_cxx_module.cc \
  Healpix_cxx/mult_alm_module.cc \
  Healpix_cxx/powspec.cc \
  Healpix_cxx/powspec.h \
  Healpix_cxx/powspec_fitsio.cc \
  Healpix_cxx/powspec_fitsio.h \
  Healpix_cxx/smoothing_cxx_module.cc \
  Healpix_cxx/syn_alm_cxx_module.cc \
  Healpix_cxx/udgrade_cxx_module.cc \
  Healpix_cxx/udgrade_harmonic_cxx_module.cc \
  Healpix_cxx/moc_fitsio.h \
  Healpix_cxx/moc_fitsio.cc \
  Healpix_cxx/moc_query.h \
  Healpix_cxx/moc_query.cc

EXTRA_DIST = \
  libfftpack/fftpack_inc.c \
  libsharp/sharp_core_inc.c \
  libsharp/sharp_core_inc2.c \
  libsharp/sharp_core_inchelper.c \
  cxxsupport/font_data.inc
include_HEADERS = \
  libsharp/sharp.h \
  libsharp/sharp_lowlevel.h \
  libsharp/sharp_geomhelpers.c \
  libsharp/sharp_geomhelpers.h \
  cxxsupport/arr.h \
  cxxsupport/xcomplex.h \
  cxxsupport/datatypes.h \
  cxxsupport/pointing.h \
  cxxsupport/rangeset.h \
  cxxsupport/fitshandle.h \
  cxxsupport/alloc_utils.h \
  cxxsupport/math_utils.h \
  cxxsupport/error_handling.h \
  cxxsupport/lsconstants.h \
  cxxsupport/safe_cast.h \
  cxxsupport/vec3.h \
  cxxsupport/wigner.h \
  cxxsupport/rotmatrix.h \
  cxxsupport/sse_utils_cxx.h \
  cxxsupport/string_utils.h \
  Healpix_cxx/alm.h \
  Healpix_cxx/alm_fitsio.h \
  Healpix_cxx/alm_healpix_tools.h \
  Healpix_cxx/alm_powspec_tools.h \
  Healpix_cxx/healpix_base.h \
  Healpix_cxx/healpix_data_io.h \
  Healpix_cxx/healpix_map.h \
  Healpix_cxx/healpix_map_fitsio.h \
  Healpix_cxx/healpix_tables.h \
  Healpix_cxx/powspec.h \
  Healpix_cxx/powspec_fitsio.h \
  Healpix_cxx/moc.h \
  Healpix_cxx/moc_fitsio.h \
  Healpix_cxx/moc_query.h

libhealpix_cxx_la_SOURCES = $(src_c_utils) $(src_libfftpack) $(src_libsharp) $(src_cxxsupport) $(src_healpix_cxx)
libhealpix_cxx_la_LIBADD = $(CFITSIO_LIBS)

bin_PROGRAMS = alm2map_cxx anafast_cxx calc_powspec hotspots_cxx map2tga \
  median_filter_cxx mult_alm rotalm_cxx smoothing_cxx syn_alm_cxx udgrade_cxx \
  udgrade_harmonic_cxx
check_PROGRAMS = hpxtest
alm2map_cxx_SOURCES = Healpix_cxx/alm2map_cxx.cc
alm2map_cxx_LDADD = libhealpix_cxx.la
alm2map_cxx_LDFLAGS = -static-libtool-libs
anafast_cxx_SOURCES = Healpix_cxx/anafast_cxx.cc
anafast_cxx_LDADD = libhealpix_cxx.la
anafast_cxx_LDFLAGS = -static-libtool-libs
calc_powspec_SOURCES = Healpix_cxx/calc_powspec.cc
calc_powspec_LDADD = libhealpix_cxx.la
calc_powspec_LDFLAGS = -static-libtool-libs
hotspots_cxx_SOURCES = Healpix_cxx/hotspots_cxx.cc
hotspots_cxx_LDADD = libhealpix_cxx.la
hotspots_cxx_LDFLAGS = -static-libtool-libs
map2tga_SOURCES = Healpix_cxx/map2tga.cc
map2tga_LDADD = libhealpix_cxx.la
map2tga_LDFLAGS = -static-libtool-libs
median_filter_cxx_SOURCES = Healpix_cxx/median_filter_cxx.cc
median_filter_cxx_LDADD = libhealpix_cxx.la
median_filter_cxx_LDFLAGS = -static-libtool-libs
mult_alm_SOURCES = Healpix_cxx/mult_alm.cc
mult_alm_LDADD = libhealpix_cxx.la
mult_alm_LDFLAGS = -static-libtool-libs
rotalm_cxx_SOURCES = Healpix_cxx/rotalm_cxx.cc
rotalm_cxx_LDADD = libhealpix_cxx.la
rotalm_cxx_LDFLAGS = -static-libtool-libs
smoothing_cxx_SOURCES = Healpix_cxx/smoothing_cxx.cc
smoothing_cxx_LDADD = libhealpix_cxx.la
smoothing_cxx_LDFLAGS = -static-libtool-libs
syn_alm_cxx_SOURCES = Healpix_cxx/syn_alm_cxx.cc
syn_alm_cxx_LDADD = libhealpix_cxx.la
syn_alm_cxx_LDFLAGS = -static-libtool-libs
udgrade_cxx_SOURCES = Healpix_cxx/udgrade_cxx.cc
udgrade_cxx_LDADD = libhealpix_cxx.la
udgrade_cxx_LDFLAGS = -static-libtool-libs
udgrade_harmonic_cxx_SOURCES = Healpix_cxx/udgrade_harmonic_cxx.cc
udgrade_harmonic_cxx_LDADD = libhealpix_cxx.la
udgrade_harmonic_cxx_LDFLAGS = -static-libtool-libs
hpxtest_SOURCES=Healpix_cxx/hpxtest.cc
hpxtest_LDADD = libhealpix_cxx.la
hpxtest_LDFLAGS = -static-libtool-libs

TESTS=hpxtest

AM_CPPFLAGS = $(CFITSIO_CFLAGS) -I$(top_srcdir)/c_utils -I$(top_srcdir)/libfftpack -I$(top_srcdir)/libsharp -I$(top_srcdir)/cxxsupport

pkgconfigdir = $(libdir)/pkgconfig
nodist_pkgconfig_DATA = @PACKAGE_NAME@.pc

DISTCLEANFILES=@PACKAGE_NAME@.pc @PACKAGE_NAME@.pc.in  @PACKAGE_NAME@-uninstalled.pc  @PACKAGE_NAME@-uninstalled.sh
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/Makefile.in0000664000175000017500000022313213010376370024372 0ustar  zoncazonca00000000000000# Makefile.in generated by automake 1.13.4 from Makefile.am.
# @configure_input@

# Copyright (C) 1994-2013 Free Software Foundation, Inc.

# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.

@SET_MAKE@




VPATH = @srcdir@
am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
am__make_running_with_option = \
  case $${target_option-} in \
      ?) ;; \
      *) echo "am__make_running_with_option: internal error: invalid" \
              "target option '$${target_option-}' specified" >&2; \
         exit 1;; \
  esac; \
  has_opt=no; \
  sane_makeflags=$$MAKEFLAGS; \
  if $(am__is_gnu_make); then \
    sane_makeflags=$$MFLAGS; \
  else \
    case $$MAKEFLAGS in \
      *\\[\ \	]*) \
        bs=\\; \
        sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
          | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
    esac; \
  fi; \
  skip_next=no; \
  strip_trailopt () \
  { \
    flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
  }; \
  for flg in $$sane_makeflags; do \
    test $$skip_next = yes && { skip_next=no; continue; }; \
    case $$flg in \
      *=*|--*) continue;; \
        -*I) strip_trailopt 'I'; skip_next=yes;; \
      -*I?*) strip_trailopt 'I';; \
        -*O) strip_trailopt 'O'; skip_next=yes;; \
      -*O?*) strip_trailopt 'O';; \
        -*l) strip_trailopt 'l'; skip_next=yes;; \
      -*l?*) strip_trailopt 'l';; \
      -[dEDm]) skip_next=yes;; \
      -[JT]) skip_next=yes;; \
    esac; \
    case $$flg in \
      *$$target_option*) has_opt=yes; break;; \
    esac; \
  done; \
  test $$has_opt = yes
am__make_dryrun = (target_option=n; $(am__make_running_with_option))
am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
bin_PROGRAMS = alm2map_cxx$(EXEEXT) anafast_cxx$(EXEEXT) \
	calc_powspec$(EXEEXT) hotspots_cxx$(EXEEXT) map2tga$(EXEEXT) \
	median_filter_cxx$(EXEEXT) mult_alm$(EXEEXT) \
	rotalm_cxx$(EXEEXT) smoothing_cxx$(EXEEXT) \
	syn_alm_cxx$(EXEEXT) udgrade_cxx$(EXEEXT) \
	udgrade_harmonic_cxx$(EXEEXT)
check_PROGRAMS = hpxtest$(EXEEXT)
TESTS = hpxtest$(EXEEXT)
subdir = .
DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
	$(top_srcdir)/configure $(am__configure_deps) depcomp \
	$(include_HEADERS) test-driver ar-lib config.guess config.sub \
	install-sh missing ltmain.sh
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
	$(top_srcdir)/m4/m4_ax_create_pkgconfig_info.m4 \
	$(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
	$(ACLOCAL_M4)
am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
 configure.lineno config.status.lineno
mkinstalldirs = $(install_sh) -d
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
    *) f=$$p;; \
  esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
  for p in $$list; do echo "$$p $$p"; done | \
  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
    if (++n[$$2] == $(am__install_max)) \
      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
    END { for (dir in files) print dir, files[dir] }'
am__base_list = \
  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__uninstall_files_from_dir = { \
  test -z "$$files" \
    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
         $(am__cd) "$$dir" && rm -f $$files; }; \
  }
am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" \
	"$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(includedir)"
LTLIBRARIES = $(lib_LTLIBRARIES)
am__DEPENDENCIES_1 =
libhealpix_cxx_la_DEPENDENCIES = $(am__DEPENDENCIES_1)
am__dirstamp = $(am__leading_dot)dirstamp
am__objects_1 = c_utils/c_utils.lo c_utils/walltime_c.lo
am__objects_2 = libfftpack/bluestein.lo libfftpack/fftpack.lo \
	libfftpack/ls_fft.lo
am__objects_3 = libsharp/sharp.lo libsharp/sharp_almhelpers.lo \
	libsharp/sharp_core.lo libsharp/sharp_geomhelpers.lo \
	libsharp/sharp_ylmgen_c.lo
am__objects_4 = cxxsupport/announce.lo cxxsupport/fitshandle.lo \
	cxxsupport/geom_utils.lo cxxsupport/string_utils.lo \
	cxxsupport/ls_image.lo cxxsupport/paramfile.lo \
	cxxsupport/pointing.lo cxxsupport/rotmatrix.lo \
	cxxsupport/trafos.lo cxxsupport/walltimer.lo \
	cxxsupport/wigner.lo cxxsupport/error_handling.lo
am__objects_5 = Healpix_cxx/alm.lo Healpix_cxx/alm2map_cxx_module.lo \
	Healpix_cxx/alm_fitsio.lo Healpix_cxx/alm_healpix_tools.lo \
	Healpix_cxx/alm_powspec_tools.lo \
	Healpix_cxx/anafast_cxx_module.lo \
	Healpix_cxx/calc_powspec_module.lo Healpix_cxx/healpix_base.lo \
	Healpix_cxx/healpix_data_io.lo Healpix_cxx/healpix_map.lo \
	Healpix_cxx/healpix_map_fitsio.lo \
	Healpix_cxx/healpix_tables.lo \
	Healpix_cxx/hotspots_cxx_module.lo \
	Healpix_cxx/map2tga_module.lo \
	Healpix_cxx/median_filter_cxx_module.lo \
	Healpix_cxx/mult_alm_module.lo Healpix_cxx/powspec.lo \
	Healpix_cxx/powspec_fitsio.lo \
	Healpix_cxx/smoothing_cxx_module.lo \
	Healpix_cxx/syn_alm_cxx_module.lo \
	Healpix_cxx/udgrade_cxx_module.lo \
	Healpix_cxx/udgrade_harmonic_cxx_module.lo \
	Healpix_cxx/moc_fitsio.lo Healpix_cxx/moc_query.lo
am_libhealpix_cxx_la_OBJECTS = $(am__objects_1) $(am__objects_2) \
	$(am__objects_3) $(am__objects_4) $(am__objects_5)
libhealpix_cxx_la_OBJECTS = $(am_libhealpix_cxx_la_OBJECTS)
AM_V_lt = $(am__v_lt_@AM_V@)
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
am__v_lt_0 = --silent
am__v_lt_1 = 
PROGRAMS = $(bin_PROGRAMS)
am_alm2map_cxx_OBJECTS = Healpix_cxx/alm2map_cxx.$(OBJEXT)
alm2map_cxx_OBJECTS = $(am_alm2map_cxx_OBJECTS)
alm2map_cxx_DEPENDENCIES = libhealpix_cxx.la
alm2map_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(alm2map_cxx_LDFLAGS) $(LDFLAGS) -o $@
am_anafast_cxx_OBJECTS = Healpix_cxx/anafast_cxx.$(OBJEXT)
anafast_cxx_OBJECTS = $(am_anafast_cxx_OBJECTS)
anafast_cxx_DEPENDENCIES = libhealpix_cxx.la
anafast_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(anafast_cxx_LDFLAGS) $(LDFLAGS) -o $@
am_calc_powspec_OBJECTS = Healpix_cxx/calc_powspec.$(OBJEXT)
calc_powspec_OBJECTS = $(am_calc_powspec_OBJECTS)
calc_powspec_DEPENDENCIES = libhealpix_cxx.la
calc_powspec_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(calc_powspec_LDFLAGS) $(LDFLAGS) -o $@
am_hotspots_cxx_OBJECTS = Healpix_cxx/hotspots_cxx.$(OBJEXT)
hotspots_cxx_OBJECTS = $(am_hotspots_cxx_OBJECTS)
hotspots_cxx_DEPENDENCIES = libhealpix_cxx.la
hotspots_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(hotspots_cxx_LDFLAGS) $(LDFLAGS) -o $@
am_hpxtest_OBJECTS = Healpix_cxx/hpxtest.$(OBJEXT)
hpxtest_OBJECTS = $(am_hpxtest_OBJECTS)
hpxtest_DEPENDENCIES = libhealpix_cxx.la
hpxtest_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(hpxtest_LDFLAGS) $(LDFLAGS) -o $@
am_map2tga_OBJECTS = Healpix_cxx/map2tga.$(OBJEXT)
map2tga_OBJECTS = $(am_map2tga_OBJECTS)
map2tga_DEPENDENCIES = libhealpix_cxx.la
map2tga_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(map2tga_LDFLAGS) $(LDFLAGS) -o $@
am_median_filter_cxx_OBJECTS =  \
	Healpix_cxx/median_filter_cxx.$(OBJEXT)
median_filter_cxx_OBJECTS = $(am_median_filter_cxx_OBJECTS)
median_filter_cxx_DEPENDENCIES = libhealpix_cxx.la
median_filter_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
	$(AM_CXXFLAGS) $(CXXFLAGS) $(median_filter_cxx_LDFLAGS) \
	$(LDFLAGS) -o $@
am_mult_alm_OBJECTS = Healpix_cxx/mult_alm.$(OBJEXT)
mult_alm_OBJECTS = $(am_mult_alm_OBJECTS)
mult_alm_DEPENDENCIES = libhealpix_cxx.la
mult_alm_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(mult_alm_LDFLAGS) $(LDFLAGS) -o $@
am_rotalm_cxx_OBJECTS = Healpix_cxx/rotalm_cxx.$(OBJEXT)
rotalm_cxx_OBJECTS = $(am_rotalm_cxx_OBJECTS)
rotalm_cxx_DEPENDENCIES = libhealpix_cxx.la
rotalm_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(rotalm_cxx_LDFLAGS) $(LDFLAGS) -o $@
am_smoothing_cxx_OBJECTS = Healpix_cxx/smoothing_cxx.$(OBJEXT)
smoothing_cxx_OBJECTS = $(am_smoothing_cxx_OBJECTS)
smoothing_cxx_DEPENDENCIES = libhealpix_cxx.la
smoothing_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
	$(AM_CXXFLAGS) $(CXXFLAGS) $(smoothing_cxx_LDFLAGS) $(LDFLAGS) \
	-o $@
am_syn_alm_cxx_OBJECTS = Healpix_cxx/syn_alm_cxx.$(OBJEXT)
syn_alm_cxx_OBJECTS = $(am_syn_alm_cxx_OBJECTS)
syn_alm_cxx_DEPENDENCIES = libhealpix_cxx.la
syn_alm_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(syn_alm_cxx_LDFLAGS) $(LDFLAGS) -o $@
am_udgrade_cxx_OBJECTS = Healpix_cxx/udgrade_cxx.$(OBJEXT)
udgrade_cxx_OBJECTS = $(am_udgrade_cxx_OBJECTS)
udgrade_cxx_DEPENDENCIES = libhealpix_cxx.la
udgrade_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(udgrade_cxx_LDFLAGS) $(LDFLAGS) -o $@
am_udgrade_harmonic_cxx_OBJECTS =  \
	Healpix_cxx/udgrade_harmonic_cxx.$(OBJEXT)
udgrade_harmonic_cxx_OBJECTS = $(am_udgrade_harmonic_cxx_OBJECTS)
udgrade_harmonic_cxx_DEPENDENCIES = libhealpix_cxx.la
udgrade_harmonic_cxx_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
	$(AM_CXXFLAGS) $(CXXFLAGS) $(udgrade_harmonic_cxx_LDFLAGS) \
	$(LDFLAGS) -o $@
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
am__v_P_0 = false
am__v_P_1 = :
AM_V_GEN = $(am__v_GEN_@AM_V@)
am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
am__v_GEN_0 = @echo "  GEN     " $@;
am__v_GEN_1 = 
AM_V_at = $(am__v_at_@AM_V@)
am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
am__v_at_0 = @
am__v_at_1 = 
DEFAULT_INCLUDES = -I.@am__isrc@
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
	$(AM_CFLAGS) $(CFLAGS)
AM_V_CC = $(am__v_CC_@AM_V@)
am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
am__v_CC_0 = @echo "  CC      " $@;
am__v_CC_1 = 
CCLD = $(CC)
LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
	$(AM_LDFLAGS) $(LDFLAGS) -o $@
AM_V_CCLD = $(am__v_CCLD_@AM_V@)
am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
am__v_CCLD_0 = @echo "  CCLD    " $@;
am__v_CCLD_1 = 
CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
	$(AM_CXXFLAGS) $(CXXFLAGS)
AM_V_CXX = $(am__v_CXX_@AM_V@)
am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
am__v_CXX_0 = @echo "  CXX     " $@;
am__v_CXX_1 = 
CXXLD = $(CXX)
CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
	$(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
am__v_CXXLD_0 = @echo "  CXXLD   " $@;
am__v_CXXLD_1 = 
SOURCES = $(libhealpix_cxx_la_SOURCES) $(alm2map_cxx_SOURCES) \
	$(anafast_cxx_SOURCES) $(calc_powspec_SOURCES) \
	$(hotspots_cxx_SOURCES) $(hpxtest_SOURCES) $(map2tga_SOURCES) \
	$(median_filter_cxx_SOURCES) $(mult_alm_SOURCES) \
	$(rotalm_cxx_SOURCES) $(smoothing_cxx_SOURCES) \
	$(syn_alm_cxx_SOURCES) $(udgrade_cxx_SOURCES) \
	$(udgrade_harmonic_cxx_SOURCES)
DIST_SOURCES = $(libhealpix_cxx_la_SOURCES) $(alm2map_cxx_SOURCES) \
	$(anafast_cxx_SOURCES) $(calc_powspec_SOURCES) \
	$(hotspots_cxx_SOURCES) $(hpxtest_SOURCES) $(map2tga_SOURCES) \
	$(median_filter_cxx_SOURCES) $(mult_alm_SOURCES) \
	$(rotalm_cxx_SOURCES) $(smoothing_cxx_SOURCES) \
	$(syn_alm_cxx_SOURCES) $(udgrade_cxx_SOURCES) \
	$(udgrade_harmonic_cxx_SOURCES)
am__can_run_installinfo = \
  case $$AM_UPDATE_INFO_DIR in \
    n|no|NO) false;; \
    *) (install-info --version) >/dev/null 2>&1;; \
  esac
DATA = $(nodist_pkgconfig_DATA)
HEADERS = $(include_HEADERS)
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
# Read a list of newline-separated strings from the standard input,
# and print each of them once, without duplicates.  Input order is
# *not* preserved.
am__uniquify_input = $(AWK) '\
  BEGIN { nonempty = 0; } \
  { items[$$0] = 1; nonempty = 1; } \
  END { if (nonempty) { for (i in items) print i; }; } \
'
# Make sure the list of sources is unique.  This is necessary because,
# e.g., the same source file might be shared among _SOURCES variables
# for different programs/libraries.
am__define_uniq_tagged_files = \
  list='$(am__tagged_files)'; \
  unique=`for i in $$list; do \
    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
  done | $(am__uniquify_input)`
ETAGS = etags
CTAGS = ctags
CSCOPE = cscope
AM_RECURSIVE_TARGETS = cscope check recheck
am__tty_colors_dummy = \
  mgn= red= grn= lgn= blu= brg= std=; \
  am__color_tests=no
am__tty_colors = { \
  $(am__tty_colors_dummy); \
  if test "X$(AM_COLOR_TESTS)" = Xno; then \
    am__color_tests=no; \
  elif test "X$(AM_COLOR_TESTS)" = Xalways; then \
    am__color_tests=yes; \
  elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \
    am__color_tests=yes; \
  fi; \
  if test $$am__color_tests = yes; then \
    red=''; \
    grn=''; \
    lgn=''; \
    blu=''; \
    mgn=''; \
    brg=''; \
    std=''; \
  fi; \
}
am__recheck_rx = ^[ 	]*:recheck:[ 	]*
am__global_test_result_rx = ^[ 	]*:global-test-result:[ 	]*
am__copy_in_global_log_rx = ^[ 	]*:copy-in-global-log:[ 	]*
# A command that, given a newline-separated list of test names on the
# standard input, print the name of the tests that are to be re-run
# upon "make recheck".
am__list_recheck_tests = $(AWK) '{ \
  recheck = 1; \
  while ((rc = (getline line < ($$0 ".trs"))) != 0) \
    { \
      if (rc < 0) \
        { \
          if ((getline line2 < ($$0 ".log")) < 0) \
	    recheck = 0; \
          break; \
        } \
      else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \
        { \
          recheck = 0; \
          break; \
        } \
      else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \
        { \
          break; \
        } \
    }; \
  if (recheck) \
    print $$0; \
  close ($$0 ".trs"); \
  close ($$0 ".log"); \
}'
# A command that, given a newline-separated list of test names on the
# standard input, create the global log from their .trs and .log files.
am__create_global_log = $(AWK) ' \
function fatal(msg) \
{ \
  print "fatal: making $@: " msg | "cat >&2"; \
  exit 1; \
} \
function rst_section(header) \
{ \
  print header; \
  len = length(header); \
  for (i = 1; i <= len; i = i + 1) \
    printf "="; \
  printf "\n\n"; \
} \
{ \
  copy_in_global_log = 1; \
  global_test_result = "RUN"; \
  while ((rc = (getline line < ($$0 ".trs"))) != 0) \
    { \
      if (rc < 0) \
         fatal("failed to read from " $$0 ".trs"); \
      if (line ~ /$(am__global_test_result_rx)/) \
        { \
          sub("$(am__global_test_result_rx)", "", line); \
          sub("[ 	]*$$", "", line); \
          global_test_result = line; \
        } \
      else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \
        copy_in_global_log = 0; \
    }; \
  if (copy_in_global_log) \
    { \
      rst_section(global_test_result ": " $$0); \
      while ((rc = (getline line < ($$0 ".log"))) != 0) \
      { \
        if (rc < 0) \
          fatal("failed to read from " $$0 ".log"); \
        print line; \
      }; \
      printf "\n"; \
    }; \
  close ($$0 ".trs"); \
  close ($$0 ".log"); \
}'
# Restructured Text title.
am__rst_title = { sed 's/.*/   &   /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; }
# Solaris 10 'make', and several other traditional 'make' implementations,
# pass "-e" to $(SHELL), and POSIX 2008 even requires this.  Work around it
# by disabling -e (using the XSI extension "set +e") if it's set.
am__sh_e_setup = case $$- in *e*) set +e;; esac
# Default flags passed to test drivers.
am__common_driver_flags = \
  --color-tests "$$am__color_tests" \
  --enable-hard-errors "$$am__enable_hard_errors" \
  --expect-failure "$$am__expect_failure"
# To be inserted before the command running the test.  Creates the
# directory for the log if needed.  Stores in $dir the directory
# containing $f, in $tst the test, in $log the log.  Executes the
# developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and
# passes TESTS_ENVIRONMENT.  Set up options for the wrapper that
# will run the test scripts (or their associated LOG_COMPILER, if
# thy have one).
am__check_pre = \
$(am__sh_e_setup);					\
$(am__vpath_adj_setup) $(am__vpath_adj)			\
$(am__tty_colors);					\
srcdir=$(srcdir); export srcdir;			\
case "$@" in						\
  */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;;	\
    *) am__odir=.;; 					\
esac;							\
test "x$$am__odir" = x"." || test -d "$$am__odir" 	\
  || $(MKDIR_P) "$$am__odir" || exit $$?;		\
if test -f "./$$f"; then dir=./;			\
elif test -f "$$f"; then dir=;				\
else dir="$(srcdir)/"; fi;				\
tst=$$dir$$f; log='$@'; 				\
if test -n '$(DISABLE_HARD_ERRORS)'; then		\
  am__enable_hard_errors=no; 				\
else							\
  am__enable_hard_errors=yes; 				\
fi; 							\
case " $(XFAIL_TESTS) " in				\
  *[\ \	]$$f[\ \	]* | *[\ \	]$$dir$$f[\ \	]*) \
    am__expect_failure=yes;;				\
  *)							\
    am__expect_failure=no;;				\
esac; 							\
$(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT)
# A shell command to get the names of the tests scripts with any registered
# extension removed (i.e., equivalently, the names of the test logs, with
# the '.log' extension removed).  The result is saved in the shell variable
# '$bases'.  This honors runtime overriding of TESTS and TEST_LOGS.  Sadly,
# we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)",
# since that might cause problem with VPATH rewrites for suffix-less tests.
# See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'.
am__set_TESTS_bases = \
  bases='$(TEST_LOGS)'; \
  bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \
  bases=`echo $$bases`
RECHECK_LOGS = $(TEST_LOGS)
TEST_SUITE_LOG = test-suite.log
TEST_EXTENSIONS = @EXEEXT@ .test
LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
am__set_b = \
  case '$@' in \
    */*) \
      case '$*' in \
        */*) b='$*';; \
          *) b=`echo '$@' | sed 's/\.log$$//'`; \
       esac;; \
    *) \
      b='$*';; \
  esac
am__test_logs1 = $(TESTS:=.log)
am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
TEST_LOGS = $(am__test_logs2:.test.log=.log)
TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
	$(TEST_LOG_FLAGS)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
distdir = $(PACKAGE)-$(VERSION)
top_distdir = $(distdir)
am__remove_distdir = \
  if test -d "$(distdir)"; then \
    find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
      && rm -rf "$(distdir)" \
      || { sleep 5 && rm -rf "$(distdir)"; }; \
  else :; fi
am__post_remove_distdir = $(am__remove_distdir)
DIST_ARCHIVES = $(distdir).tar.gz
GZIP_ENV = --best
DIST_TARGETS = dist-gzip
distuninstallcheck_listfiles = find . -type f -print
am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
  | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
distcleancheck_listfiles = find . -type f -print
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFITSIO_CFLAGS = @CFITSIO_CFLAGS@
CFITSIO_LIBS = @CFITSIO_LIBS@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CXX = @CXX@
CXXCPP = @CXXCPP@
CXXDEPMODE = @CXXDEPMODE@
CXXFLAGS = @CXXFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DLLTOOL = @DLLTOOL@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MANIFEST_TOOL = @MANIFEST_TOOL@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OPENMP_CFLAGS = @OPENMP_CFLAGS@
OPENMP_CXXFLAGS = @OPENMP_CXXFLAGS@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_AR = @ac_ct_AR@
ac_ct_CC = @ac_ct_CC@
ac_ct_CXX = @ac_ct_CXX@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
pkgconfig_libdir = @pkgconfig_libdir@
pkgconfig_libfile = @pkgconfig_libfile@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
ACLOCAL_AMFLAGS = -I m4
lib_LTLIBRARIES = libhealpix_cxx.la
src_c_utils = \
  c_utils/c_utils.c \
  c_utils/c_utils.h \
  c_utils/walltime_c.c \
  c_utils/walltime_c.h

src_libfftpack = \
  libfftpack/bluestein.h \
  libfftpack/bluestein.c \
  libfftpack/fftpack.h \
  libfftpack/fftpack.c \
  libfftpack/ls_fft.h \
  libfftpack/ls_fft.c

src_libsharp = \
  libsharp/sharp.c \
  libsharp/sharp.h \
  libsharp/sharp_cxx.h \
  libsharp/sharp_almhelpers.c \
  libsharp/sharp_almhelpers.h \
  libsharp/sharp_complex_hacks.h \
  libsharp/sharp_core.c \
  libsharp/sharp_core.h \
  libsharp/sharp_geomhelpers.c \
  libsharp/sharp_geomhelpers.h \
  libsharp/sharp_internal.h \
  libsharp/sharp_lowlevel.h \
  libsharp/sharp_vecsupport.h \
  libsharp/sharp_vecutil.h \
  libsharp/sharp_ylmgen_c.c \
  libsharp/sharp_ylmgen_c.h

src_cxxsupport = \
  cxxsupport/announce.cc \
  cxxsupport/fitshandle.cc \
  cxxsupport/geom_utils.cc \
  cxxsupport/string_utils.cc \
  cxxsupport/ls_image.cc \
  cxxsupport/paramfile.cc \
  cxxsupport/pointing.cc \
  cxxsupport/rotmatrix.cc \
  cxxsupport/trafos.cc \
  cxxsupport/walltimer.cc \
  cxxsupport/wigner.cc \
  cxxsupport/error_handling.cc \
  cxxsupport/alloc_utils.h \
  cxxsupport/announce.h \
  cxxsupport/arr.h \
  cxxsupport/bstream.h \
  cxxsupport/datatypes.h \
  cxxsupport/error_handling.h \
  cxxsupport/fftpack_support.h \
  cxxsupport/fitshandle.h \
  cxxsupport/geom_utils.h \
  cxxsupport/levels_facilities.h \
  cxxsupport/ls_image.h \
  cxxsupport/lsconstants.h \
  cxxsupport/math_utils.h \
  cxxsupport/openmp_support.h \
  cxxsupport/paramfile.h \
  cxxsupport/planck_rng.h \
  cxxsupport/pointing.h \
  cxxsupport/rangeset.h \
  cxxsupport/rotmatrix.h \
  cxxsupport/safe_cast.h \
  cxxsupport/safe_ptr.h \
  cxxsupport/share_utils.h \
  cxxsupport/sse_utils_cxx.h \
  cxxsupport/string_utils.h \
  cxxsupport/trafos.h \
  cxxsupport/vec3.h \
  cxxsupport/walltimer.h \
  cxxsupport/wigner.h \
  cxxsupport/xcomplex.h \
  cxxsupport/compress_utils.h \
  cxxsupport/colour.h \
  cxxsupport/linear_map.h \
  cxxsupport/sort_utils.h

src_healpix_cxx = \
  Healpix_cxx/alm.cc \
  Healpix_cxx/alm.h \
  Healpix_cxx/alm2map_cxx_module.cc \
  Healpix_cxx/alm_fitsio.cc \
  Healpix_cxx/alm_fitsio.h \
  Healpix_cxx/alm_healpix_tools.cc \
  Healpix_cxx/alm_healpix_tools.h \
  Healpix_cxx/alm_powspec_tools.cc \
  Healpix_cxx/alm_powspec_tools.h \
  Healpix_cxx/anafast_cxx_module.cc \
  Healpix_cxx/calc_powspec_module.cc \
  Healpix_cxx/healpix_base.cc \
  Healpix_cxx/healpix_base.h \
  Healpix_cxx/healpix_data_io.cc \
  Healpix_cxx/healpix_data_io.h \
  Healpix_cxx/healpix_map.cc \
  Healpix_cxx/healpix_map.h \
  Healpix_cxx/healpix_map_fitsio.cc \
  Healpix_cxx/healpix_map_fitsio.h \
  Healpix_cxx/healpix_tables.cc \
  Healpix_cxx/healpix_tables.h \
  Healpix_cxx/hotspots_cxx_module.cc \
  Healpix_cxx/map2tga_module.cc \
  Healpix_cxx/median_filter_cxx_module.cc \
  Healpix_cxx/mult_alm_module.cc \
  Healpix_cxx/powspec.cc \
  Healpix_cxx/powspec.h \
  Healpix_cxx/powspec_fitsio.cc \
  Healpix_cxx/powspec_fitsio.h \
  Healpix_cxx/smoothing_cxx_module.cc \
  Healpix_cxx/syn_alm_cxx_module.cc \
  Healpix_cxx/udgrade_cxx_module.cc \
  Healpix_cxx/udgrade_harmonic_cxx_module.cc \
  Healpix_cxx/moc_fitsio.h \
  Healpix_cxx/moc_fitsio.cc \
  Healpix_cxx/moc_query.h \
  Healpix_cxx/moc_query.cc

EXTRA_DIST = \
  libfftpack/fftpack_inc.c \
  libsharp/sharp_core_inc.c \
  libsharp/sharp_core_inc2.c \
  libsharp/sharp_core_inchelper.c \
  cxxsupport/font_data.inc

include_HEADERS = \
  libsharp/sharp.h \
  libsharp/sharp_lowlevel.h \
  libsharp/sharp_geomhelpers.c \
  libsharp/sharp_geomhelpers.h \
  cxxsupport/arr.h \
  cxxsupport/xcomplex.h \
  cxxsupport/datatypes.h \
  cxxsupport/pointing.h \
  cxxsupport/rangeset.h \
  cxxsupport/fitshandle.h \
  cxxsupport/alloc_utils.h \
  cxxsupport/math_utils.h \
  cxxsupport/error_handling.h \
  cxxsupport/lsconstants.h \
  cxxsupport/safe_cast.h \
  cxxsupport/vec3.h \
  cxxsupport/wigner.h \
  cxxsupport/rotmatrix.h \
  cxxsupport/sse_utils_cxx.h \
  cxxsupport/string_utils.h \
  Healpix_cxx/alm.h \
  Healpix_cxx/alm_fitsio.h \
  Healpix_cxx/alm_healpix_tools.h \
  Healpix_cxx/alm_powspec_tools.h \
  Healpix_cxx/healpix_base.h \
  Healpix_cxx/healpix_data_io.h \
  Healpix_cxx/healpix_map.h \
  Healpix_cxx/healpix_map_fitsio.h \
  Healpix_cxx/healpix_tables.h \
  Healpix_cxx/powspec.h \
  Healpix_cxx/powspec_fitsio.h \
  Healpix_cxx/moc.h \
  Healpix_cxx/moc_fitsio.h \
  Healpix_cxx/moc_query.h

libhealpix_cxx_la_SOURCES = $(src_c_utils) $(src_libfftpack) $(src_libsharp) $(src_cxxsupport) $(src_healpix_cxx)
libhealpix_cxx_la_LIBADD = $(CFITSIO_LIBS)
alm2map_cxx_SOURCES = Healpix_cxx/alm2map_cxx.cc
alm2map_cxx_LDADD = libhealpix_cxx.la
alm2map_cxx_LDFLAGS = -static-libtool-libs
anafast_cxx_SOURCES = Healpix_cxx/anafast_cxx.cc
anafast_cxx_LDADD = libhealpix_cxx.la
anafast_cxx_LDFLAGS = -static-libtool-libs
calc_powspec_SOURCES = Healpix_cxx/calc_powspec.cc
calc_powspec_LDADD = libhealpix_cxx.la
calc_powspec_LDFLAGS = -static-libtool-libs
hotspots_cxx_SOURCES = Healpix_cxx/hotspots_cxx.cc
hotspots_cxx_LDADD = libhealpix_cxx.la
hotspots_cxx_LDFLAGS = -static-libtool-libs
map2tga_SOURCES = Healpix_cxx/map2tga.cc
map2tga_LDADD = libhealpix_cxx.la
map2tga_LDFLAGS = -static-libtool-libs
median_filter_cxx_SOURCES = Healpix_cxx/median_filter_cxx.cc
median_filter_cxx_LDADD = libhealpix_cxx.la
median_filter_cxx_LDFLAGS = -static-libtool-libs
mult_alm_SOURCES = Healpix_cxx/mult_alm.cc
mult_alm_LDADD = libhealpix_cxx.la
mult_alm_LDFLAGS = -static-libtool-libs
rotalm_cxx_SOURCES = Healpix_cxx/rotalm_cxx.cc
rotalm_cxx_LDADD = libhealpix_cxx.la
rotalm_cxx_LDFLAGS = -static-libtool-libs
smoothing_cxx_SOURCES = Healpix_cxx/smoothing_cxx.cc
smoothing_cxx_LDADD = libhealpix_cxx.la
smoothing_cxx_LDFLAGS = -static-libtool-libs
syn_alm_cxx_SOURCES = Healpix_cxx/syn_alm_cxx.cc
syn_alm_cxx_LDADD = libhealpix_cxx.la
syn_alm_cxx_LDFLAGS = -static-libtool-libs
udgrade_cxx_SOURCES = Healpix_cxx/udgrade_cxx.cc
udgrade_cxx_LDADD = libhealpix_cxx.la
udgrade_cxx_LDFLAGS = -static-libtool-libs
udgrade_harmonic_cxx_SOURCES = Healpix_cxx/udgrade_harmonic_cxx.cc
udgrade_harmonic_cxx_LDADD = libhealpix_cxx.la
udgrade_harmonic_cxx_LDFLAGS = -static-libtool-libs
hpxtest_SOURCES = Healpix_cxx/hpxtest.cc
hpxtest_LDADD = libhealpix_cxx.la
hpxtest_LDFLAGS = -static-libtool-libs
AM_CPPFLAGS = $(CFITSIO_CFLAGS) -I$(top_srcdir)/c_utils -I$(top_srcdir)/libfftpack -I$(top_srcdir)/libsharp -I$(top_srcdir)/cxxsupport
pkgconfigdir = $(libdir)/pkgconfig
nodist_pkgconfig_DATA = @PACKAGE_NAME@.pc
DISTCLEANFILES = @PACKAGE_NAME@.pc @PACKAGE_NAME@.pc.in  @PACKAGE_NAME@-uninstalled.pc  @PACKAGE_NAME@-uninstalled.sh
all: all-am

.SUFFIXES:
.SUFFIXES: .c .cc .lo .log .o .obj .test .test$(EXEEXT) .trs
am--refresh: Makefile
	@:
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
	@for dep in $?; do \
	  case '$(am__configure_deps)' in \
	    *$$dep*) \
	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
	      $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
		&& exit 0; \
	      exit 1;; \
	  esac; \
	done; \
	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
	$(am__cd) $(top_srcdir) && \
	  $(AUTOMAKE) --foreign Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
	@case '$?' in \
	  *config.status*) \
	    echo ' $(SHELL) ./config.status'; \
	    $(SHELL) ./config.status;; \
	  *) \
	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
	esac;

$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
	$(SHELL) ./config.status --recheck

$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
	$(am__cd) $(srcdir) && $(AUTOCONF)
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
	$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
$(am__aclocal_m4_deps):

install-libLTLIBRARIES: $(lib_LTLIBRARIES)
	@$(NORMAL_INSTALL)
	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
	list2=; for p in $$list; do \
	  if test -f $$p; then \
	    list2="$$list2 $$p"; \
	  else :; fi; \
	done; \
	test -z "$$list2" || { \
	  echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
	  $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
	}

uninstall-libLTLIBRARIES:
	@$(NORMAL_UNINSTALL)
	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
	for p in $$list; do \
	  $(am__strip_dir) \
	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
	done

clean-libLTLIBRARIES:
	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
	@list='$(lib_LTLIBRARIES)'; \
	locs=`for p in $$list; do echo $$p; done | \
	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
	      sort -u`; \
	test -z "$$locs" || { \
	  echo rm -f $${locs}; \
	  rm -f $${locs}; \
	}
c_utils/$(am__dirstamp):
	@$(MKDIR_P) c_utils
	@: > c_utils/$(am__dirstamp)
c_utils/$(DEPDIR)/$(am__dirstamp):
	@$(MKDIR_P) c_utils/$(DEPDIR)
	@: > c_utils/$(DEPDIR)/$(am__dirstamp)
c_utils/c_utils.lo: c_utils/$(am__dirstamp) \
	c_utils/$(DEPDIR)/$(am__dirstamp)
c_utils/walltime_c.lo: c_utils/$(am__dirstamp) \
	c_utils/$(DEPDIR)/$(am__dirstamp)
libfftpack/$(am__dirstamp):
	@$(MKDIR_P) libfftpack
	@: > libfftpack/$(am__dirstamp)
libfftpack/$(DEPDIR)/$(am__dirstamp):
	@$(MKDIR_P) libfftpack/$(DEPDIR)
	@: > libfftpack/$(DEPDIR)/$(am__dirstamp)
libfftpack/bluestein.lo: libfftpack/$(am__dirstamp) \
	libfftpack/$(DEPDIR)/$(am__dirstamp)
libfftpack/fftpack.lo: libfftpack/$(am__dirstamp) \
	libfftpack/$(DEPDIR)/$(am__dirstamp)
libfftpack/ls_fft.lo: libfftpack/$(am__dirstamp) \
	libfftpack/$(DEPDIR)/$(am__dirstamp)
libsharp/$(am__dirstamp):
	@$(MKDIR_P) libsharp
	@: > libsharp/$(am__dirstamp)
libsharp/$(DEPDIR)/$(am__dirstamp):
	@$(MKDIR_P) libsharp/$(DEPDIR)
	@: > libsharp/$(DEPDIR)/$(am__dirstamp)
libsharp/sharp.lo: libsharp/$(am__dirstamp) \
	libsharp/$(DEPDIR)/$(am__dirstamp)
libsharp/sharp_almhelpers.lo: libsharp/$(am__dirstamp) \
	libsharp/$(DEPDIR)/$(am__dirstamp)
libsharp/sharp_core.lo: libsharp/$(am__dirstamp) \
	libsharp/$(DEPDIR)/$(am__dirstamp)
libsharp/sharp_geomhelpers.lo: libsharp/$(am__dirstamp) \
	libsharp/$(DEPDIR)/$(am__dirstamp)
libsharp/sharp_ylmgen_c.lo: libsharp/$(am__dirstamp) \
	libsharp/$(DEPDIR)/$(am__dirstamp)
cxxsupport/$(am__dirstamp):
	@$(MKDIR_P) cxxsupport
	@: > cxxsupport/$(am__dirstamp)
cxxsupport/$(DEPDIR)/$(am__dirstamp):
	@$(MKDIR_P) cxxsupport/$(DEPDIR)
	@: > cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/announce.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/fitshandle.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/geom_utils.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/string_utils.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/ls_image.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/paramfile.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/pointing.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/rotmatrix.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/trafos.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/walltimer.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/wigner.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
cxxsupport/error_handling.lo: cxxsupport/$(am__dirstamp) \
	cxxsupport/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/$(am__dirstamp):
	@$(MKDIR_P) Healpix_cxx
	@: > Healpix_cxx/$(am__dirstamp)
Healpix_cxx/$(DEPDIR)/$(am__dirstamp):
	@$(MKDIR_P) Healpix_cxx/$(DEPDIR)
	@: > Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/alm.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/alm2map_cxx_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/alm_fitsio.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/alm_healpix_tools.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/alm_powspec_tools.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/anafast_cxx_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/calc_powspec_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/healpix_base.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/healpix_data_io.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/healpix_map.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/healpix_map_fitsio.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/healpix_tables.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/hotspots_cxx_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/map2tga_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/median_filter_cxx_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/mult_alm_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/powspec.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/powspec_fitsio.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/smoothing_cxx_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/syn_alm_cxx_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/udgrade_cxx_module.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/udgrade_harmonic_cxx_module.lo:  \
	Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/moc_fitsio.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
Healpix_cxx/moc_query.lo: Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

libhealpix_cxx.la: $(libhealpix_cxx_la_OBJECTS) $(libhealpix_cxx_la_DEPENDENCIES) $(EXTRA_libhealpix_cxx_la_DEPENDENCIES) 
	$(AM_V_CXXLD)$(CXXLINK) -rpath $(libdir) $(libhealpix_cxx_la_OBJECTS) $(libhealpix_cxx_la_LIBADD) $(LIBS)
install-binPROGRAMS: $(bin_PROGRAMS)
	@$(NORMAL_INSTALL)
	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
	if test -n "$$list"; then \
	  echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
	  $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
	fi; \
	for p in $$list; do echo "$$p $$p"; done | \
	sed 's/$(EXEEXT)$$//' | \
	while read p p1; do if test -f $$p \
	 || test -f $$p1 \
	  ; then echo "$$p"; echo "$$p"; else :; fi; \
	done | \
	sed -e 'p;s,.*/,,;n;h' \
	    -e 's|.*|.|' \
	    -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
	sed 'N;N;N;s,\n, ,g' | \
	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
	    if ($$2 == $$4) files[d] = files[d] " " $$1; \
	    else { print "f", $$3 "/" $$4, $$1; } } \
	  END { for (d in files) print "f", d, files[d] }' | \
	while read type dir files; do \
	    if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
	    test -z "$$files" || { \
	    echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
	    $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
	    } \
	; done

uninstall-binPROGRAMS:
	@$(NORMAL_UNINSTALL)
	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
	files=`for p in $$list; do echo "$$p"; done | \
	  sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
	      -e 's/$$/$(EXEEXT)/' \
	`; \
	test -n "$$list" || exit 0; \
	echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
	cd "$(DESTDIR)$(bindir)" && rm -f $$files

clean-binPROGRAMS:
	@list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
	echo " rm -f" $$list; \
	rm -f $$list || exit $$?; \
	test -n "$(EXEEXT)" || exit 0; \
	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
	echo " rm -f" $$list; \
	rm -f $$list

clean-checkPROGRAMS:
	@list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \
	echo " rm -f" $$list; \
	rm -f $$list || exit $$?; \
	test -n "$(EXEEXT)" || exit 0; \
	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
	echo " rm -f" $$list; \
	rm -f $$list
Healpix_cxx/alm2map_cxx.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

alm2map_cxx$(EXEEXT): $(alm2map_cxx_OBJECTS) $(alm2map_cxx_DEPENDENCIES) $(EXTRA_alm2map_cxx_DEPENDENCIES) 
	@rm -f alm2map_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(alm2map_cxx_LINK) $(alm2map_cxx_OBJECTS) $(alm2map_cxx_LDADD) $(LIBS)
Healpix_cxx/anafast_cxx.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

anafast_cxx$(EXEEXT): $(anafast_cxx_OBJECTS) $(anafast_cxx_DEPENDENCIES) $(EXTRA_anafast_cxx_DEPENDENCIES) 
	@rm -f anafast_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(anafast_cxx_LINK) $(anafast_cxx_OBJECTS) $(anafast_cxx_LDADD) $(LIBS)
Healpix_cxx/calc_powspec.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

calc_powspec$(EXEEXT): $(calc_powspec_OBJECTS) $(calc_powspec_DEPENDENCIES) $(EXTRA_calc_powspec_DEPENDENCIES) 
	@rm -f calc_powspec$(EXEEXT)
	$(AM_V_CXXLD)$(calc_powspec_LINK) $(calc_powspec_OBJECTS) $(calc_powspec_LDADD) $(LIBS)
Healpix_cxx/hotspots_cxx.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

hotspots_cxx$(EXEEXT): $(hotspots_cxx_OBJECTS) $(hotspots_cxx_DEPENDENCIES) $(EXTRA_hotspots_cxx_DEPENDENCIES) 
	@rm -f hotspots_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(hotspots_cxx_LINK) $(hotspots_cxx_OBJECTS) $(hotspots_cxx_LDADD) $(LIBS)
Healpix_cxx/hpxtest.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

hpxtest$(EXEEXT): $(hpxtest_OBJECTS) $(hpxtest_DEPENDENCIES) $(EXTRA_hpxtest_DEPENDENCIES) 
	@rm -f hpxtest$(EXEEXT)
	$(AM_V_CXXLD)$(hpxtest_LINK) $(hpxtest_OBJECTS) $(hpxtest_LDADD) $(LIBS)
Healpix_cxx/map2tga.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

map2tga$(EXEEXT): $(map2tga_OBJECTS) $(map2tga_DEPENDENCIES) $(EXTRA_map2tga_DEPENDENCIES) 
	@rm -f map2tga$(EXEEXT)
	$(AM_V_CXXLD)$(map2tga_LINK) $(map2tga_OBJECTS) $(map2tga_LDADD) $(LIBS)
Healpix_cxx/median_filter_cxx.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

median_filter_cxx$(EXEEXT): $(median_filter_cxx_OBJECTS) $(median_filter_cxx_DEPENDENCIES) $(EXTRA_median_filter_cxx_DEPENDENCIES) 
	@rm -f median_filter_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(median_filter_cxx_LINK) $(median_filter_cxx_OBJECTS) $(median_filter_cxx_LDADD) $(LIBS)
Healpix_cxx/mult_alm.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

mult_alm$(EXEEXT): $(mult_alm_OBJECTS) $(mult_alm_DEPENDENCIES) $(EXTRA_mult_alm_DEPENDENCIES) 
	@rm -f mult_alm$(EXEEXT)
	$(AM_V_CXXLD)$(mult_alm_LINK) $(mult_alm_OBJECTS) $(mult_alm_LDADD) $(LIBS)
Healpix_cxx/rotalm_cxx.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

rotalm_cxx$(EXEEXT): $(rotalm_cxx_OBJECTS) $(rotalm_cxx_DEPENDENCIES) $(EXTRA_rotalm_cxx_DEPENDENCIES) 
	@rm -f rotalm_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(rotalm_cxx_LINK) $(rotalm_cxx_OBJECTS) $(rotalm_cxx_LDADD) $(LIBS)
Healpix_cxx/smoothing_cxx.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

smoothing_cxx$(EXEEXT): $(smoothing_cxx_OBJECTS) $(smoothing_cxx_DEPENDENCIES) $(EXTRA_smoothing_cxx_DEPENDENCIES) 
	@rm -f smoothing_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(smoothing_cxx_LINK) $(smoothing_cxx_OBJECTS) $(smoothing_cxx_LDADD) $(LIBS)
Healpix_cxx/syn_alm_cxx.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

syn_alm_cxx$(EXEEXT): $(syn_alm_cxx_OBJECTS) $(syn_alm_cxx_DEPENDENCIES) $(EXTRA_syn_alm_cxx_DEPENDENCIES) 
	@rm -f syn_alm_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(syn_alm_cxx_LINK) $(syn_alm_cxx_OBJECTS) $(syn_alm_cxx_LDADD) $(LIBS)
Healpix_cxx/udgrade_cxx.$(OBJEXT): Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

udgrade_cxx$(EXEEXT): $(udgrade_cxx_OBJECTS) $(udgrade_cxx_DEPENDENCIES) $(EXTRA_udgrade_cxx_DEPENDENCIES) 
	@rm -f udgrade_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(udgrade_cxx_LINK) $(udgrade_cxx_OBJECTS) $(udgrade_cxx_LDADD) $(LIBS)
Healpix_cxx/udgrade_harmonic_cxx.$(OBJEXT):  \
	Healpix_cxx/$(am__dirstamp) \
	Healpix_cxx/$(DEPDIR)/$(am__dirstamp)

udgrade_harmonic_cxx$(EXEEXT): $(udgrade_harmonic_cxx_OBJECTS) $(udgrade_harmonic_cxx_DEPENDENCIES) $(EXTRA_udgrade_harmonic_cxx_DEPENDENCIES) 
	@rm -f udgrade_harmonic_cxx$(EXEEXT)
	$(AM_V_CXXLD)$(udgrade_harmonic_cxx_LINK) $(udgrade_harmonic_cxx_OBJECTS) $(udgrade_harmonic_cxx_LDADD) $(LIBS)

mostlyclean-compile:
	-rm -f *.$(OBJEXT)
	-rm -f Healpix_cxx/*.$(OBJEXT)
	-rm -f Healpix_cxx/*.lo
	-rm -f c_utils/*.$(OBJEXT)
	-rm -f c_utils/*.lo
	-rm -f cxxsupport/*.$(OBJEXT)
	-rm -f cxxsupport/*.lo
	-rm -f libfftpack/*.$(OBJEXT)
	-rm -f libfftpack/*.lo
	-rm -f libsharp/*.$(OBJEXT)
	-rm -f libsharp/*.lo

distclean-compile:
	-rm -f *.tab.c

@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/alm.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/alm2map_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/alm2map_cxx_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/alm_fitsio.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/alm_healpix_tools.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/alm_powspec_tools.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/anafast_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/anafast_cxx_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/calc_powspec.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/calc_powspec_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/healpix_base.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/healpix_data_io.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/healpix_map.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/healpix_map_fitsio.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/healpix_tables.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/hotspots_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/hotspots_cxx_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/hpxtest.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/map2tga.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/map2tga_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/median_filter_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/median_filter_cxx_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/moc_fitsio.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/moc_query.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/mult_alm.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/mult_alm_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/powspec.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/powspec_fitsio.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/rotalm_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/smoothing_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/smoothing_cxx_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/syn_alm_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/syn_alm_cxx_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/udgrade_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/udgrade_cxx_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/udgrade_harmonic_cxx.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@Healpix_cxx/$(DEPDIR)/udgrade_harmonic_cxx_module.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@c_utils/$(DEPDIR)/c_utils.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@c_utils/$(DEPDIR)/walltime_c.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/announce.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/error_handling.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/fitshandle.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/geom_utils.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/ls_image.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/paramfile.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/pointing.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/rotmatrix.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/string_utils.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/trafos.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/walltimer.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@cxxsupport/$(DEPDIR)/wigner.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@libfftpack/$(DEPDIR)/bluestein.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@libfftpack/$(DEPDIR)/fftpack.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@libfftpack/$(DEPDIR)/ls_fft.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@libsharp/$(DEPDIR)/sharp.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@libsharp/$(DEPDIR)/sharp_almhelpers.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@libsharp/$(DEPDIR)/sharp_core.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@libsharp/$(DEPDIR)/sharp_geomhelpers.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@libsharp/$(DEPDIR)/sharp_ylmgen_c.Plo@am__quote@

.c.o:
@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<

.c.obj:
@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`

.c.lo:
@am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<

.cc.o:
@am__fastdepCXX_TRUE@	$(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCXX_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<

.cc.obj:
@am__fastdepCXX_TRUE@	$(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
@am__fastdepCXX_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`

.cc.lo:
@am__fastdepCXX_TRUE@	$(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
@am__fastdepCXX_TRUE@	$(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
@am__fastdepCXX_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<

mostlyclean-libtool:
	-rm -f *.lo

clean-libtool:
	-rm -rf .libs _libs
	-rm -rf Healpix_cxx/.libs Healpix_cxx/_libs
	-rm -rf c_utils/.libs c_utils/_libs
	-rm -rf cxxsupport/.libs cxxsupport/_libs
	-rm -rf libfftpack/.libs libfftpack/_libs
	-rm -rf libsharp/.libs libsharp/_libs

distclean-libtool:
	-rm -f libtool config.lt
install-nodist_pkgconfigDATA: $(nodist_pkgconfig_DATA)
	@$(NORMAL_INSTALL)
	@list='$(nodist_pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
	if test -n "$$list"; then \
	  echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
	  $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
	fi; \
	for p in $$list; do \
	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
	  echo "$$d$$p"; \
	done | $(am__base_list) | \
	while read files; do \
	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
	  $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
	done

uninstall-nodist_pkgconfigDATA:
	@$(NORMAL_UNINSTALL)
	@list='$(nodist_pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
	dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
install-includeHEADERS: $(include_HEADERS)
	@$(NORMAL_INSTALL)
	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
	if test -n "$$list"; then \
	  echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \
	  $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \
	fi; \
	for p in $$list; do \
	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
	  echo "$$d$$p"; \
	done | $(am__base_list) | \
	while read files; do \
	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includedir)'"; \
	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \
	done

uninstall-includeHEADERS:
	@$(NORMAL_UNINSTALL)
	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
	dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir)

ID: $(am__tagged_files)
	$(am__define_uniq_tagged_files); mkid -fID $$unique
tags: tags-am
TAGS: tags

tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	set x; \
	here=`pwd`; \
	$(am__define_uniq_tagged_files); \
	shift; \
	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
	  test -n "$$unique" || unique=$$empty_fix; \
	  if test $$# -gt 0; then \
	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
	      "$$@" $$unique; \
	  else \
	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
	      $$unique; \
	  fi; \
	fi
ctags: ctags-am

CTAGS: ctags
ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
	$(am__define_uniq_tagged_files); \
	test -z "$(CTAGS_ARGS)$$unique" \
	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
	     $$unique

GTAGS:
	here=`$(am__cd) $(top_builddir) && pwd` \
	  && $(am__cd) $(top_srcdir) \
	  && gtags -i $(GTAGS_ARGS) "$$here"
cscope: cscope.files
	test ! -s cscope.files \
	  || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
clean-cscope:
	-rm -f cscope.files
cscope.files: clean-cscope cscopelist
cscopelist: cscopelist-am

cscopelist-am: $(am__tagged_files)
	list='$(am__tagged_files)'; \
	case "$(srcdir)" in \
	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
	  *) sdir=$(subdir)/$(srcdir) ;; \
	esac; \
	for i in $$list; do \
	  if test -f "$$i"; then \
	    echo "$(subdir)/$$i"; \
	  else \
	    echo "$$sdir/$$i"; \
	  fi; \
	done >> $(top_builddir)/cscope.files

distclean-tags:
	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
	-rm -f cscope.out cscope.in.out cscope.po.out cscope.files

# Recover from deleted '.trs' file; this should ensure that
# "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create
# both 'foo.log' and 'foo.trs'.  Break the recipe in two subshells
# to avoid problems with "make -n".
.log.trs:
	rm -f $< $@
	$(MAKE) $(AM_MAKEFLAGS) $<

# Leading 'am--fnord' is there to ensure the list of targets does not
# expand to empty, as could happen e.g. with make check TESTS=''.
am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck)
am--force-recheck:
	@:

$(TEST_SUITE_LOG): $(TEST_LOGS)
	@$(am__set_TESTS_bases); \
	am__f_ok () { test -f "$$1" && test -r "$$1"; }; \
	redo_bases=`for i in $$bases; do \
	              am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \
	            done`; \
	if test -n "$$redo_bases"; then \
	  redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \
	  redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \
	  if $(am__make_dryrun); then :; else \
	    rm -f $$redo_logs && rm -f $$redo_results || exit 1; \
	  fi; \
	fi; \
	if test -n "$$am__remaking_logs"; then \
	  echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \
	       "recursion detected" >&2; \
	else \
	  am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \
	fi; \
	if $(am__make_dryrun); then :; else \
	  st=0;  \
	  errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \
	  for i in $$redo_bases; do \
	    test -f $$i.trs && test -r $$i.trs \
	      || { echo "$$errmsg $$i.trs" >&2; st=1; }; \
	    test -f $$i.log && test -r $$i.log \
	      || { echo "$$errmsg $$i.log" >&2; st=1; }; \
	  done; \
	  test $$st -eq 0 || exit 1; \
	fi
	@$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \
	ws='[ 	]'; \
	results=`for b in $$bases; do echo $$b.trs; done`; \
	test -n "$$results" || results=/dev/null; \
	all=`  grep "^$$ws*:test-result:"           $$results | wc -l`; \
	pass=` grep "^$$ws*:test-result:$$ws*PASS"  $$results | wc -l`; \
	fail=` grep "^$$ws*:test-result:$$ws*FAIL"  $$results | wc -l`; \
	skip=` grep "^$$ws*:test-result:$$ws*SKIP"  $$results | wc -l`; \
	xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \
	xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \
	error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \
	if test `expr $$fail + $$xpass + $$error` -eq 0; then \
	  success=true; \
	else \
	  success=false; \
	fi; \
	br='==================='; br=$$br$$br$$br$$br; \
	result_count () \
	{ \
	    if test x"$$1" = x"--maybe-color"; then \
	      maybe_colorize=yes; \
	    elif test x"$$1" = x"--no-color"; then \
	      maybe_colorize=no; \
	    else \
	      echo "$@: invalid 'result_count' usage" >&2; exit 4; \
	    fi; \
	    shift; \
	    desc=$$1 count=$$2; \
	    if test $$maybe_colorize = yes && test $$count -gt 0; then \
	      color_start=$$3 color_end=$$std; \
	    else \
	      color_start= color_end=; \
	    fi; \
	    echo "$${color_start}# $$desc $$count$${color_end}"; \
	}; \
	create_testsuite_report () \
	{ \
	  result_count $$1 "TOTAL:" $$all   "$$brg"; \
	  result_count $$1 "PASS: " $$pass  "$$grn"; \
	  result_count $$1 "SKIP: " $$skip  "$$blu"; \
	  result_count $$1 "XFAIL:" $$xfail "$$lgn"; \
	  result_count $$1 "FAIL: " $$fail  "$$red"; \
	  result_count $$1 "XPASS:" $$xpass "$$red"; \
	  result_count $$1 "ERROR:" $$error "$$mgn"; \
	}; \
	{								\
	  echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" |	\
	    $(am__rst_title);						\
	  create_testsuite_report --no-color;				\
	  echo;								\
	  echo ".. contents:: :depth: 2";				\
	  echo;								\
	  for b in $$bases; do echo $$b; done				\
	    | $(am__create_global_log);					\
	} >$(TEST_SUITE_LOG).tmp || exit 1;				\
	mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG);			\
	if $$success; then						\
	  col="$$grn";							\
	 else								\
	  col="$$red";							\
	  test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG);		\
	fi;								\
	echo "$${col}$$br$${std}"; 					\
	echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}";	\
	echo "$${col}$$br$${std}"; 					\
	create_testsuite_report --maybe-color;				\
	echo "$$col$$br$$std";						\
	if $$success; then :; else					\
	  echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}";		\
	  if test -n "$(PACKAGE_BUGREPORT)"; then			\
	    echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}";	\
	  fi;								\
	  echo "$$col$$br$$std";					\
	fi;								\
	$$success || exit 1

check-TESTS:
	@list='$(RECHECK_LOGS)';           test -z "$$list" || rm -f $$list
	@list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
	@set +e; $(am__set_TESTS_bases); \
	log_list=`for i in $$bases; do echo $$i.log; done`; \
	trs_list=`for i in $$bases; do echo $$i.trs; done`; \
	log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \
	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \
	exit $$?;
recheck: all $(check_PROGRAMS)
	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
	@set +e; $(am__set_TESTS_bases); \
	bases=`for i in $$bases; do echo $$i; done \
	         | $(am__list_recheck_tests)` || exit 1; \
	log_list=`for i in $$bases; do echo $$i.log; done`; \
	log_list=`echo $$log_list`; \
	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \
	        am__force_recheck=am--force-recheck \
	        TEST_LOGS="$$log_list"; \
	exit $$?
hpxtest.log: hpxtest$(EXEEXT)
	@p='hpxtest$(EXEEXT)'; \
	b='hpxtest'; \
	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
	--log-file $$b.log --trs-file $$b.trs \
	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
	"$$tst" $(AM_TESTS_FD_REDIRECT)
.test.log:
	@p='$<'; \
	$(am__set_b); \
	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
	--log-file $$b.log --trs-file $$b.trs \
	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
	"$$tst" $(AM_TESTS_FD_REDIRECT)
@am__EXEEXT_TRUE@.test$(EXEEXT).log:
@am__EXEEXT_TRUE@	@p='$<'; \
@am__EXEEXT_TRUE@	$(am__set_b); \
@am__EXEEXT_TRUE@	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
@am__EXEEXT_TRUE@	--log-file $$b.log --trs-file $$b.trs \
@am__EXEEXT_TRUE@	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
@am__EXEEXT_TRUE@	"$$tst" $(AM_TESTS_FD_REDIRECT)

distdir: $(DISTFILES)
	$(am__remove_distdir)
	test -d "$(distdir)" || mkdir "$(distdir)"
	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
	list='$(DISTFILES)'; \
	  dist_files=`for file in $$list; do echo $$file; done | \
	  sed -e "s|^$$srcdirstrip/||;t" \
	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
	case $$dist_files in \
	  */*) $(MKDIR_P) `echo "$$dist_files" | \
			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
			   sort -u` ;; \
	esac; \
	for file in $$dist_files; do \
	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
	  if test -d $$d/$$file; then \
	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
	    if test -d "$(distdir)/$$file"; then \
	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
	    fi; \
	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
	    fi; \
	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
	  else \
	    test -f "$(distdir)/$$file" \
	    || cp -p $$d/$$file "$(distdir)/$$file" \
	    || exit 1; \
	  fi; \
	done
	-test -n "$(am__skip_mode_fix)" \
	|| find "$(distdir)" -type d ! -perm -755 \
		-exec chmod u+rwx,go+rx {} \; -o \
	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
	|| chmod -R a+r "$(distdir)"
dist-gzip: distdir
	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
	$(am__post_remove_distdir)

dist-bzip2: distdir
	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
	$(am__post_remove_distdir)

dist-lzip: distdir
	tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
	$(am__post_remove_distdir)

dist-xz: distdir
	tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
	$(am__post_remove_distdir)

dist-tarZ: distdir
	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
	$(am__post_remove_distdir)

dist-shar: distdir
	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
	$(am__post_remove_distdir)

dist-zip: distdir
	-rm -f $(distdir).zip
	zip -rq $(distdir).zip $(distdir)
	$(am__post_remove_distdir)

dist dist-all:
	$(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
	$(am__post_remove_distdir)

# This target untars the dist file and tries a VPATH configuration.  Then
# it guarantees that the distribution is self-contained by making another
# tarfile.
distcheck: dist
	case '$(DIST_ARCHIVES)' in \
	*.tar.gz*) \
	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
	*.tar.bz2*) \
	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
	*.tar.lz*) \
	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
	*.tar.xz*) \
	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
	*.tar.Z*) \
	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
	*.shar.gz*) \
	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
	*.zip*) \
	  unzip $(distdir).zip ;;\
	esac
	chmod -R a-w $(distdir)
	chmod u+w $(distdir)
	mkdir $(distdir)/_build $(distdir)/_inst
	chmod a-w $(distdir)
	test -d $(distdir)/_build || exit 0; \
	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
	  && am__cwd=`pwd` \
	  && $(am__cd) $(distdir)/_build \
	  && ../configure --srcdir=.. --prefix="$$dc_install_base" \
	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
	    $(DISTCHECK_CONFIGURE_FLAGS) \
	  && $(MAKE) $(AM_MAKEFLAGS) \
	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
	  && $(MAKE) $(AM_MAKEFLAGS) check \
	  && $(MAKE) $(AM_MAKEFLAGS) install \
	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
	        distuninstallcheck \
	  && chmod -R a-w "$$dc_install_base" \
	  && ({ \
	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
	  && rm -rf "$$dc_destdir" \
	  && $(MAKE) $(AM_MAKEFLAGS) dist \
	  && rm -rf $(DIST_ARCHIVES) \
	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
	  && cd "$$am__cwd" \
	  || exit 1
	$(am__post_remove_distdir)
	@(echo "$(distdir) archives ready for distribution: "; \
	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
	  sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
distuninstallcheck:
	@test -n '$(distuninstallcheck_dir)' || { \
	  echo 'ERROR: trying to run $@ with an empty' \
	       '$$(distuninstallcheck_dir)' >&2; \
	  exit 1; \
	}; \
	$(am__cd) '$(distuninstallcheck_dir)' || { \
	  echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
	  exit 1; \
	}; \
	test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
	   || { echo "ERROR: files left after uninstall:" ; \
	        if test -n "$(DESTDIR)"; then \
	          echo "  (check DESTDIR support)"; \
	        fi ; \
	        $(distuninstallcheck_listfiles) ; \
	        exit 1; } >&2
distcleancheck: distclean
	@if test '$(srcdir)' = . ; then \
	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
	  exit 1 ; \
	fi
	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
	  || { echo "ERROR: files left in build directory after distclean:" ; \
	       $(distcleancheck_listfiles) ; \
	       exit 1; } >&2
check-am: all-am
	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
check: check-am
all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) $(DATA) $(HEADERS)
install-binPROGRAMS: install-libLTLIBRARIES

installdirs:
	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)" "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(includedir)"; do \
	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
	done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am

install-am: all-am
	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am

installcheck: installcheck-am
install-strip:
	if test -z '$(STRIP)'; then \
	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
	      install; \
	else \
	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
	fi
mostlyclean-generic:
	-test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
	-test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs)
	-test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)

clean-generic:

distclean-generic:
	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
	-rm -f Healpix_cxx/$(DEPDIR)/$(am__dirstamp)
	-rm -f Healpix_cxx/$(am__dirstamp)
	-rm -f c_utils/$(DEPDIR)/$(am__dirstamp)
	-rm -f c_utils/$(am__dirstamp)
	-rm -f cxxsupport/$(DEPDIR)/$(am__dirstamp)
	-rm -f cxxsupport/$(am__dirstamp)
	-rm -f libfftpack/$(DEPDIR)/$(am__dirstamp)
	-rm -f libfftpack/$(am__dirstamp)
	-rm -f libsharp/$(DEPDIR)/$(am__dirstamp)
	-rm -f libsharp/$(am__dirstamp)
	-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)

maintainer-clean-generic:
	@echo "This command is intended for maintainers to use"
	@echo "it deletes files that may require special tools to rebuild."
clean: clean-am

clean-am: clean-binPROGRAMS clean-checkPROGRAMS clean-generic \
	clean-libLTLIBRARIES clean-libtool mostlyclean-am

distclean: distclean-am
	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
	-rm -rf Healpix_cxx/$(DEPDIR) c_utils/$(DEPDIR) cxxsupport/$(DEPDIR) libfftpack/$(DEPDIR) libsharp/$(DEPDIR)
	-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
	distclean-libtool distclean-tags

dvi: dvi-am

dvi-am:

html: html-am

html-am:

info: info-am

info-am:

install-data-am: install-includeHEADERS install-nodist_pkgconfigDATA

install-dvi: install-dvi-am

install-dvi-am:

install-exec-am: install-binPROGRAMS install-libLTLIBRARIES

install-html: install-html-am

install-html-am:

install-info: install-info-am

install-info-am:

install-man:

install-pdf: install-pdf-am

install-pdf-am:

install-ps: install-ps-am

install-ps-am:

installcheck-am:

maintainer-clean: maintainer-clean-am
	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
	-rm -rf $(top_srcdir)/autom4te.cache
	-rm -rf Healpix_cxx/$(DEPDIR) c_utils/$(DEPDIR) cxxsupport/$(DEPDIR) libfftpack/$(DEPDIR) libsharp/$(DEPDIR)
	-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic

mostlyclean: mostlyclean-am

mostlyclean-am: mostlyclean-compile mostlyclean-generic \
	mostlyclean-libtool

pdf: pdf-am

pdf-am:

ps: ps-am

ps-am:

uninstall-am: uninstall-binPROGRAMS uninstall-includeHEADERS \
	uninstall-libLTLIBRARIES uninstall-nodist_pkgconfigDATA

.MAKE: check-am install-am install-strip

.PHONY: CTAGS GTAGS TAGS all all-am am--refresh check check-TESTS \
	check-am clean clean-binPROGRAMS clean-checkPROGRAMS \
	clean-cscope clean-generic clean-libLTLIBRARIES clean-libtool \
	cscope cscopelist-am ctags ctags-am dist dist-all dist-bzip2 \
	dist-gzip dist-lzip dist-shar dist-tarZ dist-xz dist-zip \
	distcheck distclean distclean-compile distclean-generic \
	distclean-libtool distclean-tags distcleancheck distdir \
	distuninstallcheck dvi dvi-am html html-am info info-am \
	install install-am install-binPROGRAMS install-data \
	install-data-am install-dvi install-dvi-am install-exec \
	install-exec-am install-html install-html-am \
	install-includeHEADERS install-info install-info-am \
	install-libLTLIBRARIES install-man \
	install-nodist_pkgconfigDATA install-pdf install-pdf-am \
	install-ps install-ps-am install-strip installcheck \
	installcheck-am installdirs maintainer-clean \
	maintainer-clean-generic mostlyclean mostlyclean-compile \
	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
	recheck tags tags-am uninstall uninstall-am \
	uninstall-binPROGRAMS uninstall-includeHEADERS \
	uninstall-libLTLIBRARIES uninstall-nodist_pkgconfigDATA


# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/aclocal.m40000664000175000017500000013743213010376366024201 0ustar  zoncazonca00000000000000# generated automatically by aclocal 1.13.4 -*- Autoconf -*-

# Copyright (C) 1996-2013 Free Software Foundation, Inc.

# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.

m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
m4_ifndef([AC_AUTOCONF_VERSION],
  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
[m4_warning([this file was generated for autoconf 2.69.
You have another version of autoconf.  It may work, but is not guaranteed to.
If you have problems, you may need to regenerate the build system entirely.
To do so, use the procedure documented by the package, typically 'autoreconf'.])])

# pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
# serial 1 (pkg-config-0.24)
# 
# Copyright © 2004 Scott James Remnant .
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

# PKG_PROG_PKG_CONFIG([MIN-VERSION])
# ----------------------------------
AC_DEFUN([PKG_PROG_PKG_CONFIG],
[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$])
AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])

if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
	AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
fi
if test -n "$PKG_CONFIG"; then
	_pkg_min_version=m4_default([$1], [0.9.0])
	AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
		AC_MSG_RESULT([yes])
	else
		AC_MSG_RESULT([no])
		PKG_CONFIG=""
	fi
fi[]dnl
])# PKG_PROG_PKG_CONFIG

# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
#
# Check to see whether a particular set of modules exists.  Similar
# to PKG_CHECK_MODULES(), but does not set variables or print errors.
#
# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
# only at the first occurence in configure.ac, so if the first place
# it's called might be skipped (such as if it is within an "if", you
# have to call PKG_CHECK_EXISTS manually
# --------------------------------------------------------------
AC_DEFUN([PKG_CHECK_EXISTS],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
if test -n "$PKG_CONFIG" && \
    AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
  m4_default([$2], [:])
m4_ifvaln([$3], [else
  $3])dnl
fi])

# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
# ---------------------------------------------
m4_define([_PKG_CONFIG],
[if test -n "$$1"; then
    pkg_cv_[]$1="$$1"
 elif test -n "$PKG_CONFIG"; then
    PKG_CHECK_EXISTS([$3],
                     [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`
		      test "x$?" != "x0" && pkg_failed=yes ],
		     [pkg_failed=yes])
 else
    pkg_failed=untried
fi[]dnl
])# _PKG_CONFIG

# _PKG_SHORT_ERRORS_SUPPORTED
# -----------------------------
AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
        _pkg_short_errors_supported=yes
else
        _pkg_short_errors_supported=no
fi[]dnl
])# _PKG_SHORT_ERRORS_SUPPORTED


# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
# [ACTION-IF-NOT-FOUND])
#
#
# Note that if there is a possibility the first call to
# PKG_CHECK_MODULES might not happen, you should be sure to include an
# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
#
#
# --------------------------------------------------------------
AC_DEFUN([PKG_CHECK_MODULES],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl

pkg_failed=no
AC_MSG_CHECKING([for $1])

_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
_PKG_CONFIG([$1][_LIBS], [libs], [$2])

m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
and $1[]_LIBS to avoid the need to call pkg-config.
See the pkg-config man page for more details.])

if test $pkg_failed = yes; then
   	AC_MSG_RESULT([no])
        _PKG_SHORT_ERRORS_SUPPORTED
        if test $_pkg_short_errors_supported = yes; then
	        $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
        else 
	        $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
        fi
	# Put the nasty error message in config.log where it belongs
	echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD

	m4_default([$4], [AC_MSG_ERROR(
[Package requirements ($2) were not met:

$$1_PKG_ERRORS

Consider adjusting the PKG_CONFIG_PATH environment variable if you
installed software in a non-standard prefix.

_PKG_TEXT])[]dnl
        ])
elif test $pkg_failed = untried; then
     	AC_MSG_RESULT([no])
	m4_default([$4], [AC_MSG_FAILURE(
[The pkg-config script could not be found or is too old.  Make sure it
is in your PATH or set the PKG_CONFIG environment variable to the full
path to pkg-config.

_PKG_TEXT

To get pkg-config, see .])[]dnl
        ])
else
	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
	$1[]_LIBS=$pkg_cv_[]$1[]_LIBS
        AC_MSG_RESULT([yes])
	$3
fi[]dnl
])# PKG_CHECK_MODULES


# PKG_INSTALLDIR(DIRECTORY)
# -------------------------
# Substitutes the variable pkgconfigdir as the location where a module
# should install pkg-config .pc files. By default the directory is
# $libdir/pkgconfig, but the default can be changed by passing
# DIRECTORY. The user can override through the --with-pkgconfigdir
# parameter.
AC_DEFUN([PKG_INSTALLDIR],
[m4_pushdef([pkg_default], [m4_default([$1], ['${libdir}/pkgconfig'])])
m4_pushdef([pkg_description],
    [pkg-config installation directory @<:@]pkg_default[@:>@])
AC_ARG_WITH([pkgconfigdir],
    [AS_HELP_STRING([--with-pkgconfigdir], pkg_description)],,
    [with_pkgconfigdir=]pkg_default)
AC_SUBST([pkgconfigdir], [$with_pkgconfigdir])
m4_popdef([pkg_default])
m4_popdef([pkg_description])
]) dnl PKG_INSTALLDIR


# PKG_NOARCH_INSTALLDIR(DIRECTORY)
# -------------------------
# Substitutes the variable noarch_pkgconfigdir as the location where a
# module should install arch-independent pkg-config .pc files. By
# default the directory is $datadir/pkgconfig, but the default can be
# changed by passing DIRECTORY. The user can override through the
# --with-noarch-pkgconfigdir parameter.
AC_DEFUN([PKG_NOARCH_INSTALLDIR],
[m4_pushdef([pkg_default], [m4_default([$1], ['${datadir}/pkgconfig'])])
m4_pushdef([pkg_description],
    [pkg-config arch-independent installation directory @<:@]pkg_default[@:>@])
AC_ARG_WITH([noarch-pkgconfigdir],
    [AS_HELP_STRING([--with-noarch-pkgconfigdir], pkg_description)],,
    [with_noarch_pkgconfigdir=]pkg_default)
AC_SUBST([noarch_pkgconfigdir], [$with_noarch_pkgconfigdir])
m4_popdef([pkg_default])
m4_popdef([pkg_description])
]) dnl PKG_NOARCH_INSTALLDIR

# Copyright (C) 2002-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_AUTOMAKE_VERSION(VERSION)
# ----------------------------
# Automake X.Y traces this macro to ensure aclocal.m4 has been
# generated from the m4 files accompanying Automake X.Y.
# (This private macro should not be called outside this file.)
AC_DEFUN([AM_AUTOMAKE_VERSION],
[am__api_version='1.13'
dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
dnl require some minimum version.  Point them to the right macro.
m4_if([$1], [1.13.4], [],
      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
])

# _AM_AUTOCONF_VERSION(VERSION)
# -----------------------------
# aclocal traces this macro to find the Autoconf version.
# This is a private macro too.  Using m4_define simplifies
# the logic in aclocal, which can simply ignore this definition.
m4_define([_AM_AUTOCONF_VERSION], [])

# AM_SET_CURRENT_AUTOMAKE_VERSION
# -------------------------------
# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
[AM_AUTOMAKE_VERSION([1.13.4])dnl
m4_ifndef([AC_AUTOCONF_VERSION],
  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])

# Copyright (C) 2011-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_PROG_AR([ACT-IF-FAIL])
# -------------------------
# Try to determine the archiver interface, and trigger the ar-lib wrapper
# if it is needed.  If the detection of archiver interface fails, run
# ACT-IF-FAIL (default is to abort configure with a proper error message).
AC_DEFUN([AM_PROG_AR],
[AC_BEFORE([$0], [LT_INIT])dnl
AC_BEFORE([$0], [AC_PROG_LIBTOOL])dnl
AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
AC_REQUIRE_AUX_FILE([ar-lib])dnl
AC_CHECK_TOOLS([AR], [ar lib "link -lib"], [false])
: ${AR=ar}

AC_CACHE_CHECK([the archiver ($AR) interface], [am_cv_ar_interface],
  [am_cv_ar_interface=ar
   AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int some_variable = 0;]])],
     [am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&AS_MESSAGE_LOG_FD'
      AC_TRY_EVAL([am_ar_try])
      if test "$ac_status" -eq 0; then
        am_cv_ar_interface=ar
      else
        am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&AS_MESSAGE_LOG_FD'
        AC_TRY_EVAL([am_ar_try])
        if test "$ac_status" -eq 0; then
          am_cv_ar_interface=lib
        else
          am_cv_ar_interface=unknown
        fi
      fi
      rm -f conftest.lib libconftest.a
     ])
   ])

case $am_cv_ar_interface in
ar)
  ;;
lib)
  # Microsoft lib, so override with the ar-lib wrapper script.
  # FIXME: It is wrong to rewrite AR.
  # But if we don't then we get into trouble of one sort or another.
  # A longer-term fix would be to have automake use am__AR in this case,
  # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something
  # similar.
  AR="$am_aux_dir/ar-lib $AR"
  ;;
unknown)
  m4_default([$1],
             [AC_MSG_ERROR([could not determine $AR interface])])
  ;;
esac
AC_SUBST([AR])dnl
])

# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-

# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
# $ac_aux_dir to '$srcdir/foo'.  In other projects, it is set to
# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
#
# Of course, Automake must honor this variable whenever it calls a
# tool from the auxiliary directory.  The problem is that $srcdir (and
# therefore $ac_aux_dir as well) can be either absolute or relative,
# depending on how configure is run.  This is pretty annoying, since
# it makes $ac_aux_dir quite unusable in subdirectories: in the top
# source directory, any form will work fine, but in subdirectories a
# relative path needs to be adjusted first.
#
# $ac_aux_dir/missing
#    fails when called from a subdirectory if $ac_aux_dir is relative
# $top_srcdir/$ac_aux_dir/missing
#    fails if $ac_aux_dir is absolute,
#    fails when called from a subdirectory in a VPATH build with
#          a relative $ac_aux_dir
#
# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
# are both prefixed by $srcdir.  In an in-source build this is usually
# harmless because $srcdir is '.', but things will broke when you
# start a VPATH build or use an absolute $srcdir.
#
# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
# and then we would define $MISSING as
#   MISSING="\${SHELL} $am_aux_dir/missing"
# This will work as long as MISSING is not called from configure, because
# unfortunately $(top_srcdir) has no meaning in configure.
# However there are other variables, like CC, which are often used in
# configure, and could therefore not use this "fixed" $ac_aux_dir.
#
# Another solution, used here, is to always expand $ac_aux_dir to an
# absolute PATH.  The drawback is that using absolute paths prevent a
# configured tree to be moved without reconfiguration.

AC_DEFUN([AM_AUX_DIR_EXPAND],
[dnl Rely on autoconf to set up CDPATH properly.
AC_PREREQ([2.50])dnl
# expand $ac_aux_dir to an absolute path
am_aux_dir=`cd $ac_aux_dir && pwd`
])

# AM_CONDITIONAL                                            -*- Autoconf -*-

# Copyright (C) 1997-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_CONDITIONAL(NAME, SHELL-CONDITION)
# -------------------------------------
# Define a conditional.
AC_DEFUN([AM_CONDITIONAL],
[AC_PREREQ([2.52])dnl
 m4_if([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
       [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
AC_SUBST([$1_TRUE])dnl
AC_SUBST([$1_FALSE])dnl
_AM_SUBST_NOTMAKE([$1_TRUE])dnl
_AM_SUBST_NOTMAKE([$1_FALSE])dnl
m4_define([_AM_COND_VALUE_$1], [$2])dnl
if $2; then
  $1_TRUE=
  $1_FALSE='#'
else
  $1_TRUE='#'
  $1_FALSE=
fi
AC_CONFIG_COMMANDS_PRE(
[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
  AC_MSG_ERROR([[conditional "$1" was never defined.
Usually this means the macro was only invoked conditionally.]])
fi])])

# Copyright (C) 1999-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.


# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
# written in clear, in which case automake, when reading aclocal.m4,
# will think it sees a *use*, and therefore will trigger all it's
# C support machinery.  Also note that it means that autoscan, seeing
# CC etc. in the Makefile, will ask for an AC_PROG_CC use...


# _AM_DEPENDENCIES(NAME)
# ----------------------
# See how the compiler implements dependency checking.
# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
# We try a few techniques and use that to set a single cache variable.
#
# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
# dependency, and given that the user is not expected to run this macro,
# just rely on AC_PROG_CC.
AC_DEFUN([_AM_DEPENDENCIES],
[AC_REQUIRE([AM_SET_DEPDIR])dnl
AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
AC_REQUIRE([AM_MAKE_INCLUDE])dnl
AC_REQUIRE([AM_DEP_TRACK])dnl

m4_if([$1], [CC],   [depcc="$CC"   am_compiler_list=],
      [$1], [CXX],  [depcc="$CXX"  am_compiler_list=],
      [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
      [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
      [$1], [UPC],  [depcc="$UPC"  am_compiler_list=],
      [$1], [GCJ],  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
                    [depcc="$$1"   am_compiler_list=])

AC_CACHE_CHECK([dependency style of $depcc],
               [am_cv_$1_dependencies_compiler_type],
[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
  # We make a subdir and do the tests there.  Otherwise we can end up
  # making bogus files that we don't know about and never remove.  For
  # instance it was reported that on HP-UX the gcc test will end up
  # making a dummy file named 'D' -- because '-MD' means "put the output
  # in D".
  rm -rf conftest.dir
  mkdir conftest.dir
  # Copy depcomp to subdir because otherwise we won't find it if we're
  # using a relative directory.
  cp "$am_depcomp" conftest.dir
  cd conftest.dir
  # We will build objects and dependencies in a subdirectory because
  # it helps to detect inapplicable dependency modes.  For instance
  # both Tru64's cc and ICC support -MD to output dependencies as a
  # side effect of compilation, but ICC will put the dependencies in
  # the current directory while Tru64 will put them in the object
  # directory.
  mkdir sub

  am_cv_$1_dependencies_compiler_type=none
  if test "$am_compiler_list" = ""; then
     am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
  fi
  am__universal=false
  m4_case([$1], [CC],
    [case " $depcc " in #(
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
     esac],
    [CXX],
    [case " $depcc " in #(
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
     esac])

  for depmode in $am_compiler_list; do
    # Setup a source with many dependencies, because some compilers
    # like to wrap large dependency lists on column 80 (with \), and
    # we should not choose a depcomp mode which is confused by this.
    #
    # We need to recreate these files for each test, as the compiler may
    # overwrite some of them when testing with obscure command lines.
    # This happens at least with the AIX C compiler.
    : > sub/conftest.c
    for i in 1 2 3 4 5 6; do
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
      # Solaris 10 /bin/sh.
      echo '/* dummy */' > sub/conftst$i.h
    done
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

    # We check with '-c' and '-o' for the sake of the "dashmstdout"
    # mode.  It turns out that the SunPro C++ compiler does not properly
    # handle '-M -o', and we need to detect this.  Also, some Intel
    # versions had trouble with output in subdirs.
    am__obj=sub/conftest.${OBJEXT-o}
    am__minus_obj="-o $am__obj"
    case $depmode in
    gcc)
      # This depmode causes a compiler race in universal mode.
      test "$am__universal" = false || continue
      ;;
    nosideeffect)
      # After this tag, mechanisms are not by side-effect, so they'll
      # only be used when explicitly requested.
      if test "x$enable_dependency_tracking" = xyes; then
	continue
      else
	break
      fi
      ;;
    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
      # This compiler won't grok '-c -o', but also, the minuso test has
      # not run yet.  These depmodes are late enough in the game, and
      # so weak that their functioning should not be impacted.
      am__obj=conftest.${OBJEXT-o}
      am__minus_obj=
      ;;
    none) break ;;
    esac
    if depmode=$depmode \
       source=sub/conftest.c object=$am__obj \
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
         >/dev/null 2>conftest.err &&
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
      # icc doesn't choke on unknown options, it will just issue warnings
      # or remarks (even with -Werror).  So we grep stderr for any message
      # that says an option was ignored or not supported.
      # When given -MP, icc 7.0 and 7.1 complain thusly:
      #   icc: Command line warning: ignoring option '-M'; no argument required
      # The diagnosis changed in icc 8.0:
      #   icc: Command line remark: option '-MP' not supported
      if (grep 'ignoring option' conftest.err ||
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
        am_cv_$1_dependencies_compiler_type=$depmode
        break
      fi
    fi
  done

  cd ..
  rm -rf conftest.dir
else
  am_cv_$1_dependencies_compiler_type=none
fi
])
AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
AM_CONDITIONAL([am__fastdep$1], [
  test "x$enable_dependency_tracking" != xno \
  && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
])


# AM_SET_DEPDIR
# -------------
# Choose a directory name for dependency files.
# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
AC_DEFUN([AM_SET_DEPDIR],
[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
])


# AM_DEP_TRACK
# ------------
AC_DEFUN([AM_DEP_TRACK],
[AC_ARG_ENABLE([dependency-tracking], [dnl
AS_HELP_STRING(
  [--enable-dependency-tracking],
  [do not reject slow dependency extractors])
AS_HELP_STRING(
  [--disable-dependency-tracking],
  [speeds up one-time build])])
if test "x$enable_dependency_tracking" != xno; then
  am_depcomp="$ac_aux_dir/depcomp"
  AMDEPBACKSLASH='\'
  am__nodep='_no'
fi
AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
AC_SUBST([AMDEPBACKSLASH])dnl
_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
AC_SUBST([am__nodep])dnl
_AM_SUBST_NOTMAKE([am__nodep])dnl
])

# Generate code to set up dependency tracking.              -*- Autoconf -*-

# Copyright (C) 1999-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.


# _AM_OUTPUT_DEPENDENCY_COMMANDS
# ------------------------------
AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
[{
  # Older Autoconf quotes --file arguments for eval, but not when files
  # are listed without --file.  Let's play safe and only enable the eval
  # if we detect the quoting.
  case $CONFIG_FILES in
  *\'*) eval set x "$CONFIG_FILES" ;;
  *)   set x $CONFIG_FILES ;;
  esac
  shift
  for mf
  do
    # Strip MF so we end up with the name of the file.
    mf=`echo "$mf" | sed -e 's/:.*$//'`
    # Check whether this is an Automake generated Makefile or not.
    # We used to match only the files named 'Makefile.in', but
    # some people rename them; so instead we look at the file content.
    # Grep'ing the first line is not enough: some people post-process
    # each Makefile.in and add a new line on top of each file to say so.
    # Grep'ing the whole file is not good either: AIX grep has a line
    # limit of 2048, but all sed's we know have understand at least 4000.
    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
      dirpart=`AS_DIRNAME("$mf")`
    else
      continue
    fi
    # Extract the definition of DEPDIR, am__include, and am__quote
    # from the Makefile without running 'make'.
    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
    test -z "$DEPDIR" && continue
    am__include=`sed -n 's/^am__include = //p' < "$mf"`
    test -z "$am__include" && continue
    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
    # Find all dependency output files, they are included files with
    # $(DEPDIR) in their names.  We invoke sed twice because it is the
    # simplest approach to changing $(DEPDIR) to its actual value in the
    # expansion.
    for file in `sed -n "
      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
      # Make sure the directory exists.
      test -f "$dirpart/$file" && continue
      fdir=`AS_DIRNAME(["$file"])`
      AS_MKDIR_P([$dirpart/$fdir])
      # echo "creating $dirpart/$file"
      echo '# dummy' > "$dirpart/$file"
    done
  done
}
])# _AM_OUTPUT_DEPENDENCY_COMMANDS


# AM_OUTPUT_DEPENDENCY_COMMANDS
# -----------------------------
# This macro should only be invoked once -- use via AC_REQUIRE.
#
# This code is only required when automatic dependency tracking
# is enabled.  FIXME.  This creates each '.P' file that we will
# need in order to bootstrap the dependency handling code.
AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
[AC_CONFIG_COMMANDS([depfiles],
     [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
     [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
])

# Do all the work for Automake.                             -*- Autoconf -*-

# Copyright (C) 1996-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# This macro actually does too much.  Some checks are only needed if
# your package does certain things.  But this isn't really a big deal.

# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
# AM_INIT_AUTOMAKE([OPTIONS])
# -----------------------------------------------
# The call with PACKAGE and VERSION arguments is the old style
# call (pre autoconf-2.50), which is being phased out.  PACKAGE
# and VERSION should now be passed to AC_INIT and removed from
# the call to AM_INIT_AUTOMAKE.
# We support both call styles for the transition.  After
# the next Automake release, Autoconf can make the AC_INIT
# arguments mandatory, and then we can depend on a new Autoconf
# release and drop the old call support.
AC_DEFUN([AM_INIT_AUTOMAKE],
[AC_PREREQ([2.65])dnl
dnl Autoconf wants to disallow AM_ names.  We explicitly allow
dnl the ones we care about.
m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
AC_REQUIRE([AC_PROG_INSTALL])dnl
if test "`cd $srcdir && pwd`" != "`pwd`"; then
  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
  # is not polluted with repeated "-I."
  AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
  # test to see if srcdir already configured
  if test -f $srcdir/config.status; then
    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
  fi
fi

# test whether we have cygpath
if test -z "$CYGPATH_W"; then
  if (cygpath --version) >/dev/null 2>/dev/null; then
    CYGPATH_W='cygpath -w'
  else
    CYGPATH_W=echo
  fi
fi
AC_SUBST([CYGPATH_W])

# Define the identity of the package.
dnl Distinguish between old-style and new-style calls.
m4_ifval([$2],
[AC_DIAGNOSE([obsolete],
             [$0: two- and three-arguments forms are deprecated.])
m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
 AC_SUBST([PACKAGE], [$1])dnl
 AC_SUBST([VERSION], [$2])],
[_AM_SET_OPTIONS([$1])dnl
dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
m4_if(
  m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
  [ok:ok],,
  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
 AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
 AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl

_AM_IF_OPTION([no-define],,
[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
 AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl

# Some tools Automake needs.
AC_REQUIRE([AM_SANITY_CHECK])dnl
AC_REQUIRE([AC_ARG_PROGRAM])dnl
AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
AM_MISSING_PROG([AUTOCONF], [autoconf])
AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
AM_MISSING_PROG([AUTOHEADER], [autoheader])
AM_MISSING_PROG([MAKEINFO], [makeinfo])
AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
AC_REQUIRE([AC_PROG_MKDIR_P])dnl
# For better backward compatibility.  To be removed once Automake 1.9.x
# dies out for good.  For more background, see:
# 
# 
AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
# We need awk for the "check" target.  The system "awk" is bad on
# some platforms.
AC_REQUIRE([AC_PROG_AWK])dnl
AC_REQUIRE([AC_PROG_MAKE_SET])dnl
AC_REQUIRE([AM_SET_LEADING_DOT])dnl
_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
	      [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
			     [_AM_PROG_TAR([v7])])])
_AM_IF_OPTION([no-dependencies],,
[AC_PROVIDE_IFELSE([AC_PROG_CC],
		  [_AM_DEPENDENCIES([CC])],
		  [m4_define([AC_PROG_CC],
			     m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
AC_PROVIDE_IFELSE([AC_PROG_CXX],
		  [_AM_DEPENDENCIES([CXX])],
		  [m4_define([AC_PROG_CXX],
			     m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
AC_PROVIDE_IFELSE([AC_PROG_OBJC],
		  [_AM_DEPENDENCIES([OBJC])],
		  [m4_define([AC_PROG_OBJC],
			     m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
		  [_AM_DEPENDENCIES([OBJCXX])],
		  [m4_define([AC_PROG_OBJCXX],
			     m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
])
AC_REQUIRE([AM_SILENT_RULES])dnl
dnl The testsuite driver may need to know about EXEEXT, so add the
dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
AC_CONFIG_COMMANDS_PRE(dnl
[m4_provide_if([_AM_COMPILER_EXEEXT],
  [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
])

dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
dnl mangled by Autoconf and run in a shell conditional statement.
m4_define([_AC_COMPILER_EXEEXT],
m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])


# When config.status generates a header, we must update the stamp-h file.
# This file resides in the same directory as the config header
# that is generated.  The stamp files are numbered to have different names.

# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
# loop where config.status creates the headers, so we can generate
# our stamp files there.
AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
[# Compute $1's index in $config_headers.
_am_arg=$1
_am_stamp_count=1
for _am_header in $config_headers :; do
  case $_am_header in
    $_am_arg | $_am_arg:* )
      break ;;
    * )
      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
  esac
done
echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])

# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_PROG_INSTALL_SH
# ------------------
# Define $install_sh.
AC_DEFUN([AM_PROG_INSTALL_SH],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
if test x"${install_sh}" != xset; then
  case $am_aux_dir in
  *\ * | *\	*)
    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
  *)
    install_sh="\${SHELL} $am_aux_dir/install-sh"
  esac
fi
AC_SUBST([install_sh])])

# Copyright (C) 2003-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# Check whether the underlying file-system supports filenames
# with a leading dot.  For instance MS-DOS doesn't.
AC_DEFUN([AM_SET_LEADING_DOT],
[rm -rf .tst 2>/dev/null
mkdir .tst 2>/dev/null
if test -d .tst; then
  am__leading_dot=.
else
  am__leading_dot=_
fi
rmdir .tst 2>/dev/null
AC_SUBST([am__leading_dot])])

# Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
# From Jim Meyering

# Copyright (C) 1996-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_MAINTAINER_MODE([DEFAULT-MODE])
# ----------------------------------
# Control maintainer-specific portions of Makefiles.
# Default is to disable them, unless 'enable' is passed literally.
# For symmetry, 'disable' may be passed as well.  Anyway, the user
# can override the default with the --enable/--disable switch.
AC_DEFUN([AM_MAINTAINER_MODE],
[m4_case(m4_default([$1], [disable]),
       [enable], [m4_define([am_maintainer_other], [disable])],
       [disable], [m4_define([am_maintainer_other], [enable])],
       [m4_define([am_maintainer_other], [enable])
        m4_warn([syntax], [unexpected argument to AM@&t@_MAINTAINER_MODE: $1])])
AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
  dnl maintainer-mode's default is 'disable' unless 'enable' is passed
  AC_ARG_ENABLE([maintainer-mode],
    [AS_HELP_STRING([--]am_maintainer_other[-maintainer-mode],
      am_maintainer_other[ make rules and dependencies not useful
      (and sometimes confusing) to the casual installer])],
    [USE_MAINTAINER_MODE=$enableval],
    [USE_MAINTAINER_MODE=]m4_if(am_maintainer_other, [enable], [no], [yes]))
  AC_MSG_RESULT([$USE_MAINTAINER_MODE])
  AM_CONDITIONAL([MAINTAINER_MODE], [test $USE_MAINTAINER_MODE = yes])
  MAINT=$MAINTAINER_MODE_TRUE
  AC_SUBST([MAINT])dnl
]
)

# Check to see how 'make' treats includes.	            -*- Autoconf -*-

# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_MAKE_INCLUDE()
# -----------------
# Check to see how make treats includes.
AC_DEFUN([AM_MAKE_INCLUDE],
[am_make=${MAKE-make}
cat > confinc << 'END'
am__doit:
	@echo this is the am__doit target
.PHONY: am__doit
END
# If we don't find an include directive, just comment out the code.
AC_MSG_CHECKING([for style of include used by $am_make])
am__include="#"
am__quote=
_am_result=none
# First try GNU make style include.
echo "include confinc" > confmf
# Ignore all kinds of additional output from 'make'.
case `$am_make -s -f confmf 2> /dev/null` in #(
*the\ am__doit\ target*)
  am__include=include
  am__quote=
  _am_result=GNU
  ;;
esac
# Now try BSD make style include.
if test "$am__include" = "#"; then
   echo '.include "confinc"' > confmf
   case `$am_make -s -f confmf 2> /dev/null` in #(
   *the\ am__doit\ target*)
     am__include=.include
     am__quote="\""
     _am_result=BSD
     ;;
   esac
fi
AC_SUBST([am__include])
AC_SUBST([am__quote])
AC_MSG_RESULT([$_am_result])
rm -f confinc confmf
])

# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-

# Copyright (C) 1997-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_MISSING_PROG(NAME, PROGRAM)
# ------------------------------
AC_DEFUN([AM_MISSING_PROG],
[AC_REQUIRE([AM_MISSING_HAS_RUN])
$1=${$1-"${am_missing_run}$2"}
AC_SUBST($1)])

# AM_MISSING_HAS_RUN
# ------------------
# Define MISSING if not defined so far and test if it is modern enough.
# If it is, set am_missing_run to use it, otherwise, to nothing.
AC_DEFUN([AM_MISSING_HAS_RUN],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
AC_REQUIRE_AUX_FILE([missing])dnl
if test x"${MISSING+set}" != xset; then
  case $am_aux_dir in
  *\ * | *\	*)
    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
  *)
    MISSING="\${SHELL} $am_aux_dir/missing" ;;
  esac
fi
# Use eval to expand $SHELL
if eval "$MISSING --is-lightweight"; then
  am_missing_run="$MISSING "
else
  am_missing_run=
  AC_MSG_WARN(['missing' script is too old or missing])
fi
])

# Helper functions for option handling.                     -*- Autoconf -*-

# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# _AM_MANGLE_OPTION(NAME)
# -----------------------
AC_DEFUN([_AM_MANGLE_OPTION],
[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])

# _AM_SET_OPTION(NAME)
# --------------------
# Set option NAME.  Presently that only means defining a flag for this option.
AC_DEFUN([_AM_SET_OPTION],
[m4_define(_AM_MANGLE_OPTION([$1]), [1])])

# _AM_SET_OPTIONS(OPTIONS)
# ------------------------
# OPTIONS is a space-separated list of Automake options.
AC_DEFUN([_AM_SET_OPTIONS],
[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])

# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
# -------------------------------------------
# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
AC_DEFUN([_AM_IF_OPTION],
[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])

# Check to make sure that the build environment is sane.    -*- Autoconf -*-

# Copyright (C) 1996-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_SANITY_CHECK
# ---------------
AC_DEFUN([AM_SANITY_CHECK],
[AC_MSG_CHECKING([whether build environment is sane])
# Reject unsafe characters in $srcdir or the absolute working directory
# name.  Accept space and tab only in the latter.
am_lf='
'
case `pwd` in
  *[[\\\"\#\$\&\'\`$am_lf]]*)
    AC_MSG_ERROR([unsafe absolute working directory name]);;
esac
case $srcdir in
  *[[\\\"\#\$\&\'\`$am_lf\ \	]]*)
    AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
esac

# Do 'set' in a subshell so we don't clobber the current shell's
# arguments.  Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
   am_has_slept=no
   for am_try in 1 2; do
     echo "timestamp, slept: $am_has_slept" > conftest.file
     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
     if test "$[*]" = "X"; then
	# -L didn't work.
	set X `ls -t "$srcdir/configure" conftest.file`
     fi
     if test "$[*]" != "X $srcdir/configure conftest.file" \
	&& test "$[*]" != "X conftest.file $srcdir/configure"; then

	# If neither matched, then we have a broken ls.  This can happen
	# if, for instance, CONFIG_SHELL is bash and it inherits a
	# broken ls alias from the environment.  This has actually
	# happened.  Such a system could not be considered "sane".
	AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
  alias in your environment])
     fi
     if test "$[2]" = conftest.file || test $am_try -eq 2; then
       break
     fi
     # Just in case.
     sleep 1
     am_has_slept=yes
   done
   test "$[2]" = conftest.file
   )
then
   # Ok.
   :
else
   AC_MSG_ERROR([newly created file is older than distributed files!
Check your system clock])
fi
AC_MSG_RESULT([yes])
# If we didn't sleep, we still need to ensure time stamps of config.status and
# generated files are strictly newer.
am_sleep_pid=
if grep 'slept: no' conftest.file >/dev/null 2>&1; then
  ( sleep 1 ) &
  am_sleep_pid=$!
fi
AC_CONFIG_COMMANDS_PRE(
  [AC_MSG_CHECKING([that generated files are newer than configure])
   if test -n "$am_sleep_pid"; then
     # Hide warnings about reused PIDs.
     wait $am_sleep_pid 2>/dev/null
   fi
   AC_MSG_RESULT([done])])
rm -f conftest.file
])

# Copyright (C) 2009-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_SILENT_RULES([DEFAULT])
# --------------------------
# Enable less verbose build rules; with the default set to DEFAULT
# ("yes" being less verbose, "no" or empty being verbose).
AC_DEFUN([AM_SILENT_RULES],
[AC_ARG_ENABLE([silent-rules], [dnl
AS_HELP_STRING(
  [--enable-silent-rules],
  [less verbose build output (undo: "make V=1")])
AS_HELP_STRING(
  [--disable-silent-rules],
  [verbose build output (undo: "make V=0")])dnl
])
case $enable_silent_rules in @%:@ (((
  yes) AM_DEFAULT_VERBOSITY=0;;
   no) AM_DEFAULT_VERBOSITY=1;;
    *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
esac
dnl
dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
dnl do not support nested variable expansions.
dnl See automake bug#9928 and bug#10237.
am_make=${MAKE-make}
AC_CACHE_CHECK([whether $am_make supports nested variables],
   [am_cv_make_support_nested_variables],
   [if AS_ECHO([['TRUE=$(BAR$(V))
BAR0=false
BAR1=true
V=1
am__doit:
	@$(TRUE)
.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
  am_cv_make_support_nested_variables=yes
else
  am_cv_make_support_nested_variables=no
fi])
if test $am_cv_make_support_nested_variables = yes; then
  dnl Using '$V' instead of '$(V)' breaks IRIX make.
  AM_V='$(V)'
  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
else
  AM_V=$AM_DEFAULT_VERBOSITY
  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
fi
AC_SUBST([AM_V])dnl
AM_SUBST_NOTMAKE([AM_V])dnl
AC_SUBST([AM_DEFAULT_V])dnl
AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
AM_BACKSLASH='\'
AC_SUBST([AM_BACKSLASH])dnl
_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
])

# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# AM_PROG_INSTALL_STRIP
# ---------------------
# One issue with vendor 'install' (even GNU) is that you can't
# specify the program used to strip binaries.  This is especially
# annoying in cross-compiling environments, where the build's strip
# is unlikely to handle the host's binaries.
# Fortunately install-sh will honor a STRIPPROG variable, so we
# always use install-sh in "make install-strip", and initialize
# STRIPPROG with the value of the STRIP variable (set by the user).
AC_DEFUN([AM_PROG_INSTALL_STRIP],
[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
# Installed binaries are usually stripped using 'strip' when the user
# run "make install-strip".  However 'strip' might not be the right
# tool to use in cross-compilation environments, therefore Automake
# will honor the 'STRIP' environment variable to overrule this program.
dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
if test "$cross_compiling" != no; then
  AC_CHECK_TOOL([STRIP], [strip], :)
fi
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
AC_SUBST([INSTALL_STRIP_PROGRAM])])

# Copyright (C) 2006-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# _AM_SUBST_NOTMAKE(VARIABLE)
# ---------------------------
# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
# This macro is traced by Automake.
AC_DEFUN([_AM_SUBST_NOTMAKE])

# AM_SUBST_NOTMAKE(VARIABLE)
# --------------------------
# Public sister of _AM_SUBST_NOTMAKE.
AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])

# Check how to create a tarball.                            -*- Autoconf -*-

# Copyright (C) 2004-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# _AM_PROG_TAR(FORMAT)
# --------------------
# Check how to create a tarball in format FORMAT.
# FORMAT should be one of 'v7', 'ustar', or 'pax'.
#
# Substitute a variable $(am__tar) that is a command
# writing to stdout a FORMAT-tarball containing the directory
# $tardir.
#     tardir=directory && $(am__tar) > result.tar
#
# Substitute a variable $(am__untar) that extract such
# a tarball read from stdin.
#     $(am__untar) < result.tar
#
AC_DEFUN([_AM_PROG_TAR],
[# Always define AMTAR for backward compatibility.  Yes, it's still used
# in the wild :-(  We should find a proper way to deprecate it ...
AC_SUBST([AMTAR], ['$${TAR-tar}'])

# We'll loop over all known methods to create a tar archive until one works.
_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'

m4_if([$1], [v7],
  [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],

  [m4_case([$1],
    [ustar],
     [# The POSIX 1988 'ustar' format is defined with fixed-size fields.
      # There is notably a 21 bits limit for the UID and the GID.  In fact,
      # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
      # and bug#13588).
      am_max_uid=2097151 # 2^21 - 1
      am_max_gid=$am_max_uid
      # The $UID and $GID variables are not portable, so we need to resort
      # to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
      # below are definitely unexpected, so allow the users to see them
      # (that is, avoid stderr redirection).
      am_uid=`id -u || echo unknown`
      am_gid=`id -g || echo unknown`
      AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
      if test $am_uid -le $am_max_uid; then
         AC_MSG_RESULT([yes])
      else
         AC_MSG_RESULT([no])
         _am_tools=none
      fi
      AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
      if test $am_gid -le $am_max_gid; then
         AC_MSG_RESULT([yes])
      else
        AC_MSG_RESULT([no])
        _am_tools=none
      fi],

  [pax],
    [],

  [m4_fatal([Unknown tar format])])

  AC_MSG_CHECKING([how to create a $1 tar archive])

  # Go ahead even if we have the value already cached.  We do so because we
  # need to set the values for the 'am__tar' and 'am__untar' variables.
  _am_tools=${am_cv_prog_tar_$1-$_am_tools}

  for _am_tool in $_am_tools; do
    case $_am_tool in
    gnutar)
      for _am_tar in tar gnutar gtar; do
        AM_RUN_LOG([$_am_tar --version]) && break
      done
      am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
      am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
      am__untar="$_am_tar -xf -"
      ;;
    plaintar)
      # Must skip GNU tar: if it does not support --format= it doesn't create
      # ustar tarball either.
      (tar --version) >/dev/null 2>&1 && continue
      am__tar='tar chf - "$$tardir"'
      am__tar_='tar chf - "$tardir"'
      am__untar='tar xf -'
      ;;
    pax)
      am__tar='pax -L -x $1 -w "$$tardir"'
      am__tar_='pax -L -x $1 -w "$tardir"'
      am__untar='pax -r'
      ;;
    cpio)
      am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
      am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
      am__untar='cpio -i -H $1 -d'
      ;;
    none)
      am__tar=false
      am__tar_=false
      am__untar=false
      ;;
    esac

    # If the value was cached, stop now.  We just wanted to have am__tar
    # and am__untar set.
    test -n "${am_cv_prog_tar_$1}" && break

    # tar/untar a dummy directory, and stop if the command works.
    rm -rf conftest.dir
    mkdir conftest.dir
    echo GrepMe > conftest.dir/file
    AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
    rm -rf conftest.dir
    if test -s conftest.tar; then
      AM_RUN_LOG([$am__untar /dev/null 2>&1 && break
    fi
  done
  rm -rf conftest.dir

  AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
  AC_MSG_RESULT([$am_cv_prog_tar_$1])])

AC_SUBST([am__tar])
AC_SUBST([am__untar])
]) # _AM_PROG_TAR

m4_include([m4/libtool.m4])
m4_include([m4/ltoptions.m4])
m4_include([m4/ltsugar.m4])
m4_include([m4/ltversion.m4])
m4_include([m4/lt~obsolete.m4])
m4_include([m4/m4_ax_create_pkgconfig_info.m4])
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/ar-lib0000755000175000017500000001330213010376370023413 0ustar  zoncazonca00000000000000#! /bin/sh
# Wrapper for Microsoft lib.exe

me=ar-lib
scriptversion=2012-03-01.08; # UTC

# Copyright (C) 2010-2013 Free Software Foundation, Inc.
# Written by Peter Rosin .
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

# This file is maintained in Automake, please report
# bugs to  or send patches to
# .


# func_error message
func_error ()
{
  echo "$me: $1" 1>&2
  exit 1
}

file_conv=

# func_file_conv build_file
# Convert a $build file to $host form and store it in $file
# Currently only supports Windows hosts.
func_file_conv ()
{
  file=$1
  case $file in
    / | /[!/]*) # absolute file, and not a UNC file
      if test -z "$file_conv"; then
	# lazily determine how to convert abs files
	case `uname -s` in
	  MINGW*)
	    file_conv=mingw
	    ;;
	  CYGWIN*)
	    file_conv=cygwin
	    ;;
	  *)
	    file_conv=wine
	    ;;
	esac
      fi
      case $file_conv in
	mingw)
	  file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
	  ;;
	cygwin)
	  file=`cygpath -m "$file" || echo "$file"`
	  ;;
	wine)
	  file=`winepath -w "$file" || echo "$file"`
	  ;;
      esac
      ;;
  esac
}

# func_at_file at_file operation archive
# Iterate over all members in AT_FILE performing OPERATION on ARCHIVE
# for each of them.
# When interpreting the content of the @FILE, do NOT use func_file_conv,
# since the user would need to supply preconverted file names to
# binutils ar, at least for MinGW.
func_at_file ()
{
  operation=$2
  archive=$3
  at_file_contents=`cat "$1"`
  eval set x "$at_file_contents"
  shift

  for member
  do
    $AR -NOLOGO $operation:"$member" "$archive" || exit $?
  done
}

case $1 in
  '')
     func_error "no command.  Try '$0 --help' for more information."
     ;;
  -h | --h*)
    cat <.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program.  This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").
#
# Originally written by Per Bothner.
#
# You can get the latest version of this script from:
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
#
# Please send patches with a ChangeLog entry to config-patches@gnu.org.


me=`echo "$0" | sed -e 's,.*/,,'`

usage="\
Usage: $0 [OPTION]

Output the configuration name of the system \`$me' is run on.

Operation modes:
  -h, --help         print this help, then exit
  -t, --time-stamp   print date of last modification, then exit
  -v, --version      print version number, then exit

Report bugs and patches to ."

version="\
GNU config.guess ($timestamp)

Originally written by Per Bothner.
Copyright 1992-2013 Free Software Foundation, Inc.

This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."

help="
Try \`$me --help' for more information."

# Parse command line
while test $# -gt 0 ; do
  case $1 in
    --time-stamp | --time* | -t )
       echo "$timestamp" ; exit ;;
    --version | -v )
       echo "$version" ; exit ;;
    --help | --h* | -h )
       echo "$usage"; exit ;;
    -- )     # Stop option processing
       shift; break ;;
    - )	# Use stdin as input.
       break ;;
    -* )
       echo "$me: invalid option $1$help" >&2
       exit 1 ;;
    * )
       break ;;
  esac
done

if test $# != 0; then
  echo "$me: too many arguments$help" >&2
  exit 1
fi

trap 'exit 1' 1 2 15

# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
# compiler to aid in system detection is discouraged as it requires
# temporary files to be created and, as you can see below, it is a
# headache to deal with in a portable fashion.

# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
# use `HOST_CC' if defined, but it is deprecated.

# Portable tmp directory creation inspired by the Autoconf team.

set_cc_for_build='
trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
: ${TMPDIR=/tmp} ;
 { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
 { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
 { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
 { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
dummy=$tmp/dummy ;
tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
case $CC_FOR_BUILD,$HOST_CC,$CC in
 ,,)    echo "int x;" > $dummy.c ;
	for c in cc gcc c89 c99 ; do
	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
	     CC_FOR_BUILD="$c"; break ;
	  fi ;
	done ;
	if test x"$CC_FOR_BUILD" = x ; then
	  CC_FOR_BUILD=no_compiler_found ;
	fi
	;;
 ,,*)   CC_FOR_BUILD=$CC ;;
 ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
esac ; set_cc_for_build= ;'

# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
# (ghazi@noc.rutgers.edu 1994-08-24)
if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
	PATH=$PATH:/.attbin ; export PATH
fi

UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown

case "${UNAME_SYSTEM}" in
Linux|GNU|GNU/*)
	# If the system lacks a compiler, then just pick glibc.
	# We could probably try harder.
	LIBC=gnu

	eval $set_cc_for_build
	cat <<-EOF > $dummy.c
	#include 
	#if defined(__UCLIBC__)
	LIBC=uclibc
	#elif defined(__dietlibc__)
	LIBC=dietlibc
	#else
	LIBC=gnu
	#endif
	EOF
	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
	;;
esac

# Note: order is significant - the case branches are not exclusive.

case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
    *:NetBSD:*:*)
	# NetBSD (nbsd) targets should (where applicable) match one or
	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
	# switched to ELF, *-*-netbsd* would select the old
	# object file format.  This provides both forward
	# compatibility and a consistent mechanism for selecting the
	# object file format.
	#
	# Note: NetBSD doesn't particularly care about the vendor
	# portion of the name.  We always set it to "unknown".
	sysctl="sysctl -n hw.machine_arch"
	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
	    /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
	case "${UNAME_MACHINE_ARCH}" in
	    armeb) machine=armeb-unknown ;;
	    arm*) machine=arm-unknown ;;
	    sh3el) machine=shl-unknown ;;
	    sh3eb) machine=sh-unknown ;;
	    sh5el) machine=sh5le-unknown ;;
	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
	esac
	# The Operating System including object format, if it has switched
	# to ELF recently, or will in the future.
	case "${UNAME_MACHINE_ARCH}" in
	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
		eval $set_cc_for_build
		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
			| grep -q __ELF__
		then
		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
		    # Return netbsd for either.  FIX?
		    os=netbsd
		else
		    os=netbsdelf
		fi
		;;
	    *)
		os=netbsd
		;;
	esac
	# The OS release
	# Debian GNU/NetBSD machines have a different userland, and
	# thus, need a distinct triplet. However, they do not need
	# kernel version information, so it can be replaced with a
	# suitable tag, in the style of linux-gnu.
	case "${UNAME_VERSION}" in
	    Debian*)
		release='-gnu'
		;;
	    *)
		release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
		;;
	esac
	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
	# contains redundant information, the shorter form:
	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
	echo "${machine}-${os}${release}"
	exit ;;
    *:Bitrig:*:*)
	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
	echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
	exit ;;
    *:OpenBSD:*:*)
	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
	exit ;;
    *:ekkoBSD:*:*)
	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
	exit ;;
    *:SolidBSD:*:*)
	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
	exit ;;
    macppc:MirBSD:*:*)
	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
	exit ;;
    *:MirBSD:*:*)
	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
	exit ;;
    alpha:OSF1:*:*)
	case $UNAME_RELEASE in
	*4.0)
		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
		;;
	*5.*)
		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
		;;
	esac
	# According to Compaq, /usr/sbin/psrinfo has been available on
	# OSF/1 and Tru64 systems produced since 1995.  I hope that
	# covers most systems running today.  This code pipes the CPU
	# types through head -n 1, so we only detect the type of CPU 0.
	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
	case "$ALPHA_CPU_TYPE" in
	    "EV4 (21064)")
		UNAME_MACHINE="alpha" ;;
	    "EV4.5 (21064)")
		UNAME_MACHINE="alpha" ;;
	    "LCA4 (21066/21068)")
		UNAME_MACHINE="alpha" ;;
	    "EV5 (21164)")
		UNAME_MACHINE="alphaev5" ;;
	    "EV5.6 (21164A)")
		UNAME_MACHINE="alphaev56" ;;
	    "EV5.6 (21164PC)")
		UNAME_MACHINE="alphapca56" ;;
	    "EV5.7 (21164PC)")
		UNAME_MACHINE="alphapca57" ;;
	    "EV6 (21264)")
		UNAME_MACHINE="alphaev6" ;;
	    "EV6.7 (21264A)")
		UNAME_MACHINE="alphaev67" ;;
	    "EV6.8CB (21264C)")
		UNAME_MACHINE="alphaev68" ;;
	    "EV6.8AL (21264B)")
		UNAME_MACHINE="alphaev68" ;;
	    "EV6.8CX (21264D)")
		UNAME_MACHINE="alphaev68" ;;
	    "EV6.9A (21264/EV69A)")
		UNAME_MACHINE="alphaev69" ;;
	    "EV7 (21364)")
		UNAME_MACHINE="alphaev7" ;;
	    "EV7.9 (21364A)")
		UNAME_MACHINE="alphaev79" ;;
	esac
	# A Pn.n version is a patched version.
	# A Vn.n version is a released version.
	# A Tn.n version is a released field test version.
	# A Xn.n version is an unreleased experimental baselevel.
	# 1.2 uses "1.2" for uname -r.
	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
	exitcode=$?
	trap '' 0
	exit $exitcode ;;
    Alpha\ *:Windows_NT*:*)
	# How do we know it's Interix rather than the generic POSIX subsystem?
	# Should we change UNAME_MACHINE based on the output of uname instead
	# of the specific Alpha model?
	echo alpha-pc-interix
	exit ;;
    21064:Windows_NT:50:3)
	echo alpha-dec-winnt3.5
	exit ;;
    Amiga*:UNIX_System_V:4.0:*)
	echo m68k-unknown-sysv4
	exit ;;
    *:[Aa]miga[Oo][Ss]:*:*)
	echo ${UNAME_MACHINE}-unknown-amigaos
	exit ;;
    *:[Mm]orph[Oo][Ss]:*:*)
	echo ${UNAME_MACHINE}-unknown-morphos
	exit ;;
    *:OS/390:*:*)
	echo i370-ibm-openedition
	exit ;;
    *:z/VM:*:*)
	echo s390-ibm-zvmoe
	exit ;;
    *:OS400:*:*)
	echo powerpc-ibm-os400
	exit ;;
    arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
	echo arm-acorn-riscix${UNAME_RELEASE}
	exit ;;
    arm*:riscos:*:*|arm*:RISCOS:*:*)
	echo arm-unknown-riscos
	exit ;;
    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
	echo hppa1.1-hitachi-hiuxmpp
	exit ;;
    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
	if test "`(/bin/universe) 2>/dev/null`" = att ; then
		echo pyramid-pyramid-sysv3
	else
		echo pyramid-pyramid-bsd
	fi
	exit ;;
    NILE*:*:*:dcosx)
	echo pyramid-pyramid-svr4
	exit ;;
    DRS?6000:unix:4.0:6*)
	echo sparc-icl-nx6
	exit ;;
    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
	case `/usr/bin/uname -p` in
	    sparc) echo sparc-icl-nx7; exit ;;
	esac ;;
    s390x:SunOS:*:*)
	echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
	exit ;;
    sun4H:SunOS:5.*:*)
	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
	exit ;;
    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
	exit ;;
    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
	echo i386-pc-auroraux${UNAME_RELEASE}
	exit ;;
    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
	eval $set_cc_for_build
	SUN_ARCH="i386"
	# If there is a compiler, see if it is configured for 64-bit objects.
	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
	# This test works for both compilers.
	if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
		(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
		grep IS_64BIT_ARCH >/dev/null
	    then
		SUN_ARCH="x86_64"
	    fi
	fi
	echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
	exit ;;
    sun4*:SunOS:6*:*)
	# According to config.sub, this is the proper way to canonicalize
	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
	# it's likely to be more like Solaris than SunOS4.
	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
	exit ;;
    sun4*:SunOS:*:*)
	case "`/usr/bin/arch -k`" in
	    Series*|S4*)
		UNAME_RELEASE=`uname -v`
		;;
	esac
	# Japanese Language versions have a version number like `4.1.3-JL'.
	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
	exit ;;
    sun3*:SunOS:*:*)
	echo m68k-sun-sunos${UNAME_RELEASE}
	exit ;;
    sun*:*:4.2BSD:*)
	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
	case "`/bin/arch`" in
	    sun3)
		echo m68k-sun-sunos${UNAME_RELEASE}
		;;
	    sun4)
		echo sparc-sun-sunos${UNAME_RELEASE}
		;;
	esac
	exit ;;
    aushp:SunOS:*:*)
	echo sparc-auspex-sunos${UNAME_RELEASE}
	exit ;;
    # The situation for MiNT is a little confusing.  The machine name
    # can be virtually everything (everything which is not
    # "atarist" or "atariste" at least should have a processor
    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
    # to the lowercase version "mint" (or "freemint").  Finally
    # the system name "TOS" denotes a system which is actually not
    # MiNT.  But MiNT is downward compatible to TOS, so this should
    # be no problem.
    atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
	echo m68k-atari-mint${UNAME_RELEASE}
	exit ;;
    atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
	echo m68k-atari-mint${UNAME_RELEASE}
	exit ;;
    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
	echo m68k-atari-mint${UNAME_RELEASE}
	exit ;;
    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
	echo m68k-milan-mint${UNAME_RELEASE}
	exit ;;
    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
	echo m68k-hades-mint${UNAME_RELEASE}
	exit ;;
    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
	echo m68k-unknown-mint${UNAME_RELEASE}
	exit ;;
    m68k:machten:*:*)
	echo m68k-apple-machten${UNAME_RELEASE}
	exit ;;
    powerpc:machten:*:*)
	echo powerpc-apple-machten${UNAME_RELEASE}
	exit ;;
    RISC*:Mach:*:*)
	echo mips-dec-mach_bsd4.3
	exit ;;
    RISC*:ULTRIX:*:*)
	echo mips-dec-ultrix${UNAME_RELEASE}
	exit ;;
    VAX*:ULTRIX*:*:*)
	echo vax-dec-ultrix${UNAME_RELEASE}
	exit ;;
    2020:CLIX:*:* | 2430:CLIX:*:*)
	echo clipper-intergraph-clix${UNAME_RELEASE}
	exit ;;
    mips:*:*:UMIPS | mips:*:*:RISCos)
	eval $set_cc_for_build
	sed 's/^	//' << EOF >$dummy.c
#ifdef __cplusplus
#include   /* for printf() prototype */
	int main (int argc, char *argv[]) {
#else
	int main (argc, argv) int argc; char *argv[]; {
#endif
	#if defined (host_mips) && defined (MIPSEB)
	#if defined (SYSTYPE_SYSV)
	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
	#endif
	#if defined (SYSTYPE_SVR4)
	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
	#endif
	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
	#endif
	#endif
	  exit (-1);
	}
EOF
	$CC_FOR_BUILD -o $dummy $dummy.c &&
	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
	  SYSTEM_NAME=`$dummy $dummyarg` &&
	    { echo "$SYSTEM_NAME"; exit; }
	echo mips-mips-riscos${UNAME_RELEASE}
	exit ;;
    Motorola:PowerMAX_OS:*:*)
	echo powerpc-motorola-powermax
	exit ;;
    Motorola:*:4.3:PL8-*)
	echo powerpc-harris-powermax
	exit ;;
    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
	echo powerpc-harris-powermax
	exit ;;
    Night_Hawk:Power_UNIX:*:*)
	echo powerpc-harris-powerunix
	exit ;;
    m88k:CX/UX:7*:*)
	echo m88k-harris-cxux7
	exit ;;
    m88k:*:4*:R4*)
	echo m88k-motorola-sysv4
	exit ;;
    m88k:*:3*:R3*)
	echo m88k-motorola-sysv3
	exit ;;
    AViiON:dgux:*:*)
	# DG/UX returns AViiON for all architectures
	UNAME_PROCESSOR=`/usr/bin/uname -p`
	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
	then
	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
	       [ ${TARGET_BINARY_INTERFACE}x = x ]
	    then
		echo m88k-dg-dgux${UNAME_RELEASE}
	    else
		echo m88k-dg-dguxbcs${UNAME_RELEASE}
	    fi
	else
	    echo i586-dg-dgux${UNAME_RELEASE}
	fi
	exit ;;
    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
	echo m88k-dolphin-sysv3
	exit ;;
    M88*:*:R3*:*)
	# Delta 88k system running SVR3
	echo m88k-motorola-sysv3
	exit ;;
    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
	echo m88k-tektronix-sysv3
	exit ;;
    Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
	echo m68k-tektronix-bsd
	exit ;;
    *:IRIX*:*:*)
	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
	exit ;;
    ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
    i*86:AIX:*:*)
	echo i386-ibm-aix
	exit ;;
    ia64:AIX:*:*)
	if [ -x /usr/bin/oslevel ] ; then
		IBM_REV=`/usr/bin/oslevel`
	else
		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
	fi
	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
	exit ;;
    *:AIX:2:3)
	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
		eval $set_cc_for_build
		sed 's/^		//' << EOF >$dummy.c
		#include 

		main()
			{
			if (!__power_pc())
				exit(1);
			puts("powerpc-ibm-aix3.2.5");
			exit(0);
			}
EOF
		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
		then
			echo "$SYSTEM_NAME"
		else
			echo rs6000-ibm-aix3.2.5
		fi
	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
		echo rs6000-ibm-aix3.2.4
	else
		echo rs6000-ibm-aix3.2
	fi
	exit ;;
    *:AIX:*:[4567])
	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
		IBM_ARCH=rs6000
	else
		IBM_ARCH=powerpc
	fi
	if [ -x /usr/bin/oslevel ] ; then
		IBM_REV=`/usr/bin/oslevel`
	else
		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
	fi
	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
	exit ;;
    *:AIX:*:*)
	echo rs6000-ibm-aix
	exit ;;
    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
	echo romp-ibm-bsd4.4
	exit ;;
    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
	exit ;;                             # report: romp-ibm BSD 4.3
    *:BOSX:*:*)
	echo rs6000-bull-bosx
	exit ;;
    DPX/2?00:B.O.S.:*:*)
	echo m68k-bull-sysv3
	exit ;;
    9000/[34]??:4.3bsd:1.*:*)
	echo m68k-hp-bsd
	exit ;;
    hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
	echo m68k-hp-bsd4.4
	exit ;;
    9000/[34678]??:HP-UX:*:*)
	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
	case "${UNAME_MACHINE}" in
	    9000/31? )            HP_ARCH=m68000 ;;
	    9000/[34]?? )         HP_ARCH=m68k ;;
	    9000/[678][0-9][0-9])
		if [ -x /usr/bin/getconf ]; then
		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
		    case "${sc_cpu_version}" in
		      523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
		      528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
		      532)                      # CPU_PA_RISC2_0
			case "${sc_kernel_bits}" in
			  32) HP_ARCH="hppa2.0n" ;;
			  64) HP_ARCH="hppa2.0w" ;;
			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
			esac ;;
		    esac
		fi
		if [ "${HP_ARCH}" = "" ]; then
		    eval $set_cc_for_build
		    sed 's/^		//' << EOF >$dummy.c

		#define _HPUX_SOURCE
		#include 
		#include 

		int main ()
		{
		#if defined(_SC_KERNEL_BITS)
		    long bits = sysconf(_SC_KERNEL_BITS);
		#endif
		    long cpu  = sysconf (_SC_CPU_VERSION);

		    switch (cpu)
			{
			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
			case CPU_PA_RISC2_0:
		#if defined(_SC_KERNEL_BITS)
			    switch (bits)
				{
				case 64: puts ("hppa2.0w"); break;
				case 32: puts ("hppa2.0n"); break;
				default: puts ("hppa2.0"); break;
				} break;
		#else  /* !defined(_SC_KERNEL_BITS) */
			    puts ("hppa2.0"); break;
		#endif
			default: puts ("hppa1.0"); break;
			}
		    exit (0);
		}
EOF
		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
		    test -z "$HP_ARCH" && HP_ARCH=hppa
		fi ;;
	esac
	if [ ${HP_ARCH} = "hppa2.0w" ]
	then
	    eval $set_cc_for_build

	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
	    # generating 64-bit code.  GNU and HP use different nomenclature:
	    #
	    # $ CC_FOR_BUILD=cc ./config.guess
	    # => hppa2.0w-hp-hpux11.23
	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
	    # => hppa64-hp-hpux11.23

	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
		grep -q __LP64__
	    then
		HP_ARCH="hppa2.0w"
	    else
		HP_ARCH="hppa64"
	    fi
	fi
	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
	exit ;;
    ia64:HP-UX:*:*)
	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
	echo ia64-hp-hpux${HPUX_REV}
	exit ;;
    3050*:HI-UX:*:*)
	eval $set_cc_for_build
	sed 's/^	//' << EOF >$dummy.c
	#include 
	int
	main ()
	{
	  long cpu = sysconf (_SC_CPU_VERSION);
	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
	     results, however.  */
	  if (CPU_IS_PA_RISC (cpu))
	    {
	      switch (cpu)
		{
		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
		  default: puts ("hppa-hitachi-hiuxwe2"); break;
		}
	    }
	  else if (CPU_IS_HP_MC68K (cpu))
	    puts ("m68k-hitachi-hiuxwe2");
	  else puts ("unknown-hitachi-hiuxwe2");
	  exit (0);
	}
EOF
	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
		{ echo "$SYSTEM_NAME"; exit; }
	echo unknown-hitachi-hiuxwe2
	exit ;;
    9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
	echo hppa1.1-hp-bsd
	exit ;;
    9000/8??:4.3bsd:*:*)
	echo hppa1.0-hp-bsd
	exit ;;
    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
	echo hppa1.0-hp-mpeix
	exit ;;
    hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
	echo hppa1.1-hp-osf
	exit ;;
    hp8??:OSF1:*:*)
	echo hppa1.0-hp-osf
	exit ;;
    i*86:OSF1:*:*)
	if [ -x /usr/sbin/sysversion ] ; then
	    echo ${UNAME_MACHINE}-unknown-osf1mk
	else
	    echo ${UNAME_MACHINE}-unknown-osf1
	fi
	exit ;;
    parisc*:Lites*:*:*)
	echo hppa1.1-hp-lites
	exit ;;
    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
	echo c1-convex-bsd
	exit ;;
    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
	if getsysinfo -f scalar_acc
	then echo c32-convex-bsd
	else echo c2-convex-bsd
	fi
	exit ;;
    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
	echo c34-convex-bsd
	exit ;;
    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
	echo c38-convex-bsd
	exit ;;
    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
	echo c4-convex-bsd
	exit ;;
    CRAY*Y-MP:*:*:*)
	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
	exit ;;
    CRAY*[A-Z]90:*:*:*)
	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
	      -e 's/\.[^.]*$/.X/'
	exit ;;
    CRAY*TS:*:*:*)
	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
	exit ;;
    CRAY*T3E:*:*:*)
	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
	exit ;;
    CRAY*SV1:*:*:*)
	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
	exit ;;
    *:UNICOS/mp:*:*)
	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
	exit ;;
    F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
	FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
	FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
	exit ;;
    5000:UNIX_System_V:4.*:*)
	FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
	FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
	exit ;;
    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
	exit ;;
    sparc*:BSD/OS:*:*)
	echo sparc-unknown-bsdi${UNAME_RELEASE}
	exit ;;
    *:BSD/OS:*:*)
	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
	exit ;;
    *:FreeBSD:*:*)
	UNAME_PROCESSOR=`/usr/bin/uname -p`
	case ${UNAME_PROCESSOR} in
	    amd64)
		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
	    *)
		echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
	esac
	exit ;;
    i*:CYGWIN*:*)
	echo ${UNAME_MACHINE}-pc-cygwin
	exit ;;
    *:MINGW64*:*)
	echo ${UNAME_MACHINE}-pc-mingw64
	exit ;;
    *:MINGW*:*)
	echo ${UNAME_MACHINE}-pc-mingw32
	exit ;;
    i*:MSYS*:*)
	echo ${UNAME_MACHINE}-pc-msys
	exit ;;
    i*:windows32*:*)
	# uname -m includes "-pc" on this system.
	echo ${UNAME_MACHINE}-mingw32
	exit ;;
    i*:PW*:*)
	echo ${UNAME_MACHINE}-pc-pw32
	exit ;;
    *:Interix*:*)
	case ${UNAME_MACHINE} in
	    x86)
		echo i586-pc-interix${UNAME_RELEASE}
		exit ;;
	    authenticamd | genuineintel | EM64T)
		echo x86_64-unknown-interix${UNAME_RELEASE}
		exit ;;
	    IA64)
		echo ia64-unknown-interix${UNAME_RELEASE}
		exit ;;
	esac ;;
    [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
	echo i${UNAME_MACHINE}-pc-mks
	exit ;;
    8664:Windows_NT:*)
	echo x86_64-pc-mks
	exit ;;
    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
	# How do we know it's Interix rather than the generic POSIX subsystem?
	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
	# UNAME_MACHINE based on the output of uname instead of i386?
	echo i586-pc-interix
	exit ;;
    i*:UWIN*:*)
	echo ${UNAME_MACHINE}-pc-uwin
	exit ;;
    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
	echo x86_64-unknown-cygwin
	exit ;;
    p*:CYGWIN*:*)
	echo powerpcle-unknown-cygwin
	exit ;;
    prep*:SunOS:5.*:*)
	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
	exit ;;
    *:GNU:*:*)
	# the GNU system
	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
	exit ;;
    *:GNU/*:*:*)
	# other systems with GNU libc and userland
	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
	exit ;;
    i*86:Minix:*:*)
	echo ${UNAME_MACHINE}-pc-minix
	exit ;;
    aarch64:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    aarch64_be:Linux:*:*)
	UNAME_MACHINE=aarch64_be
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    alpha:Linux:*:*)
	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
	  EV5)   UNAME_MACHINE=alphaev5 ;;
	  EV56)  UNAME_MACHINE=alphaev56 ;;
	  PCA56) UNAME_MACHINE=alphapca56 ;;
	  PCA57) UNAME_MACHINE=alphapca56 ;;
	  EV6)   UNAME_MACHINE=alphaev6 ;;
	  EV67)  UNAME_MACHINE=alphaev67 ;;
	  EV68*) UNAME_MACHINE=alphaev68 ;;
	esac
	objdump --private-headers /bin/sh | grep -q ld.so.1
	if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    arc:Linux:*:* | arceb:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    arm*:Linux:*:*)
	eval $set_cc_for_build
	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
	    | grep -q __ARM_EABI__
	then
	    echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	else
	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
		| grep -q __ARM_PCS_VFP
	    then
		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
	    else
		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
	    fi
	fi
	exit ;;
    avr32*:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    cris:Linux:*:*)
	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
	exit ;;
    crisv32:Linux:*:*)
	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
	exit ;;
    frv:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    hexagon:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    i*86:Linux:*:*)
	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
	exit ;;
    ia64:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    m32r*:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    m68*:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    mips:Linux:*:* | mips64:Linux:*:*)
	eval $set_cc_for_build
	sed 's/^	//' << EOF >$dummy.c
	#undef CPU
	#undef ${UNAME_MACHINE}
	#undef ${UNAME_MACHINE}el
	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
	CPU=${UNAME_MACHINE}el
	#else
	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
	CPU=${UNAME_MACHINE}
	#else
	CPU=
	#endif
	#endif
EOF
	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
	;;
    or1k:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    or32:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    padre:Linux:*:*)
	echo sparc-unknown-linux-${LIBC}
	exit ;;
    parisc64:Linux:*:* | hppa64:Linux:*:*)
	echo hppa64-unknown-linux-${LIBC}
	exit ;;
    parisc:Linux:*:* | hppa:Linux:*:*)
	# Look for CPU level
	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
	  PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
	  PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
	  *)    echo hppa-unknown-linux-${LIBC} ;;
	esac
	exit ;;
    ppc64:Linux:*:*)
	echo powerpc64-unknown-linux-${LIBC}
	exit ;;
    ppc:Linux:*:*)
	echo powerpc-unknown-linux-${LIBC}
	exit ;;
    ppc64le:Linux:*:*)
	echo powerpc64le-unknown-linux-${LIBC}
	exit ;;
    ppcle:Linux:*:*)
	echo powerpcle-unknown-linux-${LIBC}
	exit ;;
    s390:Linux:*:* | s390x:Linux:*:*)
	echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
	exit ;;
    sh64*:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    sh*:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    sparc:Linux:*:* | sparc64:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    tile*:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    vax:Linux:*:*)
	echo ${UNAME_MACHINE}-dec-linux-${LIBC}
	exit ;;
    x86_64:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    xtensa*:Linux:*:*)
	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
	exit ;;
    i*86:DYNIX/ptx:4*:*)
	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
	# earlier versions are messed up and put the nodename in both
	# sysname and nodename.
	echo i386-sequent-sysv4
	exit ;;
    i*86:UNIX_SV:4.2MP:2.*)
	# Unixware is an offshoot of SVR4, but it has its own version
	# number series starting with 2...
	# I am not positive that other SVR4 systems won't match this,
	# I just have to hope.  -- rms.
	# Use sysv4.2uw... so that sysv4* matches it.
	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
	exit ;;
    i*86:OS/2:*:*)
	# If we were able to find `uname', then EMX Unix compatibility
	# is probably installed.
	echo ${UNAME_MACHINE}-pc-os2-emx
	exit ;;
    i*86:XTS-300:*:STOP)
	echo ${UNAME_MACHINE}-unknown-stop
	exit ;;
    i*86:atheos:*:*)
	echo ${UNAME_MACHINE}-unknown-atheos
	exit ;;
    i*86:syllable:*:*)
	echo ${UNAME_MACHINE}-pc-syllable
	exit ;;
    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
	echo i386-unknown-lynxos${UNAME_RELEASE}
	exit ;;
    i*86:*DOS:*:*)
	echo ${UNAME_MACHINE}-pc-msdosdjgpp
	exit ;;
    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
	else
		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
	fi
	exit ;;
    i*86:*:5:[678]*)
	# UnixWare 7.x, OpenUNIX and OpenServer 6.
	case `/bin/uname -X | grep "^Machine"` in
	    *486*)	     UNAME_MACHINE=i486 ;;
	    *Pentium)	     UNAME_MACHINE=i586 ;;
	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
	esac
	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
	exit ;;
    i*86:*:3.2:*)
	if test -f /usr/options/cb.name; then
		UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then
		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
			&& UNAME_MACHINE=i586
		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
			&& UNAME_MACHINE=i686
		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
			&& UNAME_MACHINE=i686
		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
	else
		echo ${UNAME_MACHINE}-pc-sysv32
	fi
	exit ;;
    pc:*:*:*)
	# Left here for compatibility:
	# uname -m prints for DJGPP always 'pc', but it prints nothing about
	# the processor, so we play safe by assuming i586.
	# Note: whatever this is, it MUST be the same as what config.sub
	# prints for the "djgpp" host, or else GDB configury will decide that
	# this is a cross-build.
	echo i586-pc-msdosdjgpp
	exit ;;
    Intel:Mach:3*:*)
	echo i386-pc-mach3
	exit ;;
    paragon:*:*:*)
	echo i860-intel-osf1
	exit ;;
    i860:*:4.*:*) # i860-SVR4
	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
	else # Add other i860-SVR4 vendors below as they are discovered.
	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
	fi
	exit ;;
    mini*:CTIX:SYS*5:*)
	# "miniframe"
	echo m68010-convergent-sysv
	exit ;;
    mc68k:UNIX:SYSTEM5:3.51m)
	echo m68k-convergent-sysv
	exit ;;
    M680?0:D-NIX:5.3:*)
	echo m68k-diab-dnix
	exit ;;
    M68*:*:R3V[5678]*:*)
	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
    3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
	OS_REL=''
	test -r /etc/.relid \
	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
    3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
	  && { echo i486-ncr-sysv4; exit; } ;;
    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
	OS_REL='.3'
	test -r /etc/.relid \
	    && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
	    && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
	echo m68k-unknown-lynxos${UNAME_RELEASE}
	exit ;;
    mc68030:UNIX_System_V:4.*:*)
	echo m68k-atari-sysv4
	exit ;;
    TSUNAMI:LynxOS:2.*:*)
	echo sparc-unknown-lynxos${UNAME_RELEASE}
	exit ;;
    rs6000:LynxOS:2.*:*)
	echo rs6000-unknown-lynxos${UNAME_RELEASE}
	exit ;;
    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
	echo powerpc-unknown-lynxos${UNAME_RELEASE}
	exit ;;
    SM[BE]S:UNIX_SV:*:*)
	echo mips-dde-sysv${UNAME_RELEASE}
	exit ;;
    RM*:ReliantUNIX-*:*:*)
	echo mips-sni-sysv4
	exit ;;
    RM*:SINIX-*:*:*)
	echo mips-sni-sysv4
	exit ;;
    *:SINIX-*:*:*)
	if uname -p 2>/dev/null >/dev/null ; then
		UNAME_MACHINE=`(uname -p) 2>/dev/null`
		echo ${UNAME_MACHINE}-sni-sysv4
	else
		echo ns32k-sni-sysv
	fi
	exit ;;
    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
			# says 
	echo i586-unisys-sysv4
	exit ;;
    *:UNIX_System_V:4*:FTX*)
	# From Gerald Hewes .
	# How about differentiating between stratus architectures? -djm
	echo hppa1.1-stratus-sysv4
	exit ;;
    *:*:*:FTX*)
	# From seanf@swdc.stratus.com.
	echo i860-stratus-sysv4
	exit ;;
    i*86:VOS:*:*)
	# From Paul.Green@stratus.com.
	echo ${UNAME_MACHINE}-stratus-vos
	exit ;;
    *:VOS:*:*)
	# From Paul.Green@stratus.com.
	echo hppa1.1-stratus-vos
	exit ;;
    mc68*:A/UX:*:*)
	echo m68k-apple-aux${UNAME_RELEASE}
	exit ;;
    news*:NEWS-OS:6*:*)
	echo mips-sony-newsos6
	exit ;;
    R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
	if [ -d /usr/nec ]; then
		echo mips-nec-sysv${UNAME_RELEASE}
	else
		echo mips-unknown-sysv${UNAME_RELEASE}
	fi
	exit ;;
    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
	echo powerpc-be-beos
	exit ;;
    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
	echo powerpc-apple-beos
	exit ;;
    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
	echo i586-pc-beos
	exit ;;
    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
	echo i586-pc-haiku
	exit ;;
    x86_64:Haiku:*:*)
	echo x86_64-unknown-haiku
	exit ;;
    SX-4:SUPER-UX:*:*)
	echo sx4-nec-superux${UNAME_RELEASE}
	exit ;;
    SX-5:SUPER-UX:*:*)
	echo sx5-nec-superux${UNAME_RELEASE}
	exit ;;
    SX-6:SUPER-UX:*:*)
	echo sx6-nec-superux${UNAME_RELEASE}
	exit ;;
    SX-7:SUPER-UX:*:*)
	echo sx7-nec-superux${UNAME_RELEASE}
	exit ;;
    SX-8:SUPER-UX:*:*)
	echo sx8-nec-superux${UNAME_RELEASE}
	exit ;;
    SX-8R:SUPER-UX:*:*)
	echo sx8r-nec-superux${UNAME_RELEASE}
	exit ;;
    Power*:Rhapsody:*:*)
	echo powerpc-apple-rhapsody${UNAME_RELEASE}
	exit ;;
    *:Rhapsody:*:*)
	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
	exit ;;
    *:Darwin:*:*)
	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
	eval $set_cc_for_build
	if test "$UNAME_PROCESSOR" = unknown ; then
	    UNAME_PROCESSOR=powerpc
	fi
	if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
	    if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
		(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
		grep IS_64BIT_ARCH >/dev/null
	    then
		case $UNAME_PROCESSOR in
		    i386) UNAME_PROCESSOR=x86_64 ;;
		    powerpc) UNAME_PROCESSOR=powerpc64 ;;
		esac
	    fi
	fi
	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
	exit ;;
    *:procnto*:*:* | *:QNX:[0123456789]*:*)
	UNAME_PROCESSOR=`uname -p`
	if test "$UNAME_PROCESSOR" = "x86"; then
		UNAME_PROCESSOR=i386
		UNAME_MACHINE=pc
	fi
	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
	exit ;;
    *:QNX:*:4*)
	echo i386-pc-qnx
	exit ;;
    NEO-?:NONSTOP_KERNEL:*:*)
	echo neo-tandem-nsk${UNAME_RELEASE}
	exit ;;
    NSE-*:NONSTOP_KERNEL:*:*)
	echo nse-tandem-nsk${UNAME_RELEASE}
	exit ;;
    NSR-?:NONSTOP_KERNEL:*:*)
	echo nsr-tandem-nsk${UNAME_RELEASE}
	exit ;;
    *:NonStop-UX:*:*)
	echo mips-compaq-nonstopux
	exit ;;
    BS2000:POSIX*:*:*)
	echo bs2000-siemens-sysv
	exit ;;
    DS/*:UNIX_System_V:*:*)
	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
	exit ;;
    *:Plan9:*:*)
	# "uname -m" is not consistent, so use $cputype instead. 386
	# is converted to i386 for consistency with other x86
	# operating systems.
	if test "$cputype" = "386"; then
	    UNAME_MACHINE=i386
	else
	    UNAME_MACHINE="$cputype"
	fi
	echo ${UNAME_MACHINE}-unknown-plan9
	exit ;;
    *:TOPS-10:*:*)
	echo pdp10-unknown-tops10
	exit ;;
    *:TENEX:*:*)
	echo pdp10-unknown-tenex
	exit ;;
    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
	echo pdp10-dec-tops20
	exit ;;
    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
	echo pdp10-xkl-tops20
	exit ;;
    *:TOPS-20:*:*)
	echo pdp10-unknown-tops20
	exit ;;
    *:ITS:*:*)
	echo pdp10-unknown-its
	exit ;;
    SEI:*:*:SEIUX)
	echo mips-sei-seiux${UNAME_RELEASE}
	exit ;;
    *:DragonFly:*:*)
	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
	exit ;;
    *:*VMS:*:*)
	UNAME_MACHINE=`(uname -p) 2>/dev/null`
	case "${UNAME_MACHINE}" in
	    A*) echo alpha-dec-vms ; exit ;;
	    I*) echo ia64-dec-vms ; exit ;;
	    V*) echo vax-dec-vms ; exit ;;
	esac ;;
    *:XENIX:*:SysV)
	echo i386-pc-xenix
	exit ;;
    i*86:skyos:*:*)
	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
	exit ;;
    i*86:rdos:*:*)
	echo ${UNAME_MACHINE}-pc-rdos
	exit ;;
    i*86:AROS:*:*)
	echo ${UNAME_MACHINE}-pc-aros
	exit ;;
    x86_64:VMkernel:*:*)
	echo ${UNAME_MACHINE}-unknown-esx
	exit ;;
esac

eval $set_cc_for_build
cat >$dummy.c <
# include 
#endif
main ()
{
#if defined (sony)
#if defined (MIPSEB)
  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
     I don't know....  */
  printf ("mips-sony-bsd\n"); exit (0);
#else
#include 
  printf ("m68k-sony-newsos%s\n",
#ifdef NEWSOS4
	"4"
#else
	""
#endif
	); exit (0);
#endif
#endif

#if defined (__arm) && defined (__acorn) && defined (__unix)
  printf ("arm-acorn-riscix\n"); exit (0);
#endif

#if defined (hp300) && !defined (hpux)
  printf ("m68k-hp-bsd\n"); exit (0);
#endif

#if defined (NeXT)
#if !defined (__ARCHITECTURE__)
#define __ARCHITECTURE__ "m68k"
#endif
  int version;
  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
  if (version < 4)
    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
  else
    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
  exit (0);
#endif

#if defined (MULTIMAX) || defined (n16)
#if defined (UMAXV)
  printf ("ns32k-encore-sysv\n"); exit (0);
#else
#if defined (CMU)
  printf ("ns32k-encore-mach\n"); exit (0);
#else
  printf ("ns32k-encore-bsd\n"); exit (0);
#endif
#endif
#endif

#if defined (__386BSD__)
  printf ("i386-pc-bsd\n"); exit (0);
#endif

#if defined (sequent)
#if defined (i386)
  printf ("i386-sequent-dynix\n"); exit (0);
#endif
#if defined (ns32000)
  printf ("ns32k-sequent-dynix\n"); exit (0);
#endif
#endif

#if defined (_SEQUENT_)
    struct utsname un;

    uname(&un);

    if (strncmp(un.version, "V2", 2) == 0) {
	printf ("i386-sequent-ptx2\n"); exit (0);
    }
    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
	printf ("i386-sequent-ptx1\n"); exit (0);
    }
    printf ("i386-sequent-ptx\n"); exit (0);

#endif

#if defined (vax)
# if !defined (ultrix)
#  include 
#  if defined (BSD)
#   if BSD == 43
      printf ("vax-dec-bsd4.3\n"); exit (0);
#   else
#    if BSD == 199006
      printf ("vax-dec-bsd4.3reno\n"); exit (0);
#    else
      printf ("vax-dec-bsd\n"); exit (0);
#    endif
#   endif
#  else
    printf ("vax-dec-bsd\n"); exit (0);
#  endif
# else
    printf ("vax-dec-ultrix\n"); exit (0);
# endif
#endif

#if defined (alliant) && defined (i860)
  printf ("i860-alliant-bsd\n"); exit (0);
#endif

  exit (1);
}
EOF

$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
	{ echo "$SYSTEM_NAME"; exit; }

# Apollos put the system type in the environment.

test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }

# Convex versions that predate uname can use getsysinfo(1)

if [ -x /usr/convex/getsysinfo ]
then
    case `getsysinfo -f cpu_type` in
    c1*)
	echo c1-convex-bsd
	exit ;;
    c2*)
	if getsysinfo -f scalar_acc
	then echo c32-convex-bsd
	else echo c2-convex-bsd
	fi
	exit ;;
    c34*)
	echo c34-convex-bsd
	exit ;;
    c38*)
	echo c38-convex-bsd
	exit ;;
    c4*)
	echo c4-convex-bsd
	exit ;;
    esac
fi

cat >&2 < in order to provide the needed
information to handle your system.

config.guess timestamp = $timestamp

uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`

/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`

hostinfo               = `(hostinfo) 2>/dev/null`
/bin/universe          = `(/bin/universe) 2>/dev/null`
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
/bin/arch              = `(/bin/arch) 2>/dev/null`
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`

UNAME_MACHINE = ${UNAME_MACHINE}
UNAME_RELEASE = ${UNAME_RELEASE}
UNAME_SYSTEM  = ${UNAME_SYSTEM}
UNAME_VERSION = ${UNAME_VERSION}
EOF

exit 1

# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%:y-%02m-%02d"
# time-stamp-end: "'"
# End:
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/config.sub0000755000175000017500000010531513010376370024310 0ustar  zoncazonca00000000000000#! /bin/sh
# Configuration validation subroutine script.
#   Copyright 1992-2013 Free Software Foundation, Inc.

timestamp='2013-04-24'

# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see .
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program.  This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").


# Please send patches with a ChangeLog entry to config-patches@gnu.org.
#
# Configuration subroutine to validate and canonicalize a configuration type.
# Supply the specified configuration type as an argument.
# If it is invalid, we print an error message on stderr and exit with code 1.
# Otherwise, we print the canonical config type on stdout and succeed.

# You can get the latest version of this script from:
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD

# This file is supposed to be the same for all GNU packages
# and recognize all the CPU types, system types and aliases
# that are meaningful with *any* GNU software.
# Each package is responsible for reporting which valid configurations
# it does not support.  The user should be able to distinguish
# a failure to support a valid configuration from a meaningless
# configuration.

# The goal of this file is to map all the various variations of a given
# machine specification into a single specification in the form:
#	CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
# or in some cases, the newer four-part form:
#	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
# It is wrong to echo any other type of specification.

me=`echo "$0" | sed -e 's,.*/,,'`

usage="\
Usage: $0 [OPTION] CPU-MFR-OPSYS
       $0 [OPTION] ALIAS

Canonicalize a configuration name.

Operation modes:
  -h, --help         print this help, then exit
  -t, --time-stamp   print date of last modification, then exit
  -v, --version      print version number, then exit

Report bugs and patches to ."

version="\
GNU config.sub ($timestamp)

Copyright 1992-2013 Free Software Foundation, Inc.

This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."

help="
Try \`$me --help' for more information."

# Parse command line
while test $# -gt 0 ; do
  case $1 in
    --time-stamp | --time* | -t )
       echo "$timestamp" ; exit ;;
    --version | -v )
       echo "$version" ; exit ;;
    --help | --h* | -h )
       echo "$usage"; exit ;;
    -- )     # Stop option processing
       shift; break ;;
    - )	# Use stdin as input.
       break ;;
    -* )
       echo "$me: invalid option $1$help"
       exit 1 ;;

    *local*)
       # First pass through any local machine types.
       echo $1
       exit ;;

    * )
       break ;;
  esac
done

case $# in
 0) echo "$me: missing argument$help" >&2
    exit 1;;
 1) ;;
 *) echo "$me: too many arguments$help" >&2
    exit 1;;
esac

# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
# Here we must recognize all the valid KERNEL-OS combinations.
maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
case $maybe_os in
  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
  knetbsd*-gnu* | netbsd*-gnu* | \
  kopensolaris*-gnu* | \
  storm-chaos* | os2-emx* | rtmk-nova*)
    os=-$maybe_os
    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
    ;;
  android-linux)
    os=-linux-android
    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
    ;;
  *)
    basic_machine=`echo $1 | sed 's/-[^-]*$//'`
    if [ $basic_machine != $1 ]
    then os=`echo $1 | sed 's/.*-/-/'`
    else os=; fi
    ;;
esac

### Let's recognize common machines as not being operating systems so
### that things like config.sub decstation-3100 work.  We also
### recognize some manufacturers as not being operating systems, so we
### can provide default operating systems below.
case $os in
	-sun*os*)
		# Prevent following clause from handling this invalid input.
		;;
	-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
	-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
	-unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
	-apple | -axis | -knuth | -cray | -microblaze*)
		os=
		basic_machine=$1
		;;
	-bluegene*)
		os=-cnk
		;;
	-sim | -cisco | -oki | -wec | -winbond)
		os=
		basic_machine=$1
		;;
	-scout)
		;;
	-wrs)
		os=-vxworks
		basic_machine=$1
		;;
	-chorusos*)
		os=-chorusos
		basic_machine=$1
		;;
	-chorusrdb)
		os=-chorusrdb
		basic_machine=$1
		;;
	-hiux*)
		os=-hiuxwe2
		;;
	-sco6)
		os=-sco5v6
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-sco5)
		os=-sco3.2v5
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-sco4)
		os=-sco3.2v4
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-sco3.2.[4-9]*)
		os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-sco3.2v[4-9]*)
		# Don't forget version if it is 3.2v4 or newer.
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-sco5v6*)
		# Don't forget version if it is 3.2v4 or newer.
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-sco*)
		os=-sco3.2v2
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-udk*)
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-isc)
		os=-isc2.2
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-clix*)
		basic_machine=clipper-intergraph
		;;
	-isc*)
		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
		;;
	-lynx*178)
		os=-lynxos178
		;;
	-lynx*5)
		os=-lynxos5
		;;
	-lynx*)
		os=-lynxos
		;;
	-ptx*)
		basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
		;;
	-windowsnt*)
		os=`echo $os | sed -e 's/windowsnt/winnt/'`
		;;
	-psos*)
		os=-psos
		;;
	-mint | -mint[0-9]*)
		basic_machine=m68k-atari
		os=-mint
		;;
esac

# Decode aliases for certain CPU-COMPANY combinations.
case $basic_machine in
	# Recognize the basic CPU types without company name.
	# Some are omitted here because they have special meanings below.
	1750a | 580 \
	| a29k \
	| aarch64 | aarch64_be \
	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
	| am33_2.0 \
	| arc | arceb \
	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
	| avr | avr32 \
	| be32 | be64 \
	| bfin \
	| c4x | clipper \
	| d10v | d30v | dlx | dsp16xx \
	| epiphany \
	| fido | fr30 | frv \
	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
	| hexagon \
	| i370 | i860 | i960 | ia64 \
	| ip2k | iq2000 \
	| le32 | le64 \
	| lm32 \
	| m32c | m32r | m32rle | m68000 | m68k | m88k \
	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
	| mips | mipsbe | mipseb | mipsel | mipsle \
	| mips16 \
	| mips64 | mips64el \
	| mips64octeon | mips64octeonel \
	| mips64orion | mips64orionel \
	| mips64r5900 | mips64r5900el \
	| mips64vr | mips64vrel \
	| mips64vr4100 | mips64vr4100el \
	| mips64vr4300 | mips64vr4300el \
	| mips64vr5000 | mips64vr5000el \
	| mips64vr5900 | mips64vr5900el \
	| mipsisa32 | mipsisa32el \
	| mipsisa32r2 | mipsisa32r2el \
	| mipsisa64 | mipsisa64el \
	| mipsisa64r2 | mipsisa64r2el \
	| mipsisa64sb1 | mipsisa64sb1el \
	| mipsisa64sr71k | mipsisa64sr71kel \
	| mipsr5900 | mipsr5900el \
	| mipstx39 | mipstx39el \
	| mn10200 | mn10300 \
	| moxie \
	| mt \
	| msp430 \
	| nds32 | nds32le | nds32be \
	| nios | nios2 | nios2eb | nios2el \
	| ns16k | ns32k \
	| open8 \
	| or1k | or32 \
	| pdp10 | pdp11 | pj | pjl \
	| powerpc | powerpc64 | powerpc64le | powerpcle \
	| pyramid \
	| rl78 | rx \
	| score \
	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
	| sh64 | sh64le \
	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
	| spu \
	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
	| ubicom32 \
	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
	| we32k \
	| x86 | xc16x | xstormy16 | xtensa \
	| z8k | z80)
		basic_machine=$basic_machine-unknown
		;;
	c54x)
		basic_machine=tic54x-unknown
		;;
	c55x)
		basic_machine=tic55x-unknown
		;;
	c6x)
		basic_machine=tic6x-unknown
		;;
	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip)
		basic_machine=$basic_machine-unknown
		os=-none
		;;
	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
		;;
	ms1)
		basic_machine=mt-unknown
		;;

	strongarm | thumb | xscale)
		basic_machine=arm-unknown
		;;
	xgate)
		basic_machine=$basic_machine-unknown
		os=-none
		;;
	xscaleeb)
		basic_machine=armeb-unknown
		;;

	xscaleel)
		basic_machine=armel-unknown
		;;

	# We use `pc' rather than `unknown'
	# because (1) that's what they normally are, and
	# (2) the word "unknown" tends to confuse beginning users.
	i*86 | x86_64)
	  basic_machine=$basic_machine-pc
	  ;;
	# Object if more than one company name word.
	*-*-*)
		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
		exit 1
		;;
	# Recognize the basic CPU types with company name.
	580-* \
	| a29k-* \
	| aarch64-* | aarch64_be-* \
	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
	| avr-* | avr32-* \
	| be32-* | be64-* \
	| bfin-* | bs2000-* \
	| c[123]* | c30-* | [cjt]90-* | c4x-* \
	| clipper-* | craynv-* | cydra-* \
	| d10v-* | d30v-* | dlx-* \
	| elxsi-* \
	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
	| h8300-* | h8500-* \
	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
	| hexagon-* \
	| i*86-* | i860-* | i960-* | ia64-* \
	| ip2k-* | iq2000-* \
	| le32-* | le64-* \
	| lm32-* \
	| m32c-* | m32r-* | m32rle-* \
	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
	| microblaze-* | microblazeel-* \
	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
	| mips16-* \
	| mips64-* | mips64el-* \
	| mips64octeon-* | mips64octeonel-* \
	| mips64orion-* | mips64orionel-* \
	| mips64r5900-* | mips64r5900el-* \
	| mips64vr-* | mips64vrel-* \
	| mips64vr4100-* | mips64vr4100el-* \
	| mips64vr4300-* | mips64vr4300el-* \
	| mips64vr5000-* | mips64vr5000el-* \
	| mips64vr5900-* | mips64vr5900el-* \
	| mipsisa32-* | mipsisa32el-* \
	| mipsisa32r2-* | mipsisa32r2el-* \
	| mipsisa64-* | mipsisa64el-* \
	| mipsisa64r2-* | mipsisa64r2el-* \
	| mipsisa64sb1-* | mipsisa64sb1el-* \
	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
	| mipsr5900-* | mipsr5900el-* \
	| mipstx39-* | mipstx39el-* \
	| mmix-* \
	| mt-* \
	| msp430-* \
	| nds32-* | nds32le-* | nds32be-* \
	| nios-* | nios2-* | nios2eb-* | nios2el-* \
	| none-* | np1-* | ns16k-* | ns32k-* \
	| open8-* \
	| orion-* \
	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
	| pyramid-* \
	| rl78-* | romp-* | rs6000-* | rx-* \
	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
	| sparclite-* \
	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \
	| tahoe-* \
	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
	| tile*-* \
	| tron-* \
	| ubicom32-* \
	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
	| vax-* \
	| we32k-* \
	| x86-* | x86_64-* | xc16x-* | xps100-* \
	| xstormy16-* | xtensa*-* \
	| ymp-* \
	| z8k-* | z80-*)
		;;
	# Recognize the basic CPU types without company name, with glob match.
	xtensa*)
		basic_machine=$basic_machine-unknown
		;;
	# Recognize the various machine names and aliases which stand
	# for a CPU type and a company and sometimes even an OS.
	386bsd)
		basic_machine=i386-unknown
		os=-bsd
		;;
	3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
		basic_machine=m68000-att
		;;
	3b*)
		basic_machine=we32k-att
		;;
	a29khif)
		basic_machine=a29k-amd
		os=-udi
		;;
	abacus)
		basic_machine=abacus-unknown
		;;
	adobe68k)
		basic_machine=m68010-adobe
		os=-scout
		;;
	alliant | fx80)
		basic_machine=fx80-alliant
		;;
	altos | altos3068)
		basic_machine=m68k-altos
		;;
	am29k)
		basic_machine=a29k-none
		os=-bsd
		;;
	amd64)
		basic_machine=x86_64-pc
		;;
	amd64-*)
		basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	amdahl)
		basic_machine=580-amdahl
		os=-sysv
		;;
	amiga | amiga-*)
		basic_machine=m68k-unknown
		;;
	amigaos | amigados)
		basic_machine=m68k-unknown
		os=-amigaos
		;;
	amigaunix | amix)
		basic_machine=m68k-unknown
		os=-sysv4
		;;
	apollo68)
		basic_machine=m68k-apollo
		os=-sysv
		;;
	apollo68bsd)
		basic_machine=m68k-apollo
		os=-bsd
		;;
	aros)
		basic_machine=i386-pc
		os=-aros
		;;
	aux)
		basic_machine=m68k-apple
		os=-aux
		;;
	balance)
		basic_machine=ns32k-sequent
		os=-dynix
		;;
	blackfin)
		basic_machine=bfin-unknown
		os=-linux
		;;
	blackfin-*)
		basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
		os=-linux
		;;
	bluegene*)
		basic_machine=powerpc-ibm
		os=-cnk
		;;
	c54x-*)
		basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	c55x-*)
		basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	c6x-*)
		basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	c90)
		basic_machine=c90-cray
		os=-unicos
		;;
	cegcc)
		basic_machine=arm-unknown
		os=-cegcc
		;;
	convex-c1)
		basic_machine=c1-convex
		os=-bsd
		;;
	convex-c2)
		basic_machine=c2-convex
		os=-bsd
		;;
	convex-c32)
		basic_machine=c32-convex
		os=-bsd
		;;
	convex-c34)
		basic_machine=c34-convex
		os=-bsd
		;;
	convex-c38)
		basic_machine=c38-convex
		os=-bsd
		;;
	cray | j90)
		basic_machine=j90-cray
		os=-unicos
		;;
	craynv)
		basic_machine=craynv-cray
		os=-unicosmp
		;;
	cr16 | cr16-*)
		basic_machine=cr16-unknown
		os=-elf
		;;
	crds | unos)
		basic_machine=m68k-crds
		;;
	crisv32 | crisv32-* | etraxfs*)
		basic_machine=crisv32-axis
		;;
	cris | cris-* | etrax*)
		basic_machine=cris-axis
		;;
	crx)
		basic_machine=crx-unknown
		os=-elf
		;;
	da30 | da30-*)
		basic_machine=m68k-da30
		;;
	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
		basic_machine=mips-dec
		;;
	decsystem10* | dec10*)
		basic_machine=pdp10-dec
		os=-tops10
		;;
	decsystem20* | dec20*)
		basic_machine=pdp10-dec
		os=-tops20
		;;
	delta | 3300 | motorola-3300 | motorola-delta \
	      | 3300-motorola | delta-motorola)
		basic_machine=m68k-motorola
		;;
	delta88)
		basic_machine=m88k-motorola
		os=-sysv3
		;;
	dicos)
		basic_machine=i686-pc
		os=-dicos
		;;
	djgpp)
		basic_machine=i586-pc
		os=-msdosdjgpp
		;;
	dpx20 | dpx20-*)
		basic_machine=rs6000-bull
		os=-bosx
		;;
	dpx2* | dpx2*-bull)
		basic_machine=m68k-bull
		os=-sysv3
		;;
	ebmon29k)
		basic_machine=a29k-amd
		os=-ebmon
		;;
	elxsi)
		basic_machine=elxsi-elxsi
		os=-bsd
		;;
	encore | umax | mmax)
		basic_machine=ns32k-encore
		;;
	es1800 | OSE68k | ose68k | ose | OSE)
		basic_machine=m68k-ericsson
		os=-ose
		;;
	fx2800)
		basic_machine=i860-alliant
		;;
	genix)
		basic_machine=ns32k-ns
		;;
	gmicro)
		basic_machine=tron-gmicro
		os=-sysv
		;;
	go32)
		basic_machine=i386-pc
		os=-go32
		;;
	h3050r* | hiux*)
		basic_machine=hppa1.1-hitachi
		os=-hiuxwe2
		;;
	h8300hms)
		basic_machine=h8300-hitachi
		os=-hms
		;;
	h8300xray)
		basic_machine=h8300-hitachi
		os=-xray
		;;
	h8500hms)
		basic_machine=h8500-hitachi
		os=-hms
		;;
	harris)
		basic_machine=m88k-harris
		os=-sysv3
		;;
	hp300-*)
		basic_machine=m68k-hp
		;;
	hp300bsd)
		basic_machine=m68k-hp
		os=-bsd
		;;
	hp300hpux)
		basic_machine=m68k-hp
		os=-hpux
		;;
	hp3k9[0-9][0-9] | hp9[0-9][0-9])
		basic_machine=hppa1.0-hp
		;;
	hp9k2[0-9][0-9] | hp9k31[0-9])
		basic_machine=m68000-hp
		;;
	hp9k3[2-9][0-9])
		basic_machine=m68k-hp
		;;
	hp9k6[0-9][0-9] | hp6[0-9][0-9])
		basic_machine=hppa1.0-hp
		;;
	hp9k7[0-79][0-9] | hp7[0-79][0-9])
		basic_machine=hppa1.1-hp
		;;
	hp9k78[0-9] | hp78[0-9])
		# FIXME: really hppa2.0-hp
		basic_machine=hppa1.1-hp
		;;
	hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
		# FIXME: really hppa2.0-hp
		basic_machine=hppa1.1-hp
		;;
	hp9k8[0-9][13679] | hp8[0-9][13679])
		basic_machine=hppa1.1-hp
		;;
	hp9k8[0-9][0-9] | hp8[0-9][0-9])
		basic_machine=hppa1.0-hp
		;;
	hppa-next)
		os=-nextstep3
		;;
	hppaosf)
		basic_machine=hppa1.1-hp
		os=-osf
		;;
	hppro)
		basic_machine=hppa1.1-hp
		os=-proelf
		;;
	i370-ibm* | ibm*)
		basic_machine=i370-ibm
		;;
	i*86v32)
		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
		os=-sysv32
		;;
	i*86v4*)
		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
		os=-sysv4
		;;
	i*86v)
		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
		os=-sysv
		;;
	i*86sol2)
		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
		os=-solaris2
		;;
	i386mach)
		basic_machine=i386-mach
		os=-mach
		;;
	i386-vsta | vsta)
		basic_machine=i386-unknown
		os=-vsta
		;;
	iris | iris4d)
		basic_machine=mips-sgi
		case $os in
		    -irix*)
			;;
		    *)
			os=-irix4
			;;
		esac
		;;
	isi68 | isi)
		basic_machine=m68k-isi
		os=-sysv
		;;
	m68knommu)
		basic_machine=m68k-unknown
		os=-linux
		;;
	m68knommu-*)
		basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
		os=-linux
		;;
	m88k-omron*)
		basic_machine=m88k-omron
		;;
	magnum | m3230)
		basic_machine=mips-mips
		os=-sysv
		;;
	merlin)
		basic_machine=ns32k-utek
		os=-sysv
		;;
	microblaze*)
		basic_machine=microblaze-xilinx
		;;
	mingw64)
		basic_machine=x86_64-pc
		os=-mingw64
		;;
	mingw32)
		basic_machine=i386-pc
		os=-mingw32
		;;
	mingw32ce)
		basic_machine=arm-unknown
		os=-mingw32ce
		;;
	miniframe)
		basic_machine=m68000-convergent
		;;
	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
		basic_machine=m68k-atari
		os=-mint
		;;
	mips3*-*)
		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
		;;
	mips3*)
		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
		;;
	monitor)
		basic_machine=m68k-rom68k
		os=-coff
		;;
	morphos)
		basic_machine=powerpc-unknown
		os=-morphos
		;;
	msdos)
		basic_machine=i386-pc
		os=-msdos
		;;
	ms1-*)
		basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
		;;
	msys)
		basic_machine=i386-pc
		os=-msys
		;;
	mvs)
		basic_machine=i370-ibm
		os=-mvs
		;;
	nacl)
		basic_machine=le32-unknown
		os=-nacl
		;;
	ncr3000)
		basic_machine=i486-ncr
		os=-sysv4
		;;
	netbsd386)
		basic_machine=i386-unknown
		os=-netbsd
		;;
	netwinder)
		basic_machine=armv4l-rebel
		os=-linux
		;;
	news | news700 | news800 | news900)
		basic_machine=m68k-sony
		os=-newsos
		;;
	news1000)
		basic_machine=m68030-sony
		os=-newsos
		;;
	news-3600 | risc-news)
		basic_machine=mips-sony
		os=-newsos
		;;
	necv70)
		basic_machine=v70-nec
		os=-sysv
		;;
	next | m*-next )
		basic_machine=m68k-next
		case $os in
		    -nextstep* )
			;;
		    -ns2*)
		      os=-nextstep2
			;;
		    *)
		      os=-nextstep3
			;;
		esac
		;;
	nh3000)
		basic_machine=m68k-harris
		os=-cxux
		;;
	nh[45]000)
		basic_machine=m88k-harris
		os=-cxux
		;;
	nindy960)
		basic_machine=i960-intel
		os=-nindy
		;;
	mon960)
		basic_machine=i960-intel
		os=-mon960
		;;
	nonstopux)
		basic_machine=mips-compaq
		os=-nonstopux
		;;
	np1)
		basic_machine=np1-gould
		;;
	neo-tandem)
		basic_machine=neo-tandem
		;;
	nse-tandem)
		basic_machine=nse-tandem
		;;
	nsr-tandem)
		basic_machine=nsr-tandem
		;;
	op50n-* | op60c-*)
		basic_machine=hppa1.1-oki
		os=-proelf
		;;
	openrisc | openrisc-*)
		basic_machine=or32-unknown
		;;
	os400)
		basic_machine=powerpc-ibm
		os=-os400
		;;
	OSE68000 | ose68000)
		basic_machine=m68000-ericsson
		os=-ose
		;;
	os68k)
		basic_machine=m68k-none
		os=-os68k
		;;
	pa-hitachi)
		basic_machine=hppa1.1-hitachi
		os=-hiuxwe2
		;;
	paragon)
		basic_machine=i860-intel
		os=-osf
		;;
	parisc)
		basic_machine=hppa-unknown
		os=-linux
		;;
	parisc-*)
		basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
		os=-linux
		;;
	pbd)
		basic_machine=sparc-tti
		;;
	pbb)
		basic_machine=m68k-tti
		;;
	pc532 | pc532-*)
		basic_machine=ns32k-pc532
		;;
	pc98)
		basic_machine=i386-pc
		;;
	pc98-*)
		basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	pentium | p5 | k5 | k6 | nexgen | viac3)
		basic_machine=i586-pc
		;;
	pentiumpro | p6 | 6x86 | athlon | athlon_*)
		basic_machine=i686-pc
		;;
	pentiumii | pentium2 | pentiumiii | pentium3)
		basic_machine=i686-pc
		;;
	pentium4)
		basic_machine=i786-pc
		;;
	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	pentiumpro-* | p6-* | 6x86-* | athlon-*)
		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	pentium4-*)
		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	pn)
		basic_machine=pn-gould
		;;
	power)	basic_machine=power-ibm
		;;
	ppc | ppcbe)	basic_machine=powerpc-unknown
		;;
	ppc-* | ppcbe-*)
		basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	ppcle | powerpclittle | ppc-le | powerpc-little)
		basic_machine=powerpcle-unknown
		;;
	ppcle-* | powerpclittle-*)
		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	ppc64)	basic_machine=powerpc64-unknown
		;;
	ppc64-* | ppc64p7-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	ppc64le | powerpc64little | ppc64-le | powerpc64-little)
		basic_machine=powerpc64le-unknown
		;;
	ppc64le-* | powerpc64little-*)
		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	ps2)
		basic_machine=i386-ibm
		;;
	pw32)
		basic_machine=i586-unknown
		os=-pw32
		;;
	rdos | rdos64)
		basic_machine=x86_64-pc
		os=-rdos
		;;
	rdos32)
		basic_machine=i386-pc
		os=-rdos
		;;
	rom68k)
		basic_machine=m68k-rom68k
		os=-coff
		;;
	rm[46]00)
		basic_machine=mips-siemens
		;;
	rtpc | rtpc-*)
		basic_machine=romp-ibm
		;;
	s390 | s390-*)
		basic_machine=s390-ibm
		;;
	s390x | s390x-*)
		basic_machine=s390x-ibm
		;;
	sa29200)
		basic_machine=a29k-amd
		os=-udi
		;;
	sb1)
		basic_machine=mipsisa64sb1-unknown
		;;
	sb1el)
		basic_machine=mipsisa64sb1el-unknown
		;;
	sde)
		basic_machine=mipsisa32-sde
		os=-elf
		;;
	sei)
		basic_machine=mips-sei
		os=-seiux
		;;
	sequent)
		basic_machine=i386-sequent
		;;
	sh)
		basic_machine=sh-hitachi
		os=-hms
		;;
	sh5el)
		basic_machine=sh5le-unknown
		;;
	sh64)
		basic_machine=sh64-unknown
		;;
	sparclite-wrs | simso-wrs)
		basic_machine=sparclite-wrs
		os=-vxworks
		;;
	sps7)
		basic_machine=m68k-bull
		os=-sysv2
		;;
	spur)
		basic_machine=spur-unknown
		;;
	st2000)
		basic_machine=m68k-tandem
		;;
	stratus)
		basic_machine=i860-stratus
		os=-sysv4
		;;
	strongarm-* | thumb-*)
		basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
		;;
	sun2)
		basic_machine=m68000-sun
		;;
	sun2os3)
		basic_machine=m68000-sun
		os=-sunos3
		;;
	sun2os4)
		basic_machine=m68000-sun
		os=-sunos4
		;;
	sun3os3)
		basic_machine=m68k-sun
		os=-sunos3
		;;
	sun3os4)
		basic_machine=m68k-sun
		os=-sunos4
		;;
	sun4os3)
		basic_machine=sparc-sun
		os=-sunos3
		;;
	sun4os4)
		basic_machine=sparc-sun
		os=-sunos4
		;;
	sun4sol2)
		basic_machine=sparc-sun
		os=-solaris2
		;;
	sun3 | sun3-*)
		basic_machine=m68k-sun
		;;
	sun4)
		basic_machine=sparc-sun
		;;
	sun386 | sun386i | roadrunner)
		basic_machine=i386-sun
		;;
	sv1)
		basic_machine=sv1-cray
		os=-unicos
		;;
	symmetry)
		basic_machine=i386-sequent
		os=-dynix
		;;
	t3e)
		basic_machine=alphaev5-cray
		os=-unicos
		;;
	t90)
		basic_machine=t90-cray
		os=-unicos
		;;
	tile*)
		basic_machine=$basic_machine-unknown
		os=-linux-gnu
		;;
	tx39)
		basic_machine=mipstx39-unknown
		;;
	tx39el)
		basic_machine=mipstx39el-unknown
		;;
	toad1)
		basic_machine=pdp10-xkl
		os=-tops20
		;;
	tower | tower-32)
		basic_machine=m68k-ncr
		;;
	tpf)
		basic_machine=s390x-ibm
		os=-tpf
		;;
	udi29k)
		basic_machine=a29k-amd
		os=-udi
		;;
	ultra3)
		basic_machine=a29k-nyu
		os=-sym1
		;;
	v810 | necv810)
		basic_machine=v810-nec
		os=-none
		;;
	vaxv)
		basic_machine=vax-dec
		os=-sysv
		;;
	vms)
		basic_machine=vax-dec
		os=-vms
		;;
	vpp*|vx|vx-*)
		basic_machine=f301-fujitsu
		;;
	vxworks960)
		basic_machine=i960-wrs
		os=-vxworks
		;;
	vxworks68)
		basic_machine=m68k-wrs
		os=-vxworks
		;;
	vxworks29k)
		basic_machine=a29k-wrs
		os=-vxworks
		;;
	w65*)
		basic_machine=w65-wdc
		os=-none
		;;
	w89k-*)
		basic_machine=hppa1.1-winbond
		os=-proelf
		;;
	xbox)
		basic_machine=i686-pc
		os=-mingw32
		;;
	xps | xps100)
		basic_machine=xps100-honeywell
		;;
	xscale-* | xscalee[bl]-*)
		basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
		;;
	ymp)
		basic_machine=ymp-cray
		os=-unicos
		;;
	z8k-*-coff)
		basic_machine=z8k-unknown
		os=-sim
		;;
	z80-*-coff)
		basic_machine=z80-unknown
		os=-sim
		;;
	none)
		basic_machine=none-none
		os=-none
		;;

# Here we handle the default manufacturer of certain CPU types.  It is in
# some cases the only manufacturer, in others, it is the most popular.
	w89k)
		basic_machine=hppa1.1-winbond
		;;
	op50n)
		basic_machine=hppa1.1-oki
		;;
	op60c)
		basic_machine=hppa1.1-oki
		;;
	romp)
		basic_machine=romp-ibm
		;;
	mmix)
		basic_machine=mmix-knuth
		;;
	rs6000)
		basic_machine=rs6000-ibm
		;;
	vax)
		basic_machine=vax-dec
		;;
	pdp10)
		# there are many clones, so DEC is not a safe bet
		basic_machine=pdp10-unknown
		;;
	pdp11)
		basic_machine=pdp11-dec
		;;
	we32k)
		basic_machine=we32k-att
		;;
	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
		basic_machine=sh-unknown
		;;
	sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
		basic_machine=sparc-sun
		;;
	cydra)
		basic_machine=cydra-cydrome
		;;
	orion)
		basic_machine=orion-highlevel
		;;
	orion105)
		basic_machine=clipper-highlevel
		;;
	mac | mpw | mac-mpw)
		basic_machine=m68k-apple
		;;
	pmac | pmac-mpw)
		basic_machine=powerpc-apple
		;;
	*-unknown)
		# Make sure to match an already-canonicalized machine name.
		;;
	*)
		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
		exit 1
		;;
esac

# Here we canonicalize certain aliases for manufacturers.
case $basic_machine in
	*-digital*)
		basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
		;;
	*-commodore*)
		basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
		;;
	*)
		;;
esac

# Decode manufacturer-specific aliases for certain operating systems.

if [ x"$os" != x"" ]
then
case $os in
	# First match some system type aliases
	# that might get confused with valid system types.
	# -solaris* is a basic system type, with this one exception.
	-auroraux)
		os=-auroraux
		;;
	-solaris1 | -solaris1.*)
		os=`echo $os | sed -e 's|solaris1|sunos4|'`
		;;
	-solaris)
		os=-solaris2
		;;
	-svr4*)
		os=-sysv4
		;;
	-unixware*)
		os=-sysv4.2uw
		;;
	-gnu/linux*)
		os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
		;;
	# First accept the basic system types.
	# The portable systems comes first.
	# Each alternative MUST END IN A *, to match a version number.
	# -sysv* is not here because it comes later, after sysvr4.
	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
	      | -sym* | -kopensolaris* | -plan9* \
	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
	      | -aos* | -aros* \
	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
	      | -bitrig* | -openbsd* | -solidbsd* \
	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
	      | -chorusos* | -chorusrdb* | -cegcc* \
	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
	      | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
	      | -uxpv* | -beos* | -mpeix* | -udk* \
	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*)
	# Remember, each alternative MUST END IN *, to match a version number.
		;;
	-qnx*)
		case $basic_machine in
		    x86-* | i*86-*)
			;;
		    *)
			os=-nto$os
			;;
		esac
		;;
	-nto-qnx*)
		;;
	-nto*)
		os=`echo $os | sed -e 's|nto|nto-qnx|'`
		;;
	-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
	      | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
		;;
	-mac*)
		os=`echo $os | sed -e 's|mac|macos|'`
		;;
	-linux-dietlibc)
		os=-linux-dietlibc
		;;
	-linux*)
		os=`echo $os | sed -e 's|linux|linux-gnu|'`
		;;
	-sunos5*)
		os=`echo $os | sed -e 's|sunos5|solaris2|'`
		;;
	-sunos6*)
		os=`echo $os | sed -e 's|sunos6|solaris3|'`
		;;
	-opened*)
		os=-openedition
		;;
	-os400*)
		os=-os400
		;;
	-wince*)
		os=-wince
		;;
	-osfrose*)
		os=-osfrose
		;;
	-osf*)
		os=-osf
		;;
	-utek*)
		os=-bsd
		;;
	-dynix*)
		os=-bsd
		;;
	-acis*)
		os=-aos
		;;
	-atheos*)
		os=-atheos
		;;
	-syllable*)
		os=-syllable
		;;
	-386bsd)
		os=-bsd
		;;
	-ctix* | -uts*)
		os=-sysv
		;;
	-nova*)
		os=-rtmk-nova
		;;
	-ns2 )
		os=-nextstep2
		;;
	-nsk*)
		os=-nsk
		;;
	# Preserve the version number of sinix5.
	-sinix5.*)
		os=`echo $os | sed -e 's|sinix|sysv|'`
		;;
	-sinix*)
		os=-sysv4
		;;
	-tpf*)
		os=-tpf
		;;
	-triton*)
		os=-sysv3
		;;
	-oss*)
		os=-sysv3
		;;
	-svr4)
		os=-sysv4
		;;
	-svr3)
		os=-sysv3
		;;
	-sysvr4)
		os=-sysv4
		;;
	# This must come after -sysvr4.
	-sysv*)
		;;
	-ose*)
		os=-ose
		;;
	-es1800*)
		os=-ose
		;;
	-xenix)
		os=-xenix
		;;
	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
		os=-mint
		;;
	-aros*)
		os=-aros
		;;
	-zvmoe)
		os=-zvmoe
		;;
	-dicos*)
		os=-dicos
		;;
	-nacl*)
		;;
	-none)
		;;
	*)
		# Get rid of the `-' at the beginning of $os.
		os=`echo $os | sed 's/[^-]*-//'`
		echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
		exit 1
		;;
esac
else

# Here we handle the default operating systems that come with various machines.
# The value should be what the vendor currently ships out the door with their
# machine or put another way, the most popular os provided with the machine.

# Note that if you're going to try to match "-MANUFACTURER" here (say,
# "-sun"), then you have to tell the case statement up towards the top
# that MANUFACTURER isn't an operating system.  Otherwise, code above
# will signal an error saying that MANUFACTURER isn't an operating
# system, and we'll never get to this point.

case $basic_machine in
	score-*)
		os=-elf
		;;
	spu-*)
		os=-elf
		;;
	*-acorn)
		os=-riscix1.2
		;;
	arm*-rebel)
		os=-linux
		;;
	arm*-semi)
		os=-aout
		;;
	c4x-* | tic4x-*)
		os=-coff
		;;
	hexagon-*)
		os=-elf
		;;
	tic54x-*)
		os=-coff
		;;
	tic55x-*)
		os=-coff
		;;
	tic6x-*)
		os=-coff
		;;
	# This must come before the *-dec entry.
	pdp10-*)
		os=-tops20
		;;
	pdp11-*)
		os=-none
		;;
	*-dec | vax-*)
		os=-ultrix4.2
		;;
	m68*-apollo)
		os=-domain
		;;
	i386-sun)
		os=-sunos4.0.2
		;;
	m68000-sun)
		os=-sunos3
		;;
	m68*-cisco)
		os=-aout
		;;
	mep-*)
		os=-elf
		;;
	mips*-cisco)
		os=-elf
		;;
	mips*-*)
		os=-elf
		;;
	or1k-*)
		os=-elf
		;;
	or32-*)
		os=-coff
		;;
	*-tti)	# must be before sparc entry or we get the wrong os.
		os=-sysv3
		;;
	sparc-* | *-sun)
		os=-sunos4.1.1
		;;
	*-be)
		os=-beos
		;;
	*-haiku)
		os=-haiku
		;;
	*-ibm)
		os=-aix
		;;
	*-knuth)
		os=-mmixware
		;;
	*-wec)
		os=-proelf
		;;
	*-winbond)
		os=-proelf
		;;
	*-oki)
		os=-proelf
		;;
	*-hp)
		os=-hpux
		;;
	*-hitachi)
		os=-hiux
		;;
	i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
		os=-sysv
		;;
	*-cbm)
		os=-amigaos
		;;
	*-dg)
		os=-dgux
		;;
	*-dolphin)
		os=-sysv3
		;;
	m68k-ccur)
		os=-rtu
		;;
	m88k-omron*)
		os=-luna
		;;
	*-next )
		os=-nextstep
		;;
	*-sequent)
		os=-ptx
		;;
	*-crds)
		os=-unos
		;;
	*-ns)
		os=-genix
		;;
	i370-*)
		os=-mvs
		;;
	*-next)
		os=-nextstep3
		;;
	*-gould)
		os=-sysv
		;;
	*-highlevel)
		os=-bsd
		;;
	*-encore)
		os=-bsd
		;;
	*-sgi)
		os=-irix
		;;
	*-siemens)
		os=-sysv4
		;;
	*-masscomp)
		os=-rtu
		;;
	f30[01]-fujitsu | f700-fujitsu)
		os=-uxpv
		;;
	*-rom68k)
		os=-coff
		;;
	*-*bug)
		os=-coff
		;;
	*-apple)
		os=-macos
		;;
	*-atari*)
		os=-mint
		;;
	*)
		os=-none
		;;
esac
fi

# Here we handle the case where we know the os, and the CPU type, but not the
# manufacturer.  We pick the logical manufacturer.
vendor=unknown
case $basic_machine in
	*-unknown)
		case $os in
			-riscix*)
				vendor=acorn
				;;
			-sunos*)
				vendor=sun
				;;
			-cnk*|-aix*)
				vendor=ibm
				;;
			-beos*)
				vendor=be
				;;
			-hpux*)
				vendor=hp
				;;
			-mpeix*)
				vendor=hp
				;;
			-hiux*)
				vendor=hitachi
				;;
			-unos*)
				vendor=crds
				;;
			-dgux*)
				vendor=dg
				;;
			-luna*)
				vendor=omron
				;;
			-genix*)
				vendor=ns
				;;
			-mvs* | -opened*)
				vendor=ibm
				;;
			-os400*)
				vendor=ibm
				;;
			-ptx*)
				vendor=sequent
				;;
			-tpf*)
				vendor=ibm
				;;
			-vxsim* | -vxworks* | -windiss*)
				vendor=wrs
				;;
			-aux*)
				vendor=apple
				;;
			-hms*)
				vendor=hitachi
				;;
			-mpw* | -macos*)
				vendor=apple
				;;
			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
				vendor=atari
				;;
			-vos*)
				vendor=stratus
				;;
		esac
		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
		;;
esac

echo $basic_machine$os
exit

# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%:y-%02m-%02d"
# time-stamp-end: "'"
# End:
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/configure0000775000175000017500000222163413010376367024251 0ustar  zoncazonca00000000000000#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.69 for healpix_cxx 3.30.0.
#
#
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
#
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

# Use a proper internal environment variable to ensure we don't fall
  # into an infinite loop, continuously re-executing ourselves.
  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
    _as_can_reexec=no; export _as_can_reexec;
    # We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
  *v*x* | *x*v* ) as_opts=-vx ;;
  *v* ) as_opts=-v ;;
  *x* ) as_opts=-x ;;
  * ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
as_fn_exit 255
  fi
  # We don't want this to propagate to other subprocesses.
          { _as_can_reexec=; unset _as_can_reexec;}
if test "x$CONFIG_SHELL" = x; then
  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
  setopt NO_GLOB_SUBST
else
  case \`(set -o) 2>/dev/null\` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi
"
  as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }

exitcode=0
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :

else
  exitcode=1; echo positional parameters were not saved.
fi
test x\$exitcode = x0 || exit 1
test -x / || exit 1"
  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1

  test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || (
    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
    PATH=/empty FPATH=/empty; export PATH FPATH
    test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\
      || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1
test \$(( 1 + 1 )) = 2 || exit 1"
  if (eval "$as_required") 2>/dev/null; then :
  as_have_required=yes
else
  as_have_required=no
fi
  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :

else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  as_found=:
  case $as_dir in #(
	 /*)
	   for as_base in sh bash ksh sh5; do
	     # Try only shells that exist, to save several forks.
	     as_shell=$as_dir/$as_base
	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
  CONFIG_SHELL=$as_shell as_have_required=yes
		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
  break 2
fi
fi
	   done;;
       esac
  as_found=false
done
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
  CONFIG_SHELL=$SHELL as_have_required=yes
fi; }
IFS=$as_save_IFS


      if test "x$CONFIG_SHELL" != x; then :
  export CONFIG_SHELL
             # We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
  *v*x* | *x*v* ) as_opts=-vx ;;
  *v* ) as_opts=-v ;;
  *x* ) as_opts=-x ;;
  * ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi

    if test x$as_have_required = xno; then :
  $as_echo "$0: This script requires a shell more modern than all"
  $as_echo "$0: the shells that I found on your system."
  if test x${ZSH_VERSION+set} = xset ; then
    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
  else
    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
$0: including any error possibly output before this
$0: message. Then install a modern shell, or manually run
$0: the script under such a shell if you do have one."
  fi
  exit 1
fi
fi
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS

## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset

# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p

# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
  test -f "$1" && test -x "$1"
} # as_fn_executable_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error

if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits


  as_lineno_1=$LINENO as_lineno_1a=$LINENO
  as_lineno_2=$LINENO as_lineno_2a=$LINENO
  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
  sed -n '
    p
    /[$]LINENO/=
  ' <$as_myself |
    sed '
      s/[$]LINENO.*/&-/
      t lineno
      b
      :lineno
      N
      :loop
      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
      t loop
      s/-\n.*//
    ' >$as_me.lineno &&
  chmod +x "$as_me.lineno" ||
    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }

  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
  # already done that, so ensure we don't try to do so again and fall
  # in an infinite loop.  This has already happened in practice.
  _as_can_reexec=no; export _as_can_reexec
  # Don't try to exec as it changes $[0], causing all sort of problems
  # (the dirname of $[0] is not the place where we might find the
  # original and so on.  Autoconf is especially sensitive to this).
  . "./$as_me.lineno"
  # Exit status is that of the last command.
  exit
}

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null

if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi

as_test_x='test -x'
as_executable_p=as_fn_executable_p

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"

SHELL=${CONFIG_SHELL-/bin/sh}


test -n "$DJDIR" || exec 7<&0 &1

# Name of the host.
# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
# so uname gets run too.
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`

#
# Initializations.
#
ac_default_prefix=/usr/local
ac_clean_files=
ac_config_libobj_dir=.
LIBOBJS=
cross_compiling=no
subdirs=
MFLAGS=
MAKEFLAGS=

# Identity of this package.
PACKAGE_NAME='healpix_cxx'
PACKAGE_TARNAME='healpix_cxx'
PACKAGE_VERSION='3.30.0'
PACKAGE_STRING='healpix_cxx 3.30.0'
PACKAGE_BUGREPORT=''
PACKAGE_URL=''

# Factoring default headers for most tests.
ac_includes_default="\
#include 
#ifdef HAVE_SYS_TYPES_H
# include 
#endif
#ifdef HAVE_SYS_STAT_H
# include 
#endif
#ifdef STDC_HEADERS
# include 
# include 
#else
# ifdef HAVE_STDLIB_H
#  include 
# endif
#endif
#ifdef HAVE_STRING_H
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
#  include 
# endif
# include 
#endif
#ifdef HAVE_STRINGS_H
# include 
#endif
#ifdef HAVE_INTTYPES_H
# include 
#endif
#ifdef HAVE_STDINT_H
# include 
#endif
#ifdef HAVE_UNISTD_H
# include 
#endif"

ac_subst_vars='am__EXEEXT_FALSE
am__EXEEXT_TRUE
LTLIBOBJS
LIBOBJS
pkgconfig_libfile
pkgconfig_libdir
PKG_CONFIG_LIBDIR
PKG_CONFIG_PATH
PKG_CONFIG
CFITSIO_LIBS
CFITSIO_CFLAGS
OPENMP_CXXFLAGS
CXXCPP
am__fastdepCXX_FALSE
am__fastdepCXX_TRUE
CXXDEPMODE
ac_ct_CXX
CXXFLAGS
CXX
OPENMP_CFLAGS
CPP
OTOOL64
OTOOL
LIPO
NMEDIT
DSYMUTIL
MANIFEST_TOOL
RANLIB
DLLTOOL
OBJDUMP
LN_S
NM
ac_ct_DUMPBIN
DUMPBIN
LD
FGREP
EGREP
GREP
SED
host_os
host_vendor
host_cpu
host
build_os
build_vendor
build_cpu
build
LIBTOOL
am__fastdepCC_FALSE
am__fastdepCC_TRUE
CCDEPMODE
am__nodep
AMDEPBACKSLASH
AMDEP_FALSE
AMDEP_TRUE
am__quote
am__include
DEPDIR
OBJEXT
EXEEXT
ac_ct_CC
CPPFLAGS
LDFLAGS
CFLAGS
CC
ac_ct_AR
AR
MAINT
MAINTAINER_MODE_FALSE
MAINTAINER_MODE_TRUE
AM_BACKSLASH
AM_DEFAULT_VERBOSITY
AM_DEFAULT_V
AM_V
am__untar
am__tar
AMTAR
am__leading_dot
SET_MAKE
AWK
mkdir_p
MKDIR_P
INSTALL_STRIP_PROGRAM
STRIP
install_sh
MAKEINFO
AUTOHEADER
AUTOMAKE
AUTOCONF
ACLOCAL
VERSION
PACKAGE
CYGPATH_W
am__isrc
INSTALL_DATA
INSTALL_SCRIPT
INSTALL_PROGRAM
target_alias
host_alias
build_alias
LIBS
ECHO_T
ECHO_N
ECHO_C
DEFS
mandir
localedir
libdir
psdir
pdfdir
dvidir
htmldir
infodir
docdir
oldincludedir
includedir
localstatedir
sharedstatedir
sysconfdir
datadir
datarootdir
libexecdir
sbindir
bindir
program_transform_name
prefix
exec_prefix
PACKAGE_URL
PACKAGE_BUGREPORT
PACKAGE_STRING
PACKAGE_VERSION
PACKAGE_TARNAME
PACKAGE_NAME
PATH_SEPARATOR
SHELL'
ac_subst_files=''
ac_user_opts='
enable_option_checking
enable_silent_rules
enable_maintainer_mode
enable_dependency_tracking
enable_shared
enable_static
with_pic
enable_fast_install
with_gnu_ld
with_sysroot
enable_libtool_lock
enable_native_optimizations
enable_openmp
'
      ac_precious_vars='build_alias
host_alias
target_alias
CC
CFLAGS
LDFLAGS
LIBS
CPPFLAGS
CPP
CXX
CXXFLAGS
CCC
CXXCPP
CFITSIO_CFLAGS
CFITSIO_LIBS
PKG_CONFIG
PKG_CONFIG_PATH
PKG_CONFIG_LIBDIR'


# Initialize some variables set by options.
ac_init_help=
ac_init_version=false
ac_unrecognized_opts=
ac_unrecognized_sep=
# The variables have the same names as the options, with
# dashes changed to underlines.
cache_file=/dev/null
exec_prefix=NONE
no_create=
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
verbose=
x_includes=NONE
x_libraries=NONE

# Installation directory options.
# These are left unexpanded so users can "make install exec_prefix=/foo"
# and all the variables that are supposed to be based on exec_prefix
# by default will actually change.
# Use braces instead of parens because sh, perl, etc. also accept them.
# (The list follows the same order as the GNU Coding Standards.)
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datarootdir='${prefix}/share'
datadir='${datarootdir}'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
infodir='${datarootdir}/info'
htmldir='${docdir}'
dvidir='${docdir}'
pdfdir='${docdir}'
psdir='${docdir}'
libdir='${exec_prefix}/lib'
localedir='${datarootdir}/locale'
mandir='${datarootdir}/man'

ac_prev=
ac_dashdash=
for ac_option
do
  # If the previous option needs an argument, assign it.
  if test -n "$ac_prev"; then
    eval $ac_prev=\$ac_option
    ac_prev=
    continue
  fi

  case $ac_option in
  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
  *=)   ac_optarg= ;;
  *)    ac_optarg=yes ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case $ac_dashdash$ac_option in
  --)
    ac_dashdash=yes ;;

  -bindir | --bindir | --bindi | --bind | --bin | --bi)
    ac_prev=bindir ;;
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
    bindir=$ac_optarg ;;

  -build | --build | --buil | --bui | --bu)
    ac_prev=build_alias ;;
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
    build_alias=$ac_optarg ;;

  -cache-file | --cache-file | --cache-fil | --cache-fi \
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
    ac_prev=cache_file ;;
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
    cache_file=$ac_optarg ;;

  --config-cache | -C)
    cache_file=config.cache ;;

  -datadir | --datadir | --datadi | --datad)
    ac_prev=datadir ;;
  -datadir=* | --datadir=* | --datadi=* | --datad=*)
    datadir=$ac_optarg ;;

  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
  | --dataroo | --dataro | --datar)
    ac_prev=datarootdir ;;
  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
    datarootdir=$ac_optarg ;;

  -disable-* | --disable-*)
    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid feature name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"enable_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval enable_$ac_useropt=no ;;

  -docdir | --docdir | --docdi | --doc | --do)
    ac_prev=docdir ;;
  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
    docdir=$ac_optarg ;;

  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
    ac_prev=dvidir ;;
  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
    dvidir=$ac_optarg ;;

  -enable-* | --enable-*)
    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid feature name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"enable_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval enable_$ac_useropt=\$ac_optarg ;;

  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
  | --exec | --exe | --ex)
    ac_prev=exec_prefix ;;
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
  | --exec=* | --exe=* | --ex=*)
    exec_prefix=$ac_optarg ;;

  -gas | --gas | --ga | --g)
    # Obsolete; use --with-gas.
    with_gas=yes ;;

  -help | --help | --hel | --he | -h)
    ac_init_help=long ;;
  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
    ac_init_help=recursive ;;
  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
    ac_init_help=short ;;

  -host | --host | --hos | --ho)
    ac_prev=host_alias ;;
  -host=* | --host=* | --hos=* | --ho=*)
    host_alias=$ac_optarg ;;

  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
    ac_prev=htmldir ;;
  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
  | --ht=*)
    htmldir=$ac_optarg ;;

  -includedir | --includedir | --includedi | --included | --include \
  | --includ | --inclu | --incl | --inc)
    ac_prev=includedir ;;
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
  | --includ=* | --inclu=* | --incl=* | --inc=*)
    includedir=$ac_optarg ;;

  -infodir | --infodir | --infodi | --infod | --info | --inf)
    ac_prev=infodir ;;
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
    infodir=$ac_optarg ;;

  -libdir | --libdir | --libdi | --libd)
    ac_prev=libdir ;;
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
    libdir=$ac_optarg ;;

  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
  | --libexe | --libex | --libe)
    ac_prev=libexecdir ;;
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
  | --libexe=* | --libex=* | --libe=*)
    libexecdir=$ac_optarg ;;

  -localedir | --localedir | --localedi | --localed | --locale)
    ac_prev=localedir ;;
  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
    localedir=$ac_optarg ;;

  -localstatedir | --localstatedir | --localstatedi | --localstated \
  | --localstate | --localstat | --localsta | --localst | --locals)
    ac_prev=localstatedir ;;
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
    localstatedir=$ac_optarg ;;

  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
    ac_prev=mandir ;;
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
    mandir=$ac_optarg ;;

  -nfp | --nfp | --nf)
    # Obsolete; use --without-fp.
    with_fp=no ;;

  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c | -n)
    no_create=yes ;;

  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
    no_recursion=yes ;;

  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
  | --oldin | --oldi | --old | --ol | --o)
    ac_prev=oldincludedir ;;
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
    oldincludedir=$ac_optarg ;;

  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    ac_prev=prefix ;;
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix=$ac_optarg ;;

  -program-prefix | --program-prefix | --program-prefi | --program-pref \
  | --program-pre | --program-pr | --program-p)
    ac_prev=program_prefix ;;
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
    program_prefix=$ac_optarg ;;

  -program-suffix | --program-suffix | --program-suffi | --program-suff \
  | --program-suf | --program-su | --program-s)
    ac_prev=program_suffix ;;
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
    program_suffix=$ac_optarg ;;

  -program-transform-name | --program-transform-name \
  | --program-transform-nam | --program-transform-na \
  | --program-transform-n | --program-transform- \
  | --program-transform | --program-transfor \
  | --program-transfo | --program-transf \
  | --program-trans | --program-tran \
  | --progr-tra | --program-tr | --program-t)
    ac_prev=program_transform_name ;;
  -program-transform-name=* | --program-transform-name=* \
  | --program-transform-nam=* | --program-transform-na=* \
  | --program-transform-n=* | --program-transform-=* \
  | --program-transform=* | --program-transfor=* \
  | --program-transfo=* | --program-transf=* \
  | --program-trans=* | --program-tran=* \
  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name=$ac_optarg ;;

  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
    ac_prev=pdfdir ;;
  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
    pdfdir=$ac_optarg ;;

  -psdir | --psdir | --psdi | --psd | --ps)
    ac_prev=psdir ;;
  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
    psdir=$ac_optarg ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    ac_prev=sbindir ;;
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  | --sbi=* | --sb=*)
    sbindir=$ac_optarg ;;

  -sharedstatedir | --sharedstatedir | --sharedstatedi \
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
  | --sharedst | --shareds | --shared | --share | --shar \
  | --sha | --sh)
    ac_prev=sharedstatedir ;;
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
  | --sha=* | --sh=*)
    sharedstatedir=$ac_optarg ;;

  -site | --site | --sit)
    ac_prev=site ;;
  -site=* | --site=* | --sit=*)
    site=$ac_optarg ;;

  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
    ac_prev=srcdir ;;
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
    srcdir=$ac_optarg ;;

  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
  | --syscon | --sysco | --sysc | --sys | --sy)
    ac_prev=sysconfdir ;;
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
    sysconfdir=$ac_optarg ;;

  -target | --target | --targe | --targ | --tar | --ta | --t)
    ac_prev=target_alias ;;
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
    target_alias=$ac_optarg ;;

  -v | -verbose | --verbose | --verbos | --verbo | --verb)
    verbose=yes ;;

  -version | --version | --versio | --versi | --vers | -V)
    ac_init_version=: ;;

  -with-* | --with-*)
    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid package name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"with_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval with_$ac_useropt=\$ac_optarg ;;

  -without-* | --without-*)
    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
    # Reject names that are not valid shell variable names.
    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
      as_fn_error $? "invalid package name: $ac_useropt"
    ac_useropt_orig=$ac_useropt
    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
    case $ac_user_opts in
      *"
"with_$ac_useropt"
"*) ;;
      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
	 ac_unrecognized_sep=', ';;
    esac
    eval with_$ac_useropt=no ;;

  --x)
    # Obsolete; use --with-x.
    with_x=yes ;;

  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
  | --x-incl | --x-inc | --x-in | --x-i)
    ac_prev=x_includes ;;
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
    x_includes=$ac_optarg ;;

  -x-libraries | --x-libraries | --x-librarie | --x-librari \
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
    ac_prev=x_libraries ;;
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries=$ac_optarg ;;

  -*) as_fn_error $? "unrecognized option: \`$ac_option'
Try \`$0 --help' for more information"
    ;;

  *=*)
    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
    # Reject names that are not valid shell variable names.
    case $ac_envvar in #(
      '' | [0-9]* | *[!_$as_cr_alnum]* )
      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
    esac
    eval $ac_envvar=\$ac_optarg
    export $ac_envvar ;;

  *)
    # FIXME: should be removed in autoconf 3.0.
    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
    ;;

  esac
done

if test -n "$ac_prev"; then
  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
  as_fn_error $? "missing argument to $ac_option"
fi

if test -n "$ac_unrecognized_opts"; then
  case $enable_option_checking in
    no) ;;
    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
  esac
fi

# Check all directory arguments for consistency.
for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
		datadir sysconfdir sharedstatedir localstatedir includedir \
		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
		libdir localedir mandir
do
  eval ac_val=\$$ac_var
  # Remove trailing slashes.
  case $ac_val in
    */ )
      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
      eval $ac_var=\$ac_val;;
  esac
  # Be sure to have absolute directory names.
  case $ac_val in
    [\\/$]* | ?:[\\/]* )  continue;;
    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
  esac
  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
done

# There might be people who depend on the old broken behavior: `$host'
# used to hold the argument of --host etc.
# FIXME: To remove some day.
build=$build_alias
host=$host_alias
target=$target_alias

# FIXME: To remove some day.
if test "x$host_alias" != x; then
  if test "x$build_alias" = x; then
    cross_compiling=maybe
  elif test "x$build_alias" != "x$host_alias"; then
    cross_compiling=yes
  fi
fi

ac_tool_prefix=
test -n "$host_alias" && ac_tool_prefix=$host_alias-

test "$silent" = yes && exec 6>/dev/null


ac_pwd=`pwd` && test -n "$ac_pwd" &&
ac_ls_di=`ls -di .` &&
ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
  as_fn_error $? "working directory cannot be determined"
test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
  as_fn_error $? "pwd does not report name of working directory"


# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then the parent directory.
  ac_confdir=`$as_dirname -- "$as_myself" ||
$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_myself" : 'X\(//\)[^/]' \| \
	 X"$as_myself" : 'X\(//\)$' \| \
	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_myself" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  srcdir=$ac_confdir
  if test ! -r "$srcdir/$ac_unique_file"; then
    srcdir=..
  fi
else
  ac_srcdir_defaulted=no
fi
if test ! -r "$srcdir/$ac_unique_file"; then
  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
fi
ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
ac_abs_confdir=`(
	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
	pwd)`
# When building in place, set srcdir=.
if test "$ac_abs_confdir" = "$ac_pwd"; then
  srcdir=.
fi
# Remove unnecessary trailing slashes from srcdir.
# Double slashes in file names in object file debugging info
# mess up M-x gdb in Emacs.
case $srcdir in
*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
esac
for ac_var in $ac_precious_vars; do
  eval ac_env_${ac_var}_set=\${${ac_var}+set}
  eval ac_env_${ac_var}_value=\$${ac_var}
  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
  eval ac_cv_env_${ac_var}_value=\$${ac_var}
done

#
# Report the --help message.
#
if test "$ac_init_help" = "long"; then
  # Omit some internal or obsolete options to make the list less imposing.
  # This message is too long to be a string in the A/UX 3.1 sh.
  cat <<_ACEOF
\`configure' configures healpix_cxx 3.30.0 to adapt to many kinds of systems.

Usage: $0 [OPTION]... [VAR=VALUE]...

To assign environment variables (e.g., CC, CFLAGS...), specify them as
VAR=VALUE.  See below for descriptions of some of the useful variables.

Defaults for the options are specified in brackets.

Configuration:
  -h, --help              display this help and exit
      --help=short        display options specific to this package
      --help=recursive    display the short help of all the included packages
  -V, --version           display version information and exit
  -q, --quiet, --silent   do not print \`checking ...' messages
      --cache-file=FILE   cache test results in FILE [disabled]
  -C, --config-cache      alias for \`--cache-file=config.cache'
  -n, --no-create         do not create output files
      --srcdir=DIR        find the sources in DIR [configure dir or \`..']

Installation directories:
  --prefix=PREFIX         install architecture-independent files in PREFIX
                          [$ac_default_prefix]
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                          [PREFIX]

By default, \`make install' will install all the files in
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
for instance \`--prefix=\$HOME'.

For better control, use the options below.

Fine tuning of the installation directories:
  --bindir=DIR            user executables [EPREFIX/bin]
  --sbindir=DIR           system admin executables [EPREFIX/sbin]
  --libexecdir=DIR        program executables [EPREFIX/libexec]
  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
  --libdir=DIR            object code libraries [EPREFIX/lib]
  --includedir=DIR        C header files [PREFIX/include]
  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
  --infodir=DIR           info documentation [DATAROOTDIR/info]
  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
  --mandir=DIR            man documentation [DATAROOTDIR/man]
  --docdir=DIR            documentation root [DATAROOTDIR/doc/healpix_cxx]
  --htmldir=DIR           html documentation [DOCDIR]
  --dvidir=DIR            dvi documentation [DOCDIR]
  --pdfdir=DIR            pdf documentation [DOCDIR]
  --psdir=DIR             ps documentation [DOCDIR]
_ACEOF

  cat <<\_ACEOF

Program names:
  --program-prefix=PREFIX            prepend PREFIX to installed program names
  --program-suffix=SUFFIX            append SUFFIX to installed program names
  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names

System types:
  --build=BUILD     configure for building on BUILD [guessed]
  --host=HOST       cross-compile to build programs to run on HOST [BUILD]
_ACEOF
fi

if test -n "$ac_init_help"; then
  case $ac_init_help in
     short | recursive ) echo "Configuration of healpix_cxx 3.30.0:";;
   esac
  cat <<\_ACEOF

Optional Features:
  --disable-option-checking  ignore unrecognized --enable/--with options
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
  --enable-silent-rules   less verbose build output (undo: "make V=1")
  --disable-silent-rules  verbose build output (undo: "make V=0")
  --disable-maintainer-mode
                          disable make rules and dependencies not useful (and
                          sometimes confusing) to the casual installer
  --enable-dependency-tracking
                          do not reject slow dependency extractors
  --disable-dependency-tracking
                          speeds up one-time build
  --enable-shared[=PKGS]  build shared libraries [default=yes]
  --enable-static[=PKGS]  build static libraries [default=yes]
  --enable-fast-install[=PKGS]
                          optimize for fast installation [default=yes]
  --disable-libtool-lock  avoid locking (might break parallel builds)
  --enable-native-optimizations
                          Enable non-portable optimizations for your own CPU
                          by compiling with -march=native [default=no]

  --disable-openmp        do not use OpenMP

Optional Packages:
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  --with-pic[=PKGS]       try to use only PIC/non-PIC objects [default=use
                          both]
  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
  --with-sysroot=DIR Search for dependent libraries within DIR
                        (or the compiler's sysroot if not specified).

Some influential environment variables:
  CC          C compiler command
  CFLAGS      C compiler flags
  LDFLAGS     linker flags, e.g. -L if you have libraries in a
              nonstandard directory 
  LIBS        libraries to pass to the linker, e.g. -l
  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I if
              you have headers in a nonstandard directory 
  CPP         C preprocessor
  CXX         C++ compiler command
  CXXFLAGS    C++ compiler flags
  CXXCPP      C++ preprocessor
  CFITSIO_CFLAGS
              compiler flags needed for building with cfitsio, if not found by
              pkg-config
  CFITSIO_LIBS
              linker flags needed for building with cfitsio, if not found by
              pkg-config
  PKG_CONFIG  path to pkg-config utility
  PKG_CONFIG_PATH
              directories to add to pkg-config's search path
  PKG_CONFIG_LIBDIR
              path overriding pkg-config's built-in search path

Use these variables to override the choices made by `configure' or to help
it to find libraries and programs with nonstandard names/locations.

Report bugs to the package provider.
_ACEOF
ac_status=$?
fi

if test "$ac_init_help" = "recursive"; then
  # If there are subdirs, report their specific --help.
  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
    test -d "$ac_dir" ||
      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
      continue
    ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix

    cd "$ac_dir" || { ac_status=$?; continue; }
    # Check for guested configure.
    if test -f "$ac_srcdir/configure.gnu"; then
      echo &&
      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
    elif test -f "$ac_srcdir/configure"; then
      echo &&
      $SHELL "$ac_srcdir/configure" --help=recursive
    else
      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
    fi || ac_status=$?
    cd "$ac_pwd" || { ac_status=$?; break; }
  done
fi

test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
  cat <<\_ACEOF
healpix_cxx configure 3.30.0
generated by GNU Autoconf 2.69

Copyright (C) 2012 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
  exit
fi

## ------------------------ ##
## Autoconf initialization. ##
## ------------------------ ##

# ac_fn_c_try_compile LINENO
# --------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext
  if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_c_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest.$ac_objext; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_compile

# ac_fn_c_try_link LINENO
# -----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_link ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext conftest$ac_exeext
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_c_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest$ac_exeext && {
	 test "$cross_compiling" = yes ||
	 test -x conftest$ac_exeext
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
  # interfere with the next link command; also delete a directory that is
  # left behind by Apple's compiler.  We do this before executing the actions.
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_link

# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists and can be compiled using the include files in
# INCLUDES, setting the cache variable VAR accordingly.
ac_fn_c_check_header_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  eval "$3=yes"
else
  eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_header_compile

# ac_fn_c_try_cpp LINENO
# ----------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_cpp ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } > conftest.i && {
	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
	 test ! -s conftest.err
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

    ac_retval=1
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_cpp

# ac_fn_c_try_run LINENO
# ----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
# that executables *can* be run.
ac_fn_c_try_run ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
  { { case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_try") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; }; then :
  ac_retval=0
else
  $as_echo "$as_me: program exited with status $ac_status" >&5
       $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

       ac_retval=$ac_status
fi
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_c_try_run

# ac_fn_c_check_func LINENO FUNC VAR
# ----------------------------------
# Tests whether FUNC exists, setting the cache variable VAR accordingly
ac_fn_c_check_func ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
/* Define $2 to an innocuous variant, in case  declares $2.
   For example, HP-UX 11i  declares gettimeofday.  */
#define $2 innocuous_$2

/* System header to define __stub macros and hopefully few prototypes,
    which can conflict with char $2 (); below.
    Prefer  to  if __STDC__ is defined, since
     exists even on freestanding compilers.  */

#ifdef __STDC__
# include 
#else
# include 
#endif

#undef $2

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char $2 ();
/* The GNU C library defines this for functions which it implements
    to always fail with ENOSYS.  Some functions are actually named
    something starting with __ and the normal name is an alias.  */
#if defined __stub_$2 || defined __stub___$2
choke me
#endif

int
main ()
{
return $2 ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  eval "$3=yes"
else
  eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_func

# ac_fn_cxx_try_compile LINENO
# ----------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_cxx_try_compile ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext
  if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_cxx_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest.$ac_objext; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_cxx_try_compile

# ac_fn_cxx_try_cpp LINENO
# ------------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_cxx_try_cpp ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } > conftest.i && {
	 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
	 test ! -s conftest.err
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

    ac_retval=1
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_cxx_try_cpp

# ac_fn_cxx_try_link LINENO
# -------------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_cxx_try_link ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  rm -f conftest.$ac_objext conftest$ac_exeext
  if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    grep -v '^ *+' conftest.err >conftest.er1
    cat conftest.er1 >&5
    mv -f conftest.er1 conftest.err
  fi
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && {
	 test -z "$ac_cxx_werror_flag" ||
	 test ! -s conftest.err
       } && test -s conftest$ac_exeext && {
	 test "$cross_compiling" = yes ||
	 test -x conftest$ac_exeext
       }; then :
  ac_retval=0
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

	ac_retval=1
fi
  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
  # interfere with the next link command; also delete a directory that is
  # left behind by Apple's compiler.  We do this before executing the actions.
  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
  as_fn_set_status $ac_retval

} # ac_fn_cxx_try_link

# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
# the include files in INCLUDES and setting the cache variable VAR
# accordingly.
ac_fn_c_check_header_mongrel ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if eval \${$3+:} false; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
else
  # Is the header compilable?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
$as_echo_n "checking $2 usability... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_header_compiler=yes
else
  ac_header_compiler=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
$as_echo "$ac_header_compiler" >&6; }

# Is the header present?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
$as_echo_n "checking $2 presence... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <$2>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  ac_header_preproc=yes
else
  ac_header_preproc=no
fi
rm -f conftest.err conftest.i conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
$as_echo "$ac_header_preproc" >&6; }

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
  yes:no: )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
  no:yes:* )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
esac
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  eval "$3=\$ac_header_compiler"
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_header_mongrel
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.

It was created by healpix_cxx $as_me 3.30.0, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  $ $0 $@

_ACEOF
exec 5>>config.log
{
cat <<_ASUNAME
## --------- ##
## Platform. ##
## --------- ##

hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`

/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`

/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`

_ASUNAME

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    $as_echo "PATH: $as_dir"
  done
IFS=$as_save_IFS

} >&5

cat >&5 <<_ACEOF


## ----------- ##
## Core tests. ##
## ----------- ##

_ACEOF


# Keep a trace of the command line.
# Strip out --no-create and --no-recursion so they do not pile up.
# Strip out --silent because we don't want to record it for future runs.
# Also quote any args containing shell meta-characters.
# Make two passes to allow for proper duplicate-argument suppression.
ac_configure_args=
ac_configure_args0=
ac_configure_args1=
ac_must_keep_next=false
for ac_pass in 1 2
do
  for ac_arg
  do
    case $ac_arg in
    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
    | -silent | --silent | --silen | --sile | --sil)
      continue ;;
    *\'*)
      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
    esac
    case $ac_pass in
    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
    2)
      as_fn_append ac_configure_args1 " '$ac_arg'"
      if test $ac_must_keep_next = true; then
	ac_must_keep_next=false # Got value, back to normal.
      else
	case $ac_arg in
	  *=* | --config-cache | -C | -disable-* | --disable-* \
	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
	  | -with-* | --with-* | -without-* | --without-* | --x)
	    case "$ac_configure_args0 " in
	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
	    esac
	    ;;
	  -* ) ac_must_keep_next=true ;;
	esac
      fi
      as_fn_append ac_configure_args " '$ac_arg'"
      ;;
    esac
  done
done
{ ac_configure_args0=; unset ac_configure_args0;}
{ ac_configure_args1=; unset ac_configure_args1;}

# When interrupted or exit'd, cleanup temporary files, and complete
# config.log.  We remove comments because anyway the quotes in there
# would cause problems or look ugly.
# WARNING: Use '\'' to represent an apostrophe within the trap.
# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
trap 'exit_status=$?
  # Save into config.log some information that might help in debugging.
  {
    echo

    $as_echo "## ---------------- ##
## Cache variables. ##
## ---------------- ##"
    echo
    # The following way of writing the cache mishandles newlines in values,
(
  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
    eval ac_val=\$$ac_var
    case $ac_val in #(
    *${as_nl}*)
      case $ac_var in #(
      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      esac
      case $ac_var in #(
      _ | IFS | as_nl) ;; #(
      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
      *) { eval $ac_var=; unset $ac_var;} ;;
      esac ;;
    esac
  done
  (set) 2>&1 |
    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
    *${as_nl}ac_space=\ *)
      sed -n \
	"s/'\''/'\''\\\\'\'''\''/g;
	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
      ;; #(
    *)
      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
      ;;
    esac |
    sort
)
    echo

    $as_echo "## ----------------- ##
## Output variables. ##
## ----------------- ##"
    echo
    for ac_var in $ac_subst_vars
    do
      eval ac_val=\$$ac_var
      case $ac_val in
      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
      esac
      $as_echo "$ac_var='\''$ac_val'\''"
    done | sort
    echo

    if test -n "$ac_subst_files"; then
      $as_echo "## ------------------- ##
## File substitutions. ##
## ------------------- ##"
      echo
      for ac_var in $ac_subst_files
      do
	eval ac_val=\$$ac_var
	case $ac_val in
	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
	esac
	$as_echo "$ac_var='\''$ac_val'\''"
      done | sort
      echo
    fi

    if test -s confdefs.h; then
      $as_echo "## ----------- ##
## confdefs.h. ##
## ----------- ##"
      echo
      cat confdefs.h
      echo
    fi
    test "$ac_signal" != 0 &&
      $as_echo "$as_me: caught signal $ac_signal"
    $as_echo "$as_me: exit $exit_status"
  } >&5
  rm -f core *.core core.conftest.* &&
    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
    exit $exit_status
' 0
for ac_signal in 1 2 13 15; do
  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
done
ac_signal=0

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -f -r conftest* confdefs.h

$as_echo "/* confdefs.h */" > confdefs.h

# Predefined preprocessor variables.

cat >>confdefs.h <<_ACEOF
#define PACKAGE_NAME "$PACKAGE_NAME"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_VERSION "$PACKAGE_VERSION"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_STRING "$PACKAGE_STRING"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
_ACEOF

cat >>confdefs.h <<_ACEOF
#define PACKAGE_URL "$PACKAGE_URL"
_ACEOF


# Let the site file select an alternate cache file if it wants to.
# Prefer an explicitly selected file to automatically selected ones.
ac_site_file1=NONE
ac_site_file2=NONE
if test -n "$CONFIG_SITE"; then
  # We do not want a PATH search for config.site.
  case $CONFIG_SITE in #((
    -*)  ac_site_file1=./$CONFIG_SITE;;
    */*) ac_site_file1=$CONFIG_SITE;;
    *)   ac_site_file1=./$CONFIG_SITE;;
  esac
elif test "x$prefix" != xNONE; then
  ac_site_file1=$prefix/share/config.site
  ac_site_file2=$prefix/etc/config.site
else
  ac_site_file1=$ac_default_prefix/share/config.site
  ac_site_file2=$ac_default_prefix/etc/config.site
fi
for ac_site_file in "$ac_site_file1" "$ac_site_file2"
do
  test "x$ac_site_file" = xNONE && continue
  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
$as_echo "$as_me: loading site script $ac_site_file" >&6;}
    sed 's/^/| /' "$ac_site_file" >&5
    . "$ac_site_file" \
      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "failed to load site script $ac_site_file
See \`config.log' for more details" "$LINENO" 5; }
  fi
done

if test -r "$cache_file"; then
  # Some versions of bash will fail to source /dev/null (special files
  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
$as_echo "$as_me: loading cache $cache_file" >&6;}
    case $cache_file in
      [\\/]* | ?:[\\/]* ) . "$cache_file";;
      *)                      . "./$cache_file";;
    esac
  fi
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
$as_echo "$as_me: creating cache $cache_file" >&6;}
  >$cache_file
fi

# Check that the precious variables saved in the cache have kept the same
# value.
ac_cache_corrupted=false
for ac_var in $ac_precious_vars; do
  eval ac_old_set=\$ac_cv_env_${ac_var}_set
  eval ac_new_set=\$ac_env_${ac_var}_set
  eval ac_old_val=\$ac_cv_env_${ac_var}_value
  eval ac_new_val=\$ac_env_${ac_var}_value
  case $ac_old_set,$ac_new_set in
    set,)
      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
      ac_cache_corrupted=: ;;
    ,set)
      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
      ac_cache_corrupted=: ;;
    ,);;
    *)
      if test "x$ac_old_val" != "x$ac_new_val"; then
	# differences in whitespace do not lead to failure.
	ac_old_val_w=`echo x $ac_old_val`
	ac_new_val_w=`echo x $ac_new_val`
	if test "$ac_old_val_w" != "$ac_new_val_w"; then
	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
	  ac_cache_corrupted=:
	else
	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
	  eval $ac_var=\$ac_old_val
	fi
	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
      fi;;
  esac
  # Pass precious variables to config.status.
  if test "$ac_new_set" = set; then
    case $ac_new_val in
    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
    *) ac_arg=$ac_var=$ac_new_val ;;
    esac
    case " $ac_configure_args " in
      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
    esac
  fi
done
if $ac_cache_corrupted; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
fi
## -------------------- ##
## Main body of script. ##
## -------------------- ##

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu


am__api_version='1.13'

ac_aux_dir=
for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
  if test -f "$ac_dir/install-sh"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install-sh -c"
    break
  elif test -f "$ac_dir/install.sh"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/install.sh -c"
    break
  elif test -f "$ac_dir/shtool"; then
    ac_aux_dir=$ac_dir
    ac_install_sh="$ac_aux_dir/shtool install -c"
    break
  fi
done
if test -z "$ac_aux_dir"; then
  as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
fi

# These three variables are undocumented and unsupported,
# and are intended to be withdrawn in a future Autoconf release.
# They can cause serious problems if a builder's source tree is in a directory
# whose full name contains unusual characters.
ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.


# Find a good install program.  We prefer a C program (faster),
# so one script is as good as another.  But avoid the broken or
# incompatible versions:
# SysV /etc/install, /usr/sbin/install
# SunOS /usr/etc/install
# IRIX /sbin/install
# AIX /bin/install
# AmigaOS /C/install, which installs bootblocks on floppy discs
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# OS/2's system install, which has a completely different semantic
# ./install, which can be erroneously created by make from ./install.sh.
# Reject install programs that cannot install multiple files.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
$as_echo_n "checking for a BSD-compatible install... " >&6; }
if test -z "$INSTALL"; then
if ${ac_cv_path_install+:} false; then :
  $as_echo_n "(cached) " >&6
else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    # Account for people who put trailing slashes in PATH elements.
case $as_dir/ in #((
  ./ | .// | /[cC]/* | \
  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
  /usr/ucb/* ) ;;
  *)
    # OSF1 and SCO ODT 3.0 have their own names for install.
    # Don't use installbsd from OSF since it installs stuff as root
    # by default.
    for ac_prog in ginstall scoinst install; do
      for ac_exec_ext in '' $ac_executable_extensions; do
	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
	  if test $ac_prog = install &&
	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
	    # AIX install.  It has an incompatible calling convention.
	    :
	  elif test $ac_prog = install &&
	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
	    # program-specific install script used by HP pwplus--don't use.
	    :
	  else
	    rm -rf conftest.one conftest.two conftest.dir
	    echo one > conftest.one
	    echo two > conftest.two
	    mkdir conftest.dir
	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
	      test -s conftest.one && test -s conftest.two &&
	      test -s conftest.dir/conftest.one &&
	      test -s conftest.dir/conftest.two
	    then
	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
	      break 3
	    fi
	  fi
	fi
      done
    done
    ;;
esac

  done
IFS=$as_save_IFS

rm -rf conftest.one conftest.two conftest.dir

fi
  if test "${ac_cv_path_install+set}" = set; then
    INSTALL=$ac_cv_path_install
  else
    # As a last resort, use the slow shell script.  Don't cache a
    # value for INSTALL within a source directory, because that will
    # break other packages using the cache if that directory is
    # removed, or if the value is a relative name.
    INSTALL=$ac_install_sh
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
$as_echo "$INSTALL" >&6; }

# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'

test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'

test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
$as_echo_n "checking whether build environment is sane... " >&6; }
# Reject unsafe characters in $srcdir or the absolute working directory
# name.  Accept space and tab only in the latter.
am_lf='
'
case `pwd` in
  *[\\\"\#\$\&\'\`$am_lf]*)
    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
esac
case $srcdir in
  *[\\\"\#\$\&\'\`$am_lf\ \	]*)
    as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
esac

# Do 'set' in a subshell so we don't clobber the current shell's
# arguments.  Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
   am_has_slept=no
   for am_try in 1 2; do
     echo "timestamp, slept: $am_has_slept" > conftest.file
     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
     if test "$*" = "X"; then
	# -L didn't work.
	set X `ls -t "$srcdir/configure" conftest.file`
     fi
     if test "$*" != "X $srcdir/configure conftest.file" \
	&& test "$*" != "X conftest.file $srcdir/configure"; then

	# If neither matched, then we have a broken ls.  This can happen
	# if, for instance, CONFIG_SHELL is bash and it inherits a
	# broken ls alias from the environment.  This has actually
	# happened.  Such a system could not be considered "sane".
	as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
  alias in your environment" "$LINENO" 5
     fi
     if test "$2" = conftest.file || test $am_try -eq 2; then
       break
     fi
     # Just in case.
     sleep 1
     am_has_slept=yes
   done
   test "$2" = conftest.file
   )
then
   # Ok.
   :
else
   as_fn_error $? "newly created file is older than distributed files!
Check your system clock" "$LINENO" 5
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
# If we didn't sleep, we still need to ensure time stamps of config.status and
# generated files are strictly newer.
am_sleep_pid=
if grep 'slept: no' conftest.file >/dev/null 2>&1; then
  ( sleep 1 ) &
  am_sleep_pid=$!
fi

rm -f conftest.file

test "$program_prefix" != NONE &&
  program_transform_name="s&^&$program_prefix&;$program_transform_name"
# Use a double $ so make ignores it.
test "$program_suffix" != NONE &&
  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
# Double any \ or $.
# By default was `s,x,x', remove it if useless.
ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`

# expand $ac_aux_dir to an absolute path
am_aux_dir=`cd $ac_aux_dir && pwd`

if test x"${MISSING+set}" != xset; then
  case $am_aux_dir in
  *\ * | *\	*)
    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
  *)
    MISSING="\${SHELL} $am_aux_dir/missing" ;;
  esac
fi
# Use eval to expand $SHELL
if eval "$MISSING --is-lightweight"; then
  am_missing_run="$MISSING "
else
  am_missing_run=
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
fi

if test x"${install_sh}" != xset; then
  case $am_aux_dir in
  *\ * | *\	*)
    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
  *)
    install_sh="\${SHELL} $am_aux_dir/install-sh"
  esac
fi

# Installed binaries are usually stripped using 'strip' when the user
# run "make install-strip".  However 'strip' might not be the right
# tool to use in cross-compilation environments, therefore Automake
# will honor the 'STRIP' environment variable to overrule this program.
if test "$cross_compiling" != no; then
  if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_STRIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$STRIP"; then
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
$as_echo "$STRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_STRIP"; then
  ac_ct_STRIP=$STRIP
  # Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_STRIP"; then
  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_STRIP="strip"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
$as_echo "$ac_ct_STRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_STRIP" = x; then
    STRIP=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    STRIP=$ac_ct_STRIP
  fi
else
  STRIP="$ac_cv_prog_STRIP"
fi

fi
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
if test -z "$MKDIR_P"; then
  if ${ac_cv_path_mkdir+:} false; then :
  $as_echo_n "(cached) " >&6
else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in mkdir gmkdir; do
	 for ac_exec_ext in '' $ac_executable_extensions; do
	   as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
	   case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
	     'mkdir (GNU coreutils) '* | \
	     'mkdir (coreutils) '* | \
	     'mkdir (fileutils) '4.1*)
	       ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
	       break 3;;
	   esac
	 done
       done
  done
IFS=$as_save_IFS

fi

  test -d ./--version && rmdir ./--version
  if test "${ac_cv_path_mkdir+set}" = set; then
    MKDIR_P="$ac_cv_path_mkdir -p"
  else
    # As a last resort, use the slow shell script.  Don't cache a
    # value for MKDIR_P within a source directory, because that will
    # break other packages using the cache if that directory is
    # removed, or if the value is a relative name.
    MKDIR_P="$ac_install_sh -d"
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
$as_echo "$MKDIR_P" >&6; }

for ac_prog in gawk mawk nawk awk
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_AWK+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$AWK"; then
  ac_cv_prog_AWK="$AWK" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_AWK="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
$as_echo "$AWK" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$AWK" && break
done

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
set x ${MAKE-make}
ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat >conftest.make <<\_ACEOF
SHELL = /bin/sh
all:
	@echo '@@@%%%=$(MAKE)=@@@%%%'
_ACEOF
# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
case `${MAKE-make} -f conftest.make 2>/dev/null` in
  *@@@%%%=?*=@@@%%%*)
    eval ac_cv_prog_make_${ac_make}_set=yes;;
  *)
    eval ac_cv_prog_make_${ac_make}_set=no;;
esac
rm -f conftest.make
fi
if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
  SET_MAKE=
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
  SET_MAKE="MAKE=${MAKE-make}"
fi

rm -rf .tst 2>/dev/null
mkdir .tst 2>/dev/null
if test -d .tst; then
  am__leading_dot=.
else
  am__leading_dot=_
fi
rmdir .tst 2>/dev/null

# Check whether --enable-silent-rules was given.
if test "${enable_silent_rules+set}" = set; then :
  enableval=$enable_silent_rules;
fi

case $enable_silent_rules in # (((
  yes) AM_DEFAULT_VERBOSITY=0;;
   no) AM_DEFAULT_VERBOSITY=1;;
    *) AM_DEFAULT_VERBOSITY=1;;
esac
am_make=${MAKE-make}
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
if ${am_cv_make_support_nested_variables+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if $as_echo 'TRUE=$(BAR$(V))
BAR0=false
BAR1=true
V=1
am__doit:
	@$(TRUE)
.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
  am_cv_make_support_nested_variables=yes
else
  am_cv_make_support_nested_variables=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
$as_echo "$am_cv_make_support_nested_variables" >&6; }
if test $am_cv_make_support_nested_variables = yes; then
    AM_V='$(V)'
  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
else
  AM_V=$AM_DEFAULT_VERBOSITY
  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
fi
AM_BACKSLASH='\'

if test "`cd $srcdir && pwd`" != "`pwd`"; then
  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
  # is not polluted with repeated "-I."
  am__isrc=' -I$(srcdir)'
  # test to see if srcdir already configured
  if test -f $srcdir/config.status; then
    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
  fi
fi

# test whether we have cygpath
if test -z "$CYGPATH_W"; then
  if (cygpath --version) >/dev/null 2>/dev/null; then
    CYGPATH_W='cygpath -w'
  else
    CYGPATH_W=echo
  fi
fi


# Define the identity of the package.
 PACKAGE='healpix_cxx'
 VERSION='3.30.0'


cat >>confdefs.h <<_ACEOF
#define PACKAGE "$PACKAGE"
_ACEOF


cat >>confdefs.h <<_ACEOF
#define VERSION "$VERSION"
_ACEOF

# Some tools Automake needs.

ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}


AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}


AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}


AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}


MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}

# For better backward compatibility.  To be removed once Automake 1.9.x
# dies out for good.  For more background, see:
# 
# 
mkdir_p='$(MKDIR_P)'

# We need awk for the "check" target.  The system "awk" is bad on
# some platforms.
# Always define AMTAR for backward compatibility.  Yes, it's still used
# in the wild :-(  We should find a proper way to deprecate it ...
AMTAR='$${TAR-tar}'


# We'll loop over all known methods to create a tar archive until one works.
_am_tools='gnutar  pax cpio none'

am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'







{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
$as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
    # Check whether --enable-maintainer-mode was given.
if test "${enable_maintainer_mode+set}" = set; then :
  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
else
  USE_MAINTAINER_MODE=yes
fi

  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
$as_echo "$USE_MAINTAINER_MODE" >&6; }
   if test $USE_MAINTAINER_MODE = yes; then
  MAINTAINER_MODE_TRUE=
  MAINTAINER_MODE_FALSE='#'
else
  MAINTAINER_MODE_TRUE='#'
  MAINTAINER_MODE_FALSE=
fi

  MAINT=$MAINTAINER_MODE_TRUE



DEPDIR="${am__leading_dot}deps"

ac_config_commands="$ac_config_commands depfiles"


am_make=${MAKE-make}
cat > confinc << 'END'
am__doit:
	@echo this is the am__doit target
.PHONY: am__doit
END
# If we don't find an include directive, just comment out the code.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
$as_echo_n "checking for style of include used by $am_make... " >&6; }
am__include="#"
am__quote=
_am_result=none
# First try GNU make style include.
echo "include confinc" > confmf
# Ignore all kinds of additional output from 'make'.
case `$am_make -s -f confmf 2> /dev/null` in #(
*the\ am__doit\ target*)
  am__include=include
  am__quote=
  _am_result=GNU
  ;;
esac
# Now try BSD make style include.
if test "$am__include" = "#"; then
   echo '.include "confinc"' > confmf
   case `$am_make -s -f confmf 2> /dev/null` in #(
   *the\ am__doit\ target*)
     am__include=.include
     am__quote="\""
     _am_result=BSD
     ;;
   esac
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
$as_echo "$_am_result" >&6; }
rm -f confinc confmf

# Check whether --enable-dependency-tracking was given.
if test "${enable_dependency_tracking+set}" = set; then :
  enableval=$enable_dependency_tracking;
fi

if test "x$enable_dependency_tracking" != xno; then
  am_depcomp="$ac_aux_dir/depcomp"
  AMDEPBACKSLASH='\'
  am__nodep='_no'
fi
 if test "x$enable_dependency_tracking" != xno; then
  AMDEP_TRUE=
  AMDEP_FALSE='#'
else
  AMDEP_TRUE='#'
  AMDEP_FALSE=
fi


ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_CC"; then
  ac_ct_CC=$CC
  # Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_CC="gcc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_CC" = x; then
    CC=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CC=$ac_ct_CC
  fi
else
  CC="$ac_cv_prog_CC"
fi

if test -z "$CC"; then
          if test -n "$ac_tool_prefix"; then
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="${ac_tool_prefix}cc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  fi
fi
if test -z "$CC"; then
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  ac_prog_rejected=no
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
       ac_prog_rejected=yes
       continue
     fi
    ac_cv_prog_CC="cc"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

if test $ac_prog_rejected = yes; then
  # We found a bogon in the path, so make sure we never use it.
  set dummy $ac_cv_prog_CC
  shift
  if test $# != 0; then
    # We chose a different compiler from the bogus one.
    # However, it has the same basename, so the bogon will be chosen
    # first if we set CC to just the basename; use the full file name.
    shift
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
  fi
fi
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$CC"; then
  if test -n "$ac_tool_prefix"; then
  for ac_prog in cl.exe
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$CC" && break
  done
fi
if test -z "$CC"; then
  ac_ct_CC=$CC
  for ac_prog in cl.exe
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CC"; then
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_CC="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_CC" && break
done

  if test "x$ac_ct_CC" = x; then
    CC=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CC=$ac_ct_CC
  fi
fi

fi


test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "no acceptable C compiler found in \$PATH
See \`config.log' for more details" "$LINENO" 5; }

# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
  { { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    sed '10a\
... rest of stderr output deleted ...
         10q' conftest.err >conftest.er1
    cat conftest.er1 >&5
  fi
  rm -f conftest.er1 conftest.err
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
done

cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
$as_echo_n "checking whether the C compiler works... " >&6; }
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`

# The possible output files:
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"

ac_rmfiles=
for ac_file in $ac_files
do
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
  esac
done
rm -f $ac_rmfiles

if { { ac_try="$ac_link_default"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link_default") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
# in a Makefile.  We should not override ac_cv_exeext if it was cached,
# so that the user can short-circuit this test for compilers unknown to
# Autoconf.
for ac_file in $ac_files ''
do
  test -f "$ac_file" || continue
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
	;;
    [ab].out )
	# We found the default executable, but exeext='' is most
	# certainly right.
	break;;
    *.* )
	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
	then :; else
	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
	fi
	# We set ac_cv_exeext here because the later test for it is not
	# safe: cross compilers may not add the suffix if given an `-o'
	# argument, so we may need to know it at that point already.
	# Even if this section looks crufty: it has the advantage of
	# actually working.
	break;;
    * )
	break;;
  esac
done
test "$ac_cv_exeext" = no && ac_cv_exeext=

else
  ac_file=''
fi
if test -z "$ac_file"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "C compiler cannot create executables
See \`config.log' for more details" "$LINENO" 5; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
$as_echo_n "checking for C compiler default output file name... " >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
$as_echo "$ac_file" >&6; }
ac_exeext=$ac_cv_exeext

rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
$as_echo_n "checking for suffix of executables... " >&6; }
if { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  # If both `conftest.exe' and `conftest' are `present' (well, observable)
# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
# work properly (i.e., refer to `conftest.exe'), while it won't with
# `rm'.
for ac_file in conftest.exe conftest conftest.*; do
  test -f "$ac_file" || continue
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
	  break;;
    * ) break;;
  esac
done
else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest conftest$ac_cv_exeext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
$as_echo "$ac_cv_exeext" >&6; }

rm -f conftest.$ac_ext
EXEEXT=$ac_cv_exeext
ac_exeext=$EXEEXT
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
int
main ()
{
FILE *f = fopen ("conftest.out", "w");
 return ferror (f) || fclose (f) != 0;

  ;
  return 0;
}
_ACEOF
ac_clean_files="$ac_clean_files conftest.out"
# Check that the compiler produces executables we can run.  If not, either
# the compiler is broken, or we cross compile.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
$as_echo_n "checking whether we are cross compiling... " >&6; }
if test "$cross_compiling" != yes; then
  { { ac_try="$ac_link"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_link") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
  if { ac_try='./conftest$ac_cv_exeext'
  { { case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_try") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; }; then
    cross_compiling=no
  else
    if test "$cross_compiling" = maybe; then
	cross_compiling=yes
    else
	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details" "$LINENO" 5; }
    fi
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
$as_echo "$cross_compiling" >&6; }

rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
$as_echo_n "checking for suffix of object files... " >&6; }
if ${ac_cv_objext+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
rm -f conftest.o conftest.obj
if { { ac_try="$ac_compile"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compile") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then :
  for ac_file in conftest.o conftest.obj conftest.*; do
  test -f "$ac_file" || continue;
  case $ac_file in
    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
       break;;
  esac
done
else
  $as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5

{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of object files: cannot compile
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest.$ac_cv_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
$as_echo "$ac_cv_objext" >&6; }
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
if ${ac_cv_c_compiler_gnu+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{
#ifndef __GNUC__
       choke me
#endif

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_compiler_gnu=yes
else
  ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
$as_echo "$ac_cv_c_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
  GCC=yes
else
  GCC=
fi
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
$as_echo_n "checking whether $CC accepts -g... " >&6; }
if ${ac_cv_prog_cc_g+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_save_c_werror_flag=$ac_c_werror_flag
   ac_c_werror_flag=yes
   ac_cv_prog_cc_g=no
   CFLAGS="-g"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_g=yes
else
  CFLAGS=""
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

else
  ac_c_werror_flag=$ac_save_c_werror_flag
	 CFLAGS="-g"
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
   ac_c_werror_flag=$ac_save_c_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
$as_echo "$ac_cv_prog_cc_g" >&6; }
if test "$ac_test_CFLAGS" = set; then
  CFLAGS=$ac_save_CFLAGS
elif test $ac_cv_prog_cc_g = yes; then
  if test "$GCC" = yes; then
    CFLAGS="-g -O2"
  else
    CFLAGS="-g"
  fi
else
  if test "$GCC" = yes; then
    CFLAGS="-O2"
  else
    CFLAGS=
  fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
if ${ac_cv_prog_cc_c89+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_cv_prog_cc_c89=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
#include 
struct stat;
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
struct buf { int x; };
FILE * (*rcsopen) (struct buf *, struct stat *, int);
static char *e (p, i)
     char **p;
     int i;
{
  return p[i];
}
static char *f (char * (*g) (char **, int), char **p, ...)
{
  char *s;
  va_list v;
  va_start (v,p);
  s = g (p, va_arg (v,int));
  va_end (v);
  return s;
}

/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
   function prototypes and stuff, but not '\xHH' hex character constants.
   These don't provoke an error unfortunately, instead are silently treated
   as 'x'.  The following induces an error, until -std is added to get
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
   array size at least.  It's necessary to write '\x00'==0 to get something
   that's true only with -std.  */
int osf4_cc_array ['\x00' == 0 ? 1 : -1];

/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
   inside strings and character constants.  */
#define FOO(x) 'x'
int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];

int test (int i, double x);
struct s1 {int (*f) (int a);};
struct s2 {int (*f) (double a);};
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
int argc;
char **argv;
int
main ()
{
return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
  ;
  return 0;
}
_ACEOF
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
  CC="$ac_save_CC $ac_arg"
  if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_c89=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext
  test "x$ac_cv_prog_cc_c89" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC

fi
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c89" in
  x)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
$as_echo "none needed" >&6; } ;;
  xno)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
$as_echo "unsupported" >&6; } ;;
  *)
    CC="$CC $ac_cv_prog_cc_c89"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
esac
if test "x$ac_cv_prog_cc_c89" != xno; then :

fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

depcc="$CC"   am_compiler_list=

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
$as_echo_n "checking dependency style of $depcc... " >&6; }
if ${am_cv_CC_dependencies_compiler_type+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
  # We make a subdir and do the tests there.  Otherwise we can end up
  # making bogus files that we don't know about and never remove.  For
  # instance it was reported that on HP-UX the gcc test will end up
  # making a dummy file named 'D' -- because '-MD' means "put the output
  # in D".
  rm -rf conftest.dir
  mkdir conftest.dir
  # Copy depcomp to subdir because otherwise we won't find it if we're
  # using a relative directory.
  cp "$am_depcomp" conftest.dir
  cd conftest.dir
  # We will build objects and dependencies in a subdirectory because
  # it helps to detect inapplicable dependency modes.  For instance
  # both Tru64's cc and ICC support -MD to output dependencies as a
  # side effect of compilation, but ICC will put the dependencies in
  # the current directory while Tru64 will put them in the object
  # directory.
  mkdir sub

  am_cv_CC_dependencies_compiler_type=none
  if test "$am_compiler_list" = ""; then
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
  fi
  am__universal=false
  case " $depcc " in #(
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
     esac

  for depmode in $am_compiler_list; do
    # Setup a source with many dependencies, because some compilers
    # like to wrap large dependency lists on column 80 (with \), and
    # we should not choose a depcomp mode which is confused by this.
    #
    # We need to recreate these files for each test, as the compiler may
    # overwrite some of them when testing with obscure command lines.
    # This happens at least with the AIX C compiler.
    : > sub/conftest.c
    for i in 1 2 3 4 5 6; do
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
      # Solaris 10 /bin/sh.
      echo '/* dummy */' > sub/conftst$i.h
    done
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

    # We check with '-c' and '-o' for the sake of the "dashmstdout"
    # mode.  It turns out that the SunPro C++ compiler does not properly
    # handle '-M -o', and we need to detect this.  Also, some Intel
    # versions had trouble with output in subdirs.
    am__obj=sub/conftest.${OBJEXT-o}
    am__minus_obj="-o $am__obj"
    case $depmode in
    gcc)
      # This depmode causes a compiler race in universal mode.
      test "$am__universal" = false || continue
      ;;
    nosideeffect)
      # After this tag, mechanisms are not by side-effect, so they'll
      # only be used when explicitly requested.
      if test "x$enable_dependency_tracking" = xyes; then
	continue
      else
	break
      fi
      ;;
    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
      # This compiler won't grok '-c -o', but also, the minuso test has
      # not run yet.  These depmodes are late enough in the game, and
      # so weak that their functioning should not be impacted.
      am__obj=conftest.${OBJEXT-o}
      am__minus_obj=
      ;;
    none) break ;;
    esac
    if depmode=$depmode \
       source=sub/conftest.c object=$am__obj \
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
         >/dev/null 2>conftest.err &&
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
      # icc doesn't choke on unknown options, it will just issue warnings
      # or remarks (even with -Werror).  So we grep stderr for any message
      # that says an option was ignored or not supported.
      # When given -MP, icc 7.0 and 7.1 complain thusly:
      #   icc: Command line warning: ignoring option '-M'; no argument required
      # The diagnosis changed in icc 8.0:
      #   icc: Command line remark: option '-MP' not supported
      if (grep 'ignoring option' conftest.err ||
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
        am_cv_CC_dependencies_compiler_type=$depmode
        break
      fi
    fi
  done

  cd ..
  rm -rf conftest.dir
else
  am_cv_CC_dependencies_compiler_type=none
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type

 if
  test "x$enable_dependency_tracking" != xno \
  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
  am__fastdepCC_TRUE=
  am__fastdepCC_FALSE='#'
else
  am__fastdepCC_TRUE='#'
  am__fastdepCC_FALSE=
fi



if test -n "$ac_tool_prefix"; then
  for ac_prog in ar lib "link -lib"
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_AR+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$AR"; then
  ac_cv_prog_AR="$AR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
AR=$ac_cv_prog_AR
if test -n "$AR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
$as_echo "$AR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$AR" && break
  done
fi
if test -z "$AR"; then
  ac_ct_AR=$AR
  for ac_prog in ar lib "link -lib"
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_AR+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_AR"; then
  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_AR="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_AR=$ac_cv_prog_ac_ct_AR
if test -n "$ac_ct_AR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
$as_echo "$ac_ct_AR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_AR" && break
done

  if test "x$ac_ct_AR" = x; then
    AR="false"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    AR=$ac_ct_AR
  fi
fi

: ${AR=ar}

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5
$as_echo_n "checking the archiver ($AR) interface... " >&6; }
if ${am_cv_ar_interface+:} false; then :
  $as_echo_n "(cached) " >&6
else
  am_cv_ar_interface=ar
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
int some_variable = 0;
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5'
      { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5
  (eval $am_ar_try) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
      if test "$ac_status" -eq 0; then
        am_cv_ar_interface=ar
      else
        am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5'
        { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5
  (eval $am_ar_try) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
        if test "$ac_status" -eq 0; then
          am_cv_ar_interface=lib
        else
          am_cv_ar_interface=unknown
        fi
      fi
      rm -f conftest.lib libconftest.a

fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5
$as_echo "$am_cv_ar_interface" >&6; }

case $am_cv_ar_interface in
ar)
  ;;
lib)
  # Microsoft lib, so override with the ar-lib wrapper script.
  # FIXME: It is wrong to rewrite AR.
  # But if we don't then we get into trouble of one sort or another.
  # A longer-term fix would be to have automake use am__AR in this case,
  # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something
  # similar.
  AR="$am_aux_dir/ar-lib $AR"
  ;;
unknown)
  as_fn_error $? "could not determine $AR interface" "$LINENO" 5
  ;;
esac


case `pwd` in
  *\ * | *\	*)
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
esac



macro_version='2.4.2'
macro_revision='1.3337'













ltmain="$ac_aux_dir/ltmain.sh"

# Make sure we can run config.sub.
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
$as_echo_n "checking build system type... " >&6; }
if ${ac_cv_build+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_build_alias=$build_alias
test "x$ac_build_alias" = x &&
  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
test "x$ac_build_alias" = x &&
  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
$as_echo "$ac_cv_build" >&6; }
case $ac_cv_build in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
esac
build=$ac_cv_build
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_build
shift
build_cpu=$1
build_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
build_os=$*
IFS=$ac_save_IFS
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
$as_echo_n "checking host system type... " >&6; }
if ${ac_cv_host+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test "x$host_alias" = x; then
  ac_cv_host=$ac_cv_build
else
  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
$as_echo "$ac_cv_host" >&6; }
case $ac_cv_host in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
esac
host=$ac_cv_host
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_host
shift
host_cpu=$1
host_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
host_os=$*
IFS=$ac_save_IFS
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac


# Backslashify metacharacters that are still active within
# double-quoted strings.
sed_quote_subst='s/\(["`$\\]\)/\\\1/g'

# Same as above, but do not quote variable references.
double_quote_subst='s/\(["`\\]\)/\\\1/g'

# Sed substitution to delay expansion of an escaped shell variable in a
# double_quote_subst'ed string.
delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

# Sed substitution to delay expansion of an escaped single quote.
delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'

# Sed substitution to avoid accidental globbing in evaled expressions
no_glob_subst='s/\*/\\\*/g'

ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
$as_echo_n "checking how to print strings... " >&6; }
# Test print first, because it will be a builtin if present.
if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
  ECHO='print -r --'
elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
  ECHO='printf %s\n'
else
  # Use this function as a fallback that always works.
  func_fallback_echo ()
  {
    eval 'cat <<_LTECHO_EOF
$1
_LTECHO_EOF'
  }
  ECHO='func_fallback_echo'
fi

# func_echo_all arg...
# Invoke $ECHO with all args, space-separated.
func_echo_all ()
{
    $ECHO ""
}

case "$ECHO" in
  printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
$as_echo "printf" >&6; } ;;
  print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
$as_echo "print -r" >&6; } ;;
  *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5
$as_echo "cat" >&6; } ;;
esac














{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
$as_echo_n "checking for a sed that does not truncate output... " >&6; }
if ${ac_cv_path_SED+:} false; then :
  $as_echo_n "(cached) " >&6
else
            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
     for ac_i in 1 2 3 4 5 6 7; do
       ac_script="$ac_script$as_nl$ac_script"
     done
     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
     { ac_script=; unset ac_script;}
     if test -z "$SED"; then
  ac_path_SED_found=false
  # Loop through the user's path and test for each of PROGNAME-LIST
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in sed gsed; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
      as_fn_executable_p "$ac_path_SED" || continue
# Check for GNU ac_path_SED and select it if it is found.
  # Check for GNU $ac_path_SED
case `"$ac_path_SED" --version 2>&1` in
*GNU*)
  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
*)
  ac_count=0
  $as_echo_n 0123456789 >"conftest.in"
  while :
  do
    cat "conftest.in" "conftest.in" >"conftest.tmp"
    mv "conftest.tmp" "conftest.in"
    cp "conftest.in" "conftest.nl"
    $as_echo '' >> "conftest.nl"
    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    as_fn_arith $ac_count + 1 && ac_count=$as_val
    if test $ac_count -gt ${ac_path_SED_max-0}; then
      # Best one so far, save it but keep looking for a better one
      ac_cv_path_SED="$ac_path_SED"
      ac_path_SED_max=$ac_count
    fi
    # 10*(2^10) chars as input seems more than enough
    test $ac_count -gt 10 && break
  done
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac

      $ac_path_SED_found && break 3
    done
  done
  done
IFS=$as_save_IFS
  if test -z "$ac_cv_path_SED"; then
    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
  fi
else
  ac_cv_path_SED=$SED
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
$as_echo "$ac_cv_path_SED" >&6; }
 SED="$ac_cv_path_SED"
  rm -f conftest.sed

test -z "$SED" && SED=sed
Xsed="$SED -e 1s/^X//"











{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
if ${ac_cv_path_GREP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -z "$GREP"; then
  ac_path_GREP_found=false
  # Loop through the user's path and test for each of PROGNAME-LIST
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in grep ggrep; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
      as_fn_executable_p "$ac_path_GREP" || continue
# Check for GNU ac_path_GREP and select it if it is found.
  # Check for GNU $ac_path_GREP
case `"$ac_path_GREP" --version 2>&1` in
*GNU*)
  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
*)
  ac_count=0
  $as_echo_n 0123456789 >"conftest.in"
  while :
  do
    cat "conftest.in" "conftest.in" >"conftest.tmp"
    mv "conftest.tmp" "conftest.in"
    cp "conftest.in" "conftest.nl"
    $as_echo 'GREP' >> "conftest.nl"
    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    as_fn_arith $ac_count + 1 && ac_count=$as_val
    if test $ac_count -gt ${ac_path_GREP_max-0}; then
      # Best one so far, save it but keep looking for a better one
      ac_cv_path_GREP="$ac_path_GREP"
      ac_path_GREP_max=$ac_count
    fi
    # 10*(2^10) chars as input seems more than enough
    test $ac_count -gt 10 && break
  done
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac

      $ac_path_GREP_found && break 3
    done
  done
  done
IFS=$as_save_IFS
  if test -z "$ac_cv_path_GREP"; then
    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  fi
else
  ac_cv_path_GREP=$GREP
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
$as_echo "$ac_cv_path_GREP" >&6; }
 GREP="$ac_cv_path_GREP"


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
$as_echo_n "checking for egrep... " >&6; }
if ${ac_cv_path_EGREP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
   then ac_cv_path_EGREP="$GREP -E"
   else
     if test -z "$EGREP"; then
  ac_path_EGREP_found=false
  # Loop through the user's path and test for each of PROGNAME-LIST
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in egrep; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
      as_fn_executable_p "$ac_path_EGREP" || continue
# Check for GNU ac_path_EGREP and select it if it is found.
  # Check for GNU $ac_path_EGREP
case `"$ac_path_EGREP" --version 2>&1` in
*GNU*)
  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
*)
  ac_count=0
  $as_echo_n 0123456789 >"conftest.in"
  while :
  do
    cat "conftest.in" "conftest.in" >"conftest.tmp"
    mv "conftest.tmp" "conftest.in"
    cp "conftest.in" "conftest.nl"
    $as_echo 'EGREP' >> "conftest.nl"
    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    as_fn_arith $ac_count + 1 && ac_count=$as_val
    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
      # Best one so far, save it but keep looking for a better one
      ac_cv_path_EGREP="$ac_path_EGREP"
      ac_path_EGREP_max=$ac_count
    fi
    # 10*(2^10) chars as input seems more than enough
    test $ac_count -gt 10 && break
  done
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac

      $ac_path_EGREP_found && break 3
    done
  done
  done
IFS=$as_save_IFS
  if test -z "$ac_cv_path_EGREP"; then
    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  fi
else
  ac_cv_path_EGREP=$EGREP
fi

   fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
$as_echo "$ac_cv_path_EGREP" >&6; }
 EGREP="$ac_cv_path_EGREP"


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
$as_echo_n "checking for fgrep... " >&6; }
if ${ac_cv_path_FGREP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
   then ac_cv_path_FGREP="$GREP -F"
   else
     if test -z "$FGREP"; then
  ac_path_FGREP_found=false
  # Loop through the user's path and test for each of PROGNAME-LIST
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_prog in fgrep; do
    for ac_exec_ext in '' $ac_executable_extensions; do
      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
      as_fn_executable_p "$ac_path_FGREP" || continue
# Check for GNU ac_path_FGREP and select it if it is found.
  # Check for GNU $ac_path_FGREP
case `"$ac_path_FGREP" --version 2>&1` in
*GNU*)
  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
*)
  ac_count=0
  $as_echo_n 0123456789 >"conftest.in"
  while :
  do
    cat "conftest.in" "conftest.in" >"conftest.tmp"
    mv "conftest.tmp" "conftest.in"
    cp "conftest.in" "conftest.nl"
    $as_echo 'FGREP' >> "conftest.nl"
    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
    as_fn_arith $ac_count + 1 && ac_count=$as_val
    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
      # Best one so far, save it but keep looking for a better one
      ac_cv_path_FGREP="$ac_path_FGREP"
      ac_path_FGREP_max=$ac_count
    fi
    # 10*(2^10) chars as input seems more than enough
    test $ac_count -gt 10 && break
  done
  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac

      $ac_path_FGREP_found && break 3
    done
  done
  done
IFS=$as_save_IFS
  if test -z "$ac_cv_path_FGREP"; then
    as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
  fi
else
  ac_cv_path_FGREP=$FGREP
fi

   fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
$as_echo "$ac_cv_path_FGREP" >&6; }
 FGREP="$ac_cv_path_FGREP"


test -z "$GREP" && GREP=grep



















# Check whether --with-gnu-ld was given.
if test "${with_gnu_ld+set}" = set; then :
  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
else
  with_gnu_ld=no
fi

ac_prog=ld
if test "$GCC" = yes; then
  # Check if gcc -print-prog-name=ld gives a path.
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
$as_echo_n "checking for ld used by $CC... " >&6; }
  case $host in
  *-*-mingw*)
    # gcc leaves a trailing carriage return which upsets mingw
    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
  *)
    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
  esac
  case $ac_prog in
    # Accept absolute paths.
    [\\/]* | ?:[\\/]*)
      re_direlt='/[^/][^/]*/\.\./'
      # Canonicalize the pathname of ld
      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
      done
      test -z "$LD" && LD="$ac_prog"
      ;;
  "")
    # If it fails, then pretend we aren't using GCC.
    ac_prog=ld
    ;;
  *)
    # If it is relative, then search for the first ld in PATH.
    with_gnu_ld=unknown
    ;;
  esac
elif test "$with_gnu_ld" = yes; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
$as_echo_n "checking for GNU ld... " >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
$as_echo_n "checking for non-GNU ld... " >&6; }
fi
if ${lt_cv_path_LD+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -z "$LD"; then
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
  for ac_dir in $PATH; do
    IFS="$lt_save_ifs"
    test -z "$ac_dir" && ac_dir=.
    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
      lt_cv_path_LD="$ac_dir/$ac_prog"
      # Check to see if the program is GNU ld.  I'd rather use --version,
      # but apparently some variants of GNU ld only accept -v.
      # Break only if it was the GNU/non-GNU ld that we prefer.
      case `"$lt_cv_path_LD" -v 2>&1 &5
$as_echo "$LD" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; }
if ${lt_cv_prog_gnu_ld+:} false; then :
  $as_echo_n "(cached) " >&6
else
  # I'd rather use --version here, but apparently some GNU lds only accept -v.
case `$LD -v 2>&1 &5
$as_echo "$lt_cv_prog_gnu_ld" >&6; }
with_gnu_ld=$lt_cv_prog_gnu_ld









{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
if ${lt_cv_path_NM+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$NM"; then
  # Let the user override the test.
  lt_cv_path_NM="$NM"
else
  lt_nm_to_check="${ac_tool_prefix}nm"
  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
    lt_nm_to_check="$lt_nm_to_check nm"
  fi
  for lt_tmp_nm in $lt_nm_to_check; do
    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
      IFS="$lt_save_ifs"
      test -z "$ac_dir" && ac_dir=.
      tmp_nm="$ac_dir/$lt_tmp_nm"
      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
	# Check to see if the nm accepts a BSD-compat flag.
	# Adding the `sed 1q' prevents false positives on HP-UX, which says:
	#   nm: unknown option "B" ignored
	# Tru64's nm complains that /dev/null is an invalid object file
	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
	*/dev/null* | *'Invalid file or object type'*)
	  lt_cv_path_NM="$tmp_nm -B"
	  break
	  ;;
	*)
	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
	  */dev/null*)
	    lt_cv_path_NM="$tmp_nm -p"
	    break
	    ;;
	  *)
	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
	    continue # so that we can try to find one that supports BSD flags
	    ;;
	  esac
	  ;;
	esac
      fi
    done
    IFS="$lt_save_ifs"
  done
  : ${lt_cv_path_NM=no}
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
$as_echo "$lt_cv_path_NM" >&6; }
if test "$lt_cv_path_NM" != "no"; then
  NM="$lt_cv_path_NM"
else
  # Didn't find any BSD compatible name lister, look for dumpbin.
  if test -n "$DUMPBIN"; then :
    # Let the user override the test.
  else
    if test -n "$ac_tool_prefix"; then
  for ac_prog in dumpbin "link -dump"
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_DUMPBIN+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$DUMPBIN"; then
  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
DUMPBIN=$ac_cv_prog_DUMPBIN
if test -n "$DUMPBIN"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
$as_echo "$DUMPBIN" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$DUMPBIN" && break
  done
fi
if test -z "$DUMPBIN"; then
  ac_ct_DUMPBIN=$DUMPBIN
  for ac_prog in dumpbin "link -dump"
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_DUMPBIN"; then
  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
if test -n "$ac_ct_DUMPBIN"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
$as_echo "$ac_ct_DUMPBIN" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_DUMPBIN" && break
done

  if test "x$ac_ct_DUMPBIN" = x; then
    DUMPBIN=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    DUMPBIN=$ac_ct_DUMPBIN
  fi
fi

    case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in
    *COFF*)
      DUMPBIN="$DUMPBIN -symbols"
      ;;
    *)
      DUMPBIN=:
      ;;
    esac
  fi

  if test "$DUMPBIN" != ":"; then
    NM="$DUMPBIN"
  fi
fi
test -z "$NM" && NM=nm






{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
$as_echo_n "checking the name lister ($NM) interface... " >&6; }
if ${lt_cv_nm_interface+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_nm_interface="BSD nm"
  echo "int some_variable = 0;" > conftest.$ac_ext
  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
  (eval "$ac_compile" 2>conftest.err)
  cat conftest.err >&5
  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
  cat conftest.err >&5
  (eval echo "\"\$as_me:$LINENO: output\"" >&5)
  cat conftest.out >&5
  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
    lt_cv_nm_interface="MS dumpbin"
  fi
  rm -f conftest*
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
$as_echo "$lt_cv_nm_interface" >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
$as_echo_n "checking whether ln -s works... " >&6; }
LN_S=$as_ln_s
if test "$LN_S" = "ln -s"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
$as_echo "no, using $LN_S" >&6; }
fi

# find the maximum length of command line arguments
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
$as_echo_n "checking the maximum length of command line arguments... " >&6; }
if ${lt_cv_sys_max_cmd_len+:} false; then :
  $as_echo_n "(cached) " >&6
else
    i=0
  teststring="ABCD"

  case $build_os in
  msdosdjgpp*)
    # On DJGPP, this test can blow up pretty badly due to problems in libc
    # (any single argument exceeding 2000 bytes causes a buffer overrun
    # during glob expansion).  Even if it were fixed, the result of this
    # check would be larger than it should be.
    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
    ;;

  gnu*)
    # Under GNU Hurd, this test is not required because there is
    # no limit to the length of command line arguments.
    # Libtool will interpret -1 as no limit whatsoever
    lt_cv_sys_max_cmd_len=-1;
    ;;

  cygwin* | mingw* | cegcc*)
    # On Win9x/ME, this test blows up -- it succeeds, but takes
    # about 5 minutes as the teststring grows exponentially.
    # Worse, since 9x/ME are not pre-emptively multitasking,
    # you end up with a "frozen" computer, even though with patience
    # the test eventually succeeds (with a max line length of 256k).
    # Instead, let's just punt: use the minimum linelength reported by
    # all of the supported platforms: 8192 (on NT/2K/XP).
    lt_cv_sys_max_cmd_len=8192;
    ;;

  mint*)
    # On MiNT this can take a long time and run out of memory.
    lt_cv_sys_max_cmd_len=8192;
    ;;

  amigaos*)
    # On AmigaOS with pdksh, this test takes hours, literally.
    # So we just punt and use a minimum line length of 8192.
    lt_cv_sys_max_cmd_len=8192;
    ;;

  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
    # This has been around since 386BSD, at least.  Likely further.
    if test -x /sbin/sysctl; then
      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
    elif test -x /usr/sbin/sysctl; then
      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
    else
      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
    fi
    # And add a safety zone
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
    ;;

  interix*)
    # We know the value 262144 and hardcode it with a safety zone (like BSD)
    lt_cv_sys_max_cmd_len=196608
    ;;

  os2*)
    # The test takes a long time on OS/2.
    lt_cv_sys_max_cmd_len=8192
    ;;

  osf*)
    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
    # nice to cause kernel panics so lets avoid the loop below.
    # First set a reasonable default.
    lt_cv_sys_max_cmd_len=16384
    #
    if test -x /sbin/sysconfig; then
      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
        *1*) lt_cv_sys_max_cmd_len=-1 ;;
      esac
    fi
    ;;
  sco3.2v5*)
    lt_cv_sys_max_cmd_len=102400
    ;;
  sysv5* | sco5v6* | sysv4.2uw2*)
    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
    if test -n "$kargmax"; then
      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[	 ]//'`
    else
      lt_cv_sys_max_cmd_len=32768
    fi
    ;;
  *)
    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
    if test -n "$lt_cv_sys_max_cmd_len"; then
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
    else
      # Make teststring a little bigger before we do anything with it.
      # a 1K string should be a reasonable start.
      for i in 1 2 3 4 5 6 7 8 ; do
        teststring=$teststring$teststring
      done
      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
      # If test is not a shell built-in, we'll probably end up computing a
      # maximum length that is only half of the actual maximum length, but
      # we can't tell.
      while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \
	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
	      test $i != 17 # 1/2 MB should be enough
      do
        i=`expr $i + 1`
        teststring=$teststring$teststring
      done
      # Only check the string length outside the loop.
      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
      teststring=
      # Add a significant safety factor because C++ compilers can tack on
      # massive amounts of additional arguments before passing them to the
      # linker.  It appears as though 1/2 is a usable value.
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
    fi
    ;;
  esac

fi

if test -n $lt_cv_sys_max_cmd_len ; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
$as_echo "$lt_cv_sys_max_cmd_len" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
$as_echo "none" >&6; }
fi
max_cmd_len=$lt_cv_sys_max_cmd_len






: ${CP="cp -f"}
: ${MV="mv -f"}
: ${RM="rm -f"}

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5
$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; }
# Try some XSI features
xsi_shell=no
( _lt_dummy="a/b/c"
  test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \
      = c,a/b,b/c, \
    && eval 'test $(( 1 + 1 )) -eq 2 \
    && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
  && xsi_shell=yes
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5
$as_echo "$xsi_shell" >&6; }


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5
$as_echo_n "checking whether the shell understands \"+=\"... " >&6; }
lt_shell_append=no
( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \
    >/dev/null 2>&1 \
  && lt_shell_append=yes
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5
$as_echo "$lt_shell_append" >&6; }


if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  lt_unset=unset
else
  lt_unset=false
fi





# test EBCDIC or ASCII
case `echo X|tr X '\101'` in
 A) # ASCII based system
    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
  lt_SP2NL='tr \040 \012'
  lt_NL2SP='tr \015\012 \040\040'
  ;;
 *) # EBCDIC based system
  lt_SP2NL='tr \100 \n'
  lt_NL2SP='tr \r\n \100\100'
  ;;
esac









{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
$as_echo_n "checking how to convert $build file names to $host format... " >&6; }
if ${lt_cv_to_host_file_cmd+:} false; then :
  $as_echo_n "(cached) " >&6
else
  case $host in
  *-*-mingw* )
    case $build in
      *-*-mingw* ) # actually msys
        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
        ;;
      *-*-cygwin* )
        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
        ;;
      * ) # otherwise, assume *nix
        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
        ;;
    esac
    ;;
  *-*-cygwin* )
    case $build in
      *-*-mingw* ) # actually msys
        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
        ;;
      *-*-cygwin* )
        lt_cv_to_host_file_cmd=func_convert_file_noop
        ;;
      * ) # otherwise, assume *nix
        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
        ;;
    esac
    ;;
  * ) # unhandled hosts (and "normal" native builds)
    lt_cv_to_host_file_cmd=func_convert_file_noop
    ;;
esac

fi

to_host_file_cmd=$lt_cv_to_host_file_cmd
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
$as_echo "$lt_cv_to_host_file_cmd" >&6; }





{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
$as_echo_n "checking how to convert $build file names to toolchain format... " >&6; }
if ${lt_cv_to_tool_file_cmd+:} false; then :
  $as_echo_n "(cached) " >&6
else
  #assume ordinary cross tools, or native build.
lt_cv_to_tool_file_cmd=func_convert_file_noop
case $host in
  *-*-mingw* )
    case $build in
      *-*-mingw* ) # actually msys
        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
        ;;
    esac
    ;;
esac

fi

to_tool_file_cmd=$lt_cv_to_tool_file_cmd
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
$as_echo "$lt_cv_to_tool_file_cmd" >&6; }





{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
$as_echo_n "checking for $LD option to reload object files... " >&6; }
if ${lt_cv_ld_reload_flag+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_ld_reload_flag='-r'
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
$as_echo "$lt_cv_ld_reload_flag" >&6; }
reload_flag=$lt_cv_ld_reload_flag
case $reload_flag in
"" | " "*) ;;
*) reload_flag=" $reload_flag" ;;
esac
reload_cmds='$LD$reload_flag -o $output$reload_objs'
case $host_os in
  cygwin* | mingw* | pw32* | cegcc*)
    if test "$GCC" != yes; then
      reload_cmds=false
    fi
    ;;
  darwin*)
    if test "$GCC" = yes; then
      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
    else
      reload_cmds='$LD$reload_flag -o $output$reload_objs'
    fi
    ;;
esac









if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
set dummy ${ac_tool_prefix}objdump; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_OBJDUMP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$OBJDUMP"; then
  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
OBJDUMP=$ac_cv_prog_OBJDUMP
if test -n "$OBJDUMP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
$as_echo "$OBJDUMP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_OBJDUMP"; then
  ac_ct_OBJDUMP=$OBJDUMP
  # Extract the first word of "objdump", so it can be a program name with args.
set dummy objdump; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_OBJDUMP"; then
  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_OBJDUMP="objdump"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
if test -n "$ac_ct_OBJDUMP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
$as_echo "$ac_ct_OBJDUMP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_OBJDUMP" = x; then
    OBJDUMP="false"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    OBJDUMP=$ac_ct_OBJDUMP
  fi
else
  OBJDUMP="$ac_cv_prog_OBJDUMP"
fi

test -z "$OBJDUMP" && OBJDUMP=objdump









{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
$as_echo_n "checking how to recognize dependent libraries... " >&6; }
if ${lt_cv_deplibs_check_method+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_file_magic_cmd='$MAGIC_CMD'
lt_cv_file_magic_test_file=
lt_cv_deplibs_check_method='unknown'
# Need to set the preceding variable on all platforms that support
# interlibrary dependencies.
# 'none' -- dependencies not supported.
# `unknown' -- same as none, but documents that we really don't know.
# 'pass_all' -- all dependencies passed with no checks.
# 'test_compile' -- check by making test program.
# 'file_magic [[regex]]' -- check by looking for files in library path
# which responds to the $file_magic_cmd with a given extended regex.
# If you have `file' or equivalent on your system and you're not sure
# whether `pass_all' will *always* work, you probably want this one.

case $host_os in
aix[4-9]*)
  lt_cv_deplibs_check_method=pass_all
  ;;

beos*)
  lt_cv_deplibs_check_method=pass_all
  ;;

bsdi[45]*)
  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
  lt_cv_file_magic_cmd='/usr/bin/file -L'
  lt_cv_file_magic_test_file=/shlib/libc.so
  ;;

cygwin*)
  # func_win32_libid is a shell function defined in ltmain.sh
  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
  lt_cv_file_magic_cmd='func_win32_libid'
  ;;

mingw* | pw32*)
  # Base MSYS/MinGW do not provide the 'file' command needed by
  # func_win32_libid shell function, so use a weaker test based on 'objdump',
  # unless we find 'file', for example because we are cross-compiling.
  # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin.
  if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then
    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
    lt_cv_file_magic_cmd='func_win32_libid'
  else
    # Keep this pattern in sync with the one in func_win32_libid.
    lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
    lt_cv_file_magic_cmd='$OBJDUMP -f'
  fi
  ;;

cegcc*)
  # use the weaker test based on 'objdump'. See mingw*.
  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
  lt_cv_file_magic_cmd='$OBJDUMP -f'
  ;;

darwin* | rhapsody*)
  lt_cv_deplibs_check_method=pass_all
  ;;

freebsd* | dragonfly*)
  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
    case $host_cpu in
    i*86 )
      # Not sure whether the presence of OpenBSD here was a mistake.
      # Let's accept both of them until this is cleared up.
      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
      lt_cv_file_magic_cmd=/usr/bin/file
      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
      ;;
    esac
  else
    lt_cv_deplibs_check_method=pass_all
  fi
  ;;

gnu*)
  lt_cv_deplibs_check_method=pass_all
  ;;

haiku*)
  lt_cv_deplibs_check_method=pass_all
  ;;

hpux10.20* | hpux11*)
  lt_cv_file_magic_cmd=/usr/bin/file
  case $host_cpu in
  ia64*)
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
    ;;
  hppa*64*)
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'
    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
    ;;
  *)
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library'
    lt_cv_file_magic_test_file=/usr/lib/libc.sl
    ;;
  esac
  ;;

interix[3-9]*)
  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
  ;;

irix5* | irix6* | nonstopux*)
  case $LD in
  *-32|*"-32 ") libmagic=32-bit;;
  *-n32|*"-n32 ") libmagic=N32;;
  *-64|*"-64 ") libmagic=64-bit;;
  *) libmagic=never-match;;
  esac
  lt_cv_deplibs_check_method=pass_all
  ;;

# This must be glibc/ELF.
linux* | k*bsd*-gnu | kopensolaris*-gnu)
  lt_cv_deplibs_check_method=pass_all
  ;;

netbsd*)
  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
  else
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
  fi
  ;;

newos6*)
  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
  lt_cv_file_magic_cmd=/usr/bin/file
  lt_cv_file_magic_test_file=/usr/lib/libnls.so
  ;;

*nto* | *qnx*)
  lt_cv_deplibs_check_method=pass_all
  ;;

openbsd*)
  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
  else
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
  fi
  ;;

osf3* | osf4* | osf5*)
  lt_cv_deplibs_check_method=pass_all
  ;;

rdos*)
  lt_cv_deplibs_check_method=pass_all
  ;;

solaris*)
  lt_cv_deplibs_check_method=pass_all
  ;;

sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
  lt_cv_deplibs_check_method=pass_all
  ;;

sysv4 | sysv4.3*)
  case $host_vendor in
  motorola)
    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
    ;;
  ncr)
    lt_cv_deplibs_check_method=pass_all
    ;;
  sequent)
    lt_cv_file_magic_cmd='/bin/file'
    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
    ;;
  sni)
    lt_cv_file_magic_cmd='/bin/file'
    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
    lt_cv_file_magic_test_file=/lib/libc.so
    ;;
  siemens)
    lt_cv_deplibs_check_method=pass_all
    ;;
  pc)
    lt_cv_deplibs_check_method=pass_all
    ;;
  esac
  ;;

tpf*)
  lt_cv_deplibs_check_method=pass_all
  ;;
esac

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
$as_echo "$lt_cv_deplibs_check_method" >&6; }

file_magic_glob=
want_nocaseglob=no
if test "$build" = "$host"; then
  case $host_os in
  mingw* | pw32*)
    if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
      want_nocaseglob=yes
    else
      file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"`
    fi
    ;;
  esac
fi

file_magic_cmd=$lt_cv_file_magic_cmd
deplibs_check_method=$lt_cv_deplibs_check_method
test -z "$deplibs_check_method" && deplibs_check_method=unknown






















if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
set dummy ${ac_tool_prefix}dlltool; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_DLLTOOL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$DLLTOOL"; then
  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
DLLTOOL=$ac_cv_prog_DLLTOOL
if test -n "$DLLTOOL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
$as_echo "$DLLTOOL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_DLLTOOL"; then
  ac_ct_DLLTOOL=$DLLTOOL
  # Extract the first word of "dlltool", so it can be a program name with args.
set dummy dlltool; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_DLLTOOL"; then
  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
if test -n "$ac_ct_DLLTOOL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
$as_echo "$ac_ct_DLLTOOL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_DLLTOOL" = x; then
    DLLTOOL="false"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    DLLTOOL=$ac_ct_DLLTOOL
  fi
else
  DLLTOOL="$ac_cv_prog_DLLTOOL"
fi

test -z "$DLLTOOL" && DLLTOOL=dlltool










{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
$as_echo_n "checking how to associate runtime and link libraries... " >&6; }
if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_sharedlib_from_linklib_cmd='unknown'

case $host_os in
cygwin* | mingw* | pw32* | cegcc*)
  # two different shell functions defined in ltmain.sh
  # decide which to use based on capabilities of $DLLTOOL
  case `$DLLTOOL --help 2>&1` in
  *--identify-strict*)
    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
    ;;
  *)
    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
    ;;
  esac
  ;;
*)
  # fallback: assume linklib IS sharedlib
  lt_cv_sharedlib_from_linklib_cmd="$ECHO"
  ;;
esac

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
$as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO







if test -n "$ac_tool_prefix"; then
  for ac_prog in ar
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_AR+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$AR"; then
  ac_cv_prog_AR="$AR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
AR=$ac_cv_prog_AR
if test -n "$AR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
$as_echo "$AR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$AR" && break
  done
fi
if test -z "$AR"; then
  ac_ct_AR=$AR
  for ac_prog in ar
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_AR+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_AR"; then
  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_AR="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_AR=$ac_cv_prog_ac_ct_AR
if test -n "$ac_ct_AR"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
$as_echo "$ac_ct_AR" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_AR" && break
done

  if test "x$ac_ct_AR" = x; then
    AR="false"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    AR=$ac_ct_AR
  fi
fi

: ${AR=ar}
: ${AR_FLAGS=cru}











{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
$as_echo_n "checking for archiver @FILE support... " >&6; }
if ${lt_cv_ar_at_file+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_ar_at_file=no
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  echo conftest.$ac_objext > conftest.lst
      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5'
      { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
  (eval $lt_ar_try) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
      if test "$ac_status" -eq 0; then
	# Ensure the archiver fails upon bogus file names.
	rm -f conftest.$ac_objext libconftest.a
	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
  (eval $lt_ar_try) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
	if test "$ac_status" -ne 0; then
          lt_cv_ar_at_file=@
        fi
      fi
      rm -f conftest.* libconftest.a

fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
$as_echo "$lt_cv_ar_at_file" >&6; }

if test "x$lt_cv_ar_at_file" = xno; then
  archiver_list_spec=
else
  archiver_list_spec=$lt_cv_ar_at_file
fi







if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_STRIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$STRIP"; then
  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
$as_echo "$STRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_STRIP"; then
  ac_ct_STRIP=$STRIP
  # Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_STRIP"; then
  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_STRIP="strip"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
$as_echo "$ac_ct_STRIP" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_STRIP" = x; then
    STRIP=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    STRIP=$ac_ct_STRIP
  fi
else
  STRIP="$ac_cv_prog_STRIP"
fi

test -z "$STRIP" && STRIP=:






if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_RANLIB+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$RANLIB"; then
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
RANLIB=$ac_cv_prog_RANLIB
if test -n "$RANLIB"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
$as_echo "$RANLIB" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_RANLIB"; then
  ac_ct_RANLIB=$RANLIB
  # Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_RANLIB"; then
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_RANLIB="ranlib"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
if test -n "$ac_ct_RANLIB"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
$as_echo "$ac_ct_RANLIB" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_RANLIB" = x; then
    RANLIB=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    RANLIB=$ac_ct_RANLIB
  fi
else
  RANLIB="$ac_cv_prog_RANLIB"
fi

test -z "$RANLIB" && RANLIB=:






# Determine commands to create old-style static archives.
old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
old_postinstall_cmds='chmod 644 $oldlib'
old_postuninstall_cmds=

if test -n "$RANLIB"; then
  case $host_os in
  openbsd*)
    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
    ;;
  *)
    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
    ;;
  esac
  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
fi

case $host_os in
  darwin*)
    lock_old_archive_extraction=yes ;;
  *)
    lock_old_archive_extraction=no ;;
esac







































# If no C compiler was specified, use CC.
LTCC=${LTCC-"$CC"}

# If no C compiler flags were specified, use CFLAGS.
LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

# Allow CC to be a program name with arguments.
compiler=$CC


# Check for command to grab the raw symbol name followed by C symbol from nm.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; }
if ${lt_cv_sys_global_symbol_pipe+:} false; then :
  $as_echo_n "(cached) " >&6
else

# These are sane defaults that work on at least a few old systems.
# [They come from Ultrix.  What could be older than Ultrix?!! ;)]

# Character class describing NM global symbol codes.
symcode='[BCDEGRST]'

# Regexp to match symbols that can be accessed directly from C.
sympat='\([_A-Za-z][_A-Za-z0-9]*\)'

# Define system-specific variables.
case $host_os in
aix*)
  symcode='[BCDT]'
  ;;
cygwin* | mingw* | pw32* | cegcc*)
  symcode='[ABCDGISTW]'
  ;;
hpux*)
  if test "$host_cpu" = ia64; then
    symcode='[ABCDEGRST]'
  fi
  ;;
irix* | nonstopux*)
  symcode='[BCDEGRST]'
  ;;
osf*)
  symcode='[BCDEGQRST]'
  ;;
solaris*)
  symcode='[BDRT]'
  ;;
sco3.2v5*)
  symcode='[DT]'
  ;;
sysv4.2uw2*)
  symcode='[DT]'
  ;;
sysv5* | sco5v6* | unixware* | OpenUNIX*)
  symcode='[ABDT]'
  ;;
sysv4)
  symcode='[DFNSTU]'
  ;;
esac

# If we're using GNU nm, then use its standard symbol codes.
case `$NM -V 2>&1` in
*GNU* | *'with BFD'*)
  symcode='[ABCDGIRSTW]' ;;
esac

# Transform an extracted symbol line into a proper C declaration.
# Some systems (esp. on ia64) link data and code symbols differently,
# so use this general approach.
lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"

# Transform an extracted symbol line into symbol name and symbol address
lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\)[ ]*$/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (void *) \&\2},/p'"
lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\)[ ]*$/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/  {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"lib\2\", (void *) \&\2},/p'"

# Handle CRLF in mingw tool chain
opt_cr=
case $build_os in
mingw*)
  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
  ;;
esac

# Try without a prefix underscore, then with it.
for ac_symprfx in "" "_"; do

  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
  symxfrm="\\1 $ac_symprfx\\2 \\2"

  # Write the raw and C identifiers.
  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
    # Fake it for dumpbin and say T for any non-static function
    # and D for any global variable.
    # Also find C++ and __fastcall symbols from MSVC++,
    # which start with @ or ?.
    lt_cv_sys_global_symbol_pipe="$AWK '"\
"     {last_section=section; section=\$ 3};"\
"     /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
"     \$ 0!~/External *\|/{next};"\
"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
"     {if(hide[section]) next};"\
"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
"     ' prfx=^$ac_symprfx"
  else
    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[	 ]\($symcode$symcode*\)[	 ][	 ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
  fi
  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"

  # Check to see that the pipe works correctly.
  pipe_works=no

  rm -f conftest*
  cat > conftest.$ac_ext <<_LT_EOF
#ifdef __cplusplus
extern "C" {
#endif
char nm_test_var;
void nm_test_func(void);
void nm_test_func(void){}
#ifdef __cplusplus
}
#endif
int main(){nm_test_var='a';nm_test_func();return(0);}
_LT_EOF

  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  (eval $ac_compile) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
    # Now try to grab the symbols.
    nlist=conftest.nm
    if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5
  (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && test -s "$nlist"; then
      # Try sorting and uniquifying the output.
      if sort "$nlist" | uniq > "$nlist"T; then
	mv -f "$nlist"T "$nlist"
      else
	rm -f "$nlist"T
      fi

      # Make sure that we snagged all the symbols we need.
      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
	  cat <<_LT_EOF > conftest.$ac_ext
/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
/* DATA imports from DLLs on WIN32 con't be const, because runtime
   relocations are performed -- see ld's documentation on pseudo-relocs.  */
# define LT_DLSYM_CONST
#elif defined(__osf__)
/* This system does not cope well with relocations in const data.  */
# define LT_DLSYM_CONST
#else
# define LT_DLSYM_CONST const
#endif

#ifdef __cplusplus
extern "C" {
#endif

_LT_EOF
	  # Now generate the symbol file.
	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'

	  cat <<_LT_EOF >> conftest.$ac_ext

/* The mapping between symbol names and symbols.  */
LT_DLSYM_CONST struct {
  const char *name;
  void       *address;
}
lt__PROGRAM__LTX_preloaded_symbols[] =
{
  { "@PROGRAM@", (void *) 0 },
_LT_EOF
	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
	  cat <<\_LT_EOF >> conftest.$ac_ext
  {0, (void *) 0}
};

/* This works around a problem in FreeBSD linker */
#ifdef FREEBSD_WORKAROUND
static const void *lt_preloaded_setup() {
  return lt__PROGRAM__LTX_preloaded_symbols;
}
#endif

#ifdef __cplusplus
}
#endif
_LT_EOF
	  # Now try linking the two files.
	  mv conftest.$ac_objext conftstm.$ac_objext
	  lt_globsym_save_LIBS=$LIBS
	  lt_globsym_save_CFLAGS=$CFLAGS
	  LIBS="conftstm.$ac_objext"
	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
  (eval $ac_link) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && test -s conftest${ac_exeext}; then
	    pipe_works=yes
	  fi
	  LIBS=$lt_globsym_save_LIBS
	  CFLAGS=$lt_globsym_save_CFLAGS
	else
	  echo "cannot find nm_test_func in $nlist" >&5
	fi
      else
	echo "cannot find nm_test_var in $nlist" >&5
      fi
    else
      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
    fi
  else
    echo "$progname: failed program was:" >&5
    cat conftest.$ac_ext >&5
  fi
  rm -rf conftest* conftst*

  # Do not use the global_symbol_pipe unless it works.
  if test "$pipe_works" = yes; then
    break
  else
    lt_cv_sys_global_symbol_pipe=
  fi
done

fi

if test -z "$lt_cv_sys_global_symbol_pipe"; then
  lt_cv_sys_global_symbol_to_cdecl=
fi
if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
$as_echo "failed" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
$as_echo "ok" >&6; }
fi

# Response file support.
if test "$lt_cv_nm_interface" = "MS dumpbin"; then
  nm_file_list_spec='@'
elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then
  nm_file_list_spec='@'
fi



























{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
$as_echo_n "checking for sysroot... " >&6; }

# Check whether --with-sysroot was given.
if test "${with_sysroot+set}" = set; then :
  withval=$with_sysroot;
else
  with_sysroot=no
fi


lt_sysroot=
case ${with_sysroot} in #(
 yes)
   if test "$GCC" = yes; then
     lt_sysroot=`$CC --print-sysroot 2>/dev/null`
   fi
   ;; #(
 /*)
   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
   ;; #(
 no|'')
   ;; #(
 *)
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5
$as_echo "${with_sysroot}" >&6; }
   as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
   ;;
esac

 { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
$as_echo "${lt_sysroot:-no}" >&6; }





# Check whether --enable-libtool-lock was given.
if test "${enable_libtool_lock+set}" = set; then :
  enableval=$enable_libtool_lock;
fi

test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

# Some flags need to be propagated to the compiler or linker for good
# libtool support.
case $host in
ia64-*-hpux*)
  # Find out which ABI we are using.
  echo 'int i;' > conftest.$ac_ext
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  (eval $ac_compile) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
    case `/usr/bin/file conftest.$ac_objext` in
      *ELF-32*)
	HPUX_IA64_MODE="32"
	;;
      *ELF-64*)
	HPUX_IA64_MODE="64"
	;;
    esac
  fi
  rm -rf conftest*
  ;;
*-*-irix6*)
  # Find out which ABI we are using.
  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  (eval $ac_compile) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
    if test "$lt_cv_prog_gnu_ld" = yes; then
      case `/usr/bin/file conftest.$ac_objext` in
	*32-bit*)
	  LD="${LD-ld} -melf32bsmip"
	  ;;
	*N32*)
	  LD="${LD-ld} -melf32bmipn32"
	  ;;
	*64-bit*)
	  LD="${LD-ld} -melf64bmip"
	;;
      esac
    else
      case `/usr/bin/file conftest.$ac_objext` in
	*32-bit*)
	  LD="${LD-ld} -32"
	  ;;
	*N32*)
	  LD="${LD-ld} -n32"
	  ;;
	*64-bit*)
	  LD="${LD-ld} -64"
	  ;;
      esac
    fi
  fi
  rm -rf conftest*
  ;;

x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
  # Find out which ABI we are using.
  echo 'int i;' > conftest.$ac_ext
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  (eval $ac_compile) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
    case `/usr/bin/file conftest.o` in
      *32-bit*)
	case $host in
	  x86_64-*kfreebsd*-gnu)
	    LD="${LD-ld} -m elf_i386_fbsd"
	    ;;
	  x86_64-*linux*)
	    LD="${LD-ld} -m elf_i386"
	    ;;
	  ppc64-*linux*|powerpc64-*linux*)
	    LD="${LD-ld} -m elf32ppclinux"
	    ;;
	  s390x-*linux*)
	    LD="${LD-ld} -m elf_s390"
	    ;;
	  sparc64-*linux*)
	    LD="${LD-ld} -m elf32_sparc"
	    ;;
	esac
	;;
      *64-bit*)
	case $host in
	  x86_64-*kfreebsd*-gnu)
	    LD="${LD-ld} -m elf_x86_64_fbsd"
	    ;;
	  x86_64-*linux*)
	    LD="${LD-ld} -m elf_x86_64"
	    ;;
	  ppc*-*linux*|powerpc*-*linux*)
	    LD="${LD-ld} -m elf64ppc"
	    ;;
	  s390*-*linux*|s390*-*tpf*)
	    LD="${LD-ld} -m elf64_s390"
	    ;;
	  sparc*-*linux*)
	    LD="${LD-ld} -m elf64_sparc"
	    ;;
	esac
	;;
    esac
  fi
  rm -rf conftest*
  ;;

*-*-sco3.2v5*)
  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
  SAVE_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -belf"
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
$as_echo_n "checking whether the C compiler needs -belf... " >&6; }
if ${lt_cv_cc_needs_belf+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  lt_cv_cc_needs_belf=yes
else
  lt_cv_cc_needs_belf=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
     ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
$as_echo "$lt_cv_cc_needs_belf" >&6; }
  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
    CFLAGS="$SAVE_CFLAGS"
  fi
  ;;
*-*solaris*)
  # Find out which ABI we are using.
  echo 'int i;' > conftest.$ac_ext
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  (eval $ac_compile) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
    case `/usr/bin/file conftest.o` in
    *64-bit*)
      case $lt_cv_prog_gnu_ld in
      yes*)
        case $host in
        i?86-*-solaris*)
          LD="${LD-ld} -m elf_x86_64"
          ;;
        sparc*-*-solaris*)
          LD="${LD-ld} -m elf64_sparc"
          ;;
        esac
        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
          LD="${LD-ld}_sol2"
        fi
        ;;
      *)
	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
	  LD="${LD-ld} -64"
	fi
	;;
      esac
      ;;
    esac
  fi
  rm -rf conftest*
  ;;
esac

need_locks="$enable_libtool_lock"

if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
set dummy ${ac_tool_prefix}mt; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_MANIFEST_TOOL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$MANIFEST_TOOL"; then
  ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
if test -n "$MANIFEST_TOOL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
$as_echo "$MANIFEST_TOOL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_MANIFEST_TOOL"; then
  ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL
  # Extract the first word of "mt", so it can be a program name with args.
set dummy mt; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_MANIFEST_TOOL"; then
  ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_MANIFEST_TOOL="mt"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
if test -n "$ac_ct_MANIFEST_TOOL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
$as_echo "$ac_ct_MANIFEST_TOOL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_MANIFEST_TOOL" = x; then
    MANIFEST_TOOL=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL
  fi
else
  MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL"
fi

test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
$as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
if ${lt_cv_path_mainfest_tool+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_path_mainfest_tool=no
  echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5
  $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
  cat conftest.err >&5
  if $GREP 'Manifest Tool' conftest.out > /dev/null; then
    lt_cv_path_mainfest_tool=yes
  fi
  rm -f conftest*
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
$as_echo "$lt_cv_path_mainfest_tool" >&6; }
if test "x$lt_cv_path_mainfest_tool" != xyes; then
  MANIFEST_TOOL=:
fi






  case $host_os in
    rhapsody* | darwin*)
    if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_DSYMUTIL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$DSYMUTIL"; then
  ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
DSYMUTIL=$ac_cv_prog_DSYMUTIL
if test -n "$DSYMUTIL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
$as_echo "$DSYMUTIL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_DSYMUTIL"; then
  ac_ct_DSYMUTIL=$DSYMUTIL
  # Extract the first word of "dsymutil", so it can be a program name with args.
set dummy dsymutil; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_DSYMUTIL"; then
  ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
if test -n "$ac_ct_DSYMUTIL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
$as_echo "$ac_ct_DSYMUTIL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_DSYMUTIL" = x; then
    DSYMUTIL=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    DSYMUTIL=$ac_ct_DSYMUTIL
  fi
else
  DSYMUTIL="$ac_cv_prog_DSYMUTIL"
fi

    if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
set dummy ${ac_tool_prefix}nmedit; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_NMEDIT+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$NMEDIT"; then
  ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
NMEDIT=$ac_cv_prog_NMEDIT
if test -n "$NMEDIT"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
$as_echo "$NMEDIT" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_NMEDIT"; then
  ac_ct_NMEDIT=$NMEDIT
  # Extract the first word of "nmedit", so it can be a program name with args.
set dummy nmedit; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_NMEDIT"; then
  ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_NMEDIT="nmedit"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
if test -n "$ac_ct_NMEDIT"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
$as_echo "$ac_ct_NMEDIT" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_NMEDIT" = x; then
    NMEDIT=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    NMEDIT=$ac_ct_NMEDIT
  fi
else
  NMEDIT="$ac_cv_prog_NMEDIT"
fi

    if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
set dummy ${ac_tool_prefix}lipo; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_LIPO+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$LIPO"; then
  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
LIPO=$ac_cv_prog_LIPO
if test -n "$LIPO"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
$as_echo "$LIPO" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_LIPO"; then
  ac_ct_LIPO=$LIPO
  # Extract the first word of "lipo", so it can be a program name with args.
set dummy lipo; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_LIPO+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_LIPO"; then
  ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_LIPO="lipo"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
if test -n "$ac_ct_LIPO"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
$as_echo "$ac_ct_LIPO" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_LIPO" = x; then
    LIPO=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    LIPO=$ac_ct_LIPO
  fi
else
  LIPO="$ac_cv_prog_LIPO"
fi

    if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
set dummy ${ac_tool_prefix}otool; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_OTOOL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$OTOOL"; then
  ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
OTOOL=$ac_cv_prog_OTOOL
if test -n "$OTOOL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
$as_echo "$OTOOL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_OTOOL"; then
  ac_ct_OTOOL=$OTOOL
  # Extract the first word of "otool", so it can be a program name with args.
set dummy otool; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_OTOOL+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_OTOOL"; then
  ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_OTOOL="otool"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
if test -n "$ac_ct_OTOOL"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
$as_echo "$ac_ct_OTOOL" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_OTOOL" = x; then
    OTOOL=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    OTOOL=$ac_ct_OTOOL
  fi
else
  OTOOL="$ac_cv_prog_OTOOL"
fi

    if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
set dummy ${ac_tool_prefix}otool64; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_OTOOL64+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$OTOOL64"; then
  ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
OTOOL64=$ac_cv_prog_OTOOL64
if test -n "$OTOOL64"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
$as_echo "$OTOOL64" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_prog_OTOOL64"; then
  ac_ct_OTOOL64=$OTOOL64
  # Extract the first word of "otool64", so it can be a program name with args.
set dummy otool64; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_OTOOL64"; then
  ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_OTOOL64="otool64"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
if test -n "$ac_ct_OTOOL64"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
$as_echo "$ac_ct_OTOOL64" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_ct_OTOOL64" = x; then
    OTOOL64=":"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    OTOOL64=$ac_ct_OTOOL64
  fi
else
  OTOOL64="$ac_cv_prog_OTOOL64"
fi



























    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
$as_echo_n "checking for -single_module linker flag... " >&6; }
if ${lt_cv_apple_cc_single_mod+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_apple_cc_single_mod=no
      if test -z "${LT_MULTI_MODULE}"; then
	# By default we will add the -single_module flag. You can override
	# by either setting the environment variable LT_MULTI_MODULE
	# non-empty at configure time, or by adding -multi_module to the
	# link flags.
	rm -rf libconftest.dylib*
	echo "int foo(void){return 1;}" > conftest.c
	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
-dynamiclib -Wl,-single_module conftest.c" >&5
	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
        _lt_result=$?
	# If there is a non-empty error log, and "single_module"
	# appears in it, assume the flag caused a linker warning
        if test -s conftest.err && $GREP single_module conftest.err; then
	  cat conftest.err >&5
	# Otherwise, if the output was created with a 0 exit code from
	# the compiler, it worked.
	elif test -f libconftest.dylib && test $_lt_result -eq 0; then
	  lt_cv_apple_cc_single_mod=yes
	else
	  cat conftest.err >&5
	fi
	rm -rf libconftest.dylib*
	rm -f conftest.*
      fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
$as_echo "$lt_cv_apple_cc_single_mod" >&6; }

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; }
if ${lt_cv_ld_exported_symbols_list+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_ld_exported_symbols_list=no
      save_LDFLAGS=$LDFLAGS
      echo "_main" > conftest.sym
      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  lt_cv_ld_exported_symbols_list=yes
else
  lt_cv_ld_exported_symbols_list=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
	LDFLAGS="$save_LDFLAGS"

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
$as_echo "$lt_cv_ld_exported_symbols_list" >&6; }

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
$as_echo_n "checking for -force_load linker flag... " >&6; }
if ${lt_cv_ld_force_load+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_ld_force_load=no
      cat > conftest.c << _LT_EOF
int forced_loaded() { return 2;}
_LT_EOF
      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
      echo "$AR cru libconftest.a conftest.o" >&5
      $AR cru libconftest.a conftest.o 2>&5
      echo "$RANLIB libconftest.a" >&5
      $RANLIB libconftest.a 2>&5
      cat > conftest.c << _LT_EOF
int main() { return 0;}
_LT_EOF
      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5
      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
      _lt_result=$?
      if test -s conftest.err && $GREP force_load conftest.err; then
	cat conftest.err >&5
      elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then
	lt_cv_ld_force_load=yes
      else
	cat conftest.err >&5
      fi
        rm -f conftest.err libconftest.a conftest conftest.c
        rm -rf conftest.dSYM

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
$as_echo "$lt_cv_ld_force_load" >&6; }
    case $host_os in
    rhapsody* | darwin1.[012])
      _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
    darwin1.*)
      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
    darwin*) # darwin 5.x on
      # if running on 10.5 or later, the deployment target defaults
      # to the OS version, if on x86, and 10.4, the deployment
      # target defaults to 10.4. Don't you love it?
      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
	10.0,*86*-darwin8*|10.0,*-darwin[91]*)
	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
	10.[012]*)
	  _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
	10.*)
	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
      esac
    ;;
  esac
    if test "$lt_cv_apple_cc_single_mod" = "yes"; then
      _lt_dar_single_mod='$single_module'
    fi
    if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
      _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
    else
      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
    fi
    if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
      _lt_dsymutil='~$DSYMUTIL $lib || :'
    else
      _lt_dsymutil=
    fi
    ;;
  esac

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
$as_echo_n "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
  CPP=
fi
if test -z "$CPP"; then
  if ${ac_cv_prog_CPP+:} false; then :
  $as_echo_n "(cached) " >&6
else
      # Double quotes because CPP needs to be expanded
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
    do
      ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # Prefer  to  if __STDC__ is defined, since
  #  exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef __STDC__
# include 
#else
# include 
#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  # Broken: success on invalid input.
continue
else
  # Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
  break
fi

    done
    ac_cv_prog_CPP=$CPP

fi
  CPP=$ac_cv_prog_CPP
else
  ac_cv_prog_CPP=$CPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
$as_echo "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # Prefer  to  if __STDC__ is defined, since
  #  exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef __STDC__
# include 
#else
# include 
#endif
		     Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :

else
  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  # Broken: success on invalid input.
continue
else
  # Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :

else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details" "$LINENO" 5; }
fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
$as_echo_n "checking for ANSI C header files... " >&6; }
if ${ac_cv_header_stdc+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
#include 
#include 
#include 

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_header_stdc=yes
else
  ac_cv_header_stdc=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext

if test $ac_cv_header_stdc = yes; then
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "memchr" >/dev/null 2>&1; then :

else
  ac_cv_header_stdc=no
fi
rm -f conftest*

fi

if test $ac_cv_header_stdc = yes; then
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "free" >/dev/null 2>&1; then :

else
  ac_cv_header_stdc=no
fi
rm -f conftest*

fi

if test $ac_cv_header_stdc = yes; then
  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
  if test "$cross_compiling" = yes; then :
  :
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
#include 
#if ((' ' & 0x0FF) == 0x020)
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
#else
# define ISLOWER(c) \
		   (('a' <= (c) && (c) <= 'i') \
		     || ('j' <= (c) && (c) <= 'r') \
		     || ('s' <= (c) && (c) <= 'z'))
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
#endif

#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
int
main ()
{
  int i;
  for (i = 0; i < 256; i++)
    if (XOR (islower (i), ISLOWER (i))
	|| toupper (i) != TOUPPER (i))
      return 2;
  return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :

else
  ac_cv_header_stdc=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
  conftest.$ac_objext conftest.beam conftest.$ac_ext
fi

fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
$as_echo "$ac_cv_header_stdc" >&6; }
if test $ac_cv_header_stdc = yes; then

$as_echo "#define STDC_HEADERS 1" >>confdefs.h

fi

# On IRIX 5.3, sys/types and inttypes.h are conflicting.
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
		  inttypes.h stdint.h unistd.h
do :
  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
  cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF

fi

done


for ac_header in dlfcn.h
do :
  ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
"
if test "x$ac_cv_header_dlfcn_h" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_DLFCN_H 1
_ACEOF

fi

done





# Set options



        enable_dlopen=no


  enable_win32_dll=no


            # Check whether --enable-shared was given.
if test "${enable_shared+set}" = set; then :
  enableval=$enable_shared; p=${PACKAGE-default}
    case $enableval in
    yes) enable_shared=yes ;;
    no) enable_shared=no ;;
    *)
      enable_shared=no
      # Look at the argument we got.  We use all the common list separators.
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
      for pkg in $enableval; do
	IFS="$lt_save_ifs"
	if test "X$pkg" = "X$p"; then
	  enable_shared=yes
	fi
      done
      IFS="$lt_save_ifs"
      ;;
    esac
else
  enable_shared=yes
fi









  # Check whether --enable-static was given.
if test "${enable_static+set}" = set; then :
  enableval=$enable_static; p=${PACKAGE-default}
    case $enableval in
    yes) enable_static=yes ;;
    no) enable_static=no ;;
    *)
     enable_static=no
      # Look at the argument we got.  We use all the common list separators.
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
      for pkg in $enableval; do
	IFS="$lt_save_ifs"
	if test "X$pkg" = "X$p"; then
	  enable_static=yes
	fi
      done
      IFS="$lt_save_ifs"
      ;;
    esac
else
  enable_static=yes
fi










# Check whether --with-pic was given.
if test "${with_pic+set}" = set; then :
  withval=$with_pic; lt_p=${PACKAGE-default}
    case $withval in
    yes|no) pic_mode=$withval ;;
    *)
      pic_mode=default
      # Look at the argument we got.  We use all the common list separators.
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
      for lt_pkg in $withval; do
	IFS="$lt_save_ifs"
	if test "X$lt_pkg" = "X$lt_p"; then
	  pic_mode=yes
	fi
      done
      IFS="$lt_save_ifs"
      ;;
    esac
else
  pic_mode=default
fi


test -z "$pic_mode" && pic_mode=default







  # Check whether --enable-fast-install was given.
if test "${enable_fast_install+set}" = set; then :
  enableval=$enable_fast_install; p=${PACKAGE-default}
    case $enableval in
    yes) enable_fast_install=yes ;;
    no) enable_fast_install=no ;;
    *)
      enable_fast_install=no
      # Look at the argument we got.  We use all the common list separators.
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
      for pkg in $enableval; do
	IFS="$lt_save_ifs"
	if test "X$pkg" = "X$p"; then
	  enable_fast_install=yes
	fi
      done
      IFS="$lt_save_ifs"
      ;;
    esac
else
  enable_fast_install=yes
fi











# This can be used to rebuild libtool when needed
LIBTOOL_DEPS="$ltmain"

# Always use our own libtool.
LIBTOOL='$(SHELL) $(top_builddir)/libtool'






























test -z "$LN_S" && LN_S="ln -s"














if test -n "${ZSH_VERSION+set}" ; then
   setopt NO_GLOB_SUBST
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
$as_echo_n "checking for objdir... " >&6; }
if ${lt_cv_objdir+:} false; then :
  $as_echo_n "(cached) " >&6
else
  rm -f .libs 2>/dev/null
mkdir .libs 2>/dev/null
if test -d .libs; then
  lt_cv_objdir=.libs
else
  # MS-DOS does not allow filenames that begin with a dot.
  lt_cv_objdir=_libs
fi
rmdir .libs 2>/dev/null
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
$as_echo "$lt_cv_objdir" >&6; }
objdir=$lt_cv_objdir





cat >>confdefs.h <<_ACEOF
#define LT_OBJDIR "$lt_cv_objdir/"
_ACEOF




case $host_os in
aix3*)
  # AIX sometimes has problems with the GCC collect2 program.  For some
  # reason, if we set the COLLECT_NAMES environment variable, the problems
  # vanish in a puff of smoke.
  if test "X${COLLECT_NAMES+set}" != Xset; then
    COLLECT_NAMES=
    export COLLECT_NAMES
  fi
  ;;
esac

# Global variables:
ofile=libtool
can_build_shared=yes

# All known linkers require a `.a' archive for static linking (except MSVC,
# which needs '.lib').
libext=a

with_gnu_ld="$lt_cv_prog_gnu_ld"

old_CC="$CC"
old_CFLAGS="$CFLAGS"

# Set sane defaults for various variables
test -z "$CC" && CC=cc
test -z "$LTCC" && LTCC=$CC
test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
test -z "$LD" && LD=ld
test -z "$ac_objext" && ac_objext=o

for cc_temp in $compiler""; do
  case $cc_temp in
    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
    \-*) ;;
    *) break;;
  esac
done
cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`


# Only perform the check for file, if the check method requires it
test -z "$MAGIC_CMD" && MAGIC_CMD=file
case $deplibs_check_method in
file_magic*)
  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; }
if ${lt_cv_path_MAGIC_CMD+:} false; then :
  $as_echo_n "(cached) " >&6
else
  case $MAGIC_CMD in
[\\/*] |  ?:[\\/]*)
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
  ;;
*)
  lt_save_MAGIC_CMD="$MAGIC_CMD"
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
  for ac_dir in $ac_dummy; do
    IFS="$lt_save_ifs"
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/${ac_tool_prefix}file; then
      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
      if test -n "$file_magic_test_file"; then
	case $deplibs_check_method in
	"file_magic "*)
	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
	    $EGREP "$file_magic_regex" > /dev/null; then
	    :
	  else
	    cat <<_LT_EOF 1>&2

*** Warning: the command libtool uses to detect shared libraries,
*** $file_magic_cmd, produces output that libtool cannot recognize.
*** The result is that libtool may fail to recognize shared libraries
*** as such.  This will affect the creation of libtool libraries that
*** depend on shared libraries, but programs linked with such libtool
*** libraries will work regardless of this problem.  Nevertheless, you
*** may want to report the problem to your system manager and/or to
*** bug-libtool@gnu.org

_LT_EOF
	  fi ;;
	esac
      fi
      break
    fi
  done
  IFS="$lt_save_ifs"
  MAGIC_CMD="$lt_save_MAGIC_CMD"
  ;;
esac
fi

MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
if test -n "$MAGIC_CMD"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
$as_echo "$MAGIC_CMD" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi





if test -z "$lt_cv_path_MAGIC_CMD"; then
  if test -n "$ac_tool_prefix"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5
$as_echo_n "checking for file... " >&6; }
if ${lt_cv_path_MAGIC_CMD+:} false; then :
  $as_echo_n "(cached) " >&6
else
  case $MAGIC_CMD in
[\\/*] |  ?:[\\/]*)
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
  ;;
*)
  lt_save_MAGIC_CMD="$MAGIC_CMD"
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
  for ac_dir in $ac_dummy; do
    IFS="$lt_save_ifs"
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/file; then
      lt_cv_path_MAGIC_CMD="$ac_dir/file"
      if test -n "$file_magic_test_file"; then
	case $deplibs_check_method in
	"file_magic "*)
	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
	    $EGREP "$file_magic_regex" > /dev/null; then
	    :
	  else
	    cat <<_LT_EOF 1>&2

*** Warning: the command libtool uses to detect shared libraries,
*** $file_magic_cmd, produces output that libtool cannot recognize.
*** The result is that libtool may fail to recognize shared libraries
*** as such.  This will affect the creation of libtool libraries that
*** depend on shared libraries, but programs linked with such libtool
*** libraries will work regardless of this problem.  Nevertheless, you
*** may want to report the problem to your system manager and/or to
*** bug-libtool@gnu.org

_LT_EOF
	  fi ;;
	esac
      fi
      break
    fi
  done
  IFS="$lt_save_ifs"
  MAGIC_CMD="$lt_save_MAGIC_CMD"
  ;;
esac
fi

MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
if test -n "$MAGIC_CMD"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
$as_echo "$MAGIC_CMD" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  else
    MAGIC_CMD=:
  fi
fi

  fi
  ;;
esac

# Use C for the default configuration in the libtool script

lt_save_CC="$CC"
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu


# Source file extension for C test sources.
ac_ext=c

# Object file extension for compiled C test sources.
objext=o
objext=$objext

# Code to be used in simple compile tests
lt_simple_compile_test_code="int some_variable = 0;"

# Code to be used in simple link tests
lt_simple_link_test_code='int main(){return(0);}'







# If no C compiler was specified, use CC.
LTCC=${LTCC-"$CC"}

# If no C compiler flags were specified, use CFLAGS.
LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

# Allow CC to be a program name with arguments.
compiler=$CC

# Save the default compiler, since it gets overwritten when the other
# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
compiler_DEFAULT=$CC

# save warnings/boilerplate of simple test code
ac_outfile=conftest.$ac_objext
echo "$lt_simple_compile_test_code" >conftest.$ac_ext
eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
_lt_compiler_boilerplate=`cat conftest.err`
$RM conftest*

ac_outfile=conftest.$ac_objext
echo "$lt_simple_link_test_code" >conftest.$ac_ext
eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
_lt_linker_boilerplate=`cat conftest.err`
$RM -r conftest*


## CAVEAT EMPTOR:
## There is no encapsulation within the following macros, do not change
## the running order or otherwise move them around unless you know exactly
## what you are doing...
if test -n "$compiler"; then

lt_prog_compiler_no_builtin_flag=

if test "$GCC" = yes; then
  case $cc_basename in
  nvcc*)
    lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
  *)
    lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
  esac

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_rtti_exceptions=no
   ac_outfile=conftest.$ac_objext
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
   lt_compiler_flag="-fno-rtti -fno-exceptions"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   # The option is referenced via a variable to avoid confusing sed.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
   (eval "$lt_compile" 2>conftest.err)
   ac_status=$?
   cat conftest.err >&5
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   if (exit $ac_status) && test -s "$ac_outfile"; then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings other than the usual output.
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
       lt_cv_prog_compiler_rtti_exceptions=yes
     fi
   fi
   $RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; }

if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
else
    :
fi

fi






  lt_prog_compiler_wl=
lt_prog_compiler_pic=
lt_prog_compiler_static=


  if test "$GCC" = yes; then
    lt_prog_compiler_wl='-Wl,'
    lt_prog_compiler_static='-static'

    case $host_os in
      aix*)
      # All AIX code is PIC.
      if test "$host_cpu" = ia64; then
	# AIX 5 now supports IA64 processor
	lt_prog_compiler_static='-Bstatic'
      fi
      ;;

    amigaos*)
      case $host_cpu in
      powerpc)
            # see comment about AmigaOS4 .so support
            lt_prog_compiler_pic='-fPIC'
        ;;
      m68k)
            # FIXME: we need at least 68020 code to build shared libraries, but
            # adding the `-m68020' flag to GCC prevents building anything better,
            # like `-m68040'.
            lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
        ;;
      esac
      ;;

    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
      # PIC is the default for these OSes.
      ;;

    mingw* | cygwin* | pw32* | os2* | cegcc*)
      # This hack is so that the source file can tell whether it is being
      # built for inclusion in a dll (and should export symbols for example).
      # Although the cygwin gcc ignores -fPIC, still need this for old-style
      # (--disable-auto-import) libraries
      lt_prog_compiler_pic='-DDLL_EXPORT'
      ;;

    darwin* | rhapsody*)
      # PIC is the default on this platform
      # Common symbols not allowed in MH_DYLIB files
      lt_prog_compiler_pic='-fno-common'
      ;;

    haiku*)
      # PIC is the default for Haiku.
      # The "-static" flag exists, but is broken.
      lt_prog_compiler_static=
      ;;

    hpux*)
      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
      # sets the default TLS model and affects inlining.
      case $host_cpu in
      hppa*64*)
	# +Z the default
	;;
      *)
	lt_prog_compiler_pic='-fPIC'
	;;
      esac
      ;;

    interix[3-9]*)
      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
      # Instead, we relocate shared libraries at runtime.
      ;;

    msdosdjgpp*)
      # Just because we use GCC doesn't mean we suddenly get shared libraries
      # on systems that don't support them.
      lt_prog_compiler_can_build_shared=no
      enable_shared=no
      ;;

    *nto* | *qnx*)
      # QNX uses GNU C++, but need to define -shared option too, otherwise
      # it will coredump.
      lt_prog_compiler_pic='-fPIC -shared'
      ;;

    sysv4*MP*)
      if test -d /usr/nec; then
	lt_prog_compiler_pic=-Kconform_pic
      fi
      ;;

    *)
      lt_prog_compiler_pic='-fPIC'
      ;;
    esac

    case $cc_basename in
    nvcc*) # Cuda Compiler Driver 2.2
      lt_prog_compiler_wl='-Xlinker '
      if test -n "$lt_prog_compiler_pic"; then
        lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic"
      fi
      ;;
    esac
  else
    # PORTME Check for flag to pass linker flags through the system compiler.
    case $host_os in
    aix*)
      lt_prog_compiler_wl='-Wl,'
      if test "$host_cpu" = ia64; then
	# AIX 5 now supports IA64 processor
	lt_prog_compiler_static='-Bstatic'
      else
	lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
      fi
      ;;

    mingw* | cygwin* | pw32* | os2* | cegcc*)
      # This hack is so that the source file can tell whether it is being
      # built for inclusion in a dll (and should export symbols for example).
      lt_prog_compiler_pic='-DDLL_EXPORT'
      ;;

    hpux9* | hpux10* | hpux11*)
      lt_prog_compiler_wl='-Wl,'
      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
      # not for PA HP-UX.
      case $host_cpu in
      hppa*64*|ia64*)
	# +Z the default
	;;
      *)
	lt_prog_compiler_pic='+Z'
	;;
      esac
      # Is there a better lt_prog_compiler_static that works with the bundled CC?
      lt_prog_compiler_static='${wl}-a ${wl}archive'
      ;;

    irix5* | irix6* | nonstopux*)
      lt_prog_compiler_wl='-Wl,'
      # PIC (with -KPIC) is the default.
      lt_prog_compiler_static='-non_shared'
      ;;

    linux* | k*bsd*-gnu | kopensolaris*-gnu)
      case $cc_basename in
      # old Intel for x86_64 which still supported -KPIC.
      ecc*)
	lt_prog_compiler_wl='-Wl,'
	lt_prog_compiler_pic='-KPIC'
	lt_prog_compiler_static='-static'
        ;;
      # icc used to be incompatible with GCC.
      # ICC 10 doesn't accept -KPIC any more.
      icc* | ifort*)
	lt_prog_compiler_wl='-Wl,'
	lt_prog_compiler_pic='-fPIC'
	lt_prog_compiler_static='-static'
        ;;
      # Lahey Fortran 8.1.
      lf95*)
	lt_prog_compiler_wl='-Wl,'
	lt_prog_compiler_pic='--shared'
	lt_prog_compiler_static='--static'
	;;
      nagfor*)
	# NAG Fortran compiler
	lt_prog_compiler_wl='-Wl,-Wl,,'
	lt_prog_compiler_pic='-PIC'
	lt_prog_compiler_static='-Bstatic'
	;;
      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
        # Portland Group compilers (*not* the Pentium gcc compiler,
	# which looks to be a dead project)
	lt_prog_compiler_wl='-Wl,'
	lt_prog_compiler_pic='-fpic'
	lt_prog_compiler_static='-Bstatic'
        ;;
      ccc*)
        lt_prog_compiler_wl='-Wl,'
        # All Alpha code is PIC.
        lt_prog_compiler_static='-non_shared'
        ;;
      xl* | bgxl* | bgf* | mpixl*)
	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
	lt_prog_compiler_wl='-Wl,'
	lt_prog_compiler_pic='-qpic'
	lt_prog_compiler_static='-qstaticlink'
	;;
      *)
	case `$CC -V 2>&1 | sed 5q` in
	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*)
	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
	  lt_prog_compiler_pic='-KPIC'
	  lt_prog_compiler_static='-Bstatic'
	  lt_prog_compiler_wl=''
	  ;;
	*Sun\ F* | *Sun*Fortran*)
	  lt_prog_compiler_pic='-KPIC'
	  lt_prog_compiler_static='-Bstatic'
	  lt_prog_compiler_wl='-Qoption ld '
	  ;;
	*Sun\ C*)
	  # Sun C 5.9
	  lt_prog_compiler_pic='-KPIC'
	  lt_prog_compiler_static='-Bstatic'
	  lt_prog_compiler_wl='-Wl,'
	  ;;
        *Intel*\ [CF]*Compiler*)
	  lt_prog_compiler_wl='-Wl,'
	  lt_prog_compiler_pic='-fPIC'
	  lt_prog_compiler_static='-static'
	  ;;
	*Portland\ Group*)
	  lt_prog_compiler_wl='-Wl,'
	  lt_prog_compiler_pic='-fpic'
	  lt_prog_compiler_static='-Bstatic'
	  ;;
	esac
	;;
      esac
      ;;

    newsos6)
      lt_prog_compiler_pic='-KPIC'
      lt_prog_compiler_static='-Bstatic'
      ;;

    *nto* | *qnx*)
      # QNX uses GNU C++, but need to define -shared option too, otherwise
      # it will coredump.
      lt_prog_compiler_pic='-fPIC -shared'
      ;;

    osf3* | osf4* | osf5*)
      lt_prog_compiler_wl='-Wl,'
      # All OSF/1 code is PIC.
      lt_prog_compiler_static='-non_shared'
      ;;

    rdos*)
      lt_prog_compiler_static='-non_shared'
      ;;

    solaris*)
      lt_prog_compiler_pic='-KPIC'
      lt_prog_compiler_static='-Bstatic'
      case $cc_basename in
      f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
	lt_prog_compiler_wl='-Qoption ld ';;
      *)
	lt_prog_compiler_wl='-Wl,';;
      esac
      ;;

    sunos4*)
      lt_prog_compiler_wl='-Qoption ld '
      lt_prog_compiler_pic='-PIC'
      lt_prog_compiler_static='-Bstatic'
      ;;

    sysv4 | sysv4.2uw2* | sysv4.3*)
      lt_prog_compiler_wl='-Wl,'
      lt_prog_compiler_pic='-KPIC'
      lt_prog_compiler_static='-Bstatic'
      ;;

    sysv4*MP*)
      if test -d /usr/nec ;then
	lt_prog_compiler_pic='-Kconform_pic'
	lt_prog_compiler_static='-Bstatic'
      fi
      ;;

    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
      lt_prog_compiler_wl='-Wl,'
      lt_prog_compiler_pic='-KPIC'
      lt_prog_compiler_static='-Bstatic'
      ;;

    unicos*)
      lt_prog_compiler_wl='-Wl,'
      lt_prog_compiler_can_build_shared=no
      ;;

    uts4*)
      lt_prog_compiler_pic='-pic'
      lt_prog_compiler_static='-Bstatic'
      ;;

    *)
      lt_prog_compiler_can_build_shared=no
      ;;
    esac
  fi

case $host_os in
  # For platforms which do not support PIC, -DPIC is meaningless:
  *djgpp*)
    lt_prog_compiler_pic=
    ;;
  *)
    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
    ;;
esac

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
if ${lt_cv_prog_compiler_pic+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_pic=$lt_prog_compiler_pic
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
$as_echo "$lt_cv_prog_compiler_pic" >&6; }
lt_prog_compiler_pic=$lt_cv_prog_compiler_pic

#
# Check to make sure the PIC flag actually works.
#
if test -n "$lt_prog_compiler_pic"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
if ${lt_cv_prog_compiler_pic_works+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_pic_works=no
   ac_outfile=conftest.$ac_objext
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   # The option is referenced via a variable to avoid confusing sed.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
   (eval "$lt_compile" 2>conftest.err)
   ac_status=$?
   cat conftest.err >&5
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   if (exit $ac_status) && test -s "$ac_outfile"; then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings other than the usual output.
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
       lt_cv_prog_compiler_pic_works=yes
     fi
   fi
   $RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
$as_echo "$lt_cv_prog_compiler_pic_works" >&6; }

if test x"$lt_cv_prog_compiler_pic_works" = xyes; then
    case $lt_prog_compiler_pic in
     "" | " "*) ;;
     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
     esac
else
    lt_prog_compiler_pic=
     lt_prog_compiler_can_build_shared=no
fi

fi











#
# Check to make sure the static flag actually works.
#
wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
if ${lt_cv_prog_compiler_static_works+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_static_works=no
   save_LDFLAGS="$LDFLAGS"
   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
   echo "$lt_simple_link_test_code" > conftest.$ac_ext
   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
     # The linker can only warn and ignore the option if not recognized
     # So say no if there are warnings
     if test -s conftest.err; then
       # Append any errors to the config.log.
       cat conftest.err 1>&5
       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
       if diff conftest.exp conftest.er2 >/dev/null; then
         lt_cv_prog_compiler_static_works=yes
       fi
     else
       lt_cv_prog_compiler_static_works=yes
     fi
   fi
   $RM -r conftest*
   LDFLAGS="$save_LDFLAGS"

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
$as_echo "$lt_cv_prog_compiler_static_works" >&6; }

if test x"$lt_cv_prog_compiler_static_works" = xyes; then
    :
else
    lt_prog_compiler_static=
fi







  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
if ${lt_cv_prog_compiler_c_o+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_c_o=no
   $RM -r conftest 2>/dev/null
   mkdir conftest
   cd conftest
   mkdir out
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext

   lt_compiler_flag="-o out/conftest2.$ac_objext"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
   (eval "$lt_compile" 2>out/conftest.err)
   ac_status=$?
   cat out/conftest.err >&5
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
   then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
       lt_cv_prog_compiler_c_o=yes
     fi
   fi
   chmod u+w . 2>&5
   $RM conftest*
   # SGI C++ compiler will create directory out/ii_files/ for
   # template instantiation
   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
   $RM out/* && rmdir out
   cd ..
   $RM -r conftest
   $RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
$as_echo "$lt_cv_prog_compiler_c_o" >&6; }






  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
if ${lt_cv_prog_compiler_c_o+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_c_o=no
   $RM -r conftest 2>/dev/null
   mkdir conftest
   cd conftest
   mkdir out
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext

   lt_compiler_flag="-o out/conftest2.$ac_objext"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
   (eval "$lt_compile" 2>out/conftest.err)
   ac_status=$?
   cat out/conftest.err >&5
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
   then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
       lt_cv_prog_compiler_c_o=yes
     fi
   fi
   chmod u+w . 2>&5
   $RM conftest*
   # SGI C++ compiler will create directory out/ii_files/ for
   # template instantiation
   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
   $RM out/* && rmdir out
   cd ..
   $RM -r conftest
   $RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
$as_echo "$lt_cv_prog_compiler_c_o" >&6; }




hard_links="nottested"
if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
  # do not overwrite the value of need_locks provided by the user
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
$as_echo_n "checking if we can lock with hard links... " >&6; }
  hard_links=yes
  $RM conftest*
  ln conftest.a conftest.b 2>/dev/null && hard_links=no
  touch conftest.a
  ln conftest.a conftest.b 2>&5 || hard_links=no
  ln conftest.a conftest.b 2>/dev/null && hard_links=no
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
$as_echo "$hard_links" >&6; }
  if test "$hard_links" = no; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
    need_locks=warn
  fi
else
  need_locks=no
fi






  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }

  runpath_var=
  allow_undefined_flag=
  always_export_symbols=no
  archive_cmds=
  archive_expsym_cmds=
  compiler_needs_object=no
  enable_shared_with_static_runtimes=no
  export_dynamic_flag_spec=
  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
  hardcode_automatic=no
  hardcode_direct=no
  hardcode_direct_absolute=no
  hardcode_libdir_flag_spec=
  hardcode_libdir_separator=
  hardcode_minus_L=no
  hardcode_shlibpath_var=unsupported
  inherit_rpath=no
  link_all_deplibs=unknown
  module_cmds=
  module_expsym_cmds=
  old_archive_from_new_cmds=
  old_archive_from_expsyms_cmds=
  thread_safe_flag_spec=
  whole_archive_flag_spec=
  # include_expsyms should be a list of space-separated symbols to be *always*
  # included in the symbol list
  include_expsyms=
  # exclude_expsyms can be an extended regexp of symbols to exclude
  # it will be wrapped by ` (' and `)$', so one must not match beginning or
  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
  # as well as any symbol that contains `d'.
  exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
  # platforms (ab)use it in PIC code, but their linkers get confused if
  # the symbol is explicitly referenced.  Since portable code cannot
  # rely on this symbol name, it's probably fine to never include it in
  # preloaded symbol tables.
  # Exclude shared library initialization/finalization symbols.
  extract_expsyms_cmds=

  case $host_os in
  cygwin* | mingw* | pw32* | cegcc*)
    # FIXME: the MSVC++ port hasn't been tested in a loooong time
    # When not using gcc, we currently assume that we are using
    # Microsoft Visual C++.
    if test "$GCC" != yes; then
      with_gnu_ld=no
    fi
    ;;
  interix*)
    # we just hope/assume this is gcc and not c89 (= MSVC++)
    with_gnu_ld=yes
    ;;
  openbsd*)
    with_gnu_ld=no
    ;;
  esac

  ld_shlibs=yes

  # On some targets, GNU ld is compatible enough with the native linker
  # that we're better off using the native interface for both.
  lt_use_gnu_ld_interface=no
  if test "$with_gnu_ld" = yes; then
    case $host_os in
      aix*)
	# The AIX port of GNU ld has always aspired to compatibility
	# with the native linker.  However, as the warning in the GNU ld
	# block says, versions before 2.19.5* couldn't really create working
	# shared libraries, regardless of the interface used.
	case `$LD -v 2>&1` in
	  *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
	  *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;;
	  *\ \(GNU\ Binutils\)\ [3-9]*) ;;
	  *)
	    lt_use_gnu_ld_interface=yes
	    ;;
	esac
	;;
      *)
	lt_use_gnu_ld_interface=yes
	;;
    esac
  fi

  if test "$lt_use_gnu_ld_interface" = yes; then
    # If archive_cmds runs LD, not CC, wlarc should be empty
    wlarc='${wl}'

    # Set some defaults for GNU ld with shared library support. These
    # are reset later if shared libraries are not supported. Putting them
    # here allows them to be overridden if necessary.
    runpath_var=LD_RUN_PATH
    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
    export_dynamic_flag_spec='${wl}--export-dynamic'
    # ancient GNU ld didn't support --whole-archive et. al.
    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
      whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
    else
      whole_archive_flag_spec=
    fi
    supports_anon_versioning=no
    case `$LD -v 2>&1` in
      *GNU\ gold*) supports_anon_versioning=yes ;;
      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
      *\ 2.11.*) ;; # other 2.11 versions
      *) supports_anon_versioning=yes ;;
    esac

    # See if GNU ld supports shared libraries.
    case $host_os in
    aix[3-9]*)
      # On AIX/PPC, the GNU linker is very broken
      if test "$host_cpu" != ia64; then
	ld_shlibs=no
	cat <<_LT_EOF 1>&2

*** Warning: the GNU linker, at least up to release 2.19, is reported
*** to be unable to reliably create shared libraries on AIX.
*** Therefore, libtool is disabling shared libraries support.  If you
*** really care for shared libraries, you may want to install binutils
*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
*** You will then need to restart the configuration process.

_LT_EOF
      fi
      ;;

    amigaos*)
      case $host_cpu in
      powerpc)
            # see comment about AmigaOS4 .so support
            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
            archive_expsym_cmds=''
        ;;
      m68k)
            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
            hardcode_libdir_flag_spec='-L$libdir'
            hardcode_minus_L=yes
        ;;
      esac
      ;;

    beos*)
      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	allow_undefined_flag=unsupported
	# Joseph Beckenbach  says some releases of gcc
	# support --undefined.  This deserves some investigation.  FIXME
	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
      else
	ld_shlibs=no
      fi
      ;;

    cygwin* | mingw* | pw32* | cegcc*)
      # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
      # as there is no search path for DLLs.
      hardcode_libdir_flag_spec='-L$libdir'
      export_dynamic_flag_spec='${wl}--export-all-symbols'
      allow_undefined_flag=unsupported
      always_export_symbols=no
      enable_shared_with_static_runtimes=yes
      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
      exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'

      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
	# If the export-symbols file already is a .def file (1st line
	# is EXPORTS), use it as is; otherwise, prepend...
	archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
	  cp $export_symbols $output_objdir/$soname.def;
	else
	  echo EXPORTS > $output_objdir/$soname.def;
	  cat $export_symbols >> $output_objdir/$soname.def;
	fi~
	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
      else
	ld_shlibs=no
      fi
      ;;

    haiku*)
      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
      link_all_deplibs=yes
      ;;

    interix[3-9]*)
      hardcode_direct=no
      hardcode_shlibpath_var=no
      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
      export_dynamic_flag_spec='${wl}-E'
      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
      # Instead, shared libraries are loaded at an image base (0x10000000 by
      # default) and relocated if they conflict, which is a slow very memory
      # consuming and fragmenting process.  To avoid this, we pick a random,
      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
      archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
      ;;

    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
      tmp_diet=no
      if test "$host_os" = linux-dietlibc; then
	case $cc_basename in
	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
	esac
      fi
      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
	 && test "$tmp_diet" = no
      then
	tmp_addflag=' $pic_flag'
	tmp_sharedflag='-shared'
	case $cc_basename,$host_cpu in
        pgcc*)				# Portland Group C compiler
	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	  tmp_addflag=' $pic_flag'
	  ;;
	pgf77* | pgf90* | pgf95* | pgfortran*)
					# Portland Group f77 and f90 compilers
	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	  tmp_addflag=' $pic_flag -Mnomain' ;;
	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
	  tmp_addflag=' -i_dynamic' ;;
	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
	  tmp_addflag=' -i_dynamic -nofor_main' ;;
	ifc* | ifort*)			# Intel Fortran compiler
	  tmp_addflag=' -nofor_main' ;;
	lf95*)				# Lahey Fortran 8.1
	  whole_archive_flag_spec=
	  tmp_sharedflag='--shared' ;;
	xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
	  tmp_sharedflag='-qmkshrobj'
	  tmp_addflag= ;;
	nvcc*)	# Cuda Compiler Driver 2.2
	  whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	  compiler_needs_object=yes
	  ;;
	esac
	case `$CC -V 2>&1 | sed 5q` in
	*Sun\ C*)			# Sun C 5.9
	  whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	  compiler_needs_object=yes
	  tmp_sharedflag='-G' ;;
	*Sun\ F*)			# Sun Fortran 8.3
	  tmp_sharedflag='-G' ;;
	esac
	archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

        if test "x$supports_anon_versioning" = xyes; then
          archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
	    cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
	    echo "local: *; };" >> $output_objdir/$libname.ver~
	    $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
        fi

	case $cc_basename in
	xlf* | bgf* | bgxlf* | mpixlf*)
	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
	  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
	  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
	  archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
	  if test "x$supports_anon_versioning" = xyes; then
	    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
	      cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
	      echo "local: *; };" >> $output_objdir/$libname.ver~
	      $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
	  fi
	  ;;
	esac
      else
        ld_shlibs=no
      fi
      ;;

    netbsd*)
      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
	wlarc=
      else
	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
      fi
      ;;

    solaris*)
      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
	ld_shlibs=no
	cat <<_LT_EOF 1>&2

*** Warning: The releases 2.8.* of the GNU linker cannot reliably
*** create shared libraries on Solaris systems.  Therefore, libtool
*** is disabling shared libraries support.  We urge you to upgrade GNU
*** binutils to release 2.9.1 or newer.  Another option is to modify
*** your PATH or compiler configuration so that the native linker is
*** used, and then restart.

_LT_EOF
      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
      else
	ld_shlibs=no
      fi
      ;;

    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
      case `$LD -v 2>&1` in
        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
	ld_shlibs=no
	cat <<_LT_EOF 1>&2

*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
*** reliably create shared libraries on SCO systems.  Therefore, libtool
*** is disabling shared libraries support.  We urge you to upgrade GNU
*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
*** your PATH or compiler configuration so that the native linker is
*** used, and then restart.

_LT_EOF
	;;
	*)
	  # For security reasons, it is highly recommended that you always
	  # use absolute paths for naming shared libraries, and exclude the
	  # DT_RUNPATH tag from executables and libraries.  But doing so
	  # requires that you compile everything twice, which is a pain.
	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
	  else
	    ld_shlibs=no
	  fi
	;;
      esac
      ;;

    sunos4*)
      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
      wlarc=
      hardcode_direct=yes
      hardcode_shlibpath_var=no
      ;;

    *)
      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
      else
	ld_shlibs=no
      fi
      ;;
    esac

    if test "$ld_shlibs" = no; then
      runpath_var=
      hardcode_libdir_flag_spec=
      export_dynamic_flag_spec=
      whole_archive_flag_spec=
    fi
  else
    # PORTME fill in a description of your system's linker (not GNU ld)
    case $host_os in
    aix3*)
      allow_undefined_flag=unsupported
      always_export_symbols=yes
      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
      # Note: this linker hardcodes the directories in LIBPATH if there
      # are no directories specified by -L.
      hardcode_minus_L=yes
      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
	# Neither direct hardcoding nor static linking is supported with a
	# broken collect2.
	hardcode_direct=unsupported
      fi
      ;;

    aix[4-9]*)
      if test "$host_cpu" = ia64; then
	# On IA64, the linker does run time linking by default, so we don't
	# have to do anything special.
	aix_use_runtimelinking=no
	exp_sym_flag='-Bexport'
	no_entry_flag=""
      else
	# If we're using GNU nm, then we don't want the "-C" option.
	# -C means demangle to AIX nm, but means don't demangle with GNU nm
	# Also, AIX nm treats weak defined symbols like other global
	# defined symbols, whereas GNU nm marks them as "W".
	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
	else
	  export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
	fi
	aix_use_runtimelinking=no

	# Test if we are trying to use run time linking or normal
	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
	# need to do runtime linking.
	case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
	  for ld_flag in $LDFLAGS; do
	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
	    aix_use_runtimelinking=yes
	    break
	  fi
	  done
	  ;;
	esac

	exp_sym_flag='-bexport'
	no_entry_flag='-bnoentry'
      fi

      # When large executables or shared objects are built, AIX ld can
      # have problems creating the table of contents.  If linking a library
      # or program results in "error TOC overflow" add -mminimal-toc to
      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

      archive_cmds=''
      hardcode_direct=yes
      hardcode_direct_absolute=yes
      hardcode_libdir_separator=':'
      link_all_deplibs=yes
      file_list_spec='${wl}-f,'

      if test "$GCC" = yes; then
	case $host_os in aix4.[012]|aix4.[012].*)
	# We only want to do this on AIX 4.2 and lower, the check
	# below for broken collect2 doesn't work under 4.3+
	  collect2name=`${CC} -print-prog-name=collect2`
	  if test -f "$collect2name" &&
	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
	  then
	  # We have reworked collect2
	  :
	  else
	  # We have old collect2
	  hardcode_direct=unsupported
	  # It fails to find uninstalled libraries when the uninstalled
	  # path is not listed in the libpath.  Setting hardcode_minus_L
	  # to unsupported forces relinking
	  hardcode_minus_L=yes
	  hardcode_libdir_flag_spec='-L$libdir'
	  hardcode_libdir_separator=
	  fi
	  ;;
	esac
	shared_flag='-shared'
	if test "$aix_use_runtimelinking" = yes; then
	  shared_flag="$shared_flag "'${wl}-G'
	fi
      else
	# not using gcc
	if test "$host_cpu" = ia64; then
	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
	# chokes on -Wl,-G. The following line is correct:
	  shared_flag='-G'
	else
	  if test "$aix_use_runtimelinking" = yes; then
	    shared_flag='${wl}-G'
	  else
	    shared_flag='${wl}-bM:SRE'
	  fi
	fi
      fi

      export_dynamic_flag_spec='${wl}-bexpall'
      # It seems that -bexpall does not export symbols beginning with
      # underscore (_), so it is better to generate a list of symbols to export.
      always_export_symbols=yes
      if test "$aix_use_runtimelinking" = yes; then
	# Warning - without using the other runtime loading flags (-brtl),
	# -berok will link without error, but may produce a broken library.
	allow_undefined_flag='-berok'
        # Determine the default libpath from the value encoded in an
        # empty executable.
        if test "${lt_cv_aix_libpath+set}" = set; then
  aix_libpath=$lt_cv_aix_libpath
else
  if ${lt_cv_aix_libpath_+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :

  lt_aix_libpath_sed='
      /Import File Strings/,/^$/ {
	  /^0/ {
	      s/^0  *\([^ ]*\) *$/\1/
	      p
	  }
      }'
  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  # Check for a 64-bit object if we didn't find anything.
  if test -z "$lt_cv_aix_libpath_"; then
    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  fi
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
  if test -z "$lt_cv_aix_libpath_"; then
    lt_cv_aix_libpath_="/usr/lib:/lib"
  fi

fi

  aix_libpath=$lt_cv_aix_libpath_
fi

        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
      else
	if test "$host_cpu" = ia64; then
	  hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
	  allow_undefined_flag="-z nodefs"
	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
	else
	 # Determine the default libpath from the value encoded in an
	 # empty executable.
	 if test "${lt_cv_aix_libpath+set}" = set; then
  aix_libpath=$lt_cv_aix_libpath
else
  if ${lt_cv_aix_libpath_+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :

  lt_aix_libpath_sed='
      /Import File Strings/,/^$/ {
	  /^0/ {
	      s/^0  *\([^ ]*\) *$/\1/
	      p
	  }
      }'
  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  # Check for a 64-bit object if we didn't find anything.
  if test -z "$lt_cv_aix_libpath_"; then
    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  fi
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
  if test -z "$lt_cv_aix_libpath_"; then
    lt_cv_aix_libpath_="/usr/lib:/lib"
  fi

fi

  aix_libpath=$lt_cv_aix_libpath_
fi

	 hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
	  # Warning - without using the other run time loading flags,
	  # -berok will link without error, but may produce a broken library.
	  no_undefined_flag=' ${wl}-bernotok'
	  allow_undefined_flag=' ${wl}-berok'
	  if test "$with_gnu_ld" = yes; then
	    # We only use this code for GNU lds that support --whole-archive.
	    whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
	  else
	    # Exported symbols can be pulled into shared objects from archives
	    whole_archive_flag_spec='$convenience'
	  fi
	  archive_cmds_need_lc=yes
	  # This is similar to how AIX traditionally builds its shared libraries.
	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
	fi
      fi
      ;;

    amigaos*)
      case $host_cpu in
      powerpc)
            # see comment about AmigaOS4 .so support
            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
            archive_expsym_cmds=''
        ;;
      m68k)
            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
            hardcode_libdir_flag_spec='-L$libdir'
            hardcode_minus_L=yes
        ;;
      esac
      ;;

    bsdi[45]*)
      export_dynamic_flag_spec=-rdynamic
      ;;

    cygwin* | mingw* | pw32* | cegcc*)
      # When not using gcc, we currently assume that we are using
      # Microsoft Visual C++.
      # hardcode_libdir_flag_spec is actually meaningless, as there is
      # no search path for DLLs.
      case $cc_basename in
      cl*)
	# Native MSVC
	hardcode_libdir_flag_spec=' '
	allow_undefined_flag=unsupported
	always_export_symbols=yes
	file_list_spec='@'
	# Tell ltmain to make .lib files, not .a files.
	libext=lib
	# Tell ltmain to make .dll files, not .so files.
	shrext_cmds=".dll"
	# FIXME: Setting linknames here is a bad hack.
	archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
	archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
	    sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
	  else
	    sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
	  fi~
	  $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
	  linknames='
	# The linker will not automatically build a static lib if we build a DLL.
	# _LT_TAGVAR(old_archive_from_new_cmds, )='true'
	enable_shared_with_static_runtimes=yes
	exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
	export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
	# Don't use ranlib
	old_postinstall_cmds='chmod 644 $oldlib'
	postlink_cmds='lt_outputfile="@OUTPUT@"~
	  lt_tool_outputfile="@TOOL_OUTPUT@"~
	  case $lt_outputfile in
	    *.exe|*.EXE) ;;
	    *)
	      lt_outputfile="$lt_outputfile.exe"
	      lt_tool_outputfile="$lt_tool_outputfile.exe"
	      ;;
	  esac~
	  if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
	    $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
	    $RM "$lt_outputfile.manifest";
	  fi'
	;;
      *)
	# Assume MSVC wrapper
	hardcode_libdir_flag_spec=' '
	allow_undefined_flag=unsupported
	# Tell ltmain to make .lib files, not .a files.
	libext=lib
	# Tell ltmain to make .dll files, not .so files.
	shrext_cmds=".dll"
	# FIXME: Setting linknames here is a bad hack.
	archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
	# The linker will automatically build a .lib file if we build a DLL.
	old_archive_from_new_cmds='true'
	# FIXME: Should let the user specify the lib program.
	old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
	enable_shared_with_static_runtimes=yes
	;;
      esac
      ;;

    darwin* | rhapsody*)


  archive_cmds_need_lc=no
  hardcode_direct=no
  hardcode_automatic=yes
  hardcode_shlibpath_var=unsupported
  if test "$lt_cv_ld_force_load" = "yes"; then
    whole_archive_flag_spec='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'

  else
    whole_archive_flag_spec=''
  fi
  link_all_deplibs=yes
  allow_undefined_flag="$_lt_dar_allow_undefined"
  case $cc_basename in
     ifort*) _lt_dar_can_shared=yes ;;
     *) _lt_dar_can_shared=$GCC ;;
  esac
  if test "$_lt_dar_can_shared" = "yes"; then
    output_verbose_link_cmd=func_echo_all
    archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
    module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
    archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
    module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"

  else
  ld_shlibs=no
  fi

      ;;

    dgux*)
      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
      hardcode_libdir_flag_spec='-L$libdir'
      hardcode_shlibpath_var=no
      ;;

    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
    # support.  Future versions do this automatically, but an explicit c++rt0.o
    # does not break anything, and helps significantly (at the cost of a little
    # extra space).
    freebsd2.2*)
      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
      hardcode_libdir_flag_spec='-R$libdir'
      hardcode_direct=yes
      hardcode_shlibpath_var=no
      ;;

    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
    freebsd2.*)
      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
      hardcode_direct=yes
      hardcode_minus_L=yes
      hardcode_shlibpath_var=no
      ;;

    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
    freebsd* | dragonfly*)
      archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
      hardcode_libdir_flag_spec='-R$libdir'
      hardcode_direct=yes
      hardcode_shlibpath_var=no
      ;;

    hpux9*)
      if test "$GCC" = yes; then
	archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
      else
	archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
      fi
      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
      hardcode_libdir_separator=:
      hardcode_direct=yes

      # hardcode_minus_L: Not really in the search PATH,
      # but as the default location of the library.
      hardcode_minus_L=yes
      export_dynamic_flag_spec='${wl}-E'
      ;;

    hpux10*)
      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
	archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
      else
	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
      fi
      if test "$with_gnu_ld" = no; then
	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
	hardcode_libdir_separator=:
	hardcode_direct=yes
	hardcode_direct_absolute=yes
	export_dynamic_flag_spec='${wl}-E'
	# hardcode_minus_L: Not really in the search PATH,
	# but as the default location of the library.
	hardcode_minus_L=yes
      fi
      ;;

    hpux11*)
      if test "$GCC" = yes && test "$with_gnu_ld" = no; then
	case $host_cpu in
	hppa*64*)
	  archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	ia64*)
	  archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	*)
	  archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	esac
      else
	case $host_cpu in
	hppa*64*)
	  archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	ia64*)
	  archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	*)

	  # Older versions of the 11.00 compiler do not understand -b yet
	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
	  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
$as_echo_n "checking if $CC understands -b... " >&6; }
if ${lt_cv_prog_compiler__b+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler__b=no
   save_LDFLAGS="$LDFLAGS"
   LDFLAGS="$LDFLAGS -b"
   echo "$lt_simple_link_test_code" > conftest.$ac_ext
   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
     # The linker can only warn and ignore the option if not recognized
     # So say no if there are warnings
     if test -s conftest.err; then
       # Append any errors to the config.log.
       cat conftest.err 1>&5
       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
       if diff conftest.exp conftest.er2 >/dev/null; then
         lt_cv_prog_compiler__b=yes
       fi
     else
       lt_cv_prog_compiler__b=yes
     fi
   fi
   $RM -r conftest*
   LDFLAGS="$save_LDFLAGS"

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
$as_echo "$lt_cv_prog_compiler__b" >&6; }

if test x"$lt_cv_prog_compiler__b" = xyes; then
    archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
else
    archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
fi

	  ;;
	esac
      fi
      if test "$with_gnu_ld" = no; then
	hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
	hardcode_libdir_separator=:

	case $host_cpu in
	hppa*64*|ia64*)
	  hardcode_direct=no
	  hardcode_shlibpath_var=no
	  ;;
	*)
	  hardcode_direct=yes
	  hardcode_direct_absolute=yes
	  export_dynamic_flag_spec='${wl}-E'

	  # hardcode_minus_L: Not really in the search PATH,
	  # but as the default location of the library.
	  hardcode_minus_L=yes
	  ;;
	esac
      fi
      ;;

    irix5* | irix6* | nonstopux*)
      if test "$GCC" = yes; then
	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
	# Try to use the -exported_symbol ld option, if it does not
	# work, assume that -exports_file does not work either and
	# implicitly export all symbols.
	# This should be the same for all languages, so no per-tag cache variable.
	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5
$as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >&6; }
if ${lt_cv_irix_exported_symbol+:} false; then :
  $as_echo_n "(cached) " >&6
else
  save_LDFLAGS="$LDFLAGS"
	   LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
	   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
int foo (void) { return 0; }
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  lt_cv_irix_exported_symbol=yes
else
  lt_cv_irix_exported_symbol=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
           LDFLAGS="$save_LDFLAGS"
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
$as_echo "$lt_cv_irix_exported_symbol" >&6; }
	if test "$lt_cv_irix_exported_symbol" = yes; then
          archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
	fi
      else
	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
      fi
      archive_cmds_need_lc='no'
      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
      hardcode_libdir_separator=:
      inherit_rpath=yes
      link_all_deplibs=yes
      ;;

    netbsd*)
      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
      else
	archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
      fi
      hardcode_libdir_flag_spec='-R$libdir'
      hardcode_direct=yes
      hardcode_shlibpath_var=no
      ;;

    newsos6)
      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
      hardcode_direct=yes
      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
      hardcode_libdir_separator=:
      hardcode_shlibpath_var=no
      ;;

    *nto* | *qnx*)
      ;;

    openbsd*)
      if test -f /usr/libexec/ld.so; then
	hardcode_direct=yes
	hardcode_shlibpath_var=no
	hardcode_direct_absolute=yes
	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
	  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
	  hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
	  export_dynamic_flag_spec='${wl}-E'
	else
	  case $host_os in
	   openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
	     archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
	     hardcode_libdir_flag_spec='-R$libdir'
	     ;;
	   *)
	     archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
	     hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
	     ;;
	  esac
	fi
      else
	ld_shlibs=no
      fi
      ;;

    os2*)
      hardcode_libdir_flag_spec='-L$libdir'
      hardcode_minus_L=yes
      allow_undefined_flag=unsupported
      archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
      old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
      ;;

    osf3*)
      if test "$GCC" = yes; then
	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
      else
	allow_undefined_flag=' -expect_unresolved \*'
	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
      fi
      archive_cmds_need_lc='no'
      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
      hardcode_libdir_separator=:
      ;;

    osf4* | osf5*)	# as osf3* with the addition of -msym flag
      if test "$GCC" = yes; then
	allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
	archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
	hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
      else
	allow_undefined_flag=' -expect_unresolved \*'
	archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
	$CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'

	# Both c and cxx compiler support -rpath directly
	hardcode_libdir_flag_spec='-rpath $libdir'
      fi
      archive_cmds_need_lc='no'
      hardcode_libdir_separator=:
      ;;

    solaris*)
      no_undefined_flag=' -z defs'
      if test "$GCC" = yes; then
	wlarc='${wl}'
	archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
	archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
	  $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
      else
	case `$CC -V 2>&1` in
	*"Compilers 5.0"*)
	  wlarc=''
	  archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
	  $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
	  ;;
	*)
	  wlarc='${wl}'
	  archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
	  $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
	  ;;
	esac
      fi
      hardcode_libdir_flag_spec='-R$libdir'
      hardcode_shlibpath_var=no
      case $host_os in
      solaris2.[0-5] | solaris2.[0-5].*) ;;
      *)
	# The compiler driver will combine and reorder linker options,
	# but understands `-z linker_flag'.  GCC discards it without `$wl',
	# but is careful enough not to reorder.
	# Supported since Solaris 2.6 (maybe 2.5.1?)
	if test "$GCC" = yes; then
	  whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
	else
	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
	fi
	;;
      esac
      link_all_deplibs=yes
      ;;

    sunos4*)
      if test "x$host_vendor" = xsequent; then
	# Use $CC to link under sequent, because it throws in some extra .o
	# files that make .init and .fini sections work.
	archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
      else
	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
      fi
      hardcode_libdir_flag_spec='-L$libdir'
      hardcode_direct=yes
      hardcode_minus_L=yes
      hardcode_shlibpath_var=no
      ;;

    sysv4)
      case $host_vendor in
	sni)
	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
	  hardcode_direct=yes # is this really true???
	;;
	siemens)
	  ## LD is ld it makes a PLAMLIB
	  ## CC just makes a GrossModule.
	  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
	  reload_cmds='$CC -r -o $output$reload_objs'
	  hardcode_direct=no
        ;;
	motorola)
	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
	  hardcode_direct=no #Motorola manual says yes, but my tests say they lie
	;;
      esac
      runpath_var='LD_RUN_PATH'
      hardcode_shlibpath_var=no
      ;;

    sysv4.3*)
      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
      hardcode_shlibpath_var=no
      export_dynamic_flag_spec='-Bexport'
      ;;

    sysv4*MP*)
      if test -d /usr/nec; then
	archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
	hardcode_shlibpath_var=no
	runpath_var=LD_RUN_PATH
	hardcode_runpath_var=yes
	ld_shlibs=yes
      fi
      ;;

    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
      no_undefined_flag='${wl}-z,text'
      archive_cmds_need_lc=no
      hardcode_shlibpath_var=no
      runpath_var='LD_RUN_PATH'

      if test "$GCC" = yes; then
	archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
      else
	archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
      fi
      ;;

    sysv5* | sco3.2v5* | sco5v6*)
      # Note: We can NOT use -z defs as we might desire, because we do not
      # link with -lc, and that would cause any symbols used from libc to
      # always be unresolved, which means just about no library would
      # ever link correctly.  If we're not using GNU ld we use -z text
      # though, which does catch some bad symbols but isn't as heavy-handed
      # as -z defs.
      no_undefined_flag='${wl}-z,text'
      allow_undefined_flag='${wl}-z,nodefs'
      archive_cmds_need_lc=no
      hardcode_shlibpath_var=no
      hardcode_libdir_flag_spec='${wl}-R,$libdir'
      hardcode_libdir_separator=':'
      link_all_deplibs=yes
      export_dynamic_flag_spec='${wl}-Bexport'
      runpath_var='LD_RUN_PATH'

      if test "$GCC" = yes; then
	archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
      else
	archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
      fi
      ;;

    uts4*)
      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
      hardcode_libdir_flag_spec='-L$libdir'
      hardcode_shlibpath_var=no
      ;;

    *)
      ld_shlibs=no
      ;;
    esac

    if test x$host_vendor = xsni; then
      case $host in
      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
	export_dynamic_flag_spec='${wl}-Blargedynsym'
	;;
      esac
    fi
  fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
$as_echo "$ld_shlibs" >&6; }
test "$ld_shlibs" = no && can_build_shared=no

with_gnu_ld=$with_gnu_ld















#
# Do we need to explicitly link libc?
#
case "x$archive_cmds_need_lc" in
x|xyes)
  # Assume -lc should be added
  archive_cmds_need_lc=yes

  if test "$enable_shared" = yes && test "$GCC" = yes; then
    case $archive_cmds in
    *'~'*)
      # FIXME: we may have to deal with multi-command sequences.
      ;;
    '$CC '*)
      # Test whether the compiler implicitly links with -lc since on some
      # systems, -lgcc has to come before -lc. If gcc already passes -lc
      # to ld, don't add -lc before -lgcc.
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
if ${lt_cv_archive_cmds_need_lc+:} false; then :
  $as_echo_n "(cached) " >&6
else
  $RM conftest*
	echo "$lt_simple_compile_test_code" > conftest.$ac_ext

	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  (eval $ac_compile) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } 2>conftest.err; then
	  soname=conftest
	  lib=conftest
	  libobjs=conftest.$ac_objext
	  deplibs=
	  wl=$lt_prog_compiler_wl
	  pic_flag=$lt_prog_compiler_pic
	  compiler_flags=-v
	  linker_flags=-v
	  verstring=
	  output_objdir=.
	  libname=conftest
	  lt_save_allow_undefined_flag=$allow_undefined_flag
	  allow_undefined_flag=
	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
  (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
	  then
	    lt_cv_archive_cmds_need_lc=no
	  else
	    lt_cv_archive_cmds_need_lc=yes
	  fi
	  allow_undefined_flag=$lt_save_allow_undefined_flag
	else
	  cat conftest.err 1>&5
	fi
	$RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
$as_echo "$lt_cv_archive_cmds_need_lc" >&6; }
      archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc
      ;;
    esac
  fi
  ;;
esac
























































































































































  { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
$as_echo_n "checking dynamic linker characteristics... " >&6; }

if test "$GCC" = yes; then
  case $host_os in
    darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
    *) lt_awk_arg="/^libraries:/" ;;
  esac
  case $host_os in
    mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;;
    *) lt_sed_strip_eq="s,=/,/,g" ;;
  esac
  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
  case $lt_search_path_spec in
  *\;*)
    # if the path contains ";" then we assume it to be the separator
    # otherwise default to the standard path separator (i.e. ":") - it is
    # assumed that no part of a normal pathname contains ";" but that should
    # okay in the real world where ";" in dirpaths is itself problematic.
    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
    ;;
  *)
    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
    ;;
  esac
  # Ok, now we have the path, separated by spaces, we can step through it
  # and add multilib dir if necessary.
  lt_tmp_lt_search_path_spec=
  lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
  for lt_sys_path in $lt_search_path_spec; do
    if test -d "$lt_sys_path/$lt_multi_os_dir"; then
      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir"
    else
      test -d "$lt_sys_path" && \
	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
    fi
  done
  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
BEGIN {RS=" "; FS="/|\n";} {
  lt_foo="";
  lt_count=0;
  for (lt_i = NF; lt_i > 0; lt_i--) {
    if ($lt_i != "" && $lt_i != ".") {
      if ($lt_i == "..") {
        lt_count++;
      } else {
        if (lt_count == 0) {
          lt_foo="/" $lt_i lt_foo;
        } else {
          lt_count--;
        }
      }
    }
  }
  if (lt_foo != "") { lt_freq[lt_foo]++; }
  if (lt_freq[lt_foo] == 1) { print lt_foo; }
}'`
  # AWK program above erroneously prepends '/' to C:/dos/paths
  # for these hosts.
  case $host_os in
    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
      $SED 's,/\([A-Za-z]:\),\1,g'` ;;
  esac
  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
else
  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
fi
library_names_spec=
libname_spec='lib$name'
soname_spec=
shrext_cmds=".so"
postinstall_cmds=
postuninstall_cmds=
finish_cmds=
finish_eval=
shlibpath_var=
shlibpath_overrides_runpath=unknown
version_type=none
dynamic_linker="$host_os ld.so"
sys_lib_dlsearch_path_spec="/lib /usr/lib"
need_lib_prefix=unknown
hardcode_into_libs=no

# when you set need_version to no, make sure it does not cause -set_version
# flags to be left without arguments
need_version=unknown

case $host_os in
aix3*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
  shlibpath_var=LIBPATH

  # AIX 3 has no versioning support, so we append a major version to the name.
  soname_spec='${libname}${release}${shared_ext}$major'
  ;;

aix[4-9]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  hardcode_into_libs=yes
  if test "$host_cpu" = ia64; then
    # AIX 5 supports IA64
    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
    shlibpath_var=LD_LIBRARY_PATH
  else
    # With GCC up to 2.95.x, collect2 would create an import file
    # for dependence libraries.  The import file would start with
    # the line `#! .'.  This would cause the generated library to
    # depend on `.', always an invalid library.  This was fixed in
    # development snapshots of GCC prior to 3.0.
    case $host_os in
      aix4 | aix4.[01] | aix4.[01].*)
      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
	   echo ' yes '
	   echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
	:
      else
	can_build_shared=no
      fi
      ;;
    esac
    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
    # soname into executable. Probably we can add versioning support to
    # collect2, so additional links can be useful in future.
    if test "$aix_use_runtimelinking" = yes; then
      # If using run time linking (on AIX 4.2 or later) use lib.so
      # instead of lib.a to let people know that these are not
      # typical AIX shared libraries.
      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    else
      # We preserve .a as extension for shared libraries through AIX4.2
      # and later when we are not doing run time linking.
      library_names_spec='${libname}${release}.a $libname.a'
      soname_spec='${libname}${release}${shared_ext}$major'
    fi
    shlibpath_var=LIBPATH
  fi
  ;;

amigaos*)
  case $host_cpu in
  powerpc)
    # Since July 2007 AmigaOS4 officially supports .so libraries.
    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    ;;
  m68k)
    library_names_spec='$libname.ixlibrary $libname.a'
    # Create ${libname}_ixlibrary.a entries in /sys/libs.
    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
    ;;
  esac
  ;;

beos*)
  library_names_spec='${libname}${shared_ext}'
  dynamic_linker="$host_os ld.so"
  shlibpath_var=LIBRARY_PATH
  ;;

bsdi[45]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
  # the default ld.so.conf also contains /usr/contrib/lib and
  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
  # libtool to hard-code these into programs
  ;;

cygwin* | mingw* | pw32* | cegcc*)
  version_type=windows
  shrext_cmds=".dll"
  need_version=no
  need_lib_prefix=no

  case $GCC,$cc_basename in
  yes,*)
    # gcc
    library_names_spec='$libname.dll.a'
    # DLL is installed to $(libdir)/../bin by postinstall_cmds
    postinstall_cmds='base_file=`basename \${file}`~
      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
      dldir=$destdir/`dirname \$dlpath`~
      test -d \$dldir || mkdir -p \$dldir~
      $install_prog $dir/$dlname \$dldir/$dlname~
      chmod a+x \$dldir/$dlname~
      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
      fi'
    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
      dlpath=$dir/\$dldll~
       $RM \$dlpath'
    shlibpath_overrides_runpath=yes

    case $host_os in
    cygwin*)
      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
      ;;
    mingw* | cegcc*)
      # MinGW DLLs use traditional 'lib' prefix
      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
      ;;
    pw32*)
      # pw32 DLLs use 'pw' prefix rather than 'lib'
      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
      ;;
    esac
    dynamic_linker='Win32 ld.exe'
    ;;

  *,cl*)
    # Native MSVC
    libname_spec='$name'
    soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
    library_names_spec='${libname}.dll.lib'

    case $build_os in
    mingw*)
      sys_lib_search_path_spec=
      lt_save_ifs=$IFS
      IFS=';'
      for lt_path in $LIB
      do
        IFS=$lt_save_ifs
        # Let DOS variable expansion print the short 8.3 style file name.
        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
      done
      IFS=$lt_save_ifs
      # Convert to MSYS style.
      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
      ;;
    cygwin*)
      # Convert to unix form, then to dos form, then back to unix form
      # but this time dos style (no spaces!) so that the unix form looks
      # like /cygdrive/c/PROGRA~1:/cygdr...
      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
      ;;
    *)
      sys_lib_search_path_spec="$LIB"
      if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
        # It is most probably a Windows format PATH.
        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
      else
        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
      fi
      # FIXME: find the short name or the path components, as spaces are
      # common. (e.g. "Program Files" -> "PROGRA~1")
      ;;
    esac

    # DLL is installed to $(libdir)/../bin by postinstall_cmds
    postinstall_cmds='base_file=`basename \${file}`~
      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
      dldir=$destdir/`dirname \$dlpath`~
      test -d \$dldir || mkdir -p \$dldir~
      $install_prog $dir/$dlname \$dldir/$dlname'
    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
      dlpath=$dir/\$dldll~
       $RM \$dlpath'
    shlibpath_overrides_runpath=yes
    dynamic_linker='Win32 link.exe'
    ;;

  *)
    # Assume MSVC wrapper
    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
    dynamic_linker='Win32 ld.exe'
    ;;
  esac
  # FIXME: first we should search . and the directory the executable is in
  shlibpath_var=PATH
  ;;

darwin* | rhapsody*)
  dynamic_linker="$host_os dyld"
  version_type=darwin
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
  soname_spec='${libname}${release}${major}$shared_ext'
  shlibpath_overrides_runpath=yes
  shlibpath_var=DYLD_LIBRARY_PATH
  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'

  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"
  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
  ;;

dgux*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  ;;

freebsd* | dragonfly*)
  # DragonFly does not have aout.  When/if they implement a new
  # versioning mechanism, adjust this.
  if test -x /usr/bin/objformat; then
    objformat=`/usr/bin/objformat`
  else
    case $host_os in
    freebsd[23].*) objformat=aout ;;
    *) objformat=elf ;;
    esac
  fi
  version_type=freebsd-$objformat
  case $version_type in
    freebsd-elf*)
      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
      need_version=no
      need_lib_prefix=no
      ;;
    freebsd-*)
      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
      need_version=yes
      ;;
  esac
  shlibpath_var=LD_LIBRARY_PATH
  case $host_os in
  freebsd2.*)
    shlibpath_overrides_runpath=yes
    ;;
  freebsd3.[01]* | freebsdelf3.[01]*)
    shlibpath_overrides_runpath=yes
    hardcode_into_libs=yes
    ;;
  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
    shlibpath_overrides_runpath=no
    hardcode_into_libs=yes
    ;;
  *) # from 4.6 on, and DragonFly
    shlibpath_overrides_runpath=yes
    hardcode_into_libs=yes
    ;;
  esac
  ;;

gnu*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

haiku*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  dynamic_linker="$host_os runtime_loader"
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
  hardcode_into_libs=yes
  ;;

hpux9* | hpux10* | hpux11*)
  # Give a soname corresponding to the major version so that dld.sl refuses to
  # link against other versions.
  version_type=sunos
  need_lib_prefix=no
  need_version=no
  case $host_cpu in
  ia64*)
    shrext_cmds='.so'
    hardcode_into_libs=yes
    dynamic_linker="$host_os dld.so"
    shlibpath_var=LD_LIBRARY_PATH
    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    if test "X$HPUX_IA64_MODE" = X32; then
      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
    else
      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
    fi
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
    ;;
  hppa*64*)
    shrext_cmds='.sl'
    hardcode_into_libs=yes
    dynamic_linker="$host_os dld.sl"
    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
    ;;
  *)
    shrext_cmds='.sl'
    dynamic_linker="$host_os dld.sl"
    shlibpath_var=SHLIB_PATH
    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    ;;
  esac
  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
  postinstall_cmds='chmod 555 $lib'
  # or fails outright, so override atomically:
  install_override_mode=555
  ;;

interix[3-9]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

irix5* | irix6* | nonstopux*)
  case $host_os in
    nonstopux*) version_type=nonstopux ;;
    *)
	if test "$lt_cv_prog_gnu_ld" = yes; then
		version_type=linux # correct to gnu/linux during the next big refactor
	else
		version_type=irix
	fi ;;
  esac
  need_lib_prefix=no
  need_version=no
  soname_spec='${libname}${release}${shared_ext}$major'
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
  case $host_os in
  irix5* | nonstopux*)
    libsuff= shlibsuff=
    ;;
  *)
    case $LD in # libtool.m4 will add one of these switches to LD
    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
      libsuff= shlibsuff= libmagic=32-bit;;
    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
      libsuff=32 shlibsuff=N32 libmagic=N32;;
    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
      libsuff=64 shlibsuff=64 libmagic=64-bit;;
    *) libsuff= shlibsuff= libmagic=never-match;;
    esac
    ;;
  esac
  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
  shlibpath_overrides_runpath=no
  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
  hardcode_into_libs=yes
  ;;

# No shared lib support for Linux oldld, aout, or coff.
linux*oldld* | linux*aout* | linux*coff*)
  dynamic_linker=no
  ;;

# This must be glibc/ELF.
linux* | k*bsd*-gnu | kopensolaris*-gnu)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no

  # Some binutils ld are patched to set DT_RUNPATH
  if ${lt_cv_shlibpath_overrides_runpath+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_shlibpath_overrides_runpath=no
    save_LDFLAGS=$LDFLAGS
    save_libdir=$libdir
    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
  lt_cv_shlibpath_overrides_runpath=yes
fi
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
    LDFLAGS=$save_LDFLAGS
    libdir=$save_libdir

fi

  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath

  # This implies no fast_install, which is unacceptable.
  # Some rework will be needed to allow for fast_install
  # before this can be enabled.
  hardcode_into_libs=yes

  # Add ABI-specific directories to the system library path.
  sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib"

  # Append ld.so.conf contents to the search path
  if test -f /etc/ld.so.conf; then
    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
    sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra"

  fi

  # We used to test for /lib/ld.so.1 and disable shared libraries on
  # powerpc, because MkLinux only supported shared libraries with the
  # GNU dynamic linker.  Since this was broken with cross compilers,
  # most powerpc-linux boxes support dynamic linking these days and
  # people can always --disable-shared, the test was removed, and we
  # assume the GNU/Linux dynamic linker is in use.
  dynamic_linker='GNU/Linux ld.so'
  ;;

netbsd*)
  version_type=sunos
  need_lib_prefix=no
  need_version=no
  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
    dynamic_linker='NetBSD (a.out) ld.so'
  else
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    dynamic_linker='NetBSD ld.elf_so'
  fi
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  ;;

newsos6)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  ;;

*nto* | *qnx*)
  version_type=qnx
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  dynamic_linker='ldqnx.so'
  ;;

openbsd*)
  version_type=sunos
  sys_lib_dlsearch_path_spec="/usr/lib"
  need_lib_prefix=no
  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
  case $host_os in
    openbsd3.3 | openbsd3.3.*)	need_version=yes ;;
    *)				need_version=no  ;;
  esac
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
    case $host_os in
      openbsd2.[89] | openbsd2.[89].*)
	shlibpath_overrides_runpath=no
	;;
      *)
	shlibpath_overrides_runpath=yes
	;;
      esac
  else
    shlibpath_overrides_runpath=yes
  fi
  ;;

os2*)
  libname_spec='$name'
  shrext_cmds=".dll"
  need_lib_prefix=no
  library_names_spec='$libname${shared_ext} $libname.a'
  dynamic_linker='OS/2 ld.exe'
  shlibpath_var=LIBPATH
  ;;

osf3* | osf4* | osf5*)
  version_type=osf
  need_lib_prefix=no
  need_version=no
  soname_spec='${libname}${release}${shared_ext}$major'
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
  ;;

rdos*)
  dynamic_linker=no
  ;;

solaris*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  # ldd complains unless libraries are executable
  postinstall_cmds='chmod +x $lib'
  ;;

sunos4*)
  version_type=sunos
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  if test "$with_gnu_ld" = yes; then
    need_lib_prefix=no
  fi
  need_version=yes
  ;;

sysv4 | sysv4.3*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  case $host_vendor in
    sni)
      shlibpath_overrides_runpath=no
      need_lib_prefix=no
      runpath_var=LD_RUN_PATH
      ;;
    siemens)
      need_lib_prefix=no
      ;;
    motorola)
      need_lib_prefix=no
      need_version=no
      shlibpath_overrides_runpath=no
      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
      ;;
  esac
  ;;

sysv4*MP*)
  if test -d /usr/nec ;then
    version_type=linux # correct to gnu/linux during the next big refactor
    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
    soname_spec='$libname${shared_ext}.$major'
    shlibpath_var=LD_LIBRARY_PATH
  fi
  ;;

sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
  version_type=freebsd-elf
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  if test "$with_gnu_ld" = yes; then
    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
  else
    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
    case $host_os in
      sco3.2v5*)
        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
	;;
    esac
  fi
  sys_lib_dlsearch_path_spec='/usr/lib'
  ;;

tpf*)
  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

uts4*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  ;;

*)
  dynamic_linker=no
  ;;
esac
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
$as_echo "$dynamic_linker" >&6; }
test "$dynamic_linker" = no && can_build_shared=no

variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
if test "$GCC" = yes; then
  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
fi

if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
  sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
fi
if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
  sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
fi




























































































  { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
hardcode_action=
if test -n "$hardcode_libdir_flag_spec" ||
   test -n "$runpath_var" ||
   test "X$hardcode_automatic" = "Xyes" ; then

  # We can hardcode non-existent directories.
  if test "$hardcode_direct" != no &&
     # If the only mechanism to avoid hardcoding is shlibpath_var, we
     # have to relink, otherwise we might link with an installed library
     # when we should be linking with a yet-to-be-installed one
     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no &&
     test "$hardcode_minus_L" != no; then
    # Linking always hardcodes the temporary library directory.
    hardcode_action=relink
  else
    # We can link without hardcoding, and we can hardcode nonexisting dirs.
    hardcode_action=immediate
  fi
else
  # We cannot hardcode anything, or else we can only hardcode existing
  # directories.
  hardcode_action=unsupported
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
$as_echo "$hardcode_action" >&6; }

if test "$hardcode_action" = relink ||
   test "$inherit_rpath" = yes; then
  # Fast installation is not supported
  enable_fast_install=no
elif test "$shlibpath_overrides_runpath" = yes ||
     test "$enable_shared" = no; then
  # Fast installation is not necessary
  enable_fast_install=needless
fi






  if test "x$enable_dlopen" != xyes; then
  enable_dlopen=unknown
  enable_dlopen_self=unknown
  enable_dlopen_self_static=unknown
else
  lt_cv_dlopen=no
  lt_cv_dlopen_libs=

  case $host_os in
  beos*)
    lt_cv_dlopen="load_add_on"
    lt_cv_dlopen_libs=
    lt_cv_dlopen_self=yes
    ;;

  mingw* | pw32* | cegcc*)
    lt_cv_dlopen="LoadLibrary"
    lt_cv_dlopen_libs=
    ;;

  cygwin*)
    lt_cv_dlopen="dlopen"
    lt_cv_dlopen_libs=
    ;;

  darwin*)
  # if libdl is installed we need to link against it
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
$as_echo_n "checking for dlopen in -ldl... " >&6; }
if ${ac_cv_lib_dl_dlopen+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ldl  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char dlopen ();
int
main ()
{
return dlopen ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_dl_dlopen=yes
else
  ac_cv_lib_dl_dlopen=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
else

    lt_cv_dlopen="dyld"
    lt_cv_dlopen_libs=
    lt_cv_dlopen_self=yes

fi

    ;;

  *)
    ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
if test "x$ac_cv_func_shl_load" = xyes; then :
  lt_cv_dlopen="shl_load"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
$as_echo_n "checking for shl_load in -ldld... " >&6; }
if ${ac_cv_lib_dld_shl_load+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ldld  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char shl_load ();
int
main ()
{
return shl_load ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_dld_shl_load=yes
else
  ac_cv_lib_dld_shl_load=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
if test "x$ac_cv_lib_dld_shl_load" = xyes; then :
  lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"
else
  ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
if test "x$ac_cv_func_dlopen" = xyes; then :
  lt_cv_dlopen="dlopen"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
$as_echo_n "checking for dlopen in -ldl... " >&6; }
if ${ac_cv_lib_dl_dlopen+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ldl  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char dlopen ();
int
main ()
{
return dlopen ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_dl_dlopen=yes
else
  ac_cv_lib_dl_dlopen=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
$as_echo_n "checking for dlopen in -lsvld... " >&6; }
if ${ac_cv_lib_svld_dlopen+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lsvld  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char dlopen ();
int
main ()
{
return dlopen ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_svld_dlopen=yes
else
  ac_cv_lib_svld_dlopen=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
$as_echo "$ac_cv_lib_svld_dlopen" >&6; }
if test "x$ac_cv_lib_svld_dlopen" = xyes; then :
  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
$as_echo_n "checking for dld_link in -ldld... " >&6; }
if ${ac_cv_lib_dld_dld_link+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ldld  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char dld_link ();
int
main ()
{
return dld_link ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_dld_dld_link=yes
else
  ac_cv_lib_dld_dld_link=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
$as_echo "$ac_cv_lib_dld_dld_link" >&6; }
if test "x$ac_cv_lib_dld_dld_link" = xyes; then :
  lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"
fi


fi


fi


fi


fi


fi

    ;;
  esac

  if test "x$lt_cv_dlopen" != xno; then
    enable_dlopen=yes
  else
    enable_dlopen=no
  fi

  case $lt_cv_dlopen in
  dlopen)
    save_CPPFLAGS="$CPPFLAGS"
    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"

    save_LDFLAGS="$LDFLAGS"
    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"

    save_LIBS="$LIBS"
    LIBS="$lt_cv_dlopen_libs $LIBS"

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
$as_echo_n "checking whether a program can dlopen itself... " >&6; }
if ${lt_cv_dlopen_self+:} false; then :
  $as_echo_n "(cached) " >&6
else
  	  if test "$cross_compiling" = yes; then :
  lt_cv_dlopen_self=cross
else
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
  lt_status=$lt_dlunknown
  cat > conftest.$ac_ext <<_LT_EOF
#line $LINENO "configure"
#include "confdefs.h"

#if HAVE_DLFCN_H
#include 
#endif

#include 

#ifdef RTLD_GLOBAL
#  define LT_DLGLOBAL		RTLD_GLOBAL
#else
#  ifdef DL_GLOBAL
#    define LT_DLGLOBAL		DL_GLOBAL
#  else
#    define LT_DLGLOBAL		0
#  endif
#endif

/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
   find out it does not work in some platform. */
#ifndef LT_DLLAZY_OR_NOW
#  ifdef RTLD_LAZY
#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
#  else
#    ifdef DL_LAZY
#      define LT_DLLAZY_OR_NOW		DL_LAZY
#    else
#      ifdef RTLD_NOW
#        define LT_DLLAZY_OR_NOW	RTLD_NOW
#      else
#        ifdef DL_NOW
#          define LT_DLLAZY_OR_NOW	DL_NOW
#        else
#          define LT_DLLAZY_OR_NOW	0
#        endif
#      endif
#    endif
#  endif
#endif

/* When -fvisbility=hidden is used, assume the code has been annotated
   correspondingly for the symbols needed.  */
#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
int fnord () __attribute__((visibility("default")));
#endif

int fnord () { return 42; }
int main ()
{
  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
  int status = $lt_dlunknown;

  if (self)
    {
      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
      else
        {
	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
          else puts (dlerror ());
	}
      /* dlclose (self); */
    }
  else
    puts (dlerror ());

  return status;
}
_LT_EOF
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
  (eval $ac_link) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
    (./conftest; exit; ) >&5 2>/dev/null
    lt_status=$?
    case x$lt_status in
      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
    esac
  else :
    # compilation failed
    lt_cv_dlopen_self=no
  fi
fi
rm -fr conftest*


fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
$as_echo "$lt_cv_dlopen_self" >&6; }

    if test "x$lt_cv_dlopen_self" = xyes; then
      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; }
if ${lt_cv_dlopen_self_static+:} false; then :
  $as_echo_n "(cached) " >&6
else
  	  if test "$cross_compiling" = yes; then :
  lt_cv_dlopen_self_static=cross
else
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
  lt_status=$lt_dlunknown
  cat > conftest.$ac_ext <<_LT_EOF
#line $LINENO "configure"
#include "confdefs.h"

#if HAVE_DLFCN_H
#include 
#endif

#include 

#ifdef RTLD_GLOBAL
#  define LT_DLGLOBAL		RTLD_GLOBAL
#else
#  ifdef DL_GLOBAL
#    define LT_DLGLOBAL		DL_GLOBAL
#  else
#    define LT_DLGLOBAL		0
#  endif
#endif

/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
   find out it does not work in some platform. */
#ifndef LT_DLLAZY_OR_NOW
#  ifdef RTLD_LAZY
#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
#  else
#    ifdef DL_LAZY
#      define LT_DLLAZY_OR_NOW		DL_LAZY
#    else
#      ifdef RTLD_NOW
#        define LT_DLLAZY_OR_NOW	RTLD_NOW
#      else
#        ifdef DL_NOW
#          define LT_DLLAZY_OR_NOW	DL_NOW
#        else
#          define LT_DLLAZY_OR_NOW	0
#        endif
#      endif
#    endif
#  endif
#endif

/* When -fvisbility=hidden is used, assume the code has been annotated
   correspondingly for the symbols needed.  */
#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
int fnord () __attribute__((visibility("default")));
#endif

int fnord () { return 42; }
int main ()
{
  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
  int status = $lt_dlunknown;

  if (self)
    {
      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
      else
        {
	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
          else puts (dlerror ());
	}
      /* dlclose (self); */
    }
  else
    puts (dlerror ());

  return status;
}
_LT_EOF
  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
  (eval $ac_link) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
    (./conftest; exit; ) >&5 2>/dev/null
    lt_status=$?
    case x$lt_status in
      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
    esac
  else :
    # compilation failed
    lt_cv_dlopen_self_static=no
  fi
fi
rm -fr conftest*


fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
$as_echo "$lt_cv_dlopen_self_static" >&6; }
    fi

    CPPFLAGS="$save_CPPFLAGS"
    LDFLAGS="$save_LDFLAGS"
    LIBS="$save_LIBS"
    ;;
  esac

  case $lt_cv_dlopen_self in
  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
  *) enable_dlopen_self=unknown ;;
  esac

  case $lt_cv_dlopen_self_static in
  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
  *) enable_dlopen_self_static=unknown ;;
  esac
fi

















striplib=
old_striplib=
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
$as_echo_n "checking whether stripping libraries is possible... " >&6; }
if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
# FIXME - insert some real tests, host_os isn't really good enough
  case $host_os in
  darwin*)
    if test -n "$STRIP" ; then
      striplib="$STRIP -x"
      old_striplib="$STRIP -S"
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
    else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    fi
    ;;
  *)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    ;;
  esac
fi












  # Report which library types will actually be built
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
$as_echo_n "checking if libtool supports shared libraries... " >&6; }
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
$as_echo "$can_build_shared" >&6; }

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
$as_echo_n "checking whether to build shared libraries... " >&6; }
  test "$can_build_shared" = "no" && enable_shared=no

  # On AIX, shared libraries and static libraries use the same namespace, and
  # are all built from PIC.
  case $host_os in
  aix3*)
    test "$enable_shared" = yes && enable_static=no
    if test -n "$RANLIB"; then
      archive_cmds="$archive_cmds~\$RANLIB \$lib"
      postinstall_cmds='$RANLIB $lib'
    fi
    ;;

  aix[4-9]*)
    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
      test "$enable_shared" = yes && enable_static=no
    fi
    ;;
  esac
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
$as_echo "$enable_shared" >&6; }

  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
$as_echo_n "checking whether to build static libraries... " >&6; }
  # Make sure either enable_shared or enable_static is yes.
  test "$enable_shared" = yes || enable_static=yes
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
$as_echo "$enable_static" >&6; }




fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

CC="$lt_save_CC"















        ac_config_commands="$ac_config_commands libtool"




# Only expand once:




includedir="${includedir}/${PACKAGE_NAME}"

# Check whether --enable-silent-rules was given.
if test "${enable_silent_rules+set}" = set; then :
  enableval=$enable_silent_rules;
fi

case $enable_silent_rules in # (((
  yes) AM_DEFAULT_VERBOSITY=0;;
   no) AM_DEFAULT_VERBOSITY=1;;
    *) AM_DEFAULT_VERBOSITY=0;;
esac
am_make=${MAKE-make}
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
if ${am_cv_make_support_nested_variables+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if $as_echo 'TRUE=$(BAR$(V))
BAR0=false
BAR1=true
V=1
am__doit:
	@$(TRUE)
.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
  am_cv_make_support_nested_variables=yes
else
  am_cv_make_support_nested_variables=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
$as_echo "$am_cv_make_support_nested_variables" >&6; }
if test $am_cv_make_support_nested_variables = yes; then
    AM_V='$(V)'
  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
else
  AM_V=$AM_DEFAULT_VERBOSITY
  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
fi
AM_BACKSLASH='\'



# Check whether --enable-native-optimizations was given.
if test "${enable_native_optimizations+set}" = set; then :
  enableval=$enable_native_optimizations;
fi


   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5
$as_echo_n "checking for $CC option to accept ISO C99... " >&6; }
if ${ac_cv_prog_cc_c99+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_cv_prog_cc_c99=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
#include 
#include 
#include 
#include 

// Check varargs macros.  These examples are taken from C99 6.10.3.5.
#define debug(...) fprintf (stderr, __VA_ARGS__)
#define showlist(...) puts (#__VA_ARGS__)
#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
static void
test_varargs_macros (void)
{
  int x = 1234;
  int y = 5678;
  debug ("Flag");
  debug ("X = %d\n", x);
  showlist (The first, second, and third items.);
  report (x>y, "x is %d but y is %d", x, y);
}

// Check long long types.
#define BIG64 18446744073709551615ull
#define BIG32 4294967295ul
#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
#if !BIG_OK
  your preprocessor is broken;
#endif
#if BIG_OK
#else
  your preprocessor is broken;
#endif
static long long int bignum = -9223372036854775807LL;
static unsigned long long int ubignum = BIG64;

struct incomplete_array
{
  int datasize;
  double data[];
};

struct named_init {
  int number;
  const wchar_t *name;
  double average;
};

typedef const char *ccp;

static inline int
test_restrict (ccp restrict text)
{
  // See if C++-style comments work.
  // Iterate through items via the restricted pointer.
  // Also check for declarations in for loops.
  for (unsigned int i = 0; *(text+i) != '\0'; ++i)
    continue;
  return 0;
}

// Check varargs and va_copy.
static void
test_varargs (const char *format, ...)
{
  va_list args;
  va_start (args, format);
  va_list args_copy;
  va_copy (args_copy, args);

  const char *str;
  int number;
  float fnumber;

  while (*format)
    {
      switch (*format++)
	{
	case 's': // string
	  str = va_arg (args_copy, const char *);
	  break;
	case 'd': // int
	  number = va_arg (args_copy, int);
	  break;
	case 'f': // float
	  fnumber = va_arg (args_copy, double);
	  break;
	default:
	  break;
	}
    }
  va_end (args_copy);
  va_end (args);
}

int
main ()
{

  // Check bool.
  _Bool success = false;

  // Check restrict.
  if (test_restrict ("String literal") == 0)
    success = true;
  char *restrict newvar = "Another string";

  // Check varargs.
  test_varargs ("s, d' f .", "string", 65, 34.234);
  test_varargs_macros ();

  // Check flexible array members.
  struct incomplete_array *ia =
    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
  ia->datasize = 10;
  for (int i = 0; i < ia->datasize; ++i)
    ia->data[i] = i * 1.234;

  // Check named initializers.
  struct named_init ni = {
    .number = 34,
    .name = L"Test wide string",
    .average = 543.34343,
  };

  ni.number = 58;

  int dynamic_array[ni.number];
  dynamic_array[ni.number - 1] = 543;

  // work around unused variable warnings
  return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
	  || dynamic_array[ni.number - 1] != 543);

  ;
  return 0;
}
_ACEOF
for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99
do
  CC="$ac_save_CC $ac_arg"
  if ac_fn_c_try_compile "$LINENO"; then :
  ac_cv_prog_cc_c99=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext
  test "x$ac_cv_prog_cc_c99" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC

fi
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c99" in
  x)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
$as_echo "none needed" >&6; } ;;
  xno)
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
$as_echo "unsupported" >&6; } ;;
  *)
    CC="$CC $ac_cv_prog_cc_c99"
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
$as_echo "$ac_cv_prog_cc_c99" >&6; } ;;
esac
if test "x$ac_cv_prog_cc_c99" != xno; then :

fi



  OPENMP_CFLAGS=
  # Check whether --enable-openmp was given.
if test "${enable_openmp+set}" = set; then :
  enableval=$enable_openmp;
fi

  if test "$enable_openmp" != no; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to support OpenMP" >&5
$as_echo_n "checking for $CC option to support OpenMP... " >&6; }
if ${ac_cv_prog_c_openmp+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

#ifndef _OPENMP
 choke me
#endif
#include 
int main () { return omp_get_num_threads (); }

_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_prog_c_openmp='none needed'
else
  ac_cv_prog_c_openmp='unsupported'
	  	  	  	  	  	  	                                	  	  	  	  	  	  for ac_option in -fopenmp -xopenmp -openmp -mp -omp -qsmp=omp -homp \
                           -Popenmp --openmp; do
	    ac_save_CFLAGS=$CFLAGS
	    CFLAGS="$CFLAGS $ac_option"
	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

#ifndef _OPENMP
 choke me
#endif
#include 
int main () { return omp_get_num_threads (); }

_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_prog_c_openmp=$ac_option
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
	    CFLAGS=$ac_save_CFLAGS
	    if test "$ac_cv_prog_c_openmp" != unsupported; then
	      break
	    fi
	  done
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_c_openmp" >&5
$as_echo "$ac_cv_prog_c_openmp" >&6; }
    case $ac_cv_prog_c_openmp in #(
      "none needed" | unsupported)
	;; #(
      *)
	OPENMP_CFLAGS=$ac_cv_prog_c_openmp ;;
    esac
  fi


CPPFLAGS="$CPPFLAGS $OPENMP_CFLAGS"
CFLAGS="$CFLAGS $OPENMP_CFLAGS"
if test "x$enable_native_optimizations" = "xyes"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -march=native" >&5
$as_echo_n "checking whether C compiler accepts -march=native... " >&6; }
if ${ax_cv_check_cflags___march_native+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -march=native"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___march_native=yes
else
  ax_cv_check_cflags___march_native=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___march_native" >&5
$as_echo "$ax_cv_check_cflags___march_native" >&6; }
if test x"$ax_cv_check_cflags___march_native" = xyes; then :
  CC="$CC -march=native"
else
  :
fi

else

        if test "x$GCC" = "xyes" -a "x`$CC -dumpversion | cut -d. -f1,2`" = "x4.4"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -fno-tree-fre" >&5
$as_echo_n "checking whether C compiler accepts -fno-tree-fre... " >&6; }
if ${ax_cv_check_cflags___fno_tree_fre+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -fno-tree-fre"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___fno_tree_fre=yes
else
  ax_cv_check_cflags___fno_tree_fre=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___fno_tree_fre" >&5
$as_echo "$ax_cv_check_cflags___fno_tree_fre" >&6; }
if test x"$ax_cv_check_cflags___fno_tree_fre" = xyes; then :
  CFLAGS="$CFLAGS -fno-tree-fre"
else
  :
fi


fi


fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -fno-tree-vectorize" >&5
$as_echo_n "checking whether C compiler accepts -fno-tree-vectorize... " >&6; }
if ${ax_cv_check_cflags___fno_tree_vectorize+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -fno-tree-vectorize"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___fno_tree_vectorize=yes
else
  ax_cv_check_cflags___fno_tree_vectorize=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___fno_tree_vectorize" >&5
$as_echo "$ax_cv_check_cflags___fno_tree_vectorize" >&6; }
if test x"$ax_cv_check_cflags___fno_tree_vectorize" = xyes; then :
  CFLAGS="$CFLAGS -fno-tree-vectorize"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -fno-math-errno" >&5
$as_echo_n "checking whether C compiler accepts -fno-math-errno... " >&6; }
if ${ax_cv_check_cflags___fno_math_errno+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -fno-math-errno"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___fno_math_errno=yes
else
  ax_cv_check_cflags___fno_math_errno=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___fno_math_errno" >&5
$as_echo "$ax_cv_check_cflags___fno_math_errno" >&6; }
if test x"$ax_cv_check_cflags___fno_math_errno" = xyes; then :
  CFLAGS="$CFLAGS -fno-math-errno"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -funsafe-math-optimizations" >&5
$as_echo_n "checking whether C compiler accepts -funsafe-math-optimizations... " >&6; }
if ${ax_cv_check_cflags___funsafe_math_optimizations+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -funsafe-math-optimizations"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___funsafe_math_optimizations=yes
else
  ax_cv_check_cflags___funsafe_math_optimizations=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___funsafe_math_optimizations" >&5
$as_echo "$ax_cv_check_cflags___funsafe_math_optimizations" >&6; }
if test x"$ax_cv_check_cflags___funsafe_math_optimizations" = xyes; then :
  CFLAGS="$CFLAGS -funsafe-math-optimizations"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -fno-trapping-math" >&5
$as_echo_n "checking whether C compiler accepts -fno-trapping-math... " >&6; }
if ${ax_cv_check_cflags___fno_trapping_math+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -fno-trapping-math"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___fno_trapping_math=yes
else
  ax_cv_check_cflags___fno_trapping_math=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___fno_trapping_math" >&5
$as_echo "$ax_cv_check_cflags___fno_trapping_math" >&6; }
if test x"$ax_cv_check_cflags___fno_trapping_math" = xyes; then :
  CFLAGS="$CFLAGS -fno-trapping-math"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -fno-rounding-math" >&5
$as_echo_n "checking whether C compiler accepts -fno-rounding-math... " >&6; }
if ${ax_cv_check_cflags___fno_rounding_math+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -fno-rounding-math"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___fno_rounding_math=yes
else
  ax_cv_check_cflags___fno_rounding_math=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___fno_rounding_math" >&5
$as_echo "$ax_cv_check_cflags___fno_rounding_math" >&6; }
if test x"$ax_cv_check_cflags___fno_rounding_math" = xyes; then :
  CFLAGS="$CFLAGS -fno-rounding-math"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -fno-signaling-nans" >&5
$as_echo_n "checking whether C compiler accepts -fno-signaling-nans... " >&6; }
if ${ax_cv_check_cflags___fno_signaling_nans+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -fno-signaling-nans"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___fno_signaling_nans=yes
else
  ax_cv_check_cflags___fno_signaling_nans=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___fno_signaling_nans" >&5
$as_echo "$ax_cv_check_cflags___fno_signaling_nans" >&6; }
if test x"$ax_cv_check_cflags___fno_signaling_nans" = xyes; then :
  CFLAGS="$CFLAGS -fno-signaling-nans"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C compiler accepts -fcx-limited-range" >&5
$as_echo_n "checking whether C compiler accepts -fcx-limited-range... " >&6; }
if ${ax_cv_check_cflags___fcx_limited_range+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CFLAGS
  CFLAGS="$CFLAGS  -fcx-limited-range"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ax_cv_check_cflags___fcx_limited_range=yes
else
  ax_cv_check_cflags___fcx_limited_range=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cflags___fcx_limited_range" >&5
$as_echo "$ax_cv_check_cflags___fcx_limited_range" >&6; }
if test x"$ax_cv_check_cflags___fcx_limited_range" = xyes; then :
  CFLAGS="$CFLAGS -fcx-limited-range"
else
  :
fi


ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
if test -z "$CXX"; then
  if test -n "$CCC"; then
    CXX=$CCC
  else
    if test -n "$ac_tool_prefix"; then
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
  do
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$CXX"; then
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
CXX=$ac_cv_prog_CXX
if test -n "$CXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
$as_echo "$CXX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


    test -n "$CXX" && break
  done
fi
if test -z "$CXX"; then
  ac_ct_CXX=$CXX
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
do
  # Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -n "$ac_ct_CXX"; then
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_prog_ac_ct_CXX="$ac_prog"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

fi
fi
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
if test -n "$ac_ct_CXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
$as_echo "$ac_ct_CXX" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


  test -n "$ac_ct_CXX" && break
done

  if test "x$ac_ct_CXX" = x; then
    CXX="g++"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    CXX=$ac_ct_CXX
  fi
fi

  fi
fi
# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
  { { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
  *) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
  ac_status=$?
  if test -s conftest.err; then
    sed '10a\
... rest of stderr output deleted ...
         10q' conftest.err >conftest.er1
    cat conftest.er1 >&5
  fi
  rm -f conftest.er1 conftest.err
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
done

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
if ${ac_cv_cxx_compiler_gnu+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{
#ifndef __GNUC__
       choke me
#endif

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ac_compiler_gnu=yes
else
  ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
  GXX=yes
else
  GXX=
fi
ac_test_CXXFLAGS=${CXXFLAGS+set}
ac_save_CXXFLAGS=$CXXFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
if ${ac_cv_prog_cxx_g+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
   ac_cxx_werror_flag=yes
   ac_cv_prog_cxx_g=no
   CXXFLAGS="-g"
   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ac_cv_prog_cxx_g=yes
else
  CXXFLAGS=""
      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :

else
  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
	 CXXFLAGS="-g"
	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ac_cv_prog_cxx_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
$as_echo "$ac_cv_prog_cxx_g" >&6; }
if test "$ac_test_CXXFLAGS" = set; then
  CXXFLAGS=$ac_save_CXXFLAGS
elif test $ac_cv_prog_cxx_g = yes; then
  if test "$GXX" = yes; then
    CXXFLAGS="-g -O2"
  else
    CXXFLAGS="-g"
  fi
else
  if test "$GXX" = yes; then
    CXXFLAGS="-O2"
  else
    CXXFLAGS=
  fi
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

depcc="$CXX"  am_compiler_list=

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
$as_echo_n "checking dependency style of $depcc... " >&6; }
if ${am_cv_CXX_dependencies_compiler_type+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
  # We make a subdir and do the tests there.  Otherwise we can end up
  # making bogus files that we don't know about and never remove.  For
  # instance it was reported that on HP-UX the gcc test will end up
  # making a dummy file named 'D' -- because '-MD' means "put the output
  # in D".
  rm -rf conftest.dir
  mkdir conftest.dir
  # Copy depcomp to subdir because otherwise we won't find it if we're
  # using a relative directory.
  cp "$am_depcomp" conftest.dir
  cd conftest.dir
  # We will build objects and dependencies in a subdirectory because
  # it helps to detect inapplicable dependency modes.  For instance
  # both Tru64's cc and ICC support -MD to output dependencies as a
  # side effect of compilation, but ICC will put the dependencies in
  # the current directory while Tru64 will put them in the object
  # directory.
  mkdir sub

  am_cv_CXX_dependencies_compiler_type=none
  if test "$am_compiler_list" = ""; then
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
  fi
  am__universal=false
  case " $depcc " in #(
     *\ -arch\ *\ -arch\ *) am__universal=true ;;
     esac

  for depmode in $am_compiler_list; do
    # Setup a source with many dependencies, because some compilers
    # like to wrap large dependency lists on column 80 (with \), and
    # we should not choose a depcomp mode which is confused by this.
    #
    # We need to recreate these files for each test, as the compiler may
    # overwrite some of them when testing with obscure command lines.
    # This happens at least with the AIX C compiler.
    : > sub/conftest.c
    for i in 1 2 3 4 5 6; do
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
      # Solaris 10 /bin/sh.
      echo '/* dummy */' > sub/conftst$i.h
    done
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

    # We check with '-c' and '-o' for the sake of the "dashmstdout"
    # mode.  It turns out that the SunPro C++ compiler does not properly
    # handle '-M -o', and we need to detect this.  Also, some Intel
    # versions had trouble with output in subdirs.
    am__obj=sub/conftest.${OBJEXT-o}
    am__minus_obj="-o $am__obj"
    case $depmode in
    gcc)
      # This depmode causes a compiler race in universal mode.
      test "$am__universal" = false || continue
      ;;
    nosideeffect)
      # After this tag, mechanisms are not by side-effect, so they'll
      # only be used when explicitly requested.
      if test "x$enable_dependency_tracking" = xyes; then
	continue
      else
	break
      fi
      ;;
    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
      # This compiler won't grok '-c -o', but also, the minuso test has
      # not run yet.  These depmodes are late enough in the game, and
      # so weak that their functioning should not be impacted.
      am__obj=conftest.${OBJEXT-o}
      am__minus_obj=
      ;;
    none) break ;;
    esac
    if depmode=$depmode \
       source=sub/conftest.c object=$am__obj \
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
         >/dev/null 2>conftest.err &&
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
      # icc doesn't choke on unknown options, it will just issue warnings
      # or remarks (even with -Werror).  So we grep stderr for any message
      # that says an option was ignored or not supported.
      # When given -MP, icc 7.0 and 7.1 complain thusly:
      #   icc: Command line warning: ignoring option '-M'; no argument required
      # The diagnosis changed in icc 8.0:
      #   icc: Command line remark: option '-MP' not supported
      if (grep 'ignoring option' conftest.err ||
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
        am_cv_CXX_dependencies_compiler_type=$depmode
        break
      fi
    fi
  done

  cd ..
  rm -rf conftest.dir
else
  am_cv_CXX_dependencies_compiler_type=none
fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type

 if
  test "x$enable_dependency_tracking" != xno \
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
  am__fastdepCXX_TRUE=
  am__fastdepCXX_FALSE='#'
else
  am__fastdepCXX_TRUE='#'
  am__fastdepCXX_FALSE=
fi




func_stripname_cnf ()
{
  case ${2} in
  .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
  *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
  esac
} # func_stripname_cnf

      if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
    (test "X$CXX" != "Xg++"))) ; then
  ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
if test -z "$CXXCPP"; then
  if ${ac_cv_prog_CXXCPP+:} false; then :
  $as_echo_n "(cached) " >&6
else
      # Double quotes because CXXCPP needs to be expanded
    for CXXCPP in "$CXX -E" "/lib/cpp"
    do
      ac_preproc_ok=false
for ac_cxx_preproc_warn_flag in '' yes
do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # Prefer  to  if __STDC__ is defined, since
  #  exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef __STDC__
# include 
#else
# include 
#endif
		     Syntax error
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :

else
  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :
  # Broken: success on invalid input.
continue
else
  # Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
  break
fi

    done
    ac_cv_prog_CXXCPP=$CXXCPP

fi
  CXXCPP=$ac_cv_prog_CXXCPP
else
  ac_cv_prog_CXXCPP=$CXXCPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
$as_echo "$CXXCPP" >&6; }
ac_preproc_ok=false
for ac_cxx_preproc_warn_flag in '' yes
do
  # Use a header file that comes with gcc, so configuring glibc
  # with a fresh cross-compiler works.
  # Prefer  to  if __STDC__ is defined, since
  #  exists even on freestanding compilers.
  # On the NeXT, cc -E runs the code through the compiler's parser,
  # not just through cpp. "Syntax error" is here to catch this case.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#ifdef __STDC__
# include 
#else
# include 
#endif
		     Syntax error
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :

else
  # Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext

  # OK, works on sane cases.  Now check whether nonexistent headers
  # can be detected and how.
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include 
_ACEOF
if ac_fn_cxx_try_cpp "$LINENO"; then :
  # Broken: success on invalid input.
continue
else
  # Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext

done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :

else
  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
See \`config.log' for more details" "$LINENO" 5; }
fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu

else
  _lt_caught_CXX_error=yes
fi

ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu

archive_cmds_need_lc_CXX=no
allow_undefined_flag_CXX=
always_export_symbols_CXX=no
archive_expsym_cmds_CXX=
compiler_needs_object_CXX=no
export_dynamic_flag_spec_CXX=
hardcode_direct_CXX=no
hardcode_direct_absolute_CXX=no
hardcode_libdir_flag_spec_CXX=
hardcode_libdir_separator_CXX=
hardcode_minus_L_CXX=no
hardcode_shlibpath_var_CXX=unsupported
hardcode_automatic_CXX=no
inherit_rpath_CXX=no
module_cmds_CXX=
module_expsym_cmds_CXX=
link_all_deplibs_CXX=unknown
old_archive_cmds_CXX=$old_archive_cmds
reload_flag_CXX=$reload_flag
reload_cmds_CXX=$reload_cmds
no_undefined_flag_CXX=
whole_archive_flag_spec_CXX=
enable_shared_with_static_runtimes_CXX=no

# Source file extension for C++ test sources.
ac_ext=cpp

# Object file extension for compiled C++ test sources.
objext=o
objext_CXX=$objext

# No sense in running all these tests if we already determined that
# the CXX compiler isn't working.  Some variables (like enable_shared)
# are currently assumed to apply to all compilers on this platform,
# and will be corrupted by setting them based on a non-working compiler.
if test "$_lt_caught_CXX_error" != yes; then
  # Code to be used in simple compile tests
  lt_simple_compile_test_code="int some_variable = 0;"

  # Code to be used in simple link tests
  lt_simple_link_test_code='int main(int, char *[]) { return(0); }'

  # ltmain only uses $CC for tagged configurations so make sure $CC is set.






# If no C compiler was specified, use CC.
LTCC=${LTCC-"$CC"}

# If no C compiler flags were specified, use CFLAGS.
LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

# Allow CC to be a program name with arguments.
compiler=$CC


  # save warnings/boilerplate of simple test code
  ac_outfile=conftest.$ac_objext
echo "$lt_simple_compile_test_code" >conftest.$ac_ext
eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
_lt_compiler_boilerplate=`cat conftest.err`
$RM conftest*

  ac_outfile=conftest.$ac_objext
echo "$lt_simple_link_test_code" >conftest.$ac_ext
eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
_lt_linker_boilerplate=`cat conftest.err`
$RM -r conftest*


  # Allow CC to be a program name with arguments.
  lt_save_CC=$CC
  lt_save_CFLAGS=$CFLAGS
  lt_save_LD=$LD
  lt_save_GCC=$GCC
  GCC=$GXX
  lt_save_with_gnu_ld=$with_gnu_ld
  lt_save_path_LD=$lt_cv_path_LD
  if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
    lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
  else
    $as_unset lt_cv_prog_gnu_ld
  fi
  if test -n "${lt_cv_path_LDCXX+set}"; then
    lt_cv_path_LD=$lt_cv_path_LDCXX
  else
    $as_unset lt_cv_path_LD
  fi
  test -z "${LDCXX+set}" || LD=$LDCXX
  CC=${CXX-"c++"}
  CFLAGS=$CXXFLAGS
  compiler=$CC
  compiler_CXX=$CC
  for cc_temp in $compiler""; do
  case $cc_temp in
    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
    \-*) ;;
    *) break;;
  esac
done
cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`


  if test -n "$compiler"; then
    # We don't want -fno-exception when compiling C++ code, so set the
    # no_builtin_flag separately
    if test "$GXX" = yes; then
      lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin'
    else
      lt_prog_compiler_no_builtin_flag_CXX=
    fi

    if test "$GXX" = yes; then
      # Set up default GNU C++ configuration



# Check whether --with-gnu-ld was given.
if test "${with_gnu_ld+set}" = set; then :
  withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
else
  with_gnu_ld=no
fi

ac_prog=ld
if test "$GCC" = yes; then
  # Check if gcc -print-prog-name=ld gives a path.
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
$as_echo_n "checking for ld used by $CC... " >&6; }
  case $host in
  *-*-mingw*)
    # gcc leaves a trailing carriage return which upsets mingw
    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
  *)
    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
  esac
  case $ac_prog in
    # Accept absolute paths.
    [\\/]* | ?:[\\/]*)
      re_direlt='/[^/][^/]*/\.\./'
      # Canonicalize the pathname of ld
      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
      done
      test -z "$LD" && LD="$ac_prog"
      ;;
  "")
    # If it fails, then pretend we aren't using GCC.
    ac_prog=ld
    ;;
  *)
    # If it is relative, then search for the first ld in PATH.
    with_gnu_ld=unknown
    ;;
  esac
elif test "$with_gnu_ld" = yes; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
$as_echo_n "checking for GNU ld... " >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
$as_echo_n "checking for non-GNU ld... " >&6; }
fi
if ${lt_cv_path_LD+:} false; then :
  $as_echo_n "(cached) " >&6
else
  if test -z "$LD"; then
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
  for ac_dir in $PATH; do
    IFS="$lt_save_ifs"
    test -z "$ac_dir" && ac_dir=.
    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
      lt_cv_path_LD="$ac_dir/$ac_prog"
      # Check to see if the program is GNU ld.  I'd rather use --version,
      # but apparently some variants of GNU ld only accept -v.
      # Break only if it was the GNU/non-GNU ld that we prefer.
      case `"$lt_cv_path_LD" -v 2>&1 &5
$as_echo "$LD" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; }
if ${lt_cv_prog_gnu_ld+:} false; then :
  $as_echo_n "(cached) " >&6
else
  # I'd rather use --version here, but apparently some GNU lds only accept -v.
case `$LD -v 2>&1 &5
$as_echo "$lt_cv_prog_gnu_ld" >&6; }
with_gnu_ld=$lt_cv_prog_gnu_ld







      # Check if GNU C++ uses GNU ld as the underlying linker, since the
      # archiving commands below assume that GNU ld is being used.
      if test "$with_gnu_ld" = yes; then
        archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
        archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

        hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
        export_dynamic_flag_spec_CXX='${wl}--export-dynamic'

        # If archive_cmds runs LD, not CC, wlarc should be empty
        # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
        #     investigate it a little bit more. (MM)
        wlarc='${wl}'

        # ancient GNU ld didn't support --whole-archive et. al.
        if eval "`$CC -print-prog-name=ld` --help 2>&1" |
	  $GREP 'no-whole-archive' > /dev/null; then
          whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
        else
          whole_archive_flag_spec_CXX=
        fi
      else
        with_gnu_ld=no
        wlarc=

        # A generic and very simple default shared library creation
        # command for GNU C++ for the case where it uses the native
        # linker, instead of GNU ld.  If possible, this setting should
        # overridden to take advantage of the native linker features on
        # the platform it is being used on.
        archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
      fi

      # Commands to make compiler produce verbose output that lists
      # what "hidden" libraries, object files and flags are used when
      # linking a shared library.
      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'

    else
      GXX=no
      with_gnu_ld=no
      wlarc=
    fi

    # PORTME: fill in a description of your system's C++ link characteristics
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
    ld_shlibs_CXX=yes
    case $host_os in
      aix3*)
        # FIXME: insert proper C++ library support
        ld_shlibs_CXX=no
        ;;
      aix[4-9]*)
        if test "$host_cpu" = ia64; then
          # On IA64, the linker does run time linking by default, so we don't
          # have to do anything special.
          aix_use_runtimelinking=no
          exp_sym_flag='-Bexport'
          no_entry_flag=""
        else
          aix_use_runtimelinking=no

          # Test if we are trying to use run time linking or normal
          # AIX style linking. If -brtl is somewhere in LDFLAGS, we
          # need to do runtime linking.
          case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
	    for ld_flag in $LDFLAGS; do
	      case $ld_flag in
	      *-brtl*)
	        aix_use_runtimelinking=yes
	        break
	        ;;
	      esac
	    done
	    ;;
          esac

          exp_sym_flag='-bexport'
          no_entry_flag='-bnoentry'
        fi

        # When large executables or shared objects are built, AIX ld can
        # have problems creating the table of contents.  If linking a library
        # or program results in "error TOC overflow" add -mminimal-toc to
        # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
        # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

        archive_cmds_CXX=''
        hardcode_direct_CXX=yes
        hardcode_direct_absolute_CXX=yes
        hardcode_libdir_separator_CXX=':'
        link_all_deplibs_CXX=yes
        file_list_spec_CXX='${wl}-f,'

        if test "$GXX" = yes; then
          case $host_os in aix4.[012]|aix4.[012].*)
          # We only want to do this on AIX 4.2 and lower, the check
          # below for broken collect2 doesn't work under 4.3+
	  collect2name=`${CC} -print-prog-name=collect2`
	  if test -f "$collect2name" &&
	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
	  then
	    # We have reworked collect2
	    :
	  else
	    # We have old collect2
	    hardcode_direct_CXX=unsupported
	    # It fails to find uninstalled libraries when the uninstalled
	    # path is not listed in the libpath.  Setting hardcode_minus_L
	    # to unsupported forces relinking
	    hardcode_minus_L_CXX=yes
	    hardcode_libdir_flag_spec_CXX='-L$libdir'
	    hardcode_libdir_separator_CXX=
	  fi
          esac
          shared_flag='-shared'
	  if test "$aix_use_runtimelinking" = yes; then
	    shared_flag="$shared_flag "'${wl}-G'
	  fi
        else
          # not using gcc
          if test "$host_cpu" = ia64; then
	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
	  # chokes on -Wl,-G. The following line is correct:
	  shared_flag='-G'
          else
	    if test "$aix_use_runtimelinking" = yes; then
	      shared_flag='${wl}-G'
	    else
	      shared_flag='${wl}-bM:SRE'
	    fi
          fi
        fi

        export_dynamic_flag_spec_CXX='${wl}-bexpall'
        # It seems that -bexpall does not export symbols beginning with
        # underscore (_), so it is better to generate a list of symbols to
	# export.
        always_export_symbols_CXX=yes
        if test "$aix_use_runtimelinking" = yes; then
          # Warning - without using the other runtime loading flags (-brtl),
          # -berok will link without error, but may produce a broken library.
          allow_undefined_flag_CXX='-berok'
          # Determine the default libpath from the value encoded in an empty
          # executable.
          if test "${lt_cv_aix_libpath+set}" = set; then
  aix_libpath=$lt_cv_aix_libpath
else
  if ${lt_cv_aix_libpath__CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :

  lt_aix_libpath_sed='
      /Import File Strings/,/^$/ {
	  /^0/ {
	      s/^0  *\([^ ]*\) *$/\1/
	      p
	  }
      }'
  lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  # Check for a 64-bit object if we didn't find anything.
  if test -z "$lt_cv_aix_libpath__CXX"; then
    lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  fi
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
  if test -z "$lt_cv_aix_libpath__CXX"; then
    lt_cv_aix_libpath__CXX="/usr/lib:/lib"
  fi

fi

  aix_libpath=$lt_cv_aix_libpath__CXX
fi

          hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"

          archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
        else
          if test "$host_cpu" = ia64; then
	    hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib'
	    allow_undefined_flag_CXX="-z nodefs"
	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
          else
	    # Determine the default libpath from the value encoded in an
	    # empty executable.
	    if test "${lt_cv_aix_libpath+set}" = set; then
  aix_libpath=$lt_cv_aix_libpath
else
  if ${lt_cv_aix_libpath__CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :

  lt_aix_libpath_sed='
      /Import File Strings/,/^$/ {
	  /^0/ {
	      s/^0  *\([^ ]*\) *$/\1/
	      p
	  }
      }'
  lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  # Check for a 64-bit object if we didn't find anything.
  if test -z "$lt_cv_aix_libpath__CXX"; then
    lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
  fi
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
  if test -z "$lt_cv_aix_libpath__CXX"; then
    lt_cv_aix_libpath__CXX="/usr/lib:/lib"
  fi

fi

  aix_libpath=$lt_cv_aix_libpath__CXX
fi

	    hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"
	    # Warning - without using the other run time loading flags,
	    # -berok will link without error, but may produce a broken library.
	    no_undefined_flag_CXX=' ${wl}-bernotok'
	    allow_undefined_flag_CXX=' ${wl}-berok'
	    if test "$with_gnu_ld" = yes; then
	      # We only use this code for GNU lds that support --whole-archive.
	      whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
	    else
	      # Exported symbols can be pulled into shared objects from archives
	      whole_archive_flag_spec_CXX='$convenience'
	    fi
	    archive_cmds_need_lc_CXX=yes
	    # This is similar to how AIX traditionally builds its shared
	    # libraries.
	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
          fi
        fi
        ;;

      beos*)
	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
	  allow_undefined_flag_CXX=unsupported
	  # Joseph Beckenbach  says some releases of gcc
	  # support --undefined.  This deserves some investigation.  FIXME
	  archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	else
	  ld_shlibs_CXX=no
	fi
	;;

      chorus*)
        case $cc_basename in
          *)
	  # FIXME: insert proper C++ library support
	  ld_shlibs_CXX=no
	  ;;
        esac
        ;;

      cygwin* | mingw* | pw32* | cegcc*)
	case $GXX,$cc_basename in
	,cl* | no,cl*)
	  # Native MSVC
	  # hardcode_libdir_flag_spec is actually meaningless, as there is
	  # no search path for DLLs.
	  hardcode_libdir_flag_spec_CXX=' '
	  allow_undefined_flag_CXX=unsupported
	  always_export_symbols_CXX=yes
	  file_list_spec_CXX='@'
	  # Tell ltmain to make .lib files, not .a files.
	  libext=lib
	  # Tell ltmain to make .dll files, not .so files.
	  shrext_cmds=".dll"
	  # FIXME: Setting linknames here is a bad hack.
	  archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
	  archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
	      $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
	    else
	      $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
	    fi~
	    $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
	    linknames='
	  # The linker will not automatically build a static lib if we build a DLL.
	  # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true'
	  enable_shared_with_static_runtimes_CXX=yes
	  # Don't use ranlib
	  old_postinstall_cmds_CXX='chmod 644 $oldlib'
	  postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~
	    lt_tool_outputfile="@TOOL_OUTPUT@"~
	    case $lt_outputfile in
	      *.exe|*.EXE) ;;
	      *)
		lt_outputfile="$lt_outputfile.exe"
		lt_tool_outputfile="$lt_tool_outputfile.exe"
		;;
	    esac~
	    func_to_tool_file "$lt_outputfile"~
	    if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
	      $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
	      $RM "$lt_outputfile.manifest";
	    fi'
	  ;;
	*)
	  # g++
	  # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless,
	  # as there is no search path for DLLs.
	  hardcode_libdir_flag_spec_CXX='-L$libdir'
	  export_dynamic_flag_spec_CXX='${wl}--export-all-symbols'
	  allow_undefined_flag_CXX=unsupported
	  always_export_symbols_CXX=no
	  enable_shared_with_static_runtimes_CXX=yes

	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
	    # If the export-symbols file already is a .def file (1st line
	    # is EXPORTS), use it as is; otherwise, prepend...
	    archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
	      cp $export_symbols $output_objdir/$soname.def;
	    else
	      echo EXPORTS > $output_objdir/$soname.def;
	      cat $export_symbols >> $output_objdir/$soname.def;
	    fi~
	    $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
	  else
	    ld_shlibs_CXX=no
	  fi
	  ;;
	esac
	;;
      darwin* | rhapsody*)


  archive_cmds_need_lc_CXX=no
  hardcode_direct_CXX=no
  hardcode_automatic_CXX=yes
  hardcode_shlibpath_var_CXX=unsupported
  if test "$lt_cv_ld_force_load" = "yes"; then
    whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'

  else
    whole_archive_flag_spec_CXX=''
  fi
  link_all_deplibs_CXX=yes
  allow_undefined_flag_CXX="$_lt_dar_allow_undefined"
  case $cc_basename in
     ifort*) _lt_dar_can_shared=yes ;;
     *) _lt_dar_can_shared=$GCC ;;
  esac
  if test "$_lt_dar_can_shared" = "yes"; then
    output_verbose_link_cmd=func_echo_all
    archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
    module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
    archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
    module_expsym_cmds_CXX="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
       if test "$lt_cv_apple_cc_single_mod" != "yes"; then
      archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
      archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
    fi

  else
  ld_shlibs_CXX=no
  fi

	;;

      dgux*)
        case $cc_basename in
          ec++*)
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
          ghcx*)
	    # Green Hills C++ Compiler
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
          *)
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
        esac
        ;;

      freebsd2.*)
        # C++ shared libraries reported to be fairly broken before
	# switch to ELF
        ld_shlibs_CXX=no
        ;;

      freebsd-elf*)
        archive_cmds_need_lc_CXX=no
        ;;

      freebsd* | dragonfly*)
        # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
        # conventions
        ld_shlibs_CXX=yes
        ;;

      gnu*)
        ;;

      haiku*)
        archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
        link_all_deplibs_CXX=yes
        ;;

      hpux9*)
        hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'
        hardcode_libdir_separator_CXX=:
        export_dynamic_flag_spec_CXX='${wl}-E'
        hardcode_direct_CXX=yes
        hardcode_minus_L_CXX=yes # Not in the search PATH,
				             # but as the default
				             # location of the library.

        case $cc_basename in
          CC*)
            # FIXME: insert proper C++ library support
            ld_shlibs_CXX=no
            ;;
          aCC*)
            archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
            # Commands to make compiler produce verbose output that lists
            # what "hidden" libraries, object files and flags are used when
            # linking a shared library.
            #
            # There doesn't appear to be a way to prevent this compiler from
            # explicitly linking system object files so we need to strip them
            # from the output so that they don't get included in the library
            # dependencies.
            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
            ;;
          *)
            if test "$GXX" = yes; then
              archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
            else
              # FIXME: insert proper C++ library support
              ld_shlibs_CXX=no
            fi
            ;;
        esac
        ;;

      hpux10*|hpux11*)
        if test $with_gnu_ld = no; then
	  hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'
	  hardcode_libdir_separator_CXX=:

          case $host_cpu in
            hppa*64*|ia64*)
              ;;
            *)
	      export_dynamic_flag_spec_CXX='${wl}-E'
              ;;
          esac
        fi
        case $host_cpu in
          hppa*64*|ia64*)
            hardcode_direct_CXX=no
            hardcode_shlibpath_var_CXX=no
            ;;
          *)
            hardcode_direct_CXX=yes
            hardcode_direct_absolute_CXX=yes
            hardcode_minus_L_CXX=yes # Not in the search PATH,
					         # but as the default
					         # location of the library.
            ;;
        esac

        case $cc_basename in
          CC*)
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
          aCC*)
	    case $host_cpu in
	      hppa*64*)
	        archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	        ;;
	      ia64*)
	        archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	        ;;
	      *)
	        archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	        ;;
	    esac
	    # Commands to make compiler produce verbose output that lists
	    # what "hidden" libraries, object files and flags are used when
	    # linking a shared library.
	    #
	    # There doesn't appear to be a way to prevent this compiler from
	    # explicitly linking system object files so we need to strip them
	    # from the output so that they don't get included in the library
	    # dependencies.
	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
	    ;;
          *)
	    if test "$GXX" = yes; then
	      if test $with_gnu_ld = no; then
	        case $host_cpu in
	          hppa*64*)
	            archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	            ;;
	          ia64*)
	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	            ;;
	          *)
	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	            ;;
	        esac
	      fi
	    else
	      # FIXME: insert proper C++ library support
	      ld_shlibs_CXX=no
	    fi
	    ;;
        esac
        ;;

      interix[3-9]*)
	hardcode_direct_CXX=no
	hardcode_shlibpath_var_CXX=no
	hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
	export_dynamic_flag_spec_CXX='${wl}-E'
	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
	# Instead, shared libraries are loaded at an image base (0x10000000 by
	# default) and relocated if they conflict, which is a slow very memory
	# consuming and fragmenting process.  To avoid this, we pick a random,
	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
	archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
	archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
	;;
      irix5* | irix6*)
        case $cc_basename in
          CC*)
	    # SGI C++
	    archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'

	    # Archives containing C++ object files must be created using
	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
	    # necessary to make sure instantiated templates are included
	    # in the archive.
	    old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs'
	    ;;
          *)
	    if test "$GXX" = yes; then
	      if test "$with_gnu_ld" = no; then
	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
	      else
	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib'
	      fi
	    fi
	    link_all_deplibs_CXX=yes
	    ;;
        esac
        hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
        hardcode_libdir_separator_CXX=:
        inherit_rpath_CXX=yes
        ;;

      linux* | k*bsd*-gnu | kopensolaris*-gnu)
        case $cc_basename in
          KCC*)
	    # Kuck and Associates, Inc. (KAI) C++ Compiler

	    # KCC will only create a shared library if the output file
	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
	    # to its proper name (with version) after linking.
	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
	    archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
	    # Commands to make compiler produce verbose output that lists
	    # what "hidden" libraries, object files and flags are used when
	    # linking a shared library.
	    #
	    # There doesn't appear to be a way to prevent this compiler from
	    # explicitly linking system object files so we need to strip them
	    # from the output so that they don't get included in the library
	    # dependencies.
	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'

	    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
	    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'

	    # Archives containing C++ object files must be created using
	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
	    old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'
	    ;;
	  icpc* | ecpc* )
	    # Intel C++
	    with_gnu_ld=yes
	    # version 8.0 and above of icpc choke on multiply defined symbols
	    # if we add $predep_objects and $postdep_objects, however 7.1 and
	    # earlier do not add the objects themselves.
	    case `$CC -V 2>&1` in
	      *"Version 7."*)
	        archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
		archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
		;;
	      *)  # Version 8.0 or newer
	        tmp_idyn=
	        case $host_cpu in
		  ia64*) tmp_idyn=' -i_dynamic';;
		esac
	        archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
		archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
		;;
	    esac
	    archive_cmds_need_lc_CXX=no
	    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
	    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
	    whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
	    ;;
          pgCC* | pgcpp*)
            # Portland Group C++ compiler
	    case `$CC -V` in
	    *pgCC\ [1-5].* | *pgcpp\ [1-5].*)
	      prelink_cmds_CXX='tpldir=Template.dir~
		rm -rf $tpldir~
		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
	      old_archive_cmds_CXX='tpldir=Template.dir~
		rm -rf $tpldir~
		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
		$RANLIB $oldlib'
	      archive_cmds_CXX='tpldir=Template.dir~
		rm -rf $tpldir~
		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
	      archive_expsym_cmds_CXX='tpldir=Template.dir~
		rm -rf $tpldir~
		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
	      ;;
	    *) # Version 6 and above use weak symbols
	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
	      archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
	      ;;
	    esac

	    hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir'
	    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
	    whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
            ;;
	  cxx*)
	    # Compaq C++
	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
	    archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'

	    runpath_var=LD_RUN_PATH
	    hardcode_libdir_flag_spec_CXX='-rpath $libdir'
	    hardcode_libdir_separator_CXX=:

	    # Commands to make compiler produce verbose output that lists
	    # what "hidden" libraries, object files and flags are used when
	    # linking a shared library.
	    #
	    # There doesn't appear to be a way to prevent this compiler from
	    # explicitly linking system object files so we need to strip them
	    # from the output so that they don't get included in the library
	    # dependencies.
	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
	    ;;
	  xl* | mpixl* | bgxl*)
	    # IBM XL 8.0 on PPC, with GNU ld
	    hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
	    export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
	    archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
	    if test "x$supports_anon_versioning" = xyes; then
	      archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~
		cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
		echo "local: *; };" >> $output_objdir/$libname.ver~
		$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
	    fi
	    ;;
	  *)
	    case `$CC -V 2>&1 | sed 5q` in
	    *Sun\ C*)
	      # Sun C++ 5.9
	      no_undefined_flag_CXX=' -zdefs'
	      archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	      archive_expsym_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'
	      hardcode_libdir_flag_spec_CXX='-R$libdir'
	      whole_archive_flag_spec_CXX='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
	      compiler_needs_object_CXX=yes

	      # Not sure whether something based on
	      # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
	      # would be better.
	      output_verbose_link_cmd='func_echo_all'

	      # Archives containing C++ object files must be created using
	      # "CC -xar", where "CC" is the Sun C++ compiler.  This is
	      # necessary to make sure instantiated templates are included
	      # in the archive.
	      old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
	      ;;
	    esac
	    ;;
	esac
	;;

      lynxos*)
        # FIXME: insert proper C++ library support
	ld_shlibs_CXX=no
	;;

      m88k*)
        # FIXME: insert proper C++ library support
        ld_shlibs_CXX=no
	;;

      mvs*)
        case $cc_basename in
          cxx*)
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
	  *)
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
	esac
	;;

      netbsd*)
        if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
	  archive_cmds_CXX='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
	  wlarc=
	  hardcode_libdir_flag_spec_CXX='-R$libdir'
	  hardcode_direct_CXX=yes
	  hardcode_shlibpath_var_CXX=no
	fi
	# Workaround some broken pre-1.5 toolchains
	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
	;;

      *nto* | *qnx*)
        ld_shlibs_CXX=yes
	;;

      openbsd2*)
        # C++ shared libraries are fairly broken
	ld_shlibs_CXX=no
	;;

      openbsd*)
	if test -f /usr/libexec/ld.so; then
	  hardcode_direct_CXX=yes
	  hardcode_shlibpath_var_CXX=no
	  hardcode_direct_absolute_CXX=yes
	  archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
	  hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
	    archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
	    export_dynamic_flag_spec_CXX='${wl}-E'
	    whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
	  fi
	  output_verbose_link_cmd=func_echo_all
	else
	  ld_shlibs_CXX=no
	fi
	;;

      osf3* | osf4* | osf5*)
        case $cc_basename in
          KCC*)
	    # Kuck and Associates, Inc. (KAI) C++ Compiler

	    # KCC will only create a shared library if the output file
	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
	    # to its proper name (with version) after linking.
	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'

	    hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
	    hardcode_libdir_separator_CXX=:

	    # Archives containing C++ object files must be created using
	    # the KAI C++ compiler.
	    case $host in
	      osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;;
	      *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;;
	    esac
	    ;;
          RCC*)
	    # Rational C++ 2.4.1
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
          cxx*)
	    case $host in
	      osf3*)
	        allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
	        archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
	        hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
		;;
	      *)
	        allow_undefined_flag_CXX=' -expect_unresolved \*'
	        archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
	        archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
	          echo "-hidden">> $lib.exp~
	          $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~
	          $RM $lib.exp'
	        hardcode_libdir_flag_spec_CXX='-rpath $libdir'
		;;
	    esac

	    hardcode_libdir_separator_CXX=:

	    # Commands to make compiler produce verbose output that lists
	    # what "hidden" libraries, object files and flags are used when
	    # linking a shared library.
	    #
	    # There doesn't appear to be a way to prevent this compiler from
	    # explicitly linking system object files so we need to strip them
	    # from the output so that they don't get included in the library
	    # dependencies.
	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
	    ;;
	  *)
	    if test "$GXX" = yes && test "$with_gnu_ld" = no; then
	      allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
	      case $host in
	        osf3*)
	          archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
		  ;;
	        *)
	          archive_cmds_CXX='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
		  ;;
	      esac

	      hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
	      hardcode_libdir_separator_CXX=:

	      # Commands to make compiler produce verbose output that lists
	      # what "hidden" libraries, object files and flags are used when
	      # linking a shared library.
	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'

	    else
	      # FIXME: insert proper C++ library support
	      ld_shlibs_CXX=no
	    fi
	    ;;
        esac
        ;;

      psos*)
        # FIXME: insert proper C++ library support
        ld_shlibs_CXX=no
        ;;

      sunos4*)
        case $cc_basename in
          CC*)
	    # Sun C++ 4.x
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
          lcc*)
	    # Lucid
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
          *)
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
        esac
        ;;

      solaris*)
        case $cc_basename in
          CC* | sunCC*)
	    # Sun C++ 4.2, 5.x and Centerline C++
            archive_cmds_need_lc_CXX=yes
	    no_undefined_flag_CXX=' -zdefs'
	    archive_cmds_CXX='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
	    archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
	      $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'

	    hardcode_libdir_flag_spec_CXX='-R$libdir'
	    hardcode_shlibpath_var_CXX=no
	    case $host_os in
	      solaris2.[0-5] | solaris2.[0-5].*) ;;
	      *)
		# The compiler driver will combine and reorder linker options,
		# but understands `-z linker_flag'.
	        # Supported since Solaris 2.6 (maybe 2.5.1?)
		whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract'
	        ;;
	    esac
	    link_all_deplibs_CXX=yes

	    output_verbose_link_cmd='func_echo_all'

	    # Archives containing C++ object files must be created using
	    # "CC -xar", where "CC" is the Sun C++ compiler.  This is
	    # necessary to make sure instantiated templates are included
	    # in the archive.
	    old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
	    ;;
          gcx*)
	    # Green Hills C++ Compiler
	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'

	    # The C++ compiler must be used to create the archive.
	    old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
	    ;;
          *)
	    # GNU C++ compiler with Solaris linker
	    if test "$GXX" = yes && test "$with_gnu_ld" = no; then
	      no_undefined_flag_CXX=' ${wl}-z ${wl}defs'
	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
		  $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'

	        # Commands to make compiler produce verbose output that lists
	        # what "hidden" libraries, object files and flags are used when
	        # linking a shared library.
	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
	      else
	        # g++ 2.7 appears to require `-G' NOT `-shared' on this
	        # platform.
	        archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
		  $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'

	        # Commands to make compiler produce verbose output that lists
	        # what "hidden" libraries, object files and flags are used when
	        # linking a shared library.
	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
	      fi

	      hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir'
	      case $host_os in
		solaris2.[0-5] | solaris2.[0-5].*) ;;
		*)
		  whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
		  ;;
	      esac
	    fi
	    ;;
        esac
        ;;

    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
      no_undefined_flag_CXX='${wl}-z,text'
      archive_cmds_need_lc_CXX=no
      hardcode_shlibpath_var_CXX=no
      runpath_var='LD_RUN_PATH'

      case $cc_basename in
        CC*)
	  archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	  archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
	*)
	  archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	  archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	  ;;
      esac
      ;;

      sysv5* | sco3.2v5* | sco5v6*)
	# Note: We can NOT use -z defs as we might desire, because we do not
	# link with -lc, and that would cause any symbols used from libc to
	# always be unresolved, which means just about no library would
	# ever link correctly.  If we're not using GNU ld we use -z text
	# though, which does catch some bad symbols but isn't as heavy-handed
	# as -z defs.
	no_undefined_flag_CXX='${wl}-z,text'
	allow_undefined_flag_CXX='${wl}-z,nodefs'
	archive_cmds_need_lc_CXX=no
	hardcode_shlibpath_var_CXX=no
	hardcode_libdir_flag_spec_CXX='${wl}-R,$libdir'
	hardcode_libdir_separator_CXX=':'
	link_all_deplibs_CXX=yes
	export_dynamic_flag_spec_CXX='${wl}-Bexport'
	runpath_var='LD_RUN_PATH'

	case $cc_basename in
          CC*)
	    archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	    archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	    old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~
	      '"$old_archive_cmds_CXX"
	    reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~
	      '"$reload_cmds_CXX"
	    ;;
	  *)
	    archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	    archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
	    ;;
	esac
      ;;

      tandem*)
        case $cc_basename in
          NCC*)
	    # NonStop-UX NCC 3.20
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
          *)
	    # FIXME: insert proper C++ library support
	    ld_shlibs_CXX=no
	    ;;
        esac
        ;;

      vxworks*)
        # FIXME: insert proper C++ library support
        ld_shlibs_CXX=no
        ;;

      *)
        # FIXME: insert proper C++ library support
        ld_shlibs_CXX=no
        ;;
    esac

    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
$as_echo "$ld_shlibs_CXX" >&6; }
    test "$ld_shlibs_CXX" = no && can_build_shared=no

    GCC_CXX="$GXX"
    LD_CXX="$LD"

    ## CAVEAT EMPTOR:
    ## There is no encapsulation within the following macros, do not change
    ## the running order or otherwise move them around unless you know exactly
    ## what you are doing...
    # Dependencies to place before and after the object being linked:
predep_objects_CXX=
postdep_objects_CXX=
predeps_CXX=
postdeps_CXX=
compiler_lib_search_path_CXX=

cat > conftest.$ac_ext <<_LT_EOF
class Foo
{
public:
  Foo (void) { a = 0; }
private:
  int a;
};
_LT_EOF


_lt_libdeps_save_CFLAGS=$CFLAGS
case "$CC $CFLAGS " in #(
*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
esac

if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  (eval $ac_compile) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
  # Parse the compiler output and extract the necessary
  # objects, libraries and library flags.

  # Sentinel used to keep track of whether or not we are before
  # the conftest object file.
  pre_test_object_deps_done=no

  for p in `eval "$output_verbose_link_cmd"`; do
    case ${prev}${p} in

    -L* | -R* | -l*)
       # Some compilers place space between "-{L,R}" and the path.
       # Remove the space.
       if test $p = "-L" ||
          test $p = "-R"; then
	 prev=$p
	 continue
       fi

       # Expand the sysroot to ease extracting the directories later.
       if test -z "$prev"; then
         case $p in
         -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
         -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
         -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
         esac
       fi
       case $p in
       =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
       esac
       if test "$pre_test_object_deps_done" = no; then
	 case ${prev} in
	 -L | -R)
	   # Internal compiler library paths should come after those
	   # provided the user.  The postdeps already come after the
	   # user supplied libs so there is no need to process them.
	   if test -z "$compiler_lib_search_path_CXX"; then
	     compiler_lib_search_path_CXX="${prev}${p}"
	   else
	     compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}"
	   fi
	   ;;
	 # The "-l" case would never come before the object being
	 # linked, so don't bother handling this case.
	 esac
       else
	 if test -z "$postdeps_CXX"; then
	   postdeps_CXX="${prev}${p}"
	 else
	   postdeps_CXX="${postdeps_CXX} ${prev}${p}"
	 fi
       fi
       prev=
       ;;

    *.lto.$objext) ;; # Ignore GCC LTO objects
    *.$objext)
       # This assumes that the test object file only shows up
       # once in the compiler output.
       if test "$p" = "conftest.$objext"; then
	 pre_test_object_deps_done=yes
	 continue
       fi

       if test "$pre_test_object_deps_done" = no; then
	 if test -z "$predep_objects_CXX"; then
	   predep_objects_CXX="$p"
	 else
	   predep_objects_CXX="$predep_objects_CXX $p"
	 fi
       else
	 if test -z "$postdep_objects_CXX"; then
	   postdep_objects_CXX="$p"
	 else
	   postdep_objects_CXX="$postdep_objects_CXX $p"
	 fi
       fi
       ;;

    *) ;; # Ignore the rest.

    esac
  done

  # Clean up.
  rm -f a.out a.exe
else
  echo "libtool.m4: error: problem compiling CXX test program"
fi

$RM -f confest.$objext
CFLAGS=$_lt_libdeps_save_CFLAGS

# PORTME: override above test on systems where it is broken
case $host_os in
interix[3-9]*)
  # Interix 3.5 installs completely hosed .la files for C++, so rather than
  # hack all around it, let's just trust "g++" to DTRT.
  predep_objects_CXX=
  postdep_objects_CXX=
  postdeps_CXX=
  ;;

linux*)
  case `$CC -V 2>&1 | sed 5q` in
  *Sun\ C*)
    # Sun C++ 5.9

    # The more standards-conforming stlport4 library is
    # incompatible with the Cstd library. Avoid specifying
    # it if it's in CXXFLAGS. Ignore libCrun as
    # -library=stlport4 depends on it.
    case " $CXX $CXXFLAGS " in
    *" -library=stlport4 "*)
      solaris_use_stlport4=yes
      ;;
    esac

    if test "$solaris_use_stlport4" != yes; then
      postdeps_CXX='-library=Cstd -library=Crun'
    fi
    ;;
  esac
  ;;

solaris*)
  case $cc_basename in
  CC* | sunCC*)
    # The more standards-conforming stlport4 library is
    # incompatible with the Cstd library. Avoid specifying
    # it if it's in CXXFLAGS. Ignore libCrun as
    # -library=stlport4 depends on it.
    case " $CXX $CXXFLAGS " in
    *" -library=stlport4 "*)
      solaris_use_stlport4=yes
      ;;
    esac

    # Adding this requires a known-good setup of shared libraries for
    # Sun compiler versions before 5.6, else PIC objects from an old
    # archive will be linked into the output, leading to subtle bugs.
    if test "$solaris_use_stlport4" != yes; then
      postdeps_CXX='-library=Cstd -library=Crun'
    fi
    ;;
  esac
  ;;
esac


case " $postdeps_CXX " in
*" -lc "*) archive_cmds_need_lc_CXX=no ;;
esac
 compiler_lib_search_dirs_CXX=
if test -n "${compiler_lib_search_path_CXX}"; then
 compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | ${SED} -e 's! -L! !g' -e 's!^ !!'`
fi































    lt_prog_compiler_wl_CXX=
lt_prog_compiler_pic_CXX=
lt_prog_compiler_static_CXX=


  # C++ specific cases for pic, static, wl, etc.
  if test "$GXX" = yes; then
    lt_prog_compiler_wl_CXX='-Wl,'
    lt_prog_compiler_static_CXX='-static'

    case $host_os in
    aix*)
      # All AIX code is PIC.
      if test "$host_cpu" = ia64; then
	# AIX 5 now supports IA64 processor
	lt_prog_compiler_static_CXX='-Bstatic'
      fi
      ;;

    amigaos*)
      case $host_cpu in
      powerpc)
            # see comment about AmigaOS4 .so support
            lt_prog_compiler_pic_CXX='-fPIC'
        ;;
      m68k)
            # FIXME: we need at least 68020 code to build shared libraries, but
            # adding the `-m68020' flag to GCC prevents building anything better,
            # like `-m68040'.
            lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4'
        ;;
      esac
      ;;

    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
      # PIC is the default for these OSes.
      ;;
    mingw* | cygwin* | os2* | pw32* | cegcc*)
      # This hack is so that the source file can tell whether it is being
      # built for inclusion in a dll (and should export symbols for example).
      # Although the cygwin gcc ignores -fPIC, still need this for old-style
      # (--disable-auto-import) libraries
      lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
      ;;
    darwin* | rhapsody*)
      # PIC is the default on this platform
      # Common symbols not allowed in MH_DYLIB files
      lt_prog_compiler_pic_CXX='-fno-common'
      ;;
    *djgpp*)
      # DJGPP does not support shared libraries at all
      lt_prog_compiler_pic_CXX=
      ;;
    haiku*)
      # PIC is the default for Haiku.
      # The "-static" flag exists, but is broken.
      lt_prog_compiler_static_CXX=
      ;;
    interix[3-9]*)
      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
      # Instead, we relocate shared libraries at runtime.
      ;;
    sysv4*MP*)
      if test -d /usr/nec; then
	lt_prog_compiler_pic_CXX=-Kconform_pic
      fi
      ;;
    hpux*)
      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
      # sets the default TLS model and affects inlining.
      case $host_cpu in
      hppa*64*)
	;;
      *)
	lt_prog_compiler_pic_CXX='-fPIC'
	;;
      esac
      ;;
    *qnx* | *nto*)
      # QNX uses GNU C++, but need to define -shared option too, otherwise
      # it will coredump.
      lt_prog_compiler_pic_CXX='-fPIC -shared'
      ;;
    *)
      lt_prog_compiler_pic_CXX='-fPIC'
      ;;
    esac
  else
    case $host_os in
      aix[4-9]*)
	# All AIX code is PIC.
	if test "$host_cpu" = ia64; then
	  # AIX 5 now supports IA64 processor
	  lt_prog_compiler_static_CXX='-Bstatic'
	else
	  lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp'
	fi
	;;
      chorus*)
	case $cc_basename in
	cxch68*)
	  # Green Hills C++ Compiler
	  # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
	  ;;
	esac
	;;
      mingw* | cygwin* | os2* | pw32* | cegcc*)
	# This hack is so that the source file can tell whether it is being
	# built for inclusion in a dll (and should export symbols for example).
	lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
	;;
      dgux*)
	case $cc_basename in
	  ec++*)
	    lt_prog_compiler_pic_CXX='-KPIC'
	    ;;
	  ghcx*)
	    # Green Hills C++ Compiler
	    lt_prog_compiler_pic_CXX='-pic'
	    ;;
	  *)
	    ;;
	esac
	;;
      freebsd* | dragonfly*)
	# FreeBSD uses GNU C++
	;;
      hpux9* | hpux10* | hpux11*)
	case $cc_basename in
	  CC*)
	    lt_prog_compiler_wl_CXX='-Wl,'
	    lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'
	    if test "$host_cpu" != ia64; then
	      lt_prog_compiler_pic_CXX='+Z'
	    fi
	    ;;
	  aCC*)
	    lt_prog_compiler_wl_CXX='-Wl,'
	    lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'
	    case $host_cpu in
	    hppa*64*|ia64*)
	      # +Z the default
	      ;;
	    *)
	      lt_prog_compiler_pic_CXX='+Z'
	      ;;
	    esac
	    ;;
	  *)
	    ;;
	esac
	;;
      interix*)
	# This is c89, which is MS Visual C++ (no shared libs)
	# Anyone wants to do a port?
	;;
      irix5* | irix6* | nonstopux*)
	case $cc_basename in
	  CC*)
	    lt_prog_compiler_wl_CXX='-Wl,'
	    lt_prog_compiler_static_CXX='-non_shared'
	    # CC pic flag -KPIC is the default.
	    ;;
	  *)
	    ;;
	esac
	;;
      linux* | k*bsd*-gnu | kopensolaris*-gnu)
	case $cc_basename in
	  KCC*)
	    # KAI C++ Compiler
	    lt_prog_compiler_wl_CXX='--backend -Wl,'
	    lt_prog_compiler_pic_CXX='-fPIC'
	    ;;
	  ecpc* )
	    # old Intel C++ for x86_64 which still supported -KPIC.
	    lt_prog_compiler_wl_CXX='-Wl,'
	    lt_prog_compiler_pic_CXX='-KPIC'
	    lt_prog_compiler_static_CXX='-static'
	    ;;
	  icpc* )
	    # Intel C++, used to be incompatible with GCC.
	    # ICC 10 doesn't accept -KPIC any more.
	    lt_prog_compiler_wl_CXX='-Wl,'
	    lt_prog_compiler_pic_CXX='-fPIC'
	    lt_prog_compiler_static_CXX='-static'
	    ;;
	  pgCC* | pgcpp*)
	    # Portland Group C++ compiler
	    lt_prog_compiler_wl_CXX='-Wl,'
	    lt_prog_compiler_pic_CXX='-fpic'
	    lt_prog_compiler_static_CXX='-Bstatic'
	    ;;
	  cxx*)
	    # Compaq C++
	    # Make sure the PIC flag is empty.  It appears that all Alpha
	    # Linux and Compaq Tru64 Unix objects are PIC.
	    lt_prog_compiler_pic_CXX=
	    lt_prog_compiler_static_CXX='-non_shared'
	    ;;
	  xlc* | xlC* | bgxl[cC]* | mpixl[cC]*)
	    # IBM XL 8.0, 9.0 on PPC and BlueGene
	    lt_prog_compiler_wl_CXX='-Wl,'
	    lt_prog_compiler_pic_CXX='-qpic'
	    lt_prog_compiler_static_CXX='-qstaticlink'
	    ;;
	  *)
	    case `$CC -V 2>&1 | sed 5q` in
	    *Sun\ C*)
	      # Sun C++ 5.9
	      lt_prog_compiler_pic_CXX='-KPIC'
	      lt_prog_compiler_static_CXX='-Bstatic'
	      lt_prog_compiler_wl_CXX='-Qoption ld '
	      ;;
	    esac
	    ;;
	esac
	;;
      lynxos*)
	;;
      m88k*)
	;;
      mvs*)
	case $cc_basename in
	  cxx*)
	    lt_prog_compiler_pic_CXX='-W c,exportall'
	    ;;
	  *)
	    ;;
	esac
	;;
      netbsd*)
	;;
      *qnx* | *nto*)
        # QNX uses GNU C++, but need to define -shared option too, otherwise
        # it will coredump.
        lt_prog_compiler_pic_CXX='-fPIC -shared'
        ;;
      osf3* | osf4* | osf5*)
	case $cc_basename in
	  KCC*)
	    lt_prog_compiler_wl_CXX='--backend -Wl,'
	    ;;
	  RCC*)
	    # Rational C++ 2.4.1
	    lt_prog_compiler_pic_CXX='-pic'
	    ;;
	  cxx*)
	    # Digital/Compaq C++
	    lt_prog_compiler_wl_CXX='-Wl,'
	    # Make sure the PIC flag is empty.  It appears that all Alpha
	    # Linux and Compaq Tru64 Unix objects are PIC.
	    lt_prog_compiler_pic_CXX=
	    lt_prog_compiler_static_CXX='-non_shared'
	    ;;
	  *)
	    ;;
	esac
	;;
      psos*)
	;;
      solaris*)
	case $cc_basename in
	  CC* | sunCC*)
	    # Sun C++ 4.2, 5.x and Centerline C++
	    lt_prog_compiler_pic_CXX='-KPIC'
	    lt_prog_compiler_static_CXX='-Bstatic'
	    lt_prog_compiler_wl_CXX='-Qoption ld '
	    ;;
	  gcx*)
	    # Green Hills C++ Compiler
	    lt_prog_compiler_pic_CXX='-PIC'
	    ;;
	  *)
	    ;;
	esac
	;;
      sunos4*)
	case $cc_basename in
	  CC*)
	    # Sun C++ 4.x
	    lt_prog_compiler_pic_CXX='-pic'
	    lt_prog_compiler_static_CXX='-Bstatic'
	    ;;
	  lcc*)
	    # Lucid
	    lt_prog_compiler_pic_CXX='-pic'
	    ;;
	  *)
	    ;;
	esac
	;;
      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
	case $cc_basename in
	  CC*)
	    lt_prog_compiler_wl_CXX='-Wl,'
	    lt_prog_compiler_pic_CXX='-KPIC'
	    lt_prog_compiler_static_CXX='-Bstatic'
	    ;;
	esac
	;;
      tandem*)
	case $cc_basename in
	  NCC*)
	    # NonStop-UX NCC 3.20
	    lt_prog_compiler_pic_CXX='-KPIC'
	    ;;
	  *)
	    ;;
	esac
	;;
      vxworks*)
	;;
      *)
	lt_prog_compiler_can_build_shared_CXX=no
	;;
    esac
  fi

case $host_os in
  # For platforms which do not support PIC, -DPIC is meaningless:
  *djgpp*)
    lt_prog_compiler_pic_CXX=
    ;;
  *)
    lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC"
    ;;
esac

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
if ${lt_cv_prog_compiler_pic_CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5
$as_echo "$lt_cv_prog_compiler_pic_CXX" >&6; }
lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX

#
# Check to make sure the PIC flag actually works.
#
if test -n "$lt_prog_compiler_pic_CXX"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5
$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; }
if ${lt_cv_prog_compiler_pic_works_CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_pic_works_CXX=no
   ac_outfile=conftest.$ac_objext
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
   lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   # The option is referenced via a variable to avoid confusing sed.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
   (eval "$lt_compile" 2>conftest.err)
   ac_status=$?
   cat conftest.err >&5
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   if (exit $ac_status) && test -s "$ac_outfile"; then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings other than the usual output.
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
       lt_cv_prog_compiler_pic_works_CXX=yes
     fi
   fi
   $RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5
$as_echo "$lt_cv_prog_compiler_pic_works_CXX" >&6; }

if test x"$lt_cv_prog_compiler_pic_works_CXX" = xyes; then
    case $lt_prog_compiler_pic_CXX in
     "" | " "*) ;;
     *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;;
     esac
else
    lt_prog_compiler_pic_CXX=
     lt_prog_compiler_can_build_shared_CXX=no
fi

fi





#
# Check to make sure the static flag actually works.
#
wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
if ${lt_cv_prog_compiler_static_works_CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_static_works_CXX=no
   save_LDFLAGS="$LDFLAGS"
   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
   echo "$lt_simple_link_test_code" > conftest.$ac_ext
   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
     # The linker can only warn and ignore the option if not recognized
     # So say no if there are warnings
     if test -s conftest.err; then
       # Append any errors to the config.log.
       cat conftest.err 1>&5
       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
       if diff conftest.exp conftest.er2 >/dev/null; then
         lt_cv_prog_compiler_static_works_CXX=yes
       fi
     else
       lt_cv_prog_compiler_static_works_CXX=yes
     fi
   fi
   $RM -r conftest*
   LDFLAGS="$save_LDFLAGS"

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5
$as_echo "$lt_cv_prog_compiler_static_works_CXX" >&6; }

if test x"$lt_cv_prog_compiler_static_works_CXX" = xyes; then
    :
else
    lt_prog_compiler_static_CXX=
fi




    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
if ${lt_cv_prog_compiler_c_o_CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_c_o_CXX=no
   $RM -r conftest 2>/dev/null
   mkdir conftest
   cd conftest
   mkdir out
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext

   lt_compiler_flag="-o out/conftest2.$ac_objext"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
   (eval "$lt_compile" 2>out/conftest.err)
   ac_status=$?
   cat out/conftest.err >&5
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
   then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
       lt_cv_prog_compiler_c_o_CXX=yes
     fi
   fi
   chmod u+w . 2>&5
   $RM conftest*
   # SGI C++ compiler will create directory out/ii_files/ for
   # template instantiation
   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
   $RM out/* && rmdir out
   cd ..
   $RM -r conftest
   $RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; }



    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
if ${lt_cv_prog_compiler_c_o_CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_prog_compiler_c_o_CXX=no
   $RM -r conftest 2>/dev/null
   mkdir conftest
   cd conftest
   mkdir out
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext

   lt_compiler_flag="-o out/conftest2.$ac_objext"
   # Insert the option either (1) after the last *FLAGS variable, or
   # (2) before a word containing "conftest.", or (3) at the end.
   # Note that $ac_compile itself does not contain backslashes and begins
   # with a dollar sign (not a hyphen), so the echo should work correctly.
   lt_compile=`echo "$ac_compile" | $SED \
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
   -e 's:$: $lt_compiler_flag:'`
   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
   (eval "$lt_compile" 2>out/conftest.err)
   ac_status=$?
   cat out/conftest.err >&5
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
   then
     # The compiler can only warn and ignore the option if not recognized
     # So say no if there are warnings
     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
       lt_cv_prog_compiler_c_o_CXX=yes
     fi
   fi
   chmod u+w . 2>&5
   $RM conftest*
   # SGI C++ compiler will create directory out/ii_files/ for
   # template instantiation
   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
   $RM out/* && rmdir out
   cd ..
   $RM -r conftest
   $RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; }




hard_links="nottested"
if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then
  # do not overwrite the value of need_locks provided by the user
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
$as_echo_n "checking if we can lock with hard links... " >&6; }
  hard_links=yes
  $RM conftest*
  ln conftest.a conftest.b 2>/dev/null && hard_links=no
  touch conftest.a
  ln conftest.a conftest.b 2>&5 || hard_links=no
  ln conftest.a conftest.b 2>/dev/null && hard_links=no
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
$as_echo "$hard_links" >&6; }
  if test "$hard_links" = no; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
    need_locks=warn
  fi
else
  need_locks=no
fi



    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }

  export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
  exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
  case $host_os in
  aix[4-9]*)
    # If we're using GNU nm, then we don't want the "-C" option.
    # -C means demangle to AIX nm, but means don't demangle with GNU nm
    # Also, AIX nm treats weak defined symbols like other global defined
    # symbols, whereas GNU nm marks them as "W".
    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
    else
      export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
    fi
    ;;
  pw32*)
    export_symbols_cmds_CXX="$ltdll_cmds"
    ;;
  cygwin* | mingw* | cegcc*)
    case $cc_basename in
    cl*)
      exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
      ;;
    *)
      export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
      exclude_expsyms_CXX='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
      ;;
    esac
    ;;
  *)
    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
    ;;
  esac

{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
$as_echo "$ld_shlibs_CXX" >&6; }
test "$ld_shlibs_CXX" = no && can_build_shared=no

with_gnu_ld_CXX=$with_gnu_ld






#
# Do we need to explicitly link libc?
#
case "x$archive_cmds_need_lc_CXX" in
x|xyes)
  # Assume -lc should be added
  archive_cmds_need_lc_CXX=yes

  if test "$enable_shared" = yes && test "$GCC" = yes; then
    case $archive_cmds_CXX in
    *'~'*)
      # FIXME: we may have to deal with multi-command sequences.
      ;;
    '$CC '*)
      # Test whether the compiler implicitly links with -lc since on some
      # systems, -lgcc has to come before -lc. If gcc already passes -lc
      # to ld, don't add -lc before -lgcc.
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
if ${lt_cv_archive_cmds_need_lc_CXX+:} false; then :
  $as_echo_n "(cached) " >&6
else
  $RM conftest*
	echo "$lt_simple_compile_test_code" > conftest.$ac_ext

	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
  (eval $ac_compile) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; } 2>conftest.err; then
	  soname=conftest
	  lib=conftest
	  libobjs=conftest.$ac_objext
	  deplibs=
	  wl=$lt_prog_compiler_wl_CXX
	  pic_flag=$lt_prog_compiler_pic_CXX
	  compiler_flags=-v
	  linker_flags=-v
	  verstring=
	  output_objdir=.
	  libname=conftest
	  lt_save_allow_undefined_flag=$allow_undefined_flag_CXX
	  allow_undefined_flag_CXX=
	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
  (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }
	  then
	    lt_cv_archive_cmds_need_lc_CXX=no
	  else
	    lt_cv_archive_cmds_need_lc_CXX=yes
	  fi
	  allow_undefined_flag_CXX=$lt_save_allow_undefined_flag
	else
	  cat conftest.err 1>&5
	fi
	$RM conftest*

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5
$as_echo "$lt_cv_archive_cmds_need_lc_CXX" >&6; }
      archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX
      ;;
    esac
  fi
  ;;
esac






























































    { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
$as_echo_n "checking dynamic linker characteristics... " >&6; }

library_names_spec=
libname_spec='lib$name'
soname_spec=
shrext_cmds=".so"
postinstall_cmds=
postuninstall_cmds=
finish_cmds=
finish_eval=
shlibpath_var=
shlibpath_overrides_runpath=unknown
version_type=none
dynamic_linker="$host_os ld.so"
sys_lib_dlsearch_path_spec="/lib /usr/lib"
need_lib_prefix=unknown
hardcode_into_libs=no

# when you set need_version to no, make sure it does not cause -set_version
# flags to be left without arguments
need_version=unknown

case $host_os in
aix3*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
  shlibpath_var=LIBPATH

  # AIX 3 has no versioning support, so we append a major version to the name.
  soname_spec='${libname}${release}${shared_ext}$major'
  ;;

aix[4-9]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  hardcode_into_libs=yes
  if test "$host_cpu" = ia64; then
    # AIX 5 supports IA64
    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
    shlibpath_var=LD_LIBRARY_PATH
  else
    # With GCC up to 2.95.x, collect2 would create an import file
    # for dependence libraries.  The import file would start with
    # the line `#! .'.  This would cause the generated library to
    # depend on `.', always an invalid library.  This was fixed in
    # development snapshots of GCC prior to 3.0.
    case $host_os in
      aix4 | aix4.[01] | aix4.[01].*)
      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
	   echo ' yes '
	   echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
	:
      else
	can_build_shared=no
      fi
      ;;
    esac
    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
    # soname into executable. Probably we can add versioning support to
    # collect2, so additional links can be useful in future.
    if test "$aix_use_runtimelinking" = yes; then
      # If using run time linking (on AIX 4.2 or later) use lib.so
      # instead of lib.a to let people know that these are not
      # typical AIX shared libraries.
      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    else
      # We preserve .a as extension for shared libraries through AIX4.2
      # and later when we are not doing run time linking.
      library_names_spec='${libname}${release}.a $libname.a'
      soname_spec='${libname}${release}${shared_ext}$major'
    fi
    shlibpath_var=LIBPATH
  fi
  ;;

amigaos*)
  case $host_cpu in
  powerpc)
    # Since July 2007 AmigaOS4 officially supports .so libraries.
    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    ;;
  m68k)
    library_names_spec='$libname.ixlibrary $libname.a'
    # Create ${libname}_ixlibrary.a entries in /sys/libs.
    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
    ;;
  esac
  ;;

beos*)
  library_names_spec='${libname}${shared_ext}'
  dynamic_linker="$host_os ld.so"
  shlibpath_var=LIBRARY_PATH
  ;;

bsdi[45]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
  # the default ld.so.conf also contains /usr/contrib/lib and
  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
  # libtool to hard-code these into programs
  ;;

cygwin* | mingw* | pw32* | cegcc*)
  version_type=windows
  shrext_cmds=".dll"
  need_version=no
  need_lib_prefix=no

  case $GCC,$cc_basename in
  yes,*)
    # gcc
    library_names_spec='$libname.dll.a'
    # DLL is installed to $(libdir)/../bin by postinstall_cmds
    postinstall_cmds='base_file=`basename \${file}`~
      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
      dldir=$destdir/`dirname \$dlpath`~
      test -d \$dldir || mkdir -p \$dldir~
      $install_prog $dir/$dlname \$dldir/$dlname~
      chmod a+x \$dldir/$dlname~
      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
      fi'
    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
      dlpath=$dir/\$dldll~
       $RM \$dlpath'
    shlibpath_overrides_runpath=yes

    case $host_os in
    cygwin*)
      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

      ;;
    mingw* | cegcc*)
      # MinGW DLLs use traditional 'lib' prefix
      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
      ;;
    pw32*)
      # pw32 DLLs use 'pw' prefix rather than 'lib'
      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
      ;;
    esac
    dynamic_linker='Win32 ld.exe'
    ;;

  *,cl*)
    # Native MSVC
    libname_spec='$name'
    soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
    library_names_spec='${libname}.dll.lib'

    case $build_os in
    mingw*)
      sys_lib_search_path_spec=
      lt_save_ifs=$IFS
      IFS=';'
      for lt_path in $LIB
      do
        IFS=$lt_save_ifs
        # Let DOS variable expansion print the short 8.3 style file name.
        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
      done
      IFS=$lt_save_ifs
      # Convert to MSYS style.
      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
      ;;
    cygwin*)
      # Convert to unix form, then to dos form, then back to unix form
      # but this time dos style (no spaces!) so that the unix form looks
      # like /cygdrive/c/PROGRA~1:/cygdr...
      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
      ;;
    *)
      sys_lib_search_path_spec="$LIB"
      if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
        # It is most probably a Windows format PATH.
        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
      else
        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
      fi
      # FIXME: find the short name or the path components, as spaces are
      # common. (e.g. "Program Files" -> "PROGRA~1")
      ;;
    esac

    # DLL is installed to $(libdir)/../bin by postinstall_cmds
    postinstall_cmds='base_file=`basename \${file}`~
      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
      dldir=$destdir/`dirname \$dlpath`~
      test -d \$dldir || mkdir -p \$dldir~
      $install_prog $dir/$dlname \$dldir/$dlname'
    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
      dlpath=$dir/\$dldll~
       $RM \$dlpath'
    shlibpath_overrides_runpath=yes
    dynamic_linker='Win32 link.exe'
    ;;

  *)
    # Assume MSVC wrapper
    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
    dynamic_linker='Win32 ld.exe'
    ;;
  esac
  # FIXME: first we should search . and the directory the executable is in
  shlibpath_var=PATH
  ;;

darwin* | rhapsody*)
  dynamic_linker="$host_os dyld"
  version_type=darwin
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
  soname_spec='${libname}${release}${major}$shared_ext'
  shlibpath_overrides_runpath=yes
  shlibpath_var=DYLD_LIBRARY_PATH
  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'

  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
  ;;

dgux*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  ;;

freebsd* | dragonfly*)
  # DragonFly does not have aout.  When/if they implement a new
  # versioning mechanism, adjust this.
  if test -x /usr/bin/objformat; then
    objformat=`/usr/bin/objformat`
  else
    case $host_os in
    freebsd[23].*) objformat=aout ;;
    *) objformat=elf ;;
    esac
  fi
  version_type=freebsd-$objformat
  case $version_type in
    freebsd-elf*)
      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
      need_version=no
      need_lib_prefix=no
      ;;
    freebsd-*)
      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
      need_version=yes
      ;;
  esac
  shlibpath_var=LD_LIBRARY_PATH
  case $host_os in
  freebsd2.*)
    shlibpath_overrides_runpath=yes
    ;;
  freebsd3.[01]* | freebsdelf3.[01]*)
    shlibpath_overrides_runpath=yes
    hardcode_into_libs=yes
    ;;
  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
    shlibpath_overrides_runpath=no
    hardcode_into_libs=yes
    ;;
  *) # from 4.6 on, and DragonFly
    shlibpath_overrides_runpath=yes
    hardcode_into_libs=yes
    ;;
  esac
  ;;

gnu*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

haiku*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  dynamic_linker="$host_os runtime_loader"
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
  hardcode_into_libs=yes
  ;;

hpux9* | hpux10* | hpux11*)
  # Give a soname corresponding to the major version so that dld.sl refuses to
  # link against other versions.
  version_type=sunos
  need_lib_prefix=no
  need_version=no
  case $host_cpu in
  ia64*)
    shrext_cmds='.so'
    hardcode_into_libs=yes
    dynamic_linker="$host_os dld.so"
    shlibpath_var=LD_LIBRARY_PATH
    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    if test "X$HPUX_IA64_MODE" = X32; then
      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
    else
      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
    fi
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
    ;;
  hppa*64*)
    shrext_cmds='.sl'
    hardcode_into_libs=yes
    dynamic_linker="$host_os dld.sl"
    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
    ;;
  *)
    shrext_cmds='.sl'
    dynamic_linker="$host_os dld.sl"
    shlibpath_var=SHLIB_PATH
    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    ;;
  esac
  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
  postinstall_cmds='chmod 555 $lib'
  # or fails outright, so override atomically:
  install_override_mode=555
  ;;

interix[3-9]*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

irix5* | irix6* | nonstopux*)
  case $host_os in
    nonstopux*) version_type=nonstopux ;;
    *)
	if test "$lt_cv_prog_gnu_ld" = yes; then
		version_type=linux # correct to gnu/linux during the next big refactor
	else
		version_type=irix
	fi ;;
  esac
  need_lib_prefix=no
  need_version=no
  soname_spec='${libname}${release}${shared_ext}$major'
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
  case $host_os in
  irix5* | nonstopux*)
    libsuff= shlibsuff=
    ;;
  *)
    case $LD in # libtool.m4 will add one of these switches to LD
    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
      libsuff= shlibsuff= libmagic=32-bit;;
    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
      libsuff=32 shlibsuff=N32 libmagic=N32;;
    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
      libsuff=64 shlibsuff=64 libmagic=64-bit;;
    *) libsuff= shlibsuff= libmagic=never-match;;
    esac
    ;;
  esac
  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
  shlibpath_overrides_runpath=no
  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
  hardcode_into_libs=yes
  ;;

# No shared lib support for Linux oldld, aout, or coff.
linux*oldld* | linux*aout* | linux*coff*)
  dynamic_linker=no
  ;;

# This must be glibc/ELF.
linux* | k*bsd*-gnu | kopensolaris*-gnu)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no

  # Some binutils ld are patched to set DT_RUNPATH
  if ${lt_cv_shlibpath_overrides_runpath+:} false; then :
  $as_echo_n "(cached) " >&6
else
  lt_cv_shlibpath_overrides_runpath=no
    save_LDFLAGS=$LDFLAGS
    save_libdir=$libdir
    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \
	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\""
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
  lt_cv_shlibpath_overrides_runpath=yes
fi
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
    LDFLAGS=$save_LDFLAGS
    libdir=$save_libdir

fi

  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath

  # This implies no fast_install, which is unacceptable.
  # Some rework will be needed to allow for fast_install
  # before this can be enabled.
  hardcode_into_libs=yes

  # Add ABI-specific directories to the system library path.
  sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib"

  # Append ld.so.conf contents to the search path
  if test -f /etc/ld.so.conf; then
    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[	 ]*hwcap[	 ]/d;s/[:,	]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
    sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra"

  fi

  # We used to test for /lib/ld.so.1 and disable shared libraries on
  # powerpc, because MkLinux only supported shared libraries with the
  # GNU dynamic linker.  Since this was broken with cross compilers,
  # most powerpc-linux boxes support dynamic linking these days and
  # people can always --disable-shared, the test was removed, and we
  # assume the GNU/Linux dynamic linker is in use.
  dynamic_linker='GNU/Linux ld.so'
  ;;

netbsd*)
  version_type=sunos
  need_lib_prefix=no
  need_version=no
  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
    dynamic_linker='NetBSD (a.out) ld.so'
  else
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
    soname_spec='${libname}${release}${shared_ext}$major'
    dynamic_linker='NetBSD ld.elf_so'
  fi
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  ;;

newsos6)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  ;;

*nto* | *qnx*)
  version_type=qnx
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  dynamic_linker='ldqnx.so'
  ;;

openbsd*)
  version_type=sunos
  sys_lib_dlsearch_path_spec="/usr/lib"
  need_lib_prefix=no
  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
  case $host_os in
    openbsd3.3 | openbsd3.3.*)	need_version=yes ;;
    *)				need_version=no  ;;
  esac
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
    case $host_os in
      openbsd2.[89] | openbsd2.[89].*)
	shlibpath_overrides_runpath=no
	;;
      *)
	shlibpath_overrides_runpath=yes
	;;
      esac
  else
    shlibpath_overrides_runpath=yes
  fi
  ;;

os2*)
  libname_spec='$name'
  shrext_cmds=".dll"
  need_lib_prefix=no
  library_names_spec='$libname${shared_ext} $libname.a'
  dynamic_linker='OS/2 ld.exe'
  shlibpath_var=LIBPATH
  ;;

osf3* | osf4* | osf5*)
  version_type=osf
  need_lib_prefix=no
  need_version=no
  soname_spec='${libname}${release}${shared_ext}$major'
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
  ;;

rdos*)
  dynamic_linker=no
  ;;

solaris*)
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  # ldd complains unless libraries are executable
  postinstall_cmds='chmod +x $lib'
  ;;

sunos4*)
  version_type=sunos
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  if test "$with_gnu_ld" = yes; then
    need_lib_prefix=no
  fi
  need_version=yes
  ;;

sysv4 | sysv4.3*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  case $host_vendor in
    sni)
      shlibpath_overrides_runpath=no
      need_lib_prefix=no
      runpath_var=LD_RUN_PATH
      ;;
    siemens)
      need_lib_prefix=no
      ;;
    motorola)
      need_lib_prefix=no
      need_version=no
      shlibpath_overrides_runpath=no
      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
      ;;
  esac
  ;;

sysv4*MP*)
  if test -d /usr/nec ;then
    version_type=linux # correct to gnu/linux during the next big refactor
    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
    soname_spec='$libname${shared_ext}.$major'
    shlibpath_var=LD_LIBRARY_PATH
  fi
  ;;

sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
  version_type=freebsd-elf
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=yes
  hardcode_into_libs=yes
  if test "$with_gnu_ld" = yes; then
    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
  else
    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
    case $host_os in
      sco3.2v5*)
        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
	;;
    esac
  fi
  sys_lib_dlsearch_path_spec='/usr/lib'
  ;;

tpf*)
  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
  version_type=linux # correct to gnu/linux during the next big refactor
  need_lib_prefix=no
  need_version=no
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  shlibpath_var=LD_LIBRARY_PATH
  shlibpath_overrides_runpath=no
  hardcode_into_libs=yes
  ;;

uts4*)
  version_type=linux # correct to gnu/linux during the next big refactor
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
  soname_spec='${libname}${release}${shared_ext}$major'
  shlibpath_var=LD_LIBRARY_PATH
  ;;

*)
  dynamic_linker=no
  ;;
esac
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
$as_echo "$dynamic_linker" >&6; }
test "$dynamic_linker" = no && can_build_shared=no

variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
if test "$GCC" = yes; then
  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
fi

if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
  sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
fi
if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
  sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
fi






































    { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
hardcode_action_CXX=
if test -n "$hardcode_libdir_flag_spec_CXX" ||
   test -n "$runpath_var_CXX" ||
   test "X$hardcode_automatic_CXX" = "Xyes" ; then

  # We can hardcode non-existent directories.
  if test "$hardcode_direct_CXX" != no &&
     # If the only mechanism to avoid hardcoding is shlibpath_var, we
     # have to relink, otherwise we might link with an installed library
     # when we should be linking with a yet-to-be-installed one
     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" != no &&
     test "$hardcode_minus_L_CXX" != no; then
    # Linking always hardcodes the temporary library directory.
    hardcode_action_CXX=relink
  else
    # We can link without hardcoding, and we can hardcode nonexisting dirs.
    hardcode_action_CXX=immediate
  fi
else
  # We cannot hardcode anything, or else we can only hardcode existing
  # directories.
  hardcode_action_CXX=unsupported
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5
$as_echo "$hardcode_action_CXX" >&6; }

if test "$hardcode_action_CXX" = relink ||
   test "$inherit_rpath_CXX" = yes; then
  # Fast installation is not supported
  enable_fast_install=no
elif test "$shlibpath_overrides_runpath" = yes ||
     test "$enable_shared" = no; then
  # Fast installation is not necessary
  enable_fast_install=needless
fi







  fi # test -n "$compiler"

  CC=$lt_save_CC
  CFLAGS=$lt_save_CFLAGS
  LDCXX=$LD
  LD=$lt_save_LD
  GCC=$lt_save_GCC
  with_gnu_ld=$lt_save_with_gnu_ld
  lt_cv_path_LDCXX=$lt_cv_path_LD
  lt_cv_path_LD=$lt_save_path_LD
  lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
  lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
fi # test "$_lt_caught_CXX_error" != yes

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu


ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu


  OPENMP_CXXFLAGS=
  # Check whether --enable-openmp was given.
if test "${enable_openmp+set}" = set; then :
  enableval=$enable_openmp;
fi

  if test "$enable_openmp" != no; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CXX option to support OpenMP" >&5
$as_echo_n "checking for $CXX option to support OpenMP... " >&6; }
if ${ac_cv_prog_cxx_openmp+:} false; then :
  $as_echo_n "(cached) " >&6
else
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

#ifndef _OPENMP
 choke me
#endif
#include 
int main () { return omp_get_num_threads (); }

_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
  ac_cv_prog_cxx_openmp='none needed'
else
  ac_cv_prog_cxx_openmp='unsupported'
	  	  	  	  	  	  	                                	  	  	  	  	  	  for ac_option in -fopenmp -xopenmp -openmp -mp -omp -qsmp=omp -homp \
                           -Popenmp --openmp; do
	    ac_save_CXXFLAGS=$CXXFLAGS
	    CXXFLAGS="$CXXFLAGS $ac_option"
	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

#ifndef _OPENMP
 choke me
#endif
#include 
int main () { return omp_get_num_threads (); }

_ACEOF
if ac_fn_cxx_try_link "$LINENO"; then :
  ac_cv_prog_cxx_openmp=$ac_option
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
	    CXXFLAGS=$ac_save_CXXFLAGS
	    if test "$ac_cv_prog_cxx_openmp" != unsupported; then
	      break
	    fi
	  done
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_openmp" >&5
$as_echo "$ac_cv_prog_cxx_openmp" >&6; }
    case $ac_cv_prog_cxx_openmp in #(
      "none needed" | unsupported)
	;; #(
      *)
	OPENMP_CXXFLAGS=$ac_cv_prog_cxx_openmp ;;
    esac
  fi


CXXFLAGS="$CXXFLAGS $OPENMP_CFLAGS"
if test "x$enable_native_optimizations" = "xyes"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -march=native" >&5
$as_echo_n "checking whether C++ compiler accepts -march=native... " >&6; }
if ${ax_cv_check_cxxflags___march_native+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -march=native"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___march_native=yes
else
  ax_cv_check_cxxflags___march_native=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___march_native" >&5
$as_echo "$ax_cv_check_cxxflags___march_native" >&6; }
if test x"$ax_cv_check_cxxflags___march_native" = xyes; then :
  CXX="$CXX -march=native"
else
  :
fi

else

        if test "x$GCC_CXX" = "xyes" -a "x`$CXX -dumpversion | cut -d. -f1,2`" = "x4.4"; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -fno-tree-fre" >&5
$as_echo_n "checking whether C++ compiler accepts -fno-tree-fre... " >&6; }
if ${ax_cv_check_cxxflags___fno_tree_fre+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -fno-tree-fre"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___fno_tree_fre=yes
else
  ax_cv_check_cxxflags___fno_tree_fre=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___fno_tree_fre" >&5
$as_echo "$ax_cv_check_cxxflags___fno_tree_fre" >&6; }
if test x"$ax_cv_check_cxxflags___fno_tree_fre" = xyes; then :
  CXXFLAGS="$CXXFLAGS -fno-tree-fre"
else
  :
fi


fi


fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -fno-tree-vectorize" >&5
$as_echo_n "checking whether C++ compiler accepts -fno-tree-vectorize... " >&6; }
if ${ax_cv_check_cxxflags___fno_tree_vectorize+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -fno-tree-vectorize"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___fno_tree_vectorize=yes
else
  ax_cv_check_cxxflags___fno_tree_vectorize=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___fno_tree_vectorize" >&5
$as_echo "$ax_cv_check_cxxflags___fno_tree_vectorize" >&6; }
if test x"$ax_cv_check_cxxflags___fno_tree_vectorize" = xyes; then :
  CXXFLAGS="$CXXFLAGS -fno-tree-vectorize"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -fno-math-errno" >&5
$as_echo_n "checking whether C++ compiler accepts -fno-math-errno... " >&6; }
if ${ax_cv_check_cxxflags___fno_math_errno+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -fno-math-errno"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___fno_math_errno=yes
else
  ax_cv_check_cxxflags___fno_math_errno=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___fno_math_errno" >&5
$as_echo "$ax_cv_check_cxxflags___fno_math_errno" >&6; }
if test x"$ax_cv_check_cxxflags___fno_math_errno" = xyes; then :
  CXXFLAGS="$CXXFLAGS -fno-math-errno"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -funsafe-math-optimizations" >&5
$as_echo_n "checking whether C++ compiler accepts -funsafe-math-optimizations... " >&6; }
if ${ax_cv_check_cxxflags___funsafe_math_optimizations+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -funsafe-math-optimizations"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___funsafe_math_optimizations=yes
else
  ax_cv_check_cxxflags___funsafe_math_optimizations=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___funsafe_math_optimizations" >&5
$as_echo "$ax_cv_check_cxxflags___funsafe_math_optimizations" >&6; }
if test x"$ax_cv_check_cxxflags___funsafe_math_optimizations" = xyes; then :
  CXXFLAGS="$CXXFLAGS -funsafe-math-optimizations"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -fno-trapping-math" >&5
$as_echo_n "checking whether C++ compiler accepts -fno-trapping-math... " >&6; }
if ${ax_cv_check_cxxflags___fno_trapping_math+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -fno-trapping-math"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___fno_trapping_math=yes
else
  ax_cv_check_cxxflags___fno_trapping_math=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___fno_trapping_math" >&5
$as_echo "$ax_cv_check_cxxflags___fno_trapping_math" >&6; }
if test x"$ax_cv_check_cxxflags___fno_trapping_math" = xyes; then :
  CXXFLAGS="$CXXFLAGS -fno-trapping-math"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -fno-rounding-math" >&5
$as_echo_n "checking whether C++ compiler accepts -fno-rounding-math... " >&6; }
if ${ax_cv_check_cxxflags___fno_rounding_math+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -fno-rounding-math"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___fno_rounding_math=yes
else
  ax_cv_check_cxxflags___fno_rounding_math=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___fno_rounding_math" >&5
$as_echo "$ax_cv_check_cxxflags___fno_rounding_math" >&6; }
if test x"$ax_cv_check_cxxflags___fno_rounding_math" = xyes; then :
  CXXFLAGS="$CXXFLAGS -fno-rounding-math"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -fno-signaling-nans" >&5
$as_echo_n "checking whether C++ compiler accepts -fno-signaling-nans... " >&6; }
if ${ax_cv_check_cxxflags___fno_signaling_nans+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -fno-signaling-nans"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___fno_signaling_nans=yes
else
  ax_cv_check_cxxflags___fno_signaling_nans=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___fno_signaling_nans" >&5
$as_echo "$ax_cv_check_cxxflags___fno_signaling_nans" >&6; }
if test x"$ax_cv_check_cxxflags___fno_signaling_nans" = xyes; then :
  CXXFLAGS="$CXXFLAGS -fno-signaling-nans"
else
  :
fi

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether C++ compiler accepts -fcx-limited-range" >&5
$as_echo_n "checking whether C++ compiler accepts -fcx-limited-range... " >&6; }
if ${ax_cv_check_cxxflags___fcx_limited_range+:} false; then :
  $as_echo_n "(cached) " >&6
else

  ax_check_save_flags=$CXXFLAGS
  CXXFLAGS="$CXXFLAGS  -fcx-limited-range"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()
{

  ;
  return 0;
}
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
  ax_cv_check_cxxflags___fcx_limited_range=yes
else
  ax_cv_check_cxxflags___fcx_limited_range=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  CXXFLAGS=$ax_check_save_flags
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_check_cxxflags___fcx_limited_range" >&5
$as_echo "$ax_cv_check_cxxflags___fcx_limited_range" >&6; }
if test x"$ax_cv_check_cxxflags___fcx_limited_range" = xyes; then :
  CXXFLAGS="$CXXFLAGS -fcx-limited-range"
else
  :
fi

ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu











if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
	if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_PKG_CONFIG+:} false; then :
  $as_echo_n "(cached) " >&6
else
  case $PKG_CONFIG in
  [\\/]* | ?:[\\/]*)
  ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
  ;;
  *)
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG
if test -n "$PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
$as_echo "$PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_path_PKG_CONFIG"; then
  ac_pt_PKG_CONFIG=$PKG_CONFIG
  # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
  $as_echo_n "(cached) " >&6
else
  case $ac_pt_PKG_CONFIG in
  [\\/]* | ?:[\\/]*)
  ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
  ;;
  *)
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
if test -n "$ac_pt_PKG_CONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
$as_echo "$ac_pt_PKG_CONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_pt_PKG_CONFIG" = x; then
    PKG_CONFIG=""
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    PKG_CONFIG=$ac_pt_PKG_CONFIG
  fi
else
  PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
fi

fi
if test -n "$PKG_CONFIG"; then
	_pkg_min_version=0.9.0
	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
$as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
	else
		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
		PKG_CONFIG=""
	fi
fi

pkg_failed=no
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for CFITSIO" >&5
$as_echo_n "checking for CFITSIO... " >&6; }

if test -n "$CFITSIO_CFLAGS"; then
    pkg_cv_CFITSIO_CFLAGS="$CFITSIO_CFLAGS"
 elif test -n "$PKG_CONFIG"; then
    if test -n "$PKG_CONFIG" && \
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"cfitsio\""; } >&5
  ($PKG_CONFIG --exists --print-errors "cfitsio") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
  pkg_cv_CFITSIO_CFLAGS=`$PKG_CONFIG --cflags "cfitsio" 2>/dev/null`
		      test "x$?" != "x0" && pkg_failed=yes
else
  pkg_failed=yes
fi
 else
    pkg_failed=untried
fi
if test -n "$CFITSIO_LIBS"; then
    pkg_cv_CFITSIO_LIBS="$CFITSIO_LIBS"
 elif test -n "$PKG_CONFIG"; then
    if test -n "$PKG_CONFIG" && \
    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"cfitsio\""; } >&5
  ($PKG_CONFIG --exists --print-errors "cfitsio") 2>&5
  ac_status=$?
  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
  test $ac_status = 0; }; then
  pkg_cv_CFITSIO_LIBS=`$PKG_CONFIG --libs "cfitsio" 2>/dev/null`
		      test "x$?" != "x0" && pkg_failed=yes
else
  pkg_failed=yes
fi
 else
    pkg_failed=untried
fi



if test $pkg_failed = yes; then
   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }

if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
        _pkg_short_errors_supported=yes
else
        _pkg_short_errors_supported=no
fi
        if test $_pkg_short_errors_supported = yes; then
	        CFITSIO_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "cfitsio" 2>&1`
        else
	        CFITSIO_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "cfitsio" 2>&1`
        fi
	# Put the nasty error message in config.log where it belongs
	echo "$CFITSIO_PKG_ERRORS" >&5

	CFITSIO_LIBS=-lcfitsio
elif test $pkg_failed = untried; then
     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
	CFITSIO_LIBS=-lcfitsio
else
	CFITSIO_CFLAGS=$pkg_cv_CFITSIO_CFLAGS
	CFITSIO_LIBS=$pkg_cv_CFITSIO_LIBS
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }

fi
CFITSIO_LIBS="$CFITSIO_LIBS -lm"


save_CFLAGS=$CFLAGS
save_LIBS=$LIBS
CFLAGS="$CFLAGS $CFITSIO_CFLAGS"
LIBS="$LIBS $CFITSIO_LIBS"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ffgnrwll in -lcfitsio" >&5
$as_echo_n "checking for ffgnrwll in -lcfitsio... " >&6; }
if ${ac_cv_lib_cfitsio_ffgnrwll+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-lcfitsio  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char ffgnrwll ();
int
main ()
{
return ffgnrwll ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_cfitsio_ffgnrwll=yes
else
  ac_cv_lib_cfitsio_ffgnrwll=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_cfitsio_ffgnrwll" >&5
$as_echo "$ac_cv_lib_cfitsio_ffgnrwll" >&6; }
if test "x$ac_cv_lib_cfitsio_ffgnrwll" = xyes; then :
  :
else
  as_fn_error $? "could not find the cfitsio library" "$LINENO" 5
fi

for ac_header in fitsio.h
do :
  ac_fn_c_check_header_mongrel "$LINENO" "fitsio.h" "ac_cv_header_fitsio_h" "$ac_includes_default"
if test "x$ac_cv_header_fitsio_h" = xyes; then :
  cat >>confdefs.h <<_ACEOF
#define HAVE_FITSIO_H 1
_ACEOF
 :
else
  as_fn_error $? "could not find the cfitsio header file" "$LINENO" 5
fi

done

CFLAGS=$save_CFLAGS
LIBS=$save_LIBS




# we need the expanded forms...
test "x$prefix" = xNONE && prefix=$ac_default_prefix
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig libname" >&5
$as_echo_n "checking our pkgconfig libname... " >&6; }
test ".$ax_create_pkgconfig_libname" != "." || \
ax_create_pkgconfig_libname="${PACKAGE_NAME}"
test ".$ax_create_pkgconfig_libname" != "." || \
ax_create_pkgconfig_libname="$PACKAGE"
ax_create_pkgconfig_libname=`eval echo "$ax_create_pkgconfig_libname"`
ax_create_pkgconfig_libname=`eval echo "$ax_create_pkgconfig_libname"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_create_pkgconfig_libname" >&5
$as_echo "$ax_create_pkgconfig_libname" >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig version" >&5
$as_echo_n "checking our pkgconfig version... " >&6; }
test ".$ax_create_pkgconfig_version" != "." || \
ax_create_pkgconfig_version="${PACKAGE_VERSION}"
test ".$ax_create_pkgconfig_version" != "." || \
ax_create_pkgconfig_version="$VERSION"
ax_create_pkgconfig_version=`eval echo "$ax_create_pkgconfig_version"`
ax_create_pkgconfig_version=`eval echo "$ax_create_pkgconfig_version"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_create_pkgconfig_version" >&5
$as_echo "$ax_create_pkgconfig_version" >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig_libdir" >&5
$as_echo_n "checking our pkgconfig_libdir... " >&6; }
test ".$pkgconfig_libdir" = "." && \
pkgconfig_libdir='${libdir}/pkgconfig'
ax_create_pkgconfig_libdir=`eval echo "$pkgconfig_libdir"`
ax_create_pkgconfig_libdir=`eval echo "$ax_create_pkgconfig_libdir"`
ax_create_pkgconfig_libdir=`eval echo "$ax_create_pkgconfig_libdir"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pkgconfig_libdir" >&5
$as_echo "$pkgconfig_libdir" >&6; }
test "$pkgconfig_libdir" != "$ax_create_pkgconfig_libdir" && (
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: expanded our pkgconfig_libdir... $ax_create_pkgconfig_libdir" >&5
$as_echo "expanded our pkgconfig_libdir... $ax_create_pkgconfig_libdir" >&6; })


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig_libfile" >&5
$as_echo_n "checking our pkgconfig_libfile... " >&6; }
test ".$pkgconfig_libfile" != "." || \
pkgconfig_libfile="$ax_create_pkgconfig_libname.pc"
ax_create_pkgconfig_libfile=`eval echo "$pkgconfig_libfile"`
ax_create_pkgconfig_libfile=`eval echo "$ax_create_pkgconfig_libfile"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pkgconfig_libfile" >&5
$as_echo "$pkgconfig_libfile" >&6; }
test "$pkgconfig_libfile" != "$ax_create_pkgconfig_libfile" && (
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: expanded our pkgconfig_libfile... $ax_create_pkgconfig_libfile" >&5
$as_echo "expanded our pkgconfig_libfile... $ax_create_pkgconfig_libfile" >&6; })


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our package / suffix" >&5
$as_echo_n "checking our package / suffix... " >&6; }
ax_create_pkgconfig_suffix="$program_suffix"
test ".$ax_create_pkgconfig_suffix" != .NONE || ax_create_pkgconfig_suffix=""
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${PACKAGE_NAME} / ${ax_create_pkgconfig_suffix}" >&5
$as_echo "${PACKAGE_NAME} / ${ax_create_pkgconfig_suffix}" >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig description" >&5
$as_echo_n "checking our pkgconfig description... " >&6; }
ax_create_pkgconfig_description="$PACKAGE_SUMMARY"
test ".$ax_create_pkgconfig_description" != "." || \
ax_create_pkgconfig_description="$ax_create_pkgconfig_libname Library"
ax_create_pkgconfig_description=`eval echo "$ax_create_pkgconfig_description"`
ax_create_pkgconfig_description=`eval echo "$ax_create_pkgconfig_description"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_create_pkgconfig_description" >&5
$as_echo "$ax_create_pkgconfig_description" >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig requires" >&5
$as_echo_n "checking our pkgconfig requires... " >&6; }
ax_create_pkgconfig_requires="$PACKAGE_REQUIRES"
ax_create_pkgconfig_requires=`eval echo "$ax_create_pkgconfig_requires"`
ax_create_pkgconfig_requires=`eval echo "$ax_create_pkgconfig_requires"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_create_pkgconfig_requires" >&5
$as_echo "$ax_create_pkgconfig_requires" >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig ext libs" >&5
$as_echo_n "checking our pkgconfig ext libs... " >&6; }
ax_create_pkgconfig_pkglibs="$PACKAGE_LIBS"
test ".$ax_create_pkgconfig_pkglibs" != "." || ax_create_pkgconfig_pkglibs="-l$ax_create_pkgconfig_libname"
ax_create_pkgconfig_libs="$ax_create_pkgconfig_pkglibs $LIBS"
ax_create_pkgconfig_libs=`eval echo "$ax_create_pkgconfig_libs"`
ax_create_pkgconfig_libs=`eval echo "$ax_create_pkgconfig_libs"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_create_pkgconfig_libs" >&5
$as_echo "$ax_create_pkgconfig_libs" >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig cppflags" >&5
$as_echo_n "checking our pkgconfig cppflags... " >&6; }
ax_create_pkgconfig_cppflags="$OPENMP_CFLAGS $CFITSIO_CFLAGS"
ax_create_pkgconfig_cppflags=`eval echo "$ax_create_pkgconfig_cppflags"`
ax_create_pkgconfig_cppflags=`eval echo "$ax_create_pkgconfig_cppflags"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_create_pkgconfig_cppflags" >&5
$as_echo "$ax_create_pkgconfig_cppflags" >&6; }

{ $as_echo "$as_me:${as_lineno-$LINENO}: checking our pkgconfig ldflags" >&5
$as_echo_n "checking our pkgconfig ldflags... " >&6; }
ax_create_pkgconfig_ldflags="$PACKAGE_LDFLAGS"
ax_create_pkgconfig_ldflags=`eval echo "$ax_create_pkgconfig_ldflags"`
ax_create_pkgconfig_ldflags=`eval echo "$ax_create_pkgconfig_ldflags"`
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_create_pkgconfig_ldflags" >&5
$as_echo "$ax_create_pkgconfig_ldflags" >&6; }

test ".$ax_create_pkgconfig_generate" != "." || \
ax_create_pkgconfig_generate="$ax_create_pkgconfig_libname.pc"
ax_create_pkgconfig_generate=`eval echo "$ax_create_pkgconfig_generate"`
ax_create_pkgconfig_generate=`eval echo "$ax_create_pkgconfig_generate"`
test "$pkgconfig_libfile" != "$ax_create_pkgconfig_generate" && (
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: generate the pkgconfig later... $ax_create_pkgconfig_generate" >&5
$as_echo "generate the pkgconfig later... $ax_create_pkgconfig_generate" >&6; })

if test ".$ax_create_pkgconfig_src_libdir" = "." ; then
ax_create_pkgconfig_src_libdir=`pwd`
ax_create_pkgconfig_src_libdir=`$as_dirname -- "$ax_create_pkgconfig_src_libdir/$ax_create_pkgconfig_generate" ||
$as_expr X"$ax_create_pkgconfig_src_libdir/$ax_create_pkgconfig_generate" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$ax_create_pkgconfig_src_libdir/$ax_create_pkgconfig_generate" : 'X\(//\)[^/]' \| \
	 X"$ax_create_pkgconfig_src_libdir/$ax_create_pkgconfig_generate" : 'X\(//\)$' \| \
	 X"$ax_create_pkgconfig_src_libdir/$ax_create_pkgconfig_generate" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$ax_create_pkgconfig_src_libdir/$ax_create_pkgconfig_generate" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
test ! -d $ax_create_pkgconfig_src_libdir/src || \
ax_create_pkgconfig_src_libdir="$ax_create_pkgconfig_src_libdir/src"
case ".$objdir" in
*libs) ax_create_pkgconfig_src_libdir="$ax_create_pkgconfig_src_libdir/$objdir" ;; esac
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: noninstalled pkgconfig -L $ax_create_pkgconfig_src_libdir" >&5
$as_echo "noninstalled pkgconfig -L $ax_create_pkgconfig_src_libdir" >&6; }
fi

if test ".$ax_create_pkgconfig_src_headers" = "." ; then
ax_create_pkgconfig_src_headers=`pwd`
v="$ac_top_srcdir" ;
test ".$v" != "." || v="$ax_spec_dir"
test ".$v" != "." || v="$srcdir"
case "$v" in /*) ax_create_pkgconfig_src_headers="" ;; esac
ax_create_pkgconfig_src_headers=`$as_dirname -- "$ax_create_pkgconfig_src_headers/$v/x" ||
$as_expr X"$ax_create_pkgconfig_src_headers/$v/x" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$ax_create_pkgconfig_src_headers/$v/x" : 'X\(//\)[^/]' \| \
	 X"$ax_create_pkgconfig_src_headers/$v/x" : 'X\(//\)$' \| \
	 X"$ax_create_pkgconfig_src_headers/$v/x" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$ax_create_pkgconfig_src_headers/$v/x" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
test ! -d $ax_create_pkgconfig_src_headers/include || \
ax_create_pkgconfig_src_headers="$ax_create_pkgconfig_src_headers/include"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: noninstalled pkgconfig -I $ax_create_pkgconfig_src_headers" >&5
$as_echo "noninstalled pkgconfig -I $ax_create_pkgconfig_src_headers" >&6; }
fi


ac_config_commands="$ac_config_commands $ax_create_pkgconfig_generate"


ac_config_files="$ac_config_files Makefile"

cat >confcache <<\_ACEOF
# This file is a shell script that caches the results of configure
# tests run on this system so they can be shared between configure
# scripts and configure runs, see configure's option --config-cache.
# It is not useful on other systems.  If it contains results you don't
# want to keep, you may remove or edit it.
#
# config.status only pays attention to the cache file if you give it
# the --recheck option to rerun configure.
#
# `ac_cv_env_foo' variables (set or unset) will be overridden when
# loading this file, other *unset* `ac_cv_foo' will be assigned the
# following values.

_ACEOF

# The following way of writing the cache mishandles newlines in values,
# but we know of no workaround that is simple, portable, and efficient.
# So, we kill variables containing newlines.
# Ultrix sh set writes to stderr and can't be redirected directly,
# and sets the high bit in the cache file unless we assign to the vars.
(
  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
    eval ac_val=\$$ac_var
    case $ac_val in #(
    *${as_nl}*)
      case $ac_var in #(
      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
      esac
      case $ac_var in #(
      _ | IFS | as_nl) ;; #(
      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
      *) { eval $ac_var=; unset $ac_var;} ;;
      esac ;;
    esac
  done

  (set) 2>&1 |
    case $as_nl`(ac_space=' '; set) 2>&1` in #(
    *${as_nl}ac_space=\ *)
      # `set' does not quote correctly, so add quotes: double-quote
      # substitution turns \\\\ into \\, and sed turns \\ into \.
      sed -n \
	"s/'/'\\\\''/g;
	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
      ;; #(
    *)
      # `set' quotes correctly as required by POSIX, so do not add quotes.
      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
      ;;
    esac |
    sort
) |
  sed '
     /^ac_cv_env_/b end
     t clear
     :clear
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
     t end
     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
     :end' >>confcache
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
  if test -w "$cache_file"; then
    if test "x$cache_file" != "x/dev/null"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
$as_echo "$as_me: updating cache $cache_file" >&6;}
      if test ! -f "$cache_file" || test -h "$cache_file"; then
	cat confcache >"$cache_file"
      else
        case $cache_file in #(
        */* | ?:*)
	  mv -f confcache "$cache_file"$$ &&
	  mv -f "$cache_file"$$ "$cache_file" ;; #(
        *)
	  mv -f confcache "$cache_file" ;;
	esac
      fi
    fi
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
  fi
fi
rm -f confcache

test "x$prefix" = xNONE && prefix=$ac_default_prefix
# Let make expand exec_prefix.
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

# Transform confdefs.h into DEFS.
# Protect against shell expansion while executing Makefile rules.
# Protect against Makefile macro expansion.
#
# If the first sed substitution is executed (which looks for macros that
# take arguments), then branch to the quote section.  Otherwise,
# look for a macro that doesn't take arguments.
ac_script='
:mline
/\\$/{
 N
 s,\\\n,,
 b mline
}
t clear
:clear
s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 (][^	 (]*([^)]*)\)[	 ]*\(.*\)/-D\1=\2/g
t quote
s/^[	 ]*#[	 ]*define[	 ][	 ]*\([^	 ][^	 ]*\)[	 ]*\(.*\)/-D\1=\2/g
t quote
b any
:quote
s/[	 `~#$^&*(){}\\|;'\''"<>?]/\\&/g
s/\[/\\&/g
s/\]/\\&/g
s/\$/$$/g
H
:any
${
	g
	s/^\n//
	s/\n/ /g
	p
}
'
DEFS=`sed -n "$ac_script" confdefs.h`


ac_libobjs=
ac_ltlibobjs=
U=
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
  # 1. Remove the extension, and $U if already installed.
  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
  #    will be set to the directory where LIBOBJS objects are built.
  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
done
LIBOBJS=$ac_libobjs

LTLIBOBJS=$ac_ltlibobjs


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
$as_echo_n "checking that generated files are newer than configure... " >&6; }
   if test -n "$am_sleep_pid"; then
     # Hide warnings about reused PIDs.
     wait $am_sleep_pid 2>/dev/null
   fi
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
$as_echo "done" >&6; }
 if test -n "$EXEEXT"; then
  am__EXEEXT_TRUE=
  am__EXEEXT_FALSE='#'
else
  am__EXEEXT_TRUE='#'
  am__EXEEXT_FALSE=
fi

if test -z "${MAINTAINER_MODE_TRUE}" && test -z "${MAINTAINER_MODE_FALSE}"; then
  as_fn_error $? "conditional \"MAINTAINER_MODE\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
  as_fn_error $? "conditional \"AMDEP\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
  as_fn_error $? "conditional \"am__fastdepCXX\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi

: "${CONFIG_STATUS=./config.status}"
ac_write_fail=0
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
as_write_fail=0
cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
#! $SHELL
# Generated by $as_me.
# Run this file to recreate the current configuration.
# Compiler output produced by configure, useful for debugging
# configure, is in config.log if it exists.

debug=false
ac_cs_recheck=false
ac_cs_silent=false

SHELL=\${CONFIG_SHELL-$SHELL}
export SHELL
_ASEOF
cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error


# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
  as_basename=basename
else
  as_basename=false
fi

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
	 X"$0" : 'X\(//\)$' \| \
	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
    sed '/^.*\/\([^/][^/]*\)\/*$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\/\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -pR'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -pR'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -pR'
  fi
else
  as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null


# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p
if mkdir -p . 2>/dev/null; then
  as_mkdir_p='mkdir -p "$as_dir"'
else
  test -d ./-p && rmdir ./-p
  as_mkdir_p=false
fi


# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
  test -f "$1" && test -x "$1"
} # as_fn_executable_p
as_test_x='test -x'
as_executable_p=as_fn_executable_p

# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"


exec 6>&1
## ----------------------------------- ##
## Main body of $CONFIG_STATUS script. ##
## ----------------------------------- ##
_ASEOF
test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# Save the log message, to keep $0 and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by healpix_cxx $as_me 3.30.0, which was
generated by GNU Autoconf 2.69.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES
  CONFIG_HEADERS  = $CONFIG_HEADERS
  CONFIG_LINKS    = $CONFIG_LINKS
  CONFIG_COMMANDS = $CONFIG_COMMANDS
  $ $0 $@

on `(hostname || uname -n) 2>/dev/null | sed 1q`
"

_ACEOF

case $ac_config_files in *"
"*) set x $ac_config_files; shift; ac_config_files=$*;;
esac



cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Files that config.status was made for.
config_files="$ac_config_files"
config_commands="$ac_config_commands"

_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
ac_cs_usage="\
\`$as_me' instantiates files and other configuration actions
from templates according to the current configuration.  Unless the files
and actions are specified as TAGs, all are instantiated by default.

Usage: $0 [OPTION]... [TAG]...

  -h, --help       print this help, then exit
  -V, --version    print version number and configuration settings, then exit
      --config     print configuration, then exit
  -q, --quiet, --silent
                   do not print progress messages
  -d, --debug      don't remove temporary files
      --recheck    update $as_me by reconfiguring in the same conditions
      --file=FILE[:TEMPLATE]
                   instantiate the configuration file FILE

Configuration files:
$config_files

Configuration commands:
$config_commands

Report bugs to the package provider."

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
healpix_cxx config.status 3.30.0
configured by $0, generated by GNU Autoconf 2.69,
  with options \\"\$ac_cs_config\\"

Copyright (C) 2012 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."

ac_pwd='$ac_pwd'
srcdir='$srcdir'
INSTALL='$INSTALL'
MKDIR_P='$MKDIR_P'
AWK='$AWK'
test -n "\$AWK" || AWK=awk
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# The default lists apply if the user does not specify any file.
ac_need_defaults=:
while test $# != 0
do
  case $1 in
  --*=?*)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
    ac_shift=:
    ;;
  --*=)
    ac_option=`expr "X$1" : 'X\([^=]*\)='`
    ac_optarg=
    ac_shift=:
    ;;
  *)
    ac_option=$1
    ac_optarg=$2
    ac_shift=shift
    ;;
  esac

  case $ac_option in
  # Handling of the options.
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    ac_cs_recheck=: ;;
  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
    $as_echo "$ac_cs_version"; exit ;;
  --config | --confi | --conf | --con | --co | --c )
    $as_echo "$ac_cs_config"; exit ;;
  --debug | --debu | --deb | --de | --d | -d )
    debug=: ;;
  --file | --fil | --fi | --f )
    $ac_shift
    case $ac_optarg in
    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
    '') as_fn_error $? "missing file argument" ;;
    esac
    as_fn_append CONFIG_FILES " '$ac_optarg'"
    ac_need_defaults=false;;
  --he | --h |  --help | --hel | -h )
    $as_echo "$ac_cs_usage"; exit ;;
  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil | --si | --s)
    ac_cs_silent=: ;;

  # This is an error.
  -*) as_fn_error $? "unrecognized option: \`$1'
Try \`$0 --help' for more information." ;;

  *) as_fn_append ac_config_targets " $1"
     ac_need_defaults=false ;;

  esac
  shift
done

ac_configure_extra_args=

if $ac_cs_silent; then
  exec 6>/dev/null
  ac_configure_extra_args="$ac_configure_extra_args --silent"
fi

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
if \$ac_cs_recheck; then
  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
  shift
  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
  CONFIG_SHELL='$SHELL'
  export CONFIG_SHELL
  exec "\$@"
fi

_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
exec 5>>config.log
{
  echo
  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Running $as_me. ##
_ASBOX
  $as_echo "$ac_log"
} >&5

_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
#
# INIT-COMMANDS
#
AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"


# The HP-UX ksh and POSIX shell print the target directory to stdout
# if CDPATH is set.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

sed_quote_subst='$sed_quote_subst'
double_quote_subst='$double_quote_subst'
delay_variable_subst='$delay_variable_subst'
macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`'
host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`'
host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`'
host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`'
build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`'
build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`'
build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`'
SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`'
Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`'
GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`'
EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`'
FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`'
LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`'
NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`'
LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`'
max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`'
ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`'
exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`'
lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`'
lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`'
lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`'
lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`'
lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`'
reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`'
deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`'
file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`'
file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`'
want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`'
DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`'
sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`'
AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`'
AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`'
archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`'
STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`'
RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`'
old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`'
old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`'
lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`'
CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`'
CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`'
compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`'
GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`'
lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`'
lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`'
lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`'
lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`'
nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`'
lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`'
objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`'
lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`'
lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`'
lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`'
need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`'
MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`'
DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`'
NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`'
LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`'
OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`'
OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`'
libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`'
shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`'
extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`'
enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`'
export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`'
whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`'
compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`'
old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`'
old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`'
archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`'
module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`'
module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`'
with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`'
allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`'
no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`'
hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`'
hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`'
hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`'
hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`'
hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`'
hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`'
hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`'
inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`'
link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`'
always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`'
export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`'
exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`'
include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`'
prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`'
postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`'
file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`'
variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`'
need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`'
need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`'
version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`'
runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`'
shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`'
shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`'
libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`'
library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`'
soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`'
install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`'
postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`'
postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`'
finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`'
old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`'
striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`'
compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`'
predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`'
postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`'
predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`'
postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`'
compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`'
LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`'
reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`'
reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`'
old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`'
GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`'
lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`'
lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`'
lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`'
lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`'
lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`'
archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`'
enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`'
export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`'
old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`'
old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`'
archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`'
module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`'
allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`'
hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`'
hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`'
hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`'
hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`'
hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`'
inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`'
link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`'
always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`'
export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`'
exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`'
hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`'
compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`'
predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`'
postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`'
predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`'
postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`'
compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`'

LTCC='$LTCC'
LTCFLAGS='$LTCFLAGS'
compiler='$compiler_DEFAULT'

# A function that is used when there is no print builtin or printf.
func_fallback_echo ()
{
  eval 'cat <<_LTECHO_EOF
\$1
_LTECHO_EOF'
}

# Quote evaled strings.
for var in SHELL \
ECHO \
PATH_SEPARATOR \
SED \
GREP \
EGREP \
FGREP \
LD \
NM \
LN_S \
lt_SP2NL \
lt_NL2SP \
reload_flag \
OBJDUMP \
deplibs_check_method \
file_magic_cmd \
file_magic_glob \
want_nocaseglob \
DLLTOOL \
sharedlib_from_linklib_cmd \
AR \
AR_FLAGS \
archiver_list_spec \
STRIP \
RANLIB \
CC \
CFLAGS \
compiler \
lt_cv_sys_global_symbol_pipe \
lt_cv_sys_global_symbol_to_cdecl \
lt_cv_sys_global_symbol_to_c_name_address \
lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
nm_file_list_spec \
lt_prog_compiler_no_builtin_flag \
lt_prog_compiler_pic \
lt_prog_compiler_wl \
lt_prog_compiler_static \
lt_cv_prog_compiler_c_o \
need_locks \
MANIFEST_TOOL \
DSYMUTIL \
NMEDIT \
LIPO \
OTOOL \
OTOOL64 \
shrext_cmds \
export_dynamic_flag_spec \
whole_archive_flag_spec \
compiler_needs_object \
with_gnu_ld \
allow_undefined_flag \
no_undefined_flag \
hardcode_libdir_flag_spec \
hardcode_libdir_separator \
exclude_expsyms \
include_expsyms \
file_list_spec \
variables_saved_for_relink \
libname_spec \
library_names_spec \
soname_spec \
install_override_mode \
finish_eval \
old_striplib \
striplib \
compiler_lib_search_dirs \
predep_objects \
postdep_objects \
predeps \
postdeps \
compiler_lib_search_path \
LD_CXX \
reload_flag_CXX \
compiler_CXX \
lt_prog_compiler_no_builtin_flag_CXX \
lt_prog_compiler_pic_CXX \
lt_prog_compiler_wl_CXX \
lt_prog_compiler_static_CXX \
lt_cv_prog_compiler_c_o_CXX \
export_dynamic_flag_spec_CXX \
whole_archive_flag_spec_CXX \
compiler_needs_object_CXX \
with_gnu_ld_CXX \
allow_undefined_flag_CXX \
no_undefined_flag_CXX \
hardcode_libdir_flag_spec_CXX \
hardcode_libdir_separator_CXX \
exclude_expsyms_CXX \
include_expsyms_CXX \
file_list_spec_CXX \
compiler_lib_search_dirs_CXX \
predep_objects_CXX \
postdep_objects_CXX \
predeps_CXX \
postdeps_CXX \
compiler_lib_search_path_CXX; do
    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
    *[\\\\\\\`\\"\\\$]*)
      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
      ;;
    *)
      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
      ;;
    esac
done

# Double-quote double-evaled strings.
for var in reload_cmds \
old_postinstall_cmds \
old_postuninstall_cmds \
old_archive_cmds \
extract_expsyms_cmds \
old_archive_from_new_cmds \
old_archive_from_expsyms_cmds \
archive_cmds \
archive_expsym_cmds \
module_cmds \
module_expsym_cmds \
export_symbols_cmds \
prelink_cmds \
postlink_cmds \
postinstall_cmds \
postuninstall_cmds \
finish_cmds \
sys_lib_search_path_spec \
sys_lib_dlsearch_path_spec \
reload_cmds_CXX \
old_archive_cmds_CXX \
old_archive_from_new_cmds_CXX \
old_archive_from_expsyms_cmds_CXX \
archive_cmds_CXX \
archive_expsym_cmds_CXX \
module_cmds_CXX \
module_expsym_cmds_CXX \
export_symbols_cmds_CXX \
prelink_cmds_CXX \
postlink_cmds_CXX; do
    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
    *[\\\\\\\`\\"\\\$]*)
      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
      ;;
    *)
      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
      ;;
    esac
done

ac_aux_dir='$ac_aux_dir'
xsi_shell='$xsi_shell'
lt_shell_append='$lt_shell_append'

# See if we are running on zsh, and set the options which allow our
# commands through without removal of \ escapes INIT.
if test -n "\${ZSH_VERSION+set}" ; then
   setopt NO_GLOB_SUBST
fi


    PACKAGE='$PACKAGE'
    VERSION='$VERSION'
    TIMESTAMP='$TIMESTAMP'
    RM='$RM'
    ofile='$ofile'






ax_create_pkgconfig_generate="$ax_create_pkgconfig_generate"
pkgconfig_prefix='$prefix'
pkgconfig_execprefix='$exec_prefix'
pkgconfig_bindir='$bindir'
pkgconfig_libdir='$libdir'
pkgconfig_includedir='$includedir'
pkgconfig_datarootdir='$datarootdir'
pkgconfig_datadir='$datadir'
pkgconfig_sysconfdir='$sysconfdir'
pkgconfig_suffix='$ax_create_pkgconfig_suffix'
pkgconfig_package='$PACKAGE_NAME'
pkgconfig_libname='$ax_create_pkgconfig_libname'
pkgconfig_description='$ax_create_pkgconfig_description'
pkgconfig_version='$ax_create_pkgconfig_version'
pkgconfig_requires='$ax_create_pkgconfig_requires'
pkgconfig_libs='$ax_create_pkgconfig_libs'
pkgconfig_ldflags='$ax_create_pkgconfig_ldflags'
pkgconfig_cppflags='$ax_create_pkgconfig_cppflags'
pkgconfig_src_libdir='$ax_create_pkgconfig_src_libdir'
pkgconfig_src_headers='$ax_create_pkgconfig_src_headers'


_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1

# Handling of arguments.
for ac_config_target in $ac_config_targets
do
  case $ac_config_target in
    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
    "$ax_create_pkgconfig_generate") CONFIG_COMMANDS="$CONFIG_COMMANDS $ax_create_pkgconfig_generate" ;;
    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;

  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
  esac
done


# If the user did not use the arguments to specify the items to instantiate,
# then the envvar interface is used.  Set only those that are not.
# We use the long form for the default assignment because of an extremely
# bizarre bug on SunOS 4.1.3.
if $ac_need_defaults; then
  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
fi

# Have a temporary directory for convenience.  Make it in the build tree
# simply because there is no reason against having it here, and in addition,
# creating and moving files from /tmp can sometimes cause problems.
# Hook for its removal unless debugging.
# Note that there is a small window in which the directory will not be cleaned:
# after its creation but before its name has been assigned to `$tmp'.
$debug ||
{
  tmp= ac_tmp=
  trap 'exit_status=$?
  : "${ac_tmp:=$tmp}"
  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
' 0
  trap 'as_fn_exit 1' 1 2 13 15
}
# Create a (secure) tmp directory for tmp files.

{
  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
  test -d "$tmp"
}  ||
{
  tmp=./conf$$-$RANDOM
  (umask 077 && mkdir "$tmp")
} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
ac_tmp=$tmp

# Set up the scripts for CONFIG_FILES section.
# No need to generate them if there are no CONFIG_FILES.
# This happens for instance with `./config.status config.h'.
if test -n "$CONFIG_FILES"; then


ac_cr=`echo X | tr X '\015'`
# On cygwin, bash can eat \r inside `` if the user requested igncr.
# But we know of no other shell where ac_cr would be empty at this
# point, so we can use a bashism as a fallback.
if test "x$ac_cr" = x; then
  eval ac_cr=\$\'\\r\'
fi
ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null`
if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
  ac_cs_awk_cr='\\r'
else
  ac_cs_awk_cr=$ac_cr
fi

echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
_ACEOF


{
  echo "cat >conf$$subs.awk <<_ACEOF" &&
  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
  echo "_ACEOF"
} >conf$$subs.sh ||
  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
ac_delim='%!_!# '
for ac_last_try in false false false false false :; do
  . ./conf$$subs.sh ||
    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5

  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
  if test $ac_delim_n = $ac_delim_num; then
    break
  elif $ac_last_try; then
    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
  else
    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
  fi
done
rm -f conf$$subs.sh

cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
_ACEOF
sed -n '
h
s/^/S["/; s/!.*/"]=/
p
g
s/^[^!]*!//
:repl
t repl
s/'"$ac_delim"'$//
t delim
:nl
h
s/\(.\{148\}\)..*/\1/
t more1
s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
p
n
b repl
:more1
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t nl
:delim
h
s/\(.\{148\}\)..*/\1/
t more2
s/["\\]/\\&/g; s/^/"/; s/$/"/
p
b
:more2
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t delim
' >$CONFIG_STATUS || ac_write_fail=1
rm -f conf$$subs.awk
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
_ACAWK
cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
  for (key in S) S_is_set[key] = 1
  FS = ""

}
{
  line = $ 0
  nfields = split(line, field, "@")
  substed = 0
  len = length(field[1])
  for (i = 2; i < nfields; i++) {
    key = field[i]
    keylen = length(key)
    if (S_is_set[key]) {
      value = S[key]
      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
      len += length(value) + length(field[++i])
      substed = 1
    } else
      len += 1 + keylen
  }

  print line
}

_ACAWK
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
else
  cat
fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
_ACEOF

# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
# trailing colons and then remove the whole line if VPATH becomes empty
# (actually we leave an empty line to preserve line numbers).
if test "x$srcdir" = x.; then
  ac_vpsub='/^[	 ]*VPATH[	 ]*=[	 ]*/{
h
s///
s/^/:/
s/[	 ]*$/:/
s/:\$(srcdir):/:/g
s/:\${srcdir}:/:/g
s/:@srcdir@:/:/g
s/^:*//
s/:*$//
x
s/\(=[	 ]*\).*/\1/
G
s/\n//
s/^[^=]*=[	 ]*$//
}'
fi

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
fi # test -n "$CONFIG_FILES"


eval set X "  :F $CONFIG_FILES      :C $CONFIG_COMMANDS"
shift
for ac_tag
do
  case $ac_tag in
  :[FHLC]) ac_mode=$ac_tag; continue;;
  esac
  case $ac_mode$ac_tag in
  :[FHL]*:*);;
  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
  :[FH]-) ac_tag=-:-;;
  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
  esac
  ac_save_IFS=$IFS
  IFS=:
  set x $ac_tag
  IFS=$ac_save_IFS
  shift
  ac_file=$1
  shift

  case $ac_mode in
  :L) ac_source=$1;;
  :[FH])
    ac_file_inputs=
    for ac_f
    do
      case $ac_f in
      -) ac_f="$ac_tmp/stdin";;
      *) # Look for the file first in the build tree, then in the source tree
	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
	 # because $ac_f cannot contain `:'.
	 test -f "$ac_f" ||
	   case $ac_f in
	   [\\/$]*) false;;
	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
	   esac ||
	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
      esac
      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
      as_fn_append ac_file_inputs " '$ac_f'"
    done

    # Let's still pretend it is `configure' which instantiates (i.e., don't
    # use $as_me), people would be surprised to read:
    #    /* config.h.  Generated by config.status.  */
    configure_input='Generated from '`
	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
	`' by configure.'
    if test x"$ac_file" != x-; then
      configure_input="$ac_file.  $configure_input"
      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
$as_echo "$as_me: creating $ac_file" >&6;}
    fi
    # Neutralize special characters interpreted by sed in replacement strings.
    case $configure_input in #(
    *\&* | *\|* | *\\* )
       ac_sed_conf_input=`$as_echo "$configure_input" |
       sed 's/[\\\\&|]/\\\\&/g'`;; #(
    *) ac_sed_conf_input=$configure_input;;
    esac

    case $ac_tag in
    *:-:* | *:-) cat >"$ac_tmp/stdin" \
      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
    esac
    ;;
  esac

  ac_dir=`$as_dirname -- "$ac_file" ||
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$ac_file" : 'X\(//\)[^/]' \| \
	 X"$ac_file" : 'X\(//\)$' \| \
	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$ac_file" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
  as_dir="$ac_dir"; as_fn_mkdir_p
  ac_builddir=.

case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
  # A ".." for each directory in $ac_dir_suffix.
  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
  case $ac_top_builddir_sub in
  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
  esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix

case $srcdir in
  .)  # We are building in place.
    ac_srcdir=.
    ac_top_srcdir=$ac_top_builddir_sub
    ac_abs_top_srcdir=$ac_pwd ;;
  [\\/]* | ?:[\\/]* )  # Absolute name.
    ac_srcdir=$srcdir$ac_dir_suffix;
    ac_top_srcdir=$srcdir
    ac_abs_top_srcdir=$srcdir ;;
  *) # Relative name.
    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
    ac_top_srcdir=$ac_top_build_prefix$srcdir
    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix


  case $ac_mode in
  :F)
  #
  # CONFIG_FILE
  #

  case $INSTALL in
  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
  esac
  ac_MKDIR_P=$MKDIR_P
  case $MKDIR_P in
  [\\/$]* | ?:[\\/]* ) ;;
  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
  esac
_ACEOF

cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# If the template does not know about datarootdir, expand it.
# FIXME: This hack should be removed a few years after 2.60.
ac_datarootdir_hack=; ac_datarootdir_seen=
ac_sed_dataroot='
/datarootdir/ {
  p
  q
}
/@datadir@/p
/@docdir@/p
/@infodir@/p
/@localedir@/p
/@mandir@/p'
case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
*datarootdir*) ac_datarootdir_seen=yes;;
*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
  ac_datarootdir_hack='
  s&@datadir@&$datadir&g
  s&@docdir@&$docdir&g
  s&@infodir@&$infodir&g
  s&@localedir@&$localedir&g
  s&@mandir@&$mandir&g
  s&\\\${datarootdir}&$datarootdir&g' ;;
esac
_ACEOF

# Neutralize VPATH when `$srcdir' = `.'.
# Shell code in configure.ac might set extrasub.
# FIXME: do we really want to maintain this feature?
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_sed_extra="$ac_vpsub
$extrasub
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
:t
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
s|@configure_input@|$ac_sed_conf_input|;t t
s&@top_builddir@&$ac_top_builddir_sub&;t t
s&@top_build_prefix@&$ac_top_build_prefix&;t t
s&@srcdir@&$ac_srcdir&;t t
s&@abs_srcdir@&$ac_abs_srcdir&;t t
s&@top_srcdir@&$ac_top_srcdir&;t t
s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
s&@builddir@&$ac_builddir&;t t
s&@abs_builddir@&$ac_abs_builddir&;t t
s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
s&@INSTALL@&$ac_INSTALL&;t t
s&@MKDIR_P@&$ac_MKDIR_P&;t t
$ac_datarootdir_hack
"
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5

test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
      "$ac_tmp/out"`; test -z "$ac_out"; } &&
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined" >&5
$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined.  Please make sure it is defined" >&2;}

  rm -f "$ac_tmp/stdin"
  case $ac_file in
  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
  esac \
  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
 ;;


  :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
$as_echo "$as_me: executing $ac_file commands" >&6;}
 ;;
  esac


  case $ac_file$ac_mode in
    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
  # Older Autoconf quotes --file arguments for eval, but not when files
  # are listed without --file.  Let's play safe and only enable the eval
  # if we detect the quoting.
  case $CONFIG_FILES in
  *\'*) eval set x "$CONFIG_FILES" ;;
  *)   set x $CONFIG_FILES ;;
  esac
  shift
  for mf
  do
    # Strip MF so we end up with the name of the file.
    mf=`echo "$mf" | sed -e 's/:.*$//'`
    # Check whether this is an Automake generated Makefile or not.
    # We used to match only the files named 'Makefile.in', but
    # some people rename them; so instead we look at the file content.
    # Grep'ing the first line is not enough: some people post-process
    # each Makefile.in and add a new line on top of each file to say so.
    # Grep'ing the whole file is not good either: AIX grep has a line
    # limit of 2048, but all sed's we know have understand at least 4000.
    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
      dirpart=`$as_dirname -- "$mf" ||
$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$mf" : 'X\(//\)[^/]' \| \
	 X"$mf" : 'X\(//\)$' \| \
	 X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$mf" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
    else
      continue
    fi
    # Extract the definition of DEPDIR, am__include, and am__quote
    # from the Makefile without running 'make'.
    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
    test -z "$DEPDIR" && continue
    am__include=`sed -n 's/^am__include = //p' < "$mf"`
    test -z "$am__include" && continue
    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
    # Find all dependency output files, they are included files with
    # $(DEPDIR) in their names.  We invoke sed twice because it is the
    # simplest approach to changing $(DEPDIR) to its actual value in the
    # expansion.
    for file in `sed -n "
      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
      # Make sure the directory exists.
      test -f "$dirpart/$file" && continue
      fdir=`$as_dirname -- "$file" ||
$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$file" : 'X\(//\)[^/]' \| \
	 X"$file" : 'X\(//\)$' \| \
	 X"$file" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$file" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      as_dir=$dirpart/$fdir; as_fn_mkdir_p
      # echo "creating $dirpart/$file"
      echo '# dummy' > "$dirpart/$file"
    done
  done
}
 ;;
    "libtool":C)

    # See if we are running on zsh, and set the options which allow our
    # commands through without removal of \ escapes.
    if test -n "${ZSH_VERSION+set}" ; then
      setopt NO_GLOB_SUBST
    fi

    cfgfile="${ofile}T"
    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
    $RM "$cfgfile"

    cat <<_LT_EOF >> "$cfgfile"
#! $SHELL

# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
# NOTE: Changes made to this file will be lost: look at ltmain.sh.
#
#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
#                 2006, 2007, 2008, 2009, 2010, 2011 Free Software
#                 Foundation, Inc.
#   Written by Gordon Matzigkeit, 1996
#
#   This file is part of GNU Libtool.
#
# GNU Libtool is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of
# the License, or (at your option) any later version.
#
# As a special exception to the GNU General Public License,
# if you distribute this file as part of a program or library that
# is built using GNU Libtool, you may include this file under the
# same distribution terms that you use for the rest of that program.
#
# GNU Libtool is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Libtool; see the file COPYING.  If not, a copy
# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
# obtained by writing to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.


# The names of the tagged configurations supported by this script.
available_tags="CXX "

# ### BEGIN LIBTOOL CONFIG

# Which release of libtool.m4 was used?
macro_version=$macro_version
macro_revision=$macro_revision

# Whether or not to build shared libraries.
build_libtool_libs=$enable_shared

# Whether or not to build static libraries.
build_old_libs=$enable_static

# What type of objects to build.
pic_mode=$pic_mode

# Whether or not to optimize for fast installation.
fast_install=$enable_fast_install

# Shell to use when invoking shell scripts.
SHELL=$lt_SHELL

# An echo program that protects backslashes.
ECHO=$lt_ECHO

# The PATH separator for the build system.
PATH_SEPARATOR=$lt_PATH_SEPARATOR

# The host system.
host_alias=$host_alias
host=$host
host_os=$host_os

# The build system.
build_alias=$build_alias
build=$build
build_os=$build_os

# A sed program that does not truncate output.
SED=$lt_SED

# Sed that helps us avoid accidentally triggering echo(1) options like -n.
Xsed="\$SED -e 1s/^X//"

# A grep program that handles long lines.
GREP=$lt_GREP

# An ERE matcher.
EGREP=$lt_EGREP

# A literal string matcher.
FGREP=$lt_FGREP

# A BSD- or MS-compatible name lister.
NM=$lt_NM

# Whether we need soft or hard links.
LN_S=$lt_LN_S

# What is the maximum length of a command?
max_cmd_len=$max_cmd_len

# Object file suffix (normally "o").
objext=$ac_objext

# Executable file suffix (normally "").
exeext=$exeext

# whether the shell understands "unset".
lt_unset=$lt_unset

# turn spaces into newlines.
SP2NL=$lt_lt_SP2NL

# turn newlines into spaces.
NL2SP=$lt_lt_NL2SP

# convert \$build file names to \$host format.
to_host_file_cmd=$lt_cv_to_host_file_cmd

# convert \$build files to toolchain format.
to_tool_file_cmd=$lt_cv_to_tool_file_cmd

# An object symbol dumper.
OBJDUMP=$lt_OBJDUMP

# Method to check whether dependent libraries are shared objects.
deplibs_check_method=$lt_deplibs_check_method

# Command to use when deplibs_check_method = "file_magic".
file_magic_cmd=$lt_file_magic_cmd

# How to find potential files when deplibs_check_method = "file_magic".
file_magic_glob=$lt_file_magic_glob

# Find potential files using nocaseglob when deplibs_check_method = "file_magic".
want_nocaseglob=$lt_want_nocaseglob

# DLL creation program.
DLLTOOL=$lt_DLLTOOL

# Command to associate shared and link libraries.
sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd

# The archiver.
AR=$lt_AR

# Flags to create an archive.
AR_FLAGS=$lt_AR_FLAGS

# How to feed a file listing to the archiver.
archiver_list_spec=$lt_archiver_list_spec

# A symbol stripping program.
STRIP=$lt_STRIP

# Commands used to install an old-style archive.
RANLIB=$lt_RANLIB
old_postinstall_cmds=$lt_old_postinstall_cmds
old_postuninstall_cmds=$lt_old_postuninstall_cmds

# Whether to use a lock for old archive extraction.
lock_old_archive_extraction=$lock_old_archive_extraction

# A C compiler.
LTCC=$lt_CC

# LTCC compiler flags.
LTCFLAGS=$lt_CFLAGS

# Take the output of nm and produce a listing of raw symbols and C names.
global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe

# Transform the output of nm in a proper C declaration.
global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl

# Transform the output of nm in a C name address pair.
global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address

# Transform the output of nm in a C name address pair when lib prefix is needed.
global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix

# Specify filename containing input files for \$NM.
nm_file_list_spec=$lt_nm_file_list_spec

# The root where to search for dependent libraries,and in which our libraries should be installed.
lt_sysroot=$lt_sysroot

# The name of the directory that contains temporary libtool files.
objdir=$objdir

# Used to examine libraries when file_magic_cmd begins with "file".
MAGIC_CMD=$MAGIC_CMD

# Must we lock files when doing compilation?
need_locks=$lt_need_locks

# Manifest tool.
MANIFEST_TOOL=$lt_MANIFEST_TOOL

# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
DSYMUTIL=$lt_DSYMUTIL

# Tool to change global to local symbols on Mac OS X.
NMEDIT=$lt_NMEDIT

# Tool to manipulate fat objects and archives on Mac OS X.
LIPO=$lt_LIPO

# ldd/readelf like tool for Mach-O binaries on Mac OS X.
OTOOL=$lt_OTOOL

# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
OTOOL64=$lt_OTOOL64

# Old archive suffix (normally "a").
libext=$libext

# Shared library suffix (normally ".so").
shrext_cmds=$lt_shrext_cmds

# The commands to extract the exported symbol list from a shared archive.
extract_expsyms_cmds=$lt_extract_expsyms_cmds

# Variables whose values should be saved in libtool wrapper scripts and
# restored at link time.
variables_saved_for_relink=$lt_variables_saved_for_relink

# Do we need the "lib" prefix for modules?
need_lib_prefix=$need_lib_prefix

# Do we need a version for libraries?
need_version=$need_version

# Library versioning type.
version_type=$version_type

# Shared library runtime path variable.
runpath_var=$runpath_var

# Shared library path variable.
shlibpath_var=$shlibpath_var

# Is shlibpath searched before the hard-coded library search path?
shlibpath_overrides_runpath=$shlibpath_overrides_runpath

# Format of library name prefix.
libname_spec=$lt_libname_spec

# List of archive names.  First name is the real one, the rest are links.
# The last name is the one that the linker finds with -lNAME
library_names_spec=$lt_library_names_spec

# The coded name of the library, if different from the real name.
soname_spec=$lt_soname_spec

# Permission mode override for installation of shared libraries.
install_override_mode=$lt_install_override_mode

# Command to use after installation of a shared archive.
postinstall_cmds=$lt_postinstall_cmds

# Command to use after uninstallation of a shared archive.
postuninstall_cmds=$lt_postuninstall_cmds

# Commands used to finish a libtool library installation in a directory.
finish_cmds=$lt_finish_cmds

# As "finish_cmds", except a single script fragment to be evaled but
# not shown.
finish_eval=$lt_finish_eval

# Whether we should hardcode library paths into libraries.
hardcode_into_libs=$hardcode_into_libs

# Compile-time system search path for libraries.
sys_lib_search_path_spec=$lt_sys_lib_search_path_spec

# Run-time system search path for libraries.
sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec

# Whether dlopen is supported.
dlopen_support=$enable_dlopen

# Whether dlopen of programs is supported.
dlopen_self=$enable_dlopen_self

# Whether dlopen of statically linked programs is supported.
dlopen_self_static=$enable_dlopen_self_static

# Commands to strip libraries.
old_striplib=$lt_old_striplib
striplib=$lt_striplib


# The linker used to build libraries.
LD=$lt_LD

# How to create reloadable object files.
reload_flag=$lt_reload_flag
reload_cmds=$lt_reload_cmds

# Commands used to build an old-style archive.
old_archive_cmds=$lt_old_archive_cmds

# A language specific compiler.
CC=$lt_compiler

# Is the compiler the GNU compiler?
with_gcc=$GCC

# Compiler flag to turn off builtin functions.
no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag

# Additional compiler flags for building library objects.
pic_flag=$lt_lt_prog_compiler_pic

# How to pass a linker flag through the compiler.
wl=$lt_lt_prog_compiler_wl

# Compiler flag to prevent dynamic linking.
link_static_flag=$lt_lt_prog_compiler_static

# Does compiler simultaneously support -c and -o options?
compiler_c_o=$lt_lt_cv_prog_compiler_c_o

# Whether or not to add -lc for building shared libraries.
build_libtool_need_lc=$archive_cmds_need_lc

# Whether or not to disallow shared libs when runtime libs are static.
allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes

# Compiler flag to allow reflexive dlopens.
export_dynamic_flag_spec=$lt_export_dynamic_flag_spec

# Compiler flag to generate shared objects directly from archives.
whole_archive_flag_spec=$lt_whole_archive_flag_spec

# Whether the compiler copes with passing no objects directly.
compiler_needs_object=$lt_compiler_needs_object

# Create an old-style archive from a shared archive.
old_archive_from_new_cmds=$lt_old_archive_from_new_cmds

# Create a temporary old-style archive to link instead of a shared archive.
old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds

# Commands used to build a shared archive.
archive_cmds=$lt_archive_cmds
archive_expsym_cmds=$lt_archive_expsym_cmds

# Commands used to build a loadable module if different from building
# a shared archive.
module_cmds=$lt_module_cmds
module_expsym_cmds=$lt_module_expsym_cmds

# Whether we are building with GNU ld or not.
with_gnu_ld=$lt_with_gnu_ld

# Flag that allows shared libraries with undefined symbols to be built.
allow_undefined_flag=$lt_allow_undefined_flag

# Flag that enforces no undefined symbols.
no_undefined_flag=$lt_no_undefined_flag

# Flag to hardcode \$libdir into a binary during linking.
# This must work even if \$libdir does not exist
hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec

# Whether we need a single "-rpath" flag with a separated argument.
hardcode_libdir_separator=$lt_hardcode_libdir_separator

# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
# DIR into the resulting binary.
hardcode_direct=$hardcode_direct

# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
# DIR into the resulting binary and the resulting library dependency is
# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
# library is relocated.
hardcode_direct_absolute=$hardcode_direct_absolute

# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
# into the resulting binary.
hardcode_minus_L=$hardcode_minus_L

# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
# into the resulting binary.
hardcode_shlibpath_var=$hardcode_shlibpath_var

# Set to "yes" if building a shared library automatically hardcodes DIR
# into the library and all subsequent libraries and executables linked
# against it.
hardcode_automatic=$hardcode_automatic

# Set to yes if linker adds runtime paths of dependent libraries
# to runtime path list.
inherit_rpath=$inherit_rpath

# Whether libtool must link a program against all its dependency libraries.
link_all_deplibs=$link_all_deplibs

# Set to "yes" if exported symbols are required.
always_export_symbols=$always_export_symbols

# The commands to list exported symbols.
export_symbols_cmds=$lt_export_symbols_cmds

# Symbols that should not be listed in the preloaded symbols.
exclude_expsyms=$lt_exclude_expsyms

# Symbols that must always be exported.
include_expsyms=$lt_include_expsyms

# Commands necessary for linking programs (against libraries) with templates.
prelink_cmds=$lt_prelink_cmds

# Commands necessary for finishing linking programs.
postlink_cmds=$lt_postlink_cmds

# Specify filename containing input files.
file_list_spec=$lt_file_list_spec

# How to hardcode a shared library path into an executable.
hardcode_action=$hardcode_action

# The directories searched by this compiler when creating a shared library.
compiler_lib_search_dirs=$lt_compiler_lib_search_dirs

# Dependencies to place before and after the objects being linked to
# create a shared library.
predep_objects=$lt_predep_objects
postdep_objects=$lt_postdep_objects
predeps=$lt_predeps
postdeps=$lt_postdeps

# The library search path used internally by the compiler when linking
# a shared library.
compiler_lib_search_path=$lt_compiler_lib_search_path

# ### END LIBTOOL CONFIG

_LT_EOF

  case $host_os in
  aix3*)
    cat <<\_LT_EOF >> "$cfgfile"
# AIX sometimes has problems with the GCC collect2 program.  For some
# reason, if we set the COLLECT_NAMES environment variable, the problems
# vanish in a puff of smoke.
if test "X${COLLECT_NAMES+set}" != Xset; then
  COLLECT_NAMES=
  export COLLECT_NAMES
fi
_LT_EOF
    ;;
  esac


ltmain="$ac_aux_dir/ltmain.sh"


  # We use sed instead of cat because bash on DJGPP gets confused if
  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
  # text mode, it properly converts lines to CR/LF.  This bash problem
  # is reportedly fixed, but why not run on old versions too?
  sed '$q' "$ltmain" >> "$cfgfile" \
     || (rm -f "$cfgfile"; exit 1)

  if test x"$xsi_shell" = xyes; then
  sed -e '/^func_dirname ()$/,/^} # func_dirname /c\
func_dirname ()\
{\
\    case ${1} in\
\      */*) func_dirname_result="${1%/*}${2}" ;;\
\      *  ) func_dirname_result="${3}" ;;\
\    esac\
} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_basename ()$/,/^} # func_basename /c\
func_basename ()\
{\
\    func_basename_result="${1##*/}"\
} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\
func_dirname_and_basename ()\
{\
\    case ${1} in\
\      */*) func_dirname_result="${1%/*}${2}" ;;\
\      *  ) func_dirname_result="${3}" ;;\
\    esac\
\    func_basename_result="${1##*/}"\
} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_stripname ()$/,/^} # func_stripname /c\
func_stripname ()\
{\
\    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\
\    # positional parameters, so assign one to ordinary parameter first.\
\    func_stripname_result=${3}\
\    func_stripname_result=${func_stripname_result#"${1}"}\
\    func_stripname_result=${func_stripname_result%"${2}"}\
} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\
func_split_long_opt ()\
{\
\    func_split_long_opt_name=${1%%=*}\
\    func_split_long_opt_arg=${1#*=}\
} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\
func_split_short_opt ()\
{\
\    func_split_short_opt_arg=${1#??}\
\    func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\
} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\
func_lo2o ()\
{\
\    case ${1} in\
\      *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\
\      *)    func_lo2o_result=${1} ;;\
\    esac\
} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_xform ()$/,/^} # func_xform /c\
func_xform ()\
{\
    func_xform_result=${1%.*}.lo\
} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_arith ()$/,/^} # func_arith /c\
func_arith ()\
{\
    func_arith_result=$(( $* ))\
} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_len ()$/,/^} # func_len /c\
func_len ()\
{\
    func_len_result=${#1}\
} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:

fi

if test x"$lt_shell_append" = xyes; then
  sed -e '/^func_append ()$/,/^} # func_append /c\
func_append ()\
{\
    eval "${1}+=\\${2}"\
} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\
func_append_quoted ()\
{\
\    func_quote_for_eval "${2}"\
\    eval "${1}+=\\\\ \\$func_quote_for_eval_result"\
} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \
  && mv -f "$cfgfile.tmp" "$cfgfile" \
    || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
test 0 -eq $? || _lt_function_replace_fail=:


  # Save a `func_append' function call where possible by direct use of '+='
  sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \
    && mv -f "$cfgfile.tmp" "$cfgfile" \
      || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
  test 0 -eq $? || _lt_function_replace_fail=:
else
  # Save a `func_append' function call even when '+=' is not available
  sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \
    && mv -f "$cfgfile.tmp" "$cfgfile" \
      || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
  test 0 -eq $? || _lt_function_replace_fail=:
fi

if test x"$_lt_function_replace_fail" = x":"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5
$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;}
fi


   mv -f "$cfgfile" "$ofile" ||
    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
  chmod +x "$ofile"


    cat <<_LT_EOF >> "$ofile"

# ### BEGIN LIBTOOL TAG CONFIG: CXX

# The linker used to build libraries.
LD=$lt_LD_CXX

# How to create reloadable object files.
reload_flag=$lt_reload_flag_CXX
reload_cmds=$lt_reload_cmds_CXX

# Commands used to build an old-style archive.
old_archive_cmds=$lt_old_archive_cmds_CXX

# A language specific compiler.
CC=$lt_compiler_CXX

# Is the compiler the GNU compiler?
with_gcc=$GCC_CXX

# Compiler flag to turn off builtin functions.
no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX

# Additional compiler flags for building library objects.
pic_flag=$lt_lt_prog_compiler_pic_CXX

# How to pass a linker flag through the compiler.
wl=$lt_lt_prog_compiler_wl_CXX

# Compiler flag to prevent dynamic linking.
link_static_flag=$lt_lt_prog_compiler_static_CXX

# Does compiler simultaneously support -c and -o options?
compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX

# Whether or not to add -lc for building shared libraries.
build_libtool_need_lc=$archive_cmds_need_lc_CXX

# Whether or not to disallow shared libs when runtime libs are static.
allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX

# Compiler flag to allow reflexive dlopens.
export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX

# Compiler flag to generate shared objects directly from archives.
whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX

# Whether the compiler copes with passing no objects directly.
compiler_needs_object=$lt_compiler_needs_object_CXX

# Create an old-style archive from a shared archive.
old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX

# Create a temporary old-style archive to link instead of a shared archive.
old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX

# Commands used to build a shared archive.
archive_cmds=$lt_archive_cmds_CXX
archive_expsym_cmds=$lt_archive_expsym_cmds_CXX

# Commands used to build a loadable module if different from building
# a shared archive.
module_cmds=$lt_module_cmds_CXX
module_expsym_cmds=$lt_module_expsym_cmds_CXX

# Whether we are building with GNU ld or not.
with_gnu_ld=$lt_with_gnu_ld_CXX

# Flag that allows shared libraries with undefined symbols to be built.
allow_undefined_flag=$lt_allow_undefined_flag_CXX

# Flag that enforces no undefined symbols.
no_undefined_flag=$lt_no_undefined_flag_CXX

# Flag to hardcode \$libdir into a binary during linking.
# This must work even if \$libdir does not exist
hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX

# Whether we need a single "-rpath" flag with a separated argument.
hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX

# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
# DIR into the resulting binary.
hardcode_direct=$hardcode_direct_CXX

# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
# DIR into the resulting binary and the resulting library dependency is
# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
# library is relocated.
hardcode_direct_absolute=$hardcode_direct_absolute_CXX

# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
# into the resulting binary.
hardcode_minus_L=$hardcode_minus_L_CXX

# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
# into the resulting binary.
hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX

# Set to "yes" if building a shared library automatically hardcodes DIR
# into the library and all subsequent libraries and executables linked
# against it.
hardcode_automatic=$hardcode_automatic_CXX

# Set to yes if linker adds runtime paths of dependent libraries
# to runtime path list.
inherit_rpath=$inherit_rpath_CXX

# Whether libtool must link a program against all its dependency libraries.
link_all_deplibs=$link_all_deplibs_CXX

# Set to "yes" if exported symbols are required.
always_export_symbols=$always_export_symbols_CXX

# The commands to list exported symbols.
export_symbols_cmds=$lt_export_symbols_cmds_CXX

# Symbols that should not be listed in the preloaded symbols.
exclude_expsyms=$lt_exclude_expsyms_CXX

# Symbols that must always be exported.
include_expsyms=$lt_include_expsyms_CXX

# Commands necessary for linking programs (against libraries) with templates.
prelink_cmds=$lt_prelink_cmds_CXX

# Commands necessary for finishing linking programs.
postlink_cmds=$lt_postlink_cmds_CXX

# Specify filename containing input files.
file_list_spec=$lt_file_list_spec_CXX

# How to hardcode a shared library path into an executable.
hardcode_action=$hardcode_action_CXX

# The directories searched by this compiler when creating a shared library.
compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX

# Dependencies to place before and after the objects being linked to
# create a shared library.
predep_objects=$lt_predep_objects_CXX
postdep_objects=$lt_postdep_objects_CXX
predeps=$lt_predeps_CXX
postdeps=$lt_postdeps_CXX

# The library search path used internally by the compiler when linking
# a shared library.
compiler_lib_search_path=$lt_compiler_lib_search_path_CXX

# ### END LIBTOOL TAG CONFIG: CXX
_LT_EOF

 ;;
    "$ax_create_pkgconfig_generate":C)
pkgconfig_generate="$ax_create_pkgconfig_generate"
if test ! -f "$pkgconfig_generate.in"
then generate="true"
elif grep ' generated by configure ' $pkgconfig_generate.in >/dev/null
then generate="true"
else generate="false";
fi
if $generate ; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $pkgconfig_generate.in" >&5
$as_echo "$as_me: creating $pkgconfig_generate.in" >&6;}
cat > $pkgconfig_generate.in <&5
$as_echo "$as_me: creating $pkgconfig_generate" >&6;}
cat >conftest.sed < $pkgconfig_generate
if test ! -s $pkgconfig_generate ; then
    as_fn_error $? "$pkgconfig_generate is empty" "$LINENO" 5
fi ; rm conftest.sed # DONE generate $pkgconfig_generate
pkgconfig_uninstalled=`echo $pkgconfig_generate |sed 's/.pc$/-uninstalled.pc/'`
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $pkgconfig_uninstalled" >&5
$as_echo "$as_me: creating $pkgconfig_uninstalled" >&6;}
cat >conftest.sed < $pkgconfig_uninstalled
if test ! -s $pkgconfig_uninstalled ; then
    as_fn_error $? "$pkgconfig_uninstalled is empty" "$LINENO" 5
fi ; rm conftest.sed # DONE generate $pkgconfig_uninstalled
           pkgconfig_requires_add=`echo ${pkgconfig_requires}`
if test ".$pkgconfig_requires_add" != "." ; then
           pkgconfig_requires_add="pkg-config $pkgconfig_requires_add"
    else   pkgconfig_requires_add=":" ; fi
pkgconfig_uninstalled=`echo $pkgconfig_generate |sed 's/.pc$/-uninstalled.sh/'`
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $pkgconfig_uninstalled" >&5
$as_echo "$as_me: creating $pkgconfig_uninstalled" >&6;}
cat >conftest.sed <Name:>for option\\; do case \"\$option\" in --list-all|--name) echo >
s>Description: *>\\;\\; --help) pkg-config --help \\; echo Buildscript Of >
s>Version: *>\\;\\; --modversion|--version) echo >
s>Requires:>\\;\\; --requires) echo $pkgconfig_requires_add>
s>Libs: *>\\;\\; --libs) echo >
s>Cflags: *>\\;\\; --cflags) echo >
/--libs)/a\\
       $pkgconfig_requires_add
/--cflags)/a\\
       $pkgconfig_requires_add\\
;; --variable=*) eval echo '\$'\`echo \$option | sed -e 's/.*=//'\`\\
;; --uninstalled) exit 0 \\
;; *) ;; esac done
AXEOF
sed -f conftest.sed  $pkgconfig_generate.in > $pkgconfig_uninstalled
if test ! -s $pkgconfig_uninstalled ; then
    as_fn_error $? "$pkgconfig_uninstalled is empty" "$LINENO" 5
fi ; rm conftest.sed # DONE generate $pkgconfig_uninstalled
 ;;

  esac
done # for ac_tag


as_fn_exit 0
_ACEOF
ac_clean_files=$ac_clean_files_save

test $ac_write_fail = 0 ||
  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5


# configure is writing to config.log, and then calls config.status.
# config.status does its own redirection, appending to config.log.
# Unfortunately, on DOS this fails, as config.log is still kept open
# by configure, so config.status won't be able to write to it; its
# output is simply discarded.  So we exec the FD to /dev/null,
# effectively closing config.log, so it can be properly (re)opened and
# appended to by config.status.  When coming back to configure, we
# need to make the FD available again.
if test "$no_create" != yes; then
  ac_cs_success=:
  ac_config_status_args=
  test "$silent" = yes &&
    ac_config_status_args="$ac_config_status_args --quiet"
  exec 5>/dev/null
  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
  exec 5>>config.log
  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
  # would make configure fail if this is the last instruction.
  $ac_cs_success || as_fn_exit 1
fi
if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
fi

healpy-1.10.3/healpixsubmodule/src/cxx/autotools/configure.ac0000664000175000017500000001331713010375061024611 0ustar  zoncazonca00000000000000AC_INIT([healpix_cxx], [3.30.0])
AM_INIT_AUTOMAKE([foreign subdir-objects -Wall -Werror])
AM_MAINTAINER_MODE([enable])

dnl
dnl Needed for linking on Windows.
dnl Protect with m4_ifdef because AM_PROG_AR is required in
dnl autoconf >= 1.12 when using -Wall, but the macro is
dnl absent in old versions of autoconf.
dnl
m4_ifdef([AM_PROG_AR], [AM_PROG_AR])

LT_INIT
AC_CONFIG_MACRO_DIR([m4])

dnl
dnl By default, install the headers into a subdirectory of
dnl ${prefix}/include to avoid possible header filename collisions.
dnl
includedir="${includedir}/${PACKAGE_NAME}"

dnl
dnl Enable silent build rules if this version of Automake supports them
dnl
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])

AC_DEFUN([AX_CHECK_COMPILE_FLAG],
[AS_VAR_PUSHDEF([CACHEVAR],[ax_cv_check_[]_AC_LANG_ABBREV[]flags_$4_$1])dnl
AC_CACHE_CHECK([whether _AC_LANG compiler accepts $1], CACHEVAR, [
  ax_check_save_flags=$[]_AC_LANG_PREFIX[]FLAGS
  _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $4 $1"
  AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
    [AS_VAR_SET(CACHEVAR,[yes])],
    [AS_VAR_SET(CACHEVAR,[no])])
  _AC_LANG_PREFIX[]FLAGS=$ax_check_save_flags])
AS_IF([test x"AS_VAR_GET(CACHEVAR)" = xyes],
  [m4_default([$2], :)],
  [m4_default([$3], :)])
AS_VAR_POPDEF([CACHEVAR])dnl
])dnl AX_CHECK_COMPILE_FLAGS

dnl
dnl Introduce --enable-native-optimizations command line argument to turn on
dnl -march=native compiler flag, disabled by default.
dnl
AC_ARG_ENABLE(
    [native-optimizations],
    [AS_HELP_STRING([--enable-native-optimizations], [Enable non-portable optimizations for your own CPU by compiling with -march=native @<:@default=no@:>@])]
)

AC_PROG_CC_C99
AC_OPENMP
CPPFLAGS="$CPPFLAGS $OPENMP_CFLAGS"
CFLAGS="$CFLAGS $OPENMP_CFLAGS"
AS_IF(
    [test "x$enable_native_optimizations" = "xyes"],
    [AX_CHECK_COMPILE_FLAG([-march=native],[CC="$CC -march=native"])],
    dnl
    dnl FIXME: On GCC 4.4, we hit an internal compiler error unless either
    dnl -march=native or -fno-tree-fre is specified.
    dnl
    [
        AS_IF(
            [test "x$GCC" = "xyes" -a "x`$CC -dumpversion | cut -d. -f1,2`" = "x4.4"],
            [AX_CHECK_COMPILE_FLAG([-fno-tree-fre], [CFLAGS="$CFLAGS -fno-tree-fre"])]
        )
    ]
)
AX_CHECK_COMPILE_FLAG([-fno-tree-vectorize],[CFLAGS="$CFLAGS -fno-tree-vectorize"])
AX_CHECK_COMPILE_FLAG([-fno-math-errno],[CFLAGS="$CFLAGS -fno-math-errno"])
AX_CHECK_COMPILE_FLAG([-funsafe-math-optimizations],[CFLAGS="$CFLAGS -funsafe-math-optimizations"])
AX_CHECK_COMPILE_FLAG([-fno-trapping-math],[CFLAGS="$CFLAGS -fno-trapping-math"])
AX_CHECK_COMPILE_FLAG([-fno-rounding-math],[CFLAGS="$CFLAGS -fno-rounding-math"])
AX_CHECK_COMPILE_FLAG([-fno-signaling-nans],[CFLAGS="$CFLAGS -fno-signaling-nans"])
AX_CHECK_COMPILE_FLAG([-fcx-limited-range],[CFLAGS="$CFLAGS -fcx-limited-range"])

AC_PROG_CXX
AC_LANG_PUSH([C++])
AC_OPENMP
CXXFLAGS="$CXXFLAGS $OPENMP_CFLAGS"
AS_IF(
    [test "x$enable_native_optimizations" = "xyes"],
    [AX_CHECK_COMPILE_FLAG([-march=native],[CXX="$CXX -march=native"])],
    dnl
    dnl FIXME: On GCC 4.4, we hit an internal compiler error unless either
    dnl -march=native or -fno-tree-fre is specified.
    dnl
    [
        AS_IF(
            [test "x$GCC_CXX" = "xyes" -a "x`$CXX -dumpversion | cut -d. -f1,2`" = "x4.4"],
            [AX_CHECK_COMPILE_FLAG([-fno-tree-fre], [CXXFLAGS="$CXXFLAGS -fno-tree-fre"])]
        )
    ]
)
AX_CHECK_COMPILE_FLAG([-fno-tree-vectorize],[CXXFLAGS="$CXXFLAGS -fno-tree-vectorize"])
AX_CHECK_COMPILE_FLAG([-fno-math-errno],[CXXFLAGS="$CXXFLAGS -fno-math-errno"])
AX_CHECK_COMPILE_FLAG([-funsafe-math-optimizations],[CXXFLAGS="$CXXFLAGS -funsafe-math-optimizations"])
AX_CHECK_COMPILE_FLAG([-fno-trapping-math],[CXXFLAGS="$CXXFLAGS -fno-trapping-math"])
AX_CHECK_COMPILE_FLAG([-fno-rounding-math],[CXXFLAGS="$CXXFLAGS -fno-rounding-math"])
AX_CHECK_COMPILE_FLAG([-fno-signaling-nans],[CXXFLAGS="$CXXFLAGS -fno-signaling-nans"])
AX_CHECK_COMPILE_FLAG([-fcx-limited-range],[CXXFLAGS="$CXXFLAGS -fcx-limited-range"])
AC_LANG_POP([C++])

dnl
dnl Determine the compiler flags (CFITSIO_CFLAGS)
dnl and linker flags (CFITSIO_LIBS) required to build against libcfitsio.
dnl
dnl Add help messages to describe the variables CFITSIO_CFLAGS and CFITSIO_LIBS,
dnl which can be provided as environment variables or as command-line arguments.
dnl These are output variables of PKG_CHECK_MODULES, but they can be overridden.
dnl
AC_ARG_VAR([CFITSIO_CFLAGS], [compiler flags needed for building with cfitsio, if not found by pkg-config])
AC_ARG_VAR([CFITSIO_LIBS], [linker flags needed for building with cfitsio, if not found by pkg-config])
dnl
dnl Now check for cfitsio using pkg-config. If cfitsio is not found with
dnl pkg-config, CFITSIO_LIBS defaults to "-lcfitsio".
dnl
PKG_CHECK_MODULES([CFITSIO], [cfitsio], , [CFITSIO_LIBS=-lcfitsio])
dnl
dnl Linking against libcfitsio requires libm too.
dnl
CFITSIO_LIBS="$CFITSIO_LIBS -lm"
dnl
dnl With pkg-config < 0.24, PKG_CHECK_MODULES does not AC_SUBST the _CFLAGS
dnl and _LIBS variables.
dnl
AC_SUBST([CFITSIO_CFLAGS])
AC_SUBST([CFITSIO_LIBS])
dnl
dnl Perform a test compile and link to determine if cfitsio is usable. If
dnl pkg-config did not find cfitsio, then the user may still have provided
dnl CFITSIO_CFLAGS and CFITSIO_LIBS manually. If pkg-config did find cfitsio,
dnl it does not hurt to test that cfitsio is usable.
dnl
save_CFLAGS=$CFLAGS
save_LIBS=$LIBS
CFLAGS="$CFLAGS $CFITSIO_CFLAGS"
LIBS="$LIBS $CFITSIO_LIBS"
AC_CHECK_LIB([cfitsio], [ffgnrwll], [:], AC_MSG_ERROR([could not find the cfitsio library]))
AC_CHECK_HEADERS([fitsio.h], [:], AC_MSG_ERROR([could not find the cfitsio header file]))
CFLAGS=$save_CFLAGS
LIBS=$save_LIBS

AC_PROG_LIBTOOL

dnl
dnl Create pkgconfig .pc file.
dnl
AX_CREATE_PKGCONFIG_INFO(,,,,[$OPENMP_CFLAGS $CFITSIO_CFLAGS])

AC_CONFIG_FILES([Makefile])
AC_OUTPUT
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/depcomp0000755000175000017500000005601613010376370023705 0ustar  zoncazonca00000000000000#! /bin/sh
# depcomp - compile a program generating dependencies as side-effects

scriptversion=2013-05-30.07; # UTC

# Copyright (C) 1999-2013 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

# Originally written by Alexandre Oliva .

case $1 in
  '')
    echo "$0: No command.  Try '$0 --help' for more information." 1>&2
    exit 1;
    ;;
  -h | --h*)
    cat <<\EOF
Usage: depcomp [--help] [--version] PROGRAM [ARGS]

Run PROGRAMS ARGS to compile a file, generating dependencies
as side-effects.

Environment variables:
  depmode     Dependency tracking mode.
  source      Source file read by 'PROGRAMS ARGS'.
  object      Object file output by 'PROGRAMS ARGS'.
  DEPDIR      directory where to store dependencies.
  depfile     Dependency file to output.
  tmpdepfile  Temporary file to use when outputting dependencies.
  libtool     Whether libtool is used (yes/no).

Report bugs to .
EOF
    exit $?
    ;;
  -v | --v*)
    echo "depcomp $scriptversion"
    exit $?
    ;;
esac

# Get the directory component of the given path, and save it in the
# global variables '$dir'.  Note that this directory component will
# be either empty or ending with a '/' character.  This is deliberate.
set_dir_from ()
{
  case $1 in
    */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
      *) dir=;;
  esac
}

# Get the suffix-stripped basename of the given path, and save it the
# global variable '$base'.
set_base_from ()
{
  base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
}

# If no dependency file was actually created by the compiler invocation,
# we still have to create a dummy depfile, to avoid errors with the
# Makefile "include basename.Plo" scheme.
make_dummy_depfile ()
{
  echo "#dummy" > "$depfile"
}

# Factor out some common post-processing of the generated depfile.
# Requires the auxiliary global variable '$tmpdepfile' to be set.
aix_post_process_depfile ()
{
  # If the compiler actually managed to produce a dependency file,
  # post-process it.
  if test -f "$tmpdepfile"; then
    # Each line is of the form 'foo.o: dependency.h'.
    # Do two passes, one to just change these to
    #   $object: dependency.h
    # and one to simply output
    #   dependency.h:
    # which is needed to avoid the deleted-header problem.
    { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
      sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
    } > "$depfile"
    rm -f "$tmpdepfile"
  else
    make_dummy_depfile
  fi
}

# A tabulation character.
tab='	'
# A newline character.
nl='
'
# Character ranges might be problematic outside the C locale.
# These definitions help.
upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
lower=abcdefghijklmnopqrstuvwxyz
digits=0123456789
alpha=${upper}${lower}

if test -z "$depmode" || test -z "$source" || test -z "$object"; then
  echo "depcomp: Variables source, object and depmode must be set" 1>&2
  exit 1
fi

# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
depfile=${depfile-`echo "$object" |
  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}

rm -f "$tmpdepfile"

# Avoid interferences from the environment.
gccflag= dashmflag=

# Some modes work just like other modes, but use different flags.  We
# parameterize here, but still list the modes in the big case below,
# to make depend.m4 easier to write.  Note that we *cannot* use a case
# here, because this file can only contain one case statement.
if test "$depmode" = hp; then
  # HP compiler uses -M and no extra arg.
  gccflag=-M
  depmode=gcc
fi

if test "$depmode" = dashXmstdout; then
  # This is just like dashmstdout with a different argument.
  dashmflag=-xM
  depmode=dashmstdout
fi

cygpath_u="cygpath -u -f -"
if test "$depmode" = msvcmsys; then
  # This is just like msvisualcpp but w/o cygpath translation.
  # Just convert the backslash-escaped backslashes to single forward
  # slashes to satisfy depend.m4
  cygpath_u='sed s,\\\\,/,g'
  depmode=msvisualcpp
fi

if test "$depmode" = msvc7msys; then
  # This is just like msvc7 but w/o cygpath translation.
  # Just convert the backslash-escaped backslashes to single forward
  # slashes to satisfy depend.m4
  cygpath_u='sed s,\\\\,/,g'
  depmode=msvc7
fi

if test "$depmode" = xlc; then
  # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
  gccflag=-qmakedep=gcc,-MF
  depmode=gcc
fi

case "$depmode" in
gcc3)
## gcc 3 implements dependency tracking that does exactly what
## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
## it if -MD -MP comes after the -MF stuff.  Hmm.
## Unfortunately, FreeBSD c89 acceptance of flags depends upon
## the command line argument order; so add the flags where they
## appear in depend2.am.  Note that the slowdown incurred here
## affects only configure: in makefiles, %FASTDEP% shortcuts this.
  for arg
  do
    case $arg in
    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
    *)  set fnord "$@" "$arg" ;;
    esac
    shift # fnord
    shift # $arg
  done
  "$@"
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  mv "$tmpdepfile" "$depfile"
  ;;

gcc)
## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
## (see the conditional assignment to $gccflag above).
## There are various ways to get dependency output from gcc.  Here's
## why we pick this rather obscure method:
## - Don't want to use -MD because we'd like the dependencies to end
##   up in a subdir.  Having to rename by hand is ugly.
##   (We might end up doing this anyway to support other compilers.)
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
##   -MM, not -M (despite what the docs say).  Also, it might not be
##   supported by the other compilers which use the 'gcc' depmode.
## - Using -M directly means running the compiler twice (even worse
##   than renaming).
  if test -z "$gccflag"; then
    gccflag=-MD,
  fi
  "$@" -Wp,"$gccflag$tmpdepfile"
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"
  echo "$object : \\" > "$depfile"
  # The second -e expression handles DOS-style file names with drive
  # letters.
  sed -e 's/^[^:]*: / /' \
      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
## This next piece of magic avoids the "deleted header file" problem.
## The problem is that when a header file which appears in a .P file
## is deleted, the dependency causes make to die (because there is
## typically no way to rebuild the header).  We avoid this by adding
## dummy dependencies for each header file.  Too bad gcc doesn't do
## this for us directly.
## Some versions of gcc put a space before the ':'.  On the theory
## that the space means something, we add a space to the output as
## well.  hp depmode also adds that space, but also prefixes the VPATH
## to the object.  Take care to not repeat it in the output.
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly.  Breaking it into two sed invocations is a workaround.
  tr ' ' "$nl" < "$tmpdepfile" \
    | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
    | sed -e 's/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

hp)
  # This case exists only to let depend.m4 do its work.  It works by
  # looking at the text of this script.  This case will never be run,
  # since it is checked for above.
  exit 1
  ;;

sgi)
  if test "$libtool" = yes; then
    "$@" "-Wp,-MDupdate,$tmpdepfile"
  else
    "$@" -MDupdate "$tmpdepfile"
  fi
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"

  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
    echo "$object : \\" > "$depfile"
    # Clip off the initial element (the dependent).  Don't try to be
    # clever and replace this with sed code, as IRIX sed won't handle
    # lines with more than a fixed number of characters (4096 in
    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
    # the IRIX cc adds comments like '#:fec' to the end of the
    # dependency line.
    tr ' ' "$nl" < "$tmpdepfile" \
      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
      | tr "$nl" ' ' >> "$depfile"
    echo >> "$depfile"
    # The second pass generates a dummy entry for each header file.
    tr ' ' "$nl" < "$tmpdepfile" \
      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
      >> "$depfile"
  else
    make_dummy_depfile
  fi
  rm -f "$tmpdepfile"
  ;;

xlc)
  # This case exists only to let depend.m4 do its work.  It works by
  # looking at the text of this script.  This case will never be run,
  # since it is checked for above.
  exit 1
  ;;

aix)
  # The C for AIX Compiler uses -M and outputs the dependencies
  # in a .u file.  In older versions, this file always lives in the
  # current directory.  Also, the AIX compiler puts '$object:' at the
  # start of each line; $object doesn't have directory information.
  # Version 6 uses the directory in both cases.
  set_dir_from "$object"
  set_base_from "$object"
  if test "$libtool" = yes; then
    tmpdepfile1=$dir$base.u
    tmpdepfile2=$base.u
    tmpdepfile3=$dir.libs/$base.u
    "$@" -Wc,-M
  else
    tmpdepfile1=$dir$base.u
    tmpdepfile2=$dir$base.u
    tmpdepfile3=$dir$base.u
    "$@" -M
  fi
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
    exit $stat
  fi

  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
  do
    test -f "$tmpdepfile" && break
  done
  aix_post_process_depfile
  ;;

tcc)
  # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
  # FIXME: That version still under development at the moment of writing.
  #        Make that this statement remains true also for stable, released
  #        versions.
  # It will wrap lines (doesn't matter whether long or short) with a
  # trailing '\', as in:
  #
  #   foo.o : \
  #    foo.c \
  #    foo.h \
  #
  # It will put a trailing '\' even on the last line, and will use leading
  # spaces rather than leading tabs (at least since its commit 0394caf7
  # "Emit spaces for -MD").
  "$@" -MD -MF "$tmpdepfile"
  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"
  # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
  # We have to change lines of the first kind to '$object: \'.
  sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
  # And for each line of the second kind, we have to emit a 'dep.h:'
  # dummy dependency, to avoid the deleted-header problem.
  sed -n -e 's|^  *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

## The order of this option in the case statement is important, since the
## shell code in configure will try each of these formats in the order
## listed in this file.  A plain '-MD' option would be understood by many
## compilers, so we must ensure this comes after the gcc and icc options.
pgcc)
  # Portland's C compiler understands '-MD'.
  # Will always output deps to 'file.d' where file is the root name of the
  # source file under compilation, even if file resides in a subdirectory.
  # The object file name does not affect the name of the '.d' file.
  # pgcc 10.2 will output
  #    foo.o: sub/foo.c sub/foo.h
  # and will wrap long lines using '\' :
  #    foo.o: sub/foo.c ... \
  #     sub/foo.h ... \
  #     ...
  set_dir_from "$object"
  # Use the source, not the object, to determine the base name, since
  # that's sadly what pgcc will do too.
  set_base_from "$source"
  tmpdepfile=$base.d

  # For projects that build the same source file twice into different object
  # files, the pgcc approach of using the *source* file root name can cause
  # problems in parallel builds.  Use a locking strategy to avoid stomping on
  # the same $tmpdepfile.
  lockdir=$base.d-lock
  trap "
    echo '$0: caught signal, cleaning up...' >&2
    rmdir '$lockdir'
    exit 1
  " 1 2 13 15
  numtries=100
  i=$numtries
  while test $i -gt 0; do
    # mkdir is a portable test-and-set.
    if mkdir "$lockdir" 2>/dev/null; then
      # This process acquired the lock.
      "$@" -MD
      stat=$?
      # Release the lock.
      rmdir "$lockdir"
      break
    else
      # If the lock is being held by a different process, wait
      # until the winning process is done or we timeout.
      while test -d "$lockdir" && test $i -gt 0; do
        sleep 1
        i=`expr $i - 1`
      done
    fi
    i=`expr $i - 1`
  done
  trap - 1 2 13 15
  if test $i -le 0; then
    echo "$0: failed to acquire lock after $numtries attempts" >&2
    echo "$0: check lockdir '$lockdir'" >&2
    exit 1
  fi

  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"
  # Each line is of the form `foo.o: dependent.h',
  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
  # Do two passes, one to just change these to
  # `$object: dependent.h' and one to simply `dependent.h:'.
  sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
  # Some versions of the HPUX 10.20 sed can't process this invocation
  # correctly.  Breaking it into two sed invocations is a workaround.
  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
    | sed -e 's/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

hp2)
  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
  # compilers, which have integrated preprocessors.  The correct option
  # to use with these is +Maked; it writes dependencies to a file named
  # 'foo.d', which lands next to the object file, wherever that
  # happens to be.
  # Much of this is similar to the tru64 case; see comments there.
  set_dir_from  "$object"
  set_base_from "$object"
  if test "$libtool" = yes; then
    tmpdepfile1=$dir$base.d
    tmpdepfile2=$dir.libs/$base.d
    "$@" -Wc,+Maked
  else
    tmpdepfile1=$dir$base.d
    tmpdepfile2=$dir$base.d
    "$@" +Maked
  fi
  stat=$?
  if test $stat -ne 0; then
     rm -f "$tmpdepfile1" "$tmpdepfile2"
     exit $stat
  fi

  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
  do
    test -f "$tmpdepfile" && break
  done
  if test -f "$tmpdepfile"; then
    sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
    # Add 'dependent.h:' lines.
    sed -ne '2,${
               s/^ *//
               s/ \\*$//
               s/$/:/
               p
             }' "$tmpdepfile" >> "$depfile"
  else
    make_dummy_depfile
  fi
  rm -f "$tmpdepfile" "$tmpdepfile2"
  ;;

tru64)
  # The Tru64 compiler uses -MD to generate dependencies as a side
  # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
  # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
  # dependencies in 'foo.d' instead, so we check for that too.
  # Subdirectories are respected.
  set_dir_from  "$object"
  set_base_from "$object"

  if test "$libtool" = yes; then
    # Libtool generates 2 separate objects for the 2 libraries.  These
    # two compilations output dependencies in $dir.libs/$base.o.d and
    # in $dir$base.o.d.  We have to check for both files, because
    # one of the two compilations can be disabled.  We should prefer
    # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
    # automatically cleaned when .libs/ is deleted, while ignoring
    # the former would cause a distcleancheck panic.
    tmpdepfile1=$dir$base.o.d          # libtool 1.5
    tmpdepfile2=$dir.libs/$base.o.d    # Likewise.
    tmpdepfile3=$dir.libs/$base.d      # Compaq CCC V6.2-504
    "$@" -Wc,-MD
  else
    tmpdepfile1=$dir$base.d
    tmpdepfile2=$dir$base.d
    tmpdepfile3=$dir$base.d
    "$@" -MD
  fi

  stat=$?
  if test $stat -ne 0; then
    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
    exit $stat
  fi

  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
  do
    test -f "$tmpdepfile" && break
  done
  # Same post-processing that is required for AIX mode.
  aix_post_process_depfile
  ;;

msvc7)
  if test "$libtool" = yes; then
    showIncludes=-Wc,-showIncludes
  else
    showIncludes=-showIncludes
  fi
  "$@" $showIncludes > "$tmpdepfile"
  stat=$?
  grep -v '^Note: including file: ' "$tmpdepfile"
  if test $stat -ne 0; then
    rm -f "$tmpdepfile"
    exit $stat
  fi
  rm -f "$depfile"
  echo "$object : \\" > "$depfile"
  # The first sed program below extracts the file names and escapes
  # backslashes for cygpath.  The second sed program outputs the file
  # name when reading, but also accumulates all include files in the
  # hold buffer in order to output them again at the end.  This only
  # works with sed implementations that can handle large buffers.
  sed < "$tmpdepfile" -n '
/^Note: including file:  *\(.*\)/ {
  s//\1/
  s/\\/\\\\/g
  p
}' | $cygpath_u | sort -u | sed -n '
s/ /\\ /g
s/\(.*\)/'"$tab"'\1 \\/p
s/.\(.*\) \\/\1:/
H
$ {
  s/.*/'"$tab"'/
  G
  p
}' >> "$depfile"
  echo >> "$depfile" # make sure the fragment doesn't end with a backslash
  rm -f "$tmpdepfile"
  ;;

msvc7msys)
  # This case exists only to let depend.m4 do its work.  It works by
  # looking at the text of this script.  This case will never be run,
  # since it is checked for above.
  exit 1
  ;;

#nosideeffect)
  # This comment above is used by automake to tell side-effect
  # dependency tracking mechanisms from slower ones.

dashmstdout)
  # Important note: in order to support this mode, a compiler *must*
  # always write the preprocessed file to stdout, regardless of -o.
  "$@" || exit $?

  # Remove the call to Libtool.
  if test "$libtool" = yes; then
    while test "X$1" != 'X--mode=compile'; do
      shift
    done
    shift
  fi

  # Remove '-o $object'.
  IFS=" "
  for arg
  do
    case $arg in
    -o)
      shift
      ;;
    $object)
      shift
      ;;
    *)
      set fnord "$@" "$arg"
      shift # fnord
      shift # $arg
      ;;
    esac
  done

  test -z "$dashmflag" && dashmflag=-M
  # Require at least two characters before searching for ':'
  # in the target name.  This is to cope with DOS-style filenames:
  # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
  "$@" $dashmflag |
    sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
  rm -f "$depfile"
  cat < "$tmpdepfile" > "$depfile"
  # Some versions of the HPUX 10.20 sed can't process this sed invocation
  # correctly.  Breaking it into two sed invocations is a workaround.
  tr ' ' "$nl" < "$tmpdepfile" \
    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
    | sed -e 's/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

dashXmstdout)
  # This case only exists to satisfy depend.m4.  It is never actually
  # run, as this mode is specially recognized in the preamble.
  exit 1
  ;;

makedepend)
  "$@" || exit $?
  # Remove any Libtool call
  if test "$libtool" = yes; then
    while test "X$1" != 'X--mode=compile'; do
      shift
    done
    shift
  fi
  # X makedepend
  shift
  cleared=no eat=no
  for arg
  do
    case $cleared in
    no)
      set ""; shift
      cleared=yes ;;
    esac
    if test $eat = yes; then
      eat=no
      continue
    fi
    case "$arg" in
    -D*|-I*)
      set fnord "$@" "$arg"; shift ;;
    # Strip any option that makedepend may not understand.  Remove
    # the object too, otherwise makedepend will parse it as a source file.
    -arch)
      eat=yes ;;
    -*|$object)
      ;;
    *)
      set fnord "$@" "$arg"; shift ;;
    esac
  done
  obj_suffix=`echo "$object" | sed 's/^.*\././'`
  touch "$tmpdepfile"
  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
  rm -f "$depfile"
  # makedepend may prepend the VPATH from the source file name to the object.
  # No need to regex-escape $object, excess matching of '.' is harmless.
  sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
  # Some versions of the HPUX 10.20 sed can't process the last invocation
  # correctly.  Breaking it into two sed invocations is a workaround.
  sed '1,2d' "$tmpdepfile" \
    | tr ' ' "$nl" \
    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
    | sed -e 's/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile" "$tmpdepfile".bak
  ;;

cpp)
  # Important note: in order to support this mode, a compiler *must*
  # always write the preprocessed file to stdout.
  "$@" || exit $?

  # Remove the call to Libtool.
  if test "$libtool" = yes; then
    while test "X$1" != 'X--mode=compile'; do
      shift
    done
    shift
  fi

  # Remove '-o $object'.
  IFS=" "
  for arg
  do
    case $arg in
    -o)
      shift
      ;;
    $object)
      shift
      ;;
    *)
      set fnord "$@" "$arg"
      shift # fnord
      shift # $arg
      ;;
    esac
  done

  "$@" -E \
    | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
             -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
    | sed '$ s: \\$::' > "$tmpdepfile"
  rm -f "$depfile"
  echo "$object : \\" > "$depfile"
  cat < "$tmpdepfile" >> "$depfile"
  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

msvisualcpp)
  # Important note: in order to support this mode, a compiler *must*
  # always write the preprocessed file to stdout.
  "$@" || exit $?

  # Remove the call to Libtool.
  if test "$libtool" = yes; then
    while test "X$1" != 'X--mode=compile'; do
      shift
    done
    shift
  fi

  IFS=" "
  for arg
  do
    case "$arg" in
    -o)
      shift
      ;;
    $object)
      shift
      ;;
    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
        set fnord "$@"
        shift
        shift
        ;;
    *)
        set fnord "$@" "$arg"
        shift
        shift
        ;;
    esac
  done
  "$@" -E 2>/dev/null |
  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
  rm -f "$depfile"
  echo "$object : \\" > "$depfile"
  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
  echo "$tab" >> "$depfile"
  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
  rm -f "$tmpdepfile"
  ;;

msvcmsys)
  # This case exists only to let depend.m4 do its work.  It works by
  # looking at the text of this script.  This case will never be run,
  # since it is checked for above.
  exit 1
  ;;

none)
  exec "$@"
  ;;

*)
  echo "Unknown depmode $depmode" 1>&2
  exit 1
  ;;
esac

exit 0

# Local Variables:
# mode: shell-script
# sh-indentation: 2
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End:
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/install-sh0000755000175000017500000003325513010376370024334 0ustar  zoncazonca00000000000000#!/bin/sh
# install - install a program, script, or datafile

scriptversion=2011-11-20.07; # UTC

# This originates from X11R5 (mit/util/scripts/install.sh), which was
# later released in X11R6 (xc/config/util/install.sh) with the
# following copyright and license.
#
# Copyright (C) 1994 X Consortium
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to
# deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# sell copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Except as contained in this notice, the name of the X Consortium shall not
# be used in advertising or otherwise to promote the sale, use or other deal-
# ings in this Software without prior written authorization from the X Consor-
# tium.
#
#
# FSF changes to this file are in the public domain.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# 'make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch.

nl='
'
IFS=" ""	$nl"

# set DOITPROG to echo to test this script

# Don't use :- since 4.3BSD and earlier shells don't like it.
doit=${DOITPROG-}
if test -z "$doit"; then
  doit_exec=exec
else
  doit_exec=$doit
fi

# Put in absolute file names if you don't have them in your path;
# or use environment vars.

chgrpprog=${CHGRPPROG-chgrp}
chmodprog=${CHMODPROG-chmod}
chownprog=${CHOWNPROG-chown}
cmpprog=${CMPPROG-cmp}
cpprog=${CPPROG-cp}
mkdirprog=${MKDIRPROG-mkdir}
mvprog=${MVPROG-mv}
rmprog=${RMPROG-rm}
stripprog=${STRIPPROG-strip}

posix_glob='?'
initialize_posix_glob='
  test "$posix_glob" != "?" || {
    if (set -f) 2>/dev/null; then
      posix_glob=
    else
      posix_glob=:
    fi
  }
'

posix_mkdir=

# Desired mode of installed file.
mode=0755

chgrpcmd=
chmodcmd=$chmodprog
chowncmd=
mvcmd=$mvprog
rmcmd="$rmprog -f"
stripcmd=

src=
dst=
dir_arg=
dst_arg=

copy_on_change=false
no_target_directory=

usage="\
Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
   or: $0 [OPTION]... SRCFILES... DIRECTORY
   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
   or: $0 [OPTION]... -d DIRECTORIES...

In the 1st form, copy SRCFILE to DSTFILE.
In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
In the 4th, create DIRECTORIES.

Options:
     --help     display this help and exit.
     --version  display version info and exit.

  -c            (ignored)
  -C            install only if different (preserve the last data modification time)
  -d            create directories instead of installing files.
  -g GROUP      $chgrpprog installed files to GROUP.
  -m MODE       $chmodprog installed files to MODE.
  -o USER       $chownprog installed files to USER.
  -s            $stripprog installed files.
  -t DIRECTORY  install into DIRECTORY.
  -T            report an error if DSTFILE is a directory.

Environment variables override the default commands:
  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
  RMPROG STRIPPROG
"

while test $# -ne 0; do
  case $1 in
    -c) ;;

    -C) copy_on_change=true;;

    -d) dir_arg=true;;

    -g) chgrpcmd="$chgrpprog $2"
	shift;;

    --help) echo "$usage"; exit $?;;

    -m) mode=$2
	case $mode in
	  *' '* | *'	'* | *'
'*	  | *'*'* | *'?'* | *'['*)
	    echo "$0: invalid mode: $mode" >&2
	    exit 1;;
	esac
	shift;;

    -o) chowncmd="$chownprog $2"
	shift;;

    -s) stripcmd=$stripprog;;

    -t) dst_arg=$2
	# Protect names problematic for 'test' and other utilities.
	case $dst_arg in
	  -* | [=\(\)!]) dst_arg=./$dst_arg;;
	esac
	shift;;

    -T) no_target_directory=true;;

    --version) echo "$0 $scriptversion"; exit $?;;

    --)	shift
	break;;

    -*)	echo "$0: invalid option: $1" >&2
	exit 1;;

    *)  break;;
  esac
  shift
done

if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
  # When -d is used, all remaining arguments are directories to create.
  # When -t is used, the destination is already specified.
  # Otherwise, the last argument is the destination.  Remove it from $@.
  for arg
  do
    if test -n "$dst_arg"; then
      # $@ is not empty: it contains at least $arg.
      set fnord "$@" "$dst_arg"
      shift # fnord
    fi
    shift # arg
    dst_arg=$arg
    # Protect names problematic for 'test' and other utilities.
    case $dst_arg in
      -* | [=\(\)!]) dst_arg=./$dst_arg;;
    esac
  done
fi

if test $# -eq 0; then
  if test -z "$dir_arg"; then
    echo "$0: no input file specified." >&2
    exit 1
  fi
  # It's OK to call 'install-sh -d' without argument.
  # This can happen when creating conditional directories.
  exit 0
fi

if test -z "$dir_arg"; then
  do_exit='(exit $ret); exit $ret'
  trap "ret=129; $do_exit" 1
  trap "ret=130; $do_exit" 2
  trap "ret=141; $do_exit" 13
  trap "ret=143; $do_exit" 15

  # Set umask so as not to create temps with too-generous modes.
  # However, 'strip' requires both read and write access to temps.
  case $mode in
    # Optimize common cases.
    *644) cp_umask=133;;
    *755) cp_umask=22;;

    *[0-7])
      if test -z "$stripcmd"; then
	u_plus_rw=
      else
	u_plus_rw='% 200'
      fi
      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
    *)
      if test -z "$stripcmd"; then
	u_plus_rw=
      else
	u_plus_rw=,u+rw
      fi
      cp_umask=$mode$u_plus_rw;;
  esac
fi

for src
do
  # Protect names problematic for 'test' and other utilities.
  case $src in
    -* | [=\(\)!]) src=./$src;;
  esac

  if test -n "$dir_arg"; then
    dst=$src
    dstdir=$dst
    test -d "$dstdir"
    dstdir_status=$?
  else

    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
    # might cause directories to be created, which would be especially bad
    # if $src (and thus $dsttmp) contains '*'.
    if test ! -f "$src" && test ! -d "$src"; then
      echo "$0: $src does not exist." >&2
      exit 1
    fi

    if test -z "$dst_arg"; then
      echo "$0: no destination specified." >&2
      exit 1
    fi
    dst=$dst_arg

    # If destination is a directory, append the input filename; won't work
    # if double slashes aren't ignored.
    if test -d "$dst"; then
      if test -n "$no_target_directory"; then
	echo "$0: $dst_arg: Is a directory" >&2
	exit 1
      fi
      dstdir=$dst
      dst=$dstdir/`basename "$src"`
      dstdir_status=0
    else
      # Prefer dirname, but fall back on a substitute if dirname fails.
      dstdir=`
	(dirname "$dst") 2>/dev/null ||
	expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	     X"$dst" : 'X\(//\)[^/]' \| \
	     X"$dst" : 'X\(//\)$' \| \
	     X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
	echo X"$dst" |
	    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
		   s//\1/
		   q
		 }
		 /^X\(\/\/\)[^/].*/{
		   s//\1/
		   q
		 }
		 /^X\(\/\/\)$/{
		   s//\1/
		   q
		 }
		 /^X\(\/\).*/{
		   s//\1/
		   q
		 }
		 s/.*/./; q'
      `

      test -d "$dstdir"
      dstdir_status=$?
    fi
  fi

  obsolete_mkdir_used=false

  if test $dstdir_status != 0; then
    case $posix_mkdir in
      '')
	# Create intermediate dirs using mode 755 as modified by the umask.
	# This is like FreeBSD 'install' as of 1997-10-28.
	umask=`umask`
	case $stripcmd.$umask in
	  # Optimize common cases.
	  *[2367][2367]) mkdir_umask=$umask;;
	  .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;

	  *[0-7])
	    mkdir_umask=`expr $umask + 22 \
	      - $umask % 100 % 40 + $umask % 20 \
	      - $umask % 10 % 4 + $umask % 2
	    `;;
	  *) mkdir_umask=$umask,go-w;;
	esac

	# With -d, create the new directory with the user-specified mode.
	# Otherwise, rely on $mkdir_umask.
	if test -n "$dir_arg"; then
	  mkdir_mode=-m$mode
	else
	  mkdir_mode=
	fi

	posix_mkdir=false
	case $umask in
	  *[123567][0-7][0-7])
	    # POSIX mkdir -p sets u+wx bits regardless of umask, which
	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
	    ;;
	  *)
	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0

	    if (umask $mkdir_umask &&
		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
	    then
	      if test -z "$dir_arg" || {
		   # Check for POSIX incompatibilities with -m.
		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
		   # other-writable bit of parent directory when it shouldn't.
		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
		   ls_ld_tmpdir=`ls -ld "$tmpdir"`
		   case $ls_ld_tmpdir in
		     d????-?r-*) different_mode=700;;
		     d????-?--*) different_mode=755;;
		     *) false;;
		   esac &&
		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
		   }
		 }
	      then posix_mkdir=:
	      fi
	      rmdir "$tmpdir/d" "$tmpdir"
	    else
	      # Remove any dirs left behind by ancient mkdir implementations.
	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
	    fi
	    trap '' 0;;
	esac;;
    esac

    if
      $posix_mkdir && (
	umask $mkdir_umask &&
	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
      )
    then :
    else

      # The umask is ridiculous, or mkdir does not conform to POSIX,
      # or it failed possibly due to a race condition.  Create the
      # directory the slow way, step by step, checking for races as we go.

      case $dstdir in
	/*) prefix='/';;
	[-=\(\)!]*) prefix='./';;
	*)  prefix='';;
      esac

      eval "$initialize_posix_glob"

      oIFS=$IFS
      IFS=/
      $posix_glob set -f
      set fnord $dstdir
      shift
      $posix_glob set +f
      IFS=$oIFS

      prefixes=

      for d
      do
	test X"$d" = X && continue

	prefix=$prefix$d
	if test -d "$prefix"; then
	  prefixes=
	else
	  if $posix_mkdir; then
	    (umask=$mkdir_umask &&
	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
	    # Don't fail if two instances are running concurrently.
	    test -d "$prefix" || exit 1
	  else
	    case $prefix in
	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
	      *) qprefix=$prefix;;
	    esac
	    prefixes="$prefixes '$qprefix'"
	  fi
	fi
	prefix=$prefix/
      done

      if test -n "$prefixes"; then
	# Don't fail if two instances are running concurrently.
	(umask $mkdir_umask &&
	 eval "\$doit_exec \$mkdirprog $prefixes") ||
	  test -d "$dstdir" || exit 1
	obsolete_mkdir_used=true
      fi
    fi
  fi

  if test -n "$dir_arg"; then
    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
  else

    # Make a couple of temp file names in the proper directory.
    dsttmp=$dstdir/_inst.$$_
    rmtmp=$dstdir/_rm.$$_

    # Trap to clean up those temp files at exit.
    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0

    # Copy the file name to the temp name.
    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&

    # and set any options; do chmod last to preserve setuid bits.
    #
    # If any of these fail, we abort the whole thing.  If we want to
    # ignore errors from any of these, just make sure not to ignore
    # errors from the above "$doit $cpprog $src $dsttmp" command.
    #
    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&

    # If -C, don't bother to copy if it wouldn't change the file.
    if $copy_on_change &&
       old=`LC_ALL=C ls -dlL "$dst"	2>/dev/null` &&
       new=`LC_ALL=C ls -dlL "$dsttmp"	2>/dev/null` &&

       eval "$initialize_posix_glob" &&
       $posix_glob set -f &&
       set X $old && old=:$2:$4:$5:$6 &&
       set X $new && new=:$2:$4:$5:$6 &&
       $posix_glob set +f &&

       test "$old" = "$new" &&
       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
    then
      rm -f "$dsttmp"
    else
      # Rename the file to the real destination.
      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||

      # The rename failed, perhaps because mv can't rename something else
      # to itself, or perhaps because mv is so ancient that it does not
      # support -f.
      {
	# Now remove or move aside any old file at destination location.
	# We try this two ways since rm can't unlink itself on some
	# systems and the destination file might be busy for other
	# reasons.  In this case, the final cleanup might fail but the new
	# file should still install successfully.
	{
	  test ! -f "$dst" ||
	  $doit $rmcmd -f "$dst" 2>/dev/null ||
	  { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
	    { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
	  } ||
	  { echo "$0: cannot unlink or rename $dst" >&2
	    (exit 1); exit 1
	  }
	} &&

	# Now rename the file to the real destination.
	$doit $mvcmd "$dsttmp" "$dst"
      }
    fi || exit 1

    trap '' 0
  fi
done

# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End:
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/ltmain.sh0000644000175000017500000105152213010376362024147 0ustar  zoncazonca00000000000000
# libtool (GNU libtool) 2.4.2
# Written by Gordon Matzigkeit , 1996

# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
# This is free software; see the source for copying conditions.  There is NO
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

# GNU Libtool is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# As a special exception to the GNU General Public License,
# if you distribute this file as part of a program or library that
# is built using GNU Libtool, you may include this file under the
# same distribution terms that you use for the rest of that program.
#
# GNU Libtool is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Libtool; see the file COPYING.  If not, a copy
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
# or obtained by writing to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

# Usage: $progname [OPTION]... [MODE-ARG]...
#
# Provide generalized library-building support services.
#
#       --config             show all configuration variables
#       --debug              enable verbose shell tracing
#   -n, --dry-run            display commands without modifying any files
#       --features           display basic configuration information and exit
#       --mode=MODE          use operation mode MODE
#       --preserve-dup-deps  don't remove duplicate dependency libraries
#       --quiet, --silent    don't print informational messages
#       --no-quiet, --no-silent
#                            print informational messages (default)
#       --no-warn            don't display warning messages
#       --tag=TAG            use configuration variables from tag TAG
#   -v, --verbose            print more informational messages than default
#       --no-verbose         don't print the extra informational messages
#       --version            print version information
#   -h, --help, --help-all   print short, long, or detailed help message
#
# MODE must be one of the following:
#
#         clean              remove files from the build directory
#         compile            compile a source file into a libtool object
#         execute            automatically set library path, then run a program
#         finish             complete the installation of libtool libraries
#         install            install libraries or executables
#         link               create a library or an executable
#         uninstall          remove libraries from an installed directory
#
# MODE-ARGS vary depending on the MODE.  When passed as first option,
# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
#
# When reporting a bug, please describe a test case to reproduce it and
# include the following information:
#
#         host-triplet:	$host
#         shell:		$SHELL
#         compiler:		$LTCC
#         compiler flags:		$LTCFLAGS
#         linker:		$LD (gnu? $with_gnu_ld)
#         $progname:	(GNU libtool) 2.4.2
#         automake:	$automake_version
#         autoconf:	$autoconf_version
#
# Report bugs to .
# GNU libtool home page: .
# General help using GNU software: .

PROGRAM=libtool
PACKAGE=libtool
VERSION=2.4.2
TIMESTAMP=""
package_revision=1.3337

# Be Bourne compatible
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
fi
BIN_SH=xpg4; export BIN_SH # for Tru64
DUALCASE=1; export DUALCASE # for MKS sh

# A function that is used when there is no print builtin or printf.
func_fallback_echo ()
{
  eval 'cat <<_LTECHO_EOF
$1
_LTECHO_EOF'
}

# NLS nuisances: We save the old values to restore during execute mode.
lt_user_locale=
lt_safe_locale=
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
do
  eval "if test \"\${$lt_var+set}\" = set; then
          save_$lt_var=\$$lt_var
          $lt_var=C
	  export $lt_var
	  lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
	  lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
	fi"
done
LC_ALL=C
LANGUAGE=C
export LANGUAGE LC_ALL

$lt_unset CDPATH


# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
# is ksh but when the shell is invoked as "sh" and the current value of
# the _XPG environment variable is not equal to 1 (one), the special
# positional parameter $0, within a function call, is the name of the
# function.
progpath="$0"



: ${CP="cp -f"}
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
: ${MAKE="make"}
: ${MKDIR="mkdir"}
: ${MV="mv -f"}
: ${RM="rm -f"}
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
: ${Xsed="$SED -e 1s/^X//"}

# Global variables:
EXIT_SUCCESS=0
EXIT_FAILURE=1
EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.

exit_status=$EXIT_SUCCESS

# Make sure IFS has a sensible default
lt_nl='
'
IFS=" 	$lt_nl"

dirname="s,/[^/]*$,,"
basename="s,^.*/,,"

# func_dirname file append nondir_replacement
# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
# otherwise set result to NONDIR_REPLACEMENT.
func_dirname ()
{
    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
    if test "X$func_dirname_result" = "X${1}"; then
      func_dirname_result="${3}"
    else
      func_dirname_result="$func_dirname_result${2}"
    fi
} # func_dirname may be replaced by extended shell implementation


# func_basename file
func_basename ()
{
    func_basename_result=`$ECHO "${1}" | $SED "$basename"`
} # func_basename may be replaced by extended shell implementation


# func_dirname_and_basename file append nondir_replacement
# perform func_basename and func_dirname in a single function
# call:
#   dirname:  Compute the dirname of FILE.  If nonempty,
#             add APPEND to the result, otherwise set result
#             to NONDIR_REPLACEMENT.
#             value returned in "$func_dirname_result"
#   basename: Compute filename of FILE.
#             value retuned in "$func_basename_result"
# Implementation must be kept synchronized with func_dirname
# and func_basename. For efficiency, we do not delegate to
# those functions but instead duplicate the functionality here.
func_dirname_and_basename ()
{
    # Extract subdirectory from the argument.
    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
    if test "X$func_dirname_result" = "X${1}"; then
      func_dirname_result="${3}"
    else
      func_dirname_result="$func_dirname_result${2}"
    fi
    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
} # func_dirname_and_basename may be replaced by extended shell implementation


# func_stripname prefix suffix name
# strip PREFIX and SUFFIX off of NAME.
# PREFIX and SUFFIX must not contain globbing or regex special
# characters, hashes, percent signs, but SUFFIX may contain a leading
# dot (in which case that matches only a dot).
# func_strip_suffix prefix name
func_stripname ()
{
    case ${2} in
      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
    esac
} # func_stripname may be replaced by extended shell implementation


# These SED scripts presuppose an absolute path with a trailing slash.
pathcar='s,^/\([^/]*\).*$,\1,'
pathcdr='s,^/[^/]*,,'
removedotparts=':dotsl
		s@/\./@/@g
		t dotsl
		s,/\.$,/,'
collapseslashes='s@/\{1,\}@/@g'
finalslash='s,/*$,/,'

# func_normal_abspath PATH
# Remove doubled-up and trailing slashes, "." path components,
# and cancel out any ".." path components in PATH after making
# it an absolute path.
#             value returned in "$func_normal_abspath_result"
func_normal_abspath ()
{
  # Start from root dir and reassemble the path.
  func_normal_abspath_result=
  func_normal_abspath_tpath=$1
  func_normal_abspath_altnamespace=
  case $func_normal_abspath_tpath in
    "")
      # Empty path, that just means $cwd.
      func_stripname '' '/' "`pwd`"
      func_normal_abspath_result=$func_stripname_result
      return
    ;;
    # The next three entries are used to spot a run of precisely
    # two leading slashes without using negated character classes;
    # we take advantage of case's first-match behaviour.
    ///*)
      # Unusual form of absolute path, do nothing.
    ;;
    //*)
      # Not necessarily an ordinary path; POSIX reserves leading '//'
      # and for example Cygwin uses it to access remote file shares
      # over CIFS/SMB, so we conserve a leading double slash if found.
      func_normal_abspath_altnamespace=/
    ;;
    /*)
      # Absolute path, do nothing.
    ;;
    *)
      # Relative path, prepend $cwd.
      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
    ;;
  esac
  # Cancel out all the simple stuff to save iterations.  We also want
  # the path to end with a slash for ease of parsing, so make sure
  # there is one (and only one) here.
  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
  while :; do
    # Processed it all yet?
    if test "$func_normal_abspath_tpath" = / ; then
      # If we ascended to the root using ".." the result may be empty now.
      if test -z "$func_normal_abspath_result" ; then
        func_normal_abspath_result=/
      fi
      break
    fi
    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
        -e "$pathcar"`
    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
        -e "$pathcdr"`
    # Figure out what to do with it
    case $func_normal_abspath_tcomponent in
      "")
        # Trailing empty path component, ignore it.
      ;;
      ..)
        # Parent dir; strip last assembled component from result.
        func_dirname "$func_normal_abspath_result"
        func_normal_abspath_result=$func_dirname_result
      ;;
      *)
        # Actual path component, append it.
        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
      ;;
    esac
  done
  # Restore leading double-slash if one was found on entry.
  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
}

# func_relative_path SRCDIR DSTDIR
# generates a relative path from SRCDIR to DSTDIR, with a trailing
# slash if non-empty, suitable for immediately appending a filename
# without needing to append a separator.
#             value returned in "$func_relative_path_result"
func_relative_path ()
{
  func_relative_path_result=
  func_normal_abspath "$1"
  func_relative_path_tlibdir=$func_normal_abspath_result
  func_normal_abspath "$2"
  func_relative_path_tbindir=$func_normal_abspath_result

  # Ascend the tree starting from libdir
  while :; do
    # check if we have found a prefix of bindir
    case $func_relative_path_tbindir in
      $func_relative_path_tlibdir)
        # found an exact match
        func_relative_path_tcancelled=
        break
        ;;
      $func_relative_path_tlibdir*)
        # found a matching prefix
        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
        func_relative_path_tcancelled=$func_stripname_result
        if test -z "$func_relative_path_result"; then
          func_relative_path_result=.
        fi
        break
        ;;
      *)
        func_dirname $func_relative_path_tlibdir
        func_relative_path_tlibdir=${func_dirname_result}
        if test "x$func_relative_path_tlibdir" = x ; then
          # Have to descend all the way to the root!
          func_relative_path_result=../$func_relative_path_result
          func_relative_path_tcancelled=$func_relative_path_tbindir
          break
        fi
        func_relative_path_result=../$func_relative_path_result
        ;;
    esac
  done

  # Now calculate path; take care to avoid doubling-up slashes.
  func_stripname '' '/' "$func_relative_path_result"
  func_relative_path_result=$func_stripname_result
  func_stripname '/' '/' "$func_relative_path_tcancelled"
  if test "x$func_stripname_result" != x ; then
    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
  fi

  # Normalisation. If bindir is libdir, return empty string,
  # else relative path ending with a slash; either way, target
  # file name can be directly appended.
  if test ! -z "$func_relative_path_result"; then
    func_stripname './' '' "$func_relative_path_result/"
    func_relative_path_result=$func_stripname_result
  fi
}

# The name of this program:
func_dirname_and_basename "$progpath"
progname=$func_basename_result

# Make sure we have an absolute path for reexecution:
case $progpath in
  [\\/]*|[A-Za-z]:\\*) ;;
  *[\\/]*)
     progdir=$func_dirname_result
     progdir=`cd "$progdir" && pwd`
     progpath="$progdir/$progname"
     ;;
  *)
     save_IFS="$IFS"
     IFS=${PATH_SEPARATOR-:}
     for progdir in $PATH; do
       IFS="$save_IFS"
       test -x "$progdir/$progname" && break
     done
     IFS="$save_IFS"
     test -n "$progdir" || progdir=`pwd`
     progpath="$progdir/$progname"
     ;;
esac

# Sed substitution that helps us do robust quoting.  It backslashifies
# metacharacters that are still active within double-quoted strings.
Xsed="${SED}"' -e 1s/^X//'
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'

# Same as above, but do not quote variable references.
double_quote_subst='s/\(["`\\]\)/\\\1/g'

# Sed substitution that turns a string into a regex matching for the
# string literally.
sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'

# Sed substitution that converts a w32 file name or path
# which contains forward slashes, into one that contains
# (escaped) backslashes.  A very naive implementation.
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'

# Re-`\' parameter expansions in output of double_quote_subst that were
# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
# in input to double_quote_subst, that '$' was protected from expansion.
# Since each input `\' is now two `\'s, look for any number of runs of
# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
bs='\\'
bs2='\\\\'
bs4='\\\\\\\\'
dollar='\$'
sed_double_backslash="\
  s/$bs4/&\\
/g
  s/^$bs2$dollar/$bs&/
  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
  s/\n//g"

# Standard options:
opt_dry_run=false
opt_help=false
opt_quiet=false
opt_verbose=false
opt_warning=:

# func_echo arg...
# Echo program name prefixed message, along with the current mode
# name if it has been set yet.
func_echo ()
{
    $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
}

# func_verbose arg...
# Echo program name prefixed message in verbose mode only.
func_verbose ()
{
    $opt_verbose && func_echo ${1+"$@"}

    # A bug in bash halts the script if the last line of a function
    # fails when set -e is in force, so we need another command to
    # work around that:
    :
}

# func_echo_all arg...
# Invoke $ECHO with all args, space-separated.
func_echo_all ()
{
    $ECHO "$*"
}

# func_error arg...
# Echo program name prefixed message to standard error.
func_error ()
{
    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
}

# func_warning arg...
# Echo program name prefixed warning message to standard error.
func_warning ()
{
    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2

    # bash bug again:
    :
}

# func_fatal_error arg...
# Echo program name prefixed message to standard error, and exit.
func_fatal_error ()
{
    func_error ${1+"$@"}
    exit $EXIT_FAILURE
}

# func_fatal_help arg...
# Echo program name prefixed message to standard error, followed by
# a help hint, and exit.
func_fatal_help ()
{
    func_error ${1+"$@"}
    func_fatal_error "$help"
}
help="Try \`$progname --help' for more information."  ## default


# func_grep expression filename
# Check whether EXPRESSION matches any line of FILENAME, without output.
func_grep ()
{
    $GREP "$1" "$2" >/dev/null 2>&1
}


# func_mkdir_p directory-path
# Make sure the entire path to DIRECTORY-PATH is available.
func_mkdir_p ()
{
    my_directory_path="$1"
    my_dir_list=

    if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then

      # Protect directory names starting with `-'
      case $my_directory_path in
        -*) my_directory_path="./$my_directory_path" ;;
      esac

      # While some portion of DIR does not yet exist...
      while test ! -d "$my_directory_path"; do
        # ...make a list in topmost first order.  Use a colon delimited
	# list incase some portion of path contains whitespace.
        my_dir_list="$my_directory_path:$my_dir_list"

        # If the last portion added has no slash in it, the list is done
        case $my_directory_path in */*) ;; *) break ;; esac

        # ...otherwise throw away the child directory and loop
        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
      done
      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`

      save_mkdir_p_IFS="$IFS"; IFS=':'
      for my_dir in $my_dir_list; do
	IFS="$save_mkdir_p_IFS"
        # mkdir can fail with a `File exist' error if two processes
        # try to create one of the directories concurrently.  Don't
        # stop in that case!
        $MKDIR "$my_dir" 2>/dev/null || :
      done
      IFS="$save_mkdir_p_IFS"

      # Bail out if we (or some other process) failed to create a directory.
      test -d "$my_directory_path" || \
        func_fatal_error "Failed to create \`$1'"
    fi
}


# func_mktempdir [string]
# Make a temporary directory that won't clash with other running
# libtool processes, and avoids race conditions if possible.  If
# given, STRING is the basename for that directory.
func_mktempdir ()
{
    my_template="${TMPDIR-/tmp}/${1-$progname}"

    if test "$opt_dry_run" = ":"; then
      # Return a directory name, but don't create it in dry-run mode
      my_tmpdir="${my_template}-$$"
    else

      # If mktemp works, use that first and foremost
      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`

      if test ! -d "$my_tmpdir"; then
        # Failing that, at least try and use $RANDOM to avoid a race
        my_tmpdir="${my_template}-${RANDOM-0}$$"

        save_mktempdir_umask=`umask`
        umask 0077
        $MKDIR "$my_tmpdir"
        umask $save_mktempdir_umask
      fi

      # If we're not in dry-run mode, bomb out on failure
      test -d "$my_tmpdir" || \
        func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
    fi

    $ECHO "$my_tmpdir"
}


# func_quote_for_eval arg
# Aesthetically quote ARG to be evaled later.
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
# is double-quoted, suitable for a subsequent eval, whereas
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
# which are still active within double quotes backslashified.
func_quote_for_eval ()
{
    case $1 in
      *[\\\`\"\$]*)
	func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
      *)
        func_quote_for_eval_unquoted_result="$1" ;;
    esac

    case $func_quote_for_eval_unquoted_result in
      # Double-quote args containing shell metacharacters to delay
      # word splitting, command substitution and and variable
      # expansion for a subsequent eval.
      # Many Bourne shells cannot handle close brackets correctly
      # in scan sets, so we specify it separately.
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
        func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
        ;;
      *)
        func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
    esac
}


# func_quote_for_expand arg
# Aesthetically quote ARG to be evaled later; same as above,
# but do not quote variable references.
func_quote_for_expand ()
{
    case $1 in
      *[\\\`\"]*)
	my_arg=`$ECHO "$1" | $SED \
	    -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
      *)
        my_arg="$1" ;;
    esac

    case $my_arg in
      # Double-quote args containing shell metacharacters to delay
      # word splitting and command substitution for a subsequent eval.
      # Many Bourne shells cannot handle close brackets correctly
      # in scan sets, so we specify it separately.
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
        my_arg="\"$my_arg\""
        ;;
    esac

    func_quote_for_expand_result="$my_arg"
}


# func_show_eval cmd [fail_exp]
# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
# is given, then evaluate it.
func_show_eval ()
{
    my_cmd="$1"
    my_fail_exp="${2-:}"

    ${opt_silent-false} || {
      func_quote_for_expand "$my_cmd"
      eval "func_echo $func_quote_for_expand_result"
    }

    if ${opt_dry_run-false}; then :; else
      eval "$my_cmd"
      my_status=$?
      if test "$my_status" -eq 0; then :; else
	eval "(exit $my_status); $my_fail_exp"
      fi
    fi
}


# func_show_eval_locale cmd [fail_exp]
# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
# is given, then evaluate it.  Use the saved locale for evaluation.
func_show_eval_locale ()
{
    my_cmd="$1"
    my_fail_exp="${2-:}"

    ${opt_silent-false} || {
      func_quote_for_expand "$my_cmd"
      eval "func_echo $func_quote_for_expand_result"
    }

    if ${opt_dry_run-false}; then :; else
      eval "$lt_user_locale
	    $my_cmd"
      my_status=$?
      eval "$lt_safe_locale"
      if test "$my_status" -eq 0; then :; else
	eval "(exit $my_status); $my_fail_exp"
      fi
    fi
}

# func_tr_sh
# Turn $1 into a string suitable for a shell variable name.
# Result is stored in $func_tr_sh_result.  All characters
# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
# if $1 begins with a digit, a '_' is prepended as well.
func_tr_sh ()
{
  case $1 in
  [0-9]* | *[!a-zA-Z0-9_]*)
    func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
    ;;
  * )
    func_tr_sh_result=$1
    ;;
  esac
}


# func_version
# Echo version message to standard output and exit.
func_version ()
{
    $opt_debug

    $SED -n '/(C)/!b go
	:more
	/\./!{
	  N
	  s/\n# / /
	  b more
	}
	:go
	/^# '$PROGRAM' (GNU /,/# warranty; / {
        s/^# //
	s/^# *$//
        s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
        p
     }' < "$progpath"
     exit $?
}

# func_usage
# Echo short help message to standard output and exit.
func_usage ()
{
    $opt_debug

    $SED -n '/^# Usage:/,/^#  *.*--help/ {
        s/^# //
	s/^# *$//
	s/\$progname/'$progname'/
	p
    }' < "$progpath"
    echo
    $ECHO "run \`$progname --help | more' for full usage"
    exit $?
}

# func_help [NOEXIT]
# Echo long help message to standard output and exit,
# unless 'noexit' is passed as argument.
func_help ()
{
    $opt_debug

    $SED -n '/^# Usage:/,/# Report bugs to/ {
	:print
        s/^# //
	s/^# *$//
	s*\$progname*'$progname'*
	s*\$host*'"$host"'*
	s*\$SHELL*'"$SHELL"'*
	s*\$LTCC*'"$LTCC"'*
	s*\$LTCFLAGS*'"$LTCFLAGS"'*
	s*\$LD*'"$LD"'*
	s/\$with_gnu_ld/'"$with_gnu_ld"'/
	s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
	s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
	p
	d
     }
     /^# .* home page:/b print
     /^# General help using/b print
     ' < "$progpath"
    ret=$?
    if test -z "$1"; then
      exit $ret
    fi
}

# func_missing_arg argname
# Echo program name prefixed message to standard error and set global
# exit_cmd.
func_missing_arg ()
{
    $opt_debug

    func_error "missing argument for $1."
    exit_cmd=exit
}


# func_split_short_opt shortopt
# Set func_split_short_opt_name and func_split_short_opt_arg shell
# variables after splitting SHORTOPT after the 2nd character.
func_split_short_opt ()
{
    my_sed_short_opt='1s/^\(..\).*$/\1/;q'
    my_sed_short_rest='1s/^..\(.*\)$/\1/;q'

    func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
    func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
} # func_split_short_opt may be replaced by extended shell implementation


# func_split_long_opt longopt
# Set func_split_long_opt_name and func_split_long_opt_arg shell
# variables after splitting LONGOPT at the `=' sign.
func_split_long_opt ()
{
    my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
    my_sed_long_arg='1s/^--[^=]*=//'

    func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
    func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
} # func_split_long_opt may be replaced by extended shell implementation

exit_cmd=:





magic="%%%MAGIC variable%%%"
magic_exe="%%%MAGIC EXE variable%%%"

# Global variables.
nonopt=
preserve_args=
lo2o="s/\\.lo\$/.${objext}/"
o2lo="s/\\.${objext}\$/.lo/"
extracted_archives=
extracted_serial=0

# If this variable is set in any of the actions, the command in it
# will be execed at the end.  This prevents here-documents from being
# left over by shells.
exec_cmd=

# func_append var value
# Append VALUE to the end of shell variable VAR.
func_append ()
{
    eval "${1}=\$${1}\${2}"
} # func_append may be replaced by extended shell implementation

# func_append_quoted var value
# Quote VALUE and append to the end of shell variable VAR, separated
# by a space.
func_append_quoted ()
{
    func_quote_for_eval "${2}"
    eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
} # func_append_quoted may be replaced by extended shell implementation


# func_arith arithmetic-term...
func_arith ()
{
    func_arith_result=`expr "${@}"`
} # func_arith may be replaced by extended shell implementation


# func_len string
# STRING may not start with a hyphen.
func_len ()
{
    func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
} # func_len may be replaced by extended shell implementation


# func_lo2o object
func_lo2o ()
{
    func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
} # func_lo2o may be replaced by extended shell implementation


# func_xform libobj-or-source
func_xform ()
{
    func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
} # func_xform may be replaced by extended shell implementation


# func_fatal_configuration arg...
# Echo program name prefixed message to standard error, followed by
# a configuration failure hint, and exit.
func_fatal_configuration ()
{
    func_error ${1+"$@"}
    func_error "See the $PACKAGE documentation for more information."
    func_fatal_error "Fatal configuration error."
}


# func_config
# Display the configuration for all the tags in this script.
func_config ()
{
    re_begincf='^# ### BEGIN LIBTOOL'
    re_endcf='^# ### END LIBTOOL'

    # Default configuration.
    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"

    # Now print the configurations for the tags.
    for tagname in $taglist; do
      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
    done

    exit $?
}

# func_features
# Display the features supported by this script.
func_features ()
{
    echo "host: $host"
    if test "$build_libtool_libs" = yes; then
      echo "enable shared libraries"
    else
      echo "disable shared libraries"
    fi
    if test "$build_old_libs" = yes; then
      echo "enable static libraries"
    else
      echo "disable static libraries"
    fi

    exit $?
}

# func_enable_tag tagname
# Verify that TAGNAME is valid, and either flag an error and exit, or
# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
# variable here.
func_enable_tag ()
{
  # Global variable:
  tagname="$1"

  re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
  re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
  sed_extractcf="/$re_begincf/,/$re_endcf/p"

  # Validate tagname.
  case $tagname in
    *[!-_A-Za-z0-9,/]*)
      func_fatal_error "invalid tag name: $tagname"
      ;;
  esac

  # Don't test for the "default" C tag, as we know it's
  # there but not specially marked.
  case $tagname in
    CC) ;;
    *)
      if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
	taglist="$taglist $tagname"

	# Evaluate the configuration.  Be careful to quote the path
	# and the sed script, to avoid splitting on whitespace, but
	# also don't use non-portable quotes within backquotes within
	# quotes we have to do it in 2 steps:
	extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
	eval "$extractedcf"
      else
	func_error "ignoring unknown tag $tagname"
      fi
      ;;
  esac
}

# func_check_version_match
# Ensure that we are using m4 macros, and libtool script from the same
# release of libtool.
func_check_version_match ()
{
  if test "$package_revision" != "$macro_revision"; then
    if test "$VERSION" != "$macro_version"; then
      if test -z "$macro_version"; then
        cat >&2 <<_LT_EOF
$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
$progname: definition of this LT_INIT comes from an older release.
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
$progname: and run autoconf again.
_LT_EOF
      else
        cat >&2 <<_LT_EOF
$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
$progname: and run autoconf again.
_LT_EOF
      fi
    else
      cat >&2 <<_LT_EOF
$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
$progname: of $PACKAGE $VERSION and run autoconf again.
_LT_EOF
    fi

    exit $EXIT_MISMATCH
  fi
}


# Shorthand for --mode=foo, only valid as the first argument
case $1 in
clean|clea|cle|cl)
  shift; set dummy --mode clean ${1+"$@"}; shift
  ;;
compile|compil|compi|comp|com|co|c)
  shift; set dummy --mode compile ${1+"$@"}; shift
  ;;
execute|execut|execu|exec|exe|ex|e)
  shift; set dummy --mode execute ${1+"$@"}; shift
  ;;
finish|finis|fini|fin|fi|f)
  shift; set dummy --mode finish ${1+"$@"}; shift
  ;;
install|instal|insta|inst|ins|in|i)
  shift; set dummy --mode install ${1+"$@"}; shift
  ;;
link|lin|li|l)
  shift; set dummy --mode link ${1+"$@"}; shift
  ;;
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
  shift; set dummy --mode uninstall ${1+"$@"}; shift
  ;;
esac



# Option defaults:
opt_debug=:
opt_dry_run=false
opt_config=false
opt_preserve_dup_deps=false
opt_features=false
opt_finish=false
opt_help=false
opt_help_all=false
opt_silent=:
opt_warning=:
opt_verbose=:
opt_silent=false
opt_verbose=false


# Parse options once, thoroughly.  This comes as soon as possible in the
# script to make things like `--version' happen as quickly as we can.
{
  # this just eases exit handling
  while test $# -gt 0; do
    opt="$1"
    shift
    case $opt in
      --debug|-x)	opt_debug='set -x'
			func_echo "enabling shell trace mode"
			$opt_debug
			;;
      --dry-run|--dryrun|-n)
			opt_dry_run=:
			;;
      --config)
			opt_config=:
func_config
			;;
      --dlopen|-dlopen)
			optarg="$1"
			opt_dlopen="${opt_dlopen+$opt_dlopen
}$optarg"
			shift
			;;
      --preserve-dup-deps)
			opt_preserve_dup_deps=:
			;;
      --features)
			opt_features=:
func_features
			;;
      --finish)
			opt_finish=:
set dummy --mode finish ${1+"$@"}; shift
			;;
      --help)
			opt_help=:
			;;
      --help-all)
			opt_help_all=:
opt_help=': help-all'
			;;
      --mode)
			test $# = 0 && func_missing_arg $opt && break
			optarg="$1"
			opt_mode="$optarg"
case $optarg in
  # Valid mode arguments:
  clean|compile|execute|finish|install|link|relink|uninstall) ;;

  # Catch anything else as an error
  *) func_error "invalid argument for $opt"
     exit_cmd=exit
     break
     ;;
esac
			shift
			;;
      --no-silent|--no-quiet)
			opt_silent=false
func_append preserve_args " $opt"
			;;
      --no-warning|--no-warn)
			opt_warning=false
func_append preserve_args " $opt"
			;;
      --no-verbose)
			opt_verbose=false
func_append preserve_args " $opt"
			;;
      --silent|--quiet)
			opt_silent=:
func_append preserve_args " $opt"
        opt_verbose=false
			;;
      --verbose|-v)
			opt_verbose=:
func_append preserve_args " $opt"
opt_silent=false
			;;
      --tag)
			test $# = 0 && func_missing_arg $opt && break
			optarg="$1"
			opt_tag="$optarg"
func_append preserve_args " $opt $optarg"
func_enable_tag "$optarg"
			shift
			;;

      -\?|-h)		func_usage				;;
      --help)		func_help				;;
      --version)	func_version				;;

      # Separate optargs to long options:
      --*=*)
			func_split_long_opt "$opt"
			set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
			shift
			;;

      # Separate non-argument short options:
      -\?*|-h*|-n*|-v*)
			func_split_short_opt "$opt"
			set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
			shift
			;;

      --)		break					;;
      -*)		func_fatal_help "unrecognized option \`$opt'" ;;
      *)		set dummy "$opt" ${1+"$@"};	shift; break  ;;
    esac
  done

  # Validate options:

  # save first non-option argument
  if test "$#" -gt 0; then
    nonopt="$opt"
    shift
  fi

  # preserve --debug
  test "$opt_debug" = : || func_append preserve_args " --debug"

  case $host in
    *cygwin* | *mingw* | *pw32* | *cegcc*)
      # don't eliminate duplications in $postdeps and $predeps
      opt_duplicate_compiler_generated_deps=:
      ;;
    *)
      opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
      ;;
  esac

  $opt_help || {
    # Sanity checks first:
    func_check_version_match

    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
      func_fatal_configuration "not configured to build any kind of library"
    fi

    # Darwin sucks
    eval std_shrext=\"$shrext_cmds\"

    # Only execute mode is allowed to have -dlopen flags.
    if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
      func_error "unrecognized option \`-dlopen'"
      $ECHO "$help" 1>&2
      exit $EXIT_FAILURE
    fi

    # Change the help message to a mode-specific one.
    generic_help="$help"
    help="Try \`$progname --help --mode=$opt_mode' for more information."
  }


  # Bail if the options were screwed
  $exit_cmd $EXIT_FAILURE
}




## ----------- ##
##    Main.    ##
## ----------- ##

# func_lalib_p file
# True iff FILE is a libtool `.la' library or `.lo' object file.
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
func_lalib_p ()
{
    test -f "$1" &&
      $SED -e 4q "$1" 2>/dev/null \
        | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
}

# func_lalib_unsafe_p file
# True iff FILE is a libtool `.la' library or `.lo' object file.
# This function implements the same check as func_lalib_p without
# resorting to external programs.  To this end, it redirects stdin and
# closes it afterwards, without saving the original file descriptor.
# As a safety measure, use it only where a negative result would be
# fatal anyway.  Works if `file' does not exist.
func_lalib_unsafe_p ()
{
    lalib_p=no
    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
	for lalib_p_l in 1 2 3 4
	do
	    read lalib_p_line
	    case "$lalib_p_line" in
		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
	    esac
	done
	exec 0<&5 5<&-
    fi
    test "$lalib_p" = yes
}

# func_ltwrapper_script_p file
# True iff FILE is a libtool wrapper script
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
func_ltwrapper_script_p ()
{
    func_lalib_p "$1"
}

# func_ltwrapper_executable_p file
# True iff FILE is a libtool wrapper executable
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
func_ltwrapper_executable_p ()
{
    func_ltwrapper_exec_suffix=
    case $1 in
    *.exe) ;;
    *) func_ltwrapper_exec_suffix=.exe ;;
    esac
    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
}

# func_ltwrapper_scriptname file
# Assumes file is an ltwrapper_executable
# uses $file to determine the appropriate filename for a
# temporary ltwrapper_script.
func_ltwrapper_scriptname ()
{
    func_dirname_and_basename "$1" "" "."
    func_stripname '' '.exe' "$func_basename_result"
    func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
}

# func_ltwrapper_p file
# True iff FILE is a libtool wrapper script or wrapper executable
# This function is only a basic sanity check; it will hardly flush out
# determined imposters.
func_ltwrapper_p ()
{
    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
}


# func_execute_cmds commands fail_cmd
# Execute tilde-delimited COMMANDS.
# If FAIL_CMD is given, eval that upon failure.
# FAIL_CMD may read-access the current command in variable CMD!
func_execute_cmds ()
{
    $opt_debug
    save_ifs=$IFS; IFS='~'
    for cmd in $1; do
      IFS=$save_ifs
      eval cmd=\"$cmd\"
      func_show_eval "$cmd" "${2-:}"
    done
    IFS=$save_ifs
}


# func_source file
# Source FILE, adding directory component if necessary.
# Note that it is not necessary on cygwin/mingw to append a dot to
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
# behavior happens only for exec(3), not for open(2)!  Also, sourcing
# `FILE.' does not work on cygwin managed mounts.
func_source ()
{
    $opt_debug
    case $1 in
    */* | *\\*)	. "$1" ;;
    *)		. "./$1" ;;
    esac
}


# func_resolve_sysroot PATH
# Replace a leading = in PATH with a sysroot.  Store the result into
# func_resolve_sysroot_result
func_resolve_sysroot ()
{
  func_resolve_sysroot_result=$1
  case $func_resolve_sysroot_result in
  =*)
    func_stripname '=' '' "$func_resolve_sysroot_result"
    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
    ;;
  esac
}

# func_replace_sysroot PATH
# If PATH begins with the sysroot, replace it with = and
# store the result into func_replace_sysroot_result.
func_replace_sysroot ()
{
  case "$lt_sysroot:$1" in
  ?*:"$lt_sysroot"*)
    func_stripname "$lt_sysroot" '' "$1"
    func_replace_sysroot_result="=$func_stripname_result"
    ;;
  *)
    # Including no sysroot.
    func_replace_sysroot_result=$1
    ;;
  esac
}

# func_infer_tag arg
# Infer tagged configuration to use if any are available and
# if one wasn't chosen via the "--tag" command line option.
# Only attempt this if the compiler in the base compile
# command doesn't match the default compiler.
# arg is usually of the form 'gcc ...'
func_infer_tag ()
{
    $opt_debug
    if test -n "$available_tags" && test -z "$tagname"; then
      CC_quoted=
      for arg in $CC; do
	func_append_quoted CC_quoted "$arg"
      done
      CC_expanded=`func_echo_all $CC`
      CC_quoted_expanded=`func_echo_all $CC_quoted`
      case $@ in
      # Blanks in the command may have been stripped by the calling shell,
      # but not from the CC environment variable when configure was run.
      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
      # Blanks at the start of $base_compile will cause this to fail
      # if we don't check for them as well.
      *)
	for z in $available_tags; do
	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
	    # Evaluate the configuration.
	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
	    CC_quoted=
	    for arg in $CC; do
	      # Double-quote args containing other shell metacharacters.
	      func_append_quoted CC_quoted "$arg"
	    done
	    CC_expanded=`func_echo_all $CC`
	    CC_quoted_expanded=`func_echo_all $CC_quoted`
	    case "$@ " in
	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
	      # The compiler in the base compile command matches
	      # the one in the tagged configuration.
	      # Assume this is the tagged configuration we want.
	      tagname=$z
	      break
	      ;;
	    esac
	  fi
	done
	# If $tagname still isn't set, then no tagged configuration
	# was found and let the user know that the "--tag" command
	# line option must be used.
	if test -z "$tagname"; then
	  func_echo "unable to infer tagged configuration"
	  func_fatal_error "specify a tag with \`--tag'"
#	else
#	  func_verbose "using $tagname tagged configuration"
	fi
	;;
      esac
    fi
}



# func_write_libtool_object output_name pic_name nonpic_name
# Create a libtool object file (analogous to a ".la" file),
# but don't create it if we're doing a dry run.
func_write_libtool_object ()
{
    write_libobj=${1}
    if test "$build_libtool_libs" = yes; then
      write_lobj=\'${2}\'
    else
      write_lobj=none
    fi

    if test "$build_old_libs" = yes; then
      write_oldobj=\'${3}\'
    else
      write_oldobj=none
    fi

    $opt_dry_run || {
      cat >${write_libobj}T </dev/null`
    if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
        $SED -e "$lt_sed_naive_backslashify"`
    else
      func_convert_core_file_wine_to_w32_result=
    fi
  fi
}
# end: func_convert_core_file_wine_to_w32


# func_convert_core_path_wine_to_w32 ARG
# Helper function used by path conversion functions when $build is *nix, and
# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
# configured wine environment available, with the winepath program in $build's
# $PATH. Assumes ARG has no leading or trailing path separator characters.
#
# ARG is path to be converted from $build format to win32.
# Result is available in $func_convert_core_path_wine_to_w32_result.
# Unconvertible file (directory) names in ARG are skipped; if no directory names
# are convertible, then the result may be empty.
func_convert_core_path_wine_to_w32 ()
{
  $opt_debug
  # unfortunately, winepath doesn't convert paths, only file names
  func_convert_core_path_wine_to_w32_result=""
  if test -n "$1"; then
    oldIFS=$IFS
    IFS=:
    for func_convert_core_path_wine_to_w32_f in $1; do
      IFS=$oldIFS
      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
      if test -n "$func_convert_core_file_wine_to_w32_result" ; then
        if test -z "$func_convert_core_path_wine_to_w32_result"; then
          func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
        else
          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
        fi
      fi
    done
    IFS=$oldIFS
  fi
}
# end: func_convert_core_path_wine_to_w32


# func_cygpath ARGS...
# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
# (2), returns the Cygwin file name or path in func_cygpath_result (input
# file name or path is assumed to be in w32 format, as previously converted
# from $build's *nix or MSYS format). In case (3), returns the w32 file name
# or path in func_cygpath_result (input file name or path is assumed to be in
# Cygwin format). Returns an empty string on error.
#
# ARGS are passed to cygpath, with the last one being the file name or path to
# be converted.
#
# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
# environment variable; do not put it in $PATH.
func_cygpath ()
{
  $opt_debug
  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
    if test "$?" -ne 0; then
      # on failure, ensure result is empty
      func_cygpath_result=
    fi
  else
    func_cygpath_result=
    func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
  fi
}
#end: func_cygpath


# func_convert_core_msys_to_w32 ARG
# Convert file name or path ARG from MSYS format to w32 format.  Return
# result in func_convert_core_msys_to_w32_result.
func_convert_core_msys_to_w32 ()
{
  $opt_debug
  # awkward: cmd appends spaces to result
  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
    $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
}
#end: func_convert_core_msys_to_w32


# func_convert_file_check ARG1 ARG2
# Verify that ARG1 (a file name in $build format) was converted to $host
# format in ARG2. Otherwise, emit an error message, but continue (resetting
# func_to_host_file_result to ARG1).
func_convert_file_check ()
{
  $opt_debug
  if test -z "$2" && test -n "$1" ; then
    func_error "Could not determine host file name corresponding to"
    func_error "  \`$1'"
    func_error "Continuing, but uninstalled executables may not work."
    # Fallback:
    func_to_host_file_result="$1"
  fi
}
# end func_convert_file_check


# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
# Verify that FROM_PATH (a path in $build format) was converted to $host
# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
# func_to_host_file_result to a simplistic fallback value (see below).
func_convert_path_check ()
{
  $opt_debug
  if test -z "$4" && test -n "$3"; then
    func_error "Could not determine the host path corresponding to"
    func_error "  \`$3'"
    func_error "Continuing, but uninstalled executables may not work."
    # Fallback.  This is a deliberately simplistic "conversion" and
    # should not be "improved".  See libtool.info.
    if test "x$1" != "x$2"; then
      lt_replace_pathsep_chars="s|$1|$2|g"
      func_to_host_path_result=`echo "$3" |
        $SED -e "$lt_replace_pathsep_chars"`
    else
      func_to_host_path_result="$3"
    fi
  fi
}
# end func_convert_path_check


# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
# and appending REPL if ORIG matches BACKPAT.
func_convert_path_front_back_pathsep ()
{
  $opt_debug
  case $4 in
  $1 ) func_to_host_path_result="$3$func_to_host_path_result"
    ;;
  esac
  case $4 in
  $2 ) func_append func_to_host_path_result "$3"
    ;;
  esac
}
# end func_convert_path_front_back_pathsep


##################################################
# $build to $host FILE NAME CONVERSION FUNCTIONS #
##################################################
# invoked via `$to_host_file_cmd ARG'
#
# In each case, ARG is the path to be converted from $build to $host format.
# Result will be available in $func_to_host_file_result.


# func_to_host_file ARG
# Converts the file name ARG from $build format to $host format. Return result
# in func_to_host_file_result.
func_to_host_file ()
{
  $opt_debug
  $to_host_file_cmd "$1"
}
# end func_to_host_file


# func_to_tool_file ARG LAZY
# converts the file name ARG from $build format to toolchain format. Return
# result in func_to_tool_file_result.  If the conversion in use is listed
# in (the comma separated) LAZY, no conversion takes place.
func_to_tool_file ()
{
  $opt_debug
  case ,$2, in
    *,"$to_tool_file_cmd",*)
      func_to_tool_file_result=$1
      ;;
    *)
      $to_tool_file_cmd "$1"
      func_to_tool_file_result=$func_to_host_file_result
      ;;
  esac
}
# end func_to_tool_file


# func_convert_file_noop ARG
# Copy ARG to func_to_host_file_result.
func_convert_file_noop ()
{
  func_to_host_file_result="$1"
}
# end func_convert_file_noop


# func_convert_file_msys_to_w32 ARG
# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
# conversion to w32 is not available inside the cwrapper.  Returns result in
# func_to_host_file_result.
func_convert_file_msys_to_w32 ()
{
  $opt_debug
  func_to_host_file_result="$1"
  if test -n "$1"; then
    func_convert_core_msys_to_w32 "$1"
    func_to_host_file_result="$func_convert_core_msys_to_w32_result"
  fi
  func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_msys_to_w32


# func_convert_file_cygwin_to_w32 ARG
# Convert file name ARG from Cygwin to w32 format.  Returns result in
# func_to_host_file_result.
func_convert_file_cygwin_to_w32 ()
{
  $opt_debug
  func_to_host_file_result="$1"
  if test -n "$1"; then
    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
    # LT_CYGPATH in this case.
    func_to_host_file_result=`cygpath -m "$1"`
  fi
  func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_cygwin_to_w32


# func_convert_file_nix_to_w32 ARG
# Convert file name ARG from *nix to w32 format.  Requires a wine environment
# and a working winepath. Returns result in func_to_host_file_result.
func_convert_file_nix_to_w32 ()
{
  $opt_debug
  func_to_host_file_result="$1"
  if test -n "$1"; then
    func_convert_core_file_wine_to_w32 "$1"
    func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
  fi
  func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_nix_to_w32


# func_convert_file_msys_to_cygwin ARG
# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
# Returns result in func_to_host_file_result.
func_convert_file_msys_to_cygwin ()
{
  $opt_debug
  func_to_host_file_result="$1"
  if test -n "$1"; then
    func_convert_core_msys_to_w32 "$1"
    func_cygpath -u "$func_convert_core_msys_to_w32_result"
    func_to_host_file_result="$func_cygpath_result"
  fi
  func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_msys_to_cygwin


# func_convert_file_nix_to_cygwin ARG
# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
# in func_to_host_file_result.
func_convert_file_nix_to_cygwin ()
{
  $opt_debug
  func_to_host_file_result="$1"
  if test -n "$1"; then
    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
    func_convert_core_file_wine_to_w32 "$1"
    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
    func_to_host_file_result="$func_cygpath_result"
  fi
  func_convert_file_check "$1" "$func_to_host_file_result"
}
# end func_convert_file_nix_to_cygwin


#############################################
# $build to $host PATH CONVERSION FUNCTIONS #
#############################################
# invoked via `$to_host_path_cmd ARG'
#
# In each case, ARG is the path to be converted from $build to $host format.
# The result will be available in $func_to_host_path_result.
#
# Path separators are also converted from $build format to $host format.  If
# ARG begins or ends with a path separator character, it is preserved (but
# converted to $host format) on output.
#
# All path conversion functions are named using the following convention:
#   file name conversion function    : func_convert_file_X_to_Y ()
#   path conversion function         : func_convert_path_X_to_Y ()
# where, for any given $build/$host combination the 'X_to_Y' value is the
# same.  If conversion functions are added for new $build/$host combinations,
# the two new functions must follow this pattern, or func_init_to_host_path_cmd
# will break.


# func_init_to_host_path_cmd
# Ensures that function "pointer" variable $to_host_path_cmd is set to the
# appropriate value, based on the value of $to_host_file_cmd.
to_host_path_cmd=
func_init_to_host_path_cmd ()
{
  $opt_debug
  if test -z "$to_host_path_cmd"; then
    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
    to_host_path_cmd="func_convert_path_${func_stripname_result}"
  fi
}


# func_to_host_path ARG
# Converts the path ARG from $build format to $host format. Return result
# in func_to_host_path_result.
func_to_host_path ()
{
  $opt_debug
  func_init_to_host_path_cmd
  $to_host_path_cmd "$1"
}
# end func_to_host_path


# func_convert_path_noop ARG
# Copy ARG to func_to_host_path_result.
func_convert_path_noop ()
{
  func_to_host_path_result="$1"
}
# end func_convert_path_noop


# func_convert_path_msys_to_w32 ARG
# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
# conversion to w32 is not available inside the cwrapper.  Returns result in
# func_to_host_path_result.
func_convert_path_msys_to_w32 ()
{
  $opt_debug
  func_to_host_path_result="$1"
  if test -n "$1"; then
    # Remove leading and trailing path separator characters from ARG.  MSYS
    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
    # and winepath ignores them completely.
    func_stripname : : "$1"
    func_to_host_path_tmp1=$func_stripname_result
    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
    func_to_host_path_result="$func_convert_core_msys_to_w32_result"
    func_convert_path_check : ";" \
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
  fi
}
# end func_convert_path_msys_to_w32


# func_convert_path_cygwin_to_w32 ARG
# Convert path ARG from Cygwin to w32 format.  Returns result in
# func_to_host_file_result.
func_convert_path_cygwin_to_w32 ()
{
  $opt_debug
  func_to_host_path_result="$1"
  if test -n "$1"; then
    # See func_convert_path_msys_to_w32:
    func_stripname : : "$1"
    func_to_host_path_tmp1=$func_stripname_result
    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
    func_convert_path_check : ";" \
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
  fi
}
# end func_convert_path_cygwin_to_w32


# func_convert_path_nix_to_w32 ARG
# Convert path ARG from *nix to w32 format.  Requires a wine environment and
# a working winepath.  Returns result in func_to_host_file_result.
func_convert_path_nix_to_w32 ()
{
  $opt_debug
  func_to_host_path_result="$1"
  if test -n "$1"; then
    # See func_convert_path_msys_to_w32:
    func_stripname : : "$1"
    func_to_host_path_tmp1=$func_stripname_result
    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
    func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
    func_convert_path_check : ";" \
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
  fi
}
# end func_convert_path_nix_to_w32


# func_convert_path_msys_to_cygwin ARG
# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
# Returns result in func_to_host_file_result.
func_convert_path_msys_to_cygwin ()
{
  $opt_debug
  func_to_host_path_result="$1"
  if test -n "$1"; then
    # See func_convert_path_msys_to_w32:
    func_stripname : : "$1"
    func_to_host_path_tmp1=$func_stripname_result
    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
    func_to_host_path_result="$func_cygpath_result"
    func_convert_path_check : : \
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
  fi
}
# end func_convert_path_msys_to_cygwin


# func_convert_path_nix_to_cygwin ARG
# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
# func_to_host_file_result.
func_convert_path_nix_to_cygwin ()
{
  $opt_debug
  func_to_host_path_result="$1"
  if test -n "$1"; then
    # Remove leading and trailing path separator characters from
    # ARG. msys behavior is inconsistent here, cygpath turns them
    # into '.;' and ';.', and winepath ignores them completely.
    func_stripname : : "$1"
    func_to_host_path_tmp1=$func_stripname_result
    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
    func_to_host_path_result="$func_cygpath_result"
    func_convert_path_check : : \
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
  fi
}
# end func_convert_path_nix_to_cygwin


# func_mode_compile arg...
func_mode_compile ()
{
    $opt_debug
    # Get the compilation command and the source file.
    base_compile=
    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
    suppress_opt=yes
    suppress_output=
    arg_mode=normal
    libobj=
    later=
    pie_flag=

    for arg
    do
      case $arg_mode in
      arg  )
	# do not "continue".  Instead, add this to base_compile
	lastarg="$arg"
	arg_mode=normal
	;;

      target )
	libobj="$arg"
	arg_mode=normal
	continue
	;;

      normal )
	# Accept any command-line options.
	case $arg in
	-o)
	  test -n "$libobj" && \
	    func_fatal_error "you cannot specify \`-o' more than once"
	  arg_mode=target
	  continue
	  ;;

	-pie | -fpie | -fPIE)
          func_append pie_flag " $arg"
	  continue
	  ;;

	-shared | -static | -prefer-pic | -prefer-non-pic)
	  func_append later " $arg"
	  continue
	  ;;

	-no-suppress)
	  suppress_opt=no
	  continue
	  ;;

	-Xcompiler)
	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
	  continue      #  The current "srcfile" will either be retained or
	  ;;            #  replaced later.  I would guess that would be a bug.

	-Wc,*)
	  func_stripname '-Wc,' '' "$arg"
	  args=$func_stripname_result
	  lastarg=
	  save_ifs="$IFS"; IFS=','
	  for arg in $args; do
	    IFS="$save_ifs"
	    func_append_quoted lastarg "$arg"
	  done
	  IFS="$save_ifs"
	  func_stripname ' ' '' "$lastarg"
	  lastarg=$func_stripname_result

	  # Add the arguments to base_compile.
	  func_append base_compile " $lastarg"
	  continue
	  ;;

	*)
	  # Accept the current argument as the source file.
	  # The previous "srcfile" becomes the current argument.
	  #
	  lastarg="$srcfile"
	  srcfile="$arg"
	  ;;
	esac  #  case $arg
	;;
      esac    #  case $arg_mode

      # Aesthetically quote the previous argument.
      func_append_quoted base_compile "$lastarg"
    done # for arg

    case $arg_mode in
    arg)
      func_fatal_error "you must specify an argument for -Xcompile"
      ;;
    target)
      func_fatal_error "you must specify a target with \`-o'"
      ;;
    *)
      # Get the name of the library object.
      test -z "$libobj" && {
	func_basename "$srcfile"
	libobj="$func_basename_result"
      }
      ;;
    esac

    # Recognize several different file suffixes.
    # If the user specifies -o file.o, it is replaced with file.lo
    case $libobj in
    *.[cCFSifmso] | \
    *.ada | *.adb | *.ads | *.asm | \
    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
    *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
      func_xform "$libobj"
      libobj=$func_xform_result
      ;;
    esac

    case $libobj in
    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
    *)
      func_fatal_error "cannot determine name of library object from \`$libobj'"
      ;;
    esac

    func_infer_tag $base_compile

    for arg in $later; do
      case $arg in
      -shared)
	test "$build_libtool_libs" != yes && \
	  func_fatal_configuration "can not build a shared library"
	build_old_libs=no
	continue
	;;

      -static)
	build_libtool_libs=no
	build_old_libs=yes
	continue
	;;

      -prefer-pic)
	pic_mode=yes
	continue
	;;

      -prefer-non-pic)
	pic_mode=no
	continue
	;;
      esac
    done

    func_quote_for_eval "$libobj"
    test "X$libobj" != "X$func_quote_for_eval_result" \
      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'	 &()|`$[]' \
      && func_warning "libobj name \`$libobj' may not contain shell special characters."
    func_dirname_and_basename "$obj" "/" ""
    objname="$func_basename_result"
    xdir="$func_dirname_result"
    lobj=${xdir}$objdir/$objname

    test -z "$base_compile" && \
      func_fatal_help "you must specify a compilation command"

    # Delete any leftover library objects.
    if test "$build_old_libs" = yes; then
      removelist="$obj $lobj $libobj ${libobj}T"
    else
      removelist="$lobj $libobj ${libobj}T"
    fi

    # On Cygwin there's no "real" PIC flag so we must build both object types
    case $host_os in
    cygwin* | mingw* | pw32* | os2* | cegcc*)
      pic_mode=default
      ;;
    esac
    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
      # non-PIC code in shared libraries is not supported
      pic_mode=default
    fi

    # Calculate the filename of the output object if compiler does
    # not support -o with -c
    if test "$compiler_c_o" = no; then
      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
      lockfile="$output_obj.lock"
    else
      output_obj=
      need_locks=no
      lockfile=
    fi

    # Lock this critical section if it is needed
    # We use this script file to make the link, it avoids creating a new file
    if test "$need_locks" = yes; then
      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
	func_echo "Waiting for $lockfile to be removed"
	sleep 2
      done
    elif test "$need_locks" = warn; then
      if test -f "$lockfile"; then
	$ECHO "\
*** ERROR, $lockfile exists and contains:
`cat $lockfile 2>/dev/null`

This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."

	$opt_dry_run || $RM $removelist
	exit $EXIT_FAILURE
      fi
      func_append removelist " $output_obj"
      $ECHO "$srcfile" > "$lockfile"
    fi

    $opt_dry_run || $RM $removelist
    func_append removelist " $lockfile"
    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15

    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
    srcfile=$func_to_tool_file_result
    func_quote_for_eval "$srcfile"
    qsrcfile=$func_quote_for_eval_result

    # Only build a PIC object if we are building libtool libraries.
    if test "$build_libtool_libs" = yes; then
      # Without this assignment, base_compile gets emptied.
      fbsd_hideous_sh_bug=$base_compile

      if test "$pic_mode" != no; then
	command="$base_compile $qsrcfile $pic_flag"
      else
	# Don't build PIC code
	command="$base_compile $qsrcfile"
      fi

      func_mkdir_p "$xdir$objdir"

      if test -z "$output_obj"; then
	# Place PIC objects in $objdir
	func_append command " -o $lobj"
      fi

      func_show_eval_locale "$command"	\
          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'

      if test "$need_locks" = warn &&
	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
	$ECHO "\
*** ERROR, $lockfile contains:
`cat $lockfile 2>/dev/null`

but it should contain:
$srcfile

This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."

	$opt_dry_run || $RM $removelist
	exit $EXIT_FAILURE
      fi

      # Just move the object if needed, then go on to compile the next one
      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
	func_show_eval '$MV "$output_obj" "$lobj"' \
	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
      fi

      # Allow error messages only from the first compilation.
      if test "$suppress_opt" = yes; then
	suppress_output=' >/dev/null 2>&1'
      fi
    fi

    # Only build a position-dependent object if we build old libraries.
    if test "$build_old_libs" = yes; then
      if test "$pic_mode" != yes; then
	# Don't build PIC code
	command="$base_compile $qsrcfile$pie_flag"
      else
	command="$base_compile $qsrcfile $pic_flag"
      fi
      if test "$compiler_c_o" = yes; then
	func_append command " -o $obj"
      fi

      # Suppress compiler output if we already did a PIC compilation.
      func_append command "$suppress_output"
      func_show_eval_locale "$command" \
        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'

      if test "$need_locks" = warn &&
	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
	$ECHO "\
*** ERROR, $lockfile contains:
`cat $lockfile 2>/dev/null`

but it should contain:
$srcfile

This indicates that another process is trying to use the same
temporary object file, and libtool could not work around it because
your compiler does not support \`-c' and \`-o' together.  If you
repeat this compilation, it may succeed, by chance, but you had better
avoid parallel builds (make -j) in this platform, or get a better
compiler."

	$opt_dry_run || $RM $removelist
	exit $EXIT_FAILURE
      fi

      # Just move the object if needed
      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
	func_show_eval '$MV "$output_obj" "$obj"' \
	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
      fi
    fi

    $opt_dry_run || {
      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"

      # Unlock the critical section if it was locked
      if test "$need_locks" != no; then
	removelist=$lockfile
        $RM "$lockfile"
      fi
    }

    exit $EXIT_SUCCESS
}

$opt_help || {
  test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
}

func_mode_help ()
{
    # We need to display help for each of the modes.
    case $opt_mode in
      "")
        # Generic help is extracted from the usage comments
        # at the start of this file.
        func_help
        ;;

      clean)
        $ECHO \
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...

Remove files from the build directory.

RM is the name of the program to use to delete files associated with each FILE
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
to RM.

If FILE is a libtool library, object or program, all the files associated
with it are deleted. Otherwise, only FILE itself is deleted using RM."
        ;;

      compile)
      $ECHO \
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE

Compile a source file into a libtool library object.

This mode accepts the following additional options:

  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
  -no-suppress      do not suppress compiler output for multiple passes
  -prefer-pic       try to build PIC objects only
  -prefer-non-pic   try to build non-PIC objects only
  -shared           do not build a \`.o' file suitable for static linking
  -static           only build a \`.o' file suitable for static linking
  -Wc,FLAG          pass FLAG directly to the compiler

COMPILE-COMMAND is a command to be used in creating a \`standard' object file
from the given SOURCEFILE.

The output file name is determined by removing the directory component from
SOURCEFILE, then substituting the C source code suffix \`.c' with the
library object suffix, \`.lo'."
        ;;

      execute)
        $ECHO \
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...

Automatically set library path, then run a program.

This mode accepts the following additional options:

  -dlopen FILE      add the directory containing FILE to the library path

This mode sets the library path environment variable according to \`-dlopen'
flags.

If any of the ARGS are libtool executable wrappers, then they are translated
into their corresponding uninstalled binary, and any of their required library
directories are added to the library path.

Then, COMMAND is executed, with ARGS as arguments."
        ;;

      finish)
        $ECHO \
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...

Complete the installation of libtool libraries.

Each LIBDIR is a directory that contains libtool libraries.

The commands that this mode executes may require superuser privileges.  Use
the \`--dry-run' option if you just want to see what would be executed."
        ;;

      install)
        $ECHO \
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...

Install executables or libraries.

INSTALL-COMMAND is the installation command.  The first component should be
either the \`install' or \`cp' program.

The following components of INSTALL-COMMAND are treated specially:

  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation

The rest of the components are interpreted as arguments to that command (only
BSD-compatible install options are recognized)."
        ;;

      link)
        $ECHO \
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...

Link object files or libraries together to form another library, or to
create an executable program.

LINK-COMMAND is a command using the C compiler that you would use to create
a program from several object files.

The following components of LINK-COMMAND are treated specially:

  -all-static       do not do any dynamic linking at all
  -avoid-version    do not add a version suffix if possible
  -bindir BINDIR    specify path to binaries directory (for systems where
                    libraries must be found in the PATH setting at runtime)
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
  -export-symbols SYMFILE
                    try to export only the symbols listed in SYMFILE
  -export-symbols-regex REGEX
                    try to export only the symbols matching REGEX
  -LLIBDIR          search LIBDIR for required installed libraries
  -lNAME            OUTPUT-FILE requires the installed library libNAME
  -module           build a library that can dlopened
  -no-fast-install  disable the fast-install mode
  -no-install       link a not-installable executable
  -no-undefined     declare that a library does not refer to external symbols
  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
  -objectlist FILE  Use a list of object files found in FILE to specify objects
  -precious-files-regex REGEX
                    don't remove output files matching REGEX
  -release RELEASE  specify package release information
  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
  -shared           only do dynamic linking of libtool libraries
  -shrext SUFFIX    override the standard shared library file extension
  -static           do not do any dynamic linking of uninstalled libtool libraries
  -static-libtool-libs
                    do not do any dynamic linking of libtool libraries
  -version-info CURRENT[:REVISION[:AGE]]
                    specify library version info [each variable defaults to 0]
  -weak LIBNAME     declare that the target provides the LIBNAME interface
  -Wc,FLAG
  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
  -Wl,FLAG
  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)

All other options (arguments beginning with \`-') are ignored.

Every other argument is treated as a filename.  Files ending in \`.la' are
treated as uninstalled libtool libraries, other files are standard or library
object files.

If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
only library objects (\`.lo' files) may be specified, and \`-rpath' is
required, except when creating a convenience library.

If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
using \`ar' and \`ranlib', or on Windows using \`lib'.

If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
is created, otherwise an executable program is created."
        ;;

      uninstall)
        $ECHO \
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...

Remove libraries from an installation directory.

RM is the name of the program to use to delete files associated with each FILE
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
to RM.

If FILE is a libtool library, all the files associated with it are deleted.
Otherwise, only FILE itself is deleted using RM."
        ;;

      *)
        func_fatal_help "invalid operation mode \`$opt_mode'"
        ;;
    esac

    echo
    $ECHO "Try \`$progname --help' for more information about other modes."
}

# Now that we've collected a possible --mode arg, show help if necessary
if $opt_help; then
  if test "$opt_help" = :; then
    func_mode_help
  else
    {
      func_help noexit
      for opt_mode in compile link execute install finish uninstall clean; do
	func_mode_help
      done
    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
    {
      func_help noexit
      for opt_mode in compile link execute install finish uninstall clean; do
	echo
	func_mode_help
      done
    } |
    sed '1d
      /^When reporting/,/^Report/{
	H
	d
      }
      $x
      /information about other modes/d
      /more detailed .*MODE/d
      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
  fi
  exit $?
fi


# func_mode_execute arg...
func_mode_execute ()
{
    $opt_debug
    # The first argument is the command name.
    cmd="$nonopt"
    test -z "$cmd" && \
      func_fatal_help "you must specify a COMMAND"

    # Handle -dlopen flags immediately.
    for file in $opt_dlopen; do
      test -f "$file" \
	|| func_fatal_help "\`$file' is not a file"

      dir=
      case $file in
      *.la)
	func_resolve_sysroot "$file"
	file=$func_resolve_sysroot_result

	# Check to see that this really is a libtool archive.
	func_lalib_unsafe_p "$file" \
	  || func_fatal_help "\`$lib' is not a valid libtool archive"

	# Read the libtool library.
	dlname=
	library_names=
	func_source "$file"

	# Skip this library if it cannot be dlopened.
	if test -z "$dlname"; then
	  # Warn if it was a shared library.
	  test -n "$library_names" && \
	    func_warning "\`$file' was not linked with \`-export-dynamic'"
	  continue
	fi

	func_dirname "$file" "" "."
	dir="$func_dirname_result"

	if test -f "$dir/$objdir/$dlname"; then
	  func_append dir "/$objdir"
	else
	  if test ! -f "$dir/$dlname"; then
	    func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
	  fi
	fi
	;;

      *.lo)
	# Just add the directory containing the .lo file.
	func_dirname "$file" "" "."
	dir="$func_dirname_result"
	;;

      *)
	func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
	continue
	;;
      esac

      # Get the absolute pathname.
      absdir=`cd "$dir" && pwd`
      test -n "$absdir" && dir="$absdir"

      # Now add the directory to shlibpath_var.
      if eval "test -z \"\$$shlibpath_var\""; then
	eval "$shlibpath_var=\"\$dir\""
      else
	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
      fi
    done

    # This variable tells wrapper scripts just to set shlibpath_var
    # rather than running their programs.
    libtool_execute_magic="$magic"

    # Check if any of the arguments is a wrapper script.
    args=
    for file
    do
      case $file in
      -* | *.la | *.lo ) ;;
      *)
	# Do a test to see if this is really a libtool program.
	if func_ltwrapper_script_p "$file"; then
	  func_source "$file"
	  # Transform arg to wrapped name.
	  file="$progdir/$program"
	elif func_ltwrapper_executable_p "$file"; then
	  func_ltwrapper_scriptname "$file"
	  func_source "$func_ltwrapper_scriptname_result"
	  # Transform arg to wrapped name.
	  file="$progdir/$program"
	fi
	;;
      esac
      # Quote arguments (to preserve shell metacharacters).
      func_append_quoted args "$file"
    done

    if test "X$opt_dry_run" = Xfalse; then
      if test -n "$shlibpath_var"; then
	# Export the shlibpath_var.
	eval "export $shlibpath_var"
      fi

      # Restore saved environment variables
      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
      do
	eval "if test \"\${save_$lt_var+set}\" = set; then
                $lt_var=\$save_$lt_var; export $lt_var
	      else
		$lt_unset $lt_var
	      fi"
      done

      # Now prepare to actually exec the command.
      exec_cmd="\$cmd$args"
    else
      # Display what would be done.
      if test -n "$shlibpath_var"; then
	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
	echo "export $shlibpath_var"
      fi
      $ECHO "$cmd$args"
      exit $EXIT_SUCCESS
    fi
}

test "$opt_mode" = execute && func_mode_execute ${1+"$@"}


# func_mode_finish arg...
func_mode_finish ()
{
    $opt_debug
    libs=
    libdirs=
    admincmds=

    for opt in "$nonopt" ${1+"$@"}
    do
      if test -d "$opt"; then
	func_append libdirs " $opt"

      elif test -f "$opt"; then
	if func_lalib_unsafe_p "$opt"; then
	  func_append libs " $opt"
	else
	  func_warning "\`$opt' is not a valid libtool archive"
	fi

      else
	func_fatal_error "invalid argument \`$opt'"
      fi
    done

    if test -n "$libs"; then
      if test -n "$lt_sysroot"; then
        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
      else
        sysroot_cmd=
      fi

      # Remove sysroot references
      if $opt_dry_run; then
        for lib in $libs; do
          echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
        done
      else
        tmpdir=`func_mktempdir`
        for lib in $libs; do
	  sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
	    > $tmpdir/tmp-la
	  mv -f $tmpdir/tmp-la $lib
	done
        ${RM}r "$tmpdir"
      fi
    fi

    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
      for libdir in $libdirs; do
	if test -n "$finish_cmds"; then
	  # Do each command in the finish commands.
	  func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
'"$cmd"'"'
	fi
	if test -n "$finish_eval"; then
	  # Do the single finish_eval.
	  eval cmds=\"$finish_eval\"
	  $opt_dry_run || eval "$cmds" || func_append admincmds "
       $cmds"
	fi
      done
    fi

    # Exit here if they wanted silent mode.
    $opt_silent && exit $EXIT_SUCCESS

    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
      echo "----------------------------------------------------------------------"
      echo "Libraries have been installed in:"
      for libdir in $libdirs; do
	$ECHO "   $libdir"
      done
      echo
      echo "If you ever happen to want to link against installed libraries"
      echo "in a given directory, LIBDIR, you must either use libtool, and"
      echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
      echo "flag during linking and do at least one of the following:"
      if test -n "$shlibpath_var"; then
	echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
	echo "     during execution"
      fi
      if test -n "$runpath_var"; then
	echo "   - add LIBDIR to the \`$runpath_var' environment variable"
	echo "     during linking"
      fi
      if test -n "$hardcode_libdir_flag_spec"; then
	libdir=LIBDIR
	eval flag=\"$hardcode_libdir_flag_spec\"

	$ECHO "   - use the \`$flag' linker flag"
      fi
      if test -n "$admincmds"; then
	$ECHO "   - have your system administrator run these commands:$admincmds"
      fi
      if test -f /etc/ld.so.conf; then
	echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
      fi
      echo

      echo "See any operating system documentation about shared libraries for"
      case $host in
	solaris2.[6789]|solaris2.1[0-9])
	  echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
	  echo "pages."
	  ;;
	*)
	  echo "more information, such as the ld(1) and ld.so(8) manual pages."
	  ;;
      esac
      echo "----------------------------------------------------------------------"
    fi
    exit $EXIT_SUCCESS
}

test "$opt_mode" = finish && func_mode_finish ${1+"$@"}


# func_mode_install arg...
func_mode_install ()
{
    $opt_debug
    # There may be an optional sh(1) argument at the beginning of
    # install_prog (especially on Windows NT).
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
       # Allow the use of GNU shtool's install command.
       case $nonopt in *shtool*) :;; *) false;; esac; then
      # Aesthetically quote it.
      func_quote_for_eval "$nonopt"
      install_prog="$func_quote_for_eval_result "
      arg=$1
      shift
    else
      install_prog=
      arg=$nonopt
    fi

    # The real first argument should be the name of the installation program.
    # Aesthetically quote it.
    func_quote_for_eval "$arg"
    func_append install_prog "$func_quote_for_eval_result"
    install_shared_prog=$install_prog
    case " $install_prog " in
      *[\\\ /]cp\ *) install_cp=: ;;
      *) install_cp=false ;;
    esac

    # We need to accept at least all the BSD install flags.
    dest=
    files=
    opts=
    prev=
    install_type=
    isdir=no
    stripme=
    no_mode=:
    for arg
    do
      arg2=
      if test -n "$dest"; then
	func_append files " $dest"
	dest=$arg
	continue
      fi

      case $arg in
      -d) isdir=yes ;;
      -f)
	if $install_cp; then :; else
	  prev=$arg
	fi
	;;
      -g | -m | -o)
	prev=$arg
	;;
      -s)
	stripme=" -s"
	continue
	;;
      -*)
	;;
      *)
	# If the previous option needed an argument, then skip it.
	if test -n "$prev"; then
	  if test "x$prev" = x-m && test -n "$install_override_mode"; then
	    arg2=$install_override_mode
	    no_mode=false
	  fi
	  prev=
	else
	  dest=$arg
	  continue
	fi
	;;
      esac

      # Aesthetically quote the argument.
      func_quote_for_eval "$arg"
      func_append install_prog " $func_quote_for_eval_result"
      if test -n "$arg2"; then
	func_quote_for_eval "$arg2"
      fi
      func_append install_shared_prog " $func_quote_for_eval_result"
    done

    test -z "$install_prog" && \
      func_fatal_help "you must specify an install program"

    test -n "$prev" && \
      func_fatal_help "the \`$prev' option requires an argument"

    if test -n "$install_override_mode" && $no_mode; then
      if $install_cp; then :; else
	func_quote_for_eval "$install_override_mode"
	func_append install_shared_prog " -m $func_quote_for_eval_result"
      fi
    fi

    if test -z "$files"; then
      if test -z "$dest"; then
	func_fatal_help "no file or destination specified"
      else
	func_fatal_help "you must specify a destination"
      fi
    fi

    # Strip any trailing slash from the destination.
    func_stripname '' '/' "$dest"
    dest=$func_stripname_result

    # Check to see that the destination is a directory.
    test -d "$dest" && isdir=yes
    if test "$isdir" = yes; then
      destdir="$dest"
      destname=
    else
      func_dirname_and_basename "$dest" "" "."
      destdir="$func_dirname_result"
      destname="$func_basename_result"

      # Not a directory, so check to see that there is only one file specified.
      set dummy $files; shift
      test "$#" -gt 1 && \
	func_fatal_help "\`$dest' is not a directory"
    fi
    case $destdir in
    [\\/]* | [A-Za-z]:[\\/]*) ;;
    *)
      for file in $files; do
	case $file in
	*.lo) ;;
	*)
	  func_fatal_help "\`$destdir' must be an absolute directory name"
	  ;;
	esac
      done
      ;;
    esac

    # This variable tells wrapper scripts just to set variables rather
    # than running their programs.
    libtool_install_magic="$magic"

    staticlibs=
    future_libdirs=
    current_libdirs=
    for file in $files; do

      # Do each installation.
      case $file in
      *.$libext)
	# Do the static libraries later.
	func_append staticlibs " $file"
	;;

      *.la)
	func_resolve_sysroot "$file"
	file=$func_resolve_sysroot_result

	# Check to see that this really is a libtool archive.
	func_lalib_unsafe_p "$file" \
	  || func_fatal_help "\`$file' is not a valid libtool archive"

	library_names=
	old_library=
	relink_command=
	func_source "$file"

	# Add the libdir to current_libdirs if it is the destination.
	if test "X$destdir" = "X$libdir"; then
	  case "$current_libdirs " in
	  *" $libdir "*) ;;
	  *) func_append current_libdirs " $libdir" ;;
	  esac
	else
	  # Note the libdir as a future libdir.
	  case "$future_libdirs " in
	  *" $libdir "*) ;;
	  *) func_append future_libdirs " $libdir" ;;
	  esac
	fi

	func_dirname "$file" "/" ""
	dir="$func_dirname_result"
	func_append dir "$objdir"

	if test -n "$relink_command"; then
	  # Determine the prefix the user has applied to our future dir.
	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`

	  # Don't allow the user to place us outside of our expected
	  # location b/c this prevents finding dependent libraries that
	  # are installed to the same prefix.
	  # At present, this check doesn't affect windows .dll's that
	  # are installed into $libdir/../bin (currently, that works fine)
	  # but it's something to keep an eye on.
	  test "$inst_prefix_dir" = "$destdir" && \
	    func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"

	  if test -n "$inst_prefix_dir"; then
	    # Stick the inst_prefix_dir data into the link command.
	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
	  else
	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
	  fi

	  func_warning "relinking \`$file'"
	  func_show_eval "$relink_command" \
	    'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
	fi

	# See the names of the shared library.
	set dummy $library_names; shift
	if test -n "$1"; then
	  realname="$1"
	  shift

	  srcname="$realname"
	  test -n "$relink_command" && srcname="$realname"T

	  # Install the shared library and build the symlinks.
	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
	      'exit $?'
	  tstripme="$stripme"
	  case $host_os in
	  cygwin* | mingw* | pw32* | cegcc*)
	    case $realname in
	    *.dll.a)
	      tstripme=""
	      ;;
	    esac
	    ;;
	  esac
	  if test -n "$tstripme" && test -n "$striplib"; then
	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
	  fi

	  if test "$#" -gt 0; then
	    # Delete the old symlinks, and create new ones.
	    # Try `ln -sf' first, because the `ln' binary might depend on
	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
	    # so we also need to try rm && ln -s.
	    for linkname
	    do
	      test "$linkname" != "$realname" \
		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
	    done
	  fi

	  # Do each command in the postinstall commands.
	  lib="$destdir/$realname"
	  func_execute_cmds "$postinstall_cmds" 'exit $?'
	fi

	# Install the pseudo-library for information purposes.
	func_basename "$file"
	name="$func_basename_result"
	instname="$dir/$name"i
	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'

	# Maybe install the static library, too.
	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
	;;

      *.lo)
	# Install (i.e. copy) a libtool object.

	# Figure out destination file name, if it wasn't already specified.
	if test -n "$destname"; then
	  destfile="$destdir/$destname"
	else
	  func_basename "$file"
	  destfile="$func_basename_result"
	  destfile="$destdir/$destfile"
	fi

	# Deduce the name of the destination old-style object file.
	case $destfile in
	*.lo)
	  func_lo2o "$destfile"
	  staticdest=$func_lo2o_result
	  ;;
	*.$objext)
	  staticdest="$destfile"
	  destfile=
	  ;;
	*)
	  func_fatal_help "cannot copy a libtool object to \`$destfile'"
	  ;;
	esac

	# Install the libtool object if requested.
	test -n "$destfile" && \
	  func_show_eval "$install_prog $file $destfile" 'exit $?'

	# Install the old object if enabled.
	if test "$build_old_libs" = yes; then
	  # Deduce the name of the old-style object file.
	  func_lo2o "$file"
	  staticobj=$func_lo2o_result
	  func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
	fi
	exit $EXIT_SUCCESS
	;;

      *)
	# Figure out destination file name, if it wasn't already specified.
	if test -n "$destname"; then
	  destfile="$destdir/$destname"
	else
	  func_basename "$file"
	  destfile="$func_basename_result"
	  destfile="$destdir/$destfile"
	fi

	# If the file is missing, and there is a .exe on the end, strip it
	# because it is most likely a libtool script we actually want to
	# install
	stripped_ext=""
	case $file in
	  *.exe)
	    if test ! -f "$file"; then
	      func_stripname '' '.exe' "$file"
	      file=$func_stripname_result
	      stripped_ext=".exe"
	    fi
	    ;;
	esac

	# Do a test to see if this is really a libtool program.
	case $host in
	*cygwin* | *mingw*)
	    if func_ltwrapper_executable_p "$file"; then
	      func_ltwrapper_scriptname "$file"
	      wrapper=$func_ltwrapper_scriptname_result
	    else
	      func_stripname '' '.exe' "$file"
	      wrapper=$func_stripname_result
	    fi
	    ;;
	*)
	    wrapper=$file
	    ;;
	esac
	if func_ltwrapper_script_p "$wrapper"; then
	  notinst_deplibs=
	  relink_command=

	  func_source "$wrapper"

	  # Check the variables that should have been set.
	  test -z "$generated_by_libtool_version" && \
	    func_fatal_error "invalid libtool wrapper script \`$wrapper'"

	  finalize=yes
	  for lib in $notinst_deplibs; do
	    # Check to see that each library is installed.
	    libdir=
	    if test -f "$lib"; then
	      func_source "$lib"
	    fi
	    libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
	    if test -n "$libdir" && test ! -f "$libfile"; then
	      func_warning "\`$lib' has not been installed in \`$libdir'"
	      finalize=no
	    fi
	  done

	  relink_command=
	  func_source "$wrapper"

	  outputname=
	  if test "$fast_install" = no && test -n "$relink_command"; then
	    $opt_dry_run || {
	      if test "$finalize" = yes; then
	        tmpdir=`func_mktempdir`
		func_basename "$file$stripped_ext"
		file="$func_basename_result"
	        outputname="$tmpdir/$file"
	        # Replace the output file specification.
	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`

	        $opt_silent || {
	          func_quote_for_expand "$relink_command"
		  eval "func_echo $func_quote_for_expand_result"
	        }
	        if eval "$relink_command"; then :
	          else
		  func_error "error: relink \`$file' with the above command before installing it"
		  $opt_dry_run || ${RM}r "$tmpdir"
		  continue
	        fi
	        file="$outputname"
	      else
	        func_warning "cannot relink \`$file'"
	      fi
	    }
	  else
	    # Install the binary that we compiled earlier.
	    file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
	  fi
	fi

	# remove .exe since cygwin /usr/bin/install will append another
	# one anyway
	case $install_prog,$host in
	*/usr/bin/install*,*cygwin*)
	  case $file:$destfile in
	  *.exe:*.exe)
	    # this is ok
	    ;;
	  *.exe:*)
	    destfile=$destfile.exe
	    ;;
	  *:*.exe)
	    func_stripname '' '.exe' "$destfile"
	    destfile=$func_stripname_result
	    ;;
	  esac
	  ;;
	esac
	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
	$opt_dry_run || if test -n "$outputname"; then
	  ${RM}r "$tmpdir"
	fi
	;;
      esac
    done

    for file in $staticlibs; do
      func_basename "$file"
      name="$func_basename_result"

      # Set up the ranlib parameters.
      oldlib="$destdir/$name"
      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
      tool_oldlib=$func_to_tool_file_result

      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'

      if test -n "$stripme" && test -n "$old_striplib"; then
	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
      fi

      # Do each command in the postinstall commands.
      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
    done

    test -n "$future_libdirs" && \
      func_warning "remember to run \`$progname --finish$future_libdirs'"

    if test -n "$current_libdirs"; then
      # Maybe just do a dry run.
      $opt_dry_run && current_libdirs=" -n$current_libdirs"
      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
    else
      exit $EXIT_SUCCESS
    fi
}

test "$opt_mode" = install && func_mode_install ${1+"$@"}


# func_generate_dlsyms outputname originator pic_p
# Extract symbols from dlprefiles and create ${outputname}S.o with
# a dlpreopen symbol table.
func_generate_dlsyms ()
{
    $opt_debug
    my_outputname="$1"
    my_originator="$2"
    my_pic_p="${3-no}"
    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
    my_dlsyms=

    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
      if test -n "$NM" && test -n "$global_symbol_pipe"; then
	my_dlsyms="${my_outputname}S.c"
      else
	func_error "not configured to extract global symbols from dlpreopened files"
      fi
    fi

    if test -n "$my_dlsyms"; then
      case $my_dlsyms in
      "") ;;
      *.c)
	# Discover the nlist of each of the dlfiles.
	nlist="$output_objdir/${my_outputname}.nm"

	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"

	# Parse the name list into a source file.
	func_verbose "creating $output_objdir/$my_dlsyms"

	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */

#ifdef __cplusplus
extern \"C\" {
#endif

#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
#endif

/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
/* DATA imports from DLLs on WIN32 con't be const, because runtime
   relocations are performed -- see ld's documentation on pseudo-relocs.  */
# define LT_DLSYM_CONST
#elif defined(__osf__)
/* This system does not cope well with relocations in const data.  */
# define LT_DLSYM_CONST
#else
# define LT_DLSYM_CONST const
#endif

/* External symbol declarations for the compiler. */\
"

	if test "$dlself" = yes; then
	  func_verbose "generating symbol list for \`$output'"

	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"

	  # Add our own program objects to the symbol list.
	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
	  for progfile in $progfiles; do
	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
	    func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
	  done

	  if test -n "$exclude_expsyms"; then
	    $opt_dry_run || {
	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
	      eval '$MV "$nlist"T "$nlist"'
	    }
	  fi

	  if test -n "$export_symbols_regex"; then
	    $opt_dry_run || {
	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
	      eval '$MV "$nlist"T "$nlist"'
	    }
	  fi

	  # Prepare the list of exported symbols
	  if test -z "$export_symbols"; then
	    export_symbols="$output_objdir/$outputname.exp"
	    $opt_dry_run || {
	      $RM $export_symbols
	      eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
	      case $host in
	      *cygwin* | *mingw* | *cegcc* )
                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
	        ;;
	      esac
	    }
	  else
	    $opt_dry_run || {
	      eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
	      eval '$MV "$nlist"T "$nlist"'
	      case $host in
	        *cygwin* | *mingw* | *cegcc* )
	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
	          ;;
	      esac
	    }
	  fi
	fi

	for dlprefile in $dlprefiles; do
	  func_verbose "extracting global C symbols from \`$dlprefile'"
	  func_basename "$dlprefile"
	  name="$func_basename_result"
          case $host in
	    *cygwin* | *mingw* | *cegcc* )
	      # if an import library, we need to obtain dlname
	      if func_win32_import_lib_p "$dlprefile"; then
	        func_tr_sh "$dlprefile"
	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
	        dlprefile_dlbasename=""
	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
	          # Use subshell, to avoid clobbering current variable values
	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
	          if test -n "$dlprefile_dlname" ; then
	            func_basename "$dlprefile_dlname"
	            dlprefile_dlbasename="$func_basename_result"
	          else
	            # no lafile. user explicitly requested -dlpreopen .
	            $sharedlib_from_linklib_cmd "$dlprefile"
	            dlprefile_dlbasename=$sharedlib_from_linklib_result
	          fi
	        fi
	        $opt_dry_run || {
	          if test -n "$dlprefile_dlbasename" ; then
	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
	          else
	            func_warning "Could not compute DLL name from $name"
	            eval '$ECHO ": $name " >> "$nlist"'
	          fi
	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
	            $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
	        }
	      else # not an import lib
	        $opt_dry_run || {
	          eval '$ECHO ": $name " >> "$nlist"'
	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
	        }
	      fi
	    ;;
	    *)
	      $opt_dry_run || {
	        eval '$ECHO ": $name " >> "$nlist"'
	        func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
	        eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
	      }
	    ;;
          esac
	done

	$opt_dry_run || {
	  # Make sure we have at least an empty file.
	  test -f "$nlist" || : > "$nlist"

	  if test -n "$exclude_expsyms"; then
	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
	    $MV "$nlist"T "$nlist"
	  fi

	  # Try sorting and uniquifying the output.
	  if $GREP -v "^: " < "$nlist" |
	      if sort -k 3 /dev/null 2>&1; then
		sort -k 3
	      else
		sort +2
	      fi |
	      uniq > "$nlist"S; then
	    :
	  else
	    $GREP -v "^: " < "$nlist" > "$nlist"S
	  fi

	  if test -f "$nlist"S; then
	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
	  else
	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
	  fi

	  echo >> "$output_objdir/$my_dlsyms" "\

/* The mapping between symbol names and symbols.  */
typedef struct {
  const char *name;
  void *address;
} lt_dlsymlist;
extern LT_DLSYM_CONST lt_dlsymlist
lt_${my_prefix}_LTX_preloaded_symbols[];
LT_DLSYM_CONST lt_dlsymlist
lt_${my_prefix}_LTX_preloaded_symbols[] =
{\
  { \"$my_originator\", (void *) 0 },"

	  case $need_lib_prefix in
	  no)
	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
	    ;;
	  *)
	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
	    ;;
	  esac
	  echo >> "$output_objdir/$my_dlsyms" "\
  {0, (void *) 0}
};

/* This works around a problem in FreeBSD linker */
#ifdef FREEBSD_WORKAROUND
static const void *lt_preloaded_setup() {
  return lt_${my_prefix}_LTX_preloaded_symbols;
}
#endif

#ifdef __cplusplus
}
#endif\
"
	} # !$opt_dry_run

	pic_flag_for_symtable=
	case "$compile_command " in
	*" -static "*) ;;
	*)
	  case $host in
	  # compiling the symbol table file with pic_flag works around
	  # a FreeBSD bug that causes programs to crash when -lm is
	  # linked before any other PIC object.  But we must not use
	  # pic_flag when linking with -static.  The problem exists in
	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
	  *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
	  *-*-hpux*)
	    pic_flag_for_symtable=" $pic_flag"  ;;
	  *)
	    if test "X$my_pic_p" != Xno; then
	      pic_flag_for_symtable=" $pic_flag"
	    fi
	    ;;
	  esac
	  ;;
	esac
	symtab_cflags=
	for arg in $LTCFLAGS; do
	  case $arg in
	  -pie | -fpie | -fPIE) ;;
	  *) func_append symtab_cflags " $arg" ;;
	  esac
	done

	# Now compile the dynamic symbol file.
	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'

	# Clean up the generated files.
	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'

	# Transform the symbol file into the correct name.
	symfileobj="$output_objdir/${my_outputname}S.$objext"
	case $host in
	*cygwin* | *mingw* | *cegcc* )
	  if test -f "$output_objdir/$my_outputname.def"; then
	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
	  else
	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
	  fi
	  ;;
	*)
	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
	  ;;
	esac
	;;
      *)
	func_fatal_error "unknown suffix for \`$my_dlsyms'"
	;;
      esac
    else
      # We keep going just in case the user didn't refer to
      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
      # really was required.

      # Nullify the symbol file.
      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
    fi
}

# func_win32_libid arg
# return the library type of file 'arg'
#
# Need a lot of goo to handle *both* DLLs and import libs
# Has to be a shell function in order to 'eat' the argument
# that is supplied when $file_magic_command is called.
# Despite the name, also deal with 64 bit binaries.
func_win32_libid ()
{
  $opt_debug
  win32_libid_type="unknown"
  win32_fileres=`file -L $1 2>/dev/null`
  case $win32_fileres in
  *ar\ archive\ import\ library*) # definitely import
    win32_libid_type="x86 archive import"
    ;;
  *ar\ archive*) # could be an import, or static
    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
      func_to_tool_file "$1" func_convert_file_msys_to_w32
      win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
	$SED -n -e '
	    1,100{
		/ I /{
		    s,.*,import,
		    p
		    q
		}
	    }'`
      case $win32_nmres in
      import*)  win32_libid_type="x86 archive import";;
      *)        win32_libid_type="x86 archive static";;
      esac
    fi
    ;;
  *DLL*)
    win32_libid_type="x86 DLL"
    ;;
  *executable*) # but shell scripts are "executable" too...
    case $win32_fileres in
    *MS\ Windows\ PE\ Intel*)
      win32_libid_type="x86 DLL"
      ;;
    esac
    ;;
  esac
  $ECHO "$win32_libid_type"
}

# func_cygming_dll_for_implib ARG
#
# Platform-specific function to extract the
# name of the DLL associated with the specified
# import library ARG.
# Invoked by eval'ing the libtool variable
#    $sharedlib_from_linklib_cmd
# Result is available in the variable
#    $sharedlib_from_linklib_result
func_cygming_dll_for_implib ()
{
  $opt_debug
  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
}

# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
#
# The is the core of a fallback implementation of a
# platform-specific function to extract the name of the
# DLL associated with the specified import library LIBNAME.
#
# SECTION_NAME is either .idata$6 or .idata$7, depending
# on the platform and compiler that created the implib.
#
# Echos the name of the DLL associated with the
# specified import library.
func_cygming_dll_for_implib_fallback_core ()
{
  $opt_debug
  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
    $SED '/^Contents of section '"$match_literal"':/{
      # Place marker at beginning of archive member dllname section
      s/.*/====MARK====/
      p
      d
    }
    # These lines can sometimes be longer than 43 characters, but
    # are always uninteresting
    /:[	 ]*file format pe[i]\{,1\}-/d
    /^In archive [^:]*:/d
    # Ensure marker is printed
    /^====MARK====/p
    # Remove all lines with less than 43 characters
    /^.\{43\}/!d
    # From remaining lines, remove first 43 characters
    s/^.\{43\}//' |
    $SED -n '
      # Join marker and all lines until next marker into a single line
      /^====MARK====/ b para
      H
      $ b para
      b
      :para
      x
      s/\n//g
      # Remove the marker
      s/^====MARK====//
      # Remove trailing dots and whitespace
      s/[\. \t]*$//
      # Print
      /./p' |
    # we now have a list, one entry per line, of the stringified
    # contents of the appropriate section of all members of the
    # archive which possess that section. Heuristic: eliminate
    # all those which have a first or second character that is
    # a '.' (that is, objdump's representation of an unprintable
    # character.) This should work for all archives with less than
    # 0x302f exports -- but will fail for DLLs whose name actually
    # begins with a literal '.' or a single character followed by
    # a '.'.
    #
    # Of those that remain, print the first one.
    $SED -e '/^\./d;/^.\./d;q'
}

# func_cygming_gnu_implib_p ARG
# This predicate returns with zero status (TRUE) if
# ARG is a GNU/binutils-style import library. Returns
# with nonzero status (FALSE) otherwise.
func_cygming_gnu_implib_p ()
{
  $opt_debug
  func_to_tool_file "$1" func_convert_file_msys_to_w32
  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
  test -n "$func_cygming_gnu_implib_tmp"
}

# func_cygming_ms_implib_p ARG
# This predicate returns with zero status (TRUE) if
# ARG is an MS-style import library. Returns
# with nonzero status (FALSE) otherwise.
func_cygming_ms_implib_p ()
{
  $opt_debug
  func_to_tool_file "$1" func_convert_file_msys_to_w32
  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
  test -n "$func_cygming_ms_implib_tmp"
}

# func_cygming_dll_for_implib_fallback ARG
# Platform-specific function to extract the
# name of the DLL associated with the specified
# import library ARG.
#
# This fallback implementation is for use when $DLLTOOL
# does not support the --identify-strict option.
# Invoked by eval'ing the libtool variable
#    $sharedlib_from_linklib_cmd
# Result is available in the variable
#    $sharedlib_from_linklib_result
func_cygming_dll_for_implib_fallback ()
{
  $opt_debug
  if func_cygming_gnu_implib_p "$1" ; then
    # binutils import library
    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
  elif func_cygming_ms_implib_p "$1" ; then
    # ms-generated import library
    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
  else
    # unknown
    sharedlib_from_linklib_result=""
  fi
}


# func_extract_an_archive dir oldlib
func_extract_an_archive ()
{
    $opt_debug
    f_ex_an_ar_dir="$1"; shift
    f_ex_an_ar_oldlib="$1"
    if test "$lock_old_archive_extraction" = yes; then
      lockfile=$f_ex_an_ar_oldlib.lock
      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
	func_echo "Waiting for $lockfile to be removed"
	sleep 2
      done
    fi
    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
		   'stat=$?; rm -f "$lockfile"; exit $stat'
    if test "$lock_old_archive_extraction" = yes; then
      $opt_dry_run || rm -f "$lockfile"
    fi
    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
     :
    else
      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
    fi
}


# func_extract_archives gentop oldlib ...
func_extract_archives ()
{
    $opt_debug
    my_gentop="$1"; shift
    my_oldlibs=${1+"$@"}
    my_oldobjs=""
    my_xlib=""
    my_xabs=""
    my_xdir=""

    for my_xlib in $my_oldlibs; do
      # Extract the objects.
      case $my_xlib in
	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
	*) my_xabs=`pwd`"/$my_xlib" ;;
      esac
      func_basename "$my_xlib"
      my_xlib="$func_basename_result"
      my_xlib_u=$my_xlib
      while :; do
        case " $extracted_archives " in
	*" $my_xlib_u "*)
	  func_arith $extracted_serial + 1
	  extracted_serial=$func_arith_result
	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
	*) break ;;
	esac
      done
      extracted_archives="$extracted_archives $my_xlib_u"
      my_xdir="$my_gentop/$my_xlib_u"

      func_mkdir_p "$my_xdir"

      case $host in
      *-darwin*)
	func_verbose "Extracting $my_xabs"
	# Do not bother doing anything if just a dry run
	$opt_dry_run || {
	  darwin_orig_dir=`pwd`
	  cd $my_xdir || exit $?
	  darwin_archive=$my_xabs
	  darwin_curdir=`pwd`
	  darwin_base_archive=`basename "$darwin_archive"`
	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
	  if test -n "$darwin_arches"; then
	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
	    darwin_arch=
	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
	    for darwin_arch in  $darwin_arches ; do
	      func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
	      $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"
	      cd "$darwin_curdir"
	      $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
	    done # $darwin_arches
            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
	    darwin_file=
	    darwin_files=
	    for darwin_file in $darwin_filelist; do
	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
	      $LIPO -create -output "$darwin_file" $darwin_files
	    done # $darwin_filelist
	    $RM -rf unfat-$$
	    cd "$darwin_orig_dir"
	  else
	    cd $darwin_orig_dir
	    func_extract_an_archive "$my_xdir" "$my_xabs"
	  fi # $darwin_arches
	} # !$opt_dry_run
	;;
      *)
        func_extract_an_archive "$my_xdir" "$my_xabs"
	;;
      esac
      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
    done

    func_extract_archives_result="$my_oldobjs"
}


# func_emit_wrapper [arg=no]
#
# Emit a libtool wrapper script on stdout.
# Don't directly open a file because we may want to
# incorporate the script contents within a cygwin/mingw
# wrapper executable.  Must ONLY be called from within
# func_mode_link because it depends on a number of variables
# set therein.
#
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
# variable will take.  If 'yes', then the emitted script
# will assume that the directory in which it is stored is
# the $objdir directory.  This is a cygwin/mingw-specific
# behavior.
func_emit_wrapper ()
{
	func_emit_wrapper_arg1=${1-no}

	$ECHO "\
#! $SHELL

# $output - temporary wrapper script for $objdir/$outputname
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
#
# The $output program cannot be directly executed until all the libtool
# libraries that it depends on are installed.
#
# This wrapper script should never be moved out of the build directory.
# If it is, it will not operate correctly.

# Sed substitution that helps us do robust quoting.  It backslashifies
# metacharacters that are still active within double-quoted strings.
sed_quote_subst='$sed_quote_subst'

# Be Bourne compatible
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
  emulate sh
  NULLCMD=:
  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
  setopt NO_GLOB_SUBST
else
  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
fi
BIN_SH=xpg4; export BIN_SH # for Tru64
DUALCASE=1; export DUALCASE # for MKS sh

# The HP-UX ksh and POSIX shell print the target directory to stdout
# if CDPATH is set.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

relink_command=\"$relink_command\"

# This environment variable determines our operation mode.
if test \"\$libtool_install_magic\" = \"$magic\"; then
  # install mode needs the following variables:
  generated_by_libtool_version='$macro_version'
  notinst_deplibs='$notinst_deplibs'
else
  # When we are sourced in execute mode, \$file and \$ECHO are already set.
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
    file=\"\$0\""

    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
    $ECHO "\

# A function that is used when there is no print builtin or printf.
func_fallback_echo ()
{
  eval 'cat <<_LTECHO_EOF
\$1
_LTECHO_EOF'
}
    ECHO=\"$qECHO\"
  fi

# Very basic option parsing. These options are (a) specific to
# the libtool wrapper, (b) are identical between the wrapper
# /script/ and the wrapper /executable/ which is used only on
# windows platforms, and (c) all begin with the string "--lt-"
# (application programs are unlikely to have options which match
# this pattern).
#
# There are only two supported options: --lt-debug and
# --lt-dump-script. There is, deliberately, no --lt-help.
#
# The first argument to this parsing function should be the
# script's $0 value, followed by "$@".
lt_option_debug=
func_parse_lt_options ()
{
  lt_script_arg0=\$0
  shift
  for lt_opt
  do
    case \"\$lt_opt\" in
    --lt-debug) lt_option_debug=1 ;;
    --lt-dump-script)
        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
        cat \"\$lt_dump_D/\$lt_dump_F\"
        exit 0
      ;;
    --lt-*)
        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
        exit 1
      ;;
    esac
  done

  # Print the debug banner immediately:
  if test -n \"\$lt_option_debug\"; then
    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
  fi
}

# Used when --lt-debug. Prints its arguments to stdout
# (redirection is the responsibility of the caller)
func_lt_dump_args ()
{
  lt_dump_args_N=1;
  for lt_arg
  do
    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
  done
}

# Core function for launching the target application
func_exec_program_core ()
{
"
  case $host in
  # Backslashes separate directories on plain windows
  *-*-mingw | *-*-os2* | *-cegcc*)
    $ECHO "\
      if test -n \"\$lt_option_debug\"; then
        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
        func_lt_dump_args \${1+\"\$@\"} 1>&2
      fi
      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
"
    ;;

  *)
    $ECHO "\
      if test -n \"\$lt_option_debug\"; then
        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
        func_lt_dump_args \${1+\"\$@\"} 1>&2
      fi
      exec \"\$progdir/\$program\" \${1+\"\$@\"}
"
    ;;
  esac
  $ECHO "\
      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
      exit 1
}

# A function to encapsulate launching the target application
# Strips options in the --lt-* namespace from \$@ and
# launches target application with the remaining arguments.
func_exec_program ()
{
  case \" \$* \" in
  *\\ --lt-*)
    for lt_wr_arg
    do
      case \$lt_wr_arg in
      --lt-*) ;;
      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
      esac
      shift
    done ;;
  esac
  func_exec_program_core \${1+\"\$@\"}
}

  # Parse options
  func_parse_lt_options \"\$0\" \${1+\"\$@\"}

  # Find the directory that this script lives in.
  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.

  # Follow symbolic links until we get to the real thisdir.
  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
  while test -n \"\$file\"; do
    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`

    # If there was a directory component, then change thisdir.
    if test \"x\$destdir\" != \"x\$file\"; then
      case \"\$destdir\" in
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
      *) thisdir=\"\$thisdir/\$destdir\" ;;
      esac
    fi

    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
  done

  # Usually 'no', except on cygwin/mingw when embedded into
  # the cwrapper.
  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
    # special case for '.'
    if test \"\$thisdir\" = \".\"; then
      thisdir=\`pwd\`
    fi
    # remove .libs from thisdir
    case \"\$thisdir\" in
    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
    $objdir )   thisdir=. ;;
    esac
  fi

  # Try to get the absolute directory name.
  absdir=\`cd \"\$thisdir\" && pwd\`
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
"

	if test "$fast_install" = yes; then
	  $ECHO "\
  program=lt-'$outputname'$exeext
  progdir=\"\$thisdir/$objdir\"

  if test ! -f \"\$progdir/\$program\" ||
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then

    file=\"\$\$-\$program\"

    if test ! -d \"\$progdir\"; then
      $MKDIR \"\$progdir\"
    else
      $RM \"\$progdir/\$file\"
    fi"

	  $ECHO "\

    # relink executable if necessary
    if test -n \"\$relink_command\"; then
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
      else
	$ECHO \"\$relink_command_output\" >&2
	$RM \"\$progdir/\$file\"
	exit 1
      fi
    fi

    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
    { $RM \"\$progdir/\$program\";
      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
    $RM \"\$progdir/\$file\"
  fi"
	else
	  $ECHO "\
  program='$outputname'
  progdir=\"\$thisdir/$objdir\"
"
	fi

	$ECHO "\

  if test -f \"\$progdir/\$program\"; then"

	# fixup the dll searchpath if we need to.
	#
	# Fix the DLL searchpath if we need to.  Do this before prepending
	# to shlibpath, because on Windows, both are PATH and uninstalled
	# libraries must come first.
	if test -n "$dllsearchpath"; then
	  $ECHO "\
    # Add the dll search path components to the executable PATH
    PATH=$dllsearchpath:\$PATH
"
	fi

	# Export our shlibpath_var if we have one.
	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
	  $ECHO "\
    # Add our own library path to $shlibpath_var
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"

    # Some systems cannot cope with colon-terminated $shlibpath_var
    # The second colon is a workaround for a bug in BeOS R4 sed
    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`

    export $shlibpath_var
"
	fi

	$ECHO "\
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
      # Run the actual program with our arguments.
      func_exec_program \${1+\"\$@\"}
    fi
  else
    # The program doesn't exist.
    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
    exit 1
  fi
fi\
"
}


# func_emit_cwrapperexe_src
# emit the source code for a wrapper executable on stdout
# Must ONLY be called from within func_mode_link because
# it depends on a number of variable set therein.
func_emit_cwrapperexe_src ()
{
	cat <
#include 
#ifdef _MSC_VER
# include 
# include 
# include 
#else
# include 
# include 
# ifdef __CYGWIN__
#  include 
# endif
#endif
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

/* declarations of non-ANSI functions */
#if defined(__MINGW32__)
# ifdef __STRICT_ANSI__
int _putenv (const char *);
# endif
#elif defined(__CYGWIN__)
# ifdef __STRICT_ANSI__
char *realpath (const char *, char *);
int putenv (char *);
int setenv (const char *, const char *, int);
# endif
/* #elif defined (other platforms) ... */
#endif

/* portability defines, excluding path handling macros */
#if defined(_MSC_VER)
# define setmode _setmode
# define stat    _stat
# define chmod   _chmod
# define getcwd  _getcwd
# define putenv  _putenv
# define S_IXUSR _S_IEXEC
# ifndef _INTPTR_T_DEFINED
#  define _INTPTR_T_DEFINED
#  define intptr_t int
# endif
#elif defined(__MINGW32__)
# define setmode _setmode
# define stat    _stat
# define chmod   _chmod
# define getcwd  _getcwd
# define putenv  _putenv
#elif defined(__CYGWIN__)
# define HAVE_SETENV
# define FOPEN_WB "wb"
/* #elif defined (other platforms) ... */
#endif

#if defined(PATH_MAX)
# define LT_PATHMAX PATH_MAX
#elif defined(MAXPATHLEN)
# define LT_PATHMAX MAXPATHLEN
#else
# define LT_PATHMAX 1024
#endif

#ifndef S_IXOTH
# define S_IXOTH 0
#endif
#ifndef S_IXGRP
# define S_IXGRP 0
#endif

/* path handling portability macros */
#ifndef DIR_SEPARATOR
# define DIR_SEPARATOR '/'
# define PATH_SEPARATOR ':'
#endif

#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
  defined (__OS2__)
# define HAVE_DOS_BASED_FILE_SYSTEM
# define FOPEN_WB "wb"
# ifndef DIR_SEPARATOR_2
#  define DIR_SEPARATOR_2 '\\'
# endif
# ifndef PATH_SEPARATOR_2
#  define PATH_SEPARATOR_2 ';'
# endif
#endif

#ifndef DIR_SEPARATOR_2
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
#else /* DIR_SEPARATOR_2 */
# define IS_DIR_SEPARATOR(ch) \
	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
#endif /* DIR_SEPARATOR_2 */

#ifndef PATH_SEPARATOR_2
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
#else /* PATH_SEPARATOR_2 */
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
#endif /* PATH_SEPARATOR_2 */

#ifndef FOPEN_WB
# define FOPEN_WB "w"
#endif
#ifndef _O_BINARY
# define _O_BINARY 0
#endif

#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
#define XFREE(stale) do { \
  if (stale) { free ((void *) stale); stale = 0; } \
} while (0)

#if defined(LT_DEBUGWRAPPER)
static int lt_debug = 1;
#else
static int lt_debug = 0;
#endif

const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */

void *xmalloc (size_t num);
char *xstrdup (const char *string);
const char *base_name (const char *name);
char *find_executable (const char *wrapper);
char *chase_symlinks (const char *pathspec);
int make_executable (const char *path);
int check_executable (const char *path);
char *strendzap (char *str, const char *pat);
void lt_debugprintf (const char *file, int line, const char *fmt, ...);
void lt_fatal (const char *file, int line, const char *message, ...);
static const char *nonnull (const char *s);
static const char *nonempty (const char *s);
void lt_setenv (const char *name, const char *value);
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
void lt_update_exe_path (const char *name, const char *value);
void lt_update_lib_path (const char *name, const char *value);
char **prepare_spawn (char **argv);
void lt_dump_script (FILE *f);
EOF

	    cat <= 0)
      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
    return 1;
  else
    return 0;
}

int
make_executable (const char *path)
{
  int rval = 0;
  struct stat st;

  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
                  nonempty (path));
  if ((!path) || (!*path))
    return 0;

  if (stat (path, &st) >= 0)
    {
      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
    }
  return rval;
}

/* Searches for the full path of the wrapper.  Returns
   newly allocated full path name if found, NULL otherwise
   Does not chase symlinks, even on platforms that support them.
*/
char *
find_executable (const char *wrapper)
{
  int has_slash = 0;
  const char *p;
  const char *p_next;
  /* static buffer for getcwd */
  char tmp[LT_PATHMAX + 1];
  int tmp_len;
  char *concat_name;

  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
                  nonempty (wrapper));

  if ((wrapper == NULL) || (*wrapper == '\0'))
    return NULL;

  /* Absolute path? */
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
    {
      concat_name = xstrdup (wrapper);
      if (check_executable (concat_name))
	return concat_name;
      XFREE (concat_name);
    }
  else
    {
#endif
      if (IS_DIR_SEPARATOR (wrapper[0]))
	{
	  concat_name = xstrdup (wrapper);
	  if (check_executable (concat_name))
	    return concat_name;
	  XFREE (concat_name);
	}
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
    }
#endif

  for (p = wrapper; *p; p++)
    if (*p == '/')
      {
	has_slash = 1;
	break;
      }
  if (!has_slash)
    {
      /* no slashes; search PATH */
      const char *path = getenv ("PATH");
      if (path != NULL)
	{
	  for (p = path; *p; p = p_next)
	    {
	      const char *q;
	      size_t p_len;
	      for (q = p; *q; q++)
		if (IS_PATH_SEPARATOR (*q))
		  break;
	      p_len = q - p;
	      p_next = (*q == '\0' ? q : q + 1);
	      if (p_len == 0)
		{
		  /* empty path: current directory */
		  if (getcwd (tmp, LT_PATHMAX) == NULL)
		    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
                              nonnull (strerror (errno)));
		  tmp_len = strlen (tmp);
		  concat_name =
		    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
		  memcpy (concat_name, tmp, tmp_len);
		  concat_name[tmp_len] = '/';
		  strcpy (concat_name + tmp_len + 1, wrapper);
		}
	      else
		{
		  concat_name =
		    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
		  memcpy (concat_name, p, p_len);
		  concat_name[p_len] = '/';
		  strcpy (concat_name + p_len + 1, wrapper);
		}
	      if (check_executable (concat_name))
		return concat_name;
	      XFREE (concat_name);
	    }
	}
      /* not found in PATH; assume curdir */
    }
  /* Relative path | not found in path: prepend cwd */
  if (getcwd (tmp, LT_PATHMAX) == NULL)
    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
              nonnull (strerror (errno)));
  tmp_len = strlen (tmp);
  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
  memcpy (concat_name, tmp, tmp_len);
  concat_name[tmp_len] = '/';
  strcpy (concat_name + tmp_len + 1, wrapper);

  if (check_executable (concat_name))
    return concat_name;
  XFREE (concat_name);
  return NULL;
}

char *
chase_symlinks (const char *pathspec)
{
#ifndef S_ISLNK
  return xstrdup (pathspec);
#else
  char buf[LT_PATHMAX];
  struct stat s;
  char *tmp_pathspec = xstrdup (pathspec);
  char *p;
  int has_symlinks = 0;
  while (strlen (tmp_pathspec) && !has_symlinks)
    {
      lt_debugprintf (__FILE__, __LINE__,
		      "checking path component for symlinks: %s\n",
		      tmp_pathspec);
      if (lstat (tmp_pathspec, &s) == 0)
	{
	  if (S_ISLNK (s.st_mode) != 0)
	    {
	      has_symlinks = 1;
	      break;
	    }

	  /* search backwards for last DIR_SEPARATOR */
	  p = tmp_pathspec + strlen (tmp_pathspec) - 1;
	  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
	    p--;
	  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
	    {
	      /* no more DIR_SEPARATORS left */
	      break;
	    }
	  *p = '\0';
	}
      else
	{
	  lt_fatal (__FILE__, __LINE__,
		    "error accessing file \"%s\": %s",
		    tmp_pathspec, nonnull (strerror (errno)));
	}
    }
  XFREE (tmp_pathspec);

  if (!has_symlinks)
    {
      return xstrdup (pathspec);
    }

  tmp_pathspec = realpath (pathspec, buf);
  if (tmp_pathspec == 0)
    {
      lt_fatal (__FILE__, __LINE__,
		"could not follow symlinks for %s", pathspec);
    }
  return xstrdup (tmp_pathspec);
#endif
}

char *
strendzap (char *str, const char *pat)
{
  size_t len, patlen;

  assert (str != NULL);
  assert (pat != NULL);

  len = strlen (str);
  patlen = strlen (pat);

  if (patlen <= len)
    {
      str += len - patlen;
      if (strcmp (str, pat) == 0)
	*str = '\0';
    }
  return str;
}

void
lt_debugprintf (const char *file, int line, const char *fmt, ...)
{
  va_list args;
  if (lt_debug)
    {
      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
      va_start (args, fmt);
      (void) vfprintf (stderr, fmt, args);
      va_end (args);
    }
}

static void
lt_error_core (int exit_status, const char *file,
	       int line, const char *mode,
	       const char *message, va_list ap)
{
  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
  vfprintf (stderr, message, ap);
  fprintf (stderr, ".\n");

  if (exit_status >= 0)
    exit (exit_status);
}

void
lt_fatal (const char *file, int line, const char *message, ...)
{
  va_list ap;
  va_start (ap, message);
  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
  va_end (ap);
}

static const char *
nonnull (const char *s)
{
  return s ? s : "(null)";
}

static const char *
nonempty (const char *s)
{
  return (s && !*s) ? "(empty)" : nonnull (s);
}

void
lt_setenv (const char *name, const char *value)
{
  lt_debugprintf (__FILE__, __LINE__,
		  "(lt_setenv) setting '%s' to '%s'\n",
                  nonnull (name), nonnull (value));
  {
#ifdef HAVE_SETENV
    /* always make a copy, for consistency with !HAVE_SETENV */
    char *str = xstrdup (value);
    setenv (name, str, 1);
#else
    int len = strlen (name) + 1 + strlen (value) + 1;
    char *str = XMALLOC (char, len);
    sprintf (str, "%s=%s", name, value);
    if (putenv (str) != EXIT_SUCCESS)
      {
        XFREE (str);
      }
#endif
  }
}

char *
lt_extend_str (const char *orig_value, const char *add, int to_end)
{
  char *new_value;
  if (orig_value && *orig_value)
    {
      int orig_value_len = strlen (orig_value);
      int add_len = strlen (add);
      new_value = XMALLOC (char, add_len + orig_value_len + 1);
      if (to_end)
        {
          strcpy (new_value, orig_value);
          strcpy (new_value + orig_value_len, add);
        }
      else
        {
          strcpy (new_value, add);
          strcpy (new_value + add_len, orig_value);
        }
    }
  else
    {
      new_value = xstrdup (add);
    }
  return new_value;
}

void
lt_update_exe_path (const char *name, const char *value)
{
  lt_debugprintf (__FILE__, __LINE__,
		  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
                  nonnull (name), nonnull (value));

  if (name && *name && value && *value)
    {
      char *new_value = lt_extend_str (getenv (name), value, 0);
      /* some systems can't cope with a ':'-terminated path #' */
      int len = strlen (new_value);
      while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
        {
          new_value[len-1] = '\0';
        }
      lt_setenv (name, new_value);
      XFREE (new_value);
    }
}

void
lt_update_lib_path (const char *name, const char *value)
{
  lt_debugprintf (__FILE__, __LINE__,
		  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
                  nonnull (name), nonnull (value));

  if (name && *name && value && *value)
    {
      char *new_value = lt_extend_str (getenv (name), value, 0);
      lt_setenv (name, new_value);
      XFREE (new_value);
    }
}

EOF
	    case $host_os in
	      mingw*)
		cat <<"EOF"

/* Prepares an argument vector before calling spawn().
   Note that spawn() does not by itself call the command interpreter
     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
         GetVersionEx(&v);
         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
      }) ? "cmd.exe" : "command.com").
   Instead it simply concatenates the arguments, separated by ' ', and calls
   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
   special way:
   - Space and tab are interpreted as delimiters. They are not treated as
     delimiters if they are surrounded by double quotes: "...".
   - Unescaped double quotes are removed from the input. Their only effect is
     that within double quotes, space and tab are treated like normal
     characters.
   - Backslashes not followed by double quotes are not special.
   - But 2*n+1 backslashes followed by a double quote become
     n backslashes followed by a double quote (n >= 0):
       \" -> "
       \\\" -> \"
       \\\\\" -> \\"
 */
#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
char **
prepare_spawn (char **argv)
{
  size_t argc;
  char **new_argv;
  size_t i;

  /* Count number of arguments.  */
  for (argc = 0; argv[argc] != NULL; argc++)
    ;

  /* Allocate new argument vector.  */
  new_argv = XMALLOC (char *, argc + 1);

  /* Put quoted arguments into the new argument vector.  */
  for (i = 0; i < argc; i++)
    {
      const char *string = argv[i];

      if (string[0] == '\0')
	new_argv[i] = xstrdup ("\"\"");
      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
	{
	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
	  size_t length;
	  unsigned int backslashes;
	  const char *s;
	  char *quoted_string;
	  char *p;

	  length = 0;
	  backslashes = 0;
	  if (quote_around)
	    length++;
	  for (s = string; *s != '\0'; s++)
	    {
	      char c = *s;
	      if (c == '"')
		length += backslashes + 1;
	      length++;
	      if (c == '\\')
		backslashes++;
	      else
		backslashes = 0;
	    }
	  if (quote_around)
	    length += backslashes + 1;

	  quoted_string = XMALLOC (char, length + 1);

	  p = quoted_string;
	  backslashes = 0;
	  if (quote_around)
	    *p++ = '"';
	  for (s = string; *s != '\0'; s++)
	    {
	      char c = *s;
	      if (c == '"')
		{
		  unsigned int j;
		  for (j = backslashes + 1; j > 0; j--)
		    *p++ = '\\';
		}
	      *p++ = c;
	      if (c == '\\')
		backslashes++;
	      else
		backslashes = 0;
	    }
	  if (quote_around)
	    {
	      unsigned int j;
	      for (j = backslashes; j > 0; j--)
		*p++ = '\\';
	      *p++ = '"';
	    }
	  *p = '\0';

	  new_argv[i] = quoted_string;
	}
      else
	new_argv[i] = (char *) string;
    }
  new_argv[argc] = NULL;

  return new_argv;
}
EOF
		;;
	    esac

            cat <<"EOF"
void lt_dump_script (FILE* f)
{
EOF
	    func_emit_wrapper yes |
	      $SED -n -e '
s/^\(.\{79\}\)\(..*\)/\1\
\2/
h
s/\([\\"]\)/\\\1/g
s/$/\\n/
s/\([^\n]*\).*/  fputs ("\1", f);/p
g
D'
            cat <<"EOF"
}
EOF
}
# end: func_emit_cwrapperexe_src

# func_win32_import_lib_p ARG
# True if ARG is an import lib, as indicated by $file_magic_cmd
func_win32_import_lib_p ()
{
    $opt_debug
    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
    *import*) : ;;
    *) false ;;
    esac
}

# func_mode_link arg...
func_mode_link ()
{
    $opt_debug
    case $host in
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
      # It is impossible to link a dll without this setting, and
      # we shouldn't force the makefile maintainer to figure out
      # which system we are compiling for in order to pass an extra
      # flag for every libtool invocation.
      # allow_undefined=no

      # FIXME: Unfortunately, there are problems with the above when trying
      # to make a dll which has undefined symbols, in which case not
      # even a static library is built.  For now, we need to specify
      # -no-undefined on the libtool link line when we can be certain
      # that all symbols are satisfied, otherwise we get a static library.
      allow_undefined=yes
      ;;
    *)
      allow_undefined=yes
      ;;
    esac
    libtool_args=$nonopt
    base_compile="$nonopt $@"
    compile_command=$nonopt
    finalize_command=$nonopt

    compile_rpath=
    finalize_rpath=
    compile_shlibpath=
    finalize_shlibpath=
    convenience=
    old_convenience=
    deplibs=
    old_deplibs=
    compiler_flags=
    linker_flags=
    dllsearchpath=
    lib_search_path=`pwd`
    inst_prefix_dir=
    new_inherited_linker_flags=

    avoid_version=no
    bindir=
    dlfiles=
    dlprefiles=
    dlself=no
    export_dynamic=no
    export_symbols=
    export_symbols_regex=
    generated=
    libobjs=
    ltlibs=
    module=no
    no_install=no
    objs=
    non_pic_objects=
    precious_files_regex=
    prefer_static_libs=no
    preload=no
    prev=
    prevarg=
    release=
    rpath=
    xrpath=
    perm_rpath=
    temp_rpath=
    thread_safe=no
    vinfo=
    vinfo_number=no
    weak_libs=
    single_module="${wl}-single_module"
    func_infer_tag $base_compile

    # We need to know -static, to get the right output filenames.
    for arg
    do
      case $arg in
      -shared)
	test "$build_libtool_libs" != yes && \
	  func_fatal_configuration "can not build a shared library"
	build_old_libs=no
	break
	;;
      -all-static | -static | -static-libtool-libs)
	case $arg in
	-all-static)
	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
	    func_warning "complete static linking is impossible in this configuration"
	  fi
	  if test -n "$link_static_flag"; then
	    dlopen_self=$dlopen_self_static
	  fi
	  prefer_static_libs=yes
	  ;;
	-static)
	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
	    dlopen_self=$dlopen_self_static
	  fi
	  prefer_static_libs=built
	  ;;
	-static-libtool-libs)
	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
	    dlopen_self=$dlopen_self_static
	  fi
	  prefer_static_libs=yes
	  ;;
	esac
	build_libtool_libs=no
	build_old_libs=yes
	break
	;;
      esac
    done

    # See if our shared archives depend on static archives.
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes

    # Go through the arguments, transforming them on the way.
    while test "$#" -gt 0; do
      arg="$1"
      shift
      func_quote_for_eval "$arg"
      qarg=$func_quote_for_eval_unquoted_result
      func_append libtool_args " $func_quote_for_eval_result"

      # If the previous option needs an argument, assign it.
      if test -n "$prev"; then
	case $prev in
	output)
	  func_append compile_command " @OUTPUT@"
	  func_append finalize_command " @OUTPUT@"
	  ;;
	esac

	case $prev in
	bindir)
	  bindir="$arg"
	  prev=
	  continue
	  ;;
	dlfiles|dlprefiles)
	  if test "$preload" = no; then
	    # Add the symbol object into the linking commands.
	    func_append compile_command " @SYMFILE@"
	    func_append finalize_command " @SYMFILE@"
	    preload=yes
	  fi
	  case $arg in
	  *.la | *.lo) ;;  # We handle these cases below.
	  force)
	    if test "$dlself" = no; then
	      dlself=needless
	      export_dynamic=yes
	    fi
	    prev=
	    continue
	    ;;
	  self)
	    if test "$prev" = dlprefiles; then
	      dlself=yes
	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
	      dlself=yes
	    else
	      dlself=needless
	      export_dynamic=yes
	    fi
	    prev=
	    continue
	    ;;
	  *)
	    if test "$prev" = dlfiles; then
	      func_append dlfiles " $arg"
	    else
	      func_append dlprefiles " $arg"
	    fi
	    prev=
	    continue
	    ;;
	  esac
	  ;;
	expsyms)
	  export_symbols="$arg"
	  test -f "$arg" \
	    || func_fatal_error "symbol file \`$arg' does not exist"
	  prev=
	  continue
	  ;;
	expsyms_regex)
	  export_symbols_regex="$arg"
	  prev=
	  continue
	  ;;
	framework)
	  case $host in
	    *-*-darwin*)
	      case "$deplibs " in
		*" $qarg.ltframework "*) ;;
		*) func_append deplibs " $qarg.ltframework" # this is fixed later
		   ;;
	      esac
	      ;;
	  esac
	  prev=
	  continue
	  ;;
	inst_prefix)
	  inst_prefix_dir="$arg"
	  prev=
	  continue
	  ;;
	objectlist)
	  if test -f "$arg"; then
	    save_arg=$arg
	    moreargs=
	    for fil in `cat "$save_arg"`
	    do
#	      func_append moreargs " $fil"
	      arg=$fil
	      # A libtool-controlled object.

	      # Check to see that this really is a libtool object.
	      if func_lalib_unsafe_p "$arg"; then
		pic_object=
		non_pic_object=

		# Read the .lo file
		func_source "$arg"

		if test -z "$pic_object" ||
		   test -z "$non_pic_object" ||
		   test "$pic_object" = none &&
		   test "$non_pic_object" = none; then
		  func_fatal_error "cannot find name of object for \`$arg'"
		fi

		# Extract subdirectory from the argument.
		func_dirname "$arg" "/" ""
		xdir="$func_dirname_result"

		if test "$pic_object" != none; then
		  # Prepend the subdirectory the object is found in.
		  pic_object="$xdir$pic_object"

		  if test "$prev" = dlfiles; then
		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
		      func_append dlfiles " $pic_object"
		      prev=
		      continue
		    else
		      # If libtool objects are unsupported, then we need to preload.
		      prev=dlprefiles
		    fi
		  fi

		  # CHECK ME:  I think I busted this.  -Ossama
		  if test "$prev" = dlprefiles; then
		    # Preload the old-style object.
		    func_append dlprefiles " $pic_object"
		    prev=
		  fi

		  # A PIC object.
		  func_append libobjs " $pic_object"
		  arg="$pic_object"
		fi

		# Non-PIC object.
		if test "$non_pic_object" != none; then
		  # Prepend the subdirectory the object is found in.
		  non_pic_object="$xdir$non_pic_object"

		  # A standard non-PIC object
		  func_append non_pic_objects " $non_pic_object"
		  if test -z "$pic_object" || test "$pic_object" = none ; then
		    arg="$non_pic_object"
		  fi
		else
		  # If the PIC object exists, use it instead.
		  # $xdir was prepended to $pic_object above.
		  non_pic_object="$pic_object"
		  func_append non_pic_objects " $non_pic_object"
		fi
	      else
		# Only an error if not doing a dry-run.
		if $opt_dry_run; then
		  # Extract subdirectory from the argument.
		  func_dirname "$arg" "/" ""
		  xdir="$func_dirname_result"

		  func_lo2o "$arg"
		  pic_object=$xdir$objdir/$func_lo2o_result
		  non_pic_object=$xdir$func_lo2o_result
		  func_append libobjs " $pic_object"
		  func_append non_pic_objects " $non_pic_object"
	        else
		  func_fatal_error "\`$arg' is not a valid libtool object"
		fi
	      fi
	    done
	  else
	    func_fatal_error "link input file \`$arg' does not exist"
	  fi
	  arg=$save_arg
	  prev=
	  continue
	  ;;
	precious_regex)
	  precious_files_regex="$arg"
	  prev=
	  continue
	  ;;
	release)
	  release="-$arg"
	  prev=
	  continue
	  ;;
	rpath | xrpath)
	  # We need an absolute path.
	  case $arg in
	  [\\/]* | [A-Za-z]:[\\/]*) ;;
	  *)
	    func_fatal_error "only absolute run-paths are allowed"
	    ;;
	  esac
	  if test "$prev" = rpath; then
	    case "$rpath " in
	    *" $arg "*) ;;
	    *) func_append rpath " $arg" ;;
	    esac
	  else
	    case "$xrpath " in
	    *" $arg "*) ;;
	    *) func_append xrpath " $arg" ;;
	    esac
	  fi
	  prev=
	  continue
	  ;;
	shrext)
	  shrext_cmds="$arg"
	  prev=
	  continue
	  ;;
	weak)
	  func_append weak_libs " $arg"
	  prev=
	  continue
	  ;;
	xcclinker)
	  func_append linker_flags " $qarg"
	  func_append compiler_flags " $qarg"
	  prev=
	  func_append compile_command " $qarg"
	  func_append finalize_command " $qarg"
	  continue
	  ;;
	xcompiler)
	  func_append compiler_flags " $qarg"
	  prev=
	  func_append compile_command " $qarg"
	  func_append finalize_command " $qarg"
	  continue
	  ;;
	xlinker)
	  func_append linker_flags " $qarg"
	  func_append compiler_flags " $wl$qarg"
	  prev=
	  func_append compile_command " $wl$qarg"
	  func_append finalize_command " $wl$qarg"
	  continue
	  ;;
	*)
	  eval "$prev=\"\$arg\""
	  prev=
	  continue
	  ;;
	esac
      fi # test -n "$prev"

      prevarg="$arg"

      case $arg in
      -all-static)
	if test -n "$link_static_flag"; then
	  # See comment for -static flag below, for more details.
	  func_append compile_command " $link_static_flag"
	  func_append finalize_command " $link_static_flag"
	fi
	continue
	;;

      -allow-undefined)
	# FIXME: remove this flag sometime in the future.
	func_fatal_error "\`-allow-undefined' must not be used because it is the default"
	;;

      -avoid-version)
	avoid_version=yes
	continue
	;;

      -bindir)
	prev=bindir
	continue
	;;

      -dlopen)
	prev=dlfiles
	continue
	;;

      -dlpreopen)
	prev=dlprefiles
	continue
	;;

      -export-dynamic)
	export_dynamic=yes
	continue
	;;

      -export-symbols | -export-symbols-regex)
	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
	  func_fatal_error "more than one -exported-symbols argument is not allowed"
	fi
	if test "X$arg" = "X-export-symbols"; then
	  prev=expsyms
	else
	  prev=expsyms_regex
	fi
	continue
	;;

      -framework)
	prev=framework
	continue
	;;

      -inst-prefix-dir)
	prev=inst_prefix
	continue
	;;

      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
      # so, if we see these flags be careful not to treat them like -L
      -L[A-Z][A-Z]*:*)
	case $with_gcc/$host in
	no/*-*-irix* | /*-*-irix*)
	  func_append compile_command " $arg"
	  func_append finalize_command " $arg"
	  ;;
	esac
	continue
	;;

      -L*)
	func_stripname "-L" '' "$arg"
	if test -z "$func_stripname_result"; then
	  if test "$#" -gt 0; then
	    func_fatal_error "require no space between \`-L' and \`$1'"
	  else
	    func_fatal_error "need path for \`-L' option"
	  fi
	fi
	func_resolve_sysroot "$func_stripname_result"
	dir=$func_resolve_sysroot_result
	# We need an absolute path.
	case $dir in
	[\\/]* | [A-Za-z]:[\\/]*) ;;
	*)
	  absdir=`cd "$dir" && pwd`
	  test -z "$absdir" && \
	    func_fatal_error "cannot determine absolute directory name of \`$dir'"
	  dir="$absdir"
	  ;;
	esac
	case "$deplibs " in
	*" -L$dir "* | *" $arg "*)
	  # Will only happen for absolute or sysroot arguments
	  ;;
	*)
	  # Preserve sysroot, but never include relative directories
	  case $dir in
	    [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
	    *) func_append deplibs " -L$dir" ;;
	  esac
	  func_append lib_search_path " $dir"
	  ;;
	esac
	case $host in
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
	  case :$dllsearchpath: in
	  *":$dir:"*) ;;
	  ::) dllsearchpath=$dir;;
	  *) func_append dllsearchpath ":$dir";;
	  esac
	  case :$dllsearchpath: in
	  *":$testbindir:"*) ;;
	  ::) dllsearchpath=$testbindir;;
	  *) func_append dllsearchpath ":$testbindir";;
	  esac
	  ;;
	esac
	continue
	;;

      -l*)
	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
	  case $host in
	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
	    # These systems don't actually have a C or math library (as such)
	    continue
	    ;;
	  *-*-os2*)
	    # These systems don't actually have a C library (as such)
	    test "X$arg" = "X-lc" && continue
	    ;;
	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
	    # Do not include libc due to us having libc/libc_r.
	    test "X$arg" = "X-lc" && continue
	    ;;
	  *-*-rhapsody* | *-*-darwin1.[012])
	    # Rhapsody C and math libraries are in the System framework
	    func_append deplibs " System.ltframework"
	    continue
	    ;;
	  *-*-sco3.2v5* | *-*-sco5v6*)
	    # Causes problems with __ctype
	    test "X$arg" = "X-lc" && continue
	    ;;
	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
	    # Compiler inserts libc in the correct place for threads to work
	    test "X$arg" = "X-lc" && continue
	    ;;
	  esac
	elif test "X$arg" = "X-lc_r"; then
	 case $host in
	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
	   # Do not include libc_r directly, use -pthread flag.
	   continue
	   ;;
	 esac
	fi
	func_append deplibs " $arg"
	continue
	;;

      -module)
	module=yes
	continue
	;;

      # Tru64 UNIX uses -model [arg] to determine the layout of C++
      # classes, name mangling, and exception handling.
      # Darwin uses the -arch flag to determine output architecture.
      -model|-arch|-isysroot|--sysroot)
	func_append compiler_flags " $arg"
	func_append compile_command " $arg"
	func_append finalize_command " $arg"
	prev=xcompiler
	continue
	;;

      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
	func_append compiler_flags " $arg"
	func_append compile_command " $arg"
	func_append finalize_command " $arg"
	case "$new_inherited_linker_flags " in
	    *" $arg "*) ;;
	    * ) func_append new_inherited_linker_flags " $arg" ;;
	esac
	continue
	;;

      -multi_module)
	single_module="${wl}-multi_module"
	continue
	;;

      -no-fast-install)
	fast_install=no
	continue
	;;

      -no-install)
	case $host in
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
	  # The PATH hackery in wrapper scripts is required on Windows
	  # and Darwin in order for the loader to find any dlls it needs.
	  func_warning "\`-no-install' is ignored for $host"
	  func_warning "assuming \`-no-fast-install' instead"
	  fast_install=no
	  ;;
	*) no_install=yes ;;
	esac
	continue
	;;

      -no-undefined)
	allow_undefined=no
	continue
	;;

      -objectlist)
	prev=objectlist
	continue
	;;

      -o) prev=output ;;

      -precious-files-regex)
	prev=precious_regex
	continue
	;;

      -release)
	prev=release
	continue
	;;

      -rpath)
	prev=rpath
	continue
	;;

      -R)
	prev=xrpath
	continue
	;;

      -R*)
	func_stripname '-R' '' "$arg"
	dir=$func_stripname_result
	# We need an absolute path.
	case $dir in
	[\\/]* | [A-Za-z]:[\\/]*) ;;
	=*)
	  func_stripname '=' '' "$dir"
	  dir=$lt_sysroot$func_stripname_result
	  ;;
	*)
	  func_fatal_error "only absolute run-paths are allowed"
	  ;;
	esac
	case "$xrpath " in
	*" $dir "*) ;;
	*) func_append xrpath " $dir" ;;
	esac
	continue
	;;

      -shared)
	# The effects of -shared are defined in a previous loop.
	continue
	;;

      -shrext)
	prev=shrext
	continue
	;;

      -static | -static-libtool-libs)
	# The effects of -static are defined in a previous loop.
	# We used to do the same as -all-static on platforms that
	# didn't have a PIC flag, but the assumption that the effects
	# would be equivalent was wrong.  It would break on at least
	# Digital Unix and AIX.
	continue
	;;

      -thread-safe)
	thread_safe=yes
	continue
	;;

      -version-info)
	prev=vinfo
	continue
	;;

      -version-number)
	prev=vinfo
	vinfo_number=yes
	continue
	;;

      -weak)
        prev=weak
	continue
	;;

      -Wc,*)
	func_stripname '-Wc,' '' "$arg"
	args=$func_stripname_result
	arg=
	save_ifs="$IFS"; IFS=','
	for flag in $args; do
	  IFS="$save_ifs"
          func_quote_for_eval "$flag"
	  func_append arg " $func_quote_for_eval_result"
	  func_append compiler_flags " $func_quote_for_eval_result"
	done
	IFS="$save_ifs"
	func_stripname ' ' '' "$arg"
	arg=$func_stripname_result
	;;

      -Wl,*)
	func_stripname '-Wl,' '' "$arg"
	args=$func_stripname_result
	arg=
	save_ifs="$IFS"; IFS=','
	for flag in $args; do
	  IFS="$save_ifs"
          func_quote_for_eval "$flag"
	  func_append arg " $wl$func_quote_for_eval_result"
	  func_append compiler_flags " $wl$func_quote_for_eval_result"
	  func_append linker_flags " $func_quote_for_eval_result"
	done
	IFS="$save_ifs"
	func_stripname ' ' '' "$arg"
	arg=$func_stripname_result
	;;

      -Xcompiler)
	prev=xcompiler
	continue
	;;

      -Xlinker)
	prev=xlinker
	continue
	;;

      -XCClinker)
	prev=xcclinker
	continue
	;;

      # -msg_* for osf cc
      -msg_*)
	func_quote_for_eval "$arg"
	arg="$func_quote_for_eval_result"
	;;

      # Flags to be passed through unchanged, with rationale:
      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
      # -r[0-9][0-9]*        specify processor for the SGI compiler
      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
      # +DA*, +DD*           enable 64-bit mode for the HP compiler
      # -q*                  compiler args for the IBM compiler
      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
      # -F/path              path to uninstalled frameworks, gcc on darwin
      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
      # @file                GCC response files
      # -tp=*                Portland pgcc target processor selection
      # --sysroot=*          for sysroot support
      # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
      -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
        func_quote_for_eval "$arg"
	arg="$func_quote_for_eval_result"
        func_append compile_command " $arg"
        func_append finalize_command " $arg"
        func_append compiler_flags " $arg"
        continue
        ;;

      # Some other compiler flag.
      -* | +*)
        func_quote_for_eval "$arg"
	arg="$func_quote_for_eval_result"
	;;

      *.$objext)
	# A standard object.
	func_append objs " $arg"
	;;

      *.lo)
	# A libtool-controlled object.

	# Check to see that this really is a libtool object.
	if func_lalib_unsafe_p "$arg"; then
	  pic_object=
	  non_pic_object=

	  # Read the .lo file
	  func_source "$arg"

	  if test -z "$pic_object" ||
	     test -z "$non_pic_object" ||
	     test "$pic_object" = none &&
	     test "$non_pic_object" = none; then
	    func_fatal_error "cannot find name of object for \`$arg'"
	  fi

	  # Extract subdirectory from the argument.
	  func_dirname "$arg" "/" ""
	  xdir="$func_dirname_result"

	  if test "$pic_object" != none; then
	    # Prepend the subdirectory the object is found in.
	    pic_object="$xdir$pic_object"

	    if test "$prev" = dlfiles; then
	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
		func_append dlfiles " $pic_object"
		prev=
		continue
	      else
		# If libtool objects are unsupported, then we need to preload.
		prev=dlprefiles
	      fi
	    fi

	    # CHECK ME:  I think I busted this.  -Ossama
	    if test "$prev" = dlprefiles; then
	      # Preload the old-style object.
	      func_append dlprefiles " $pic_object"
	      prev=
	    fi

	    # A PIC object.
	    func_append libobjs " $pic_object"
	    arg="$pic_object"
	  fi

	  # Non-PIC object.
	  if test "$non_pic_object" != none; then
	    # Prepend the subdirectory the object is found in.
	    non_pic_object="$xdir$non_pic_object"

	    # A standard non-PIC object
	    func_append non_pic_objects " $non_pic_object"
	    if test -z "$pic_object" || test "$pic_object" = none ; then
	      arg="$non_pic_object"
	    fi
	  else
	    # If the PIC object exists, use it instead.
	    # $xdir was prepended to $pic_object above.
	    non_pic_object="$pic_object"
	    func_append non_pic_objects " $non_pic_object"
	  fi
	else
	  # Only an error if not doing a dry-run.
	  if $opt_dry_run; then
	    # Extract subdirectory from the argument.
	    func_dirname "$arg" "/" ""
	    xdir="$func_dirname_result"

	    func_lo2o "$arg"
	    pic_object=$xdir$objdir/$func_lo2o_result
	    non_pic_object=$xdir$func_lo2o_result
	    func_append libobjs " $pic_object"
	    func_append non_pic_objects " $non_pic_object"
	  else
	    func_fatal_error "\`$arg' is not a valid libtool object"
	  fi
	fi
	;;

      *.$libext)
	# An archive.
	func_append deplibs " $arg"
	func_append old_deplibs " $arg"
	continue
	;;

      *.la)
	# A libtool-controlled library.

	func_resolve_sysroot "$arg"
	if test "$prev" = dlfiles; then
	  # This library was specified with -dlopen.
	  func_append dlfiles " $func_resolve_sysroot_result"
	  prev=
	elif test "$prev" = dlprefiles; then
	  # The library was specified with -dlpreopen.
	  func_append dlprefiles " $func_resolve_sysroot_result"
	  prev=
	else
	  func_append deplibs " $func_resolve_sysroot_result"
	fi
	continue
	;;

      # Some other compiler argument.
      *)
	# Unknown arguments in both finalize_command and compile_command need
	# to be aesthetically quoted because they are evaled later.
	func_quote_for_eval "$arg"
	arg="$func_quote_for_eval_result"
	;;
      esac # arg

      # Now actually substitute the argument into the commands.
      if test -n "$arg"; then
	func_append compile_command " $arg"
	func_append finalize_command " $arg"
      fi
    done # argument parsing loop

    test -n "$prev" && \
      func_fatal_help "the \`$prevarg' option requires an argument"

    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
      eval arg=\"$export_dynamic_flag_spec\"
      func_append compile_command " $arg"
      func_append finalize_command " $arg"
    fi

    oldlibs=
    # calculate the name of the file, without its directory
    func_basename "$output"
    outputname="$func_basename_result"
    libobjs_save="$libobjs"

    if test -n "$shlibpath_var"; then
      # get the directories listed in $shlibpath_var
      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
    else
      shlib_search_path=
    fi
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"

    func_dirname "$output" "/" ""
    output_objdir="$func_dirname_result$objdir"
    func_to_tool_file "$output_objdir/"
    tool_output_objdir=$func_to_tool_file_result
    # Create the object directory.
    func_mkdir_p "$output_objdir"

    # Determine the type of output
    case $output in
    "")
      func_fatal_help "you must specify an output file"
      ;;
    *.$libext) linkmode=oldlib ;;
    *.lo | *.$objext) linkmode=obj ;;
    *.la) linkmode=lib ;;
    *) linkmode=prog ;; # Anything else should be a program.
    esac

    specialdeplibs=

    libs=
    # Find all interdependent deplibs by searching for libraries
    # that are linked more than once (e.g. -la -lb -la)
    for deplib in $deplibs; do
      if $opt_preserve_dup_deps ; then
	case "$libs " in
	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
	esac
      fi
      func_append libs " $deplib"
    done

    if test "$linkmode" = lib; then
      libs="$predeps $libs $compiler_lib_search_path $postdeps"

      # Compute libraries that are listed more than once in $predeps
      # $postdeps and mark them as special (i.e., whose duplicates are
      # not to be eliminated).
      pre_post_deps=
      if $opt_duplicate_compiler_generated_deps; then
	for pre_post_dep in $predeps $postdeps; do
	  case "$pre_post_deps " in
	  *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
	  esac
	  func_append pre_post_deps " $pre_post_dep"
	done
      fi
      pre_post_deps=
    fi

    deplibs=
    newdependency_libs=
    newlib_search_path=
    need_relink=no # whether we're linking any uninstalled libtool libraries
    notinst_deplibs= # not-installed libtool libraries
    notinst_path= # paths that contain not-installed libtool libraries

    case $linkmode in
    lib)
	passes="conv dlpreopen link"
	for file in $dlfiles $dlprefiles; do
	  case $file in
	  *.la) ;;
	  *)
	    func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
	    ;;
	  esac
	done
	;;
    prog)
	compile_deplibs=
	finalize_deplibs=
	alldeplibs=no
	newdlfiles=
	newdlprefiles=
	passes="conv scan dlopen dlpreopen link"
	;;
    *)  passes="conv"
	;;
    esac

    for pass in $passes; do
      # The preopen pass in lib mode reverses $deplibs; put it back here
      # so that -L comes before libs that need it for instance...
      if test "$linkmode,$pass" = "lib,link"; then
	## FIXME: Find the place where the list is rebuilt in the wrong
	##        order, and fix it there properly
        tmp_deplibs=
	for deplib in $deplibs; do
	  tmp_deplibs="$deplib $tmp_deplibs"
	done
	deplibs="$tmp_deplibs"
      fi

      if test "$linkmode,$pass" = "lib,link" ||
	 test "$linkmode,$pass" = "prog,scan"; then
	libs="$deplibs"
	deplibs=
      fi
      if test "$linkmode" = prog; then
	case $pass in
	dlopen) libs="$dlfiles" ;;
	dlpreopen) libs="$dlprefiles" ;;
	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
	esac
      fi
      if test "$linkmode,$pass" = "lib,dlpreopen"; then
	# Collect and forward deplibs of preopened libtool libs
	for lib in $dlprefiles; do
	  # Ignore non-libtool-libs
	  dependency_libs=
	  func_resolve_sysroot "$lib"
	  case $lib in
	  *.la)	func_source "$func_resolve_sysroot_result" ;;
	  esac

	  # Collect preopened libtool deplibs, except any this library
	  # has declared as weak libs
	  for deplib in $dependency_libs; do
	    func_basename "$deplib"
            deplib_base=$func_basename_result
	    case " $weak_libs " in
	    *" $deplib_base "*) ;;
	    *) func_append deplibs " $deplib" ;;
	    esac
	  done
	done
	libs="$dlprefiles"
      fi
      if test "$pass" = dlopen; then
	# Collect dlpreopened libraries
	save_deplibs="$deplibs"
	deplibs=
      fi

      for deplib in $libs; do
	lib=
	found=no
	case $deplib in
	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
	  if test "$linkmode,$pass" = "prog,link"; then
	    compile_deplibs="$deplib $compile_deplibs"
	    finalize_deplibs="$deplib $finalize_deplibs"
	  else
	    func_append compiler_flags " $deplib"
	    if test "$linkmode" = lib ; then
		case "$new_inherited_linker_flags " in
		    *" $deplib "*) ;;
		    * ) func_append new_inherited_linker_flags " $deplib" ;;
		esac
	    fi
	  fi
	  continue
	  ;;
	-l*)
	  if test "$linkmode" != lib && test "$linkmode" != prog; then
	    func_warning "\`-l' is ignored for archives/objects"
	    continue
	  fi
	  func_stripname '-l' '' "$deplib"
	  name=$func_stripname_result
	  if test "$linkmode" = lib; then
	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
	  else
	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
	  fi
	  for searchdir in $searchdirs; do
	    for search_ext in .la $std_shrext .so .a; do
	      # Search the libtool library
	      lib="$searchdir/lib${name}${search_ext}"
	      if test -f "$lib"; then
		if test "$search_ext" = ".la"; then
		  found=yes
		else
		  found=no
		fi
		break 2
	      fi
	    done
	  done
	  if test "$found" != yes; then
	    # deplib doesn't seem to be a libtool library
	    if test "$linkmode,$pass" = "prog,link"; then
	      compile_deplibs="$deplib $compile_deplibs"
	      finalize_deplibs="$deplib $finalize_deplibs"
	    else
	      deplibs="$deplib $deplibs"
	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
	    fi
	    continue
	  else # deplib is a libtool library
	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
	    # We need to do some special things here, and not later.
	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	      case " $predeps $postdeps " in
	      *" $deplib "*)
		if func_lalib_p "$lib"; then
		  library_names=
		  old_library=
		  func_source "$lib"
		  for l in $old_library $library_names; do
		    ll="$l"
		  done
		  if test "X$ll" = "X$old_library" ; then # only static version available
		    found=no
		    func_dirname "$lib" "" "."
		    ladir="$func_dirname_result"
		    lib=$ladir/$old_library
		    if test "$linkmode,$pass" = "prog,link"; then
		      compile_deplibs="$deplib $compile_deplibs"
		      finalize_deplibs="$deplib $finalize_deplibs"
		    else
		      deplibs="$deplib $deplibs"
		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
		    fi
		    continue
		  fi
		fi
		;;
	      *) ;;
	      esac
	    fi
	  fi
	  ;; # -l
	*.ltframework)
	  if test "$linkmode,$pass" = "prog,link"; then
	    compile_deplibs="$deplib $compile_deplibs"
	    finalize_deplibs="$deplib $finalize_deplibs"
	  else
	    deplibs="$deplib $deplibs"
	    if test "$linkmode" = lib ; then
		case "$new_inherited_linker_flags " in
		    *" $deplib "*) ;;
		    * ) func_append new_inherited_linker_flags " $deplib" ;;
		esac
	    fi
	  fi
	  continue
	  ;;
	-L*)
	  case $linkmode in
	  lib)
	    deplibs="$deplib $deplibs"
	    test "$pass" = conv && continue
	    newdependency_libs="$deplib $newdependency_libs"
	    func_stripname '-L' '' "$deplib"
	    func_resolve_sysroot "$func_stripname_result"
	    func_append newlib_search_path " $func_resolve_sysroot_result"
	    ;;
	  prog)
	    if test "$pass" = conv; then
	      deplibs="$deplib $deplibs"
	      continue
	    fi
	    if test "$pass" = scan; then
	      deplibs="$deplib $deplibs"
	    else
	      compile_deplibs="$deplib $compile_deplibs"
	      finalize_deplibs="$deplib $finalize_deplibs"
	    fi
	    func_stripname '-L' '' "$deplib"
	    func_resolve_sysroot "$func_stripname_result"
	    func_append newlib_search_path " $func_resolve_sysroot_result"
	    ;;
	  *)
	    func_warning "\`-L' is ignored for archives/objects"
	    ;;
	  esac # linkmode
	  continue
	  ;; # -L
	-R*)
	  if test "$pass" = link; then
	    func_stripname '-R' '' "$deplib"
	    func_resolve_sysroot "$func_stripname_result"
	    dir=$func_resolve_sysroot_result
	    # Make sure the xrpath contains only unique directories.
	    case "$xrpath " in
	    *" $dir "*) ;;
	    *) func_append xrpath " $dir" ;;
	    esac
	  fi
	  deplibs="$deplib $deplibs"
	  continue
	  ;;
	*.la)
	  func_resolve_sysroot "$deplib"
	  lib=$func_resolve_sysroot_result
	  ;;
	*.$libext)
	  if test "$pass" = conv; then
	    deplibs="$deplib $deplibs"
	    continue
	  fi
	  case $linkmode in
	  lib)
	    # Linking convenience modules into shared libraries is allowed,
	    # but linking other static libraries is non-portable.
	    case " $dlpreconveniencelibs " in
	    *" $deplib "*) ;;
	    *)
	      valid_a_lib=no
	      case $deplibs_check_method in
		match_pattern*)
		  set dummy $deplibs_check_method; shift
		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
		    | $EGREP "$match_pattern_regex" > /dev/null; then
		    valid_a_lib=yes
		  fi
		;;
		pass_all)
		  valid_a_lib=yes
		;;
	      esac
	      if test "$valid_a_lib" != yes; then
		echo
		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
		echo "*** I have the capability to make that library automatically link in when"
		echo "*** you link to this library.  But I can only do this if you have a"
		echo "*** shared version of the library, which you do not appear to have"
		echo "*** because the file extensions .$libext of this argument makes me believe"
		echo "*** that it is just a static archive that I should not use here."
	      else
		echo
		$ECHO "*** Warning: Linking the shared library $output against the"
		$ECHO "*** static library $deplib is not portable!"
		deplibs="$deplib $deplibs"
	      fi
	      ;;
	    esac
	    continue
	    ;;
	  prog)
	    if test "$pass" != link; then
	      deplibs="$deplib $deplibs"
	    else
	      compile_deplibs="$deplib $compile_deplibs"
	      finalize_deplibs="$deplib $finalize_deplibs"
	    fi
	    continue
	    ;;
	  esac # linkmode
	  ;; # *.$libext
	*.lo | *.$objext)
	  if test "$pass" = conv; then
	    deplibs="$deplib $deplibs"
	  elif test "$linkmode" = prog; then
	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
	      # If there is no dlopen support or we're linking statically,
	      # we need to preload.
	      func_append newdlprefiles " $deplib"
	      compile_deplibs="$deplib $compile_deplibs"
	      finalize_deplibs="$deplib $finalize_deplibs"
	    else
	      func_append newdlfiles " $deplib"
	    fi
	  fi
	  continue
	  ;;
	%DEPLIBS%)
	  alldeplibs=yes
	  continue
	  ;;
	esac # case $deplib

	if test "$found" = yes || test -f "$lib"; then :
	else
	  func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
	fi

	# Check to see that this really is a libtool archive.
	func_lalib_unsafe_p "$lib" \
	  || func_fatal_error "\`$lib' is not a valid libtool archive"

	func_dirname "$lib" "" "."
	ladir="$func_dirname_result"

	dlname=
	dlopen=
	dlpreopen=
	libdir=
	library_names=
	old_library=
	inherited_linker_flags=
	# If the library was installed with an old release of libtool,
	# it will not redefine variables installed, or shouldnotlink
	installed=yes
	shouldnotlink=no
	avoidtemprpath=


	# Read the .la file
	func_source "$lib"

	# Convert "-framework foo" to "foo.ltframework"
	if test -n "$inherited_linker_flags"; then
	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
	    case " $new_inherited_linker_flags " in
	      *" $tmp_inherited_linker_flag "*) ;;
	      *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
	    esac
	  done
	fi
	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
	if test "$linkmode,$pass" = "lib,link" ||
	   test "$linkmode,$pass" = "prog,scan" ||
	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
	  test -n "$dlopen" && func_append dlfiles " $dlopen"
	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
	fi

	if test "$pass" = conv; then
	  # Only check for convenience libraries
	  deplibs="$lib $deplibs"
	  if test -z "$libdir"; then
	    if test -z "$old_library"; then
	      func_fatal_error "cannot find name of link library for \`$lib'"
	    fi
	    # It is a libtool convenience library, so add in its objects.
	    func_append convenience " $ladir/$objdir/$old_library"
	    func_append old_convenience " $ladir/$objdir/$old_library"
	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
	    func_fatal_error "\`$lib' is not a convenience library"
	  fi
	  tmp_libs=
	  for deplib in $dependency_libs; do
	    deplibs="$deplib $deplibs"
	    if $opt_preserve_dup_deps ; then
	      case "$tmp_libs " in
	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
	      esac
	    fi
	    func_append tmp_libs " $deplib"
	  done
	  continue
	fi # $pass = conv


	# Get the name of the library we link against.
	linklib=
	if test -n "$old_library" &&
	   { test "$prefer_static_libs" = yes ||
	     test "$prefer_static_libs,$installed" = "built,no"; }; then
	  linklib=$old_library
	else
	  for l in $old_library $library_names; do
	    linklib="$l"
	  done
	fi
	if test -z "$linklib"; then
	  func_fatal_error "cannot find name of link library for \`$lib'"
	fi

	# This library was specified with -dlopen.
	if test "$pass" = dlopen; then
	  if test -z "$libdir"; then
	    func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
	  fi
	  if test -z "$dlname" ||
	     test "$dlopen_support" != yes ||
	     test "$build_libtool_libs" = no; then
	    # If there is no dlname, no dlopen support or we're linking
	    # statically, we need to preload.  We also need to preload any
	    # dependent libraries so libltdl's deplib preloader doesn't
	    # bomb out in the load deplibs phase.
	    func_append dlprefiles " $lib $dependency_libs"
	  else
	    func_append newdlfiles " $lib"
	  fi
	  continue
	fi # $pass = dlopen

	# We need an absolute path.
	case $ladir in
	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
	*)
	  abs_ladir=`cd "$ladir" && pwd`
	  if test -z "$abs_ladir"; then
	    func_warning "cannot determine absolute directory name of \`$ladir'"
	    func_warning "passing it literally to the linker, although it might fail"
	    abs_ladir="$ladir"
	  fi
	  ;;
	esac
	func_basename "$lib"
	laname="$func_basename_result"

	# Find the relevant object directory and library name.
	if test "X$installed" = Xyes; then
	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
	    func_warning "library \`$lib' was moved."
	    dir="$ladir"
	    absdir="$abs_ladir"
	    libdir="$abs_ladir"
	  else
	    dir="$lt_sysroot$libdir"
	    absdir="$lt_sysroot$libdir"
	  fi
	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
	else
	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
	    dir="$ladir"
	    absdir="$abs_ladir"
	    # Remove this search path later
	    func_append notinst_path " $abs_ladir"
	  else
	    dir="$ladir/$objdir"
	    absdir="$abs_ladir/$objdir"
	    # Remove this search path later
	    func_append notinst_path " $abs_ladir"
	  fi
	fi # $installed = yes
	func_stripname 'lib' '.la' "$laname"
	name=$func_stripname_result

	# This library was specified with -dlpreopen.
	if test "$pass" = dlpreopen; then
	  if test -z "$libdir" && test "$linkmode" = prog; then
	    func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
	  fi
	  case "$host" in
	    # special handling for platforms with PE-DLLs.
	    *cygwin* | *mingw* | *cegcc* )
	      # Linker will automatically link against shared library if both
	      # static and shared are present.  Therefore, ensure we extract
	      # symbols from the import library if a shared library is present
	      # (otherwise, the dlopen module name will be incorrect).  We do
	      # this by putting the import library name into $newdlprefiles.
	      # We recover the dlopen module name by 'saving' the la file
	      # name in a special purpose variable, and (later) extracting the
	      # dlname from the la file.
	      if test -n "$dlname"; then
	        func_tr_sh "$dir/$linklib"
	        eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
	        func_append newdlprefiles " $dir/$linklib"
	      else
	        func_append newdlprefiles " $dir/$old_library"
	        # Keep a list of preopened convenience libraries to check
	        # that they are being used correctly in the link pass.
	        test -z "$libdir" && \
	          func_append dlpreconveniencelibs " $dir/$old_library"
	      fi
	    ;;
	    * )
	      # Prefer using a static library (so that no silly _DYNAMIC symbols
	      # are required to link).
	      if test -n "$old_library"; then
	        func_append newdlprefiles " $dir/$old_library"
	        # Keep a list of preopened convenience libraries to check
	        # that they are being used correctly in the link pass.
	        test -z "$libdir" && \
	          func_append dlpreconveniencelibs " $dir/$old_library"
	      # Otherwise, use the dlname, so that lt_dlopen finds it.
	      elif test -n "$dlname"; then
	        func_append newdlprefiles " $dir/$dlname"
	      else
	        func_append newdlprefiles " $dir/$linklib"
	      fi
	    ;;
	  esac
	fi # $pass = dlpreopen

	if test -z "$libdir"; then
	  # Link the convenience library
	  if test "$linkmode" = lib; then
	    deplibs="$dir/$old_library $deplibs"
	  elif test "$linkmode,$pass" = "prog,link"; then
	    compile_deplibs="$dir/$old_library $compile_deplibs"
	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
	  else
	    deplibs="$lib $deplibs" # used for prog,scan pass
	  fi
	  continue
	fi


	if test "$linkmode" = prog && test "$pass" != link; then
	  func_append newlib_search_path " $ladir"
	  deplibs="$lib $deplibs"

	  linkalldeplibs=no
	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
	     test "$build_libtool_libs" = no; then
	    linkalldeplibs=yes
	  fi

	  tmp_libs=
	  for deplib in $dependency_libs; do
	    case $deplib in
	    -L*) func_stripname '-L' '' "$deplib"
	         func_resolve_sysroot "$func_stripname_result"
	         func_append newlib_search_path " $func_resolve_sysroot_result"
		 ;;
	    esac
	    # Need to link against all dependency_libs?
	    if test "$linkalldeplibs" = yes; then
	      deplibs="$deplib $deplibs"
	    else
	      # Need to hardcode shared library paths
	      # or/and link against static libraries
	      newdependency_libs="$deplib $newdependency_libs"
	    fi
	    if $opt_preserve_dup_deps ; then
	      case "$tmp_libs " in
	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
	      esac
	    fi
	    func_append tmp_libs " $deplib"
	  done # for deplib
	  continue
	fi # $linkmode = prog...

	if test "$linkmode,$pass" = "prog,link"; then
	  if test -n "$library_names" &&
	     { { test "$prefer_static_libs" = no ||
	         test "$prefer_static_libs,$installed" = "built,yes"; } ||
	       test -z "$old_library"; }; then
	    # We need to hardcode the library path
	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
	      # Make sure the rpath contains only unique directories.
	      case "$temp_rpath:" in
	      *"$absdir:"*) ;;
	      *) func_append temp_rpath "$absdir:" ;;
	      esac
	    fi

	    # Hardcode the library path.
	    # Skip directories that are in the system default run-time
	    # search path.
	    case " $sys_lib_dlsearch_path " in
	    *" $absdir "*) ;;
	    *)
	      case "$compile_rpath " in
	      *" $absdir "*) ;;
	      *) func_append compile_rpath " $absdir" ;;
	      esac
	      ;;
	    esac
	    case " $sys_lib_dlsearch_path " in
	    *" $libdir "*) ;;
	    *)
	      case "$finalize_rpath " in
	      *" $libdir "*) ;;
	      *) func_append finalize_rpath " $libdir" ;;
	      esac
	      ;;
	    esac
	  fi # $linkmode,$pass = prog,link...

	  if test "$alldeplibs" = yes &&
	     { test "$deplibs_check_method" = pass_all ||
	       { test "$build_libtool_libs" = yes &&
		 test -n "$library_names"; }; }; then
	    # We only need to search for static libraries
	    continue
	  fi
	fi

	link_static=no # Whether the deplib will be linked statically
	use_static_libs=$prefer_static_libs
	if test "$use_static_libs" = built && test "$installed" = yes; then
	  use_static_libs=no
	fi
	if test -n "$library_names" &&
	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
	  case $host in
	  *cygwin* | *mingw* | *cegcc*)
	      # No point in relinking DLLs because paths are not encoded
	      func_append notinst_deplibs " $lib"
	      need_relink=no
	    ;;
	  *)
	    if test "$installed" = no; then
	      func_append notinst_deplibs " $lib"
	      need_relink=yes
	    fi
	    ;;
	  esac
	  # This is a shared library

	  # Warn about portability, can't link against -module's on some
	  # systems (darwin).  Don't bleat about dlopened modules though!
	  dlopenmodule=""
	  for dlpremoduletest in $dlprefiles; do
	    if test "X$dlpremoduletest" = "X$lib"; then
	      dlopenmodule="$dlpremoduletest"
	      break
	    fi
	  done
	  if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
	    echo
	    if test "$linkmode" = prog; then
	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
	    else
	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
	    fi
	    $ECHO "*** $linklib is not portable!"
	  fi
	  if test "$linkmode" = lib &&
	     test "$hardcode_into_libs" = yes; then
	    # Hardcode the library path.
	    # Skip directories that are in the system default run-time
	    # search path.
	    case " $sys_lib_dlsearch_path " in
	    *" $absdir "*) ;;
	    *)
	      case "$compile_rpath " in
	      *" $absdir "*) ;;
	      *) func_append compile_rpath " $absdir" ;;
	      esac
	      ;;
	    esac
	    case " $sys_lib_dlsearch_path " in
	    *" $libdir "*) ;;
	    *)
	      case "$finalize_rpath " in
	      *" $libdir "*) ;;
	      *) func_append finalize_rpath " $libdir" ;;
	      esac
	      ;;
	    esac
	  fi

	  if test -n "$old_archive_from_expsyms_cmds"; then
	    # figure out the soname
	    set dummy $library_names
	    shift
	    realname="$1"
	    shift
	    libname=`eval "\\$ECHO \"$libname_spec\""`
	    # use dlname if we got it. it's perfectly good, no?
	    if test -n "$dlname"; then
	      soname="$dlname"
	    elif test -n "$soname_spec"; then
	      # bleh windows
	      case $host in
	      *cygwin* | mingw* | *cegcc*)
	        func_arith $current - $age
		major=$func_arith_result
		versuffix="-$major"
		;;
	      esac
	      eval soname=\"$soname_spec\"
	    else
	      soname="$realname"
	    fi

	    # Make a new name for the extract_expsyms_cmds to use
	    soroot="$soname"
	    func_basename "$soroot"
	    soname="$func_basename_result"
	    func_stripname 'lib' '.dll' "$soname"
	    newlib=libimp-$func_stripname_result.a

	    # If the library has no export list, then create one now
	    if test -f "$output_objdir/$soname-def"; then :
	    else
	      func_verbose "extracting exported symbol list from \`$soname'"
	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
	    fi

	    # Create $newlib
	    if test -f "$output_objdir/$newlib"; then :; else
	      func_verbose "generating import library for \`$soname'"
	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
	    fi
	    # make sure the library variables are pointing to the new library
	    dir=$output_objdir
	    linklib=$newlib
	  fi # test -n "$old_archive_from_expsyms_cmds"

	  if test "$linkmode" = prog || test "$opt_mode" != relink; then
	    add_shlibpath=
	    add_dir=
	    add=
	    lib_linked=yes
	    case $hardcode_action in
	    immediate | unsupported)
	      if test "$hardcode_direct" = no; then
		add="$dir/$linklib"
		case $host in
		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
		    *-*-unixware7*) add_dir="-L$dir" ;;
		  *-*-darwin* )
		    # if the lib is a (non-dlopened) module then we can not
		    # link against it, someone is ignoring the earlier warnings
		    if /usr/bin/file -L $add 2> /dev/null |
			 $GREP ": [^:]* bundle" >/dev/null ; then
		      if test "X$dlopenmodule" != "X$lib"; then
			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
			if test -z "$old_library" ; then
			  echo
			  echo "*** And there doesn't seem to be a static archive available"
			  echo "*** The link will probably fail, sorry"
			else
			  add="$dir/$old_library"
			fi
		      elif test -n "$old_library"; then
			add="$dir/$old_library"
		      fi
		    fi
		esac
	      elif test "$hardcode_minus_L" = no; then
		case $host in
		*-*-sunos*) add_shlibpath="$dir" ;;
		esac
		add_dir="-L$dir"
		add="-l$name"
	      elif test "$hardcode_shlibpath_var" = no; then
		add_shlibpath="$dir"
		add="-l$name"
	      else
		lib_linked=no
	      fi
	      ;;
	    relink)
	      if test "$hardcode_direct" = yes &&
	         test "$hardcode_direct_absolute" = no; then
		add="$dir/$linklib"
	      elif test "$hardcode_minus_L" = yes; then
		add_dir="-L$absdir"
		# Try looking first in the location we're being installed to.
		if test -n "$inst_prefix_dir"; then
		  case $libdir in
		    [\\/]*)
		      func_append add_dir " -L$inst_prefix_dir$libdir"
		      ;;
		  esac
		fi
		add="-l$name"
	      elif test "$hardcode_shlibpath_var" = yes; then
		add_shlibpath="$dir"
		add="-l$name"
	      else
		lib_linked=no
	      fi
	      ;;
	    *) lib_linked=no ;;
	    esac

	    if test "$lib_linked" != yes; then
	      func_fatal_configuration "unsupported hardcode properties"
	    fi

	    if test -n "$add_shlibpath"; then
	      case :$compile_shlibpath: in
	      *":$add_shlibpath:"*) ;;
	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
	      esac
	    fi
	    if test "$linkmode" = prog; then
	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
	    else
	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
	      test -n "$add" && deplibs="$add $deplibs"
	      if test "$hardcode_direct" != yes &&
		 test "$hardcode_minus_L" != yes &&
		 test "$hardcode_shlibpath_var" = yes; then
		case :$finalize_shlibpath: in
		*":$libdir:"*) ;;
		*) func_append finalize_shlibpath "$libdir:" ;;
		esac
	      fi
	    fi
	  fi

	  if test "$linkmode" = prog || test "$opt_mode" = relink; then
	    add_shlibpath=
	    add_dir=
	    add=
	    # Finalize command for both is simple: just hardcode it.
	    if test "$hardcode_direct" = yes &&
	       test "$hardcode_direct_absolute" = no; then
	      add="$libdir/$linklib"
	    elif test "$hardcode_minus_L" = yes; then
	      add_dir="-L$libdir"
	      add="-l$name"
	    elif test "$hardcode_shlibpath_var" = yes; then
	      case :$finalize_shlibpath: in
	      *":$libdir:"*) ;;
	      *) func_append finalize_shlibpath "$libdir:" ;;
	      esac
	      add="-l$name"
	    elif test "$hardcode_automatic" = yes; then
	      if test -n "$inst_prefix_dir" &&
		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
		add="$inst_prefix_dir$libdir/$linklib"
	      else
		add="$libdir/$linklib"
	      fi
	    else
	      # We cannot seem to hardcode it, guess we'll fake it.
	      add_dir="-L$libdir"
	      # Try looking first in the location we're being installed to.
	      if test -n "$inst_prefix_dir"; then
		case $libdir in
		  [\\/]*)
		    func_append add_dir " -L$inst_prefix_dir$libdir"
		    ;;
		esac
	      fi
	      add="-l$name"
	    fi

	    if test "$linkmode" = prog; then
	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
	    else
	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
	      test -n "$add" && deplibs="$add $deplibs"
	    fi
	  fi
	elif test "$linkmode" = prog; then
	  # Here we assume that one of hardcode_direct or hardcode_minus_L
	  # is not unsupported.  This is valid on all known static and
	  # shared platforms.
	  if test "$hardcode_direct" != unsupported; then
	    test -n "$old_library" && linklib="$old_library"
	    compile_deplibs="$dir/$linklib $compile_deplibs"
	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
	  else
	    compile_deplibs="-l$name -L$dir $compile_deplibs"
	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
	  fi
	elif test "$build_libtool_libs" = yes; then
	  # Not a shared library
	  if test "$deplibs_check_method" != pass_all; then
	    # We're trying link a shared library against a static one
	    # but the system doesn't support it.

	    # Just print a warning and add the library to dependency_libs so
	    # that the program can be linked against the static library.
	    echo
	    $ECHO "*** Warning: This system can not link to static lib archive $lib."
	    echo "*** I have the capability to make that library automatically link in when"
	    echo "*** you link to this library.  But I can only do this if you have a"
	    echo "*** shared version of the library, which you do not appear to have."
	    if test "$module" = yes; then
	      echo "*** But as you try to build a module library, libtool will still create "
	      echo "*** a static module, that should work as long as the dlopening application"
	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
	      if test -z "$global_symbol_pipe"; then
		echo
		echo "*** However, this would only work if libtool was able to extract symbol"
		echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
		echo "*** not find such a program.  So, this module is probably useless."
		echo "*** \`nm' from GNU binutils and a full rebuild may help."
	      fi
	      if test "$build_old_libs" = no; then
		build_libtool_libs=module
		build_old_libs=yes
	      else
		build_libtool_libs=no
	      fi
	    fi
	  else
	    deplibs="$dir/$old_library $deplibs"
	    link_static=yes
	  fi
	fi # link shared/static library?

	if test "$linkmode" = lib; then
	  if test -n "$dependency_libs" &&
	     { test "$hardcode_into_libs" != yes ||
	       test "$build_old_libs" = yes ||
	       test "$link_static" = yes; }; then
	    # Extract -R from dependency_libs
	    temp_deplibs=
	    for libdir in $dependency_libs; do
	      case $libdir in
	      -R*) func_stripname '-R' '' "$libdir"
	           temp_xrpath=$func_stripname_result
		   case " $xrpath " in
		   *" $temp_xrpath "*) ;;
		   *) func_append xrpath " $temp_xrpath";;
		   esac;;
	      *) func_append temp_deplibs " $libdir";;
	      esac
	    done
	    dependency_libs="$temp_deplibs"
	  fi

	  func_append newlib_search_path " $absdir"
	  # Link against this library
	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
	  # ... and its dependency_libs
	  tmp_libs=
	  for deplib in $dependency_libs; do
	    newdependency_libs="$deplib $newdependency_libs"
	    case $deplib in
              -L*) func_stripname '-L' '' "$deplib"
                   func_resolve_sysroot "$func_stripname_result";;
              *) func_resolve_sysroot "$deplib" ;;
            esac
	    if $opt_preserve_dup_deps ; then
	      case "$tmp_libs " in
	      *" $func_resolve_sysroot_result "*)
                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
	      esac
	    fi
	    func_append tmp_libs " $func_resolve_sysroot_result"
	  done

	  if test "$link_all_deplibs" != no; then
	    # Add the search paths of all dependency libraries
	    for deplib in $dependency_libs; do
	      path=
	      case $deplib in
	      -L*) path="$deplib" ;;
	      *.la)
	        func_resolve_sysroot "$deplib"
	        deplib=$func_resolve_sysroot_result
	        func_dirname "$deplib" "" "."
		dir=$func_dirname_result
		# We need an absolute path.
		case $dir in
		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
		*)
		  absdir=`cd "$dir" && pwd`
		  if test -z "$absdir"; then
		    func_warning "cannot determine absolute directory name of \`$dir'"
		    absdir="$dir"
		  fi
		  ;;
		esac
		if $GREP "^installed=no" $deplib > /dev/null; then
		case $host in
		*-*-darwin*)
		  depdepl=
		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
		  if test -n "$deplibrary_names" ; then
		    for tmp in $deplibrary_names ; do
		      depdepl=$tmp
		    done
		    if test -f "$absdir/$objdir/$depdepl" ; then
		      depdepl="$absdir/$objdir/$depdepl"
		      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
                      if test -z "$darwin_install_name"; then
                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
                      fi
		      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
		      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
		      path=
		    fi
		  fi
		  ;;
		*)
		  path="-L$absdir/$objdir"
		  ;;
		esac
		else
		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
		  test -z "$libdir" && \
		    func_fatal_error "\`$deplib' is not a valid libtool archive"
		  test "$absdir" != "$libdir" && \
		    func_warning "\`$deplib' seems to be moved"

		  path="-L$absdir"
		fi
		;;
	      esac
	      case " $deplibs " in
	      *" $path "*) ;;
	      *) deplibs="$path $deplibs" ;;
	      esac
	    done
	  fi # link_all_deplibs != no
	fi # linkmode = lib
      done # for deplib in $libs
      if test "$pass" = link; then
	if test "$linkmode" = "prog"; then
	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
	else
	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
	fi
      fi
      dependency_libs="$newdependency_libs"
      if test "$pass" = dlpreopen; then
	# Link the dlpreopened libraries before other libraries
	for deplib in $save_deplibs; do
	  deplibs="$deplib $deplibs"
	done
      fi
      if test "$pass" != dlopen; then
	if test "$pass" != conv; then
	  # Make sure lib_search_path contains only unique directories.
	  lib_search_path=
	  for dir in $newlib_search_path; do
	    case "$lib_search_path " in
	    *" $dir "*) ;;
	    *) func_append lib_search_path " $dir" ;;
	    esac
	  done
	  newlib_search_path=
	fi

	if test "$linkmode,$pass" != "prog,link"; then
	  vars="deplibs"
	else
	  vars="compile_deplibs finalize_deplibs"
	fi
	for var in $vars dependency_libs; do
	  # Add libraries to $var in reverse order
	  eval tmp_libs=\"\$$var\"
	  new_libs=
	  for deplib in $tmp_libs; do
	    # FIXME: Pedantically, this is the right thing to do, so
	    #        that some nasty dependency loop isn't accidentally
	    #        broken:
	    #new_libs="$deplib $new_libs"
	    # Pragmatically, this seems to cause very few problems in
	    # practice:
	    case $deplib in
	    -L*) new_libs="$deplib $new_libs" ;;
	    -R*) ;;
	    *)
	      # And here is the reason: when a library appears more
	      # than once as an explicit dependence of a library, or
	      # is implicitly linked in more than once by the
	      # compiler, it is considered special, and multiple
	      # occurrences thereof are not removed.  Compare this
	      # with having the same library being listed as a
	      # dependency of multiple other libraries: in this case,
	      # we know (pedantically, we assume) the library does not
	      # need to be listed more than once, so we keep only the
	      # last copy.  This is not always right, but it is rare
	      # enough that we require users that really mean to play
	      # such unportable linking tricks to link the library
	      # using -Wl,-lname, so that libtool does not consider it
	      # for duplicate removal.
	      case " $specialdeplibs " in
	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
	      *)
		case " $new_libs " in
		*" $deplib "*) ;;
		*) new_libs="$deplib $new_libs" ;;
		esac
		;;
	      esac
	      ;;
	    esac
	  done
	  tmp_libs=
	  for deplib in $new_libs; do
	    case $deplib in
	    -L*)
	      case " $tmp_libs " in
	      *" $deplib "*) ;;
	      *) func_append tmp_libs " $deplib" ;;
	      esac
	      ;;
	    *) func_append tmp_libs " $deplib" ;;
	    esac
	  done
	  eval $var=\"$tmp_libs\"
	done # for var
      fi
      # Last step: remove runtime libs from dependency_libs
      # (they stay in deplibs)
      tmp_libs=
      for i in $dependency_libs ; do
	case " $predeps $postdeps $compiler_lib_search_path " in
	*" $i "*)
	  i=""
	  ;;
	esac
	if test -n "$i" ; then
	  func_append tmp_libs " $i"
	fi
      done
      dependency_libs=$tmp_libs
    done # for pass
    if test "$linkmode" = prog; then
      dlfiles="$newdlfiles"
    fi
    if test "$linkmode" = prog || test "$linkmode" = lib; then
      dlprefiles="$newdlprefiles"
    fi

    case $linkmode in
    oldlib)
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
	func_warning "\`-dlopen' is ignored for archives"
      fi

      case " $deplibs" in
      *\ -l* | *\ -L*)
	func_warning "\`-l' and \`-L' are ignored for archives" ;;
      esac

      test -n "$rpath" && \
	func_warning "\`-rpath' is ignored for archives"

      test -n "$xrpath" && \
	func_warning "\`-R' is ignored for archives"

      test -n "$vinfo" && \
	func_warning "\`-version-info/-version-number' is ignored for archives"

      test -n "$release" && \
	func_warning "\`-release' is ignored for archives"

      test -n "$export_symbols$export_symbols_regex" && \
	func_warning "\`-export-symbols' is ignored for archives"

      # Now set the variables for building old libraries.
      build_libtool_libs=no
      oldlibs="$output"
      func_append objs "$old_deplibs"
      ;;

    lib)
      # Make sure we only generate libraries of the form `libNAME.la'.
      case $outputname in
      lib*)
	func_stripname 'lib' '.la' "$outputname"
	name=$func_stripname_result
	eval shared_ext=\"$shrext_cmds\"
	eval libname=\"$libname_spec\"
	;;
      *)
	test "$module" = no && \
	  func_fatal_help "libtool library \`$output' must begin with \`lib'"

	if test "$need_lib_prefix" != no; then
	  # Add the "lib" prefix for modules if required
	  func_stripname '' '.la' "$outputname"
	  name=$func_stripname_result
	  eval shared_ext=\"$shrext_cmds\"
	  eval libname=\"$libname_spec\"
	else
	  func_stripname '' '.la' "$outputname"
	  libname=$func_stripname_result
	fi
	;;
      esac

      if test -n "$objs"; then
	if test "$deplibs_check_method" != pass_all; then
	  func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
	else
	  echo
	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
	  $ECHO "*** objects $objs is not portable!"
	  func_append libobjs " $objs"
	fi
      fi

      test "$dlself" != no && \
	func_warning "\`-dlopen self' is ignored for libtool libraries"

      set dummy $rpath
      shift
      test "$#" -gt 1 && \
	func_warning "ignoring multiple \`-rpath's for a libtool library"

      install_libdir="$1"

      oldlibs=
      if test -z "$rpath"; then
	if test "$build_libtool_libs" = yes; then
	  # Building a libtool convenience library.
	  # Some compilers have problems with a `.al' extension so
	  # convenience libraries should have the same extension an
	  # archive normally would.
	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
	  build_libtool_libs=convenience
	  build_old_libs=yes
	fi

	test -n "$vinfo" && \
	  func_warning "\`-version-info/-version-number' is ignored for convenience libraries"

	test -n "$release" && \
	  func_warning "\`-release' is ignored for convenience libraries"
      else

	# Parse the version information argument.
	save_ifs="$IFS"; IFS=':'
	set dummy $vinfo 0 0 0
	shift
	IFS="$save_ifs"

	test -n "$7" && \
	  func_fatal_help "too many parameters to \`-version-info'"

	# convert absolute version numbers to libtool ages
	# this retains compatibility with .la files and attempts
	# to make the code below a bit more comprehensible

	case $vinfo_number in
	yes)
	  number_major="$1"
	  number_minor="$2"
	  number_revision="$3"
	  #
	  # There are really only two kinds -- those that
	  # use the current revision as the major version
	  # and those that subtract age and use age as
	  # a minor version.  But, then there is irix
	  # which has an extra 1 added just for fun
	  #
	  case $version_type in
	  # correct linux to gnu/linux during the next big refactor
	  darwin|linux|osf|windows|none)
	    func_arith $number_major + $number_minor
	    current=$func_arith_result
	    age="$number_minor"
	    revision="$number_revision"
	    ;;
	  freebsd-aout|freebsd-elf|qnx|sunos)
	    current="$number_major"
	    revision="$number_minor"
	    age="0"
	    ;;
	  irix|nonstopux)
	    func_arith $number_major + $number_minor
	    current=$func_arith_result
	    age="$number_minor"
	    revision="$number_minor"
	    lt_irix_increment=no
	    ;;
	  esac
	  ;;
	no)
	  current="$1"
	  revision="$2"
	  age="$3"
	  ;;
	esac

	# Check that each of the things are valid numbers.
	case $current in
	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
	*)
	  func_error "CURRENT \`$current' must be a nonnegative integer"
	  func_fatal_error "\`$vinfo' is not valid version information"
	  ;;
	esac

	case $revision in
	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
	*)
	  func_error "REVISION \`$revision' must be a nonnegative integer"
	  func_fatal_error "\`$vinfo' is not valid version information"
	  ;;
	esac

	case $age in
	0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
	*)
	  func_error "AGE \`$age' must be a nonnegative integer"
	  func_fatal_error "\`$vinfo' is not valid version information"
	  ;;
	esac

	if test "$age" -gt "$current"; then
	  func_error "AGE \`$age' is greater than the current interface number \`$current'"
	  func_fatal_error "\`$vinfo' is not valid version information"
	fi

	# Calculate the version variables.
	major=
	versuffix=
	verstring=
	case $version_type in
	none) ;;

	darwin)
	  # Like Linux, but with the current version available in
	  # verstring for coding it into the library header
	  func_arith $current - $age
	  major=.$func_arith_result
	  versuffix="$major.$age.$revision"
	  # Darwin ld doesn't like 0 for these options...
	  func_arith $current + 1
	  minor_current=$func_arith_result
	  xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
	  ;;

	freebsd-aout)
	  major=".$current"
	  versuffix=".$current.$revision";
	  ;;

	freebsd-elf)
	  major=".$current"
	  versuffix=".$current"
	  ;;

	irix | nonstopux)
	  if test "X$lt_irix_increment" = "Xno"; then
	    func_arith $current - $age
	  else
	    func_arith $current - $age + 1
	  fi
	  major=$func_arith_result

	  case $version_type in
	    nonstopux) verstring_prefix=nonstopux ;;
	    *)         verstring_prefix=sgi ;;
	  esac
	  verstring="$verstring_prefix$major.$revision"

	  # Add in all the interfaces that we are compatible with.
	  loop=$revision
	  while test "$loop" -ne 0; do
	    func_arith $revision - $loop
	    iface=$func_arith_result
	    func_arith $loop - 1
	    loop=$func_arith_result
	    verstring="$verstring_prefix$major.$iface:$verstring"
	  done

	  # Before this point, $major must not contain `.'.
	  major=.$major
	  versuffix="$major.$revision"
	  ;;

	linux) # correct to gnu/linux during the next big refactor
	  func_arith $current - $age
	  major=.$func_arith_result
	  versuffix="$major.$age.$revision"
	  ;;

	osf)
	  func_arith $current - $age
	  major=.$func_arith_result
	  versuffix=".$current.$age.$revision"
	  verstring="$current.$age.$revision"

	  # Add in all the interfaces that we are compatible with.
	  loop=$age
	  while test "$loop" -ne 0; do
	    func_arith $current - $loop
	    iface=$func_arith_result
	    func_arith $loop - 1
	    loop=$func_arith_result
	    verstring="$verstring:${iface}.0"
	  done

	  # Make executables depend on our current version.
	  func_append verstring ":${current}.0"
	  ;;

	qnx)
	  major=".$current"
	  versuffix=".$current"
	  ;;

	sunos)
	  major=".$current"
	  versuffix=".$current.$revision"
	  ;;

	windows)
	  # Use '-' rather than '.', since we only want one
	  # extension on DOS 8.3 filesystems.
	  func_arith $current - $age
	  major=$func_arith_result
	  versuffix="-$major"
	  ;;

	*)
	  func_fatal_configuration "unknown library version type \`$version_type'"
	  ;;
	esac

	# Clear the version info if we defaulted, and they specified a release.
	if test -z "$vinfo" && test -n "$release"; then
	  major=
	  case $version_type in
	  darwin)
	    # we can't check for "0.0" in archive_cmds due to quoting
	    # problems, so we reset it completely
	    verstring=
	    ;;
	  *)
	    verstring="0.0"
	    ;;
	  esac
	  if test "$need_version" = no; then
	    versuffix=
	  else
	    versuffix=".0.0"
	  fi
	fi

	# Remove version info from name if versioning should be avoided
	if test "$avoid_version" = yes && test "$need_version" = no; then
	  major=
	  versuffix=
	  verstring=""
	fi

	# Check to see if the archive will have undefined symbols.
	if test "$allow_undefined" = yes; then
	  if test "$allow_undefined_flag" = unsupported; then
	    func_warning "undefined symbols not allowed in $host shared libraries"
	    build_libtool_libs=no
	    build_old_libs=yes
	  fi
	else
	  # Don't allow undefined symbols.
	  allow_undefined_flag="$no_undefined_flag"
	fi

      fi

      func_generate_dlsyms "$libname" "$libname" "yes"
      func_append libobjs " $symfileobj"
      test "X$libobjs" = "X " && libobjs=

      if test "$opt_mode" != relink; then
	# Remove our outputs, but don't remove object files since they
	# may have been created when compiling PIC objects.
	removelist=
	tempremovelist=`$ECHO "$output_objdir/*"`
	for p in $tempremovelist; do
	  case $p in
	    *.$objext | *.gcno)
	       ;;
	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
	       if test "X$precious_files_regex" != "X"; then
		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
		 then
		   continue
		 fi
	       fi
	       func_append removelist " $p"
	       ;;
	    *) ;;
	  esac
	done
	test -n "$removelist" && \
	  func_show_eval "${RM}r \$removelist"
      fi

      # Now set the variables for building old libraries.
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
	func_append oldlibs " $output_objdir/$libname.$libext"

	# Transform .lo files to .o files.
	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
      fi

      # Eliminate all temporary directories.
      #for path in $notinst_path; do
      #	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
      #	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
      #	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
      #done

      if test -n "$xrpath"; then
	# If the user specified any rpath flags, then add them.
	temp_xrpath=
	for libdir in $xrpath; do
	  func_replace_sysroot "$libdir"
	  func_append temp_xrpath " -R$func_replace_sysroot_result"
	  case "$finalize_rpath " in
	  *" $libdir "*) ;;
	  *) func_append finalize_rpath " $libdir" ;;
	  esac
	done
	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
	  dependency_libs="$temp_xrpath $dependency_libs"
	fi
      fi

      # Make sure dlfiles contains only unique files that won't be dlpreopened
      old_dlfiles="$dlfiles"
      dlfiles=
      for lib in $old_dlfiles; do
	case " $dlprefiles $dlfiles " in
	*" $lib "*) ;;
	*) func_append dlfiles " $lib" ;;
	esac
      done

      # Make sure dlprefiles contains only unique files
      old_dlprefiles="$dlprefiles"
      dlprefiles=
      for lib in $old_dlprefiles; do
	case "$dlprefiles " in
	*" $lib "*) ;;
	*) func_append dlprefiles " $lib" ;;
	esac
      done

      if test "$build_libtool_libs" = yes; then
	if test -n "$rpath"; then
	  case $host in
	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
	    # these systems don't actually have a c library (as such)!
	    ;;
	  *-*-rhapsody* | *-*-darwin1.[012])
	    # Rhapsody C library is in the System framework
	    func_append deplibs " System.ltframework"
	    ;;
	  *-*-netbsd*)
	    # Don't link with libc until the a.out ld.so is fixed.
	    ;;
	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
	    # Do not include libc due to us having libc/libc_r.
	    ;;
	  *-*-sco3.2v5* | *-*-sco5v6*)
	    # Causes problems with __ctype
	    ;;
	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
	    # Compiler inserts libc in the correct place for threads to work
	    ;;
	  *)
	    # Add libc to deplibs on all other systems if necessary.
	    if test "$build_libtool_need_lc" = "yes"; then
	      func_append deplibs " -lc"
	    fi
	    ;;
	  esac
	fi

	# Transform deplibs into only deplibs that can be linked in shared.
	name_save=$name
	libname_save=$libname
	release_save=$release
	versuffix_save=$versuffix
	major_save=$major
	# I'm not sure if I'm treating the release correctly.  I think
	# release should show up in the -l (ie -lgmp5) so we don't want to
	# add it in twice.  Is that correct?
	release=""
	versuffix=""
	major=""
	newdeplibs=
	droppeddeps=no
	case $deplibs_check_method in
	pass_all)
	  # Don't check for shared/static.  Everything works.
	  # This might be a little naive.  We might want to check
	  # whether the library exists or not.  But this is on
	  # osf3 & osf4 and I'm not really sure... Just
	  # implementing what was already the behavior.
	  newdeplibs=$deplibs
	  ;;
	test_compile)
	  # This code stresses the "libraries are programs" paradigm to its
	  # limits. Maybe even breaks it.  We compile a program, linking it
	  # against the deplibs as a proxy for the library.  Then we can check
	  # whether they linked in statically or dynamically with ldd.
	  $opt_dry_run || $RM conftest.c
	  cat > conftest.c </dev/null`
		    $nocaseglob
		  else
		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
		  fi
		  for potent_lib in $potential_libs; do
		      # Follow soft links.
		      if ls -lLd "$potent_lib" 2>/dev/null |
			 $GREP " -> " >/dev/null; then
			continue
		      fi
		      # The statement above tries to avoid entering an
		      # endless loop below, in case of cyclic links.
		      # We might still enter an endless loop, since a link
		      # loop can be closed while we follow links,
		      # but so what?
		      potlib="$potent_lib"
		      while test -h "$potlib" 2>/dev/null; do
			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
			case $potliblink in
			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
			*) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
			esac
		      done
		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
			 $SED -e 10q |
			 $EGREP "$file_magic_regex" > /dev/null; then
			func_append newdeplibs " $a_deplib"
			a_deplib=""
			break 2
		      fi
		  done
		done
	      fi
	      if test -n "$a_deplib" ; then
		droppeddeps=yes
		echo
		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
		echo "*** I have the capability to make that library automatically link in when"
		echo "*** you link to this library.  But I can only do this if you have a"
		echo "*** shared version of the library, which you do not appear to have"
		echo "*** because I did check the linker path looking for a file starting"
		if test -z "$potlib" ; then
		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
		else
		  $ECHO "*** with $libname and none of the candidates passed a file format test"
		  $ECHO "*** using a file magic. Last file checked: $potlib"
		fi
	      fi
	      ;;
	    *)
	      # Add a -L argument.
	      func_append newdeplibs " $a_deplib"
	      ;;
	    esac
	  done # Gone through all deplibs.
	  ;;
	match_pattern*)
	  set dummy $deplibs_check_method; shift
	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
	  for a_deplib in $deplibs; do
	    case $a_deplib in
	    -l*)
	      func_stripname -l '' "$a_deplib"
	      name=$func_stripname_result
	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
		case " $predeps $postdeps " in
		*" $a_deplib "*)
		  func_append newdeplibs " $a_deplib"
		  a_deplib=""
		  ;;
		esac
	      fi
	      if test -n "$a_deplib" ; then
		libname=`eval "\\$ECHO \"$libname_spec\""`
		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
		  for potent_lib in $potential_libs; do
		    potlib="$potent_lib" # see symlink-check above in file_magic test
		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
		       $EGREP "$match_pattern_regex" > /dev/null; then
		      func_append newdeplibs " $a_deplib"
		      a_deplib=""
		      break 2
		    fi
		  done
		done
	      fi
	      if test -n "$a_deplib" ; then
		droppeddeps=yes
		echo
		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
		echo "*** I have the capability to make that library automatically link in when"
		echo "*** you link to this library.  But I can only do this if you have a"
		echo "*** shared version of the library, which you do not appear to have"
		echo "*** because I did check the linker path looking for a file starting"
		if test -z "$potlib" ; then
		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
		else
		  $ECHO "*** with $libname and none of the candidates passed a file format test"
		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
		fi
	      fi
	      ;;
	    *)
	      # Add a -L argument.
	      func_append newdeplibs " $a_deplib"
	      ;;
	    esac
	  done # Gone through all deplibs.
	  ;;
	none | unknown | *)
	  newdeplibs=""
	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
	    for i in $predeps $postdeps ; do
	      # can't use Xsed below, because $i might contain '/'
	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
	    done
	  fi
	  case $tmp_deplibs in
	  *[!\	\ ]*)
	    echo
	    if test "X$deplibs_check_method" = "Xnone"; then
	      echo "*** Warning: inter-library dependencies are not supported in this platform."
	    else
	      echo "*** Warning: inter-library dependencies are not known to be supported."
	    fi
	    echo "*** All declared inter-library dependencies are being dropped."
	    droppeddeps=yes
	    ;;
	  esac
	  ;;
	esac
	versuffix=$versuffix_save
	major=$major_save
	release=$release_save
	libname=$libname_save
	name=$name_save

	case $host in
	*-*-rhapsody* | *-*-darwin1.[012])
	  # On Rhapsody replace the C library with the System framework
	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
	  ;;
	esac

	if test "$droppeddeps" = yes; then
	  if test "$module" = yes; then
	    echo
	    echo "*** Warning: libtool could not satisfy all declared inter-library"
	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
	    echo "*** a static module, that should work as long as the dlopening"
	    echo "*** application is linked with the -dlopen flag."
	    if test -z "$global_symbol_pipe"; then
	      echo
	      echo "*** However, this would only work if libtool was able to extract symbol"
	      echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
	      echo "*** not find such a program.  So, this module is probably useless."
	      echo "*** \`nm' from GNU binutils and a full rebuild may help."
	    fi
	    if test "$build_old_libs" = no; then
	      oldlibs="$output_objdir/$libname.$libext"
	      build_libtool_libs=module
	      build_old_libs=yes
	    else
	      build_libtool_libs=no
	    fi
	  else
	    echo "*** The inter-library dependencies that have been dropped here will be"
	    echo "*** automatically added whenever a program is linked with this library"
	    echo "*** or is declared to -dlopen it."

	    if test "$allow_undefined" = no; then
	      echo
	      echo "*** Since this library must not contain undefined symbols,"
	      echo "*** because either the platform does not support them or"
	      echo "*** it was explicitly requested with -no-undefined,"
	      echo "*** libtool will only create a static version of it."
	      if test "$build_old_libs" = no; then
		oldlibs="$output_objdir/$libname.$libext"
		build_libtool_libs=module
		build_old_libs=yes
	      else
		build_libtool_libs=no
	      fi
	    fi
	  fi
	fi
	# Done checking deplibs!
	deplibs=$newdeplibs
      fi
      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
      case $host in
	*-*-darwin*)
	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
	  deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
	  ;;
      esac

      # move library search paths that coincide with paths to not yet
      # installed libraries to the beginning of the library search list
      new_libs=
      for path in $notinst_path; do
	case " $new_libs " in
	*" -L$path/$objdir "*) ;;
	*)
	  case " $deplibs " in
	  *" -L$path/$objdir "*)
	    func_append new_libs " -L$path/$objdir" ;;
	  esac
	  ;;
	esac
      done
      for deplib in $deplibs; do
	case $deplib in
	-L*)
	  case " $new_libs " in
	  *" $deplib "*) ;;
	  *) func_append new_libs " $deplib" ;;
	  esac
	  ;;
	*) func_append new_libs " $deplib" ;;
	esac
      done
      deplibs="$new_libs"

      # All the library-specific variables (install_libdir is set above).
      library_names=
      old_library=
      dlname=

      # Test again, we may have decided not to build it any more
      if test "$build_libtool_libs" = yes; then
	# Remove ${wl} instances when linking with ld.
	# FIXME: should test the right _cmds variable.
	case $archive_cmds in
	  *\$LD\ *) wl= ;;
        esac
	if test "$hardcode_into_libs" = yes; then
	  # Hardcode the library paths
	  hardcode_libdirs=
	  dep_rpath=
	  rpath="$finalize_rpath"
	  test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
	  for libdir in $rpath; do
	    if test -n "$hardcode_libdir_flag_spec"; then
	      if test -n "$hardcode_libdir_separator"; then
		func_replace_sysroot "$libdir"
		libdir=$func_replace_sysroot_result
		if test -z "$hardcode_libdirs"; then
		  hardcode_libdirs="$libdir"
		else
		  # Just accumulate the unique libdirs.
		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
		    ;;
		  *)
		    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
		    ;;
		  esac
		fi
	      else
		eval flag=\"$hardcode_libdir_flag_spec\"
		func_append dep_rpath " $flag"
	      fi
	    elif test -n "$runpath_var"; then
	      case "$perm_rpath " in
	      *" $libdir "*) ;;
	      *) func_append perm_rpath " $libdir" ;;
	      esac
	    fi
	  done
	  # Substitute the hardcoded libdirs into the rpath.
	  if test -n "$hardcode_libdir_separator" &&
	     test -n "$hardcode_libdirs"; then
	    libdir="$hardcode_libdirs"
	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
	  fi
	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
	    # We should set the runpath_var.
	    rpath=
	    for dir in $perm_rpath; do
	      func_append rpath "$dir:"
	    done
	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
	  fi
	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
	fi

	shlibpath="$finalize_shlibpath"
	test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
	if test -n "$shlibpath"; then
	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
	fi

	# Get the real and link names of the library.
	eval shared_ext=\"$shrext_cmds\"
	eval library_names=\"$library_names_spec\"
	set dummy $library_names
	shift
	realname="$1"
	shift

	if test -n "$soname_spec"; then
	  eval soname=\"$soname_spec\"
	else
	  soname="$realname"
	fi
	if test -z "$dlname"; then
	  dlname=$soname
	fi

	lib="$output_objdir/$realname"
	linknames=
	for link
	do
	  func_append linknames " $link"
	done

	# Use standard objects if they are pic
	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
	test "X$libobjs" = "X " && libobjs=

	delfiles=
	if test -n "$export_symbols" && test -n "$include_expsyms"; then
	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
	  export_symbols="$output_objdir/$libname.uexp"
	  func_append delfiles " $export_symbols"
	fi

	orig_export_symbols=
	case $host_os in
	cygwin* | mingw* | cegcc*)
	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
	    # exporting using user supplied symfile
	    if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
	      # and it's NOT already a .def file. Must figure out
	      # which of the given symbols are data symbols and tag
	      # them as such. So, trigger use of export_symbols_cmds.
	      # export_symbols gets reassigned inside the "prepare
	      # the list of exported symbols" if statement, so the
	      # include_expsyms logic still works.
	      orig_export_symbols="$export_symbols"
	      export_symbols=
	      always_export_symbols=yes
	    fi
	  fi
	  ;;
	esac

	# Prepare the list of exported symbols
	if test -z "$export_symbols"; then
	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
	    func_verbose "generating symbol list for \`$libname.la'"
	    export_symbols="$output_objdir/$libname.exp"
	    $opt_dry_run || $RM $export_symbols
	    cmds=$export_symbols_cmds
	    save_ifs="$IFS"; IFS='~'
	    for cmd1 in $cmds; do
	      IFS="$save_ifs"
	      # Take the normal branch if the nm_file_list_spec branch
	      # doesn't work or if tool conversion is not needed.
	      case $nm_file_list_spec~$to_tool_file_cmd in
		*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
		  try_normal_branch=yes
		  eval cmd=\"$cmd1\"
		  func_len " $cmd"
		  len=$func_len_result
		  ;;
		*)
		  try_normal_branch=no
		  ;;
	      esac
	      if test "$try_normal_branch" = yes \
		 && { test "$len" -lt "$max_cmd_len" \
		      || test "$max_cmd_len" -le -1; }
	      then
		func_show_eval "$cmd" 'exit $?'
		skipped_export=false
	      elif test -n "$nm_file_list_spec"; then
		func_basename "$output"
		output_la=$func_basename_result
		save_libobjs=$libobjs
		save_output=$output
		output=${output_objdir}/${output_la}.nm
		func_to_tool_file "$output"
		libobjs=$nm_file_list_spec$func_to_tool_file_result
		func_append delfiles " $output"
		func_verbose "creating $NM input file list: $output"
		for obj in $save_libobjs; do
		  func_to_tool_file "$obj"
		  $ECHO "$func_to_tool_file_result"
		done > "$output"
		eval cmd=\"$cmd1\"
		func_show_eval "$cmd" 'exit $?'
		output=$save_output
		libobjs=$save_libobjs
		skipped_export=false
	      else
		# The command line is too long to execute in one step.
		func_verbose "using reloadable object file for export list..."
		skipped_export=:
		# Break out early, otherwise skipped_export may be
		# set to false by a later but shorter cmd.
		break
	      fi
	    done
	    IFS="$save_ifs"
	    if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
	    fi
	  fi
	fi

	if test -n "$export_symbols" && test -n "$include_expsyms"; then
	  tmp_export_symbols="$export_symbols"
	  test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
	fi

	if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
	  # The given exports_symbols file has to be filtered, so filter it.
	  func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
	  # 's' commands which not all seds can handle. GNU sed should be fine
	  # though. Also, the filter scales superlinearly with the number of
	  # global variables. join(1) would be nice here, but unfortunately
	  # isn't a blessed tool.
	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
	  func_append delfiles " $export_symbols $output_objdir/$libname.filter"
	  export_symbols=$output_objdir/$libname.def
	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
	fi

	tmp_deplibs=
	for test_deplib in $deplibs; do
	  case " $convenience " in
	  *" $test_deplib "*) ;;
	  *)
	    func_append tmp_deplibs " $test_deplib"
	    ;;
	  esac
	done
	deplibs="$tmp_deplibs"

	if test -n "$convenience"; then
	  if test -n "$whole_archive_flag_spec" &&
	    test "$compiler_needs_object" = yes &&
	    test -z "$libobjs"; then
	    # extract the archives, so we have objects to list.
	    # TODO: could optimize this to just extract one archive.
	    whole_archive_flag_spec=
	  fi
	  if test -n "$whole_archive_flag_spec"; then
	    save_libobjs=$libobjs
	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
	    test "X$libobjs" = "X " && libobjs=
	  else
	    gentop="$output_objdir/${outputname}x"
	    func_append generated " $gentop"

	    func_extract_archives $gentop $convenience
	    func_append libobjs " $func_extract_archives_result"
	    test "X$libobjs" = "X " && libobjs=
	  fi
	fi

	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
	  eval flag=\"$thread_safe_flag_spec\"
	  func_append linker_flags " $flag"
	fi

	# Make a backup of the uninstalled library when relinking
	if test "$opt_mode" = relink; then
	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
	fi

	# Do each of the archive commands.
	if test "$module" = yes && test -n "$module_cmds" ; then
	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
	    eval test_cmds=\"$module_expsym_cmds\"
	    cmds=$module_expsym_cmds
	  else
	    eval test_cmds=\"$module_cmds\"
	    cmds=$module_cmds
	  fi
	else
	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
	    eval test_cmds=\"$archive_expsym_cmds\"
	    cmds=$archive_expsym_cmds
	  else
	    eval test_cmds=\"$archive_cmds\"
	    cmds=$archive_cmds
	  fi
	fi

	if test "X$skipped_export" != "X:" &&
	   func_len " $test_cmds" &&
	   len=$func_len_result &&
	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
	  :
	else
	  # The command line is too long to link in one step, link piecewise
	  # or, if using GNU ld and skipped_export is not :, use a linker
	  # script.

	  # Save the value of $output and $libobjs because we want to
	  # use them later.  If we have whole_archive_flag_spec, we
	  # want to use save_libobjs as it was before
	  # whole_archive_flag_spec was expanded, because we can't
	  # assume the linker understands whole_archive_flag_spec.
	  # This may have to be revisited, in case too many
	  # convenience libraries get linked in and end up exceeding
	  # the spec.
	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
	    save_libobjs=$libobjs
	  fi
	  save_output=$output
	  func_basename "$output"
	  output_la=$func_basename_result

	  # Clear the reloadable object creation command queue and
	  # initialize k to one.
	  test_cmds=
	  concat_cmds=
	  objlist=
	  last_robj=
	  k=1

	  if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
	    output=${output_objdir}/${output_la}.lnkscript
	    func_verbose "creating GNU ld script: $output"
	    echo 'INPUT (' > $output
	    for obj in $save_libobjs
	    do
	      func_to_tool_file "$obj"
	      $ECHO "$func_to_tool_file_result" >> $output
	    done
	    echo ')' >> $output
	    func_append delfiles " $output"
	    func_to_tool_file "$output"
	    output=$func_to_tool_file_result
	  elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
	    output=${output_objdir}/${output_la}.lnk
	    func_verbose "creating linker input file list: $output"
	    : > $output
	    set x $save_libobjs
	    shift
	    firstobj=
	    if test "$compiler_needs_object" = yes; then
	      firstobj="$1 "
	      shift
	    fi
	    for obj
	    do
	      func_to_tool_file "$obj"
	      $ECHO "$func_to_tool_file_result" >> $output
	    done
	    func_append delfiles " $output"
	    func_to_tool_file "$output"
	    output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
	  else
	    if test -n "$save_libobjs"; then
	      func_verbose "creating reloadable object files..."
	      output=$output_objdir/$output_la-${k}.$objext
	      eval test_cmds=\"$reload_cmds\"
	      func_len " $test_cmds"
	      len0=$func_len_result
	      len=$len0

	      # Loop over the list of objects to be linked.
	      for obj in $save_libobjs
	      do
		func_len " $obj"
		func_arith $len + $func_len_result
		len=$func_arith_result
		if test "X$objlist" = X ||
		   test "$len" -lt "$max_cmd_len"; then
		  func_append objlist " $obj"
		else
		  # The command $test_cmds is almost too long, add a
		  # command to the queue.
		  if test "$k" -eq 1 ; then
		    # The first file doesn't have a previous command to add.
		    reload_objs=$objlist
		    eval concat_cmds=\"$reload_cmds\"
		  else
		    # All subsequent reloadable object files will link in
		    # the last one created.
		    reload_objs="$objlist $last_robj"
		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
		  fi
		  last_robj=$output_objdir/$output_la-${k}.$objext
		  func_arith $k + 1
		  k=$func_arith_result
		  output=$output_objdir/$output_la-${k}.$objext
		  objlist=" $obj"
		  func_len " $last_robj"
		  func_arith $len0 + $func_len_result
		  len=$func_arith_result
		fi
	      done
	      # Handle the remaining objects by creating one last
	      # reloadable object file.  All subsequent reloadable object
	      # files will link in the last one created.
	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
	      reload_objs="$objlist $last_robj"
	      eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
	      if test -n "$last_robj"; then
	        eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
	      fi
	      func_append delfiles " $output"

	    else
	      output=
	    fi

	    if ${skipped_export-false}; then
	      func_verbose "generating symbol list for \`$libname.la'"
	      export_symbols="$output_objdir/$libname.exp"
	      $opt_dry_run || $RM $export_symbols
	      libobjs=$output
	      # Append the command to create the export file.
	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
	      if test -n "$last_robj"; then
		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
	      fi
	    fi

	    test -n "$save_libobjs" &&
	      func_verbose "creating a temporary reloadable object file: $output"

	    # Loop through the commands generated above and execute them.
	    save_ifs="$IFS"; IFS='~'
	    for cmd in $concat_cmds; do
	      IFS="$save_ifs"
	      $opt_silent || {
		  func_quote_for_expand "$cmd"
		  eval "func_echo $func_quote_for_expand_result"
	      }
	      $opt_dry_run || eval "$cmd" || {
		lt_exit=$?

		# Restore the uninstalled library and exit
		if test "$opt_mode" = relink; then
		  ( cd "$output_objdir" && \
		    $RM "${realname}T" && \
		    $MV "${realname}U" "$realname" )
		fi

		exit $lt_exit
	      }
	    done
	    IFS="$save_ifs"

	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
	    fi
	  fi

          if ${skipped_export-false}; then
	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
	      tmp_export_symbols="$export_symbols"
	      test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
	    fi

	    if test -n "$orig_export_symbols"; then
	      # The given exports_symbols file has to be filtered, so filter it.
	      func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
	      # 's' commands which not all seds can handle. GNU sed should be fine
	      # though. Also, the filter scales superlinearly with the number of
	      # global variables. join(1) would be nice here, but unfortunately
	      # isn't a blessed tool.
	      $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
	      func_append delfiles " $export_symbols $output_objdir/$libname.filter"
	      export_symbols=$output_objdir/$libname.def
	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
	    fi
	  fi

	  libobjs=$output
	  # Restore the value of output.
	  output=$save_output

	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
	    test "X$libobjs" = "X " && libobjs=
	  fi
	  # Expand the library linking commands again to reset the
	  # value of $libobjs for piecewise linking.

	  # Do each of the archive commands.
	  if test "$module" = yes && test -n "$module_cmds" ; then
	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
	      cmds=$module_expsym_cmds
	    else
	      cmds=$module_cmds
	    fi
	  else
	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
	      cmds=$archive_expsym_cmds
	    else
	      cmds=$archive_cmds
	    fi
	  fi
	fi

	if test -n "$delfiles"; then
	  # Append the command to remove temporary files to $cmds.
	  eval cmds=\"\$cmds~\$RM $delfiles\"
	fi

	# Add any objects from preloaded convenience libraries
	if test -n "$dlprefiles"; then
	  gentop="$output_objdir/${outputname}x"
	  func_append generated " $gentop"

	  func_extract_archives $gentop $dlprefiles
	  func_append libobjs " $func_extract_archives_result"
	  test "X$libobjs" = "X " && libobjs=
	fi

	save_ifs="$IFS"; IFS='~'
	for cmd in $cmds; do
	  IFS="$save_ifs"
	  eval cmd=\"$cmd\"
	  $opt_silent || {
	    func_quote_for_expand "$cmd"
	    eval "func_echo $func_quote_for_expand_result"
	  }
	  $opt_dry_run || eval "$cmd" || {
	    lt_exit=$?

	    # Restore the uninstalled library and exit
	    if test "$opt_mode" = relink; then
	      ( cd "$output_objdir" && \
	        $RM "${realname}T" && \
		$MV "${realname}U" "$realname" )
	    fi

	    exit $lt_exit
	  }
	done
	IFS="$save_ifs"

	# Restore the uninstalled library and exit
	if test "$opt_mode" = relink; then
	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?

	  if test -n "$convenience"; then
	    if test -z "$whole_archive_flag_spec"; then
	      func_show_eval '${RM}r "$gentop"'
	    fi
	  fi

	  exit $EXIT_SUCCESS
	fi

	# Create links to the real library.
	for linkname in $linknames; do
	  if test "$realname" != "$linkname"; then
	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
	  fi
	done

	# If -module or -export-dynamic was specified, set the dlname.
	if test "$module" = yes || test "$export_dynamic" = yes; then
	  # On all known operating systems, these are identical.
	  dlname="$soname"
	fi
      fi
      ;;

    obj)
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
	func_warning "\`-dlopen' is ignored for objects"
      fi

      case " $deplibs" in
      *\ -l* | *\ -L*)
	func_warning "\`-l' and \`-L' are ignored for objects" ;;
      esac

      test -n "$rpath" && \
	func_warning "\`-rpath' is ignored for objects"

      test -n "$xrpath" && \
	func_warning "\`-R' is ignored for objects"

      test -n "$vinfo" && \
	func_warning "\`-version-info' is ignored for objects"

      test -n "$release" && \
	func_warning "\`-release' is ignored for objects"

      case $output in
      *.lo)
	test -n "$objs$old_deplibs" && \
	  func_fatal_error "cannot build library object \`$output' from non-libtool objects"

	libobj=$output
	func_lo2o "$libobj"
	obj=$func_lo2o_result
	;;
      *)
	libobj=
	obj="$output"
	;;
      esac

      # Delete the old objects.
      $opt_dry_run || $RM $obj $libobj

      # Objects from convenience libraries.  This assumes
      # single-version convenience libraries.  Whenever we create
      # different ones for PIC/non-PIC, this we'll have to duplicate
      # the extraction.
      reload_conv_objs=
      gentop=
      # reload_cmds runs $LD directly, so let us get rid of
      # -Wl from whole_archive_flag_spec and hope we can get by with
      # turning comma into space..
      wl=

      if test -n "$convenience"; then
	if test -n "$whole_archive_flag_spec"; then
	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
	  reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
	else
	  gentop="$output_objdir/${obj}x"
	  func_append generated " $gentop"

	  func_extract_archives $gentop $convenience
	  reload_conv_objs="$reload_objs $func_extract_archives_result"
	fi
      fi

      # If we're not building shared, we need to use non_pic_objs
      test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"

      # Create the old-style object.
      reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test

      output="$obj"
      func_execute_cmds "$reload_cmds" 'exit $?'

      # Exit if we aren't doing a library object file.
      if test -z "$libobj"; then
	if test -n "$gentop"; then
	  func_show_eval '${RM}r "$gentop"'
	fi

	exit $EXIT_SUCCESS
      fi

      if test "$build_libtool_libs" != yes; then
	if test -n "$gentop"; then
	  func_show_eval '${RM}r "$gentop"'
	fi

	# Create an invalid libtool object if no PIC, so that we don't
	# accidentally link it into a program.
	# $show "echo timestamp > $libobj"
	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
	exit $EXIT_SUCCESS
      fi

      if test -n "$pic_flag" || test "$pic_mode" != default; then
	# Only do commands if we really have different PIC objects.
	reload_objs="$libobjs $reload_conv_objs"
	output="$libobj"
	func_execute_cmds "$reload_cmds" 'exit $?'
      fi

      if test -n "$gentop"; then
	func_show_eval '${RM}r "$gentop"'
      fi

      exit $EXIT_SUCCESS
      ;;

    prog)
      case $host in
	*cygwin*) func_stripname '' '.exe' "$output"
	          output=$func_stripname_result.exe;;
      esac
      test -n "$vinfo" && \
	func_warning "\`-version-info' is ignored for programs"

      test -n "$release" && \
	func_warning "\`-release' is ignored for programs"

      test "$preload" = yes \
        && test "$dlopen_support" = unknown \
	&& test "$dlopen_self" = unknown \
	&& test "$dlopen_self_static" = unknown && \
	  func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."

      case $host in
      *-*-rhapsody* | *-*-darwin1.[012])
	# On Rhapsody replace the C library is the System framework
	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
	;;
      esac

      case $host in
      *-*-darwin*)
	# Don't allow lazy linking, it breaks C++ global constructors
	# But is supposedly fixed on 10.4 or later (yay!).
	if test "$tagname" = CXX ; then
	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
	    10.[0123])
	      func_append compile_command " ${wl}-bind_at_load"
	      func_append finalize_command " ${wl}-bind_at_load"
	    ;;
	  esac
	fi
	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
	;;
      esac


      # move library search paths that coincide with paths to not yet
      # installed libraries to the beginning of the library search list
      new_libs=
      for path in $notinst_path; do
	case " $new_libs " in
	*" -L$path/$objdir "*) ;;
	*)
	  case " $compile_deplibs " in
	  *" -L$path/$objdir "*)
	    func_append new_libs " -L$path/$objdir" ;;
	  esac
	  ;;
	esac
      done
      for deplib in $compile_deplibs; do
	case $deplib in
	-L*)
	  case " $new_libs " in
	  *" $deplib "*) ;;
	  *) func_append new_libs " $deplib" ;;
	  esac
	  ;;
	*) func_append new_libs " $deplib" ;;
	esac
      done
      compile_deplibs="$new_libs"


      func_append compile_command " $compile_deplibs"
      func_append finalize_command " $finalize_deplibs"

      if test -n "$rpath$xrpath"; then
	# If the user specified any rpath flags, then add them.
	for libdir in $rpath $xrpath; do
	  # This is the magic to use -rpath.
	  case "$finalize_rpath " in
	  *" $libdir "*) ;;
	  *) func_append finalize_rpath " $libdir" ;;
	  esac
	done
      fi

      # Now hardcode the library paths
      rpath=
      hardcode_libdirs=
      for libdir in $compile_rpath $finalize_rpath; do
	if test -n "$hardcode_libdir_flag_spec"; then
	  if test -n "$hardcode_libdir_separator"; then
	    if test -z "$hardcode_libdirs"; then
	      hardcode_libdirs="$libdir"
	    else
	      # Just accumulate the unique libdirs.
	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
		;;
	      *)
		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
		;;
	      esac
	    fi
	  else
	    eval flag=\"$hardcode_libdir_flag_spec\"
	    func_append rpath " $flag"
	  fi
	elif test -n "$runpath_var"; then
	  case "$perm_rpath " in
	  *" $libdir "*) ;;
	  *) func_append perm_rpath " $libdir" ;;
	  esac
	fi
	case $host in
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
	  testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
	  case :$dllsearchpath: in
	  *":$libdir:"*) ;;
	  ::) dllsearchpath=$libdir;;
	  *) func_append dllsearchpath ":$libdir";;
	  esac
	  case :$dllsearchpath: in
	  *":$testbindir:"*) ;;
	  ::) dllsearchpath=$testbindir;;
	  *) func_append dllsearchpath ":$testbindir";;
	  esac
	  ;;
	esac
      done
      # Substitute the hardcoded libdirs into the rpath.
      if test -n "$hardcode_libdir_separator" &&
	 test -n "$hardcode_libdirs"; then
	libdir="$hardcode_libdirs"
	eval rpath=\" $hardcode_libdir_flag_spec\"
      fi
      compile_rpath="$rpath"

      rpath=
      hardcode_libdirs=
      for libdir in $finalize_rpath; do
	if test -n "$hardcode_libdir_flag_spec"; then
	  if test -n "$hardcode_libdir_separator"; then
	    if test -z "$hardcode_libdirs"; then
	      hardcode_libdirs="$libdir"
	    else
	      # Just accumulate the unique libdirs.
	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
		;;
	      *)
		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
		;;
	      esac
	    fi
	  else
	    eval flag=\"$hardcode_libdir_flag_spec\"
	    func_append rpath " $flag"
	  fi
	elif test -n "$runpath_var"; then
	  case "$finalize_perm_rpath " in
	  *" $libdir "*) ;;
	  *) func_append finalize_perm_rpath " $libdir" ;;
	  esac
	fi
      done
      # Substitute the hardcoded libdirs into the rpath.
      if test -n "$hardcode_libdir_separator" &&
	 test -n "$hardcode_libdirs"; then
	libdir="$hardcode_libdirs"
	eval rpath=\" $hardcode_libdir_flag_spec\"
      fi
      finalize_rpath="$rpath"

      if test -n "$libobjs" && test "$build_old_libs" = yes; then
	# Transform all the library objects into standard objects.
	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
      fi

      func_generate_dlsyms "$outputname" "@PROGRAM@" "no"

      # template prelinking step
      if test -n "$prelink_cmds"; then
	func_execute_cmds "$prelink_cmds" 'exit $?'
      fi

      wrappers_required=yes
      case $host in
      *cegcc* | *mingw32ce*)
        # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
        wrappers_required=no
        ;;
      *cygwin* | *mingw* )
        if test "$build_libtool_libs" != yes; then
          wrappers_required=no
        fi
        ;;
      *)
        if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
          wrappers_required=no
        fi
        ;;
      esac
      if test "$wrappers_required" = no; then
	# Replace the output file specification.
	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
	link_command="$compile_command$compile_rpath"

	# We have no uninstalled library dependencies, so finalize right now.
	exit_status=0
	func_show_eval "$link_command" 'exit_status=$?'

	if test -n "$postlink_cmds"; then
	  func_to_tool_file "$output"
	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
	  func_execute_cmds "$postlink_cmds" 'exit $?'
	fi

	# Delete the generated files.
	if test -f "$output_objdir/${outputname}S.${objext}"; then
	  func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
	fi

	exit $exit_status
      fi

      if test -n "$compile_shlibpath$finalize_shlibpath"; then
	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
      fi
      if test -n "$finalize_shlibpath"; then
	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
      fi

      compile_var=
      finalize_var=
      if test -n "$runpath_var"; then
	if test -n "$perm_rpath"; then
	  # We should set the runpath_var.
	  rpath=
	  for dir in $perm_rpath; do
	    func_append rpath "$dir:"
	  done
	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
	fi
	if test -n "$finalize_perm_rpath"; then
	  # We should set the runpath_var.
	  rpath=
	  for dir in $finalize_perm_rpath; do
	    func_append rpath "$dir:"
	  done
	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
	fi
      fi

      if test "$no_install" = yes; then
	# We don't need to create a wrapper script.
	link_command="$compile_var$compile_command$compile_rpath"
	# Replace the output file specification.
	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
	# Delete the old output file.
	$opt_dry_run || $RM $output
	# Link the executable and exit
	func_show_eval "$link_command" 'exit $?'

	if test -n "$postlink_cmds"; then
	  func_to_tool_file "$output"
	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
	  func_execute_cmds "$postlink_cmds" 'exit $?'
	fi

	exit $EXIT_SUCCESS
      fi

      if test "$hardcode_action" = relink; then
	# Fast installation is not supported
	link_command="$compile_var$compile_command$compile_rpath"
	relink_command="$finalize_var$finalize_command$finalize_rpath"

	func_warning "this platform does not like uninstalled shared libraries"
	func_warning "\`$output' will be relinked during installation"
      else
	if test "$fast_install" != no; then
	  link_command="$finalize_var$compile_command$finalize_rpath"
	  if test "$fast_install" = yes; then
	    relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
	  else
	    # fast_install is set to needless
	    relink_command=
	  fi
	else
	  link_command="$compile_var$compile_command$compile_rpath"
	  relink_command="$finalize_var$finalize_command$finalize_rpath"
	fi
      fi

      # Replace the output file specification.
      link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`

      # Delete the old output files.
      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname

      func_show_eval "$link_command" 'exit $?'

      if test -n "$postlink_cmds"; then
	func_to_tool_file "$output_objdir/$outputname"
	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
	func_execute_cmds "$postlink_cmds" 'exit $?'
      fi

      # Now create the wrapper script.
      func_verbose "creating $output"

      # Quote the relink command for shipping.
      if test -n "$relink_command"; then
	# Preserve any variables that may affect compiler behavior
	for var in $variables_saved_for_relink; do
	  if eval test -z \"\${$var+set}\"; then
	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
	  elif eval var_value=\$$var; test -z "$var_value"; then
	    relink_command="$var=; export $var; $relink_command"
	  else
	    func_quote_for_eval "$var_value"
	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
	  fi
	done
	relink_command="(cd `pwd`; $relink_command)"
	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
      fi

      # Only actually do things if not in dry run mode.
      $opt_dry_run || {
	# win32 will think the script is a binary if it has
	# a .exe suffix, so we strip it off here.
	case $output in
	  *.exe) func_stripname '' '.exe' "$output"
	         output=$func_stripname_result ;;
	esac
	# test for cygwin because mv fails w/o .exe extensions
	case $host in
	  *cygwin*)
	    exeext=.exe
	    func_stripname '' '.exe' "$outputname"
	    outputname=$func_stripname_result ;;
	  *) exeext= ;;
	esac
	case $host in
	  *cygwin* | *mingw* )
	    func_dirname_and_basename "$output" "" "."
	    output_name=$func_basename_result
	    output_path=$func_dirname_result
	    cwrappersource="$output_path/$objdir/lt-$output_name.c"
	    cwrapper="$output_path/$output_name.exe"
	    $RM $cwrappersource $cwrapper
	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15

	    func_emit_cwrapperexe_src > $cwrappersource

	    # The wrapper executable is built using the $host compiler,
	    # because it contains $host paths and files. If cross-
	    # compiling, it, like the target executable, must be
	    # executed on the $host or under an emulation environment.
	    $opt_dry_run || {
	      $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
	      $STRIP $cwrapper
	    }

	    # Now, create the wrapper script for func_source use:
	    func_ltwrapper_scriptname $cwrapper
	    $RM $func_ltwrapper_scriptname_result
	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
	    $opt_dry_run || {
	      # note: this script will not be executed, so do not chmod.
	      if test "x$build" = "x$host" ; then
		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
	      else
		func_emit_wrapper no > $func_ltwrapper_scriptname_result
	      fi
	    }
	  ;;
	  * )
	    $RM $output
	    trap "$RM $output; exit $EXIT_FAILURE" 1 2 15

	    func_emit_wrapper no > $output
	    chmod +x $output
	  ;;
	esac
      }
      exit $EXIT_SUCCESS
      ;;
    esac

    # See if we need to build an old-fashioned archive.
    for oldlib in $oldlibs; do

      if test "$build_libtool_libs" = convenience; then
	oldobjs="$libobjs_save $symfileobj"
	addlibs="$convenience"
	build_libtool_libs=no
      else
	if test "$build_libtool_libs" = module; then
	  oldobjs="$libobjs_save"
	  build_libtool_libs=no
	else
	  oldobjs="$old_deplibs $non_pic_objects"
	  if test "$preload" = yes && test -f "$symfileobj"; then
	    func_append oldobjs " $symfileobj"
	  fi
	fi
	addlibs="$old_convenience"
      fi

      if test -n "$addlibs"; then
	gentop="$output_objdir/${outputname}x"
	func_append generated " $gentop"

	func_extract_archives $gentop $addlibs
	func_append oldobjs " $func_extract_archives_result"
      fi

      # Do each command in the archive commands.
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
	cmds=$old_archive_from_new_cmds
      else

	# Add any objects from preloaded convenience libraries
	if test -n "$dlprefiles"; then
	  gentop="$output_objdir/${outputname}x"
	  func_append generated " $gentop"

	  func_extract_archives $gentop $dlprefiles
	  func_append oldobjs " $func_extract_archives_result"
	fi

	# POSIX demands no paths to be encoded in archives.  We have
	# to avoid creating archives with duplicate basenames if we
	# might have to extract them afterwards, e.g., when creating a
	# static archive out of a convenience library, or when linking
	# the entirety of a libtool archive into another (currently
	# not supported by libtool).
	if (for obj in $oldobjs
	    do
	      func_basename "$obj"
	      $ECHO "$func_basename_result"
	    done | sort | sort -uc >/dev/null 2>&1); then
	  :
	else
	  echo "copying selected object files to avoid basename conflicts..."
	  gentop="$output_objdir/${outputname}x"
	  func_append generated " $gentop"
	  func_mkdir_p "$gentop"
	  save_oldobjs=$oldobjs
	  oldobjs=
	  counter=1
	  for obj in $save_oldobjs
	  do
	    func_basename "$obj"
	    objbase="$func_basename_result"
	    case " $oldobjs " in
	    " ") oldobjs=$obj ;;
	    *[\ /]"$objbase "*)
	      while :; do
		# Make sure we don't pick an alternate name that also
		# overlaps.
		newobj=lt$counter-$objbase
		func_arith $counter + 1
		counter=$func_arith_result
		case " $oldobjs " in
		*[\ /]"$newobj "*) ;;
		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
		esac
	      done
	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
	      func_append oldobjs " $gentop/$newobj"
	      ;;
	    *) func_append oldobjs " $obj" ;;
	    esac
	  done
	fi
	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
	tool_oldlib=$func_to_tool_file_result
	eval cmds=\"$old_archive_cmds\"

	func_len " $cmds"
	len=$func_len_result
	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
	  cmds=$old_archive_cmds
	elif test -n "$archiver_list_spec"; then
	  func_verbose "using command file archive linking..."
	  for obj in $oldobjs
	  do
	    func_to_tool_file "$obj"
	    $ECHO "$func_to_tool_file_result"
	  done > $output_objdir/$libname.libcmd
	  func_to_tool_file "$output_objdir/$libname.libcmd"
	  oldobjs=" $archiver_list_spec$func_to_tool_file_result"
	  cmds=$old_archive_cmds
	else
	  # the command line is too long to link in one step, link in parts
	  func_verbose "using piecewise archive linking..."
	  save_RANLIB=$RANLIB
	  RANLIB=:
	  objlist=
	  concat_cmds=
	  save_oldobjs=$oldobjs
	  oldobjs=
	  # Is there a better way of finding the last object in the list?
	  for obj in $save_oldobjs
	  do
	    last_oldobj=$obj
	  done
	  eval test_cmds=\"$old_archive_cmds\"
	  func_len " $test_cmds"
	  len0=$func_len_result
	  len=$len0
	  for obj in $save_oldobjs
	  do
	    func_len " $obj"
	    func_arith $len + $func_len_result
	    len=$func_arith_result
	    func_append objlist " $obj"
	    if test "$len" -lt "$max_cmd_len"; then
	      :
	    else
	      # the above command should be used before it gets too long
	      oldobjs=$objlist
	      if test "$obj" = "$last_oldobj" ; then
		RANLIB=$save_RANLIB
	      fi
	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
	      objlist=
	      len=$len0
	    fi
	  done
	  RANLIB=$save_RANLIB
	  oldobjs=$objlist
	  if test "X$oldobjs" = "X" ; then
	    eval cmds=\"\$concat_cmds\"
	  else
	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
	  fi
	fi
      fi
      func_execute_cmds "$cmds" 'exit $?'
    done

    test -n "$generated" && \
      func_show_eval "${RM}r$generated"

    # Now create the libtool archive.
    case $output in
    *.la)
      old_library=
      test "$build_old_libs" = yes && old_library="$libname.$libext"
      func_verbose "creating $output"

      # Preserve any variables that may affect compiler behavior
      for var in $variables_saved_for_relink; do
	if eval test -z \"\${$var+set}\"; then
	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
	elif eval var_value=\$$var; test -z "$var_value"; then
	  relink_command="$var=; export $var; $relink_command"
	else
	  func_quote_for_eval "$var_value"
	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
	fi
      done
      # Quote the link command for shipping.
      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
      if test "$hardcode_automatic" = yes ; then
	relink_command=
      fi

      # Only create the output if not a dry run.
      $opt_dry_run || {
	for installed in no yes; do
	  if test "$installed" = yes; then
	    if test -z "$install_libdir"; then
	      break
	    fi
	    output="$output_objdir/$outputname"i
	    # Replace all uninstalled libtool libraries with the installed ones
	    newdependency_libs=
	    for deplib in $dependency_libs; do
	      case $deplib in
	      *.la)
		func_basename "$deplib"
		name="$func_basename_result"
		func_resolve_sysroot "$deplib"
		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
		test -z "$libdir" && \
		  func_fatal_error "\`$deplib' is not a valid libtool archive"
		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
		;;
	      -L*)
		func_stripname -L '' "$deplib"
		func_replace_sysroot "$func_stripname_result"
		func_append newdependency_libs " -L$func_replace_sysroot_result"
		;;
	      -R*)
		func_stripname -R '' "$deplib"
		func_replace_sysroot "$func_stripname_result"
		func_append newdependency_libs " -R$func_replace_sysroot_result"
		;;
	      *) func_append newdependency_libs " $deplib" ;;
	      esac
	    done
	    dependency_libs="$newdependency_libs"
	    newdlfiles=

	    for lib in $dlfiles; do
	      case $lib in
	      *.la)
	        func_basename "$lib"
		name="$func_basename_result"
		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
		test -z "$libdir" && \
		  func_fatal_error "\`$lib' is not a valid libtool archive"
		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
		;;
	      *) func_append newdlfiles " $lib" ;;
	      esac
	    done
	    dlfiles="$newdlfiles"
	    newdlprefiles=
	    for lib in $dlprefiles; do
	      case $lib in
	      *.la)
		# Only pass preopened files to the pseudo-archive (for
		# eventual linking with the app. that links it) if we
		# didn't already link the preopened objects directly into
		# the library:
		func_basename "$lib"
		name="$func_basename_result"
		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
		test -z "$libdir" && \
		  func_fatal_error "\`$lib' is not a valid libtool archive"
		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
		;;
	      esac
	    done
	    dlprefiles="$newdlprefiles"
	  else
	    newdlfiles=
	    for lib in $dlfiles; do
	      case $lib in
		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
		*) abs=`pwd`"/$lib" ;;
	      esac
	      func_append newdlfiles " $abs"
	    done
	    dlfiles="$newdlfiles"
	    newdlprefiles=
	    for lib in $dlprefiles; do
	      case $lib in
		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
		*) abs=`pwd`"/$lib" ;;
	      esac
	      func_append newdlprefiles " $abs"
	    done
	    dlprefiles="$newdlprefiles"
	  fi
	  $RM $output
	  # place dlname in correct position for cygwin
	  # In fact, it would be nice if we could use this code for all target
	  # systems that can't hard-code library paths into their executables
	  # and that have no shared library path variable independent of PATH,
	  # but it turns out we can't easily determine that from inspecting
	  # libtool variables, so we have to hard-code the OSs to which it
	  # applies here; at the moment, that means platforms that use the PE
	  # object format with DLL files.  See the long comment at the top of
	  # tests/bindir.at for full details.
	  tdlname=$dlname
	  case $host,$output,$installed,$module,$dlname in
	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
	      # If a -bindir argument was supplied, place the dll there.
	      if test "x$bindir" != x ;
	      then
		func_relative_path "$install_libdir" "$bindir"
		tdlname=$func_relative_path_result$dlname
	      else
		# Otherwise fall back on heuristic.
		tdlname=../bin/$dlname
	      fi
	      ;;
	  esac
	  $ECHO > $output "\
# $outputname - a libtool library file
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
#
# Please DO NOT delete this file!
# It is necessary for linking the library.

# The name that we can dlopen(3).
dlname='$tdlname'

# Names of this library.
library_names='$library_names'

# The name of the static archive.
old_library='$old_library'

# Linker flags that can not go in dependency_libs.
inherited_linker_flags='$new_inherited_linker_flags'

# Libraries that this one depends upon.
dependency_libs='$dependency_libs'

# Names of additional weak libraries provided by this library
weak_library_names='$weak_libs'

# Version information for $libname.
current=$current
age=$age
revision=$revision

# Is this an already installed library?
installed=$installed

# Should we warn about portability when linking against -modules?
shouldnotlink=$module

# Files to dlopen/dlpreopen
dlopen='$dlfiles'
dlpreopen='$dlprefiles'

# Directory that this library needs to be installed in:
libdir='$install_libdir'"
	  if test "$installed" = no && test "$need_relink" = yes; then
	    $ECHO >> $output "\
relink_command=\"$relink_command\""
	  fi
	done
      }

      # Do a symbolic link so that the libtool archive can be found in
      # LD_LIBRARY_PATH before the program is installed.
      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
      ;;
    esac
    exit $EXIT_SUCCESS
}

{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
    func_mode_link ${1+"$@"}


# func_mode_uninstall arg...
func_mode_uninstall ()
{
    $opt_debug
    RM="$nonopt"
    files=
    rmforce=
    exit_status=0

    # This variable tells wrapper scripts just to set variables rather
    # than running their programs.
    libtool_install_magic="$magic"

    for arg
    do
      case $arg in
      -f) func_append RM " $arg"; rmforce=yes ;;
      -*) func_append RM " $arg" ;;
      *) func_append files " $arg" ;;
      esac
    done

    test -z "$RM" && \
      func_fatal_help "you must specify an RM program"

    rmdirs=

    for file in $files; do
      func_dirname "$file" "" "."
      dir="$func_dirname_result"
      if test "X$dir" = X.; then
	odir="$objdir"
      else
	odir="$dir/$objdir"
      fi
      func_basename "$file"
      name="$func_basename_result"
      test "$opt_mode" = uninstall && odir="$dir"

      # Remember odir for removal later, being careful to avoid duplicates
      if test "$opt_mode" = clean; then
	case " $rmdirs " in
	  *" $odir "*) ;;
	  *) func_append rmdirs " $odir" ;;
	esac
      fi

      # Don't error if the file doesn't exist and rm -f was used.
      if { test -L "$file"; } >/dev/null 2>&1 ||
	 { test -h "$file"; } >/dev/null 2>&1 ||
	 test -f "$file"; then
	:
      elif test -d "$file"; then
	exit_status=1
	continue
      elif test "$rmforce" = yes; then
	continue
      fi

      rmfiles="$file"

      case $name in
      *.la)
	# Possibly a libtool archive, so verify it.
	if func_lalib_p "$file"; then
	  func_source $dir/$name

	  # Delete the libtool libraries and symlinks.
	  for n in $library_names; do
	    func_append rmfiles " $odir/$n"
	  done
	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"

	  case "$opt_mode" in
	  clean)
	    case " $library_names " in
	    *" $dlname "*) ;;
	    *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
	    esac
	    test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
	    ;;
	  uninstall)
	    if test -n "$library_names"; then
	      # Do each command in the postuninstall commands.
	      func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
	    fi

	    if test -n "$old_library"; then
	      # Do each command in the old_postuninstall commands.
	      func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
	    fi
	    # FIXME: should reinstall the best remaining shared library.
	    ;;
	  esac
	fi
	;;

      *.lo)
	# Possibly a libtool object, so verify it.
	if func_lalib_p "$file"; then

	  # Read the .lo file
	  func_source $dir/$name

	  # Add PIC object to the list of files to remove.
	  if test -n "$pic_object" &&
	     test "$pic_object" != none; then
	    func_append rmfiles " $dir/$pic_object"
	  fi

	  # Add non-PIC object to the list of files to remove.
	  if test -n "$non_pic_object" &&
	     test "$non_pic_object" != none; then
	    func_append rmfiles " $dir/$non_pic_object"
	  fi
	fi
	;;

      *)
	if test "$opt_mode" = clean ; then
	  noexename=$name
	  case $file in
	  *.exe)
	    func_stripname '' '.exe' "$file"
	    file=$func_stripname_result
	    func_stripname '' '.exe' "$name"
	    noexename=$func_stripname_result
	    # $file with .exe has already been added to rmfiles,
	    # add $file without .exe
	    func_append rmfiles " $file"
	    ;;
	  esac
	  # Do a test to see if this is a libtool program.
	  if func_ltwrapper_p "$file"; then
	    if func_ltwrapper_executable_p "$file"; then
	      func_ltwrapper_scriptname "$file"
	      relink_command=
	      func_source $func_ltwrapper_scriptname_result
	      func_append rmfiles " $func_ltwrapper_scriptname_result"
	    else
	      relink_command=
	      func_source $dir/$noexename
	    fi

	    # note $name still contains .exe if it was in $file originally
	    # as does the version of $file that was added into $rmfiles
	    func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
	    if test "$fast_install" = yes && test -n "$relink_command"; then
	      func_append rmfiles " $odir/lt-$name"
	    fi
	    if test "X$noexename" != "X$name" ; then
	      func_append rmfiles " $odir/lt-${noexename}.c"
	    fi
	  fi
	fi
	;;
      esac
      func_show_eval "$RM $rmfiles" 'exit_status=1'
    done

    # Try to remove the ${objdir}s in the directories where we deleted files
    for dir in $rmdirs; do
      if test -d "$dir"; then
	func_show_eval "rmdir $dir >/dev/null 2>&1"
      fi
    done

    exit $exit_status
}

{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
    func_mode_uninstall ${1+"$@"}

test -z "$opt_mode" && {
  help="$generic_help"
  func_fatal_help "you must specify a MODE"
}

test -z "$exec_cmd" && \
  func_fatal_help "invalid operation mode \`$opt_mode'"

if test -n "$exec_cmd"; then
  eval exec "$exec_cmd"
  exit $EXIT_FAILURE
fi

exit $exit_status


# The TAGs below are defined such that we never get into a situation
# in which we disable both kinds of libraries.  Given conflicting
# choices, we go for a static library, that is the most portable,
# since we can't tell whether shared libraries were disabled because
# the user asked for that or because the platform doesn't support
# them.  This is particularly important on AIX, because we don't
# support having both static and shared libraries enabled at the same
# time on that platform, so we default to a shared-only configuration.
# If a disable-shared tag is given, we'll fallback to a static-only
# configuration.  But we'll never go from static-only to shared-only.

# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
build_libtool_libs=no
build_old_libs=yes
# ### END LIBTOOL TAG CONFIG: disable-shared

# ### BEGIN LIBTOOL TAG CONFIG: disable-static
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
# ### END LIBTOOL TAG CONFIG: disable-static

# Local Variables:
# mode:shell-script
# sh-indentation:2
# End:
# vi:sw=2

healpy-1.10.3/healpixsubmodule/src/cxx/autotools/make_release0000664000175000017500000000050413010375061024655 0ustar  zoncazonca00000000000000#!/bin/sh

NAME=HealpixCxx-3.12_experimental
URL=http://svn.code.sf.net/p/healpix/code/trunk/src/cxx
REV=HEAD

svn export -r ${REV} ${URL} ${NAME} &&\
cd ${NAME}/autotools &&\
autoreconf --install &&\
./configure &&\
make -j2 distcheck &&\
cd - &&\
mv ${NAME}/autotools/*tar.gz . &&\
chmod -R a+w ${NAME} &&\
rm -rf ${NAME}
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/missing0000755000175000017500000001533113010376370023722 0ustar  zoncazonca00000000000000#! /bin/sh
# Common wrapper for a few potentially missing GNU programs.

scriptversion=2012-06-26.16; # UTC

# Copyright (C) 1996-2013 Free Software Foundation, Inc.
# Originally written by Fran,cois Pinard , 1996.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

if test $# -eq 0; then
  echo 1>&2 "Try '$0 --help' for more information"
  exit 1
fi

case $1 in

  --is-lightweight)
    # Used by our autoconf macros to check whether the available missing
    # script is modern enough.
    exit 0
    ;;

  --run)
    # Back-compat with the calling convention used by older automake.
    shift
    ;;

  -h|--h|--he|--hel|--help)
    echo "\
$0 [OPTION]... PROGRAM [ARGUMENT]...

Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
to PROGRAM being missing or too old.

Options:
  -h, --help      display this help and exit
  -v, --version   output version information and exit

Supported PROGRAM values:
  aclocal   autoconf  autoheader   autom4te  automake  makeinfo
  bison     yacc      flex         lex       help2man

Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
'g' are ignored when checking the name.

Send bug reports to ."
    exit $?
    ;;

  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
    echo "missing $scriptversion (GNU Automake)"
    exit $?
    ;;

  -*)
    echo 1>&2 "$0: unknown '$1' option"
    echo 1>&2 "Try '$0 --help' for more information"
    exit 1
    ;;

esac

# Run the given program, remember its exit status.
"$@"; st=$?

# If it succeeded, we are done.
test $st -eq 0 && exit 0

# Also exit now if we it failed (or wasn't found), and '--version' was
# passed; such an option is passed most likely to detect whether the
# program is present and works.
case $2 in --version|--help) exit $st;; esac

# Exit code 63 means version mismatch.  This often happens when the user
# tries to use an ancient version of a tool on a file that requires a
# minimum version.
if test $st -eq 63; then
  msg="probably too old"
elif test $st -eq 127; then
  # Program was missing.
  msg="missing on your system"
else
  # Program was found and executed, but failed.  Give up.
  exit $st
fi

perl_URL=http://www.perl.org/
flex_URL=http://flex.sourceforge.net/
gnu_software_URL=http://www.gnu.org/software

program_details ()
{
  case $1 in
    aclocal|automake)
      echo "The '$1' program is part of the GNU Automake package:"
      echo "<$gnu_software_URL/automake>"
      echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
      echo "<$gnu_software_URL/autoconf>"
      echo "<$gnu_software_URL/m4/>"
      echo "<$perl_URL>"
      ;;
    autoconf|autom4te|autoheader)
      echo "The '$1' program is part of the GNU Autoconf package:"
      echo "<$gnu_software_URL/autoconf/>"
      echo "It also requires GNU m4 and Perl in order to run:"
      echo "<$gnu_software_URL/m4/>"
      echo "<$perl_URL>"
      ;;
  esac
}

give_advice ()
{
  # Normalize program name to check for.
  normalized_program=`echo "$1" | sed '
    s/^gnu-//; t
    s/^gnu//; t
    s/^g//; t'`

  printf '%s\n' "'$1' is $msg."

  configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
  case $normalized_program in
    autoconf*)
      echo "You should only need it if you modified 'configure.ac',"
      echo "or m4 files included by it."
      program_details 'autoconf'
      ;;
    autoheader*)
      echo "You should only need it if you modified 'acconfig.h' or"
      echo "$configure_deps."
      program_details 'autoheader'
      ;;
    automake*)
      echo "You should only need it if you modified 'Makefile.am' or"
      echo "$configure_deps."
      program_details 'automake'
      ;;
    aclocal*)
      echo "You should only need it if you modified 'acinclude.m4' or"
      echo "$configure_deps."
      program_details 'aclocal'
      ;;
   autom4te*)
      echo "You might have modified some maintainer files that require"
      echo "the 'automa4te' program to be rebuilt."
      program_details 'autom4te'
      ;;
    bison*|yacc*)
      echo "You should only need it if you modified a '.y' file."
      echo "You may want to install the GNU Bison package:"
      echo "<$gnu_software_URL/bison/>"
      ;;
    lex*|flex*)
      echo "You should only need it if you modified a '.l' file."
      echo "You may want to install the Fast Lexical Analyzer package:"
      echo "<$flex_URL>"
      ;;
    help2man*)
      echo "You should only need it if you modified a dependency" \
           "of a man page."
      echo "You may want to install the GNU Help2man package:"
      echo "<$gnu_software_URL/help2man/>"
    ;;
    makeinfo*)
      echo "You should only need it if you modified a '.texi' file, or"
      echo "any other file indirectly affecting the aspect of the manual."
      echo "You might want to install the Texinfo package:"
      echo "<$gnu_software_URL/texinfo/>"
      echo "The spurious makeinfo call might also be the consequence of"
      echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
      echo "want to install GNU make:"
      echo "<$gnu_software_URL/make/>"
      ;;
    *)
      echo "You might have modified some files without having the proper"
      echo "tools for further handling them.  Check the 'README' file, it"
      echo "often tells you about the needed prerequisites for installing"
      echo "this package.  You may also peek at any GNU archive site, in"
      echo "case some other package contains this missing '$1' program."
      ;;
  esac
}

give_advice "$1" | sed -e '1s/^/WARNING: /' \
                       -e '2,$s/^/         /' >&2

# Propagate the correct exit status (expected to be 127 for a program
# not found, 63 for a program that failed due to version mismatch).
exit $st

# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End:
healpy-1.10.3/healpixsubmodule/src/cxx/autotools/test-driver0000755000175000017500000000761113010376370024523 0ustar  zoncazonca00000000000000#! /bin/sh
# test-driver - basic testsuite driver script.

scriptversion=2012-06-27.10; # UTC

# Copyright (C) 2011-2013 Free Software Foundation, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.

# This file is maintained in Automake, please report
# bugs to  or send patches to
# .

# Make unconditional expansion of undefined variables an error.  This
# helps a lot in preventing typo-related bugs.
set -u

usage_error ()
{
  echo "$0: $*" >&2
  print_usage >&2
  exit 2
}

print_usage ()
{
  cat <$log_file 2>&1
estatus=$?
if test $enable_hard_errors = no && test $estatus -eq 99; then
  estatus=1
fi

case $estatus:$expect_failure in
  0:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
  0:*)   col=$grn res=PASS  recheck=no  gcopy=no;;
  77:*)  col=$blu res=SKIP  recheck=no  gcopy=yes;;
  99:*)  col=$mgn res=ERROR recheck=yes gcopy=yes;;
  *:yes) col=$lgn res=XFAIL recheck=no  gcopy=yes;;
  *:*)   col=$red res=FAIL  recheck=yes gcopy=yes;;
esac

# Report outcome to console.
echo "${col}${res}${std}: $test_name"

# Register the test result, and other relevant metadata.
echo ":test-result: $res" > $trs_file
echo ":global-test-result: $res" >> $trs_file
echo ":recheck: $recheck" >> $trs_file
echo ":copy-in-global-log: $gcopy" >> $trs_file

# Local Variables:
# mode: shell-script
# sh-indentation: 2
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End:
healpy-1.10.3/healpy/0000775000175000017500000000000013031130324014576 5ustar  zoncazonca00000000000000healpy-1.10.3/healpy/data/0000775000175000017500000000000013031130324015507 5ustar  zoncazonca00000000000000healpy-1.10.3/healpy/data/pixel_window_n0002.fits0000664000175000017500000002070013010374155021735 0ustar  zoncazonca00000000000000SIMPLE  =                    T / Written by IDL:  Fri Nov 29 16:12:11 2002      BITPIX  =                   16 / Number of bits per data pixel                  NAXIS   =                    0 / Number of data axes                            EXTEND  =                    T / FITS data may contain extensions               DATE    = '2002-11-30'         / Creation UTC (CCCC-MM-DD) date of FITS header  COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy  COMMENT and Astrophysics', volume 376, page 359; bibcode 2001A&A...376..359H    END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   16 / width of table in bytes                        NAXIS2  =                    9 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    2 / number of fields in each row                   COMMENT                                                                         EXTNAME = 'PIXEL WINDOW'       /                                                NSIDE   =                    2 / Resolution parameter for HEALPIX               MAX-LPOL=                    8 / Maximum multipole l=4*nside                    COMMENT                                                                         COMMENT                                                                         COMMENT                                                                         COMMENT  Contains pixel window smoothing factors                                COMMENT  for temperature and polarization for NSIDE =     2                     COMMENT  for multipoles in range [0,    8]                                      COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / TEMPERATURE pixel window smoothing factors     TFORM1  = '1D      '           / data format of field: 8-byte REAL              TUNIT1  = 'unknown '           / no unit                                        COMMENT                                                                         TTYPE2  = 'POLARIZATION'       / POLARIZATION pixel window smoothing factors    TFORM2  = '1D      '           / data format of field: 8-byte REAL              TUNIT2  = 'unknown '           / no unit                                        HISTORY                                                                         HISTORY  For NSIDE <= 128, the T and P windows are computed exactly             HISTORY  by averaging the individual pixel windows.                             HISTORY  For NSIDE > 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ??F??/?GҠr?ԻhHU?-a-?Jӝd?>?^?Ogq:?4**?9"Ȳ^^?pF3?ԳX`?rm3=?thealpy-1.10.3/healpy/data/pixel_window_n0004.fits0000664000175000017500000002070013010374155021737 0ustar  zoncazonca00000000000000SIMPLE  =                    T / Written by IDL:  Fri Nov 29 16:12:11 2002      BITPIX  =                   16 / Number of bits per data pixel                  NAXIS   =                    0 / Number of data axes                            EXTEND  =                    T / FITS data may contain extensions               DATE    = '2002-11-30'         / Creation UTC (CCCC-MM-DD) date of FITS header  COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy  COMMENT and Astrophysics', volume 376, page 359; bibcode 2001A&A...376..359H    END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   16 / width of table in bytes                        NAXIS2  =                   17 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    2 / number of fields in each row                   COMMENT                                                                         EXTNAME = 'PIXEL WINDOW'       /                                                NSIDE   =                    4 / Resolution parameter for HEALPIX               MAX-LPOL=                   16 / Maximum multipole l=4*nside                    COMMENT                                                                         COMMENT                                                                         COMMENT                                                                         COMMENT  Contains pixel window smoothing factors                                COMMENT  for temperature and polarization for NSIDE =     4                     COMMENT  for multipoles in range [0,   16]                                      COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / TEMPERATURE pixel window smoothing factors     TFORM1  = '1D      '           / data format of field: 8-byte REAL              TUNIT1  = 'unknown '           / no unit                                        COMMENT                                                                         TTYPE2  = 'POLARIZATION'       / POLARIZATION pixel window smoothing factors    TFORM2  = '1D      '           / data format of field: 8-byte REAL              TUNIT2  = 'unknown '           / no unit                                        HISTORY                                                                         HISTORY  For NSIDE <= 128, the T and P windows are computed exactly             HISTORY  by averaging the individual pixel windows.                             HISTORY  For NSIDE > 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ?$@?z2O?r~Mc?FL?G?D~f?1o?WE$?R%?_޾?M"?Z|5?%YW}?yXc?߯=.G?0?j+?̘Dx?	3x?Sw!?傪A?IZ~(?=x?0?
T?T%<?⑽?he?et?3T?ޝJ
?t?h`(healpy-1.10.3/healpy/data/pixel_window_n0008.fits0000664000175000017500000002070013010374155021743 0ustar  zoncazonca00000000000000SIMPLE  =                    T / Written by IDL:  Fri Nov 29 16:12:11 2002      BITPIX  =                   16 / Number of bits per data pixel                  NAXIS   =                    0 / Number of data axes                            EXTEND  =                    T / FITS data may contain extensions               DATE    = '2002-11-30'         / Creation UTC (CCCC-MM-DD) date of FITS header  COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy  COMMENT and Astrophysics', volume 376, page 359; bibcode 2001A&A...376..359H    END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   16 / width of table in bytes                        NAXIS2  =                   33 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    2 / number of fields in each row                   COMMENT                                                                         EXTNAME = 'PIXEL WINDOW'       /                                                NSIDE   =                    8 / Resolution parameter for HEALPIX               MAX-LPOL=                   32 / Maximum multipole l=4*nside                    COMMENT                                                                         COMMENT                                                                         COMMENT                                                                         COMMENT  Contains pixel window smoothing factors                                COMMENT  for temperature and polarization for NSIDE =     8                     COMMENT  for multipoles in range [0,   32]                                      COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / TEMPERATURE pixel window smoothing factors     TFORM1  = '1D      '           / data format of field: 8-byte REAL              TUNIT1  = 'unknown '           / no unit                                        COMMENT                                                                         TTYPE2  = 'POLARIZATION'       / POLARIZATION pixel window smoothing factors    TFORM2  = '1D      '           / data format of field: 8-byte REAL              TUNIT2  = 'unknown '           / no unit                                        HISTORY                                                                         HISTORY  For NSIDE <= 128, the T and P windows are computed exactly             HISTORY  by averaging the individual pixel windows.                             HISTORY  For NSIDE > 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ?	?Qq?b@?`
?>
?Ѝd@?07?Qk?O24L?f?	\M? [08? P?ό?\k?sc??
|?X?='?
>,Y'?#Ad?P4v?ε?~V?4G?jcII?b^Y?Χ'o?Gdͳ?+vq??9??Q&?Pf?_Uk?xV?.kN?`ܳ^?s
?"4{?(_?x?\~*?1?(? N?Mʷ?^i?g?s?mgg?s???Ͱ?;&?'Ǐ^?K,?Y%a]?GC?h?cp2?}b?:$?7healpy-1.10.3/healpy/data/pixel_window_n0016.fits0000664000175000017500000002070013010374155021742 0ustar  zoncazonca00000000000000SIMPLE  =                    T / Written by IDL:  Fri Nov 29 16:12:11 2002      BITPIX  =                   16 / Number of bits per data pixel                  NAXIS   =                    0 / Number of data axes                            EXTEND  =                    T / FITS data may contain extensions               DATE    = '2002-11-30'         / Creation UTC (CCCC-MM-DD) date of FITS header  COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy  COMMENT and Astrophysics', volume 376, page 359; bibcode 2001A&A...376..359H    END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   16 / width of table in bytes                        NAXIS2  =                   65 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    2 / number of fields in each row                   COMMENT                                                                         EXTNAME = 'PIXEL WINDOW'       /                                                NSIDE   =                   16 / Resolution parameter for HEALPIX               MAX-LPOL=                   64 / Maximum multipole l=4*nside                    COMMENT                                                                         COMMENT                                                                         COMMENT                                                                         COMMENT  Contains pixel window smoothing factors                                COMMENT  for temperature and polarization for NSIDE =    16                     COMMENT  for multipoles in range [0,   64]                                      COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / TEMPERATURE pixel window smoothing factors     TFORM1  = '1D      '           / data format of field: 8-byte REAL              TUNIT1  = 'unknown '           / no unit                                        COMMENT                                                                         TTYPE2  = 'POLARIZATION'       / POLARIZATION pixel window smoothing factors    TFORM2  = '1D      '           / data format of field: 8-byte REAL              TUNIT2  = 'unknown '           / no unit                                        HISTORY                                                                         HISTORY  For NSIDE <= 128, the T and P windows are computed exactly             HISTORY  by averaging the individual pixel windows.                             HISTORY  For NSIDE > 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ?D?}?)?`?$cŶ?y=]?A<?2|?jp?Yf?mLo?Ǐ$μ?L5?SNZ?UM?;2?zfE??]"R?c]yt?=S
C?C+K2?XP? +Ts?=?d?
6??卉s?=Ż?(d?sF1?x?B<H?H@IC?~R??'zpc?ʿnʢ?L?5K.?R?W1;*?U?OD?驹/?鮳ZӶ?S*e?X
6d 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ??A4i?ç@h?A6,1?o?~??
	?Ӑ1?Pƛa?\K߅?U?'#x
?8?4d!?e/?ބg?Y?SM?ؓC?I?j	u?	A{?DŽw??hfk?mT?ٳ?ﳇzP?o?q7?'?H=:?n?ZǨ?^j7?(?sfA'I?tuf'?dk??f/`?URi?V?E9&E)?FԳ%?4klV?5Igy?"
{?$_|?љ
?,zѝ3?Xa|?G6U?@+x?볍U?)Zh?pD}??L?q`T??)x??~72?bE?f-/?h
xH?N[W?O0sz?5sX?6m??1l6:?RS@?M?!E4??OvB?uek?*s?e(?ABb?풸W?M+a?upzRG+?vBs?Wq$~?XU?9J i?:v_'?1?d^?^r?>Y?&?-+Y3?\K?;@?ꎎ?Vp:?e~?f|n?{?@?8?ﯟz~?冀|D?#?c?Z:`L_?>"?qu??[rA?T!??EK?҅?:6?Z ?}n9?~4E?vR/?w7m?oS?p
?hW
 ?h{?`я˥?a/t
C?Y4?Y||?Q>yb?Q70*?I1S?I+?@D?AT6l?87Lň?8췣-?/5hn?0Xb@?':V?'V~?Lt3:?[*c?2r1J?
?'L?I-?y?֎+F?9?7ͮ?x?mB?,?v
@?<`P?T?Ъ}?L?2HA?Ǝjhs?
䍘?Tݲ?¥?2?u9N?!+Q?n?fI?Q1c,x?
x$?׉'?3Hԧ?x3U?xB6N?le?l$9#?`mz?`?TLhTw?TM?O?Hy?H[?;Ci?;#*?.1bM?/IS?"'=j?"
r?7k2G
?·e?}?ysԯG?Mj?8N+?t?S6J?O?=<,?)L?҃?H?Ģh䂚??"}?;]?k?i^;3?홸??:^b?틓;?|rp2?|Y.?mdn?n#?^)"?_1v?O7d8?Pn?@X?@V?1ī]?1w97?!:^?!G?U??}4Ut?qA?kN?P?s
?")4?Vt?ѽz?k?X?cUb?ΜH?%ѡ?!{?xէ#?P0E?쏧R?~\F?~&5?mFq?mܨA?\`1?\b3h?JKb?KU?91zv?9$|?'AF?'꽦?j>?$?U\??wf??:?#?߾\eG?4?vg%??F	?c?먆?9?&?2?=?j?p-؉/?pI?]&?]zujo?J/n:?JS?6?7
?#W2;:?#HW??(=x?4_?*l?w?ŨZ?ԛA??Թx?2X}?ꬍ?Ihk?Z9?꘬?ƒ>?]y?o5?oCV?[߆?[k!?Fw
!4?F6HH?12?2	]!?0?0Y?~??\?ImD,?oB?7n?xi>?xu)?`QU?`6oA?G$?H@77?/b?/XZ?{>?eq??U?{P?DM?Rfڴ4?oDVZ[?͵(T)?gG+?w?&?T_/?LG+
?僑o	?j}
s?j†)E?QHr?Q?8̱"?9P?6*? &&?Aqϔ?+?:?8?Ի?qv?仠YT?&i?}FF?1?PSk?䉒lF?pd
?p\Jɢ?Vû?W_9?=?=֦Ѫ?$E	?$H?
?0?M+@.?rKi?*P?k[Z?㾾$|?ǵ??J?㥋`J?цQo?j?rR?r|"?Xg?Yj+??B$ ??ܡ?%Uf>?%n޷L?J?\	4Q?weuC?j?N?%Pd?E[?⿃EE(?⥠i;>?7#?|ě?5p1?rLF?r}M?Xl?X>f?>ey??)H?%9j9?%v>?O?fkA?j?	?d?L?QuI?\4a?ᾗ?ᤢ?ݽ?
d?"%?q-SzKc?qhJ6?Wr?W?=bE?=8?#4B?$8?
E?
?qd??ciE?~T?$8m?\?q7Z?࣪o?'+?@H?p?pLs?Vj3x?Vql?<~? 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ??4(?5xT?S?k?GU!??T1?Mw2?dM?y?TۋJ?r?ӿ?R=?je8*?/-I?
?o#??i?#Z?]t?urGB??i?'?3vEM?hHf?????4?LL{?$քP?b4? 	?&;*?>Y?7&?OYa?=?Ugw?7f>v?O;^?%W>(?=,N?f?:cKQ?ݔ|?g?.?n?<+5?l4h?ae??@?O[?g''?RC	?ʒ?Y??Jj?b3?݇2?ݞ@?۷dWX?*E{?T?m???u?>FS??d?w	~?65?)?矤3??4U?W!'Knv?W8i?S0
BQ?SHaAf?O5jY%?OLD~?K.jH??KF֏^?>\?:j?:Ic?6c9?6{
bl(?2m?20A?-L=?-WGn?)ca+?)znU?$8?%t? ? B?$ґ?L?q?Ѻ?^?Q?F2?6$?MJn?	_3+?	N?@j?u+?	k7\?!T?:dk?Q%?_2?w/?zj5?Fc?8TΣ?iκ?5?ZB?∸	?
?w?ݎ:e?[_j?rP?4?K>?)?*[}?Ƃ?ݝz*?)a?ÖA_?-?DJԢ?5?/?ht1?8?:?
$?x"Ú?SO?#:G?'?^B?u??؂Z?<?0B?g](	?~RC?a??S?;Ug??{?{'w[?u4?uJ?n?oL}?ocfU?i[CF?ir#?c_%&:?cvd?]X?]olc?WGd
?W^i??Q,-"O?QB?KcUp?K0p"?Dh4?>?8V)?8mg?2Ҙi?2)>?+pO?+)?%JkR?%aI?ﳊ)?X?d?{q?[?Do?V/%?lTv+?9Q?B?,\?5t#?t1q?ʰ?\?K?|KY?
?7?N#۸?d?{9
w?ՇӐ|?՞W6	?Ρ?ηVȦ?ǰD
#?Yo'?wZ?a?r)?Ǐ&G?3^?,W?cr	?I?h_ן?~j?<ǎ?S(?A[??>?Y=^?
ڂ?퇕a)*?,m?S?B&?x&p?xpu?qj?B?q7?iX?j4z?b?bKa?Z?[G\?Sr셄?S?KJt?Ky4?D>1ǔ?DT[+rm?w$;C?%cL?%yd?Gdz?Z?G3!?Tn/?
ݨ?
У?r?	:H?p?ejw?eJW?^#?w?⊹d?S9?B/?؛?[?շ5S?Ͳ?͍?ͣVY?[
0?p:M?)wɵ?4:?LAg?|*?쬌}_?쬢Hm?5'?KQC?'bJ?q?m%9?쓃k}?d%{?E?삂Kd0?삗:?ymV?z?qsy?qw?hQ?h )?`B~eR?`X&?WI(W?Wl]̡?=Đq?4F
y?4V?+N??+G?#G?#Nz?%t?:l?;Yu?Q?Iu)k?^ڐUE?Nsd?dJj?L?agkl?@+7?V:??-}*h?B0U?tI?' ʅG?(?C
a?e?;?뿍u7?뿣?Qj?fS?
Fp?"r 
z?T?O?ll?뚁`?-YtR?%Gt?뇫ߺV?w	?~?w?~T	?tˍbS"?t>?kOۈ?kd~B?aҮr?a>?X@B?XU9H?N?:?Nڊ?E?E&4?;o+
?;?1}?1٥bA?([IR?('ҵ?Y%[?mE??$?
F{?
?Q?W?'k_?<%C?HU%3?]Ԥ?a(?vmJ?s?و?~):?ϓs&o?łX?B?Ŗ
{?~^/?껓/i=?s?!?"	Wd?XX?P?
Hȴ?
o3?)??=S?WXx?rS#S?f?y?<?B:h?VV?͡mMm?͵l?7?
?*t?
.F?]ʙ?q?鶭fk?-X]b?R?ªU`?ݡ;?ݴS?tz?҇Q?Bz?Us*?
vz?rD?̕1?o_?襉0?襜͋16?@W?Tg?&|{?9?e>71?w΄^?yo$?y]{?m1c?m痍s?b?;?b_?V2[?VEc8@?J[8hA?JmG?>`?>~!?2k[?2­?&?&4^??!a?f?#?)T?*u7G?y~8?}?^U?C?U1?guTv???NV?mA?l?t$?Ӆנ?"z?4O?s7?qyY/?vŐX?宇j?G?,E^?啼u?
C?[wv?lģF?|6xs
?}|%?pE~?p;
*?d%C?d7
l?WM&?WB!?>??2`rn?2q?%XE?%fq>?m^o?~d?{XS?
?ooԤ?f??|*_?gb~?xr?$
?=#?T!?e@p?W_?ؘJ? ?8y?I?}?䨦M?䨷R?¢?#x	?|oZa?䏍G_?;v?~Z?vI?vYڮ?iȖ?iju?]޸?]l?Pk?P|rFy?C@mo?Cؾt?7"݅zf?73S)?*{yyQ?*?8?⃤u?&9?72d?ya??ʟG?S?Ŏ?*
v?g#k?w`?ѲͲ?i(?o?&=:?D;&?UV?㫋P?㫛m,D?Џ>??SaM?$?U7?edp?xh8?xc_?khx?k[%?_g!?_"Z`?RO6#t?R_7j?E.I?E?8èY?8{8D?+a?,	v?3?B
?hM?xq??\?GQ?ی5?Ho?pb
?5Lk??D?e?uVfwY?ŕG?Ť!?vB?X3,)?zrE?K?Qz?-?JKfu?YU?u{E?⅄@n?x{R?x@?kɡx?ko"?^?_?R
!^?R*Jw,?EBX.?ER	[?8j?8y5i?+p?+.h?ޓy?s?ܒS"	?1?JD?
?&?5?K??Z:e8?osP?~e?ѓ^"?ѢH.?Wv?W?2? (a?/f?CӁ?R?fΐ?u>e?wS?w?jc֒?jfY?]ϵBi?]Tdt?P?QT?D)?D$pF?79,A?7Gb?*\?*k m?P?>MA?>]?CG?tc+?(?C?W2?&? 2y?7&YQ?Eqm)?\6?kT?Ã#?Ñ>Dt?ඩg?භJb4?W?d?)?)k? hT?/cEq?Ir?X
gF?vs		?v%m?i`?i?\ E?\?O'u0?Pla?C!h2?C/?6O??6];?)})?)?1w?4?I?
=&x?ʑ?H'?쁭 ?n|?Y:?-P?߹Q1?߹lu"?ߟG`?ߟzV?߆)k?߆D ?lt¢?l}0?SF?S&?9k~?9Zˑ?,W? ?qMi??llt?	(5J?mNu?ӈu	?޹A!?޺
~!?ޠuL$?ޠ뙒?ކ?އB1?m?m?T1G?T1]?:5ʰ~?:{M?!>I?!XSs?\U?H?r] ?+?6l?+	?ݻfC?ݻͯ+?ݢY ?ݢsb?݉0?݉]w?ox?oC.?Vb`H?V|??=DŦ?=1Q?#сCyz?#P?
?
8?P
Ek?ivi ?~?.?D?ܾ"	e?ܾiD?ܥ
*?ܥ@q?܌Gg?܌lVhealpy-1.10.3/healpy/data/pixel_window_n0256.fits0000664000175000017500000005500013010374155021751 0ustar  zoncazonca00000000000000SIMPLE  =                    T / Written by IDL:  Fri Nov 29 16:12:11 2002      BITPIX  =                   16 / Number of bits per data pixel                  NAXIS   =                    0 / Number of data axes                            EXTEND  =                    T / FITS data may contain extensions               DATE    = '2002-11-30'         / Creation UTC (CCCC-MM-DD) date of FITS header  COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy  COMMENT and Astrophysics', volume 376, page 359; bibcode 2001A&A...376..359H    END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   16 / width of table in bytes                        NAXIS2  =                 1025 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    2 / number of fields in each row                   COMMENT                                                                         EXTNAME = 'PIXEL WINDOW'       /                                                NSIDE   =                  256 / Resolution parameter for HEALPIX               MAX-LPOL=                 1024 / Maximum multipole l=4*nside                    COMMENT                                                                         COMMENT                                                                         COMMENT                                                                         COMMENT  Contains pixel window smoothing factors                                COMMENT  for temperature and polarization for NSIDE =   256                     COMMENT  for multipoles in range [0, 1024]                                      COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / TEMPERATURE pixel window smoothing factors     TFORM1  = '1D      '           / data format of field: 8-byte REAL              TUNIT1  = 'unknown '           / no unit                                        COMMENT                                                                         TTYPE2  = 'POLARIZATION'       / POLARIZATION pixel window smoothing factors    TFORM2  = '1D      '           / data format of field: 8-byte REAL              TUNIT2  = 'unknown '           / no unit                                        HISTORY                                                                         HISTORY  For NSIDE <= 128, the T and P windows are computed exactly             HISTORY  by averaging the individual pixel windows.                             HISTORY  For NSIDE > 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ??ٴ^?T?h?sP?֝8t?
h?)?҃?ms?HT?ŚS?Y?Q?G3??S?ylD?~-i?[q^?`^`?:E?@/3?>.p?Fu?[a?1=?Ɓ ?
?):?9ߧX?j?om"?7/+:?GXv?يk@V?5?w8/l?|R-?u1?)'?{Ot?D?>?*s?Cd?G?Th?^Ym
?dn@?c>??sW0?x<?5wRM?P?|
?ZV7?	?EP?xg?~)?ҔvN?"?iĨ?oc?&@?g[X?NT?T?ㆯ?2?'u?-C/?D?hw?; M?J?WpiK?\Vu?s?+f?pj?6?l+d?qzrV?‚Od??ǡ?%R?f@I?kŚ3?골?ՇXT?ԂD?ԇS?ӀW+?Ӆ?{]C@?ҀYPU?rܮ?x&v%?g|%?l&t'?Y?^?H'?Mې?4eE7?9x?Y?"ˀ?:?	)_(??`l?f-?̮j+?ǤB6?Ǫhfs?0?Ƅw?Vj?[\#?+A&ڢ?05r?4?)k?˛#?Ԁ+?bE?@v?`Ag\?e}ԧ?&/?+u'?5\?{/@?ﻩJ[T?ﻮڻ?fy?k}}? ?%\/??Up?ﶌx$Y?﶑s3A?=?8Qa?=i
?~` ??Ge?LO.?jd?o}?Ji?ʈ?E?"Ci?q(?w#N(*?.? R?Ms?A?_E8e?d-?~i?~K?|/WI?|k$?{2GgX?{8K?ys?yx7?wu`?wQ?u쨐]?u!S?t$?t*?rZ>"?r_x?p_?p?nhS?n?l84V?lq?k+Z?kdpP?i:I?i?{?g^[\?gcUG?e|?e.6?c/?c7?aE?a|W?_(?__?]8S?]o!_?[o'0?\i?Zqy?Z	`?X_T?X?V%?V*O
/T?T,?T21*?R2s?R7C?P4J?P9=?N3k?N8o?L0Md?L5H{?J*b?J/HQ?H!\?H&;W?F-vC?F`^.?D]q?D~?A뽤?A5p??c??v-?=ɛ[?="r?;@?;y?9?9)mu?7sqIf2?7xx?5Qf>b?5VO:z?3+׀?31-g?1 .?1	B>I?.Y0?.ވ_?,?,l}?*{Ŕ?*?(Hr	w?(M?&?&>g!?#\.?#I`]?!pY(?!KX?`5?ebC?1?$\b?g/9?7Á?7?Ec3?K4|f?P@?`?Es?TP?<֞?^؍?d?
ob)8?
?
@/q?
h?YPH?^xc?'[?\?(^H?Od5?:`?@+?P?!?nBl?sh̝)?̹?-?{?
C?&"?+M?b?$ݷ?>?C?Q?u?Ki?P6?êۋ?+?Md?RrK?Io?kb?Du)z?ItF?޻?L?0%?5h#?٢~:?٧v?Av?
?~{u?ԃxG?XgH?wV?O|NY?T˔?̳Swg?̹a???tO?y
x?\?!?$5?*'?/ت??q?Ѯ}*?|?'\h?,wģ?v8(?{S{?cMB?}M?H?LE?RV?WGί?3?N?>4?V0?{??S?X4Jr!?#?i%?Lg?c!?f8`?|i?(?-?Wt?\7?I3?9P
?.?B~W?@b?k8?%W?8?0?o?8?=?T
?Y?nS0"?sdɮ?|DN9?|Ulw?yY?yw1?vA|c?vQK?sO@H?s^蜁?pƺ~J?pɨa?mЇn?mՖq?j״Fh?jB#?gC¥y?gQqc?d3׍*?dA?a݈0Y?aO?^?1]?^K`!?[[μ ?[g}?Xۘ?X&?U?Uti?Rd?R?O?O̶?L݌?Lr?Izb-?Ij?FbN13?FgVP&r?CGNG?CLT?@*fF?@/m'c?=
P6?=֦?9*1?90}E?60?66z?C?*?뗣L?Vb4?V?4C?4:f??P?DoJ?T2?RƎ?	l?	t?eN?jL??}lF?*]?&n?tNF4?yJ,&??#?/?W?l9?qd	?s?#?>+?7?NM|F?SFx?ګ
?ҖY??e?u=P?l}$?ڭ?ڲ{\??ì?DÐ?*,? &G?Z?_?j?>?l]?qs??KL?tUlм?yG??}C?rIQr?w:Xnc?A?\/?zE?z+?vΐ?vs?sC0?sH8?on6?oRFb?k֭?kۑ/?h?h!ml?d`P?dd
??`?`?\ō?\M?Y?Y c?UV;?UZ؎\?Q
*?Qrz_?M7X?MǠ]0?Ij?Iqt?F&_?F*I:?BT^?BXCɨ?>?>H`(?:9"?:TN?6??6s?2#H?2z?/A4cU?/l?+7>Q?+<K?'Tx?'Y?d?#p6X?#u
?1\$?y}?٭Xi?$R?-h?0?0_?x?Ӝ]?ڵT?Ao8?ۊ?QD?$?5?晌D?gR?YG*????Yxķ?<&?3?]Z?,	?Yg6?'?M?٬w?w[?D?ޛb?g?z[%?F7,?EV?ts?ӭi7?Ӳ3	?Ϙz2?ϝDyl?ˁJT?ˆʇ?gعk@?l1I?L'	/?Pi?.4ŭ?2؁B??*'/?!?[i?Q9?˰[?쮠(*?쮤?v%?{w?KHl?PH?X?GT?"|g?"'	?,X?왼_7V???앇S?알%V?Qpe?V01?ʔ?[MF?(\?A?선7?섥.?a{?fdH?| 8q?|$.?wܚ?wUb?s|ߓv?C~D?븠֫A?븥]M{?Sُ?8?^sI?c
(?몺G.S?몾
?4?{ɭ?k?pdF?A?Ph9\?h? ?g]_?k?뎷3g&o7?rl]?rq:)k?m/ܚ?m?1o?hL?hOq?d,ޒa?d1l"?_i	.?_mY?ZA7k?Z2?Uۉ	N?U?QY??QjJ?LFIec?LJ?Gx8 ?G}Lq?BR֜w?BڲB?=n2?=|(?9S?9	3D?4/{G?44zS?/XaEy?/\D?*_?*n?%v?%? Ǩͮ? +	S?I?x>U?`~?s۝?%%0?*h?
A?
F??[VR?_}?s=NN?wy?F?L6@?r@?AB??=%a?7?ı? 9?La?ە$?
?\?*?oա?
8?/?Gq?;?*'M?B?Efz?p;r?9O?S8?g.?,?+k?ݍ?kf?~ɑ?q?6?m? r?Mt?A?߮A?Ζ*?J?$a?ĐUX?ꕯC?ꕴT?ꐝ(?ꐢR0a?ꋊ!t?ꋎP?tQ ?x?]G2p?a3?|D6:|?|H?w)crT?w-{f?r3~?r6(?l~?l2Ռ?go9)?gҵ?b!$0?b»&?]?]{t?XcI?Xh6NU?S<l@?SA99'?N#?N<-?H ?H^?C?C?>`@?>?9`+?9dR?4.^?43FR?.Hi`?/SR?)V@D?)˯m[A?$B?$[:*7?YTT?]XY@?Q?#7??K??E?Cs?
h<ɥ@?
l!?'ᡘ?,471??1	?4O?=_?\ܫ?a5SW?V??L?W6?Ѧy?!"?jme?7@k'?;^?v'A?v?՚?՞!?Ik:?N7:??(?ţdx?ŧ
?N>?R]M'?O}?5?鵞.L?鵢t_?C?H_?6?-S?饊f;?饎?+P/?/}#?ʦB??hj?lu??,n?銟C?銣?8Xt?<{i?g	a?T;?zeݖrv?zjIb?tO mp?t@~?o6^t?op?j8?j"Ί?dl.I?dv	?_v?YɇE?Y;E?TTθd?TYk?NޒJy?N?IfA:?Ik$%?CF?C?>rl?>w}%?8P?8>?3xRr?3}?-`?-i?(x:?(}#w[?"Ȩk?"'Y6?s#?wPS?)?2j"?gss?kDB?jD?T?U퉄?Zp_??%
v?>?B)?ǚLr?V=?!?%`?F?Z?$??k)EO?oKZC?3-?TY??ɣ?C]K?Ϩ	攗?Ϭ)ї?k?$?tAR?x_?E2F?b
9?:?A f?1?[g&?XH6?!8?X?\7C?ޮ?/?1?/j?p?m?8s?.?aÐ?e?竈?竌?祭Iv?祱7?K1	?8X7A?#O?|?ҍ?`j?6Zlz?AvR\?Az/|?;-i?;	
?59T?5x3?/?/~:?)AYG?))v?#4ݽ?#å/?G?!@-?ղYT?وQ0?M??]Z?P|?JDo?J{?DsvP?D&*?>;?>oL?8".?8Lm?2|)?2V?,aG?,d`?&E	d?&Hl:? 'T9? +4?	I?
r?8?sY?
fv?
˵?y?b
?r+"?P?g4u?jϡ?DǍu?G	? 5w؉?#ڴ)?w??)?l?و^?ܯ?ܳ$@?ֈM|?֋?`J{ŧ?cA?7x?;?
ˇ8?w߾^?n?G?巸9?巻ՙO!?屌:cb?屏Ց54?_s]?c
W?1}x?5}K??(L?wC??咤:?咨1?sU?w,@S?BhB?F07O?|p?8]?yݝv?y/(M?s ?sG?mu	6?my8_J?g@A
?gD#?a
ǘm?aU7?ZA:?Zͨf?T4?Tat?Ne?Nh ?H,df_?H/qъ?ADv?AP?;=!?;~G?5~4^?5#6?/BPȖ?/FGb?V"?Yh8?
7?
EW?\/Y?#b?yo?ys\?s"W][?s%flw?lӀ/"?l7?fu?ft?`4:BJ?`8E*?Y͙?Y(?S$%?Sop?MB?MF\?FPk?F?@!b?@BS?3[?-?-5?'Q\)?'T!m? W:?!?7X?h˃?QІ/?U8#?
?
;j?-?\?Nꎗ?Qs?T?4f?`?nbR?F6??Iܑ?Wp]??U
?U9֝?:F[?=K,??b?΅yyW?Έ2?*oE^i?-F?2?B<?s'?va4q?З^G??㮺Ζ?㮽e\?]?`L4?z]K?W7?㛡K?㛤b?CcЊ?F?_??㈅?㈈?&M?)?{Ƈ?{zb?ufd1?ui,%?o?o	4?h
J?hDT?bC?bGBK?[I;?[S?Ud?U?O*lf?O!_	?HD?HGڈ?BXD4?B[C?;?;[!?5*?5*xE?/. n?/1Q-#?(?((l?"ee?"h"?A???ߜ@?lN7?C?e6?ՙRO?՝g?1`	?5!9?ɤjD??a)?dG47n?rOh?(6?ⵏ_?ⵒ	?&VJ?)qX?⨼??S\#_?Vt'??쥾p^?x}?╂+?Uip?kk|4?∪;?∮?@U*?CiE&?{ՍC?{؟5?ujyA?umD?nrOq?o?h!4)?h1+?b(%?b+6?[.?[H?UQ3?UT?(@E?N=|?NHsq?Hy!oj?H|+U6?B>?B[n?;zl4?;u?53R?56?.H)~?.M?(Z}[Y?(]?!?!?t&?7?d~?fw?"چ?#$i?8-?;eH?OŦb?M=?]Ϲ?`?m:?pr?]ɜ?XV?'?f?ᦦNv?᩟r?8?;?ʣ?͚;4?\ԧ?_~n?^Q\?SEX?&iV??A?iZk?ᴣW+?ᴦ-?53?8#J?[?ɼ?X_?[M7?a??{n)?~ZC\?&b?ca?ᇞhRu?ᇡR*?/ఓq?2wE?zWmU?z?"`_?tRͣ?tUG2y?mD?m*ia?gu\\?gxo?a8?a
?Z<%?Z;?T*=΀?T-M1?M?MP-7?GMZM?GP9r?@%?@]?:p?:swX?4J\C?4&O}f?sA9?lӭA?lh?fi7r?fk?_]?`Sq?YZGW?Y6?S*LÜ?S-:?Lq	Ӱ?L&j?FVy?FY~R??Yc|??ŗ?9?9E)*?36?3w"?,RWc?,N?&Ib2?&LqB?m8?W?yT²x?|?yO"?%p?'~?G?ݵ]Ї?ݵbA?ݨn?ݨW?ݜT?ݜ	-{?ݏY?ݏ^Y:?݂$$?݂&?vH4?vG?i^d?icG	?\'?\g@?Pg?PE?Cks"?CpPȿ?6?6
?*#`R?*(?S,#?)"?hY?6???Dg`w? 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ???u7?A߽?j?MR?h6?3?,?ʗ?XMy?#?
 ?w6?rF?>?NbV?"7]?֋aq?Vʽ{?;o?Ή6?Ė@F?a~o?tX?[?l1?8[?|/?:?Tn??\g?QA|?Jv??q?r?b@?c'
?Sv%?TA?C2|R?C}}?1|d?2{@?B? v?
o!v?:?(.E?v,?TT?柷2?oT?ѯq?va?AùJ?.Ұ?4}??Mr?u?v8?]W?^X?DG0?E?*	o?*u?'8?oo?o?7?r1Z?=x*t?=o?讃?ai4J?,ĵ?}ޭ?~=?^8*4?_{#?>??Oe?C6?yiq???!R?
?,#?̓81??;?
?K?n!z?ol$?IhW?J3nz?#K&?$%?9P?M=gV?׺?8?w?:a?Ό0?_j?Z
?ZV?/,?0pJ?t}?@;?f]R?2J~?l?tW0?~G\N??P@D^?P+?!??!]?]T?(?r?˵?ډҥ?˗P?]گ?^A?+)?+S ?iB?3gu?ð?{̨?ڠl??Y
?YW?"?#O?=?j,[?J?x?{	i?{ԞZ?Ac?B9r?H?qُx?̼p?͇ĥ???n>?TwG?U?q?_?G?ڱu?Oz?+?\
2w?\Y?2?Xr?*7F?[?
jS?f,P?W_M&?X*7?]W0?(B5?Њ?UP?(?-?F͒t
?GDU?^?vj?)Q???r8?sS/'?*Y?+$?f ?1?񗣸?n?M+p/C?M}q]?Q#?]*???i^kO?j)r?Cc\?I ?ε?Ιd?~Q+?R?/9Z̫?0Z?јI?ߜ?j??;޼Wh?<?5!.??֘+?햡\?A%y?Bd?v??g?T(?"?@x3?Ae;?t?}w?-??9K?:b2a?Ju8?ZY2?LsO?U9?+²?,V??.?sخF?t
?wr??bD?ں4?ZHU?[X?S?l?h?3!?:si?;@?C;5??w*LZ?w.?2,?sr?小Ќ?ZBs?L"W?L ??ȟ8?'*?¬\?zSr?Y3w?,?q?K|D?KC[?FoV? ?xS?yC?aR?,?S?]1]?7JP?8]ZM?v?7?]Bד?^r?'?wM?߁
_?߁?f?a{U?ޡW"?ޢ"sc?0a}l?1,%A+?ݾ
3?ݿ$?LMJ?MCd?DI?χw?e1_?e}?Vs?^&?{6W?|? V?۟w?ڎ4ND?ڎy??nkD?ٞS34?ٟU*?%;$?&?ثk?ج6#bw?0蓥?1H ?׵H?׶o#?9?:ev?ּlY&?ֽп&??c?@.`t?.%?Z?B2?B?F`i?I3?B?BVX?3Z?K\??$??
;?Ҽ_?ҽ)cϡ?9uv?9н)b?ѴBZ?ѵ]X?08?0y?Ъzub?ЫEB?$1?qŻ%?Hx	d?IAt?°K?±]A>?@?k?~܆?U8u?n(Z?8?In?JgD?￮ ?￮2?'?c?t|?u{3?H?׽?8x&r?9A(?９9t?：3?C?
l)?X\?YcU?ﺷ1_?ﺷ?N?c)?r&p?=?rq?ΐ?Zh?*=?+ ?ﷅ(6?ﷅI
?\zk?&B?8;?9?ﵑaNp?ﵒgۙ?鞵F?hCB?@2?AH?ﳗ}pG?ﳘFCv?U?8U?Bl??C5lK?ﱖo?ﱗ~?w*A?A#?=fe4?>/?﯏?﯐]*A?
m-?ԡ?1]?2T	?סּ.?﭂DD??7?B? o?L?m4?nIU'n?諸?請g?0?_0?R?SjL?精^~?羽\?Ɏõ?u?1?'-?2^?yb\?zǓU?	?Ȩ6?	Xش?
"
NF?O?P??"?`?ۮzs?Nm8? `?bu(?c?W?c?)[(?c?)?*u&?jpS&?k9?~W_B?GP?G3?_?Z=f?H@0?H??b6?x>!?V?Ws?-x?H?ʂw?J_L?YJ?!݇?;q2Ƒ?<9;?rӨ7w?sg:???KR?v=???o?u8e?I,@?IV|?|cT?}	+A?(?H?_?(3?$d?ƺJ?D`l6?Ef?ua!_?uX?T?U_?K	?rd?U?-b?.?/n}?[8?\0?\e7?F?@ ?	J/	?ܱ?zI?d?-:5?/c(.?0+ ?Wz&h?Xvl?@:d??7?
p?4?ƥ?hـ?i?T?~;#?}]֧?}^U"?|=u?|J?{?{,?zv?zԑU?yqx?y9?y#8?yA?x"m?x"x?w@Z)?wA"?v]r?v^rSH?uz֑a?u{з?tדn?t'?s9?ls,Z?lt|i?kxRD?kv3??j?jr?i?iLD?hY(X?h R?gy?gA@.?f2|?f3h?es?ef?e?ebA?dz*?dŞ?c%zK?Jdu?JmjX?IB=V?I%ό?HKj?H?G̨?GhjF?F'?F?EF?EI0?D*?D?C#::Oec?>P,[?=C B?=C煇a?<6*?<6p?;(Z?;)Ki(?:)1?:ll?99?9ݳM?7SD?7?6ߎJ?6?5ٷ&A?5}r?4Nf?4ȝ"?3Fk ?3ú?2?2Lc?1)?1f'?0ye|N?0z+]
?/dE?/d΂x?.Mf?.NM1?-7;6?-8?,đ:?, ?+w?+bZ?)>?)(?(;?(\?'?'O?&J?&I?%gS?%-P?$hV?$h ?#K?#Ky?"-MQ?".t?!?!e??F?&?к|?r?8d?A.?M?l]fn?m#$o?Iæ?J]m)?&z:/?'?k	?_f?H,[c?W?ޝ?x29h?=˨?hL?.??=?-?'?(?Vz?Y0?f<7?f?
?ګ	y?{d?>(?>3?>A?=?!U?uL1?v`ks?V^S?p?cw?&̵?C,O?DR?y[?8?%?'Y^?(<
?~-?~b?}??}@Kw?{[?{?zTl]?zUF*K?xg?xÁ?wf$ ?wg)?usr?u&?tvŤ?twQ2 ?rkۘ?r-j?qd?qbr?p	15?p	3^?n6bs?n٩.?mTc
?ms?kH?k!}?jl?jR?h#}R?hx?gv?g?e?ez?d|h?dͬ?b;?bxb?a/?ayMZ?_d?_w?^?^0@?\{%S?\{?[=B ?[3?YR?Yu ?X	:?X	Ǥ?VՏ?VML?TW@?T?Sv}+j?Sw>L?Q1a?Q=~?Pf̱^?Pg]?Nq?Nc!w?MTX?MUY?KʂBh:?KB8?J?@?J@w?H_EI?Hz?G(U3L?G)U?E d?Eh`?DSæ?D(K,?BW1?BK_?@	?@xZR??btg??c5CZK?=ҋ?=L/??N#?
<?yH?87]$?mB@?nY?
#?
ˣ/q9?'(?'}??;?ۈ?ۉCÄ??ҪL!??rxW?bk$?ca?Ԫj%?ԫ'ƈ?S?6Z?7?8\K:?}Mm^?~
?\2|?$? P??Jr?KWЬn?ȍK?ȎG?bQV?w?VA[?~o?S?Tj(K?g;?$bJ?Ԃ ???C?Tv?Re?S8!?(?܀Ј?8?π?n?R׈?H02?Hx~?!??+JR?t??w?3a?4k
ȃ?mb8
?mz?ؼ?}n2W?܋?ޙ1t?\K?]?LA,?L??F
?34`?h?AǨ??!Ka?"q_?UX?VHb?횈yw?횉?혻c?혼?gŒ?#ݬ?χ?{~?Oɯ?PU?ɉ3A?푀~?폯_Uz?폰pe?YX?z?!s?
rq?:y?;5J?g
x?h^A?톔1]?톔?"w??z#{?5?8=@?c?@\u?A/?}i?}jR?{p?{^?y'v5P?yԷ[?wP[?w㝣#?v
_
?v
?t0D?t1Bo?rVu~,r?rW0?p{8!?p|\Y?nF?n<@?lġuXH?l\s9?j)'?jm?iV?iK?g-k$?g.&
?eO&b:?eO>?cpJ=h?cq5?aԴ?ay?_ĭ?_fo?]?]ף?[D?[ˡ?Z
?Z
/b?X*n?X+Olo?VG?VHFa?TcQ?Td?R5!?Rn@	?PzC?Pz?Ny?N4/?L{ H?L5a=?J@t?JuT?I3ړ?In\?G
?Gи#?E1rF?E2K?CHT?CIW?A_?A_??t ??ud?=6-?=
?;÷?;f?9+`X?9%?7Ɓ?7;?5o?5)?3I?3}?1?1?H?0

f?0i;?.E8?.K?,/D>J?,/a?*>V8?*?esq?(MD^?(N8H?&[W?&\weR?$if?$j <?"vx?"w2A? ? ?k,??4?qH?*?:4??ժZ%?m,?lVϊ?n?mXb? v?ق*F??ұ?>?g?F?jj?
	Y?
nRZ?Zm&N?X#?X7J&?Vf?VR?T[?T\I`d?R0?R0߸?P!?P?MDgP ?MS|?K}?K?I|]T[?I}ѫ?GN?GNk?ES_^?E g?BD?B*!?@#qZP?@
Ps?>(?>s@4?<^D?<_pbJ?:-\r?:.?7^5?7+?5ƿ2?5Ɍ?3e?齯?l>"?l?*Bt?*uG?²a?l?2?~>?aZބ?r
?ʨ?뢕6?뢖O?Ac?Bp?Kp?pw?뛖ͮ?뛗dL?@?AM3?W?6?딒%?딓c?;Yp~?<	a?E?79?덊7=?덋_5?1ǩ?2KM?Hk?غPT?}r?~?#j˿1?$B?\]?cE?lP?m
?}I ?}v_?z>+!?zz?xW7Q?xW9Q?u?ub?s|F4?s`1.?q=2V?q=ȕC?n5@?nT?l~/?lj3?jĝ?jrᮗ?gO|?g?e]]b:?e^O?bejH?b|^?`J?`c?^75(?^8K%?[ԹդF?[gi?YqZc?Yr>I?W
~w4?W,Br?T%+?TF\?RDQ3C?RD=A?Oø?O߯?My6i?My3-|?K?Kg-?H,E٢?Hٵ?FD/p?FE&H??!?Ix?p?A+,?AW?q?C'?AAO*?BA?E?꣘+?꣘ǂk?F?r[g?Ꞌa^n?Ꞌ&?E?n?rk?|[?|q\v?j??kqzT?lp?q"I?T?X?Y]??&?DG?EoT?ꇺtw?ꇺ>?.Rk?/r縥?ꂣ"b?ꂣL?7	??}ll?}+D%?z^?z1l?xp?xpB?uG"?uV?sS
S?sT.!Q?pDV?piM?n6Kݨ?n6O$?kNV?k+A?i{ea?i#?f/?f[?c\ڢ?c ?ackP$?adp?^U?^ҫz?\?н?\@xN?Y.A?Yd?W+R?Wƛ?T~?TH9ߢ?Q?QZ?O^X?O^?LɐF&?L7u?J4Y?J59?G%Fd?G\3??u?=C,?=D?:y
t?:4?8w}?8/?5{Do?5{8X?27mr?2?0H'P?0Id*?-+??-T?+?+."]?(yɮ?(zoa?%ޠ?%F?h?#C6T?#C]nz? 
? ?
?C?m?nk?Ѓr?)WUI?2յ?3{?\?b?8$?Cl?WJ2?WR	?}??	.kR]?	Z?x.X?xKs?iU?#qX?6h~?7
w?R?8?'@p?1?P/?Qc?ў$j?ўC?`Fo3,??{i?驐vL?驑5}?pNo?s~?2g?3Mf~?顃;"?顃)0?.\?фT?"ٷB?#|?r b_?r|(?8^z?B?Ѣ?#r\\?]?^=5
?鎫Q
?鎫?dU?E

?E{?F3χ?醒Sz?醒?DCJ?u?*-?*♌?~ui?~v ?{g?{	?yqE?y^
?vU?ẙ΍?yh ic?v'2?vۋ?t?tYk?q,6a?q,)?nTZ;?nT0`c?k|)6?k|&UG?e%?ed?W=?]>8.?Zdr?Zdv[?Wf}?W/#GL?T@s?T[X?QӚP|?Q4|?N?N%?LR/?L죪r?I@1o)?I@{?Fc??FdW3?C^?C2?@?@w?f?=qs?=)O?:2~?:L9/b?88?8;-R?52>i?52LY?2Svu?2T#F]?/t@$?/u;?,)N?,.?)$?)?&Ճ/I?&l?#6?#5?!?!1?3 ?4C"v?Ri?S.&?p
l^?qr8?v	?
?t?_zz?DU?ݭ?r+^?c7?
Pv?
Pf? W?!w.?=%?=Y'?Yy;?YY?t6?uD	`?>?/	?0[??ŰV:?Hc?F?-?){?8/?v?3A?-gyq?-~S?FJn?G)=?_mXz?`8?w^ `?x,?ސ;DA?ސ?ۨ-?ۨa`?ؿRX?jՈ?*;?U@?5T?̎?*??cc/??1_?2|?G^j4?Gn?\0:?]E&M?r'6?r?羇o?羇_?绛J?猾Bj??΄+?V?`\N?]<(.?]а??Zi?Zz?WO%^?W"?TTfX?T>?QF?QON?NXSK?N|?K#hH?Kָ+5?HߩEl?H=I}?E.?E|?BH=?Bu&~????(/f?=?=S?:*)?:>%?7
_
]?7z?4*?4>-?1"?1"<?.)@?.)$?+/m\?+0yX?(6p~j?(70v?%<\?%=I}?"B?"CJZ?Htg"?I?MI?N2)'?S#*?SՎ?X6_F?X+?\:?]U6?a.f ?a4?
eUweJ?
e?v-R?v$ބ?xįF?yV-W?{]0?{b?}+ܙ?}x?~&??/??&?i,?h?u0_?惭7U??P?6nȩ?h	?~}E?Դ?݄@0?݅罆?ڄK?ڄ?׃.6?ׄba?ԃ}?ԃ6?тhȤ?тu?΀l?΁py?d?m?}xD?~:L?{^?|?_?ys2?zǪ?vy?w?t@5?ty&?qH?q'?n>?nь?j^?k+b;Y?fnf?gv?b-E?cU(?^O*?_Qdb?ZQT"?ZUO?Ut~?V3b|?P?QGm}?Ko?Lu	?F&BPQ?F?@|?A+g?:iЬ?;.1?4?5Y?.#f3^?.ͷ?'8?(? :?!C{y?l%0?0?RGK?bY?
Rt?V
?}@#?}F?yk?y,?vog?vK=:?sA|e?s6?p-?pf?mؘ?m'O@?jkgF?j瘆?g$@?gƑv?d_?d6v?aj?a?^hG?^Y?[P?[?X]?X
?U?UM,?R}$?R~Kz?Or43?Os}?Lg8?Lgf?I[]J?I[t?FOtì?FP)8?CCR?CC5?@6?@7tz?=*cD?=*?:.?:#yH?7*?7?4RD9?4h5?0a?0hr#?-,R4|?-O`x?*ELz?*6`?'&>?'̳?$-t?$[u"?!@?!78?zn? y?}f?	?H5?ԪC2?r\'?shwc?c97?ct?S`I`?S&&?CP?C,c?	3	]v?	3p?"?#?_}Xc?\aC,?\bxq?YF.S?YG9?V*<{?V+g??S}Cx?SD?OH,?Ol?L1m?Ly6?I?I$fh?F#x]?FbcS?ClVXR?Cz?@dL8?@eh?=Gf?=H%?:*SL?:*?7f?7
yԳ?3eY(?3쪁?0Ѭ+Q?03n?-ǑW#?-N1?*k?*=I$?'wzkŇ?'x䫕?$YR?$Ye_?!:q[?!;?-~8?Gj3??^/"j?ق?Jo?(?*ak?׺?Ï?;j?m?_X?pBɥ?pƟ?Mw?Nyހ?+G%v?,Bt?F;?	fu2?c?械?2?÷6?ɠ b2=?ɠF?|ܣ?}j?Yc?Z
Z?5?$?6ʼn?R˞?]6?~7ux?P?ʄ2O??䳦d>?䳦笣?䰂v]?䰂w+G?]#?^5?9 ?9?i?/?v??ʌNw?#t?䝥emC?䝥;?䚀J?䚀CZ?Z)?[-w?5~?5O͌?\w%?49?!W	? j?}Þ?'f?䇝X^?䇝ړ?w;?w9?P"?Q$)d?~*5?~*zt?{]@ȯ?{qo&?w܆?w;6?t?t
u?qn?qu?ng.?ngn`?k?n?k@MF?hFN?hȃ0Z?d8?d ?a|a#?aW/?^-[?^k>d?[x%?[y]L7?XPal?XQ-v?U([?U(?Q?RjDqY?NUMM?Ne)?KF?K!I?HD?HK3?E\s
?E]TN%?B3?B4_?WD?Wh8?Si	?S`Ee?P25?PBF?Mt?MP?JTMB?JTv?G"y?G#k?CR2?Cr~?@B?@s5e?=]r?=	q?:\01Q?:](jG?7*R?7+dxm?3CE?3U?0&1a?0Ǡ/?-&Ce?-,[?*c~?*cmI?'0R?'1ek?#E*?#*KnK? b͖? =?݄?{	b?gax?hЪ?5e|?5[?l??| ?9W?
D?
z&?
j0?
j?7M	?7\?XV?ѻ?R?͝?9{?3K?koi?
`:?vm?YR[?So?ݛ
.?ݜ?gƮ\?h>n?3e$?4])'D?VW?l[?U?k??͗r?͘Z?cZH?d;\?/1
?0??Wj	?γU?
6?ǁ?⽒F?⽓&go?^E8?^D?)̱[?*Cs?EJ?!??'?⭌
f?⭌z+a?W\?Ws?"c?#W!?
?HQ?⠸?⠹ni?❄o?❄c?O
?OK??ҏ?
PN?僪vX?␯ŤK?␰hf?zd!?{ATJ?E?F
p?W|.?Cl?@?ۀ4?‥B?…(~?}pNj?}pw[?z:#|A?z;T}#?wcA?w)?s?sRQO?pJ;?p3	?mdІ?me"?j/&D?j/z&y?fR?fǫS?cÕݠ?c	?`@4?`A	?]W-?]Xn:?Z"Nq?Z"jj?V6R?V?SE\?S#?PJ ?P?MJF#5?MJz?J8'?Jj?F ?Fޔ;?C(z?CtB?@qsb?@rJy?=;ȕ?=<-?:hLQ?:)?6$'_?6ϗf?32?3K34Z?0bum\?0b{?-,%.$?-,Oc?)тJ?)3HA?&R1?&~?#l?xe?o0?'?B?Z8?.;9?Q?R[ze?"˿0?V?[?mz?뭚Gj?XK?v-?wKt??@+K?@간?	}bz?	љ??AI?ۜ5Y.N?ۜ@?e?f?/ʛ?/s?}$?+?>?cY?ˋ{Q?ˋ渎?U@?UqZd[?k??3Z!:??ྱխ
?ྲ@?{Ȝ?{|?E2+?ExQ?	?X*U?رw?X?஢~",R?஢--?lS_{?lV?61V?6G??l?	?sd?w?mU?^EE?^p?(0?(~q?+p~?(?LG?~?wģ?#?PV2H?Q#[?%]A?V;?7qL?sn	?j6?Xx?~y<َ?~zU-z?{DV?{Dtl?xóN?x5t:D?tMG?tٶeg?q6|@?qB7^?nnr?nnڑG,?k9z?k9}j?h ?h-67?d΀/5J?de\*?aG{
x?a?^d^}?^d?[.b&?[/b\?Wsd?WN
?T?TG3?Q囉?QMW[?NZ$S%,s?>Sf|?+z?'F?']s4?$?$$*#?!{%k?!{v?GwiW?G#!0?|3ș?V>0?Or0?O}1?IxF?Ix~!?CIc?C?<?Hs?>I-?L?	]?ˎYG?ˏy+^?7e}?8"?ݾG@?ݾ[?ݸcw?ݸ eJ?ݲ2?ݲ3u#?ݫH?ݫ-?ݥA|M?ݥζ_?ݟ0N?ݟ0;?ݘU?ݘo6?ݒ?ݒ+?݌/O0?݌0A#?݅va?݅2
?p?^Q?y1,?y1Q?rܲ|?rm:Ty?l1`?lO;?f4iG?f5nK?_?_ʂI?Yj?Yd?S:b?S;;z~?L疸k1?LP?Fg?FĽ?@B|H?@C6u?9N?9L?3^s?3c?-Lf?-Mg
O?&=CU?&? V? ~H?YN?YԫY?kZ?	$2?
Z?
M&?g?hc?k^?p^?3f?띝3?x ?y?)?*X?ںj?ryc?@*???={$?>m?.?P?ΡB?΢ux?T'7?T?,??ܻ@,2?ܻ|?ܵl?ܵmD?ܯ v\G?ܯ!,H{?ܨ5eH?ܨ?ܢ9_g?ܢ?ܜ 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ??	 ??F?I
?qH$M?R>?Uk?OI?)d?j@"?/&T?p2?,#?:k?a|?Y?H?#r?K.p?$7??J?ʏ??؅]?r?M?%9E?L?
?ɠ?쫦?g?W;?)j?^f?܆"
?ؑJ5w?ع?R?zs?a??f'?ˍf?Ѓd??59?:+?bl?c??WC1?~ӣ?$?LJ?;?S?>?A?+?Uk?A8?ն?08?hŗ?i~?A?gd?f?n?zN?|$?|?un\W?uKv?n?n4h?f@z?f?^Y.g?>^?6%k?6M&=X?-KI?-s\?$OG>?$wE?4*?[儗??'u?#&??[?7f?J[?9(K?:?zU??up>?t$?,P?	?	f?ʬ ?Ă.?7?_?
?`v?|?4H?L?'?Jx?j?wnt?wV#?e^/=?eP?R,?Rqq??U?@q?,Ÿ?,?k?4?1?Y5?:zs?y[c?y>;?dynb?d%
?On
?OID?:;v?:b?$?%	Ŏ?I:?q?pa?;ӵ?f>]?-?Kqb?|R?oK?kے?lAj?Lo9?L8=3?,
?,4)?Ub?ӑ?`;S?D=?"?E#?q?%?
|e?1X4?g;l?h?F+7?F?%#no?%Km3?hyO?&K0?~ǐ	?t?g3??/?#ۆ?K0i?zsH?z[i?Xwv?X@؟?5T(*?5{`?WD?~N? #N?G?˺NN?+?&?NA?f|]?s֩?`z?`IMW??yGt?yoݤ?PZ[?P??'4?'[{?i-??\?Ԅ2?R??S??a??Vp]?VI?,?,GSb?-i?U,?׌?׳?쬼
0?I?쁾!bf?F ?V=?V#?bQj?ሉ$?Rh?RWh?uM??4lh?\X?௽R8??y?y?=m?BC*?Bk?Bq/?j?A?^6?;?ߜ?ߜ&?e2пX?eZd[6?-w?-c={??_?޽g<?޽F?ޅ?ޅA+!q?Lc?L?N?l?!J&?Hg?ݢ n?ݢH?hlj?i&?/?/W(?R??ܼ &B?ܼG0?܂+4?܂RČ?H	*?H0?
N?
??ʷ?gY?ۘ'~?ۘc?]躤?]wU?"J>?"?YB?з?ګ?ڬY?pO2?pv?4?4?_V?>?ټjn??ټ&?ـbV?ـ4mH?Ć\?CX?ƣ9F?.??gQo?،?،y?OObd?O26?|2?Bi?yo?Ԡ?זm`?ז?XDa?X?jSD?A?	'?0G?֝{X?֝2?^W.?^9$?Ss? 2N?ۃ?cM?աoU?աܙ?aM?b?"E3ת?"l?kw??Ԣd?Ԣ9?b0z?bX]j(?!ܱ?!bQX?=$?e?Ӡug?Ӡ?_~@?_A?Z8
?g??/$$?қ	s?қ.?Y۩?Z-4J?ބ?*w ?w??ѓ}y?ѓ?QGk\?Qn4?J?z?߂?`?Јe&?Љ/?E±`?E25?q??ϾJ?Ͽ?{4?{\B?7MFe?7t?7%:?_{U?ήm?ίI?j^?jZ&?>D}?M-?iW	??sX?X"r?X+m?
	???&:?pQ|F?pxo?"Q?"1?R#?;?ￆOH?ￇ R?8D:?8j?xSI?%?ﾛr9?ﾜDX?MA?Mi!?bP?s
?ｯWI?ｯ~	?`k?`@R?N"?Ϸ?H?0S?q;D?qcy*?!@?!h?w??P?ﻀm?ﻀ?0A?0i2I?ߎ-?ߵ9?ﺎ@?ﺎΥr?=bm?=xۛ?NK?va_?﹚Oמ?﹛?I@d?Igh?uٕ??︥~/$?︥a?ST?S|N??x?ڴ?﷮mP?﷮.t?[;L|?[ܝ1t??z?ﶵR?ﶵ1?b{u%,?3g??ﯻ@No?ﯻ/?ci?dii?_~?ӷIL?﮵:{
?﮵a1?]a=?]
?[L??ﭭӆp?ﭭܨ?U?UQc?FY?m?ﬤ[?ﬤ>V?L=?L)Qfp?P?C5
?﫚'?﫚08r?@Y??@??Xi??揄?揄2S?3G?4
?ؠ?:?P?d?%]?%cW?5??p"Ȝ?pJ?>?e_yI?狀&a&?狀N*V?^ᠲ?_?nEQ?ޠ?獵;
?獵Г?La?L'k?=:?-	?肋E ?凜k?7"?7d*?d?#?~DKf?~kLØ?!]D?!$?J,?q^?g	G. ?g0K?	?	q?t_?(E?N6)0?N]qv?8;?_?
?4]?3?3+#?-Mc?TP&?vy?v
?M?XNI??J/?YM^?Yu7r?ݸ?K???f;R?:st?:%?zj?ڡ?zTWx?z{?HR?(???X2f?Xra?T.?6?1?p?5"Ԡ?5aŹ?4l8?[Y?rEHQ?rÃGC?`?Bs?C??L¬?L?n"G?^??z?9 ?%;]?%cy?^$?…|?_T0$?_{j??DT)?x?:?5%6?5Lo?_
>B?цE}z?mk+?mL?	I?	p1??!*?@~?@(aW?c?n?wZM?w(??"??R}?u`??|ެ?}?51q?>Y?iF?E8?fb5?f>`?f3r2?f3?em?e~?eC?eC
?dmX?d˓3)?dS:?dS85?cڈ?cگ?caBG?ca;f?b?b|?boN?bp
G?aV8?aɴ2?a}5w,?a}[;?ae,?a\p?[w.}?[B?[B@?ZƲP?Zف@?ZJpD?ZJZ?YX9en?Y' 7?YQe:?YR~?XJ?Xq},?XX?XX?WۋB4?W۲-?W^i=?W^oG?Vn?V?z"?Vc~?Vcp?U?Ulz?Uh?Uh5I?TY̞?T.Atc?TkӝH?TkY?Ssbd?S횞Љ?Sn?So?R,w?RS˫0?RqA?Rqh?Q*?QP7?Qrn?QsR8,?PtJ.?P,?Ps?Ps|?O
=a?O4k5?Ot]?Ot>=?N4h?N:?Nsƌ?NsŦ.J%?>pq?>T~$?>{Ig3?=2/H?=X>?[?;k6?;l"?:~/?:E?:]&S?:]?9ea?9֌'J?9N	?9OjT?8&z?!x?!!	?!V~FZ?!Vk'? ? EM? 7j8? 7ټ?QUT?\??}?ԓ5?7U?G>??g&D?gLl?֍.?ִZ?E#?EqR?j?	P?#(-?#?jD&?\?^?:?oL
?osAW?|@H?ݢݮ?KaZ?K?Y31z?>?'R?'*I?Bak?ܢ?VG?E?nw?ovL??k
)?H8?H+?Z?~4^?!y3?!rL?.P??Ò4?2?YbJ?f _M?fFv???=xR?=?u~@?	'?!?H?5\?[?
n+?
A`?
T	?
T?^9.?*D?)a6?)?|??
 2?
!?
gpZ?
gǁ?	ъ?	ѱ%c?	;#?	;5?e'`?S_?
N?
?v=?v:?`.?߇L??H޴ ?H.dB?ɬ??@?j?hm?T8?eYš?9N`?9?뚝Q_?;5Z?׹?;"?\Lzl
?\r?P?	H?NB)?t{?}L?j?`"|\_?˸G?˸`?&?*b?iH8?inC?af?:?Pe8?vD;?q?q9@e?Ȩ!Ͳ?Z7ҫ/v?>g&?Y=3?S?ߵn??ۂÝ?/`@?0
s@?6Z?IA?)?(?~}??o?W?o*O?^.??
:?
H?\/v?\="w?p?g\?"~?H?HK?HОb?\?,E?5k?\w
?3:
?3`?S?;?Ű?ꋴ?L%+?r+?ip?iuߧ?_?n?4?L?PҡN?P/?kZ??6?7O?6L?6r`?}d?l?΅p?Ϋnҍ?c(?%C?f%=?f;!=?)?g?7Y?1\?H'\*?HMV]>?.l3?TeI?4?1?(҃.?(ɔ?sHm?snd?g3]?\?1?&bY?Q߷T?RT???pzJ_?l?.!?/?xY&?x'}?߾?܂?
z3.?
hm?Sxf?S?-TC?S@{?䷙k}?݄p?-@?-=ڷ2?uNy?utc?[W|=?@_?>7?d6k?L?Mt?sZ$?>}?@?+?Y7?^l?	;?/֎?~V?~WF?}鯨?}?|>}?|dXg?|'P@?|'f?{l7J?{m
-?zC?z!x?y@u?y
>Y?y;l6?y;L*?x7Nb?x]E?wĢ?w,?w䈪?w	
\?vLgC?vM" ?uf?uS?tԯ,e'?t?tG(x?tlJ?s[F?s[Vx?rΈ?rux?qh~?q:6>Y?q%l?q%+yAb?pg͒P?pg^:?ol:?o?n\`?no?n/'>?n/Mf?mqF?mqkX?l:n?l`fx?k^R?k+l.?k6C?k6xe?jxͽ?jxEZX?in?i(?h?h?h;ǜ?h;f?g|Z?g|g?f?f%?e|J?eE?e=ίh?e=m?d}n?d~عP?cqɋ?c-?b走?b?b=wI?b=S?a|v?a}/j?`On?`u&r?_}j?_?_:[?_:{?^y\?^yF1?]k?]4w!?\-ֈ?\)?\4R?\5r?[s$?[sJu?Z.1?ZS%??Y
?Y3
:?Y,ľ*D?Y,m;?XjRi~?Xjxr?W'X?WE?V6?Vw?V">?V"%ĉM?U^?U_3+)?T%?TL}?S4?SZ/q?SSY_?Sل?RP&>?RQ?Q_?Q?P䃔?P
(:n?Pg?Py-?O@?q?O@el0}?N{~?N{?Mx(?MN?L
?L9A?L-NJ.?L--7~?Kg4n?KgҎ?JuE`?J|'V?>p?>6i?>6"?=nhb*+?=n}?< }?A?5]7^?5^?4z-7?4ʟ?4mҀ?4Si?368F?36^g3?2kۉ'?2lq?1T42?1y+5?0֢?0ǏU?0!֖?0?/@^?/@?.u?.ua0?-AIb?-gPS?,L?,j?,d?,C?+GN%?+Gs9?*{T((?*{y>?)0?)Vl+?(}?(
?(p?(?'IuZ?'IzM?&}Ò?&}3s?% I	?%E?$3?$.W?$Ƹ\(?$%z?#H\?#Hn"?"zȦw?"z?!b?!2,? (r? M3? Җ:? A:=?B?Cg?td:?t?6?$v?N?sl?sxb?Y"?9qr?9Ơ?jF?jk-?F^?hd?xT&?˝?u9?X@?,s!X?,)=?\ݙr?\29?ДP?++?gd??3;?YN?*?KÎ?I ?Iw̺?x#?y,^?Hk?q?֞\nZ?ðo?9?^b?3~/?3(#?
ax:?
bl??=K?Bcz?7N?

?
[r?
-}?
:?	Gg6?	G-?t^B8?ti???Β5?ηi?pm?2$?(&?(Ks?T_̧?Tإ?L-@?;?P?v.'?cWc?و'?Ml?r'?1d?15F?\Nw?\ϾR?3d?Bqs?f?D?ކY?ޫtG?	} K?	=?4MB?4r|r2?^'o?_‾?t+ ?cp?}?Ŀ?L?!#ѵ?9?(K?1?2B?[48?[gXL?"U*?G?󮇏V?$O?>?*?ڳ?-?)Ӷ%?)?Rwo?RV?{)r?{Nz?_0?''7?vp?
2?f?1?|?-x?C?Do?k7?k?
.V?3j?hQ?躍?@P?cG-?-
?>?/?X?/`7?VDb?Vi2x?|Zk?|߇?EUfd?jrV?ɉw?ɮ(?}Q?ȘS??1?;`I?;?a1?a)IW?ކ2?ކb?ݫ+׫?ݫA??&3[?P:?*cQ?V	?i????vX?dCH?dDS?؈\?؈l ?׬?k?׬?Y@?f\?p?|?.??<%B??1>?1>Y?Sxn=?So?uc?uc?˗
?˗NL?ʹW\?ʹ
&?g`?ی3?~Z?&?td?_g??-A??	?`M?a	yW?Ł߰?Ł?Ģ)?ĢјT&?W?|?*?1E?9K6?^??$ovy?$i?D}L?D=ɥ?dbg?dW? '?E&??ۑ?%R?J?n9O?%??o,? ? Wf??\$G??
%I?^?^*?|?|T?4?7?J??Ì0?ۦ:x?:N?_?s?R`?w?#ze8?#s՞?;o6?;D#?R?R>A?i
?jh?팁 5?팁D?틘("
?틘LR?튯	͈?튯.Bw?ġ,?Oi?Yc,?~G?'9?l ?	v?	3?.IQ?RQ?5&?5Kt?J0j?KPP?`Z?`ɪ?v*?vO4U?큋繨?큋?퀠${?퀠e??4?~ʿ.s?~ľ?}߂
?}ߧ??| 3g@?|D*?|=?|	P?{?{1?z1Ŕ?z17p?yE?yE<-ǃ?xX{?xY5?wlT?wlύ?v:|?v_U?udo?uQe?tc?tb?s0?s(\0?rĆ?rU[?q:?qf?puQ?pS?p5hU?p?oTcn?ox*?n)e,?n)>?m;SH?m;aK?lMC(?lM?k_HLV]?k_l?jp?jqv?i]?i=?h?hS;?g5
?g2#?f͗?fO?eƸkjX?e@?dp$D?dה}?cu?c&?bnH:?bj?b'?bX?aѝ?a?`(ə?`(?_8v?_8?^HGA?^Hl70?]Wu?]WR?\g./?\gS4b?[vihR?[vt?Tƨ?Ts?Sߺ?S%f?Rü?R&H?R@?R?Q@?>eI^?>?>	@b}?=c?=?<?<j?;#׽?;$#9?:-
r?:.UB_?97 ?98?8A/k?8Aw|?7K>L݃?7Kb%?6T9`?6TMu?5^'?5^+OE?4g2?4gV㈼?3p7a?3p[i?2y? ? '????)#?aD4?4p?4?/?/O?*i?*Я3h?%;?%.? Y`? }c?\&?Yl?vn?'?ϼ?@?
J(?
'x?1A?6?j9?"*ݘ?ŵ*l?t?i&4?L???D|?h	h?}"ص?ݠ?֐?ִZ?v?ϣuz?J?nlv?MJ?xy?uG??쿱L?쿱y?쾪0\?쾪4?콢)$?콢M?켚?켚Az?컑i%?컒.?캉	R*?캉{?칁 L:?칁D9&?x@t4?x?o3?o馏m?fA?g?]?^'?T?TC?Kcz.?K?A_?BNL?8ZF?8}a?.]U?.s?$?$栕U?J`1?%W?Gn?Y?V?yA?A-?ڟc?X%?|?"Q?ȸ?E?H?f ?D?ŵf?/4?줺t?줺6?죯f?죯3
?좣Cv?좣?졗'y?졗?젌J?젌,j?쟀KҶ?쟀8u?skS?t"
;?gĒm?gv?[g,?[?N摘?O
D?BAK?Bdϫl?5x?55?(p?([?}ԕ?T̐?KO?o38`?J?
v?~o/??qq?;?"NU?E,?>P*?bm?쏼8y?쏼[q?쎮?쎮2dL?썟e?썟5?쌑R?쌑vdP?싂%?싂%?t
'S?t.?e0?eS?V3Yib?VVH?G(?G6z?7?7p?(jx?(k?0?H?	5A?	Y?ft݀?֙?s_x?\?]P7?ـ?~$YZ?~G?}ȍ(?}??|I4	?|m]?{E?{RP?zX?z<?yu~H?yv z/?xdVN?xe*?wSRg?wS竵
?vBs)?vBܗ?u0y?u1#U?ti?t(Š?s
08?s
hX?q%?q'D?p1	?pi?o״^d?o6?no^?nœ-?m*/?m+wY?l}?l'?k(4?kOJf?j{?j{%?ih=?ih3Nn?hTP?hUWr?gA–?.?gAl?f.gzߨ?f.U?e?e
?dII?dl?b?bXs?aߢ/*?amG?`˚D?`˾;T?_p?_?^"?^F(?]?][?\z 9N?\zC;?[ej"?[e.
?ZP{?ZP6,?Y;
?Y;=v	?X&~Lb?X&~m#?W?j?Wb?U݁?U+S?TY?T|D?SвW?SՄS8?RX^?R?Q*d?Q!S?P?P?OxI?Ox䭌?NboI ?Nbo
s?MK7?ML\R?L5b@?L5c?Kd?Kˆؖ?JfF?J?HV?HuZ?GٮG:?Ge~?FlI@?FfI?E~d?E*?D?Dr?C{H?C{B?Bd	F?Bd,̘?AL\?AL>?@40?@4.)??J=??9?>K/?<Ez?<21?;v?;ҙ?:mp?:zP?95 ?9AD?8`l?8!'v?7n"RB?7n+7?6U{j]
?6Uri?5<?5<:S?4"7?4"w?3]?3		a?1(?1=þ?0-K?0PLV?/G?/A?.t?..?-|J?-yg?,l&L?,lIH`?+Q?+Q	?*6ց?*6z?)~'?)v@?(N?(!??&Zj_?&OLU?%ʠZH?%ND?$>|u?$aŞ?#ō?#Ƈ?"xl?"x9?!\N?!\q? @e^y? @K?$ZQ?$}?xkD?WK`Z?Wnj?5Rj?6	yV?`v?U?Ug?(???
?,F?t?" ?j\?j?Ht]?H?&1.?&<%?,K?ڌ?u?%P??0D?e?@;S?x?x-?TQ?TH?1
m?1!?p?20M?z4sC?ε?e??ۢI?ۣF?~??Z|?[O?6$?6S?Ib!?k?p?m?27?Uw?Ӥw?ӤI?ű?Q?ZZ-?ZD?5~n?5"??D?a̾6?l2?9?_ d6?Ł\?˟p%?˟!?yk?z?T"?T>?.?.<[G?aE/?/?r??ĻNNJ?ĻpĚ?Ôxk?Ô]?n$nr?nG?G_ka?GD? z%? ?t?v?L?o@T?뼫D1?뼫'?뻃wP?뻃?\t?\7	?4mM)?4v?o?{4? ?63?뵼G?뵼6?봔s?봔Fb~?l?T?lb!ӕ?Ctn?C}?KY:?my?򠴱?h?\	??뭠?뭡{U?wC?xa)?N?N?%iz?%9u?? w)p?rhR?ҔjL?릨W?릨!?~Ym??UJ?U2rM?+mw?+&ed?
?]c?֋?֮	I?러?러AϹg?랁u?{?랁?Vr?W	?,
?,>_?07?S,d?%[?Gi^?똪G?똫%?`)?Ϣj?TAg?Tc?(Q?(ؑl[?I"?-?@z?b?둥Vh?둥xJj?yL%N?yn_?M!`$?MC? ? )?lG
??!?Jf?늛9ܯ?늛\H?nq,?n]l?AxD?AC]r?G??Xs?z_?넺ln?넺2?냌?냌?_!!?_D
A?1{{2$?1R>??C(?~и^?~E?}˿h?}$?|yZ?|yT?{Kb	?{K3?z \?z >?xz%?x?wI?we+?v	X?v8?ub5@(?ubW;?t34LW?t3VJ+?sS?s6,k?q5	?qA?pt?p?ou#?ov4*?nFXr.?nFz?mA?mjF?k6-?k?jZ?jf	F?if?i#^?hVnl'`?hVtji?g&^?g&6|?e?eٓ?d$k?d&(??cM`u?cob?bcw?bce?a2{>A?a2z?`mYz?`C?^9~v?^[z?]u
(?]o?\mtw;?\mq^R?[;㕓?[<}?Z
3ܦ?Z
U(?Xe\?X؇Q
?Wwp;?Wc?Vti*?Vt՟?UB=sqf?UB_d?T_?T
u?R݇q?Rݩ݉?Q?Q ?PxWY?PxyD}?OE4?OEW?Nu?)?N\:?Lߦf?LL?Kh?Km?Jy?)?JyaW?IEޙ/?IFzp?H^V?H?F?F:?E[%?E$y?Dw&?DwH?CC+>)?CCM?BB?B2?@%]?@׳??3??{?>r
_?>r,=?==v^_?==1?<Ð?<a?:?:A?9I{?9"]?8i'.Y?8jx?74?74T?5v?5]?4"T?4-wcD?3u?3?(sBuR?'v??'vY?&?=?&?(?%ǰz?%e+?#ѲUB?#>?"~ʠ?"|M	?!c-M?!cNwm? +a? +ƾ?/#j?QKG^?=d??'?ٽE?Lο,?Lg"?Od?{?ܡѩ?w=?^T??k䂤?lr?3}P?31??ad?#LsA?Dr?HΫ?jk&?PPVo?PqeB?9|V?[?
/?
'Et?"?/-?kC?keU1?
1:X?
1#@??*mW?>Ab?_q(?UB?w[@?JOVa?Jqr?+
?Mʑ??l?k?m?a
?a.7?&q(V}?&?}??_'?it??u
y?vM?:d?:?+p?ɩE?Zr?{ 3??!8?Mdj?M֨?G?f,?2?!Q?޿(?6S?^I?^6
??!G?"T
E?]?=?b?쩄6?lgo?m
?0W?0xr8??[}?si?%?y蜢X?z
L?b?\.?\{?a??ރ?ޤVj?͟KU?͟lPD?_?`-? :? GM?`?$?ȡH[x.?ȡik?aK?a 
?!a{z?!T?r?O?áu7F?ásB?a7a}?aX? ܞ:? ?d?1?꾟Ѓ?꾟m?_Fl?_@zd?QP>?r2?fc?݇I??깜]x ?깜~m?[7.?[Y,n?N??ؖ?طH6?괗\?괗<,(?U%F?UѧA?͹h?߲?k?S?ꯐV?ꯐ-y?NL?N!nR?ט??ɒHD?ɳfV?ꪇ0h?ꪇQq?D??ꦿrD?|ey?|{/?9qt?90??J?ꡳ`A!t?ꡳR/?pH{@?p:X?,\?,?6AK?WN\?ꜥO?ꜥǦ;?a9.?bCYr?
D0?+MX??8?ꗖ	8?ꗖ*=7?Q:b?Q>+a?
>?
?3?T?ꒄk,?ꒄi,?@n.?@7k/?]!B?~d?ꎶ?ꎶ?q˅?q?,g?,B?]χ9?~R?ꉢ?ꉢ8-?\R?\x?5k?Vhh?њ/?ѻ-?ꄋ_?ꄌMY?F?F/t)???9?ꀺ?ꀺ34?sP?t7?~--{?~-?|Fxw~?|g\c/?{ɸ?{0?zZ0+?zZQ|?y|K?y*?'?w̫?i?w̓ԭ?vH?v$?u>6?u>|t?sX-?sd+4?rQ_?rrp?qh+v?qiѤ?p!|
ђ?p! ?nt?nX@?m7>?mX?lJk@?lJ?k?kfnD?iN7?ij?hr_!%?hr|?g*#w?g*De;?e=?e?dX?dya?cPX?cP:?b?b@`?`Y	?`z^?_vw?_vY?^-yr1?^-/R?\_0?\c&/?[*E?[J?ZQX?ZQ#?Yl?Y?W[?Wȃl?VuAZ?Vub?U+?U+cn-?S᧎?S??R}?Rќx|?QM5?QM?PqY?P?N(K?NI+=U?MnX=?Mn7o?L$D.?L$e?J٩ў?Jk?IL?Ie?HD `eq?HDA?F2z?FSN?E)?EJU{?Dc&?Dc&#:?C(3?C1?Ak2?ǍE?@5?@.,??5cm??5^?=鶾&?=T?<
?<{?;R.?;R+5?:%?:-P?8E\?8ԠH?7mxb?7m[?6!n?6!nB?4am?4#L:?3|z?3SK?2;'j?2;H?0<2?0?
?/FC?/gs=:?.UTqC?.Ut
@?-G}?-g<=?+o?+>?*mVC?*mJ1?) {Ij?) O?'S_?'!D?&l>D?&?%7C?%7T?#u?#6?"
T~?"-ȃ?!N
?!N-z?o? (?ݠ?tM?ci֡%?cC??Yd?wV?Ɨ?w?wQ|?)N?):ra?Cw?c?QyO?qhc??$y?D?C?ט]֙?ט}~r?D|~o?Dq?F?𡔢G?ӜlP?Ӝ ?H>%D?H^6?AB?ã-?ã?N6F?NVV?J?E4l?鿣"mrc?鿣BfZ?Mr?Mo?'J?r?黡ԉ?黡x?K?K
?m??鷟2E?鷟!?I8?IXo?a?MfQ?鳜Xݯ?鳜xǨ>?E?EQ??3sV?鯘Kg?鯘kL+?Aiv?A?n?bȁ?髓Y1?髓yh0?<+C?T.??6?(˾?H??鄋S?}H?"~?"NN?}+[>?}Ko?|mkL?|m?{`J?{0%?y^Z0?y~dq??x]#A?x]?wΫ?w6`?u?uӯx?tL?tL?rqK?rI?q+"?qJ?p:z?p:O?nUh?nt?mO?m凑?l(6?l(=RvF?j\	?j|D?ip53z?ipC?hLcP?hؓ
?f?fmu?e\di?e\T.?d)?dI?b`?bX}?aGj1?aG&?_1A?_:?^Ipj?^h?]1j?]1M?[*!T?[R?Zw?Zx4?Y#NX?Y?Wqm?Wb?V`K}?V`f?UY?Uyg?SJ?S)&?RH)1?RH'H?Pf?P%F?OM{>L?Ol?N/V
?N/?Lѷ9?L֣?Ks?Ks5?J?J^}?H
l?HH?GYhAۘ?GYf?Ev/>?E7?DK?D"p?C>10?C>PE
?AߙK?A߹(?@;n?@	??""h??"AA?=BxQ?=b
9??-I?+p?+gF?*DF?*c?)("?))?'ȣ᚜?'?&h0Rb?&hO3?%=G?%v5x?#_.?#!.?"FH?"Fgy? w@>? t
r??L?#"k?#R?t{?“$?aDס?ad???+?6?=),?=HT?ۜ	?ۻ/?yO?zs?:胞?Z,G?g0DZ?Q5?T|02?TO
?y?o+?
`|?
?./̔?.O[?
2}?
Je?	iw?	iM?W?1lͯ?z]?J?Ay~|?A?#`?BoI?|P7?|oE?f
gv??d0?~?SLm?Skvq?u?;?չ?1{?)w,?)?A?";?bwP?bQ?ԴH?D?B
o?:>c?7J)?7iL?b%?Ӂ#?od?o?N1?m}?"$[?A?B|?B?ޅ\?ޤ?z~?z3m??D?6ŀ?
"KC?L8Ȕ?LW_?l>"?狍M?₉ւ?₨f?fO?J?߸]?߸@?SYǑ?Sx,?Uo
?;4?ۈ]?ۈd?#\?#{ѩ	?ؽh(?ؽB\0?XCS?Xb,,L?-t??ԌϽ+h?Ԍ*?&N?'!g?)m? ?Z9?[	tX?]?j?͎&[?͎v?(Wϫ?(v>f?C?K?[|h?[/?Hy?
Չ?ƎGp?Ǝf[?'AZ?';>??Z?YϬ?Yj?Ѐu?=?迋!\z?迋F?$z?$P?輽M?輽l#	?Uֳ?Vc?A?G?踇l?踇!2%?g^?Ma*?起u?起OO?O?PA3?HV?1.?豀uwJ?豀>?!w?4ɣ?讯u?记M?G#;?Ge_Z?u'?ߓ%?wjb?w2
??x?触hX?触-?=k/?=?Աr?O?kL?lJ?@?0R?蠚C?蠚}?0(?1l?/NI?KV?^??^H?:) ?X?虋Ҙ?虋^T?"SnB?"q=?薸L	?薸D?OwO?O3?Uy?t|0?{jc?{Y`?u??菧:?菧U?=?=7?S8?r2(g?is?i0D? ?h?舔N?1@?舔l?)v?)^H?腿4r?腿R,?Th?TL?İ)?ʉ?~6j?
i?H$?{?~Y?~[Q?}=9??}>e?{Ҵ),?{Ґm?zgp˻?zg0?x(ó?x68?we(?w]g?v%&4?v%D?t?t}O?sM&@?sM e?q-;?q9V?pvBd]?pv`M?o
Tqc?o
rȤ?mQ^?mo?l28'U?l2W;?j
X?j)N?iY?iY7c?go,?g?ff?f M?e
n?eX3?c诟+?co?b;*?D>Hw?Bϲ0?B͝+?Aa&	z?AaD'P????eh?>?>D?=yg?="d1?;$F?;B?:700?:7No?8(V`?8F26?7Y)?7Y);?5zY?5~d?4zH?4z?39ʏ?3W>i?1U.?1`?0,F?0,dG?.?.?-M^H?-M cp?+A8?+_~?*ml?*m?(md?(m]?'Tl?'?&s[
h?&Wpy?$L?$j?#=J?#=/?!:?!? \_Vz? \}h?"?9?{\?{zå?
y?
ڧ?kE`?&Y_?)?x?)]?cn,?Xu?GrΚ"?GVM?n$6?֌*?eUy%?es^?(?F>??q?}?\?
)Ɩ?
G?.&?.ʑX?
?
9?	Kv ?	K?پ?Q)?g}`?hRgP?ל?.??9h??1Q+Y???-&|?-3??â;|%?âY(,?,H?,?gu?/?Al
?A6?F!?d@?VM&?VS[?!?u_?k93?k$S?!??	?)?F}?	L?	;@H?糒t?糓?$
?i?簦0?簦]'?02n?0P_'?筹7?筹枩?CLʗ?Cj#?̽4??VJ?V9 ?g
	J?߄l?hp?h?'?⃆?z8?z ?حY?b?砌ƌT?砌t??4?睞j?睞y?' &?'>=?皯!{?皯ifQ?8Tu?8r3?30^?~?I?f?I\R4?јnih?ѵd?YmC?Yl?
Q?1Qs?j6B	?jS^Ź?EL"?b?zBBA?z_ =?-T\(?Jg'?犊?犊"͆??bb?燙:?燙e?!!K?!>ѹ?焨?焨ͳ?0-=
?0Jp@?灷?灷"{?>
f??
;t?~6. ?~S[V@?}Mj+؟?}MV?{Ԍ\?{ԩ5?z[٠?z[,?xbO;?xⶇV?wi?wio?u]?uz޳_?tw$t)?twACS?r1?r,?q|sH?qb?pR?p+P?n+V?nDh?m6=?mM?kU?kr-u?j$	\$?j$Z?h8?h"a^?g08!?g1Gub?e
?e*.?d=?d=,z?b|?bP:?aHrR?aHz~V?_Ψ+.?_1?^Tb?^TG?\
DN?\'Gn3?[_?[_I?Y%p?YBo?Xj'?Xj~(?VԶ?V?UuI?Uuf?SJw?SA?Rd ?RZ?Q?Qվ?OV?OK?N"v?N?L?L+?KLr?K8c?IJT?Ig?H!1?H"[?Fb>?FI*?E+)`Nh?E+FEb?Cx?CѶ4?B4?B4-?@j^J?@??O3?'?r?"D ?c?ʗ?^b?;X?CA?`YD?X?Z?F?? L\? 2?:?W?$N?$kO`j?Qu?n4?(Cz3?(`	?*?5zG?5J/?֥?1_?8"}?8>&?\׶?y`Z]?:/$?:
???`?>x?b'?M?@* Z?@F?N?b?A`?A!r??:f?Br?B4??5S?C~S?C3?%?4e?D: ?D3y?Ku>?g?Do~Q?DY?ă[?ğڈ?Dq?DMe?z?Ė~Sv?D]#V?DyJ?0P?Lh?CV?D0?åj??CH1?Cd1?y?.L?B]O2?Byi?ϕr??A1׉y?AN*3??mao??l	???ʾ3?ʿD3?>Gc=?>7s?ǽ-
?ǽJ+bN?<0x}??Q'~?Q
z]?P5TL}?P5pf?N6?Nÿ;?M)IT?M*uK?K#G?K? ?JLPƦ?Jg?HfH?Hm?Gq=B?G?EoD'?E=?D^U	?DyE?B?'?BZR?@^?@-???sղ%d??sR@)?=틊Ӳ?=)	??F.?b?Y?uW܌?_t?z?
WS߰?
r]?Aʟ?\a?	D?	9G?nb?oUJ?F?R?^c
w?^~es?	M?$'U?M`q?M9?-Z?I?<-M???rHz-?rcfl??J?]?]|?{m?,C?H6+*?H<W?9M?=P%?3gT?3mC?徨2?徨2M?6?'4O8?廓Ki?廓f[?~M?H	?}H*x?}@??ءw?g|1?gp)?|?B?Qfc??|]2Ɋ?|w?.K?叵?cY72?cs-?Sʞ?5?J%Q?J@;Q?}y(1?}?|0E?|0?z5"?z^?y/Hf?yI2?wT
G?wnc?um?u:?tpz0\?tpb?r{;?rB?qVqU֑?qV?o[?V?ouݔ?n<9Yp?n9;?>@?<>M?aߐ?+]X'?)+ݐ?)E^6n?(??(?'5R2?&?&6p?% 	?% R	?#qH?#9?"'+~?"A? rR\? rV?t1~?k]"?T
T?T$?ĕN.?į8?5ف?50?~?%?" ??7}?L,8?f*-?ш?)	G?~[??uG?vj?f~?f3.?ճ&T?0?EBy?E\?ǎ??$BX?$\[{?("?֯;?l?3k?ru49?r2i?#U??Q:?Q(O?L?f\?//,z?/%
B?枩?Ò?
"?
ڷj?|#N?|W?TP>?Bf?Zꁭ?[mҢ?=?p?8Ѝ?8?o~?p/rE?ݛp?ݴW?K6?Q?KO^
?䤸`?䤸?&P׈?&jDT?䡓fX?䡓銗Y?E:?_Ce?ny?n[?Zm?/U?Ip?IK1g?䙶к@?䙶e'?$	V?$#T!?䖑HQ?䖑b-?~9ex??k˃?kX ?I\V??E踙?FAN,?䎲|?䎳b? N? mA?䋍?䋍?Ñ"?Ds?f?fZ?Q?n?@#?@+I?䃭w&
?䃭?@?Z".j?䀇=?䀇?~?~d?}`g?}`=N?{
|?{'B45?z9`?z9y5?x?{?xX\?w)tu?wb?uNQ?ugrq?s"@1-J?>@JP?<͞?<c?;Ћ`?;
?9&V*?9-CM?7O׍?7hؠ?6XE?6X^?4î@?4Tf?3.F^?3.[{?1?1F?0q'?0V?.p
#A?.p&2?,7?,)3?+FY?+F%餩?)?)?(=7?( ?&U?&[?$c?$҃?#\
?#\9?!OuB?!ht? 2;? 2-F?K?y?%Z?G?r5?rNd??a?Gz?GO??*^??Z?(t?A?l?Ԙ?\!{?\:dߕ?ƒu?ƫ]?
0?
1,?]Қ?vh?
@?
"?p5?p$?Vv?o'?D?D?g?Aʽ??%l?:^,?S4=?{>e??_5?N?N֢4?'?踗7?"9op?"Q?4?;?ī?G?_?>$?㺧ʏ?㺧>W?֓?T"?y~C?yē?e6?~Lf?KFc?K_??㲴 i?㲴9;1???㯅x?㯅R??85?WIJ>?Wal?cb??(d?(?㧑dl?㧑|F?m?#ӫ?b?bĂ}?F?^?3ڣ	@?3Y?㟜h?㟜޾??w{?mqudž?mϲ?Ε??>a?>y?㗦Y?㗦?8I?QP=?w?wѐ?}?7L?HN4I.?Hf]?㏰d?㏰C?eb?ͅW?㌁,ׄ?㌁D/?j?#3?Q?Q?ㇹ?ㇹq?"?"1?ㄊ'H?ㄊ?XS?GPsn?_?ZaК?Zyr?vn_?Ž6?~*h?~*?|1?|d!B?z?z8}?yb
?yb;w?wʄA?wʜmd?v2uR?v2$?taH#?typ?sG*y?s_P?qj'Rʐ?qj?wL?oN?o?n9։rl?n9,?l#?ls?k	o^?k	+cb?iq2=
?iqJ'?g,?g	?f@?f@B%?d\}?dt??c	?c!?aw=?aw?_T"?_l+5?^F?^G?\@?\KJ?[?[2 y?Y}{?Y}V?W-p?WEux?VL?VLZ?T+!?TC"^?SU?Sm?QMF?Q+J?OWj?ORT?NQ
?NQl?LGuL?L_lq?K :
?K 1?Inj?Iaf?GL	(g?Gc);?FVizr?FVX?Dߏ?D|i?C%!J?C%9jXX?A^A?Av*(}??n??(?>ZO0?>Z4LN?j?$C͐?$Z+?#2 W?#28?!4?!X?1c??fT?f`¾?hO?̀.?4.>,?4Ed?u˒?-EC?/]?î?hc?h{B?'?.?5xZ?5/)?ob?4'?a#?,Q^?iRY!?i	?Qkn?i?6ut?7?	{K?	?
u$?"v?js,?j#?p)?1?7M?7?g?/)?V?N\?kuO,?k?r?ъc?7˄?7]C6?Dm?[¯??Dd?k;?k8?^T?u޻?7t?7=[??X?QJ?i5?jV=?j*?J?G&?7c?76C0?[.V?r?m?wR?i?i:ً?j?
p?6!?69lߺ?Is}?`?l݆2?M{x?h;O?hH0?Χr4?ξm?4h?4MgE?ٚ8[?ٚ?(?~?f?gc:?x1?j?2W?3h{?ј?љ/?v?
ҥ?d_1~?eGD?oE??0Ϭ|?0?ɖq?ɖoM?/!?P'?b?b?jҤ?Ȃ.?.HT?._j}?!L?9x?v?T?_X?_K?ŘD?ůx?+cb&?+z?⹑*N?⹑B8Ζ??{?\ܯ?\F?kp?‚?($v*?(;
?ⱍ2K?ⱍ*xn?x?!|?Y:gR^?YQ?⬾fm?⬾?$Ĩ?$?⩊1[?⩊H1?ѭ??UnHq?U?⤻>?⤻r? IC	? m@?⡆2l?⡆IU?;?[x?QN?QeC$?✶?✶*?]?tE?♁tX?♁6?_IF?v?L?L^?┲Tv?┲l?Ƅ??}=aj?}Tp
?;v??H&>?H00?⌭YK4?⌭a+?sf?y~?xKx?xb|?ݫm~?o?CV?CW0-?ℨb9I?ℨy8-?
}?
$$?s?s#>?]Ą?tQI?~=9N?~=?|?|
ڨ?{??{US?ym7\?ym()/?wƋ@?wzm
?v8{?v8}?tB&?tY^?s|nV?sV?qgj?qgQj~?o眵?oVl?n2?n2/^1?lGq-?l^q?js5?jX?ia}k?ia%i?g]??g8R?f+3'x?f+#?d^??d5J?b&䑀?b=@?a[Bɣ?a[YT?_\ja?_r>?^%r^?^%?\a?\?Zv:?Z@?YT~w+?YTG1?WO?Wb?Vdy?V!?Tŋ4?TM?Rʚ?R[lw?QM8?QMTh?Oiɴ?O&?N1t?N?L|ƕ`?L|N'?JῘ֎?JOp?IF@?IFS?GΠ?GD?Ff'?FA3?DuB?Duc?Byb?BڐZ3z?A?d	?A?{~G??M??dc?>	4gX?>	K
???+	?+^ǩ?ZJ?4?6?̇c?YLA?YbQ?>?O9?"uGl?"~s?:?M?a>?뮨&W?P'c?P>*y-?p?W?B?Y46F?}Έx?}ǐ?X$-?o=?F?F$?iګ?i?Tn?>?tuo?tN?Nd?mR?=|?=%?ݡ9?ݢZ???jC&?knJ?}љf?ϓ?3K?4r?՘wS?՘z?d?	6?amj?aEC?f??*_?*u<?͎փ?͎	?L?c
F?Wut?W،?ȼ7
?ȼM ? /? ^:?ŅW?Ņ3o?uS?饄c?NՉ?N?pB?2>?R?[u?{O?{e8?߼??D*
y?D@
B?Ḩp?Ḩq?ᰞ?ᰞ
/?s?(h?gz2?g%.?X,?Il?0G:?0]G?ᨔt?ᨔj?t,?)_n?]xlJ?]U?a?ɥu?&@?&V	?᠊YÈ?᠊=	?c?D?Sj@?S;?ᛷ8M?ᛷ,?.	>A?CL?ᘀxh2?ᘀQ ??a[?IQBt?Ig(?ᓭ!?ᓭyn ??'m)?vqk?vSY?
i?=??0U??F!/)?ዣ`?ዣ)ޘ?28t?N?lL/)?lb?Ы;?1?5	|#q?5=w?კgw?კ}X>?ř?W?b#|?b985.?~ƁG8?~Ɨ?}*$?}*h?{u0?>u/?<.?<&l8{?;>z贬?;>N1?9vS7?9`?8P?8f>#?6k?6k?4)V?4>?34 ?34 ?1S?1N2?/sk&?/A?.ayg?.a/?,T6a2?,i?+*ŕM?+*ԫ?)7u?)M?')?';{?&X;?&X48o?$s?$`?#!	 ?#!.?!\E?!F?
r~?
N?Np̿?N[T?S?Ef?d?z=v?{?{u ?]k?rR?D47?Dl?ZG?oE~?

?
4?r[x?rp>??JY6?(	Q?(#o?V,?kC?訚9?@/?V|p?V?w?&a?kE?z,?@?U5??%i1?Mu?M)?W"?&*??Ĥ?{Op?{d#?'e?)f?D?ͣEX?ͷF;?2H:*?2)?ࢗ$?ࢗD?G5?]?aJJ?a?ƈ?ƝN'?+w?+??Pl?[q??Zu|?Z̫?_?]?$co?$̤c?Ȕݯ?(?ۜ?.?S2k?TI?	[f?mU?$?8?Ae?U?aNe?uq*?Mp?MZ~f?=???J*z?|E?}Ů?({?<?GXeWh?Gln?}?}*?|hN?|N?zv*?zw?x3o?xG㟶?wAq6/?wAW?u?u?tA?t	o5	?rq;8$?rqO?pքMZ?p֘x?o;BU?o;䪀?m7?m3	?lp$?lB
?jkŌc?jk?h3z?h1?g6w?g68@0?e|l?e?d6?dJza?bf?bf;?`vR?`̏?_1j1"?_1~?]6?]Ox?[F
?[[5=K?Zaa?Za>3?X0A?XDf?W,iNw?W,e?U%ߣ,?U:']?S?S&?R](Sf?R]V?~-Q60?~-y?zAh_?zhL?w:w"?wa?t=-?td<(?qeI?qep&?n3_G?n3T?k'?k=?gϩ`8?g`
?d?d?al}?alAt?^:a?^:P-?[/<4?[}T?WrJ?W5^#?Tsy.?T?Qs?Qt	"G?NB\%u?NBc?Kt?K6?GmL?Gߔµ?DNB?D,y?A|!y?A|Τ?>KT(]$?>Kz?;
P?;1:?7˯G?7s=?4?4k?1lý?1z?.ULF*?.Us?+$7ަ?+$^A?',+?'SO)?$,2Ō?$Rޡ?!6MGn?!\-$?`K
v"?`qew?/jx?/?q?*-?Tf?s_? ?/dx?lS?ly?;V?;Θ?ۀ?.c?rΒ?ڙ?A/"?wi?yh?yYoB?Hn(7?I??pM?,?R[?+?=??E?WS?Wz!)?'!?'H9?(}?!?߳s?#?ޖπfR?ޖ!)?fʗ@?fI?6U?6Le??		L?]?&;D?Χ(r$?ΧNc,?d?޾?޾v?޻!?޻5V?޸Yr-?ޛ㭘?ޛ	@?ޘ&88?ޘ#O?ޕQЪ?Ǩ?|c^?`?	m?	m"?A?A:+?`v|?3?繿Y?? .?Evj?XH?&?bp?b<4?5?5?	Ek?	j??0?鰫A?f?r0?愘z?XHxƔ?Xmi?,,Ar?,Q?:?B{P?;?B',\?֨*4?֨O?|Fq1?|kzA?Ppim?Po?$T?$͐>??M?C|H?hu ?áS"a?áH8?vs7?vz?^Lb*?["]_?["A?W)?Wu?TSh'?Tw?Qλ?Q"?N|Y
?N|}O?KRs\?KSQq ?H)?H)??EWn˓?E{~?A c?AD?>m?>f?;yb?;P?8[m~?8[?52?53g>?2	#?2
݊W?."r3?.F
?+Z$]V?+~]?(V(?()?%f>6R?%go?">`?">K?i?V?`?;|?
3?A???tW̌?t{,?LΫ?LC ]?#"?$4?d%??ټB?y???֏? |?\&o?\J
C?4a?4U?݆?ӡ?#C?+s	?r?ｖ4?mԶ?ܧAbh?ܤA	3?ܤd/?ܠT?ܠx5	a?ܝy?ܝϝ/}(?ܚڈ?ܚӐ{?ܗތ 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ????64?~?լ?>}?2?{q?i?ײp?a?j=?'kY?0?V?2?V??2},?;tR?/?a?H8?Qk?.? O	??#D?gYf?p6?*4?\|??"0?o?ݡfx?ΙV?
?Th?LJ?[p?I7?>HB?G{?ic?ޮj?zj8	?EDp?@%c`?AWuE?<?< "^?8Qe?8Z8t?3p?3?/!?/Su?+B?+t(E?&,#?&6p?"|?"?xF??䧣n?٩?Js4?SA?z`?=~??P C?_b?h?|?*|q?^?\?l?? ?R?p?z?Q>x?Zp?'?0͛?Z@??ظ)0?:?s ?|R?&?/F	?s8?ڥ'i?u'?~???w?@?>tm?G:]?6&??VQ?<z? b̹?)y?`b?c?Ӿ7!??|S?̅h?/8׷?8j|v?j1?:?t:x?}lF??B7?4?]p??#[?(??#?9?T7?]??+F?zT?zB?rNhE.?rW?j{/G~?j`,?b`л?bY#?Z6?Z?R?R%?J--?J?B|=?B%m?:[@?:d?20>	?29o?)^?*ϕ?!?!/{?q?za?g?($?;?B/?^\dj?gЙ?$W^?U!?{G?a?-$?0?CJ?L|x?Րፗ?՚z?E?%?	&?^?5O?>>?Vf?_?lYb?u⬕?x?4b?zMg0?~:?r&?{W,?`U?i?|Eu?|NI?s ~?s)z?i{?i	?`?`Rc?WmpP[?Wv?ND0?N}?D>,?Dp&e?;Jz?;%{4?1Al?1.r-?(O?(P?e7?nh18?!z?R?
G??M?V?j?ۊ?ۦ??h?䙨l???
m?'?ht?zQ?ȟ?-ט?*?[??Ө?z??5D?>GH?x~??~cZ?~`?t"[pL?t+j?iL\?i}T?_5ͤp?_>?TVl?TDG?J VF?J)5??ʛ???4e4?4MW?*7"?*@S?w?߮?0?ay?	?W?	p??ö_?UcC?8?굗?iS?Յ???o?ǝXs?ǦF!/?m{?vAZ?3{?xj?>jC?2?2ž?&q?&N?5?f6?.Ѹ?77er?@?I=x>?Gq?P=?DcZ?M?7\?@A?Q`?(?M|X?}T?7?hU?)t?>2u?1rk^?1{?$U?$l????S??.G7?7w}?D#v4?MS?PH\?Yy2?Gs?P-?,
?5:M ?ߝ"?ϭ?XJ?H?/?
Z?JB?Sr.?y??zD?z?m*ۅ?m4P?_RTv?_l1?R5.D?R>^X?D?D?7C?7P?)vyzc?)??֋?fI?#J/?S#	?\SY?y~??D1?Hטr?Hȿ?:oN?:x?+?,?x3?4?SŎ?|{?%_?.;?.?a"(m?jQ?b?У?c??A?"ڦ?ᕆ@?឵??Fx?kI?tI?ӞH?+?;?k0?YR?c^?sk?츽?s5T?sGv?c8?c6u?TI?Tց?D"(?DQ[?4˨'?4֠?##?$+?Mޫ?}?	+?8K?{8[?gD?8Z?B(?g?f?’~?›Y?.Ȩ?7?.?#?F@?Oo?i?d?p2y)?p;oX?_6\v?_eM?NI>?Nx+K?>G{?>PLb?-ZI?-=N??`?h?&?5?|?%?[?}[?&H?4Z?,?\?"E??"I???N
?X+;$?rF4?>
]?GO?PF?vN?vW?aJ'?aS?L<!?LEA
?7"?7+׀t?!?"ӧ?V?-a???4)Xs?=V"?׻;??o?x1?0I?]?}81?쌆d?vt?v?a]S8?afq?K7J?Kžk?6,j?6Q? Y
? cw?
?
D8	?|?ԩ'?$?Qs?%,?Q?0v?(ˣ??&.\??J?pH?p?Z?Z?D҃?D&?.a$JN?.jPn?+L?"WU?"?c$?gs?px?"?ʑ?꾉G?꾒t?	D?kU?PuT?ꑈ|^?z?zJX?dJ=u?dSi?MR?M1?6?6? 
#? ?	6N?	?z?So@?\Ca?d[':?m?j*|?sVە?d?mƴJ?S?\ƭ?7U^?@&?hw!?h?P3?P_i?9?9#;?"XO?"b?F??;7?f"?:fU?C?ļ.?|?3TX?<?蕞;Z?蕧gvn?}?~;L?fQN?fZzw?N?NQ?6֎j?6ߺoA?/f?[f?.j?7?It?R.?Y?c%6?_%?hQ,T?Y`P?b?HǾ=?Q?w-kʖ?w6X?_J?_=?F?F.-?.3?.^{?-0?6?ϝ?ȩ?eW?o&i??Z?pd?y?7?4?M~$?Vs?jK@?jv/B?QbL?R"I?9E=?9NƤ? SLJ? ~%?,)?VE?8|?c~?of?@?
n?6?GH???FY?qʲW?q	?X?XQ??qO??zz?&3z)?&?i*?% ?!U֘?*?rx?r$?X	<"?Xf?=X?=?#Ul?#?	CB?	m;?S2=2?\\+?
8a?bH?⺶h?#?⺿s?SZ?\/j?AfM?k6m?ka?kj/?P׏]?P?6A?6J?pyJ?*??Ȧ?;g?D#?wԽ6?ˀW?ᰨFT?ᰲ#-??E?z鱛B?z?_fe?`?Dg?EDDP?)١?*E?Aq??;?d_?ؖh[?؟?Zؔ?dt???&?c?kbdr?kk?O?P!g?4=?4f???ZK?Zn?>st?>}
1?"O?"({?n?ɗ?V?_,|?8R?鳬?ݰ`!?ݰiE?ݓk?ݓ?w:9?wCbM'?Z?Z?=5Y?=][?!*?!#RL?M*n?Vev?uS?~{h?ʑ@?ʚ@?ܭG?ܭf?ܐ@?VgZ?9u	?9~1?M?Vݱg?T}?$|m?&??ĕpS?ĞOy?ۧ>Be?ۧGj{?ۉ?ۉ?le4?ln?NZ2?N?1^E?1gC?ɔ?Ҽsp?)&?2Mo?}H?؆o4?ںA?ں2?ڝ~kQ?ڝ?5=^?>׿?a\AI?ae׺Y?Cxq?C?%]?%?)'?P??*$?u3?	:.?٭Rи?٭[3?ُ$	?ُ-0G?p?p?R~?R=?4Q?4[?
??X~??rr?!{.?غ;?غb?؜ڪ?؜s?}y-s?}=s?^Fr?^m?@,_\?@59?!uu6?!~?3	????2?Y~?צݍF?צ!=_?ׇ h?ׇ*?hH?h'o^?I&**?IL?)f?);?
v?
ڝV?$?,?e@?ngZ?֭9?֭'`CN?֍ݮ?֍$=:?nn?nwGj?OR?OC?/?/K?W?@??$?]l?憰?ձBų?ձL!?Ց?Ց*
?qЉ@?qٯ/?R?R l?2/V?29?Nk
?W?a>a?j'?iVl?r|?Բeݶ?Բo?ԒW,	?Ԓ`Q׵?r=R
?rFwь?R]?R!]?1]e?1?b%?(?c?lyk?J?p?Ӱ3G?ӰY ?Ӑ7u,?Ӑ@D?o?oC?O5a?.A*?.??4s?[ޅ?e?̧V?̰{X?ҫl\?ҫF?ҋ?ҋ%(w?jFQѬ?jOw?Ie?In(t?(xR??(nc?Lz?q?{O>?tk?f?oخu?ѤFep?ѤO?уq?у#w?a?a
o&?@?@9?QB6?Zgr???d[?ܑٸ?ܚu?л!
?л*B?Йk?ЙA ?x|?x'_?Vvm?V?41h?4?EU?Nz5??c?ϔ`?ظW?ϭ8?Ϯ?ό"xp?ό+?j:p(v?jCz?HF(?HOqd?&GM?&PɌh?=?F$5?&Ar?0
l?n?w?Ν؟?Ν?{c
?{p?Y]1?YfV?7}\?7wh?
,?1Y?PW?Y{t?
?o?ͭbjz?ͭkM?͊չb?͊V?h=[}p?hF<?E[k?E E?"Ē?"=?.?7R?h	n?q,$?̺yJ?̺!?̗&d?̗?tɱc?t*
?Qۺm?Q?.o)?.咎.??e?V?z&c?śN?Ť?ˢo?ˢyQ?5K\?>}m?[Do?[g?8?80	?94?BW\??Z?Vb?_b
?ʪa?ʪ݄?ʇF?ʇO?c="?c`?@?@Y%?X>:?a
P?6??H>?j?ɱҪ"?ɱW`?ɍ)E?ɍ2hP?iA?iJEg?EKƝ=?ET+?!Gs
?!P?71?@?
?%#g;?ȴR4?ȴ?Ȑ4?ȐV_.?l 2?l1p.?H:y~?HCä?#l?#?3?UL?C:?"ik?Ƕ!?Ƕ=?ǒ ?ǒ)U?m0
?m6?HC?
?Ie;=?$WI?$a;?_,]?|?~??ƶ?ƶ$?ƑCJ?ƑL2?la!?lj:ޙ?Gr?G{?"y"D?"CC?s0?}?co?lK?ųG?ųP?Ŏ a?Ŏ)K?hv?h?CY?Cz)?g?p9?3?څ?Ӵ@?ӽ8?ĮG\?ĮPՙp?Ĉ]?Ĉ~?cE_?cN6?=Ċ?=Y?V?h9?jO?t	V?̵?̾?æ%l?æFW?Á)+g?Á2LM?[QbY?[Z=?5o>?5x_i
?c)i??S?t?Ä	?Í@H?ta?}6?wZn?wczF?Q1jI?Q;?*E?+f9C???k#?t'e??fH?P ??k<T?kE1?D,1?DLsU?8WH?B?Et?eU?[?{!?_2(?hRX?ֶ??\R%?\r?6 d?6)W?K{?T!dc?gC׼?pc.?udi?~?ￚw'?ￚ?snǼP?swx$?LZ*?Lc=ۏ?%9?%C?Mט?mq?>?]?ﾯ̳?ﾯ7%?ﾈGX?ﾈP%O?`6
?`?9?9{/?z?#:/?l]?ꨋ??"a?｛"?｛W?s
3?s	6?L<^?LF?$lR`?$db?E?d?M(?HK?Ｍ_I?Ｍ~?％.&?％7ӑ]?]g?>M?o]?)7?U?^?I?g:4?﷙t"?﷙ȑ?pc*?plH?Fw>??G?e.?Z?	_?Q?ʀMA?ʉj?ﶠ^k?ﶠ{?wK9K?wTVrP?Mq?Mj?#|?#&Q?'H?1?Xײ?a΃?ﵦ{pt?ﵦ?WƳ6!?,Fպ?,b?Z?9w?'zZO?0,?ﱬ4H?ﱬ=/l?ﱁ5e*?V+wjg?V4?+VV?+q_??&]?ʠy~?Ӽ?ﰩ!Y?ﰩ=H*?~O?~Y?RJD?S3?'F*?'a*?7g?@5?kD?ˆR?ﯥBBR?ﯥK]?y?y\?N?N(?"}R?"m?Ϧ0??x?jf?ﮟRc?ﮟ[?s?s6?Gd?G1c?p?0?f?9?Ӳr?͙?ﭗǀV?ﭗЛ[S?kj?k?bϕ?b?5k$?5
?2?
D?36?K/?索?索?|%?|=JK?N?N&Vo? dTM? mlx?
?8\?K}?ۋ#?䞊Y?Y?Y\?'T
?']T??ly&?ɞ5?ɧ>?J~8?S?b?b~?/]f?TiLH?*e?86?dN?mv?]
?jG?z?~K4O?~♴?~ﮯ?~U0 ?~U=I?~0p?~=?}?}7?}Tc?}]pd?}yQ?}y"?}AӻJg?}AC?}
?}
?|&r?|/}?|'?|3?|dLʯv?|dU%?|,e`?|,q?{E?{N?{?{Z2?{
a?{?{N\U?{Neai?{g?{}j?zݹ 1?z&x?z
wF?z3@^?x>v?\{?\b[I?\k^?\Xex?\X?\\%?\_S?[2g?[;Ʉ)?[b,?[k/L?[a@?[a:?[#?[#?ZǥU?Z{H?Z?Z?Zij?Zil?Z+d?Z+o?Yh?Yq/x?Y;ʧ?YDGb?Yq?Yq`?Y24?Y279
?Xq!?Xzh?X?X J?Xw+%?Xw-HA?X9CSm?X9LU?Wrm?Wt?WB?WK?W}~o?W}Y?W?u?W??	?Wmc7?Wvd?V&?V(b+?V?V` ?VD+be?VD4?VT;?V]٫?Ur̬?U{)?U9?U;?UH_?UHO?U	qR?U	&?Tz0/?Tʃ1?T`Q?TiRT?TL;f?TLDf#?T
rY?T
s7?S?Sـo1?Ss?Sr\?SO9CM?SOB?S9–?S:X?RrN?R{
?R?R?RQ{}?RQoG?R?R&V?QX?QaI?QgZ?Qg?QSIe?QS_?QP_tN?QY_w?Pӌ?Pӕ?Pa?P??PS1?PS1g/?Pf&?Pe?O9L?O?Oݾ?OS?OT-o3?OT,?O?b?O?Ni!?N?NX?N?NS~KV?NSJ?N=?NF^?M?M:?M)2?M*?MR8X?MRA}?Mr?MqdJ?LS"n?L\!8?LÌ?LDS?LPA\z?LPJ[J|?L?L	?K?Kk?KT:?K]8?KMj?KM.?K%
?K#?J?JS?J "?J)?JJ7|?JJ@
?J	A?J	JS?IA4?IJ?I6 ?I?g?IFD?IF(
K?Is?I%?H+?H)s?He?HcfI?HAVZ?HA_t?Hе
?H?GWV?G9?G}LZi?G}UX)?G;ݻ
X?G;K?>FQ?>=ߨ?>8A?>p̜0?>pՖ?>-Ǘ?>--?=ſ?=A?=˙?=Ø:,?=dUn*?=dOt?=!v?=!]??5s5g?5s-B?5.?)>I?(bZo?(j0?(?(~?(kbS?(kk?($;_&?($/?'6ӌ?'?Ǹ?'cNR?'We?'PrZ?'Pue?'
"~,o?'
+r&?&[?&d	N?&|qV?&|7[?&5tѥ?&5hL?%H?%;?%:0	?%-?%`R6?%`E?%ɕ?%҉?$Ҵd?$ҽ1	?$6?$)G?$Dfڌ?$DoK?#/&?#8?#R?#v?#nj?#nP'?#'F"?#'O?"pD?"c
?"s&?"-?NC?=7?J2j_?J;Y7??a?9N?(?m;?m)?#zS?#?2f?;T?x6?	d̆?	mnU?j?wY?~ڴ?~4?3D F?3M2?Ka?׶G?Mu?V\?PE?P0?+?4w?3f?'?m>?m.?"& ?"/r?dˊ?m?m??> ?>|YS?U??$???Z/?Z!?(^{???߻??v[&?vE?*?*}G?lv?u:?0n?9?E鶛?Et?ޙ[?-?;1۸?D
?`ӴR?`ܝ=?am?jV?b?K?{\`?{e:?.?.x?+?4p	?B?],?H1Ni?HG?
D?{???G6?bh^?bqsy?,\??Ț?ȣ?{p|?{m?.?.Ǹ?Z?j?}e?v ?G[9=?Gd ?."?7
^?P9g?7?_?_9G?eAKX?n(K?
?T?w?wh?*4|˺?*=c?ܹ?x?2oz?;L&?Ak?AR?Q2X?7k?^^?gE8?X\?X5?
?
?(?1t?oV?o_w@?!yii?!i?Ӓ#?ӛ	&?ݦ?ã?7a?7,?S+?8?;??Ma?MjFu?6̡X??.Z??	?bL?bW?tNp?}4?0?&O7?wz?w`	9?)PaeU?)YFkK?ق?g?W?`ʴ?=ˎ?=s?4?=gHK?n?񠛬#?Qd?QS?+i_?4MǨ?f?oF?e:?e!?E?ůi?~+?bh?xW_z?x;V?)\>?)@?}?u??a?<?<ÆB?픈?p?E3M!?E
    x?g ?~xT?襇ZƱ?U9?U"?d?6?絟#?絧9?ec?eEc?{n?T?_?Av?Ib?oJ?xO?l,?l?<%??ʻK?ă?y??y/0?(2?("?צ$+_?ׯ?߆w%?߆V?5bg?5j?/L?8?ޒ,U?ޒqM?A?A?YX?b}E\?ݞ?ݟÐ ?M[?M:??(¹g?ܪ3?ܪo?YgS?YE?l0"?J=?۵X?۵ꂡ?d7o?d??u?=?ƨ?ʊ?n?n;?!^J?*??g?x˝?xx}?%|}?%W?4c}?=?~e?~??+sx?+|R??
di?̈́TM?̈́.?0	)
?1E?hц?q?̉?̉?6"?6+^s?o2?x=?ˎ)=?ˎ?:o ?:H"??"?ʓ6E?ʓ?ѡ??NF)??WP?ZV\?c͂?ɗ]ň?ɗe?CTM?C]aI?Av>?JOކ?ț"X?ț+#?F!У?G?8;?˞?ǞW?Ǟ~ٝ?J7l/?J@v?- ?r?ơx?ơ-C?MN?M?+G??Ť Ӳ?Ť)?Op?OH?=j?	o?Ħ`ę?Ħhl?Q=?Qs9?}?a?è??èH?Stf^>?S}=?
K?#?©??©U?TI?TG3?ti?Ku?%?a?U#?U?uH?KR??}
?V`#?Vh{?(r?1^?Rn?)'5?VQ?V]r?B)œ?JQ???9?Vs?V|?d?B{?w?G\?UM?U#?O?XMY??4?T@3?Uw?C+?LW? ?3?S?S??v? 1??R]د?R2?IuJ??,?|H?O}?PRG?]?꣫?+?Z`?MV?MWrn?R$?['?
S2?'?J/ 3?J|?b]sR?k1+??I?Gƈ?G?	|?|n??)?Cݸ?D?bAN?kqb?2??@
?@n}^?Sw?\Rh
?e?	?;œ?;LJiM?l??=$M??7
?7cE??A?eg9?7?1%G$?1W?E&????,p?,6u?Hh"?P?~?~
g?&-Y?&Q?UI?^Z?w1x?wL? G? v?1 ?
5?q|E?qBk?꠭?q?MӠX?Vj?j_e?j/đ?GT??7?@`M?cp>;b?cy?V1`?&}?2?ʬD*p?	X"|?	ai?q?z`?Uߞ?U?#k?O>?|?_?Gk=?Gtt$?P?X\w?){$?1.?8?8_,?޹o?|VVj?{jMv?{-?{??{?{>,,?{>5F?zt?z࿼	?z56?z>N?z%m?z%ޫ?y?y?yjsCO?yj|H?y$/?y$?xg?xS:?xQRO?xQ[Q~?w$@?w?wQF?w1?w7hc?w7ϫ?v?vJ??v{?3?v{\p~?vVI?v?us@?un?uaC?ua|?u?0?uv\?t0?tO?tGa.V?tGi`?s"!
?s+r?su?sΦ?s,^k?s, +?r(qD?r1N?roTn?ro?rM]0?rVuI?qд
?qs?qTIU?qTRg?p?p]1e?p8?p$O?p8u1y?p8}Q?oąP?oDX?o{	G?o{Nu?oC_WP?oLj?nqy?nzq1?n^5?n^|?me?m$?m&?mA-?mA2*?mA?lzJT?l8q?l]?l?l$A?l$ط?knv?kvœ*?kf>գp?kfG4?kN?k?jwG?j5M?jHsT`?jH|)?i0?i#k?i7Қ?iKl?i*JTX?i*Sy?h!0q?hre?hkM{?hkV9?hg;?h$F?g&5?g/?gLE>?gLT?fַ)?ft?fx?f'?f-]
`L?f-e?e͐?e͙kN?em?em»?e
bR?e
ὑA?dN?dsal?dM%S?dN?cPH?c|?c;:?c?c-R?c-?b͸r`?b-!?bm|?bm8+=?b
X?b
`?aY?a!QQ?aL2	?aL?`yƊ?`hř?`,?`#?`+?`+U9?_>̦?_Fx?_j>?_jS?_
8?_
@}P?^*?^r?^I	x?^Ii?]b(?]j"?]t?]yz?]&!?]&z#?\-:?\5з?\e[K?\ed?\~?\?[Fn?[V?[B7O?[B2?Z~k?Zᴉ?Z?Z?Z=j?ZH)?Y{b?Yd9?Y]W(?Y]_?X(?X0׏?Xhr?X?X9?X9D,?W]
-?WfmO?WwR?Ww{?W,?WX#?V4?V=/?VRbr?VR˛?U9u,4?UB-W?U,M?U?U.Ұ?U.Dq?TrŊ?T{QH?TjV?Tj`?T	?T	R?SNA?SW?SE-?SE?R}?R4S?R{?Rם?R|?R;A?Q0?QvM?Q[?Q[e
?P锢?PKI?PnB?Pл?P5C?P53?OӍ?Oӕ4	?OqY?OqbAv?O&&?O$j?NӍ?NC]?NJ?NJӼ?M$g_?M-?Mn
?M#u?M#L6F*?M#T때?L?LxQ?L^K?L^S܅?K;o?Kjg?K!.]?K);?K6|4?K6?Jͮ?Jc8?Jq??Jq?JNw?JW, e?I]M?I?IH2x?IHfM?H:ߟ?H?H;q?Hl?H?Hm?Gp^?G$Os?GY̭?GYa`/?F?Fd_?F~?F1q7?F0i?F0q?E3?E<:;I?Eiɨ?Ei|?E??E:8?DTQ?D]Z?D?~^?D???C܊?CܓFF?CyY?Cyc?CS?C6?B
v?Bgl?BNz4?BN&?Au/?A'E?A4z.?A=,k?A#FT?A#u?@ޣ?@ΐb?@[F|=?@\~??.??735O??S??\D??0n??0w1?>L-?>̇^.?>hz.?>hɍ?>?>|?=p2[?=x5?=?6w?6+r?6+H?5̓?5A?5a?5aFp?4gQ?4?4Rw?4?42㞮?42G?3?3=$?3h?3h=?3?33?2r?2{!?29:u?29B?1YV?1A?1n6?1nEA?1	N?1	WD?0X?0̰?0>}ߠ8?0>?/1h?/?/sO?/s?/
>P?/m?.b?.j?.Bo?.BI߈?-?-l?)
!?N?N®?j|7?sY?~
Ju?~{?S?A?*?3WQ?D ?DD? g?).?s?s?
s?
<4	?EM?M?9a
?9Mf?ըF*?Km?h?hA@?
>	?
F&?
c+?
k?
-~H?
-خ?ďd?ĘW?[m?[%Z?򓥨?H;?ѥ
?t? o;X? wݯ?
LF?
Uk~?
N 9
H?
N('?	w?	/sA?	{1?	{l?	]E&?	f?	R???f??7?Aצ?I?6s?L$?L--`?BF?J:?xUm?x^'G?^T?g]@?]2?f@?:S?:[3?>@D?Fߤ?fm:?f(M??>?rE?zv?'$?'?@~?I?R웡?RD?蔧
H?E?~.+?~73?p(?]?D=k}?Lۚ?>4?>ȜD?1 ?:T?ij?iG??_?JΑg?Sl&?)CF?)$
?HU?學?T
?TK?5?>	}?~WߒJ?~`|E?oIn?x&?~.?z?=ud?=j?z#KF?҂K?gh-Y?gqa?M]?Ul?'?0?%s?&R?d?ǬK?O{ZH?OA"?.A?6s&?x?x߄m?
u9?
~9?
ei?>?^6?g?exH?e{?8 ?@]?匕sG?匞x?鿸?W#?3*?1?sFdJ?vn?	w?Ӗԍ&?Ӗf?(mMd?(uߦ?Һ?ҺwD?K@?K0?C||?L^?ñ?n/?K?TFC6?hxkv?h)?\?%9?͊A?͊fD?2v??̭!d?̭*<:?>3H{?>;?;	R?Cv?`8?`Ak?-)`?5?ʂF?ʂֻ?*?In?ɣa+?ɣY?4A"2?4Ї!?^[{?fr?V4?V C1?N??wlr.?wu-?	z?v?Ƙ+?ƘM?)R?)'#״?Źq?Źr?J?J@?w:?ڀ?jz?j?-&?5?Ëy?Ë	?;_?ì߻?«qVB?«~?<"|?<*
?F
n?O`Qb?\a谏?\ju[?sEm?{q`?|z3d?|?v?)4?i*)j?qx?,Q ?,Zk?0"?9J?LL?LW?	cz?ٕ?k{??k@?J$Rx?R4?fg?'?)tX?a?6???90Yn?9ϻ?Nx8?VQ?XR
?X?>H'?GaG?wR?w~b???[]P'?cw?%U?%߄?~?b?D?D'e
?Ln?T?bp??t.?}2?"J ?*ҖE?!?Ω?2`3K?2h??	ނ?Ow?O?t?kH?lfh?loE?_??0ْ?8J?
6? ?` ?P?4J?4?N	V?VEe?P|?P:?ޠf?ީw|?ldx?la?0?ԙ'??ۅ?*?ذ?Úo? x?2P~N?2f?Oc?ն?Nc?Nl";?08#?8Xp
?֪?ֲ "?dtk?d?u!\?}߶?~?~Ԝw?[Nz?!(?\?er?&܀?&Xt?ퟳ1?ퟳϓl?@?@(@(?
?9y?[?[&h}?'̻?0 ?u'%?u01?~ʇ?&{?휏\?휏s?꧞+?*
L?훨¤?훨&?5Ų?5m?U?^?Od3?OV??x?hi)F?hq.??Y?혁Rx?혁?%
"?.uO?헚o?헚x ?'`F?'&?햳2?햳O??nf??xs?Jk/?RI?X4?XJ?,?5|?qC}?q$
?NyK?WS?퓉wD?퓉6=g?ﾤ?o?풡V?풡?-qJ?-?푹??푹>q?Ep ?Eq?Ѣ?ѫ7(?]?]?cl?lmZ?u6F}?u>J?A??펌?펌 s?q#`?zd?퍤{?퍤$O?/cf?/Ƨ?팻T>?팻]!!?F?|Fz?|Cy?|CG?{ͫ}ar?{ͳ?{W
?{Wc?z:?zGG?zl-p?zl)?yM?yX!?yjk?y?y
M1?y
s0?xul?x}?x✨?x?w7?w,?w18?w1_?vVrQ?v_"#?vEڭ}?vER?[?[	G?[:/18?[:7]?ZR>?Z?ZI9^y?ZIAb?YЯqN?YиX?YX
?YX%eY/?X߀C|?X߈_?XfڠJ?Xf?W+B?W3~?Wurr^_?I>;?HIJ?HĻd.?>n[?>B<7?>BDi?=DŽ?=ǍR
?=LQ?=Lx?<)?<x??1\?1g:?1Cљ?1C5T9?0AQ?0I?0LE)?0L縋?/кmxg?/6?/T,?/TsX?.nU?.^|?.]*?.]2?-=i?-E|?-eG
?-eOm?,F6c?,mۊZ?(GHv^H?!>P~? ^f? f:? Dk? Ds~l?o7
?w?Ji/?JrRA?Z?cT?PC	ޥ?PKh&?!?*MO?UI?Uq҈?dD? ?[k?[6?=)?EB ?`C?`?ٲ5?6o?f/ck?f8-?Éx?杞?kN?kVd?N?׫=?pG_?pO?<܃?P`?u~?u$FB?xjD??y˿b?y?4?Hڞ?~Va?~^T?(?f?q(?̟?ޕ??|x??	''?	2?v?]?
Ӫf?
.li?P??4	??
?VY?ᰮ?(F?+YV?"
?|'?MLQ?U?SL??7?ʑ?
nl?
vp?
ޜD?
7??l?":?"Bg*?v6?+`?%>`ҁ?%Fv?
9aQ^?>A?Q?o??_Y??hj??y?@`o?@hn7?=#?ڒ?:2?B?A@&|?Af?͋\?d?A4E ?A2׮;(%?r?z??NjS?%L ?%UҬ?<>'?ى}?"LL?"Ti?࠿?f?(?0[?ߝD?ߝ8}?W^?|?ޚ.??ޚ77?t>+?|&?ݖ6+?ݖ?6j?c?ܓɚ?ܓ=-C?,6?4/R?ۏCna?ۏKa?
Qs?
Yg\?ڋV?ڋ_
?	R޽?	[)f?هE>?هND?0?8^)?؃0|?Ĕ&?D,T?LpR?ÍR?Í䅑?
^?
 `k?†t?†|?6N?z?O?,?T1?\ѧU?wW?wԜ?7?z`?o0^?osZ?Em?
?hx?h?G_?>*??k5?츺P?츺'?6U?6]u?췱?췱0}?-oi?-
?충?충$Qt!?$?$m?쵠ƨ?쵠'??%?촖$?촗?^2?g=?쳍k?쳍?	?	-%?첄Mon?첄Uż?8?w??z	?zD
?O?/*q?qz?q:/?))0-?1g?g:{h?gB8?B?K4!(?]B?]Jٵ?9ia?A?S'h*?S/g??վ?Hz?HV?ú??>2|?쪹ETl?쪹M?3+I?4h3u?쩮!O?쩮^?)R;?)ZxT?쨣z2p?쨣=?R?4?짙ok:?짙T?+en?gi+?즎?즎Q>?}0 ?l?쥂q?쥂Y?E(?M?!X?w::?w~?7?sQ?l-Y%?l5?h]?p֑?`"?`;6'?Ċ~??T<-Z?Tvp?ǔ?Q.?I?IY?V'?x?=?=V ?잷X?잷?0(?0a?읪135?읪j?$sW?$H?윞~?윞,p?G?O럴?웒5f?웒nR?j?ţ3R?욅jNj?욅r?Nɇ?
?x'?x:?=-u?F!?kF?k0?I@E?Qw^?^MI?^}?1rm?9S?Qb7?QjX??%?DK?DT1?씽U?씽u?6ܚs?6?쓰A~?쓰 ?)Ig?)RO?쒢rJ?쒢z?=j?:t?쑔?쑔?
?
,Eu?쐆O?쐆ŵذ?BP?x5?x?f?xt|?y??j{f^?j(S?U?]Y?\&?\..?`?)OB?MT?MW?e]A?mc??T??X?슷Bl?슷?0T@?0\tC>?쉨6&?쉨jN?!qeҡ?!y;7?숙%?숙g=?kw^?s?쇊_?쇊㒶?Bg?J4?{U?{*O??f?lC!?~
^?~vK?}߫r?}_?w̝?w0+?wpLl?wxz??v߷?v?u?u3?uu]?uue9>?t욞'?t& ?tcψ%?tc׶d?s?s^?sRmq?sR'r?r:l>?rB?r@L̹V?r@T?qV?q^?q.W@?q._m(0?pN?pVNF?p=0?pEJ?o#y?o,?o
P+2?o
	|0?n?nK*?mE?mqa?mneæt?mnm(?l 9?l(y?l[?l[?k|e?k҄??kI[?kI%?j>?j߰?j6Es?j6Mu?i̛&?i
?i#K--?i#SW?hd,?hsz?h-#W?h5M??g:?gr?f?f(w?fs>q~?fsF?e>_?eh?e_iÅ?e_ђs?d>?d
?dL1l
?dL:
>?cY2#?caZ7?c8wF?c8?b	?b1?b$t?b$̩?a?a?aq?aV?`.?`f?_{۪?_q4?_r]lf?_reԣ?^6C?^>Cf?^^R?^^7[?U|}?Ub2?U+bv?U+‡?J?T?Ta?T76?T$\B?S@G:R?SHk+?>I6?>ITnl?>IrT?=iA?=q)?=1-?=16`??3OY?2sE?2{)?25?25lD?1K?1?1,?1ID?0"?0?0?0+?/t?/tX?.y;E?
>CT?	%?	?	f?		?<?D?-޺?<+;?qhF?qpǧ??
?Rr͍?Rz]?Y?g}?3[?3c)P?ÂU?ˏ?#"?+/A?zw/?2s?Ƀh?ѐ?eI>?eVP ?N]?V#?E
i5?Et?	'?;?%ɚ?%եS?ضZ?e?0>?0F9????«?~@B{?~HJP\?텑nT?퍙$?\©?\ʰ?r?N?;$;?;,B??Hb?P?eT?m	?y+/?툁2Y>???fW?f?Ղ_^D?ՊeS?Dtui?D|?_F?g?"A
v?"In?=?"?d$?ii?nºS?n?v.?~S?/F=?ᝤ_?᝭W?9??[H=@G?N?n?6[L?6c#?ѣ)?ѣ'?U?]
?~ƐC?~Ύ?/	z?7?Y_n2?Y]r?U?/d?47!S?4?t?͡?͡v?vx?t C?{6c?{3?&ޗ?.۟F?VNp|	?VVmY@?mJ?u?0Y?0Vpf?ɝ͍?ɝ,?
J?
.?w?w$?D?@?Qr?Q(w?ƾeV?ƾm?+C[?+KCX?Řp?Ř!g?yr?u?q:v?q5X?j?r_?K M?K({P?·
ē?·'?$si?${(??S?[ND?U2I?j3GU?j;?ֹ?8?C5?C=[?뾯}ɤ?뾯w?f?v?뽈{2߹?뽈+\?n?g=?a+
?a3?먱xg?먱kP(?՝.P?ݏ?마DŽW?마F?1|?9?^T42?^\'?n{N?vm?4ρ?4i?뤟2?뤟$?
7?
?uj?u?y?8:?Kcqx?KkbN?롶ED?롶M5?!\?!'jK?렋?렋I??6?a|Ȁ?a?6d?>?6Șn?6}?띡8?띡Ρ?5F+?=?O'x?O/_Q:??t~f%n?sl?stn?sOܙ?sO}?rDc?rLGb?r Z?r >?qŦ?qb?pLԬ\?pT?pY[$?pY>FM?o7?oz?o*7}?o*k?n@-)?nHw?mi?mqp?mb*?mb}?lʥ?lʬc|?l2?l2Cb?ktrz?kÛ?k÷$X?k˘R?jj??jjŸB?iҰ'?iҸ?i:?i:?]R%?\J?\'1?\!j?\!nRI?[H =?[O+?Zw?ZX?ZV[?ZV?Yx?YiF?Y$Lv?Y$(S?X]?X8|?Wi20?WD#?WYe"r?WY@m?V?V}Z?V'!?V'?U
?U?T8?T?T\F9?T\ ?SW䍠?S_
?S*"
?S**^?RO!?Rw?Q?Qie?Q^Uh?Q^]B~?P?P	oI?P+V?P+ʹ?OBwI?OJ?N#?N?N_eZge?N_m3Z?M*?Mbu?M,h?M,o61?Lƽw?L,?KK?KS+?K_7?K_?J??Jk?J,g?J,oÇ~?IC^6?I?H-?H@K?H_>+?H_Fe?GwU#@?G,0?G+??G+?F'o?F$?EM$?Et>?E^v9?E^Lc?D[]?D&2?D*(C?D*0?C*{]?C2Q?B%?B,@?B\M?B\?A#&?A
y?A'(?A'/?@¡">?@v??8??Ф??Yc??Yke?>(?>0l?>$?>$G"?=͌?=??6x 2?6L
F?6L?52pT?5$L8?5fH?5n0?4|?4|\?3?X?3?3Gy~?3G |?2E,9?2L޸?2i[@?2q,??1v,?1v$?0ۛ?0ۣe?0@?0@%T?/}?/W?/
?/
h"?.ok?.oa4?-ԑw?-ԙh?-9yA?-9g?,XKW?,`ʋh?,1$j?,8~h?+h?+h	?*?*җe?*1Hz?*1O?)F=?)N?(w?(x?(_?(_^?'FC?'Nm?'(j?'(?&ua|?&}.j?%d>P?%	1l?%V?%V<?$?$
w?$xY"?$(*?#?#횑?"Lc?"ST?"L?"Lm?!?!	?!Q?!YU.? y? yv?I?t?BhzT?B3s?Eh?LӤ?
n?
v?n?nۻ?ҫ?ΰN?^7l?^X??F7?$z?$onh?Rl|?Z/8?"Ă?*}D?L?Ly?p{?c?fw?n9?u?u F{??c?:fJ?:n??	t^?TB?ӏ?b#7?b*?ĨD?İrz?'&»?'.?nG?/#'?7?uy?Nt?N|Yj??I?.?o@?5?u6'?u/3? ?౤?:?:GE?G?OBO?{g?ӫ]?`=r?`?
?ӿ?$^*?$?Y??
J?!?K.?K;?
R?X?
)?H?p?qme7?g_?o!?5TY?5{?E?{?')|?.v?YX<|?Y_Թ?޺>?޺?n?'Dt?|-?|HL?d*??>`?>祭K?۟,h?۟䑣?#g?3r?a.?ad??x??#?#?p?ph:?пL?͑?0K?0v?꿐@D?꿐G?.?h?O?OJpF?꽯KFx?꽯S?.??n3?nZ???ꖢf?ꖢ
+?c?zZ?^8?^O?ꔼ~WJ?ꔼ/,?L?Tx3S?xP?x?R(?ۦ`,?3,?3>g?ꑑ>B?ꑑEy?艄a?,w?L?LsT?ꏪ(+x`?ꏪ/͝!?c??eKX?eS/_?Ҫ?L0? R? Z]?}?}fA?=p?Ef?8?8_?ꊖ?ꊖTz?i?qF&+?P?P6*?ꈮ@?ꈮ?U?]<?h7?h0?-l>??#e!?#	v?ꅀ,N?ꅀ43H?PJ2?XZT]?:m4?:u{?ꃗU?ꃗ?
>??Q.n?Qm?z[;?ye)?ye1r@?xȔ?x0?x`J(?xg?wz	7?wzh?vzҢx?vׂm?v3/?v4BDZ?uyM"?u%?t~?tvp?tI\=?tIc_?s)?s[˧?s"I4?s)?r^zէ`?r^o`?qh-?qw?q?q-?psZ?psbCQ?oϗZ{?oϞy?o+;?o+Ա	?nW?n|)?m#?m+X?m@D?m@LF?l^`?lfGr?kq0.?ky]?kT}d?kT?j5Nx?j?jOo?jB?ihx7?ih?hh+?hoŽ?h Q-?h XY?g|3?v?g|:՟'?fa?fu?f3Ќ?f3,
?eޅ?et?dv<?d}ҝ?dG5 ?dG=G?c??cpX?b~?b}1?bZJo?bZRA?aS?a"	.?a
[?a!?`m!?`m)B ?_Ȱ7?_ȸBpQ?_$8?_$@[?^p?^H?]3rA?];ψ?]6^u?]6!r?\q?\T?[x?[c?[H|9`?[HPr?Z.E3?Z5,?Y~?YB?YZ{?YZ
?XhǦ?X!d?XG{v?XO
,?Wl|Z?WlDc?VǫK?VDz?V"Қ*?V",t?U}*?U}?T]'?Tȫ?T4?T4&]?S*[?S1M?R/
0h?R6ߵ?RE,ۭ ?RE4l-?Q#ПH?Q+`?Pn?P{3q?PU,z?PVl?Oߕ8?O%U?O)b8?O¸?Nf/~?Nfw?M]M?Mec)?M$Av?M,}E?Lv8?Lv]n?KўY?KѦBT?K,Q"?K,X'?Jzhp?J?IW?Iᨆn_?I<>Sw?Ix#?> ?><?=%?=̰e-?<
??7G3?r ??{r-??@ŀ?@J)(?M~#d?TV?񬋠?	\?J|?JsO?Vv>?^;/?J?br	?Rm?RR2?$Wv?+?[?c#z?
[Z{?
[,?8š?D@?9L-?൝?c?c?
Lӫ?
đ?
cl?
!?	l"ا&?	l*T7?$?,*h??'c4?t?t?v?
E?#?#iq?{ʿ?{:X,?ӤQ?Ӭt?+x=?+)?E?M+g?1b??2z?2_z]?c?>?7ŝ?>?9ⱥ?9*\?#x?9?&9
?-?@.?@œ?OgB?VlO? *?ᘨ?G^Hq?Ge?Ö?V\?R戌?Z]?M`?M,?-N?4Ż;??(ų?S?SZ?CQ?K?]?e?Yۨf?Y?m?%E0?Yfm?`܁?_nS?_\?*?^~?
פ&?
L?e;yH?e
ku?!(7?(?5i?<ݧ?jC5?jJ#?J}J
?Qz?KA?R?oEZ?oL0?9Eu]?@?&M߰?-MZ?t~?t?QG_?S?!ń?!Z?x1#?x?dWT?k?&)|b?&1j[?|"?|w?ӡ?ө$?*S?*[@z?kP?݁?פN?׫?.C.?.J?Wj?_?m?twc?1>w?1f?|R?∄6?J?H?5qT?5yTV?ⲃ.?"T=?M?TqS?8R?8C%?ޏ+"?ޏL?e?lv"?;jM?>:"D?ڔY@?ڔZ?t]?⇻?A?AN?ؗ3[?ؗ:=s?O5
?W^?CeH?CmEn?֙uF0?֙|o?~=?F?E?Iؾ?О?ОI@?q?N?Juf?J|B?Π7?Π? Q+?o??K3>?K {?̡WC#*?̡^:?`Me?4=?L6P?Lx2?ʢ#?ƣ`?ǫ?(?N/0?N7!-?ģf5E?ģ$?-?a?NAο?NI8?£?£i8?z?*(`?E]&?LF$?LM?麡G9?麡O-%?CT?Jy9?K8
=?K?n?鸠&?鸠.??&?IHJ?I@[?鶞o?鶞ӫL?:W?󧞂?Hn?Hvq?鴝6|?鴝>$o??♄?F?FI\?鲛h_B?鲛pZ?M?$N?D k?Dǂ?鰙b9?鰙i*??d?B}>?B?鮗"?鮗*?뫋?6a?@-?@5M?鬔2?鬔&?H?&?=y?=ُ7?骑W?骑_?Y?aD.?:"?:?騏ޥ?騏q?[?c?7?7l(@?馋?馋z?$1?,?&?4[^?4bQ?餈3?餈Ŧ?ܵ#?ܼ/?0<5%?0d0?预vSu?预Q?
1z?F?-?-$g?頁'Ŧm?頁/#?+3c?2k^?))4ϱ?)0=?} ?}'!?3?(?$NQ?%
?xЙ?x,ڴ?̿?m? ? n?th?tp1?4\9?;z??
?o?o7?qY̽?x?#f ?*?jr?j̘?镾u?镾|uR??0?e?e*?铹@5i?铹G?Jq?ԣ?`S?`[A?鑳°?鑳T?M?UXj?Z?Z%?鏮/d?鏮6'?Z? ?T?TQ!?鍨RS?鍨ZQ#?s?x?N?Nk?鋢=?鋢E?xd??臎?
?;(?;;?酎?酎d[?	$?`M?4l?41+?郇?郇h?ڱ?ڸW?-'$?-|eg?遀 .?遀>?q{?x?&Oݐ?&W1?y(?y/e?~H?~k?~ ,?~F?}q?}qH?|K+?|R?|S?|E?{ij&?{i*?zdیc?zl.?z8?z?ya*?ya>?xGJ?xN?x?x+d?wYj6?wYqiA?v!?vN?us?u{?uPQ?uP?tdV?tlr?s?sa7?sH=<?sHDmE?rEL?r#?q/V?q?q?S?q?[J%?pk?p$?o:?oH?o63?o6;B?nrR?ny_B?mڪV'?mڱ?m,܅q?m,?lm/?l&?k.;J?k5Tj?k#M/?k#TB?jufܯ?jun*?iz?iǁj?iB-?i?hkM`?hk?gAd?g~&?gr?gj?fa~|)?fa11U?em?etW?eV6%]?e]vz?dW8?dW@?cAA?c.?b@?b?bLe?bL[=P?a2S?a}?`J?`QZN?`B?`B!ʚ?_?_ԫW?^q)w#?^xt?^74?^7${?]4e?]~m?\a?\h?\+f?\,Ky?[}U?L?[}??Zh?Z"H8?Z ?Z #t?Yr$F?Yr+X?Xß=K?XæJ?Xd?Xk?Wf?Wf?Vu?V?V	O(fq?V	Vpi ?UZ@2?UZ?Thu?T	?SR?SZ@?SN?SN?Rph?RFx?Q x?Q'?QBXQ?QB`3?P]?P^?O9?Ox?O59N?O5?NJ?Nц?M?M [?M)-b?M)4͉?Lz;?LzCCCe?KDI
?KK?KFbM?KM,?JmBw?JmI;?I8?I?$?I(J?I/
:?H`7?Em~?EU?DK8Y?DR{G?DEf?DE{?Cѝ?C-?B?B"~?B7@-J?B7Goֿ?ACZ?Aam?@ؖ?@؞r?@)8ҪK?@)@c??yW??y*?>k?>rG?>+[?>l}?=kY.?=k?<	{0?<8b?<?<w?;](?;]ig?:rœ?:yn?9G?98:?9NEx
?9NL?8^?8K+?7?7&?7?Ul|?7?\?6=?6|?54?55?50/?506p?4l;Q?#+"/?#3b?#NԷ
?#N?"w\?"~3?!x?! ?!=&Ez?!=_? =? D1?/?@?,Nk~?,U?{r?{'~"?Gd?N=?^z?–'?j)L"L?j0?_s?0?󙡾?Я?XO?XW2?'?L?>?uN?FB!?FIW?1L?gH?pg4?ͦDd?37?4j?3~h?:?a"'?hW?!v?!?p?p?Ɖ?;^?ܭ?A?]+0?]3q?u??/8?c?Jl?KEUi?%~?YZ?
mz?
4?
7
?
7"?{?z?՞?եe?$zL?$N?
sQ?
sX>?	!xsX?	(&?	/p?	P?_?_R?opu?v?(?/	?K{E?K^?IP)?z5L?1F?82?7?7&?o$g?vT?.?j?#:x?#j}?r!$?r(S?N,?}[?%?,]?]iK2?]eg?0H?_v?	)?8SO?H?HMH?Kq:?R?0?0K?3!F?4	:?O.?W?Л9#?Тf[?
??m Vv?m'r?Z?a`?	9_?	fZ?W~}?W???E?
.?Z!?B'	?B.??u?FT?QEC?XqD?,][#`?,dr?zcj?zj?dZt?k]?_G
f?fqÎ?dT}?d[!?C?K*?-Ε?49?N!b?N
?Vo??~?p? gG?ns?n?e͖?l?
v,?
2?WnY?WȖC?f{\?m1V?R?
zY?@A?@hQ ?4?;$??C?)Lv?)S3,?vTj?vz?L?T???_7I?_>o?ެu?ެ$*? ?7%?GlY?GsA?ܔS?ܔb?G?$ą?/ma}?/t?|I	?|m?%ٽ?J'_?<_?$?CYh?du:?d}?ױ>?ױ?A[?edw?L-?Lz?ՙ$?ՙ+6/?AȂ?Hi?3YsFZ?3`?Ӏk?Ӏr|?xlFK??[+?}_?gS?g8|?д|
Y?д,E?q?y?\?NbBEk?Nic?ΛL2?ΛTIy?2c?9,~?56?51?́pGs?́?ο?:?z?&b?hW?h^?ɵ2}s?ɵ"R+?31?R?NT?Nœ`?ǛD/?ǛK?ww?W?4?46E?Ł:?ŁBQ?,?K?mو?tE?f?g5?³|ξ?³y?u?v?LD?L??]?
}?*ZP?1Ҏ?17?~[
?~b*+?ʿB?C?(?&d?cx1?c?軯̅t?軯ӡ?ǡI?!?Hc}?Hj_v?蹔f?蹔l?F/?ao?-]?-#w?Ed?a(?k_C?~N5\?~N?f%k?f%n?eo?	j?eoA?dZ?da{?d"?d$w/?cL3?cL5?bh?bo	*?ap?aHZ?a)?a)ԍ?`sE?`sL?_/~?_06?_iz?_p{?^O'?^Oo?]xQ?]R?\7?\߁?\,r/?\,y/?[uD=L?[uDX?@N4o??j*??g?>}
?>߄F?>(
E?>(#?=pXUN?=pO&?J?*y?)Y~],?)YN?(?(#n?']:?'錿8?'1\?'1w?&yxx?&y>+?%jU?%qF?%	W?%	]?$Q>p
?$QE?#!?r_?y?	y?f@?3v? N?\'lp?\.٩??5?2F1?924?2h?2a?z(Z?z/d{?Fn?1?	
Y?	݈?Ptg?P{a?R?u?@("?
7?
}?
C%Ң?
CY#?J??Iʐ?P?h?P&?
` ;?
`?	Y?	?	D?- ?6,交?63`?}K)?}Rw?eEQz?l,?z2?0?Rk?R$?P?7&?}?Q?'?'Qv?nM!?n3i?y??~֧??Ck?Cr?S}?Z{}?6Y?=q?c8?w?^%?^O?,\?ȺN?>(??3[i1?3bM??z ?z':$?3??F??j?NR^?NYΕ?aŽ?E
?۰R?۷W?"X=?"_m?h?#H?i!?
1??1?8@u?<?<ʻ?TR?[)J?.Τ?o?d{o?k\ۏ?V?VSk?`l?gM?*C?
?*Hl?*O?p_\?p@}?:?#f??؂??C:?CaS?7?=$X?Ћ8?В&?ڌ?kõ?]%̐?]+7?j3n?qw?S4?2'?/2Y?/?v6|?v%ՙ?Pa@?W?!?}Ox??H.?H}?ɲ?А~?=??tl?J?an?a?ߧ&?ߧ-?1:u?8o?38%?3??y9f?y@t?ܿ66\?ܿ=LV?-?4E?K ?K'ؠ?ڑ?ڑh?j?E?웻?%V?b:?by?ר)?ר]?m{?tU?4>&?4E]^?z
Z?zDs?ԿW?Կ3?k?z?KRu?KYN?ґlg?ґDe?ֿ_?mJ?nw?uɴu?b	?b Ze?ϧJ:h?ϧ"6?`Hh?g ?2~?3Vk?x?x8/?̾&m[?̾-nh?|a?RT?I=~h?IDT?ʎ5?ʎpF?@I?Gt?w\?M?_1;?_8Jr?>Qrf?纃e?纃l?|
|?ȃg!?
{?
L?R?Rz#?緗!?緗?ܧ$ ?ܮ?!i?!?fMY?f?紫U?紫*?(I??5s|?5z!?z[(j4?zae?籿=(?籿DbS?F?"z?H?H?篍aY?篍0gi?ҙ2B?Ҡ0?dSt?k!z?\*42?\1*?笠?
X?O|g}?O3#?礔
	?礔dz?ؔ!
?ؚ??ߓ?a=7,?a?硦?硦? ?ꒌF?.
?/(?sk?sr!?瞷ԿF?瞷ۉ}?9'8??Û?@?3?@?眄?眄#*?JI"?Q?
?nΧ_?n3)-p?n3/P?mv_?mvfo"?lI?l]?k&?kS?k?~?k?t?jt?j:?i,}6?i38S{?i	H3?i	N0/?hL_
Fk?hLed?gq?gxZc?f?f҆w8)?fdN?f2?eX?eXP8?dU?d@?cދV?cޒZ.?c!{u?c!4?bdvl?bd}!?aeó?al{?`Pj?`V̦?`-5w?`-<@?_p[?_pk?^RN?^	"?] ?]ӏE?]8?]8?\{p
Z?\{wJ·?[;-?[B*?[?[	LI?ZC?ZC˫?Y\?Y1?X?P>?PE?OC?O?O+S\?O+3?Nm?NmJ>?MK?M&?L{5$?Lߒ?L4鿭??L4q3?KwS?KwZt?J?JiwS?I>~4O?Hd(?Hɣ?G$6L?G+/D?Gt:e?Gz?FG?FGGY?E8?E
FX?DI8m?DOO?D)?D//?CPlɤ?CPFt?B?Ba?A(:?A.?AUؠ?A[̱?@Y}d
?@YY??/???>hN?>q?>8?>浘?=a=p?=a?<?<
_?;A?;j?;(AJ#?;(%n?:j$o?:j+pf?9&CJ?9,?8#HB?8)Á?80?80"?7r[?7r?6l?6{?5.	?5(P?57ӢV?57Mq?4y?4yt?3=?3N@=?2p2T?2v ?2?F^W?2?M?1#?1C?0n?0E"0?0ė?0n?/Fs?/FzKF?.43P?.:?-z?-#?-x?-!2?,M\-@?,Mb?+_?+C?*ж?*нin?*]?*dJj?)T>?)T?(h?(>7?'8?'?S?'c?'&?&Z_?&Zf,?%(?%m?$u?$|]?$q?$+P?#`zQH?#`}T?"v?".?!n?!u[?!$Diq?!$8? fQt? fX9*w??J+?#x|?*?*?*U?kl߃?kxi?>h?E3)?wM?xX?/'YJ?/M?q3L?q:+?|?9A?hK?Sa?5?5$?v>^/'?vE?v?}&?q?t?9)d?9ˢ?{?{M
?,n?3հ?P
?V	?>nQ?>uP??LZ?.\?.?Z?#?B?BG7?ʅ9~?%?
?
ֻ&"?
~ǫ?
?Fα?FQE@?ǴS-?S?
ȼ\?
'(?
	-Bz?
	IJ?	Jw?	JDG?m??f?li(?
F9?
Le?N!?N(s?yD???ӓe?LP?r?Qg|,?Qnޚ?.qfW?5G?'?òj?
?P?Tj?Tp? X(?&?q?
o?f?O?W*79?W0?7?ր?qq+?x?*?w?Y(J?Yϑ?=T?C4?b?w?Ơ?a?x?ᴍ?!^?!W,??#y?#)߱?c?c&?գ`E?գfձM?-w?4(a?"괆?"z=?b?Ɯw)b?H?g8?g!;?msZ?Zn6?Z\?ÚM?ÚTO?ٻ$n?X?$z?+Ծ?X?X?눯Z??I?O??A$T?Uen?U?潕J#l?潕P]?ԗh?Ԟ{?,l?\˚?S'\?S.PĘ?溒iK?溒pC?ѧ?Ѯ2?᪄%?2E?P?PCS?淏Ix"?淏Pf?xM?~i:?
ac%?
G?Lu?LHN?洋7?洋F?	"?jnEn?i8n?i?h(?h错~?h'0lXQ?h'6
?gd?gdtX?fin?fpan?e!}?eV?e+?e?d[$W?d[*_w?cq?c65?b8/?b?M?b?bo8?aQ>*?aQE+?`/?_	?_	?^G?^G%	g?]tO?]??\?\,?[`;~?[f?[<+r?[<ʘ=?Zz$y?Zz*1,?Y!?Y|z?X@?Xg?X2/>?X25ޠ?WoF?WoK?VC ?VJ?U>#*?Uf
?U'_F?U'fh3?Td#`?TdW?S;?S	?R?R$s?RV̴2?R]6=?QYy?QY?Pl?P'0?O\?On?Oh@?ONX?NN:-s?NN@?M\̨B?Mc5Z?L{_?LȂ)iu?L,_?Ls?KB6?KBEF?Jm?Jnh?IӘ?I?Hc?Hb?H6f?H6cm^?Gso??Gs5.?F
?Fsf?E?E|?E*?E*9:?Dg[?DgI?CT"?Cݺ%?BǽU?B#?B?B?A[ӶJ?A[9?@n&?@H??exjl??kT??Cl;??JX?>Os?>O%Da?=>
?="*?<#?_?6?5Dx?5룦؃?5(M?5(T?4d+f?4e-?3?3CG?2I1?2Pbq?2T|?2XL?1WiN?1W)?0%Dq?0,\}?/н?/$?/
Q`?/
XW?.I.?.Ix?-o>?-vPP?,:?,
:?+?+L?+<^?+<	:?*x?*xTb?)_?)X?(u`?(|\?(-?(-
?'j[?'jbA?&ɛ?&S?%3؇?%:5k?%f?%«?$[?$\?*?#]]?#d)?"Ժ	к?"feU?"?"F|C?!MhT$?!MnH? H? ?Ȉ?$m2?>!`?zߕt?za? :?&_?]\pr?c
?/
?/e!?kFg?kӠ?!?jg?/h4?5? [Q}? a?\ʪZ?\# ?n?.?r?g??{?Mg!F?M	?Z?!?.;R?52Q??4?Es?=LQ]?=R?yUT?y\Mc?\!?bx?^/?e:?-^;Qm?-d?
iZ+g?
i`'?Ra?Y	[?G ?N*3?9&??{?
Y't?
Y.=?	.?	/?i?9?ޖ?d?Ha?HŶ|?L? ?v8?}+o?M9?S:?8 	?8'y?s?s?'?M~??Z?'K+?'R	?cͺ?cY|>?G?L2?ڈn?ڎ#?@E?GK$?QT,?Q!?5f?A?Uc?[R?:7"?Z?@%4?@
f?|K቗?|R2<\?Y?Z?"?s:w?/$+W?/*{aK?jr?j,s?N8b?T-?>~?4?jg?q??XNݨ?X?zZN?򔀩?d?bE?||'?m?F62?FC?q\V?w(?Ĩ?$`?Yn?_P=G?4E?4/7?p3uM?p9)?뫛?뫡h+??֓?"b%?"heoG?][j?]ƧC?Re0?!=?rU?yIo?`?ͫ?KxZ?K ?fHN?l?p?.?
?D?Z?DB?~fT?6u?6`?qE0;z?qKi^?娫R?娫?䵷?? /+? 6
?Zw)?Z~-?奔?奔l?X?f??
m?E9r?S?S7?僌	v?僌8D?|?ƂJ?f?fm?eOT?eOr?d0
?d#U?cc?ci?bƈ?b8?b4^Sc?b4탌[?an$J?an+J]?`_d?`e+L?_|-?_	?_tZ?_ҘL?^R?^SK?]-?]3d$?\Z
T?\`0?[?[ao?[72?[7>i?Zp?ZpΔ?Y?Yrn?Xp?X9?X'?X.E?WU@+[b?WUFMt]?VUy?V[Y?Uh?Un0?Uw?U}چV?T9/?T9d5?Sr?Sr=?R|?R_k?Q?Q
?Qa=?Q?PV?PV?O6?O?NȎ?NȔެ?N᳦?Nm?M:x2?M:~QQE?LshU?Lsn?KV^]?K\}?JA1?JGP:?J)'?J/FA?IWLZ?IWj?Hx?HS6?G&N?GC?G?G}?F:?F:?Es]!?EscX?D2+?D8Hh?CZ*?C		?Cc?C؀:{?BVP# ?BVl3?Agr?Am?@-̜?@3:?@^J?@y??9(??9C?>rp!e?>rv<{?=+G?=1b?<@?!?EV?Ot?ʏ?К
??.x?IQ?+T?+^m?cЖ
?cE?&?v1?r?yf?YNZ?_Qc?C=N?CC?{$O?{%,?	Z?_?AIB?If=?"?"?ZR?ZB?_%?e?1{?7e?c?``?9ͥ:?9ӫ
?q/?q?_J?e5?$?*?-Q?3/~?P)?P/9?dj?j4?[?%a.?ך?ݟH?/Kݼ?/P?g@o?gFtd??h?֟?֥?J`?P8w?E?Ҥm%?Ҥc?]p?YD?,W?2S?Jx?J~g{?ρ
?ρ?ι
s?ι?O0I?U?'i?'c?^ҥ<*?^؟ey?˖o?˖i?Kɱ?Qg??|O?;/dH?;(?rq<?cV?c\n?r?xg?ыk?ёu?I???He??b?v!Z?v?伭٧e?伭ߝ??	m?V?ֶ?RΖ?S5?乊u?乊4?H3?
M?d?Y-?/r?/x?fCph?f7I6?䵜?䵝y
??L+?
0h?
#?Ad?AWʼ?x:?x-}?䱯_?䱯¥?%?j??)?TyT?T^?䮋^?䮋d,?Aؠ?G5?"
(?'0?0?0e?f۪b?fᛆ%?䪝?䪝g?ԋ?ԑ ?`%?fy?B2{?B8}?y߲?ync?䦯_(?䦯O?曠K?桏-W?d}V?j{^?T+%X?T1O?䣊ly.?䣊Z?al(?O?qf?v`?/.YO?/4F\?e]?eJE?䟜?䟜bO?Xy?^f?
q?
J_?@_V?@K&?wmߥ?ws
?䛮
?tМ;?t?䐪?䐪^?-?3q??!?N=6?NBT?䍄+8?䍄R?䌻C	b&?䌻HAt?¦^?ȎK?(@;?(E)?^!bN?^?䉕4:?䉕92?˪?˰_?[?$Y?8+$"?8n?oT?oK?䅥nņn?䅥t\v?:^? Dx?Cu?I[J?Hx?H]-?:o??䁵q?䁵w9?b??"0?"5U?X%?X?~e?~y2B?}=־?}BiY?|:l?|X?|1>?|1!?{h6X?{h;?q)W?q)J?p_?p_?oh?o5i?nH?n*I?nDs&?nJt~&?m8n?m8s܂?lnpI?lnN?kL?kNE?jݬX?jO?jA?jo*?iGI?iG#'E?h}9;?h}??gT;	d?gZDG?fl{?frX?f/?ft?eUڅ?eUmgS?df?dB?c?c?būڎ?bˇA?b-Ƨ?b-kP?acmR?acH?`ឰ?`ya?_@?_?_*?_?^;{?^;Vhd?]q5?]q)?PмY?PPv?P'M?O?L?Lf?L;b?KI?KI1?JT?JZh?Ij?I$?Hb?H[6?H ?H ?GVrD@?GVxn)?F4#{?F:dD?EҢ?E`?D	?D(?D-o6{?D-u	?Cc)Tn?Cc/':?Bb?B5F??AΗg?AΝ9?AKcI?AQ6(?@9X^?@:*AW??oE??oCY?>[,=?>`?=
?=E?=豆?=??z?ټ}?!\	j?'"T
?lط?r9?LmQ?L3'-???C?IDH?22?썆Y?!ɼ?!ρ?W	?~?WI?HS?Me?M??Y?r]?++?+e5?a-/?a3?
b~`?
hB?˕U?˛_?Lu??5c%?5%H?
k"e?
k(\Ѯ?	M?N?Iee?Iki?~?e?~?H??q?赡s?~?ʮ=?R$?R`??Bj?
Q??=??''$?'_y?\?\"k?$坺?*{?+K?1	Xj?/?5^)?02}?08`C?e3?e9M?2?8ep?/Y?5{?+hN-?1$?9%9}?9*D?n뒇?n"c=?D??7?A??f-8?AR?A
q?v.n?v^?@S?@?ై&?C&]?H?!?J?JxKk?hC?nf̫?LX?R?/'oI?4?b?p`?RL?R:>?˅?>T?漦A?漬}ls?@g^?W?&Wy?&]?[-FJ?[3?lN?խ?Ԏz?Ef?>[?(k?.t-N?.yq?cA\?cGPc?ߘiB?ߘ?v?5Y?oe?%
?6dX?6jRzy?k)
G?k.{M?۟?۟uG?Ԭ4?Բl?	k?	q3?>)t?>/()?r;0]?r@?קHS?ק(?W3?]P4?8n??E?Eg?㰷(E?㰷.?돆O5?.?kT?=?TX	?T]?㭈V?㭈s?㬽%`?㬽?xͽ`?~u?%U?%ہ`R?Z1K3F?Z6?㩎$Y?㩎D?fr??:F??gW?+(F?+-?_(g?_N?㥔45?㥔:;M?Ȅ'r?Ȋ^?ӳ7?X?p
%!?pvb?㙤ENs?㙤JM?~>r?؃:??E8g?@?@ p?ubT?u%rz?㕩R,?㕩X<?݃# ?݉}ƒ?j?8KJ?E?El/"?zz:R?z.?㑮9?㑮??%?c=?h܍?Ugn?h?J?J^?~q?~ܘ@?㍲Ÿ?㍳&Y?2?"1?=?B?O\%?OaÓ[?㊃yL?㊃K'?㉷?㉷T"B?@M?݂?Kf?zw?SǤ?Su?ㆇ?ㆇq?ㅼ|t??ㅼ??$-X?$0&?$5†?X@@?XE܎?れNw?れT{ו?\ܦ?a?gd?mL?(qK?(wsF?\z?\:?~f?~|%?}ć
?}čH*?|?|x?|,?|,~?{`P)?{`z?zF?z?yȎƖ?yȔb?xو?xr)Q?x0s?x0C?wd?wd1?vzK?vb?uq?uw%4?ug^g?ul?t4[92?t4aVy?shN?shTG?r@33>?rE?q0GV?q5#?qij?q$c?p8(>.?p8Y?ok?ok?nW?nR?mNl?m?mՉ?mp@?l;~?l;t,?ko}?Wb?Vϙc?V()m?Uy?U攔?UM4?UR?TN	ӉS?TNa?S6?SĚ?RBG?RА?Q7\?Q=?QQ;?QF
?PPVF?PPb?OZw?O_?N
aL?N@?Mh3?M+?Mpk?Mu?LS~s?LS%
>9?K͍q?KvB?JzLd?JV}?I%N?I+Di.?I!oN?I!aN?HUxj?HU~.V?G " ?G%S?FRA?F(?Ek5?EpV?E$?E$R?DW
Y?DW?CRVd?CW?BX?B:'?A9?AeL?A&-)&?A&2?@YF?@Y~%??cy<[??i[5?>b?>;~?=?=.V?=(+QX?=(0g?<[|x?<[=W?;T"?;Z[B?:筑4?:4O?9yAn}?9~?9*	p?9*.O?8]?8] ?7&^	?7+e?6IJi?6ĸe?5>?5Ce?5+4]?5+͡Ws?4_P0?4_V]?3Sp?3V?2^@?2dR?1㋎/?18?1-gI5?1-l2?0`?0`L?/k
4?/pu?.N?.𓛴?-i{F?-o\u?-.gK?-.ص?,bcT?,bi?
6j#?
6?iS?ĩ?D?Iu?
Ў?
Д4?
=0?
ݵ:?	7 dž?	7&H?jgۿ?jmTY?
?r?w?q*?6??7?7z+?k+'?kf??:L?DF?n5P?sa?_?4?7R?7d?j?j&?dR?$P?If?Nuw?q9>?w?7,y?7?j?j,??R?	4d?qg?,yՆ?1ꅨ?7N8?7T"*?joJO?juN?띏?띕m?Яh?д-S?x?҈?6c?6?j
'?jy"? 	?&d?:?@G?S&?Y"?6k?6p@m?iU8?il?㜘?㜝?Ϭ?ϲL\_?!?	^?5U.?50?h
l?hwa?ߛ
?ߛ)K?l4_?
؅?b?yL?5!(+?5'/?h.m$?h3ػ?ۛ:$?ۛ?)?DȔ?J+]?Nkx?Sֶ[?4WE?4\?g^?gd1e?ךexVc?ךj╎?k-?p
?o子?uOv?3sܤ?3yk?fve)$?f{|?әx-)?ә}A?x?~d^?x?~8`?2w$?2}h?eu??ez3?ϘryR?ϘwD?nmv?sՉ?ilI?nӀ{?1ctu?1h۷?d\?daV?˗TT?˗Z
a?KgR?Q7?B?Go.?07M?0<*?c+"?c1h?ǖ#:?ǖ$f?q$?֍?n?U]?.#?.#?a'O?a`?ÔϚ?Ô4?ǿ?J?f?ʓF?-N5r?-?`It?`:?⿓mX?⿓rI:?V}0?[M?>?Da?,&[,?,+i?_ll,?_?⻑-?⻑K?~??+??*?*S?]~G?]2?ⷐ_?ⷐe+??7d?E>q??$l,?(U?)?[ڼ1?[1c?Ⳏ?dB?ⳎG?)???m?r?'G|?'L|?Z yt?Z%lQ?⯌'?⯌3?⮿F?⮿1P?)?.m?F?F@3?y?yMc@?⊬B@?⊬GU?L?4??`0?DT|gr?DYٽ?w%?w	,o?↩(?↩{N?_O?e.?͙?  ?A?APR?tdo19?tiAx?₧ 6?₧r?ٹ&*?پcd?bE?gU??
,??:`?qsF?q/?~Yn?~^h ?}?}^?}	1?}	?|oql?>p
?=nN?=sҴ?<ϝ?<
a?<R}?<WB,?;9ß?;9?:l45?:l9rG?9@^?9}y?8?88?8?8t?75("#?75dI?6h_?6hdJ|?5l$?5Ѩ?49C?4>)n?3?3Қ?32]?32?2d|đ?2dۈ?1_8?1?0Q?0VAK?/Nh?/?/.$r?/.)t?.`/?.`iA?-\B?-?,]@?,b@&?+0q:?+i\?+**?+*0I?*\%?*\=?)\?)?([?(a?'"?'"?'&$s?'&)?&Xm?&X?%3?%F?$N^2?$S?#ﰝ?#r?#"b?#"hN?"Ts?"Tx?!{?!ٱZ? 4һ? :l?따?X?K?L1?PS?PX;?a?%? ??m*?rFxu?+1T?_D?L&Ϸ3?L,?~Pe?~3?޽??:??;$? ?6?GF}?GyD?zI;?zNnb?A?=?kR?j4?Tzd?Yw-?C?C⟘?vzJ?v	n?[3?a+?ڲf?ڷ?
	JrG?
{??_bp??du?
qum?
q>z?
P??_'?dWJ?y?D?
;Rp?
;Ɍ?	m[6?	m`eJ?k?z?8"?f?SZH?X̧x?6Md?6_x?h8N?hfaF?Hn?M?͙BC?͞oE???29A?2>,\?dh
?dP?دx?4?'?,-?v0?{G.?-@P?-kE?`D?`0?_j?d?Ĭq?ı ?\L?E2?)Ee?)J?[S`?[}???W;?I7ZJk?I<D?{|2u?{X
-??D???
?HR?N?Dv|?DO?vP?v?e?扙?Ut?Z?
f?
6??a??t?r?r O??ߤ]GO?ߤbj?֞޺?֣?r?3?; O?;%??m`!?me?۟V?۟?n?|?4?%:?6_CC?6ddf?hEG?hf/?ךi?ך#?{E? ?Y`?^З?1B5?1=?cQx?cq9 ?Ӗ?ӖK?O'?U	hb?Ԧq??,ɀo,?,ΟC"?_T?_p?ϑBF?ϑG;x?~
N?Ã+?v?]?'5M?'St?Z0nU?Z5	?ˌkj?ˌp۽?ʾ+E?ʾH??Ǹ?͇w?#G?# *?UU5?UZ(ˮ?LJ
?LJc?ƹȂ??ƹ͞?7O?_?;T?@1?Pt?Py*?ÂV?Â?´a+$?´{֦?"?"Ԓd?Uah?Z?K{?Kv?}Ŋu?}ʤh?ᾯci?ᾰ-9?4kGw?9#?k4?pBr?Fh?F{?xFD?x^?ẫz?ẫ9?F:R?KSK?|n??Arw&?A!?sJg?sb?ᶦ?ᶦ#?Sw1?Xt?
?
:??ᦒ-ɹ?ᦒ2Oo?`E6?eXX?t?>?(ܭ?(?Z6?Z	?ᢍ((?ᢍ.?᡿ZW?᡿_V??
?#4#K?#Dߨ?UHz?Uɲ?ឈ!!?ឈ&2C)?᝺Rp_?᝺WL?샦s?숶;?›?0v?PāP?P?ᚃ'm?ᚃE?ᙵG}f?ᙵL?x4ל?}C??b?K]?Kl+?~	i?~`?ᕰ:,?ᕰ?::?js?oJh?\??FL?FV?x\?x8?ᑫ*PS?ᑫ/
?Z?_i?4d?Q?ADx?AP?se?s?፦?፦?I1 N?N܎?>ܓ?>1*?>&6?=@+?=@n^?r?,_qr?,_v-?+ZY6?+IP?*?F?*.G
?)\X?)!K,?)(Uc?)(ZK?(ZCle?(Z1?'
?'j?&
4?&?%=C
m?%B0?%#w?%#|?$Ub)#?$UOQ?#Iz?#6g??"(l?"-XT?!cD`?!h?!d?!QK? P<? P(8?P??T[ٖ?^Ԙ?=4f?)?}N?K:>?K??}>V+?}?؞%?{?(^?-<%?xԓ?}]Ѵ?FL?F{P?y?yNJ?k7?py?ݼX?iI??߻t?Ba?Bf]I3?te5?t@_?	?%H?[_~?`:}?wju?R}?>?>ч?pX\?p]F-?᢮/P?ᢳ	??öK?Z
$?^m?94O?9u?l]7?lnm?ݞ^?ݞc?жͺ$?лT:?$?S?5g?5l?g?gż?ٚs?ٚJx?tq>?yHE?3?ӶkT?1)q?1.nH?cj?c@?ՕX?Օb?<U?APh??y?,Ǡ?,?_TEmJ?_Y?ёC?ёL?+??o?tv?(a?(A?[.F?[3b?͍4?͍?̿ܓ?̿ز?QAt}?V5?$
?$R?W1kh?W@?ɉw?ɉ|گ?ȻzZ?ȻO?>?C~0? ʯ? 
?Se:?S7^?Ņl|?ŅqN?ķ?ķy?8 ?
?BX??j?KT6?K(?}z?}j?༯n)?༯=?PT?U^x"?3E?y?G(\?G-+J?y
.?yؠ?ฬ?4lB&?f0?f?ङ\п?ङaB?~?FϦ?T1?Yq??0h?00f?cN?cSu?ࠕ̩g?ࠕp?K+?O\?DQ??-I?-N}?_??_z.?K$?O%?̧?my?Nų?Sau?)~i?)D?\T!9?\YX??݈&?]Q?b?{S??Q?&hCF?&m?XX?Xmi
?ud?zqo?Qڷ?t?H|?Xm?#x2?#;?U?U?"">]?&)??^?8^0F?= g?s?4,?RQ+ݪ?RUH?މFh?J?l?qM9?3?u?x?B?Ov[?O6|??]??]?`=$?ef?KA?KІy?~w.?~\??!F7?ƭ?㶅o?G?Ls?HO?HA?{uԖ?{zU?
-?K}?~0w?~?~?=?~D??}Eق?}E@#?|xt35?|xx?{f#?{P?zݫn?zݰ`=?zHe?zM!S?yBl?yB/?xu\?xu?w"b0?w'?v_e?v-?v
b?v
g\l?u@?u@V?trK?tr?sG?sLk_?rʹ?r?r
?r
Z?q=3+M?q=7?pomR?po&9?o~g?o!4:?n%:?n)ԃ?n̈p^?nA3?m:tC?m:yg>?lms?lm"HP?k,~?k?jq?jv;c?j4;?j!NЪ?i7jo?i7"(?hjt?hjyP?g"S`?g'
L_?fe?fT`?f721?f?e5.ȒV?e53~̺?dg>R?dg=?c,*?cw?bBt&?bF?a?aKIW?a2?a2D?`e\l?`e`E*?_J?_?^Ƈ?^GD?Cx?CBs?Bu?B"?Ac1?Agͺ?A!6ƿL?A!;ra?@T5A?@T??}9??)#a?>?>K?=썞b?=I?=ew?=j"?-A?qw?$IC	?#|2?#|7b?"(RG,?",cU?!s?!#J?!6?![? H0? HE?{A?{ъ?T?x[?Wl??L??F6?F1?yi?ys?x?F???W-J?tI?8?E'?E$S?xH?xo+?m?
3?S?P?%?	-H?EV?EN?x?x+G?9??$lb?)V?.?3p?D:2_?D>Ь?wFj?wK/?S*?X!?
bK=K?
f]?
q5?
v@?C?C@c?vK6?vE?
v?
9?	ܸP?	ܽI?	=?	?Be?B(?u\
?uxW?.?%?({?-?A6?Fn?B\)?B`\?uwa?u|@?*?}?۱LdG?۵b?Ϻ?TN?A/?AM?Sl?([?PbUI?Pk?e?s???7O?@q??'6?OKѴ?O{&??(t?q.X?z\?ľ۰??e?#B?Or#P?O{P9??.V?(7?1/?肆"?肏M+?]lF?%?OH?OQo?㵭/D?㵶YlW?ǭ?_?|v?Vy?\?E?OTZ˸?O]P?۵|?۵̤ځ?4?=t?؂0z?؂W?ć?&?O?O?Ӷd?Ӷ2?z?Ƙ?Ѓ	oO?ЃV???d"5?P7?Pr?˶1?˶s?p?!뙽?ȃ?ȃ%hn?-oP?6D?PI?P1?÷J4?÷T)??!?q0}?zP=?߾?߾U?߽QYb?߽Qx?߻;C^?߻Db8?ߺg?ߺ]?߸w?߸?߶j?߶"w?ߵRn
t?ߵRƊ,?߳c
5?߳lgI?߲ 
MS?߲ )4?߰^?߰B*?߮c?߮lЅ?߭Tu?߭T	?߫nz?͈߫`?ߪ!x3?ߪ!MOL?ߨ.??ߨ7Y*?ߦ!?ߦ?ߥU1g?ߥUI?ߣ^?ߣg0X?ߢ#J?ߢ#&a?ߠȥ?ߠ?ߞj?ߞ?ߝWhȪ?ߝWqޘ?ߛ1E٭?ߛ:[Rk?ߚ$?ߚ%)?ߘ60?ߘKv?ߖ򘬱p?ߖb?ߕYjw8?ߕYs*?ߓ>]?ߓG?ߒ'Z?ߒ'!G?ߐ:?ߐ|T?ߎ?ߎU?ߍ[j?ߍ[?ߋ†`Ҧ?ߋq~?ߊ)h?ߊ)q,?߈M+$b?߈V;?߆4?߆=+r?߅^t,8?߅^&6?߃	6f?߃Ee?߂+[O?߂,io_?߀?߀B?~K?~݀?}`"\?}`/?{Ƹ?{?z.t?z.G?x^?xǍ?vsP?v~i?uc?ucA?s•7?s˟5,?r1Ǹ?r1@w?pgAC?ppS?nt?n}^?mf9i?mf`?k?kb?j5Wi?j5_?h!=_?h*C/?g8?>?gA?ejRgc?ej[m>?cns?cwN?b8mZ?b8rKp?`?`?_V?_Z?]mV?]nY?[!*?[*-?Z?8.?8&1X?7?7Δ(?5	?5}?3N2?3Wm{?2R?2R¢?0'%Z6?00?/!9?/!0,?-	Lc?-?+7g?+,?*W"7t?*X@?(q&?(z?'&?'&ȷ?%n^?%w)?#	=?#p?"]vw?"]	E? ? .E?,&L?,UT?5?&?!?3?c7N?c@>h?Y}?ITT?2d8Z?2l?sI8?b4??r?i;B?iD0?ݯE?T?8͏v?8?
*eT?
3N?=?	i#?
oQ
j?
o?0?4?FzY?O`?*x?"v5?Uc?::X?h??M]c?SAv?S%N?2?Ĕ?#eP?#n3@?Ib?Rv\?0?9ķ?[}?[#_5?%?
?*5:?*|????W?bP?b޽?З ?v?2"?2O?ښ΂?ښ`yJ?Ѷ?ڔ|?jA5?jN??ʫo?ʫw+??β?{K2?{ñ?MD?%H?Kͣ?L1?´+2\?´4	u?Y|^?bS>?޿?޿ ?޽Z?޽Ǚ?޼T}?޼T?޺/?޺8?޹%lH?޹%u\s?޷Zh?޷.Mi?޵/?޵^?޴^4ʎ?޴^=?޲}jF?޲ƆfSg?~>o?|j?|-?{ǘ?{Z?yx|H?yxJ?w56?w=?vIl?vIk?t7Ea?tA?spb?sy?q5?q>`v?o.V?o>}?nUzF?nU9?l.?l\??k'go?k'p_O?i<[>?iE?g8?g>i?faO~?faa*?d́l?d=0?c3~?c3?%?ax?agt?`xH?`y?^ncv?^nl1t?\Q 
?\Y?[@A
?[@Jj?Y5?Y>l?X-~?X5?V{'Z?V{0I?T$ܺ?T-D?SM%~G?SM.N?Q)?Q2D}?P0x?P9nHc?N;&?NC]?LH?LQ_?KZYtn?KZb)~?Imv^?Iv*?H,?H,c?F"?F^D?DӚ?Dł?Cgݷ?Cgj94?Aۃ?A
9?@:)<)e?@:1?>SڞN?>\?=0?=hw?;uԘs?;u:?9;?9y?8H
?8H'1?6Y@?6bR?5'D?5p?3٭?3ZK?1z
6?1''?0Vf?0Vo<?.R?.-?-)?-)	D?+RD?+[8d"?)͹a?)x_?(e[?(e	3?&\85?&d/?%7co?%7
e?#?#&A?"
?"
T	:? s? s{^?YYC?bC?F5RN?Fv?d?vb?E]?N/?WQ?
e;u?
e9h?t旱?} ?
9
+?
9@6??E{?Gj?PA?u?uT?ߏ!?ߘb8?I9?IAJ?y?`!?
?n?IIΪ?Q2A?>;;?f?{?G?/
?{&.|?{ǿ#?~?`?OPPj?O\9?j?s5z2?#Ug?#]7?CP?LEQ?5s?>	?a*-?a3M}?#{X?,?58?5(Uh)?ڟ*?ڟ(,?	"|?	+dm?s)oX?s20B?3?l.?>t[?L.?TbԌ?0f?8t
?8-? =?bkN??Y
?Y?	'?	BG$?1T?1?O.?)?	c@?	Ey?u?u_!?(?E?M@?N陡?	{Կ?	
?&{?&&Ё,?7???TIP?]!`?jvG?j~hF?֛}?֣?ByB?BU"???$h-?,?ZR?b?ia?󜺄?_ҤJ?_L?/?R?8[v?8c?褦2
X?褮?ϐ?R7?}G?}PKR? ?n~?Umh?Vs?Y?b1?.?.Ԣ?ݛ%X"?ݛ-??V0?li?tO?t	?um?~(?Ls?Ld?չkFV?չs‡?%M}?%7?Ғq?Ғy?2?E?k'R?k2??"?Dd?D;d?ʱJA?ʱSB#??Ұ?NJYX:?NJr?3b?;j?cީU?c[?Ў.f?Жr?=A{(?=J7?ܿT?ܿ;?ܾI	?ܾ?ܼvi?ܼ)?ܺ;Ws?ܺD
v?ܹ]?ܹ]
6?ܷg_?ܷڨ0?ܶ6!L?ܶ6a?ܴz$_
?ܴdH?ܳTq}?ܳ\h?ܱ}3	n?ܱ};H=?ܯf?ܯ,\?ܮV??ܮW\Y?ܬ蜦?ܬL?ܫ0i?ܫ0H?ܩ̆#,?ܩ?ܨ
p?ܨ
/P8?ܦw:+?ܦw!?ܤˑ?ܤ?ܣQDt?ܣQ?ܡ?ܡO9x?ܠ+;?ܠ+u?ܞb-?ܞ?ܝ	?ܝ&?ܛs$ƾ?ܛs,kH?ܙDTw"?ܙL?ܘMh>|?ܘMpuFhealpy-1.10.3/healpy/data/pixel_window_n4096.fits0000664000175000017500000102060013010374155021756 0ustar  zoncazonca00000000000000SIMPLE  =                    T / Written by IDL:  Fri Nov 29 16:12:12 2002      BITPIX  =                   16 / Number of bits per data pixel                  NAXIS   =                    0 / Number of data axes                            EXTEND  =                    T / FITS data may contain extensions               DATE    = '2002-11-30'         / Creation UTC (CCCC-MM-DD) date of FITS header  COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy  COMMENT and Astrophysics', volume 376, page 359; bibcode 2001A&A...376..359H    END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   16 / width of table in bytes                        NAXIS2  =                16385 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    2 / number of fields in each row                   COMMENT                                                                         EXTNAME = 'PIXEL WINDOW'       /                                                NSIDE   =                 4096 / Resolution parameter for HEALPIX               MAX-LPOL=                16384 / Maximum multipole l=4*nside                    COMMENT                                                                         COMMENT                                                                         COMMENT                                                                         COMMENT  Contains pixel window smoothing factors                                COMMENT  for temperature and polarization for NSIDE =  4096                     COMMENT  for multipoles in range [0,16384]                                      COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / TEMPERATURE pixel window smoothing factors     TFORM1  = '1D      '           / data format of field: 8-byte REAL              TUNIT1  = 'unknown '           / no unit                                        COMMENT                                                                         TTYPE2  = 'POLARIZATION'       / POLARIZATION pixel window smoothing factors    TFORM2  = '1D      '           / data format of field: 8-byte REAL              TUNIT2  = 'unknown '           / no unit                                        HISTORY                                                                         HISTORY  For NSIDE <= 128, the T and P windows are computed exactly             HISTORY  by averaging the individual pixel windows.                             HISTORY  For NSIDE > 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ??B%b???(?iT}?x?J?/?o}?O?ܐ?7q?xi???y?o??X???n2?ps?Sٞ?V?7er?9D{??݁?݃ŎU??B.?ܐ3-?ܒs?ѻ)??La?1!?}?l?zd?BI?[E?o??Ч?W?&?\,?לw?J?‹?ҨZ?Ҫτ?ю{F?ѐZ?rdH?t?T%?Vf?4!ե?6b??5v9?X?X'C?P?Α?ɧ?ɩi>?Ȃ(?Ȅid?\Pc?^1?6e?8?j#(???N?-?Po?	s?JAG?NJW??^>?`QA?>?A?!?#B?h?	U?E?g?ڍ?΄?d?ˤy??:?-?0?Ιb?ڧ?l4>?nur??	!l?N?˲?3~A?5J??Do?U.?X?M?.?m[0?p'?q$?S?|ǝJ?h?D;?}?ﭨ?0y ?ƅY?P?F??J??k?~?Z??]?sPǿ?u??N?d?g8X?+?l4?Tǧ?Wr7?-?n?CԬ?F?Am?7?3
EV?5NN??М?$Þ?'h??\o?L$??NA?PAث??U*?Tru?֕;?ڲ?-?N?P㯡?}Ǎk?}V7?{r?{_?y	?yǰ?x"V?x$Z?vQ#|?vSc?t}8*G?txp?r,?rG4?pΒz?pa?nm?n"5y?m9?mz?k8-?k:?iWŒ?iZ6?gu?gw]?e_?ey{?c8?cyt?a\}?aǝD?_l?_F3=?]}Q?]?\?\8?ZP?Zn3?X0_?X3%?VCG?VE
%?TU?TWٶ?Rg9?Rize?Px{?Pz?NpL?Nw?L?L#xx?J|4N?J~tт?Hcd?HeKr?FG,?FJ?D)*B?D+kx?B	K?B	??!x??b=`?=
?=N`?;74?;x[?9eZ?9gY?76?78G?5 T?5am?2~?2V?0?0?.bY?.dS?,''d?,)ht?):?)T"?'Ǡ?'$_?%i?%k!?#&wP?#(޾? z? ??1?R3?Ts?!?
Q?e?Am?oR?qX? ?#!E1? ?a?Fh?`b?.C!?0?	A?	݂_?vZ?J?/i?1U`?U??DM?G0
?5;?v?N1?P??%?B~?L"0?Nv?l~k?ɭ=???A?X?'?'?)sr??(?r?|?p?rI
?_?۠??Nv?B
?ܣҙ?ܦW&?q?ٹ?e_?g	??%ˏ?cò? k?wָ?z B?eN?ѥè?%Ed?'O?x4?{/?U?\o??R?j
?lv??"I??%Q?NoT?Pm*?C1???-\[?t??7e*?99?_?aٺ{?
6??g?`?؋?E?;d?|?ʍ?E?<??&?)7?86?:̀p?G?Iھ?T
t?VKJC?]>?`;E?eA?gY?jF?lڇu?m_?o?}mv?}p!-?zl	?znJS?wh?wjFH(?ta?td+>?qY?q[ᱽ?nOL?nQz?kC?kE_n?h4?h7?e$y?e'?b*r?bT?_?[N?[I?X?X_B(?U@?Ul8?R?R{?Op~9?Orc?L<6?L>?Im?I8R?EC?E΄C?B?B??P=??R~?<9M?<Ou?8Y6?8A#?5),?5j5?26.?28ߋ?.x?.븼P?+@?+ݎ@?(G5׆?(IvJ?$$?$eO?!-?!@?@=?CL?Tk?敊>?U?*?$^M?&??6?
[E?
]?	e?	$?L;?f?%?f`??#3?>l?@?P?Αa?X6Aw?Zv??]??j4J?lu??ԕ?u'?wgK?|?F(?TuO?V?ܾ!7?,̪?&wO?(M?Ջ'?Սh[?p?0y?Kq?N?ʧ@?ʪ<}m?N?U?W핧?Z.?P?,??(&?SK?K?M?q???PT
?'w ?*;8?ll~?nS?\??ӳ?q?[?]F?2e?4?=?	ڿ?
цP?
"??Z?vM?x}?A˞?D:?3?
t+r?~O?Ծ??n?[)?]FĐ??m`?ZT??l?nF?t?
?׼~s?׾?`iRD?b?w??ʟ?ʡ
?;#?=Th?Ӷ??iV?k͒?x??&B?g?:?!H?-?H?.?0A?w?q&?7#?: ?Y?n?7?9\^O??YŸv?Y(?U@f?U?P`eK?Pc?K?KՒ?F`
2?F?B8;4.?B:{¹?=z:F?=|{N{?8ju#?8?3V?3?//N ?/1;T?*f?*h[}?%%?%fRm? zɬ? ͻU??^?&
j?(Km?OZT9?Qd?
v-?
xLt? y?a?]??ں?px?=a?}?@@?\?(ө"?+1?=כ?@=`?P^6?SH?a2g?cs{ ?oI?q{?{?}U?҄?҆06?͋`?͎?Ȑi%?ȓ(?Ó3?Ö??F?|LfD?~.?j邥?m*4?VR?Xd??OO?A?%-?'n? Ӑ?
aV?8z?xL?ejx?g?R?Ғ6?8|?:-?!q?a??]m?aq?cr?@,?s?|?	?s3v?usp?g%?˧5?)?jo?nnY?pɧ?I?!]?	??{Sn?{V?u?u
?o?o'd?j#?j&6E?d\?d_?^?,D?^?X?X?R3?Rt'X?M?MG)?G@y?GB?AeD'?Agj?;2?;sO?5ER?5?/‰;?/ml?)8?)@Q?#?#T/??G?J?`?&?(P?1b?4?:?=W?Ag?C[l?D?G1T?Ec?H?DTsV?F?@2?Bs?9X?;μ?0]?2W?$`?&%B?u??͔?	/?6?4?#yZ?cچ?+&?lO?[?S?-T&?m?g>?j(9?<=d9?>}=?
c?? k?L~?/?N?p?r[V?55?8?yj?y5?s?s?mui?mwB?g00?g2PB?`@?`^?ZN88?Zg?TNEQ_?TP?M?M+?G?GEM?\C??YA? 9?\m?Y?⏙x??@y?Bw?~?T?*?k:?I\z?L?BS?p?}9?}샥?w:
?w?
~D??a?e?2?10?q_B?rr??~?
-?=d?}?? ?#l?%ē?%,v?'l?$S?&V%? 1y6?"qY?t?2%?+?+Q?q?=?N?ǽu?w?@?&iT?f}?\e? ??"=?~>e?~~j?w`IQ?wc-y?p>j?pA.U?iUD-?i{T?a!?aa?ZV~?Z˖ˣ?S',?S<\?Ln]?LpO?E&^?>ʦ?>
?6?6\ؕ?/&?/f?(]~[?(`?!(#?!hH8???Ӏ|?h_!?/?6+?8\U??%?=Ys?}?8?:ֹ?>]?~+?d?0X? iz?#?׽~m?X?W8?Z8d?Z*|?V\?辌?(?=?<?¡P?˞?1
qh?3J/???
?As6?C?ŗ-?U?G?IX??%?~B
?~DJ-?v/m?vU?o2?o4"?gY?g`?`p?`ڔ?XC?Xg?Pck?P?I^?I`?A?A\_?:+5n?:-u?2C?2e?*?*?#5?#786?س?ҫ?
N@?Mm_?#V5?%?l?n?;V?{?دm?`?7?9?un,?wˊ?ݰ?ݲf?'?.B?k&v? @?Q.?SV??G?1?qh?؛??N?ڌ?%O?'?Gk?Iցr?g7F?iw\b?,l?l?y\??w*2?wjF7?o98]?oyK?gݰ?g?_;?_?W??W+Q?P)'?P:}?H
T(?H+d?@\t?@l?8FP?8U?0
0?0
 ??(u?(1??N?@7?怴?хm?z?
??Y9?E??5!?i?kp?H%?J?$sj?&|?D?M\?Dr?քد?Ƨl?ƪ#?x?z?F`B?If?:?^@?ڮ~???ɹY?c?eN?$?&\# ?΄?%ь?|?|DM?tUy3?tW4?lQ4?l
|?c?c˲?[o(?[qh?S2V?SrVc?JȪ[$?JZ?Bq?Bsi?:M?:2Kk?1?1T	?)Q?)SS^? &? f?|=k?~}g[?
d?]?X?뻍?'bp?)A\
?pN?S?5 ?7B?巹?z?7@?9z?Դ?Զ{?.\X?0R^?æa?èSVs??i?dZ?󲎣?aX??g??i2??^d?7%?:?槈?&?~<8H?~|(?v[?v^?mג?m;?e&9G?ef(?\gm\?\j[?S	?S
?K
4d?KtS?B[z!?B^?fs?99?9y?0ܰ?0?(8#?(;,Ğ?y?{G̎?k?KU4?
E?
\?!;4?#{?Sj?Uw&??̛?-F?@l?p?ڰe?z?Cua?"?$&?CWt?E;?a}?c`?|y?~\U?f?@,?򣪈H?hn?E?򚿅4?:V?z5?c?ܣ\?d??vM?v+?mxy{?mV?d'?dR?[>1Z?[~
s?R?RTʃ?IB??I?@h?@g?7֟?7D?.J?.4?%wK?%#Z?v???o?$o?
wu?
yY?X?[	B?4
?7?
T?0?X?P!?ܷG&?ܹfI?Ӈ?ӉՍ?Tm?W4?f?p;?!n??Ex?񮫼
??m0?o5?,4?.ٺ?辗"?e??V?XN?Z%?wVPf?wa?mIT?m 6?dkr ?dmy?[,:?[=?QzM?Q-?Hed?HgX??b??
̣k?5?5EO?,FD?,I
v?"?"ä?zH_?|?;9?F?T?\?32*?5?p+?ïY?Lx?Nb?Q?ב{?Wfn?Y*?~}?־=?N?P6?ڣ?bi?:g?<]qt?{'?𧭺?5?'?mܮ?𔇭??Vs?Se?V?w?wր?n7?n?dtȤ?dvGJ?Zdf?ZФ?Q%?Q(5|#?GzP?G|%?=̪n?=k[?4?4?*h@Z?*j*? ? !y?ȃ?7"?
<?
?/u?~_j?G ;?>"{w?4!Z?4#3?*`H?*!? ? Vn?e??	?WI?V??e?}_?*?jO? ??٬?ٯk?ϑj?ϔ3?tf?vW?TVN?V\?1$/z?3cy?wPE?
?t?Z
w?g?Nl?_>?b`?~Z	
?~\Iu?t'JT?t)S?i|?i󻬵?_`?_?Ut?Uw=F?K1Yq?K3?@4?@aK?6>+W?6}?,T4?,W	^?"m?"?+?k|?
^p?
`A?ڎ?5hJ?
cP?LR?MD?O=D?p?x?ى3f?ًr?"?%'?Ĺ?ļk?M)?P"
?+ ?k?mA?o>?jg??퐂dǴ?퐄M_?	$?
َ?{?{Vr.?qbz?q?f?fd?\8?\xM	?Q~k?Q}?F"?F2??褿n??ꭨޠ?꭫Q?fb?hc?!'?#g??v?~?ꀎ"3?ꀐp?uAb$?uCq?ir9?ia?^؏?^?SFr-?SHu?GP?GM?<;we??l;_?l=~?`b?`e?T5x?T)\?H9?Hx-?<Ʋt?<?0U2,?0V?$%q?$dAi?%s?d?
$R?
&A?4Q?6s?BY@?D?M-݈?OlM?U??W?Z?\?]$?_c?\|?_?\]?T?V^?L4w?Ns?A7^?Cvw?}3l?}5Dž?q#*k?q%iܺ?e
=?e|m?X?XИ?L?L\?@?@㦖?4;2?4z=?(j?(m&?A?C,?>??t6?F*?F>?U??n?HZ?J@g?
v??%\?G0?溏G?溒Rk?L?N*?ˋ?	
?敾
@?L?r!?tɚ?}$3?}&r1?pFP?pYK?d2?dq=?ZTs?@4? Z^?_E:?=??]?Pd?N	?ڻS?;?%bZ?'A[?mC?o?䭲`c?䭴IK?a?F[?4d?6f?qKZ?s=~?zy?z[?mk;?m9L;?a%?a??TI;?TL?Gv?Gx?:?:h?-?C?5	?ۛ{?۝I?tIu?v9?J^^b?L!5?}? b?l?-?♵md?♷%?|݁?~J??O?A#?rx8?r?dL?d_?Wy6?W{uN+?J14?J3r??f9?fɿ?Y9>?Y;{?KA?K8 ?>;L?>=D?0y!t?0?#2w?#4?
?T?ӣ?!G?]?^|?hn?^?az?c?ơ?c?(ܙ?+8?ඈ&?ඊe?.?*?>?@G`
?[??G?l?r9u?r;X?d6?d@Xs?V"?VS@h?IIZ?I?;_,?;ae?-'?-f:??z?O? H?Xnn?Z??0*,?[?ƚE#??:9.?$
?'{?߿P?߿S#?߱z/S?߱|nV?ߣ5?ߣV?ߕĀ_?ߕƿh?߇?߇xG?z/?z?lky?l!08?^8Hw?^:O?PNpy?PPxC?B_w%?Bam?4l?4nD?&uŏ?&wGg?|HG?~p?
?
Ex?;??~(?i?yV?{ӵ?qo?t?gP?iPA?޶Yd
|?޶[o?ިH{?ިK`p?ޚ5lC?ޚ7?ތ$?ތ!cp?~z?~B?o
gS?oHP?a<?az{?SY?SEY?E(?Efw?7]䅻?7`"?)32?)6p5?W?	.dZ?H?ن?ڐ??o~?q?7?9r?Oz?,}?ſs'?8)?ݷ<?ݷz{?ݩ	?ݚ?ݚ?݌6?݌u?~`L]?~cY?pc?p$r\?a6y?aPp?SbOrn?Sdc?E?E	
?69$?6@?(I'?(K? ?R	?U???~?p}[?8?;u+v?=O?ɝ)S?ہ(?T?W&i?ܴY?ܴߗQ?ܦb\?ܦe4"?ܗR?ܗX?܉eq?܉gĺ?z|?zb?l]4?l_M{?]Ԋ?]h?OI>?OK}7@?@ a?@_?2*?
:?2,}V?#A*?#ӌ?#+?au?fm?i1??AS?,Ph?.?ڊ)?ڍ#?c?J?۽?
?۽B i?ۮ?ۮDI?۟E?۟S?ۑ0B?ۑ2^?ۂzf݁?ۂ|?sZw?sØ?e]X?e?VFy?VH?GD?G?8L?84GS?)^J5?)2?->?0$1?`?b?R?2?Bn??Pa?鎕?=??2K?5*?ڳTv?ڳVGk?ڤs.$?ڤul?ڕ?ڕWf?چ1*?چoY,?w~2?w_v?h~?h:v?YV?YD?Jf?JJ?;o?;?-0O?-n|?	?(?U?{?X"?"}%?
P&?J?z?C?̪?
{?4?r(?ٴڭk?ٴ"?٥5]?٥s?ٖ_?ٖ|?هm]?ه?xwG?xy3;?iW'?iYec?Z4"No?Z6`g?K8Um?Kvm?;j?;稜?,T?,!v?0CH?nXX?YKP?\_N?%
?'?i??x.?බ??w]?ymO?8?:P#?زG?زUw?أkF8?أR?ؔh^?ؔjـ?؅?؅ F?uRV?u([?f}?f?W,NR?W.Z?G\X?Gؚ\?8}R?8A?)".?)$l?vP?:y?
c	?
eGr?[@?AE?_?^?)?,4e?̺'Ɔ?̼e?׽Gi?׽I?׭Ѿ?׭?מY)yN?מ[gsc?׎ݫg?׎e?_D?a?oye?o6p3?`Y01?`\%?PҸ4?P)m?AHȌ?Ө?ӘRzFU?ӘT?ӈ?ӈGY?w>?wIx?g{?e?g?WV	:?WXGc5?G>K?G ?6Ɖx?6"?&z}8?&|Y?+?-դ?Ր?7?:\?xs?-̻?0
`?ӈ?ŻZ?vq(?x9?ҴX?Ҵ?ңB8?ң?ғNP?ғPr=?҂s*?҂B/?rz?r}(f?b
i?bFt?Qcs?Q?A(?A+3Y?0ȐX?0(? 9K? <?,}?j???As??㦐?5Fk?7|?ͪB?ͭ6?ѽ?ѽr?Ѭ\m?ѬZ?ћA?ћ?ыd@
?ыf̡?z˥?}?z?j/?j2?Y4\?Yq*?H\?HF?8K9>?8Mw=?'?'.$X?&?b?LDL?ODž?w?(?7!R?t1?4?6/?|RaB?~?в !?в]!?Т
?Т\p6?БBMY?БD}?Ѐ~6k?Ѐ8?oA.$?o~?^
&V?^J?N#Ka?N%I?=TH?=Vs?,?,??r?Zw?
fh?
٤#?b?.?!
n?#J???Bu?Zu!?\:?϶rD?϶tW
?΄-+?΄/ׁ?sk?s8?aN?aN?PȜ?PT??YvG??v?.wOk?.y?J|t?L?#?!?舔?	?hS?鵥?{%?}"?@햃?C*8?Ͷs?Ͷ%?ͤNJ?ͤa?͓w?͓z4V?͂.{y?͂0P?p?pJ?_iu?_i?NAi\k?NC??w{x?ʳ*?ʳD;`?ʡ(?ʡ.(?ʐ)n@?ʐ+>}?~_:?~aw
?lH*?lTh?Zu?Z[?HҺc?H?72?7퓬?%CI?%EP?hb?k:Y?j??,?H??!(??,?ɹ2>?ɹo?ɨ
3
?ɨ1r?ɖl?ɖ!C?Ʉ.bӯ?Ʉ0ϐ?r:1`?r<+?`D-?`FI	?NH?NK;?3y"?>5c?+K9?+
?6?9?K[??.ݫ?1f?ᦗ^?ԙ?|ݶ??żC?ż?ũ?ũ ?ŗi2?ŗkn
?ń?ń?r9f?r;>?_x?_З?Lĕ?ME?:]+b?:_hF?'ɹ?'g??݃?g8?i[?V&?:y?g?
?YP?[P?ķ!?>+C?+Ϫ^?+3?5?c?%?bx?3?ܹE?M?3?2[?o/?¹O?ºl?¦?¦?“:A?“v?€	?€FQP?m	?mR?Z?Zq?GW?Gx`?4~?4>?!i?!ks?Hz[?J?$?&È?
?ˀy?Ӵ,?"?O?2P?wUu?y_?D?G!?u??t9?tv+d?a =?a\?N^,?N`i?y6,?f7?ftOv?S7|?S9ׯ??_??Ԝ?,jIC?,l&?qF?q`??Sg??".?ީޑY?ެW?0qw?3-?￷c?￷S
?￤6UF?￤8?￐X?￐?}0x5?}2[V?iy?i{?VZWk?V ?B"?B^?/
9??/Iz?n?pV?I?څ???A!??RT&??"?ﾹd|?ﾹfP-?ﾥmR?ﾥ©?ﾒN ?ﾒĄ?~o?~r?jIy6?jŅ?W?W(>?CaM?Cd~?/?/
?
9?F{?:|C?y??=E???RS?+<,?+>Bt?7b0?9l?0fd?2mg?&\@a?(Go???	e?j?ﻲ\
?ﻲ?ﻞ``?ﻞSa?ﻊ?ﻊA?v*?vf ?b|?bz?Nq?NsZ{?:M?:P,?&(G?&*<@?KO?G?O?ԋ?O,?飋!P?maj?o?6O?8?ﺬѤ?ﺬ
,?ﺘ/a?ﺘkP?ﺄ?ﺄ?p>?[~?p@{G?[ߖ?[-@?G?GR?3e?3g?ӟ8??
?
G?sj?uۀ?f?){?Ø?0?ﹹgnh?ﹹi?﹥ly?﹥
WQ?﹐G?﹐$!?|A?|D(ѯ?goC'?gܫ?Sp#/?Sr_8????C=?*׸?*[? g?"e??#?2~?4XT?طS?ع#?9?;?︯o?︯O<4?︛5&1?︛7A?︆?︆Dz3?r%'9a?r'c?]?]?Is?IK?4q:6?4sui??Xc?@V?BWz?4a?p_?i>&?,?`)?bD?ﷸ3m?ﷸo(?﷤G?﷤N?﷏g2?﷏iyg?z[~?zH>?f\&?f
?QT.?QV?-?6A6?!	W?!D?Gr?R?ǹ}H??_?᜛d?j7?lsHg?ﳷ7Gt?ﳷ9]?ﳢA%?ﳢ˲?ﳌ?ﳌJq?w0?w?bO"q?bQ_?M?M0^t?7;?73?")?"@Y?
5)g?
7eW?fMT?衲?┿a[?K?@2?Bns?ﲷą?ﲷ?ﲢs?ﲢ`?ﲍ1@?ﲍ3{?w0p?wk?bnA?bp|?Mtܚ?M
6?7?7p}?"4L?"6d?mI?,+?T?V?/??iԪ?l?ﱶ"3?ﱶ]?ﱡs?ﱡu?ﱋC5?ﱋ?vrV?vtW
?`&J]?`a%?Kea9?Kg?5?5?2ve?2y'?9z?to?{[?ݫ?Y,,&?[g[
?۞ԛ/?ۡȍ?]?׉?ﯰ!V?ﯰ#٥?ﯚ^?ﯚ`7L?﯄X6?﯄t?n$?n`w?Y?Y3?C6P?C8i?-e#G"?-g^h=?#?^/d?K6?T?ࢲ?8?):
?dU?$ބ?'?ﮪB?ﮪEl?ﮔ]?ﮔ`	J?~v/Y?~xjn?he?h?RmS?Res?<]H?8P?靈@?列PR?列Sؿ?礪`5]?礪bp@n?nlv?noh?WvS?Wx)?@}J?@?)?)G?0FH?jB??d?}%F?՟?v]?x2{?略l|?略o p?寧`bW?寧b6?賂QY|?賂SQ̻?q? ?qAEM?Z(/?Z+..?Cb?C6?+??+Y?^b?ԙN?-??6?p?a;r?d?露6?露8(?嵐j?嵐
?契j?契٥6 ?r(?r@?[l?[oI?D3F?D5?,ܚ?,p?W?ձ"?u?w)?0
8?2`?Z?p?Jq~??P?S!8?Ã??r!?ro?[W2?[Z~?CAr?D|?,ؔ?,c?E8'?G??:?;?e??T?8??=ZY?D?G(V?r?O?qc4*?qeo?Y{]?Y?Brv?Bu?*ZP-?*?vD?y0yy??
3?o9?qk???\[?^?&?$SK?>P?@?n=?n/?W"?W)??{hp??}t?'l?'L?@(?BKQ??.?yq+??S+?Ufo?v?I?"O?\?Ld*?NC~?jڨ?j?R䃍?R潢y?;,`?,?;.R?#quz?#s?t??A	?{?/Vv?28cv?i?l.	?%"?_?Փ6?/?}:?}<@?e2?e4?M\Of?M^X?5!3?5[4N?ͬ?JB?!r?[p?S?荠??ݺS??T?/r?1i?Brƒ?D?vRW?vTk?^_c?^a?Fi6?Fkx?.p?.s/?u'+?w9?w2?ylm?vȔ?xO@?r$?t]?ka3?mB?a4?d1?UqE?W(?nFC?nH}{.?V4K4y?V6?>-?>!?&d?&
.?
8F?
?~l?Ҹ&?ݰ?ݲs?ō?Ő(J?h%?j?@K(?B?}?}X?d!?d[O?L?S?LyN$?4{|?4}q	?BH?E±?O?	?H?'G?Ӈd?ӉU?CB?E?N?F-?Īi?i?rf?rhR ?Z?Z?A9e?As?)ot?)q@-0??;_=?'w?a,?^y9?`? ?6??WQ?4?66?~ˤX?~ ?f_f?fb"?M_?MR?5V?5I*?O?.p??Jc^?h??ӞP?ӡ.V?S?!4?j?4??@W?qUc?q}?Y?Y1?@tuS*?@v?'2?'l,"?M?OKcm?CG?I?.k?g?|s3j?~?ج?8?8d%?:?{QJ?{NN?b{?b'?Jd\?w?7h?q?j]l&?j_SO?QR?Q"|?7gU?7u?,?ed?Q
?SF??H+?Ҹ2%?Һl
%?gx?iJ?᠙??o???md?mfXx?T?T
4/?:8?:4?!G!?!IZ5,?t ??z?}(?
+?O?k?x?3l?5)]??ӡ?oJ
T?oM3M?UҊ9?U@??2?N?&]??t?Ŭ?D??d?fg?}1%hj?}3]Q?ar?a?FS?F÷9Y?+r~?+a?FX?H7?R?*1?~p?¶N?y>5?{v?/2?1j?]l?E?l?l/?Q@X~?QB?5+?5bL?8?oG?8X?:p?,?9?zz?|E?ns?7P?:?~
F`?~?~co?~c!?~G(s?~G`#i?~,m?~,oI`?~W1?~ݜ?}L2?}Njf?}ٷAQ?}ٹyzE?}O?}!?}"?}#z4?}J?}ƛi?}kGd-P?}kI}?}OlT?}O9?}3?}4u]?}V!|	?}XY_?|i?|Q?|[>?|?|KY?|N	}?|*#@?|a?|r?|?|r(?|r*u*?|Vla?|Vn?|:?|:#rG?|xd7?|?|'=S?|)u%%?{^Y]?{`
;?{˒?{˔8z?{W?{7r?{]?{?{x=.?{x t?{\G?{\IO?{@m?{@oR?{$H?{$y?{?{?z$d?z\>?z?z<%?zd?z+?zݪ?zJ?z}'a?z}*5?za7ko?za9?zED%.?zEFB?z)MR?z)P>?z
Tޗp?z
W?yY?y[N0?yZ?y\?yY%Q?y[]?yUβ?yW8*K?yN"?yPI|n?yeD\b?yeFM	?yI7?yI:u?y-(b?y-*۵?y?yg?xؖ?xV?xNQ?x?x?x9k?x4?x/C?x+?xb?xhm?xho?xLFiS?xLH?x0??xuZ?we$?w?wیJ?wێ8?wW-y?wYd?w?w!	O?w?w?wj~e?wjϲ`?wNd?wNf?w2!?w2#O?wڝ?w:?vT+H?vWM?vE:'J?vGqQP?vR?v?v?v֫?vP?vRTЊ?vk0?vk	u?q0?q2V3?qdu=\?qf?q8u?q>?q)?q?q>?q&̵?qeKj?qex?qH>	?qH@@e?q+_ ?q+b"~?q~?q+te?p'`Z?p^?pԴߴ?pԶ?p?p??p޻R\?p?p}`?p}*?p`,{?p`?pD?pD?p'??p'vl?p
?p
?oވ?oы}?oBl?oW?o?o?o?oQ)v?oyԸ?oy
y?o[r*?o[:?o>o?o>8?o!ޢ7!?o!?o:J?oB?n細?ns?nʛ?nʝqS?n?n/?n`W?nc1d?ns?4?nsA,?nVV9V?nVɤ?n8aQ?n8D?nʬ>?n"p?m4n_?mj?mnV?mq5
?m<?m>N9?m?mx?m4M[?mjF?mlŃ?ml4E^?mOP4?mOS&?m2?m2EwV?mW|>?m̍?lʦ\?l?l8l@?l:W?l;f?lrW?l8?ln?lHfz?lJ?ld,.?ldz?lGP9B?lG|?l*?$?l*AHN?l?l;b&?k+д?kb5?kD?k?kj?h6?ho?h)q?hi3l?hki?h^n?hۇ ?hxI?hyU?h[F!?h[HX#Q?h=.?h=df?ho_?h߲ͥ?h	j?h?gEa?gG}4?g~.D?gƀHN?g
@?g%0?ge ?g1z?gm?gműZ?gOFah?gOHzS?g1qm?g1sp?g?g3?fC?fy$?fTq?fA]?f9?fG[?f]?f!?f~9}?f~<i?f`P
t?f`RE?fBdp?fBfHo7?f$t?f$vx?f!?fWt?e?e ?eʔ?eʗ?ev?e3j?eKӀ?eō?ep4?ep$?eRt?eR\?e4OP?e4?e[E?e/M?d}?dϮ?do>?dqA?d]?d_C?dI?dKڼ?d2ݪ?d4ʼ?db ?db?dCRa?dC&?d%(?d%;?di?d$?c?cIcF?cnrB?cp?cDC|?cFD?c?cϲ?cp?cp-?cRIk?cR5?c4~??c4?cFKS?cH?b^?b
!u?b
E?b@H?bM?bxp?bI?bK¤?b?b?b`j@?b`?bBjT?bBlN?b$?b$(R-?b?b/?aq.?asd_Q?a~?aV?a%;?aZ?a^8?aa4?am.?anO?aOv6?aO5?a13W+Z?a15ι?a	?aB?`]*?`_ԑ@?`P?`PA?`|Rr?`~??`h?`
OV?`ziL?`z?`\H?`\O?`= ?`=?`A ?`2?`Oj?`RV?_?_Ab?_Ê:?_Ì9?_8o?_nh?_q3C?_s㸕?_gad?_gO?_INU[$?_IP(?_*?_*T?_ o)?_"7?^턼9?^?XcB?Xܘ
?Xŭ?Xů)?X}~?X!?XK?XM7?Xh`e>?Xhj??XHu*?XHળ?X)و?X)$?X
fU[?X
h?W&&$?W([ G?W4I|?WiC~?Wq'?Wh?WU?WWF)?Wn	㳬?Wn?WNS?WN-D?W/kS",?W/m)?Wޝ?WEf?VE8?Vz?Vd-?Vfx?V8J?V	mus?V[?V)N?VsCN?VsF/?VS~?VS2?V4uI?V4w~e?V	k\?VFw?UyX?Uv=?U*^W?U,?Uwq?UF?U?Ƕ?UA?UwG?Uw{?UXIz?UXL4K?U8?U8$g?UIR?UKLƳ?Tzd?TƯ,?T=,R?T?HC?T,?T(?Sݞj5?Sݠ?S1?Sf^?S[9/?S]m_?S~o?S~.?S_
?S_J8?KrW?K~$ֻ?K~'
@?K]dz?K]?K=g'?K=j>?Kj?K37?J|5y?JH?J3?J5?J2S?Jf?JWշ(?JZ	i?Jz?Jz?JZp߫?JZr[?J9)F?J9".?J~]Ӷ?J?I3R?I64%?I؀i?I؃g?I?I?Ix2~`?IzfxU?Iv?Iv?IVdg(?IVf?I5Xʖ?I5،?IE}?IGnh?Hc?HRW?HR?H?Hk(?H?H?H?HrG@L?HrJ%?HQ|?HQ?H1W?H1?H[q?H]U?Gq?G?Gm(?G?GVOz?GXR&?Gtփ?G?Gl?Gl?GL8/?GL:{?G+~Ci?G+?G
?G
&z?Fߖh?F`?F;U?F>1?FuN?Fw?FeL?F(?Ff߀?FfOj?FFg?FF?F%>?F%@i?Fi\?Fl?EX?E㔌u?E¸\?EºHKB?E?E;m5?E3?Eg_?E`?E`Gv?E?332?A=?A>po?A&?A>B?@~h?@?@9Y,?@;?@0?@3E?@ke?@O?@vZA??VVy?>A?>Oz:?>t?>vĺ?>?>{?>?>?>`
}?>`Qc?>>B?>>p?>~?>?=|?=!?=H?=na?=~*?=QN?=&?=?=ud?=uf5?=SӰ}?=S㚳?=2?zS?=2B1?=|?=	?<Jɬ?<}v?a?<%AiE?<e?< ?;@?;O?;1?;3Kz?;|X5e?;~3}?;|W?;|Sn?;[
0?;[Ҏ?;9M׾?;9Oε?;M?;0B?:˕v~?:h?:t?:x?:>2?:@?:sD2?8.>4?8.@pP?8=?8@0D?7:z6?7?7!`?7b?7b7?7?Ѡ?7@P ?7W?7G?68?6k?6ٻ2?6پ	?6?6?6?6@L?6s_aB?6sa?6Q:Y`8?6Qnz?3_@u?3<9?37?2)N?2=?2Nk?1K?1M?1wq?1!?1?Uh?1A?1|R?1|#U?1Z'?1Z)\?17?17>0?1?1G?0o(x?0qf1?0M?0?0<@?0>s?0o?0 W?0g?0hH?0EZ"1?0E\S?0"k?0"?0?0
?/_?/b&.?/',?/N?/}?/?/uLFp?/uNiS?/R?/R>!R?//ܸp?//o?/
 y6?/
"ؔ?.ag,?.dG?.ǠR*?.Ǣ?.D?.Cy?.n?.J0?._Kd`?._Mp?.<~,?.<+#?.ؤV?.
?-?-2
?-	q?-?-1n!
?-3$?-U+?-X0+?-kwV?-kyz?-H~&?-Hy?-%w?-%&pN?-`'?-Β?,ϐ?,8?,?,?,?,
/?,wRD?,w3?,T!H?,T$?,1*l?,1,T?,0U?,2;z?+4Bh?+62%}?+4?+6Г?+2J9?+4|?+-O|?+/-?+_%4?+_'m?+<?+<Po?+
G(?+q?*?*(?*H.?*zZ?*?*?*?*w?*i?*iԑ?*FA˔?*Fs
?*#dg?*#g!d?*Ae/?*D%?)(R?)Z?)󰸒?)t"?)ȆU?)ʸ%?)s?)s9?)PiPТ?)Pk?)-4x?)-6<?)	Q?)	AL}?(k?(?(Å?(ÇܫK?(EΊ?(H1?(}+?(}]?(Y0?(Yq?(6u7}?(6w?(*D?(,?'6?'$"?'̌|?'̎\?'9D?';v?'LV?'}/?'b?'b?'?/?'?1J??'?'}?&o\?&r_??&6G?&g?&?&l?&k?&jЯX?&jB?&Gb
?&Gd>?&#?&#J?&|2?&~Q?%Ɇ,?%?%B?%t%?%@?%5/?%r'?%rBF?%Of?%Oi?%+k??%+8Ԯ?%?%&?$yqI?${0?$1?$	?$Z۪?$]	;?$y_E?$yɑW0?$V1!_?$V3R?$2@?$2N6(?$SI?$?#]a?#_$D?#Ǽsu?#Ǿk?#^"?#?#qr?#s?#\?#\!?#9؄?#9?#l{?#n˕?"V?"?"
0?";?"N8?"P?"?"-?"b4%?"bkf?"?EX?"?vL?"U?"X/%?!in?!,!?!>?!p(?].T?8=f?8s?)?+$?ﲳ??9)Z?;Z?D?/?=f?@ ?]Av?]r?97ٮ?9:Y?2!??&m?))?˚zO?˜'?H#?
x?ye?{P?]?]LQ?9Kt\d?9Mo??9O)?1?	?p#?shr?.?_o?&?(
?]}z?]c?8р<?8Ӱ	?"į?$?qIk?sy?ʽQ?ʿ@??HL%?LbY.?N>?\2?\ 3?7TT?78?}5?Ă?J5?Le8?ɂͮ?Ʌ?g"?寧?\D? 5?[h?[?6J)?6LYc?u4?wd?읊3x?쟺f	?)l$?Y??DG?~Lw?~|?Y#W{?Y&?4>IC?4@n?V})?X&?l2J?nbkF?~>?ŀnJ??0?{ݛ?{1?V?V5?1m?1?f8?Cv?P?({?« ?­L???x&4X?xV:?S@?Sr
?X?`?
3=w?
5m?
ŭD4?
ůt?
$~?
&Ǥr?
z89 ?
zgo?
U%?
U
U?Zk?Z
?5?5S?5V?7G?T?V?p?sBm?d??w?w3?QE	?QpW?+Sr?+ɂ"?5ɿ?d?i?7a?C?r"a?ɰ%??m?m?G?GĚ?!'(?!=?c?풰?.-?]>R?:
?i?ʉ?̸?cX?cLaI?=?=$??B-?xvu?zv?] =?_O;b??)?A@$'?IyW? xq?X?X?2Ԕܕ?2Ϣ?w?gk??6o?QC?S.? ?"m?s	?s?Mu?Mn?'}Rߩ?'?A~?C??&a?Ƕ??}u-?J?h7GH?h9vn?A?A3Z?{?BI?Rj?T?3]?bU??
??Rƭ?Tp?[?[!?5`P?5a{?:?<@$?>?4?q>?smg??
9?u~?uz?O/m?O1|?(}?((
?KqJ?M0?Q??\z ?^·?쫰?K?hbxB?hd?AF?A?^[?`2?ע?щN?NUd?P?F?/¶?sqp?s?L_?La{i?%t?%?
? -X?`w?b?`?̱?ĶN?[?dH;?dJj?=?=%??$z?;?jZ?VV?XV?T?ǭ?{ͲF*?{?U?UB_?.9g?.;c?k4?m?Ԉ??sd:?ɡ?E?s>?lbp?l?E?^D?`?}?ƥ?ЙڲC?М#?}X?{?n*?̝?[ްx?[ާ?4C?4r?
'?U9?^9?
;?m?7?Ş??rt?r"%?K ?K#?$l?$ *?D$?r;?`I?^?m??c:?H?`Lw?`z?9z?9بN?+?2K?먫?A?č-j?ď.^?o1?r)0#?vOۨ?vQ?O,ok5?O.c?("?(??9?ٲP?ٴ?n??T-[?V[F?d ҽ?d#??<Ů?<1??5W?vM?xƔ'?8yG?:$?^H?8?x.?x\a?Qn?Qp0?*%*Ŏ?*'X?٥o?>Z?ۋs]?ۍ*:?:L7?<?
y?;n?e6?ec?>6к?>8E$?<ˤ?jH?yP?{t/?TI??H3?葅kX?i{?i0?AA?AHab?i??L?y/p?ɞf?ɠ?硛P?硞y?yg?y+'?Qb?Q?)[^?);g?r?to?a9?cf?M;?Oh?6o?8?a:?aC?9?9?8?E0?t?¶ܒ?Ed?rV?uN?w{3?pKz?pMп?HF?H!s?7?d?w
?+?ϊI?ό2?RG?U?h??C?Vܒ.?V޾?.c
?j?CF?E]?~?!?⛒?⛔Ϫ?s5F?s7K	?J)?JLz?"r+/?"t1B?1?^*?ѣ=?ѥc?8eL?:{?mJ?̙K?XY?X[슴?/[?/舏
?pB?ro)?v?o,?{?~#%?,??e|S?e?5?OE?OG1?&&F?&(rp?q?Y?4?H?֪؜?֪~?ցOW?ց{?Xd?XfB?/5.}?/7ZW@?%??N	?zr?ճY?ճ|?Պ^Z?Պ`j?a"en?a$9C?7h7?7唲x??Q?]l3j?_?Լm؏?Լ?Ԓ1>?Ԓ?iq`?i?@1v?@3`?Ӫ?^?틈?퍴?44?6?ӚX+?Ӛ)W?q~m?q?H(?H"g?r??Xb(?ZE?T4?=?Ңv?Ңh%?y+?yE?O"?O?&5D?&7=N2?m?p?G>ܺ?Ijg?ѩJ?ѩvB?рNN?рP?VQ?V}SV?-KMS?-Myl?śP??=9??e4?а)؞?аUO@?Ї$m?Ї&/O?]?]0R?4Ґ?4@j?
k/v?
m[Cb??^?Ϸ7?Ϸ9T?ύ?ύ"-?cǯ?c&?:VwE?:X?[?i?`F?
?ν]YD?ν_?Γ?ΓmM-?TGT2?TJX*?*P?*S?W>}?Yi{?Zz?]?ɬ[?ɬ^$,?ɂZ]\?ɂ\u?XV?XXGM?.O8E~?.Qc4?EGS?G3?9eJ?;N?Ȱ* U?Ȱ,K<?Ȇ?ȆT?\@.?\k[?1D?1o?ϖ?7?ݲ7B?ݴbo?dz'p?dzRo?ljohU.?ljq&?_I?_L"?5!z?5$FQ?
C?
6?ɑS?˼F?ƶi?ƶ?ƌf$W?ƌh(?b1\?b3>r5?7y~?73]?
1*?
:?『?ジv?Ź@b8?ŹB?Ŏ?Ŏ?d?d:9?:oZ?:rD`?%
?'G?ר?]?Ļ9h?Ļ?đ4I?đ6?fg0?fᒌP?<^mZ?<?,6?.ۂ`?^P?щX}?ýoj"?ýquT?Ó*?Ó?hyY?h3?>>
A?>@7X?`B?Ԋ?d;?f+?¾-*?¾q?”2aY?”\٢?j~,?j
x??C??j?3]??\?ꗇB7?5/?`1?`U?a?k	߉?k	?@T?@H??Me?f[H1?h?0?Zb?AZ?CO@?k1T?k?A?A?u?x+C?v?١=?6]JP?8?c?ƥ`?k6$?k`~?AC,sE?AEV?}c>??+V?UI?85?:_??0N?kd?kЎ?A?An?Y~(!?[On?Cŀ?m?Y%=?ڃF??#_?kLr?kNG?@z,0?@Dn?HE?]?|??z8a?G??o?A{?jhn0?jj:??g??#?|?ޱ?V|?Ԁ?Q
?{??
ʗ?i$H?i&q?>:G~>?>?
?,B?W?e?&D?(m?EA?Gj?ya?ycg?M{KR(?M}t&?!W?!%?x?F?ɸ?ɺ??Ǣl2?4?qy?qG>S?E?E!?/C?XyM?0??v?.?-?8D?ig?i?=3?=?S>?{?-w?V8?jA?’??1?a?a?5?5
?	l}u?	nf?Pzi?RR"?1?3?u?G?Xt?X1k?,>?,??w?QG?p}?r?Ai?D?|?|6{?Oܣ?O	?#g?#7Z?lԷ/?n+?0D?3?t??O?rM?ru?Fm?Fox?' ?)@g?	b?12?Z?r?D
?F27?h?hBC?<@??%?M?lp1?nJ??=|?W?Y?0C?js_?jʛ?>7-?>9U?CL?k?P?߸`?s?u?׻??_9Jو?_;r+?2:L?2bz???N=N?PeB?O?w???SK]Z?SMH ?&?&ɫ?s{?`?1u?3J?xۏ\?{m?s2?si:?FQC1?Gy?=ܨ?@}O?y?{v??c?1r??믴?gr?g?:N?:Pۿ?
}Oo?
w>?E?mk?ҖUR?Ծ?AC?h?ZH+?Zo?->:\?-@a?]k	p?_K?yX?{r
?
?*?y۹}?y^?LK?L:P?Ϫ4?ӧ?ޠ&?@?r?:)?ǒ?]?kk?kG??D??lD?"G?I?cp??_\?/?C\?8?]~?]8?0Q[?0x?֊5;?رA?)?P~??p?|
?|4uZ?Oi?O?"fܼ?"i%?HI?Jq#x?'oY?)7$?1i?XT?mܬ?m4R?@Q?@???YE?[m5?(1zB?*X?z?5e?^"[?^I\?1',?1NV?I?K>?P3?
ws?s?̚ʩ?|L?| ?O@l?OC?!#V?!J;b??M?^|>?`?G?n*j?lE?l@k??eO??gw)?vg?M?+ ?G?TR?Vy?e8?F{?\S?\{	?/+?/.?np?ŕ}?W?Y??3?yx1?yzR?LD?LC1?E?B?M?:F?Úy?Üo?y#?A?hH?hr3?;Sa7?;zM?
MR?
t,?@??<Ћ?U?UI?'#ˀ?'&l?r?˜?Y6H?\?JO?p"=?m	aq?m/1K??&f??L3?W? ?/|!?1??S??O?Au]e?VH4?Vnm?(D?(Fw?~_]l?~Ņ?~?|<4?~A?~?~">?~n/߭L?~n2Y%?~?%W?~?Kf?~?~?}?}?}Ol?}uq(?}[(2?}]NA?}Vf?}VČy?}('?}()0?|=?|;?|E?|{?|Ec?|GB?|my?|mM;?|>S~?|>yh?|Li5?|N?{Uy?{_?{Ӟ?{t?{<(=2?{>M?{U蔥?{U?{&	?w [c?vdtd?vfE?vm?vo9y?vsS?vuAqF?vdvb?vdx}?v5wmx?v5y?vu?vw?uqj~?us?uj?ul!{?uya(?uyc=֏?uJU>?uJW8E?uE/?uH$?t3p?t6q-?t	?t!??t?t	?t^F?t^=
?t/^?t/:?t؇5?tw?sя?sђ!?sk?smL?ssDoN&?ssF4?sD?sDr?sp(?skp?r忈?rޣ?r?r)?rY4?r\
?rX#1P?rX%VxL?r(e?r(4z?q6?q?qoxsr?qq;u?q._?q0o?qk갡`?qkb?q?pP o?p ȇ^?p ʬg?op0?orUOr?oG?ol_\?oX?oe`?ocW!?ocY併?o3?o3ˏO?o?o?n%?n'?n]P#?n|?nvL^fT?nvNV?nFВ?nFY?nj?mE?mSA?mz?O?m|c?m2?mW/B?mY?mY=?m*G+?m*lP?l~k?l'?lW?lB?lpD?ls?lk?ǜ?lkd.?lr?eU;?eU_?e%м?e%s?dݪ?dn?dX?d)6?dF`?d [?de~?de)UW?d5ē?d5Η?d?d?cE:Q?ci?c:Uh?c^|?cu?cuħc?cE ?cE#q?cWF?c{m5?b?b7C?b44?bWC?bt?b;?bUȖ?bUy?b%d?b%g:?aG?aIh?a'!?a)?aN?aq?ad:?ad^R(?a4Jv?a4?aM?aq!Z?`as6?`c-|?`2^?`4'?`s?`t#._?`Cd
?`C͈@!?`5V?`X?_ZrV?_\?_t?Zhc`?Z7ق?Z7ۦ?ZN:?ZQ
?Y6?Yx?Y1X?Y4/?Yu9?YuKh?YE
ĵ^?YE_?YsPM?Yus?XI?Xl?X<қ?X>W?X̙?X?XQZ?XQWj?X!Wi?X!Yc5?WDŽ?Wz"?Wh	
?W	?W[|t4?W]cb?W^?W^'tm?W-3V?W-?VG?VI.m?V̏?V̒P?VFIS?Vi'\?Vk?Vk!\?V:[?V:]Bf,?V	?V	?Uՙ"?U׼p?U3l?UK?UwEy?UwG?UFyŎ?UF|?U?Ua?Tڌ4?TܯYU?Th?T	!$?T0J?T3??TRX(?TRZKO?T!|?T!#?S4?S*?S?S?S۟?S(?S]z?S]5D?S-
ret?N@?Nc-?NcO\?N1dw:?N1놽?N{?N*?Mϊv?Mό>N?MV?MX?Mm ?Mm"f?M;?M;?M
?M
!L?Lov?Lq4?L.U?L0~?Lv?Lv?LEі?LEL?L^]?L`כ?K)?KK+?K"8?KDQ?Kw?Ky?KO%tkY?KO'}?K\?Kkf?Jy(?J{J]?J"B?J *0?JOe?Jq?JXa~?JXc?J&*?J'@(8?I%(?IG"?I2|?I4?Iv?Iʘ?Ia[4?Ia]?I/wb?I/~|?Hz?H|ԧ?H. ?HPlC?H.?HOO?Hj?Hj?H8zV?H8?H?HL?GՙDX?G՛?Gz?GK?GrO1?Grq?GA_E?GA?Gzߎ?G}S?Fڸ?F?F\;?F^]HI?FzP?Fz6ʜ?FI3ch?FI57?F$?FF?EZ?E|a?Ec?Ee(02?E(P?EI?EQ RK?EQ"?E{?E}?DS?DuF?D)"?D+?D|l>?D~X?DXgC?DXΈ؝?D'ly?D'?Cd~=?Cf?Cìۼ?CîG+?C?C?C`5H?C`7?C.v!~?C.xC\W?B/"?B5z?Bu֘?BOo?B(F?B*hiE?Bg^s?Bg`G?B56t?B5W?BV{?BxCL?An?A!?A`S?A 
 ?AnG^*?AnIg?AzI?>||&?>d?>?>Jp?>k?>O70?>OXX?>?>?={V5?=}x6?=s?=u]?=i*7?=kK+?=U\:?=U^[5a?=#LP?=#N9?<:[N?<?)ȴ^D?)Z*v?)y?)bn?)b	?)/Y?)/X?(kgѼ?(myd?(SWS?(Uw1b?(8?(:[?(cP?(c,?(/?(/?'پ*?'ݰ?'ɵV?'ɷ ?'?'I3?'cc9?'cf?'07^?'09=?&ʴ?&
8Y?&n?&َK*?&dH?&?&cm&Bp?&coEE?&04;J?&06[.?%v?%A?%ɺa1?%ɼ4?%zfd/?%|Ζ?%c7n ?%c9,?%/^?%/g?$)?$Ӊ.?$]P?$_pF?$`?$x?$b?$bS?$/k?$/m:?#B?#bB?#Ⱦ +h?#?uL?#cq_:?#e?#b8c?#bW?#.vO?#.TY?"D'K?"FFܷ?"P:?"o?"wDV?"zx?"a9?"a&jB?"-
?"-7?!2?@???k?
?hӢ?h>q?4?4
??հW?Ry?T ?!K?#S?cs?c6=?/5!?/A?3L?QU?G&?I,??
\?8^w?^?^.	?*}t?*o?BaD$?D:?(?ڛ??6?Yc	?Ye4?% ?%?߬??nLq?p,?Ɂ?]?SvC?S?b?d
?A?^k?`?}??\?BO?M?M1eI?qo?s2?
&?
x?
O'R?
l?
|)^?
|+|?
G8?
G]?
A\y?
D
?ʈ?̦?P?R)?u&^
?uD?AU6
?AWS?F?cX?O?Qmc?r+(?ˏ?o@g?oB~`?:?:Q"?&
P?(+:?
є?
і?
U?
0
?
hjT?
hlZ?
3?
3~?	6.U?	8çd?	ʘʪ@?	ʚ?	i5?	0?	aU?	aW?	,@?	,23?&*?
C?]?_Lu??v?Z@?Z^?%OB1?%Q`Q?*?[%??@?*?F?,]?Rn;غ?RpY!?z?Կ?/?p?+/Ǣ?-MT?e,
?gI?JP?Jdž?Ѫ^??,:&?Ih?40l?6M?wab?wc?Bs?B?
Q?
n?dj?݁??	?o ?o!5?:<:?:>J?Wꝇ?Z?p?ri?q\?w??f?f?1l?1k;?^A?{j?]?+?]\6?([?(%?n?}|?݊D?ߧ(f?ڠ?ܽg?T5f\?TRC7?Jx?gR?=^???m?e?3?K?K$?:1?V]?iVo?ks2@?O ?R?w4?w62h?BS?B׹???ѐ;`?Ӭa?O?l?mx}?m&?8X6?8Z۷?+>?--F??vP?DŽ~e?ɡ?c?ce?.Y@Y?.\d?NT?!ki?5!?Q?9??Y`y|K?YbW?$J?$?Գ1?K?m?+@8?>:?A-E?N@}.?N\w?!I?4?Kp?MB?K?g?y?yR?DA*q?DC??H?ك?م?!$Z?#@a?n?n'b?9Tt[?9V?b?~a?}ŧ??k+?窙?cG?cd!?.)J3?.+f?#L?Wp?9Î?;?w?~?X@/?XBKx?"
6?"&I?;aԗ?=}?5?Q*a?,?.7?LU?Lq5??2*?kB?ᅇQ?^?i3?v[|B?v]+?@SC?@Vf?)
?+g?Ռ?Վ.?fn?^>?jK?jN?4?4X?? Ǐ?WՖv?Y)?(4?D ?]D8?^%\?(MZ't?(Ov?9?T?07??,<>?.B?Qqa.?Qt/j??;?_j?{?3`?5{?zn?zqR?D(O?D?ލY?੆?j??C:?FY,?mr\?mtw
?7Bݖ?7^?ǩ&?IJ?f?h?W??`4Ҫ?`6C?*T4?*VO3?q֏?s1h+?y?2?]?y?R?Rޕ%?˪}??>*?/?wB??zpd?z?Db?E~.?B?h??
RA?
S?o?m	X6?ms?7?7?Aj???9??6?ŋ?^O:?^j:?(|x?(ї?1?M<|?꼨py?꼪Y
?ꆑ7?ꆓR[?Pw)%?Pyg?[a+?]}5R?~~??*/?w3tv?wN-?AZ?Au٬???z*q"?|Eh?K?M[?i	?i%Z?2v6?2Ď
?D?X?y-?{>?>H?@U'?Zs
?Z?#?#ɠ?mTf?큈UP?:?<ˬ#?y˧??J?J?]E?_7??y?姽՞V?姿P?qj=MA?qlX3h?;,Y?;G<?ܾ?>?`?b?*?E?a<
?aVݐ?+@׎?+B]?n??t\M?v#?
?
Q?Qp?Q0|?/x?1=?佳#??IL?Kgo?wf?wԁ`?AY?A[3?
 {h?
;$B?^(?`|,?N?*?gZ?g\2?0ԵF@?0?Lb?N}2S?&?ðh?4M?6h%?Vej?V? L? gN?}?M@?߲c?߲~?|L}.?|N?E;G?E2???p
b?sy?ޡ\?ޡw_?k'ZW?k)u3?4~B?4d?Z?
?&F[?(W?ݐv?ݐx6?Yf?rb?ӲM+E"?>D/??T?5e?7~?Ϙe?Ϙ?a׶?a?*9f?*;o?y?&?λ2?λKl?΄'?΄)(t?LJ ?L7?ba?d̢??3?ͦn?ͦWJ?o)I?o+Ϊ?7B?7\b?Lx?NV?5|3?N?̑ezn?̑g?YHvI?Ya$?"tW?"vK?m??˳y?˳|7?{@?{#{?Du\?Dwuf?f??f
2?i?ʝ3?ʝ4?fN?fP
d?.?.D?,&?.?ɿ+?ɿ6?Ɉ?Ɉ?Pgn@?Pi+#?l|?ͅd?,n?/k?ȩ#?ȩ0X?qf?qB$?:C?:En?=??-?EИ?ǓB.?ǓDש?[?[d|?#NS?#??*?,ǥ?ƴr~?ƴu?|ތ?|D,?DI?DbA?
==v?
?V':?{?}2)?ŝ?ŝھ?eS?el5?.(n?.*XF?]GD?_.?ľHX?ľ`?ĆX?Ć9'?NOv?Nh+V?%?>??|?A	?çey ?çg5?o?o?7?7I?Ȝm?ʵO??ޅ
?~F?G?X`?XR? *Y? ,§?=
.??o?M`?Or?xZK?x\3?@e?@g?nVI?pn?t?v#?xֆ?z%$z?`xa&?`zѫ)?(v?(y?r0?tO?kJ?n
Yx?bK?dچ?HW?HY5 ?I	?K;k?8qiJ?:?%lZ?'?hX?h?/r?/?ݤ?߽$??Y?t?T?Oϴ?Odz?[ϯ?]x?53l?7>@???nz\?nH?6q,?6p$?+	g?Cj?O\?Qt??4?Uo?UB?T?lz?k?m?,Ȋ?.?tlx?t턜?<??[	~?#.W
o?#0n?0?HWW?-i??z-D?z/T?AFF?A?	vT?	x#H??F?eE??`Pp_f?`R+?'?'Ĕ?v1?a?-H?"?~?~;?F6*?F8Bt?
0F7?
G%?Mƕ?O!?X??d[F?d]?+!J?+P?_1?ax=?.?F?Z,Z?\Dq?IӼ%?I@?J|?L?ؿŔ?-?1/b?3?g&?gyU?/1IG?/Hy?z9(?|P?t??H?J5?L?L[a?]O?t:?j\v?l?=Lm?T?j-9?j!i?1vP?1xg?ʭ_?Ĕ!??4?l!?n*N?Ng?N2.?X?}/?K?M(3?4?Q?kF`?k^?30?3?T?V18?r.?,~?ɢ?˹?PCn?PG?5qR?7?g?i?R??lÂ?l?3%?3??i?>&?@̏?bt?PAu?GSi2?Ij!}?M9?OPa?P?RZ?lQ?lSYN?3PLY?3Rc?Lrw?N?F*
?H@2?=syH??z?O2M?O4dt?$9?&Ͷ??э?M?d?jsN?j?1-O(?1C>?z>?{O?]?s'??`?M`G?Mb?=??T???-??h!?h		?/졬?/?h?j??6%?8}?rr?Z?Jw`?J͍? ?l?U)?Wd???e?eE?,`g?,v?LqK?N)??(?Ei?[y?Gl	?Gn.?`_?v?I?_?uď>?wڮ?b?b 1?(u?(Nj?i	?kU?t ?
W?|?|?CG/?CI6?	N\?	dt?zl?|?ퟗ ?ퟗ6?]j?]?$4K?$6a?Α?ٽq?ힱNB?ힱP
?w|#?wڒ
?>_?>aр?;??g6?i?흑#?흑'?Xd?Xfho?ߟ.Z??W	?Yo?휫́0?휫ϖ3?r@˩?rBk?8\?8? ?")%?ŌN?Ŏ(|?훋?훋s?R\w?R^%?}f?Óqi?#?%|?횥|?횥b?k?k.?2<3?2>4??К?홾}?홾?홅>?홅@șk?K?K%`?'|??+?-e~?혞u:U?혞wķ?dh??}S?C)?D?
9AƠ?
;W'?p)L?r?5?햖[?햖³?\˾?\v?#h?#?3?5k?핯]?핯_I?u?u?;F?;9?H??|??픎l?픎?T(Y?T*n֬?A?C?X}?Z?퓦l：?퓦oc?l~?lő?2?2$??#?풾?풾?풄?풄~?J?J@?u}?%?ֹ?ֻ6?표]/R?표r.^?b?bߕ?(q?(Q?28?G?퐴W=?퐴l?z?z+?@~q?@?lf/?n{?WY?Z
Ѳ?폒A"T?폒C7.?X'!?X)7?O3?cF?Pbx?e0t?펩͘l?펩ϭQ?o&q?o;>?5IB?5^?[(?^?1IX`?3^?퍇(?퍇=?Lԝ?Lֱ?W??nGT?p\xt?팞7}H|?팞9?cI?d^Y?)­0l?)??a?_?틵D;?틵FO?{f2?{z8?@)D?@=	?t?vn?*{]?,\?튑
?튑	?W3?WH?=y?@?T~?iH?퉨MD?퉨b?n;$?n=f?3d?3&??fq?툿$I?툿&]c?툄NV?툄c@w?J]?J`?3~?H>f?ՎD?Ր'?퇛"i?퇛$?`XIO?`l?&Cg>}?&E{? ?_L?톱ZEd?톱\Y̜?v?v)??-X?-	=??2?탸?탸(G?}|?}?CRz?CTwM?Z?ҟ?۲??킓v?3?b&Oi?a괄?a궖$?ah?ay?arM?ar?a6k?a6p?`6?`G?`*W?`;?`)w?`;?`FUq?`F/?`
L"?`
ͦ?_ηR?_ι!?_g?_y?_Vg?_VP;?_M?__n*?^{?^}m;?^f@?^hͨ?^fOgc?^fQyK?^*5?^*7{>?]T?]?]>?]P)?]uyV?]u܊?]9X	?]9iX@?\c?\(?\jׁ?\l?\??\AP?\II?\I[?\eM?\vd?[г'
?Lt8?Lt:\?L7jV?L7l֛{?K?K?KǼ?KӴ?KA?KQ?KDh?KDx?K@3c?KBCj?JcM?JeOy?Jj?Jh?JPg?JPw}?Jtے?>۔?>=z?>@?>`?>`7?>#m?>#?=1 ?=4;?=/?=?=ksD?=kuV?=.)?=.D?<"?<*?R?8ۈo_?8ۊ.?86o?8E*y?8`g:?8`iH?8"j?8"ə?7S?7LL+?7Z?7j?7j
(?7,jaJ?7,lo?6na?6|?6()?6*8}?6s?6s)?65ܪz?65޹*?53oH?55~$j?5"?5?5|Q?5|N?5?)ͫ?5?+K?5w^G?5yl	?4D?4S6a?4
?4?4HP~d?4HR?4
L?4
%S?3X?3g?3B?3Q
?3QP\?3QRC?3?3 ?2?2O@?2=?2?2Z+޹?2Z-(?2\
?2^P8?1ދ7\?1ލEԕ?1r?1e?1bZM?1bhX?1%?1%
4?0.-P?00;?0Q`?0S(?0kqp?0ks?0-?0-	t?/?//?/Œ?/ǠǼ?/s??/s?/5??/5"?.h?.X?.?.?.|"6?.|%
m?.>.?.>0?.8,ݎ?.::?-?M"?-A[B?-D?-F,?-FF2?-FH!3?-F]H?-HGQ?,CHn?,E.?,>lt?,@M?,N7o?,N9}dp?,-w:?,/O?+!Q*?+#%\?+MӰ?+[?+V9?+VӮ?+?+?*/e?*=?*~4?*ċ?*]x=?*]?* t?*-?)msl?)o?)Lt'?)N?)e)$?)e+2T	?)'Ű?)'i?(ۍ$?(ݛ^?(H?(V?(l
?(l?(.U?(.Wt%?'$?'&?'?'Y?'s8K?'sE?'5r?'5?&H?&Jr?&K?&
b?&zzx?&zc?&G?"x ?"N3?"W3m}?"W5zM?";?"`t?!^d?!`r[?!g?!u?!]	?!](!W?!
}Z?!n"? dm? s\? !U? #bY? cɦ,? c֬N? %+? %-z??A?-R?/_y?iwa?ik?+%J?+'k?"l?/%?xI??o?ok?0@g+?0ME?i?k?/O??uAkb?uCx?6g~?6tK?+Y??reW?tqj?zhD?zuB?<2B?<4&l?x?X?
?꒣{?@Bϲ?BO}?AN?A}?G?hy?9(?;???F:?FG$?? #&?eb?g??Z?Kΰ?KT?
.w(?
0P?lW	?n{?ռQ?5X?P␽z?P2???O#6?Q0
???C?Uj?U??*F???6e$&?8qy?Z]?Z_9?܀o?;?ܥ?ܧb?y?2k?^㉑?^Џ?? (?⛆?.?.?0?cB?cEr?$U	J?$W?d̟?f?r??tK_?g}d?gp;?(9A?(EYo?A?1u???kQ?k?,?,$???Ն??o?oJ?0y?0|?n0?p"?_?a?sOr@?sQ~?4?'Q?)^B?K?W_?vxl?vM{?7ڿ?7a?`???`?zyI?z{UY?;TF??
>I?v?xB?CF@?ER9d?
??T2?TQ?ui?ȏH?xA??]?n~?VW?V?(?0?c?nl?X?b?Wݦ?W7?k8?mC?۔r?ݟ?Iq?K^?Yn ?Yy	?k? O>?چ ?ڈ*?D8^?N?_;?_=??]!?'7?2c1??(#?`@!?`BѰ? |$? ~/lX?6Ш?AV??x?a zo?a"?!R?!T]O?႓?ᄝ*?1U?;ŋ?aۄ?aݏ:?"6?"&?+R0`?-\q?OZ?Qb?bqX?btk?"}?"&?⯅.?ⱏ~?3S?~?b?bH?"1?"t$?C.?NB?!z?#-
?c1}@?c3T?#?2d?#A?cA?#0?#2? M)?"C$?

[??b?b?"k?"S?>=?H!?ud??be6?bo?"n?"p8?Km?Mv?&C?(?aYn?bcD?!qJ?!5?-0?7L?|.;Z?~7?aK1@?aM?!a-?!j	?7??𠭀?𠯊G?`t*͖?`v4rC? 8gK? :s?؞?t???O?_x/}?_z9?3?5L?Z??y??^Xw?^Z*?
b?l?ݺ/?ݼ9*?guA?i~?]q?]{2`?&?/?a!?cn?^1??[[?[J?G*?I4Kq?{!?tG?^?뚁?ZG?ZP*?0?vI?B?E?Gj??Xdm?Xf?r?E?}+|}?4_?
?IH?Vњ?Vg?p?-?ՓJ?Օ&gB?*?W?TG?T?Ka?
Zx?ӄ?ӆ4???Rp=T?RrF?≼?䒹?R=:?T5?`r?iD?P+?P-d?9?BP?M?3?`D?bMzl?M@T?MI1?
!>?
#d?c?́lw?ڌ??ܕt?K3p6?K5yZ?
?
W?g?p?0}?2?HM&V?HU???!ߠ?*,?b&U\?d/Z?E?E?gq\?p^G?5U
?5WV?lxI?n?ܳ#gc?ܳ+f?r?r?1?1?2?f?ۯ'?ۯ/O?nƀW?nȈ?-͖|?-Ϟ?j?rۃ?ګ3O?ګP?jM?jV?)]T?)e,?+_?3?٧ȹj?٧u?fd?fj?%:?%-??-?أo?أw`?bGO?b;?!r?!t?\Z?^F?ןD5?ןF<4?^)N?^+.??Y{?YO?6??Z#?\?Ֆ/\?Ֆ1?Uڵ?Ur??Շ?ҡ;}?ң|?ԑn?ԑp	f?P74?P9?yڲ??^@??ӌJ?ӌ?KH"?KJɃ?
X\?
	_?î\?Ŷ3?҇}9?҇H?F5?F7?0j?8r?Þ?àS?тO?тQ?@y?AEq?d7?H?оUq$?оWx?|?|N?;s*?;z+?G?IL?_U^?a[?î?îj?lˋ?l͑&?*I8x?+O;?.q?0?§]
?§_?e];?e?#K?#4?j?q1???^"LJ?^$ס?C?E?bJm?dQu?~(?oq?Vٛ?Vg????ȅ	?쿐?쿐ț?N@(?NF0X?J?P7?d?	"=J?쾉S?쾉u?Gv?G? @-?"FF?$2`?&8?콁%s$?콁'??%q??'x?"~?$ g?켻K>?켻L?ye&?yk#?7{?7
9?V[?\Ob?컲`?컲?pR?pX7?.vQ?.|7S?^]?d>?캪
p?캪^?h{?hi?&kJ?&m?M?O?칢-l?칢/r?`
!?`??fp?E'?ۿR?XI|?츙+4?츙1x?Wj78?Wl?=4_?~VZp?~[?(C?1C?R9?T?쬬:?쬬?@?j1+?j305?'(?'?|?NE?쫢lr?쫢n@?_&?_r?4V?6[K
?ڔ?ږh-?쪗U?쪗?UNB?UPD[?u#?y?J??쩍U4?쩍W8?JAU?JEB?Ȱ?gP?G?I?쨂 4?쨂$p??S5??WU?&Pj?(T?짺l3-?짺nQ?w?w?46?4
?01.?26K9?즯m'?즯o+k?l]R?l?)vx?)zkh?np?Ԭ?쥤J4?쥤L?a|
?a~W?-?M?>?B?줙#?줙rs?V.+?V0u?U?W,?yt?{ӵw?죍?죍?Jܠ?J?Z1?3lƀ?v?x?젭ht?젭l|?j?j>?'<"?'@!?W@?[9?쟡?ej?쟡CZ?^9?^?s?wG?؆?؈?잕~?잕?Rtx?RvU?hz?j~?Ye?\:?읉IQ\?읉KU?F6sT?F8w?!d?#hZ?
$?'?|6?|E?9W?9?C?FǕ?웳M?웳f?ptU]*?pvY?-Op?-Qs?(T?*X?욦e?욧?c{[?co? ^? [Y?um?wѨ?왚C"y?왚E?WM?WPs?ؾE??Пs?СG?옍ekA?옍g?J'-J?J)ߞ$?G?ke?æ?èJ/?엀c/0?엀e2?=:?=>Q?A??얶O?얶
?s>7S?s@:~?/~o?/c?잕f?젘L?앩K{^?앩M~`?e0Y?e4;?",z?"dw?E
?G ?씛5@?씛8?X.J@?X1t?*?,?ȕ?ʘ>?쓎dNf?쓎fi?J0?JF?Y?k?'y*?실|@?실~͈?`球x?`?{?َd]?ِ?슕	:H?슕?R,/K?R.Z?xC?z?@?M?쉇	Zj?쉇\?CNq?CPt!?X^?Zh?숻
Z?숻?x%?x?4LG?4N.?	|O?p?쇬:?쇬(?hv?h??%(V?%*Xf?Y>?[H?솝?솝??Y?Y?N?wd?	\?K?셎00?셎2=X?JTT:?JVVT?vyO?x{e?–qR?˜sct?~?:>?:F?PxZ?Rz?샳m|?샳k.?om?oft?+(7?+*+6?9nQ?;p@o?삣H
?삣J?_T@q?_VBWY?^
L?`-?e%~?g?쁓kq?쁓m?OnOa?OpQ3?oZ!?q[?n58?p7?쀃jඏ?쀃lz??e]G&?v Bh?v Dp?uh?u?u%?u%?uS,
?uS.y?u?u?tgv?tiw?t~?t촣?tA7?tA8U?s0Y?s2Z?sR:?sS?stV#U?stX$.?s/Z?s/ˣh?rsJ?ruJB?rt?r?rb.?rb?rnF?p>
H?on?od?oi9?okg?opJ?opE?o,I?o,KB?n#Ԑ?n$[o?n Y?n"fc?n^i?n^?n!?nܚ^?mRz?mTF?m@J?m?mL4?mL?mqx?ms+?liB?lz?l~%	q?l~'d?l9|*p?l9~ր?kѠs?kӠ*?k$Bx?k&Bţ?kkt?kkv6?k&h5?k&j?j=?j=?jYC?j[C?jX#]?jX#@?j܌@?jܼ?i*pk?i,p9o?ik+?im
X?iE&?iE&%?iJځ?iJ?h#B?h%Z?hw[qP?hw]q?h2q?h2?gŴT?gǴr?g?g?gd'L?gd)L@?gTʭ?gVB?fڀ<#?fڂ<E?fu5^?fu&A?fPЄ?fP҄?fk;?fkfk?e)y?e)\3?e8:?e:?e=W+~?e=Y+q#?dsqC?duq?d*|?dm?dnX?dno?d)T/?d)Tl?c?c0?cij?c$?cZ?cZڽ?c(b?c4?b!?b
 ?b?bU?bGљ|?bGe+?]@d|D?]l4?]l ;?]&?]&8e?\fS?\ըR?\?\Q	?\W?\W,;?\[?\]?[.F?[0
?[D_?[C1?[Bͷ?[B϶>?Z?Z?Zd.?Zf-?Zs,4?Zs.3?Z-&}?Z-7?Y?Y ?Ywn?Yym??Y^6?Y^8f?Y;?Y:h?Xӯn?Xӱm?Xh|?Xj~q?XIm?XI!l?X: ?X9b?WM6?W2?Wy78V?Wy977Y?W3,j?W3+?V0W?V?V:*p?Vކ?Qǻ=Xf?Q:.?Q<-I?Q<.?Q?P&4?O˕?O#1?O?O?OU	?OU?ObԹ?Odp?NG?NEa?N7_[?N9]Ex?N?Q[?N?O?M?MB?MeC?Mgs?MnI?MnG=m?M)$n?M)&	?L᜾?L߾r?LT[?Lq'?LX2-?LX4E?L$?L7?Ke8?KcF?K-g?K/q ?KA}Tt?KAR?Jʘ0?J̖ό?JP?J?Jp^?Jp`ɉ?J*X?J*?IXd?IVP?I,?I.l?IYmq8?IYoo?IX?I5?HO?H\c?H"$;?H$"?HBZ =?HB\_?G	?G_?Gúْ?GŸ?GpZs?GpX2?G+$Ј?G+&؋?FR<:?FT:?F}?FH?FY(?FY*?Fy?Fv?E?E9?EF|?ED?EB4wf?EB6uS?DRA?DTd?Dnq<?DpnZ?Dp9?Dp78?D*a?D*	?Ce.?Cb?Cw?C>?CX?CXe?C(>?C&?B'W?B$?Bz?Bvh?BA	?BAg?Aaw?A^?A$|?A|?Ao=	!?Ao:\Z?A){?A)y2/?@r3?@?@2?@v?@W~?@W
{?@B~2?@???F??{??p??n(X??>T??><?>*T?>'5,?>[/?>XQ?>lo?>lmx?>&g?>&d?=uC?=w@?=ZF?=\p?=Tl?=?=-?<{؜??;^o?;i0R?;i2Ow?;#E?;#&?:В?:ҏ?:E?:X?:PhT;?:PjQ?:
1v?:
3f?9_?9'?9}?9}
č?97~c
?97`%?8>TN?8@v?8@D?8z?8d?8do?8r?8t:?7*Vj?7,SY?7s?72?7K#?7K?7D1o?7F?6Fe/?6B?6x|;?6xy%?62L=?62NO?5?5sq?5}L?5y
?5_AG?5_CD\?5?5?4҄?4҆?4"'?4$w?4EG8?4Eí2?3Xjv?3Z|?3Lp?3H?3rV?3rܭ?3,T?3,P?2媪2?2嬦?29;?2;u?2X?2X?2Qd?2Sd?1ҳ?1?1aG?1c{?1>4?1>1
w?0h@?0jԵ?0#?0X?0kgp.?0kilN?0$[W?0$v?/]g?/_?/խ?/ת	_?/QK`?/QMm2?/
Ni?/
Jq?.0t?.2.?.}`?.}#?.7
?.7?-yPZ?-{LNd?-f?-??-cI?-cK?-1?-?,	~?,m?,rb?,t=?,HU;f?,HQc?,.?,/^?+\|Z?+XHe?+th|?+tdV?+.6V'A?+.8QX?*%P?*!{m?*?*?*Z+m?*Z-iF?*x:?*zvh?)A?)=QE?)
.h?)|ҡ?)?T?)?V5?([f?(?(ܘ9?(ޓ?(ki*?(kd?($\*?($^?'ݘZ?'ݚ|?':H;?'5ɕ?'P0?'P
V?'	AiQ?'	C?&v 1@?&x?&{9?&{5Yz?&49l?&45?% q?%S?%1n?%3*?%`[?%`]9?%C.?%>?$Ҩf??$Ҫŵ?$8?$4 k?$D퐔?$Do?#!?#bB?#)T?#+?#pE
?#pG	
Q?#)^m?#)`?"t9$?"ve?"?"L?"Td?"T`R?"
Q?"
o5?!ƹ?!ƻ)?!ŒTm?!Ǎh?!8kt?!8f*	? )? $(X? ? ܗ? cV? cQo? V? Q?&??Yn?T^?G|?Gw9?҇z?Ԃ?yӪ?t@?rS?rNk?++?+W??䣺W?Rw?M
?V|l?V~5_?g2?i-?O?Q{V?5h8?7!?:3?:p??
??ԅU?dx?d?
Z??o;m?q6O?FݠV?H6?Hk]?He?w:??r? 2?r?r}N?+\F?+^Avs?&?(?-?{?U?Ut?zWh?|Q|?Q?t?
?8?8K?v?x8?0?2'&?b薫P?b?O?J?Q[?S]?}?w٫?@҆?\	V?^?iw)i?iy":?!8?!1u9?٧8?٩0?'? D?I`?IO??ѭ?u?(?qNF?qG<?*?*~u?
?E?C?j?R?Rlm?
?
H?T?9?z;?z|?2T+?2MZ?d?$???Y	f?Yb]?w?p?Ӑ???x?9W?9O?1?xa??l?av?ax[?[J?]!?>~N?@v:?Uٽ?!N?@?A??'	?%?{Y?hNS?h}7? d? fʓ?9,K?;$pa?J?
?G[?G?Z^?Rt?v?x?o@'?oB3
?'߉0?'
׏j?ΚC?Вg?C7w?;3?NS!?NU?_N\?W@=?ҶP?ʣ?u5?u,?-E?-G~i:??o?,??TeD?Tg^?'?@?'?*?{r	>?{tP?3T?3??Ĵ`?l?n_?ZFzq?Z>*"?Ê?n#?T?V'?5?
?8D?8+?*?+?@T?h?ht? /? 1?פ0[?צ(6?>?6$?F>K?F5Hn?/R?&X?d
?f
/?l}?lp?$7{q?$9#?۞nwR?۠e??~?Je?Jg?W:L?NA?$k?&Ό?p`?pW?'?'?4;:?62?斊h?斌?Mi?M?12@?3)?弁p?弃g7N?0k_a?0mV?qC?g+?w?n2?Uru?Uhl?
ap?
XF?8E?:?ZsG,_?m?o?f?h?^?`?6T3lI?6V)h?Gin?I`?ؤ9`ڎ?ؤ;V?[({?[*h?c?Y?f?˼y?4W=?6ҝ0?6ԓp?%?舊?֤>?֤40?[|Yv?[~x"?[Ұ?]?8N?:
a?Հ?Հ>?6?us?k$?6h]?6]?mUG|?oJ?Ҥ4<
?Ҥ62D+?Z?Zx
??+y?|ea?~?;g-?=ت?5s?5igg?1?5]?Уjذ?Уl:?Z cx?Z"Y3Q?Ԡt?֕k?dž$Q?Ljv?~6C?~8?4!M?4Y?;l?0?΢;M3q?΢=BqR?XWN?XL?Y??Nr?-Te?/I?x2?/Y2?/[ِ?ۈ?}c|?ȜZk~?Ȝ\WO"?<@KA^?dd:?fX'?뻨ms?뻨a[?^rd?^f?u*?i$?t>?hx?뺁q9?뺁e?7kyR?7 _G%?6c?8W|?빣LYH?빣NMi?Y`N6V?YbA?rA\:?t5:?ł2p?ń&;?{#?{o?1?1,????뷝,?뷝˧?S?S#?	?	{&?붿?붿}^?u?u]?+t?+h1?A?D?뵗w?뵗?M?M
2_???봹|?봹?o~l?oҒ?%n?%p
?[8'?][?병G?병H?G0t`?G2g&?!??벲RZ?벲E??h?h+?)?t?ԡPC?ԣ?뱊~`?뱊1?@Zd8?@\WdR?3˳?5ڗ?밬3W?밬
&y?a?as?F?]?ͅj2?͇]D?믃TӉz?믃VƖb?9"=?9$0"o?}??뮤l?뮤j&?Z~?Zv?C?E}?fڡ?	Y.?{:?{#?1S?1F?Ed?GA?묝3*?묝?Rմ4?Rȇ?p?r1?뫾&8?뫾'*?sI?s
8?)+?)VT?9==?;/?몔NY?몔A
?J^'?JQV?:nZk?.?f-:=?f6?08?
'w?k?m?럆
Z?럆G?<+?<,:???랦
P?랦I?\<w?\=Oc??u?U?P?|;%z?|=l?19ī?1+[?R?C
?뜜(o?뜜*aF?Qsg,?Qu??B3?뛼H?뛼?qI*7?qK
V?&U(?&G?͖S?χ%?뚑9?뚑?FIvg?FKy?c?1?뙰ߘ?뙰c"?e?eI?)Œ?+>?\$?^t?똅?똅W+?:".?:΋b???뗥y?뗥M#?Z=[?Z??e
?f@?Ċ?Č?y9;?y*a?.Vֽ?.H
?ym?j?땙
4?땙
?N%$?N'Y??1?@`;?딸V8O?딸X)x?mkvu?mmg?"~_V?"~?אH?בf?듌Vm?듌GE?A?A?'?1?뒫t?뒫e?`+?`+?Yc?J^*?
)?U?^?Oi?4Uo?4@?X?ID?됞˛u?됞͌U?S~?SA?,ؖ??돽{?돽lg?ry?rC?'&
?'[?܅5v?܇s?뎑r6~?뎑t?F^LB?F`=?Go?I?데/+?데1x?eG?e-.?#??٨?ۙKQ?댃4`?댃%i?8T?8]?rb?tSU??닢L?닢MC?W#n?W%M?`s?P?\?
 ?ui?u
?*n?*p7?<{T?>l?뉔X9?뉔
H?H>?H/X?/-P??눲`(?눲b,?g$, ?g&?;\?+?ЦT@?ШD!?뇅dJ#?뇅f:_?: v?:"Q?x??놣Ϻ?놣?XGE?XIk?̺?@?^?}?v](?v_t??+[?+
rm{?߷?߹x=?넔a'?넔c(?I	L?I?G?DT?냲S?냲U?f;c?f-+?S\?CI?4n?6V
?낄?낄?9k/?9m?^?|]?끢?끢?W.c?W0Sl???Qd?STO?t_"?t?)l?)nn?8?(W?봔?aR?Gt?GG?~uG?~e;d?~L[W?~;$?~d07?~d`?~
O?~?}͊U?}͌^?}?}6ܐu?|'?|I?|ig},?|kV?|S1?|S!
?|M?|N?{?{Ve?{q(s
?{q*X?{%?{%k?z
?za?zcͤ?ze?zBȿox?zBʮy?y+?y-fV?v-?u?u?u?ur?u?i^?iL?i?iў?i`ZA?i`v?i$Z?iqj?hȄ?hȆn?h|s?h|u?h0aaX7?h0cO_v?gL?gN ?g6yX?g8gUh?gLm?gL 	d@?gˤ?gf?f犟?fx#?fgXh?fgF?f6
?f#B?eχ"?eω~?ec ?ee
ؑ?e7=,c?e7?5?dI?d7N\?dw?ddޙ?dRR?dRO?daY?d?cbdq?cdR(^?cn0#?cn2?c!Yld?c!G~?bZ?U+B?TaV?TcB?Te?Tl?T696?T6;?S?SG`?S
m0?SZ\?SPo?SPqz?Sk~^?SX?R5?R6h?Rjr?RjY:?R{?Rhw?QNT{
?QP@?QAF?Q-s?Q8Bƅ?Q8//?PVY?PXE?P?PqdH?PQW?PQ?PMI?PO	O?O?Ov?Ok?Ok?O2?O4w?N{UC%?N}A#?N/?N?N9v{?N9bR?MI
K?MJ?M_?M?MRs?MR`?MC0?M/?L@%S?LBl ?Lly`?Ll{s?L"?L'?K??K+!?Koe?K[?K9IlL?K9Kil?Jy'?Jz?Jxd?Jd?JR?JR?J?J|?I#?GR-?GR?G2$_?G4?FF?FH?FkYT-?Fk[?d?Fj˓?Fkl?Exx~?Ez/?E(?E?E7?E7z?DƮ?D꛲:H?Dd?D#?DP?DP_?Du?Dn?C?C
e?Ci&?Ciۖe?C6b?C!͍?Bϡ?Bϣ}}?Bk?B?B5`?B5tZ?A%h?A?A{V4?A}å?ANmǿ?ANo?A]e}?A_kl?@Kvl?@Ma?@g7?@g9o#?@!x5?@#??	H ??wY??7??#i??2ԣD(??2֎h?>'7?>V?>CR?>\?>Kvw?>Kxb?=SD?=d*އ?=d	O?=D"?=/!O?<ɳv?<ɵa?<|ú?<|I?E?5>ٶ?4P?4:@?4XB@?4ZB?4UbV?4UM?4?4?31Ạ?33I?3m?3mʹE?3 co?3 e?2?2K?2+G?2?28 ?28"n6?1df?1Z?1?bi?1AL3?1O˼o?1Oͦ{?1V/?1X3I?0޺?07?0ge^?0ggH*h?0?0W?/l?/nڢf?/~0?/~#?/1l?/1n?.6|?.4?.eG?.g1p?.Hޞ?.H]?-V3?-W!?-˜b?-͆K1?-`?BX?-`A,s?-?-?, ?,"?,wچ?,wYL?,)#?,)d?+e?+g	P?+l?+VE?+A3թ?+A5e?*[m?*EL?*4?*$?*X[?*X]8?*
ɋ?*
p?)??)~?)orV?)ot[h?)!sY?)!	?(#8ߘ?(%"p?(x?(zu?(8=?(8't2?'x?'?'mA*?'o*A?'O?'O?'?'q.?&PR?&R<?&f8ñ?&f")?&:N?&#a3?%"W"?%$@}2?%}dj?%}fy^?%/[?%/K?$T"?$="?$?$!?$FZ?$F\t	?#P?#9?#3?#?#\3?#]4?#2Q_?#4:?"c?"eu_?"s$?"sBI?"%[?"%E?!?!ګK?!?!
?!<=wd\?!o?]' ?v?´!?v9?_1?s?j?s(
?%&s(?%
?+?c?O?8ko?;ƒ?;{?b?p?vx?^?Q.?Qg?S?+?bN??gP?gd?w8E?y?e?g?}P{_?}RcJ?/9T?/;?!r?#?h?	PO?DOO8?D7?Xn?A??l/*?Zt0?ZF?hA?j)P?B?D"?pau?pI?!S?!o.?ƌ?u?Pq?8?7j3Ʈ?7l>?95I?;W?W??T?Lј?LӀ?e?[?bx?d`?b( ?b*??µ?ŭ?ůc?wmɰ?wo?)+?)-˸.?)"??J?w?>[8?>]R+??o?Ə0?w?Sy?S{f1?*i?,xs?
?
۬?
h:?
hQ?
2?
4I(?6
X?.?}?}N,?/)g?/+Q4?3?f{?pk?q?Di\?DP?
~?
@?
KV=?
M=K?
XƼa?
X(?

~X!?

?xL?		?	"?	m?	m*?	<)?	>?,?KA?]3?_~[?3w?3^?u}?w?j?w?HQ*z?H8^?
3E?3?:;?!e?]c?]J?:?0? M?f?q|?q?#	l?#S?ԂHP?Ԅ/?I:?0?7nn2?7pU`?d?[?S)+?U?K½?KĤK?0x3?2^@?X)C??
?`^+?`D'?n^Q?pq4?r?Cp?t9V-?t;?&?&o?9k6?;Q?u?N?:s?:Zf?0F?	?H@?I#?NaH?N?K?1?V	??b9R7?b;&?p?rG?Ħ+%?Ĩrk?u~f?udE?'a?'~=??kB
?m)?:ԃ?:?Ž?td?q?W?N}]?Ncr?7M?9q0?Z?\G?a{?a}^?&?G?ø6?ú?tFZ?t,w?%s?%a*?L?4	??M?90M?923?Bi?DA?S7J?U?Las?Lct?n?pL?yVN?{g?_H?_ň?,???3?r?5?r$?#?#-?Ԕ?Ԗ"A?	?(?6I@?6/g?牳AN?狘Y?E?+SR?Iylb?IzK?m?oΘJ?`?bK?\R4?\T?
A?
C?/*	.?1qB?o[?oe? N? Z??h
?MeK)?x?p?sR	?u7
?߁r?߁
t?1[?1u-?7qu?9V4?ޒ~p?ޒb?C[?C]?E??ݤxiT?ݤz/?Ui?UN=?T(8?8b?ܶkD?ܶOz?f{?f?!!?#?ǣp?ǥ,?x$8?x&r?(f?(n? 14?"D?ډ?ډv?:W?:w`H?I?-r?ٛ-?ٛ?Kw?Kyd?My??[?جY5T?ج[?\ǁ?\eY?
3P?
5d?׽tS?׽O?no?n	S?nlj*?pP:m?ӕw?yA?6?8?/m?/QS?z|?4T?ՐUSq?ՐW?@?@n-?\?E{v~j?E}Y@?$6?sm?ϥ??ϥ>?V-pn?V/TCj?d1?fȏ?ζG?ζn?f]?f@I?[?>^?0?2l?w^?w`?'mn?'P??׶%i?׸?̇^?̇?8!z?8?+f
?-I?˘ND?˘PEN?Hp~?Hra	s?Q%r?4?ʨT?ʨ7|?Xʇw?Xja?2Z??ɸ0?ɸb?iDJ?i's?);5?+	?E;?yM#?yO*?)]E}0?)_(??kiX?l&]?ljv?ljxd(?9?9?b}?Eo?ƙ+?ƙ&?I(?I?u?o?ũb?ũ?Y':?Y2?	A?	V?Ĺ}#?Ĺ_h?iY?i=j??yp?wv?y?yle?ym倍?)^]+q?)`??N]?PI??‰=j?‰?.?9*q?9,rO?U??5?"?H~?H`?1??f?!?X-\?X!?rwv@?tY`?꿸PҶ?꿸R2?h-?h/#??
g>??}b?wA?wU?'`z?'Bƾ?b?c'?꽇3ֲ?꽇5٫?7?7?]???꼖;?꼖D?FiG?Fky3?2?4e?껥?껥?U ?U??۸?꺵CCD?꺵Erh?e61 ?e?\?!?}Kr?~
?t7T?t96?#~?#`?Ӧed?ӨG?긃[:d?긃]z?3B1?3$b?~M?_]?귒n6:?귒p?B?Bq?f?H=f?궡rq]?궡tS?Q2?Qm/?$Ţ?@?군eͣ?군g?`?`
?+??괿I?괿J?n愩~?nf?8?O?"q?ļ?}B?}#߰?-J?-Lzb?&?B?게q3?게sp?<?<.t?u%??걛V?걛!bh?J?J?4?6o?갩Q?갩2)?YBH}?YD)h?s?Tf?꯸H2?꯸Jݿ?ꩽū?ꩽJ?me?mF9-?]>;v?_g?˸O6?˺/;?{i?{y?*i?*j?پr??꧉7u?꧉?8dۺ?8f*?X??ꦗS?ꦗ3fL?FO?FQ4??6?ꥤ?ꥤ|B?T*?T,dR?p2?r%?ꤲu?ꤲX?a8?a?5.?775?sK/?u}?orc?oR1?&j??$O?%q%?}[7:?}]V?,|p?,tW?*:?
p?ꡊ?ꡊ	?:&L?:'!?TD?V$?ꠘ2?ꠘ+?Gu(?GU?e&?E)?꟥?꟥n?U ?U"8?D?Fqi?Ꭓfk}Y?ꞳhKT?b?b_+?=?$?[gp?;-?o"?oK_?`??0?yT?
.r?}!())?}#ؕ?,4Rt?,6n,?F.z?H?ꛊV?ꛊWgV?9d?9e'A?paV?r@?ꚗz?ꚗ|fN?Fr?F8??v*n?Ꙥ4?Ꙥ?S/՜?SL?ӭf??꘱a?꘱}d?`ʊ~?`?<^??ꗾ?ꗾ?mv?mU?y{?{[H~?n?p?zb9h?zd[{?)SK?)Uĩ?C?EW]?ꕇ2?ꕇ35?6d?6 c?	.K?
?ꔓ?ꔓ'?B:v?B2?ܮ?z?ꓠ;-5?ꓠpk?@N]u?nǾ?nɜ?OL0?Q)8?&?H?zY&;>?z[?(sr3?(QG?\RN?]!c?ꁅB?ꁅܫ?4WP?4Y?+?ʟ?ꀑLKw?ꀑN??Č,??jZ?:D8?<|?t?h?K!?K#g/?~a`?~??~Zy?~7$?~Vnq?m?~VpN[?~ƃt?~ۤ
?}CZe*?}E7?}a-8?}a
K?}?S?}E?|u6?|wm?|l!	?|lw_?|8P?|:θ?{ɘ,?{əގ?{wQ?{w.?{&PY[?{&R?zԪ?zԬo?z/z?zzp?z1YE?z1Z?y߭N?y߯?y|?yYX?y?q?q@\?q@9T?p'?p)ɜ!?pI?pKn?pJi?pJk?o-t?o
?o?oh?oTZT?oT?o?oڦzv?n/J?ne.?n_?n_?n
țh?n
?m+?m-/a?miM?mK-?mM	o?lX-t$?lZ	k?lscs2'?lseO?l!l
?l!nR?ktQ?kv?k}z'?k}|c?k+@ET?k+{?jف2R?jكb?jA?jl?j5?j5&?i	;?iZ?iz|?i|X?i?t3d?i?vx?hl-?hn	?hbj?hdF?hIV?hIXr?gIdy?gKa#?g:	?gy?WCHIz|?WCJ$J?VyP?VTl?Vtn?Vv2?VL)?VL
?U?U?U*!?U,ٗ?UT`ha?UT;"?UF	??UG?T$?T9?T]Z0R?T]\g?T
V?T
l?Sgw}#?SiR?Se놐Q?Sea;?SmF?So?R~'?RX?Rnmf?Rno@]?R?Rr?Qf?Qg*?QvA?Qvᰨ?Q$Wㅌ?Q$Y?P:v?Pу?PBM?PDT?P,ť?P,?O&S?O(ԝ?Oy[?OS#?O5C?O5N?NpWZ?Nr1?Nڶ?Nܑ&?N=Ca?N=E;?MW2?M1M?M?Ms?MEs&8?MEuT?LZ,?Lo?L5$O?L6_?LM?LMo?KS ?K-S?KK^R?KM8QZ?KU?KUoh?Kd?KWG?JQ?JS~?J]?J]sl?J
?J
?IHaI:?IJ;$?Ie4q?IeF?IQG?I+?H/?H1?Hmyl?Hm{E?HhP?HB?Gn?G	?GuLDn2?GuN ?G"#J?G"?FM?F': ?F}Z?F}m?F*M?F*O_}?E׉U?E׋m?E?EȤ?E1=F?E1o,?D3?D5cp?DhQ?Dj?D9X?D92f?C4?C
n?C\p?C6D0?CA,M?CA.?BY)?B[pb>?BԢ?B/?BH
!?BHw]?Aչ?AגRf?A?A?AP ]#?AP!ܡ?@B~z?@DX?@c(PB?@e?@WPW?@W?@]Q?@7??@????^??^֜&?????>YR?>23?>f?>f#T?>+!?>,?=Ri>?=mL/?=mM,?=Zh$?=[`+?%^^g?+>'6}?*X`?&KQ?&L?%0j?%?%aqW?%asrU?%Y\?%0?$kn?$B?$g?$g  ?$?$cO?#4?#6q?#l?#l=?#C?#E?".?"ʙKw?"rL$@?"rMX?";?"ϲ(?!M?!Op?!wcI?!wi-?!$Ha?!$J8? (f? ? }Ր? )|? )k?)nz=?+Eb??X;?/.?/m?ۀNN?ۂv%$?9|?
p?4]E?4^?#?ʖ?2Ȅx?4C?9%!H?9ڱ?G?m?f?hA?>6?>
K}?+?-u?݊?y?CEU`?Cu?F?Hˑ&?"?p?HVS?H,"?SШ?TO/?M%??MnNP?@$@?`8(?6o?Wԫ3?Wց?.T?R?d?eU??\2I?\B?K{?H?.?0^(?an]?ap?
1?
$?W?x/?f%1\?f'?^?`,n?|?^?j̵ ?j΋?88i?;!?4?5V?oeA?og?DZ-?0?¥Q?{n?sB?sx? g? <1?BK?D Y?xi5?xk]	?$L?$Z?г+?дܐ?|J/?| m?([?(?
>s!?	?	V'?QM:?Q"?j?@:?ܺ?b?Uv?Uo?kH?m;?Rln&?TA[?Y7Q?Y9%??f?,??\?\ۄO????b?`qV?`s*?JwK?LL?!6?#,?cgV?c?D?J?}1?Rm?go_j?gq4	?>c?@o?1m??j!E?jbZ?mD?A?k?l+?n2f?n3h?q?F1%?Ż)?ż>R?q}=q?q
?=??V#?xh?Llj?t?ttH? u#9? v?/	?0V?w@?wEo?#?#D?R?T??{%?{+?&W?&?g涍?i?~S?~'f?)?)+?n*?o`?u?I?,?,?eS?fY?	yv?M?/1n?/$?ME/?O"?P@?>?2ַ?2S?&J?({,v?+XV?4V?5Z?5[߿?II??b?󌈷,?8?8Y?/|&?:o?=???::f?:?Z^?\2>8?)q??=pS?=r&[??ug?8?𔁔́?@Kv?@,?눩w?}9?

??BǷ?BD?	xP?9?b??Er1z?EE|?|S1?~&?m?gJ?Gk?Gl?m?>?ST?Tբ?IăP?IVc?4aL?64ͣ?렢,?려phL?L7?L
@s?z.V?|?Y?X?NK9?NM?Lx?R??3?Pxȹ?Pzai?پ?ۑ?9M?; z?R<<_?R?aa?m??lK?߷b?߷?c?cr?H)5q?I6?޹vdZ?޹x&?d?dg?OA?!?ݺ?ݺm?f!Px?f#"|?G?I x?ܼle?ܼn?g1^?gY?'?J?۽	rV?۽ۏ]?hL?h[Y?
m??-0?ڿ(~?ڿ*3?jB]?jD/?Zk^b?\=]?pܯ\?r?kY:?kLh?봛??k?[S?l)b?l^
?-?ʨo?hʥ?:?m\X?m.'?O??hY@?:?n?nS|?h? =?F??p:?pʟ??3??tn?p/?ph\??g>?,?%?q?q
?۹?݋>???rS?rħ?;d?̪?ȣ>?ȥV?ss%?sD?}*??h~%
?jO|?tQ?tSm?9?:?!'B?g?i?w8L@?w:qC?"ܡ?"	?}?N}?w]?wT?"k'?"m?4?6yq?wK?w`?"?"bm?ͅh?͇d
?xG.?xI̅?#??#
H??NQ?x?xj*?#A
?#Cl?	?խn?x^H?x?#lW?#mb?!i?#{H?xղqR?xׂ?#!z?#?8?:\?x5?xcz?#2?#b?AI?C9?xd?x5	 ?#E?#A[?D?x?x?#З?#?(~?)A?xX?xʕ%?#g}?#i?T5V?$l?x6'?xY?#;~?#=O{?.m?8?xkF?xm0&?#N?#h?͔?͖|#t?!3?ˀN}?˂6-?uəzS?C
?驻p/N?驻r?e$?e޶'?˛q?i?騹\?騹a1?d,?d!ƬL?GB?Ir?駸n?駸o?b?bQ'?p?h?馶T6?馶#8d?`I?`?g\?zq?饵2|?饵4K@?_M?_Oh?	giz?	i7?餳xc?餳SG?]o?]G?
?ר?飱sxb?飱A ?[L?[,>?
)?b+?颯1?颯8T?Y!?Yo??	MĒ?顮J5?顮<@?X`?XO? &Q?!?頬%9?頬'?V(?V*?*?,t?韪+N?韪,0&?T)S?T+/?'aN?(7L?鞨"?鞨$x?R
,?R
?D1?o?靦7?靦^?P?PgPu?kd?9/?霣6?霣y?M\:?M*?}~?K?雡
$?雡]?K?KH?/?M:x?隟t`?隟v.I#?I[_?I]w?Au?CCO,?陝%4?陝'wE=?GO0?G
?e?3?阚?阚ʻ!?D}?D3D?9Q&??闘]?闘_@s?B6?B8X?}:?J?閕s?閕@M??p??&?鋬>?yq,?镓\tp?镓^?=,?=.r)?u??锐^m?锐+?:d?:1?[H?]*-?铎#?铎%?7?7!?e?ᰯa?钋r?钋s?53ɧ:?55?(??鑈wvB?鑈DY?2oy?2qF{2?*?,w?鐅?鐅?/-7?/?S(L?UP?鏃	8	?鏃Ȇ?,!"?,?on?p87?鎀?鎀!t?)δO?)Ё4?|4_?~|?}((67?})а?&vK_?&B?{,?|d}?z"4?z$5?#ǾC,?#ɊT?kp?mo?w%%?w#? ,5? М?NU>L?P!!?sN?s䲂?N.??"9?$‘?p
?p3?S(?Ukt?9N?l~?m~)?mi?˪??W?#8?j2%?j3}?i'?5N?醽M j?醽N~?fK̨?fa?a?c&?酹_H?酹m?cp8?crU?K:?TM?鄶xŅ?鄶z?_@?_7"?	{B?	}~?郲f?郲P?\w_?\y+t?m?K?邯mUT?邯o!,?X®?X糔R?\}8?^H?遫6?遫?UF?UGd-?TF? S?逨)y	?逨*,5?QB'?Q
?Ԝ?{?r?sz?Mܐq?M[:?~E?~G_d?~Iq?~?~J?~JWk?}w\K?}y(U?}5=~?}?}F;X?}F=N?|G?|?|Zn?|Lm?|BV1z?|BW?{X%?{#?{
s?{B?{>c	c?{>dl?z繓?z_
L?zsp?z`?z:b R?z:c_?y8>?yql?yf-?y1a	?y6SE.M?y6U[G?xߠd?xߢgC?xk?x7N?x26H?x28~b?wsK?wہ>`D?wƒ?w]?w.\?w.
d?vPCw?vQE?vjh?v5݈?v)Iy?v)o?u@?ui)?u|Pj4?u|R5?u%R?u%w6y?teK9?t0(?tx3@?tx`
?t!8;?t!:e?snZ&?sp$?ss\?ss!0?s?sN?r?r	L`?ro7~s?ro9Il@?reN?rg?q?q:2?qjF?qj?q$:?q;?p{i?pF?pf7K@?pf9?p\G?p^^ϖ?oVF?o!-)?oaR?oa\P?o
G$:?o
?nvzD?n@?n]%%?n]鎏?nB"?nP?m6ߴr?m8?mXO83?mXQB?mgM?miS?l}}|'?lG?lSH?lS?k 5?kh^?k>?k?kNŠ"b?kNjT?jI?j՟u?j?jM?jI몦?jIt?iJ?i?ic?i-V?iE?iE?h	Ü?h
?hT?hR?h@B6?h@R=o?g?g
?g
H?gA?g;dt?g;
-L?fL?f	?f5?fzQ?f5d?f5X;?ex?ej?eH?e?e0?e0Վ?d֒?dРPx?db?dS3?d+A\?d+?cԞy?cԟs?c}ٞ?c}DW?c&vx?c&w{?b_f?ba?bxG ?bxIp(?b!.?b!0kV?a0?a|?ar'?ar2X?a?aߋ?`Ĺ?`ĻHk?`mb?`m,U?`uW^?`wu?_Q@?_Sd5?_h+a?_h-?_$l?_z?^
: ?^Ӊ?^b?^b\?^?^C?]X4?]Zq?]]*
?]]+8?]d?]A>?\?\E?\WIK?\Wpm?\_ӛx?\a?[)} ?[+F$k?[Qݤ?[Ql?ZG&?Z(?Z}h?Z1?ZLA?ZLBЕ?Y$,?Y%?Yþ?YŇ|$?YFx`?YFe?X@nWT?XB7>z?Xg?XLH?X@?X@?Wp)?Wq?W'"?W)?W:˃?W:ߔK?VB?V6?VEF?VF?g?V4y3?V4A.?UݦN?Uݨw?UTX?UVj*?U/q?U/:`?T׬?T׮
?TVi	?TXRE?T(щ?T)?Sѥ=B?Sѧ_2?SzJ?SzLI?S"0?S"ej?Rːܳ?R˒,$?Rt1?Rt3cY-?Rr?RҠa?Qni?Qp[ϝ?Qn
W5?Qn?Q?QOo?P>l?P@:?Pgv?Pg>T?Pl?Pnv@?Od?O,?Oa6?Oacq?O
&RF?O
(:?N?NQ?N[E??N[G??Nw?N?i?M^/?M_۹?MTh?MT0?Lq"u?Lrv?L]?L%y?LN~?LN?K??K?K7,?K.`?KHW?KHb?JeN?J-k/?Jp?J7?JA0?JAp?I4H?I?ItR?IvU$?I:?I:]1?Hc?Hd潎?H(?H?H4KW?H4My?GܽN?Gܿ¸?G.E?G0
D^?G-Py2?G- G?F
ܭ?FN?F~v?F~xY?F&w?F&??EJ3A?ELO?Ewa?Ew+?E ,r+?E ??D|.?D~!?Dpس?Dp(?DAq?DC9L?C?CT?Cj+?CjH?C]L?C_?B?Bߪ?Bcu?Bc-?BkG/?Bm?A?AĶ,?A\4?A\g
g?Al?An?@DjH?@"?@UL?@U??_֍	??a??q??!??Mn??M6?>E}]?>GDp?> j?>-8?>F ?>Ff?=?=|?=b`\?=dZ?=?f"?=?-?D?5@?4]?4^S?4Ty?4T{fX?3Dq?3
?3%0?3I$?3Llj?3LP?2s/?29jX?2M?2n?2En?2E	?1Ly?1?1+IT?1-u?1=:˗?1=?$+AB?#t?#מ?#z؆?#zD ?#"u?#";W?"ʎ?"ʐ#?"r^d?"r`u{?"-T?"/U_?!(?!q-J?!iQy?!i?!=X?!F5z? Y:? Z? a ~o? a"C$? 6G? -P?`O1?%.z?XmC?XnU?.K?0c?
?o?OX	?O?i+l?jâ?$)?&K?Fkd?F0`,?R??MY?O?>Pz?>?Y??i^?kF?5
v?5-?ʱ`?vP?x;?zF?,%?,'cI?:?ҩC?{z&?{|y?##?#$m?^?	miE?	o-	V?	?	r?	=9Q?	=;1E?'D?k?l]?0y?3`MD?3b#?ڿn?~??z$ ?)z?e?)|?V??x.͞?x0H?+~??봚?߮?n39?n4??w?ف"?D/?d*z?d,=?zA?{.??E?Z?Z?_ʾ?a???OZ~?O(8?8#?:_?~l&?.?Ep?E3|?O?Ț?F++Hc?vL?x\?y?mv?&?&Y|?\?U?uOz?uPi??y?ò?ô;?j☓?jZQ?%K??==??{?`i!P?`j?b??n?e?US?U?gV?
)?,#?.dU?KOn#?KQ0N?p;=?r`'?Nj?{m?@8?@Z?J? ?_?鮼@?6!?6͹?z??2A8?4R?+H-,j?+IA?\?^lx?yoO?yq}6/? ^n?  |?ǑL?ǓV?n^k?n ?L?`?}.'?󼹕u?Wv?c엱?cŮXo?
Ԫ+?
Ζd?N??XX?X?lѿN?nx?m9J?m;?U?,?vǢ?7n?a-?a*@?_y?a:q?%[?'Rf?>h,?!{?#J?ߋڶF=?ߋvJ?2y?2:q?Hs?JY??B?&O?&?cq?e1VP?t?t3?:?+ ?pm?r?hGB?h۷?/)?8T?۵qG?۵sl'?\d?\s?j"?*m?کe?کgk?P		?PC?? ?ٝL2?ٝN"?C쓉?CSsv?NJ?ꌇnf?ؑ'?ؑ)R/?7`?7ĵS?\K?^h?ׄe?ׄD/?+KB?+oS?"rv?$2N;?xD?x(?IKt?K?O@?;!?lkuF?lm4E?4.:?̃?Թb?ԹL^?`}?`=r??^F?ӭ'-r@?ӭ(V?Sr?S;;?5C ?7
?Ҡ5?ҠY?G=p?G?le??h-?є@?ЇK?ЇH?.4~k?.6=	?Ԯ?ԯ]p?{&3?{'X?!?!0?K?
?n>
?n1??(?ͻiJs?ͻkdc?aٮ?ame?H?I/?̮2?̮6?U (?U"G?9.?o3?ˡr?ˡ11?HZϮ?H\??†H?ʕ%Z?ʕ'B?;?;Gx?R%?>X??䭸b1?赊c?赊m?0̗s3?0T?԰?ܒ
?|*?|n}?"-?"?Ik??oh?o_L?
`J?2?費\?費?a?a?5$??豭?豭4?S'f?SNAF?7?mKZ?谟\V,?谟c_?E#[?EQ*8?j;?'?译
ྕ?译?7}!?7p?ƅ?f?讂Q?讂9?(X?(9}?Ճ?@F?tƶ?tsj?q?Fa>?L??fC?f~a?}??諲h.?諲ic?XQG?XR?8q?:b0?誤ݪX?誤 K?J8?JsWF?0?v?評L?評	uY?;
?;%?j(?&H?訇gk`?訇i(;?-D?-E?U:?!??x>fb?xΫ?l?Ӆ?Ĩ?ĪwG?j~!?jZ^?S;?Tt?襶&Rc^?襶(?[?e?[?.1?P?褧?褧2?Md{?Mf7?0B?2Pj?裘NV?裘
?>ī)?>gE?䌩G?e\?袊SI?袊U=?0G?0HP?q?-?{+?{|?!`"a?!aX??!)?l_Q?l?s?.?蟸W)?蟸X ?^"?^?R?ʁ7?<?螩"P?螩S?O8gT?O:"q?Oժ?l?蝚ܻ?蝚r?@S
?@TɊ??i?蜋^$}?蜋?1a}k?1c9?Ax?2?|g?|f?"c#?"etO?lv?'?mO5?m^?Y>k?[k6?虸,l?虸?^L?^r'?C)?Dʁ?蘩v=X?蘩1?Or?Op?1!J?ֵ8?ַc?|IX?|K|?!·?!މ?nHѮ?p?li?m$-?/?*6?蓸X?蓸U?]Vf?]gT??1d%?3y?蒨
n?蒨|?NB?ND?r?,k?葙N?葙P~?>Ҽ؂?>w#?U\X?W)?萉֣9?萉]?/V?/XLg6?'\b??zRd|?zT4W?Ir?m?Hâ{?J~M?j?jË}p?9%?;>?荵
?荵?[$4?[&7?V?	?솳S?m_3?腑t?腑$?742?75?܈﫴?܊?脁W\ ?脁N#?'.h?'0"z?#c?̀ݶ?qvC?q0w?_;??肼h?肼j?a)6?a?
?ėe?聬F?聬HN?Q?Q?ӣ?]h?耜(k?耜?A[V/?A]?-fp?k?ݭ2?g?11?1?~Z5(?~\e?~{*i?~{?~ Q?~ ^?}#V?}
C?}kD+?}kFY?}{7?}}?||t?|Q?|Z?|Z?|;?|:?{K?{Ln?{J{@]?{J}D??z華1?zmwD?z؈Q?zA?z:?z:?y03%S?y1W?yZ
q?y[Ý?y)?y)F?xΩeJ?xΫvg?xsϙz^?xsR?x?x?w;?wGv?wc8?wc:?wY9ef?wZd?vxG?vz?vR?vRW?ud?u?ut,h?u-?uA.Ǐ?uA禯?t?tM?t`?t_V?t1,c?t1.?s@o?sB5j?s{S?s{U?s eR?s g]y	?rvw?rw)?rj-?rj孂?r??rq?qh:?q T?qY
P?qYA?pW?p?pѷ?pC?pH1?pHŲ_?o(?oˈ?oS~?o}?o7ф.?o7=1q?ncA?nb?n>?nթ@?n&,yd?n&n?m2?m΋?mpͮ>k?mpf?m'?mʭs?lؑi?lĐ?l_Vb?l_a?l?l:?kZr?k9?kN&?kN/?j.?j܈?j}?jn?j=r~S?j=t6?iaH?icqf?iOh?iQZt?i,<9?i,=
?h'}?h)5?hvpʎ?hv(?h.?h ?gb4?g?gd`b?gdH?g	
X?g	~'?fi?f!:?fSquA?fSs-?eR/?eS`?e1N?e3Q5?eB@?eBja?d{K?d3?d~?dɫc?d0l?d0u?cz?c|?czR~?czT5?c(X^?c*n?b?bX?bh;?bh!?b
˿?b
>P?at?av:g?`?`Es?`Eت?_u?_vBU?_>?_?E?_4y?_4n?^
&$?^qM?^}^?^}?^"TLM?^"V?].~?]k?]kD\?]k?]_?]i?\Vu?\X:B?\Z]?\Zb{?[τ?[;?[1?[Bb?[HCJ?[HE?Z7?ZG?Zh?Zf?Z6g&?Z6h݄w?Y(?Yߙ?Ys%?Yϓ]?Y$B!?Y$/?X/Zi0?X1G?Xm%2?Xm׭?X[?XXg?W7?W9e?W[g?W[k+?WJ?W?V4?V6I[%?VIێX?VIE	?U+od?U?U%i;?U'A?U7X%?K?K
G?K7"?K7؋?Jh|?J	]?JR5?J?J$܃?J$?Iw C?Ix[?Im1?ImʽJ?Ie?Igs?H?Hw?H[O+t?H[P7?G^u?Gç
?G3kI?G5!s'?GH?GHPO"?F~n?F4*g?F?Fc?F5e?F53?EWiB?EY-?E~"4?E~׶?E#)ٹ?E#+FUt?Dǐt?Dǒj?Dkgu?DkDJ?D[?D\!?Ce?C!?CY bV:?CY"?B^?Bʳ
?B~?B40m?BF>j:?BF@TY?Av-?A+?AK?AɃ?A3QI,?A3R?@תFo?@׫?@|?@|0?@ Xer?@ Z??ĭ??į>&??ic
??i??
Sa??
Uo?>DE?>K?>Ur?>U?=C|8?=E13?=?=zF?=BFd?=B{4&?<'}+(?<)2u??9?9T?9Q~?9QͳI3?8?8
Lz7?8C?8EE?8>}?8>V?7ⶶ˜?7kXx?72?7?7+$f&?7+&R?6YTD?6[,?6s?6sV?6Z?6&N?5s%?5(79?5` F?5`!1?5N;?5P?4|?4}|?4LG?4LΓ?3Դ?3ԈR?38I?3?39$D?39%U?2K3?2LA?2p~E?2r8'?2%!?2%n?1ɷj?1ɹ\=\?1mO9?1mRT?1ʋ?1c܍?03?0}?U?0Z6&b?0Z8P+t?/S(?/Tԡ?/no#?/p#7?/Fo?/F#	J?.)?.:?.C?.Q'?.2ˍ?.2l5?-O=?-h'?-zW?-z?-	]?-i'?,N?,?,g*?,g,UJ?,90?,:㼆?+Fyj?+H-X?+SR?+ST2x?*]??*^P?*f?*ho ?*?n2?*?pu:?)u4?)w;?){?)}Kg?)+-?)+?(σ,?(τ &?(s?(s?(
?(U8?'-?'X?'_+?'_:a?' ?'7?&zn?&|?&Ku?&Kvԝ?%m?%o>a?%e?%gIt?%7[4Z?%7]p?$Q@S?$Rv.?$D R?$FO?$#7c1?$#9Y?#(|T?#*_?#k?#kdԩ?#s?#	&?"z?"p?"V,ݽ?"V7?!%?!?!?!?!BKӘ?!BȞ? {? .P? kgX? mf? .P? .Qĝ?3y?5,?v[?vR0}??5/?$?׃0?aaR?a7"t?Rn?U
?m?o1?MH?MI̺?!s1?#&g_?|?.?81]l?8?ܥS?ܧUi?y?{4?$L	?$Nr?jb? ?kң8?k?v??܈??WX~?WZ1"?#խ?%5v?Y??ﯲ?BP?B?~u?(;H?D=??F?.	D?.E??s?uYN?uL?QX?Sa.?^?x?`Л?`M?1?$?J6h?L8HA?L\?LMh'?p۬?"?x?yy?7/\c;?71[?s#?%A?~J9P?~$,?"M(?"O
$?;$??iU
?i\?
a?
bx??K?T~C?TB ?h?j~?Bs?7O????N?e8b?f=?1G?
?*+?* ?
Vc?
X?
q"?
qP7?
zL?
K??\?\݃g?z	?{;?J?$?G>?G?
MQ?
Oy?
q?
E;?
2~?
2J?	`x(?	?	y釮?	y?	?4m?	@$4?Bl?̱?ddt?deéX?F?V?D?l?OD?OeP?io?򠞄(?*?,<
?9Z?9?>???֐?ǚ>?$Ls?$N$?D?q84?kUJ2?kW7W?؞:?O!/?Z0¦?[?Uڅ?U6r?Y3?[MpL?v|I?'H?@T?@Uò?rI?#	?I@?KE}J?*zim?񛀙R?H?>??>PG?QN?\K?D?F?{D?0u?0$Y??	?w&_C?we?/.Q?0L?@?B)?`Qm?`S#K?`?ba?n}
?pos?I{?I}GU?9???R?2&Y?2?բY?դ?xQV?xIy?,?E?ܐA*?ܐ?3&o?3ԇ?֪C4?֬T?yQK?yV?z?E?ڿ?ڿW?bv?b4?~/?vj?٨qN?٨sR9#?KcF.?Ke)?TsY?VP?ؑD	?ؑFy?43q?45^? ?"?z
"8?zj@?.
??ֿ?ֿㅱ?b\F?b	̤?z?YmJ?ը~?ըt ?K|D?K~Zg?`_)?bN?ԑB?ԑDq?4$&?4%A?<:?e?yH?y̓2?ͅ?z*?ҿH?ҿC?bx?bz=[?R?TRY\?Ѩ+S$?Ѩ-3C?K4?Kk?ٰ8?]]9?А҈?А?3*?3<?Ul?We?y'J?y)QO?#I?v2?ξp%?ξJ?a\?a8o?buH~?纲>5?纲 ?T5?TgI?7
?8.?繙+OG?繙??SH?wW"?w[[?*$?+ȳk?篼^ٵ?篼	e?^s,?^E?e[?gk?箣?箣bw?F1T?F3S?
w?藸M?筊F5^?筊?-[S?-\u
?ϼ5k?Ͻ-?r?rb?zwkG?|" 
?競?競ق?Y4
W?Y5?2? 1?窝?窝OZ?@A?@CWn?7??穄d?穄C?'D=F?'FyL?ɘۓ?ɚ
3?k믲?kZ%W?=J?>?称5?称d?R[)?Rި3?+?,*?禗x?禗y?9Ȱ?9r?a5c?z	?~W?~Yy(? &? ^I?+?H?e-s?e.Ý?qR?s?磩x;?磩"Y?K܅?K?9/?:ٯ?碐yM?碐z
?2@8?2?
??w2?w4V?n$i!?oW?砻sM(?砻5e?]ᙖ?]Cw?y?@?矢Pk?矢R|@?D>?D?溜5?E?瞈"?瞈.?+ +?+!z?Q7?RA?	e?瘫?瘫?M۪?MM+?jF?ĸ?痑SҘ?痑?3p?3߇?f1
?f?x14Z?x2݉?It?Kj?畼a['?畼c)?^w?^y^?1??產,?產
W?D?D?Śp?Ca?瓈4F?瓈A?*?*PA???o?o6?
 nj?NH?瑳n?瑳G_?U!?U#]E?*9kN?+7S?琙1n?琙32?;77+?;9[?_-?@	?B;W?!CIH;?!D)?D٭v?FQ?eECL?eF=?D0?F04D?獩B?獩DNV?K?,?KAG?;qk?=?猏6,	?猏7Ǩ?1/k?11P&d?(
?)D?uH?u [?b3?Z&3?ZΈ?N?y?牞Wʊ?牞)?@Һr?@b??à?爄?爄?&	3?&`?Ȉۯ?Ȋ?js?ju2?]?^?熮E~$?熮G&6?P,¥?P.j?J?PQ?煓?煓?5۰?5X?׾ML?׿>V?y8U?ym#5??U?烽_H?烽`u?_=Tc?_>:??sV̰p?sXsj?s-?s-?rέ4S?rί?rpW֏?rpY}5?rQL?r@i?q>}?qB?qUN?qUPi?p(RR?p݁?pnz?p?p:;n?p:=;?oݝ\x?oCӸ?o}~?o}-s?oP?o>?n%?nu?nbZ?nb\0wP?n?n
?m<6Q?mⅲ?mG,S??mG-?lJ?l?l]"?l^?l+Q?l+?k͉t2?k͋V?ko?koD?kI?k?jC?jE,.?jSԣd?jSI?idz?ifH_?i?i(?i8D?i8O?h
c?hU?h{nWT?h{I?h#?h%{]?g?g?g`5K?g`6!?gZv"?gM?fBKxD?fCIM?fD?fDĮ?eJ2?eLzd?en?eM?e)N-?e)Pj?dI?d?dlN?dlP2??d
̲?d
X(h?cI?cKaj?cPũ;*?cPNQ?b@y?bBJ`?b.[?b?b52?b54lw>?a֪6i?a֫ ?ax |?ax""?a0$?aJ[?`	|?`U
?`\|+{?`\~Da?_p?_
Y?__%}?_`m?_@ν?_@b?^=93?^>y
?^O?^=*?^%Y?^%?]Ƃ/?]ƃ`?]g1?]g&?]	T%?]	V6?\'q?\tD?\L#?\L%+9?["?[?[tM?[H}?[0QL?[0R?ZѳR^?ZѴ]?Zs ?Zs'?Zt<?Zv;*?Yӏ|?Y4?YW1nҾ?YW3?X3:?X?X:?X??X;Dl?X;FbW?Wܝ?Wܟt?W}=?W}q?WM4X?WO#?V?VKZT?Va?VaY~?VLh?VNA?U\?U,m?UE?UEy?TA?TC1F?Tj?T"?T)RPB?T)I?S,G*?S.1Ć?Slx?SlzR?S
ôҔ?S
YB?R
?REE?RPVt?RPX~?Q-+|?Qч?Qzt?Qp?Q4*R?Q4+[|?Pn.N?N>0gg?Mj&?MlA?M+2.?M>#?M!ޠBN?M!DG?LJC?LH?LdNBt?LdOl?Lo5?Lw?KA?K),p?KG9?KG'?J i?J"
B?JR8S?JS܄?J+m?J+P?I̲j?I̴oH?Imؚw?Im|]?I.{?I7?H:k?H<?HQe4?HQg4?GK?GA?G?G7W?G4qG?G4?F7(?FڼR?Fw,/?Fw.L?FQ|^*?FS?Et?Ev?EZd?EZ?D?DYqc?Dz?Dړt?D=I?D=	?C!?C~0?C3
?C4?C!Nv?C!Ps?Bi*?Bkdu?Bct?Bcs?B?B1?Ab?AH%p?>Jp&9?>OV|?>OX*Օ?=c ?=ds#?=n?=pE=?=2y^2?=2zD=?<ӂe?<ӄ??8K?8=\?8_?8_?89!?8۪A?7iɹ?7Ko?7BV?7B(?6ㄎ?61e;?6{v?6}%?6%qd?6%s?5f2!b?5gԁ?5gYJ?5g[X?5L?5N5d?4>&(?4?^T?4J.'(?4J0Hl?3M?3?3m?3?3,&r?3,WW?2-?2Xh?2n`?2nҢ?2l?2?1iR?1{?1Q?1QJ?0rd	$?0t^?0Xs?0Y?04<@?04>C;?/ "?/!ڭ?/v?/v3I?/a_?/I?.6N?.Y?.Xl?.XZ>?-?-1מ?-^@?-`C
?-;:?-;a?$ߍ?$N?$N*!U?#Z‡_?#\c?#z,?#$?#0?#0ۥ?"ј?"љ@?"rUS?"rV+?",?")?!ZL?!cP?!T?!T*? >A`K? ?IN? 2? Ӏ? 6? 6!?b	?c?x"?x##?}?ˍ?|G?}w?Z-?Z/4??qxI?#?4?<;?<dN?
5PЍ?
5U?T??v#?v/*?
?s?H?>i?X5.?X?
~D?
?
܆o?
{b?
9q/H?
9rΗV?	v(?	Ԩ?	z^0?	z`R?	6?	ՃA?H	d?I?[$.?[?-58?.^?:ؿ??=6?=/c?}&˶?~c?}"?}?WA?YG?ûR?ZQX?_.}v?_0"u8?A????@hZ?@j@?Ch?E?4۰?6z?!j?!	i?~?F?b_J?b`e?q%?D,P? Y?"-?CQ?6?Ԧ?ja'F?jccG?
L)C?
B??j?K8Dt?K9※?}?S'? U$?þS?,m?,!8?G?Ir?l?l?J?\?y?
y?MF?MH>3?,?^z??vY?-?-?4?6U?nm6?no????ބ`?OԤ?OrE?G+?IY?{?}:?/w{I?/.?K
?d1?p?p=?@ᴤ?B,L?o
?qAW?P`2?P:?I?˳?ǯ?el?1 s1P?1"?n6?n8QC?
?
'>?ȭ1?ȭ;?M|!?Ms'?K*?MIV?Ǎ-?Ǎǵ?,4?,u"?̐y?̒?lP?lQ~?-?X;?ū_5?ū?K/?Kn?DW?FA"K?ĊMd?ċ˵?*C]?*?q?s;?j)O$h?j*w>?	'?	s?©?©L6!?IJg5?ILtn?z'??ګF?t6?(b?(d3,?Z?g?gYH?gĹu?qs?sB?濧,`?濧!M;f?F̂?F?xUv?y?澆#,?澆$Ɯ9?%Z?%Ρ??uP?wl?e>?ecΑ?ı?K}?漤j7?漤l7?Dz?D(L?㳃??滃V~?滃X?"}?"|?™v?›?b9j?b;4?bFl??湡v]?湡w?A];?A?b??渀Jj0?渀L)M?w?P!?淿}9?淿"?_.{?_9;??U?涞Br?涞Dut?=?=ٛ`?l,?m?|\.?}? \?+q_?洼"Oh?洼$f?[
?[QQ?BTz?C?泚С+?泚:a?:]?:_?L#?L?yu+e?ywDL?3O?M?汸{?汸	?X;`?XHz?g??気
0?気!	?6m˪?6c?)?+?u{?u)?0,5?1ň?殴?殴^?T2\U?T3?Kc?X?歓0!?歓23J?2D[?2b?*G?,3?qA?Pޣ?}?e?檏?檏??.x?.z!|?r??mac?mbKG?\r?K?樬F]c?樬G=0?Kf2?K42?'w?)U?槊4?槊)?*?*Kh?qֺ?sv%?h?hߩ?IL^P?J䟄?楧?楧(O?G9?Gvm?4z?F?椅H?椅,G?%R?%T?ĸok?ĺ?d?d¥?q)?	4L?梢n?梢r?BDz?BF??ᦠ
-?桁x?桁5? c?2H a?2Ix4?ёb?ѓ7?p,R.?pÞb?!ô}?#Z?旯hfP?旯i6?N?N?1?h
'?斍6U?斍8%?,yM??,zb?˻[?˼9?jo?j?
;?
=d ?攩zc?攩|Pz?H?HG ??K{?擇1O?擇3ZB?&lSY?&nu@/?ŧ[?ŨA?d8y?dY-?w?X?摣Od`?摣QZ5?B?BVF?ỀG.? ?搀?搀S? #o? %Bg?揿U?揿WW?^?^)ls?7͐?on?掜2?掜?<?<@u!?Dv,?F
v?zqQ?zr@S?:-?Ь?挸00*?挸Ʃ ?W4h+?WP?Fe?C?拖Cf?拖DD?5j.?5l+k?Ԑ?ԒhE~?s(?s4?Yd&?`?扱?扱C[?Q 
x?Q!?A|J?C~?戏a?戏c?.m?.2?͠??͡?l2e?lXK?w%?
84?憪:?憪Рq?J~?J?*?,?慈C	?慈Er;?'[?']p?r?t|?e?e?-?ò?惣h?惣?Bű?BGK?
?٠?悀s?悀	T?;|?o?恿	t?恿
c?^s?^y?%?'Jk?怜2mj?怜4	g?;>6?;?˥?I2?J?yR?yT;0?[R?]{?~c?~eq$?~Vk^{?~Vl(?}q)i?}rk?}vRE?}w?}3z;?}3| ?|}?|i[:?|q-]v?|q°?|?|,/6?{?{?{NO?{N0?z6~?z˷+?z}R`?zw?z+z$?z+|4O?yvl?yx?yiqK?yir฀?yk;:?ylH?xd?w#@f?v3K'?v4?va&(?va(Kb?v4?lK?l?l#sa$?l#t??kLʹ?kN^?ka%H0?ka&ܪ"?jڔ)?jnC?jӀ	?jL?j=;ac?j=l?i~
X?i]"?i{Q`?i{S?i$?i&y?h?h?hW:?hWɨp?gKx?gߊ?gg?gi+vh?g45?g47z?fo5=?f?fq5y?fqюv?fnc?f'.?ef7?eg˛C?eN/?eN1gI?d?dQǛ?d?d4LT?d*1?d*+?cMp?cO8*?ch]?chY?cj?cؐ|?bI/?bK?bD\Q?bD^?P?a#S6?a?aްz?aC?a Sx?a ?`]?`^.?`^6?`^oP?_e?_TW?_4?_PQ?_:NR?_:Pb@9?^g?^
?^w6?^w?^zV?^|\?]1 ?]3F?]S|/?]S?\0?\L?\Rn?\T\ b?\0?\0%?[ιrl?[λsW?[mkj[?[ml\1?[y?[~?Z̠?Z3Ȓ?ZI{?ZI}r?Y*-?Y+?Y׉?Y1?Y%rj?Y%I?X/?X18?Xb)b8?Xbۼ+?X|m?Xu?&?W,P?W.E/?W>ԛ?W>- ?V{?V}-?V|!u?V|#E?VS?Vtm?Uk)@?Ul??UXr?UXN0?Tr3?T?TRh?TT#o?T39?T3˛,?SҒC?SҔ?Sq15?Sq3f{?Sƨ^?SY?Rl?RndEw?RM[~?RM
a?Q3>?QF?Q>KH?Q@t?Q(=H?Q(ٌ?PpT?Pr?Pf&x?Pf	+?PR?Pu'?O4V?O6K?OAɩe?OA;?N]iZ?N_E?N~׃?N~i?N_?N?Me{?M?MZ?MZX ?L4@ ?L5?LЫ?LeŪ?L6P+%?L6RG?KH?KE?Ksi)
?Ksj	?K#Ǐ?K?J~8}?JP?JOgv?JOB?I폰?IBc?I9?I?I*Y?I*$?H#*?H$}?Hgފ?Hgp4_?H+?H->s?G?G't?GC0Q?GC2+?FᱹĚ?FKR?F1ah?F3?FJ%?Fۦ(?E/`?E1M=?E[H[?E[.?D)e?D+Ѡ?D?DG5?D7 ?D7"'Y?C՚*?C՜#?Ct?Ct<?Ci`?Cp?B0P?B?BOy?BO{.L?A'?AҬ?AcŔ?AeV­?A*w ?A*G?@JDW1?@Kw^?@g-~A?@g?@-2o?@.??TT????C??C"A?>z?>||?>a?>z?>Tk?>V?=9.?=5"e?=[+p_?=[-??3p#Q?3 y?3"	i?2r~p?2tK?2Kâ?2K2?1	?1u#?1cGc?1d	?1&^?1&Ydf?0ii?0?0cL)?0cMO?0!?0?/?/䗶?/>-&,B?/>.4?.vdzl?.wW}?.zŒ?.zR?.@"?.Фo?-L6?-Nnw?-U?-U-M[?,|Ql?,?,{?,[?,0^i?,0`+?+Π۵?+΢k[?+l?$#s?$+/?$+?#E*?#Gߙ?#gu
?#gv?#2E?#Mm?"ЀN?"?"Ag?"Aa?!(T?!*R?!~S8?!~T?!}f?!~? 	? h? X'? Xϵ?f?…??X:?3AP?3B?eXC?g#?o?oT?
?
D?֨?X}?I5?IC?T??/%?1P?$NS>b?$O?lZ?m߲?`ޭ?`m+|??g|??X?:8G?:ư?L?+.?w%k?w
P?#a?%`!?:8?<0?QPѫ?QR%_?e]?g=?y?{zE?+M ?+R?ɟ҆?ɡ`;?g|]T?g
?J؂??>;?R7?AV`J?Ao?xN?!?}N?}
?	}?
?)??Xw?X!?)Y?+g?3?4l5?2;So'?2?P?SѮ?U_kC?HW?HYO?Z?\eo
?]?^?"^s?"`+?^S?`{?^^?^`3?
]w?
_{?
[o?
\k$?
8XJ?
8Z]?T?V_s?tP?
5gB?
6?
,M?
.?
("?
($rE(?	^K?	F?	d?	d)/?	ưb?	S?Z?B.?=	?=Y.z?
)$?ؗG*?yp	?y ?r\??^??Ӭ?S=?S?o?"kG?lR?nO?-X"?-Y?BՃ?D#J?i,5?i-¤?_?U?ۣ?hu"?BG>?Bwd? 5?˭s?~c?~ ?,?l?w3?yA¸?XZk+?X\?<16?>??A?1c2?1?g`?Y?m"?m??z3?vx0?xnn?GSP0?GT?.G?/"?/?
D? R/l? ތ?ũ?Y?\G?\?ji/?k
?@[o?A?6ƭ?6R?[??qmF?q~?t??c?d?K4X?K5Q?t?N
?V=?Gw?$
r?$/?p?rsU?`=J?`?x?n?
??s??9?98?iт?k0?u2}Z?u4	,o??PQ?q^?:5?N?NC9?M?O?j?:?I?'4?'נ
?ř?Ś_?c[K?c\ט??4?1s?޽??F?VbF?~h?~}?M/?ք?ѹו?ѹ`?V[?V˜??
I?БQ?Б)?.?/z=?wt?x?i*k"?i𳏳?f?g*]?Τ+?Τݴq?BQw?BS
O?ɀ?P?}9k?};1K?4?/?̸
?̸ ,?U?Uu?iizq?@O?´E?´?Qz?Q?TJG?Uy"?4??*	Te$?*
܈?b?d14s?d3?d1P?7V?zF4?忟i?忟kn?<!?<?p;?5?wj\?wkO?r^?X^?彲љl?彲Y~?Oc?Odw?u??弊B?弊ј?'T<$?宧O?宧P!?D?D+?g1+?K?~a?~a??Z!?嬹I_?嬹J?VxE?Vz+???嫐՘@H?嫐ީ?.w?.nJ?/oh?0o?h[1?h\f?,\?߆?婢`V?婢K????U]?vmk??z*Wp?z+'%?Qr?RM?姴w$?姴yN}g?QWM?Qݟ? ?æ?妋$1?妋u?)	b|?)
An?+ڄ$?-` ?cMe?cO?nz?p?夝a??夝)X?:?:?̤?*8?t}P?t?1N?	6?墯#?墯%gC?L?l?L@f?Z,X?[II?塆t ?塆um?#O?#Ք'?
???]^?]}???"?埗ZY?埗 C?4/?56?CE4??o(?o)l?;??劶(Th?Sa?S?Kq?)?剌oș?剌?)t?)N	?Ƽ?ƾ6C(?c/^?c?칟?p?凝sܺ?凝um?:Z&F?:[??>?A'?t$`
?t%v?^%L?	?六뛢?六g?J?JϝX?+?[?億?億ZY?!q}?!r?僾P$?僾R?[/X|?[0\?
Ze?ޱ?傔hM?傔"#?1""?1Ȧ?΢?Τl|?k}?ks5?X8?YO?倥1D?倥3Fk?B
aX?B?2? ?{@?{ph?~q??~fR?~gxT?~R;g?~R?vXZ?vD?vFP?v/
OB"?v/E?u8?uЖ_?uh
?uhۯ?uVh'?uW˳?t>Nl?sۛ㑜?s۝fC?sx\??sx]U?s?sb?rĦ?rGD?rN!?rNpXc?qV[Cr?qWҷ?q
#?q$j?q$?q$Ї?p@B?p½+?p^Dl?p^F=?oth.?oԀ?or1?o|?o4oeI?o4q6à?n';)?n(.?nm?nm߈?n
:?n
?mIkۏ?mJ?mC?mCV?lW?lg2?l}e	5 ?l}fb?lr?l?k!?kʣX?kSz	?kS{(t?j*O'?j+?jt?jQT?j)?j)q?i6?i8!??ib$0?ibs?h6?h
$?hQ?]t?]Zy?]Zz|?\Iߠ?\.?\@c?\=N?\09w|?\0:
?[zh6?[h?[i`Ʃ?[ibGT?[[v?[ܞ?Z9?Zt?Z?`\B?Z?@?YۦA?YۨQg?Yx6e?Yx8
<?Yŋђ?Y?XS#?XUX?XMl?XM!?WnK?Wó?Wnn?WJ?W#?W#Uǀ?V?VY]?V\}?V\=?U#?U%@m?UKV?U$?U24 ԗ?U25^?Tλ?H?Tμ"?TkAVK?TkC(?TZ?TBC?SLW?SM~9?S@Нm?S@Ӎ?RT-?RULF?Ry?Ry؈g?RY-N?RZ?Qڝ=?Q?QO[W%B?QO\h?P[?P?PZX?P\+"?P$D:?P$ ?OW)0?OX?O]Yd?O]?NPԥ?NRT?N̚?N@2?>Bz%?>@@~?>@j?=ӝ?=R?=yYd?=y[3M?=?=b?<a	?<q?Ɉi?7>ׂ?6%?6$?6wkj?6wl?6Rx?6P?5	?5^/?5LX=?5LYI?4v?4i]?4dZ?4g?4!?7?4!@P?3i?3T^?3YŔ?3YCC?2 R?2!s>?2i?2k1?2.qό?2.?1:?1?1gB?1gCZ?1v?1Vt?0?0n`?0<Yz?0<ǽ?/Y0?/Zn?/t:?/tr?/y?/|?.#&Q?.$}?.Ie#4?.IfQZ?-rG?-?-?-?-'I?-(?,fE,?,gß:?,V*?,VW?+?+=?+ ?+!uF?++\4Z?++]O?*ǘ\D?*Ǚ3?*cӊ?*c?*	?*$?)G^?)IXc?)8[z?)8|O?(ԹuNJ?(Ժ1X?(p>?(p?(
(Z38?(
)׎?'^U?'`E?'EO?'EH?&ɝ}?&_)?&}?&}+?&1?&3:?%dŦ@?%fB?%R'?%RR1?$E?$@iO?$]t?$;y?$'*Ed?$'+Z?#Y?#[*?#_t?#_?"D?"eD?"䂱?"(?"4p?"4s?!=c?!?.?!liFg'?!ljKo?!.g?!? j? U? @? @w&?ެ?[t?y9?y:c?`?bO?4?F?M?M4=?@?Խ/?*>?8?"P?"̫??Ȭ?ASX?Zb=?Zd.Ɣ?⍢?_{?g?]?.Bg?.Ⱦf?q?_?g?gs?%?'M4?Dr3?E|?;aZ?;b?~PB??su?s'?]\?l?;??U?0{?u?v??-̙?->?
я<>?

?
e;?
eXu?
قR?
?	?	*?	9գG?	9Pb???q?q
?
?
c?០??Eu?E*???}'?}T&?G?n?X?fW?H\?Q2O?Qӭ9[?W=?m??PW?%?%(?'?Y?]i\?]?ND8??kp?#?1$2*?1?͏ҝ?͐|?ia9?iK{?y?z%?m~?n?=`]?=aד?SG?TL[?uEP?%k?'(?4
]?4לO?g??kͫ0?kGa?-?	
R?B?&5??%1???m* ?ot?wQ+?wR?3j?51O?	R?*?Jh?J`1?׈?݋?􂷆KE?? ?Z)?u?w
?VSV?VU/?1[?2~?
*?A?)q?)a?cSv??a;?aU7?zq:?{I?T>?U|8?5,(?5.k?>X?yn?l6?l`?H*?f$?PÀ?m?@`?@ae?5/?6i?x	ZH?x$?݄܅?7R?>?jO?ME?u+?uv"5?D*?Fk?ڬEH?ڬ1?HM?Hk??fĿ?g{?ـt?ـ쐛?F?Ͼ?طz%,?ط?S4?S59??|u?׊\"?׊Ԉ?&Hj'?&I?1?=t?]?]&?Vz?X?Օy?ՕF"?0q?0
?_vN?`;^?h/?h
U??X?ӟbO?ӟdK?;
c-3?;ڐ?ַTs?Άݵw?"~Ҳ?"I?; #?;"=#?Y?YÓx?bF?dN8q?̑?̑l?,v?,"?A[?BҘ?cߤ?c?}Q?~?ʛc?ʛa?6.?6NI?R?T(J5?mR?mf?	j?	?ȥ"?ȥ$?@7?@y$?TR?VIf,?wk?w}`?p?9'?Ư+?Ư?J?Jx?GՒ?IAH?Łu"?Łn?qUz?s?Ĺq?Ĺ?Tw?TW?+?-E?Ë?ËD?'O\?'P?QQ?Nj~?^p?^r!?lo?⛐??O?1@P?1]?̫U?̭slE?h9MA?h:Q1??yQ?俟R?俟S?:ݡ?:?h5?i(?q?qM??
|v?
~?佩?佩?D**s?D\?w?>l??f`?j?jzc?7?8w0.?䴡cUY?䴡ؐ?=-,3?=.\?ا^}1?بӪF?t i?t"mj???p%,?䲫f#!?䲫:?F9&?F?v?(`?}x\%?}y^?)F?BF?䰴c6?䰴e+
?O؀2Q?O?La&?N>Gq?䯆{z?䯆?"3r?"5J?䮽s?䮽D!?Yz?Ys?cGJ?
.?䭏%,?䭏?+jPJ?+ka?;?Z?bHU?bJZ@?N>?Ð?䫙%"w0?䫙&?4`C?4a?[t?|?kk~?klj?֗	?z?䩢At?䩢B?=Ą?=F2n?e?9?t~)?t&?=D?豝?䧫O2L?䧫P?F?F\U?\?H?} ?}?u?2;?p?䥴N=l?䥴O?O?O'?4?	T?䤆y	?䤆{V!?!ܚN?!""?䣽>qs?䣽@1|1?XL?X?G
x?
?䢏a4?䢏c!*.?*q?*`? H?"10L?ag"]?a?}n??䠘: ?䠘?Et?E?p'i\?q`?{'?{ǚ???䚲pn?䚲qh?Mĵ?M)?i
?H?䙄kx?䙄lM?UZ??䘻?䘻 ?Va?VbR?X5?AX?A?(??xF*e6?xG?Q??䏮ЏG?䏮?JaP?JWo?X$?Z?䎀*?䎀J?x?|?䍷 Xr?䍷!1?Rb?RczYt?7?i}?䌈U?䌈YE?$#$?$$ ?䋿bc3?䋿cՎ?Zh?Z#?0|?Ș?䊑N$?䊑1"?,Ykv?,[0\?ǖ-d?Ǘ2?b
$?b?
^5?^Q?䈙H-?䈙IOj?4QX?4*?ϻ?Ͻe?j*?jy6?-?.?䆡e$?䆡f"?<1??䄩tN?䄩vak?DP?D$b?ݜ5?h?{Z?{n?Dh?E\?䂱vq?䂱w㟵?LA2?LI*?ق=?k?䁃
5?䁃K?:Z*?; ?䀹i,w?䀹kb
?T?Tks?t:?D?a0?Ew?&"?&$2?~Oo?~Qa?~\{/2?~\}H-?}?}q?}ҷ?}(?}-Sz?}-(?|'b?|(?|dPd?|dRU?{yv,?{{J?{APL?{?{5u?{5ˍ?zj˪?z?zl,N?zlI?z>a.?z??yd
l?ye{?y=&?y=>?xح_?xد'?xsѺ1@?xs+/?x1?xG?w7 ?w'd?wE:||?wE;?v\Pm?v]O?v{}Ul?v{	0a?vQ?v?uzd?u1~?uL?uL߈?t)?t>?tH3?t?t9S?t;4?sW	?sX?sTs
?sTuk?rRy?rQ?r?r|?r%_?r%Їc?q"?qf?q[@	?q[@?pr?pP$?p.x?p0e?p-GL?p-H?o_~!?o`\R?ocv?ocxd?nH?nN6C?n=r?nR?n4?n42s?m^\?mO?mj?mjo?mU?mŰ*?l&J?l
rO?l<$?l< E?k1V?k3-x?krC?krE=
?k
URbI?k
Vo5?jfND?jgJ?jCvV?jCx0
?iކ?iވ?iyۻ?iyu9?iQ$?iE:?hz?h?hJx?hJGT(?g
u?gzI?gڳz?g#n?gk?gD1?fkv?f~3?fQyV?fQ?e1?e	n>?e?ek4H?e#o?e#޽E?d$Z.?d%ɢ^?dY,T?dY.+?c4?c6?c;h?c=Vv?c*BYD?c*D?bH?bJ`g?b`Na?b`P҆?aST?aUI-?aX@?aYn?a1\~?a1^?``;!:?`auQ?`gcK?`gd5?`e*&?`gDp?_g?_iF)?_8iP?_8j7?^jC?^k ?^nj?^nlEF?^	jL?^	lo?]if?]k_?]?h~ ?]?j56?\gFI?\hSC?\ud?\ufB?\b?\c}?[^?[`0K?[FZ38?[F\\#?ZV\?ZXE?Z|Q?Z|S?ZLHDQ?ZM?YFY?YG?YM?N?YMAR?X8>?X:V?X1dl?X2a'?X)[G?X*u?W ̧H?W";W?WTba?WT&?Vz?V?Vg?ViM?V$Sq"?V$.?U&ev?Ud?UZsF?UZ*?T;2?Tש7?T}5?T묖?T+9?T+6?SƮpH?SƯ3?Sa"?Sa?RO*?R?RW?RdY?R2rd?R2sJH?Qa0?Qc$?QhP(]?QhR=g?Q?bJ?Q@"?P-r?P.C"?P9|?P9gJ?O?O	g%?Ons?On%?O	iկ?O	?N?NI'?N?Z?N?5?Mڡ0$?Mڢ#B?Mu{?Mu?MtsS?Muᜲ?L]O?L^D?LFEGT?LFG)w?K-y?K.\?K|Ȫ?K|6~?K?K?JۛH?JI`?JLǟ\R?JL
?IߞJ?IMU?IF(?I	u?Iuxh?IwC!?HYI?HZ?HS<0?HS>+"?Gmj?G ?G@?G@?G#B?G#t?FiO?F?FY4?FYza?E-?E$#?Ed?>?>rƐ?>r~?>
?>
n?=q?=s\8?=CF?=CHJi?<J?<o-??7Uަ?6QTZ?6R(?6w?6 ?6%!T?6%t?5F?5_q?5[b?5[??4J3]?4K?4{0?4?4+s?4+.I?3ƦT܂?3Ƨ
?3anh?3ap"?26f?28?2J?2g.q?21ު8?21J??1̋C'f?1̌,K?1gQ(R?1gR?1D?1?0vOr?0>?07?07J?/c?/e4?%X?%$S)?%$T-}?$	O@^?$
Y?$Yt?$Yc?#t%?#u?#(.?#*A2N?#)
T?#)uR?"ĐE?"Ē-;?"_CF?"_Eh?!?!(?!9Z?!l?!/Z?!/\3`? ? 
e? d? dOB?m9 ?nO%?q?}.?4o,?4i?{Q?|c?j)I-?j+"?ףX?S?Mw?{?:2?:3kk?ug?ߝY?onE?o؞?
5?
7VR??X??vT??s?5-?6,?t)=?t`?,??0P?23c-?Dr?DU`,?߀?߁?z'X?z)*?r?j?tP?v~?Ji?J?俭f?O?dx`P?ey?,?
2?k*?	u?OOTt?OQfW?ߟ?I?I0?%?79j*?8X?ذ0
??Ty?T{H?1I??<1?Η?$Yv?$[8??Q?Y#?Y?5?7?VQ?Կ?)p?)qT?
>M??^|V?^e?EB?FX-???.{d}?.|΁\?
S/?
*?
c(	?
c?I?Jz<\?Ko?m?3z?T?'q?H?jn?l~?Q??P?P[?
-x?;?ȕ?1`? ? VaK?x??U-?U/@0?ﵜ?
?TB?$  ?$.o?J+?K_??Y?YуR`?U?VE?ڛ??)_-?)`D?IrC?䱗$?^f'?^hY,?$!l?8?lf?nJ?-,ґ?-?qG?rjl?bd?b?sQ3?ty
?j?0V8?2sȢ8?2u0?TɁ??grl?gsԪB?R?xq?o@b?pg[?6?6d?jEp?k?k]!?k?cz5@?d?gk?'?;ZZ[?;\Hq?\?OrL?pPz?pQ?
ʚ?
G5?DGj?E??/???6Gd?76?t?t?&|?'?艹$?著R?DPq?DM
?ދoG?ތ֖C?y|?y?w)?x"@?[Z?Y?HaBf?Hbt??hb??}ID
{?}J1?VE?r?/t?1γ?L*h?Lv?<??ꁅو?ꁇ@T?	?l?g}?i%?P%>?Pn?Gݧ?ID?腷B?腸l? &60? 's?纔z?纖Hp?Ub?U0)8?pi8?qO?ݗ?#?$JU_?$K3?徶?徸?Y"}
?Y#?կ?Oq[?9?Ib?(cl
?(dӋh?͆!?W?]7.?]8@?fC?m+?	.?
bi?,qإ?,rB>?n#??a@$?aBL?J?T!n???0t?0vՓ?e8?+?e??eAΒ??y?ޚG?ޚ
Wp?4lI?4nOk?op?ջW?i3iz?i4}9?.X??ܝf&k?ܝ+?8Z/?8[1?һ?Ҽ?msH?mلB?|3?~U?ڡ{?ڡa$?<<2?<=?֛?֝.?p{?pH?XS?ZA?إŪ?إ$?@3?@ld?q:d5?r?tҵ?t8]?)?+b!?֩[?֩}t?C?Clw?;?=L?xYF?xR?]c?W?ԭI?ԭKZU?Gy?GS??>?|T'm?|UD??m1?ұ|(?ұ{n?KZN?K[?`?岁?рF?рX?]?^f9?дN?д?O/ ?Oв?[z?]9?σ?σ?DU?n?θVr/?θW:?R2?Rd?@J??Ǒ?,2s?,3?}M?~1n?`Ǣو?`N?.??ŕ[?ŕ\p*?/!i?/x}?u?-``?d5U2?d6h?|?~9'?Ø:T?ØŞ?35?35?QnJ?S*e?gx?gPi?ݨ2??"+?$^.?6gg?6iE~?Ь^j?Эŵ?jqp?j?42?54?㿟wZ?㿟xf?90A?95v?0?P?n>?n@u?7T8?2]?㽢f/?㽢d*?=,\?=,`?B?C[?q|aD?q"?&?jUy?㻦'Y?㻦t?@??@AC?~/V?p?t?tyX?p??㹩6?㹩8(
?CsU&1?Ct\?ݯE?ݰF?wt=?wP?&J?(IM?㷬ay|?㷬cP?F8?F?‰?%?{?{?Il?KZC?㵯?㵯W9?I1?Iѳ?t??~+~?~,?b?d@7?㳲?㳲6?Lb?L}?d??㲁J?W-?47?6	?ニ*?%De-?%Eŭ?タK?タMj~?YR?YT$?Y9W?Zjv?き_nj?き`Ͱ[?'eD?'fb?j ?lV?[oo?[q4P?t?ua
?x>m?zMv?)|Ү?)~MC?~À?~ÁA?~]j?~]2$?})?}x?}B,?}?}+m?}+d?|ō:a?|Ŏ%?|_h?|_	?{y?{o?{s?{O?{-ˁ?{-*?zǐ?zǒ&?zaevw?zađ$?y
j?y?y?yf?y/d?y/r?xɋ>?xɌ?xc?xck`?w{\h?wK?wޖ?w?w1C޳?w1?v|]?v}7?vex?vey]Y?ut;e?uu1b?uo?upg?u3jh?u3kbh?tdv?tfS?tg_%|?tg`=j?tX '?tZX?sRrФ?sSq4?s5KR?s5Lg?rDQ+?rE]?ri<ӹ?ri>^?r48%?r6?q,o?q-j?q7#`?q7%!Մ?pd?p?pkX?pk?pu?p?oK?oߤ?o8
 J?o8kq?n>?nL?nl???nlrh?nя?n?mŰ
?m?m:v}?m:?lԬcv?lԮ@?ln1?lnQm?lı?lܾ?k!?kd1?k+?i>-q?h/6?h
?hr)[?hr?hY?h?g/?g?g?׬?g?
|?f?f-?fsj?fs?f
P?f
h-?e!W?egg?eAzψ?eA|=mh?dgD?dhm?duSP:?duTw?d??d@a?c*^Y?c+?cC_ـ?cCSp?b?bf?bvX?bvO?bPW?bխ?a?aM"?aD6?aD?`ސ%
?`ޑ\]?`xxV9?`xz?``?`bV?_Hߨ?_J?\?)?\{{M	?\{}L?\`q?\aY?[D??[FD?[I)s!?[I*c]K?Z$?Z*?Z|>?Z|?ZW'K?ZԳ?Y=?Yv;?YJ;$~?T%|?T?T-?Tt\?S?S;'?SN:?SNF?R@?R蒝 ?RmVs?RoMi?RJJ?RKD?Q&N?Q'CP?QPn?QPWj?PSWJ?Pޯ|?PU?P?P?P_8o?Om[
?On'D?OQG]?OQH?N!?N"g?NdK?NO?Nh ?N?M?Ms?MRq*?MRh?L\v~?L]Ғ?L4'
?L5d ?L 
?L ߜ?K⋘?Kj?KS>?KSe?J폝?J?Jen?Jg?J!;_x?J!<-?I
?I`?ITб?IT,Xh?He?H?H8?HMЭ?H"cW?H"d`?G6Ĵ?G8 >H?GV
0m?GV?FH?Fޤ:#?F
?Fh?F#~?F#]?ET?EUr?EW&f?EW'8?Dd?>B?>3Yn?>=?>',?>'?=z7?=|/
?=[F)?=[Gȕ?<-?<|?<&?<:N?<(@?<(?;pP5?;q?;\:
?;\;h?:zuC?:?:̕"?:Al?:)_?:)?9]R?9_2?9]&*?9]'Z=?84?81s?8[?8b?8*|?8*}U?7Cq
h?7DtP?7^
?7^\?6C1K?6ѝ?632?6,?6+[ҹ?6+]-?5!!l?5"|V?5^ G?5^z|?4Ι?4(}?4o,C?4pݕ?4,3:{?4,4ț?3?3R?3_fM?3_hs?2}?2~,X?2@R
?2A?2-;?2-*@!?1?1X?1`ݙ=?1`7?0Hl?0I]?0	?0)?0-ʝ;?0-?/Nj>P?/nj)?/aK2?/aL?.?.7?.F?.̠Pc?..!?..?-I?-K?-ba?-b	T?,?,YXB?,)?,+?,/C?,/D]M?+?+}?+bʮ?+b$9?*z?*|f?*7V?*8n?*/v?*/{?)ɯ1?)ɱ?)ck]?)cl}r?(&?((C?(ڧ?(3?(0pZ?(0z?'W L?'Xy?'dNZ?'d?&.>?&̇?&F$?&zu?&1>^?&1?_?%f?%VP?%d?%d?$h?$i]?$ /?$!m$~?$1EK?$1/Ng?#ˏKX?#ːZ?#eFsN?#eGIE?"Na?"UA?"܃e?"5o?"2j?"2kv?! Y@?!!k7&?!eպ9?!eO? ? nPB? @$L.? A}x? 2曱? 2?\?̩\}?̪7?f]??f^?b	?p?;?J?3x5&?3y-7?+,ф?,gb?f'?f0?7cg??BJ?C`
?3tD?3jQ?ͥj?ͦb?gV?gX.?{^??<Ќ?,?4h2?4i:?!?o?gDg4?gɜ?w?y.?&t%?()]?4էv0?44?΄2y?΅?h2rD?h3ʾ?g?0??j?5;r ?5<ʤ??i?hR?ha?AaP?C+X?	'?atR?5t?5M]y?E#I?F?hn?hF?] ?T0y?F	?H.?58?5Ý?ϛgS+?Ϝ?iEK?iFw?摕?>@?7?O?6A?
?6B??T?iqD?i)?:?;A=?~??6H?6nő?
1f?
2"?
imF?
iĀ?
*?
?%	?&i?6ʩ?6"d?q ?s?jG?j
J?g|??
ab?
b?
7b?
70x?	ЪB?	Ь2p=?	jO'?	jPbN?	և?	I?l??79?7;@?IG?PR?jل?j?"@z?#u?xX?K?7fh?7ga?-V?	h?jqs?jRH?J?Kp?Z;?
?7e?7:.?,%E?-|K?jv?jv?k"Z?m)k???0?7dŪ?7jO?IC?J?jt"?j1
]?+"?(?$5%?%?7@0?7N?_t	?`bn?j
?j??5?6D.?7o?7ҧG?7?n?\?p?k
N?kVq?+?y?Av~?B̾?7{V?7я?w:U.?xz?k?k	?D?=g?EC?G+_7?7}0?7?x?z6?k
?kT?3?-?Ci?D?7۶E?76?s ?uR?koO?kQK??S?:6"?;v?7*r$?7Ҁ>~?g{?i/A
?jC>?j,?iw?-?*J
?+_?7["?7=m?U??VS4?jSy?j?X?#`Y?x?.??7$?7La?;?=Oq?jϹt4?j?c5?d~$?l?g&?7a?7x3??f?j~?ҍ?4?7d0?7e??H?jQS?j?|?ڣ?읨?읩p.?78n?79?~f-?w?jXJ?jYG?,?).?w?xoD?7K?7sG?Д?Ж5w?j#_?j$z?!6???=(?@J?6N1?6Σ?Z?\?ia?iL#T?tx?v=??9?6?6ZÌ?1?O?i?ipN?1Q?3E?䜽+?䜾?6HPS?6I?3?Ԉc?i]pi?i_*?7w??rWA>?s*?55?5Z?υӉ?χ'?i0#?ix?KҜ? ?!&?"zy?5?5W?2?3n?h2~?h8?B
?C^1?ޛɠ4?ޛ?5P?5RJ??`8?h^F?h`6
g?w)5?/?ܛk&B?ܛm $?4j?45
?wv?y	ߺ?gJ?g??Ԋ?ڛ4?ڛ		H?4?4}? 8?teh?gv"?gʪ?G?g?ؚe'?ؚƱ?4 	?4"PF?ͤU&?ͥiA?g'o`r?ԙ.?37a`?38?̸Eo~?̹n?f8?f:>ow?RF?Q?ҙ9{8?ҙ:΂?2e9?2K?9&?:db?e~Ά?e)?7QR?9~?Иz?И?25Se?26?˳.?˵Fi?e23?e3TC?q?Nz?Θ-"?Θ/%?177Q?125?(x?)?d}@7?d,?"D#x?#?̗h?̗ n?1]?1m4g?ʗ)ζ?ʘ|K?d8?dO=??x?ʗ	;U?ʗ?c{,?^???Ȗo?ȖpiKb?/R?/V6?b5?d?b(x?bz'?U`?V?ƕ\sS?ƕϮ?/GDm?/Hn?ȿ+k??b7?b9:@+?U?E?ĕ'?ĕ)G\?.VW?.1?7?v?a?a#??D?”{R
?”|?-??-a`?gi?i>?`ZH?`2n*?Sa?T
?-?hҞ?->Y?-??ƳaG?ƴ>?`(.:?`))?j?Sw?⾓?⾓iS?,4;?,Z??h?_lB?_n?,=?~:?⼒S_X?⼒T1?+X8-?+ǩ1?9?:h?^?^,:??7?⺑
?⺑H@,?+U@?+)?sj1?tH?]e?]L?U?WH^?⸐?⸐7?*7w$?*8?è(?éj8?][?]?e}?3?ⶏ5r?ⶏ7]?)g}?)iO/?+/6?|q?\FPD?\G;??ⲎKnF?'|?'ͽ@?$,?%m?Z?Z?I^?I?Ⰽj?Ⰽlt?&+u?&_?C]?Dmm?Y?YC??c?⮌\t?⮌I?%'}?%x6?⭿\u?⭿]o{?XF?X/?1g?R?2?⬋S?⬋?%?%"?⫾o:?⫾q?W_?Wگy?BY?D#R?⪊}?⪊_?$?$e?⩽}?⩽4(?V{w?V?Nܻ\?P-?⨉ ?⨉Wu?#?# K@?⧼?⧼[?U>?Uf?U?VN7?⦈?⦈0?"#r?"$8?⥻::?⥻\c?Tr?T?VU?XCo?⤇N?⤇NZ?!"ŝ?!$#D?⣺s{ ?⣺x?SP?S-F?S~?Tam?⢆?⢆`?  J? )?⡹lX?⡹?R
?R ?IF?KC ?⠅?⠅7N?
??⟸u/p?⟸v%?Q؃0?Qw$?;!?<Ȱ?➄u?➄?B??❷c`?❷ehm?P?P_y?('l4?)v?✃
g?✃Yt??`?⛶M3	?⛶Nv?Ox?OL[??;?⚂pg?⚂qL?k:?`??♵1?♵2?N(>?Ni??$?☁Q?☁R?U??◴?◴1.?Mpn?MqU??a*?▀-?▀/9
??ݐ?╲.?╲N?LI=|?LJ?H(?娗;?Kg?z?{U?}\?}تJ?4?5QW?⑰wg?⑰ ?I8?I?Hȣ?JM?|?|Wg?Px?\?⏯[?⏯]7?H?H^?$?r?{mn?{nTx?Ƕ?v&?⍮"5'?⍮#$?G|i?G},?֝?%O?z0^?z1ո??]??⋬?⋬C?F=+"?F>io?ߖ?Q?ߗ@?x1'?xR?G?IA:?≫FD?≫m?D?D0Y?Q?R^?wP-?w\b3?ҙ?(e?⇪Xv?⇪Yĥ@?Co?C/?d$?jYA?v^&ox?v_t][?i?M?Ⅹ2?ⅩH?Bb"	[?Bco?۸j?۹?u@s?u
1?dkV?et?⃧$?⃧q?A?A@?e?fRdz?s-?s{~b?
&&?
tp?⁦c/`?⁦e=ƃ????}?6?AS?ra/?rb|"?:xR??	?
d?>\ÌS?>^?~װAF\?~ױ?~q?~qK9?~
V?~
W(?}C#?}?}a?oU?o25?o2?n( ?n)m='?netO
?neu8?mR?m?m)?m
u?m1WW?m1Y }?lʣSBb?lʤa?lcdP?lc|R?jP?jbd	?jbf?i?iR
?i(˕?it?i.C ;?i.Dl?hnjyL?hǎ8P ?h`֍X?h`{?g F?g!O?giOP?gjs?g,ojR?g,$9?fd?f5?f_D/?f_E{W=?eȋ?el?eEG.?e֐'?e+]?e+{?de?dfmV?d]?d]?cr?cx?c=?c>`?c)2?c)}?bh?b$L?b\?b\H;?aY:&?a[A?aT?a?a'k?a'Q?`-E?`/2s?`Zt9?`Zu?_bL?_?_a?_X?_&F7?_&G;?^I=?^/k@?^Xg?^XҲ?].?]
BM?][b?]]>no?]$l?]$F?\ڬ?\%?\W*?\W+߲?[o9?[pi)U?[|?[ˡ?["g?["	P?Z;v?Z=#?ZUȒ?ZU?Y~ ?YɻU?Y?Ycz?Y!J5?Y!KT?XM?X%?XS4?XS>?W?W7?WV?WXe?Wf?W?Vn?V1^?VR@j?VR+?U`qi?UaG?U{?UŐ,?U\?Uj?T&4?T'a?TPgU?TPhmC?Sx?S_l?SYw?S0?S+v9?S,(?RlkR?RmP?RN:2?RNY?Q?Q+Q?Q.b?Q/(?Qnc?Qpp?P݋?P:\?PLNE?PLFk?O.?O0,2xR?@>yTy??ײ!(??׳j??p3??p] ??
%??
'+V?>_?>`?><?><^?=y?=±?=o
?=o
t?=D0b?=F ?<}m?<(?<:?<:=?;]b?;;?;m'o?;m)7.?;`\?;a?0b?0잀?0a?0/!yi?0/"D?/V3cr?/W{6?/ai)?/a5Y?.D?.{?.V?.x?.-'>?.-)4?-[I?-]1K?-_y?-_'!?,ôV?,|?,i?,}?,+*k?,+,F@?+^s57?+_B?+]?+]?*e?*DH?*?*Z1?*)+-?*),O?)]?)_%1?)[?)[i?()]?(qJ?(A?(d?(''?(')>?'Z/.?'[vq?'YGlz?'Y?&@I/?&}^?&p?&aa?&%!k?&%#\?%SoC?%Tݺ?%W?%W3#?$IeE?$uB?$|?$;?$#Z?$#\6?#I6P?#J0?#UzM?#U{@?"MF?"?"`?"9?"!yW_?"!
4?!(C?!Sm+$?!Snqi? V|? 잝\? cչ? Ϊ? R? ?-$?.jr?Q\?Q^}?l??ꍲ4??*?>?>?{?)=?OI?OJᆆ?x?yg?fm?d?Hn?׎߅?t?wj?C=?Dx?o"a?ph?B?B1?ƚ?B?t-?tsd??dd?I?JH07?@tDr?@u?ٟk:?٠?rw+?r˼u?h3?F?
 >d%?
!9?
>JD?
>L?U?uz?v+?p!?pfq
?	ʌ?	7?P?#?<E0?< Z?
I1@?
Jw.?
ns4q(?
ntyN?
?
a?	?	0
@?	9?	93K?9O?~e?lCV?lDH?m Bq?neI%?m?q?7>?77???jQ?j?:h?;K#?cm?dpF?5!w6?5fK:?δ?ζ?g?l?gބ2#?R?ќ?-Կ?/>?3V1?3WvU?~Pw?U?eVN?e?DzU?ωj?q$?^?1ұ?1^K?Ey?F;?cm'?cnI8?x^=??5d??.*?.Z9?
@a?v?̭g?
?^H?^o??2b?@77?A|n?*f`p?*gi?Ì^??Î
u?\~?\3?M?AV?Y~?8[?($:?(&5?J"?K?ZpNT?Zq?J?./?o??%X#?%".?6O?zM?X+w?X,}?P?QQ?u?v?#T?#?'?Z@?Un1?U屾?	)c?
mn?-·?/4?!R]?!S$?vֽ?xC?S9_?S}h?쿇7R?ʯ??N'?m?	$*X?+?-0i?QO?QQ'h?s@?uLp?,??G5B?z?\?+y?OtB
?OyE?%?'.?N?$?>???Jao?Jb?Ə?[?|S?|3?-?p?&?ܧ?H
^?H4?06n?1x?zRf+?zSB?tM?u?欖?欗_!?EO?E;?`F?ۢ?w-:?wp??z?*
??ϸ?@Y?Ca ^?CbcO?܂g?܃?u?uO)?e?ƨP[??K?A?A	!2?(?*A#?sJ\?sKN.?kp?lHO?ोq&?्/?>?>Q?̈́(?Z?p3?pu?
Іj?
d?ޣ/[	?ޣ0&?O??Ҕ+?Ҕ?-9#?-z_?Ok?߄Y?`:=h?`<5k?Y;?Z|A.?Вwr"?ВxB"?+X??+p4?ijE?Ĵ?]Ѹ?]ʕ?
??ΐ
?r?C"?᭚I?᭚)G.?4&?4
ș?"0p?#?f?ל:?ᩕ?ᩕ'M?/	kB?/
Lt?"R?$#E?a?ᥐV}?*
?*?ұ?!x?\8d?\:.g.?R?SD?ᣎk?ᣎlQ?'>?'W??U@?Y-?YL2??;fG?ᡋ?ᡋ"/?%P?%?ᠾcV?ᠾ$`?W2n~?W38g?K8T?LvX?៉c%?៉e8s?"|n?"}?ុjY?ុn(?T2|?TU?ƿ3?4?ᝆa^e?ᝆx?x?9?᜹?᜹m?R)y?R*\G?AG?B,?ᛄZ'HX?ᛄ[d0?r;?sK?ᚶ[y?ᚶS?O?O?{?)m?ᙁNp?ᙁՋD?X ??ᘴN?ᘴ=~?MPjM?M.?5	?6۬?MM
?Ogm?f$?g[7?ᖱ~Wd?ᖱp?Jn?J!?㮹Zf?W?|;?|1??Bn?ᔮ$?ᔮ`J?H=?Hy5?'P?(?z?_?z@?Wi3?XX?ᒬonpt?ᒬp3?En?E>?ޟi?ޠn?w`=?w;?S"]?Џ?ᐩB?ᐩN!?B-k?Cjca?j?Q%!?u.?u03[?Fg?H
?Ꭷ^?Ꭷ_?@v?@w6?َW؀?ُD?r&?rbn?b?,?ጤն?ጤ7?=y+?=?8?u&?pX?p0?	4b?	5i?ኢL`6?ኢM?;dr?;eN:?{
?|?mj$?m??M,?ሟ¶#?ሟ1?8WUv?8ۓ\??1?k	?k
͇?!)@x?"e1?ᆝ88?ᆝ9G?6PQ?6Q?g3?i?ho'?hy??6?ᄚt?ᄚ:?3
>?3F?ݑA?3?e?eQ/??
P?႘$?႘%S~?1; ?1<Ѻ?S?TN.?cj=^?ck:?-n?A?ပ}t?ပ?..?..?gW
?ɢ?`	>?`p?~Ka?~?~h?~?~,&*9?~,'e?}=?}>?}^UG?}^V??|lo5?|m]?|?|P?|)Cj?|)~?{²M?{³tJ?{[7Q?{[OV}?z{g?z?z?ze?z'G?z'?y'W?y(Y??yY?Q?yY@MK?xVv?xW?xmA6?xo-?x$?GN?x$z,?w+k?w	_?wV?wVB?vnE?v̩=?vԝ?ve9?v!;1?v!u?u6?u?uT)	H?uT*C?t@p?tA?tW&?tY?toA:?tp|?sAy?s?sQG=?sQO}?r굀H?r궺I?r뻲?r&;t?rX@?r咹E?qŸ?q)G?qO46?qOn?p*2?p+4?pB?pCNo?pY?pZ?op?or4!?oLn?oL_?nD?n?n~\?n~Q?nD?nt?mO
?m!?mIg?mI?lJ?la?l|,ʙ	?l|.?lDLx?lE?k[S?k]
X>?kGsV0?kGt.R?j\?jq?jyi{?jyj?jh9?j2O?iщ?iì9?iD?iDW2?h$?h?hwM0E?hw?h/?h1"?gGb?gHE?gB_(?gB`b?fv::?fx?fttx?ft2?f
b?f
Xv?eJ?e?e?|ڂ?e?ֶk%?d0?dj2?drF?dr!Sk?dU?d?c4`B?c5>?c=L!?c=M["?bc?be 
?bo{I?bo|觠?b{U?b?aK.?a	?a:?a:X?`r?`0?`l0?`li?`
?`%A?_"6?_#g?_8:~r?_8;
d?^Rk,?^SI2?^jj[Ȼ?^jk0?^P?^=?]K\j?]ca?]5KO?]5?\Q)
?\ˊ!?\g[4?\g&'?\jz?\u?[}?[?[3*?[3+ςM?ZB?ZCXT?ZeZj'?Ze\7&?Yr?Yt8Ng?Y,?YeL?Y0_?Y0J?Xɻ.?XɼS2?Xb,?Xb
?W*?WP?W`?W>5?W.e?W.mm?V5?V6;S?V`M\f?V`Nf?Ue?Ufq0?U~![?UY?U+?U+?TĮ?Tİ6w?T]uf?T]Ȯ?SP?S+?Sw=?S?S){?S)9n?R)?R*HZ?R[B)"?R[CaR7?QZƛ?Q[Ч?Qsj?Qtt?Q&^?Q&M?P?P4?PX?PX?ODP?O}
?O
?OE?O$!?O$	>?N H?N!C?NV9Џ?NV:.?MRy?MS
?Mkf޵?Ml?M![?M!e?LW?LM?LS[?LSUM?Kf?KО?Kz
?K?K?K̴?J.?Jc?JQ3Y?JQ5C?IM?INL?IfOY?IgL?Iy?I?Hf?H?HN0R?HNh&C?Gˌ?GÖe?Gr?G'm?G\<%?GY?F?Fb?FL1NS?FL2p?EJM?EL>?E~dbl?E~eO?E}w?E1?Di?D$?DIC߉?DI{?C\5?C.r?C{_?C{?C|?C^?BM6A?BW?BG2':.?BG3^Tp?AL
?AMA?AyeC?Ayg.?A%d?A%)?@Sr?@%P?@DI2?@D/?:??~??BG??v)y??v`h??P??/?>h:?>AF?>B6?>B7?=Q?=R:MK?=tkSOu?=tl?=
R4?=
F?<
?V?+^:tN?*UU?*V˔?*r1N?*sfL?*),/?*)?)«^)?)¬4?)[	3?)[?KD?(Ë?(?(?(\{?('`]?('?';DF?'?'YYk1?&u5r?&vk?&D?&y6s?&$`?&$5?%̋`I?%x'?%Vĩ?%VS?$yd?$A?$$bܿ?$%?$"A?$"B?#_;?#`pz?#T|	?#T}?"OU?"후:?"T?"$j=?"՞A?"ӊ?!\?!&?!R*.?!R^? /? 0;p? L^D? N'? jN6? l"??,K?O\?OF?:?o%a?sS%???Q? ʢ?!HQ?M>}?M??\?^,On?{$?|c?'?Q(?Ȝ??J׃?JظK%?O??}+r?}_y?4(?5Lb?S(?TIgB?Hr"_?HsV?@?u?zoҌ?z[?ϯx,?㙼?t?4?Fag?Fz?-Z?//?xMW/?xN3?l.{;?>b!?
?ڮ?q.3+?q/f?
N?
P?o.?p?U?xt?w?7+?7+?
?
8?
j1?
j d?
@(?
BL
?	b?	c?	5v?	5?ΦY?Χg?gȒL?gS?ꬻ@?߻?4?
?3/M?30O?Qr?\6$
2?cD@?du?K͒?}x?j?+?Pՠ]?P?\?W?"Q?#d?H?I?o_?pS?N	?N;tO?˹?+??d?
?+?1T-?2ϯ?LX?LYR??'I?~Fi?~w%?ή6?u}?-p?_0?Jў?J?Eu`?Fr?|m=W?|no*?R?Omy?쮽g?쮾H?G(1?x?)..?*_?R!F?SR?C{-T?C|^]?ܤS%?ܥ?u͒?uA?s?!
? \F?!?AID?AK9?s
?tH?sK&?s{?#_?T	!??F&??!??R"?EG>?FwG?qoc?qp?
O?
f?UY?Ņ%??ͅ?f.?f??ޢR?S?ؙ?ؙ_?28!?2:$j2?fGv?gwkI?d?d,?BX?q2?֖?֖p1?0#?0D?J?Ksw?bx?by
?Ȋ?0?Ԕo?ԔБ?.+=?.[?1?2?``&_t?`aU?0?#"?Ғ=?ҒzI?+vj?+?u?	3?^J,?^KS?y˦?zƔ?А"J?АQc6?)ؗ)?)n?,?	[?\7	6?\9?g?h@?Ύv?Ύ?'ǨT9?'AL?џ??Z(ߚ?Z)G2?X~?Y?̌L?̌0?%?%u?˾b+o?˾?X?h?Xn?L;?Mj?ʊ}V:?ʊ~?#~?#-?ɼ9K?ɼּ?V[?V	?B_@?D6?Ȉtm4?Ȉu?!u'?!Z?ǺeL?Ǻٔ;?T
u5.?T1??öw?öӥ6?P7?Pa"?9*2?:Y?‚ld?‚mC?_D?-?*,?X$?N[?N	B?<?=L"?pI?qw?Z?Jw?࿲{{?࿲-c?L
#?La?B6I?CdJ?~w?~x0??R?཰W8?཰+?J+d?JY!?Kz4?L?|?|}g?z7??໮+?໮Y/?H!?H#+?W8 ?Y?z|?z32?;=z?h?๬v?๬`?F1
2v?F27#?g\?h?x^?xM?:?hI?෫82?෫
f(?DCXPl?DD?z?{?v*?v+l?醔?Ͼ?൩!1 ?൩"^F?BX?BZ*3?ې:?ےK?t?t*?1?^$?೧9?೧:D?@q?@s,&?٪u?٫V?rWI?rC?7M?d@*?౥U:?౥Vf?>_K?>d:?ǧ*?ԩ?q-?q?Т?
:)?
;?௣tRd?௣u+
?<&5?
?ࣘyio?1SLn?13???d2?d4?qr?r?ࡖ#?ࡖIe?/?/U?-?/\?bl?bn*?@,|?kF?
?Ұ_?.+3:?.,_Z?jY.?lC?`h?`pA?jb??*?,
?,k,ۇ?,lXU?ū?Ŭ?^:D?^f4?,j?.'?m?o ?*,?*$?)O?T?]1o?]2?s	"?t4c?p?ީ?(??(?8}'5?9Q?[z?[{?D ?`8?Q)?|>?'Ac?'CqE?V??Ydžx?Yȱ?
}H?u5?MŇ?Nx[?% F5?%K/?ԢJ?͆?XL?Xw	?\`?]I!?{?CU?#:QP?#e?(?)ʹ?Vlߨ?Vn z?ﱏM?ﲺ~?Q?|9?";<_6?"I??O?Q"7??V?Ϩ?ސ?K-҃?K.=H?x?yD{X?}?}÷I2?
-6?V/?WF(?Y"?I?I6???|g?|E(?|E1?{ir^?{j,?{wO.?{wxIT?{W?{U?zS)?zT5?zCt?zCU?yz7?y4?yv?3τ?yv@\?y&?u?u?td?t?t?Ne?t?Ok?s؟I?sؠ
?sq0%?sqYP?sB)?sC[?rz?r/?r=d(?r=猝#?q8{?q9?qp?qp#?q	3t?q	\F	?p/?p0m?p8?cD?clq?b_?bi5?b3Hܰ?b3I/?a̢%3?ạLg?ae16?aeu?`U;?`V?`n?`I?`2	:?`2 h?_dh,b?_eT!?_d?_d//G?^G?^?^t
?^v?^0
;?^04?]+r?],?]cc?]c.`?\?\?\??\/k?\/}?[TR?[{?[bS?[bU!?Z?Zυ?Z
|?ZF?Z.j2C?Z.k?Y?YC8?Ya%?Ya&h?Xd?XV?XS ?Xz?X-?uL4?X-@?WƝ?Wƞ亮?W_O5?W_u?V[ʨ?V\.Si?V?M?MЄ ?MZx6
e?MZy[?LQ?Lm?L?9?LA?L& ?L&7X?Kn?K	W?KYm^?>?>mJ?>n@?>ؚC?>ٿT?=DP?=Et~?=R<%?=Ra?<`sZ?<&?<#|??8I?8>{?8@G?7-l?7?7Pt?7P$~?6d?6鍈S?6[?6#T?6kԷ%?6l?5i#?5K?5OL,nz?5OMPh?4輬?4
O?4-e?4.H?4Wv?4{?3?3?3N~?3N?2P?2?2dT{?2exrv?2a?2ׅ?1H?1I?1M'D?1MJ?0-5?0/?0ЌX?0_?0?0 ?/^x?/N?/L
?/L}?.n*h?.o?.?.?.W+;?.XN?-ˮ
-?-Ѫ?-L@jp?-LA	?,`w?,嶄
*?,*D?,+?,[?,X5?+=r?+?+Kz?+Kp?*?*^?*~w<\?*~yU?*n?*	M?)e4<&?)fW?)J6~?)JYc?(StwL?(Td?(}t?(}?(B5?(CT?'w ?'?'J2?'J3۾?&?&??&}#]?&}$|W?&/?&G>?%?%R?%I?%I?$?$	?$|K/4?$|n)?$L?$oe?#v~?#wjY?#Hg?#H$m?"ka?"l>?"{椈?"{_e?"aA?"b6?!5?!Xj?!HX׵?!HYv? Ե~v? 8-? {P ? {Q҆? $@? GI?I?Jع?Gƃ?GǦ!q?C?Dj?zҔ?z"?>T\??v?c?4?G:?G;/*?C_?e+?z6m?z7?l??4]R?5x?F?FS3?2$?4ݕ?y?yd?2.?30?n?Ŧ]?F3^?F4$?߳~?ߴI?y4wL?y5p???6,?8?Etz?EM?:Cj?;e?xPu?xrs?>>???#?Dl?EC?EE
*?컅??xJ.n?xKPH?ͮT??Qk?Rv?Dg?D։D8?Y^?Z?wv?w;,?b>?c?z?"I?Dl'?Dn-f?i??wx?wy:??)>?7?X(?D
r?D;?ݑV?ݒxD?wE8&?wf?r?:R?
&ߠ:?
(?
C?
C?6v?7I?v?v`?G?H-$1?ϵ??CXk?CYn?
ǥ\?
)?
vk0-*?
vlQR?
o?
:?	~&?	N?	C?	C
	?ܓP^?ܔqgz?vE?vG?8$?2p?4>?5)2?Bpp?B\~?K?L9?u
?u"e{?c*h?dKv???B|=?B}^?	(~>?
I>?uS?utH?#I?$?k?j?B?X?B@yl?͉$?Ω?u[?u]+?9Q?i?y#S?zǪ4?Bj?B	g?ۘW?ۙwv?u(8{?u)1??-N?PO?Py???WX?T?$?X???P:\?Pv:"?@R?eb?g	~?X??OX?OE?O??	>?	٨?1Zf?3(?[2?]?O{9?OW^?҃?i?߲e?߱=Q?߱x?߰
?߰#?߰ c?߰ e0?߯S?߯S6[?߮?߮Bk?߭h?߭jߟ?߬?߬
{?߬! ?߬!pI?߫Tr#?߫Tu}?ߪD?ߪ?ߩ':?ߩ)uc?ߨ@ը?ߨ{.?ߨ!?ߨ!?ߧU:"9?ߧU<=?ߦ?ߦ
?ߥ8F?ߥH(?ߤQR:?ߤT)?ߤ"c?ߤ"f?ߣViU?ߣVa?ߢop+?ߢq7?wcuk?vQV?v{?u?u6+*?tG?t~?t1*?t1aٺ?sd?sd^?rw?r
T?qˌv?qˎɫ?pѹ?p?p2?p2ѡ?of8?ofov?n[{(?n7?m(Ш?m*PWQ?mtY?m?l47n1?l49.?kg
?kg@?jICAi?jKy|?ic?iO?i]S?i_š?h5k?h5э?gitH?giv~b?f4?f9?eЍ{Y?eЏPK?e ?e7	?d7$m?d7ZT?ck7P	?ck:?bE"?b{??aWCN?aYy5?az?a#?`9yd?`9{OVR?_m
?_m
()?^j?DG|{?DG௳?C{_.?C{c?B.妄?B1#?A?AC?A3?Ap?@J,NO?@J.W??}c`_??}ٖD?>[j?>O?=/yi?=1?=z?=ޭǶ??﹯?ﹲx?x߄?w5?!ȏy?!?U}?Um?nQ?pE?_޺?b?Y8na5?Y:Q?,1?.?!N?#e?7?d$?)
CL?)?ެ?ެ4?ޫ6vI|?ޫ6?ުj,2?ުj/?ީZ?ީ\5?ި҇g?ިҊ/d?ި?Ow	/?Nӊ?N9'(?N"wU?N"5?MWxS?MWI?Lu?L7?KC?K^1?J
7?J/C?J)*P?J),0?I]?I]3?H@y\?HB]?G?Gϕ?FZT?F\@F?F/&lH?F/H"N?Edv?Edy?D%^?Dþ?C͗/?C͙7?C(Y&4?C*z?B6k#?B6F?AkMLC?AkOm%?@?@??u|??w	??	
??	0?>=?>=܏?=r7c4?=r9{?<ϗ?<Ѹ?;h&[E?;jGW?;?;?:Dwf?:DV?9y6?9y8r?8қ҈?8Լ?7oG#q?7qgר?7û?7`?6K?6K2EP?5J1!?5LQ%?4"7?4B?3?3p?3,y?3.?2R:8?2R0?1r?1t9?0#_?0C?/р?/ ?/%`_?/%bvj?.Z2:?.Z	R?-ML?-GZ?,VF?,X?+J?+(?+,v6?+,P?*aTM?*aV7Y?)?)E?(ʫK?(ʭ?'X(?'[?'45,?'4?&h.?&h?%e2$?%gRX?$?$E?$WE?$?#;x=>?#;{}/?"p+n?"p-8?!ߍr?!.? ٔ S? ٖ?R? I? Kb?B:?Cٙ?w?w	m?nر-?p?'?)k?6P?U?J?Jġ?V8?Y
??p?&??z???RLav?RNp?֤B?
0?"?AH?F.?dl?%O@Po?%Q^n?Z?Z/f?պ
8??Ú9l?ÜW}?_N?a?-%?-'ݱ?a/?a	?dz?0N?
}Z{?
x9{?
F衪?
IP?5N?5l?i܍m?iޫf?
H"?
k?	u8?	w3?	C[8?	Ex?=+?=E?qzj?q㗵?#?0?ۃ
u?ۅ*G?UH?W:,k?E(?E*#?yʪ?y?hf?҅???|3S?~P,.?MS`T?MU}?+g?-?J-?fڴ?O?#5? T^? s?U`>?U.?p`?r}F?MT?O?+>?-V?)
od ?)?]+i?]G?#?O?Ǭ6?ǮR?c?t,?1q?1s?fUL?fW
?:',?<? ^_?"z??	?9u~?9?n|?n)?	??ت?ج,#?
?
n?B?B?wm.0?wo?[Ep?]7?I?K?8)?:c?K)$?K+ O??*2????^?g??Sm?S{?R;?mh?Җʘ?Ա?ɺZ?B?'`
?'
?\
?\?b;x?|?ƯI?Ʊ?R?ù?0g?0)?e*?eD?ܚM?ܚgb?ϡO?ϣj7?3`W?M?9Z?9v?n?n \?أ!?أ;?ة8?ث)?
?
鼯?B?B~d?w?w:?Ԭ.-?Ԭ?r)??Ѓ?ҝ?KD?K9qI?рE"?р?еIN?е?C>?\fd? 	iN? *?Us?UU?͊&_(?͊(xo?̿6/Z?̿8H?Fi?H?)Xx?)Zc?^j٪?^m?ɓ~P^?ɓit3?Ȓ?Ȕ”?,?X?2s?28?gԭ*?gƅ?Ŝ_?Ŝ?5T?M?϶? Bb?<9N?<;g-/?qTM?qVʼ?pƞ?s'?ێ(?ې@od?:z?R?ݿE1?ݿEJ5.?ݾz?ݾz&r?ݽ?ݽ
)?ݼ-x?ݼ/?ݼPь?ݼR΄?ݻOs}r?ݻOu!?ݺ?ݺwl?ݹ*%#?ݹAA?ݸZk?ݸr/?ݸ$
ql?ݸ$"+?ݷY2oL|?ݷY4?ݶ[T0.?ݶ]k*?ݵÅ ?vl3E>.?uc?uj?t]?tU?t@N?t(*v?sB	?sB?rw?rw#J?qzLt?q?puX?pwt?p#}?p6{W?oMmiH?oMo{u?n̊?nR?mh׿?mj7?l.?l?l#h>j?l#j&?kX 0?kX2Y|?jk7?jm1A?ia?i%?hqz?ht
A?h.?h.,?gd|V?gd~\"?fl{?f~=?eϋ%N?eύ77?eD?e?d:u?d:?cp(
?cp*Ms?b)?bn?a@?aB-?a͒?aϤv?`F[Hs?>H݂/?=~?=~֞?u=?%Hny?%U?%'?%4 ?$7?$7.?#m}?#m?"x?"z1?!Tt?!V?!1*?!3`? E@]? EDW?zqG?z~=?Z?gܗ?Ep?RJ?01?=>?Rt,?Rv)X?X
?Za??0?ܸ.hx?ܸ.4?ܷeO?ܷe
N?ܶq^[?ܶsc[?ܵM?ܵS(?ܵFO:?ܵHT?ܴ>cMT?ܴ>h?ܳuT?ܳu!L?ܲ=T?ܲȉ?ܱ[?ܱ?ܱmna3?ܱos1?ܰNg*?ܰN?ܯQe?ܯSj?ܮ?ܮ
?ܭ9?ܭ;W?ܭ(iO?ܭ(nX?ܬ_&;?ܬ_(@΢?ܫ"?ܫ'M=?ܪg?ܪ!?ܪ+8?ܪ/?ܩ9M?ܩ9R2?ܨo4?ܨo?ܧ?ܧb?ܦ܄.	?ܦ܆2?ܦ4?ܦ?ܥI.ڻ?ܥI35?ܤ%?ܤr?ܣ?ܣ"?ܢe1k?ܢia?ܢ#M,?ܢ#QO+?ܡZJ?ܡZO?ܠ^?ܠb?ܟ&D?ܟ(;?ܞ?ܞ?ܞ4:F?ܞ4?ܛnV?ܛpZ?ܚD?ܚE!j?ܙ{d?ܙ{8?ܘ b?ܘ"healpy-1.10.3/healpy/data/pixel_window_n8192.fits0000664000175000017500000202050013010374155021757 0ustar  zoncazonca00000000000000SIMPLE  =                    T / Written by IDL:  Fri Nov 29 16:12:12 2002      BITPIX  =                   16 / Number of bits per data pixel                  NAXIS   =                    0 / Number of data axes                            EXTEND  =                    T / FITS data may contain extensions               DATE    = '2002-11-30'         / Creation UTC (CCCC-MM-DD) date of FITS header  COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy  COMMENT and Astrophysics', volume 376, page 359; bibcode 2001A&A...376..359H    END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   16 / width of table in bytes                        NAXIS2  =                32769 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    2 / number of fields in each row                   COMMENT                                                                         EXTNAME = 'PIXEL WINDOW'       /                                                NSIDE   =                 8192 / Resolution parameter for HEALPIX               MAX-LPOL=                32768 / Maximum multipole l=4*nside                    COMMENT                                                                         COMMENT                                                                         COMMENT                                                                         COMMENT  Contains pixel window smoothing factors                                COMMENT  for temperature and polarization for NSIDE =  8192                     COMMENT  for multipoles in range [0,32768]                                      COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / TEMPERATURE pixel window smoothing factors     TFORM1  = '1D      '           / data format of field: 8-byte REAL              TUNIT1  = 'unknown '           / no unit                                        COMMENT                                                                         TTYPE2  = 'POLARIZATION'       / POLARIZATION pixel window smoothing factors    TFORM2  = '1D      '           / data format of field: 8-byte REAL              TUNIT2  = 'unknown '           / no unit                                        HISTORY                                                                         HISTORY  For NSIDE <= 128, the T and P windows are computed exactly             HISTORY  by averaging the individual pixel windows.                             HISTORY  For NSIDE > 128 :                                                      HISTORY  * The average T window is extrapolated from smaller NSIDE              HISTORY  assuming a scaling of the window function with the pixel radius        HISTORY  similar to the one exhibited by a tophat window                        HISTORY  * The P window is assumed proportional to T                            HISTORY      E. Hivon, Nov 2002                                                 END                                                                             ????8??i?n?Q?b?gb??p?->N?1?L?^?g?lz??ލTE?.?#?_4V?c?w?|R?Ϊv@?Ȯ?Ȇ(?Š??#]?g-?k??A?? )?,?1F?l?:?	?@?)?yo?sz{U?m~?fj?`?Y0?S"Z?K0?E5Q?<(I?6,?-X?']I?C????=?W?w?])??};9?Ё?D?Iz?:-w?>?	?J?@6?~EZ?mֆ?gV8?T?NȐ?;{|?5?"m*??)??O?TM??W?7E??p?tK?uX?ot?U[?O`_?4i?.nc??Q?=|`?AZ??T?O?Ϣ?}sC?ww×?UP?O0f?-?'|.?43?8(??R3?}?"?{(_?uʨ?M?G-L?@?Euh?M??]?b
d?p]?|tG?L
?F/?:?錼?'?Q?i-?m?g&?aj?*T?$Y9??[???n\#?haG?+?P?%.?N|?R?q?h?_E&T?YIX?#}??V*?H?7p/?;[?z?BH?^?c_?)?$@?ȁ>?†h?fR`J?`V?%w?)l?i?nN?;ٔ??5?y??q#q?k(!P?
C?5?D?KJ?<'t?6?Ԋ?Ώ/?l&?fe?غ?>#?G??2r.?,v??\?_QN?YV:??Ӝ?D/?H?"?{?-??O?Ih?T4?YcL?}F?w?O?U?孺?姿
?F?@.?YV??y?s!?Y??5?\?Lgv?F;?:??Ŏ:?#?)x?#|?I?MU?mq?g?c?
?D??_?YR7?O?s?ߴe^?߮j=?b?\<?(?-??
I?޽?wB?qȀ?-C?'H?Kw?Ph>?ݡa?ݛ5?_{?Y[? .?9?,iJ?0A?ܪٸ
?ܤ>?t?n?AWr?;[3?M?Rw?Upf?OtI?ԕ?Κ?SI?MNX?5s?9?Mg?Gh
?e{?j?DvP?>%?׿\?׹a}~?8U?2	?ֱ?֫Ǖ?)?#?ա	@?՛k?車?B?ԍڮ?ԇb5?:??wE?qu?,D?״?_-V?Y1?:>'?>0?D?>f?ж?аW?(ip?""?ϘV?ϒ?ҳ?[w?XX?R?,??5?/.?ˣr*?˝[?/j??ʀ-%?z1?|:??[	?U.?&??*N?5'y?/,?Ǣ;?ǜ@?&]?	+|i?{g0?uW?:?O?V{?P)?wf?Ľ{?0&?*΄?Þ8t?Ø?s%?&?ᨪ)?U?O?J?_?3h?./?`X~?d?~?
??}Q?h?%'?f2?`7D?,W{?0p?J#-?D=?&?+?2[}?,`c?>0?	ʎ?3?e?0?5Za?
}8-???|#\?
C??/qI,?)u0?~k?{3?ҷU=?̻?#1?V?rSI?l?NJ?U2??	M?\?W?B?-N?N?S]?@F/?:??`;x?Z_???L?QG?p??^N?XS3]?s??Pj?!*?q??V?P?Gp?L?v}?z??X?K?E
?H7?Lm?#?䶕?%?V-?; ?5)?wԓ?qg?S??xGR?|?+Z?%^m?fp?`?~?]?`-?d+?*3?о?UŒ@?O ???~?ǃ^?	0?}?F?@?w?||q?1C?6?MDH?Qٿ?9d"?3i.?oF?iKb??y?c?j$?n?ڃ+?Ԉh??m?Gm?L?>uU?8?_)?Y-?~GQ?xL9_?*K??̄D??~?~HD?}?}~h?}?}
?|+K?|%VW?{F!?{@&6?z_5?zYZ?yy-l?ys2,?x"?x?w?w*~?v?v,?u׆u?uыi?t	?t癣'?tZ?s8?sL1?s?r,i?r&n?q?*?q96?pS#z?pM(?oe?o_|?nw!?nq仨?m?m?lQ@?l5?k_?kd9 ?j-?jX|?i}?iłqT?hз?hl_?g?g㓪r?f$z?f)}?fK?fw{?e?e
ɛ?d!?d?c-C?c'?b:d?b43J?aF~(?a@AQ?>;Z?=-.?='?<?<?;<#?:@^?9o?9$p?82_V?87?7DI?7 ?6vڝ?6{?5?5?4tLU?4nP?3Zb?3Tf?2?k?29f?1$t?1y^?0?0Ǖ@?.Od?.T?-{.*?-?,r?e?_o?"aIG?e?މv?؎(??Q?T٪?N?SG??"c?'>?c?z4{?9
i"?3w?y?~g?OI?S?]~t4?W(B?)?
.m0?%
X?)?|J?v?0f›?*kw?u8
?yM?ޖ6J?ސ?H7?B<[e??ʭ?ڪw@?ڤ|~?Z$?TN?
?X ?8ݔi?J?Oa`?U#WN?O("?I.?NtH?hM?b	?ά?뎒S?y?s? 	?$?
vH?:??Co?!?^?Co?H?&X? Ҿ?(??*B\?$GMU??tG?~+b?~%*F?|{?|C`?{)H?{#a?yc3?yg?x&i`?x n?vl?v]?u ?u_?s?sN?r?r\R?p+V?p0!?o
?o	b?mp]&?mu'?l0"?k4?j|?jvP?hP?h
?gm؉?ggR?e'?e?d]t?dWyW+?baz?bfGQ?aK`?aE
aO?_9?_>s?^6Ѵ?^0ւc?\9 ?\=?[!@?[D?YZ?Y?X	?X{?V}?Vw?T8?Tv?Sdv?S^[?Q?Q?P9?P3?N?NK?M6?M?Kk?Ke?IЙp3?IʞA?H4|v?H.?F?F?D%Wj?D*)?C[z?CUMA?A|?AQ?@?@?>|f?>v:?<ۆ?<Ջ\?;9}?;3Q?9?fu?9D:?7B?7P?6Pb?6J7?4?4h?3B?3G?1`Cz?1ZHP?/M?/a?.?.~?,j?,dc?*?*b?)ÜR?)s?'n:?'ih?%g?%k?$B?$G?"m12?"g	? &? +?2? [?fR?`,0?u?z?	?Q?Zky?TpT?z????Hl?B?%??!?ވH?1?+֨?~:?x?
tT?
yo?		S?	0?`?Zd?g%?l4?BAs?G?>?8d?OC?SH?ϴxK?ɹW?p3?u?^!?X?O,?/{??
N?1?+?wu?qz"?\?>!?H?d5?Ex??Z?툴
6?킸?1????Q
?K?揭	?扲?闎?{?V|?[?5?/n?k׆5?ekl?ݡ/?ݛ
?xd?}I?	iE?n,??ˇ}c+?ɺ7?ɵ!?/?~??
u?>?8i?ii?c?c?hՉ?\D?G?R[v?WG!?
B?G?4!?.L?[,U?U1	?'?{4?6?$C?<^?ALL?L?Q?Ǹ?̦?5?/?W+?Q?yMGp?sR6?Rp?W_?J_?:?^e?c??r?/z?3?6GH?0L?S6?M'?pf?jkq?m?_?_y?dz?mQq?rD?1?%?}?q?j??*K?$?B???|5?znI?zsA?yD?yI?w
?w?u-g?u'l?s??s9?qQ?qKڨ?o`?oZ?mi7?mc2^?kq?kkÖ?iy$?isg?ge?gya2?eE?eJ?cp3?cu0?a?aQ?_<?_A?]U?]#S!?[N?[Sp?YE?YC?Wy}?W~?Um^!?Ur]?Sq?Sp?QL?QQl?O;?O@?MS:?MX;=?KMX?KN2?IJ?I?G?GF?EA?EzF?Czd?Ct?As(x?Am-6??k*N??e-n?=cz2?=]?;Z?;Tv?9Qw?9K|?7FN?7@R?5;ÿ?55?30u?3*z'?1$Z
?1_?/֪?/?-
8)?-=?*5݋?*:|?(?(?&KU?&P]?$]$?$b>?"?"ź? Y? 
9?N??K?T?u?o?b:?\?,?N$?H)Ա?9v?3{?$:.\??9?`?e
?
?
x?`?"?	Ʌ?	Ê'?~t?.???f1?yt?e!?_?KQ?E`?0L?*?}??ţ?ʳf?S?XU?ĉ?՞?ˆ?!?IR?N!1?f
?`P?F
?@ ?ޡ??v?{?Ih?N|?P?U.?}?wn?SLs?MQ?(<?"$Q??D@?DZ'?Ϥ6?ɩ?֢Q?֜Vp?t=?nB?E??R??,??Q?˴6?ˮ?ɃVz?}[8?Qn?K?C,?])?Qw?V-?L?g?0?zj?K9x?E>?@?\?ݪ?ׯo?h?ۅ?mlE*?gqbv?4R?.W?y}?~?!Z?&x?k?m_1?mY\2?kP?k"?h#?h:d?fzT?ftl?d-c6?d'hb?arc2?aw?_?_%?]@,?];)?ZO?Z}Y?Xa;?X揃?V<(?V6.
?S`?SǏ?Q?QC?O0q?O*?L'?LX
?Jzk?Jt?HtG?HyyF?E&?E?Cd4?C^fO?Aɫ?@ݷ?>ғ^?>~?e?Qb?Ve?5e:-?/jp?7?f?#M?R_?#?)?3V?8??|K?;Nh?@?i;?c#O?WY?\?LAX?Fݑ???-7?']??]?'?z2?yZ?s
K?M?ԡ?SM?MS6x?.T?4&?*TYD?$Y"?ǧd??b?8?gl ?aq?o?|?}7F?}16?zp?z}?xQ?wW#O?uk?ueB?r ?r&	 ?p4]z?p.3?mB5?mG?jZPN?j_?h]?hW&%?eb?e?c ?c.-?>(3`-?;?&/?&)c?#!y?#|'? "c? '?_%?];?]?Z27a?Z,?WJN,?WDTOi?TaO?T["?QwI2?Qq ؇?N`?Nfb?K=i?K?H1?H߰(?EF?E?#W5?#
\???X?!?zI=?tO?E?@
???w4?}d?G?M{?	n};?	h5?7H?1r?W?3?FY?L(=???Re?L?tY?z?A?Gf?n?@g?e5j8?_;a?C|?=?|텬?|?y%9$t?y?;?u
c?u%?rAG?qZ?nrK?nlQm?jv?jʞ?gM?gG?ce?ck)?`% _?`'?\??\E?X?XK?Ud}t?U^ɠ?Qͯ?Qǵ?N62R?N08r@?J,?J#L?Gf.?Fl4
?ClB?Cf	&??2!??TU?<7i?<1o?8*/?80S@?5H?4N?1c?1]5?-h?-ʎ?*)J?*#q?&D?&k~?")]?"P?DR?>Xd?ޯ"??+?U?T?N+??#Ϊ?
I?
?	^w\?	X??ů#?#?)DP?a?[C?\?|?	*?+?^?Xy?Y]3?_b?]+?c]e?T?N-?c?i7.?Q)?W]?D?>U?ٓ?ٍW?ް??-*?'M?zX?t_f?8a?
pw??p?[RY?UXM???y?L?Շo?6+?0g?}P?wG?[t?a?
?RR?X?K@#?K:?GtL?Go?C?CU??;??:J?<m
?<?8@s3?8:yK?4nU=p?4h[?0#?0*J?,!z>?,'?(sK?(yk?%Y?%?!Fm?!@p4?oJM?i?K?QZF?n?z?添(??+??
2Om?
,U?Wa?Qn?{	X?u?IX6?Ox?Q?ް??ܮ)??5c?$*e?19?C
?=l?b-+?\Џ?
>?{,?ߞr[?ߘh?ۻl$?۵s(?הG?>N|?:J?:	ͻ?6
]?6?2	O?2>?.T.b?-Z?*S?)Z)?%?%`?!4?!;0?*?
m??&?sc?yU?? r?
|?
B?	+;?	2D??o?P"A?V?\t?c&???}7z?w>
?n?hUu?^:?XA4k?M?G?t?+av?'3?'-WL?"/H?"5??w?
!??][:?Wb?%?Vb?
=?
9?	~?	kd?{Qq?uX.Q?@?;??#?.?5l?􍧻3?{?PwW?J~m?nT?/?J?܆?㔉?㎏Ȗ?Txܞ?Nq??
S?'0,?-?ҏi?҉0*?M	$?G?	g?nN?8?ſ"?͉?z?:\t?4cU??c?	?ؓ?e?_
l??8?R	0?Xc?x?˛?>?8W?,?]?󖧶&T?󖡼?[?U#QN?
~p?Qt??ؼ?q54^?k<?!%?*?|?|۾?x**?x{1?t/ȅF?t)] ?o(?o?k^?k"8?g7D?g1?b?b?^'?^&h
?Z9`?Z3=O?UƯ:?U͌?Q?Q&c?M5T'?M/3K?H?H?DM?DT?@,
?@&jz?; l?;&?7w`?7q?3f?3m}?.A?.&?*d*?*^D?&F?&?!y?!?DB?>]?@+?Go?m?y+???]b?d?Pǖ?J?vQ?cY?ُD?}}?0L?7;V??V?J>?D??ѩ?vMH?pTB???ߟOg?ߙC?2R?,YQ?a8?־V?Vj?P`?`:?W+?xDu6?rKl??|M?H?
Bm?%I?P?(????b?9źO???%?>6?:nm`?:u?5.`?55sx?1	M?1TB?,\?,{q?'W?'M?#p	?#j?2?9x?]L?W	e^?9?@*?Fդ?@ܿ?ƀ??.	'"?(C	?S?%o?r??z*v?tH?*2?1Q?T?N??캑?Fʗ?a??YG?SN?7+]?>YM?t3?|+?yQ?s?o?ǠK?66?0hF?0t?7H??C?LC?Fw?
?B?~z?}7?y\ޑ?yV,?tϭ?t'?p-?p4=?ke?k_?f4?fK?bn%?b
u`?]i `?]c'n?X ?X'[?Tn$?Tub$?Of{l?O`?J?J
?FJ?FR ?A\1?AVr?<?X>|?z??K?"??	1?aG?[OD?{p?uw???
?j?
?6?Q#?KU??~/?v?g?~.?~q?z:f?zA?uK?uE@?p|
?pvs?kVj6?k]?87?JbL?DjT$?|UK?|On?w_?wY
|?rh?e?rbF?mp.?mj?hxxqx?hr
?ct&?cy?^Ϝf?^7?Yd?YlI@?TFR?TM?Oe/?Ol?J?Jٟ?Ep?E?@,2?@!?;?;Ή?6ZQX?6a%?1/?16?,Q?,Y?'Ljh?'.?"xT?">?}Ŝ?m??jA?gU?ns?Q@?X?	Z?	}p?}r?w
?uֲ?o_;?mL?g?ec?_kV?\o?V%?R*L"?L1?G{?Az?< f?6(?0?*e?#S?[=v?N?d?:X???E?T??l>]?s?ȗr|?Ÿ,?.?Rt?-??e?"=?~?x[?jeX?dmHj?Ub?Og?@?:?)֑?#S?m?
L?z:?
?U?]g?{{UN?>O  ?90?9*.?4hV?4oz?.+`>?.34Y?)4"?)<3?$N?$$?n!g?h)>?D???'&1?.?=a?E?
C?
K?@?G?l.`?f+???9g?:?
?]??flE?nL??|"?Q?KT?WJ?_?$??ѹȎ?ѳt$?̅s?Z^?QcUQ?Kk
?G?O?툤gl?툞o`?fF?`;!?~(4?~"Y?x'?x?s
X?sO?ni4?ncK?i(?i"?c"P?c*^?^8?^A?YaA~?Y[=?T$$Q?T,!S?Ne?Nc?IN(?IM!?DO ?DI(?????9?HG?C?C)?>.s?>(	k?8Z?8b¸?3VQ?3P?-
?-?({J?(uR?#ݗ?#?4?k?-?(?ԥ?
?
Ln{?
Fv1?ڡ*?ԪI?h'j?b/?]?"?(f?{0۔?Љ??업f?쑎8?!7?Yu?.?7?3?..g?ּ34?ֶ;ɂ?CA?=?ʇ?ďX]?P?J?=eB?E?Y#c
?S+z?ڸ&?pz?[?U'?ۜQ?դ?Z?U#v?ٔe?Ӝ`?Wv=?Q~?ԝV?ΦF?Q?K
?K?̲N?ƻP?G?A?~T?~R?y;X$I?y5`z?s!o?s)}?n,*?n&2__?hy?h?c>{?cg?]?];?X"?W!?Ry?Rsx$?L6e?L?Gv?G`7"?GZ??A҂Ɇ?A̋)??6?8,[?؁a.?{j7?Ë?ҽ?J:??E&???Ŭ?T?u?黿?e??AR?;J?~1>?x݊?餻Mk?餵VW?_?%
?2:?,CT.?l?f}?鍦Ho?鍠Q!?Js?S&?b??|O%4?|I-?v?v?p=l?pF?j!?j?e&?e BG?_ZT?_TϬ?Y?Y&S!?S9?S5?MG?M?H$L@u?HT$?BT, ?BO?<\?<?6U'L?6]=?0?0&?+F?+

?%>;?%8C?jL?de?߂?̦?I?
?
Qu?
?+?P??I?9o?hlw?buC?NE?WQ4?~A?MH?+̑?4?LQ?Ux?%sx?#E?G-;'?A6?h{Y?b.c?͉L?̓k?ǨK?Ǣ"??`?lm(?uF??l? {X?Vr?=(?71_?X?R/?sZ?mct?蘍]ah?蘇f@?蒦?蒠ӏ?茿5??茹>??Q?'"?0?{?z"?u2'?u;
?o/*̸?o)3?iC^?i=g"?cV?cPj?]i?]c?W{?Wuy?QJ?Q(?KɎ?K|f?EE!?E4!?????9ˀu|?9ʼnf?3O?3W>?-l`?-uTC?'?'%?!?!^?	Z?|$?e?
L?k*?t	.?
&Kp?
 T?.V?(?6t?0	?<@?6>w?B[?<?HMO?BVO?Lj?G??Q~,?K?TXO?Nab?V?P?Xd?R?Z1?T:ɍ?Z<7?TC?Z2?T?Y*o?S4;?Xw|?R~?Va?Pj?Sh?M?P?J?K8?EHF?G?A%\?A?;
?;u>w?5~QC?4t?.?z-
1?z'>?t$?t?nn?n?hِ?h
?bRB?a[$?[?[0?U8?UT?O.c?O76Y?Iʰ\?IĹt?Cm?Cw?=}?=#?7F_?7g?1UY?1_?+r,3?+l5WM?%^F?%XO?IZ3?C=?4Dx?.M$?2*?;z?
`~?
i???jY?טp?Ѣ'+??_?\??b??o\?ie@?S?M?6?1B4?r?*???(D?^G?ý6?÷^?潝|h?潗?|b?v?["?U+&?
.?G)?P?_Mx?Y?)vR?#i?X?^?2??傰ʹ?|+l?H%y?B.W?G0?Ph7?Ϩ?ɲU8?̒Rct?嚌L?嚆?IV/?C?V?`[?凾W?凸m?xpH?r?{13?{+t?tL"?tU?n>?n
s+?hXؑ?hRP?b48?b	>B~?[į?[)?Uy8?Us?O-F?O'?Hfb?H]?B?Bu?#?䊟?䊙c?=qkH?7{?}چL?}ԏ?wv?wp?q?qL?j?jb?dH?dB$.`?]=?]n(?Wzϖh?WtA?Q9s?Q
B?JU,?J^`?D>?D8#W?=,>?=5&?7e}X?7_	?0??0?*|?*0.?$?$?sc?}?;?5)i?c?ѷ?
X>҆?
RH?ޏ?™L?rpI?֯l?֩0?7G=?1Qc?ɾ:?ɸDh?Dx?>R?޶??N8?H[?>??V-?P7W?O?0?Zw6?TEO??R?\}?VJ?Q?[?[cԎ?Um?{ ?{?uWx?uQX?nvk?n΀?hP-?hJ?aUv^?a_Oi?[G1^[?[A;8?Td?Tnsy?N:b$?N4>?G9?G?A+?A%Ȱ?:ҏ?:(?4W?49N?-5P?-?'?&? y-? sn???`\$?ZC?O?Yn?E.??8w ?\uh?f`?&ä? װ??K?9?r?a?t%?n/?潊??N?Ic?ѻP?ѵZׇ?'La?!A?Ē}?Č$t0?s&?}?f ?`*?,?6?5W?/?⣛xl>?⣕h?C?M?dB?^L?ǚsM?s?*-?$7	N?₋?₆?{,?{!0?uMxw?uG|?n?n&L?h
?hą?aj9g?adC`?ZǬְ?Z?T$k?Tu$?Me\?Mzo?FۦF?Fհ7?@69u?@0Cɣ?9
?9L?2?2'u?,AN?,;a?%-O?%7w?3?&ؚ?FX8?@b?Tr?lW?
𮬶?
?D?>)O?%?/.?2?O?P
?~Y?x?HE?R?>?ߊ&?&? N?[?UB?X?c0?d5?nf?@?񸒸?*C?$M?\!?V,4?Ǎ=@?LJG?w?V?O?Yk?4??T?Jkk?Dus?w$?q?=?:?Й?ʤYW??J?&q2? |VF?PM?JWf?|ye,?|so2?uɀL?u6?nz|?nÄ?glz?gw`?a2_?a ?Z<5?Z6??Sa\?S[j?L?L%>?E?E,?>1?>;?7"CE?7,?1i?1t]`?*.v?*)?#N˲$?#H&r?m읬?gB?Z?eH?/?|Y?~?A?eܰ?pWm?	?
?_b?ܳ?4 h?.*R?MsB?G'?fxf?`)?~8H?x?ЕMR?А?ɬJ?ɦϱ?·?¼Y?߻?߻hb?ߴ췙
?ߴ!?߮[?߭@?ߧ?ߧ
s?ߠ&?ߠ ?ߙ8g?ߙ2r?ߒI9?ߒC6?ߋZ"t?ߋT-?߄ixz?߄d
|?}y?}s'	?v?v7?od?on?h|?hz0?a?aZ?ZB?Z8?S>0?SJ?L-?L8X?EŴ?EҊci?>}|?>و~?7S?7ӏ?0P?0Z?)f?)mS?"(?"3?#??V)?4?$R?
Fr?
?y]?)"??7?7M?B`?-?8Y?aq,?l??쫓?\?IT?A 0?A+Sz?:}x?:ވi?3%V$?30'?,8?,#
?%a?%l)?ޞ??wԾ?qߔH?_?Z	%?	GvH?	A!?.9 ?(C?P'?[?=??fF?q$?i(y?t?ޥ?ޟ?׈S?ׂ]+?jKɐ?dV?K*?Ep?, A?&+'E?ݻV?ݻ>8?ݳ=,?ݳH?ݬɿL?ݬ7"?ݥ?ݥ2?ݞ?ݞ~͹?ݗa@Q-?ݗ[K?\?ݐ=ʜ?ݐ7 ?݉2?݉=?݁E5?݁P(?zxW?zk?s ?s*?lvqC?lp|95?eLG?eF?9?^ c?^\a?V?V$?O`k?Okg4?H1?H?Al+?Ag)?:>.?:89?3?3?+dh?+oj?$d-?$o?{?u"?I8 ?CC&?l~?t'?.e?9n??H?x@N?rKZa?B-?<8?c?ne?82?G?ܛ,?ܕF?b?\̞/?)  ?#+4{?4?2[?ܿ1^?ܿG?ܸw?ܸr7u?ܱ;{r?ܱ5?ܩA?ܩL0L?ܢXӬ?ܢc?ܛ?ܛ{æ?ܔBcn?ܔ?w84?o4?o@?hD?h?ashYm?ams?Z.rŇ?Z(}?Rl
?Rϖ?Kn4??Ky`s?D[`*X?DUkW?=?=
?51?5?ڙD?ڙ>>?ڑ9?ڑu?ڊ^'0?ڊXb?ڂiΤ?ڂuP:?{u?{o?tw?s,?l_?l̥$?eՏ?e?]3X?]?M?V"7?V?N@?N呚?G0?G*)9Y??Ij??ב?8:+?849?0ŝ?0.}?)BJ?)?ٸ?ٱ?Y?ٱKx?٩IY?٩
?١?١\?ٚqXH?ٚkc?ْ8?ْb?ًWN?ًQ?كA?ك?|;F?|5R4?t:g?t?mP?mx?e'?e#w?]?]Ba?VgRv?Va^0?NaT?Nm?G@om?G:,??I??U?8)L?85?0N?0{Zw?(?(f?!SxJ?!M?x??"σ?J?
b?
n?;?F?Te"?Nq?Ә?e+??5??y??u?Cz)?=?ͤh_?͞t3R?Ռ?O?ؾd?ؾ^qH?ضQ?ض?د jz?دC?ا~T?اx`B?؟?؟?ؘ7ވ?ؘ1
?ؐEk?ؐQ,?؈[8?؈;f?؁FL?؁@r?y@?yJ?qn&?qz?jP8,?jJD?bNQ?bZ8?Z?ZsS?SSshbS?V?U?J[?D?В}?Ќu?M?Q? /|?5?׹f?׹`?ױR?ױ?ש&?ש2?ע3?ע-?ךvg?ךp*?ג4?גB?׊?׊G?׃;e?׃5q?{{w?{up?s@?sT?kj?k)?d7ee?d1qL?\t?\n?T;m?TUBj?zuu?u?E?*?C?PW????Nş?H?t?{-?k?w?/#?;S$?6>?BX?G{)?A?w9|?qF?$zd?0?ָf?ָr?ֱ?ְK,?֩.4?֩(ne?֡Z?֡Tb?֙X
?֙dI?֑z?֑?։{H?։%?ւqj=?ց}n?z-?z'.?rU ?rO??j|Iz?jvU?br?bX?Zȷ?Z?Rt?R?Ke?Kqu?C6:a?C0F{?;YV?;Sc1?3{7x?3uχX?+U?+&?#?#ne??]?!?wY???;ʜ?6#Q?Xe.?Rr'\?s`?m??c;?¯?Q?7?ܺN?$?
h???N?Z?սX?սec?յ28?յ,%?խGO?խA\?ե[(8?եU4D?՝nO[?՝h[ǯ?ՕvU?Օz?Սg?Սt]?Յ_C?>?6%Rͥ?6_L?..^I?.(jg?&6?&0%?>VGX?8b?E>??K(?Ks ?E?P0?J?U,?OC?YӪ?S5?]+{?W8V?_?Y۟8?aO?[a?c?]D?c~?]8 ?c`*?]m L?Ծb^?Ծ\N?Զ`B?ԶZa?Ԯ^^?ԮX?Ԧ[[?ԦUy?ԞWV?ԞQx?ԖS^?ԖM{?ԎN?ԎH|?ԆH?ԆB̰4?~BJ?~?
4?
AB?gFP?s}?{6?u?gd?a?S@?MMj:?=?7?'R?!??X?k:?w??)V?Ӽ$?Ӽ&I?ӴZ.?Ӵf!?ӬH?Ӭ?Ӥx$?Ӥr?Ӝ\l?ӜVǯE?Ӕ@?Ӕ:N?ӌ"
?ӌ?ӄ'?ӃՌ?{o:?{A$?s+g?s8;N?k0?k?c?c~{n?[c3?[]@?S@v?S:P2?Kj?KE?B?Br8?:}"?:([6?2ʊ?2jf?*ę?*z?"c
?"]4?;}?5a?o&:?
|?	ꏕ?	|P???-?s?kN=?e:
??n?:[p??
?ldn?yT?и°?в?Ȋ ?Ȅ?Z?T
?Ҹ*?Ҹ$?ү07?ү=A?ҧP?ҧۿ?ҟ?ҟɑ?җco?җ^lp?ҏ0?ҏ*#?҆YX?҆fX?~}:?~v?v?v!?n[?nUf?f$i?fo?]$?]1#?U}\?UچF?M{ǬQ?MuԶ?EB;?E<G?=-?=;?4̖6?4ƣG?,?,w?$TYP?$Nfu?4?A;?]?jE?Y??[D?U
???pm??%?,A?Soa?M|?]Y?	}a?}?9?Ƀ(?~K&?=^?7l?Ѹ?Ѹ:1?Ѱ?ѰE?Ѩe&K?Ѩ_3?Ѡ>?Ѡip?ї[|?їh?яY:?яg	1?ч:?ч4}?~8]?~E?v
?vC?nS'c?nM4?fd?e?]1T?]>A?Ue&?U_4?Me]D?Mr?D?D#?=\?KR?l%?f`?I?
Vi?:Zt?G?^uI?X~?`?
%?Ǧ˴,?Ǡ?пIv?пCV[?жLO?жY7?ЮE?Ю
?Ц.l?Ц)6?НGK?НT?ЕnV?Еh(?Ѝ
?ЍR(?Є-L?Є&?|Iq?|C$=?s=?sJ?kX?k|f?c@?c7`?ZrO?Z
?RRt?RL?I(?Iғ?Ad\?A~r?9NB?9\@=?0?0|?(J1?(D?昕?H?u
`?λո?λ?γ0?γ*?Ϊ՞?ΪV?΢f.?΢ @?ΙN?Ι\b?ΐ?ΐ
?Έpq?Έk0?9?G?wRΆ9?wLHJ?n¯?na?f1۸?f+}?]R?]`t^?UA?U)
I?L{%?Lu3j?C_?C+?;S6?;MDxJ?2+0?29h?*(vu?*"FI?!?!?*B??c)`d?]75?ʪ?ĸ{?1}u?+N!?+?M??$?a:?[?`?ܿV?)OD?#]?ˌ?ˆ?؟?j?ͺNCI?ͺHQDZ?ͱJo?ͱXV?ͩ?ͩ?͠i+B3?͠c9,r?͗w?͗c?͏"f?͏!Tx?͆}s:?͆w)?}I?}!?u1.?u,
 ?l(_/?l6S ?c?cݨ?[;V?[5d?RT?Rb?I?IA?A>*?A88&?8D?8?/UN?/"T?':|9?'4:?$j?2mB?uL?$yq?
0Pp?
*^v?	?z*?Й0R?ʧ9V?L|?W ?nO?h[?ỢS?ᵰa?*?9?T¢?Nг)?Ǡ4?L?ȹt?ȹne?Ȱirנ?Ȱc-?ȧ]H?ȧW!
?ȞPғ?ȞJmv?ȕCs?ȕ=?Ȍ5W?Ȍ/f?ȃ&3N?ȃ Q?zz?z	/?q4z?q?g8?gP?^3?^(?UѴ?U3?Lh?LQ?CЄ?Cջe?:?,?:N?1 ?1{?(kN?(eH?TgK?Nv?=	wu?7j?
$?
?-96??؂?ґ?轜4?跫?ߢ?ߜ6?օ!?!?h)?b'?JBy?EE*?ǻ,?ǻ&?Dz
rׂ?Dzݝ?ǨA?Ǩ?ǟ'?ǟ+0?ǖΜ?ǖ?Ǎ?Ǎ?DŽgd?DŽas,?{DR?{>*bq?r  K?r/Y?hw%?h9?_y]?_#?VА?V?M??MN!?Da//?D[I?;9vG?;3?24?2
k?ƞ??=-?"o?ƺuu?ƺ?Ʊ{?Ʊu+*?ƨF
?ƨ@BZ?ƟBYw?Ɵ
Q?ƕپޫ?ƕ?ƌ?ƌY?ƃj?ƃd?z1,?z+mf?px.+?ppM?gYr?ghKM?^`?^}2?UG|?UB?L?L3 ?BαDC?B?9 ?9
g?0R?0L
?'ec?'
t?ӊ?͚+w?=??	?QT?K??	???:?-?Ej1??z@?~?p?ӻz?ӵٖ?tG?nΨV?-A?'ؤ?ŷ7?ŷ'?Ů?Ů?ťT?ťN
F?Ŝ
?ŜA?Œ\P?ŒkR?ʼnu+e?ʼno;K?ŀ)BG?ŀ#Rm?vܭ/?vֽ?m`*?mp?dAYő?d;i9?Zv?Z?QD(d?QS=?HS'9T?HM6??Zl?>i?5?5!?,^k?,Xq?#ɏg?#?4*?C?c?]?^?	
?V?fk?bq?]
?~?	?>5?M‘?[Җk?U$?>j?ί?Ũ)?Ţ=-?ļM?ļGy?IJM?IJ#?ĩ?ĩ?Ġ5g~l?Ġ/wq?Ė֗?ĖЧo?čw+?čq9?Ą?Ą+1?z?zŻ?qSk?qNb3?g>l?g?^Q?^a*?U*dv0?U$t?ë}&?ëQ?â6?â0t_?Øęԕ?Ø?ÏQ*?ÏK?Å?Å?|i{V?|cJ?reD?ru?i~'
?ix%?`	Gt?`T?VP?V'=?Mշ~?M?C3R?CC,?:&?: }?0 ?0?'29?',~?y?s?:i?4yg?

?
h???:t)?C?,D?B0t?<?R\?+>H?B?<
u??ѻ??]?:O"?¾I0?¾<7?µ:^x?µ4nm?«2J?«(?¢2zX?¢,r?˜~?˜?&? ?…M
?…]?|Zl?|Y?r?r(?ia?iq?_~ ?_x0?U?U췡?Lfri?L`?Bو?BӘ?9KC.?9EO(?/uN?/\r?&.YP*?&(i_?{q?%?
V!?iB?	|l:?	v$?ꐇ?䠞j?Yx?i.?0&y?*6?ٛ8?iFԱ??+?@LY?:\~?O?v???tw?n?-?Z?>Ք?8?yedd?yu3?p?o1?fh"?fbV?\$?\Y?S*-P?S$dP?IƤ?I*q??H??ǃc?6I?6C)?,h?,I?#C?"S]?b[|?\J??E?g?wK?t
&?n\?+?
t?'4?!DR?M+?yș?׉r?љ?.4?(Pp?…?"?n?FG?/.?)܄D?v?~-+?׵?a?*f?${?|-G?v+?~[?~k?u.(?u>t?koP*?ki`?ah?a;?X
w?X?N[?NUW?D?Dm?:OZ?:?1Au?1;?'@?'D?L?\?!0+?A_?
j`$?
dpr??'
??㎼???9F?ㄋ4?~?͔?k?U(?e?O$?I59?:?K?￲Ҕ[?￲̥|1?￩6SJ?￩
F?￟S+?￟M+m?ￕE?ￕU?ￋй1\?ￋɽ|?ￂq?ￂ?xKp?xEo?nn?ny?dG?dX1G?Zf?Z.?Q8?'?Q2O?Gq'
?Gk?=OA?=`F?3H;?3X?*j?*? Ph6? Jp?غ?\?Z^?A?P?aq?f?>k	?4D?4U\?*H?*(k? 7ؼ? H?u?F?
&b1?
 s?ek?vE
?T?e
?ɕak?æ>P?"6?3???ｾ#(?ｾ9?ｴ?
?ｴ9`?ｪ[k?ｪU|'?｠vF?｠p.?ｖ?ｖ?ｌt?ｌ`W?ｂƧ?ｂוZ?xٽN$?x=?nr}?nc?eui(?d\B?[=?[N{?Q.D?Q(UY?GA?G;}?=T.
?=N?0?3f

}?3`	?)w+ؖ?)q?X8?X2!?N9?N4?D:Q?D4z?::y?:4?09?$(*?$"Ǫ?$??ا@w?Ҹ????7?[8f*?UIw?/z?*
q?"b?}?\?n+?ȩ?Ȥ$?ﹾ{x:?ﹾu
?ﹴMx5?ﹴG0?﹪
?﹪?﹟fD?﹟xB?﹕}=;?﹕?﹋p?﹋N?﹁X.?﹁RTk?w%{޺?w?l񼲺?lc?bLK?b]?X)r?X:R?NRSH?U?;o~?5?܀~?zʨ?GO?ѿZl?	#`?6?ﰎh@?ﰃ?ﰃ5^?x‚?x ?n*D?n=?c9?c3k?Xdm?X^'k?Mx?M|?B?BO;?7g	?7zr?-Dk?-W(?"/if?")}+?U5?O?{?uU]?.?q?(}?_?Y?mW?,E??7?-J?'^9?N>?H)A?o\Y[?ioe?ﯵU^?ﯵh?ﯪ?ﯪq?ﯟ?ﯟ,|3?ﯔ?ﯔ?﯊?﯊?$jV?}?t@?t:,9_?i[
?iU!1T?^uP?^odh?S?S?H?HR?=z?=s?2:{0?2N?'
?'??^?8 ?Kn?-W?';?AC?;f?Tٮ?NU~?gO?acC?yt|?s'T?Њ!?Є5?Ś}?Ŕ?﮺#~T?﮺7/O?ﮯ%?ﮯ.,?ﮤXR?ﮤlMd?ﮙI?ﮙ?ﮎ	?ﮎ?ﮃ?ﮃt6?xX?xlc?nZ?m1?c,?.?.	?#>h?#Rm??](
`?B:??~A?rt?r¶?g'?g3?\ZP?\oGr?Q?Qzh'?FV
?FPa?;+I'F?;%]?/O?/a?$ʧ?$9?U??x_?r߿?Ih5?C|z
?K"?`B?|H?␯?ˊ?4?ք&%?~Z?Q?KpL???華}(?華W?睊T	X?睊h|?爵~s?爵x?望Gؖ?望AP^?愈?愈
?|tV?|҈?q7?qKJ?ff4M?f`H;?[,!?[&B?OU?O,U?Dwi?D?9ypN?9s3?.<n?.6"S?"I?"^?À?R_??z??@@{?:Ӑ??N?꾬m?B?|?vAO?9ڪ?3E?a?vdm?墳1?墳EK?全mJm?全g_?逸'N?逸!?者b5@?者vH?祖]?祖rN?海R5?海LYt?z
3Z?zH?nG?n$?cw7?cqK?X,?X&Ϸ?Ln?Lۃ6s?Ax?A6x?6Hѣ?6B\?*v?*q?dm?yB?^?X2?	0H?		EC?r?K?n-t?hB:-?kN?߀Y?6-5?0B2?刺u
?刺2t?林kVI?林ekK
?里Ԅg?裡釳?利?利?戮5tt?戮/|?阮CA?阮L?{c?{]?os?o?dɪ?d޺&?Y#EFt?YZX?M
M?Maa?BJK?BD,b
?6q?6ֆՖ?+n|?+h(B?V?s?1_?Gk?	Ql?	r?z?2d?;?5r?Q?,?U^?O?1?ۛ?lL?fJT?隸Jn?隸`?玲 h?玲{53?廉
A5?廉W/?練P?練?曆a?曆v>?eg?z?t'?t!!?hO?hd?]26n?],Kʌ?/8?#3r?#H?@?:*?c?#?@3H?:I5?Ί?޶?bI=_?>\^.?2p?2,?'%+6?'Ac]?*??9\?O?D/?>E?pX?~1?4I?O?\_?Vϒ?ո?ճv2?^?ts?of?i, ?9n?/V?"h?~a?zj?uݭ?j{?1?*`?$/?x¾?xz?l`?lvv?a+vrh?a%B?U?Uy?IӍ7?Iͣy?>&:?> ?2x/^?2rC?&n)?&Ą=?Td?jB	?kJx?e)?	Z?;?	z?^?W?R	?a?wp&?Un?2??>"b?88?y?? ?6v?B?+5?gZ	?ao?U??n?hb?w>M0s?w8c,Y?k1x?k}/?_L#?_b#?T4?TJ_?HOfP?HI|?<+~?<2\?0ӟ?0͵?%>k?%I?T?O
?
Zd?
j?f"?|4???N?I?ދ'D?ޅ??ǯ?Ŵv???=\?7h?w`G?qv??q??ݮ? WT?.?W?Q?teR?t?hr?h?\M?\c΅?Q,r(6?Q&[?E_?EY?9]?9?-ė?-P?!?!VH?&{g? P?
VZ?
Pp?b???Y?`?է?j.?#?;)p?5?7?f̲?`?}8??K??~r/?ߔ4?Q?g?6t?0*?|]'y?|W"?p?p~V?d-?dQD?Xn?X
?Lp?LV?A?Aq?5;?55?)^Ho?)X^?!|p?z7?CO?Y?.?Ο?x?ێ??V?B?!??Y~?Sp?uђ|?o?j?c?M?dB?Ƃ????|L^F?|Fu!?pS?pMo?dZO?dT5
?X_M?XZ?Le?L_?@ih?@c?4mi4?4g-1?(pBk?(j)|?rT{?lkH?sL?ma?t?nq?t'?n?tPL?ng?s?m$ ?q?k(?ne ?h|$?k?eA?fU|?a5?b(?\?G?\1?V2?V}q?P?O%?Ie?tHV?tB?h?-?h9?\6?\0ѥ4?P-n?P'#?D"?D?8?8?,
?,N?Tȭ?k/?(I???K/T?b/W?շ?\?A?s՚??㶄~i?㰛/?ץ
k?ןt?˔?ˎ?/&?|p?.eV#?"N?"I?1xt?+?
$2}?
;a??+:?r9?Љm?嶌?尣?ٕ?ُM?tVi?n5?R?L@?/X?)З?;`?R??`~?G?lPy?lJ1?`(Y?`"p?SS?Sf?Gֳ?G2?; :?;vG?/X??L?^?+v?l?p?P?y'?L?F?=	x?Th??߈T?x?xP?lxy?lr_?`B1?`?ٻ7?ٶ?},O?w?=lz?7??4??7.:?zt?t+r?8U?2.?=\??wb$?w?kk
?ke/?_$J?_?R?Rv?F+lV?FC ?:Mƀ?:G6?.?-?!τ8?!>?p:\?jRG?	$A?	kx?K[??-?E?>\?8ڻy?I??ˡl?˛$?R #?L7?Y?(?˅k?W?_?Y)S?j?Ȥ?wTn?,?ue%?u_?is?i?\,?\?Pe?P_ֈ?Dז?D	?7%&?7?+_{7?+Y?t?tp?[?-Hi?RVE?LE?ێ\?E?5A?M5??Rs?9H?ρ?Y?Ȅ$?L?&K? |?M?e?go?a?3?8???~C??~=I?qڰ?q?e}tD?ewQ?YX?Yp?L'?L9?@Obh?@I,w?3?3?'?'|5?hr?? 9?8?I(7?C@o?z6J?ْX?u?o7?
˽?(?ОL]?Иd?1FW?+r*?ĸ=?кc?V⫉?P?X?p?y%i|?s=?	,?>&4?1ك?1ȰU?$?$$?D[?>7h?2?a?1?)?V`K?Px?*A?CA?	7?Pm?al?[n(?2ks?KW??
6_?fUwJ?`nh?p?d ?l?
?d?^?s?sN?g
F?g?Z\?ZV?Mt?Mר?@='?@V?4N
?4H#?' XF?'9`?}?喺?9".?3<v??."R?N?g$?h?*?h?bǰ?βȪ(?άP?2e?K7?D???_+?u?2 ?K??)%?`?Z@9?u,?uV?hXf?hqǖ?\.?\(8.?Oq/?OkHͥ?Bq?BX?5>ts?5W*?)67?)0P9?vr
?p?c?.,@?\??3+/8?-Dp?p|?j?ܭlZ?ܧL??%?$T?
?_?Y]?B???K5?{d??Cu>?=?vz?vt|?i9G?iR?\?\/5?P;Q?PT?CP?CJ?6wB?6~?)w?)kS?u?
?? {?JK?E-W?zCt?t]j?M?j?֠?кp?gx??0#"?*z?:?s?ڃ1?Ԝ?V`?of?v+oձ?v%_?iR͋H?iL?\yu?\s/?OhX?OI?Bĥ?B?5-?5F?)
5?)?0Sb?*5?RP?Lm?t3]@?nLP?+0?Dm?o?诉H?p??L?Y?y?$ ?/oE?)9?L%Ă?F?tl?h*dV?bD?~?}H??/1?tZ?tb?g,?gE?Z:?ZH?Ns~?M>?A?A?4.?4)z?'D0?'>:?Y]?S'?
m1?
g?rp?{޸?TR?n$?榃b?栝|?ٷD?ٲ?
???Q?E?_?#???zj?>i?XN?j?RC?r*?r$?e5*?e0|?X@?X:?KJSU}?KDmF?>Sth?>M\j?1[$?1V?$c0?$](?j\?dWs?
qd?
k8b$?v́?p瀺?{?u?-?z2?փU?}4S?ɅXq? a?7?R?
?W?n?V?yD"?WG?3?}?{bV?{{|n	?n~G?nxag?azt?at?Tu?Tp?GpJ?Gj?:j?:d˳?-c?-^]? \U? V~"?T}j?N?K+?EY?B!ކ?<<?77?1j?,v?'9?!F?ak?n??Σ?w??"A??=
?Nb?iB?dP?~?v?v?in~?i?\e$?\?O|?O̧?Br9S?BlS?5^KR?5X2M?(I<?(CVm?3{?-i?i{??o?N?H??k4?Ѕy?ٽ[;?ٷu2?̣v'?̝޶?!L?;N?m0b?h?R0?L0?5Ő?/7?B?]%?}K
?}f(Q?p۩z?pÂ2?cMr?cg?VC?V^1>?I{?Iu?3?O)SP?O~D ?BTw
?BNmT?5$H?5+?'0?'?>?4?
T?
?[E}?U`r?'I?!dV?9??ؽ-a?طH'?ˇI?ˁ'5?P3r?JN|g?&??bi?}O?o?a?mZ?g^2?|3Z
0?|-t?nC?n^T?as&?a|j?TX?Tz?GB?G<,?:)?9
B?,)G?,Cr?Ŧ?J?F˶?@桞??(?ęD?|X?o*?|??T?9]?b?"Y?·}?±{?rh?l?- ?';???n?rl?WV/?R\?sma?s	j?eAC?e\N`?X|d8V?XvF1?K1?K+r?=k?=~?0'?0=?#M?#H?H?7?Ԩ?l?ck;?]|?i??K?g"?sw?m:?!j ?W???|ٛ?v?)B2?#^?R?-?.
?z c?v*^`?v$yي?h
?h%S?[|?[w=?N%Cg?N^.?@D?@_?3r+,?3lG8?&^?&y?n?D?_<)?YJ??c?m;?\?F?@1?y??ȇP?ȁ?'#?!?O?T?D?c?^
?GgR?b?
?r8?x9?x3)?jJb?j?]o}Ԝ?]iAA?P	Gl?Pc?BYy?Bt?5:Z?54	?'`r?'|?iSV?cn??mp??0!?)3M?$?
7?m?QkW?K?hX?7?v?p9[?i?}+???'H?!??/?yEM?y?5?kU?kq"?^`nPK?^Z?Pʵ?PS?Cx{?Crr?6s?5d?(S?(
?P?kp?
5n~?
Q?(_?"{?8B??6ޠ?0Ñ?׼q?׶}?B?<;?5%??Jսr?Dz?&Y?B?PE?J?ұL?g?yS!?yN2?kz`?kΖ*r?^TO*+?^Nj]?Pt?P͐|?CQgj?CL	8?5ϱ?5V?(L>?(F=?08?Lj?
DCl?
>?}?[?:8?4T?Ju?fe?+F?%b{?ɢ?ɜכ??3i?R?
a??+w?xue?rW?#??w?x_q?xY9?j\G?jxA?]B?]=-?O5?O?B#ۦ?B8?4F-?4b1?'?&?o?j???[$'?I8?C#;??ّ? ӰU?l?ՋG ?Յc6~?p?#?^j~?X#4?]m?y?- !?(??w???1?v`6:?vZ]?had?h}?[)z;?[#h{?Mܡ,?M9??'??YY?2Q'?2K\?$̈y?$*?]Nd?
y?	s>?	mZՂ?g>?̄:?0?*,h?2N?u?*&?p!?H?B9;Y?W?袜?Ʋ?=?Y#?S+s?;?9?`??XF?j?ꩇ,?T?ȁ?O'
?I?
N?)?j\??;Zu?5v-?|?S??f1?} (?}8?oj6J?odR0?a4&?a(?S;?SX,?FD0H?F>M2j?8l-?8S?*l?*-?#?߉?\j?V?:>?W6?~'?~y?~'6?~!8P?~j"GX?~d>?~ʫtk?~ʥ?~u?~?~,i?~&?~lM?~f(A?~?~ؽ??~{?~/?~x&?~x !6x?~jbwf?~j\0?~\r0L?~\?~Nٞ[?~Nӻ?~A֗?~A0?~3MP?~3G?~%q?~%7?~1?~ND?~	L?~	?}-"?}'?}c?}^'?}H?}^H?}^?}{1?}}?}?}5b?}0e?}hi?}bG0?}u.?}U?}?}~Q?}?}k!?}r,}PP?}r&7?}d[U?}dU??}V?}:I9?}-`;?}-T?}=V ?}7s-?}hbl?}b(?}?})?|[?|x?|Q?|nc?|
?|?|5;?|/R?{Mܶ?{G?{h?{bM?{҂?{|&?{Ĝ
-?{Ė'!?{?{̧?{̷:?{x
?{?{t?{G?{?{d
?{
R?{q%
?{q!?{c9?{c4)?{UMJ?{UGa
?{G`#M?{GZr?{9r?{9m	?{+@?{+~?{rť?{?{*?{v?{{8?{3ל?z?zK?z~?zo?zE?zc+#?zh?z,:?zד?z?z8?z+B?z
4?zj?zg4?zZv?z ?z'b?zv(?zv#q?zh0?zh*?zZ7-?zZ1ĩ?zL=rl?zL8?z>C,?z>=?z0Hyi?z0B?z"L
?z"F̓D?zP1x?zJO?zR=?zML?yU6?yO8IJ?yV6?yPƥ?yW;p?yQY?yW=[?yQ[V5?yV/4?yPǬ?yU-Z?yOK&p?yS?yM6K?yPUR?yJs@?yL2%?yF?yzH	?yzBүU?ylCݓ?yl=;?y^>Po;?y^8n
?yP8?"?yP2,?yB1!@?yB+>?y4)l?y4#?y&!-i?y&KC?y0l?yNpY?y
|?y
l?xk?x8(?xm?x#_9?x>R?x\e?xh?xu?xӧ?xhi?xϬF?xv?xJ?xht?x?x2m!?xʔ?x?x}R?x}:$?xosU3?xon,?xa`Ą?xa[?xSMI!?xSGfW?xE8
?xE3
?w9)"w?w+x?w+?w<_t?wZv2?wH??wfY??w?w?v{J?vuhâ?vU<2?vOZ/?v.x?v(A?v?v&?v]?v ?vt-?v%?v{|?v?vb9?v\XE?v7DX?v1b?vs?vs?vdBSW?vd`|?vV6R?vVT?vH|Ǩ?vH~?v:V:S?v:P*{l?v,&
?v,!P?v?t?v4?vƏ?v,?vZ[?vx?ucs?u]kW?u0:h?u*m?ux-?u?uɎr?uì?u?uo?u_{(?uY:?u)k?u#?uA?uǡ?u5?uSk?usB?us}2?ueJ>?ueD\?uW!?uW
3?uHև?uHХS?u:A_?u:H?u,`&I?u,Z,?u#"}?u꘸?u֊)?u?uH?u2?tiq0t?tc?t)xʻ?t#K?t1?t?tȧo?tȡ?teS+?t_q?t"B
?t͘?t?t 8?t&?t?tU?tOle?ts3?ts
Q?tdZ?tdu?q]?q"?q	74?qzC?qzb`?qlLj?qlF2?q]}j	?q]ٜ?qOq	?qOk5?qA}?q@(?q2s//?q2a?q$$%?q$ZR?q55?qTt?qC?q="*?p?p;?p^:?pXǓ?p+?pK!?pw!?pqA#?pg?pe?p^?pކ?p?p5?pS?p(?p(^?p"~8?pv?pv7T?ph7{?ph1 ?n|˛?nv?nY?ny~?mOpnF?mI:?m'?m?mR?mI?mˆ
@?mˀ*7?m~j?m垔?mP=?mJ],?mB?ma?m?m?mz.?mtN?ms?ms5?me=D9?me7d
?mV߮?mV:?mGF?mG?m9\?m9V?m*J?m*
?mٞ?m?m
uyE?m
o~?lѳ?l?l-8pE?l'Xm?l	+?l),n?l&P(?lFSU?l;?l5?l;?l[F?l:C?lZO=?lC?l=A?l?l:?lz?lz^?llE,*?ll?M?l]?l]?lNo?lN珧?l@@=?l@:\?l1ᵐ?l1?l"-?l"ޯQ?l5.8?l/U?lʞE?l?k^^?k~3?k$?Qt?k_?krlW?klv?kʿ?kʺ5J?kX?k?kXf4?kRA?k-?kMѩ?kߗ?kׄ?k8?k3g?kr3?kr|TA?kcw?kcU?kU?kUF?kFY?kFTd?k7y?k7?k(P?k(p?k+s?k%?ko?kj?jS?jof?j
?jS?j9?j390?jz?jt\B?jň?j?j40?j3?j;3?j5П5?jz?jt	?j?jy?jwmS?jwDZ?ji3L{?ji-lo?jZoyg?jZi
?jK?jK !?j<?j<?j.??j.?jX?jRvI?j:?j?jP?j?iS?is?i4?i.1D?iib?ic:U?iƝnsi?iƗv?i	H?i*E?i?i'?i6!۷?i0By?ig[?iaƒy?i|g?i|?imy?imšNN?i^sm?i^?iP&}5?iP g?iATs?iANQ?i2oJ?i2{ ?i#?9?i#_?i1?i8?i>:?i^?h/0?h)X?hYc?hS`?hقke?h|w?hʪ??hʤ?h]?hq=?hq?hbg?hbT?hS"X?hSC3@?hD'F?hDH#?h6|Bh?h6"U?h'8!d?h'2Be?hXSv?hR08?h	wK3d?h	ql?g֪?g?g볰?gы?g֢.?g?gN3>?go&?g	?g-7?g$r?g=k?g>{v?g8rA?gX(?gRI,?gq&e?gkGgO?gtr?gtë?ge8?ge)?gVÇ?gV7?gG(?gGI͉?g8?g8S?g)?g)򤱣?g?g?g E?g<]f?f2ޗ?f,Q?fD^n?f?{?fVV?fPw?fg
q?fa+M?fwm?fq/^?fb?f)?fo?f'?f4r?fbj?f@`?fa?fv?fvMi?fg>)?fg`1?fXҗ}?fX̸?fI;?fI\ñ?f:*N?f:K?f+_ӥ?f+1?f?f$?f
?f
?eǻ?e?e.7?eO?e27?e?eWO?e	?e?e
@m?e`?eS?e?eSi?eO?e?e%0.?eF?exv?ex8?eil?eid?eZB-,?eZc?eK?eKT?e<?e<
0$?e-
	?e-+$H?e?eg?ebT?^ M\?^DV?^>y5?^?^?^z?^zʍ?^kH#*?^kBE?^[$?^[]?^Lv?^L?^=E?^=?K?^-
?^-~?^W?^?^?]	2?]	U%?\s?\|m;?\F?\i]?\۵D?\ۯg?\M?\G?\)p?\Lz?\|Z?\v8E?\LE?\oO?\M?\Z?\<ɞ?\6/?\oI?\o]W?\`d9c?\`^\y?\PH?\P?\A	Y?\A-r?\2i^?\2}?\"qF?\"8$?\;~?\56Z?\]c?\Ā,?[X#l?[SM?[$?[ ?[t9?[n:jH?[?/?[r`?[{?ZqXb.b?Za|?Za#B?ZRU?ZRO/?ZBfi?ZBɊ'?Z3I
-?Z3C-?Z#?Z# H?Z:=$?Z4`?ZƳV?Z:?Y(2?Y"K?YG4?Y4?Y.?YR{?Yƈj?Yƃ?Y:?Y`?YpHK?Yjk?Y?YG?YT}?YNo?Yx?Yx9ev?Yi6]A?Yi0?YYz|?YY$?YJʔ?YJt?Y:
Ğ?Y:~1q?Y*\?Y*?Y^ׅl?YX8S?Xkr?X'?X7?X{/?XuSxv?Xo5?Xo?X`EU?X`?y?XP`2?XP?XAP?XA?X1obǤ?X1i1?X!]?X!ˁdž?X2?X,l?X;?X_?W!)T?WE?WRX?WL|!?WӰ?Wӫ?W?Wے?Wk(8?Wf#?WR?Wvܷ?W$?W?C?W3X?WyW	?WuٝS?Wu?Wf3X?Wf-|?WVc7?WV?WF佬?WF\?W7??W86U?V,Ze?VPso?Vb&?Vߵ~?V8A?V2e?VɊ@?VɄd?Vۇ?Vիa?V,z?V&>@?V{?VvH4?V#~?VH?V{q|?V{?Vkg\?Vka:?V[i?V[
7?VLĊ^?VKë?V?R~z?Rx?R(_?RL?R?Rf?Rڴ?R?R?R|D?Ry(o?Ry"?RiH@ݩ?RiBe?RYg]ܰ?RYa?RI?RIG?R9|J.?R9FY?R)?R)*?RMc?RO?R	k?R	򐮕?QUP?Q
zX?Q-]?Q'
c?QG?QA5?Q_?QZ
$?Qx?Qr(˅?Qq?Q?Q/f?QTJ?Q4?QY?Qzщ?Qzˮ%?Qj,-b?QjQP4?QZs4?QZ>?QK
Xh?QK}?Q;ˢ?Q;b?Q+1?Q++u?QBD?Q=ve?QSb?QM/T?Pc'9~?P]Lq)?Pr;h?Pla?Pۀ?Pz+e?PˎOG?Pˈu ?PR?PwR&?PO?PC?PBP?Ph(?P3!?PXm?P{u.?P{š~V?PkT?Pk)?P[?P[T?PK?PK4?P; ?P;| ?P+W,?P+}"?Pu*?P,?Pߡ?PX?O{?O~?Ov\?O?O		Q?O.?OV?O?O
0P?Oܣ?O	?O	.|V?O?O	͒?O?O	mK?O|?O|	]g?Ol
uK?OlN?O\\m?O\?OL=?OL?O<|?O;AA?O,S?O+?O(?Ots?Of?O?Ny?N?N2?N?NW}?N}?N3v?NYi?NYa?N?N?N?N[?N?N ?N'?N{
?N{?Nk>?Nk?N[x?N[zy?NKqH?NKkU?N;b@?N;\f=?N+R$?N+L;m?NA8n?N;^G?N/?N)s?Mi?MqM?M
u?Mk?M-?M?Mr#?Mܘ{s?Mfh?Mnj<=?M4?MɈ?M5!X?MZ?M?M7(?Mzr=?Mzlb?MjYN?MjS?MZ@{
'?MZ:?MJ&?MJ ?M:'(?M:?M)	?M)9?Mԣ?M[?M	?M	!?L?Lz?L|znj?Lvh?L]?LW٭?L>?K5L6o?K5F\?K%us?K%‘?K糞?K?K@?Kg$4?J?Jz97?JK4R?JEZw?J
?Ji)?J^ ?Jل?Jdv?J*?Jp?Jj_U?J8U}?J2{?J=w?Jc?Jru?Jrb?Jb?Jb1?H8X0?HR
?Hyw?H8?HK?HX=?HR?H
n?H6?H>?H?Hzl؈?Hzfŧ0?HjR?Hj?HYD?HY?HIz?HIt?H9(v?H9"?H(ն?H(p?HA r?H|hh?H.j$?H(FN'?GMF?GtnW?G˩?G}?G-f?G'S?G־?GE?G,n?GySڶ?G&8?G!̏?G,?G+%?Gtg?Gnf?Guff?GuBe?Gd!?GdH?GTcxS?GT]?GD$N?GDKWV?G3wi?G3F'?G#Lj?G#Ft?GT?Ge?Gª?Gq?F-8?F'_?FE?F#Q?Fj"?Fd51>?Fi0?FQK?F/?F9l?F@d?F:.=?FG?FoX?Fu2h?Fo_?Fo8?Fo	iX?F^,?F^`^?FNAH>?FN;ou?F=
b?F=1m?F-p?F-j>?FqW?F?FV?F@.=?E1?E+3x?EPH?EwOS?EXOc?ES	?E٫?E(?E}Q?Ex?Edh?E	ݼ?E,f?ET5?E0C?E*k"??ExD?Exϣw?EhNX(d?EhH?EWW2"?EW~?EGi"p?EGcЊ4?E6E&?E6mD?E&3y?E&|Zw?E
oj?EBi?ES?EǛ?D!O9?D`?D5?D?o?D3lWV?D-ԥ?Dû3?Dõ[t?DBI?D?BN?B
?B
%?AO?Ax?A[=?AV ?A?A۾?A+0l?A%Y?A?A?Ao?Aǃ?A\ʮ?AV?AC ?Ak;?Ax%{?Ax4?Ag#i?AgK>?AV?AV9?A?AD?@*YR?@$CG?@R?@8c?@?@/?@@?@;į?>De?>>2?>8?>݇a?>݁8?>Dm?>mLF?>vy?>cr?>Y0?>T(?>"?>\?>Ԫ?>T?>y&;i?>y dU?>hhj_?>hc?>WZ?>Wm?>F4t?>F]uT?>6,J?>6&L?>%l~?>%f؈?>Q?>'?>^Σ?=(+Mz?="T?=eFX?=_o?=ѡZ?=ћ&?=e?=׎|?=ir?=E?=R/A?=Lv?=\?=?=}L?=}u?=l?=l.?=\5|?=\/;_?=Kk&?=Kf?=:?=::?=)ׇp?=)Ѱٜ?=Ma?=vQJ?=@_@?=:??{eJ?<>u&w?<-~?<-?<m?<?<B?<?;#'?;?;L?;F;?;s7?;mb?;Ț?;Ȕ?;	?;3,M?;?;9'?;qD?;?;/H9?;*
?;tSh?;tM?;cvK?;cpt?;R?;RE?;Am?;A-?;0?;0F]?;?;28~?;?;k?:9P3?:3y'?:Wl?:QC?:tڞ?:o?:ˑ?:ˋ&X?:s?:ӿ?:P?:?1%?:d5?:ݍk2?:/?:{U?:wIS?:ws#?:f--/?:f'WW?:UD`\?:U>l?:DZ~Q?:DU?:3pAp?:3jԻe?:"I?:"?:,P?:U?:!$?:?9t3?9
?92Q?9[۠?96?9À?98?9US?9?9\?9y5?9?9$LO?9v%?9y2l??9y,Q?9h?G?9h:?9WL?9WF~?9FX3?9FRkz?95dI?95^-?9$nR?9$h?9xV?9rϸ ?9.?9|%?8?8շ?8gy?8K?8ϙ?8ϓ^?8 ?8Jb?8?8?8d?8;Xd?8n?8e?8z@o?8zjN?4O=}?4Igw?4+v?4%s?4y_?4?4ѽ?4ܸW#?4y?4W?4z/S?4zѻ#?4io?4iiւ?4XG?4XB*s?4G?4G̚?45$?45h?4$O?4$?4fJ?4?4wFyU?4qq?3Kvb?3E?3?3#`?3ˀ?3+?3†?3q?3^V?3k?3f א?3`K?365m?30`&s?3y!?3x}?3gL?3gwG-?3VR?3V}?3Eo?3Eid$?34z?1_J?1"NN?1y?1ނ?1حѢ?1
?1/ .?1T?1N?1tn?1t	
?1bZ{?1b…?1Q?1Q{??1@9oC?1@3C?1.k>?1.&?1@\?19m?1\f?1W*?0>{v?0i?0ˮ'?0?0zl4?0tԥ?0-ԂZ?0'H?0P~?0{?0c?0DQ?0C04?0=[?0^?0¨?0pMz?0px?0_RP?0_L|1j?0N#?0MR?0?/]?/X T?/)
?/U
?/Ա'?/ԫՒ?/Z{?/T?U?/?'E|V?'?g?&P.?&}'?&xD?&ܥ?&/U?&*pX?&|5?&v%?&W?&?&7ۂ?&e?&^q"?&Y?&s?&s+?&aZ?&aO?&P;	?&P56_?&>	զ?&>}7
?&,Y?&,ĆLi?&Y?&)5
?&	Vg?&	Q?%5?%c0?%?%UE?%$?%?%grc?%b#?%?%,?%hZ?%1C?%-L?%'?%{n"X?%{hOy?%iuv?%i*S?%W's?%WT?%F+r$?%F%դ?%4iyl?%4c\??%"?%"ʄ?%=E?%@?$ݤ?$q?$Y^?$Sz?$ۓTU?$ۍ;?$`:?$MBl7B?$;{zM?$;u?$)?$)>?$d0?$4?$
?$;Xe?#BJ?#<.?#rr?#lt?#Т'.|?#МT?#6}?#(?#.?#}.?#,
MS?#&8?#X`?#R
?#wx?#w~w?#eD7?#e?#S:P?#Sh0?#B
:?#A8:?#0--?#0'[P?#Ux?#OL#?#}d~$?#wL%?"u?"?"?"?"H?"꺨L?"f?"?"9?"4v?"]2?"W:?"Mu?"z2?"}ɝ?"}?"k`?"kk?"YId?"YwTH?"Hb?"GUL?"6%x0?"6:nD?"$C+b?"$>$?"b{?"\ExZ?"h?"yh?!eKJ?!N?!ܸ9?!ܲ@|?!v6?!'Y?!C?!P?!׊?!i?!"?y?!mD?!:f?!5(~j?!qS8?!qM6?!_jf?!_d(?!My?!M{G;?!;?!;M?!)sȥ?!)?!?!M[?!&?!KU? l? ⚹? 
4? ;jX? 
X? 0^? G*? u? .V? )? >ݶ? 9 ? N-]? HAs? v\CX? vVq#? di{? dc	? Rv? Rp0on? @ק? @|+? .f^? .&? i? ? 
*	? 
Xg?9J?g?沕$?Él?ԺAXL?ԴoN?<&f?»j?DŽ?p??Is??1i?z9??zh?hپp?hS?Vܕ?Vh?D޺?D?2/B?2]4? K?  l?K?3]K?h5V?ږų?T?H?؈?Lo?q?Ԡ\?(?BƬ?!/?6a?Kn@?z?~O?~
?l#?lq?Z?Z)@?H!?H?6T?6{?$~!?$ڛ??%?M?
u?٤(?g?yF?sta?m?g0aY?`d?Z>Yl?Rp ?L%?D F?>O?5$u?/SM?p%y?p|&?^![?^OD?Lœ?KH?9c8?9?'*?'/4??T?.n?]]?o4?ab?ߏ?߉?yh?tY?ckd?]aE?LIe?Fx?4{w?.z?)?./?s<?rE?`g?`-ĥ?N{?Nȫ??>
c?,f?,٬?[?`?sA.?mq?KM)?E71?";L?K?~m?/??1^D?`{?6?e|?w,?qK.?K*?EYO?w?wMgN?d_i?d'?R,?R"B?@?@?.c1?.]6$?2l?,5:?
_-?	F?τa?ɳ?s?)?iŸ ?c&?54?0U?Ad?p?y?,+?q?8?x_ez?xY?f(?f"Ce?Sp?SB.?Ab*?AG?/~h`?/x7n?CH?>)8?	?J?oV)?7?p?摾ͯ?_?TO?O*?`?N?gt?ӗ_?Y??[ ٘?UPU?y3?y$?f$?fM?T8?T?BVh	?BPI?0?0
?Q?.+?V??F?A
?KV?{:?Ի
G7?Ե:.?t?nM6?,?&ؖ?@i?p?NZ?~?yQs?yKk?g?g5?Tcg?T7?BoF?Bi?H?0"	{z?09"?UK?΅_?$?1i?6׿?1ύ?`?>Ϲ?ԖT?Ԑk?EkV??͈??}?=?5^?Mǯ?G?xف?x	?f>?fn7
?TO?TJLh?A-?A"_H?/FUJ?/v?K?F?
@!?
|?W?N?A?;I'?瓾(??~?"?1L8-?+|?!]?Q?xF?rwQ
?x"?xz{?eB?e?S]Mr?SWˬI?_o5?Ma#~?M[T?:T?:ޅ?(fخ?(a	.?謿?ݹ?iG?c?@xD?qy	?jl?d5?K`?ES?gv?a?)?Z?b+A[?\\Sm?}L?خbE?oZ!r?oTSp?\?\C?JOX?JI+?7`?7%?%A?%<,t?n?9?1C?+qn?h???6?Ȕx?Ȏ?>??T%?|f?w$?aP?꒓Y?~c#?~]P.?k/@?ka?YF5?Y@0?FFΘ?Fx?4'M?4!~ix?!M?!
?Km?}J?sG?my4?p9??M6|?Gg?Ĺ&?ijXb~?$lB|??f?3f?K?3?zb'?z\YY?gʵׂ?gQ?U2,?U,Ǫ?B?Bm?0S*?/?f.?``{?
]?
ŏ%K?/(z?*x?哳%?|??
	?YVO?SE?#H?T?G(?x+?|?v~?u܄?uֶPO?c;]?c5}3?PM?PE?=dR?=?+Tc?+N?\???p?F?
e?
`	?
࿋?
๽?
^?
%?
pW_?
k!?
ȅ?
·?
yp?
A?
uH?
o?
pL%?
p~]N?
^ .|^?
^`X?
Kt`k?
KnҐ?
8	?
8?
&R?
&r?
l?
g	i?
G@?
y\??	>߯?_ z?YR?Ȯ"?Ȩչ?:?l?K@ݤ?Er9?٫?۾?}>?}p?k17x?k+iȉ?X|p?Xv?E?EM?3
?3<6? ZGo? Ty?
~?
7?b?p?1?,P?xn+~?rP?¾D?¸v?k`?p?Go?B?>?q?wЁ?w?e@hd?erw?RS?RM4S????F-?,{k2?,έ?5wQ?gi?S>(?Mq"?
֪?
%?
M?
?
Rc?
?
H+?
Bۅ$?
S1?
~?
N?
?
?
?
q3B9?
q-t?
^l6B?
^fi%n?
KZH?
K?
8+_?
8Q?
&W}?
&
B2?
IWq?
C?
~xE?
y!?	ک?	
)A?	9?	No?	c?	?	N"N?	Hͭ?	aU?	{
?	kR?	R?	|U5?	|$?	j!i?	jD?	WAi
?	W;l?	Do^?	DiϚB?	1 X?	1R'?	Ci?	'W?	?	H`?!??LJP?F}l?v\#?pp&?o4?'?sG?¦YV?uQe??E?_?u>k0?u8k?bd_?b^x?O\h?O*?<8s{?B?>v!9?+X?+???G?>?a P?Ĕ_?6h?i?`Z}?ᓠN?T?W?z?a?
ә\??J?}?n$3^?nK?[.9U?[(l?H72?H1e?5@u?5:`?"H?"BH?Pd?J5W?Vt?P?\{?W?bQN?\?f?`
T?j.f9?da9?l[?g%H?o?i:"?wpk]?wj?dqV?dkR:?Qq"͒?QkVZT?>pv?>jfc?+o?+iL}?m
DC?g@ۮ?jRn?df?fN
?a?bR?\?^6?X6ܒ?XS?R„?R`+?L؞?K?EK?Dzq?>4.N?m;?m5?Z2f?Z-!?G)Q?G#{4?41^?4Bw?!?!QO?}?$?.6?b?2a?f2`?b{rI?Onљ?Oi?<[?A?uHM?uk?3ڏ?h@?pCf?jwǪ?O?I?.b=?(yI?nx??Љp??qƇ?q?^Â?^
=?K}6u?Kx"?8X+?8R|b?%2O?%,?d?;\p?`?ޔt?āb??ؒy,?،?h~C?b?=?8T?wJu??l???xR?xM?eHV]?e|Ω?R^0/(?RXd
??/f??)}?+?+$?V!???$?mj?gT?;64?5j^?R6?k5?p??	??k?eÇ?5ٻ?0%}?k\?kڭO?XȪ?X9?E ?E6OC?2Xh?2R??ڴ(??&Ps?Z@??pm?j-?4-?.?Y#????s?}w~?w??&?99m?88Z?$ے?$˿?d?H?vˠ?q?36?-;%~?}%?$?ĩF(?ģ{@?cd,l?]&?Օ?
?՗ T?!;?w?w4?dEFX?d?NNu?P/?P;I?=?=I?*gN|?*a?	1?>G?#g?L=?z}?}E?61f?0f,?=B?r-:?Q?Ҳ?JR#?DAT?Y??|?|5?iXm?iR?Vuj?V
?B۪?B?/`)?/Z_/??e\?H?}?`MŊ?Z>?	=?؎?βO?άst?ZG?T}
?j=?h?*l?_}?N?HHD?mNF?mXK?Z?Z-n?G;??G5?3K?3? jQ?? {?
#9G?
o0f?^?!m?dC8?_	–???>>?+1Ԟ?++ֳ?%Od?[U??er?:!n?	:??G?Kz?E?=?s?TXx?Nf?{?h?Z?T?{ܥP?{s?h^?hXG#?A?k|?B?m]?m售?ZQe?ZK;j?FF?F5z?3MC?3?}p?x%4?a?)+?C-Q$?=d.?Z?)??p?fO^?`8%j?ř,?r?$M??=}{?n(DP?n#?Zb)_?Z\;^?F$?F-?2SN?2̋C?	w?:??hT?:*?uq?o,e?/?_?YS?ّo6?% ?
\=?FCe?@{.?x0?rc.?퀪2?퀤?lۜW?ڐ?׻?~?~?kl,?k?WC܏?W=?Cj?CdG?/!H?/1?D?1?f?Ӟ
?&M?^g? 8cq?>]ޚ?*w8+?*r?_?k?.?g^p?NL??/3?ڻ~?Ҋ?8!??ݤR?m?Mu??s?w?w	'E?c\?cbl?O)?O#W?;51?;/i?'@m?':`?KV?E?Uh?O-?^΄?Y0?g?a?oCL?i?v??q2X?}1?w?臃J?}	?s"?s[j?_h?_.C?K?K?7G?7=?#8?#7͝?
?B?k_?8?#Q?\?Ӝ.,m?Ӗg?翛B?翕X?竚J%?竔l?痘W(?痒?烕g]?烏L?ov?oÍ?[?[5?G\?G?3։?3|O?{;?ut?sC?n,Iv?k)?f83?c[?]?Z	$?TB5?PU?JEi?E\+???:s?49\?-_F?(2D?k!A?k{?W?WA?C4?C`"?.R?.D?{?خh?ׅ{?ѿ)?ƽ?$S?޵Jg?ޯ?ʣ(?ʝa?嶐W"?嶊8?|%?wnK?h?b?zSGZ?zN?f>`?f8H?R(2oZ?R"kǟ?>TO(?>.?)/?)`?ᚿ?#p?ȸ\?L?-YB?fO?ٔ`?ُ.ϰ?z"b?tJ?^~?XOX?BCv%?<|;?%[J??uŅ?u|?`8?`?Lʛb?L?8?8<?$~A?$?iѝ?d2,?H6?Bp?%h? ,PZ???/9?y??K?EPn??թ?ݍs?݇ؠ?-?'ܨ?ܴ?ܴY@?ܠk~?ܠf*w4?܌
?܌M?w?w?cDQ?c>?Nn?Nکs?:{
s?:v?&h?&x???J?DS?ҿ'?
?zSu?uq?A}?|?۫?۫2'?ۗ??ۗ9\s?;R?;8?'XA?'R?2?9q?j^?d?3?έ?yP?t?yt?PP?٬n?٬W?٘?٘8?كT?كk?oIL,?oX?ZH?Z݁?F3
?Fo-?1)f?1eg?t??/?Q?b?J
E?ߝZ?ߗ{?|?9,?ضq%?ض4$?آG ?آ?؍)?؍(<}?y?y
&X?d=̊?dy?PQ?Oѫ(?;C?;y@?&?&b?o=?jN?;?wgA?]S?X.-?L?6+?IV?C}Z?׫i?׫@Oo?ח2*?ח,A?ׂY!?ׂ]?n?n?֋ا/?֋?wC7?w=s?b[
?bX~?NS?N?9~m?9yF?$?$?Mв?H.*?x?#Z?T!.?[Z?_*?y0?ս	B?սEb?թGhM?թB ?ՔJV?ՔO?Հ

?Հ[
?kom?kiE?VКZ?V?B1?B+W%?-R`?-- ;?!21F?!,mM?)??ޏ?zn?3b?-??ΈGc?΂?ӹ%?ӹb-?ӥ/Z[?ӥ)6?Ӑ㻘?Ӑ| e?{Ň?{5?g$	?g:?Ru??Ro??=q?=1?)^16?)?b_P0?\y?`?%?Z:?P@?HS?B?	?ܭ?Ҭ?B?Ҭ|c?Ҙ(/?Ҙ"l^?҃qr?҃k;?n^?nHr?Z&?Y3G?EI3I?ECp1?0%?0?թ?j??Ԅ?_m?Y+?ݣL/p?ݝ*?z?z)?Ѵ)42?Ѵ#B7T?џjG?џeN?ъ
?ъK?u쏤?u̳?a,fz?a&$ ?Lk?Leˍ?7{|?7I?"ݮ?"0?%;?B]>?a}?[?O`?䗌P?r?ү[?л?л
(?ЦLSa?ЦF?Б?БYn?|Pj8?|?g?gWZ?S-cAL?>]O?){O4?)?ΛF??+?O?6j`?1?iq=?d:Ͱ?sQ??Ϭ>C?Ϭ{?ϗ]?ϗ?σ/?σ*G?n_?nY:?YJ?Yq?D:?DxU?/?/DK?*_1?gީ?Dݠ?>`?ps?jf?ܛLY?ܕ?J?Uٮ?β9?β(?Ξ8?ΞS?ΉA?Ή;ԍ?tin.9?tc?_g?_{?J!M?J_?5֫?5;?!0H? nH?&8? ?JL?D?l{?g3g?͎L?͉.?͸=],?͸{?ͣO?ͣ?͎r?͎?z?z
V^"?e.?e(?PL?PF?;ijG?;dCl?&uݣ?&?]???Մ?&?dՊ?	R?G?̾>U?̾|E?̩#	#?̩?̔;?̔5?R7?M?ji^ԗ?jc?U: ?Uyx$#?@hT?@\?+K?+(???ǀ?B?*Vl?m?ܬV?AlZ??kh??ˮI?ˮ'm?˙%)?˙?˄4?˄/#&M?oCb(
?o=W6?ZQ2?ZKq?E^Y?EXU?0jb?0eAM?v?p?w?|?Ht?񆆻M?ܖi?ܐW?ǟ?k"?Ǚ}?ʲG?ʲԶ?ʝj?ʝ?ʈH?ʈ?s5@"?ssS?^`?Ȑ}?{Fi?{?f?f?QzP?Qth9??n1??/e?*6v?*u?Ζ?z
|?i"?cw?RJ?M>?;U?5a ?#??Ƭ
q?Ƭ?ƖY?Ɩ1?ƁCJ?Ɓтe?lUn?lt_?W]?WU?B?B>?-h>ߍ?-b~
U?Jҷn?E(?,3.?&e?
0?:gX??T%?y(?ȸgk?Ů%?Ůg?řOL?řո?ńj9?ńdx?oGz?oA\?Z$?5lvu?/?s~?U?ò_&?ò?Ý?Ýİf?Èqo?ÈkO?s>?s8C?^
Q?^?H\?HМ%?34!a?3sړ?k\?e?	4
G?	/g?,?D?&?
5?ɍGn?ɇ;?´T?´NTع?Ÿ5?Ÿt?‰ߪI?‰!?ttb?tH?_hu?s?^g1?^b(a?H`?H(?3}>R?3w4?g?)ԃ??+(?CJ??ݟ3l?ݚ3{?&?!82?R
,?ZZ?3^?-F[?
3??Nu?r??88"?p=l?p7?Z8?Zz/?E4\cF?E.?/m?/?(w?"_?>?`?^K?I?ْ;\?ٌ}>?	"?d?&?yhj?|q?%?i&)?cg?m&V?mg?XPyD?XJD?B"?BdKe?-5 O?-/b?q:??0|?Ye?p-?SE?_8??es?_DP?`d?XV?8u?Н?З˫?U{??ZV?T|?v?Ry?zY@?zBN?dp`h?djk?N˹lY?N?9&jt?9 ?#u?#zx?
?
}?2B?,Ϥq?⊜N?,?'?C5?80?2
?`?u?c?)q?$0F?r4i?m6?Q+?ﵓ??FwW?J]Y?DK)?c??Q?V$??Z?m_qS?mY/?W G?WcZ?A#v?Af[?,({?,"?j*,?dmq?.?q[?놞?ɓZ?+4%?%w?j7"r?dz?@?AV?>H?M?
Qx?z??*m?$	?`V?[+9??,?xˬ?xI?cx?bU
#?M3?M.9~?7fP?7a#?!J5?!?
N?NF?#?fT?,Gz?&ӝ?\V&4?Vi?rp?}?6>?(?N??s!?sq?]AM%`?];?Gm
:?Gga|?1E(?1N?rq?	I?b?zP?F?wI?>Z?8?f:h?`~M?r[T???FB??.$?l+m?lo	c?W#?Wb?AG?AAw?+k0?+eD6??_??3?Щ??=??a?K?
F?/et?)]%?M?Su4?
)Q?
_?&UYg? >?>wJ[?83?Uc?P5?l3?g%??}%J?uZ֜?u>?_)%?_m#?IM.?I?3i?3o|?痡?۫???9(7?}:p?y^?P?,6!?&z;?;!?5@A?J??Dbo?X?R?nf:q?n`~l?Xs+?XmWZz?BC?By:?,(?,_?D??B?y?g=	?꣫?ԲG?Ԭϰ?#??"?U8???cJ?][j?K8?F	x?3ʡ?.t?'?.=I?_B?Ho?ygX?s?\ wp?Ve?>1u\?8v?Z??Ve??lTz?ڱv?}?}5?gU?g?Q|?QvF?;Z*?;Tov?%6=O?%18??
Y_?0?|$?\?áu?̣w?̝?}?wK}?U?P#Ai?.
L?(R?t&?s9?]w?]ֽ5?GU?G?1A?1?])?Wn:?1i^*?+?[?HP?l?:Q?ª>_?¤$T?{=?v'W?Lx?G#?1@?wV?i?i#?Sl[?S)
?=B?=?'W?'R?Ȱ?%;?QK`?v]?m?!?6ٓ?·c?΁+/?Qu?K?&{?b?S%?ݘ?uA~+?uVa?_r?_lub?I9Oq?I3d/?2
a?2S?Q???1?L?G"?!?
g*?ҽZ?TV?|?y?Ueb?P>g)?Z?܆I?j֊?j?T?T)??>Ty?>N?(qyT?(???d?0?H`+?BN?\,?f?\4??x\?r#h?1Tq?+)?ub	?u?_h?_?IYƟ?IT	?3{g?3
?Ƈ?Y?{`?v1?0c?*鴎?䴌+?8?ØZ?ÒdG?J8?E%g?G`?=?g?i?j_/6
?jYu?TOW?T	?=0z?=
?'m?'gW???@?Ç_?v?p`?u?"J?|?ՈV??xK?r?"?8C?t̆?t̲?^uqeb?^o_?Hk?HP?1S?113?lIѰ?fz5?Ő?rC?Ad?{?]B?W???N?k?H[7?B[?~?~?hi?h3?R-PC?R'h?;@}?;LJPB?%l(?%fs? :)?g?a?X@q?FX?@ ?}?:dS?~g]?y-R?/5?v%?/o?#>?rNN?rIF?[?[SD?E\?Ez\?/-?/ܼ?
?9?Fb?@S?ܑx|?؉?q6?l+L7?n?Ҭ?0,?8wW?I?4?W?QH?n#y?ܵw?nm2?ngy]?WNF?Wm?A0?A{	?+	5?+m??|??-"=?t??G@?&,6? s??a?05?*~u?R??w8M?w2T?`2?`z?J=p.G?J7W?3J(?3Om??U?:=?=$?q???:&?پ?ٹ?=*$?7q\?8~??7@?2!?6v?~d?i/?i*6&?RsN?RF0?<%hg"?<(?%+h?%s.?Gd?c_????Տ??y/?H?:#?kNY?ee??H?qTf?qNP?Zg"?Z?D:|%?D4dl
?-&?-n	?k?Ϗ?=??JQ\?R#?m?g$?if?ֱ?Jx?D5?s8?b?b?K O?Kh?5f;?5a+^
??E?:n?4Ҕ?5T?}?U@T?s?r?m?ٙ:???9?:z?fS?B?Ѷ¢?)? ?~?K?4?>:?8|?aߖ?[e5?qX^?q}Tu?ZK?ZE??C?Ccc?,b?,+?5?J&?>/6?'?'L?{{e?r?O9?5R?{_?_?˦?ˠP?|?1?ޥr?)C??E.?ol?oz1?Xu5Đ?XoL?AiU?Ac?*\d?*W;?O?I:?A?<
?3;N?-˗?$
$?X?:?3??I?f??q?q"?ZS?ZȞ?C3/?C~}?,mZ?,^#??II?}F?x22?h(?bt?Q?L
M?:h?4E?" ?Fk?
"?n"?sf?s?\?\35g?E?E?. ?.kf?/?;?j(?dﲋ?Mƽ?GT?0?*b*?D]? >?	?6=?[[?ͦ?u%?upg?^Ep?^U?GpG?Gk
?0NX?0H*?+¿`?&t?JM??*??v}?ӿc?ӹ¤?'?B?se?n.0Y?M(??Gt[?w%.?w ̝?_?_?H,?HeyE?1"d?1?!?|?W0?Q{?+Z?3,?3E???b?\O ?~ ?~k_?~ǫ?~,?~-\?~yC?~Xf2?~S9?~D\?~Rc?~yvtM?~y?~bAZ)?~b?~KEcj?~K?k~?~3?~3*?~~?~vF?~o?~j/s?}'i?}!Po?}JKh?}ؖ??}?n?}?}Jn?}DaX?}p?}P.q?}yIJU?}y?}bfLj?}ba3?}KLp?}K-h?}31?}3~?}}?}x)y?}.⌅?})/d?|AlU?|َH?|֎Ҥ?|։Ff?|>Q	?|8[6&?|zH?|?|@?|v?|yGc?|yA?|a?|a,S?|J?|J|?|3J殐?|3E3?|r%?|)r?|VT?|U?{H(?{B㲆?{12?{~?{%	?{r!?{@vx?{:'?{?{m?{x#vv?{xp?{a2?{a,b?{I@u?{Iэ?{2{VG?{2u>?{%?{Y3?{S?{Ζ?zb?z]LT?z?zR0?zb?z%?zDeO?z>b?z"g?zo?zwk?zw{??z`@y?z`<?zHU?zHi?z1XB?z1S?z?z$d?z&?z?y*?y$bg?yh?yӾ-و?y]Q?yWR*?y?y~?yU@?y?yv$?yvEo?y^
<?y^W?yGPʔ?yGK6U?y/!?y/o(?yz?ytv?y
?y?xcR?x+?x4wP?x.ŞR?xk6F?x۩?xWD?xRv	?x_P?x~v?xtx_?xtr(?x]K?x]?xEj1v?xE?x.$u?x.`-?xڷ?x({?w>O?w8^?wʯ?w?wV"?wPpP?w?w;o?wkʠ?we`?w\?wm?wr}kr?wrw{5?w[?wZ?wC*?wCxdž?w,X?w,_uE?wQ
?w]?vQ?v?u?u! ?u_?umZ?umI?uVYb?uV,?u>?u>X?u'!e?u'o&?u{?uz?th?tO?tl}?tg;?t⍭?t?tWB?tQҩv?t?t!b?t?z"?t9(?tjy:?tjǮu?tS$7?tS?t;4?t;?t$?t$m?twwX?tr6?sby?sK?sV"?sQ[?s?sſm;?s2	?s-1?s?sM?sr?sv?sgxA20?sgrr?sOh?sOݷ4/?s8MeE?s8H6Y?s ?s 
?s	 S?s	B	}?r	L?rÛ?re$??r?rXY ?rRA?r9?rK?r%-_c?r|+W?r{wN?r{Ƣ?rc
?rcj|?rLS&?rLMhX?r4s. ?r4?r#?rq?r{/F?ru~-?qܔ?q?q=SP?q7@?qm?qŦ?qB?q/:?q[*?qU't?qwD?qw%E?q`YEo?q`J?qHt3?qHnw?q0l?q0ʻ?q+'?q&M,?q?q85?p1?pۀ(c?p:?p5!?p΀?pe?p&?puӪ?pC?p>(2?ps߄?ps4?p[N\P?p[띒N?pDGu?pDA`?p,/}-?p,~?p?p
?oD}^V?o>̦?o嗫?oI7?o7\R?o䆬?o<ͣ?o6n"?o`?oa?o`_?oM3?oo-?oo(F?oW}K?oWwM?o?˽f3?o?Q?o(SN?o(
?of>rX?o`R?n$?n՝7?n#Or?nrH?nIww?nCg?ni?nAE?n?n_&?n&u?n _ ?njnh(m?njhm?nR?l?l؂m?lL%?l"?lr?lQ?lKkr?llq?l:?lw?lwj8?l`!=?l_q2N?lH:?lH4{
?l0s;6?l0m?lPI
?lK?lp>?lv?ku8?kـ?kO(?kI?k*?kz|?kT?kS?k7r?k#?kr!(?krI?kZTK?kZNp?kBTx?kB@~?k*f?k*?ka?kؔ?j?j-{?jIIp?jCڅI?jxj?jr?j;?jK>?jԺz?j
õ?jm:?j'?jl.M?jl(H.?jTZl?jTToU?j?iRq?iz?itQ?hBsm?h?hֽN?hַW?hݳO?h?ho?hP?h&8?hц?hw:?hw5F?h_X[v?h_S?hGu?hGp0?h/Y?h/d.?h,P?h}!?gZb?gë(?g
?g2d?g~?gM?gZ?gK.@?g/E?g)ގ>?gGyG?gA?gp^?gpY?gXu_?gXovq?g@W!?g@?g(?g(u ?gXm?g8?f]j?fî?f|?fxY?f};X?f;?fE?fJ?f?f
Q?f#?f?fi3v?fi.>?fQCl$?fQ=:?f9RD?f9L
&?f!`w?f!Zȥ$?f	n0D?f	hXTH?ez?euB,?eه3%?eفR?eר?e$	?e!"?eW?e ?ep[?eye?ey ]G?eaD$?ea)?eI?^آ?^[_?^h?^bӥn?^mAXZ?^m;=?^Uq?^Uܘ/?^<?^?]cb+?]K95i?]K30C?]3	GM.?]3&?]ر?]_?]y?]?\u?\o?\C
?\=_?\߁?\
2b?\	Di?\\*?\?\ʹ?\qrl?\ql?\Y<^?\Y6?\A4W?\A?\( V?\(s?\e?\
?[_?[YVѤ?[%]?[ Q?[Oʘ?[s?[!?[NȄ?[w.O?[qWF8?[;f?[5?[f!?[ft;?[N8!.?[NF?[61?[6~6:?[Fs1?[@`C?[Ά?[?Z?ZmU?ZՇ?ZՂI?ZG-?ZA[n?Z^,?Zi?ZèU*?Z?Zt﬘?Zt{B?Z\=*?Z\7}?ZC?ZCE=?Z+i?Z+8š?Zoe>?Zių?Y)?Y#c?Y?YcJb?Yʛc?Yʖ(Ѭ?YS?YNH?Yqh?Y?YH&?YB?Yixyk?Yir?YQ.x?YQ([1>?Y8w>?Y8E?Y 6?Y w?YJٰ^?YE-B?Xג?X+)?Xװ/?Xת(?Xa ?X\8?X?X
J;J?Xb?X?Xvs-?XvmG?X^"S?X^*?XEk|?XE(">?X-~?X-y?X+W?X&B1?W؆4?W?W{`?W~(?W/}L?W*J?Wwq,?WC7?WQ?W~Մ?W-?W(;إ?Wj֪|?Wj\3?WR~?WRy ?W:&aP?W: _J?W!q?W!\?W	r4b?W	lI?VO=?V3?VػĢ?Vض?V_Fz?VYF
?V8?VV?V>?V?VwG?VwAn?V^P?V^⤿?VF?VF3k?V.(l?V.#?V?Vc'?Uf ?UaD
?UX?U?U̡?U̜N?U>?U8k?UڱK?U7?Uv¾?Upg?Uk@?Uk#L?UR??UR~)?U!&?U!zS?U	uOr?U	o?TҧT?T&?Tأ0?T؞?T9e?T4>?T~?T?Tdk؎?T^@?Tv^?Tv ?T^^@?T^?TF\j:?TF]?T-?T-N?TCq?T=_
?SԄ?S ?Sdw?S_H:?S`?STZ?S?S~7t?Se?S?SB?S2`?Sj-{s?Sj'ϸ?SQ.d?SQe7?S9F	?S9@WJn?S O?S ˤ>?S[?SVNX)?Rh?RSb?Ro__?RiA?Rt?Rr?R7}?RzAy?RJ?R?Ru%?Ru?R].}?R]
?RD;?RD?R,#?R,xs?RhQ?R?Q'
?Q!^`?Q	?Q^A?Q,eS?Q&Z?Q?Qr6?Q/47?Q)-?Q~?QyE?Qh/vǃ?Qh)?QO]?QOJ?Q7--?Q7'K?Q?Q+?Q'=?Q"Os?Pةg?P-?P^?P?P@?P"6?P{?P?Phg?Pd?Ps?PsU-?PZJ?PZyB?PA*r?PAC`?P)m?P)hC?PFȕ?Pޜ?OY?OTP?O
"?O_?OCs]{?O=Ȫ?O6?O?O*Ut8?O$ʰ?O}=f?O}#u?Oe(j?Oe?OL#?OLz%@a?O3Zut?O3I?O`=?OZj?O}*?O/?N>?N8n?NѬ
?NѦci4?N`R?NҞ?NN?Nb?NL?NjUI?No]yi@?NoW?NV9f?NVŽ?N>2SW?N>,?N%m&?N% ?N
9?Nٱ?Ml
?Mg ?MVm?Mά+?M;;?M52P?M|?Mѵ]?M?MpΊ?Myl?Myfj?M`i.l?M`ʾ?MH4AX?MH.r?M/*?M/Q4?MZ?M(?L[Y~?LU?L|ŧ?LҜ?LJ?LQ&?L|ئd?Lw.?L?Lg?L:h?L4?Ljz>?Ljho?LQE?LQ<?L9R~?L9LvL?L ?L ?L
?LV&?Kd?K_
?K־K?Kֹ8Uo?K]O?K?Kq6d?Kkq?Km?K?Kt!#b?KtY??K[wN?K[rI0?KBC ?KBșΝ?K*#?K*F?Kx?KsO?J%A?J|?J zf?JО?Js("?Jm~?J3\?J1?Jz?JL?J}gT?J}a1?Jdna6?Jdİ9?JL$?JL7j?J3UL?J3P?Jj?J.?JZ&?JV?I>8U?I8?IЊr0?IЄȚ?I?I]M?I ?IL	?IkAx?Ie{
?Im?Im=}?IT3?IT?B\?Bsm?Bs=8?BZ_%?BZ|?BB8?BAz?B)l?B)Ă?B4?B/Tu?AL?AG@o7?Ad0?A^?Az:?Au,%?Aկ?A-Y?A2ڈ?Aρ?Az?AzDw?Aal?Aa[
?AHvK?AHN?A/E?A/0?Ar?A?@?@SIJ?@)?@$9t?@:$m?@4|?@I?@D?@XT?@S?@g?@ar
?@htў?@ho)?@O?@O|=+$?@6WI?@6?@&F?@~,?@Qb.?@????4E??ҹ??Ҵ????^Iu??˩V????Ө{2????nZ??n]c??UT??U??VX?>C?>9?>>?>?>.
?>#bc?>{R?>?>Q?>u.R?>t?>\%?>[~$?>Cv2?>BM?>)#
?>){?>+x|?>v?=?=6?=Ky?=?=dz?=B|?=ز?=1a?=驰?=db?=z+?=z.?=a[m?=a״%?=H@T?=HЙL?=/~?=/l?=?=pZ?<?H(?28?1XX?18a?1?1S?1I-@?1C)?1 ?1{׷?1p?1ˢj?(`?(6|,?(5?(?(#?(@f?(L?(oS?(id?(ou?(o??(VQ?(VK>?(?(#+:?(	%?(	?'jb?'"?'|
7?'vil?'?'iA?'Uk?'O?''?'w!?'p,B/?'p&?'Vyo?'VV+?'=&~?'<?'#iȅ?'#d%l?'	_nr?'	̼Y?&:R\?&4:?&֡F?&֜;?&V/?&Π?&nf7?&hír?&?&0?&p8?&p3#?&Vm?&V+z?&=YL?&~(Q?$<8ۙ?$"V[?$"?$?$?#>L?#8yf?#Ւ
0?#ՌgP?#V\f?#߳?#7S ?#2[(?#y?#`~N?#nfr8?#n	?#U,&?#U&m2?#;|D"=?#;vz?#!˿?#! ?#?#?"hа?"c.`0?"Զfn?"԰8?"X\?"?"O|?"J͌?"T:?"?"m`?"mV?"T0ȥ?"T+&r?":z4?":t?" ÷V?" ,?"9Ÿ?"?!T?!Nz?!ӛ[?!ӕ
?!0L?!V?!'v?!"T?!mPl?!g_?!l}?!leu?!RQ?!R}?!99*?!93ы?!|i?!vB?!x?!y? .#A? 3? AdB? ;|x? n?? {Xu? ? y? (2? 7E? k>`? k8C? Q|]? Qv? 7? 7_? l? o
? 1q6? ,W]?m@t&?g?Ч0?ТG?A?N?T?1X?Te?NxM?i?m?i?O?O F?5?5f?05?+G?fO?`I?蛎??Ϲ???̥?rFu?5oH?0*?g?b@!?gP?gd?M"?M}?3Iܬ?3n?)ю?$0$?XQ?SK?B?V(?̴?̮?ᒡ?K?
W?J>?9.?46?ed-!?e_?K'?Kg?1c?1T&?#?܂
?
֬?
?2?,C?Yߺl?T>??z0??j0?|喆?|Dz?b𤧩?b?I8?I&@?/88?/2d?[H?Un?}D\G?wX??:?ǿW?Ǻ-\?l?|wm??+(X?zټ?z8?`=DF"?`7_`?F[)?FUoG?,x9?,r?_?a?? ??M?I4?}??T??X?w2?w-?]J?]E<
s?Cb]?C\??~??i?i,?ORY?Nex?54?4?xRX?g?%?y1~?)?w3_?uO?"b?0,?U?Jj?:8?~G|?~"z(?dښi2?d?Jc?J0{?0e'?0Il?W??%(?p)?Y$,?⧹t?ȢhȄ?ȜB?,?6???z} ?zx26z?`p\2?`jk?FbG*?F\?,S?,M	?D;Y?>?4C?.P?#4?f?o?ul?`???h?u-9?ueM?[M?[?AI?AS?'ڒ?'Y}F?
^բ?
}7?r"?l?[H
?U?CY?>/?+?&:?o?
Y/?pK?p?Vߤn?V(?<
#?.??ftĒ?foD?LM'?LHI?2&J?2 (??j?(ɷ?ϊ?㫦??Ɂ?{?V?Q?+Tw?%B?zJ;Z?z?`Ҡ?`?FU)?F
?,wi?,q{?H?C?x??
?Y?@ɉ?ùp޾?óS?^??V-?Q
)?u$YV?u?Zd?ZOU?@:?@1?&~"?&V?T=?O&?
O?
?
8?
㚅?
)?
8?
{)'?
ui?
C2?
=G?
o
#n?
o?
Tb-p?
T?
:>6?
:?
 ]x?
 Wq|?
!?
V?:?o?ѩ?ѤAΆ?l?gGt?/M"?)?|?t"?h9?h>?Nrf?Nm#Pu?42lT?4-[?/?S#???nU?iS?,?&n?@?:*??f?|`T?|Zf?b{qM?b݇?GՔ~?G?-Ț?->?G?A9?
?
?
޶P?
ޱN?
m?
h6?
#ˣ?
-?
H?
ӫ?
u%9?
u?
[Ba?
[<`?
@u
?
@[?
&?
&Sm?
[EOJ?
U?	l?	Y?	׾
*?	׸lB?	n{S?	hl?	I?		?	yi?	?	n|?	nvgv?	T)?	T$Rx?	9<?	9џ?	?	~I8?	/^?	*P?U?շ?І]?Ѐ|?0>?*}+?Br?&?h?}	C?g*?g%L?LҎ4h?Lޜ?2yj?2s?퍴?PA?ŭ*?%?j?e/?J|?	R?*c?+e?Vi?P|?y?yi}?_"?_gԯ?EY?w?K?d??ۻA?۵1'?Yd?T9X?ud?؍v?s`'?^'?r0m~?r+6pn?W̐h?WF?=g?=b ?#0l?"~w?M?s?5QlO?/?g?W6?e?`YAe?Yx???=?j*Ct?j$?O(?O+b?5T?5O,??XN.?|m?w?!?
	^?ˢ/#?˜t?3?.	8?p0??|T
	?|Nm?ae?a>?GsA?GmcB?-A#?,H?"?Ex??CM?ݨ=ʦ?ݢI?3\F?.\ߤ?q?xD?I*?Csl?sd>s?sШ?Y\g?YV?>03?>ߔDM?$m$Ϋ?$go?	zy?	ݹy?{*?u?;?X?C?=?e}?J?Zw?7?k??}i?w??X?oض?jA?)?
?s_5?sZ8'?Xr0?XD?>MMG?#?#}&?	8E@?	2vh?Ӕ?7t? ?$ƙ?j?t+?H]??;??lK?w|?rF)?p?pׁr?VA?V<?;K{?;Y?!	?!e?k?f?+?-?/6??2Q?$:v=?m?	Y?znV?4?ՙ?5u?0%?Dg?O?v?va(9?\A ?\<
6?A?Ak?&"n6?&뇍?G!?BQ֑??}?S?
>?HA?B*?Ƕ?D?n??lC?b?l=?Q	3?Qnz?6?6>Y?9
T?3m^???وCM?힙?(رR?#>?wV?q?Ş3??|I?|
tK?a_H?aZI5?F?F%?+?+o?B?=Q9?|?d?ֶd??k|?6?hL,'?b\?(G?uz?pfٸ?pz?V>?V8mS'?;?;~l4%? i? ρ*?. ??RS?LL?Еۤ?АAc:?å?)j?
ɍ?s?\@?W"?e?e?Jݤ:?J	h?0$?0y?[߸?VE?Q&?q8U?ז?)??(?PS?K/ޅ?s?B?t{q?tr!?ZY?814?kgE?kalO?Py??P?5>?5M?MU?س?* ?#ϼ?*^?$?O
)?J&?tQ?n?D?򔒫?yi*?y'?^QE?^ظ	??Dj;H?C
?)!>?)K?B?˜?˗?{&s8?{ y?`1(E?`+ȡ?E;:?E5?*Dl=?*???MR?G?U?P
?]Kd?W?dAkr?^?j2R?e؊?pQh?j?muj?mo:
?Ry?RtL?7}?7x%W?!?{`ݒ?"C?}?慔v?@?ˆ}?ˁ[?찇?찂?앇^!?앂<6?zV'6?z?_;2?_c?D?D~辒?)',?)|?/?y?{T?uL?wd-?q)?r?l?m?g!:?g6H?ayAt?l`d?lZ?QY&?QSn?6Q/?6Kq?HT?C??xK?9蜼?5?0%?+]u?%? ^f?ƚD?P?+?y.?y?]?]Fq?B;?BF?'(d?'ڐI?wk?j^?~?^A?ֱv?֬һ?黠V?黛&?頏3'?頉jW?}7I?wo?jj8?jdh?OVΒz?OQ7?4Bl?4=*f?./?(}V?ʆ?3
?ޗ@?G ?Q|?M?%_L?ύ
?葽[B?葷Q?v,?vY?[!?[N?@r;?@l?%W?%R[y?
=
?
7s;?!3??XB8??ލ??*?Œȇ?炭#p?炧P?g~|?gR
?Lo9?Li3?1OW8?1I?.ք4?)?c?
MJ?2$?p?_]?ə?	?橦O?橡C?掂?}h)?s^'^?sY/%?X9K?X4UN?=tK?=T?!^H?!?ǩ?w?U?뚾ƕ?xd?r:?Os?J=02?&%?!L?~w?~B?co?c??Hf ?H:0?-{p?-v'?O{+0?Ikh?"?/?V??X?c?䥘=?䥒a?h?cN\y?o8~?o3Ul?TW,?T?8%?8юu?TC
??r8?mNC??j?:C?3???W4?㕣
?㕝t?zmr7?zg?_7m?_1=?Dw?C?((?(Ñ?
p?
>?W=?RI(?M?N??ރ?⠩E?⠣?mwn?h=1?j1&?j,)΅?N2R?Nx?3?3'Xb?y={?t5!?;:c?57?
kr?tDG?Ƽ:?ƶr?{?v6?:?5*?t?t|x5?Yǽw?Y1?>s۪?>nE?#0R?#*?(z??a+W?2
?al?\c8?8?]?O|?Ϲ/{??u?dF*?d@>?H6?H?-I?-?jΫ?e8 ? sv?ݫ?x?'??JŒ?ߥ=T?ߥ8=?߉t?߉>?n`L?nʚ?SUOXL?SO?8G?8?Qr?U?gg?a~?۾?F&c?Ŵ
?}?ޯs|?ޯnY?ޔ!a?ޔئ?xΊ?x
?]z
?]uVJ9?B& ?B!?&jE?&A?|_?vʋ?&I@? /?ϗDz?bn?ݹxGt?ݹrM?ݞ Zr?ݞīg?݂?݂;'?gn?gi7?L?LNg?0R?0w?_?Y?4o?Q?ާWd?ޢ %?J٤?EDr?ܧeB?ܧТ>?܌VU?܌.?q0?q+?U.\?U˙?:pe?:kUM?%?
r???Lb9?F0o?)5?%#?۱?b?۱o?ۖ"@e?ۖl"?z?zm!c?ҐG2?Ґ8?u?u
f[?Yy	?YsH?=|@?=\?"D
?"?=]?h
?7?
??q2N?k[?ѳ"@?ѳiw?ј6>[?ј0@8?|ᚪ?|N4?`S?`S?EYO?ESp?)Ԗ?)͞?Jզ??vZ7?qJ]?Ε???л2)G%?л,T?Пc?ПP@?Ѓb?Ѓoz?hFE?h@x?Lio?L֒?0L?0?U]ك?O8?l???LB?^?Y Q?Ϧ%?ϦY?ϋ#?ϋҲ?ob?o\?S\?SX?8?8 F,?`x?[JQ?l7f?ٗ?_s?r?Y3?T"+?έo`?έR?Α\K(?ΑG?vLP?vF?Z
n?Zw:?>[?>`?#9=l?#3?e?V?Z?b=? b?T_?ʹl3?ʹfA?͘f&	?͘?}?|f?aKa.?aF^C?EF?ER?)8?)m7?&uQ? 2?m?h\?ִv?֮?̺o?̺%?W>{?QS?˥Uk?˥Ét?ˉ?ˉ=?n4?n@?RS?RNXu?6?6?Β??
v?h?F:%?A3_?ǁ7	?|aa?ʫ>?ʫ?ʏvc?ʏ?t/p?t*<9?Xh?Xb)g?<)?<-? $2>? Ғ{??	tը?ELT???z?ufZ?ɱx?ɱs?ɕu?ɕ?zK
?z?^Kg?^E{?B~?Bx0?&.?&?
I?
U?G*?o?Bq?<?ȷq)4?ȷlmy?ț[6?ț_?F?ɵe?c?co:?H*3?H$?,V?,Q??|?җ?AIP?؁?ｎ?ǽ?Ǽ?ǡ+?ǡ&K?DžT^̜?DžN͓?i|?Y?ivR?M.?M?1)j?1Ę?2UK?0??	o?:hU?4;C?^?Y?Ʀ$f?Ʀ|?Ɗ?Ɗj?ni?nن?R ?R?7
8?7?*,?%"a?J?D?iY?d>nj?Ljq0?ǂI?ūt?ū?ŏ]?ŏK?s?s;?W?W=?<]9?<l? 3Lt? -?ML?H
Ӥ?gU,?a?̀m?z)?İ=?İX?Ĕ?Ĕ71P?x	z?xy2?\ޮ?\)?@&?@&?%
"A?%OV?	?	_]-?3"ɶ?-<;?F?A&^?õYt?õTj?Ùl?Ùf{o?}}]?}x9?aZ?a]O?Es>?E ?)[,?)î?
]?
?Y0?.?o+?K?¹?¹UU?n?2K?‚??q?f
?f?J?J{?.#=?.?,v?'\O?6 ?0ʀ?>_?9*5?Fz?A'U?N?H?Tk?OM?j[N?jUw9?N`?N[q?2e9?2_.*?i܋?dLD?m?h?p?k)?s>]?mg6?t`?ohoj?uT?p]?nvC1?npK?RuC?Rpl:J?6uEP?6oi?sm#?n?qqS?k]?n?i!?kV?eV?g[0?ao?b	?]5M?r]\?rXH?VW+?VR.z?:QM
?:Ks?J??D?B''?=	?:Me?4?1h?+%?'?"X
?rG?9 ?v
/?v
}{F?Zy?Z#?=?=,4k?!'?!/??h@?)H?Ι?žya?/?]?'x?
.?9?yԟ?yEF?],|?]i?At?An?%bjJ?%\VR?	O]?	J)??iTD?iŮU?Mh5K?Mc
H?1@@C?1:?K?=?`?)?Ç9?ܽ(E??.6?mS?g.P?AI?;?l?l?Of2U?Oз?3?3k??zs?[@?Vb?,;v?&*5??\??nB?n??ngEl?nag?R4G?R.?6bD?55Z?!Xo?Ǔ0?*??cM?]?-z?')?T?~B3?Z?pMF?pUp?ph?TP]?TJZR?8.&?8?ݲR?$#'?
?	%?h?cU(?-k?(?ý????rw֔?rri?V:7?V4?9ڞJ?9LX?=d?Ut?}P?w
?=!p?7?Vv?ӥ?8?b-?x4?saS?t6R?t0G
?W
?W7[?;Fe?;V?jE?eJ?%M? ?7?'?ڙ?g?mD?g~.?w4?w6?Zм?Z/x?>?>|k?"1?",kR?5o??鐼n?/??4i?9>?3?炤v?L?d?xF?xAay?[D_?[e/??Y??
?#I%u?#C2?U2?
;??Y??E?@Q!?7Yz?dh??e+?y=^E?y7s?\?\?@,?@M?$.62?$)A[?~\V??w?r?
.?}cd?a]?X?`$?Z?zx6?y:t?]~?]C7?AC;E?A=?$r.?$W?@h?|5? ؘ)?K?Ͼק?ϹK
?\7%?V	?}6?o?z)?z?^02?^+,?"IK?w
_?wCB?Zwx1?Zq[_?=?=k?!Iۉ?!DP?%V??ԯ?I?ˀ?p?{a?hQ?- ?MKW?G?u?u	O?Yb?Y=?(?9$??./?$?0p?Si_?Nl&?+?L?	m?:?rc~?r^9|V?U$?U?9n?9b.d?n?hܢ?Ŧ??t?DH?rVW?mk+T?ȳf?)@]?q?JP?pr[3?plѫD?SH2?S?7F?7
?lN?fĴ:?i}?߫?r?
_q?`?[D?^?h?ǷL?=B?nO݃h?nJS?QW?QA?46b,?4欂9?9|4?3ZI?&C?n?5J?̫z?`??ퟥh??ퟥbz?퟈f?퟈9@?kh?k?OEs?O?'?2
?2Z,e?ջa?1A??nL?cHd?^?ힿ|?ힿ?힢H?힢釳N?힆32B?힆.Z?ixϏ?irE?L?L64B?/Ɩv?/='?A2X?;h??}{|??b?پ?흽x?흼U?흠D?흠?\5y?흃O?흃~\?f#^?f?J[x?I$C?->e?-9Dv?{~G?u?}?
9?$?3?휺-C?휺(_	?휝h(a0?휝b-%?휀%A?휀D?c]?cO4p?GE??G
X?*Kq?*E?
N'?
|?y?_p?"?^7?훷$K`?훷W?훚Yi?훚SfZ?}??}u?`n?`HΖ?C?C?Y?'&"LX?' ^D?
Wwv?
RY??~>?йH?д]?횳x ?횳?횗Ӿ?횗J?zGV?zB?]uA?]p#yA?@0c?@?#?#ʎ3?e??(\?"1?S1?MK?홰}c?홰x'[?홓?홓
4k?ڶJ?|?u?향\h?향Rz?했/#?했)}8?kH'?kB>?N`&w?N[ [?1xeH?1rG?? ?'"Z?,u?ڻ]c?ڶ[l?핽զ?핽z?할?할1,?핃t?핃?gJ?g:o?JuSj?J}?-1`?-,"S?C	A?=D?S5+?Nco?d0?^?픹sƱ?픹nSH?픜0?픜}d{?`?B?b9+?bw?Ex?Es2?퓗?zAl?zM?^\?]#^?Ayu?A?$?$
&?E??D??!]?"v?풰&rt?풰 ?풓*N?풓%Z?v.8
?v(?Y13L:?Y+?<3"?<.
ߒ?5]?/j)?6$?1t?7H?1?7k?1c?푫6w?푫0uv?푎5?
?푎/?q3k?q-䮧?T0Lh?T+v4?7-?7(nzk?*S_2?$R$?&cZ? [?!Eȱ?}?إ?Q?퐦`?퐦I?퐉0:,?퐉	H??l?lnԇ?O"?N2?1Z?1.yT?=f?)a/?N?߉w?׋?P?폽?폽??폠Ě?폠?폃GJ?폃8?ft>?ft?IW?I>`?,Զ?,r#?-?}
E?sH?n
_?cj?^t?편SA?편N?펛B?펛<g?~0?~+A[]?ats?ao?D?D?&?&u
E?>@]Vu?!,Å?!'bt?S\Y?
?"?󜥷?Z	9?ʞ?팬d_?팬n+6?팏:s?팏o?r[?rѥ?Um'?Ug^?8OXh?8If?0?+j??i?Q?ˣ?J8?̗V?͹op?ʹs?툰?툰!G?툓X?툓Sp?v'?v!~r?X\[?XOM?;r?;?C?(?Z
?U2?&(`? (?~?y/E?퇩<'?퇩P?퇌"'?퇌]Q?oM8?oH>?RB?Ra	-?4l'?4R?XP?T?j?e&?0b?*ܸ?톿s%?톿U?톢џ?톢|~?톅}15?톅xe?hA8?h;?K?Jg?-?-?)?-?HhU?B^d??-=?텸aG?텸?텛w&?텛??~E&.?~@nD?a*?`O-?C?CV?&}˩?&xF?	9~?	4[?Z??ΰ;}V?Ϊ?턱jr(?턱d?턔$0>?턔S?vD?vF?Y ?Y:&c?v?Q?Q/.?4R?4	fX?[q$?UR??6(?ܽl%Q?ܷ?킿mP?킿h?킢H?킢b?킄`?킄fG?gz8[S?gt
?J'`?J"h?,m;?,τ*?U|?|Q?-u7H?} 8H?}:?}ʔ{?|a^(?|[?|	ܼ?|솜>?|K?||?|?|$?|ox?|oc?|R.8?|R)>
?|4qO~?|4*?|IP"?|D0?{z?{ЃՄ?{a?{\jp?{8?{?{w?{rjH?{	?{?{f_?{faB?{Iuƕ?{Iͪ?{+e?{+Er,?{$?{%?z𫣆?z 2?z2,4?z,Q?z?z?z=v?z7?3?zz6.?zz?z]F]?z]@ ?z??z?k¿?z"L?z"Gb?zE7?z{q?yQu?yKP?y:R?y̷V?yR5?yMO:u?yѦ?yOh?yqR:I?yqLU?yS	f?ySˆˊ?y6OCo?y6I*?y?y`?xIkd?xDj?x^,?xC	?xBf?x/?s,?s'}P?s/?s$?so0?so3:?sRM,R?sRG?s4@?s4\?s
Ra?s?rhV?rb*1?r!	?rۿo?r!?r}?r}?rx^?rB?rS?re3d?re.?rG5?rG.-?r):?r)LR?r@-?r:9?qy?q@G?qNЋ?q͜?qG{?qAU?q?qq?qwr?qwv\?qZIM?qZC̠Z?q<͞?q?pO&R}?p1{R?p1u?pԧs?pS?o?oM ?l>Ͷ?l ԓ?l W?lD.?l?kG\?kAܾ?kܐ?kz\}??k?kGa?k?kB?kn%}?kn Tz?kP[N=?kPVyQ?k2?k2?kzK?k'?jP?jYe.?j.F'?j) _?jaH?j\PhL?jh?j?jjz?j?jaգ?jaUӭ?jD(y?jD#,%?j&X@?j&Si{J?j ?j`?iwe?iJ?i?i!?i0?i

5?i@'w?i:?isl8?isg?iUI?iUN?i7w>4?i7?i
F?i?h]?hп?hAg\?h;ԍ?hj0@?hd>[?h_?hLo?h?hx%#?hfw?hfw?hI['?hIi?h+-)?h+'9?h
R^w?h
LS
?gv?gq|gF?gћ?gѕ?gm?g9/?g??g?gx{P?gw?gZ%r?gZׇ?g?aM?a_&c?ac$?ac?aEǖ*l?aEx?a'ɏ[?a'E^?a	?a	q)?`˶?`8?`C?`j=?`ˀ'2?`'H?`)P?`/?`s?`shI?`UƶO?`U89?`7왜?`7n"?`Ȑ?`?_?_w?_ݸdg?_ݲ?_-?__4&?_
n?_@?_v?_I(?_e ?_e[:?_GS?_GTK?_)2Ѡ?_)?_}?_?^~2JR?^x?^tLc?^nF?^it?^dTY?^^,?^YA?^uS^?^uMɆ?^WFx?^WAU?^99\?^94}2U?^,?8?^'?]M?]?]ar?]
gF?]x?]3?]$:?]hL?]5?]&?]fψT?]f
m?]H#?]Hzƞ?]*?]*S?]?]?\?\@?\qM?\lTo?\]N|3?\W;>?\H65"?\B?\v2?\v-	?\X@!?\X?\:dR?\9'?\ʼn?\u?[#?[lS?[߽K0?[߷Χ?[D?[P?[LY?[Kw?[o?[jnN?[gTm?[gOv[?[I9g&R?[I3(?[+DC?[+s?[
?[
P?Z3?ZݔG`?Z?Zп_?Z,?Z.?Zh?Z-?Zvf?Zva0?ZXF	?ZX@Ĥ?Z:$?Z:n?Z&?Z?Yܲ?YL3?Y߽?Y߸U<
?YD/?Y?Yv?Yp҆?YQaJ?YKlU?Yg,7?Yg&-?YI"#?YI?Y*ߜ@?Y* W4?Y?Y?X! ?XQZ?XhE>?Xc?X??X:$"?X'?X?Xu?Xu昧?XWm5$?XWď?X9,8H?X9W?XjUC0?Xd?W=?W8j:N?WQ?Wc?WB?W*?W?WT>?WD˸?WȂ?WfVb?WfQe?WH&P?WH!m?W)Yq\?W)94?W1PR?W?Vsm?V@?Va?V[q?V.3*?V(?V?V6#?Vtƙl?Vt#?VV1?VVn!H?V8\?T9Q
0?T3g?S:?Sk?S۷?S۲i?SvO#?Spӎ?S4#q?S.P?Sa"?Sm&?Sbq?Sbf@?SDi?SDd-@?S&$_?S&[]?Sm?S?Rj?R?RRϾ?RMTW?R?R#.a?R5?RZ|?Rp{tx?Rpu"?RR2|?RR-?R3K?R3q?Rŧ?RJb?QT?QNo?Q6?Q5pz?Qy?QGE?Qp>?QjmK?Q~#"!W?Q~?Q_o8?Q_e%?QA%?QAV?Q#8C{?Q#2d?QfB?QPT/?P昻?P@B?PH?PBV?P׫?P\?Pe?P?PmRf?PmMq0?PN!r?PN1a?P0?P0V?PWω?PRT?O?O?Oխ?Oը1?OW\?OR>?O/h?O.^?Oz:?Ozr?O\RYS?O\LޑG?O=\a?O=[?O(b?O?OGÃ?OB4?N?N$l?NĒI,?Nč~?N7Ѵ?N2B1
?NƐ?No+?Ni^?NizA?NK"?NKL?N,R?N,rv_?Nfw?NaHC?M?M:?MѨ?Mѣ0~?MHX?MCD?M<כ?Mj
?Mv#x?Mv?MX%u?MX'?M93?M9]J?M`Y?MZߒ?LaJ?Lr"?LޘϜ?Lޓn"?L4N?L.j?LI?Lɥ	?LiZ0?Lc?Le!?Ldb?LFC?LF?L(4?L(/H?L	t>?L	V?Kcǂ?K^Md?K[-?Kp?K45s?K"?K%w2?Kz??Kq"8k?Kq1(?KSN4%?KSH?K4
?K47?KtT?Ko!?J(?Ji,?J٘#?Jٓ!&Q?J)yk?J$AI?JC8?JX?J~J4?J~D?J_ُ?J_3?JAhR5?JAb@?J"$?J"[?J)?J~f?I?IC?Iǝ{	?Iǘo?I)N??I#ԍ?Il?I&5?Il?.\?Il9?IM;6?IM;c?I/RJ:?I/M9?I۔?IP?Hc?H^eh?H둗
?H
?Hrl,?Hm6?H6*?HR?Hx'?Hxy7?HZ{T?HY?H;F?H;̖h?H
t?H^2?G
=/?G?G	?G?GyJ?G{?GP}e?G,W?GeF?G?Gf9I?GfU?GGN(?GG5?G)?G)Re?G
I?G
;N?F?Fɿ?F͔Ŀ?F͏Kw?F췉?Fs?F~Z?F?Fr
z?Fr߲?FS?FSh?F5$?F4:?FzR?FuwK?E?E?Em?Eh/?E$>?E૥u?E^
?EX?E}\Y0?E}n?E_L5Z?E_FP?E@??E@)?E"7p?E"2Y@2?E`?EVE?D!6Z?DO?Dƕ	?DƏ;?DF?DU?Dzl?Duu?Dj?Dj?DL^‰?DLY	F?D-Cۄ?D-/?D?Nq}?D9˨?C2?CH ?C
 ?C#r?C᝟?Ci?CU?C?Cvf?Cva.?CW'?CWͯ=S?C9?6?C99?Cd$?C묤?B ?B-t?BF#?Byͷ,?B,?B[?BQ?BLS?B.%?B?Bc!U?Bc&?BD.ib?BDN?B%4?B%T?BUԖ?BP\Q?AG	?A?A "*?Ak?Ah?A~C?A8z?A
?AnK2h?AnEhb?AObv?AO=@(?A1?A1
*?Ap'?Ak?@ѻ*?@C	?@1[J?@,qO?@d?@?@x%?@x2?@yN
?@yIp?@ZR?@ZF]?@<	?@<
?@f?@a.??ºt,??B??7:????y!V??s6z??u??G??-1r7??'??eZ??e%???Ff??Fvv??(6:??(1tZ??	U??	8?>)9v?>߱?>;gL?>5?>4?>N?>$?>?>p:z?>p5+?>Q?>Q6?>2߼?>2jRe?>4?>/*s?=͟6?=VX?=dB9?=?=)d?=#w?=y݉?=t[l?=zɪ?=z3?=\v`?=\v0?==g~?==b'S?=??6&pBVx?6&jJT?6XR?6/Q?5s?5$?5?57$?5SmW?5xC?5Cd&y?5=7)?5mk=?5mfk?5N=?5NVY?5/!i;?5/7?5?5kݰ?4*?4W?4-|"?4(k?4R;?4Lĥ?4va?4p?4v?4vz+-?4Wh?4Wq?48J?48?4e?4IL?3"M:?3?3Bf?3=y?3be?3]:?3mR|?3|{?3N?3~a?3`?3`!?3AJl?3A?3"iS?3"Hi?3?3|z?22?2-o=t?2NB+?2H?2i
?2cA?2=?2}ǧ?2iڌ?2ie2?2J\?2Jk?2+R?2+]?20P?2?1xD?1c?1+,?1C?1*JI/?1$?1?T?1:^#?1rTz?1rOQr?1Si%K?1Sc&?14|?14wzm+?1$?1?0v?0Nb?0״u?0ׯYf?0C!?0?0&R;?0ѱO?0zr?0zF?0[+?0[?0=O?0=?0+~?0j@?/"ظX?/cҶ?/0>zF?/*ɚm?/=X?/7~?/IK?/C*?/T?/OG?/d`L?/dZ'?/Ej?/Ee?/&tuYq?/&oQ?/}N?,>w	?,+?,a?,`?,,?+ᢛE?+'u?+›P?+–o?+?+Z?+
??+	?+e?+e:M?+F{bu?+FvJ^?+'r9T2?+'lVR?+h )~?+b1l?*]p?*W\?*R-?*LA?*FU,?*@Et?*9X?*4s}?*m,?*m'pѳ?*NLJG?*Nu	?*/?*/o?*^3?*Œ?)	^_?)핚?)H?)ݪ.D?)ҟ?),?)W?)?)t?)tom/?)Ul:?)U2q?)6%?)6ak+?)wo?)q?(cu?(^?(N?(ItJ7?(9š?(4R?($3?(,G?(|
]?(|Qp@?(\?(\r??(=s?(=,?(l?(7q?'Ѿ
?'^W.?'kv?'/
k?'{_?'vke#?'a?'\{W?'FE?'A'=?'d+?'d%
?'Ev?'E	?}?'%b	"?'%?'(CR?'ϵ
?&Z?&~2?&k:_?&k4l?&Le?&L? T@? TOH? 4h,? 4bvC? T*? ?K?ќ?Eb?;?&Z?\x??g??yI-:?yC^?Z9?Z?:ı?:?Bq?	$?|$K?=G?8v9??3;?з?_8?oi?iN?)nk?#?_2?_oz?@?@N4?!T?!N?U/?Tz?/?z??y
?t?/e?*?ȑ?W q?e[?eP?FMY>?FG;?'?&Pb9?X?#?eӪ?`d?5?;?Ȗ?%?y6?sh?k)>?k#?K^?K?,#?,?
5S?
/??|?Ώ"-?Ί?GR?Q8J?1i?1?`?(?:K?5~?T??& ?|?2cP?,?u
?uӜ)-?V#?Vy,?7$?73P?ɒ|?!&?mC?h}|p??Dd?蠙?w?W&?Rp?z?^a? /$4?#?e?_p?>լ?8?c<[?c|M?D0
?D*%?$r ?$my?u?J??fV?6,y?10[?v?qf$?w?
?e?e?F4I2?F.?&q?&l?F?D?
v?,?(v?-۝3?,o>?
+G?
&|X?Vb?P?̀Jy	?zޕ?J?7#?g̼??m?m.T?N"^?0eZ?tq-?	 ?_???лȒ?V?o?'8X?#?qf
?qB?Q+G?Q%?1D,@?1>?\?WE?t?o:v?ьl?цG?Ԟe?i?~??qκ?qO?Q`?Qe?1VH?1?I?ި7??@
?2z?-?'Q?򠼴n?Ҵf:?ҮP???/?d?r۸?rM?R籞?RF?2{?2ԛ?8?$?/?|?z?v?t??#r?$?s+g?s&"?S2a?S-6)?39?34hK?@"G?:?E)?@g?J8?Ea?O?J$>?S?N)3?? ?n? ?v%?U`?쨌?:??p?p{'?PcU?P]3?0E?0@ ?'+a?!p?<-A?As?2$?TLW?ȭd?D?
f??oۜ?or*?Oe?O_+?/Bm?/=^O?
?{K?o??l=?]?n?oA???H?nh?nc$?NB:?N=Ni?.-?.xB|?
{^?
?aB	?]?ͣ?͞-k?z8	?t`d?PHt?J8?m%3?m ]l?L?LJt?,2.?,ɣʗ??k?v
-?pJ?Hoo?CF?g?XS?A?ٍk?k/t?k1L?Ki?K#?+]WZF?+W"?,?'(wz?8?Ё?Ox?S?몖?몑k/?c`?^]?j0(??j*,?I?Ii?)6?)΄a?	?	|?\&?V+N?%:? #D?.?>?ꈶ2?ꈱI?h~{?hy[O?HF	>?H@)?(5?(V^??y?uB?
w?]wD?X?!,?m??`U?ff?fHn?FkZ?Ffk?&.t?&(??4#?尨_?@Ľ?q#?k
;?1?+Y?g??d0?d^a?DmhҊ?DhU?$+?$%g?)7??㤰D?IH?`P?[@9??;y??}CZ?b)?bd?BJņ?BEyy?")?!Z???5?t?o?us?z~?▍+?█5?v1"?v,?UJB?Ut?5xP?5r?Z??
?I?])
?WG??Pil?ᓝ/d?ᓘN?s="r?s7<%?R?R֘?2zK,?2t??>?3?a?Qe?LgM??s	?T??p$>V?pU?OE?O4E?/Xco?/Ru?[?8h?H?&?"c (?8q?߭Ǝ?߭?ߍP&?ߍKJ?lS?l&t?L}.˲?Lw7?,y"?,
޷?4?R?;`?5/r?y?ɗ¨?ުb?ު\w?މ􆏆?މ j?itXr?ie?I?Ikg?(R?(9Jf?8?3xn'?ȌC?'?ܣ>s?܂A?܂ǥ?bU?bPHm!?Aݾ?AYk?!e?Yb?!_!?.?Ʌ#?r}"?m)Qn?ۿ\?ۿb?۟}]?۟x3>]?D?~߹`?^`ް?^F?>	x?>k?[?T?Pr?	~A?ܑ)h8?܋m?ڼrЭ?ڼ

ۢ?ڛ+`?ڛh?{T?{
0?Z?ZC?:?:V?kE?o-?R]??؋*?؆D`5?ٸo36?ٸ
n?ٗz\?ٗB?wM?vH?V{ez?VvmJ?5뼖?5y?oF?j|>?H?G?b W?\y?سg?س\?ؓR?ؓL!+?rF?r?R?.?R:xc?1|?1'?+]M?%k?Ep?c?;?:.?ׯh2?ׯw?׎1?׎>?nnN=f?nhs?Mj[?M~?-Q,?-L8??d?3`?-p"?ˣ>?˝r?֫o?֫
)?֊N?֊{]?i~?i?I]XJ?IW8!?(2?(?6?1Q?碩G?E:?{?s?զx:.?զs^8y?ՅƢ7?Յb?eL:ّ?eF?Dex?Dv	?$p>h?$U?36?SG?d?5?S?M?ԡI?ԡS?ԁ?ԁ/?`?`~*??ˢ??~?KL?FL??d+??4L?ӽs*?ӽnQE?Ӝ@?ӜQ?|6<~?|0?[?[Eh?:G?: 0d?U>?Pkt??'k??
R\~?ҸpQ5?Ҹj?җ[?җ[?w)j(?w$s?Vq?V^?5h	?5۹
?;?6?$??So?m?ѳHDJ?ѳC?ђy
?ђXz?qv+?q?QP⡶?QKo\?0?0]?6?k?S?Nix?Ψ?Σ?Э?Э7E?ЍQǶ?ЍLF?l+6?l/@?K?KV?+J~e/?+Ei?
Qan?
l)?n?2D?>IfV?8}I?Ϩo?Ϩ?χ?χء?g-r?g'ƻ?F{d?Fv!?%l/?%	??c?cV?^.X?ï'?êjL?΢x?΢E?΂F ?΂A5U3?a(F?aw?@)@?@? $^? :P?m?h5O?޵Z?ްs̴?ͽm?ͽ;b?͝D@?͝?s?|]ը?|Z?[7v?[R?;?;T?[8ٱ?Uq?a/?_??ݗ?̸&cs?̸ 
,?̗hy/?̗c?va>?v5?UW?UW?5,4?5'j?l?gUq?]#b??u?v?˲)?˲$â?ˑg?ˑb?pZKp?p2c?O1L?OϏ_?/xc?/?Z1i)?Tb}?Xj???ʎP?ʬ	?ʬ?ʋCq?ʋ>T?j|Z?jv?I?IS&?((,?(Ld?#(?Y>?Zga?U?ƐO?Ƌ"[?ɥ"?ɥ-?Ʉz?ɄX?d/y?d*<?CcYH?C]Ri?"\b?"G?i?Tm?v?9q?->T?'f?ȟ^SP?ȟXo?~׎?~v?]̺6?]k4E?<3d?<,?
Բ?[?KR?E]??y?s\d?ǹ7?ǹSX?ǘ@?ǘr߯?w?w?W*a>`?W$?6UQ?6O?(?zS??%$??j?Ʋ?Ʋ!?ƒ#?ƒIt?qKD?qE?PrOh?Plj?/p?/i?-?ZN??޺?H??Ŭ-0*?Ŭ'$?ŋP?ŋK?jt!?jn(?IY?I(?(SH?(?َ=?-WS?9Z|?zT?Sk??ĥ9ް?ĥ4}ܬ?ĄX#?ĄSyV-?cwELs?cq?B?Bj?!k?!
Ԃ?'Yj?ƤI?T5??ÿ?ÿ/?Þ!B5?Þ?}<}?}7?\Vl?\Q!t?;oˤ?;jk_?m?9?s?zB?ظ?س*U?·ϫ?·KA?–??–t^?uC>?u?U?UWI?4&V?4!;?:	l?5?N#?IX?a?\5?tn~?o;(??T@?n?m?n߾Z?Mm6?>gI?t	V?o]>&?{˘?vT?ۂ?|?쾺?쾺&a?쾙DP?쾙?xr?xm?W3-?Wq?6յ?6v?n?9?p??ӡh?Ӝ	q?콲?콲sN?콑/?콑R4?p(?p?OqX?Oc?.2?.r?
~l?
k?W?e?˜i?˗A??켪Zh^?켪`?켉8?켉$?h ?ht?G+?G̢+?&?&I?]?{7&?y(?t?r?mc?컢kk?컢eF?컁b?컁]RF?`Y;?`Ts#^??Pd|;??Kj(?FfŒ?A?;ȁ?6{?0?+a!?캻%,?캻3?캚#?캚~
?y;?y8?W/?WaZ?6ڹ?6{#?g>?	?e&e?R?9?Ӿuk?칲?칲UP?칑?칑?pǔ,?ph؛?O?Oz=o?.mف?.hD*M?
Z+?
U[;&?GD~?A4?3?s?-?츪?츪M\?츉	{?츉,z?g?g}l?Fݞ"?F?|9?%ҽ?%t??y,?A?㗐K"?1?R?y?췡fA@?췡`F?췀L6?췀G%?l?_2d?_-K?>&?>Wm?za??F?R>?Y?ھh	?춹sa?춹?춘ۆ?춘?wl{?wfM?VMq?VHw?5.V?5(_$?	?	NZ?v_Z?J?ͳ?U??쵰a?쵰?쵏?쵏#?nhZ?nb^?ME?M?*?,!~?,6G?
'?
"=?ޠ?Ӏ?ȳU?Ȯ1x?촧?촧5?촆gpe?촆a?e?c?e:j?DF?D"?"
T?"L?G0 ?x?;?3?쳿t
2?쳿nB
?쳞I?쳞D<ۑ?}:d?};?[?[l?:?:t?:cB??l;?g	H??2?9/?첶LD?첶{ҹ?첔\?첔ܔ?sz?sI?Ru?R}A?1Q?1Lq&? ϳ?bu.??쬜9?쬜?z?zΣ|?YL̩?Y?8@k?8:@?; T??۴?~]?]R+?X!?쫳q?쫳?쫑fW?쫑	?pvU?pqq8M?O(q?O#JZi?-vX?-ԕeH?u?RjH?:N?5?~?"%?쪨`?쪨4h?쪇Hl?쪇B{?e
R?e𮺡?Dq0I?DJ?#PK??#J`?¨?:?TS/?j?쩿Sm?쩿N)G?쩝&k?쩝ʥF?|:d?|Q?[Ql?[LeH?9d?9^:?%l??Kb?E=?SrZ?q?쨴z?쨴?쨓?Jn?쨓92?qϠ?qߖAl?P0?P.8?/.?/)=
?
Ҙc?
?{?Av?짩EHr?짩ߪ?질]
D?질W*?fI?fV?E0?E?$?*?$9:?ޯ&?ST?}8?x[?1"?֬?즞 x?즞ū?}W?}R%m?[T~?[T/?:fp?:@BL?,U?&,?ǂ?'8?b#4R?\"?쥴7j?쥴_?쥓S?쥓cN?r."?r)_#?P'?P̽?/_?/Yk?
]y?
؇?% ?n?#a?+?줩?줩(?줈N2?줈H?f?fmD?Evf?Eqw0?$
.͐?$
Z?M?+W?/?)E?죿T?죿B\?죞Q%m?죞LJ~7?| l5?|??[r?[l0?:jY?9 ?:?\?}ʞ?#B?լ2?զ\-?좴9Z5?좴3O?좒}?좒nK?qQ?qLx?O}u
?O#[?.hn?.c?Ф?vHp?|i?wK???졨?졨KZ?졇ԋ?졇xe?eq?e?D%p?D ):N?"?"gX?2[
?,0?߷i?߲5?젾?젾6F?제̰?제:Y?{DW&?{>?Ynjs?Y2h?8J4?8DV?OX??Mܘn?He?r?ɂӬ?쟲OQK?쟲I`?쟐7(?쟐ݮ?oNe?oI7i?M^y?M?,K9?,FEf?
S?
?Fz?A ?Yl?ǽ?잦?"V?잦9ȝX?임8?임It?c5]?c0=ۀ?AWU?A? )ڶ? $x?)??|?P?읻!M~?읻ǿ?읚˛?읚rr?xI?x}?Vzf?V ?5o~~m?5j%	??ߝB?Y?T?B2?貐?윯BP?윯?>?b?~R?i=?4?\Nq?VnR?욷Ǧ`?욷M$?욖2o?욖-?t%?tTw?SZ?S?1o}o?1j$6Q??ҹ?@
?:3k?̧X?̢:!?왫?왫	&?왉t|2?왉o{?gڱr?gX?F?#?F:c?$?$XmA?ӂ?'?l{?g#,?옿ύ?옿5?옞2?옞,:P?|?|+?Zv?ZK?9VTa?9P?. ?N?lk??um?pK?엲Pڴ?엲m?엑2o?엑-@Z?o/?o?ME@?Mb?,IHP?,D(?
n?
5?u?x.?[;?VL?얥?얥)?얄B?얄
RT!?bhڪ~?bc|?@}I?@%?;?=?q 8?k??(?앺D?앺:?았ty?았o!?vfZ?v}d?U}P?UL?3r6-?3m@?Ɵ?G?ʧ?r5?lk?g5?씬~R?씬&v?씋?씋
?ia?i[$?GsL?G/,?&Y\?%9?P?K\?]?⟁F=?)?u?l?쓟;{e?쓟6#?}?}OK?[(79?[К2?: F?:?lH?f%?JB?"?6`+?X?쒳JC?쒳Eh?쒑0?쒑?ow.?o 1C?N$ss?Nh?,k?,f?
f?
lje?n?!?>i?9??쑥"?쑥~?쑃ʰ?쑃sk?be?b'B?@P?@K)w?S$?1!H?A?Э??hh?쐹YUj?쐹Sz?쐗,?쐗iS?uuŇ?u6?T2#?T?2Yb4h?2T.??&?j?ƷV?J?SX+?쏫P^?쏫KR?쏉T?쏉0?gg?gì?F^&R?EL?$?+8?$9Ը?ym?t?%a?Κ?쎾O?쎾?쎝$Ќ?쎝?{]I
?{Wl?YTn?Y0?7˂?7+??tV?7X?2~n?m,?ge?썰?썰?썎9@?썎?m	0?m?K=i?K7?)oH?)j]"?q/?p
?Mm?%?HC2??쌢4?쌢/`?쌀d?쌀_Ds?^?^đ?<h??O}]?J'M?xU ?sfL*?ȡQ?ț.?슦[?슦D?슄4}?슄>?c?cq?A>+?A8|?d§?^ߨ?L?Y?ۮ?ۨ=w?쉹;&j?쉹Vh?쉗(?쉗
{?v6?vsk?T;=?T6/?2]		?2X/RZ?~r?y?ߩ??:?̺?숪
%e?숪ڴ?숈Ml?>gۂ?m|?h(P?mvh?h":?lw?gP?쀶k ?쀶fr6?쀔jH?쀔d?rgJ?rb6?Pe&r(?P_d?.aU\?.\N'?]?X?YAN?TEF?Tkb?OTwB?O,#?I5?I${?CГ?bBw?b=?@6d4?3̵?.sc?~+<2?~&>n=?~"t?~|F?~~?~17C?~?~
Z0?~tJ8?~sD?~Q];?~Q	?~/㹊?~/?~
z?~
݊]?}N?}?}3ج?}C?}?}:q?}]X?}
8f?}cN?}cM?}AZ?}A0?}?}z5?|o,?|iA?|^D6 ?|X?|L>{?|G~ܾ?|:?|5to?|u(Mk?|u"?|S;7*?|S?|1?|0KuW?|v?|#??{*?{q?{È?{ʾ5{?{.?{m?{ns?{?{dY?{d{>7?{Bi)J?{Bcք?{ Q8'?{ KK?z8{r?z3il?z?zc?z'P?zN?z?z?zug?zuj?zS8G?zSX?z1Ax?z1-X?z~k?y%?y M5?y?y0?yd?ydl]B?yBC?yB©B?y ?y \3W?xլ?xH?xepi?x`?xC?x>-j?x!&!?x?xu?xu+?xSj6?xS?x1LJt?x1?xO?xO?wlmF?wg?wF?wAZE?w `:?w
@?wk?w8?wd(A?wd?wB:l?wB|*?w Z?w |pnz?vX?vSl^?v//Š?v)yp?v?v@?vq?vs?vuB?vu?vS?vS~66?v1WB֙?v1Qp?v*r
h?v%?u.4?u?u1@?u*?uَ?un?uq	?ultp?udB?T&?ud?tC?s?st@?sp?sqMW?s4?sL6?sp?sj^?sc8|?sc3+?sAO?s@R{?sǚw?sHx?rY?r1:?rT_?rO<֞?r:u?r?r\?r
?rsr?rsS?rQhf?rQbl?r/+?r/&5Tq?rXV?r.k?qQo?qꫠ?qr?qmƂ?q46V?q.=?q
?qǫ?qa5{?qa䑓?q?tV?q?oi]?q3J?q.d?p#?pҵ?pذ?pتZ{?pm_C?ph`?p*-?p$!?pqo%?pq?pO%B?pOԶ?p-]QYZ?p-XP?p?p?o;?o̷??oƋF?oƆA?bك6?bÊ?bMO?bHT?bz;k?bz?bXTH?bXOOm?b5wB?b5(?bYR?bTy)?aۏ?a@?a\͢?aWI,?a݂?a3?a]F?aX_?afPn?afOO?aD\ki?_>?_C?_6?^yX?^s e?^7@/?^t?^b?^]:?^ɦ?^Ѵ?^oJ%?^oEJma?^L
?^LUd?^*0&V?^**ث?^Q?^Ѭ?]?]?m?]„sR-?]%\?]x?]?]}d?]}_Q?]ZZ?]ZΘ(?]8B	?YO?Y;R?X!2?XF;?X\2?XV?X}/?X}m?XZp06?XZj5&?X7[?X7h?X%?X :p?Wd0?Wz"?Wغv?Wm?W1?W,<?W9?Wc`?Wg4)?Wgq?WE8-7?WE2?W"?W"R1?V?V7P?V9?V4W?Vy?Vfv)?Vn?Vݮ?Vu6ݩ?Vu1nP?VR.?VROQ?V/ܛG?V/O?V
.A(?V
)qB?UVd?U{
`?Ud
?Ut?U!?Uc?Uq?Ul?U_YP?U_
Jd?U=BJG?U=
JI?U^?UYUe?Tx?T,?TŒ?Ty
?TF?TA'?J	?Jſݵ?J^?J^?J<p}?J<
&#?J5W?J0
?IW?IRm[?IyW?ItCz+?IO?IxU?Im?IY ?IjR?Ij֘?IG.?IGN0v?I%?I%{4?I9k\k?I4!?HW??HR?e?Hu*X?HoԀ?H,c?HF?Hva?Hvi$?HSʰȊ?HSg2y?H0'zG?H0?H?H
{?G{?G2r?G5Z?G0c?GNH?GIh\?Gg[?Gb6?G_ȏM?G_z&?G<{H?G<@i?G-?Gxҋ?Fs7?F)
?Fۜ&?FSZ?F?2?FKn?FZ?F?Fk	j?Fkε?FH.7?FH)?F%Ba&c?F%=?FU%H?FOr)?EgaB?Eb?Eyk?EsQ?E??E2?Ev?Ev?ES:?ES?E0?E0A?E
ɒ?E
I?D ?D+A?DU?Di/?DrB?D)u?DWd?D?D_@?D_jh?D<x?D<=1E?D#1P?De?C.X:?C)J?C8͉%?C3ʍ?CBS.?C=6?CKE?CF_?CjTHo?CjN?CG\bd?CGWN?C$c0?C$^?Cj?CeJ?Bqy ?Bl0K?Bwq=k?Br( ?B|?Bw?Bu?Bu|~u?BR%?BR ?B/w?B/T?BJ?BV?Ad?A?AƒO?AƍS?A?A?A5?A_?A](f?A]߄?A:?A:rY?A*?ALG^?@?@[o?@ѓ+?@э{?@,#?@?@?@]|?@h,*?@hO?@E۠?@E?@"%?@"~*??<^??yW??zҽ??t??tYt??o??nm??h??sg[Z??sb??P`??PZȤ??-X>}??-RX??
O1??
JΘ?>G=?>A;1?>=?>8UK?>3@?>.gN?>~)9[?>~#W?>[=^?>[(?>8.?>8
q;?>?>e?=?=S?=	?=tf?=bzX?=D?=;?=-?=eq?=e*=?=BC?=BJ?=/F?=ȱi??;?;f?;Z?;ze?;zǨ8?;W/Ax?;W?;4^?;4<~?;sֽ?;ng?:[^K?:V\?:B^z?:=t?:(?:#?:?:	
?:a.?:a/?:>r?:>S?:h=?:!Ou?98?9?9Մb?9;?9gD?9aͭ?9I~h?9D7?9l+1?9l%?9I\,?9I+?9%?9%L?9?95z?8߬??8ߧj?8];?8wT?8jE?8d/?8vHD8?8vB4?8S%?8S t?80|?8/d?8T?8E?7=?7鵯+?7ƖP?7Ƒ
?7q$D?7k7?7Kỏ?7F)[?7]%5?7]Q?79t# ?79-~?7+j?7Y?6\?6?6ЇF?6Ё%?6^%~?6Xa%?64T&?6/{`?6g
?6g?6Cb:>?6C?6 jV?6 $dI?5q?5I^?5]f?5XD?51V?5,?5BJ8?55y?5p֧Y?5paK?5M;?5M@4f?5*y?5*t?5J7?5Ek=X?4?4??4?4{φ?4N?4h?4zdԭ?4z?4WV]^?4WQ?44#Υ]?44g?4U?4r?3?3J?3ʈ/#?3ʃo?3TD?3N5?3?3?3`P?3`
?3=
\?3=ķ?3|?/12?/,s0?/b?/bb?/?
?/??/`??/[`O?.J7A?.^?.-?.[?.l/?.'dt?.C2?.=?.ks?.k.{?.H,>?.H?.%g`z?.%bɻ?.?.{?-3?-!-?-Z?-?-:x?-5?-t/?-tJ?,?,?,}!?,}ÓA?,Zx:T?,ZrE?,7'?,7!Xp?,lWa?'>R?'?'?&V?&P?&'c?&"j@?&@?&_?&ZM8?&U	(?&iE?&i?&Ff?&F.?&#"N*8?&#
x?%A?%s?%OVN?%Jk1?%\1?%R>N?%z?%u|?%rґ+?%r
?%N(`?%NV?%+7A?%+2=?%?;?%s?$^k?$Xu?$@O?$`o?$?$|?$z*f?$z
*?$V?$V'?$33s?$3.?$Ým?$Z?#R(?#Mv6_?#N:4?#y?#o]0?#jv?#o?#?#^-?#^S?#;h?#;&W?#b?# J?"-+?"(w?"иq?"г/?"B4?"=a?"Nʻ?"E:?"fUqe?"fP/?"B
;?"Bf?"f".?"`?!ܯ?!oq?!t?!owp?!:?!`?!4O?!{9?!nK?!nf/?!J??!JQ?!'!s?!'
C?!5:?!? 3? ? B? ? O2? 
? u*? uҸ&? RS`? RE? .
? ."?  =0? "?眱?皥9??.?^?h,?}?}T?YTЪ?Y?6`2?6)?m??%??U?$?*?go?g}4?C$?CuAL? G2? B??Nr?
~?rI?kO?Qp?QkJ?-oh?-jH{?	S?	ğ#?#S?p?|?wj?;?Ђ?{.?{(Öz?W?W?3i?3׳%?3?.c?Ώ?섎?s?4d?4F?/SZ?.@? R?]B?]?:0!d?:+H?ݛ8?~L?cC?#x?(c0?##k?yc?t??ŕGw?dF?dT?@k3?@eX??Z?	|D?=?WI?R{h??s??t?j?-
?j:2?FG?Fo?"]?"ҥc?#%qp??m?h7?"?ؘ?? ?pJQ?pE?L\?Lb?(۫*?(ld?#Վ?זv?i?do?\%B??6?v?v;?v6I׎?RV?R{pd?.ĞN
?._7	?`ǜ?!E?KX?F]?ÎR?
,?
?
u?
6S?
8Wz?
3 ?
rz?
mvv?
c{?
cM]?
?3?
?ࠨv?
h?
m?VM?Q"
?Ԏx?ԉz3?yP?	m?3H?p?i2⵪?i-S)?Ehp?EcR?!A?!}?ap?#"?x?C[?:?4ި?m3RF?g?no?n;?J4?J̓=?'Ys?&L?4\?/
?
dr?
_Z?
?
ѻ?
Jj?
_6?
s<
?
sB?
P!@?
PkBs?
,O?
,JRs?
|*?
wv?	$?	䤖:?	-5?	?	0?	T?	y-U:?	y(e?	UX"Wn?	UR8?	1k?	1}-P?	
0E?	
u?p?3?.?NG?*G?* ?@V?7a?R?O?n?6?]?j?.?p9??hHѓ?h
=,?D$?D
 ? {? ??
M
O??	?_*4?c?(t??m{?ki7?k-E?Gv?Gh?#[	M?#?荟?RN?:NJ??d?)@!?
`?$ ?o+yT?oC4?KX?K?'?'?u!h?9~?ߟ!?ߚJ??֝0??޽N?s{?svb?Onn?OibnW?+a8?+[?S?M֐F?DQ??Je?5t?09?%?Vw?V}Iո?2m"!?2h?XO?SSY?B\v?=?,	?'P???}yר?}?^P?Y櫚?Yq($?5Z>?5 be??L%?.c~?$?ɂR?}.?g?b7?M;?Gڨ!?]1r?],vp?9|i?9u???׉'??ִċ?̾H?̹q?ԯ??l ?|2I?`b8?`\??6-8?󊝃Ǭ?Jh?fw?fq]&?BP d?BJ ?(R?#n
?{?s=@?-#??*$)?s?򍅢?hw?i[?iV^.?E1"?E+g?!?!?^H?$?خC"?ة
4?񴁥&?|l:?T?OJ|0?l&t?l!?G1?G|g?#	?#Ш?'?T?k']J?e!?:?5k?
7?b>?n;q?n?J8?Jz2?&t ?&o*?B,T?<"?K|?	??ɕ??O?Q?qqM?ql.?M<*9?M7_8?) ?)6=?aZ?(v>?i?H?bi?\䓯?*7ͤ?$$?sιJ?s?O?O
?+rݪ?+z:"z?E8?@G???~U?Z%?Zq?6\Lv|?6W?-ʂ?
`?ËԳ?TZ?vf)\?q.o?(?#?ړ?\?\14?\?80?>?e"e?`I?#-?K?ѧ?Ѣ?H4}?B??'x?d8T?d?@%?@ ?/y??as?\?m?x>?⮛j??⮖?7T?2n?eӜq?ef`?An³?Ai2?	dy?-?N?LO?=`?7?7:?y?n͉;?i*I?g?g?Bor?B9!?5z?0DA?a?}?b;?\Q?a]?X+B?,?X?h!ţ?h֝&?C
?C8?H~?CG?rA?<2?ml?h_@?߱f?߱?ߍAA?ߍ?i",m?it?D
T?D^S? BzBf? =DW5?D?̥?`?[ ?޲w?޲;?ގ|?ގw?j
Kc?jB?E!?E?!#v ?!@e?Hr??:C?5a?ݳd?ݳ.?ݏOH?ݏJy?jwM?jAE?Fb6?F]|?!L?!Lw?sd?nߊ?M?Mϭ?ܴT1?ܴ}?ܐ	}?ܐG?kj?k?GnFo?G8?"?"n?Xa6?#?٣^]?ٞU?۵':c?۵"N?ېh?ې2?l-O?l'z]?G@?Go?#0F?#+??­o?2lhx?-7I?ڵ]l2?ڵ(T\?ڑ1?ڑ,?lb?lX?H/rZ?H)n?#\?#?*fj?%1
?ڧE"A?ڢ3`?ٶ#?ٶl?ّz?ّE?m?m?ԒM=?ԒG.?mL?m^?I@?Ib?$w5?$晫??#?Wk?Rg	?Ӷ?Ӷe?Ӓ%I?Ӓ5?m?m??HX?HW#?$Um?$PO:? ?VT?J?vV?ҶbB'?Ҷ|.?ґT$?ґ l?mFů3?mA#?Hp?Hy?$
$/4?$z?k2?e޻?d!?1?Ѷ+>?Ѷ%ջ?ёU$?ё!?l	w?lj?HG;?HB?#ҽ?#???^?Y?еn?е/?Бr?Б\
?lqo?llf?GTP?G!,H?#&s5?#!@?N?z7?*??ϵ1)?ϵ, _?ϐ%?ϐ#?kj?k7E?G8|E?G3IP_?"
?"״?y??:?5o{?δC?δxj?Ώ2?Ώ,?k87?k3m?F0?F9s?!޼7?!ي4U?1;J?,	8C?؃8?~D^?ͳԵ?ͳςW?͏%1?͏ |T?jv'?jp?E9?E[?!B?!ab?d?_Tl?ײ6*?׭Ŷ?̳^?̲i?̎NV4U?̎I#?iC?iF?D箈.?D|#w? 3? .fW??y?v?ĶV?˲O|?˲3T?ˍ^4?ˍYC*?h=?heZ?Cy]?CGx?8`?32??{?Š?楋?ʱ?ʱ	?ʌURES?ʌP 2?g,_?g?BF?BUĨ?%`? .>?i%?dD?ԭ?Ԩ^?ɯ#?ɯ?ɋ3G?ɋ.?fv7p?fp\?Ai?A?4?0g?:Q?4,?zX?u&Ơ?Ȯ;?Ȯ,?ȉ/?ȉc?e7?e2?@u穣?@p1?`?N?l?e?-+s?'?ǭi>dJ?ǭdV?Lj[?Lj?c?cڬu}??k??:$V?Tv?OE:??3J?%?ןq?ƫr?ƫ\?Ƈ7(?Ƈ2_?bo`?biL?=?=?ܒ?aB\?aS?
`*?H
$?B?Ū}?Ūwgk?Ņ?ŅN2?`wb?`FH?<l?<X?K;?F?~U{h?y$u?ͰF?ͫ{?Ĩc?Ĩ܆?Ą?Ą
u\?_C?_=D?:rz?:mΗ?jF?9(F?Tlw?#Y?#??ç-?ç(t
v?Â[
?ÂU,?]?]C?8V:?8%͈?9Fp??Jp?k?6}?1M?¥`!>?¥[?€?€n_?[?[c&?6p?63?Ye?(?-58?(?TX?O_?{lU?v;?~Ƕ?~U?Yǡ!?Yp?4f?4ʩ!?d??6,X?0?Z7@?T?}\$?x+3?|2qy?|@?W‰	?WXߓ?2_?2.???&0?!Yq?Fޔ?A?뿟f2V?뿟a*?z?zK?U?Ued?0·?0?YM_?)a~?xMB?HhG?{?d?뾝62Gn?뾝1p=?xQ?xL?Sl?Sg?.}/?.M?	e$?	d?)w,?x?뽿>U?뽿?뽚ѧ?뽚?v⌾?u?Qsg?QCΌ?,3?,.SM?J?D?`?Zm?뼽u?뼽px&?뼘 f?뼘?s;?s ?ND@?N?)?)?1?Ԣ5?WV?(?뻺\h?뻺-?뻖)?뻖
j?q D?q?L1e?L,6}?'Ag?'<7?P:\?K?_?Z[?뺸nf?뺸i7G?뺓|dN?뺓w5_?n?n׋?I޼?I?$[R?$,Qp?WA?(F?ںӃl?ڵ?빵,?빵հ?빐I`?빐?kDI?kjr?F㾭?FޏR?!?!?1?T?*6?s?븳#?븲tgw?븎?븎m=?i<-?i?D?DeR??V7n?"|X$?M?&?!n?뷰*hR?뷰%ܚ?뷋.c ?뷋)5S?f1[?f,,?A3ob?A.i?5:?0ʸ?7C.?2ń?8<D?3
?붭8&O?붭3?불8i?불3~c?c8&N?c2?>7?>1cf?5O?0!Tw?3q?-鬹?0_4?+1?뵪-$?뵪'v?뵅)jT?뵅$;_?`%.?` ?; p?;B?3CX?4%?tBh?F:"?4(?
'r?봧sJ?봧E	?봂1Y?봁f	?\o6I?\AI?7,1f?7K?hυ?:?#??^ن?1?볣x?볣?~T?~&Q?Y
Ԣ?Y?4F?4g?z!P?*8?'Tn8?"'Q}??
y?믺?p?@?Kٛ?K	?&J?&+?y?t?^?Yͮ?뮷Ch?뮷>K?뮒'臒?뮒"3?m0?mr?GeI?G骛?"ѐ,?"cj?u??ؕ??ؐV"?뭳v?뭳qT?뭎Wwk?뭎RKO?i7X?i2?Do?DC_???QFu?$l?Գ_oy?Ԯ2a?묯횥?묯~?묊m?묊hr?eJTH?eE[?@&?@!h? }F??+o?r?зo|?в?뫫?뫫N?뫆kL4?뫆fc?aDV_i?a?* ?<'?<?+?jh?r?F?̣zΆ?̞N?몧z~?몧t?몂P??몂J*?]%?] gޠ?7?7o?#
??+??vp?q}?멣I?멣D?~D?~?XMCr?X!f?3?3'??0V?aga?\;B?1o:4?,Cx?먟Z?먞˻?y?y6?T?T^b?/l{?/gg?
:
?
4??'?;?맿ӱ?맿Ά]?맚r?맚?ukI2?uf6?P6U;?P1)?+?*??.?|O?Q'?릻]?릻X_Tt?릖&?릖 fX?p)?pb~?K?KV?&|˨}?&wd?C\[?>1?	o*?Dd?륶?륶?륑A?륑뽺?lX?lSS?G*?G܏?!Xi?!-V'?pO`?EB?f	?`ޯ?뤲(#&?뤲"c?뤌v?뤌?g+?gU?Bkx?BfM?+?&l?6]n?|?ҪW+?ҥ,V?룭h/?룭c0+?룈&?룈!P?bJV?b?=?>?=a?]z?XȘ??}Y??Zh?뢨?뢨NA?뢃Jc0?뢃EX?^xJg?]M?8{?8O#?v3?q ?/U4?*+?JJ?C?롣@?롣u?~UĜ?~P_?Y*(\?Y?3?39>?wl?rl?,?'c8???렞jL?렞.?yHu?yCJ?SmyT?SCK?.j?.?	_w,?	ZWh?[A?1)?럾V?럾,r?럙r?럙m'?t"F?th?NK.?N!2?)H7?)|M?/|?*?Ʈ|?؜Ɔ?랹FU`?랹td?랔8G?랔3?nɅH?nߟA?I>@?Ir3?$?iq?iG}?D6u?D1?g?ӝ?-?iY?-$?(w?뜮/dF?뜮?뜉z??뜉uj?dp?d$?>1?>ǖ?iw^T?dM?
X?c0?α$)?ΫY?뛩T?3?5=c?0?8B??nN?i[?뙞
Q?뙞	?x,0?xK:?SA)k3?S<?-ۧ=?-~f(?u@?p|o?#
?	v?똽#ld?똽?똘@%|?똘;{i?rؤZ+?r{?Mp&a?Mj?.k>?	tB;?	ox?s[?L8?뒾~'?뒾xp+?뒙\N?뒘4?s?s?N	N,?N&t?(	96?(ᱦ?G$K?	?ݐsj?݊?둸Hz?둸!?둒0?둒?mQ?m
*k>?G}?G 9?"b?";|?d??7F?	?됱~?됱=?됌-?됌?f3B?fv?A>?@R?}hs?xANy?>?h?s6_?n?돪_
?돪7?독g	?독a-?_3_?_?:X?:SӀ?
? ?Hc?Cvs?ɿT8?ɺm?뎤6\?뎤1u?~u?~:?Y"I?Y[x?3l?37;?m?F^?耤(?{~A?_D?8?덝g$D?덝bsv'?wV?w/u?RLd?RGmQ?,TZ?,.'M?/*?*n8"?W?1i?댼d?댼v?댖cU?댖{<?p﫥?p/*?K^uy>?KYO
T?%jT?%ǚp?:W?5g?ڧ||?ڢ"?답R?답?닏?닏{ڴ?ib?i篨?DX+~?DS?z
?CU?-a?(:?ӗ=?Ӓ!?늮w?늭w?늈i~,?늈dXd?b[V?b̻G?=9d?=4?.~?}??z?n+?i_?뉦sh?뉦N?뉁9?뉁4D?[T?[-?6N?5(N?gFl?b ?.?śa?-p?(/?눟>O?눟?y@x?y?TS?TNg?.ʴ?. ?	V?	1	?L?'MJ?'H'j?6?oR_?%r?ۺ?놶b?놶]>+?놐_ҩ?놐:u?kQP?k+?Esw?En?ͺ
?ȕfp?'1Kd?"
?Ԁ)?{b?녮ؤu?녮CU?녉05 ?녉+{	?c?cy?=2?=?5
?0x?򋡳u?|*?&M??넧6,?넧1Ŋ?넁6?넁?[?[ٛ?62M7?6-(K?[?7?V)?x*?);?$ٲH?냟{xt?냟vn?y̫1?ydžh%?TD?T K?.m`{?.h;Z?&c>?&>E?ܑ?lC?(AS\?#?끵st?끵nP}?끏*O?끏c?jc"?j>j?DR0?DL>?[?7?bv?j?,^Ǧ?':}?뀭t$}(?뀭o:7?뀇l?뀇Hl?b8|?a}??~+E?y>?ys>r?ynGW?yYR?yiI?yr|?yrY?yM?yLs?y'11?xD9xl?xi?xdD1?wt?w_?wҾJ?wҹ?wtK?wQ?wC?w?wa:q?wa5O?w;b
?w;]O(?w}Z?wZ?vR?vﬤ?vؖ?vsZ?v!?vľ|?v~$d?v~	?vXJa?vXD
M?v2n%?v2ip?vM_?v+?u/?u
?uږ~?usa?u'
?u\?uu5?uuʛ@?uOAݒ?uO?oo&?oN	f?oۤ?oփx?o]R?oW?nYN?nYI)?n3X?n3S??n
bT?n
]?ml5?mgGS?mu+?moq?m}?mx_H?muj?muJ1?mOݯ?mO9?m)˲,?m)7?mB?m""?lݠw?k;n?k;.N?kW?k?jqd?jQ2!?jv?jɻVw|?j?jވ\?j}	?j}q?jW;T?jWx%S?j1gy?j1X?j>+?j`?iU<3?i5;?i?iϒi?i
j?i?is[?is?iM%?iM?i'z?i'Z>?iP?iG?hۇS
n?hۂ3>?ht?hzd8?hw9ʚ?hr	?hinqW?hiiQ?hCe-b?hC`
M?h[mk?hVMi?gQ0?gLb?gFvF?gAV?g;@S?g6 ?g/:?g*n?g_#_#?g_??g9?g9*?g	jN?gl?fo?f?a%Y#?a?akq?akSV?aEA)?aE#I?am?ahu?`Lkh?`GM$?`*]?`%q?`%%?`?`?`湵?``go?``.U?`:Rj?`:4dr?`{>?`v ?_V?_Q2?_1?_,Z?_?_	?_{j?_{?_Udw?_Uv]H?_/P?_/yC?_	q?_	l?^I)r?^D?^ H|?^]?^la?^?^pb!?^pE?^J~'3?^J`Q?^$zI?^$t{u?]O?&?]J"&,?]#v?]B?]H?]ݓ?]C|?]Ƥ?]e?]eH?]?q?]?l]?]CcJ?]>"?\?\?\o?\?\@?\W?\?\;?\ZWu?\ZR-?\4'-Ԥ?\4"cQ?\
?\
b?[hj?[K?[KD?[.|]?[_v?[Z"?[u,?[u'>?[N?[N?[(?[(e?[O?[g?Z[5?ZVe(?Z&?Z j?Z?ZK?Zi{?Zi?ZCG?ZC}3D?ZKIO?ZF+?Ye)?YH#q?Y?Y?Y,6?Y>?YhT?Ycd
?Y^/]?Y^)?Y7?Y73?YO?Ys?X~E?Xyp?XB'
?X=Z?X?X?Xxn?Xx	?XR_?XRȨ?X,O(f?X,JL?Xc?Xt?Wy?W[?W=?W?WS
?WM?Wmo?Wm
?WF!?WF]?W '??W ƨ?VO2-?VJ?V
X?Vw?V^?VA?V:?V?VaC|?Va>|?V:~+?V:aA?V8?V:?UuC?Up}?U0E ?U+)$?U:?U?U{-?U{?UU\v@?UUWM?U/7?U/i?U>&?U"?Tʠ5?T*?T;ڹ?T6?Tp&?TT!?To?Ton?TI^(?TIY?T#K6?T#/?S?S?S|?Sw?S/Юx?S*Ա?S?SP?Sc)?Sc^/?S=Hv?S=B*?S!?S?R?R6?R[?RVY%?R08?R^?R}?R}Z?RWke?RWfI4?R1GP?R1,P'?R
ȯs?R
Ó?Qvw?QqG?Q$jB?Q?Q?QU?Qq}~5?Qqxb?QK)X?QK$d0,?Q$?Q$J?P||?Pz#?P*r?P%?PԷ3}?Pϛ?P~RO?Py7?Pe's?t?Pe"XI?P>,o?P>n?PxD#?Ps(?O?Oa?O,?Ỏ?Om"?Oh͈?O*A?O?OX?OXէ?O2_<?O2Z!>?OG?O?NgF?NL?NLE?NG*U?N?Nx?NrR@?Nr7a?NL4c?NL/y?N%\
?N%Ao?Mw??Mru?My?M^?MN`?MH?MX?MS?Me?Me?M??M?y&?M5Ql?M07X?L>U?L#?Lp?Lkt?L
T?L?L!?L&?LYF #?LYAh?L2ᥫf?L2܋8?L|\?Lw74?K>?Jd?JI=?JpK`?Jk'?Jfa4?JfF?J?"?J??J0r?J+X,?I(?I {?IX0?IS/?I?IڨX?I~?Iy&x?IY;?IY!?I2&(?I2r?I4O7?I/}r?Hō:?Hse?HV	#?HP?H?H&?Hru?HrpxK?HLyk?HK?H%0?H%I?G!H?G.?Gخ
?Gة?G<	ĩ?G6(?GȲ-t?GØ?GeT,?GeOǟ?G>}?G>{?Gkλ?Gfѵ?>k?>n2?>i$?>?>?>Np?>I?>^?>^;?>8,p?>8'ߚ9?>]?>F+?=	J"?=2C?=v[?=q?=)?=ޠp[?=wP8$?=wK q?=P>}?=P&ҧ?=*'?=*"/ ?=?=s?r?<' }?j?9>e+?9eq?9N?8'sP>?8"\v?8ʅ5?8	?8 ?8	Ɗ?8}>}f?8}9Z?8VL?8Vy?8/H%?8/{?8	Q@?8	L?7{?7ec?7?7?7`}D?7[g?7nQ?7nD?7H~?7H
%>?7!j
X?7!e؊S?6=?6;?6.?6f?6qCV?6l?6LjB?6q&?6`}v?6`g?69r?69m?6b?67?5h^?5q,?5p?5k	?5.?5?5xJr?5x4?5Qi ?5Qdت?5*H?5*?2Kv)p?2$=?2$ܩ?1-0?1r?1Sc?1N4?1"?1
M4?1+?1ܴ?1c'C?1c"$?1?(s?(sz?(L6_]?(L10?%.?$St?$MWG?$q͏?$lx?$s?$?$
?$?$Y6k@?$Y#k?$2?$2?$t?$a?# _?#L?#;?#67\?#V?#Q-?#pqH(?#pl5Í?#IP?#I=G3?#"iJ?#"̣:?"?"(?"֒V?"?"S?"餣R?"dY?"Q?"`?"`?"94T?"9/A~1?"JX?"Eŏ?!`a?![Oi	?!u?!pR(?!?!{c?!vI*?!v ?!Oج?!O=?!(I@?!(7A?!BJ?!/? ? D? ʭ? \? Zb? 
H=? f r6? f_? ?1? ?+*? A9G6? <'?P/6?K?`!?[?nA"?i"n?|}(`?|xI?U͙?Uu?.Oq?.=h?/L?Ÿ?౗&?ଅ?C?uP?=M?Q?kg?k?Dtz?Db?]KG?Kuf???
!?E?C9?1y?H?7-?[B?[
Ñp?4G?4?
 ?
q?&?!z)?,O?8?'=?1w?,m?q67p?q1%?J:wq?J5e?#>>?#9,?A"?l@)?9[6_?:$?5?6u-?1d2?e1?e,?>,?>'?&ݼ?!k? -?O?W(4?FQz?P$
??T?{?{l?T?S@?,ii?,X?&?qt|?"ָ?+?K?:	???i5?i%X?BOp?B?AI?16??
?͚nO?͕]u?P?@qV??z??XqI?A?>X?.ك?uRt?uU?Ng
V?NW?'zH?'u8%?[?V]o????E?m?
P?
y?
mU?
hF?
Dx?
?iݞ?
|$U?
|
t?
TY-?
TJ{+?
-H?
-?
]u?
N?q-?le_?EiZ?@v?fJp?W~?i?i1?B͞?BNR?@?1?dE?_6B?5Ӗ?0-0?빹?W?~׋a?~}?W=?WE?0wh-?0rZj(?	F[?	A?
ibt?
[%?
ҝ?
ޕ?
TU?
F'4?
l~W?
ly~0P?
EKM,[?
EF?N?
)?
?	f?	Xm?	Ϯ?	ϩ?	y?	tH?	DRR?	>V?	Z
?	Zw?	2vv?	2h?	y?	l^?i?c?1	?,
2B?k?t?n+?n?G?Gw? L1>? Gw?y?
k?׿F?ұA?5V??`,?[?\$ū?\?4/%0?4!?
!!?
?m??h?/m?*?)?U?p>t?p1H?Ir?Im΍d?"3c?"-	x?Ӣ??ӱmf?Ӭ"?p@?k6?.-?),?]Ǵ?]~?6#/?6)?g?af?#v?i?m?`m?$?{?rU.?rP%~?KK?K~I?#ʦ?#ř?K?>?=z-$?8mA1?2F?%bL?s?f?ބ?Sm?Nh?6??t??t?M`,?M[ P	?&?&		??{?h?cvk?
P???:?A\?5?b6{?b1$?:ӝ?:M?tkK?o`s?x?
?İ7?ī,[?Ml4?HaUr?u*߂?u?Ns?Ng?'"Dľ?'9?{?.?X6?Sz(??)?\?'?b&q?b!f0?:
?:tG?X
?S	?5Ó?*?ć%?Ăջ??
?uӯ?u+?NL{	?NG?&?&1?wL\r?rA?3%?(???4?/gt?a&'?a?:[6}C?:V+?r?1??z?BP?85?S?Io{?u2?u-7?M?M?&Re?&MTR?5?,?p|?k.E?2?e>?ˉ*?I?a%٩?au?9
[G?9*s?3x@?.n2?ot?esa?JeQ?EJ?(R??t`}?t[q?Lp?LlZ?%tU
?%oK??{$?ֆ@-?ց6?I??	z?R?H?`?`֕?8i?8}?*J?%D?@??6l?1b?uO#?k?s@h?s:c?K%?K?$G?$BK?0?Q?M;)?H?ee?J?Qkm?L?^#?^?7T?7Nf)?s,?i?TjG?O`~?0?Ec?R?MZ?qэ\?q̄XT?JO"?JJ?"XQ?"O]?J?EV1?Lqn?CB?CQ?>*?j`?aAF?]:D?]5?5}{?5l?0%]?+T4?#H? ?#??x?"?p[=?pR@?H}?Hz7?!6?!.?|t$?wkO,?=P?4?i_?d?nG?9?=z?h?%Z? R)n?았O6?앓G?n
K?n6h?F|?FwΈA?iZ6?`?_5?Z}@?,,C?#?@[?;S?뀰?뀫
'?YZ?YQ?1'K?1?	)?	wc?ja?eYS?}h?B?Dd??C?kCw3?k;Kx?DM?DE|5?b?E?]?H?^?Yn?ݿ0?ոu?~2=?~-=?Vⵣ?Vڽ?/o?.?mu'?h	?g8??u?>p?Խ~?ϵ?3?.?ǒ?ǍR?լ?y?xN?xIS?P
?Pӈ?)	JI?)P?exN?`qv?vv?ټoP??i?x?sb?bҳE?bͬ	[?;,3?;'0???k??8iu?3|2?㜐?㜋C?t٤?tŪ?M@3?M;,
?%?%&b?e?^R?CL?>F6?⮘,?⮓r?ä??_BB^,?_=;?7S@?7M;#??p?=?87?œ?,?*?`?q3
E?q.??I?IE?!9?!S?&S?!L?vBSH?q;?żE?.W?p?"?[cP47?[^I ?3j?3dXZ?E?		?L??G8?߼?߼v?ߔ>9?ߔ8?m14?m,?E|gx?EwaV?L ?Fj???[Ն?Vթ?ަ??ަ9N?~PT?~JQ?W6u?W1I?/_?/z=5??X?\??ݸT͌?ݸO!?ݐ!?ݐX^?h?h?A&i[?A!c)?k^p?fYIC?P?٩Z?qB??ܢ7W?
$?դ9	T?|l(?|g?TT?T?,]X?,*m?8?3?!2??ԵN"?ԵIލ?ԍyX@?ԍtC?e?e?=(z?=";?Q?M1?$>?
?:G?M.f?H>?Ӟv ?Ӟq8w?vJ!?vF@?Nef?Nb?&?&	?>f?;%?<?70?үcI?ү^EX?҇Z?҇i?_Y?_}?7ojL?7k?Z?弙?`?t???:~M?јbM?ј](?pI?pF?HQ?H|{? B? >?
?匈A?j
?fO?Щ+D?Щ&?ЁKb?ЁF?YkCqR?Yf@%Z?1N0?1Jέ?	(e?	V?	&?`?ϹD?Ϲ߶?ϒ?ϑf?j?j?B:H?B5?V*?QY?qG?l>?ʌH?ʇ?΢N?΢	^?zk{?zy?Ri?Rf?*i?*fY?xp?V?$"?N?ͳ;]j?ͳ6}h?t%^?s&?\4AY?\3ž?4߀N?4ڀ1?Z9h?Yɧ??-???2?2E?l>zo?Dֳh?Di?y?tZ?i,/?d?X0?SY?꿤G̞?꿤BD?|6?|1f?T#6?T?,d?,d?b,?a?>?Y?꾳?꾳?꾋¨[?꾋c?c}(?cٌ?;?;?㒅?}?l2?gX?V"?Q"A+?꽛?lu?꽛:?s'\?s"?K(?K
3?":o?":?aF?aP?f?z?꼪VW?꼪W+_?꼂%Ŝ?꼂&/#?ZvV?Zq]?2[j|?2Vk ?
?
;?
:@?#e??껺ur?껺vw?껑Z?껑	?i,??i-RC?AA?AB^4?̧?y?rd?mu?Rʌ?MH?꺡3?꺡.}?y?y
?PC2?PDc?(/)?(0/?+?
H?؍Z?؈C?깰k?)W?깰f@?깈H]I?깈C^A?`%\?` 	\?8?1?7@=??¨?V?W$?긿3K?긿4i(?긗m9?긗hAJ?oGN?oB{_?G!X
?G?*?+*??0?ΪA?Υ4?귦S ?귦}t?H=(?H8{?p@3?s
??z?i"?>?>+?9/?	Y??œv?Ŏz?꧝=r ?꧝8v?t?tU?Lγ?L/_?$8?$3??ۙg?ӈ37?Ӄ7h?ꦫ/^y?ꦫ*b?ꦂ4?ꦂw?Z|]?Zwa?2"0ш?25g?	ǒ3Q?	–V?lf{?g?ꥹ?ꥹ-?ꥐ?ꥐ?hX?hS????ۓ?y?~P?@_?;5?A?ݎ?ꤞP?ꤞ~>?v$Yt?vA?MI?%`U?Ď?î?ԤI?ԟP?꣬B?꣬=?ꣃ֢?ꣃg?[~>?[y?3՞?3!|?
?
	??Uz)?P]?ꢹ~?ꢹ?ꢑ2?ꢑJD?i(1zV?i#6?@߹@?@m?]7t?X!/?he?ɮ?ǐ@?NjE?ꡟ)'?ꡟ$-
?v.?vc?NYH?NTo?%5'>?%:K?V?\??'"?꠬C?꠬I??ꠄK+?ꠄFp?[k?H?[p?3uT˰?3pZ?	̼E?x5?ҳp?v?ꟺ1g?ꟺ,mX ?ꟑĊ?ꟑ+?iW=BI?iRCt?@}b?@Df?{Mb?vSKK?F??ǝ?ǘ:?ꞟ.t?ꞟ)t?v?v$e?NMJ?NHY?%>?%U?k$?fB?D?-?ꝬY?Ꝭ?Ꝅ?Ꝅ"?[6~?[
r?3.wUd?3)}g?
d)?
jӼ?E?@9?ꜹ{?ꜹ֧?꜑[R?꜑V?h妤{?hO?@oZ?@ja'?J?9??lf?|r/?	ɳ?;?ꛞ?ꛞF?v/v?v6
S?M8iy?M?B?%&.?%!?8z?e?2?-G}?ꚫE?ꚫ?ꚃ<^?ꚃ7#?ZPH?Zz?2E?2@?	?	Æ?K?FЂ?ꙸ ?ꙸ'>?ꙐPF\?ꙐKM}f?g]?gWn??S>??NE???Tp[?OwlB?_?g?ꘝSݣ?ꘝN?tی?t?LQ?LL(?#Ϯzw?#ʵ?Mg;?Ho?ʮ?Ŷ=Q?ꗪGP?ꗪB?ꗁ	?ꗁ^E?Y?f?Y:\s?0`nY?0g?6qƔ?1y1?߱?߬?ꖷ+@?ꖷ&Hs@?ꖎP?ꖎҝ?fLU?fSM?=({%?=0;?3?
;?쇎Q?삕?^?/?ꕛv1*t?ꕛq8?r*?r?Jc#?J^E?!ֈ?!N?N+?I3a?Ph?о%?ꔨ7i$?ꔨ2F??4?Wb?W N?.9?.A|??&?w+D?r3F?ꓴ?ꓴx?꓌ZZ?꓌Ub?cH?cP˚?;;]y?;6~? ?:?>r?F?G?P	?꒘jA?꒘穱?pg?pb
?GԺ?G3?A?=C?N?׬S?0E?8?ꑥ#?ꑥ(#?|B?|?T]ƌ?TXB?+D?+Mgg?2n?-w0i?ڜ',?ڗ0x?ꐲo?ꐲxyZ?ꐉnF?ꐉiO>?`֬?`ѵ@?8>`]?89?$?-d[?
7M?@?ꏾsײ?ꏾnz?ꏕ?ꏕA?m?ʠ?m:ϡ?D{?DC?	J?1?n^0?ig?YP?bF?ꎢ5M\?ꎢ0J?yI?y?P@?P?(]4?(X.!?,?He? Q?u?ꍮc?ꍮ|B?ꍅW?ꍅ`6?]B[p?]=dp?4?4[ ?rR?h?_?ZnG?ꌺ&,?ꌺ~t?ꌒj?ꌒ^J?iy:IX?itC?@*?@4?2p?-q?ݥ?[?Y?c|?ꋞE:?ꋞ@?uGd?uQt?Lō?Lb6?$Tt'6?$O}x?ጬ?8?7j??ꊪ_lb?ꊪZv?ꊁ?ꊁDB?Y66x?Y
@?0fr?0a|Ů??\?I6F?K?1%b?qE?|n	?3W?.b?ꂷudB?ꂷpٛ?ꂎ?ꂎ:?eka?ev?=:b?=5?{H,$?vS?뻎?붚?eD?pu?ꁚ:\?ꁚ5ɫ?qyH?qtνP?HJM?HU?a?ma?4
"?/l?qA+?lL?ꀥ
4?ꀥ*?|bV?|m=?T&J>?T!Vz?+aí?+\_"?`C?G?f?r}?kR?3?KK?FW?_FR?_?6rp?6~Α?
?
?~-?~([?~eX7?~`d-?~T&?~`$?~j?~j!?~BGC?~BT$?~>[?~9p?}sߐH?}ni?}Ǩ?}ǣ?}?}d?}v?}v
?}MDeM?}M?q'?}$wn?}$rz:?|7?|?|0?|p?yf(?yyyk?yy6?yPB?yP?y'q?y'+?x?x?x4-?x/>*?xZҥ?xU߽?x/?x|?hߛ}?h:Ĉ?hJs?h]z?h]ԋ?h4M9Z?h4]e?h̯v4?hǿ!?gŢ'?g>*Mo?g?g!?f<?fL"?fÈ'K?fÃ7?f}S?fx̎?fqr?fqm%O?fHgN}1?fHb_?f[|g?fVyd?eO=?eJNUt?eB?e==?e5s6?e0?9?e{'?e{"a?eR?eR}b?e)x?e)7?d?d?dhۇ?dy?dݴn?dC?d͑8?dȢ?d[%?d[	x?d2*?d2?d	|?d	B?c?cǸR?cvk, ?cq|/B?cc8Z?c^C)?ceP"?ceK̟?c<t0?_9%/?_ ?_G?_K?_\?_a@?_aRbj?_8J?_8?_=T?_E?^戉?^惛?^h?^c?^H+d?^C$e?^k'b-?^k#b?^BX5?^B`?^_}i?^q|?]q?]ﾃ³?]ơ?]Ɯ'
?]~I?]y[?]t[b?]tV"?]K7h?]K2zj?]"R:?]"dq?\e?\M?\?\k?\y?\?\}~9?\}y?\TXk;?\TS~?\+1}?\+,H?\
?\.?[?[.m?[$ ?[7D?[2G?[ѽl?[]i\?[]dH3?[4@,?[4;T?[?[
V?ZEp?Z^?ZR?Zd«?ZXV?Zk?Zfk?Zfg?Z=@t?Z=;.=?Z1>?Z?Y&&?Y8?Y/#?Y?Yy?Yq?Yo^~Q?YoYŅ?YF0T?YF+)K?Y?C?YRBg?Xy?X
]?XʢHd?Xʝ[r?Xr'?Xm:?XxA#?Xx?UiP?U@5?U@Hf?U≔?UݝS?TpZ7?T!?Tmw?ThFu?T2?T.B?Tq|?Tq|?TH&?THV?T{*?Tzt?SBM?S=B?Sk?Sh?S%P?S9?Sz.
?SzB&P?SQK
?SQF	?S(?S(s?Rͱ?R?RՎ?RՉ9?RM:J?RHm?R
X?Rm#Q?RY^Z?RYs/?R0?R0f?RI"3?RD7?Q
?QGn?Q/	?QCj?Q~?Q|%|P?Qb=?Qb8?Q8Iz?Q8?Q$?Q9??PpP|&?Pke?P+?P&#N?P_T?Pt(p?PjB4$?PjV?PAX{?PAS"?Pq?P?OYT?OnqN?Ołc
?O} ?O:F?O5[g?OrF?Or쭻g?OI}Q?OI&?O ^?O Z	?NJ?N/=?Nʛž?NŰ?Ny?Nzm?N{4H?N{/DL?NQ6]?NQ9?N(˱x?N(Z?MPE:?MKZ?MS?Mh;?M?M
?Mh(?Mc==K?MZ?MZF?M0H?M0]M?M|4;?MwI|?L,vk?L'ȿ?L5?Lۆ%?LkTW?Ls?Lb;:?Lb6k?L8pd?L8?Lֵ?LE?KF?KAv?KGNd?K\?K_
?Kt?KjM?KjIf-?K@C?K@/?K	?K(?JQd)?JL$	?J]	?J
 ?JKώ?Ja_?JrPEr?JrK[?JHӟ?JHc?Jn?Jn?IK?IFɢ?I?IZ?I#I?Iy?IzC)Q[?Iz>??G79+>?G
?G
.?FE?Fzë?FB?F>?F?F?Fh^ޡ
?FhY?F>l?F>l?F2?FI}"?E::B?E5QYO?E?Et?EuAB?Ep?EpZ?EpS?EFo?EF,#?EI:?EE?Dv
?D9?Dʀ?D{?D#?D9?DwWS?Dwn.?DNOF?DNJ4?D$w?D$㎼B?Cf?C|}?C>\?C8?C?C]?CIM?CDW?CUD?CU%?C,w?C,ré?CXy?C	&x?B٤&?Bٟ@?B9w\?B44?BΪ?BHY?B]cZh?B]^qɽ?B3?B3?B
v}?B
f?Aݰ?A4@?Aߪ?A	+?ADr&?A?+?Ad֗?Adѯb?A;hQ?A;ci`8?A:?A?@Q>?@há?@M?@ڍ?@?@4?@l:^?@l5?@BA?@B,%H?@W`I?@R??,??%??s??n=V?? ??$??s}??s`A??Js??Jg>?? ?? ?>2+(O?>-C
S?>ͽc5?>͸{?>H/?>CGE?>zҍ?>zͥ^?>Q\?>QW?>',$?>'4?=od?=j5?=xG?=ᐍ?=	w=?={!C?=r?=!:?=XAљ?=XZ!?=/;`?=/T	?=tb?=l?<"%?<l?O?;9?;,x?;?;D?;??;fل?;f
f?;=H
e?;=C?;N?;gT?:KYR?:Fq?:z?:?:L)E$?:GA?:m?:m?:DKH1n?:DF`T?:5j?:N5u?9Hg?9C9?9?9>?9Dt7Z?9?J?9t?9tlB?9K>T?9K9F`?9!f?9!?866?811?8βkU?8έ?8-?8(@?8{@m?8{Y?8R"ˆ?8R?8(f\?8(^?7׍?7?7Վ?7Չ9?7uC?7>Y?7U?7z?7Xe?7X~\?7/nl?7/ir?7A9?7ཟ]?6\"?6W;p?6%K?6>?6Gy?6B"?6_o?6_ᚤ?661vyg?66,`?6/Y?6Ѽ?5A?5?5?55?5?5<?5fr|?5fm(?5<䥉?5<߿?/
?/uT?/poGT?/cG(?/ca9?/::b?/:5隞?/?/?.?.?._1?.Zt?.&?.?.j!&Sn?.jAM?.@)?.@|D?.?.?-?L?-;]?-Þ1V?-ÙJ?-L?-0Y?-pZ(p?-pVQE?-FgN?-F~?-z&k?-^?,r![?,m?(dޱ?(;7M?(;24^?(`?(?'ր?'ѝ#?'%?' ?'t<$?'oXDb?'jx2?'j{?'AI?'Aeխ?']ؘ?'X18?&?&_B?&8d?&T?&C[?&>xY?&p?&p0sp?&Fa?&F~Mv?&%C?& _Q?%oμ?%j]?%ɹ?%ɴ?%f?%.m?%vL?%vG'?%Lf
?%L?%"ĨC?%"^u?$%?$ կ?$mB)r?$h^>?$_/?${N?${?${.b?$RAZ=?$R?!h?!$?!o?!b;?!b忥i?!9(c?!9#?!fb?!aH? ‡? -C? I? %	-? lq? >h? з? B???F?N1?N{]?$jLN?$?Þj??A?φ?M4,?HRRX?}L?}zk{?SBP?S?)=g?)[k?w?3?C@?> ?s?n??;	?XIOX?Xg?/`?.*"?/c?*Q?]PL?XoEt?%?ϩ?G?	o?]䘯?]߷i?4.2?4?
<B?
7σ?h#A?cB?&?Eß?x?߱/?b?b?9?9ӵO?;?6..?cm,?_m-?7????i?gSv?grl?>?=L?*xf?%?P	?L
8?vs?r7?*?,?l?l=?BeA?Bᄐ?
?ݛ?.|?)d?Q?MWc?tc?pN?q?q=?G?G5?jr?։??T?#?ɸ?>*U?9Ie?v^??*?vY^?L}L+?LyV?")?"Ib??>?h?Ո[e?i??{4?{ ?Q3)
?Q.H?'OH)?'K	+#?l>0?g^?ӈ)A?ӃI?i?c?@?CD?Ul?UԌ%?+?+?
??&?"s??A?;jz?Xp?S0?Zp?Zk'?0|;n?0|g?ԙ~?M?ܶ?ܱ6p?G?g?ao?ށ?^#?^2E?5X?5	x?#4.?U"?7?2?K?F15?_K?ZleE?cr?cm@?9J.?9j?U?ʋ.?婟??,~?M5e?N?op^?gn?g'ǣ?=Uv?=vD?9>?Z ?p?u*?Ÿ??*la?%N?l8$?l3'?BF~H?BAE?Ss?O	w?
`B?
\		?
m?
h]?
y?
t7/?
pn?
p?
FȌb?
F鸈?
p?
٤~?0VC?Q?Ȱ0,?ȫQ`??A9?te?t?	-#h?	-=?	#?	+?#{?{?#@A?bI?"x??[!F?[h^?1!?1A?f?ƭ?5֤?X?\?~??<*b?_m?_0?5
Wq=?;#)?n??{v4?v/?SA?N:D?*L>?%qI?i?h>?>!?>Ҥ? :?~?3/?C?i??6*?wkty?wf?M5p!/?M0(p?"1?")V?-A
?SX?ΐ?Όu?YG?Tm?z!7S?z]?O?Ow?%?%D]?v?qk?<▼?8?f??|E5?|lI?RZ?RI?(RB?(M-?J?pm?%g?L(?𩝘v?𩘿q?`>?[m?U#F0?Ul?*
?*১?R ?y5E?h?c?)V?$F?V^i?}??W?W?-jQf^?-ex3?)l?$A[?D?³?:z?a_?ebq3?`]o?Z#"~?ZI?/z?/ۡ?k+?/?Y?U?("?;;?̚??\W?\6?2G[6?2C?>;?en?ݼ8?ݷ_?u?p*?.'?*N6?^A?^.7?4?44?
W?
S#b??
+U?Ơ? ?}U?x}#?a3?a.(\?6?6hg??*N7?TH?O=?P?0U?ꍽq?ꍸ+?cpC?cl?9$P2?9x?Y?ҁ8?0?"?<4h?7\:?d?+?elL?eɔ?;Pl?;KD?uO?,fi?4V?ۨhw!?~(~B?~#@?SW5?S?)E$'?)@??R?aw?\?ک$?ک?{'?v?Uw?U!)G?*?*'T?{?>?ժ ?զ6?٫5_?٫01?ـF?ـ<=?VJK?VE@l1?+Ӳ-?8?جn|?جiJ~?؁ w?؁K?W}?Wx?-?-n??i?J?
t?׭?׭"?׃4)?׃_g?XG
?XrO?.&?."\?4Az?_?/??*;?֮?֮?ք5?ք0?Y5?Ya'?/:s?/5?I?uJ?=)?8䲛?կy?կ
6?Յ?`?Յ:{?Zo?Z?0?l?0:{??w?=ٽ?9v3?԰u(?԰Or?Ԇ:z?Ԇ5ո?[w?[{?15	?11	=??#?/u/?*?ӱk?ӱ[?Ӈ'pn?Ӈ"f?\Ӣ4?\?23?2?c*???
/?ҲYGp?Ҳg?҈?҈?]~?]ys?2E#?2q?oql3?j?6?b`?ѳ^?ѳYH?шՋ9?шз?^LZ?^GH?3E?3qD?	84&?	34V?ޭe?ިz?д"Zn?д?ЉS?Љ#?_E:?_=9?4~ҵV?4yLJ?	-?	ZK|?e!?`Nz?ϴׯ?ϴC?ϊIXG?ϊE
?_>?_?5,k?5(1?
?
[?s?	_?ε~N?εy-X?Ί[!i?Ί?`]֤?`X?5̩s?5֭?;6?6cc?]?ऊ?Ͷk?ͶK?͋ke?͋|1?`D"?`q.[?6]?6X
?ɾ?ճ?5b'+?0]E?̶J?̶ˈ?̌s{/?̌5?au!?aqo?6'?6}v?IUr?D[?t?ڑ?˷@?˷?ˌ+:?ˌ.?aT?a3u?7S?7N9w?ۑ`?	?!?٬a?ʷ?ʷCq?ʌ?ʌFX?bS?bN]'?7ꮆ?7d?
By?
?"4j?}O?ɷ#?ɷQ{?ɍI&?ɍD쬄?bY?b!7U?8/?8
|?
r(?
mV:?*5?X
r?ȸ5M?ȸ0?ȍb ?ȍ%gL?b{j?b?8X,
?8SZ#?
,6?
ZJ?Ab?fn?Ǹv?Ǹr)?Ǎ%?ǍZ?c4/%?c/^9?80u?8^c?
@?
?M@?H.?Ƹ?ƸhW?Ǝ5j?Ǝc?cb7?c]e?8?8Zk?	?7?s؜a?o!?ŸA?Ÿpq?Ŏ(EW?Ŏ#s%?c?c}?8s?8Hd
?3?/s?VV?㇅?ĸ[j,?ĸߊ&?Ď;)?Ď7)|?c4?cbS?8?85
?@u?;?}?㑫?ø%x?øM?ÎAZ=?Îk?9w?D=?sQ?¸g?¸.?Ž8%1?Ž3T$h?c{?c'?8k?8כ?-?)%7??zI('??B? -v?\,?cp*?ckM0?8=?8֡?WX?	`?]?X?&??Ϭi?0c?cGZh?cB)^?8~:?8w+?
WF?iX?dt?؏ګ7?؋
N?鯭V ?鯭?鯂?鯂/?W?W)un?-$P?-H?HK?CK?l5s?g	*?鮬?鮬?鮁b?鮁!F?VՋ%?Vо~?+?+x?x|?tD?;Z?69&?魫\C?魫WD?魀|
?魀w?Um~?UU?*'?*K{?????鬪su?鬪?7y?2f?TUeu?TP?)r??)m*5?_??ӬW?ӧ ?髨Ȉ?髨üa?}T?}߈)?R?R?(dC?(T?5Z)?0@?OM?JFi?骧id?骧d?|?|~?Q?Q,?&}?&<?̼#?J?䕜?`?驥	?驥=?{d?{M?P)Ĵ?P$3?%@
?%;=?U굽?Q?kf?fp?騤}?騤{O?y/?ycO?N}Q?N?#f0?#D??[?
?>]?駢Ę:?駢?x	.?xNͿ?M?M@9?",n?"'̲?=S?8W?Nx?Ij#?馡^(?馡Z?vn?vj}b?K~s?Ky? {? u?qֈ?SV?ʪ?ʦh?饟ސl?饟I?t~_?t?Iӹw?I:c??Ę??7?`?F?餞QH?餝S?sP?s4c?HH?Hnb?%^94? W?/v?*?9,i?4aO?飜B|?飜=?qKh?qFW?FS.?FO&+?\?WI?cԊ?_	6?k#3?fX?颚r?颚m5s?oxxǰ?os'?D~?Dy?:?p2&?g?w?Îjm?É?願Ը?願 "[?mFQ?m;?B*?B??Dg?b?37+?z?L?頖~?頖?kkcy?k^?@MB?@1?
?a?P?ꥅ?響}?響?韔GY?韔}?i/?i?>?>@?GT?}‰?.?蠵m?鞽S?鞽L?鞒?鞒?g̼?g?^?qJ?ly?霹j
?霹e=?霎cjd?霎^N;?c[‡?cV΄?8Sx?8Nn?
KG'?
F}j ?Bs7?=?雷9;Q?雷4qb?雌/kh?雌*ڄ?a%?a ?62?*-?*(V?s???q?镨14?镨i:?}o8?}˧4,?RI?R?'?'/ ??	?m ?hѯ?锦S?锦O?{9?{4Q?P4UB?Pl?%SMP?$?#b?E?e>,?ȝ?铣Yf?铣?xd?x VL?Mx߱?MsLg?"Z *?"V!?=A?8z?C
	?{?钡?7?ڇ?ü*	?鏘z8]?鏘w?muZ?mp?BOo?BJ@?)?$=.??P|b?E@??鎕D?鎕L?j86?j5??bd??]O?9?4ޑR?e2?-?鍽C?鍽G[?鍒|?鍒?gS+?g???m??THNb?T?)\i?)Wf?#(?bd?F?侕?醧|-?醧?|u8?|pL?Q:D?Q5?%?%OG-?Â?
D?χf?ςƊ?酤K3?酤FnW]?yxu?y	>?MZb?M̔?"B?"?U?Q1;?-??鄠=?鄠AA?u?u6h/?JZކ?JUǦ??h?ڈ?Ly?XQ3?	b*?邙?邙K?nY_?n?CC3?C>n???칾?(?tnY?o#?遖.X+?遖)?j?jdj??._??i?[S_?V??Pm?逽r?逽Ǯh?递nW?递?g<1k?g7B?;<Ч?;xZ?n?K-?`#>?|g,8?|Xp?|?|0`?|P>M,?|Kz?|W?|W'?|,?|,?$?|ZW?|U[?{P`z?{H?{Z?{Z?{` ?{[Ǎ?{Tr?{T^?{(<l?{(x?zc?z^Y?zem?z	?z?z"?z{cW
?z{^@?zP?zPCA?z$&?z$Xr?y_?yZPF?y)?y/?yMw?y?ywWO?ywR?yK?yK[/?y ,?y i'?xL?xHG?x"?x_pj?x	?xFo?xs>?xs9̗d?xGr?xGy?xt{?x?w,z?w(?w-?wM#?wtb6?wo^?wo%?woT?wCB4\?wCk?w\?wW8@?v4B?v|?v.L?vk?vAb?v<?vj4f?vjq4?v?]?v?}{?qUQY?qUl?q)@7t?q)~?p1͗?p-?p?p7Q?pYA7?pU4?p{*p?p{i]?pP1B?pP{o?p%7?p%?oH?nɕ}?n)t4?n$h?nrHT?nre?nGF?nGAQ?n͐?n~?mb}B?m]8?mym?m
wv?m|?mw?mn	DUk?mnc?mBo
?mB!d?m!8?mw?l묟?lB?l7]?l2$?l&-G?led.?liLP
?liGF?l=?l=W?l_?lZT&?k?kV?kq$?kldK?ke'_?k?kdC'?kd|?k9S?k9˴?k
ڌ?k

?j^v?j?j?j*5?j"߻?jS?j_sV?j_?j4-	N?j4(?ju7?j?i6?i2"?iW?i/?i>M?i9ږ?iZm?iZ#>?i/D?i/@
W?iQ_?i‘Ag?hIu?hDY?h8[M?hxM&?hLs?hGn?hU͚q?hUt	?h*N8?h*Ix-?gv?gɶ*5?gNP?gIQ?g?g
?g|Ly?g|H#_?gP˚d?gPڗp?g%IY4?g%E0>?fu?f%F?fEw?f@?f©?f?fw?y?fw:$|?fK8?fK)G?f 7?f 36X?ee?e?e.`?e*/W~?e?er?er$b]?er?eFF?eFU?eP#?e/?d"?dg?d
x?d$?d]?d~P?dlOB?dlx?dAsY?dAnJ?d?dBpk?cb!i0?c]b>?ct?c9?cO<я?cJ}x?cg9?cgz?c<:?c<6?cQ?cPOh?b$	?b *t?ba?b?b
yC?b?bb0?bb|r?b61?b6X?bg|:?bbg?a?aFO?aL!?aGbW	?aۡ?a6?a]/4{?a]*uy?a1+Q?a1l?a?aE$?`ڀ=?`|6?`c?`	?``:_?`[{A?`WKP?`Wʍ?`,=p?`,9<'2?`H?`?_5ߩ?_wx?_?_?_}Q
?_},`?_Ra?_R\O?_&I?_&^r?^:#?^5do?^ϥZ?^ϡ
G?^
|?^N?^x{P?^xw2?^Lro?^L?^!P`?^!K?]T+o?]?]#V?]&?]X?]O?]rO:?]rE?]G]ׁ?]GX?]g7?]S?\,c?\(# ?\ēx
?\ď=?\~?\\?\ma>F?\m\NzJ?\A?\AE&?\,?\'?[:F?[?[6?[z?[[C?[VZ\?[g+?[gn?[<"?[< w?[/O?T>ϓ?T(
?T#W?S{v&?SvU?Sxh?Sɼk~?S!?S^
?Sds[?Sdnq?S8[?R^X
?R^T?N?N?M?M9m?M:k?M6e?MLx?M{z?Mji&?Mj0?M?
%j(?M?j|?MN^?MIyG?LD?L0?L?Lb7	?LZk?L?Ld\9p?LdW~?L8w?L8?LQ?Lt?K"r?Kg?Kc?K^U?K?K?K]&t8?K]k?K2%L?K2 |c?KeM?K`Wʂ?Jڤx;e?Jڟt?J}!?J¯7?J""t?Jhh?JW`h?JW[>c?J+M#?J+ɞ?I.?Iܙ?I-?I?Eat?E57?E5~c?E
0l?E
,(^?Dc, ?D^r#?DK?D]?DƢ?Dm?DZκ?DZv?D/(k?D/#/?DY?DTO{?C׉1?Cׄ]g?Ci??CF?C?C[y?CTY?CTK?C(E
?C(@?BsŴX?Bo?BС:?BМ	?B
~n?BQn?Bx%?BxdV?BM(ѥ?BM$:?B!U'NF?B!Pnt?A4[?A|dc ?Aɬ?Aɧ?A?A3=?Ar;?Aqt?AF-=+?AF(ܷ?AWL?AR#?@?@|6?@ª3q?@¥z?@y?@^9?@j?@jlQ?@?#?@??@K?@F̈??r4??n1??]??7K????}??cۧ??c#Q??8‹A??8
=*??2I|??-?>Wq9?>R?>|9?>w?>?>Ub?>\ī
 ?>\?>0TL?>0g?>?>`?=.?=)S?=Q|?=L]0?=sB?=n?=U?=UV?=){?=)i?<׊b?<Y?<9,B??2?9?9=C?9
?9ʥ?9d7֕?9d3^}?98P0?98L?9i;u?9d?8`?8|E?8%?8nƒ?8?8?8\Ǖm?8\g?80>Ѕ?80ه?8^?8?7
vO?7?7 ?7Ml?752?70|?7UJM?7UELy?7)^t?7)Y?6r?6m0?6ц;Li?6с]?6?6.?6yuX?6yɸ?6M!W?6Mj?6!O?6!̘~?59+?5\/?5xb?5?5}+?5f?5r$?5rnj?5F&lM2?5F!?56T?514?4E?4A'?4U9|?4PQ?4cҵO?4_d	?4jr>ր?4jmq?4>LJ(?4>{	P?4?4Ct9?3I?3斓R0?3:
?3?3?3ٗ?3bY?3bG?36?36ߎ?3
D?3
ӎ_?2Z?2ޤ~?2}?2\?2jE?2V?2[c?2Z6?2/7?2/H?2:P?2z?1+?1a]?1&ў?1!
?1.?1)1?1S6v(?1S1"?1'==?1'9$OS?0Dv?0@(V?0K7?0F͛(?0QnA?0M?0wW?0wR?0K]<?0KX?0bgJd?0]?/g3/m?/b}?/k?/f&|?/o?/j0?/osb?/on?/Cv?/Cq3?/y?/tWr?.|?B:?.w3?.~v%?.yL?.O?.{?.g
?.g}ȳ?.;?.;~1?.0?.~I?-T?-O?-X?-RP?-?-~?-_o?-_~;o?-32?-3}"B?-`C?-{?,~W?,yx?,|W?,w?,y?,u8"?,Wv?,Wr!L?,+s5N?,+nv?+ot?+k'?+k}j?+gw?+gki?+bh?+{b}?+{]6?+O]?+OX2?+#W?+#S@4?*Qt?*MI,?*KC?*F;?*D?*@@?*s=1?*s9.?*G6qx?*G1,?*.N?*)푩?)&s?)!c?)?)2?)=?)GnJ?)kL?)kJ?)?	c?)>U1l?)?)N?(?(?(1?('i?(׺y?(h%?(b:׎?(bdž=?(6\qќ?S9?'A3K?'	b?ݴY??άY
?>UH*??CJ?8?։[?Nd?U?[?VW}?ab>?au?4a?4Ա?0?S?VH P?Qܟ?0?9?Ѽ}?
J?WGG?W<i?+K1?+G
Ι?
2V?
v?
Jl0?
ҿZ%?
~?
{W?
z;f:?
z68?
Mh?
M?
!?
!_?kY?f?%E:/? Y??'(?p	?p[&&?DPǢ?DL2?	[z?4?y?5?y;u?t?0-?+T?f?frv?:V1n?:?Tr!?O?

?
?
2e?
?
umK?
pY?
]*Mz?
]%?
0V?
0!#?
?
?X?X	_?X'?+b?+?[:/?VD?oѾ?nc?IP
??zU?zQ?Mk?M9P?!w?!5?M,?HeoE??qR{?n? ?pA!>?pcf?9}??U]I?cj`?^s?/s?4u?aF?a?5Pc?5+??SX?8Q4?3)?H?Ýf?WH?S8#?V#?Vx?*vpI?*q]j?|-?~?ђ%?ю?3k?TA?O/?I?۞?k?gK?mG?m?A=/I?A}*?C?-)?X?l? $?P?Y?г?c3VW?c/?6"?6ת?
Dn#?
@M4?u?i0?T?P(x?8P,?׍/?XcA?X^/?+.e?+E?pD'?k?0?a?{?w
f?z}?y9b?Ms?M	s?!
(P?!~<?A@?4?^ ?
SZJ?^l?򛐴q?od?o'|?B
e?Bcz?[e??Nh?隤? %?;S? ?vQ?d#?dW66?7?7X?#`??ޣ{?ޞ9?"F?DVB??[

?Y ?Ye?,3?,v$?$A?zQ?Ӛͤ?Ӗ$.??q?z
l?zdC?Nd2?N?!?!7?	Q??ȅF?ȀYv?p?B?o{>?ov?B?B	l?oN?k"+?2f??bx?^B?'?Iv?dT?dO?7?7F8?D}?@??YDi?T?ci?cd'T?7:4?75?
?
Ybl?tO?&?豈a?豃pY?)5?򁛂?Xev|z?X`l?+hJ7?+B/?@$?9"?Axz?A?1aT?-"?|,?w^6?ֻ:
?ֻyt?֏K?֏%?b[ݽ?bV{(?5:?55??C?6V?1ܺR?կ~4?կzI?Ղv?Ղ\?V?V
+)?)VXJ?)Qu
? 8?{Ƨ?U?'n?ԣ*?ԣ%zV?vpf
?vks
??I?I@?l0?W$??+?;B[?Äz?5?ӖȲ]?Ӗb?j?jz?=P?=Kr̴?C])?GE??q?ҷ]?ҷ4?ҊZ#?ҊV'?]j"?]ƒ?0w?0?x??_d:
?Z^?Ѫ?Ѫ
G?}ߞzL?}?Q4m?Q>0?$^o"?$YC?Q?H?ٙ?5?О"?Оd?qWF?qS9e?DW?D?w?5???
?ϾK!p?ϾG?ϑ?ϑ=;?dym?dOe?75?9Uh?5;?tY?o|?αC?α:?΄ׁ?΄4E+?X"w?X?+[?+W%?N?+?<?Ș+?ͥu2[?ͥ?x=TP?x83?Ktڠ?Kp7?J?dQ?,J?7;K?S?,?̘Os?̘J؎?k:?kC?>?>	I?ﻚ?ӳ?$v?Y?˸X׮?˸T4?ˋ߷?ˋ=	?^:z?^?1t?1@3?&x?"?˂H?}`&
?ɞ4D?ɞcf?q
?qkkQ?E5x?E[?@?<D?o?jᙪ?Ⱦ?ȾVİ?ȑVI?ȑs6?d?d5T?8'Bf?8"WB?TSr?Ol'?ށ4x?|i6d?DZjb'?DZlu?DŽq?DŽ?X?X|2?+0hbB?++ƅ?[P8`?Vd4?хݟ?с;?ƤU?Ƥp?w?wKF?Kn?J?,k?'Q?Ue7B?PÕb?}o
?y8Ռ?ŗq?ŗT?j͹?j^?=#L|?=$?36?@?BL?>H?ķiG?ķdE?ĊL[?Ċ?]?]VZ4?0I\0?0ը(?Bk??#s?AR0?êH(?êC#?}lz?}guN?PW?P
=?#
	?#ER?L?(9u?Rt?i???pE??Yo?۸?c9.?bzqY?6H?6?	>?	9?]KW?X?{Z?w	O???U\_*?Uɭ?(԰?([? ??NI?	@?迢*
?迢%?uFAP?uA?Hb"?H]|?}cW?x?JR?_?ٌ?9B?辔?辔o9?gȬ?gM?;rو?:Ҩ?@?M?2s?-ӓ?轴J4?轴FOC?轇cy4?轇^rj?Zz1?Zv=*E?-Oc?-eS?io?y?*?ӻY?輦֓?輦?y줒L?yz?M\?Lb? K'? !?,+?(g?AU?<$?軙Uo?軙PU?li?ldg??}Φ??xr,?I#??(	?垈x?躸m?躸Q?躋J?躋;ʇ?^ٰ~?^t?1+t?1K?N ??
o?z
?蹫H?蹫\?~-pE?~)";?Q=dd?Q8Ŵ?$L,?$H-?[F?W=?j`?e?踝x)J?踝tRC?p?pW-?C	?C?4B?Y)q??TJ?跼?跼?跏?跏C?bO?b7?5p/?52b??:$?D?t?趯-c?趮?趂
e?趂\?UFg?U:?(ζ?(0?&[?"_?/d?+7e?赡8V*J?赡3$?t@}(?t;xj?GHK?GC&{?O'?K$?Vx?RC?]?Y	?贓d9?贓_xe?fj,yv?fe*?9o ?9kK?uP?pM?z^td?u3R?賲?賲zuQ?賅rI?賅~Z?Xwտ?X٭?+%x?+
?|
??ёz?ь+?貤?貤?wnm?wˤ?Jd?J???eR?IZ??Ü8?×ӛ?豖?豖1KU?i"?ip?$? {}7?{??vƼ?vo?qW?讙qDF?讙l3?lkC8?lf??e*??`R?_0?Z?Xz8?Sݣ5?譸Qlty?譸LY?譋J>?譋Ehw?^BG?^=?1:1f?15e?1ŒQ?-%g?(9@?$_H?謪t?謪A?}gh?}?P?P'?#t_?"ב,?h+?Y?!"?d?諛?諛W4F?nn2?n?Aʒ?Ak(?]?7?j^?4ր?誺퇇?誺P?認?認X?`#?`?3|3GR?3w$?mK?iTY?_V?bjd?5[E?5V?G4Q?Bw(?2P?./~z?覮
?覮o.?要'K?要Wf
?Sd?S>?&ݽ,?&"-?Ǡ?O ?̱,bT?͈$?F?ޡ2?ޝH?蚱uV'?蚱qL,?蚄I!?蚄D	?W8?WO!?)?)ENs?rg?َ5?ϔ-?ϐ?虢f:?虢aa?u8(Ou?u3?H	aJ5?H?B?թo?3?3t?{3?vh?蘓Jݳj?蘓FD?fcz?fN?8Q?8<,?i+??ކ頄?ނP?藱Up?藱Pz?藄"`?藄Mr?VaN?td?t^?G)I'?Ga?Ef?9?P
?Kr?yh
?ȡ?蕒Z9?蕒A?eR~?eh?8w?8s%?@J?<8I?	b?:?蔰F?蔰\?蔃?蔃m?G~?GfT?Z>e??_D?Ǟ?蒿X?蒿Sv?蒒g
?&֦?[?*0c?Q?MV2?荟?荟,{?qC?q¬?DlU?D|շ?;?F1?6E8?(?$?茼.Y?茼K>M?茏f?茏bo?b+1?bR?4M?4ҷ.???Fe?A>?苬?苬?z??Rjdk?RfW?%!N?%u
t?!??y
?ymˆ?ymDn?y@8y?y@3m?y?ysB?x_K?x[K?x?xM?xZ?x;?x]h0?x]4?x/n?x/?x<7?x77?wʸ?ws6?w_8]?wZ^?wysO?wy|?wL?wL|	#?w@?w;[?v񠪰?v?v01i?v+P?vcq?vХ?viN?%?viIbI?v;Ƌ?v;3н?vjU?vfe)?u߲?uB5?u\?u9o?uN?u?uXlo?uX[?u+,D?u+(b0?t(k?t?tEZ?t@s?tЏ?t ?tu[úA?tuW1T,?tG8?tG?tq,?tl?saIZ?s?s@?sP?s?s
8P?sd4?sdn?s7 }?s7ORx?s	mUv?s	3_?r1b@?r-H?r?r?rA4?r<,Y?rSL?rSú?r&O/+C?r&J3?qսT?q,>?q[&?qWf@9?q
W?qK/B?qpgm?qpbށ?qB?qB?qq?qls?p"?p	?pz`&?pu?pIش?p-?p_:?p_}LE?p2?p2?p?pvj?o
)?o
?o$*?oO?o|ե?o|
<]?oNfT?oN)?o!!?o!
?n^?n?n5q?nCm?n{?no?nkm?nk܅?n=?n=zRE?nU??n
?mI?m⌸?m1	?mY?m6?m?mZ.)W?mZa?m,ю?m,@d?l!
\?l	j?lфj|?lr?lMo?l]?lv|u
?lvxT?lH>6?lH>_L?ltd?lo+?k!?kS?kjK?kf?k)ڽ?k?ke_l?keZΆ?k7ZJ=?k7ɞc?k
R7?k
Nb@?j8Pv?jǧ?jE'%?j@?j?j2F/?jT6	?jT1y?j&R?j&j?i%9?i!@?i˜?i˘QRM?i>?iEj?ipuZ?ip;?iC%?iB0?ivf?ir'!?hYՑ?hɘa?haW?h]?h֡4W?h.?h_KF1?h_FA?h1k?h1P?h3@%?h/-?g֧;^]?g֢TD?g#h?g!?g{A>?g{H,?gN9hI?gMw?g rJ?g n@?f䒙?fI?fV@?fQ?fǚ0?f?fj8W3?fj4;?f?e(?em6Y?eݒs?ehΉ'?ed>?eXܓ?eXKI?e+Fy?e+B!?dD?dh?d#?dyDi?dP?d5?dt.L?dt	?dGkB6?dGfW?d?ds?cDo+z?c??cS/?c
?cK?c?cc?cc-?c5ug?c5JH?c]&?cY?b?bÈox?b288?b-*?b4?bw*+?bR܊?bRڈ?b$n/?b$j?avt?a~?a??a;e?a+:?aKP?an^?an]O?a@w]?a@r2?ay?aF?]UY+@?]'gʙ@?]'cwo?WaR?W]	i?V
a?V鱀S?V
2;s?Vc?V^H?VYvy?V`R?V`?V3?V3?VW{|?VRNj?Uש?UץaJ?U?UZ?U|M;?U|IK?UNOj?UNׯ?U s?U ?TADS1?T<?Tő'?Tō4N?TC?T]x?Tj1#:?Tj-3?T*Ҹ?R9?Rsje?Rs[1?REW6?RE}?Q3o?Qp?Q'F?P*]?P%y:?Ps&?Pnyq|?P|=?P|%?PO
R?PN~?P!Lj~?P!G?OJ?O7Rh?O"qn?O֖?O"/i?O?OjhX?Ojd]_?O=?Dv9?Dr?D}?D]?D@?DIя?DUnp?DU
?D'AZ?D'=,?Cs?Co"5?C˥Ol?Cˠ{?C֟?Cv0?Cp?Cps?CB8JMf?CB3?Ch?Cdx?B昪,?B!?B_ٸ?B?Bs?B9a?B]&҆?B]"I~Q?B/UZ?B/QT?B3?BsgF?>ccL?>Ȑ;,?>ȋ?>?>8Rq?>lA?>l&h?>?K?>?a?>/D?>+Q?=V_!?=R,?=}1C?=x?=w4?=U?=YɃ?=Y7?=+0f?=+}O?<$f?<?<9
?<5
?<^L?4?: :?9^}2?9Y?9~}?9yQ?9T ?9N?9hEH?9h?9:?9:\?90T?9w?8+O|?8
3?84?80L?8R+z?8MI?8Uo0L?8Uj$?8'?8'\d?7E}?7fT?7UC?7˿4L?7/?7ی(?7o?7o?7BAj?7BLW?71at?7,ڈR?6K؏?6GQ?6e?6avn?6Q?6{J(?6\R!?6\?6.?6.#?6`"?6 ?5?5fo?5(q?5?5wj?5w'?5I+D?5I'"?5B?5>iw?4Y~?4U]c\?0.?0yw9?0q.b?0q*c.?0C=?0C8<]?0KD?0GA5?/Y
?/U6u?/g_:I?/b٭?/t\?/p+Vr?/]D?/]}+L?//_?//?/?/7?.Ӧ?.ӢC	?.U?.m_?.w됐?.wf@1?.I&?.I}]_?.
?.Ba?-eI?+I>{r?+D?+jO@?+jJ8?+?+?%NY(X?% X?% Tsiy?$S`?$Nr?$Mi?$I6?$G&?$C?$hA:]?$h<'?$::?$:5?$3w?$.5?#,b?#'
?#$nX?#?#r4?#?#T#?#T?#&+?#&?"F?"U=?"T!x?"
?""?"?O?"m?"m]u?"?ۭ?"?*?")?"̦?!Tܱ?!L?!/R?!e	?!?!6?!Y2?!Yo?!+0>?!+W\H? rV? ?? ~:? z6x1? ql? m-J? sdU6? s_? EV? ER(? H o? D,!?:b?5?+?'C?HM?U?_
C?_	g?0j?0*?..&???|?r?D?x:`?x,?J]I?J??E?\??vJmN?q3~?69?*"#?&_=?=T??A?r?}A?}kM?OH@?OUY?!R?!.?`?󫉅?Śs?ŕB?D?	{?inR?ii̕?;W?;SGa?
@?
??T`?T"?&?&q3?5z?$?ʘ':?ʓAk?~?zG[?ne?n`9?@K?@Fl?0Ⱥ?,Ixd?*bg??:>???w?YgW?Yo|?+?+?S?Ҡ(?od?kPP?R}?N}q?s5^?s1Z\7?Eg?E?F5?#T?܏??+?w?w?B?^sS?^{?0aĭ?0\G?Az??
:y3?
?
?
Zl}?
ZdL?
,M?
,aR?;?-5?S?Om?#`?{c?s}?s9?E'?EB?F?ǣp?aK?\?/l1?+L??F%?^ˤ?^%(?05?0?fv?a?
3g?
.?
	?
?
w\$?
wݏ?
I^2?
IId?
dO?
_ː?	/u?	*w?	Ɯ?	S?	NǑ?	]Q?	b`?	bD?	4Y+?	4Uj3?	#O?	@b?Ez?s?}!??{e6Z?{z?MGa?MC?G1??A$?m?Ÿߨ?›m?gG?b
?f.S 8?f)?7?7
?	}w?	?ہ#?};S?Gk?B8??m)?P?P͞?" ?"Y?[c?W6?ҳ?T?㾪)?@?iS?ip?;jz?;fd?
-)M?
)?4Q??,@?
U?t%?p?T6Iv?T1?%V?%40Z?ʃG?M$?yU?uF?:
S?5G?l8	?lQ?>?>W?y:?u!?8C?4]?"?JR?e?i?Wtv?Wp6f?)2!?).5?b.?/J?̭?̩E$?jQ4?fVcH?p'?p#?A#?Aߋ΃?,$?P?\@?W??	$?һ?>?Z&?Z&t?,H:?,CQ]?"(??ϼ~H?ϸh?v(?q?s/I?s+á?De?D5?N|?҉?Y?UAR]?ݬ?
aH?ɮ)?1B?]/?]|?/8b0?/3捡?Fp?/?ҥV^?ҡ_?\!?Wn?v ?v
?G@?GD?}qg?x[?2&?-?̙?fE?P0?4q?`On?`J?2?&?1;? ?D?3?iZ?ev?+z?Z[?xkG?x?JJ?J}55?3z?/-F?R?BB?%?1}?G?C={?bv?b8/?4I?4j&?X?T}w??D?2?(p?{gV,??{bþ?M+(?M?İ?5?r?nl? К?UT?i?j?5?e{l?ew88Y?7()J?7$3g?[?೻?ځ|?}>a?-p?)M^?}وi"?}
_?O^?O~?!0X?!+m??u?ąuz?ĀO?/**?+1L;?gٓS?g?9-	?9~?G?QI?E?NP?IB-?Sa?S?%c| ?%B?;v?6??o?oٕq?Az"Z?AuE"?yz?o2?_?=?Lm?H8?c,R??Yy?Y}vU?+-\?+@?+ ??O>?KF4?U?T?ql>?q}s?C6?CUF:?62?/?KO?Fב??ޢ?zA?v t?[y?[
P$?,g(?,1i??=?:?ՃV?
N?kz2?gz?s#L?r?D~?D W?+v?'?J?R?T_?uo?u.+Z?GPfp?Gؕ
?U?4/?;?7C_?|x~?$?Vr?Rwd?^?^ߞ?0p߭?0lvBa?xk??ӉS?Ӆ=DZ?(?-k?vF?vx[?H,e?H(#?J?+?B\OJ?=?ӭ?Q{?V0?Rp?_%9?_A?1jR?29۽?#K&?u?Ia?E/?C?da?xSG?xOK?I\?Ic?\?X1i??0G)?߾dXH?߾_/?ߏ?ߏEY?aj"?af[>?2횧?2$)\?p?k
2?CD?̕
?ާt#4x?ާo?xˀ?x?o?Jvi?JrzC?|?|G?x*?t%K?ݾ3X?ݾF?ݐy	?ݐt?a?aTi?3x?y?3sZ?g?N?vA*?q(?ܧ.?ܧWE?ys
?yn?J"?Jڝ?n?j/??7?ۿi?ۿd7?ې7?ېNz?bb5?ٿ$y?ّ.e?ّ)?b'ݯ?buP?4?4Z??%??F?ب?ب32?zHv?yJ?Kwa?Ks&L3?w?,?eZϦ?`?׿ǃ&?׿Ri?בQ/?בMrq?bǹ۵?bD?4=7?48?a??'>.?"@?֨d?֨X~?zw?zK?Kr?K?@[?7t?kI?f
8?տn9?տٟ?ՑP?ՑL`p?bHI?bӠ?45n?40l?GS??ӫ?_?ԨJ?Ԩ&?yG?y$?KkF?Kg4??׍?Ltz?G(?ӿ
?ӿVl?ӑ+;i?ӑ&ǜ?b`?b@O?4	85Z?4?wU?sN1?5D?-?ҨS7>?ҨO}?y?y ??K.R?K*wZ?Q??|??yc?ѿu$5*?ѿp:Q?ѐH3?ѐA?bM~?bH?3*?35I?#q?s?֎u?֊d?Ч|?Ч?ycԱe?y_`?JS?Jk?7?3*z?-?휜Nj?Ͽ
5Y?Ͽ?ϐsI?ϐn?aۚwn?a&?3Cٗz?3?f??Y{[?s?e?Χz?ΧvZ?x۝?xh??JH?JD)??v?9L?Ƴ[?;{6?;v?͏?͏1?aE?aAt?2*?2k??2?s!?otx?̦?̦Ӈ?x;?x7KБ?I8*~?I4?e?:?eE?`?˽K?˽gpl?ˏ*<?ˏ%iY?`?`ߐ?1	?15G?N?JS?԰3?ԫf?ʦ?ʦI?wq*?wl2?HL?Hم?1 
?,M?됩?6H?ɼ?ɼrOH?ɎN?ɎJa?_vҚ?_h?1̌?1Z++?ip?ed&?Ǔ?!o4?ȥ%3?ȥ [?v).?v}!?Gj@?Gڏ4~?;?7??Y?ǻҀ?ǻM?ǍOfd?ǍJR?^W?^N/?0G&?0]E?`Q?\YG?һ?Ҷ?Ƥ0h$?Ƥ?uo
K?uj?FȞ?F,?!ㄸ?q?z.*?vji?źӈ?ź?Ō+j?Ō'wx?]m?]T4?.2?.T6?3B04?.Зm?ъrMp?цb?ĢV??Ģc?t7]?t3|?E:\V?Es?:A?Ծ?9f?5}P?ùVzX?ù?Êr7?Ê?\9BD~?\4:?-Ʀ?-Ud?x?ݍ?5>?1z^'?¡z?¡X?r-?roN?D/N?D+x9?D?~4?̆?Х?'!?羞n?羞i7?o?oQ?A7e?A?Sa	?N?>?Τ?罴и.?罴`|~?罆6n?罆1;?W!x?W|>?(5?(P?"??`9j?[Z?缜G?缜@?m)?m??3?e?$?$? ]?糪`J?糪[ܑ?{L_?{ފ?LI	?Lєg?n?D?JI?F ?bH?Y?粑*?粑}6?b(F?b\?40
i?4+>?hp?dT
?֡)?֜|?籧.3?籧8?yM?y[?JHms&?JC??{.(@?eV?d?簽?簽詾?簏#d?簏«?`Yf\?`Tj?1]?1?Ĉh?2?om?;?篥.,?篥*?vc	?v^?GH?Gb?=I?"?
?x?箻2D-?箻-ֿ?箌eW?箌`JG?]?]]?.ʝ?./?ϞN?bRV?.?*I?筢`S?筢[\t?s_?s8-?D¬c&?D?:.?h??#ّR?ly?笸Sw?笸Oh?笉گ?笉m?Zk?Z?+1?+C??
>B?@[?;?竟n?竟jTu?p.1?po\?AʬB?A?ݐ?1??%l=-? ?窵R\W?窵M4?窆c?窆z.?W[?W?(lH?(?1?Q}?.?*@Gm?穜Ye?穜Up?mƂ?mVU[?>][?>x?ٮl^?B?M?Hfk?稲-p:?稲)?稃Vڪ?稃Rne2?T?T{?%|n?%TH?C??z?b?秙!gr?秙X~?jI
1?jD!?;pa?;k?nq?rC?ݾ0L?ݹVI?禮r?禮;=?禀
?禀h?Q0?Q,J$?"VL?"QN?{]?w,?Ġz?Ĝ.{?祕QdH?祕?f齐J?fQ?8
߄?8	s_?	1U?	-J?UB?Pd?礫xf?礫tK?|{?|rC?M(?M}?E?҇?C?6خ?$o? $m?磒EČ?磒Ak?cg*?cbt?4̀?4)??QRR?x\?ĪB?碧$(@?碧3?yP?y}?J(bX?J#=-?G?C&?fwP9?bF:?硽J?硽?硎b??硎?_i)?_:&?0$?0ڹ֚?"?+?~?S/?砤6xj?砤20?uS.?uNû?FowJ(?Fk?u?
۾?*@Z?袿?矹”4?矹*&d?矊ݴخ?矊J@?[i?[ i?-?-
L?-Y?(%?GQ?B2?瞠aB?瞠\?qzc?qu7?B}?B:Y?M?E?X?i?睵}?睵إ="?睆Z?睆#\?X?X?+?)$?)?;/?6?Q߆?Mur?眜hQ?眜c%?m~y?mz?>W8?>>??q?3t??盱2B?盱c?盂E?盂}n?SQ?Sj?%q&?%
?%H? a?8Ԯ:?4j3?皘L?皘G?i_
?iZ?:qg*?:mRt? ???ܖ9?ܑ\?癭	?癭,?~]?~%?Ox?Oa
0? ۻ? Rr?c!'?? ?W?瘔?瘔kY?e?e5G$?6,?6'd?;U?6ץ?J@?Eg	?痩X?痩Ty?zg;b?zbK?KuI˙?KpI?W$?~R?퐉
`? ?疾~?疾P?疏?疏8?`>3?`?1Ò%?1)L?Ϝ?3?\*?5?畤Ӵ"?畤j?u"Z?ul?Ft?Fzݲ?|6?;?̓?
c?町@?町jL?甋%L?甋!&V?\/?\*?-8,?-3
{?Agp?<#?IԻ?E:n6?瓠Q?瓠M"?qYy?qUk?Ba?B]DM?ia?d/?pD/o?k?璵w!A?璵rl?璆}?璆yM?W?W?(?(???Q	?ʕ(9?ʐ4?瑛M:?瑛=?l)]P?lh?=?=T?L?j?߫_\?ߧ[?琰?琰0-?琁?琁?Rn?R?#?#o0?X]??Žj?Ź(Ĵ?珖~uP?珖?g#?g.G?8W?8f?	Ð}?	(?XG?ڿ΋?玫g?玫o?|
 ?|T?Mu?M?ę"?2P?
c?ￊ???獑}?獑_ˡ?bC?b?3u?3Й?_ӱ?2?չ?յ?猦W"?猦?wdT?wM?H(9?H;?v?< ?X?m?狻Cg?狻V_m?狌\-?狌R?]7-?]Kd?.'?.W^?^?Ў?Ќ*?Јr?犡,?犡?rH?r|?CzE?CvL?t?o?m[?hτ?牶el?牶ar&?片^Rf?片Y`?XVT$?XRs?)Nl?)Jv?F?A?=b
?8?爜4o?爜0?m+3%|?m&?>!'?>G?_&?z+?
?	co?燱j3G?燰?燁I?燁[r?Rr?Ri}?#֮?#/΄?N?Ҭ?F>?H"?熖1[
?熖mF?g-?gnH?8-?8ǤW?	>?	?ڌx?ڇ?煫~?煫z -?|pAz?|lVz?MbC"?M^=?T:;?OԔ!?EQ?A#?6H?2(#?焑'Iݯ?焑"P?bt?bW'=?3?3??k5{?k]?;/?;L?Ѻ?L?~?~ݼi?~pm?~?~Ӹ?~ei&?~Pvڍ?~Prv+?~!]3?~!Y>G>?}D"`?}??}*Y?}%F?xlU5?xlqO?x=5?x=?x~l?xz	ow?w[s?wW(E?w8a?w3~?w&q?w
?wQ5+'?wQ"?w"2?w"Ӗ?v?vj?vĄT?v#?v_x?v[L?vf:U?vf5?v7`?v7?v4?vѲ-?u83?ugY?u?u?uz|e?uzx?uKUl?uKQ-?u.r?u*?t
?tc)?t_Z?t'?ti#|?t?t_+Oa?t_d?t0f?t0bCf?t=]@?t9t?sJJ?s^?sc/?su?ssz?ssZc?sDΝ]?sDlLF?sm?si6?rCv?r>7/?rSݾ?r?rE2?ra?rXE?rX ?r)QQ?r)5?qjkk?qf	X"?q>=5?q9ۍ?q݈?q
e?ql
?qlਖ?q=$?q=?qxv?qU2?p]"?pXǩ?p/Ej?p*?p ?p?pQҴC?pQR?p"w?p"?ou(?op?oEL?oA^h?o4p?YX?Y{?Ywd#?Y*4\?Y&?Ynx?YnՊ?Y??Y?2?Y6x?Y2
?X
2?X\?X?X?X@qC?X<K?XR?XR['?X#?ST`?ST1?S%p?S%lcH?R [}?R?Rƻ*?Rƶ?R_Ə?R[jZ`?Rh0%?Rg?R8S?R8K?R	L/|`?R	Ga?Qŕ?QiH?QV?Qg?Q{6nS?Q{1n??QKᇀ?QKԅG?Q{^V?Qw?PD?P8^?P?P(G?Pa-?P\?P_}?P^5'?P/Oh?P/RQ?PDD?P@)-?OX.?O๧?O_|?O?Or%c?Or!?OB!j
?OB;?Od/?O`=?Nv?Nog^?NTj?NZ.?NA[?N=K?NUߺm?NU_u?N&}4?N&yx?M?MK?Mǹ3e?MǴ?MVy?MR?Mhz?MhSP?M95?M9.?M
,?M
(N4?LD.?L}!?Ld?L`e?L|ch?L{W?LL?LLe?L6֦?L2{?Kѧ?KL3?Kl2)?Kg<?Kwim?K?K_viM?K_?K0:/?K05 ?KӢv?KH+k?Jl>?Jhu}?JF?J]??JrYv?Jr,?JC6O?JC2T?Jιz?J^z?If|?Ib!?I?I?I0VM?I(?IV,!F?IV'̘?I&Ӡ?I&qb6?HY0H?HT4?HO$?HIs?H(a?H
F?Hiz?Hi`|?H98J?H91?H
E
?H
@s?G΄!?GtP?GnI?Gi?G|~!`?G{#?GLmB?GL)?G*?G%?Fx?F?FP^?FL<`[?Fm^?F?F_u?F_qD?F0J?F0C?FP?F2?E,?E')?E9?E0p?ErN}?ErJd?EB߬p?EBS4?EpUɀ?Ek"?D?D_6\?D	?D|m9?D a?DT?DU??DU吣?D&?	?D&;1?CΑv?C7m?C]R|?CX4?CEn?Cs?Chz?Chu.?C9?C9i?C	d?C	DL?B#?B?B!u?B:?B{<?B{8?BKɏZX?BK61?BUW&?BQ6?A$?Aݎ?AmJ?AiR;]?A)V?AВ?A^ba?A^	d?A/Uq?A/
Z?@z?@?@$lp_?@ ?@?@6(?@q8mvx?@q4?@A,?@Ad?@KY(?@GM??g????]/G??X++??|??ZR??Tm??Ti\??$??$o?>}_?>yEL?>~?>?>46?>ۋZ?>g|?>gC?>7?>7K)?>2w?>;?=إ?=ءca?=+
?='_?=y3?=yZ]?=J6jo?=J2ʹ?=Z?=?<@Ko?<;#u??7f?7T}?7P~N?7Ѩ*?7Q~?7ZN6g?7ZIIk?7*?7*(5?6F9?6B-.
?6C?6˽?6=?69g?6lk?6ly?6=3??6=/WR?6
 ?6
9AT?5(n?5$?55?5hW?5\k?5?5Ox?5O6?5 ?5 ?4a?4?4-c?4b/?4z>0J?4u?4a~B?4a(,?42jy?42f#?40p?4ٜ?3YyX?3UL?3A[?3xx?3tG?3tCaI?3D[s=?3D ?34?30d\?2tz?2,$?2 ?2Uz%?26j4?23?2Wv?2W o?2'r8E?2'|{?1(
?1?1i?1eC?1VJ?1pL+?1iQl?1iMW0?19P(?190??1
82'?1
4XB?0ګƒ?0ڧp?0?0Dc?0{*XR?0{ԃ?0Ltq?0K?0uz?0q$?/;d?/G?/X?/Tb5g?/d?/řK?/^:S?/^6?/.J3?/.9?.?.?.όj?.χ?.f]?.}?.pk?.pgC#?.@N?.@֙?.J?.EJp?-4P?-x?-'W?-#C?-?-EO?-SP*?-RE?-#qU?-#m;?,3%?,wO?,K?,G?,W?,=?,e%?,e!>k?,5?,5y}?,"P?,"?+i@?+eJ?+Պ.?+5A*?+w@?+w<
W?+Gz?+G̱?+v?+_?*:S ?*|!?*zІ?*&m?*Uw?*Q"?*Y/?*Y;s?**(]?**$Nw?)ϡ?)~2?)8?)i?)ce?)_8?)k?)ks?)<3ո?)?'f0?'$?'̩dO?'`6r?'`2i?'0?'0On?'i?'?&ɘ[W?&D^?&r-?&r)YW?&B}7?&B)K?&	?&9?%XPw|?%S?%SP?%=?%Dn?%|?%T?%T|9?%$ǎ?%$on?$DGY?$@a ?$Ŧc?$Ţlt?$(?$x?$fhȾ?$fd6:?$6?$67?$*oe?$&?#׊?#׆t?#?#扈8?#xJU2?#xFY2?#H9s?#H?#	?#.Nd?"h/?"d2P?"E?"or?"%?"!nbQ?"Z_=?"Z.?"*N$?"*ݚ&y?!??!;I7?!˝?!˘y?!09?0?T$1?T@ ?$f_&U?$b-???,G?ڢ?i-?dۼ}?eJ?e?6eyb?6n?i`/?eJ^~?־?ֺ=?>?3?wg#?wcY.?GӜ?G?1?f?cZ1t?_e?y8?y?IKe?IG},???.?˱???[?W4oy?Z?Zzz?*^A?*}?$"? >O?g>?b?4,?c?k ;?k?<,@D?<(yҎ?n.W?i߇?
ܯQQ?
ܫ8?
0s?
 ?
}0X?
},}?
Mq%?
Ml]?
;?
[?
??0?,N޲?o꜄?k%?^aq?^M?.X?.lMK?,?;N?'8?j?f0?}{?.?o7D?ow?@#?@`?`#?\I1?
J?
!F?
چ4?
7T?
?
?
QSr?
QN7?
!k0?
!?	ʦM?	W#?	#?	s?	A%A?	<ֳ;?	b|
?	bw$z?	2?	2J(?	ע?	c?+??&?dҡ?`?5?s`?s@?C׫
?C]F
?N?e?Ix?E*o?f?}5?<&?J?T9?T{?%)v?%%?am?]Z?Ř`?ŔT?ϖs?H?fF?f?6<:?68g(?r>?n)s?֨ɲ?֤{?p:Y?"gm?w?w+?GHl?GD?}Ո?yj?r?%9?>? ?h?	?XNf?XJl?(MJ?(}?e?P-?h?_?y?+?iN?iI?9JƵ?9{g?	PK?	y?
N??j?5Jx?zFV?zBgT?Jw.?JsW?R?p?ؽX?p8n?p?Y?8?4~q7?[hnu?[d!?+˙?+)?_?¡k??}.?$c? ?lR&?lNnN?<ϡ?<|H?r?Tڥ?1y?B?	-
?2x?}6*?}2=~	?McSYJ?M_@?ُ?m??p?я?IY?O.??^?\?^;	?.j?.fKGP?{?C	?Fv]?λ?Q?n?o8K?o??>:??:Í?h0?d>u?ߑo?ߍ@Q??Ӧ ?Y?߻^?_f?[tu?V{ּ?VwpO?&?&mU?'?n?3o?$*?lvA?"3?gc?g8?7 ?7Τ;?:?6B[?Tn?PuP
?ne?je?w^X?wL?Gˏ?G?5?:?.?ϗ)??????X?X̪e?(4t?(0B?L??HSz\?c*,?_m?{?v?hz?h|?86?8N#??Ji?
??Z?6?y}Ǟ?x4J
?Iӡb?I,?*?&/??|?;r/?TMg?P8?h?dT(?Y|W?Yxd1?){.?)1???ɷSX?ɳ
md?]z?V?i&?iu?9J.?9e8?
?	f??^?%]"?!ue?z7AD?z2	?JH?JD;
?Yɭ?U;^?j?,E?eX?zj?vi?ꊊ7?ꊆ6?Z՗?Zޢ?*ݜ?*<.?B???#?N?†?jV?jlM?:??:^?E0{?
?+%?$c?|?$?{,4?{'볳?K9V2?K5vT?F8?A?R?Nۦ?_7?Zӱ?kT?g?[w1Do?[rc?+̺?+~?&??˙@	?˔?曤T8?曟O	?k;h?kg?1?;0?;=?_?t??ȥ?ր?8:?{Ң_?{ۊ?K?KYW??jq?AVn???G"v?
/?T(?\hi?\ m?,?,:3?!<?O\?(F0?#/?/?*A?l5?l1N?<;?<7d?A5q?=ڥ?G.?C_?M+J?HJo?|RnJ?|N'f?LWq@?LS*qU?\3?W?`?\m?d}0?`a/?hPN?d=D?\le?\hmZ?,p2?,k?spN?o).?vm?r&߽?y*?t4?l{V?lw_/!?<}=??<:?8\.?4v ?2W?.H?٬+-?٬'mk?|$͐+?| ?LԖ?LbLr?A???
U'?ؼw]?ؼn
)?؋k?؋G}?[$x8?[?+|v?+712?G?N?k|z?&<,?כ?כͽb6?kYȟ?kH?;px?;+R?F?u?۩ܶ?ۥt?֫2O?֫E`?{H^?{\?K*?K2?}#?yn4?r/?mI0?ջf?ջaL?ՋYn?ՋU?[M_?[IBi?+@w?+<?3n?/D?&ŵ8?"?ԛZa?ԛ?k/?kj?:?:gL?
P?
T5?-9r??Ӫҁ?Ӫ=]7?zÖ?zR0?Jj5?J&y}?h?h?O?=?ҺY?Һi?Ҋu#?Ҋp߄.?Zd?Z`in1?*S?*OB?C0i?1ɚ?-y?њ R`?њ?j9?j
W*?9
?9`?	la?	(d??ӱ/?Щ=f?Щ|?yEp?y?IW)?I~8??SE?wKw?s?Ϲc?Ϲ_?ωO?ωKla?Y;8E?Y6?)&?)"=?5t?Zׯ?Vlb?R?Ƅ`O?Ƅ\
?T?ޢ?T;?$-?$
v?>?&Q??̳*?œC:?œ]j?c'?cX2?3xY?3s/?UG?Q?3h!?/&m0?ģ_?ģy?rϨ?rk?Bʤ_?Bbŭ?9f?ս?⃎?M`?ò_?ò[d&q?Â;|u?Â7;U?RP?R=?!k=?!*.?̈́?Bo?]?=?‘n?‘~?a]Rl?aY,?17m?13,?Jt?
	G?
^??DV??pcc?p"Q?@vBp?@rgB?Nd?JdA?'C@?#'?dʰ?#]?Gk?P?O?O?N?
n?]s?Y2?濿4Y?濿06?濏=?濏?^h"?^'r?.?.P,?z/8?9?c$0?^a?澞88?澞4P?n
-?漼|?漌S?漌Oy?\&my?\"-Y?+?+fK?ʡ?a?˜]??˘?滛mڳK?滛i?k??k:?;?;؝~?
?
ܙ#?ڱU?ڭ?溪ԫ?溪}O?zQ'?zMH?J!C?J??&??黽?湹?湹?湉]ф?湉Yz9m?Y,9?Y'?(z1?(;2?|[?=rL?Ȗ?B?Ȓ]6?渘c?渘_?h1	Z?h,uS?7Jx?7s?5?Ƙ~?חa-H?ד!J?淧c6?淧_k?w/U?w+w ?FJ[?FDe?B?ѦO?_*? ;?涶]p=1?涶Y1,E?涆(A?涆$?UԱ?U?%(?%?>'b?:?Q|?L?浕XT?浕n}{?d
?d4?4!?4?u
?qM?>?:\?洤x?洤ܲ?s"?s}?C {?C?^?Za?&\?!?泲+{?泲O?泂K?泂A?Rz?Rv~P?"A'@?"<1?Tx??B$?t?沑b?沑8?aXb?aT$d0?1\?1W$?ְ?K!?Ч?^Z?У7?池k׬?池gx&?p/?p+a??@??|?K?i?{%3?v9?氯>e6?氯:'F)?fh?~)?N*?N>&?P?q2?H4?Dh?毾
?毾p?母Z?母ȋ?]U?]v?-OO?-Ke??um?рn?C/?殜
b?殜̄(?lRU?lN~p?<a3?<$I?0U?+?ۑ?ۍ?歫Q?歫L?{$b?{u?JQ?Jʼ??R?K?G?欺
T?欺P?欉ݳ?欉à?Yzc?Y=ij?)Bd?)>L?!j?}?ȼ1?ȸ+%?櫘y,?櫘uC/?h5cP?h1ot?7
?7??F?ie?ef?檧%G?檧 ӹ?v?ٱ?v?F1d?FS?Uř?Q?X??橵ʏs?橵R?橅?橅Km?U>B?U:	%?$T1?$̟?X??i?eJ0?樔"+?樔2?cEڜ?c	w%?3?3PE7?K^n?GY
?`?#2?槢ۼ?槢_?rr;?rmd?B)L?B%o[??o?ᖴb?x!?榱M?榱H?榁%}?榀te?PC?PC? n? jb|?#L?^?楿!?楿?楏??楏c?_B!`?_>qNX?.g,?梊z'Y?梊>?Zl<}?Zh;#?*z#?*@??&?}ȭ?xԡ:?桙,ڴ?桙([?hgȈ?h,&?8-?8|!8?:Ȟh?6?霳?a?栧31?栧?wF8?wBP?Fl?Fk?最X?PKm?P?@?(:?V1r?Rw"?曾r?曾?曎!+5?曎-?^NbN?^Jn?-3S?-bH??/?E!q?@&L?暜޶?暜?l4?lx$?<9˕?<4
?MV?-Z?ۅ??ہQ?晫*R?晫&j?zl?z2i?Ju?JqmE?3?jZi?c?*??昹c0?昹_i|?昉,k?昉V?X5iB?X?(Po?(K
??Vxi?ǖ5?ǒ?旗9?旗5t?f͜?fؔf_?6h2?6{/W?!7???տh?斥eD?斥a2S?ub3?u)*?D?Du?I?E r?>?'*?敳p??敳76?敃+?敃'?R?R?"ko?"gQ?7?sv?"U??攑J[?攑F#?`W|,?`r?0?07?&?"_ku??h?擟b5?擟^?o?nv=?>^?;?7U:?ؠb?h?播uwb?播q?
?}7?}
?Lm?L5Z?J?FU^?p$?8j?摻^?摻}6?摋2?摋G?Z??Zs*?*SfV?*ObZe?L??Ɉe?Ʉ?搙"?搙?h'?hf?8V?8R}?7|??׉}FJ?ׅEy?揧"m?揧Ns?vRg?v?FS᧞?FO(?4|?}?J3&??掵#?掵N?掄F?掄8?TK2?TF%?#C?#{?y* ?t???捒A;?捒	?b|?拮yf?拮uNaQ?~
Y?~	"?MQ?M?4K?0?i?2?押ZK?押VF?抋Ug?抋趆:?[Ld?[{.F?+p,?+
9o?V? ?5V%?0ɫ/?扙mk?扙6?iW2?iSgY?8%V?8[?yIv?u:?	ā??戧?戧?w*c?w%?F?F?IRp?EM?؞?hcq?懵g$?懵cxL?懄?懄K{\?T?T?$sV)?$=)?B?[?/s>?+=$?憒?憒?bJ?bFK?1׮l	?1xm$?d5?`h_?R??慠}ʗ?慠y
?p
,?pR>??_??F?!?)&?ޭNs?ީ]?愮8~?愮4b&?}æ^?}p?MNxe?MJBb?
?A?cfb?_1\1?惻V?惻N͛?惋weM?惋s0;?[
N?Z2K?*sSI?eV?kq?ɜ?ɘ[?悙%E@~?悙!?h[?h?85b?81B?D?ͮ?ER?A$q?恦F?恦p??vT?vP]?Eۣ4?Em?bwH?^B>?M?ڰ?怴ok۬?怴k6?怃:?怃WK?S{p|?Sw<u?#?"?-O?QYh?B ?wI?ű?w?ad%?a0)o?0	#?0Y}?#q?s?~Ϣ(]?~ϝ?~%|?~!{?~n{I?~nF?~>,>?~>(?~
?~
o?}2?}.m'b?}6*?}?}|7?}|3Z?}Ky?}Kw$?};@L?}7W]?|1 ?|?|>E?|:eSx?|?|?|Y@A?|Y<&?|(ko?|(7?{As?{=?{!?{ǽ}?{B"g?{=?{fv?{f|?{6Ar
(?{6=>?{v?{?z?Q?z;r|?z|?zs?zt=A?zt9
?zC?zCl2?z9¼?z5?yⷩv.?yuc?y5Tpx?y1 ?y?y50?yQ/?yQ+}?y ??y ?x)N[?x^{l?x^H?x.HĶ?x.d?w?w?w1?w?wLQ?w]?wl,m?wl1?w;Б?w;}_?w
86?w
y?vve?vr2_c?vVt?v#?vyj"W?llOՌ?llK__?l;?l;v?l)?l%ߘ?kږZ?kڒs?k?kg?kyo]p?kyk,]?kHa\?kH0^?kG*?kB?j粸?j箇?jB?j?j#>?j?jUҮ?jU	?j%^t?j%Zr?i}?i\?i37,?i/?i)?i?icS?ic?i2p\j?i2l+ש?iٝغ?imN?hBYB?h>sX?hp:?h?e?hpY?hp.?h?|Wui?h?x'?hrr?hB|?gLS?gH#[g?gլ?gɋD?g}d?g}4r?gL?gL~e?g鋧p?gI?fPG?L?fL;?f?f?f
?f?fY`?fY~U??f(h?f(߯?eNr[?eJB?edz#?eǯ?e|?e?ef}?efy?e5Z8?e5*?eFi?eB?dԪ=X?dԦ{;?d`Y?d
R?dsr?dsne'?dB?dB?d9Qj?d5"W?cX?c)?c$?cye?ca?c]?cOL?cOӐ?c&&?c!`?b?b?b魯l?b~QG?bKI?bF;?b\I?b\?b,
@8?b,	HY?am?a.d?a*?ai6?ai̳?a8^?a8r?aN8.?aJ	?`׭mb?`שfj%?`?`?`vk&?`vgp?`EL0?`E9?`(x?`$?_?_?_?_$?_B^?_>8?_RB"1?_Rg?_!?_!a?^Z4?^Vv2?^~8?^PD?^5?^?^_p?^_lU!?^.̮?^.Ȁ?](?]$p?]̈́U?]̀'	?]?]ۣ?]l;@?]l6T?];X?];?]
胸?]
6V?\K{k?\GM'?\Y?\m?\xQF?\x,?\HYס]?\HUx[?\߮?\S?[4?[?[f(?[a5?[$?[
?[U?[U"?[$pmJ?[$l??ZȻv?Zč5?Z ?ZD?Zxb?Ztz=?ZaGxx?Zak?Z1'?Z1#/?Z~p?Zz?YռJ3?Yюq?Y,jx?Y(.?Y=ꦷ?Y
/1?Y
*?X܄n?X܀X)?Xh/?X:?X{/R?X{+߬?XJ"?XJ)?X٬y?X?W.O'?W*!W?WN^?W~?W͈?WҸ?WW*[?WW&?W&~1?W&zf?V?V?V%ZO?V!-.?Vxe?Vt8د?Vc7?Vc
?V3ύ?V3?Vp-?Vl?UP?UѾ#?U:"?U
Ȏ?Upe?Upa_?U?`?U?3?U{?Uo?TYur?TUqF?Tf?T:?T|o?T|_w?TLKIS?TLG?Tc??T7N{?SDɂ?S0?S:v?S6??SX?S,+W?SXٌ?SX_?S((.?S($X?RwD?Rs2~?Rʇ?R%?R:?R?Reb(u?Re]D?R4R?R4K?R.?Rs?QKR?QF
?Q0b?Q?Qq!H?Qq?QA1?QA-T?Q~X?Qz,?Pʝ`?PqY?P?P|?P~bz;?P~^N'o?PM&?PMv?Pp6?PDT?OD5?O@i\C?Oc?OT?O1?O?OZ$2?OZ ~t?O)n?O)jr?N?N?Nb?N?NLKi?NH?Nf?NfxtY?N5æ?N5ژ?N'/2?N#}?MpQ%%?Ml%?MD?M؂?Ms\?Mrx?MBHJ5?MBD:?M\?Mt?L"7?Ls?Ll?LA?Lf}t#?LbR>?LNSl?LN(?L'?LA?K:T}?K6)E?K~e?K|ST?KnU?KCT?K[%?K[?K*Q'?K*Mx1?J-M?J@?J{?J?J ±?JY?JgeZ]9?Jga/?J6?J6i?J
?JK?I1ȂH?I-F?Iuz[?IqOu?Is6j?IsȒ?IB2W?IB?I?8?I;
?H?H}E\?Hė"?Hmc?H?H1u?HOI?HOD粖?Hs?H?Ģ;&?G|B?G?G	q"?GOW3F?GK,?G[Y?G[/u?G*"~?G*`?Fm?F
@[?FR	L?FM?F&4(?F?Fg
t8?Fgb=?F7p?F7
?FQ'?FL?EՐ`?EՌ6&?E_?E5g?Et&p?Et	?ECL,?ECH?E-?EZ?D#d?D?D`?Dn?DD,|?D@u?DOX?DO}2?DV(?D,?CTp?C+L?C9?C4UI?CuL?Cq|^?C[ZJ??[q"??[lb#??*k??*C8?>ߘO?>pM?>K?>dn?>MHvN?>I"?>gu?>gYh?>6_?>6(r?>%<?>8?=%ո?=!^	?=[7?=Wse?=sj?=s?=B/?=B]z?=$?=B?>?:fj?:5C?:5yv?:,Oed?:('*?9]4?9YY?9y|?9R?9r:f?9r^?9A.?9Agt?9 ?9
k?8P(O
?8Lđ?8Ƅ?8{E+?8~/?8~g?8M?8M#m?8Os?8
({?7=Lގ?79%?7l?7gX?7)?7u͒?7Y?7Yɕ?7(?7(丌?6$?6 ǂ?6RBB?6Nr-?66?6{A?6eE-?6e?64Fe?64?6?6?53+?5/y?5_?5[R?5q?5q?5@?5@?5㝙m?5v~?4Q?4
?4:C?46K=?4}eAc?4}a?4Lx?4L=?4=?4mr?3t?3tL?3mk?3
d?38'?34A?3Xb?3X^n?3'?3'\&?2C?2Q?2F?2 OD?2&?2ɴ?2d/a?2d+}?23WD
?23S?2/?2{U?1Ѩ?1ѣ?1ϹxL?1˓H?1o2p?1oJ/?1?sJ?1?M-V?1E|
?1AUR?0lLH?0h&=?0t?0r?0{D=?0{q?0Jl{?0JF(?0[(?05?/+ʆ?/&!?/Po?/Lm?/uԖ?/q	u?/VhW?/VĦX?/%?/%?.`ƭ?.;?.L?.^?.,?.(V?.bP޾?.bLJj?.1t5k?.1p:?.4l?.z?-ϻ$?-Ϸ^38?-ޚԂ?-ud?-ny?-mT_7?-=$!7?-=Z?-F?-Bkn?,h?,de?,ǥ|?,c`?,y?,yj[?,HB?,H8?,wA?,R_?+?+rG?+1 ?+-[?+R0?+N5?+Tr0?+Tn?+#꠲?+#ŧ?*
?*(?*R?*Πk]?*_
J?*:/?*`?*`
#K?*/0?*/,?)OBK?)K?)n??)jt?)^?)t?)kh ?)kCyT?):x?):Sz?)	LC?)	'/?([?(ϴ?("La?('߲?(w?y?(w;T?(F\m?(FXIE?(y*z?(u=?'䕯?'䑋L?'s?'
?'t?'A?'Q?'QFi?'!)?'!p?&!&?&?&<90?&8^?&W8"?&S?&]qM?&]m8?&,z?&,j?%!?%?%r?%ʼT?%
?%
?%hQ?%hzj=?%8m?%8	7?%'X-?%#5?$@b1?$<>?$Y4?$U?$tqmS?$tm4?$C2v?$CƱ?$]b?$:?#Q˜?#.-?#q?#?#?#oj-?#Ou?#N?#m?#ҜO?".gY?"*`?"E{c?"AXP?"[?"WDZh?"Zr#%?"Zm?")#?")l?!3?!l?!dz3?!ǯ[y?!?!Ķ?!e?!e-?!4?!4wC?!Z?!zFZ? qB? e? 0`G? ,=EF? qDn? q@K? @XF C? @T#0R? kN? gg?OMz?{,o?J?]?|z?|X*8?K=?K?ɤ?Ʀ?c=?S?<
?c?"W??Wq?W=?&$I
?& &?5e?1g?F$`?BqY?WfK?SDtj?bhbF?bc?1xg1a?1tD?½?nnN?Ϙ~?ϔ\?5W?4?mĎ?m?<?Ԧ?˱I?p*?N?ijho?iH?8-'N?8?่?ܘ"E?"??-P??t?tr?DO?D?>\??̤?`
?$}? l
?-b?)AV?O6?O1?>hw?:Gl?F^?Bw?Nz?Jq?VU?R4@?Z]᠏?ZY4?)e6?)a?lU?h4?s=n?oՋ?yۺ?u?ei0?e|Hx?4.?4^?1??Ғy?Ҏoܷ?03??pp?px??|u???~??ݬs-?ݨl?Z?/?{r?{RL?J7?Js]?L?^˚?3@??ı?-?`?Y(?U?Uֿ?$:?$?ЇF?g2V?:?К? ??`?`?/[?/Թl?dF?D5S?۸?ט??ض1V?kݼ?kٝ%y?:m?:MN?	T?	ǜ?*֎?'?7??v
?v?Eޭ?EڍR?QA??
H?
)?
D%?
%(?
?
?
P٘?
PyS?
\G?
?l?D??߯O?ѴN ?͕
?[3ns?[6?*{?*\}?ɍ?n?ia?JD???f}d?f^Q?5v?5?]??
ӳ?
ӯe??
'?
?
qz2?
q[.?
@u?
@?
?
w?	ޛSG?	ޗ4?	ٔ?	8?	|*0?	|?	KD'H?	K%?	'j?		JO?}Օ?y?wL=?s.Ew?pk?lo?ViF?Ve{E?%bnO?%^PZ	?[?V?Sw=?OXK?K?GN?aCQ?a??0;m?07O?2I?.Y?*X.?&:?!}u?2?.*?z?xE?t?`ǏQ?\?nH\s?nD@?=/V?=+???O?F?`?e%?x}?x-T?GO[?G4?f?KW?}Hs?y-??b?^٭P?Hl?DPu?R-~?R)P?!?!??v ?22???p?\ʶ?\o?+5?+S?lK?ha?P:?L E?3s?/?gR?g?5:?51	?܂?hC?ӿD?Ӻ;q?g?M\?q]?qo6?@ew3?@a\?G/	?C?()?ߪ,<ǒ?ߪ(%?x
?x4b?Gf^?GP?;?z??]?Y
?޴)1?޴%R?ނG`;?ނ0?Q-?QU? s ? ?W?Rm?ݾ!?ݾS
?݌쉍?݌s?[?[H?*6R?*} +?K>?G(?t
?!)?ܖ޳zy?ܖڝ0?eF?e?4qW-?4m@?:[?6D?*H?h?۠WS?۠ǰ;?o.D?o2?>\aH?>XK?
$a}?
 K}n?-? 3?ڪij?ڪ,?y{(W?yws,?HBX)j?H>BN'?	Sî?=?p~??ٴ?ٴ_?ك]WT?كX?R#;R?R%? 3E? 9?t?^?ؾt2?ؾpr?؍9#:?؍5Ϛ?[
N?[)?*?*??u?MQ4?I;?ח8?ח
?e?eѻq?4V?4?]?Yk?!?[?֠b}?֠Mb?o}?opiM?>juO?>f`5!?
-1?
)?#Z??ժ
?ժʒ?yt.?yp?H6?H2?0?M?Z?F?Դz?Դv'H?ԃ;?ԃ7&?Q?Q>0? nm? YT?}y?y$?Ӿ>CW?Ӿ:.?ӌ`S?ӌK;?[F?[2?*}|?*y?=p?9\??b?ҖK ?Җ?ezt?ev?49W2?45C?И?I:?Ѷ?Ѳ?Ѡt'?Ѡpj?o2?o-S?=?=K?'$??jj8?fV ?Ъ'y?Ъ#e?xV`?xBZ?GS?G?]s?Y`?.??ϳ?ϳѰ?ς?ς
Q?QMF$?QI2O? !? ??[?ν?νzP?Ό9cW?Ό5̹?Z_?ZrX?)B?)?i8?e%	?#Dr?1M?͕e?͕	v?d¦?d4P?3P4(?3L!1?	si6?`	@??оk?̟{W~I?̟wD0?n3c?n/?Ӻ`?Ű?ŰvP???NW3ܰ?NS!V?=R?+k???ĺi(?ĺew?ĉ'Z?ĉM?Wd?WRτ?&znn?&v]8d?*F;?&4A?I??Ò\q?ÒJo?a8eh?a4??/S?/?aF?n?E&q?A?›?›?jR?j?9O,?9K4?[?	?֫k6?֧Y?Xp?T/?t#
?tӹ?B2?B!t@?`?[×?UE?9?1v? d?}ev?}ae?L@?L
w?hC?WM?i}?e?忸Z?忸~d?忆h(?忆ƍk?Uje?Uf۔Z?$?$)?~?n.?j\p?f릗?徐G4?徐6r?^_?^Nsv?-iDҞ?-e48q??9?ʼxH?ʸg
?彙e-?彙a?h៥?h
*]?6ű?6Y?`]?\p?	(?W?弢V?弢FJ?qYv_?qUfy?@c*??R?W?
"?P/?LX?廫?廫v?z6?z?IFJ?IA:1??K?Y?I?庵9R?庵5^?広???媲z?媲v"?媁U?媁?OYJ?OLgb?;؝?7v?"1?H?婻f=?婻b0K/?婉%?婉~?Xܵi?X7?'$bJ?' U?"?4?Lc?H?娒?娒ܼ]?at+?ap{+?0?0	I?qM?e/?.JD?*?姛LJ?姛@?jT]?jPP0?8C?8?yW?uK?`?#?妤r?妤?s/]ZB?s+Q/?A?AX?Rj??N^'??ߚ?奭tD?奭p?|qR?|t?J3Ƥ?J'?&?"??X?夶G?夶B!?处?处N?Sfs?Sb?!U?!
?g0?\>?壿?壿yu?壍r?壍fc?\2-?\."?*2?*
?O^?K#?8L?-.O?墖k/&4?墖g#v?d?daH?3Rz?3}9?@??Сߴ?Н	?塟.?塟*?mE?m?@?>?
u	?
pf?JZ?@Z?嚪]?嚪}S1?y?x?y5?G7?GR?r?h3?y?䓸?噳x?噳4?噁^?噁ş?P&?P"@?Ǭ?
?/u?+lT{?嘻#P?嘻2?嘊7;?嘊3$]?Xeӽ?X\L?'>?':W?g>?]!?E?A?嗒Ȧd?嗒Ĝ?aK|}?aGs$z?/"s?/"?P
?L/?>??喛T?喛Pq?iG?i.?8X?8T}?	:?"?[Z"?WQ?啣x7?啣o"?r]b?rYY?@$?@?^I?Z_1?AC?`1?唬_$w?唬[?z6?z٦?I^?IZ?w*>?nn0?]J!?YӗT?哴p?哴?哃\#>?哃X?Q(?Qޑ? Y? UR?P??咽V=?咽R4?咋M6?咋E2?ZR.?ZN%?(?(Ս?M]3?ITz?ʬ	?ƣ?呔GO?呔C?bĸN?b(?1Au?1=mql?,?l5?:_I@?6W*?吜?吜k ?k2=?k.1?9R:?9JK?)W?%^?֥W?厭&^?{l?{?Jy]
?Juض??c?mJ?i,s?卵vY?卵oE?卄_yv?卄[#?Rؔ?Rԍ?!QZf?!MS?x??匾BW?匾>P`G?匌?匌X?[2$?[.g`?)i?)bJM?"^?'?ƙ?ƕ}?動?動Ûe?c?c?1Ŭp?1c?凄*?S!
$?S=/?!25?!?	?h?冾yE?冾u??册뤝?册i?[][?[Y1?)d?)?A?=?Ƴ??Ư9?兕$?兕 ?c?c粜?2	?2v?w#?s9?EZ?d?儝Y
j?儝U(?kZ?kT?:9z?:5t?k1?ev?+b?%1?僥*#?僥6?s?sz^?BgN?BcHu9?O$?I?E ?A)?傭‡?傭?|"4)?|/f?Jw<2?Jq#?&?X[?ll?hg]?偵,?偵?偄G?偄CP?R?Re?!"B?!??u?倽?倽ݨ?倌hk?倌dfx?Zњ?Z̏|?)Ar?)=U??	2??/?Z?4?bT?bJ?1[O:?1WJu?~iG,?~d|?~1S%?~-Nc?~
{?~?~k?~k?~9pMY?~9l?~ #?~?}E
(?}AwF?}{?}p?}s5Z?}s?}Au?}A},c?}5?}18?|TB]?|P=\?|?|R?|{%DZ?|{!`?|IB?|I>y+?|?|M?{^?{Z[?{Ɨ3?{“L?{.Te?{*P?{Q^?{Q?{AQ?{=@?zdp?z`l?zp>?zl@?z2@9c?z.Z?ya;!?y/?y/?xbK?x^6?x??x<?x,6?x(3"?xio?xi?x7?x76?xYR?xUo?wԾ9?wԺ6Iy?w"Dvx?wAN?wq >?wq?w?Ԩ?w?}
?wMI%?wIF?vܰ[?vܬeJ?vn?v?vyvG?vyr?vGg~?vGcA?v;?v7c?uZ?uWd?uϵ?uK?ub"?u^?uOg?uOd?u&
#?u"
28?t쇄*t?t상B%?t,8?tM0?tI6?tEu?tW?tW8?t&?t&/?sl?shJ	?ss!?spq?s,O?s(#?s_n?s_В?s-pA?q={?q=}s?qL?qJZ?p[?pW蜜?pY(?pW?pwA?pw.?pEsc?pEo?p`?p}`-?o--?o)+	q?o?o.?o~و?o~?oMBM?oM>?o9?o
E?n?n-?nUg?>?nQe?n5'?n
?nU(?nU4S?n#gM?n#c
+?mGV?m?m$?m3'?mws?ms
?m\X?m\W(N?m++wo?m+'uJ?lf?le&?l'?l&+?l8?l4l?ld`?d>a?dq?d?c;X?c7XԆ?cm?c@?cwݔW?cwٔgt?cF.l;?cF*lw?c?c{`H?bϑ?b˒F?bW?b߄?bo_?bk&?bM~?bM?b!?b?a_Fmp?a[G?a?a[?a?aՃ?aUL?aUH?a#ʼ8?a#ˆ?`xS?`y'?`8?`45?`I?`Jq?`\lN?`\m
?`+#a8?`+bA?_q);?_m*?_Ǿ?_ǺX?_,!?_-
?_dYiW?_dUjv?_2w\?_2y?_X
?_Y?^@O?^<b?^f?^?^k'?^kG?^:%?^:!?^q
):?^mx?]ּɃ?]ָ2?]u?]w5?]sSq?]sO?]A)^D?]A*?]>'2?]??\5%W?\1&?\ލ~?\{-?\zjS?\zk??\Iǝ?\IP?\^,?\Z]X?[sP?[8?[9?[^?[]~?Y@1?Y?Y=?Y_Z?Y_V0?Y-K?Y-MeY?X?Xh`?X0?X,p?Xwb:?Xsų?XfA?Xf?X5%?X5'&?XK?XG:X?Wё?Wэk?W1?W?Wn"?Wn˰b?W+C?I>'H?Id1?I`*?Hڜr?Hژ*N?H!?HuK?Hw
> L?Hw	C?HEELY?HEAQʄ?H}-?Hy3@?G'$?G窈?Gi?GoNx?G~#V^?G~`?GLZ
?GLVg?Gz?G#u?Fv?F(?Fmz?Fs5N?F5?F1nV?FSl4~?FSh:X?F!U6?F![
?EH?EN:?E{0?E
d?ECU?E?H?EZyp?EZum?E(V?E(\^?Dj?Dp?DPa?DV?DM
?DIب?Da$R?Da}OB?D/s?D/ֲ?C,?C2n?C3v?C9S?CR?CNf?Ch>?Ch?C6??6??jW~??fk3??R;??R@?? ʛ~P?? Ƣ?>H?>P#+?>).?>%
#?>Y?>U2$?>Y9w?>YA	?>'/?>'7,?=r?=?=)?=?=Ch>?=??=`qK^?=`mR?=.c?=.j??6^{?6,p?6,xq?5#)k?5,?5ԏ?5?5š?5
h?5eE3?5eA?1NTQ ?1NP[q?1wd?1s\?0{e?0I?0?0x?0?0?0U
?0Tq?0#&?0#"!u?/Ht*?/D~(?/jO/?/fU?/"?/?/[m?/[?/)2
?/)<,v?.O?.{?.
W?.?.45?.0?M?.bU4?.bQ>]?.0v	?.0rZ?-tC?-Ι?-̷*?-̳4y:?-z4#?-ӄ?-hL?-h-?-7
?-7?-7d?-3n?,Ww?,S	?,v{N?,r?,oP?,o?,=?,=?,6?,E?+N?+[6?+:X?+
E"?+v/R?+v+?+DM6?+DI?+l?+h?*?*b?*N;?*G?*|O?*|Z?*JSb?*J^?*FW?*[-?)n?).?)9ut?)6?)V6?)R,?)QsHE?)QoS?)X?)~?(l>?(
?(pj?(Ɗ?($?('?(WI;?(W?(&&?(&1t?'6v8?'2?'Q?'M+v?'lTk?'h?'^?'^/?',aN?',l
?&B?&?&I?&U2?&},?&?&e?&ee?&3%b?&3!nA?&?g?&; @Z?%XW?%T9?%q?%mY?%kB?%k%7w?%9?%9$?%H?%P?$Ֆ?$Ѣj?$?$?$rew?$rq?$@ ?$@?$6?$2?#NY1?#Jeq?#e?#b
ۢ?#x}xk	?#xy	?#FC"?#FӞw?#y?#@"?"7B?"@?"ٰ{5?"ռ?"~R?"~_	?"Mc?"M?"R)?"!z?!35e?!/B?!I+Z?!E8RU?!^@??![?!St?!SpHw?!!	?!!? S7? `? qu	? ~I? dYa? q7Z? Y,Lj? Y93? 'r? 'c{?;I?HC?|\??/?+u?`C?`?
?.WUH?.Sb?j??f?~`?zn-?[j??f?f
?4GO?4G?t>?Ƃ0?`?M?}#?늍?m%?lΘ?;G?;Ď?	%ȯ?	!5|?7?3?I$?E2L?sZ?sV<?Akm?Ag.?|^?xm?ݍ9?݉??L?y5.?yC?Go?Gl???jM?V?y?o??
?ND?NR?u?v?-?*87?=έ?9Z?KO?H-R?TZ1?TVL?"iLU?"eZZ?w;L?s…S??5?k??ZR?:?EJ?A&b?ZM?ZI?(S?(P?Zb?VZD?aSP?]cQ?g?c1?`n
?`j?.t+t`?.p;h?z?v/Ah??{Ռ??/?ft?f
?4H?4Y
q?i?z?
КaH?
Жqe?
-?
>Rv?
lЧ?
l,?
:I`?
:YO?
w$?
Ok?
~e7s?
~v4?
La?
Ls>?
4̸?
Eܶ?	݆?	?	\q,?	m?	ݱn?	š?	R܀u?	R?	 ݊:?	 ?m6?ŵI?aj?r?ի?0p?X=?XOa?&mS?&~?r?ބa?NA?`6i?p?x?^ሣ?^ݚ5?,ʘ?,f??,C?%I?6???dܼ?dL&?2Ir?2[d?٭?վ!??k???&?j܈?jxt?8ј?8ͪ?+{?=~?̔*?Ȧ??z?p?p?>ս(?>???ڽ0?ڹB??B?v1?vZ?D?D3=?H?`?੻I?,?Z5?m5r?|D?|?JM?J.?>?Q,?7?J3?_?]???P);?P~?*:$?*6@z?37?/K?+=?'l.?#!?Y>?bЂ?b?0"3?0l?f
?z??U?WX?k8?g?g?5/?5䶨?ߊl?۞?H?\e?r?D?mI
o?m\?;!)?;
?	?	?ץ*?סW?Y?mi?sz2?s
G?Ajv?A}?{U?w5?pդ?l?e͊?a}z?yZ?yV.?GOAp?GKU?C??ћ?8+?4$P?,:cd?(N? :.?N	?MDd?M&x????FQ?Z?xr?Ⱥ?ջ?{?Ry5?R5? ǿ? bK?w?P?d?0?k/?_?XX>?X?&??&dd?u-H?q?gg?c|?Y?UH?^Jo?^F?,;?,7m?,I?(?з?ݭ]??
y?c7b?cLQ?1?1?~??)ж?>(?)/p?>D>?ig?i>?7?7?1v?FX?~	?zD&?m??ia?o\z?oXǐ?=K?=G?:N/?6c?(؏?$?:Bb?O?urȮ?uDq?BD?B
c?ic?~?&??Sb;?!p:?!#?)B???[¼?q_?dp?|{-p?YkE^m?Yg[?'U?'Rh?@[?D?:N	?$@? X.?N	n(?Nw?r?S?N?e?淸6?淴?慜5?慘P/?S?S}?!e'?!a?lj?I9{?EQN?-#?):5?$?
w?X|8?Xg?&@n?&8?5r[?MtF?žU?šmB?䐁MoS?}e?^dr?^`5y?,F~O?,Bܥ?)C?%\?s?3??I?c?c$?1r?1/?f?~pt?tr?qۨ?VZf?RsO?i73
?i3?7v?7?iP??cO?{?ᠻ{?ᠷ1?nwG.?n?<{?D~ ?D0??k?gU?B ?>q?ծ#?ծm'?{\?{?IǸ~?In?b?}?t|X?q~?ԳK@l?ԳG[S?ԁ!t^?ԁs?N?Na?f?Ɂ*?#zU?>?Ӹx?ӸtՋ?ӆN(?ӆJC?T#p$?Tq?!0P?!??͉N?ɤr?ҽZjr?ҽu#?ҋw}d?ҋsv?YKn?YGf?'l?'@?U?2?$*?@K?ѐ
W?ѐ%?^o	@?^k䴙?,C`j8?,?|?\ ??ʴ3
?ʴ/U?ʂ3?ʁP{v?On;?Ő8???ln?hk?ɹ:4?ɹ6Q'?ɇӸP?ɇ?TK4?Th9?"F?"?oJ?k䉊?Ⱦ?S[9?!:L	?XO?ğ`?ğ-˧?m(?mܴ?;~G/?;zeO?	G?	C-?c?
7?ä}|?ä?r)?ro ?@k?@g?4Nc?0l"?ȕ?o?©Od?©:?wIF?whI?EUP?EQo?0m?Op??	O?|??|s
?|p?J;'i?J7F?B?a[?8)?V?U?%`?VL?Rͫ?O0~?OOZ?㋱?ߪ?ꩿR??俸o(?俸k&?俆5?俆1ԏ^?Svn?Sx?!
:?!0c?D?bZ?侽K?侽G&?例_d?例
?Xe?X?&մ`?&}?_?[M?$[? 6?住~P?住?]?]?+px?+l?4Ν?0??g?伔DG`?伔c՟?b\?b{h?0C!?0?@?U?uv?d8?ńw?仙M9?仙l?gOn?gK/I?5_?5
/?!V?A/?Жp?ВX?亞XV?亞TC?l?ls?9z\?9ؚO?1$?Q|?_?[?乣!-(?乣MJ?prM?pޒr?>8?>#?d?`>H?%[%?!{f?丧@?丧'iZ?u?ujU?Cf0?Cc
?'',?#G?;P?[F?䷬(?䷬It?zf?zc?H&?H"??/?dD?㡅d?䶱d?䶱`?#k??L|?LޣQ?A/l?a?_1?[?䵶K?䵶l?䵃ܘ?䵃ظ?Qn?QW?Xg?TҜ?o?k?䴺D	?䴺e	?䴈ΰw?䴈?VO3GG?VKT`?$r?$>?Ɋ?Ŭ~?䳿~,?䳿a?䳍CKl?䳍?ln?Z?Z?(t)?(z?xό?t(?5A?1&?䲑?䲑6x?_˱?_ Bs?-h^?-dF?$a? ?v?	?䱖+>?䱖M?dVX=?dRzw?2_?2
j!?@?by?͆1?̓q?䰛A?䰛=?h?h#¿?6Ln?2?1!l?Tm?u?qk?䥛(?䥛$:?hR?huP?6gv?6?>X,?:|2?$#?H#?䤟t?䤟}s?mSKn?mOo۫?;?;?~??fi?c?䣤*?䣤*?qȤ?q??yG$9??ukn?
)]o?
%豂??@?䢨O?䢨t'?v:]R?v6`?CF?Ck:?
?/{?Iֹ?Ec;?䡬$?䡬H?zy ?zs?HWV?HSg??ث?㵚K^?㱿?䠱d[4V?䠱`J?~?h?Lnރ?LG?o6?kb?"?w?䟵>@?䟵2?geo???m?䕮Ι?䕮m?|__?|[&?JO?J6{??;?R8?N_?䔲8J?䔲_B?䔀9?䔀:Eh?NC*?N??\7?W???h?䓷4۳?䓷0;
?䓄9N?䓄`5?R~:?Rza? #d? >?
2?d?䒻ld?䒻hw?䒉?䒉/T?Vw?VGf?$YFے?$UnX?J)~?qB?䑿)?䑿P?䑍D?䑍APa?Zz?Z䡿?(:?(F?/:?+bHq?dh?Ό( ?䐑ui~?䐑q*?_K?_sk?,?,0?]?YǏ???"?䏕h8?䏕?cD ?c@!?0O?0?x??*5̃?&]?䎙Ζ?䎙^?gmB?gij?5?5
+K?)?l?P?LX?䍝ړ?䍝0}?kj?k!?93?9/.r?~v?Ϧ?s?oM?䌢+?䌢)?oÍ?o5Q?=S[?=P?
?
XE?ؓW8X?؏?䋦2Ң*?䋦.VA?s*|?sR?Aq]z?AmA?l$?}?ܯX6?ܫ?䊪Nf?䊪JH?w,?w,?EB?Ek?)R?%Q???䉮e\?䉮bϣ?|ټ[?|?I,?I
J??N:?;wi?ҟ??䈲z3U?䈲v\C?䈀p?䈀K?MÕ?M?Q}?M>V?O?x?䇶?䇶&%:?䇄'l?䇄#Q?Qr?QL?`.?\X)`?M1f?vǎ?䆺G?䆺qR?䆈4T?䆈0HNS?U+(?Uݓ?#ka?#gr???䅾)?䅾?R?䅌=:?䅌9d?Y;?YeƘ?'s6?'oC!?
@?	?¨h6?¤?䄐Bۜ{?䁜:X?iZ?i.?7o֦?7kA~??0c?ҞUf?Қ?䀠6y?{Nc?{k?{7?z(^?z$?z?z?zOC?zKo?zRdX?zRޭU?z u?z q΋?yFJ?yJl?yg~-?y?y.ޔ?y*D?yV)?yVJ_?y$Sc?y$O>?xZl\?xᆟ?xwH?xsd?x	?x@?xZ_o?xZ?x(-b?x()G]?w/1?w?wP*4?wLV?w|?wݩQ$?w^r?w^n(?w,`?w+?vN?v?v%js?v!?vut?v;?vbF?vbBX?v/?v/Y?ug#,?ucP?u8?ue?u*m?uW?uf}?uf&Z?u3?u3ҁ\?u6."?u2[?tŔ?tF?tT?tQ"q?ti?ti$%?t7rI?t7o!_@?tҌ?t?sҐ?sҌ>?s?sGy?sm;v?smv?s;;?s;8K?sm?s3?rX+?rT=?r?r#D?rqs2?rqo?r?YP?r>F.?rŪ?rB?q2?q`5?qj~?qa?qu6j?qu2?qBr?qBn?qPB?qLpU}?p?p_?piz/?peЂ?px?px[?pF'?pF~T?pI*?p
wc?oIC?ow(?o&&?o"Tl?o|x?o|p?oJ=xW?oJ9X?orY?o}!?nT?~?nPmߵ?no?n۝?nj}?nf+0?nMg?nM^?n/?n|]?m
P?m?mXy.?m?m2?m0?mQ?mQ%`8?m4d?m0@?lbP?l9?lG?lDW?lѕ?l9W?lU['Mf?lUWU??l"*?l"?kmn?kj?k|[?k;'?k?k|Bf?kY>?kY'	?k&?k&
?j\3?jV?jډ?j	c?j+6'D?j'e?j\oA?j\.@?j*;?j*77?iz?i?iKLѝ?iG{?i?i*?i`Z$B?i`V@?i-짛?i-j?hi1R?hea.?hT?h&?hwUvc?hs?hc3?hcc?h1޲?h13?gc?gc?g̒?g̎0\?gU?gC?ggX?ggҾ?g5$H?g5 Bs?gp?g
?f0R&?f,Q1?f?f+?fk;f?fk7?f82?f8v?fF*?fBZvZ?eK?ez?ePIG?eLy*?en%SH?enU,b?e6?bވ/?bބ_j?b-Rd?b]?by	?by:=?bG,?bG_I?b[?bo?a?a?a&!?aV?a}XK?a}s?aJh,?aJP|?aW?a?`#Z?`TL?`!®?`~P?`V1?`?`N$0?`N ?`g?`2Z?_'$?_#U%?_%`?_VJ?_)?_%5?_Q?_QV?_*]&?_&-9?^f+?^v?^+.*?^'_2?^c?^~?^U+w?^U'?^"i?^"*?]+:Y?]'k]%?]
?]J?]*u?]&>?]X༜?]X?]&)*)?]&%[F?\P?\󤁅?\'Rm?\#*?\3oh?\dL?\\$A?\\!$;?\).?\)L?[")M?[<DŽ?[Ġe@?[Ĝ?[	?[΃#?[_?[_m?[-_?[-#?Zy%?Z?Z*{?Z\~Z?Zv?Z?Zc'=?Zc
Y'?Z0s?Z0N?Yw?YtM?Yˈ?Y˄?Y"?Y?YfRb?Yf~{?Y3#?Y3'?Y{w?Yw
?X?X
B?Xt?XpHv?Xi3?Xie*?X7l/;=?X7ha?X	M$?X;8?Wc?W_?WX_?WۋBV?WmZ\?WmWf?W:!$?W:TR?WQT??WM?Ve?VȗE?VGTez?VC?Vp"b?VpU	p?V><ε?V>9e?VY?VY?U1d?U-'?U&?U=>?Ut&12?Ut"d?UA7K?UAj+
?U^?UM?Tܓ݄c?Tܐv?T
~A?T	?Tw?Tw1?TE\
?TDɒ?Ty?Tu?S?SA?SkS>?Sg~?Sz@?Szt?SH]?/?SHYs?S?S	Y?RNK\c?RJ~?RƟ*t?R҄?R~>џ]?R~;?RK0?RK/?R.'??R+?Q榡?Q?QO7?QR?Q?Qy?QO
F?QO	z@?Q?Qč?Ph?P??PrV?Pn;?Pl?Pr?PR`k/?PR\?P ?P@?OM?OI>?OY?KV	?K[r?KW?KbPrP?Kb˅*?K0B?K0>?J?J/?J)?J%S{?J!?JV~{?JfT?Jf8G?J3Ğ?J3}9?Je?J?Ifp?Ict@?IBp?Ix	0?IiK?IiG?I6%?I6EO?I/'?I+P?Hѡt6?Hѝip?H.U?Hc?Hlǥ?Hlk?H9@J?H9u?Hg&;<2?>7s=?>-?>?>Φ?>?>Y|:?>Yyb!?>&_?>&p?=R,?=N?=oxv?=q?=(?=$>D7?=\}U?=\:?=)Ԓ?=)??8K?7o?7?7kB%!?7gzO?7nL?7n-M?7<8Y?7<4r?7	$#?7	1?6HK?6O?6kx?6gWq?6qш?6qL?6?7xZ?6?3/?6H?6A?5p?51F?5h9?5dl?5t!?5t0?5B3H#s?5B/&?5xAs?5%?4^?4L>?4bx}t?4^t?4wH?4wÁ?4E+(?4E(22?4{?4Ž?3?335?3YK?3U*1?3z{;?3z?3H!?3H?3}?3T?2O?2]M?2Ma?2I9?2}k?2}\?2K?2K=Y?2wU?2s9?1ڈ?1~?1=B?19	C?1Oe?1?1N`fx?1Mf?1fk?1bMM?0ȧCS?0.?0+!?0'Tr?0oNv?0=?0P?0PO?0Q\?0M-?/볭?/h?/?/ļ?/w8?/sr?/SΰC?/S?/!:D?/!6~?.X?.?.6v?.
Ih?.]?.Z$Y?.Vz?.VZ?.$%?.$T?-s'?-|"?-
f?-G?-A?~?-=9?-Y?-Ym4?-'sh?": ?"xj?"xNF?"EZ?"E?"Jd>?"G,
?!1W?!m3?!SE?!ɱ?!{VVY?!{R?!H9z?!Hv'?!&A?!;f? `? \᠆? ,
(? h>? ~kq? ~
'? Kiݵ? Kf{? ϐ? D?X?P1?q?n<>?Fn?
2V?N!{?Na?y?uH?|V?̹?'?$$?s?{??Pp?PT=+?-?)J?? ?ښg?ש?11 ?-nj?S4?S(K? p? ?"?4<?0y|?W*M??S:?ܑ<3?V61bA?V2n?#,A?#-,?a|??7Œ?3Oen?tz^?#?XC?XN?&6݁?&3=?㹠?!`?ˊ?	Z?5؀?1ұ2?[?'F?[}	q?(?(~?37L?/ui?Ç?Ã??۵??^/Ƣ?^,?+'?+(?׌һ?6?+B9?'D-?~ؐE?{Dz?`P?`Ύ?.%2?.!8?x䷌?u#d???]S??=0?cq?cnC?0Ğf?0f$?A
??iĴ?fAe?*?h?fp?f
S?3`@?3\׷]??qq?E??V[G?R?h	?hHu	?5?5ػ?K?GJ?М^}?И??z?k>]r?k:[?8Z?8b?|D?ܻU?171?-v?}?~?mS?mΒ?;",?;i?r?o5??տY1?u?^ȼ?pc?p_F
?=Դ?=;S?z?
?Rw?NF
?u??rŭ#?r9?@?
?@<7*?
'N?
I?8??:1?6f?z+?zkΠ?GՖ>?Gb?"ʏ?"4?
p?
lQ2?
!?
aS?
}
2?
}S|?
JV?
JS'R[?
&?
T.?4?ueP??
QŁ?
5$?
v?	_]i?	[LR?	?	?	^S.?	Z?	T>?	T;&>?	!9?	!z?zwm?ϻ???g?c?V?VQx?#Sw?#}?DNU?A@?????)a?Y!O?Yj?&jM?&f??"?l?'>?ֳ?EpH?A8(?[.\?[o?(Η?]&b?]h0?+@2G?+?1?|Zq?xЋ?bYf?bb?0
:4?0|k?Pu?M?~?ʗ-)?ʓw1?+4?mq?e$?e ?2j?2g$X??Ti?#?f]\?=j?9[X?gF?g1?4Ȩ?4Z?D?
M?S?P^?#Α?f?ig
?iکu?7#?7?h?dP?ѭd;?ѩ"?>@-t?fL0?bC?ة]?إ-?씞X?c?s/b?s+?@rg)V?@nZ?
$x[?
h?į?E|?:G ?6p?u|D?uxJ9?B"K?B9Խ?!?eP?C/v??s?!?d?w?w8s?E?Eja?JE:?F&?ߋ{?߈T?!?eE?zc`
?z
g?GO?GK̴%?g?Ԭ3?{?Ϳ?I?i?|R?|O>%?IZ?Iқ>??Ih8?^ٺ?-s?Td?P?~?~V?KԷ?K[??ma?Ta+?P?
8x?N?ӖY??N?NJ2V?RWh?N?葌?jj?Ф????PN}?PJŸ'?????'(?
j^?J'?HԺB?EH?R"%?Rg$?R??f4%?E?A\?=?6N?{{?T?T8ƿ?!?!E?8?4\?u}?q-??9?V@?V9G?$-?$)I~?iR}?f?(?MT?NE?ѓJ?xQ?
?[Mw?[IV?(v$?(v?J?N?B?G??a??C@6??I?py+?pv?=?=bq]?
]p?
??˩?RD*?N?r|:?rƥ??Mǧ???}?KW'?)?%?_C?[b/~?t{7?t-?A?A?认?0?3T?0=fp?h??e- ?v!?vF?Cr9?Cκ??V?;?7?o?l;,?x:?x
?Ef*?EԮ?v?i?@j??GY?!.?j5?B?>0?uՄX?r.?|^6?|N?I?IbY9??Z?AJ?>6?߱t8z?߱pJ?~R?~?K}?K#L?G?,?>q3?:q?޳pv?޳m?ހx?ހ/?Mg?M+*??
n?8?4?ݵj,?ݵfu:?݂g?݂?O'#?Opoq?z?O?/R?+K?ܷ`;?ܷ]?܄ύ
?܄?Q´ ?Q?}?Ɯ?$)i? sh?۹T?۹Q?ۆ0[?ۆy?S\?S#? 	? O??3ھ?ڻEz|?ڻB:A?ڈuM?ڈr%?Uz?UTX?"]?"ѧƜ?k]??X?ٽ4qS?ٽ0J?يcўo?ي`?W.?W`8]?$??$?LG?dO?ؿ >?ؿ8?،OKj?،K^{0?Y}ζ?Yze?&m?&?@?;?	Y?^e?׎7IT?׎3福?[e8?[b m?(?(5?|?.?˜'?
o?֐8?֐Z?]K,_?]Gv?*x.&?*u?(J?rY?|P?Ǩ?ՒK?Ց	\?_-?_*?,Z?,W L?g?2?ƴ]z?ưA?ԓ8f?ԓ݃t1?a
-?a
$?.:F6?.67b?f?b)X?Ȓ櫅?ȏ1R?ӕ
?ӕX?b\?bd?0
?0U28?B5??*n?n?jZ?җ7ʏ?җa?dź?dI?1#/~?1nQ?o?0o?GW?C?љr3?љo?fR
?f?3Ȍս?3e?O?`??A?ЛH%?ЛDͅ?hrV?ho>?5G?5l?ǁ?m??{:?M?ϝc?ϝ?jES?jA8?7oY;?7k*?*?W"?¡?Ѿ=?Ξ?Ξi?l~$?l98?9>Ît?9;Z?g	?d9p?ӐÄ?ӍHl?͠t?͠<?m>?m?;$?;r?4)?0v?\8?Xw?̢?̢j
?onI?ok?<եC?<5?	6J?	
?%?"8?ˤM*4?ˤIê?quq?qq}?>!#?>m?ĵ?}?}A?J[?JD?ޣ?,?d?(?ò3_+;?ò/@?VV?SEv?LzuI?LvE
??&51? Jt?n9?³M?³:X?a#?r?N*Y+?N&x?M7?I?o?lIrC??t?2J?j?OצD?O`?W?M?>??>b~x?:"?`k?\?QZj?Q~?/?~??8?㿸牮?㿸؂?㿆	2?㿆^?S*y?S&? K?iKQ?6i+?6e}nK?=$??Н5q@?Й?㰝?㰝eD?j?j)v?7Q?7Ԧ???e?>??㯟6葤?㯟3:h?lP, ?lL~?9iW
?9e?g?~?ӛ^:?ӗ?㮠;3?㮠B?m/?mQ??:?:8?9e7??H?0h?㭢/
?㭢+_R?oGPtN?oCv?<_zI?<[̒I?	w?	sB?֏9?֋ӕZ?㬣^wN?㬣܈?p";?pt[?=K?=?
\?
I??&{??㫥1j(?㫥?r4t?r0o2??K??G(\?b1?^?yxO?u31?㪦~?㪦щ,?sA?sN~?@?@=u?
z?
ȡ?Z ?DD?㩨N%?㩧?u#?u?B-n?B*u?C̾?@a?Y?V2?㨩ol?㨩k?vf8W?veq?C]?Cd?*?.M?(:?nq?㧪z,?㧪̀	?w?w?E?E?MG??RlV?/k?,KR?㦬Dخ?㦬A,1?yY~?yU7?FnMD?Fjo??5w`?]*?ӣ?㥭?㥭F?z/?z[w?G7X?GЋ.?M*?P?Js?L
?㤯.P?㤯2?|#H?| L?I7;0?I302?KBk@?Gi?^p?[x?㣰r'K?㣰n{]b?}t\.?}wE?J͛?J7?w??:??㢱Ѭ0 ?㢱qL?~{H?~?K1V?K?	h?#/$?R??㡳.?㡳+[z?㡀A̰?㡀=dF?MSHJ?MO`?eh?aMm?wo[?s?㠴]+_?㠴?㠁21/?㠁?N?NB,??尫?>?oֶ?㟵?㟵?㟂o?㟂8?P"c?Pwk?IL?9?&V2?"}F?㞷7J4I?㞷33?㞄H#?㞄Dx?QX?QU9?i?e?z?vp0?㝸?㝸=?㝅?㝅C?R3?RH?^?v?>?q?Yf?㜹j?㜹׿?㜆Kf?㜆?S?Si%?!
˜?!h?Y1??㛻)֫?㛻&,::?㛈9;?㛈5?UH?UD?4?"W?"Th?fA?c*P?㚼u?㚼r,?㚉S?㚉?V
'?VB?#G]?#8?]8?Y??㖎:?㖎?[?[x7?(d?("?UH?m?ͱ?[?㕏3K?㕏֊?\J?\	T?)?)CU?%,W?{?D??㔑L*h?㔑?^#:˃?^\?+/U+?++hM?:n5?7&p?Ftx?B?㓒R,?㓒NX?_]v?_Yͱ?,h?,e*?t")?pnS?BM?{[?㒓V!?㒓f`?`PH?`1d?-3S?-?R?T}|?ǵf?Dz?㑔Ej?㑔?2J?
?Wb?QX?㏗$?㏗!T[?d.J?d*_N?17J?14V19?AZ?=?J?Fb?㎘S?㎘P#?e\H?eY6?2e3?2b2J$?n?k?w-?sWÌ
?>,i?K|?å?s?M?ゥ΃?ゥ/?r}?rVŐ??]u??ѷǑ?ئ8?7?س?3#?て?C?~?~
?~st?~΍?~w|?~wp?~D?~D./?~U?~no?}oD?}h?}	{?}޸?}x
~?}x;?}E?}EQ+?}?}	OC?|
ɞ?|
6?|]Z?|C?|yb\!?|y’?|F"?|F^?|h?|,?{z?{
ZV?{Y?{
lf?{zC6?{z
S?{Gɖ?{G%6?{ޠ?{:I?zb7?z8?z?zL?z{3?z{
r?zHJ)[?zH
?zi?z
FC?yt?yv?yE?yB2?y|B,?y|"d?yIR[?yI
QY?y
B?y
J?x?x	$?xLj?x#T?x}
?x}
6?xJ	|[?xJ?x4/?xgJ?wԹU?w0?w^?w[?w~7?w~,?wK+k"?wJ{?woT?w˻?v?ve}?v?v"?v~[?v~?vK?vKH?vh{?f9BN?f5?fZ0i?fZ,p?f'&6?f'#(z?ej?eʏ?et?eV:2?e
l?e˸@?e[5?eZ*?e'?e's?dF?dK?dbB?d³?dhR?dȽQ?d[X?d[˸?d(2a?d(S+?c?cUb?c°?c­?c:/[?c>?c\D?c\?c)%?c)\?bz[?b1?b{9r?bxnQ?bp]?bm@b?b]eu?b]bR?b*Z)?b*WNz?aOӘ?aL4.?aD?aA&?a9]?a5?a^.V?a^*a+?a+"?a+S?`V?`e?`ft?`N?`?`?`^?`^G	?`+?^-l~a?^-hqz?]_c8?]\}!?]R&?]O!?]E?]B!?]a8?]a50?].+E
?].' ?\=?\H?\?\
Gn?\x?\M?\a\?\aV#?\.\?\.佈m?[ڬ?[v1?[G?[Io?[
d?[n?[b?[b~c?[/?[/x%(?Z3?Z[ܥ?ZɆ3?ZɃ)c?Zxj+?Zt&U?Zcj"?Zcfl?Z0[cd?Z0X2?YM&*#?YI?Y>.?Y:C?Y/s?Y,4_?Yd!y?Ydj
?Y1'%?Y1 ?X1?X:?X&?X/?XL?Xg'?Xd6B?Xd0[l?X1Ɓ?X1㾦?WJ?WS?W˧B?Wˤ	X?W?W{-?Wev&?We{?W2x@?W2u?Vhџ?VeQ9?VY
?VUl?VI?VEs)?Vf9u ?Vf5c?V3(?V3%?
?V)@?V?UR8?U^?U?UOX?Ufqo8?Uf#?U3R?U3C9?U:{?Us?T͵~?Tͱ?T?T
?TgE[?Tg*)r?T4?T4.?Tqmf?Tnd?S`S?S\T?Sh:fi?S5,e?S5(?S}?S?R	6?RgN?RV/?RH2?Rh(U?Rh⋙W?R5UI?R5и?RlH?Rϟ?Qϰm?QϬH?QZ+Q?Q?Qi0?Qi+?Q6yFE?Q6vU?Qg^t?Qd?PU5!	?PQ?PBT
?P??Pj0"q>?Pj,H?P7y?P7ܯS?P
F_?P?O\	?OJ?O	?O`?Ojom?OjbB4?O7?O7NA?OJ?O%n*?Nј!d?Nє?N/?N?Nkqt?Nkn*?N8^HT?N8Zf?NJo?NG]?M7?M3q?M#OJ?MsP?Ml|?Ml%?M8pp?M8A?M*!?Mo~?Lӄ?L!?L]Nw?L?Ll ?Ll?L9R?L93m?Lg?L~Y?Km`?KjPz	?KYZ?KUY?KmD?KmA?K:/k?K:,]?K(2?Kq
?JCEj?J?JH?Jz?Jm9d:?Jm؞%?J:?J:y?J+?J@)?IԜ ?IԘoH?I(?IO?Inq-?Inn-?I;\"?I;X?IFp?IB?H0u?H--h?H?Ha?Ho?Ho?H;$R?H;B?H?H~?Gx?Gտ]5?GJO?G(?Goyz?Go˓?G<v?G<|?G	i?G	f?FS$?FOo?FV?Dq:?D>&?D>#$j?DC?Dw6?CO~?C{?Cx?Cޥ"?CqǍ;!?CqJ?C>?C>/?Cxڋ ?>ڇP?>qFh?>mw?>tWX?>tSA=Tվ?>A9?>#=?>+W?=	,?=xG?={?=7v?=t{a?=tG?=A,?=Ay7?=?=?<ۅ?<ہh?X?;F?;?:v?:sP4?:[v~?:W2?:v?1?:vW.?7?7w?7wh?7D|ǯ?7Dy$B?7_?G?7\Dg?6Bf?6?P??6%?6"I?6xĜ*?6x-?6DT?6D??6Pb?6ʸJ?5ް|?5ޭ`9?5R?5V?5xv
l?5xrsP?5EXu?5ETR?5:k?575?4.0?4xn?4??4P?4xZ*X?4x?4EaY?4E?p?4TR?4B!?3߇35c?3߃.i?3h\?3eg_i?3yJS?3yG_?3F,XW?3F(m?3
L?3
Pl?2bR?2{h?2M&?22?2yy?2y?2F[+?2F?2tܠ?2p+?1U4?1R?16?13
?1z-?1zh?1Fl?1F#>?14D?1՝ã?0?0Q"?07?0ə?0z{>:?0zw}ٹ?0G[m?0GW?0;?08Z.?/A_?/`?/~u?/[.?/zܧA?/zh?/G?/G&t?/?/'A?.|?.y?.\L?.X?.{A?)̘?).?)|?)|?)Id?)I?)?)?(㖶?(!?(tBzm?(p?(}Qr?(}N&H?(J/?(J+?(q},?(ܪ!?'P?'?'+?'E.??'}8?'}\*?'J8?'J}_k?']?'ZP6?&:_?&7,?&?&`p?&}@?&}j'?&Jo?&JN?&r?&50?%?%Z?%fVޅ?%b~3?%~Bz?%~??%K?%KYq?%
?%?$7?$Ӣ?$>?$Ǝ?$~3}?$~V?$Kk?$KgG?$F◞?$CN?#".r?#	$,?#Dx?#xH?#~ؖ?#~D?#KYk?#K~E?#?#33?"l!~?"hp?"Gh:?"CԴR?""g?"?"K(?"K)k?"ʬ?"6?!D?!1f?!Z"?!	?!iMI?!e쵿?!LDA'?!L@?!?!x? Ad? Ɗ? ? }0w? q? ? L0j? LR?? c4b\? _
?=o?9=u?ik?'?B1?
G?Lˮ2A?L?w?	S
?wg	?{K?Y?N?U	??ZL?,~?dzs??[S~?Mُ?M?:?a?^1?:`L?6:??ytw?j?,?0'??c??ă??N"S?N?v	?rb?M?Is~c?#Pc? HC?t?y?NM6?Nͻ?l?Y?~uRd?z?Tz?Q\~?+R?'$?O?N}?7?T?Ԛ?誂?.!??Z7u?VU?O0-sP?O,R??U?
?Q	?q?n>?LH?M?O\?OYT@?\?Yh}?2?.4Q????vZ~?O?OV9?+,?#?ZoS?VH?/?+Y??`?O1?Oԡ?9q??:?}q"?UO?Qk?)=^?%?O&.?O ?y?6?
?9?y?v*&?Mƙ?J	?P!f(,?P&? /*?7]?
?
8?
]?
ͨT?
oj?
lQP?
PCQd?
P??
.?
 7?D?m?7e??_??Pcu?P_!?6y^?2?	j?q ?J>?غ?uL??P҇?P~C?T{Z^?P?
'h?
#?
?
g?
	?
yE?
Pip?
P.?
p?
m(d?	B6?	?dS?	
?	M?	6
n?	?	P;?	P?	0?	
?]^?YS?.?+Rp???PK??Pμ\?;?V(v?ul?q?FⰄ?CS?F?ǩ?PVW?P	?G?I?;?w|?]"RA?Yw?.,4L?*?P$v?PK?
7?|-!??PT]?qG{?n?BQu?>'?Q?Qa>?{?c??g$?^M|?b?T-?Q&?Q$s3?Q!kP=?,C?*\?M,*?X?\i?b?eYS?aĤ?Q5Eq?Q1~{?@?W6?M?Yn?}?B?tB]?p??QCԣ?Q@FN?U?	??7-?"I?6?m?}c?QP?QM]?R?B??Y??^?c=?Q?Q[7|?QX3?*D?'?O?Z?M?o?%?
I?Qe ?Qa?3?0?1?r\?SJ?ƸJ?&?	?Qlȯw?Qi;?:蝚?7[Q?0y?j??/?gG?ߛ?R?Qrv`?Qo,_?@`?<2?8?
6?QuT?F?C	BA???Z?	T?{8?7?QzObY?Qv?Gb?C'*??7\?d'K??+?g?Qyp?Qu䬁?E?BP?8?*?ށdH?ln?*;?-;?Qv߆?QsSY?B??h?{?l??_P?R?@{?Qrf(?QoO?>[T^?:ϩ?
B?}%?ե5??0g^??Ql]`?Qid?8?4;?j?,?ΰ?%?@?Zf?Qe
al?QaN?0?,z?B?J??„P+?
J?cv?Q[g?QX2B?&zR?"?&??.?6?LW?b?QP?QM: ?-
'?!X????O?>?y?vs?QD"~:?Q@?5*?
n?6?ԬJl?'@?񷞝/u?lf?h|.?Q5Z?Q2KA?@*?	?A5?Ŷg?=?R?\hY?X[?Q%5?Q"X%o?K?w?긤6?h?ﷁx4?~a/'?K"?G?QG?Q!?\@?V?`_(??7?3?p+?*?O.?O)7??YS?LH?Hz?4?
Y?\?҉T?O(k?Oy`?_W;?\X[?$/C?!'z?m8??Ⴎ1?Ⴊ{
?OrC?Oo2?7G?3n?ű?>,?2?ർ?5?U?OH`?OEU?
'?	?F?Ϳr?ߵcu?ߵ*?߂YoD?߂U?Ok?OF?W?еt?3V?衬1?޵h*?޵ew?ނ,?ނ)2ň?Ne?N?h?x?wT?t?ݵ;?ٴo?ف5?ف2?M=?M;%??F?{UG?xBP?ش=?ش:.
?؀ ?؀
.?M\?M+f?8?Z?D?A>?״aY?״ێ?׀?׀h\?MkC?Mc?JT?GR
?5?"_?ֳ̓y4?ֳU?ր?ր;?MO︚?MLj/?g?
?r?Η?ճ?ճ
?ՀTd?ՀP?M-?Me?ջ?5?{?@b?ԳW,5[?ԳSJ?Ԁ4?ԀH?L^?Ly?F?['G?YR\?UF?ӳ?ӳ/b?j?ւ?LK!c?L(c?Z~?Vb?ʈ??ҲڷX:?Ҳ2{?Ft?7s?LZ?LW,??L	?l?@?Ѳ3E?Ѳ3?Y#?Vet^?LO?L?)+?դ?嘱!?-	?вX*^?вT;??)$?K?Ki?7?{L?Ur?Ql?ϲYE?ϲ?~Ӻ?~6??K?KB͏?Q>?N@?+H?
.?αϐZ|?α=?~__1?~L&?KM?KI~?^D?K^c?p[?e?ͱ?ͱ~?~G!?~D>t?K	?Ks0a?Z?$?䂮?*F?̱@?̱=oؼ?})]@?}?JOP?J?{f~?w9q?9nO?5?˰fx?˰n?}P6?}̳[?Js*D?Jo?0	?-q??-[B?ʰ]4~?ʰׅ?}i)>?}fv?J'?J$??პ?vi^?2?ɰ_y?ɰ\Sj?}(;?}v?Ij0`?I|?&?ɧ?{1OSc?{-Om?G?GLs??d%?s[?c5?`N?®:?®r]F?z8:?zֶf?Gm?G!?Pޕ?M?i(?)?ƴK?2=?z1?z~,n?GDl?:6?⼫{?⼫]?xi{?x?Ej?EgeS?$St? I'?ݳ@?2Z?⻫gs?w?w8j7?D.?D#?_L?\?O?{?⹪˵?⹪͏q?w`?wA?}}?yk?ݳ?ݯ?⸪k?⸪hwێ?w$a,?w 8?Cܼ!j?C<6A?>??MF?I?ⷪvT?ⷪ
?v?v?Cu?Cr+O?-?*0!?@?'?ⶩ|F?ⶩ?vUig?vQ?C
5!?C	?Ud?rӰ?|l?y"N?⵩4Bl?⵩0k?u^?uUm?BYdu?B	?Zφ?WP4?7H?~?⴨ɑ?⴨J?u}?u}]H?B8՛?B40?HO?{?ۦj?ۢJ?⳨]|&?⳨Y?uZ?uU?Aẇ?A?_?~?9:/?5G?ⲧ$?ⲧE?t#?tEM?A]s?AY'D?v??ʩc?*8?Ⱨ.?Ⱨ}8?t7I?t4'?@:?@?
jS?
ZQ?ZO?W9J?Ⱗ1?Ⱗ
y\?s(?q+?qvC?> ?>s??a?^r?2D??⫤ov?⫤?qD?q|ul?>5?>1'?
ƍ?
I.?מr?ךSR?⪤S0:?⪤O?qε?q$y"?=$?=?
pk?
m?%d?!+?⩣[?⩣?p?p)h?	?	͍?֪8P?֦u?⨣^N?⨣Z?pU@?pœ??◚fuo?gB?g?3!6?3ŧy?x?u-J|?(~?$?▙׋?▙?fp?fql?36=0?32ã?Q?	O?̔v?̑A?╙CX?╙@m?exz?e?2?2_?QB?MZ?h??┘?┘?e]6$?eZh?2?2	;l?zI?\?j3x?f^?ⓘߠ?ⓘf?dPN?dI?1v:?1rM?$J?!V?.?ϙr?⒗~?⒗~?d/ۢ?d,f?02z?0ڹ?yP??f
?b}?⃎?⃎
lZ?Z?Z0?'f_lY?'bo?D?
??6"|?₍f@?₍bʮH?Z?Z
S@?&Ei?&Ͽ?e`?b@?#^?iB?⁌s?⁌B]?Yd	?YaKb?&(?&Y?7.?'?‿c`?‿_?‌
}T?‌
s?X?X*?%ae?%^?B??}Vj?G?__?[Q?X	6'Q?X_?$?$?~\z?~YJ?~s?~آ?~}&?~\?~WY?~WVA?~$E,?~#?}?}U?}VB?}R͒?}!?}:1I?}V8:?}VQB?}#Re{?}#N?|
?|:7?|?|x?|N-G?|Jl?|UE?|U?|"`?|"C?{Iop?{EA?{sWT?{$?{kW?{Y?{UDW?{U@(?{!8_?{!?z
q?z/?z>Bm?z;b;?z>p?z ?zTGs?zT^s?z!8o?z!5z"~?y?y?y|?yBr?y2b?y/)?ySS?ySע,?y v^?y X?x+?x(p?x;?x	X?x|G?xy?xS$?xS!P?x?xɄF?wu!?wq,?w=?w?wOgW?wۖ?wRmU3C?wRil=?wOE?w
?v>I?v'v?ve"G?va?v6?v	:?vQǕ?vQS?v\"6?vY?u?K6?ub?u?uvz?uSv{?uP?uP{?uP?u?u2?tJ#O?tF ?twt?t"-8?t(z?t?tP@Wy?tP^?pBU?pU?p,?pV?pMJDwL?pMF@?p~?pB7?o?o擧Q?o=s?o:5h?oP?oO?oL2?oL?o0>l?o,̇?nl|`?nH?n|?ny?n"?n4tv?nKȳ>?nK@2?nn?nkB[?m	O?m9w?m~ ?m$?m~`v>?m~]?mKLI?mKb?m?m+?lQJ4?lNdv]?lS?l#?l}4?l}W?lJB*?lJ?as?lf?l6?k?k~?k3m?k/
\?k|P?k|o8?kI~HK?kIzjB?k#Y?k 4m?j˖?jŇW?jn@dS?jj?j|}A?j|N?jH&?jH=?j]?jZd?iM?i	?i?ihZ?i{M
'?i{I|?iG?iG?i?i/?h;Rq?h8l>?h2?hG?hzHS?hzG?hG*O]?hG&f?h
tS?h˙?gs?gpI?g`p9?g?gyf?gy?gFa?gF^ձ?g!?gd(?`@ú4?`
j>	?`
f$?_
H?_	K^?_H^?_?_sS=?_sOl8?_?(̆?_?򹅕?_	rp?_5?^;ˆ?^8p?^ޫL?^<*?^rm?^r}?^?$%@?^? )?^}E?^co?]iu?]f)?]-?]3?]q?]q-?]>Q +?]>M@?]
d ?]
+?\ז
!e?\גM?\8o?\5ٔ?\pʗb?\p[?\=}?\=yԵ?\
bI?\
?[3?[־0-?[c%b?[`bJ?[pc]?[p?[<S?[<?[	J+1?[	F?Z4+?Zƈ}?Z4~?Z?Zo0)?Zo,R?Z;r?Z;Χ4?Zs?ZpD?Y͊?Y_F?Y?Y,[?YnY]`?YnU0?Y:$`?Y:?YƂ?YVB?X>id?X:Q?XJ?Xܕ??Xm~m?Xm~&}?X:#?X:?Xė`?X)sJ?Wf	H?Wb?Wr2|?WXv?WlУ?Wlb?W9J%?W9FT?Wo?W߇?VҌf?V҉BW?V-?V*x?Vk(?Vk˥X?V8p58?V8lCk?VN?V
?UѲ]4?UѮE?USa!?UO$?Uj]?Ujm?U7M?U7?U64?U2Ǒ?T*?TӤk?Tw倥?Ttx6?Tj?TjA?T6n}?T6F?TZ$DL?TV$?S
?Sb?SrL	?S2?Si<
s?Si8ce?S5ܘ?S5+*?S}2?Sy?Rm*?R+y?R	~?R?Rh^p?Rh[^?R49?R4ac1?R"%?RX?Q?lHf?Q;?Q߬?Q@?Qg?Qg|v?Q4 ?Q4#?Q3?Q]?P`M?P\3h?P]?P@=?Pfd?Pf?P3@`|?P3<i?OSa?OO?Ò?N;}?NdޏF?Nd#?N1~,a?N1zK?M!F?MSA?MʽHG?MʹDo?M\;?MY\k?Mc>$
?Mc3?M0+?M0>ّ?L;
Ⱦ?L7?Lg?!?Lk?Ly@?LvKw/?Lcϟ?Lcq?L/::?L/?KWnD+?KT2?KeK?K,?K?KMb?Kb4(?Kb1d{?K.ݒ?K.r?Jrᰢ?Jov3?J܂?JqL?J?Jb?JaOd?JaLJwC?J-@?J-( ?Ii?I2?I,5$?I(?I?InjL?I`i?I`fEu?I-`/I?I-?H]
?H@'?HEL?HB89F?H6?H˽?H_?H_Vw?H,!A?H,z?Gb?GN?G^'q?GZ0?G~?G")?G^خ?G^~?G+9;^d?G+5З?Fׄ?F&?FuĀ?FrY͙?F?@u?@dD?@X*^?@X'3?@$}?@$Ė_??e
5??a???????????W;'??W8??#ݎr??#tHC?>u4X?>rR?>p?>(x?>^?>q.?>VL"]?>VH=?>"eB?>"tO?=?=&y?="8?=?=}3?=p?=U[qy?=UX(?=!?=!?< ?<?<1'?<-T?{)?;;L?;:?;s?;Swy?;St.?; ?; H]?:+z?:v?:L?:H\(?:!d?:f,?:R5?:R͖;?: A{?:%?9DF?9g?9X>?9TMU?90?9˪?9Q?9Q?9+,?9(?8Q?8h?8c?8`7;?8f5?8,?8P$	?7Ou?7@?7=}:3?6gA?6?6w	?6tyV?6R~?6]n?6N?6NSI?6Jw?6F^?5r?5?5V?5}Z>?5~L?5F?5MF?5M2}?5R|e?5O?4?4Bn?4?4grp?4#+?4 ?4LD?4LA?4Z
?4V?3F?3?3	+?3?3*w?3'^?3K~M?3K~n?3`@h?3]`:?23?29?2q ?2
?2~1:^u?2~-u?2Jc?2Jȓ?2ftf?2cK?1b*?1^?1	?1ǝ?1}6A?1}3Af?1I?c?1Iش?1k.?1hg-?0T?0p|?09?0k~?0|;G?0|7/?0Hյ-?0HN?0p?0l?/
wy?/
?/EP?/e?/{??/{;>?/G]I9?/G?/sr?/p3>?.
͖?.
g[?.I?.?.zB?.z>D?.F8A?.F҂#?.vL?.r?-W2?-&?-Zl?-jW?-yDU@?-y@HH?-EH/?*6?*pC?*"?*\u?&>v?&o?&lLa?%~?%,
?%D?%
?%q:?%q6[?%=ҹ@N?%=Tѝ?%
kg?%
hy?$"?$?$6W?$Iz?$p5E|?$p1v;?$<Ր?$?ct?^(J?q}r?n@r?j	2(W?jf?6ߧ?6|N?8G?5"?$?
{?gD?dXC?[;&`?'B?'?i/?f$?n?F,?N_?!?Z*F?Z'?&v?&))?V?R)?멦?Il?/%?}χ?Y	?YN?%';?%a?
Aak?
>9M?
?
Ӥ?
lh?
i?
Xƾ
?
Wf?
$?
$3?N(Ɓ?N%y??{=?Q;X?M%?c?t?y?v'?M
?M
C.?6?Y?5W/?2iT?и?rO?]>?Zu`?Kt?Ks3?ǽ7?i??Z??E)?Je!?J?i=7?e+??'?ی?}i?}$u?}!CD?Ia?I?L/?H(?P?p?s{?pNl?|#?|ų?HČ?Hg6?._?+?;?ᾗ'?Us?R'V>?z
	?z尻q?G|47?Gy4i2?E;Z?ѫV?N{?dS?aE?\u?t?wMq?wF?DwR?D(?C???Dl?A^H?r?v?vjc?vg?B[f?B?^?QH?#? D??Z?uIf?uF&?Al4?Aف6?oǍ?lka??OP?h?.?t(c?t%y?@7?@Z?
N0?
J=?/e?q=?sU?p3?sL?s??Y"???+f?(ZO?ؾbC?ػ?Q.?Mӈ?qX?qM?>vDd?>r运?j?~??כi{?טJ?-?*u?px?p?=R"?=O?	q`?	?wۛ?ty}?
S2H??o?o`(???r?orr?P?~?YY?YzW?&$O?& ??p1?E;?A3?ժѷ?S:?Xf#?Xb`?$z?$#n??񃄙u?߾8|?߾?ߊ.?ߊ8?W7m?W4?#1?#ږ?X{ܮ?U$?޼)?޼i?މy5?މue?V	>s?VF?"v?"`?)?&S?ݻi?ݻ?݈J:?݈F~?T*w?TY?!jL?!f?i??ܺ?ܺ+?܇?܇@P?S?SOק? :? 7[g?ʸf?a?۹ZD?۹WdV?ۅ[?ۅbG?Rzf?Rw[?
p?P݅?뚘^?A?ڸ*>0?ڸ'-?ڄl]?ڄ?QJOmi?QF?.nX??j	?f?ٶd4?ٶ.?ك2&?كZ?P~?P(?H?U?9|?5?ص͒?صwr?؂Xض?؂U3c?NA?N?wt?tq?=?N?״O#?״G?ׁ&?ׁ#}?M?MC;~?F7^?B዁?x?{?ֳeg.?ֳbo???L?L0qs?=?1?壔'f?>?ղ3?ղ/i?~‘o?~;?KR	?KNa?~?(?pX?m?ԱY?԰q?}>?}l\@?J%H?J/?h?/q?=o?:J?ӯ7c?ӯ4D?|\!?|Y5h7?Hٮ?H脑?{$?w{.?
ke?\y?ҮD	?ҮYD?{(?{%?G'?Gͪ?G^{?D	?֑	?<;?ѭe?ѭbj?y?y	?FZ?Fc:?5??ߢU1m?ߟ?Ь1p?Ь.?xbK?x3̣?EO?ELG?ޫ?W8?mR?jc?Ϫn$?Ϫj?wMs?wn?Di?Do
#?s?kb?84?5c|?ΩǬ~?ΩX??vVr?vSH?B5?B5V?tre?q~$?Wb??ͨ8ȗ?ͨ乒?u!1^?u+?A^?Aʖ?>ň?;q?͗N?C?̧\e?̧Y
?s0/?sZ?@yP?@v?
n?
fY?ٗxq?ٔ%??˦&4j|?˦"໤?r ?r{w??C??@Le&?PB??`6?]C?ʤ縷?ʤR?q~J0?qzS?>	a?
s?
6?*$B?&]?ɣ8?ɣgy?pGM?pCJ?<ܵ7?<҉y?	dhH?	aB? ??Ȣtg?Ȣ~!H?o-R?oY?;r;?;0D?,?)?Իa%?Ը?ǡI?ǡF?mB?m?:f?:c[&???ӃyP?Ӏ'H?Ơڀe?Ơ?l7?l?9.?9+>r?>??K9R?GE`?Şو.?Ş6`?kgԂ?kd?7u?7^?a??Y?s?P?ĝ?ĝL?j/?j+ɣ/?6S?6?K[?H6w?ٹu5?g=p?ÜgL?*r\|?'!?ɸQ4?ɵl?ᾖF-b?ᾖB|?b2?bеe?/am?/^B?6?][?}~A?z-t?ὕK?ὕ ?a9?a5?.&ڇY?.#??LJ?B]??o?ἓ	?ἓɲ?`]t>?`ZV?,/?,:eQ?y>?u9C?ƪ??Ồm?ỒLk?_"H?_h)?+,?+0?=h&?:Cא?6??ẑX?ẑUf?]p?] ?*t	6O?*p3??N?Ï1M?ËUm?Ṑ|?Ṑq/N?\Nj$?\&?)7M!?)4?_A??RWn?O0?Ḏd?Ḏc?[m⿟?[j?'^=?'3?ַ?􅆷4?L?(?᷍+?᷍p?Z11|?Z-l?&?&O?L?HF?ᶿsri?ᶿ#?ᶌf+?ᶌcn?X<?Xe|?%/S?%~L???ᵾT:.?ᵾ?ᵋ)?ᵋ&\z?W9?W?$DS?$A?ѣ4?SĚ?ᴽ^|?ᴽ[?ᴉ:^?ᴉ?Vya?Vv21?#Ƥ?#w[?y??᳼!HE?᳼k?᳈?᳈5?U;J?U8p'?!?!ŧ_?V+@?Rܑd?Ჺ]?Ჺ?ᲇpX?ᲇm>?Sk?Skx? 5? ?b??ᱹ1?ᱹ?᱆2Tn?᱆/g?Rtb?R%?LQ?IC%?٬ձ?^&?᰸f<?᰸cv?ᰄ?ᰄv4?Qh
?Q}9?
/?
?
j?ꗾ9?᯷(CH?᯷$R?ᯃ"v?ᯃ	?PB)j?P>ڼ?-ip?U?\/,G?X?᮵.?᮵Y?ᮂv+u?ᮂr_4?O%"?Nŀ????w?᭴?᭴?ᭁ6wv?ᭁ3kM?M?M?Pm?M߁?ݻ[r?ml%?ᬳj?ᬳgT
?km?9\?LiG?L?J?
;&?'X?"?᫲+;\?᫲'?~P1?~7?KD?KAej8?чq?9?^Z&?[?᪰+&?᪰z?}wM?}t,l?J?Jx?3?Bw?X?
?ᩯF?ᩯl?|7%?|4?HĢ>?HUE?Qa[?N]?a?2?ᨮj ?ᨮg?z^?zD?GG?G{?*?
"?;H?a&!,?>_?H;?EH??Ѵ?ᠤak
?ᠤ^h?pӫ?p?=z:x@?=v?
?
T9?֓/?֏J?៣d%?៣?o?oxV?<8!v?<4?}?21C?Pn?Mq?ឡ0N?ឡ
"?ni?nf;?:(?:?/?~6?Y?7nt?ᝠz?ᝠfB?m'"X?m#װ?9pO?9%N??9??ᙛѬ?ᙛY
?h@C?h?4/<8?4?4[ʏ?1??ͽ_?/֝?/PVW?&PN?#`٦?Ȳr;?ȯp2?ᔕ>X?ᔕ;}"?a۞?aNJ?.V2?.S?64?ߟ?n9?kH?ᓓ|?ᓓI`?`W?`?-e?-P?l!?U?+
?'?ᒒ2:?ᒒ/?_CE?_?L
?+?+?[R?W?%0?Hp?ᑑsf?ᑑo?]}?]0?*1?*4M?x?3?â?ßC?ᐐ.U?ᐐ+?\?\PY?)Fn?)C|?Ҹ?pmj?^C?[bƁ?Ꮞ꜆?ᏎT?[v͒?[sDd@?(|0?'3}?j??!?WP?{?ᎍC?ᎍA?Z2.}?Z.C?&^?&i?J?F?፿+?፿ҡ?ፌa?ፌ^?X5?Xo,?%yX?%vTY??85?ጾc?ጾ|?ጋFV-?ጋs?W'?W?$5]D?$1?m?$?ዽLƧ?ዽI~?ዉؤa?ዉ\?Vd&?Va97?"]?"o?|8?x(?ኼ?ኼv?ኈ~4?ኈ?U#?U}?!?!Ui?7s?4,}a?ቺJx?ቺ~?ቇOV{?ቇK?S(?S׬j? fǼf? c}H?򚱾?S|>?ሹ~l6?ሹ{%U?ሆ
>N?ሆ,?R-?R҉?!޼??뭭`?f?ᇸ9|F?ᇸ65K?ᇄI?ᇄ?QQ?QMm?#?ٜD?h6?eg?ᆶy?ᆶ2?ᆃC?ᆃ|?P
8>?P??c?#-P? W?ᅵer?ᅵ#?ᅂ;,?ᅂ7?N?NìY?Rt3?Oqx?}?7e?ᄴjA?ᄴf??ᄀ?ᄀa?Mɢ?M~Jl?
e?
G[?P?
R?ჳ%S?ჳ!?e?3?L<?L9P?XJ)?+?Tۡ?Pƶ?Ⴑ
?Ⴑܒ?~k?~hRV?JWm?J^?N?С?,?Z?ၰ?ၰL?}&P?}#
>G?I
?IH?=ɀ?:+?Ʌ???ုUA`?ုQ?{?{ݷ?Hl?Hir?r?,?,>p??A???zg?zY?G'X?G$ ?:8??~>ɗ?~;B?~ʁY?~?}D??{u??{B,b?{BL?{D?{24?z(D?z%?zO?zg?zt@^ϒ?zt=N?z@0?z@o?z
W?z
Ts?yw?y33{?yo*??ykL?yr?yr|?y?B?y?Jl?yAF?ya?x؝?xؚ?x)?x&a?xqX;?xq?x>A
N?x>=7?x
̼Ar?x
x3?wXn/G?wU*+m?w &?w,?wpoҾO?wplͳ?wuV?ul?u)??uY k?uUх?umK?um᐀?u:p?u:mDO	?u;'?u?o2̯f?n[D?nXj?nh?n&]?ns$?noH?nd?nd?n1X?n1["?mZh?m<?mʢI?mʞ՘h?m-բ?m*[?mc?mcQ?m0ER?m0B?lc?l?l\рo?lY?l葓?lOo?lbtR?lbq9I?l/?l.H?k}e?k?ky?kT?kY?kMy?ka/
s?ka+[?k-߆>?k-j?jF4?jCb?jh?j&?j^-?jZP
?j_Y?j_]?j,uZ?j,rz?i?iCn?iōMJ3?iŊ?i?iJ?i^?i^EZ?i+09"?i+-i?hv?h5H?hHB][?hE*?hD?h}?h]_2?h]\?h)1w?h)i?gwx?gt7?gH3>?g0?gS?gZr?g\C?g\%4?g(?g(y?f2?f/K>?f_?f?fJ3'H?fF^?fZ?fZ?f'a?f'^?et?er?ey~?evHܐ?ea"?e g?eY9^?eY?e&^?e&8?d쵉?d9?d4h?d1?d\?db?dXL?dXI?,)?d$\?d$p?cd:"?c`?c?cپ?c{؜?cxQ?cWڛ\?cWl?c#V?c#|1?by?b^
?b\(?bBJW?b7f?b4&?bUL?bU
N?b"O26?b"KA?amU?aف?agz?ac?aꕉ?a諾p?aT~ԉ ?aT{?a!
~?a!?`햫w?`k?`"e?`XZ?`Y?`F?`S:uS?`S75?`eS%?`%a?_RV@?_O?_HPa?_?_j;\?_f?_Q/fW?_Q?_$?_~$?^i?^
\\?^?^үm?^&
K*?^"Z?^P?^Ps?^=C?^:e?]ٌ?]ƺ?]UI?]R(i?]k?]޷T?]Om;?]Oj#?]M?]IB?\?\肻?\?\R?\+?\?\N*
7?\N&Y?\p?\?[BN?[>ۄ;?[$A4?[?[Z/?[V|?[L;?[L.?[rIb?[o
?ZXg?Z?Zh?Z*O?Zz[	?Z;Ӝ?ZK?ZKN?Z.?X?Z+b(?Y亶v?Yx@?YFa7?YCD?Y}|L?Y}ϧ$?YJ^?YJ[,?Y?YQ?Xw5w?Xs?XS'?X?X|q?X|3?XI?XIS?X~?Xur~?W3֐>?W0?WV?W?W{L ?W{H?WGG4?WG	ݯ?Wdp ?Wa29?Vk?V\V?V|?Vy?Vzբ?Vz?VF!$?VFg?V!QX?VO?U߭XN?UߪD?U9?U6wv^?UxM?Ux«?UER
{?UEN}&?UV3?U)?Tj+?TgQ?Tb?Tq?Tw4?Tw?TDB~?TD'A?T_?TDQ?S')?S$~*?S|?SƋ?Sv@Gx2?Sv=
Ap?SB̌?SBOl?SXK?SU(A?R?Rސ?Rqe?Rn(F?Rt9?Rtt2u?RAyG?RA|?M#?MnR?Mni?M;?"J?M;<?MIa?M
^?LXǚ?LU?LG?L?Lmqz]?LmnD?L9MW?L9{'?L
?L7?KZr?K4?Km?K;?Kl0om?Kl-44l?K8u?K8n?KIۉ?KFQ8?JQ?J?Jb?J_v/?JjG?Jj?J7{ށ?J7xs?JwP?J?H6?H$?G?GZ
%?GF?G?Gg,&?Gg)0k?G3K?G3v_?GFi?GC.?F$	?F0Q?F_?F\^?FeH?Fed?F2y`:?F2v%~?E#Sm?E!?E˒b?Eˏ?E=?Euw.?Edy?Ed?"?E19Eb?E16
?Dc?D?DR\?DO
?Dߵ??D{{G?Dcl?DciP&?D/a\?D/'?C;/U?C9?C?Cݼw?C#?C?Cb,?Cb)J^?C.Ng?C."?BFN?BCh,~?Bӊ|?BP?B`u^-?B];Oe?B`bT?B`(O?B-zQ}?B-w?ACt~?A	?AƔ7~?AƐ0?A!.)j?AJ?A_'?A_?
?A,;"`.?A,7蔺?@ ?@Y?@U G?@Q揲?@"
?@)r?@^o'?@^k(#?@*/]F?@*??99????E????TlZ????]0e??]-,'??)yz??)@?>Jƒ?>GV`?>ר?>o9?>d?>ar?>[?>[hK?>(?>({Ȳ?=$a?=?=JD?=/?=&r3?=#9M?=Z?=Zc?='@Ǚ?='=?<`?<_?<[+?AD?.?.{?t?.{	y}?.H.D?.H+Y?.L?.d
?-JW!?-G!?-fI?-0#X?-zfx?-zcB?-FT?-FV?-7?-o.1?,ͯ?,
ͪ?,ߓ?,?,y-	?,y)˹??,E'?,E!?,IO?,FB?+{:?+EJ?+el?+bu"?+wu8?+w𧸅?+DS?+D~ݟ?+L?+
p?*ݞT~?*ݛS?*,l?*)q?*v?*v2$?*CITB?*CF?*ן1?*jf?)e?)b?)Aw?)`?)uf?)ub	?)BO?)B
g?)MO?)y?(-$l?(*x?(?(߶?(tJyT?(tGD(?(@%?(@կ=?(
gRy?(
d`?'F?'6?'9?'?'s4?'s}?'?.?'?
?'/?',z?&ؾ2H?&غ?&L?&I?&qDk?&q?&>iҶ?&>f?&
d0?&
/)?%׆?%׃9l?%?%^`/?%p/C?%p?%=27?%=/j?%	s?%	?j?$P{?$L?$Ʊ?$ے<8?$omu?$ojA?$;(?$;
?$R?$?#GS?#c?#U?#!q?#n7?#n3?#:?#:§@?#T?#Qp)?"qF?"='p?"rAe?"o
Oz?"m:A?"l.V?"9?"9U?"N?"V?!ҭZ?!Ҫsk?!<;?!9VV?!kp?!k=#(?!8Z[?!8W'^?!I?!S? x;P? u7U? 1_? .? j+? j/? 7%)? 7!t? *k? :?C/X??s?8?@?iaE}?i^6?5V}?5#?k(?|7$??PU? ?l[?h,?h)>6?4?4?K?G?9
??ii?f5?f.?fj?3;?3)?2??̦VH?̣#	?5_?2hY?e?e(t?2T2+?2P`?0h?QX~x?"
?jF?gy*?A??v?^?Uz?UL7?!?!Vr?
=	w?
9@?
͐?
`?
^?
Z9?
SIJ?
S}?
 C:?
 |**?i?b+?|6V?L9?1?-?R?R"?Rt?OE?&?)?s.8?p`?p?h?QX~?Q(?&??"k?
N?
곷'?
G?
D?
؈J(?
X?
Pi`,?
Pf0?
<?

x?	?	 ?	?	՛?	@?	ܚ?	O=Kh?	O:?	+?	˥^?_?\	?͕b?X]? ?~&?Nك?NZ
?-??4g?1?%?3?W,?S3?LLX?L?yr?vC?
?no?c??-?)4T?K;X?K?Ozg5?LK0??ݏF?r?n?~T?~%|?J?Jx"H?%I?"Ϲ?Z?,^?H4?E~?|#Fk?|R?Ik?Ih`P??^?u?GQ?Lx??{r>?{D9?HB(?H?`?ԅdq?W4?fjw?bDK??~P?zG?z?GZL?GP?{?`?>8?;
?{?̺?ya*?y^pG?EX?E*??Mk?}?6?p?q?y6?x:v׀?x7I$?DKh?D:?^%v(?Z֘??,??~?wҰz?w-?C0?C3?7?4r?ɯ?Ƃ9#?[?XH?u?uꅲL?B?B|i?˯?pV?ۣ?۠>?5?2y?t?t'?AZ=.?AW?
f?
9?2w?ȷ?5?2km?%?։?qZs?qWGe?=?='?
eV?
|86???lW?@r?p6$?p3*?<Ɋ&?<]U?	\!H?	X??둣$?`.?~3C?o?oX?;^?;5?9hWI?6<8N? ?Ƀ?^?[$?m?mv?:l"?:@*?;??Ӫ?Ӧ?c{?Ԙ?mY,?gc?d|?x|??jw?j?7 9?7ч??nh?GL%?D ?~O?S$?im3J?ijo?6,?5ȿ?7
?pj?'u?$Ur?af?򛷥F?hN%?hJ?4ယ?4U?thu?qi?HD?O"?񚛴?񚘉s?g/'}?g+?3 ?3u,?V[,?R?颶:?wZ?},e?z4"?f?f
b?2S3?2(~?7M?4Į?ˑb?fD?_9X?\?dY?dQ?1Kb?1pj?UHd?*
?ʮD?ʪ?A3?>؎?cէ0?c|?0iy!?0fN?Qx?&/?ɑ/&:?Ɏ?%G?!?bn?bL?/L|?/It?d?ݹ,?t_%?qZ???awv?a?.0$?.-RC?:?L5?"3?_f'?_ch?+R?+?1?}?#L? bS?鑷;?鑴;?^LS?^I)u?*?*ݖ3?u3R;?r
G?	??萞,V?萛?]2Y?]/?(48?"#)?q?@?Q/?N
?._?t&?T|;D?Ty%?!?!E?aZ?9?ߺ?RUP?RQ?Ԋ?篍?뀰?}ܒ?ݸ?ݸh?݄v?݄O?QBd4?Q?=*?Y.?2>?nU.?k.?ܷYX?ܷ2U?܃c8?܃<=?P0tύ?P-M/?ƌi?e?\?Yh?۵=?۵j)?ۂ?ۂ?O1N?O
?k?D
?Kk?H9U?ڴ?ڴbK?ځxD?ځu?N"?Ns[?|?s?;Z?84Y?ٳŎ?ٳΟ?ـh7M?ـeD?L?L?/?	C?++[?(b?زCA?زs?XX?U??Ks4?KM?x?R3?=?S?ױpt?ױJ'?~J(O?~GEl?J?J
?w?tM?yu5?SZ?ְMS	?ְ'o?}<(&?}9MP?I
%?IU?iC?f|?r??կڵl?կX?̦;V)?rw?rՕ_??oJ:S??l&J?w'?~G?ؠE?؜ie?˥8i?˥5E?q؀?qʹ?>iO]?>f+U?
?
T?ךRG?ח/?ʤ2?ʤ/a+?pt?pQ.?=d0z?=`?	K
?	D?֕`l?֒=hB?ɣ.>=?ɣ*˯?o?=?oëK?<_*?<\nn?\?8?Ց.{?Վ
]?Ȣ*O?Ȣ&U?n?nŮ?;[?;X?o?J??ԍ?Ԋ?ǡ&B?ǡ#?m?m?:XH?:UIN??ƕ/?Ӌpy?Ӈt?Ơ$/.#?Ơ!K?l]?l:޿?9Vm?9Sq$=?z?)?҉X?҅
`?ş"e^?şBl?k?k?8U/?8QE
?|߃?ZI?ч2?ф F?Ğ!^J?Ğ;Ȣ?jڼt?jC?7T_(T?7Q<?ƫj?๓J?๓F?_A&??_ ?,?,}e&?Gn?l?ŷ'_?Ŵ0?ฒRۥ?ฒOd?^K?^ʄ?+Y8?+8ӥ?$ϻ?!?N?Ľ.B?ෑ[-?ෑX?]fo?]EJ?*3?*4?.%?+~7?G?(?ඐe]?ඐb|%?]*?\R?)zW?)Zd?9G?6'G?ck?#?൏p6L?൏mڄ?\?\	?(l?(E?Dm?Ac??ݧj?എ|ό?എy?[ఒ?[8?'b?'?Qպ?Mp?GR?(?್{j?್\7?Z%?Z"E?&[g?&?^I?[*?ಿ?ಿg?ಌ-?ಌߑ?Y3e?Y0F?%l?%̷?lN?i/Z?౿Kj?౿PG?ోZo?ో;}?XAC?X>[?$ވ?$i?{-?x-?ా.?ా0?ఊ?ఊp?WQM?WN/C?ȼ?୻J?୻F?େQ6?େ3?TZ?Tuy?!!ؤ?!w?2y??଺\n?଺Yqw?ଆ?ଆ̷?Sd`?SF? 4G? 1Yt?\?>B?ૹoNt?ૹls?૆
xm?૆
Z?R?RF?HW?Eu?e_?G?સ?સF?અ!?અb?QG?Qz?]t*?ZV?N?(?0?੷23L?੷m?੄7 -?੄4?P?P?s'?oɺ? Q?`?ਸ਼26?ਸ਼M_?ਃMM?ਃJ0?Orb?OU+?ॳ?ॳo?ी1u?ी?M3u?M0T?Җ?z
?qW1"?n:?ळ ?ळ
o??ke?LM?LJo?쵠[?2s?勤o?刈T?ࣲ*j?ࣲ'*?~ɝ ?~Ɓ	?Kh?KeYl??j	?,?䣽?ࢱFx6?ࢱBM?}0ip?}H_?Ji~?JM?#aH? Sm?v?q?ࡰbM?ࡰ_1"?}	?|?Ic?I?@S?=j~?p
??࠯݅?࠯|j?|?|?HҌ?H#?^KhF?[/x?W?$??f:?{=e?{:Jg?G,w?GB?|??y
?՞t?*G?R??z\V?zY_?F?Fo??~??G?E;,?ި?ۍ6?BQ?{^5?u?l[?w2?wa?D`?D]qb??3?ݡ}?ݞ
g?B]]??B
?v?v?Cï/?C?$f?!jn?P?6g?f&?c_?v?v?B?Be?HF?Ej?ܑ?=??J`?u+^?u(?A?A?n/T?k'?\?B^??yj~?tQw?tNf?@
?@?
s?
Y?5$?]=?Z#?E2??rz(?ra^??B($V???}'?߆?L?؅?؂'?'k?$R]?qA?q'?>k `?>h6?
?	n?׮?׫⢡?P?MߋC?p?p?=2?=?
7+?
4?Pl?7xz?{?xf|?p?pg??jd?jaZ?7K?74!?U?-?O58?L_?U?p?i[^?iD;?6;9˗?68"4?"05?
?σ:?md?'5?#n?h?hZM?5o+?5lq?HD
?0?ηoB?δW?[K?Xd?gܠ?g`Y?4"0?4)?HsĈ?E\?)??4??g5Q?g2A!?3 //?3	(*?~?{g?#5? ??ĹW?flu|?fi^"?3$B?3
???
w?Zxb?W?r(?\?eL:?e5?2I1?2Fl? z?	s?˓w?ː1?8e?5v1?d,	?dto?1F5?10 5?'jY?$TF?̙?Ƀ)??qN?n?d&?d!?0f?0P?ag ?^)?(v?_??c?cRJ?cN)|?/7?/8?,?f?By???o?Y?b![?bk?/3Y?/0[?٤$?֏?w2?|a=h?%SX?">/'?a;+?a%?.q.;?.n?+??ǽ3?Ǻ>8?cG`?`1j0?a	e9?aOz?-^?-xc`?~U0?~R1?~g?~D?~I@?~4?~`Hry?~`E?~,R?~,T?}h^?}S?};ݷ?}8t?}^N?}H?}_6p?}_?},/u?},,jN?| ?|?||%?|y[?|#>?| n?|^EV?|^0?|+q?|+m$	?{)b?{;?{ľML?{Ļi?{ez?{bh?{^?{^	Ԇ?{*?{*?zZ4?zWv?z?zD?z?zG?z]P9p?z]M$K?z)t?z)`Y?y?y
?yF
g?yB?yj9?yU?y\5h?y\?y)T?rg?r=?rW8S?rW?r$<Љj?r$9r]?q(?q^?qV?qR?q8?q5?qVD-?qV1=T?q#}R?q#jC?p3?p06?p`?pك?poD?p]?pV/~V?pV,Ľ?p"J?p"7?ov?oȗ?o,S?o)A%?or?o*?oUR?oU|x`?o")7S?o"&%e>?nd?n?n|?ny?n&5?n#qʻ?nT_?nTM ?n!zFs?n!w4?m$8?m!&s?m7?m$Ⱥ?mx@B?mu.?mT"VO?mTD>?m wa?m e:o?lv?ls?l ܀?lm?l 2?lx?lSupI?lSr^I?l ˯@?l  ?k2z?k ?kt_?kqq?k$;?kB?kRɮ6q?kRƜe?ktD$8?kq2]?jͯ?j#?jɓ&?jƁr?jtLU?jq:?jRB?jR?j:?jV?itVg?iq?ih?ir?iʛ?iNJ8?iQuU?iQr??i ?ij?hc?hȳ?hvT?hspY?h"?h	@?hPX.?hPF?hx,?hu?g#$?g :?gW
B?gEB?gz?gw?gP&䠞?bv?be?bT?b v?bG?bD?bLB?bL1?b?bp?aMh?aJt?a{g?akc?aQe?aAkq?aLT3?aLQ#&?a"z?a#?`?`D?`[#[?`X?`6A?`&wp?`KUj,?`KE6?`b?`_p[?_6H?_?_?_P?_~jL?_~g?_K?_?_*I?^rj?^ou?^ ],?^?^}͓?^}ʄ^?^J{-?^Jx?^(?^%â?]օ8?]uf?]C?]4T?]}2=V?]}.?]IR?]I ?]Ⱦ)?]?\;h?\8K ?\V?\A?\|?\|A?\IE֓?\IBǒ?\?Z{f?Z{cn?ZHgs?ZHXҭ?Zc6?Zˮ?Yr?Yo'?Y!l?Y^l?Yz2?Yz#?YG{?YG{S?Y-?Y*%k?Xͻ?Xٿ]?XP?X?Xz:s@?Xz7(x?XF?Vߴ1c?V߱3[?Vd%ӂ?Va?Vy ?VyG?VE6p?VE(/?VrjX?VoĒ?U"z]?UlK?U/d?U!?UxH?Ux~_g?UE1aC?UE.?UK4?Uތ?TޑR?TގtG8?TAvI|?T>h?TwwR?Mں(?Mo|:?Mlps?Mt!B[?Mt6}+?M@l?M@	M?M
Z?M
2?L6W?L38?LO}?L:?Lsv?Lsk?L@L?L@I?L?L
?KٱG?Kٮ;u?Kc*?K`wE?KsN?Ks?K?!d?K?϶?Kz?Kwx?J,ɒ?J)?Jr?Jfc)?Jr?JrI?J?D,?J?A?J8?J-N?Iة?IئUP?I\?IYx?Irv[v?Irj?I>Pd?I>D?Iu6c?Ir+{4?H(*?H%?H,4?H ?Hq:?Hq/mZ?H>AVj?H>>K)?H
p?H
t8?Gק?Gפ?GZT?GW/?GqJ@??Gq?$?G=hq?G=V?G
u?G
rœ?F(E?F%?F?F~?FpS?Fp?F=CFD?F=@;Z?F	?F	黹?E֪s?E֧?E^x?E[mv?EpNɭ?EpD ?E<2DK?E<'T?E	z#
?E	we?D.!3?D+"?D,5?D".?DoEa?Do;0?D??:??&?>^"t?>[[?>2?>l.~?>l‘?>9"?>9|L?>5z?>2q2?=Uڞ?=Lv?=>|?=5@?=lW4?=lT+?=9
9
?=9
/ڠ?=K?=A?j?.2(?.2	Q?-B?-
?(o?(l?(d*c?(d']?(0E?(0?'m?'1?'^?'[?'?'?'c֦p$?'cӡR?'0ɸ?'0ĥ?&N?&K?&ߦ?!;?!a?!a?!.$?!.? wݟ? t? 5.? 2? –? ? ax? aڪ? .p	J? .m(?.B?+?D?싱??zz?Ҿ?aiJ@?afF?.'?.$qH?Dɔ?A>?Ǥؙ(?ǡ?c{?`xB?a"-v?a*?-l?-?c??^u?[$!??A?`܈A?`م?-z?-ܻ?ZmF?WB?(?ݒ?N?vM?``cR?`]T?-WQ?-T{y?#? r?֜0?ә>X?#ܰ? ?`U?`R&?-`?-]?/?c?Ɣں?Ƒ?T?Q͎?`b?`?,Ԅ?,с[??	?T?Q	?O?)?_&?_?,$?,"u?UsW?Rp?{|??=;?:?_Y?_
?,WD?,TB?ߢ?f?؉?Շ?C@?A?_Z7?_W
?,i?,T=??	?Ŝ:?ř7?]ɧ?ZǯH?_߃?_ݔ?+?+?9|?7?b}k?_{,?#4? l?^43N?^2t8?+?+?h(?e&?)	?&gY?Z?YO?^F?^	?+n?+kɓ8?0k?-?yJ?w(?gv?f[?^ve?^sdG?+8sm?+5q·?p?O?ļ?ĹM?~?{j?^ADTv?^>C%?+$?+pU?
\?	@?Ĉ?ą?KŘ?H
?^
h?^
i2?*Q?*P(?
P?	c?UҺ?R
?
??]ے?]ؑ:?*?*"?a?^*_?$?!??jw?]	L
?]V?*nQE?*kP?1
?.=?,?5??_^?]|?]y?*??*'??Б?\^* ?\[	?)$Zk?)![T?.?/?°
h?­?vi?sok?\<E?\9?) o
?(!?E"u?FD?Žyy?‹{?T?Q?\?\J?(x?(z0?8??ns?kt?5	+A?2
?[?[V?(dM?(f??*?,g?P)$?M?竍?@?[G?[?(H?(?k1m?h?3&e?0(i?`n?b3?[?[]?(?(n?Po|p?Mq^k?D?t?uݚ?wҼ?[U?[
?(nU?(k?6y%?3{?F?H?#	?%?[B?[q?(V-T?(Se}?<:4?6?a?xq?|?\X?V?UQt?Z`?P}.-?Pw????$??0:?*??·.?PS~?PMQ?g
]?lPV?u%j?o{?A5?{?\a?a?P+Ex?P%K?O~?Uo7?Oz?I?T??t4?n:>?P?PS?rW?xY?,BM?&H?4?:?RGV?LM?O{>?O߁M?xЦ?r?F?MZ???3?-?Op?Ow_?[lNP?UsC?"?鏄;?Vh?}>?%D?,@`?O{?O@?AG-?;NN?
y?DO?j?OL}?OF???ႀ ?zS?ſL??൵h?൯ ?OO?OIp?$?(w\?߂?߂~ra??r?޵WF?޵?OUF?OOѴ??h?݂hn?݂s`?'A?!y?ܵÓ?ܵE?O_[?OYfʛ?Fp?Q?ۂS.?ۂ_?3H?-?ڵK?ڵß?OlI?OfU#B?0?봊?ق&?ق¥?Bt??K?·k?·ey?Qcp?Q
s?-}:?=?ZO?T*}?*
?:?^?n#?QI6?QC8l?߿0?߿@
?߿?߿\?߿:~?߿4#?߾u?߾چR?߾Q~V?߾Qq?߽,?߽&?߽?߽6?߽ynd?߽s?߼ 
?߼m?߼Qƿ\?߼Q?߻m?߻g/?߻?߻5n?߻|?߻ܴ?ߺcU?ߺ] 
l?ߺR
{>?ߺRx?߹	$?߹?߹Y[?߹Sf?߹w?߹7I?߸2?߸w?߸RQ?߸RKК?߷)?߷0?߷r?߷E?߷K?߷E?߶S?߶ȆJ?߶ReU?߳8w?߳]3?߳p"?߲ydK?߲V
?߲S??ߥ ]9?ߥ!?ߥϜb8?ߥɱA?ߥ"~?ߥ"x~?ߤ-U?ߤ'?ߤU,?ߤU
?ߣ:?ߣPx?ߣ;?ߣ5݀?ߣ"f?ߣ"{?ߢ2j?ߢHX?ߢVK$*?ߢVE:,?ߡ:5S?ߡPJ?ߡu?ߡ;?ߡ#[?ߡ#U?ߠY/?ߠo~?ߓc?ߓ+?:?ߓD?ߓ&ԣ?ߓ&μ?ߒA?ߒZ{?ߒZ@?ߒZ:?ߑv?ߑ§?ߑ	?ߑ.V?ߑ'b/\?ߑ'\I?ߐ)l?ߐt?ߐZ?ߐZ!vQ?ߏ~"?ߏ?ߏ?ߋFD?ߋho)?ߋbm?ߋ) 2k?ߋ)?ߊe?ߊq	?ߊ\?߉)0?߈va
y?߈p{w?߈]/ѥ?߈])삻?߇h6?߇&A?߇$r?߇?u?߇*]x?߇*W!?߆?߆*e?߆]<ڣ?߆]X[?߅y?߅AO?߅F^?߅@,?߅+?߅*G?߄Ļa[?߄ĵ?߄^vq)?߄^po?߃1?߃+J?߃%?߃൲?߃+(4?,Z?~ƿF	?~ƹb?~`|te"?~`v 9?}9?}3A?}C(?}`|?}-`q?}-T?|r-
?|l4?|a0p:?|a*?{*?{Xw?{8F?{y0?{.kL?{.ej+?z)8?z#V^?zau*?zan?yXf?yv?yfT#?y`qÓ?y/%v3?y/?xX?xܭ?xb."?xbKq?wcW?w]N?w#G?wG?w/cVf?w/݁i?vɣl?vɝ$g?vccK?vc]?u#X?u?uq1?uސR?u0N?u04|?teF?t_i?td&Z?td [?sa?s
4?s*Dž?sI?s1j~?hi	%D?hi?hϪs{?h\?g+?g'?g6[4
?g6UC?f!?fʙ?finK?fi@?fe?fݫ?euZ?eo"w?e7;'?e75;?dJ?d?djsY?dj?d8?d?cXZ?cR|h?c8:?c8?b&?b?bkj@?bk5?bwi2H?bq:t?a??a9?a9Ł?a9?`S\p?`u?`l?`l?`aer?`[*?_*?_$S?_9
?_9ؚ?^Ӽ~?^ӷf?^mU@?^mw7?^Oq#?^J8g?]Yj?]3?]:n?]:ݐ>?\ԭp^f?\ԧ^?\nwc?\nqw?\A;?\<b?[e?[,?[;e"?[;*(?ZաПf?Z՛?Zol?Zof!?Z	7ڇ?Z	1
v?YN\?Y>?Y<΄(?Y<ȧ?X֚?X֔8R?Xpe?Xp_n?X
1?X
+g?W?W?W= Q?W=
,j?Vז>\?Vאb{F?Vqb?Vq\?V/f??V)?U60?U[F?U>/?U>S?TؖOL?Tؐs˒?Trc?Tr]=?T1k?T+,^?Sj?S" ?S?`?S?ƅ?RٚK?RٔpW?PڢI-?Pڜn?Ptq(?PtkM?P@/?P:UP?O_?O	?OA޷T?OA?Nۮ7?Nۨ]?Nu}*?Nux?NM?NGH?M?MѢt?MB?MB؅?Lܾ?Lܸ>Z?Lv?Lv?L_'S?LYMv?K/l?K*?KD*?KCs?Jt?J?Jw+&?JwQD?Jt~?Jnh?IF q,?I@G?IEn?IE2?H??H?Hx?HxӬ?Hf?HH?G`L?GZs?GF2X?GF,a0?Fzb?F?FyO?FyvJ%?FL)?FskW?E~q؈?Ex-8?EGQYa?EGK*?D%7?D_?Dzף$?Dz1"?D̠mJ?Da?CF?Cw?CHt?CHnGg?BH@?BC?B|\?B|_?B?BF?AƯ?A?AI^?AI*?@pX?@j=?@}Ee`?@}@_?@@?@ht.??ʩ????J~3??J?>Z?>䖃|?>~r`z?>~l'E?>H?>Bm?=潵?=g?=Kgv?=K[?<>_?<:7D?</?<
;?<y&?<t	9=?;Q"?;K.T?;M(Sn`?;M"|?:P?:%?:kL3?:є?:4?:^v|?9'?9Qb?9N_F(?9NYo͍?87?81ј?8j?8
-5?8?8?7f7?7)?7OU?7O	?6sn?6m?6L/?6FZ
?6&n?6 G7?5M?5ܞD?5Pq?5PӛM?4Yj?4ꭃ?4kN?4w?4g?4aM?3BC?3<6Bg?3R$H?3R?2RO?2}%n?23?2^j?2?@?2j=h?1tE?1U?1Sc?1S]?0?[9?09L
?0?087?0 ?0 ?/"?/<?-!z*D?-?-Uy ?-U?,ۣ?,ϕ\?,"?,#?,#tK~?,#fr?+tkr?+nG~?+WQH?+WL??*/+?**L?*D?*8K?*$ZtP?*$?)v?)?)Xu?)X)n?(A%?(n?(g8U?(ae?(&FXʜ?(&@?'%&?'?'Z?'YD?&?&?&~k?&?&'p&?&'3?%?%~?%[dB?%[_?$EE?$?r{|?$%z?$ 
e2?$)6?$)Ґ?#,(?#?#\ȭ
?#\J?"a?"w?"^?"?"*lc?"*g$?!Nj?!H?!^0 ?!^*>? s? ? ? *$? +g? +і?Ź|?Ŵ-?_?_rv?f?yje?bD/?\E?-F)P?-@>}?)~h?#S?a
q0?aFN?;?	Ѭ?I??.t?.i?ȝ$Z?ȗS?b6?Ώ?h}.?hw^s?e`?_N?M8w?GiW?65~?6/?"?	?j(?jB?P?ߕ?B+F?sko?7^`?7?ѪM?Ѥ״;?k?kJf.?}?w.?gT?a,?9Qs*?9Kz?
;$?
5?
m%6?
m ?
Qa?

M?ʨ?#ɫ?:A!?:S:?гu??n?nW?"u?U:?
4=?
͒?
<~>#?
`?>,1p??ә?qs7e?q.?q/\?ۤ9?Κ?ͯ ????$?٩vMD?٣?s&?sY??
r?
5?s
?m=?Aa=-$?A[p?O&?8;?/xao?)[?H!?HK5??
J?|?{
??.?F?|2?I0?I!?f?Ȝ/`?}8?}n&?6n?l?`qT?*i?K?KO?8?nm?h?|?u?o
h?i_?cx?M]?MX/w?RXk?LO?F?Af?;$?5g?0}7?*?O%Z?O?ݐ?{?/?
fL-?Ç?K?g??Pp9q?P#?Z???E??\r?v??78?R
?RQ?츝['?Է??va? "? F??:?T2~?Tj5??>?툆F?툀?w?"~4l?"xl˹?vx?p?Vox?ViS?g}{?b?`?Zۗ?$Yț?$Tn?S>=?M>?XLp?XF?Fa?@@F??I?:?&9?&3l?3?."?Z.#%)?Z([Y?(?"?#=?v?(?(G?r?DB?\5&?\n??	l?x2?I?*H?*??j?]0?]2?Y??Ew??+qm?+0??5?_?_e?8??ߕ?o?-R,?-ߌK?h?,
?aྜ-?a?޸]8??ߕAB?ߕ?/3`?/m?ٴr?Z?cbܞ?cҝ?>i?y ?ݗG?ݗЁ?1|?1Ϸ?p??epLW?eΫO?-?ha?ۙ?ۙSa?30?3k*?u?α>3?g|?g#'?Ո~??ٛU?ٛБ??5P>?5ыw?x.6?ҳ'?in@?i	0C?P/z?Ռ?םB$?ם<*I?7ݾ?7?=?$?k!?k]2?ڻ?%?՟A?՟V?9?9b?`)??m2?m!?.?k?ӡh?ӡ?;L,?;?"?_?p'du?odDy?
Y?
?ѤD?Ѥi?>Gx?>
??@1]?rY\?r)??@u?Ϧ$H?Ϧ	?@)_?@#?/\[?)?t5*?t/h?;'w?5e)?ͨAR3?ͨ;?BGja?BAB>?N0?Hn?vTr?vO#p?[>O?VO]?˪b׀.?˪]L?Djn?DdS?q?kI?xy>W?xsZ??{"S?ɬ?ɬo~?FP?F=?Q͎?w?z}?z9?G!??Ǯ^ ?Ǯ?Hi8?H.^?Ţm?u?|	?|H?؟g?ޖ?Űc/5?ŰܢqD?JU~?Ji?uHN?}?ÿ?~:Y?@f??ó냝?ó+$?M \?M?+q?&9w?7c?1B=?Bf ?G?޼/?޼-(	?޼"	B?޼!JN
?޻UP?޻!?޻VZQ?޻V?޺.x<?޺(?޺=O?޺7?޺$LUn?޺$F<:?޹[ڨ?޹UX?޹Xj?޹Xe6?޸z+9?޸t1?޸RJ?޸Q?޸&F?޸&|?޷jEw?޷"?޷Z?޷Z?޶>/?޶ŀq?޶L?޶0cL?޶(Z?޶(?޵ۣ?޵9?޵]?޵]	[@?޴ м?޴3F?޴21?޴,bO?޴+C?޴+>,lB?޳Un?޳P%q#?޳_h
.?޳_bM?޲zbN?޲t ?޲*I?޲*(?޲-j?޲-R?ޱDzŲ?ޱǬ?ޱaŕ0
?ޱa>?ްמ"?ް:?ްIXs?ް挌?ް/#j?ް/-j?ޯ?ޯ
Y?ޯd')8?ޯd!?ޮ;}?ޮ6*b?ޮPEX?ޮJ?ޮ2dȯ?ޮ2_o)?ޭy{?ޭs{?ޭfx;?ޭf?ޭ^?ޭ_?ެE[?ެ!8?ެ4Vh?ެ4Țnm?ޫ?ޫB?ޫhi"?ޫh?ޫw.?ޫ
!?ު&f?ު X*Z?ު7?ީS)?ީMS8?ީki?ީkd?ީ?ީ{D?ި2?ި.F?ޤ>?ޣؼ
(?ޣضO?ޣr՗\-?ޣr?ޣT(?ޣ?ޢ	@??ޢ[;?ޢA#\?ޢA?ޡ=g?ޡ7\?ޡuX#?ޡuRi?ޡr?ޡm/?ޚ1-3?ޚKU?ޚKO^q?ޙs&_$?ޙmm1?ޙeg?ޙL?ޙW?ޙ?ޘu?ޘȼ?ޘMD?ޘM猤?ޗD
?ޗU?ޗ+u?F?ޗ%#?ޗJժ?ޗE6?ޖjfY?ޖdc?ޖP'>?ޖPo[?ޕ[?ޕ`?ޕ9?ޕĂ$?ޕꋵ?ޕ?ޔ
X?ޔV!?ޔS+?ޔS&?ޓLT?ޓFq?ޓm?ޓg?ޓ!G?ޓ!A?ޒm.?ޒ
?ޒU4?ޒUZ?ޑ6?ޑ.,?ޑ?ޑ3?ޑ$8 CR?ޑ$2iX^?ސZ-?ސTU?ސX}?ސXwe?ޏX?ޏ,C?ޏڤ?ޏ$?ޏ&?ޏ&K ?ގ	Zi?ގe?ގ[,?ގ['-Z?ލP6?ލJA?ލtA?ލn	?ލ)F?ލ)?ތü8?ތ÷6?ތ]h?ތ]۲}?ދY?ދ_fi?ދ*0?ދ%?ފo͹?z9X?ylP>?yf?yE ?yEQQ?x钂?x70?xyj?xyN8?x$H&?x?wR?wM?wHnN8?wH{8?vKHj?v⪙F?v|Y?v|٧?v?v ?u>?u8Y?uKmo?uKgg7?t坄-?tҊg?t͊&?t)?t9?ts?s.,;?s({i&?sN^b?sNY?r菕~?rrz?r?r㆒?rf ?rH-?q#'΍?qvã?qQT	?qQO5?p놁Y?p
?py?p?p2?ps??o-?oMl?oTO?oTI?nJ/?n|F?n;?n:?n"^b?n"?m?mZ?mWO;q?mWI?l1?l}I!?lH?l8p?l%	?l%Y?k]?kh?kZS?kZN3CD?jM?j?j ?j
?j(=?j(Q?i'2~?i"?4?i]]o?i]W%?h"?E?hr?h}?hWJ?h+0?h+n?g5g}?g/TZ?g`k?g`f3?f?f?fq5?f??f/?f/
ؔ?eGtV?eBW?ec??ecy?d&?d:|?d	?dr?d2&gH?d2!$g?c_/?cYeU?cf?cfط?c,~?c~3?b	p?bV8?b5Bԟ?b5<`?a{K?au?ai~?ai?a\?a\?`(1
?`"5E?`8b7@?`8\&?_Ҝqbo?_Җï?_lY?_l/y?_{f?_C?^LL?^Fg;?^;Pp?^;#?]†?]ռzj?]oT?]oBv?]
9S?]
3%?\uY{?\o?\>Z?\>?[(,?[3?[s)m?[s$G?[
f~?[
`?ZYC?ZA?ZAW?ZAګ	?Y?YXU?YvZ?YvU@t`?Yf?Y^??XMf?XС
k?XEIF?XE*?WRy?WLڽ?Wy"?Wy.?Wp'?W?V7V?VR?VHM2?VHGп?U`x?U↴?U|?U|7?UT?U
?TK?TEoD?TKQ?TKh?SC
G?Sŗl?SNo?S?SL>?SFQ?R	-?R]?RN?RN[?Q7?Q	B?QP
?QJS?Q3g?Q?P6?PSV?PR?PRQEn?OX-H?OR?O?O(_?O )?O ~?N[?NJ'?NUb)?NU]H?M$?Mz^Q?M?Mߋg?M$-"J?M$'x7?Lp,x?LkD
?LXt?LXCu?K ;;?Kv??K=h?K7܀?K' ?K'|v,?J?JCD?J\w?J\Cȟ?IQ!y'?IKw?I?Iu?I*$|?I*z,?H!e?HIN?H_g?H_bKv?G*n?G1l?GM?G?G.;0?G.5u?FȂ?F|W?Fbs?Fb\C?E4?>/
?>p+&?>pzF?>
?>
aC:?=
?=ؾ;?=?b+{:?=?\?d?<ٮ
?<٨c+??5&͓?5!'H?5Mv?5Mp?4ƊUs?4?4b:?4Ȩ?4g$?4asW?3e?3	a?3Qy0?3Q?2Yw?2SҮs?2gB?2,?2[?2n3?1M?1H
Y?1T?1T۸?0=?0O?0CV?0>{>?0#/?0#=?/??/-??/X;"?/X6m?.򎶏O?.?.?.SA?.'5m:?.'/%?-?-s;?-[B?-[R?,1#?,+f?,S=?,?,*?,*--?+.)?+(2?+_j?+_}'9?*؅?*?*-?*(2>?*.[$?*.}y?)/1?)q?)c/?)c)`sC?(''?(&?(ۀ(?(z?(22
=?(2,jC?'̈Ͻ?'̃,l?'f,?'f#?'6V?'1P?&T;?&;?&51?&5GD?%=$?%8J?%j?%jNI?%?%G[?$FSy?$@[2?$9?$9PYF?#?#$m?#nP?#nK-u?#
?#kH?"b?cT?
O?
Iz?
*j?
"?
3?
3Sܻ?}Q?xQ$y?g"N?g݄l?HҎ?BA?+4?*?7xU?7b?
z
x?
tn?'?
kM?
kگ?
Fk
?
A'µ?	sWu?	?	;W]?	;H?{q?u=?o?o$`?
JH?
DQ??j??Y??b?ق-?|?s꒹?sS?S-?MH??ba?C%?CjB?ݎF)?݈xm?w/g?w?afi?[3?H’?ŬJ!?G5aD?G/߂?៰R?6?|
5?|?t?oUw??H?KK;A?KEr4?n@?M>?"	?h?"4?6T??:8o?Oft?O`th?ҁ@???)T?9#?H?l??Y?Si?Su?섏?QN?a-?\?"ϖ^?"z?= ?8"{?Wv?W???|C]??&~?&=(?gY9?b?[(?[ю*3?F?A5q??%?+&?+!(K?ŗ?őt3?`?`5?xKؾ?r?d_?hx>~?hrГ?a?H?^y!?X٨?7P?7.Y?EMY??^?l
j?lql?,?'e?*H?𡛑_?<?<?֊&?ք?p?p_6?t6'?ng??L?E1?@^]?@Y =?l27??uJVԥ?uD}?x'??6yv?1:ND?Dc?D{?$,C?>?y,e?ys?d?>?ꮉx%?ꮄ;?Iz\?H⣘?yXZ?s2	?}oH?}n?i?d%7Q?BS?ܪ?MZ??MUg?Ϫ?\@?M +?G?ƄB\? ?@ 	?:o?Q?Q\?32?.g?冮Al?冨?!(?!#%?代o,n?仝|?VY?VY?{?4?նH????%g\?%7?1V??Z2?Z,?ls?H?Ꮐ?{GY?)?)A?zhCP?tQ?^f{?^뇫?t҄?o?2N??g;?a?gN?g-?f?`q?ۜ"?ۜ+
?7e>?7`V?6?Ga}?lf>Dw?l`M?ؗ?C`?١g?١b|}?;?;!J?i?dd;~?ps*?pf?m'4?gx?ץ"?ץ~?@q6?@k??G?uv'?up}(?P(?`^?ժ{~?ժve?D6?D4n?߂1M?}x?zbbh?zμ?N???ӯrd?ӯ+?IM?I;[?d?d?~2¼?~|
?!9}?I?ѳxA?ѳ巀?N+?N&],?象a|?f?Ѓ7?Ѓ1=???ϸD]?ϸ>t?Rʚ?R?Qf?K6	?·k`?·d?"_A?"Zˬ?ͼ-?ͼ>"?Wn?Wi%?+F[?+?=C1?8c?`,?`KU?Q?Llv4?ȕW?ȕI?0fl?0aYQ??$?e|f?ew)?=?gn?ƚoT?ƚG?5*?5/\?ϫ?ϥw?j7)?j1?Äl?=?ğP"?ğJs>?9aJ?9U{?i?d\L	?n,e?n?	?	?¤V?¤Ʀ?>B?>?.fP?(&?sH?s3:?KZ?Eʉ?*p?ԚQ?Ci3?Cc	?ݿvr?ݿ槱?ݿx@%?ݿxb?ݿs3?ݿ?ݾ?ݾV?ݾH7?ݾH2.:*?ݽ3?ݽ`?ݽ}XS>?ݽ}S)?ݽ@#?ݽ?ݼz?ݼu`?ݼM[?ݼMR:?ݻa}?ݻp*?ݻ/|F?ݻ)?ݻxT?ݻ?ݺSFL?ݺM"?ݺQ3?ݺQ#r1?ݹxWD?ݹr\?ݹ5Q?ݹ?ݹ!M?ݹ!1?ݸ1?ݸ,37?ݸV+??ݸVܜ?ݷX?ݷSbD?ݷ`?ݷalf?ݷ&(e?ݷ&{;?ݶ@?ݶ1?ݶ[GLi?ݶ[HP?ݵ?-_?ݵ9ns?ݵMJS?ݵοl&?ݵ+i{?ݵ+d*C?ݴ:X?ݴ?ݴ`?ݴ`zQ?ݳ+BJ?ݳ%?ݳPf?ݳ?ݳ0Wnr?ݳ0R>?ݲr?ݲt?ݲeoD?ݲeo?ݲ3?ݲ
?ݱk?ݱm?ݱ5KxG?ݱ5F
j?ݰn?ݰ?ݰj{~?ݰju=?ݰz?ݰ.?ݬH?ݬؼ?ݬtx!?ݬts?ݬ-Z?ݬ
*?ݫO3?ݫkJ?ݫDHg?ݫDCo)!?ݪ9+?ݪޭM?ݪylt?ݪyz%?ݪc?ݪ/?ݩP(?ݩ?ݩISw?ݩIM!t?ݨ?ݨMb?ݨ~tb?ݨ~?ݨ)J*?ݨ#V?ݧZ;F?ݧ?ݧNc?ݧN^?ݦ)?ݦe-?ݦV?ݦ]?ݦ<,?ݦ7W1?ݥ0?ݥՋ(G?ݥSy?ݛV?ݚ
:?ݚe?ݚ=*7?ݚ=%cue?ݙW?ݙ}n?ݙru[7?ݙroi?ݙ
?ݙ
bf?ݘ"?ݘ-o?ݘBf6?ݘBa3c?ݗ?ݗtp?ݗwx?ݗwf?ݗZ/H?ݗT?ݖ!?ݖ?ݖGO+`?ݖG&?ݕO?ݕJ/?ݕ|Z?ݕ|?ݕ9?ݕ?ݔGSO?ݔA˖?ݔL5?ݔL ?ݓ8N??ݓ環?ݓAR?ݓ;|?ݓ
$?ݓ䂩?ݒK0?ݒĄ?ݒR<?ݒR7A{?ݑo?ݑ?ݑtj?ݑI?ݑ":#?ݑ"5s?ݐ
&?ݐ߆*?ݐW?ݐW+J?ݏ:0?ݏ5Ev?ݏ?ݏ(I?ݏ'x?ݏ'Ȱ?ݎ<?ݎ7|"?ݎ\g(?ݎ\?ݍp?ݍ<?ݍ@L?ݍ;/=;?ݍ,5?ݍ,篖?݌ǙT?݌ǔkw&?݌bFw?݌bAb;?݋?݋p?݋a?݋?݋2O3c{?݋2Iq?݊?݊U?݊g9F$?݊gy?݊Yx	?݊Tt?݉-=?݉H?݉7?݉7{?݈fS?݈`d?݈ma_?݈m?݈쬉?݈gQ?݇t?݇o.l?݇=$?݇=1O?݆?݆o?݆ro"?݆rw?݆
6%ϛ?݆
0m?݅?݅n?݅BE?݅B?݄I:?݄D*?݄wU]?݄wЭ?݄6?݄P?݃_T?݃Yf?݃H?݃H)$?݂Cj?݂⾿?݂}w4?݂}q{z?݂*",?݂$b?݁kn?݁C?݁M?݁Ml?݀D?݀?.?݀K?݀+A?݀N?݀e4?a^?[ڷ?SW?SZ?~d?~z
?~'p?~zg?~#5I?~#0	%?}/V:?}?}X
N?}X/?|W'H?|Q?|
~c?|-?|(`?|(?{z.?{u\a?{^1&d?{^,h)?z2.?z㯡A?z%
?z3N?z.Xu?z.R;?yr'(?y
v?ycȪ?yc'?x9?x{S?x9G?x4M?x3?x3;I?wΫz?wΦe(.?wieM?wi_Tc?w?wm&?vh?vL?v9I?v9hB?uMB?uGI?uo" ?uoTAE?u	¦s?u	$?t}?tx1?t?8'?t?3{y?s/r?sR?stE9?st'?slDA?sf
?K h$?K c?J=?J7?JV?JV`Q?I?I`PJ?Izl?I?I&Se?I&?HgPz?Ha?H\=J
?H\7З?G?G?G6?G~?G,?G,3?FǗ?Fǒ&?FbnѪ?FbiX?EFA?E@ȼ?EB?EwR?E2K~?E2do?D/?Dȏ?Dhr?Dhb?DI)?Dy?CXa;?CRЁ?C91("?C9+?B
?>s>?>{rU?>{l?>NT?>H?=*op?=%oY?=L?=LA|?<]??*V
M?*Vv?){[?)u?)d2|?)^Gu?)'MRJ?)'H1*?(7WF?(1Y?(]!I?(]Ջ?"2?"Al?"pglA?"p_?"[^?"?!ЏdF?!-/?!Aq?!AM? ܭ? ܨE? w&? w:? wz? n?{U?u(?Hk	`?He?Z?U?~K3?~E.?;?67?,^?&$?OTo?O?w?	#k??if?B?FR?X?c>?49?44#Ѱ?/Pm?)?j%N?j+F?P?'?
t??;u>?;Yy?
2?YhQ?p	-?p񙞵??z?KZ??AM]h?A?֐v? ?wf?wɤ6?U?h8?
.?mg?H!j?Hr?㳧?8?~nQn?~P?u?!L?,?Oz?OGG?Oخ,?
+@?
ꑢ?
?
^O?
 gX?
 ??`?V?VR??{`?}?w?'y_?'t??
v~4?
qE;?
]s,?
]n$P2?	p魡?	k{?	nRj?	i?	.l\
?	.ff?jv?e	N?dh߹?dcea?gp	u?b'?fNQ?`?{Ҳ?7K?lF?QqV?Q?~?숁4r??>Ty?"?"Z?!Ԯ??1^S??+?;,
?6V%'?uFc~?u@?QH?K͌?\o`?W?Fgآ?Fbn?RBJ>?^T?Ye1?u?p3y?#?#:?ᾤz?ᾟ'?Yk?Ya?Ԍm?&?q?	?+F?+0M{?@7?Z?a7?a2E)]?Q|?K?ޗj0?ޗee'?2?2Y\ ?͞?͙^?hod?h
AZ?,Y??ܞ+?ܞƓm?:
nV{?:	?%? zm?pA܄?p?55?_8?_A?$@?h(S?ĖO	?ĖJ}?1{8b?1uפ?̦?̡u:?gҷY?gVA?ܽ?|8O?ž+F ?ž%M?9Wn?9R?ԄV?n6?o	v?o/?
ߓ^?
37t?
P?C?A;R?A5?ܿi?ܿd7?ܿw!r?ܿw=i?ܿy?ܿI?ܾg?ܾ?ܾI%]x?ܾI?ܽTi?ܽO#?ܽ!Z?ܽ?ܽ?ܽm?ܼs?ܼ?ܼQ$I?ܼQ{?ܻG_?ܻA?ܻxR?ܻr+?ܻ"ϓ?ܻ"pB?ܺۑk?ܺ2q?ܺY
?ܺY8?ܹ?f;?ܹ:?ܹrqa?ܹm
?ܹ*E?ܹ*p_?ܸ]2?ܸ[?ܸa?ܸa[4P?ܷ?Z.?ܷ9J8?ܷs@@?ܷmݾ?ܷ2jJ?ܷ2F?ܶ?ܶz}?ܶiQ?ܶi-?ܶEF?ܶ@%?ܵz8?ܵub
S?ܵ:@(?ܵ:?ܴkW?ܴ਌!?ܴq?ܴq|?ܴR_K?ܴM!?ܳZ?ܳ?ܳBʵ?ܳBm!?ܲs?ܲ?ܲy.Hx?ܲy(nO?ܲe?ܲ`=?ܱ֓?ܱ|?ܱJ	g?ܱJЬ2)?ܰ}F?ܰ	 z?ܰG6H?ܰAT?ܰ4?ܰz׸?ܯw^*?ܯs?ܯR?ܯR?ܮ, ?ܮ'n\'?ܮf:?ܮa'?ܮ$2>H?ܮ$՟^?ܭY?ܭpE?ܭ[Ǐ?ܭ[PNS?ܬQd2?ܬLt?ܬ:?ܬޖU?ܬ,X?ܬ,Í?ܫܻ?ܫ?ܫcA*?ܫc;?ܪ}HD?ܪx6@?ܪTW?ܪ?ܪ4[?ܪ4?ܩ4Y?ܩ/L7?ܩkr9F3?ܩkl݉X?ܩ?ܩ?ܨ*?ܨMa?ܨ=,I?ܨ='/X?ܧk0H?ܧeM?ܧsP?ܧs?ܧJ?ܧ?ܦ(j?ܦ#di?ܦEhy?ܦEc?ܥx?ܥe?ܥ{W?ܥ{dV?ܥ)M?ܥ#A?ܤj!z?ܤdƟ4?ܤM:S?ܤMU?ܣ?ܣ>L?ܣ.ҿ?ܞf%??ܞ}?ܞU?ܝ'eG?ܝ"=q?ܝ8ma?ܝ8h.?ܜӳ*?ܜӮI~?ܜn*N?ܜn?ܜ
@?ܜ
;?ܛ	?ܛb?ܛ@a?ܛ@?ܚ?ܚ?ܚw^?ܚwY"n?ܚY"?ܚz?ܙ{Q?ܙ"&?ܙI80?ܙI2`?ܘ*?ܘ{healpy-1.10.3/healpy/data/totcls.dat0000664000175000017500000040566313010374155017540 0ustar  zoncazonca00000000000000     0    0.00000E+00    0.00000E+00    0.00000E+00    0.00000E+00
     1    0.00000E+00    0.00000E+00    0.00000E+00    0.00000E+00
     2    0.17261E+04    0.67367E-01    0.27107E-01    0.36347E+01
     3    0.15364E+04    0.10453E+00    0.31381E-01    0.36945E+01
     4    0.14360E+04    0.11664E+00    0.30865E-01    0.35829E+01
     5    0.13686E+04    0.10460E+00    0.27188E-01    0.32291E+01
     6    0.13225E+04    0.79333E-01    0.22020E-01    0.27779E+01
     7    0.12930E+04    0.52648E-01    0.16767E-01    0.23139E+01
     8    0.12745E+04    0.32182E-01    0.12342E-01    0.18617E+01
     9    0.12631E+04    0.19942E-01    0.90690E-02    0.14629E+01
    10    0.12579E+04    0.14374E-01    0.69485E-02    0.11590E+01
    11    0.12577E+04    0.12453E-01    0.58401E-02    0.95013E+00
    12    0.12607E+04    0.12156E-01    0.55031E-02    0.82618E+00
    13    0.12650E+04    0.12104E-01    0.56960E-02    0.77466E+00
    14    0.12706E+04    0.12161E-01    0.62552E-02    0.77381E+00
    15    0.12780E+04    0.12501E-01    0.70366E-02    0.79957E+00
    16    0.12873E+04    0.13259E-01    0.79184E-02    0.83150E+00
    17    0.12985E+04    0.14406E-01    0.88676E-02    0.86375E+00
    18    0.13108E+04    0.15870E-01    0.98735E-02    0.89415E+00
    19    0.13240E+04    0.17582E-01    0.10925E-01    0.92050E+00
    20    0.13374E+04    0.19469E-01    0.12013E-01    0.94061E+00
    21    0.13509E+04    0.21477E-01    0.13126E-01    0.95269E+00
    22    0.13642E+04    0.23605E-01    0.14264E-01    0.95661E+00
    23    0.13775E+04    0.25871E-01    0.15424E-01    0.95262E+00
    24    0.13907E+04    0.28288E-01    0.16606E-01    0.94099E+00
    25    0.14039E+04    0.30873E-01    0.17809E-01    0.92198E+00
    26    0.14171E+04    0.33641E-01    0.19032E-01    0.89586E+00
    27    0.14304E+04    0.36608E-01    0.20275E-01    0.86288E+00
    28    0.14437E+04    0.39789E-01    0.21535E-01    0.82332E+00
    29    0.14571E+04    0.43200E-01    0.22813E-01    0.77743E+00
    30    0.14707E+04    0.46856E-01    0.24107E-01    0.72548E+00
    31    0.14845E+04    0.50770E-01    0.25416E-01    0.66762E+00
    32    0.14983E+04    0.54945E-01    0.26739E-01    0.60360E+00
    33    0.15124E+04    0.59381E-01    0.28073E-01    0.53306E+00
    34    0.15265E+04    0.64077E-01    0.29417E-01    0.45562E+00
    35    0.15408E+04    0.69035E-01    0.30768E-01    0.37092E+00
    36    0.15552E+04    0.74252E-01    0.32125E-01    0.27860E+00
    37    0.15696E+04    0.79731E-01    0.33484E-01    0.17829E+00
    38    0.15841E+04    0.85470E-01    0.34845E-01    0.69630E-01
    39    0.15987E+04    0.91469E-01    0.36206E-01   -0.47747E-01
    40    0.16134E+04    0.97729E-01    0.37563E-01   -0.17421E+00
    41    0.16280E+04    0.10425E+00    0.38916E-01   -0.31011E+00
    42    0.16428E+04    0.11103E+00    0.40263E-01   -0.45583E+00
    43    0.16575E+04    0.11808E+00    0.41602E-01   -0.61172E+00
    44    0.16724E+04    0.12539E+00    0.42931E-01   -0.77815E+00
    45    0.16873E+04    0.13297E+00    0.44249E-01   -0.95549E+00
    46    0.17023E+04    0.14082E+00    0.45554E-01   -0.11441E+01
    47    0.17174E+04    0.14894E+00    0.46845E-01   -0.13443E+01
    48    0.17326E+04    0.15734E+00    0.48119E-01   -0.15566E+01
    49    0.17479E+04    0.16601E+00    0.49376E-01   -0.17812E+01
    50    0.17634E+04    0.17496E+00    0.50614E-01   -0.20185E+01
    51    0.17790E+04    0.18418E+00    0.51831E-01   -0.22688E+01
    52    0.17947E+04    0.19368E+00    0.53026E-01   -0.25318E+01
    53    0.18106E+04    0.20346E+00    0.54198E-01   -0.28073E+01
    54    0.18266E+04    0.21351E+00    0.55346E-01   -0.30948E+01
    55    0.18428E+04    0.22384E+00    0.56468E-01   -0.33939E+01
    56    0.18591E+04    0.23443E+00    0.57565E-01   -0.37045E+01
    57    0.18756E+04    0.24529E+00    0.58634E-01   -0.40260E+01
    58    0.18923E+04    0.25642E+00    0.59675E-01   -0.43582E+01
    59    0.19091E+04    0.26781E+00    0.60687E-01   -0.47007E+01
    60    0.19262E+04    0.27946E+00    0.61668E-01   -0.50531E+01
    61    0.19434E+04    0.29138E+00    0.62617E-01   -0.54153E+01
    62    0.19608E+04    0.30355E+00    0.63535E-01   -0.57870E+01
    63    0.19784E+04    0.31598E+00    0.64420E-01   -0.61684E+01
    64    0.19962E+04    0.32866E+00    0.65271E-01   -0.65595E+01
    65    0.20142E+04    0.34158E+00    0.66088E-01   -0.69603E+01
    66    0.20324E+04    0.35475E+00    0.66871E-01   -0.73708E+01
    67    0.20509E+04    0.36816E+00    0.67618E-01   -0.77910E+01
    68    0.20696E+04    0.38181E+00    0.68330E-01   -0.82210E+01
    69    0.20885E+04    0.39569E+00    0.69005E-01   -0.86608E+01
    70    0.21077E+04    0.40981E+00    0.69643E-01   -0.91104E+01
    71    0.21271E+04    0.42414E+00    0.70243E-01   -0.95698E+01
    72    0.21468E+04    0.43870E+00    0.70806E-01   -0.10039E+02
    73    0.21667E+04    0.45345E+00    0.71331E-01   -0.10517E+02
    74    0.21870E+04    0.46839E+00    0.71818E-01   -0.11005E+02
    75    0.22074E+04    0.48351E+00    0.72267E-01   -0.11502E+02
    76    0.22282E+04    0.49879E+00    0.72679E-01   -0.12007E+02
    77    0.22492E+04    0.51423E+00    0.73053E-01   -0.12522E+02
    78    0.22705E+04    0.52980E+00    0.73389E-01   -0.13044E+02
    79    0.22920E+04    0.54549E+00    0.73688E-01   -0.13576E+02
    80    0.23139E+04    0.56130E+00    0.73949E-01   -0.14115E+02
    81    0.23360E+04    0.57720E+00    0.74172E-01   -0.14662E+02
    82    0.23585E+04    0.59319E+00    0.74357E-01   -0.15216E+02
    83    0.23812E+04    0.60923E+00    0.74506E-01   -0.15777E+02
    84    0.24042E+04    0.62532E+00    0.74617E-01   -0.16345E+02
    85    0.24275E+04    0.64143E+00    0.74692E-01   -0.16918E+02
    86    0.24511E+04    0.65755E+00    0.74730E-01   -0.17496E+02
    87    0.24750E+04    0.67365E+00    0.74731E-01   -0.18079E+02
    88    0.24992E+04    0.68971E+00    0.74697E-01   -0.18667E+02
    89    0.25237E+04    0.70572E+00    0.74627E-01   -0.19257E+02
    90    0.25484E+04    0.72166E+00    0.74522E-01   -0.19851E+02
    91    0.25736E+04    0.73751E+00    0.74381E-01   -0.20447E+02
    92    0.25990E+04    0.75325E+00    0.74206E-01   -0.21045E+02
    93    0.26247E+04    0.76888E+00    0.73998E-01   -0.21645E+02
    94    0.26507E+04    0.78439E+00    0.73756E-01   -0.22247E+02
    95    0.26770E+04    0.79976E+00    0.73483E-01   -0.22850E+02
    96    0.27036E+04    0.81498E+00    0.73178E-01   -0.23453E+02
    97    0.27304E+04    0.83005E+00    0.72843E-01   -0.24058E+02
    98    0.27576E+04    0.84494E+00    0.72479E-01   -0.24662E+02
    99    0.27850E+04    0.85966E+00    0.72086E-01   -0.25266E+02
   100    0.28127E+04    0.87418E+00    0.71665E-01   -0.25870E+02
   101    0.28407E+04    0.88850E+00    0.71217E-01   -0.26473E+02
   102    0.28690E+04    0.90260E+00    0.70743E-01   -0.27075E+02
   103    0.28975E+04    0.91648E+00    0.70244E-01   -0.27675E+02
   104    0.29263E+04    0.93013E+00    0.69720E-01   -0.28274E+02
   105    0.29553E+04    0.94352E+00    0.69172E-01   -0.28871E+02
   106    0.29847E+04    0.95666E+00    0.68601E-01   -0.29466E+02
   107    0.30142E+04    0.96953E+00    0.68009E-01   -0.30057E+02
   108    0.30440E+04    0.98212E+00    0.67394E-01   -0.30646E+02
   109    0.30741E+04    0.99442E+00    0.66760E-01   -0.31231E+02
   110    0.31044E+04    0.10064E+01    0.66106E-01   -0.31813E+02
   111    0.31350E+04    0.10181E+01    0.65433E-01   -0.32391E+02
   112    0.31657E+04    0.10294E+01    0.64742E-01   -0.32964E+02
   113    0.31968E+04    0.10405E+01    0.64035E-01   -0.33532E+02
   114    0.32280E+04    0.10511E+01    0.63311E-01   -0.34095E+02
   115    0.32594E+04    0.10615E+01    0.62573E-01   -0.34651E+02
   116    0.32910E+04    0.10714E+01    0.61821E-01   -0.35200E+02
   117    0.33228E+04    0.10810E+01    0.61055E-01   -0.35742E+02
   118    0.33548E+04    0.10902E+01    0.60278E-01   -0.36276E+02
   119    0.33869E+04    0.10990E+01    0.59490E-01   -0.36801E+02
   120    0.34192E+04    0.11074E+01    0.58692E-01   -0.37318E+02
   121    0.34516E+04    0.11154E+01    0.57885E-01   -0.37824E+02
   122    0.34842E+04    0.11230E+01    0.57070E-01   -0.38321E+02
   123    0.35168E+04    0.11301E+01    0.56247E-01   -0.38806E+02
   124    0.35496E+04    0.11368E+01    0.55419E-01   -0.39281E+02
   125    0.35825E+04    0.11430E+01    0.54586E-01   -0.39743E+02
   126    0.36155E+04    0.11488E+01    0.53748E-01   -0.40193E+02
   127    0.36486E+04    0.11541E+01    0.52907E-01   -0.40629E+02
   128    0.36817E+04    0.11589E+01    0.52065E-01   -0.41052E+02
   129    0.37149E+04    0.11632E+01    0.51220E-01   -0.41461E+02
   130    0.37482E+04    0.11670E+01    0.50376E-01   -0.41855E+02
   131    0.37815E+04    0.11703E+01    0.49532E-01   -0.42233E+02
   132    0.38148E+04    0.11731E+01    0.48690E-01   -0.42596E+02
   133    0.38482E+04    0.11753E+01    0.47850E-01   -0.42942E+02
   134    0.38816E+04    0.11771E+01    0.47013E-01   -0.43272E+02
   135    0.39149E+04    0.11783E+01    0.46179E-01   -0.43585E+02
   136    0.39483E+04    0.11791E+01    0.45349E-01   -0.43881E+02
   137    0.39817E+04    0.11793E+01    0.44523E-01   -0.44158E+02
   138    0.40150E+04    0.11791E+01    0.43703E-01   -0.44418E+02
   139    0.40483E+04    0.11784E+01    0.42889E-01   -0.44659E+02
   140    0.40816E+04    0.11771E+01    0.42081E-01   -0.44880E+02
   141    0.41148E+04    0.11754E+01    0.41281E-01   -0.45083E+02
   142    0.41479E+04    0.11732E+01    0.40489E-01   -0.45265E+02
   143    0.41809E+04    0.11705E+01    0.39705E-01   -0.45427E+02
   144    0.42139E+04    0.11673E+01    0.38930E-01   -0.45569E+02
   145    0.42468E+04    0.11637E+01    0.38166E-01   -0.45689E+02
   146    0.42796E+04    0.11595E+01    0.37411E-01   -0.45788E+02
   147    0.43123E+04    0.11549E+01    0.36668E-01   -0.45865E+02
   148    0.43448E+04    0.11499E+01    0.35937E-01   -0.45919E+02
   149    0.43772E+04    0.11443E+01    0.35218E-01   -0.45951E+02
   150    0.44095E+04    0.11383E+01    0.34512E-01   -0.45960E+02
   151    0.44416E+04    0.11318E+01    0.33820E-01   -0.45945E+02
   152    0.44736E+04    0.11249E+01    0.33142E-01   -0.45907E+02
   153    0.45054E+04    0.11175E+01    0.32478E-01   -0.45845E+02
   154    0.45370E+04    0.11098E+01    0.31828E-01   -0.45759E+02
   155    0.45684E+04    0.11016E+01    0.31192E-01   -0.45649E+02
   156    0.45996E+04    0.10931E+01    0.30571E-01   -0.45515E+02
   157    0.46306E+04    0.10842E+01    0.29965E-01   -0.45356E+02
   158    0.46614E+04    0.10750E+01    0.29373E-01   -0.45173E+02
   159    0.46919E+04    0.10655E+01    0.28796E-01   -0.44966E+02
   160    0.47222E+04    0.10557E+01    0.28234E-01   -0.44733E+02
   161    0.47523E+04    0.10456E+01    0.27687E-01   -0.44476E+02
   162    0.47821E+04    0.10352E+01    0.27156E-01   -0.44194E+02
   163    0.48116E+04    0.10246E+01    0.26640E-01   -0.43887E+02
   164    0.48408E+04    0.10138E+01    0.26139E-01   -0.43555E+02
   165    0.48697E+04    0.10028E+01    0.25655E-01   -0.43197E+02
   166    0.48984E+04    0.99156E+00    0.25186E-01   -0.42814E+02
   167    0.49267E+04    0.98019E+00    0.24733E-01   -0.42405E+02
   168    0.49547E+04    0.96868E+00    0.24297E-01   -0.41970E+02
   169    0.49823E+04    0.95704E+00    0.23877E-01   -0.41510E+02
   170    0.50097E+04    0.94529E+00    0.23473E-01   -0.41024E+02
   171    0.50366E+04    0.93345E+00    0.23086E-01   -0.40511E+02
   172    0.50632E+04    0.92154E+00    0.22715E-01   -0.39972E+02
   173    0.50894E+04    0.90958E+00    0.22362E-01   -0.39407E+02
   174    0.51153E+04    0.89758E+00    0.22025E-01   -0.38815E+02
   175    0.51407E+04    0.88557E+00    0.21706E-01   -0.38197E+02
   176    0.51658E+04    0.87356E+00    0.21404E-01   -0.37552E+02
   177    0.51904E+04    0.86160E+00    0.21119E-01   -0.36880E+02
   178    0.52146E+04    0.84971E+00    0.20850E-01   -0.36182E+02
   179    0.52384E+04    0.83793E+00    0.20597E-01   -0.35457E+02
   180    0.52617E+04    0.82630E+00    0.20361E-01   -0.34706E+02
   181    0.52846E+04    0.81485E+00    0.20139E-01   -0.33929E+02
   182    0.53070E+04    0.80361E+00    0.19933E-01   -0.33126E+02
   183    0.53289E+04    0.79263E+00    0.19741E-01   -0.32297E+02
   184    0.53504E+04    0.78194E+00    0.19563E-01   -0.31443E+02
   185    0.53714E+04    0.77157E+00    0.19398E-01   -0.30562E+02
   186    0.53919E+04    0.76156E+00    0.19248E-01   -0.29656E+02
   187    0.54119E+04    0.75194E+00    0.19110E-01   -0.28725E+02
   188    0.54314E+04    0.74275E+00    0.18985E-01   -0.27768E+02
   189    0.54503E+04    0.73403E+00    0.18871E-01   -0.26787E+02
   190    0.54688E+04    0.72581E+00    0.18770E-01   -0.25780E+02
   191    0.54867E+04    0.71813E+00    0.18680E-01   -0.24748E+02
   192    0.55040E+04    0.71101E+00    0.18601E-01   -0.23692E+02
   193    0.55208E+04    0.70451E+00    0.18532E-01   -0.22611E+02
   194    0.55370E+04    0.69865E+00    0.18474E-01   -0.21505E+02
   195    0.55527E+04    0.69346E+00    0.18426E-01   -0.20376E+02
   196    0.55677E+04    0.68900E+00    0.18386E-01   -0.19221E+02
   197    0.55822E+04    0.68528E+00    0.18356E-01   -0.18043E+02
   198    0.55961E+04    0.68234E+00    0.18335E-01   -0.16841E+02
   199    0.56093E+04    0.68023E+00    0.18321E-01   -0.15615E+02
   200    0.56220E+04    0.67897E+00    0.18316E-01   -0.14365E+02
   201    0.56340E+04    0.67860E+00    0.18317E-01   -0.13091E+02
   202    0.56454E+04    0.67916E+00    0.18326E-01   -0.11795E+02
   203    0.56561E+04    0.68067E+00    0.18342E-01   -0.10476E+02
   204    0.56663E+04    0.68316E+00    0.18364E-01   -0.91356E+01
   205    0.56758E+04    0.68667E+00    0.18393E-01   -0.77743E+01
   206    0.56847E+04    0.69123E+00    0.18427E-01   -0.63926E+01
   207    0.56929E+04    0.69686E+00    0.18467E-01   -0.49914E+01
   208    0.57006E+04    0.70361E+00    0.18512E-01   -0.35712E+01
   209    0.57076E+04    0.71149E+00    0.18563E-01   -0.21328E+01
   210    0.57140E+04    0.72055E+00    0.18618E-01   -0.67670E+00
   211    0.57198E+04    0.73081E+00    0.18678E-01    0.79631E+00
   212    0.57250E+04    0.74231E+00    0.18741E-01    0.22856E+01
   213    0.57295E+04    0.75507E+00    0.18809E-01    0.37905E+01
   214    0.57335E+04    0.76913E+00    0.18880E-01    0.53103E+01
   215    0.57368E+04    0.78452E+00    0.18955E-01    0.68444E+01
   216    0.57395E+04    0.80126E+00    0.19033E-01    0.83921E+01
   217    0.57416E+04    0.81940E+00    0.19113E-01    0.99527E+01
   218    0.57431E+04    0.83895E+00    0.19195E-01    0.11526E+02
   219    0.57440E+04    0.85996E+00    0.19280E-01    0.13110E+02
   220    0.57443E+04    0.88246E+00    0.19367E-01    0.14705E+02
   221    0.57439E+04    0.90647E+00    0.19455E-01    0.16311E+02
   222    0.57430E+04    0.93202E+00    0.19545E-01    0.17926E+02
   223    0.57414E+04    0.95915E+00    0.19635E-01    0.19550E+02
   224    0.57392E+04    0.98789E+00    0.19726E-01    0.21183E+02
   225    0.57365E+04    0.10183E+01    0.19817E-01    0.22823E+02
   226    0.57331E+04    0.10503E+01    0.19909E-01    0.24469E+02
   227    0.57291E+04    0.10841E+01    0.20000E-01    0.26122E+02
   228    0.57246E+04    0.11196E+01    0.20091E-01    0.27781E+02
   229    0.57194E+04    0.11568E+01    0.20181E-01    0.29445E+02
   230    0.57136E+04    0.11959E+01    0.20270E-01    0.31112E+02
   231    0.57072E+04    0.12367E+01    0.20357E-01    0.32784E+02
   232    0.57003E+04    0.12795E+01    0.20443E-01    0.34458E+02
   233    0.56927E+04    0.13241E+01    0.20527E-01    0.36134E+02
   234    0.56845E+04    0.13706E+01    0.20608E-01    0.37812E+02
   235    0.56758E+04    0.14191E+01    0.20687E-01    0.39491E+02
   236    0.56664E+04    0.14696E+01    0.20763E-01    0.41170E+02
   237    0.56565E+04    0.15221E+01    0.20836E-01    0.42849E+02
   238    0.56459E+04    0.15766E+01    0.20906E-01    0.44527E+02
   239    0.56348E+04    0.16332E+01    0.20971E-01    0.46202E+02
   240    0.56231E+04    0.16919E+01    0.21033E-01    0.47876E+02
   241    0.56108E+04    0.17528E+01    0.21091E-01    0.49546E+02
   242    0.55979E+04    0.18158E+01    0.21143E-01    0.51212E+02
   243    0.55844E+04    0.18810E+01    0.21191E-01    0.52874E+02
   244    0.55703E+04    0.19485E+01    0.21234E-01    0.54531E+02
   245    0.55557E+04    0.20182E+01    0.21271E-01    0.56182E+02
   246    0.55404E+04    0.20902E+01    0.21303E-01    0.57826E+02
   247    0.55246E+04    0.21646E+01    0.21328E-01    0.59463E+02
   248    0.55082E+04    0.22413E+01    0.21347E-01    0.61093E+02
   249    0.54912E+04    0.23204E+01    0.21359E-01    0.62714E+02
   250    0.54736E+04    0.24019E+01    0.21365E-01    0.64326E+02
   251    0.54555E+04    0.24858E+01    0.21363E-01    0.65928E+02
   252    0.54368E+04    0.25722E+01    0.21354E-01    0.67519E+02
   253    0.54175E+04    0.26610E+01    0.21338E-01    0.69100E+02
   254    0.53977E+04    0.27521E+01    0.21316E-01    0.70669E+02
   255    0.53773E+04    0.28456E+01    0.21286E-01    0.72225E+02
   256    0.53564E+04    0.29415E+01    0.21251E-01    0.73769E+02
   257    0.53350E+04    0.30396E+01    0.21209E-01    0.75300E+02
   258    0.53131E+04    0.31401E+01    0.21161E-01    0.76816E+02
   259    0.52907E+04    0.32428E+01    0.21107E-01    0.78317E+02
   260    0.52678E+04    0.33478E+01    0.21048E-01    0.79803E+02
   261    0.52444E+04    0.34550E+01    0.20983E-01    0.81274E+02
   262    0.52206E+04    0.35644E+01    0.20912E-01    0.82727E+02
   263    0.51963E+04    0.36759E+01    0.20836E-01    0.84164E+02
   264    0.51715E+04    0.37896E+01    0.20755E-01    0.85583E+02
   265    0.51464E+04    0.39055E+01    0.20669E-01    0.86983E+02
   266    0.51207E+04    0.40234E+01    0.20579E-01    0.88365E+02
   267    0.50947E+04    0.41434E+01    0.20484E-01    0.89727E+02
   268    0.50683E+04    0.42655E+01    0.20384E-01    0.91069E+02
   269    0.50415E+04    0.43897E+01    0.20280E-01    0.92390E+02
   270    0.50143E+04    0.45158E+01    0.20172E-01    0.93689E+02
   271    0.49867E+04    0.46439E+01    0.20060E-01    0.94967E+02
   272    0.49588E+04    0.47740E+01    0.19945E-01    0.96221E+02
   273    0.49305E+04    0.49061E+01    0.19825E-01    0.97453E+02
   274    0.49018E+04    0.50401E+01    0.19703E-01    0.98661E+02
   275    0.48729E+04    0.51759E+01    0.19577E-01    0.99844E+02
   276    0.48436E+04    0.53137E+01    0.19448E-01    0.10100E+03
   277    0.48140E+04    0.54533E+01    0.19316E-01    0.10213E+03
   278    0.47841E+04    0.55947E+01    0.19181E-01    0.10324E+03
   279    0.47539E+04    0.57380E+01    0.19044E-01    0.10432E+03
   280    0.47234E+04    0.58830E+01    0.18904E-01    0.10537E+03
   281    0.46927E+04    0.60298E+01    0.18762E-01    0.10640E+03
   282    0.46617E+04    0.61783E+01    0.18618E-01    0.10739E+03
   283    0.46304E+04    0.63286E+01    0.18472E-01    0.10836E+03
   284    0.45989E+04    0.64805E+01    0.18325E-01    0.10929E+03
   285    0.45672E+04    0.66341E+01    0.18175E-01    0.11020E+03
   286    0.45353E+04    0.67894E+01    0.18025E-01    0.11107E+03
   287    0.45031E+04    0.69462E+01    0.17873E-01    0.11191E+03
   288    0.44708E+04    0.71047E+01    0.17719E-01    0.11272E+03
   289    0.44382E+04    0.72648E+01    0.17565E-01    0.11350E+03
   290    0.44055E+04    0.74264E+01    0.17411E-01    0.11424E+03
   291    0.43726E+04    0.75895E+01    0.17255E-01    0.11495E+03
   292    0.43396E+04    0.77542E+01    0.17099E-01    0.11563E+03
   293    0.43064E+04    0.79204E+01    0.16943E-01    0.11626E+03
   294    0.42731E+04    0.80880E+01    0.16787E-01    0.11687E+03
   295    0.42396E+04    0.82570E+01    0.16631E-01    0.11743E+03
   296    0.42061E+04    0.84275E+01    0.16475E-01    0.11796E+03
   297    0.41724E+04    0.85994E+01    0.16320E-01    0.11845E+03
   298    0.41386E+04    0.87726E+01    0.16165E-01    0.11890E+03
   299    0.41048E+04    0.89472E+01    0.16011E-01    0.11932E+03
   300    0.40709E+04    0.91231E+01    0.15857E-01    0.11969E+03
   301    0.40369E+04    0.93003E+01    0.15705E-01    0.12002E+03
   302    0.40028E+04    0.94787E+01    0.15554E-01    0.12032E+03
   303    0.39687E+04    0.96583E+01    0.15404E-01    0.12057E+03
   304    0.39346E+04    0.98390E+01    0.15255E-01    0.12078E+03
   305    0.39005E+04    0.10021E+02    0.15108E-01    0.12096E+03
   306    0.38663E+04    0.10203E+02    0.14962E-01    0.12109E+03
   307    0.38321E+04    0.10387E+02    0.14817E-01    0.12119E+03
   308    0.37979E+04    0.10571E+02    0.14674E-01    0.12124E+03
   309    0.37637E+04    0.10756E+02    0.14532E-01    0.12126E+03
   310    0.37296E+04    0.10942E+02    0.14391E-01    0.12124E+03
   311    0.36955E+04    0.11128E+02    0.14253E-01    0.12118E+03
   312    0.36614E+04    0.11314E+02    0.14115E-01    0.12109E+03
   313    0.36273E+04    0.11502E+02    0.13980E-01    0.12095E+03
   314    0.35933E+04    0.11689E+02    0.13846E-01    0.12078E+03
   315    0.35594E+04    0.11877E+02    0.13714E-01    0.12057E+03
   316    0.35255E+04    0.12064E+02    0.13583E-01    0.12032E+03
   317    0.34918E+04    0.12252E+02    0.13455E-01    0.12004E+03
   318    0.34581E+04    0.12440E+02    0.13328E-01    0.11971E+03
   319    0.34245E+04    0.12628E+02    0.13203E-01    0.11936E+03
   320    0.33910E+04    0.12816E+02    0.13081E-01    0.11896E+03
   321    0.33577E+04    0.13004E+02    0.12960E-01    0.11853E+03
   322    0.33245E+04    0.13192E+02    0.12842E-01    0.11806E+03
   323    0.32914E+04    0.13379E+02    0.12725E-01    0.11756E+03
   324    0.32584E+04    0.13565E+02    0.12611E-01    0.11702E+03
   325    0.32257E+04    0.13752E+02    0.12499E-01    0.11645E+03
   326    0.31930E+04    0.13937E+02    0.12389E-01    0.11584E+03
   327    0.31606E+04    0.14123E+02    0.12282E-01    0.11519E+03
   328    0.31283E+04    0.14307E+02    0.12177E-01    0.11451E+03
   329    0.30963E+04    0.14491E+02    0.12074E-01    0.11380E+03
   330    0.30644E+04    0.14673E+02    0.11974E-01    0.11305E+03
   331    0.30327E+04    0.14855E+02    0.11876E-01    0.11227E+03
   332    0.30013E+04    0.15036E+02    0.11781E-01    0.11145E+03
   333    0.29701E+04    0.15216E+02    0.11689E-01    0.11060E+03
   334    0.29391E+04    0.15394E+02    0.11599E-01    0.10971E+03
   335    0.29084E+04    0.15572E+02    0.11512E-01    0.10879E+03
   336    0.28779E+04    0.15748E+02    0.11428E-01    0.10784E+03
   337    0.28477E+04    0.15923E+02    0.11347E-01    0.10686E+03
   338    0.28178E+04    0.16096E+02    0.11268E-01    0.10584E+03
   339    0.27882E+04    0.16268E+02    0.11192E-01    0.10479E+03
   340    0.27588E+04    0.16438E+02    0.11120E-01    0.10371E+03
   341    0.27298E+04    0.16607E+02    0.11050E-01    0.10259E+03
   342    0.27010E+04    0.16774E+02    0.10983E-01    0.10144E+03
   343    0.26726E+04    0.16939E+02    0.10920E-01    0.10026E+03
   344    0.26445E+04    0.17102E+02    0.10860E-01    0.99053E+02
   345    0.26168E+04    0.17263E+02    0.10802E-01    0.97811E+02
   346    0.25894E+04    0.17422E+02    0.10748E-01    0.96538E+02
   347    0.25624E+04    0.17579E+02    0.10698E-01    0.95233E+02
   348    0.25357E+04    0.17734E+02    0.10651E-01    0.93897E+02
   349    0.25094E+04    0.17887E+02    0.10607E-01    0.92531E+02
   350    0.24835E+04    0.18037E+02    0.10566E-01    0.91134E+02
   351    0.24580E+04    0.18185E+02    0.10529E-01    0.89707E+02
   352    0.24329E+04    0.18330E+02    0.10496E-01    0.88251E+02
   353    0.24081E+04    0.18473E+02    0.10466E-01    0.86766E+02
   354    0.23838E+04    0.18614E+02    0.10438E-01    0.85253E+02
   355    0.23599E+04    0.18752E+02    0.10414E-01    0.83713E+02
   356    0.23364E+04    0.18887E+02    0.10393E-01    0.82147E+02
   357    0.23132E+04    0.19020E+02    0.10375E-01    0.80556E+02
   358    0.22905E+04    0.19150E+02    0.10359E-01    0.78940E+02
   359    0.22682E+04    0.19277E+02    0.10346E-01    0.77300E+02
   360    0.22463E+04    0.19401E+02    0.10336E-01    0.75638E+02
   361    0.22247E+04    0.19523E+02    0.10328E-01    0.73953E+02
   362    0.22036E+04    0.19642E+02    0.10322E-01    0.72248E+02
   363    0.21829E+04    0.19758E+02    0.10319E-01    0.70522E+02
   364    0.21626E+04    0.19871E+02    0.10317E-01    0.68776E+02
   365    0.21427E+04    0.19981E+02    0.10318E-01    0.67011E+02
   366    0.21233E+04    0.20088E+02    0.10320E-01    0.65229E+02
   367    0.21042E+04    0.20192E+02    0.10324E-01    0.63429E+02
   368    0.20856E+04    0.20293E+02    0.10330E-01    0.61614E+02
   369    0.20673E+04    0.20391E+02    0.10337E-01    0.59782E+02
   370    0.20495E+04    0.20486E+02    0.10346E-01    0.57936E+02
   371    0.20321E+04    0.20577E+02    0.10356E-01    0.56077E+02
   372    0.20151E+04    0.20665E+02    0.10367E-01    0.54204E+02
   373    0.19985E+04    0.20750E+02    0.10379E-01    0.52319E+02
   374    0.19824E+04    0.20832E+02    0.10392E-01    0.50423E+02
   375    0.19666E+04    0.20910E+02    0.10407E-01    0.48516E+02
   376    0.19513E+04    0.20985E+02    0.10421E-01    0.46599E+02
   377    0.19364E+04    0.21056E+02    0.10437E-01    0.44674E+02
   378    0.19219E+04    0.21124E+02    0.10453E-01    0.42740E+02
   379    0.19079E+04    0.21189E+02    0.10470E-01    0.40800E+02
   380    0.18943E+04    0.21250E+02    0.10486E-01    0.38853E+02
   381    0.18811E+04    0.21307E+02    0.10503E-01    0.36900E+02
   382    0.18683E+04    0.21361E+02    0.10521E-01    0.34942E+02
   383    0.18560E+04    0.21411E+02    0.10538E-01    0.32981E+02
   384    0.18440E+04    0.21457E+02    0.10555E-01    0.31016E+02
   385    0.18326E+04    0.21499E+02    0.10572E-01    0.29050E+02
   386    0.18215E+04    0.21538E+02    0.10588E-01    0.27081E+02
   387    0.18109E+04    0.21573E+02    0.10604E-01    0.25112E+02
   388    0.18007E+04    0.21604E+02    0.10620E-01    0.23143E+02
   389    0.17910E+04    0.21631E+02    0.10635E-01    0.21176E+02
   390    0.17816E+04    0.21654E+02    0.10649E-01    0.19210E+02
   391    0.17728E+04    0.21673E+02    0.10662E-01    0.17246E+02
   392    0.17643E+04    0.21688E+02    0.10674E-01    0.15286E+02
   393    0.17563E+04    0.21699E+02    0.10685E-01    0.13331E+02
   394    0.17488E+04    0.21706E+02    0.10695E-01    0.11380E+02
   395    0.17416E+04    0.21708E+02    0.10704E-01    0.94355E+01
   396    0.17350E+04    0.21707E+02    0.10711E-01    0.74976E+01
   397    0.17287E+04    0.21701E+02    0.10716E-01    0.55674E+01
   398    0.17229E+04    0.21691E+02    0.10720E-01    0.36455E+01
   399    0.17176E+04    0.21677E+02    0.10723E-01    0.17329E+01
   400    0.17127E+04    0.21658E+02    0.10723E-01   -0.16973E+00
   401    0.17082E+04    0.21635E+02    0.10721E-01   -0.20615E+01
   402    0.17042E+04    0.21607E+02    0.10718E-01   -0.39418E+01
   403    0.17006E+04    0.21576E+02    0.10712E-01   -0.58102E+01
   404    0.16975E+04    0.21540E+02    0.10705E-01   -0.76660E+01
   405    0.16948E+04    0.21500E+02    0.10696E-01   -0.95087E+01
   406    0.16924E+04    0.21455E+02    0.10685E-01   -0.11338E+02
   407    0.16905E+04    0.21407E+02    0.10672E-01   -0.13153E+02
   408    0.16890E+04    0.21355E+02    0.10658E-01   -0.14953E+02
   409    0.16879E+04    0.21299E+02    0.10642E-01   -0.16737E+02
   410    0.16872E+04    0.21238E+02    0.10624E-01   -0.18506E+02
   411    0.16869E+04    0.21174E+02    0.10605E-01   -0.20259E+02
   412    0.16869E+04    0.21107E+02    0.10584E-01   -0.21994E+02
   413    0.16873E+04    0.21035E+02    0.10561E-01   -0.23712E+02
   414    0.16881E+04    0.20960E+02    0.10537E-01   -0.25411E+02
   415    0.16893E+04    0.20881E+02    0.10511E-01   -0.27092E+02
   416    0.16908E+04    0.20799E+02    0.10484E-01   -0.28754E+02
   417    0.16926E+04    0.20713E+02    0.10455E-01   -0.30396E+02
   418    0.16948E+04    0.20624E+02    0.10425E-01   -0.32018E+02
   419    0.16973E+04    0.20532E+02    0.10394E-01   -0.33618E+02
   420    0.17001E+04    0.20436E+02    0.10362E-01   -0.35198E+02
   421    0.17033E+04    0.20337E+02    0.10328E-01   -0.36755E+02
   422    0.17067E+04    0.20234E+02    0.10292E-01   -0.38289E+02
   423    0.17105E+04    0.20129E+02    0.10256E-01   -0.39801E+02
   424    0.17146E+04    0.20020E+02    0.10218E-01   -0.41288E+02
   425    0.17190E+04    0.19908E+02    0.10179E-01   -0.42752E+02
   426    0.17237E+04    0.19794E+02    0.10139E-01   -0.44190E+02
   427    0.17286E+04    0.19676E+02    0.10098E-01   -0.45603E+02
   428    0.17338E+04    0.19556E+02    0.10056E-01   -0.46991E+02
   429    0.17393E+04    0.19433E+02    0.10013E-01   -0.48351E+02
   430    0.17451E+04    0.19307E+02    0.99687E-02   -0.49685E+02
   431    0.17511E+04    0.19178E+02    0.99236E-02   -0.50991E+02
   432    0.17573E+04    0.19047E+02    0.98775E-02   -0.52269E+02
   433    0.17639E+04    0.18913E+02    0.98305E-02   -0.53518E+02
   434    0.17706E+04    0.18776E+02    0.97827E-02   -0.54738E+02
   435    0.17776E+04    0.18638E+02    0.97340E-02   -0.55928E+02
   436    0.17848E+04    0.18496E+02    0.96845E-02   -0.57088E+02
   437    0.17922E+04    0.18353E+02    0.96343E-02   -0.58216E+02
   438    0.17998E+04    0.18207E+02    0.95833E-02   -0.59313E+02
   439    0.18077E+04    0.18058E+02    0.95316E-02   -0.60378E+02
   440    0.18157E+04    0.17908E+02    0.94792E-02   -0.61411E+02
   441    0.18240E+04    0.17756E+02    0.94262E-02   -0.62410E+02
   442    0.18324E+04    0.17601E+02    0.93727E-02   -0.63375E+02
   443    0.18410E+04    0.17444E+02    0.93185E-02   -0.64306E+02
   444    0.18498E+04    0.17286E+02    0.92638E-02   -0.65203E+02
   445    0.18587E+04    0.17126E+02    0.92086E-02   -0.66063E+02
   446    0.18678E+04    0.16963E+02    0.91530E-02   -0.66888E+02
   447    0.18771E+04    0.16799E+02    0.90969E-02   -0.67676E+02
   448    0.18865E+04    0.16633E+02    0.90404E-02   -0.68427E+02
   449    0.18961E+04    0.16466E+02    0.89836E-02   -0.69141E+02
   450    0.19058E+04    0.16297E+02    0.89264E-02   -0.69816E+02
   451    0.19156E+04    0.16126E+02    0.88689E-02   -0.70452E+02
   452    0.19255E+04    0.15954E+02    0.88111E-02   -0.71051E+02
   453    0.19356E+04    0.15781E+02    0.87532E-02   -0.71610E+02
   454    0.19458E+04    0.15606E+02    0.86950E-02   -0.72132E+02
   455    0.19560E+04    0.15430E+02    0.86367E-02   -0.72616E+02
   456    0.19664E+04    0.15253E+02    0.85783E-02   -0.73063E+02
   457    0.19769E+04    0.15076E+02    0.85197E-02   -0.73473E+02
   458    0.19874E+04    0.14897E+02    0.84612E-02   -0.73846E+02
   459    0.19981E+04    0.14718E+02    0.84026E-02   -0.74182E+02
   460    0.20088E+04    0.14538E+02    0.83440E-02   -0.74482E+02
   461    0.20195E+04    0.14358E+02    0.82855E-02   -0.74746E+02
   462    0.20303E+04    0.14177E+02    0.82271E-02   -0.74974E+02
   463    0.20412E+04    0.13996E+02    0.81688E-02   -0.75167E+02
   464    0.20521E+04    0.13815E+02    0.81107E-02   -0.75324E+02
   465    0.20631E+04    0.13633E+02    0.80527E-02   -0.75447E+02
   466    0.20740E+04    0.13452E+02    0.79951E-02   -0.75535E+02
   467    0.20850E+04    0.13271E+02    0.79376E-02   -0.75589E+02
   468    0.20961E+04    0.13090E+02    0.78805E-02   -0.75609E+02
   469    0.21071E+04    0.12910E+02    0.78238E-02   -0.75595E+02
   470    0.21181E+04    0.12730E+02    0.77674E-02   -0.75547E+02
   471    0.21292E+04    0.12550E+02    0.77114E-02   -0.75466E+02
   472    0.21402E+04    0.12372E+02    0.76559E-02   -0.75353E+02
   473    0.21512E+04    0.12194E+02    0.76009E-02   -0.75206E+02
   474    0.21622E+04    0.12016E+02    0.75463E-02   -0.75028E+02
   475    0.21731E+04    0.11840E+02    0.74924E-02   -0.74817E+02
   476    0.21840E+04    0.11665E+02    0.74390E-02   -0.74574E+02
   477    0.21949E+04    0.11492E+02    0.73863E-02   -0.74300E+02
   478    0.22057E+04    0.11319E+02    0.73342E-02   -0.73994E+02
   479    0.22165E+04    0.11148E+02    0.72828E-02   -0.73658E+02
   480    0.22272E+04    0.10979E+02    0.72322E-02   -0.73291E+02
   481    0.22379E+04    0.10811E+02    0.71823E-02   -0.72893E+02
   482    0.22484E+04    0.10645E+02    0.71333E-02   -0.72465E+02
   483    0.22589E+04    0.10480E+02    0.70851E-02   -0.72007E+02
   484    0.22693E+04    0.10318E+02    0.70377E-02   -0.71520E+02
   485    0.22796E+04    0.10158E+02    0.69913E-02   -0.71004E+02
   486    0.22898E+04    0.99996E+01    0.69458E-02   -0.70458E+02
   487    0.22999E+04    0.98438E+01    0.69013E-02   -0.69884E+02
   488    0.23098E+04    0.96903E+01    0.68578E-02   -0.69281E+02
   489    0.23197E+04    0.95394E+01    0.68154E-02   -0.68650E+02
   490    0.23294E+04    0.93910E+01    0.67741E-02   -0.67990E+02
   491    0.23390E+04    0.92454E+01    0.67339E-02   -0.67304E+02
   492    0.23484E+04    0.91025E+01    0.66949E-02   -0.66590E+02
   493    0.23577E+04    0.89626E+01    0.66570E-02   -0.65849E+02
   494    0.23668E+04    0.88257E+01    0.66204E-02   -0.65081E+02
   495    0.23758E+04    0.86919E+01    0.65851E-02   -0.64286E+02
   496    0.23846E+04    0.85613E+01    0.65511E-02   -0.63465E+02
   497    0.23932E+04    0.84341E+01    0.65184E-02   -0.62619E+02
   498    0.24017E+04    0.83104E+01    0.64871E-02   -0.61746E+02
   499    0.24099E+04    0.81902E+01    0.64572E-02   -0.60848E+02
   500    0.24180E+04    0.80736E+01    0.64287E-02   -0.59925E+02
   501    0.24258E+04    0.79608E+01    0.64018E-02   -0.58977E+02
   502    0.24335E+04    0.78518E+01    0.63762E-02   -0.58006E+02
   503    0.24409E+04    0.77467E+01    0.63521E-02   -0.57010E+02
   504    0.24482E+04    0.76454E+01    0.63294E-02   -0.55993E+02
   505    0.24552E+04    0.75481E+01    0.63079E-02   -0.54953E+02
   506    0.24620E+04    0.74547E+01    0.62878E-02   -0.53893E+02
   507    0.24687E+04    0.73653E+01    0.62689E-02   -0.52813E+02
   508    0.24751E+04    0.72799E+01    0.62512E-02   -0.51713E+02
   509    0.24813E+04    0.71986E+01    0.62347E-02   -0.50595E+02
   510    0.24873E+04    0.71214E+01    0.62193E-02   -0.49459E+02
   511    0.24931E+04    0.70483E+01    0.62049E-02   -0.48306E+02
   512    0.24987E+04    0.69794E+01    0.61917E-02   -0.47137E+02
   513    0.25040E+04    0.69148E+01    0.61794E-02   -0.45952E+02
   514    0.25092E+04    0.68544E+01    0.61682E-02   -0.44753E+02
   515    0.25142E+04    0.67983E+01    0.61578E-02   -0.43540E+02
   516    0.25189E+04    0.67465E+01    0.61484E-02   -0.42314E+02
   517    0.25234E+04    0.66991E+01    0.61398E-02   -0.41076E+02
   518    0.25277E+04    0.66561E+01    0.61320E-02   -0.39826E+02
   519    0.25318E+04    0.66176E+01    0.61249E-02   -0.38566E+02
   520    0.25357E+04    0.65835E+01    0.61187E-02   -0.37296E+02
   521    0.25394E+04    0.65540E+01    0.61131E-02   -0.36017E+02
   522    0.25428E+04    0.65290E+01    0.61081E-02   -0.34729E+02
   523    0.25461E+04    0.65086E+01    0.61038E-02   -0.33434E+02
   524    0.25491E+04    0.64928E+01    0.61000E-02   -0.32133E+02
   525    0.25519E+04    0.64818E+01    0.60968E-02   -0.30825E+02
   526    0.25545E+04    0.64754E+01    0.60941E-02   -0.29513E+02
   527    0.25568E+04    0.64738E+01    0.60918E-02   -0.28196E+02
   528    0.25590E+04    0.64769E+01    0.60900E-02   -0.26875E+02
   529    0.25609E+04    0.64849E+01    0.60885E-02   -0.25552E+02
   530    0.25626E+04    0.64978E+01    0.60874E-02   -0.24227E+02
   531    0.25641E+04    0.65155E+01    0.60866E-02   -0.22901E+02
   532    0.25653E+04    0.65382E+01    0.60860E-02   -0.21574E+02
   533    0.25663E+04    0.65658E+01    0.60856E-02   -0.20248E+02
   534    0.25671E+04    0.65985E+01    0.60855E-02   -0.18923E+02
   535    0.25677E+04    0.66362E+01    0.60854E-02   -0.17600E+02
   536    0.25681E+04    0.66790E+01    0.60855E-02   -0.16280E+02
   537    0.25682E+04    0.67270E+01    0.60856E-02   -0.14963E+02
   538    0.25681E+04    0.67801E+01    0.60858E-02   -0.13651E+02
   539    0.25678E+04    0.68383E+01    0.60859E-02   -0.12344E+02
   540    0.25672E+04    0.69019E+01    0.60860E-02   -0.11043E+02
   541    0.25664E+04    0.69707E+01    0.60860E-02   -0.97485E+01
   542    0.25654E+04    0.70448E+01    0.60858E-02   -0.84617E+01
   543    0.25642E+04    0.71243E+01    0.60855E-02   -0.71832E+01
   544    0.25627E+04    0.72091E+01    0.60849E-02   -0.59138E+01
   545    0.25610E+04    0.72994E+01    0.60841E-02   -0.46544E+01
   546    0.25590E+04    0.73952E+01    0.60830E-02   -0.34056E+01
   547    0.25569E+04    0.74964E+01    0.60816E-02   -0.21684E+01
   548    0.25545E+04    0.76032E+01    0.60797E-02   -0.94338E+00
   549    0.25518E+04    0.77156E+01    0.60775E-02    0.26852E+00
   550    0.25489E+04    0.78336E+01    0.60749E-02    0.14666E+01
   551    0.25458E+04    0.79572E+01    0.60717E-02    0.26500E+01
   552    0.25425E+04    0.80864E+01    0.60680E-02    0.38184E+01
   553    0.25389E+04    0.82211E+01    0.60639E-02    0.49711E+01
   554    0.25351E+04    0.83611E+01    0.60593E-02    0.61079E+01
   555    0.25311E+04    0.85065E+01    0.60542E-02    0.72283E+01
   556    0.25269E+04    0.86572E+01    0.60486E-02    0.83317E+01
   557    0.25225E+04    0.88129E+01    0.60425E-02    0.94177E+01
   558    0.25178E+04    0.89738E+01    0.60360E-02    0.10486E+02
   559    0.25130E+04    0.91396E+01    0.60290E-02    0.11536E+02
   560    0.25080E+04    0.93103E+01    0.60215E-02    0.12567E+02
   561    0.25027E+04    0.94859E+01    0.60136E-02    0.13579E+02
   562    0.24973E+04    0.96661E+01    0.60052E-02    0.14572E+02
   563    0.24917E+04    0.98510E+01    0.59963E-02    0.15544E+02
   564    0.24860E+04    0.10041E+02    0.59870E-02    0.16496E+02
   565    0.24800E+04    0.10234E+02    0.59772E-02    0.17427E+02
   566    0.24739E+04    0.10433E+02    0.59670E-02    0.18337E+02
   567    0.24676E+04    0.10635E+02    0.59563E-02    0.19224E+02
   568    0.24612E+04    0.10842E+02    0.59452E-02    0.20089E+02
   569    0.24546E+04    0.11053E+02    0.59336E-02    0.20932E+02
   570    0.24478E+04    0.11268E+02    0.59216E-02    0.21751E+02
   571    0.24409E+04    0.11487E+02    0.59091E-02    0.22547E+02
   572    0.24339E+04    0.11710E+02    0.58962E-02    0.23318E+02
   573    0.24267E+04    0.11937E+02    0.58829E-02    0.24065E+02
   574    0.24194E+04    0.12168E+02    0.58692E-02    0.24787E+02
   575    0.24119E+04    0.12402E+02    0.58550E-02    0.25484E+02
   576    0.24044E+04    0.12639E+02    0.58404E-02    0.26154E+02
   577    0.23967E+04    0.12881E+02    0.58253E-02    0.26798E+02
   578    0.23889E+04    0.13125E+02    0.58099E-02    0.27415E+02
   579    0.23809E+04    0.13373E+02    0.57940E-02    0.28005E+02
   580    0.23729E+04    0.13624E+02    0.57777E-02    0.28568E+02
   581    0.23648E+04    0.13878E+02    0.57610E-02    0.29102E+02
   582    0.23565E+04    0.14135E+02    0.57439E-02    0.29607E+02
   583    0.23482E+04    0.14395E+02    0.57263E-02    0.30083E+02
   584    0.23398E+04    0.14658E+02    0.57084E-02    0.30530E+02
   585    0.23313E+04    0.14924E+02    0.56901E-02    0.30947E+02
   586    0.23227E+04    0.15193E+02    0.56713E-02    0.31333E+02
   587    0.23140E+04    0.15464E+02    0.56522E-02    0.31688E+02
   588    0.23052E+04    0.15738E+02    0.56327E-02    0.32013E+02
   589    0.22964E+04    0.16014E+02    0.56128E-02    0.32305E+02
   590    0.22876E+04    0.16293E+02    0.55924E-02    0.32565E+02
   591    0.22786E+04    0.16574E+02    0.55717E-02    0.32792E+02
   592    0.22696E+04    0.16857E+02    0.55507E-02    0.32986E+02
   593    0.22606E+04    0.17142E+02    0.55292E-02    0.33147E+02
   594    0.22515E+04    0.17429E+02    0.55074E-02    0.33273E+02
   595    0.22424E+04    0.17718E+02    0.54851E-02    0.33365E+02
   596    0.22332E+04    0.18009E+02    0.54625E-02    0.33422E+02
   597    0.22240E+04    0.18302E+02    0.54396E-02    0.33444E+02
   598    0.22147E+04    0.18597E+02    0.54162E-02    0.33430E+02
   599    0.22055E+04    0.18893E+02    0.53925E-02    0.33379E+02
   600    0.21962E+04    0.19191E+02    0.53685E-02    0.33292E+02
   601    0.21869E+04    0.19490E+02    0.53440E-02    0.33167E+02
   602    0.21776E+04    0.19791E+02    0.53193E-02    0.33006E+02
   603    0.21683E+04    0.20092E+02    0.52942E-02    0.32808E+02
   604    0.21589E+04    0.20395E+02    0.52688E-02    0.32574E+02
   605    0.21496E+04    0.20699E+02    0.52431E-02    0.32304E+02
   606    0.21403E+04    0.21004E+02    0.52172E-02    0.31999E+02
   607    0.21310E+04    0.21309E+02    0.51910E-02    0.31659E+02
   608    0.21217E+04    0.21615E+02    0.51646E-02    0.31284E+02
   609    0.21124E+04    0.21921E+02    0.51380E-02    0.30875E+02
   610    0.21032E+04    0.22228E+02    0.51112E-02    0.30432E+02
   611    0.20939E+04    0.22535E+02    0.50843E-02    0.29955E+02
   612    0.20847E+04    0.22842E+02    0.50571E-02    0.29445E+02
   613    0.20756E+04    0.23148E+02    0.50299E-02    0.28902E+02
   614    0.20664E+04    0.23455E+02    0.50026E-02    0.28327E+02
   615    0.20573E+04    0.23762E+02    0.49751E-02    0.27719E+02
   616    0.20483E+04    0.24068E+02    0.49476E-02    0.27080E+02
   617    0.20393E+04    0.24373E+02    0.49201E-02    0.26409E+02
   618    0.20304E+04    0.24678E+02    0.48925E-02    0.25707E+02
   619    0.20215E+04    0.24982E+02    0.48649E-02    0.24974E+02
   620    0.20127E+04    0.25285E+02    0.48373E-02    0.24211E+02
   621    0.20040E+04    0.25587E+02    0.48098E-02    0.23418E+02
   622    0.19953E+04    0.25888E+02    0.47823E-02    0.22596E+02
   623    0.19867E+04    0.26188E+02    0.47548E-02    0.21744E+02
   624    0.19782E+04    0.26486E+02    0.47275E-02    0.20863E+02
   625    0.19697E+04    0.26783E+02    0.47003E-02    0.19953E+02
   626    0.19614E+04    0.27078E+02    0.46731E-02    0.19016E+02
   627    0.19532E+04    0.27371E+02    0.46462E-02    0.18050E+02
   628    0.19450E+04    0.27662E+02    0.46194E-02    0.17057E+02
   629    0.19370E+04    0.27952E+02    0.45927E-02    0.16037E+02
   630    0.19290E+04    0.28239E+02    0.45663E-02    0.14990E+02
   631    0.19212E+04    0.28524E+02    0.45401E-02    0.13917E+02
   632    0.19135E+04    0.28806E+02    0.45142E-02    0.12817E+02
   633    0.19059E+04    0.29086E+02    0.44885E-02    0.11692E+02
   634    0.18984E+04    0.29363E+02    0.44631E-02    0.10542E+02
   635    0.18910E+04    0.29637E+02    0.44380E-02    0.93669E+01
   636    0.18838E+04    0.29909E+02    0.44132E-02    0.81670E+01
   637    0.18767E+04    0.30177E+02    0.43887E-02    0.69429E+01
   638    0.18698E+04    0.30443E+02    0.43646E-02    0.56949E+01
   639    0.18630E+04    0.30705E+02    0.43409E-02    0.44234E+01
   640    0.18563E+04    0.30964E+02    0.43176E-02    0.31288E+01
   641    0.18498E+04    0.31219E+02    0.42947E-02    0.18113E+01
   642    0.18435E+04    0.31470E+02    0.42723E-02    0.47144E+00
   643    0.18373E+04    0.31718E+02    0.42503E-02   -0.89052E+00
   644    0.18313E+04    0.31961E+02    0.42288E-02   -0.22742E+01
   645    0.18254E+04    0.32201E+02    0.42077E-02   -0.36792E+01
   646    0.18197E+04    0.32437E+02    0.41872E-02   -0.51052E+01
   647    0.18142E+04    0.32668E+02    0.41673E-02   -0.65519E+01
   648    0.18089E+04    0.32895E+02    0.41478E-02   -0.80188E+01
   649    0.18038E+04    0.33117E+02    0.41290E-02   -0.95056E+01
   650    0.17988E+04    0.33335E+02    0.41107E-02   -0.11012E+02
   651    0.17941E+04    0.33548E+02    0.40931E-02   -0.12538E+02
   652    0.17895E+04    0.33756E+02    0.40761E-02   -0.14081E+02
   653    0.17851E+04    0.33959E+02    0.40596E-02   -0.15643E+02
   654    0.17810E+04    0.34158E+02    0.40437E-02   -0.17221E+02
   655    0.17770E+04    0.34351E+02    0.40284E-02   -0.18816E+02
   656    0.17732E+04    0.34539E+02    0.40136E-02   -0.20425E+02
   657    0.17696E+04    0.34723E+02    0.39994E-02   -0.22050E+02
   658    0.17662E+04    0.34901E+02    0.39856E-02   -0.23687E+02
   659    0.17630E+04    0.35075E+02    0.39724E-02   -0.25338E+02
   660    0.17600E+04    0.35243E+02    0.39597E-02   -0.27001E+02
   661    0.17571E+04    0.35406E+02    0.39474E-02   -0.28675E+02
   662    0.17545E+04    0.35564E+02    0.39357E-02   -0.30360E+02
   663    0.17521E+04    0.35717E+02    0.39243E-02   -0.32055E+02
   664    0.17498E+04    0.35865E+02    0.39135E-02   -0.33759E+02
   665    0.17477E+04    0.36007E+02    0.39030E-02   -0.35470E+02
   666    0.17459E+04    0.36144E+02    0.38930E-02   -0.37190E+02
   667    0.17442E+04    0.36276E+02    0.38833E-02   -0.38916E+02
   668    0.17427E+04    0.36402E+02    0.38741E-02   -0.40647E+02
   669    0.17414E+04    0.36523E+02    0.38652E-02   -0.42384E+02
   670    0.17403E+04    0.36638E+02    0.38567E-02   -0.44125E+02
   671    0.17393E+04    0.36748E+02    0.38485E-02   -0.45870E+02
   672    0.17386E+04    0.36853E+02    0.38407E-02   -0.47618E+02
   673    0.17380E+04    0.36952E+02    0.38332E-02   -0.49367E+02
   674    0.17377E+04    0.37045E+02    0.38259E-02   -0.51117E+02
   675    0.17375E+04    0.37133E+02    0.38190E-02   -0.52868E+02
   676    0.17375E+04    0.37215E+02    0.38124E-02   -0.54619E+02
   677    0.17377E+04    0.37291E+02    0.38060E-02   -0.56368E+02
   678    0.17381E+04    0.37362E+02    0.37999E-02   -0.58115E+02
   679    0.17387E+04    0.37426E+02    0.37941E-02   -0.59860E+02
   680    0.17394E+04    0.37485E+02    0.37884E-02   -0.61601E+02
   681    0.17404E+04    0.37539E+02    0.37830E-02   -0.63338E+02
   682    0.17415E+04    0.37586E+02    0.37778E-02   -0.65069E+02
   683    0.17428E+04    0.37628E+02    0.37728E-02   -0.66795E+02
   684    0.17443E+04    0.37663E+02    0.37679E-02   -0.68514E+02
   685    0.17460E+04    0.37693E+02    0.37632E-02   -0.70225E+02
   686    0.17479E+04    0.37716E+02    0.37587E-02   -0.71929E+02
   687    0.17499E+04    0.37734E+02    0.37543E-02   -0.73623E+02
   688    0.17522E+04    0.37745E+02    0.37500E-02   -0.75307E+02
   689    0.17546E+04    0.37751E+02    0.37458E-02   -0.76981E+02
   690    0.17572E+04    0.37750E+02    0.37418E-02   -0.78644E+02
   691    0.17600E+04    0.37743E+02    0.37378E-02   -0.80294E+02
   692    0.17630E+04    0.37730E+02    0.37339E-02   -0.81931E+02
   693    0.17661E+04    0.37710E+02    0.37300E-02   -0.83555E+02
   694    0.17694E+04    0.37684E+02    0.37262E-02   -0.85164E+02
   695    0.17730E+04    0.37652E+02    0.37224E-02   -0.86758E+02
   696    0.17767E+04    0.37614E+02    0.37186E-02   -0.88335E+02
   697    0.17805E+04    0.37569E+02    0.37148E-02   -0.89896E+02
   698    0.17846E+04    0.37518E+02    0.37111E-02   -0.91439E+02
   699    0.17889E+04    0.37460E+02    0.37072E-02   -0.92964E+02
   700    0.17933E+04    0.37396E+02    0.37034E-02   -0.94470E+02
   701    0.17979E+04    0.37326E+02    0.36995E-02   -0.95955E+02
   702    0.18027E+04    0.37248E+02    0.36956E-02   -0.97420E+02
   703    0.18076E+04    0.37165E+02    0.36916E-02   -0.98865E+02
   704    0.18128E+04    0.37075E+02    0.36875E-02   -0.10029E+03
   705    0.18180E+04    0.36980E+02    0.36834E-02   -0.10169E+03
   706    0.18235E+04    0.36878E+02    0.36792E-02   -0.10307E+03
   707    0.18291E+04    0.36770E+02    0.36749E-02   -0.10443E+03
   708    0.18349E+04    0.36656E+02    0.36706E-02   -0.10576E+03
   709    0.18408E+04    0.36537E+02    0.36662E-02   -0.10707E+03
   710    0.18468E+04    0.36412E+02    0.36617E-02   -0.10836E+03
   711    0.18530E+04    0.36281E+02    0.36571E-02   -0.10962E+03
   712    0.18593E+04    0.36145E+02    0.36524E-02   -0.11086E+03
   713    0.18658E+04    0.36003E+02    0.36476E-02   -0.11207E+03
   714    0.18724E+04    0.35857E+02    0.36428E-02   -0.11326E+03
   715    0.18791E+04    0.35705E+02    0.36378E-02   -0.11442E+03
   716    0.18859E+04    0.35548E+02    0.36327E-02   -0.11556E+03
   717    0.18929E+04    0.35386E+02    0.36275E-02   -0.11667E+03
   718    0.19000E+04    0.35219E+02    0.36222E-02   -0.11775E+03
   719    0.19071E+04    0.35047E+02    0.36168E-02   -0.11881E+03
   720    0.19144E+04    0.34871E+02    0.36113E-02   -0.11984E+03
   721    0.19218E+04    0.34690E+02    0.36056E-02   -0.12084E+03
   722    0.19293E+04    0.34504E+02    0.35998E-02   -0.12181E+03
   723    0.19368E+04    0.34314E+02    0.35939E-02   -0.12275E+03
   724    0.19445E+04    0.34120E+02    0.35879E-02   -0.12366E+03
   725    0.19522E+04    0.33922E+02    0.35817E-02   -0.12455E+03
   726    0.19600E+04    0.33719E+02    0.35753E-02   -0.12540E+03
   727    0.19679E+04    0.33513E+02    0.35689E-02   -0.12622E+03
   728    0.19759E+04    0.33302E+02    0.35622E-02   -0.12701E+03
   729    0.19839E+04    0.33088E+02    0.35554E-02   -0.12777E+03
   730    0.19920E+04    0.32870E+02    0.35485E-02   -0.12850E+03
   731    0.20002E+04    0.32648E+02    0.35414E-02   -0.12920E+03
   732    0.20084E+04    0.32423E+02    0.35341E-02   -0.12986E+03
   733    0.20167E+04    0.32194E+02    0.35267E-02   -0.13049E+03
   734    0.20250E+04    0.31962E+02    0.35191E-02   -0.13108E+03
   735    0.20334E+04    0.31727E+02    0.35113E-02   -0.13165E+03
   736    0.20418E+04    0.31488E+02    0.35033E-02   -0.13218E+03
   737    0.20502E+04    0.31247E+02    0.34952E-02   -0.13267E+03
   738    0.20587E+04    0.31003E+02    0.34868E-02   -0.13313E+03
   739    0.20672E+04    0.30755E+02    0.34783E-02   -0.13355E+03
   740    0.20757E+04    0.30505E+02    0.34696E-02   -0.13394E+03
   741    0.20842E+04    0.30252E+02    0.34606E-02   -0.13429E+03
   742    0.20928E+04    0.29997E+02    0.34515E-02   -0.13460E+03
   743    0.21014E+04    0.29739E+02    0.34422E-02   -0.13488E+03
   744    0.21100E+04    0.29479E+02    0.34326E-02   -0.13512E+03
   745    0.21185E+04    0.29217E+02    0.34229E-02   -0.13532E+03
   746    0.21271E+04    0.28952E+02    0.34129E-02   -0.13548E+03
   747    0.21357E+04    0.28685E+02    0.34027E-02   -0.13561E+03
   748    0.21443E+04    0.28416E+02    0.33923E-02   -0.13569E+03
   749    0.21528E+04    0.28146E+02    0.33817E-02   -0.13574E+03
   750    0.21614E+04    0.27873E+02    0.33708E-02   -0.13574E+03
   751    0.21699E+04    0.27599E+02    0.33597E-02   -0.13571E+03
   752    0.21784E+04    0.27323E+02    0.33483E-02   -0.13563E+03
   753    0.21869E+04    0.27046E+02    0.33368E-02   -0.13552E+03
   754    0.21953E+04    0.26767E+02    0.33250E-02   -0.13536E+03
   755    0.22037E+04    0.26488E+02    0.33130E-02   -0.13517E+03
   756    0.22121E+04    0.26207E+02    0.33009E-02   -0.13494E+03
   757    0.22204E+04    0.25925E+02    0.32886E-02   -0.13467E+03
   758    0.22287E+04    0.25643E+02    0.32761E-02   -0.13436E+03
   759    0.22370E+04    0.25360E+02    0.32634E-02   -0.13401E+03
   760    0.22451E+04    0.25076E+02    0.32506E-02   -0.13363E+03
   761    0.22533E+04    0.24792E+02    0.32376E-02   -0.13321E+03
   762    0.22613E+04    0.24508E+02    0.32245E-02   -0.13276E+03
   763    0.22693E+04    0.24223E+02    0.32113E-02   -0.13226E+03
   764    0.22773E+04    0.23939E+02    0.31980E-02   -0.13174E+03
   765    0.22851E+04    0.23654E+02    0.31846E-02   -0.13117E+03
   766    0.22929E+04    0.23370E+02    0.31711E-02   -0.13057E+03
   767    0.23006E+04    0.23087E+02    0.31575E-02   -0.12994E+03
   768    0.23083E+04    0.22803E+02    0.31438E-02   -0.12927E+03
   769    0.23158E+04    0.22521E+02    0.31300E-02   -0.12857E+03
   770    0.23233E+04    0.22239E+02    0.31162E-02   -0.12784E+03
   771    0.23307E+04    0.21958E+02    0.31024E-02   -0.12707E+03
   772    0.23379E+04    0.21679E+02    0.30885E-02   -0.12626E+03
   773    0.23451E+04    0.21400E+02    0.30746E-02   -0.12543E+03
   774    0.23522E+04    0.21123E+02    0.30606E-02   -0.12456E+03
   775    0.23591E+04    0.20847E+02    0.30467E-02   -0.12366E+03
   776    0.23660E+04    0.20573E+02    0.30327E-02   -0.12273E+03
   777    0.23727E+04    0.20300E+02    0.30188E-02   -0.12177E+03
   778    0.23794E+04    0.20030E+02    0.30049E-02   -0.12078E+03
   779    0.23859E+04    0.19761E+02    0.29910E-02   -0.11976E+03
   780    0.23923E+04    0.19494E+02    0.29771E-02   -0.11871E+03
   781    0.23985E+04    0.19230E+02    0.29633E-02   -0.11762E+03
   782    0.24046E+04    0.18968E+02    0.29496E-02   -0.11651E+03
   783    0.24106E+04    0.18708E+02    0.29359E-02   -0.11537E+03
   784    0.24164E+04    0.18451E+02    0.29223E-02   -0.11420E+03
   785    0.24221E+04    0.18197E+02    0.29088E-02   -0.11300E+03
   786    0.24277E+04    0.17946E+02    0.28953E-02   -0.11177E+03
   787    0.24331E+04    0.17698E+02    0.28820E-02   -0.11052E+03
   788    0.24384E+04    0.17452E+02    0.28688E-02   -0.10924E+03
   789    0.24435E+04    0.17211E+02    0.28557E-02   -0.10793E+03
   790    0.24484E+04    0.16972E+02    0.28427E-02   -0.10660E+03
   791    0.24532E+04    0.16737E+02    0.28299E-02   -0.10524E+03
   792    0.24578E+04    0.16506E+02    0.28173E-02   -0.10385E+03
   793    0.24622E+04    0.16279E+02    0.28048E-02   -0.10244E+03
   794    0.24665E+04    0.16055E+02    0.27924E-02   -0.10100E+03
   795    0.24705E+04    0.15836E+02    0.27803E-02   -0.99536E+02
   796    0.24744E+04    0.15621E+02    0.27683E-02   -0.98049E+02
   797    0.24781E+04    0.15410E+02    0.27565E-02   -0.96538E+02
   798    0.24817E+04    0.15203E+02    0.27450E-02   -0.95003E+02
   799    0.24850E+04    0.15002E+02    0.27336E-02   -0.93445E+02
   800    0.24881E+04    0.14804E+02    0.27225E-02   -0.91864E+02
   801    0.24911E+04    0.14612E+02    0.27116E-02   -0.90260E+02
   802    0.24938E+04    0.14425E+02    0.27010E-02   -0.88634E+02
   803    0.24963E+04    0.14242E+02    0.26905E-02   -0.86987E+02
   804    0.24987E+04    0.14065E+02    0.26803E-02   -0.85319E+02
   805    0.25008E+04    0.13893E+02    0.26703E-02   -0.83632E+02
   806    0.25027E+04    0.13725E+02    0.26606E-02   -0.81926E+02
   807    0.25044E+04    0.13563E+02    0.26510E-02   -0.80202E+02
   808    0.25060E+04    0.13406E+02    0.26417E-02   -0.78460E+02
   809    0.25073E+04    0.13254E+02    0.26326E-02   -0.76702E+02
   810    0.25084E+04    0.13107E+02    0.26236E-02   -0.74927E+02
   811    0.25094E+04    0.12965E+02    0.26149E-02   -0.73138E+02
   812    0.25101E+04    0.12829E+02    0.26064E-02   -0.71334E+02
   813    0.25107E+04    0.12698E+02    0.25980E-02   -0.69517E+02
   814    0.25110E+04    0.12572E+02    0.25899E-02   -0.67687E+02
   815    0.25111E+04    0.12452E+02    0.25819E-02   -0.65845E+02
   816    0.25111E+04    0.12337E+02    0.25741E-02   -0.63991E+02
   817    0.25108E+04    0.12227E+02    0.25665E-02   -0.62127E+02
   818    0.25104E+04    0.12123E+02    0.25591E-02   -0.60253E+02
   819    0.25097E+04    0.12025E+02    0.25518E-02   -0.58370E+02
   820    0.25089E+04    0.11932E+02    0.25447E-02   -0.56479E+02
   821    0.25078E+04    0.11844E+02    0.25378E-02   -0.54580E+02
   822    0.25066E+04    0.11763E+02    0.25310E-02   -0.52675E+02
   823    0.25051E+04    0.11687E+02    0.25244E-02   -0.50763E+02
   824    0.25035E+04    0.11616E+02    0.25180E-02   -0.48846E+02
   825    0.25017E+04    0.11552E+02    0.25117E-02   -0.46925E+02
   826    0.24996E+04    0.11493E+02    0.25055E-02   -0.45000E+02
   827    0.24974E+04    0.11440E+02    0.24995E-02   -0.43071E+02
   828    0.24950E+04    0.11393E+02    0.24936E-02   -0.41141E+02
   829    0.24923E+04    0.11352E+02    0.24878E-02   -0.39209E+02
   830    0.24895E+04    0.11317E+02    0.24822E-02   -0.37277E+02
   831    0.24865E+04    0.11287E+02    0.24767E-02   -0.35344E+02
   832    0.24833E+04    0.11264E+02    0.24713E-02   -0.33412E+02
   833    0.24799E+04    0.11247E+02    0.24661E-02   -0.31482E+02
   834    0.24762E+04    0.11235E+02    0.24610E-02   -0.29554E+02
   835    0.24724E+04    0.11230E+02    0.24559E-02   -0.27630E+02
   836    0.24684E+04    0.11231E+02    0.24510E-02   -0.25709E+02
   837    0.24642E+04    0.11239E+02    0.24462E-02   -0.23792E+02
   838    0.24598E+04    0.11252E+02    0.24415E-02   -0.21881E+02
   839    0.24553E+04    0.11272E+02    0.24369E-02   -0.19977E+02
   840    0.24505E+04    0.11298E+02    0.24324E-02   -0.18079E+02
   841    0.24455E+04    0.11330E+02    0.24280E-02   -0.16188E+02
   842    0.24403E+04    0.11369E+02    0.24237E-02   -0.14306E+02
   843    0.24349E+04    0.11414E+02    0.24194E-02   -0.12433E+02
   844    0.24294E+04    0.11466E+02    0.24153E-02   -0.10570E+02
   845    0.24236E+04    0.11524E+02    0.24112E-02   -0.87180E+01
   846    0.24177E+04    0.11589E+02    0.24072E-02   -0.68771E+01
   847    0.24115E+04    0.11660E+02    0.24032E-02   -0.50484E+01
   848    0.24052E+04    0.11738E+02    0.23993E-02   -0.32326E+01
   849    0.23986E+04    0.11822E+02    0.23955E-02   -0.14305E+01
   850    0.23919E+04    0.11913E+02    0.23918E-02    0.35721E+00
   851    0.23850E+04    0.12011E+02    0.23881E-02    0.21297E+01
   852    0.23778E+04    0.12116E+02    0.23844E-02    0.38866E+01
   853    0.23705E+04    0.12226E+02    0.23808E-02    0.56274E+01
   854    0.23631E+04    0.12344E+02    0.23773E-02    0.73517E+01
   855    0.23554E+04    0.12467E+02    0.23737E-02    0.90592E+01
   856    0.23475E+04    0.12597E+02    0.23703E-02    0.10749E+02
   857    0.23395E+04    0.12733E+02    0.23668E-02    0.12422E+02
   858    0.23313E+04    0.12875E+02    0.23634E-02    0.14076E+02
   859    0.23230E+04    0.13023E+02    0.23600E-02    0.15711E+02
   860    0.23144E+04    0.13177E+02    0.23567E-02    0.17328E+02
   861    0.23057E+04    0.13336E+02    0.23533E-02    0.18925E+02
   862    0.22969E+04    0.13502E+02    0.23500E-02    0.20502E+02
   863    0.22879E+04    0.13672E+02    0.23467E-02    0.22059E+02
   864    0.22788E+04    0.13848E+02    0.23434E-02    0.23595E+02
   865    0.22695E+04    0.14030E+02    0.23401E-02    0.25110E+02
   866    0.22600E+04    0.14216E+02    0.23368E-02    0.26603E+02
   867    0.22505E+04    0.14408E+02    0.23335E-02    0.28074E+02
   868    0.22408E+04    0.14605E+02    0.23301E-02    0.29523E+02
   869    0.22309E+04    0.14807E+02    0.23268E-02    0.30949E+02
   870    0.22209E+04    0.15013E+02    0.23235E-02    0.32352E+02
   871    0.22108E+04    0.15225E+02    0.23202E-02    0.33730E+02
   872    0.22006E+04    0.15441E+02    0.23168E-02    0.35085E+02
   873    0.21903E+04    0.15661E+02    0.23134E-02    0.36415E+02
   874    0.21798E+04    0.15886E+02    0.23100E-02    0.37720E+02
   875    0.21692E+04    0.16116E+02    0.23065E-02    0.39000E+02
   876    0.21586E+04    0.16349E+02    0.23030E-02    0.40254E+02
   877    0.21478E+04    0.16587E+02    0.22995E-02    0.41482E+02
   878    0.21369E+04    0.16829E+02    0.22960E-02    0.42683E+02
   879    0.21259E+04    0.17075E+02    0.22923E-02    0.43856E+02
   880    0.21148E+04    0.17324E+02    0.22887E-02    0.45002E+02
   881    0.21036E+04    0.17578E+02    0.22850E-02    0.46121E+02
   882    0.20924E+04    0.17835E+02    0.22812E-02    0.47210E+02
   883    0.20810E+04    0.18096E+02    0.22774E-02    0.48271E+02
   884    0.20696E+04    0.18360E+02    0.22735E-02    0.49303E+02
   885    0.20581E+04    0.18627E+02    0.22695E-02    0.50305E+02
   886    0.20465E+04    0.18898E+02    0.22655E-02    0.51277E+02
   887    0.20348E+04    0.19172E+02    0.22614E-02    0.52218E+02
   888    0.20231E+04    0.19449E+02    0.22573E-02    0.53128E+02
   889    0.20113E+04    0.19729E+02    0.22530E-02    0.54007E+02
   890    0.19994E+04    0.20012E+02    0.22487E-02    0.54855E+02
   891    0.19875E+04    0.20298E+02    0.22442E-02    0.55669E+02
   892    0.19755E+04    0.20586E+02    0.22397E-02    0.56452E+02
   893    0.19635E+04    0.20877E+02    0.22351E-02    0.57201E+02
   894    0.19515E+04    0.21171E+02    0.22304E-02    0.57916E+02
   895    0.19393E+04    0.21467E+02    0.22255E-02    0.58598E+02
   896    0.19272E+04    0.21765E+02    0.22206E-02    0.59245E+02
   897    0.19150E+04    0.22065E+02    0.22156E-02    0.59857E+02
   898    0.19028E+04    0.22368E+02    0.22104E-02    0.60435E+02
   899    0.18905E+04    0.22672E+02    0.22052E-02    0.60976E+02
   900    0.18782E+04    0.22978E+02    0.21998E-02    0.61482E+02
   901    0.18659E+04    0.23287E+02    0.21943E-02    0.61951E+02
   902    0.18536E+04    0.23596E+02    0.21887E-02    0.62383E+02
   903    0.18412E+04    0.23908E+02    0.21829E-02    0.62780E+02
   904    0.18288E+04    0.24221E+02    0.21771E-02    0.63141E+02
   905    0.18165E+04    0.24535E+02    0.21711E-02    0.63467E+02
   906    0.18041E+04    0.24850E+02    0.21650E-02    0.63757E+02
   907    0.17917E+04    0.25166E+02    0.21588E-02    0.64012E+02
   908    0.17793E+04    0.25483E+02    0.21526E-02    0.64233E+02
   909    0.17669E+04    0.25801E+02    0.21462E-02    0.64419E+02
   910    0.17545E+04    0.26120E+02    0.21398E-02    0.64571E+02
   911    0.17421E+04    0.26438E+02    0.21333E-02    0.64688E+02
   912    0.17297E+04    0.26758E+02    0.21266E-02    0.64772E+02
   913    0.17174E+04    0.27077E+02    0.21200E-02    0.64823E+02
   914    0.17050E+04    0.27397E+02    0.21132E-02    0.64840E+02
   915    0.16927E+04    0.27716E+02    0.21064E-02    0.64825E+02
   916    0.16804E+04    0.28036E+02    0.20995E-02    0.64777E+02
   917    0.16682E+04    0.28355E+02    0.20926E-02    0.64696E+02
   918    0.16559E+04    0.28674E+02    0.20856E-02    0.64583E+02
   919    0.16437E+04    0.28992E+02    0.20785E-02    0.64438E+02
   920    0.16315E+04    0.29309E+02    0.20714E-02    0.64261E+02
   921    0.16194E+04    0.29626E+02    0.20643E-02    0.64053E+02
   922    0.16073E+04    0.29941E+02    0.20571E-02    0.63814E+02
   923    0.15953E+04    0.30256E+02    0.20499E-02    0.63544E+02
   924    0.15833E+04    0.30569E+02    0.20426E-02    0.63243E+02
   925    0.15713E+04    0.30881E+02    0.20353E-02    0.62911E+02
   926    0.15594E+04    0.31191E+02    0.20280E-02    0.62550E+02
   927    0.15476E+04    0.31500E+02    0.20207E-02    0.62158E+02
   928    0.15358E+04    0.31807E+02    0.20134E-02    0.61737E+02
   929    0.15241E+04    0.32112E+02    0.20060E-02    0.61286E+02
   930    0.15125E+04    0.32415E+02    0.19987E-02    0.60807E+02
   931    0.15009E+04    0.32716E+02    0.19913E-02    0.60298E+02
   932    0.14895E+04    0.33014E+02    0.19840E-02    0.59760E+02
   933    0.14781E+04    0.33310E+02    0.19766E-02    0.59195E+02
   934    0.14667E+04    0.33604E+02    0.19693E-02    0.58601E+02
   935    0.14555E+04    0.33895E+02    0.19620E-02    0.57979E+02
   936    0.14443E+04    0.34183E+02    0.19547E-02    0.57329E+02
   937    0.14333E+04    0.34468E+02    0.19474E-02    0.56652E+02
   938    0.14223E+04    0.34750E+02    0.19401E-02    0.55948E+02
   939    0.14114E+04    0.35029E+02    0.19329E-02    0.55217E+02
   940    0.14006E+04    0.35305E+02    0.19257E-02    0.54459E+02
   941    0.13900E+04    0.35577E+02    0.19185E-02    0.53675E+02
   942    0.13794E+04    0.35845E+02    0.19114E-02    0.52865E+02
   943    0.13689E+04    0.36110E+02    0.19043E-02    0.52029E+02
   944    0.13586E+04    0.36371E+02    0.18973E-02    0.51167E+02
   945    0.13484E+04    0.36627E+02    0.18903E-02    0.50280E+02
   946    0.13383E+04    0.36880E+02    0.18834E-02    0.49368E+02
   947    0.13283E+04    0.37128E+02    0.18765E-02    0.48430E+02
   948    0.13184E+04    0.37372E+02    0.18698E-02    0.47469E+02
   949    0.13087E+04    0.37612E+02    0.18630E-02    0.46483E+02
   950    0.12991E+04    0.37847E+02    0.18564E-02    0.45472E+02
   951    0.12896E+04    0.38077E+02    0.18498E-02    0.44438E+02
   952    0.12803E+04    0.38302E+02    0.18433E-02    0.43381E+02
   953    0.12711E+04    0.38522E+02    0.18369E-02    0.42301E+02
   954    0.12621E+04    0.38737E+02    0.18306E-02    0.41199E+02
   955    0.12532E+04    0.38948E+02    0.18243E-02    0.40076E+02
   956    0.12444E+04    0.39153E+02    0.18181E-02    0.38932E+02
   957    0.12357E+04    0.39354E+02    0.18120E-02    0.37767E+02
   958    0.12272E+04    0.39549E+02    0.18060E-02    0.36584E+02
   959    0.12189E+04    0.39739E+02    0.18000E-02    0.35381E+02
   960    0.12106E+04    0.39925E+02    0.17941E-02    0.34160E+02
   961    0.12026E+04    0.40105E+02    0.17883E-02    0.32922E+02
   962    0.11946E+04    0.40280E+02    0.17826E-02    0.31666E+02
   963    0.11868E+04    0.40449E+02    0.17769E-02    0.30394E+02
   964    0.11791E+04    0.40614E+02    0.17713E-02    0.29107E+02
   965    0.11716E+04    0.40773E+02    0.17658E-02    0.27804E+02
   966    0.11642E+04    0.40926E+02    0.17603E-02    0.26486E+02
   967    0.11570E+04    0.41075E+02    0.17550E-02    0.25155E+02
   968    0.11499E+04    0.41218E+02    0.17496E-02    0.23811E+02
   969    0.11429E+04    0.41355E+02    0.17444E-02    0.22454E+02
   970    0.11361E+04    0.41487E+02    0.17392E-02    0.21084E+02
   971    0.11295E+04    0.41614E+02    0.17341E-02    0.19704E+02
   972    0.11229E+04    0.41735E+02    0.17291E-02    0.18312E+02
   973    0.11165E+04    0.41850E+02    0.17241E-02    0.16911E+02
   974    0.11103E+04    0.41960E+02    0.17192E-02    0.15500E+02
   975    0.11042E+04    0.42064E+02    0.17144E-02    0.14080E+02
   976    0.10983E+04    0.42163E+02    0.17096E-02    0.12652E+02
   977    0.10925E+04    0.42256E+02    0.17049E-02    0.11216E+02
   978    0.10868E+04    0.42343E+02    0.17003E-02    0.97727E+01
   979    0.10813E+04    0.42424E+02    0.16958E-02    0.83233E+01
   980    0.10759E+04    0.42500E+02    0.16913E-02    0.68681E+01
   981    0.10707E+04    0.42569E+02    0.16868E-02    0.54078E+01
   982    0.10657E+04    0.42633E+02    0.16825E-02    0.39429E+01
   983    0.10608E+04    0.42691E+02    0.16782E-02    0.24741E+01
   984    0.10560E+04    0.42742E+02    0.16739E-02    0.10019E+01
   985    0.10514E+04    0.42788E+02    0.16697E-02   -0.47289E+00
   986    0.10469E+04    0.42828E+02    0.16656E-02   -0.19498E+01
   987    0.10426E+04    0.42862E+02    0.16616E-02   -0.34281E+01
   988    0.10384E+04    0.42889E+02    0.16576E-02   -0.49072E+01
   989    0.10344E+04    0.42911E+02    0.16537E-02   -0.63865E+01
   990    0.10305E+04    0.42926E+02    0.16498E-02   -0.78653E+01
   991    0.10268E+04    0.42935E+02    0.16460E-02   -0.93431E+01
   992    0.10232E+04    0.42938E+02    0.16423E-02   -0.10819E+02
   993    0.10198E+04    0.42935E+02    0.16386E-02   -0.12293E+02
   994    0.10166E+04    0.42925E+02    0.16349E-02   -0.13764E+02
   995    0.10134E+04    0.42909E+02    0.16314E-02   -0.15231E+02
   996    0.10105E+04    0.42887E+02    0.16279E-02   -0.16694E+02
   997    0.10077E+04    0.42858E+02    0.16244E-02   -0.18153E+02
   998    0.10050E+04    0.42822E+02    0.16210E-02   -0.19606E+02
   999    0.10026E+04    0.42781E+02    0.16177E-02   -0.21053E+02
  1000    0.10002E+04    0.42732E+02    0.16144E-02   -0.22493E+02
  1001    0.99804E+03    0.42677E+02    0.16112E-02   -0.23926E+02
  1002    0.99601E+03    0.42616E+02    0.16081E-02   -0.25351E+02
  1003    0.99413E+03    0.42548E+02    0.16049E-02   -0.26768E+02
  1004    0.99240E+03    0.42474E+02    0.16019E-02   -0.28177E+02
  1005    0.99082E+03    0.42394E+02    0.15989E-02   -0.29577E+02
  1006    0.98938E+03    0.42307E+02    0.15959E-02   -0.30967E+02
  1007    0.98809E+03    0.42215E+02    0.15930E-02   -0.32348E+02
  1008    0.98694E+03    0.42116E+02    0.15901E-02   -0.33719E+02
  1009    0.98592E+03    0.42012E+02    0.15873E-02   -0.35079E+02
  1010    0.98505E+03    0.41901E+02    0.15844E-02   -0.36429E+02
  1011    0.98430E+03    0.41785E+02    0.15817E-02   -0.37767E+02
  1012    0.98369E+03    0.41663E+02    0.15789E-02   -0.39093E+02
  1013    0.98321E+03    0.41536E+02    0.15762E-02   -0.40407E+02
  1014    0.98285E+03    0.41403E+02    0.15735E-02   -0.41709E+02
  1015    0.98263E+03    0.41265E+02    0.15709E-02   -0.42998E+02
  1016    0.98252E+03    0.41121E+02    0.15683E-02   -0.44274E+02
  1017    0.98254E+03    0.40972E+02    0.15657E-02   -0.45536E+02
  1018    0.98268E+03    0.40818E+02    0.15631E-02   -0.46784E+02
  1019    0.98293E+03    0.40658E+02    0.15605E-02   -0.48017E+02
  1020    0.98330E+03    0.40494E+02    0.15579E-02   -0.49236E+02
  1021    0.98378E+03    0.40325E+02    0.15554E-02   -0.50439E+02
  1022    0.98438E+03    0.40150E+02    0.15529E-02   -0.51627E+02
  1023    0.98508E+03    0.39971E+02    0.15503E-02   -0.52798E+02
  1024    0.98589E+03    0.39788E+02    0.15478E-02   -0.53953E+02
  1025    0.98680E+03    0.39599E+02    0.15453E-02   -0.55092E+02
  1026    0.98782E+03    0.39406E+02    0.15428E-02   -0.56212E+02
  1027    0.98894E+03    0.39209E+02    0.15403E-02   -0.57316E+02
  1028    0.99015E+03    0.39007E+02    0.15378E-02   -0.58401E+02
  1029    0.99147E+03    0.38800E+02    0.15352E-02   -0.59468E+02
  1030    0.99287E+03    0.38590E+02    0.15327E-02   -0.60515E+02
  1031    0.99437E+03    0.38375E+02    0.15302E-02   -0.61544E+02
  1032    0.99596E+03    0.38156E+02    0.15276E-02   -0.62553E+02
  1033    0.99763E+03    0.37934E+02    0.15251E-02   -0.63542E+02
  1034    0.99940E+03    0.37707E+02    0.15225E-02   -0.64510E+02
  1035    0.10012E+04    0.37476E+02    0.15199E-02   -0.65457E+02
  1036    0.10032E+04    0.37242E+02    0.15173E-02   -0.66384E+02
  1037    0.10052E+04    0.37004E+02    0.15146E-02   -0.67288E+02
  1038    0.10073E+04    0.36762E+02    0.15120E-02   -0.68171E+02
  1039    0.10094E+04    0.36517E+02    0.15093E-02   -0.69030E+02
  1040    0.10116E+04    0.36269E+02    0.15066E-02   -0.69868E+02
  1041    0.10140E+04    0.36017E+02    0.15038E-02   -0.70681E+02
  1042    0.10163E+04    0.35761E+02    0.15010E-02   -0.71472E+02
  1043    0.10188E+04    0.35503E+02    0.14982E-02   -0.72238E+02
  1044    0.10213E+04    0.35241E+02    0.14953E-02   -0.72979E+02
  1045    0.10238E+04    0.34976E+02    0.14924E-02   -0.73696E+02
  1046    0.10265E+04    0.34709E+02    0.14895E-02   -0.74388E+02
  1047    0.10291E+04    0.34438E+02    0.14865E-02   -0.75054E+02
  1048    0.10319E+04    0.34164E+02    0.14835E-02   -0.75694E+02
  1049    0.10347E+04    0.33888E+02    0.14804E-02   -0.76307E+02
  1050    0.10375E+04    0.33609E+02    0.14773E-02   -0.76893E+02
  1051    0.10404E+04    0.33328E+02    0.14741E-02   -0.77453E+02
  1052    0.10434E+04    0.33044E+02    0.14709E-02   -0.77985E+02
  1053    0.10463E+04    0.32758E+02    0.14676E-02   -0.78490E+02
  1054    0.10494E+04    0.32469E+02    0.14643E-02   -0.78969E+02
  1055    0.10525E+04    0.32179E+02    0.14609E-02   -0.79421E+02
  1056    0.10556E+04    0.31886E+02    0.14575E-02   -0.79846E+02
  1057    0.10587E+04    0.31592E+02    0.14540E-02   -0.80245E+02
  1058    0.10619E+04    0.31296E+02    0.14505E-02   -0.80617E+02
  1059    0.10651E+04    0.30998E+02    0.14469E-02   -0.80964E+02
  1060    0.10683E+04    0.30699E+02    0.14433E-02   -0.81285E+02
  1061    0.10716E+04    0.30399E+02    0.14397E-02   -0.81579E+02
  1062    0.10749E+04    0.30097E+02    0.14360E-02   -0.81849E+02
  1063    0.10782E+04    0.29794E+02    0.14323E-02   -0.82092E+02
  1064    0.10815E+04    0.29490E+02    0.14286E-02   -0.82311E+02
  1065    0.10849E+04    0.29186E+02    0.14248E-02   -0.82504E+02
  1066    0.10882E+04    0.28880E+02    0.14210E-02   -0.82672E+02
  1067    0.10916E+04    0.28574E+02    0.14172E-02   -0.82815E+02
  1068    0.10950E+04    0.28267E+02    0.14133E-02   -0.82934E+02
  1069    0.10983E+04    0.27960E+02    0.14094E-02   -0.83027E+02
  1070    0.11017E+04    0.27653E+02    0.14055E-02   -0.83097E+02
  1071    0.11051E+04    0.27346E+02    0.14016E-02   -0.83142E+02
  1072    0.11085E+04    0.27038E+02    0.13976E-02   -0.83163E+02
  1073    0.11119E+04    0.26731E+02    0.13936E-02   -0.83160E+02
  1074    0.11153E+04    0.26424E+02    0.13896E-02   -0.83133E+02
  1075    0.11187E+04    0.26117E+02    0.13856E-02   -0.83082E+02
  1076    0.11220E+04    0.25811E+02    0.13816E-02   -0.83007E+02
  1077    0.11254E+04    0.25506E+02    0.13775E-02   -0.82910E+02
  1078    0.11287E+04    0.25201E+02    0.13734E-02   -0.82789E+02
  1079    0.11320E+04    0.24897E+02    0.13694E-02   -0.82644E+02
  1080    0.11354E+04    0.24594E+02    0.13653E-02   -0.82477E+02
  1081    0.11386E+04    0.24292E+02    0.13612E-02   -0.82287E+02
  1082    0.11419E+04    0.23991E+02    0.13571E-02   -0.82074E+02
  1083    0.11451E+04    0.23691E+02    0.13529E-02   -0.81839E+02
  1084    0.11483E+04    0.23394E+02    0.13488E-02   -0.81581E+02
  1085    0.11515E+04    0.23097E+02    0.13447E-02   -0.81301E+02
  1086    0.11546E+04    0.22802E+02    0.13406E-02   -0.80999E+02
  1087    0.11577E+04    0.22509E+02    0.13364E-02   -0.80675E+02
  1088    0.11608E+04    0.22219E+02    0.13323E-02   -0.80329E+02
  1089    0.11638E+04    0.21930E+02    0.13282E-02   -0.79962E+02
  1090    0.11668E+04    0.21643E+02    0.13241E-02   -0.79573E+02
  1091    0.11697E+04    0.21359E+02    0.13199E-02   -0.79162E+02
  1092    0.11726E+04    0.21077E+02    0.13158E-02   -0.78731E+02
  1093    0.11754E+04    0.20797E+02    0.13117E-02   -0.78278E+02
  1094    0.11782E+04    0.20521E+02    0.13076E-02   -0.77804E+02
  1095    0.11809E+04    0.20247E+02    0.13035E-02   -0.77310E+02
  1096    0.11836E+04    0.19976E+02    0.12995E-02   -0.76795E+02
  1097    0.11862E+04    0.19708E+02    0.12954E-02   -0.76259E+02
  1098    0.11888E+04    0.19443E+02    0.12913E-02   -0.75703E+02
  1099    0.11912E+04    0.19182E+02    0.12873E-02   -0.75127E+02
  1100    0.11937E+04    0.18924E+02    0.12833E-02   -0.74531E+02
  1101    0.11960E+04    0.18669E+02    0.12793E-02   -0.73914E+02
  1102    0.11983E+04    0.18418E+02    0.12753E-02   -0.73279E+02
  1103    0.12005E+04    0.18171E+02    0.12714E-02   -0.72624E+02
  1104    0.12026E+04    0.17927E+02    0.12675E-02   -0.71952E+02
  1105    0.12047E+04    0.17687E+02    0.12635E-02   -0.71261E+02
  1106    0.12067E+04    0.17451E+02    0.12597E-02   -0.70552E+02
  1107    0.12086E+04    0.17218E+02    0.12558E-02   -0.69827E+02
  1108    0.12104E+04    0.16990E+02    0.12519E-02   -0.69084E+02
  1109    0.12122E+04    0.16765E+02    0.12481E-02   -0.68326E+02
  1110    0.12139E+04    0.16545E+02    0.12443E-02   -0.67553E+02
  1111    0.12155E+04    0.16328E+02    0.12405E-02   -0.66764E+02
  1112    0.12171E+04    0.16115E+02    0.12368E-02   -0.65960E+02
  1113    0.12185E+04    0.15906E+02    0.12330E-02   -0.65142E+02
  1114    0.12199E+04    0.15702E+02    0.12293E-02   -0.64311E+02
  1115    0.12212E+04    0.15501E+02    0.12256E-02   -0.63466E+02
  1116    0.12225E+04    0.15305E+02    0.12220E-02   -0.62609E+02
  1117    0.12236E+04    0.15113E+02    0.12184E-02   -0.61739E+02
  1118    0.12247E+04    0.14926E+02    0.12147E-02   -0.60857E+02
  1119    0.12257E+04    0.14742E+02    0.12112E-02   -0.59965E+02
  1120    0.12267E+04    0.14563E+02    0.12076E-02   -0.59061E+02
  1121    0.12275E+04    0.14389E+02    0.12041E-02   -0.58147E+02
  1122    0.12283E+04    0.14219E+02    0.12006E-02   -0.57223E+02
  1123    0.12290E+04    0.14053E+02    0.11971E-02   -0.56290E+02
  1124    0.12296E+04    0.13892E+02    0.11937E-02   -0.55347E+02
  1125    0.12301E+04    0.13736E+02    0.11902E-02   -0.54397E+02
  1126    0.12305E+04    0.13584E+02    0.11869E-02   -0.53438E+02
  1127    0.12309E+04    0.13437E+02    0.11835E-02   -0.52472E+02
  1128    0.12312E+04    0.13295E+02    0.11802E-02   -0.51499E+02
  1129    0.12314E+04    0.13157E+02    0.11769E-02   -0.50519E+02
  1130    0.12315E+04    0.13024E+02    0.11736E-02   -0.49533E+02
  1131    0.12315E+04    0.12897E+02    0.11704E-02   -0.48542E+02
  1132    0.12314E+04    0.12774E+02    0.11671E-02   -0.47545E+02
  1133    0.12313E+04    0.12656E+02    0.11640E-02   -0.46544E+02
  1134    0.12311E+04    0.12543E+02    0.11608E-02   -0.45539E+02
  1135    0.12307E+04    0.12435E+02    0.11577E-02   -0.44530E+02
  1136    0.12303E+04    0.12332E+02    0.11546E-02   -0.43518E+02
  1137    0.12298E+04    0.12234E+02    0.11516E-02   -0.42503E+02
  1138    0.12292E+04    0.12141E+02    0.11486E-02   -0.41485E+02
  1139    0.12286E+04    0.12054E+02    0.11456E-02   -0.40467E+02
  1140    0.12278E+04    0.11972E+02    0.11427E-02   -0.39446E+02
  1141    0.12270E+04    0.11895E+02    0.11398E-02   -0.38425E+02
  1142    0.12260E+04    0.11824E+02    0.11369E-02   -0.37404E+02
  1143    0.12250E+04    0.11757E+02    0.11340E-02   -0.36383E+02
  1144    0.12239E+04    0.11697E+02    0.11312E-02   -0.35362E+02
  1145    0.12226E+04    0.11642E+02    0.11285E-02   -0.34342E+02
  1146    0.12213E+04    0.11592E+02    0.11257E-02   -0.33324E+02
  1147    0.12199E+04    0.11548E+02    0.11230E-02   -0.32308E+02
  1148    0.12184E+04    0.11510E+02    0.11204E-02   -0.31295E+02
  1149    0.12168E+04    0.11477E+02    0.11178E-02   -0.30285E+02
  1150    0.12152E+04    0.11450E+02    0.11152E-02   -0.29278E+02
  1151    0.12134E+04    0.11429E+02    0.11126E-02   -0.28275E+02
  1152    0.12115E+04    0.11413E+02    0.11101E-02   -0.27276E+02
  1153    0.12095E+04    0.11403E+02    0.11077E-02   -0.26282E+02
  1154    0.12075E+04    0.11399E+02    0.11052E-02   -0.25293E+02
  1155    0.12054E+04    0.11400E+02    0.11028E-02   -0.24309E+02
  1156    0.12031E+04    0.11406E+02    0.11005E-02   -0.23330E+02
  1157    0.12008E+04    0.11418E+02    0.10981E-02   -0.22358E+02
  1158    0.11984E+04    0.11435E+02    0.10958E-02   -0.21392E+02
  1159    0.11959E+04    0.11457E+02    0.10935E-02   -0.20432E+02
  1160    0.11933E+04    0.11485E+02    0.10913E-02   -0.19479E+02
  1161    0.11907E+04    0.11518E+02    0.10891E-02   -0.18534E+02
  1162    0.11880E+04    0.11555E+02    0.10869E-02   -0.17596E+02
  1163    0.11851E+04    0.11598E+02    0.10847E-02   -0.16665E+02
  1164    0.11823E+04    0.11646E+02    0.10826E-02   -0.15743E+02
  1165    0.11793E+04    0.11698E+02    0.10804E-02   -0.14830E+02
  1166    0.11763E+04    0.11756E+02    0.10783E-02   -0.13925E+02
  1167    0.11731E+04    0.11818E+02    0.10763E-02   -0.13030E+02
  1168    0.11700E+04    0.11884E+02    0.10742E-02   -0.12144E+02
  1169    0.11667E+04    0.11956E+02    0.10721E-02   -0.11268E+02
  1170    0.11634E+04    0.12032E+02    0.10701E-02   -0.10402E+02
  1171    0.11600E+04    0.12112E+02    0.10681E-02   -0.95459E+01
  1172    0.11566E+04    0.12197E+02    0.10661E-02   -0.87011E+01
  1173    0.11530E+04    0.12286E+02    0.10641E-02   -0.78674E+01
  1174    0.11495E+04    0.12379E+02    0.10621E-02   -0.70451E+01
  1175    0.11458E+04    0.12477E+02    0.10602E-02   -0.62346E+01
  1176    0.11421E+04    0.12579E+02    0.10582E-02   -0.54362E+01
  1177    0.11383E+04    0.12685E+02    0.10562E-02   -0.46502E+01
  1178    0.11345E+04    0.12795E+02    0.10543E-02   -0.38769E+01
  1179    0.11306E+04    0.12908E+02    0.10524E-02   -0.31167E+01
  1180    0.11267E+04    0.13026E+02    0.10504E-02   -0.23699E+01
  1181    0.11227E+04    0.13148E+02    0.10485E-02   -0.16368E+01
  1182    0.11187E+04    0.13273E+02    0.10466E-02   -0.91775E+00
  1183    0.11146E+04    0.13403E+02    0.10447E-02   -0.21305E+00
  1184    0.11104E+04    0.13535E+02    0.10427E-02    0.47696E+00
  1185    0.11063E+04    0.13672E+02    0.10408E-02    0.11520E+01
  1186    0.11020E+04    0.13812E+02    0.10389E-02    0.18116E+01
  1187    0.10977E+04    0.13955E+02    0.10370E-02    0.24556E+01
  1188    0.10934E+04    0.14102E+02    0.10350E-02    0.30836E+01
  1189    0.10890E+04    0.14252E+02    0.10331E-02    0.36953E+01
  1190    0.10846E+04    0.14405E+02    0.10312E-02    0.42904E+01
  1191    0.10802E+04    0.14562E+02    0.10292E-02    0.48684E+01
  1192    0.10757E+04    0.14722E+02    0.10272E-02    0.54292E+01
  1193    0.10712E+04    0.14885E+02    0.10253E-02    0.59724E+01
  1194    0.10666E+04    0.15050E+02    0.10233E-02    0.64976E+01
  1195    0.10620E+04    0.15219E+02    0.10213E-02    0.70046E+01
  1196    0.10574E+04    0.15391E+02    0.10193E-02    0.74930E+01
  1197    0.10527E+04    0.15566E+02    0.10173E-02    0.79624E+01
  1198    0.10480E+04    0.15743E+02    0.10152E-02    0.84126E+01
  1199    0.10433E+04    0.15923E+02    0.10132E-02    0.88433E+01
  1200    0.10386E+04    0.16106E+02    0.10111E-02    0.92540E+01
  1201    0.10338E+04    0.16291E+02    0.10090E-02    0.96446E+01
  1202    0.10290E+04    0.16478E+02    0.10069E-02    0.10015E+02
  1203    0.10242E+04    0.16668E+02    0.10047E-02    0.10366E+02
  1204    0.10193E+04    0.16861E+02    0.10026E-02    0.10696E+02
  1205    0.10145E+04    0.17055E+02    0.10004E-02    0.11007E+02
  1206    0.10096E+04    0.17252E+02    0.99823E-03    0.11298E+02
  1207    0.10047E+04    0.17450E+02    0.99603E-03    0.11569E+02
  1208    0.99978E+03    0.17651E+02    0.99381E-03    0.11821E+02
  1209    0.99485E+03    0.17853E+02    0.99158E-03    0.12053E+02
  1210    0.98991E+03    0.18057E+02    0.98933E-03    0.12266E+02
  1211    0.98497E+03    0.18262E+02    0.98706E-03    0.12459E+02
  1212    0.98001E+03    0.18469E+02    0.98478E-03    0.12634E+02
  1213    0.97505E+03    0.18677E+02    0.98249E-03    0.12789E+02
  1214    0.97008E+03    0.18886E+02    0.98018E-03    0.12925E+02
  1215    0.96511E+03    0.19097E+02    0.97786E-03    0.13043E+02
  1216    0.96014E+03    0.19308E+02    0.97553E-03    0.13141E+02
  1217    0.95517E+03    0.19521E+02    0.97318E-03    0.13221E+02
  1218    0.95020E+03    0.19734E+02    0.97082E-03    0.13282E+02
  1219    0.94523E+03    0.19949E+02    0.96845E-03    0.13325E+02
  1220    0.94027E+03    0.20163E+02    0.96607E-03    0.13350E+02
  1221    0.93531E+03    0.20379E+02    0.96368E-03    0.13356E+02
  1222    0.93036E+03    0.20594E+02    0.96128E-03    0.13343E+02
  1223    0.92543E+03    0.20810E+02    0.95887E-03    0.13313E+02
  1224    0.92050E+03    0.21027E+02    0.95645E-03    0.13264E+02
  1225    0.91559E+03    0.21243E+02    0.95402E-03    0.13198E+02
  1226    0.91069E+03    0.21459E+02    0.95158E-03    0.13114E+02
  1227    0.90581E+03    0.21676E+02    0.94914E-03    0.13012E+02
  1228    0.90094E+03    0.21892E+02    0.94668E-03    0.12892E+02
  1229    0.89610E+03    0.22108E+02    0.94422E-03    0.12754E+02
  1230    0.89127E+03    0.22323E+02    0.94175E-03    0.12600E+02
  1231    0.88647E+03    0.22538E+02    0.93928E-03    0.12427E+02
  1232    0.88170E+03    0.22753E+02    0.93680E-03    0.12238E+02
  1233    0.87695E+03    0.22967E+02    0.93432E-03    0.12031E+02
  1234    0.87222E+03    0.23180E+02    0.93183E-03    0.11807E+02
  1235    0.86753E+03    0.23392E+02    0.92933E-03    0.11566E+02
  1236    0.86287E+03    0.23603E+02    0.92683E-03    0.11309E+02
  1237    0.85824E+03    0.23813E+02    0.92433E-03    0.11034E+02
  1238    0.85365E+03    0.24021E+02    0.92183E-03    0.10743E+02
  1239    0.84909E+03    0.24229E+02    0.91932E-03    0.10435E+02
  1240    0.84457E+03    0.24435E+02    0.91681E-03    0.10110E+02
  1241    0.84009E+03    0.24640E+02    0.91429E-03    0.97689E+01
  1242    0.83565E+03    0.24843E+02    0.91178E-03    0.94115E+01
  1243    0.83125E+03    0.25044E+02    0.90927E-03    0.90379E+01
  1244    0.82689E+03    0.25243E+02    0.90675E-03    0.86481E+01
  1245    0.82259E+03    0.25441E+02    0.90423E-03    0.82421E+01
  1246    0.81833E+03    0.25636E+02    0.90172E-03    0.78202E+01
  1247    0.81412E+03    0.25830E+02    0.89921E-03    0.73824E+01
  1248    0.80996E+03    0.26021E+02    0.89669E-03    0.69288E+01
  1249    0.80585E+03    0.26210E+02    0.89418E-03    0.64595E+01
  1250    0.80179E+03    0.26396E+02    0.89167E-03    0.59746E+01
  1251    0.79780E+03    0.26580E+02    0.88916E-03    0.54743E+01
  1252    0.79385E+03    0.26761E+02    0.88666E-03    0.49587E+01
  1253    0.78997E+03    0.26940E+02    0.88416E-03    0.44284E+01
  1254    0.78614E+03    0.27116E+02    0.88166E-03    0.38837E+01
  1255    0.78237E+03    0.27290E+02    0.87917E-03    0.33249E+01
  1256    0.77865E+03    0.27460E+02    0.87668E-03    0.27524E+01
  1257    0.77500E+03    0.27628E+02    0.87419E-03    0.21666E+01
  1258    0.77140E+03    0.27793E+02    0.87171E-03    0.15678E+01
  1259    0.76786E+03    0.27955E+02    0.86924E-03    0.95643E+00
  1260    0.76438E+03    0.28115E+02    0.86677E-03    0.33282E+00
  1261    0.76096E+03    0.28271E+02    0.86430E-03   -0.30265E+00
  1262    0.75760E+03    0.28424E+02    0.86185E-03   -0.94963E+00
  1263    0.75430E+03    0.28574E+02    0.85940E-03   -0.16077E+01
  1264    0.75106E+03    0.28721E+02    0.85695E-03   -0.22766E+01
  1265    0.74788E+03    0.28865E+02    0.85452E-03   -0.29559E+01
  1266    0.74476E+03    0.29006E+02    0.85209E-03   -0.36453E+01
  1267    0.74171E+03    0.29144E+02    0.84967E-03   -0.43443E+01
  1268    0.73871E+03    0.29278E+02    0.84726E-03   -0.50526E+01
  1269    0.73578E+03    0.29409E+02    0.84486E-03   -0.57699E+01
  1270    0.73291E+03    0.29536E+02    0.84247E-03   -0.64958E+01
  1271    0.73011E+03    0.29661E+02    0.84008E-03   -0.72298E+01
  1272    0.72736E+03    0.29781E+02    0.83771E-03   -0.79718E+01
  1273    0.72469E+03    0.29899E+02    0.83535E-03   -0.87212E+01
  1274    0.72207E+03    0.30012E+02    0.83299E-03   -0.94777E+01
  1275    0.71952E+03    0.30122E+02    0.83065E-03   -0.10241E+02
  1276    0.71704E+03    0.30229E+02    0.82832E-03   -0.11011E+02
  1277    0.71462E+03    0.30332E+02    0.82600E-03   -0.11786E+02
  1278    0.71227E+03    0.30431E+02    0.82369E-03   -0.12568E+02
  1279    0.70998E+03    0.30526E+02    0.82140E-03   -0.13355E+02
  1280    0.70776E+03    0.30618E+02    0.81912E-03   -0.14146E+02
  1281    0.70560E+03    0.30705E+02    0.81685E-03   -0.14942E+02
  1282    0.70352E+03    0.30789E+02    0.81460E-03   -0.15743E+02
  1283    0.70150E+03    0.30869E+02    0.81235E-03   -0.16547E+02
  1284    0.69954E+03    0.30945E+02    0.81013E-03   -0.17355E+02
  1285    0.69766E+03    0.31017E+02    0.80791E-03   -0.18166E+02
  1286    0.69585E+03    0.31085E+02    0.80572E-03   -0.18979E+02
  1287    0.69410E+03    0.31148E+02    0.80353E-03   -0.19795E+02
  1288    0.69243E+03    0.31208E+02    0.80137E-03   -0.20613E+02
  1289    0.69082E+03    0.31263E+02    0.79922E-03   -0.21433E+02
  1290    0.68928E+03    0.31314E+02    0.79708E-03   -0.22254E+02
  1291    0.68782E+03    0.31361E+02    0.79496E-03   -0.23076E+02
  1292    0.68642E+03    0.31404E+02    0.79286E-03   -0.23898E+02
  1293    0.68510E+03    0.31442E+02    0.79078E-03   -0.24720E+02
  1294    0.68385E+03    0.31476E+02    0.78871E-03   -0.25543E+02
  1295    0.68267E+03    0.31505E+02    0.78666E-03   -0.26365E+02
  1296    0.68156E+03    0.31530E+02    0.78463E-03   -0.27186E+02
  1297    0.68053E+03    0.31550E+02    0.78262E-03   -0.28005E+02
  1298    0.67956E+03    0.31565E+02    0.78063E-03   -0.28824E+02
  1299    0.67868E+03    0.31576E+02    0.77866E-03   -0.29640E+02
  1300    0.67786E+03    0.31583E+02    0.77671E-03   -0.30453E+02
  1301    0.67712E+03    0.31584E+02    0.77477E-03   -0.31264E+02
  1302    0.67646E+03    0.31581E+02    0.77286E-03   -0.32072E+02
  1303    0.67586E+03    0.31573E+02    0.77097E-03   -0.32877E+02
  1304    0.67534E+03    0.31561E+02    0.76909E-03   -0.33678E+02
  1305    0.67488E+03    0.31544E+02    0.76724E-03   -0.34476E+02
  1306    0.67450E+03    0.31523E+02    0.76540E-03   -0.35269E+02
  1307    0.67418E+03    0.31497E+02    0.76358E-03   -0.36058E+02
  1308    0.67394E+03    0.31466E+02    0.76177E-03   -0.36842E+02
  1309    0.67375E+03    0.31432E+02    0.75998E-03   -0.37622E+02
  1310    0.67364E+03    0.31393E+02    0.75821E-03   -0.38396E+02
  1311    0.67358E+03    0.31350E+02    0.75646E-03   -0.39165E+02
  1312    0.67359E+03    0.31302E+02    0.75471E-03   -0.39928E+02
  1313    0.67366E+03    0.31251E+02    0.75299E-03   -0.40686E+02
  1314    0.67380E+03    0.31195E+02    0.75128E-03   -0.41437E+02
  1315    0.67399E+03    0.31135E+02    0.74958E-03   -0.42181E+02
  1316    0.67424E+03    0.31071E+02    0.74789E-03   -0.42919E+02
  1317    0.67455E+03    0.31003E+02    0.74622E-03   -0.43650E+02
  1318    0.67492E+03    0.30931E+02    0.74456E-03   -0.44373E+02
  1319    0.67535E+03    0.30856E+02    0.74291E-03   -0.45089E+02
  1320    0.67582E+03    0.30776E+02    0.74127E-03   -0.45797E+02
  1321    0.67636E+03    0.30693E+02    0.73965E-03   -0.46497E+02
  1322    0.67694E+03    0.30606E+02    0.73803E-03   -0.47188E+02
  1323    0.67758E+03    0.30515E+02    0.73643E-03   -0.47871E+02
  1324    0.67827E+03    0.30420E+02    0.73483E-03   -0.48545E+02
  1325    0.67901E+03    0.30322E+02    0.73325E-03   -0.49210E+02
  1326    0.67980E+03    0.30220E+02    0.73167E-03   -0.49865E+02
  1327    0.68063E+03    0.30115E+02    0.73010E-03   -0.50511E+02
  1328    0.68152E+03    0.30006E+02    0.72854E-03   -0.51147E+02
  1329    0.68245E+03    0.29893E+02    0.72698E-03   -0.51772E+02
  1330    0.68342E+03    0.29778E+02    0.72544E-03   -0.52387E+02
  1331    0.68444E+03    0.29659E+02    0.72390E-03   -0.52991E+02
  1332    0.68550E+03    0.29536E+02    0.72236E-03   -0.53584E+02
  1333    0.68661E+03    0.29411E+02    0.72083E-03   -0.54165E+02
  1334    0.68775E+03    0.29282E+02    0.71931E-03   -0.54735E+02
  1335    0.68894E+03    0.29150E+02    0.71779E-03   -0.55293E+02
  1336    0.69016E+03    0.29014E+02    0.71627E-03   -0.55839E+02
  1337    0.69142E+03    0.28876E+02    0.71476E-03   -0.56373E+02
  1338    0.69272E+03    0.28735E+02    0.71325E-03   -0.56893E+02
  1339    0.69405E+03    0.28591E+02    0.71174E-03   -0.57401E+02
  1340    0.69542E+03    0.28443E+02    0.71024E-03   -0.57896E+02
  1341    0.69683E+03    0.28293E+02    0.70874E-03   -0.58377E+02
  1342    0.69826E+03    0.28140E+02    0.70724E-03   -0.58845E+02
  1343    0.69973E+03    0.27984E+02    0.70574E-03   -0.59298E+02
  1344    0.70123E+03    0.27826E+02    0.70424E-03   -0.59737E+02
  1345    0.70276E+03    0.27664E+02    0.70274E-03   -0.60161E+02
  1346    0.70432E+03    0.27500E+02    0.70124E-03   -0.60571E+02
  1347    0.70590E+03    0.27333E+02    0.69974E-03   -0.60965E+02
  1348    0.70752E+03    0.27164E+02    0.69823E-03   -0.61345E+02
  1349    0.70916E+03    0.26992E+02    0.69673E-03   -0.61708E+02
  1350    0.71082E+03    0.26818E+02    0.69522E-03   -0.62056E+02
  1351    0.71251E+03    0.26641E+02    0.69371E-03   -0.62387E+02
  1352    0.71422E+03    0.26462E+02    0.69220E-03   -0.62702E+02
  1353    0.71595E+03    0.26281E+02    0.69069E-03   -0.63002E+02
  1354    0.71770E+03    0.26097E+02    0.68917E-03   -0.63285E+02
  1355    0.71947E+03    0.25912E+02    0.68765E-03   -0.63552E+02
  1356    0.72126E+03    0.25724E+02    0.68613E-03   -0.63803E+02
  1357    0.72306E+03    0.25534E+02    0.68460E-03   -0.64038E+02
  1358    0.72488E+03    0.25343E+02    0.68307E-03   -0.64258E+02
  1359    0.72672E+03    0.25149E+02    0.68154E-03   -0.64462E+02
  1360    0.72856E+03    0.24954E+02    0.68001E-03   -0.64650E+02
  1361    0.73042E+03    0.24758E+02    0.67847E-03   -0.64822E+02
  1362    0.73229E+03    0.24559E+02    0.67693E-03   -0.64978E+02
  1363    0.73416E+03    0.24360E+02    0.67539E-03   -0.65119E+02
  1364    0.73605E+03    0.24159E+02    0.67384E-03   -0.65245E+02
  1365    0.73793E+03    0.23956E+02    0.67230E-03   -0.65355E+02
  1366    0.73983E+03    0.23753E+02    0.67075E-03   -0.65449E+02
  1367    0.74173E+03    0.23548E+02    0.66919E-03   -0.65528E+02
  1368    0.74363E+03    0.23342E+02    0.66764E-03   -0.65592E+02
  1369    0.74553E+03    0.23135E+02    0.66608E-03   -0.65641E+02
  1370    0.74743E+03    0.22928E+02    0.66452E-03   -0.65674E+02
  1371    0.74933E+03    0.22720E+02    0.66296E-03   -0.65692E+02
  1372    0.75123E+03    0.22510E+02    0.66139E-03   -0.65695E+02
  1373    0.75312E+03    0.22301E+02    0.65982E-03   -0.65682E+02
  1374    0.75501E+03    0.22090E+02    0.65825E-03   -0.65655E+02
  1375    0.75689E+03    0.21880E+02    0.65667E-03   -0.65613E+02
  1376    0.75877E+03    0.21669E+02    0.65510E-03   -0.65556E+02
  1377    0.76063E+03    0.21457E+02    0.65352E-03   -0.65483E+02
  1378    0.76249E+03    0.21246E+02    0.65193E-03   -0.65396E+02
  1379    0.76433E+03    0.21034E+02    0.65035E-03   -0.65295E+02
  1380    0.76616E+03    0.20822E+02    0.64876E-03   -0.65178E+02
  1381    0.76798E+03    0.20610E+02    0.64717E-03   -0.65047E+02
  1382    0.76978E+03    0.20399E+02    0.64558E-03   -0.64901E+02
  1383    0.77156E+03    0.20187E+02    0.64398E-03   -0.64740E+02
  1384    0.77333E+03    0.19976E+02    0.64238E-03   -0.64565E+02
  1385    0.77508E+03    0.19765E+02    0.64078E-03   -0.64375E+02
  1386    0.77681E+03    0.19555E+02    0.63918E-03   -0.64171E+02
  1387    0.77851E+03    0.19345E+02    0.63757E-03   -0.63953E+02
  1388    0.78020E+03    0.19136E+02    0.63596E-03   -0.63720E+02
  1389    0.78186E+03    0.18927E+02    0.63435E-03   -0.63473E+02
  1390    0.78349E+03    0.18719E+02    0.63273E-03   -0.63211E+02
  1391    0.78510E+03    0.18512E+02    0.63112E-03   -0.62936E+02
  1392    0.78668E+03    0.18306E+02    0.62950E-03   -0.62646E+02
  1393    0.78823E+03    0.18102E+02    0.62788E-03   -0.62342E+02
  1394    0.78975E+03    0.17898E+02    0.62625E-03   -0.62024E+02
  1395    0.79123E+03    0.17695E+02    0.62462E-03   -0.61692E+02
  1396    0.79269E+03    0.17494E+02    0.62299E-03   -0.61346E+02
  1397    0.79411E+03    0.17294E+02    0.62136E-03   -0.60986E+02
  1398    0.79549E+03    0.17095E+02    0.61972E-03   -0.60612E+02
  1399    0.79684E+03    0.16898E+02    0.61809E-03   -0.60225E+02
  1400    0.79815E+03    0.16703E+02    0.61645E-03   -0.59823E+02
  1401    0.79942E+03    0.16509E+02    0.61480E-03   -0.59408E+02
  1402    0.80066E+03    0.16317E+02    0.61316E-03   -0.58980E+02
  1403    0.80185E+03    0.16126E+02    0.61151E-03   -0.58538E+02
  1404    0.80300E+03    0.15938E+02    0.60986E-03   -0.58083E+02
  1405    0.80411E+03    0.15751E+02    0.60821E-03   -0.57616E+02
  1406    0.80518E+03    0.15567E+02    0.60656E-03   -0.57137E+02
  1407    0.80620E+03    0.15384E+02    0.60490E-03   -0.56645E+02
  1408    0.80719E+03    0.15203E+02    0.60325E-03   -0.56142E+02
  1409    0.80813E+03    0.15024E+02    0.60159E-03   -0.55627E+02
  1410    0.80903E+03    0.14848E+02    0.59994E-03   -0.55101E+02
  1411    0.80989E+03    0.14673E+02    0.59829E-03   -0.54564E+02
  1412    0.81070E+03    0.14501E+02    0.59663E-03   -0.54016E+02
  1413    0.81147E+03    0.14330E+02    0.59498E-03   -0.53458E+02
  1414    0.81220E+03    0.14162E+02    0.59333E-03   -0.52890E+02
  1415    0.81288E+03    0.13997E+02    0.59167E-03   -0.52312E+02
  1416    0.81351E+03    0.13833E+02    0.59003E-03   -0.51724E+02
  1417    0.81410E+03    0.13672E+02    0.58838E-03   -0.51127E+02
  1418    0.81465E+03    0.13513E+02    0.58673E-03   -0.50521E+02
  1419    0.81515E+03    0.13357E+02    0.58509E-03   -0.49907E+02
  1420    0.81560E+03    0.13203E+02    0.58345E-03   -0.49284E+02
  1421    0.81600E+03    0.13052E+02    0.58181E-03   -0.48652E+02
  1422    0.81636E+03    0.12904E+02    0.58017E-03   -0.48013E+02
  1423    0.81667E+03    0.12757E+02    0.57854E-03   -0.47366E+02
  1424    0.81693E+03    0.12614E+02    0.57691E-03   -0.46712E+02
  1425    0.81714E+03    0.12473E+02    0.57529E-03   -0.46051E+02
  1426    0.81731E+03    0.12335E+02    0.57367E-03   -0.45383E+02
  1427    0.81742E+03    0.12200E+02    0.57205E-03   -0.44708E+02
  1428    0.81749E+03    0.12068E+02    0.57044E-03   -0.44028E+02
  1429    0.81750E+03    0.11939E+02    0.56884E-03   -0.43341E+02
  1430    0.81746E+03    0.11812E+02    0.56724E-03   -0.42648E+02
  1431    0.81738E+03    0.11688E+02    0.56564E-03   -0.41951E+02
  1432    0.81724E+03    0.11568E+02    0.56405E-03   -0.41248E+02
  1433    0.81705E+03    0.11450E+02    0.56247E-03   -0.40540E+02
  1434    0.81681E+03    0.11336E+02    0.56090E-03   -0.39827E+02
  1435    0.81651E+03    0.11224E+02    0.55933E-03   -0.39111E+02
  1436    0.81617E+03    0.11116E+02    0.55776E-03   -0.38390E+02
  1437    0.81577E+03    0.11011E+02    0.55621E-03   -0.37665E+02
  1438    0.81531E+03    0.10909E+02    0.55466E-03   -0.36937E+02
  1439    0.81481E+03    0.10811E+02    0.55312E-03   -0.36206E+02
  1440    0.81424E+03    0.10715E+02    0.55159E-03   -0.35472E+02
  1441    0.81363E+03    0.10624E+02    0.55006E-03   -0.34736E+02
  1442    0.81296E+03    0.10535E+02    0.54855E-03   -0.33997E+02
  1443    0.81223E+03    0.10450E+02    0.54704E-03   -0.33255E+02
  1444    0.81145E+03    0.10369E+02    0.54554E-03   -0.32512E+02
  1445    0.81061E+03    0.10291E+02    0.54406E-03   -0.31768E+02
  1446    0.80971E+03    0.10216E+02    0.54258E-03   -0.31022E+02
  1447    0.80876E+03    0.10146E+02    0.54111E-03   -0.30276E+02
  1448    0.80775E+03    0.10079E+02    0.53965E-03   -0.29528E+02
  1449    0.80668E+03    0.10015E+02    0.53820E-03   -0.28780E+02
  1450    0.80555E+03    0.99557E+01    0.53677E-03   -0.28032E+02
  1451    0.80437E+03    0.98999E+01    0.53534E-03   -0.27285E+02
  1452    0.80313E+03    0.98478E+01    0.53393E-03   -0.26537E+02
  1453    0.80183E+03    0.97995E+01    0.53252E-03   -0.25790E+02
  1454    0.80047E+03    0.97549E+01    0.53113E-03   -0.25044E+02
  1455    0.79906E+03    0.97139E+01    0.52974E-03   -0.24299E+02
  1456    0.79759E+03    0.96766E+01    0.52837E-03   -0.23556E+02
  1457    0.79607E+03    0.96429E+01    0.52701E-03   -0.22813E+02
  1458    0.79449E+03    0.96128E+01    0.52565E-03   -0.22073E+02
  1459    0.79286E+03    0.95862E+01    0.52430E-03   -0.21335E+02
  1460    0.79118E+03    0.95631E+01    0.52297E-03   -0.20598E+02
  1461    0.78945E+03    0.95436E+01    0.52164E-03   -0.19865E+02
  1462    0.78766E+03    0.95275E+01    0.52032E-03   -0.19133E+02
  1463    0.78583E+03    0.95148E+01    0.51901E-03   -0.18405E+02
  1464    0.78394E+03    0.95055E+01    0.51771E-03   -0.17680E+02
  1465    0.78201E+03    0.94996E+01    0.51641E-03   -0.16959E+02
  1466    0.78002E+03    0.94970E+01    0.51513E-03   -0.16241E+02
  1467    0.77799E+03    0.94978E+01    0.51385E-03   -0.15526E+02
  1468    0.77592E+03    0.95018E+01    0.51257E-03   -0.14816E+02
  1469    0.77379E+03    0.95091E+01    0.51131E-03   -0.14110E+02
  1470    0.77162E+03    0.95196E+01    0.51005E-03   -0.13409E+02
  1471    0.76941E+03    0.95333E+01    0.50880E-03   -0.12712E+02
  1472    0.76715E+03    0.95502E+01    0.50755E-03   -0.12021E+02
  1473    0.76484E+03    0.95702E+01    0.50632E-03   -0.11334E+02
  1474    0.76250E+03    0.95933E+01    0.50508E-03   -0.10654E+02
  1475    0.76011E+03    0.96195E+01    0.50385E-03   -0.99783E+01
  1476    0.75768E+03    0.96487E+01    0.50263E-03   -0.93090E+01
  1477    0.75520E+03    0.96809E+01    0.50142E-03   -0.86459E+01
  1478    0.75269E+03    0.97161E+01    0.50020E-03   -0.79891E+01
  1479    0.75014E+03    0.97543E+01    0.49900E-03   -0.73390E+01
  1480    0.74755E+03    0.97954E+01    0.49780E-03   -0.66957E+01
  1481    0.74492E+03    0.98393E+01    0.49660E-03   -0.60594E+01
  1482    0.74225E+03    0.98862E+01    0.49540E-03   -0.54305E+01
  1483    0.73954E+03    0.99358E+01    0.49422E-03   -0.48091E+01
  1484    0.73680E+03    0.99883E+01    0.49303E-03   -0.41955E+01
  1485    0.73402E+03    0.10044E+02    0.49185E-03   -0.35899E+01
  1486    0.73121E+03    0.10102E+02    0.49067E-03   -0.29925E+01
  1487    0.72836E+03    0.10162E+02    0.48949E-03   -0.24035E+01
  1488    0.72548E+03    0.10226E+02    0.48832E-03   -0.18233E+01
  1489    0.72257E+03    0.10292E+02    0.48715E-03   -0.12520E+01
  1490    0.71962E+03    0.10360E+02    0.48598E-03   -0.68983E+00
  1491    0.71665E+03    0.10432E+02    0.48482E-03   -0.13707E+00
  1492    0.71364E+03    0.10505E+02    0.48365E-03    0.40608E+00
  1493    0.71060E+03    0.10582E+02    0.48249E-03    0.93937E+00
  1494    0.70753E+03    0.10661E+02    0.48133E-03    0.14626E+01
  1495    0.70443E+03    0.10742E+02    0.48017E-03    0.19755E+01
  1496    0.70130E+03    0.10826E+02    0.47901E-03    0.24778E+01
  1497    0.69815E+03    0.10912E+02    0.47786E-03    0.29694E+01
  1498    0.69497E+03    0.11001E+02    0.47670E-03    0.34500E+01
  1499    0.69176E+03    0.11092E+02    0.47554E-03    0.39193E+01
  1500    0.68853E+03    0.11185E+02    0.47439E-03    0.43772E+01
  1501    0.68523E+03    0.11280E+02    0.00000E+00    0.48198E+01
  1502    0.68195E+03    0.11377E+02    0.00000E+00    0.52543E+01
  1503    0.67864E+03    0.11477E+02    0.00000E+00    0.56771E+01
  1504    0.67532E+03    0.11579E+02    0.00000E+00    0.60882E+01
  1505    0.67197E+03    0.11684E+02    0.00000E+00    0.64877E+01
  1506    0.66860E+03    0.11790E+02    0.00000E+00    0.68754E+01
  1507    0.66521E+03    0.11898E+02    0.00000E+00    0.72515E+01
  1508    0.66180E+03    0.12007E+02    0.00000E+00    0.76159E+01
  1509    0.65838E+03    0.12119E+02    0.00000E+00    0.79686E+01
  1510    0.65494E+03    0.12232E+02    0.00000E+00    0.83097E+01
  1511    0.65148E+03    0.12347E+02    0.00000E+00    0.86390E+01
  1512    0.64801E+03    0.12464E+02    0.00000E+00    0.89567E+01
  1513    0.64453E+03    0.12582E+02    0.00000E+00    0.92628E+01
  1514    0.64103E+03    0.12701E+02    0.00000E+00    0.95571E+01
  1515    0.63752E+03    0.12822E+02    0.00000E+00    0.98399E+01
  1516    0.63401E+03    0.12944E+02    0.00000E+00    0.10111E+02
  1517    0.63048E+03    0.13067E+02    0.00000E+00    0.10370E+02
  1518    0.62694E+03    0.13192E+02    0.00000E+00    0.10618E+02
  1519    0.62340E+03    0.13318E+02    0.00000E+00    0.10854E+02
  1520    0.61985E+03    0.13444E+02    0.00000E+00    0.11079E+02
  1521    0.61629E+03    0.13572E+02    0.00000E+00    0.11292E+02
  1522    0.61273E+03    0.13701E+02    0.00000E+00    0.11493E+02
  1523    0.60916E+03    0.13830E+02    0.00000E+00    0.11682E+02
  1524    0.60560E+03    0.13961E+02    0.00000E+00    0.11860E+02
  1525    0.60203E+03    0.14092E+02    0.00000E+00    0.12027E+02
  1526    0.59846E+03    0.14224E+02    0.00000E+00    0.12181E+02
  1527    0.59488E+03    0.14356E+02    0.00000E+00    0.12324E+02
  1528    0.59132E+03    0.14489E+02    0.00000E+00    0.12456E+02
  1529    0.58775E+03    0.14622E+02    0.00000E+00    0.12576E+02
  1530    0.58418E+03    0.14756E+02    0.00000E+00    0.12684E+02
  1531    0.58062E+03    0.14890E+02    0.00000E+00    0.12780E+02
  1532    0.57707E+03    0.15024E+02    0.00000E+00    0.12865E+02
  1533    0.57352E+03    0.15159E+02    0.00000E+00    0.12939E+02
  1534    0.56998E+03    0.15293E+02    0.00000E+00    0.13001E+02
  1535    0.56644E+03    0.15428E+02    0.00000E+00    0.13051E+02
  1536    0.56291E+03    0.15563E+02    0.00000E+00    0.13089E+02
  1537    0.55940E+03    0.15698E+02    0.00000E+00    0.13116E+02
  1538    0.55589E+03    0.15832E+02    0.00000E+00    0.13132E+02
  1539    0.55240E+03    0.15967E+02    0.00000E+00    0.13136E+02
  1540    0.54892E+03    0.16101E+02    0.00000E+00    0.13128E+02
  1541    0.54545E+03    0.16235E+02    0.00000E+00    0.13109E+02
  1542    0.54200E+03    0.16368E+02    0.00000E+00    0.13078E+02
  1543    0.53856E+03    0.16501E+02    0.00000E+00    0.13036E+02
  1544    0.53514E+03    0.16634E+02    0.00000E+00    0.12982E+02
  1545    0.53173E+03    0.16765E+02    0.00000E+00    0.12916E+02
  1546    0.52835E+03    0.16897E+02    0.00000E+00    0.12839E+02
  1547    0.52498E+03    0.17027E+02    0.00000E+00    0.12750E+02
  1548    0.52164E+03    0.17157E+02    0.00000E+00    0.12650E+02
  1549    0.51831E+03    0.17286E+02    0.00000E+00    0.12538E+02
  1550    0.51501E+03    0.17414E+02    0.00000E+00    0.12415E+02
  1551    0.51173E+03    0.17541E+02    0.00000E+00    0.12280E+02
  1552    0.50848E+03    0.17667E+02    0.00000E+00    0.12134E+02
  1553    0.50525E+03    0.17792E+02    0.00000E+00    0.11976E+02
  1554    0.50204E+03    0.17916E+02    0.00000E+00    0.11808E+02
  1555    0.49886E+03    0.18039E+02    0.00000E+00    0.11629E+02
  1556    0.49571E+03    0.18161E+02    0.00000E+00    0.11439E+02
  1557    0.49258E+03    0.18281E+02    0.00000E+00    0.11239E+02
  1558    0.48947E+03    0.18401E+02    0.00000E+00    0.11029E+02
  1559    0.48640E+03    0.18519E+02    0.00000E+00    0.10808E+02
  1560    0.48335E+03    0.18635E+02    0.00000E+00    0.10578E+02
  1561    0.48032E+03    0.18750E+02    0.00000E+00    0.10338E+02
  1562    0.47733E+03    0.18864E+02    0.00000E+00    0.10089E+02
  1563    0.47436E+03    0.18977E+02    0.00000E+00    0.98308E+01
  1564    0.47142E+03    0.19088E+02    0.00000E+00    0.95632E+01
  1565    0.46852E+03    0.19197E+02    0.00000E+00    0.92868E+01
  1566    0.46564E+03    0.19305E+02    0.00000E+00    0.90017E+01
  1567    0.46279E+03    0.19411E+02    0.00000E+00    0.87081E+01
  1568    0.45997E+03    0.19516E+02    0.00000E+00    0.84063E+01
  1569    0.45718E+03    0.19619E+02    0.00000E+00    0.80963E+01
  1570    0.45442E+03    0.19721E+02    0.00000E+00    0.77784E+01
  1571    0.45169E+03    0.19820E+02    0.00000E+00    0.74528E+01
  1572    0.44900E+03    0.19918E+02    0.00000E+00    0.71197E+01
  1573    0.44633E+03    0.20014E+02    0.00000E+00    0.67792E+01
  1574    0.44370E+03    0.20108E+02    0.00000E+00    0.64316E+01
  1575    0.44111E+03    0.20200E+02    0.00000E+00    0.60770E+01
  1576    0.43854E+03    0.20290E+02    0.00000E+00    0.57156E+01
  1577    0.43602E+03    0.20379E+02    0.00000E+00    0.53477E+01
  1578    0.43352E+03    0.20465E+02    0.00000E+00    0.49734E+01
  1579    0.43106E+03    0.20549E+02    0.00000E+00    0.45929E+01
  1580    0.42863E+03    0.20631E+02    0.00000E+00    0.42064E+01
  1581    0.42624E+03    0.20711E+02    0.00000E+00    0.38141E+01
  1582    0.42389E+03    0.20789E+02    0.00000E+00    0.34161E+01
  1583    0.42157E+03    0.20865E+02    0.00000E+00    0.30128E+01
  1584    0.41929E+03    0.20938E+02    0.00000E+00    0.26042E+01
  1585    0.41705E+03    0.21009E+02    0.00000E+00    0.21905E+01
  1586    0.41484E+03    0.21078E+02    0.00000E+00    0.17720E+01
  1587    0.41267E+03    0.21144E+02    0.00000E+00    0.13489E+01
  1588    0.41055E+03    0.21208E+02    0.00000E+00    0.92125E+00
  1589    0.40845E+03    0.21269E+02    0.00000E+00    0.48934E+00
  1590    0.40640E+03    0.21328E+02    0.00000E+00    0.53339E-01
  1591    0.40439E+03    0.21385E+02    0.00000E+00   -0.38656E+00
  1592    0.40242E+03    0.21439E+02    0.00000E+00   -0.83017E+00
  1593    0.40049E+03    0.21490E+02    0.00000E+00   -0.12773E+01
  1594    0.39860E+03    0.21539E+02    0.00000E+00   -0.17277E+01
  1595    0.39675E+03    0.21585E+02    0.00000E+00   -0.21813E+01
  1596    0.39494E+03    0.21628E+02    0.00000E+00   -0.26379E+01
  1597    0.39317E+03    0.21669E+02    0.00000E+00   -0.30971E+01
  1598    0.39145E+03    0.21706E+02    0.00000E+00   -0.35590E+01
  1599    0.38977E+03    0.21741E+02    0.00000E+00   -0.40232E+01
  1600    0.38813E+03    0.21773E+02    0.00000E+00   -0.44896E+01
  1601    0.38653E+03    0.21802E+02    0.00000E+00   -0.49579E+01
  1602    0.38498E+03    0.21828E+02    0.00000E+00   -0.54281E+01
  1603    0.38348E+03    0.21852E+02    0.00000E+00   -0.58999E+01
  1604    0.38201E+03    0.21872E+02    0.00000E+00   -0.63731E+01
  1605    0.38059E+03    0.21890E+02    0.00000E+00   -0.68476E+01
  1606    0.37921E+03    0.21905E+02    0.00000E+00   -0.73232E+01
  1607    0.37787E+03    0.21917E+02    0.00000E+00   -0.77997E+01
  1608    0.37657E+03    0.21926E+02    0.00000E+00   -0.82768E+01
  1609    0.37531E+03    0.21932E+02    0.00000E+00   -0.87545E+01
  1610    0.37409E+03    0.21936E+02    0.00000E+00   -0.92325E+01
  1611    0.37292E+03    0.21937E+02    0.00000E+00   -0.97107E+01
  1612    0.37178E+03    0.21935E+02    0.00000E+00   -0.10189E+02
  1613    0.37068E+03    0.21930E+02    0.00000E+00   -0.10667E+02
  1614    0.36962E+03    0.21923E+02    0.00000E+00   -0.11144E+02
  1615    0.36860E+03    0.21913E+02    0.00000E+00   -0.11621E+02
  1616    0.36762E+03    0.21900E+02    0.00000E+00   -0.12097E+02
  1617    0.36667E+03    0.21885E+02    0.00000E+00   -0.12573E+02
  1618    0.36577E+03    0.21867E+02    0.00000E+00   -0.13047E+02
  1619    0.36490E+03    0.21846E+02    0.00000E+00   -0.13520E+02
  1620    0.36406E+03    0.21823E+02    0.00000E+00   -0.13991E+02
  1621    0.36327E+03    0.21798E+02    0.00000E+00   -0.14461E+02
  1622    0.36251E+03    0.21769E+02    0.00000E+00   -0.14928E+02
  1623    0.36178E+03    0.21738E+02    0.00000E+00   -0.15394E+02
  1624    0.36109E+03    0.21705E+02    0.00000E+00   -0.15858E+02
  1625    0.36044E+03    0.21669E+02    0.00000E+00   -0.16319E+02
  1626    0.35982E+03    0.21631E+02    0.00000E+00   -0.16777E+02
  1627    0.35923E+03    0.21590E+02    0.00000E+00   -0.17233E+02
  1628    0.35868E+03    0.21546E+02    0.00000E+00   -0.17686E+02
  1629    0.35816E+03    0.21501E+02    0.00000E+00   -0.18135E+02
  1630    0.35768E+03    0.21452E+02    0.00000E+00   -0.18582E+02
  1631    0.35723E+03    0.21402E+02    0.00000E+00   -0.19025E+02
  1632    0.35681E+03    0.21348E+02    0.00000E+00   -0.19464E+02
  1633    0.35642E+03    0.21293E+02    0.00000E+00   -0.19899E+02
  1634    0.35607E+03    0.21235E+02    0.00000E+00   -0.20330E+02
  1635    0.35574E+03    0.21175E+02    0.00000E+00   -0.20757E+02
  1636    0.35545E+03    0.21112E+02    0.00000E+00   -0.21180E+02
  1637    0.35519E+03    0.21047E+02    0.00000E+00   -0.21598E+02
  1638    0.35496E+03    0.20980E+02    0.00000E+00   -0.22011E+02
  1639    0.35475E+03    0.20911E+02    0.00000E+00   -0.22419E+02
  1640    0.35458E+03    0.20839E+02    0.00000E+00   -0.22822E+02
  1641    0.35444E+03    0.20765E+02    0.00000E+00   -0.23219E+02
  1642    0.35433E+03    0.20689E+02    0.00000E+00   -0.23612E+02
  1643    0.35424E+03    0.20610E+02    0.00000E+00   -0.23998E+02
  1644    0.35418E+03    0.20529E+02    0.00000E+00   -0.24379E+02
  1645    0.35415E+03    0.20447E+02    0.00000E+00   -0.24753E+02
  1646    0.35415E+03    0.20361E+02    0.00000E+00   -0.25121E+02
  1647    0.35418E+03    0.20274E+02    0.00000E+00   -0.25483E+02
  1648    0.35423E+03    0.20185E+02    0.00000E+00   -0.25838E+02
  1649    0.35431E+03    0.20093E+02    0.00000E+00   -0.26187E+02
  1650    0.35441E+03    0.20000E+02    0.00000E+00   -0.26528E+02
  1651    0.35454E+03    0.19904E+02    0.00000E+00   -0.26862E+02
  1652    0.35470E+03    0.19806E+02    0.00000E+00   -0.27189E+02
  1653    0.35488E+03    0.19706E+02    0.00000E+00   -0.27509E+02
  1654    0.35508E+03    0.19605E+02    0.00000E+00   -0.27822E+02
  1655    0.35531E+03    0.19501E+02    0.00000E+00   -0.28127E+02
  1656    0.35555E+03    0.19396E+02    0.00000E+00   -0.28425E+02
  1657    0.35582E+03    0.19288E+02    0.00000E+00   -0.28715E+02
  1658    0.35612E+03    0.19179E+02    0.00000E+00   -0.28999E+02
  1659    0.35643E+03    0.19069E+02    0.00000E+00   -0.29275E+02
  1660    0.35676E+03    0.18956E+02    0.00000E+00   -0.29543E+02
  1661    0.35711E+03    0.18842E+02    0.00000E+00   -0.29805E+02
  1662    0.35748E+03    0.18727E+02    0.00000E+00   -0.30058E+02
  1663    0.35787E+03    0.18610E+02    0.00000E+00   -0.30305E+02
  1664    0.35827E+03    0.18491E+02    0.00000E+00   -0.30543E+02
  1665    0.35869E+03    0.18371E+02    0.00000E+00   -0.30775E+02
  1666    0.35913E+03    0.18250E+02    0.00000E+00   -0.30998E+02
  1667    0.35958E+03    0.18127E+02    0.00000E+00   -0.31214E+02
  1668    0.36005E+03    0.18003E+02    0.00000E+00   -0.31423E+02
  1669    0.36053E+03    0.17878E+02    0.00000E+00   -0.31624E+02
  1670    0.36102E+03    0.17752E+02    0.00000E+00   -0.31817E+02
  1671    0.36153E+03    0.17624E+02    0.00000E+00   -0.32003E+02
  1672    0.36205E+03    0.17496E+02    0.00000E+00   -0.32181E+02
  1673    0.36258E+03    0.17366E+02    0.00000E+00   -0.32351E+02
  1674    0.36312E+03    0.17236E+02    0.00000E+00   -0.32514E+02
  1675    0.36367E+03    0.17105E+02    0.00000E+00   -0.32669E+02
  1676    0.36423E+03    0.16972E+02    0.00000E+00   -0.32816E+02
  1677    0.36479E+03    0.16839E+02    0.00000E+00   -0.32955E+02
  1678    0.36537E+03    0.16705E+02    0.00000E+00   -0.33086E+02
  1679    0.36595E+03    0.16571E+02    0.00000E+00   -0.33210E+02
  1680    0.36654E+03    0.16435E+02    0.00000E+00   -0.33326E+02
  1681    0.36714E+03    0.16299E+02    0.00000E+00   -0.33433E+02
  1682    0.36774E+03    0.16163E+02    0.00000E+00   -0.33533E+02
  1683    0.36835E+03    0.16026E+02    0.00000E+00   -0.33625E+02
  1684    0.36896E+03    0.15888E+02    0.00000E+00   -0.33709E+02
  1685    0.36957E+03    0.15750E+02    0.00000E+00   -0.33785E+02
  1686    0.37019E+03    0.15612E+02    0.00000E+00   -0.33853E+02
  1687    0.37081E+03    0.15473E+02    0.00000E+00   -0.33913E+02
  1688    0.37143E+03    0.15334E+02    0.00000E+00   -0.33965E+02
  1689    0.37205E+03    0.15195E+02    0.00000E+00   -0.34008E+02
  1690    0.37267E+03    0.15055E+02    0.00000E+00   -0.34044E+02
  1691    0.37329E+03    0.14916E+02    0.00000E+00   -0.34071E+02
  1692    0.37391E+03    0.14776E+02    0.00000E+00   -0.34091E+02
  1693    0.37453E+03    0.14636E+02    0.00000E+00   -0.34102E+02
  1694    0.37514E+03    0.14496E+02    0.00000E+00   -0.34105E+02
  1695    0.37576E+03    0.14357E+02    0.00000E+00   -0.34099E+02
  1696    0.37636E+03    0.14217E+02    0.00000E+00   -0.34086E+02
  1697    0.37697E+03    0.14078E+02    0.00000E+00   -0.34064E+02
  1698    0.37757E+03    0.13938E+02    0.00000E+00   -0.34033E+02
  1699    0.37816E+03    0.13799E+02    0.00000E+00   -0.33995E+02
  1700    0.37875E+03    0.13660E+02    0.00000E+00   -0.33948E+02
  1701    0.37933E+03    0.13522E+02    0.00000E+00   -0.33893E+02
  1702    0.37990E+03    0.13384E+02    0.00000E+00   -0.33829E+02
  1703    0.38047E+03    0.13246E+02    0.00000E+00   -0.33757E+02
  1704    0.38102E+03    0.13109E+02    0.00000E+00   -0.33677E+02
  1705    0.38157E+03    0.12972E+02    0.00000E+00   -0.33590E+02
  1706    0.38211E+03    0.12836E+02    0.00000E+00   -0.33494E+02
  1707    0.38264E+03    0.12701E+02    0.00000E+00   -0.33391E+02
  1708    0.38316E+03    0.12566E+02    0.00000E+00   -0.33281E+02
  1709    0.38368E+03    0.12431E+02    0.00000E+00   -0.33163E+02
  1710    0.38418E+03    0.12297E+02    0.00000E+00   -0.33037E+02
  1711    0.38467E+03    0.12164E+02    0.00000E+00   -0.32905E+02
  1712    0.38515E+03    0.12032E+02    0.00000E+00   -0.32765E+02
  1713    0.38562E+03    0.11900E+02    0.00000E+00   -0.32619E+02
  1714    0.38608E+03    0.11769E+02    0.00000E+00   -0.32466E+02
  1715    0.38652E+03    0.11639E+02    0.00000E+00   -0.32306E+02
  1716    0.38695E+03    0.11510E+02    0.00000E+00   -0.32139E+02
  1717    0.38738E+03    0.11382E+02    0.00000E+00   -0.31966E+02
  1718    0.38778E+03    0.11254E+02    0.00000E+00   -0.31787E+02
  1719    0.38818E+03    0.11128E+02    0.00000E+00   -0.31601E+02
  1720    0.38856E+03    0.11003E+02    0.00000E+00   -0.31410E+02
  1721    0.38893E+03    0.10878E+02    0.00000E+00   -0.31212E+02
  1722    0.38928E+03    0.10755E+02    0.00000E+00   -0.31009E+02
  1723    0.38962E+03    0.10633E+02    0.00000E+00   -0.30800E+02
  1724    0.38995E+03    0.10512E+02    0.00000E+00   -0.30585E+02
  1725    0.39026E+03    0.10392E+02    0.00000E+00   -0.30365E+02
  1726    0.39055E+03    0.10273E+02    0.00000E+00   -0.30140E+02
  1727    0.39083E+03    0.10156E+02    0.00000E+00   -0.29909E+02
  1728    0.39109E+03    0.10040E+02    0.00000E+00   -0.29673E+02
  1729    0.39133E+03    0.99247E+01    0.00000E+00   -0.29433E+02
  1730    0.39156E+03    0.98112E+01    0.00000E+00   -0.29187E+02
  1731    0.39177E+03    0.96991E+01    0.00000E+00   -0.28937E+02
  1732    0.39197E+03    0.95883E+01    0.00000E+00   -0.28682E+02
  1733    0.39214E+03    0.94791E+01    0.00000E+00   -0.28422E+02
  1734    0.39230E+03    0.93713E+01    0.00000E+00   -0.28158E+02
  1735    0.39244E+03    0.92650E+01    0.00000E+00   -0.27890E+02
  1736    0.39256E+03    0.91603E+01    0.00000E+00   -0.27618E+02
  1737    0.39266E+03    0.90571E+01    0.00000E+00   -0.27342E+02
  1738    0.39274E+03    0.89556E+01    0.00000E+00   -0.27062E+02
  1739    0.39280E+03    0.88558E+01    0.00000E+00   -0.26778E+02
  1740    0.39284E+03    0.87576E+01    0.00000E+00   -0.26490E+02
  1741    0.39286E+03    0.86611E+01    0.00000E+00   -0.26199E+02
  1742    0.39285E+03    0.85665E+01    0.00000E+00   -0.25905E+02
  1743    0.39283E+03    0.84736E+01    0.00000E+00   -0.25607E+02
  1744    0.39279E+03    0.83825E+01    0.00000E+00   -0.25306E+02
  1745    0.39272E+03    0.82933E+01    0.00000E+00   -0.25002E+02
  1746    0.39263E+03    0.82060E+01    0.00000E+00   -0.24696E+02
  1747    0.39252E+03    0.81206E+01    0.00000E+00   -0.24386E+02
  1748    0.39239E+03    0.80372E+01    0.00000E+00   -0.24074E+02
  1749    0.39223E+03    0.79558E+01    0.00000E+00   -0.23759E+02
  1750    0.39205E+03    0.78764E+01    0.00000E+00   -0.23442E+02
  1751    0.39184E+03    0.77991E+01    0.00000E+00   -0.23122E+02
  1752    0.39161E+03    0.77239E+01    0.00000E+00   -0.22800E+02
  1753    0.39136E+03    0.76507E+01    0.00000E+00   -0.22477E+02
  1754    0.39108E+03    0.75796E+01    0.00000E+00   -0.22151E+02
  1755    0.39078E+03    0.75105E+01    0.00000E+00   -0.21824E+02
  1756    0.39046E+03    0.74435E+01    0.00000E+00   -0.21495E+02
  1757    0.39011E+03    0.73785E+01    0.00000E+00   -0.21164E+02
  1758    0.38974E+03    0.73155E+01    0.00000E+00   -0.20832E+02
  1759    0.38935E+03    0.72546E+01    0.00000E+00   -0.20499E+02
  1760    0.38893E+03    0.71956E+01    0.00000E+00   -0.20165E+02
  1761    0.38850E+03    0.71387E+01    0.00000E+00   -0.19830E+02
  1762    0.38804E+03    0.70838E+01    0.00000E+00   -0.19494E+02
  1763    0.38756E+03    0.70309E+01    0.00000E+00   -0.19157E+02
  1764    0.38705E+03    0.69800E+01    0.00000E+00   -0.18820E+02
  1765    0.38653E+03    0.69311E+01    0.00000E+00   -0.18482E+02
  1766    0.38599E+03    0.68841E+01    0.00000E+00   -0.18144E+02
  1767    0.38542E+03    0.68392E+01    0.00000E+00   -0.17806E+02
  1768    0.38483E+03    0.67962E+01    0.00000E+00   -0.17468E+02
  1769    0.38422E+03    0.67552E+01    0.00000E+00   -0.17130E+02
  1770    0.38359E+03    0.67161E+01    0.00000E+00   -0.16793E+02
  1771    0.38294E+03    0.66790E+01    0.00000E+00   -0.16456E+02
  1772    0.38228E+03    0.66439E+01    0.00000E+00   -0.16119E+02
  1773    0.38159E+03    0.66106E+01    0.00000E+00   -0.15783E+02
  1774    0.38088E+03    0.65794E+01    0.00000E+00   -0.15448E+02
  1775    0.38015E+03    0.65500E+01    0.00000E+00   -0.15114E+02
  1776    0.37940E+03    0.65226E+01    0.00000E+00   -0.14780E+02
  1777    0.37863E+03    0.64971E+01    0.00000E+00   -0.14449E+02
  1778    0.37784E+03    0.64735E+01    0.00000E+00   -0.14118E+02
  1779    0.37704E+03    0.64519E+01    0.00000E+00   -0.13789E+02
  1780    0.37621E+03    0.64321E+01    0.00000E+00   -0.13461E+02
  1781    0.37537E+03    0.64142E+01    0.00000E+00   -0.13136E+02
  1782    0.37450E+03    0.63982E+01    0.00000E+00   -0.12812E+02
  1783    0.37362E+03    0.63841E+01    0.00000E+00   -0.12490E+02
  1784    0.37273E+03    0.63719E+01    0.00000E+00   -0.12171E+02
  1785    0.37181E+03    0.63616E+01    0.00000E+00   -0.11853E+02
  1786    0.37087E+03    0.63531E+01    0.00000E+00   -0.11538E+02
  1787    0.36992E+03    0.63465E+01    0.00000E+00   -0.11226E+02
  1788    0.36895E+03    0.63417E+01    0.00000E+00   -0.10917E+02
  1789    0.36797E+03    0.63388E+01    0.00000E+00   -0.10610E+02
  1790    0.36696E+03    0.63378E+01    0.00000E+00   -0.10306E+02
  1791    0.36594E+03    0.63385E+01    0.00000E+00   -0.10005E+02
  1792    0.36491E+03    0.63412E+01    0.00000E+00   -0.97080E+01
  1793    0.36385E+03    0.63456E+01    0.00000E+00   -0.94140E+01
  1794    0.36278E+03    0.63518E+01    0.00000E+00   -0.91236E+01
  1795    0.36170E+03    0.63599E+01    0.00000E+00   -0.88367E+01
  1796    0.36060E+03    0.63698E+01    0.00000E+00   -0.85537E+01
  1797    0.35948E+03    0.63815E+01    0.00000E+00   -0.82746E+01
  1798    0.35835E+03    0.63950E+01    0.00000E+00   -0.79996E+01
  1799    0.35720E+03    0.64103E+01    0.00000E+00   -0.77287E+01
  1800    0.35603E+03    0.64273E+01    0.00000E+00   -0.74622E+01
  1801    0.35486E+03    0.64462E+01    0.00000E+00   -0.72002E+01
  1802    0.35366E+03    0.64668E+01    0.00000E+00   -0.69426E+01
  1803    0.35246E+03    0.64891E+01    0.00000E+00   -0.66896E+01
  1804    0.35123E+03    0.65131E+01    0.00000E+00   -0.64411E+01
  1805    0.35000E+03    0.65387E+01    0.00000E+00   -0.61972E+01
  1806    0.34875E+03    0.65659E+01    0.00000E+00   -0.59580E+01
  1807    0.34749E+03    0.65948E+01    0.00000E+00   -0.57233E+01
  1808    0.34622E+03    0.66251E+01    0.00000E+00   -0.54934E+01
  1809    0.34494E+03    0.66570E+01    0.00000E+00   -0.52681E+01
  1810    0.34364E+03    0.66903E+01    0.00000E+00   -0.50476E+01
  1811    0.34234E+03    0.67251E+01    0.00000E+00   -0.48318E+01
  1812    0.34102E+03    0.67613E+01    0.00000E+00   -0.46208E+01
  1813    0.33970E+03    0.67989E+01    0.00000E+00   -0.44146E+01
  1814    0.33836E+03    0.68378E+01    0.00000E+00   -0.42133E+01
  1815    0.33702E+03    0.68780E+01    0.00000E+00   -0.40168E+01
  1816    0.33567E+03    0.69195E+01    0.00000E+00   -0.38252E+01
  1817    0.33430E+03    0.69623E+01    0.00000E+00   -0.36385E+01
  1818    0.33293E+03    0.70062E+01    0.00000E+00   -0.34568E+01
  1819    0.33156E+03    0.70513E+01    0.00000E+00   -0.32801E+01
  1820    0.33017E+03    0.70976E+01    0.00000E+00   -0.31084E+01
  1821    0.32878E+03    0.71449E+01    0.00000E+00   -0.29418E+01
  1822    0.32739E+03    0.71933E+01    0.00000E+00   -0.27801E+01
  1823    0.32599E+03    0.72428E+01    0.00000E+00   -0.26236E+01
  1824    0.32458E+03    0.72933E+01    0.00000E+00   -0.24723E+01
  1825    0.32317E+03    0.73447E+01    0.00000E+00   -0.23260E+01
  1826    0.32175E+03    0.73970E+01    0.00000E+00   -0.21850E+01
  1827    0.32033E+03    0.74503E+01    0.00000E+00   -0.20492E+01
  1828    0.31891E+03    0.75044E+01    0.00000E+00   -0.19186E+01
  1829    0.31748E+03    0.75594E+01    0.00000E+00   -0.17932E+01
  1830    0.31605E+03    0.76152E+01    0.00000E+00   -0.16732E+01
  1831    0.31461E+03    0.76717E+01    0.00000E+00   -0.15585E+01
  1832    0.31318E+03    0.77289E+01    0.00000E+00   -0.14491E+01
  1833    0.31174E+03    0.77869E+01    0.00000E+00   -0.13451E+01
  1834    0.31031E+03    0.78455E+01    0.00000E+00   -0.12466E+01
  1835    0.30887E+03    0.79047E+01    0.00000E+00   -0.11534E+01
  1836    0.30743E+03    0.79646E+01    0.00000E+00   -0.10658E+01
  1837    0.30599E+03    0.80250E+01    0.00000E+00   -0.98360E+00
  1838    0.30455E+03    0.80859E+01    0.00000E+00   -0.90695E+00
  1839    0.30312E+03    0.81473E+01    0.00000E+00   -0.83585E+00
  1840    0.30168E+03    0.82092E+01    0.00000E+00   -0.77033E+00
  1841    0.30025E+03    0.82715E+01    0.00000E+00   -0.71042E+00
  1842    0.29882E+03    0.83342E+01    0.00000E+00   -0.65615E+00
  1843    0.29739E+03    0.83972E+01    0.00000E+00   -0.60754E+00
  1844    0.29597E+03    0.84606E+01    0.00000E+00   -0.56462E+00
  1845    0.29454E+03    0.85243E+01    0.00000E+00   -0.52743E+00
  1846    0.29313E+03    0.85882E+01    0.00000E+00   -0.49599E+00
  1847    0.29171E+03    0.86524E+01    0.00000E+00   -0.47032E+00
  1848    0.29030E+03    0.87167E+01    0.00000E+00   -0.45047E+00
  1849    0.28890E+03    0.87812E+01    0.00000E+00   -0.43645E+00
  1850    0.28750E+03    0.88458E+01    0.00000E+00   -0.42829E+00
  1851    0.28611E+03    0.89105E+01    0.00000E+00   -0.42601E+00
  1852    0.28473E+03    0.89753E+01    0.00000E+00   -0.42955E+00
  1853    0.28335E+03    0.90401E+01    0.00000E+00   -0.43885E+00
  1854    0.28198E+03    0.91049E+01    0.00000E+00   -0.45382E+00
  1855    0.28061E+03    0.91696E+01    0.00000E+00   -0.47441E+00
  1856    0.27925E+03    0.92343E+01    0.00000E+00   -0.50055E+00
  1857    0.27790E+03    0.92990E+01    0.00000E+00   -0.53215E+00
  1858    0.27656E+03    0.93635E+01    0.00000E+00   -0.56916E+00
  1859    0.27523E+03    0.94279E+01    0.00000E+00   -0.61150E+00
  1860    0.27390E+03    0.94921E+01    0.00000E+00   -0.65910E+00
  1861    0.27258E+03    0.95562E+01    0.00000E+00   -0.71190E+00
  1862    0.27127E+03    0.96200E+01    0.00000E+00   -0.76982E+00
  1863    0.26997E+03    0.96836E+01    0.00000E+00   -0.83279E+00
  1864    0.26868E+03    0.97469E+01    0.00000E+00   -0.90075E+00
  1865    0.26740E+03    0.98099E+01    0.00000E+00   -0.97361E+00
  1866    0.26613E+03    0.98726E+01    0.00000E+00   -0.10513E+01
  1867    0.26487E+03    0.99349E+01    0.00000E+00   -0.11338E+01
  1868    0.26362E+03    0.99969E+01    0.00000E+00   -0.12210E+01
  1869    0.26238E+03    0.10058E+02    0.00000E+00   -0.13128E+01
  1870    0.26115E+03    0.10119E+02    0.00000E+00   -0.14092E+01
  1871    0.25993E+03    0.10180E+02    0.00000E+00   -0.15101E+01
  1872    0.25872E+03    0.10240E+02    0.00000E+00   -0.16154E+01
  1873    0.25753E+03    0.10300E+02    0.00000E+00   -0.17250E+01
  1874    0.25634E+03    0.10359E+02    0.00000E+00   -0.18390E+01
  1875    0.25517E+03    0.10417E+02    0.00000E+00   -0.19571E+01
  1876    0.25401E+03    0.10475E+02    0.00000E+00   -0.20794E+01
  1877    0.25286E+03    0.10532E+02    0.00000E+00   -0.22058E+01
  1878    0.25173E+03    0.10589E+02    0.00000E+00   -0.23361E+01
  1879    0.25061E+03    0.10645E+02    0.00000E+00   -0.24704E+01
  1880    0.24950E+03    0.10700E+02    0.00000E+00   -0.26086E+01
  1881    0.24840E+03    0.10754E+02    0.00000E+00   -0.27506E+01
  1882    0.24732E+03    0.10808E+02    0.00000E+00   -0.28962E+01
  1883    0.24625E+03    0.10861E+02    0.00000E+00   -0.30456E+01
  1884    0.24520E+03    0.10913E+02    0.00000E+00   -0.31985E+01
  1885    0.24416E+03    0.10964E+02    0.00000E+00   -0.33549E+01
  1886    0.24314E+03    0.11014E+02    0.00000E+00   -0.35148E+01
  1887    0.24213E+03    0.11064E+02    0.00000E+00   -0.36781E+01
  1888    0.24113E+03    0.11112E+02    0.00000E+00   -0.38446E+01
  1889    0.24016E+03    0.11160E+02    0.00000E+00   -0.40144E+01
  1890    0.23919E+03    0.11206E+02    0.00000E+00   -0.41873E+01
  1891    0.23825E+03    0.11252E+02    0.00000E+00   -0.43634E+01
  1892    0.23731E+03    0.11296E+02    0.00000E+00   -0.45425E+01
  1893    0.23640E+03    0.11339E+02    0.00000E+00   -0.47245E+01
  1894    0.23550E+03    0.11382E+02    0.00000E+00   -0.49094E+01
  1895    0.23462E+03    0.11423E+02    0.00000E+00   -0.50971E+01
  1896    0.23376E+03    0.11463E+02    0.00000E+00   -0.52876E+01
  1897    0.23291E+03    0.11501E+02    0.00000E+00   -0.54807E+01
  1898    0.23208E+03    0.11539E+02    0.00000E+00   -0.56764E+01
  1899    0.23127E+03    0.11575E+02    0.00000E+00   -0.58747E+01
  1900    0.23048E+03    0.11610E+02    0.00000E+00   -0.60754E+01
  1901    0.22971E+03    0.11644E+02    0.00000E+00   -0.62786E+01
  1902    0.22895E+03    0.11676E+02    0.00000E+00   -0.64839E+01
  1903    0.22821E+03    0.11707E+02    0.00000E+00   -0.66915E+01
  1904    0.22749E+03    0.11737E+02    0.00000E+00   -0.69010E+01
  1905    0.22679E+03    0.11766E+02    0.00000E+00   -0.71124E+01
  1906    0.22611E+03    0.11793E+02    0.00000E+00   -0.73255E+01
  1907    0.22544E+03    0.11819E+02    0.00000E+00   -0.75403E+01
  1908    0.22479E+03    0.11843E+02    0.00000E+00   -0.77566E+01
  1909    0.22416E+03    0.11867E+02    0.00000E+00   -0.79742E+01
  1910    0.22354E+03    0.11889E+02    0.00000E+00   -0.81931E+01
  1911    0.22295E+03    0.11909E+02    0.00000E+00   -0.84130E+01
  1912    0.22237E+03    0.11929E+02    0.00000E+00   -0.86339E+01
  1913    0.22180E+03    0.11947E+02    0.00000E+00   -0.88557E+01
  1914    0.22126E+03    0.11963E+02    0.00000E+00   -0.90782E+01
  1915    0.22073E+03    0.11979E+02    0.00000E+00   -0.93013E+01
  1916    0.22021E+03    0.11993E+02    0.00000E+00   -0.95248E+01
  1917    0.21972E+03    0.12005E+02    0.00000E+00   -0.97487E+01
  1918    0.21924E+03    0.12017E+02    0.00000E+00   -0.99727E+01
  1919    0.21877E+03    0.12027E+02    0.00000E+00   -0.10197E+02
  1920    0.21832E+03    0.12035E+02    0.00000E+00   -0.10421E+02
  1921    0.21789E+03    0.12043E+02    0.00000E+00   -0.10645E+02
  1922    0.21747E+03    0.12049E+02    0.00000E+00   -0.10868E+02
  1923    0.21707E+03    0.12053E+02    0.00000E+00   -0.11091E+02
  1924    0.21669E+03    0.12057E+02    0.00000E+00   -0.11314E+02
  1925    0.21632E+03    0.12059E+02    0.00000E+00   -0.11536E+02
  1926    0.21596E+03    0.12059E+02    0.00000E+00   -0.11757E+02
  1927    0.21562E+03    0.12059E+02    0.00000E+00   -0.11977E+02
  1928    0.21530E+03    0.12057E+02    0.00000E+00   -0.12196E+02
  1929    0.21499E+03    0.12053E+02    0.00000E+00   -0.12414E+02
  1930    0.21469E+03    0.12049E+02    0.00000E+00   -0.12630E+02
  1931    0.21441E+03    0.12043E+02    0.00000E+00   -0.12845E+02
  1932    0.21415E+03    0.12035E+02    0.00000E+00   -0.13058E+02
  1933    0.21390E+03    0.12026E+02    0.00000E+00   -0.13270E+02
  1934    0.21366E+03    0.12016E+02    0.00000E+00   -0.13479E+02
  1935    0.21344E+03    0.12005E+02    0.00000E+00   -0.13687E+02
  1936    0.21323E+03    0.11992E+02    0.00000E+00   -0.13893E+02
  1937    0.21303E+03    0.11978E+02    0.00000E+00   -0.14096E+02
  1938    0.21285E+03    0.11962E+02    0.00000E+00   -0.14297E+02
  1939    0.21269E+03    0.11945E+02    0.00000E+00   -0.14495E+02
  1940    0.21253E+03    0.11927E+02    0.00000E+00   -0.14691E+02
  1941    0.21239E+03    0.11907E+02    0.00000E+00   -0.14884E+02
  1942    0.21227E+03    0.11886E+02    0.00000E+00   -0.15074E+02
  1943    0.21215E+03    0.11864E+02    0.00000E+00   -0.15261E+02
  1944    0.21205E+03    0.11840E+02    0.00000E+00   -0.15445E+02
  1945    0.21196E+03    0.11815E+02    0.00000E+00   -0.15626E+02
  1946    0.21189E+03    0.11788E+02    0.00000E+00   -0.15803E+02
  1947    0.21183E+03    0.11760E+02    0.00000E+00   -0.15977E+02
  1948    0.21178E+03    0.11731E+02    0.00000E+00   -0.16146E+02
  1949    0.21174E+03    0.11700E+02    0.00000E+00   -0.16313E+02
  1950    0.21172E+03    0.11668E+02    0.00000E+00   -0.16475E+02
  1951    0.21170E+03    0.11634E+02    0.00000E+00   -0.16633E+02
  1952    0.21170E+03    0.11600E+02    0.00000E+00   -0.16787E+02
  1953    0.21171E+03    0.11563E+02    0.00000E+00   -0.16938E+02
  1954    0.21174E+03    0.11526E+02    0.00000E+00   -0.17084E+02
  1955    0.21177E+03    0.11487E+02    0.00000E+00   -0.17227E+02
  1956    0.21181E+03    0.11447E+02    0.00000E+00   -0.17366E+02
  1957    0.21187E+03    0.11406E+02    0.00000E+00   -0.17502E+02
  1958    0.21194E+03    0.11363E+02    0.00000E+00   -0.17634E+02
  1959    0.21201E+03    0.11320E+02    0.00000E+00   -0.17762E+02
  1960    0.21210E+03    0.11275E+02    0.00000E+00   -0.17888E+02
  1961    0.21219E+03    0.11229E+02    0.00000E+00   -0.18010E+02
  1962    0.21230E+03    0.11182E+02    0.00000E+00   -0.18129E+02
  1963    0.21241E+03    0.11134E+02    0.00000E+00   -0.18244E+02
  1964    0.21254E+03    0.11085E+02    0.00000E+00   -0.18357E+02
  1965    0.21267E+03    0.11035E+02    0.00000E+00   -0.18467E+02
  1966    0.21281E+03    0.10984E+02    0.00000E+00   -0.18574E+02
  1967    0.21296E+03    0.10933E+02    0.00000E+00   -0.18678E+02
  1968    0.21312E+03    0.10880E+02    0.00000E+00   -0.18780E+02
  1969    0.21328E+03    0.10826E+02    0.00000E+00   -0.18879E+02
  1970    0.21346E+03    0.10771E+02    0.00000E+00   -0.18976E+02
  1971    0.21364E+03    0.10716E+02    0.00000E+00   -0.19070E+02
  1972    0.21382E+03    0.10660E+02    0.00000E+00   -0.19161E+02
  1973    0.21402E+03    0.10603E+02    0.00000E+00   -0.19251E+02
  1974    0.21422E+03    0.10545E+02    0.00000E+00   -0.19338E+02
  1975    0.21442E+03    0.10487E+02    0.00000E+00   -0.19423E+02
  1976    0.21464E+03    0.10427E+02    0.00000E+00   -0.19506E+02
  1977    0.21486E+03    0.10368E+02    0.00000E+00   -0.19587E+02
  1978    0.21508E+03    0.10307E+02    0.00000E+00   -0.19666E+02
  1979    0.21531E+03    0.10246E+02    0.00000E+00   -0.19744E+02
  1980    0.21555E+03    0.10184E+02    0.00000E+00   -0.19820E+02
  1981    0.21579E+03    0.10122E+02    0.00000E+00   -0.19894E+02
  1982    0.21603E+03    0.10059E+02    0.00000E+00   -0.19966E+02
  1983    0.21628E+03    0.99962E+01    0.00000E+00   -0.20037E+02
  1984    0.21653E+03    0.99325E+01    0.00000E+00   -0.20107E+02
  1985    0.21679E+03    0.98684E+01    0.00000E+00   -0.20176E+02
  1986    0.21705E+03    0.98038E+01    0.00000E+00   -0.20243E+02
  1987    0.21731E+03    0.97388E+01    0.00000E+00   -0.20309E+02
  1988    0.21758E+03    0.96735E+01    0.00000E+00   -0.20374E+02
  1989    0.21785E+03    0.96079E+01    0.00000E+00   -0.20438E+02
  1990    0.21812E+03    0.95419E+01    0.00000E+00   -0.20501E+02
  1991    0.21840E+03    0.94757E+01    0.00000E+00   -0.20564E+02
  1992    0.21868E+03    0.94092E+01    0.00000E+00   -0.20625E+02
  1993    0.21896E+03    0.93425E+01    0.00000E+00   -0.20686E+02
  1994    0.21924E+03    0.92756E+01    0.00000E+00   -0.20747E+02
  1995    0.21952E+03    0.92085E+01    0.00000E+00   -0.20806E+02
  1996    0.21980E+03    0.91413E+01    0.00000E+00   -0.20866E+02
  1997    0.22009E+03    0.90740E+01    0.00000E+00   -0.20925E+02
  1998    0.22037E+03    0.90066E+01    0.00000E+00   -0.20984E+02
  1999    0.22066E+03    0.89392E+01    0.00000E+00   -0.21043E+02
  2000    0.22095E+03    0.88717E+01    0.00000E+00   -0.21102E+02
healpy-1.10.3/healpy/data/weight_ring_n00002.fits0000664000175000017500000002640013010374155021616 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:03:03' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   24 / width of table in bytes                        NAXIS2  =                    4 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                    2 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                    2 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1D      '                                                            MAXVAL1 =   5.569143403334E-02 / maximum value of T weights                     MINVAL1 =  -3.955469343004E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1D      '                                                            MAXVAL2 =   5.569143403334E-02 / maximum value of Q weights                     MINVAL2 =  -3.955469343004E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1D      '                                                            MAXVAL3 =   5.569143403334E-02 / maximum value of U weights                     MINVAL3 =  -3.955469343004E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?o[?o[?o[?v*RKN?v*RKN?v*RKNqHqHqH@E^!@E^!@E^!healpy-1.10.3/healpy/data/weight_ring_n00004.fits0000664000175000017500000002640013010374155021620 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:03:42' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   24 / width of table in bytes                        NAXIS2  =                    8 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                    4 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                    8 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1D      '                                                            MAXVAL1 =   1.198278418678E-01 / maximum value of T weights                     MINVAL1 =  -1.931310224103E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1D      '                                                            MAXVAL2 =   1.198278418678E-01 / maximum value of Q weights                     MINVAL2 =  -1.931310224103E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1D      '                                                            MAXVAL3 =   1.198278418678E-01 / maximum value of U weights                     MINVAL3 =  -1.931310224103E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?	?	?	zUzUzUZ	fZ	fZ	f~aFηk~aFηk~aFηkq0y$~q0y$~q0y$~jbv\jbv\jbv\?,C0?,C0?,C0?s5ô?s5ô?s5ôhealpy-1.10.3/healpy/data/weight_ring_n00008.fits0000664000175000017500000002640013010374155021624 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:03:50' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   24 / width of table in bytes                        NAXIS2  =                   16 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                    8 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                   24 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1D      '                                                            MAXVAL1 =   1.656768309032E-01 / maximum value of T weights                     MINVAL1 =  -7.226390397992E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1D      '                                                            MAXVAL2 =   1.656768309032E-01 / maximum value of Q weights                     MINVAL2 =  -7.226390397992E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1D      '                                                            MAXVAL3 =   1.656768309032E-01 / maximum value of U weights                     MINVAL3 =  -7.226390397992E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?47?47?47 Fgܿ Fgܿ Fg?mo?mo?mo{ V{ V{ V?,0?,0?,0?sH?sH?sHݿr3?r3?r3?zzzx|Ϳx|Ϳx|?z,/DE?z,/DE?z,/DEc<"fI]>fI]>fG}ɑG}ɑG}ɑ?XC甀P?XC甀P?XC甀PK7樠̿K7樠̿K7樠̿DqIׇADqIׇADqIׇA?W,-?W,-?W,-F/±FRſF/±FRſF/±FRſL_̒UL_̒UL_̒U?[uBIezx?[uBIezx?[uBIezxhealpy-1.10.3/healpy/data/weight_ring_n00032.fits0000664000175000017500000002640013010374155021621 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:04:02' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   24 / width of table in bytes                        NAXIS2  =                   64 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                   32 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                  100 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1D      '                                                            MAXVAL1 =   1.685120771520E-01 / maximum value of T weights                     MINVAL1 =  -7.723710942327E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1D      '                                                            MAXVAL2 =   1.685120771520E-01 / maximum value of Q weights                     MINVAL2 =  -7.723710942327E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1D      '                                                            MAXVAL3 =   1.685120771520E-01 / maximum value of U weights                     MINVAL3 =  -7.723710942327E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?ő,?ő,?ő,ϫ6ϫ6ϫ6?̭j?̭j?̭jHHH?s̈́?s̈́?s̈́?`#?`#?`#t1c&7ht1c&7ht1c&7h?uH+#?uH+#?uH+#pcS¿pcS¿pcS?b?b?b߿A^A^A^JBѝz]JBѝz]JBѝz]?Y0qq|?Y0qq|?Y0qq|ο[
9ο[
9ο[
9?V%?V%?V%ӿK\vK\vK\v?/4Sm?/4Sm?/4Sm?1^?1^?1^ſC}aC}aC}a?G]'?G]'?G]'Eud
Eud
Eud
??ir\Ȫ??ir\Ȫ??ir\Ȫ16&16&16&?J: M?J: M?J: M?9^&T?9^&T?9^&T!~3S!~3S!~3S?2\?2\?2\
3XO
3XO
3XO<['G<['G<['G>?\>?\>?\?6Ê24?6Ê24?6Ê24iGviGviGv666?G|?G|?G|󻰿N+KaN+KaN+Ka?L Pb?L Pb?L PbB4ϧB4ϧB4ϧ?$MSh?$MSh?$MSh?1?1?1B(UB(UB(U?B0\P?B0\P?B0\P1ָ1ָ1ָ"v "v "v ?=b߯1?=b߯1?=b߯1>;#~1>;#~1>;#~1?&$˷9?&$˷9?&$˷9?.95?.95?.95=p'׾=p'׾=p'׾?5-3?5-3?5-3?~?~?~8c 8c 8c ?8J?8J?8J5~%5~%5~%4#j4#j4#j?9\1Ϙ?9\1Ϙ?9\1Ϙx‘x‘x‘1ȸ'K1ȸ'K1ȸ'K?9c?9c?9c#Ӱ#Ӱ#Ӱ.N.N.N?9Pr,?9Pr,?9Pr,$%k$%k$%k1Q1Q1Q?>
P?>
P?>
Phealpy-1.10.3/healpy/data/weight_ring_n00064.fits0000664000175000017500000003410013010374155021622 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:04:09' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   24 / width of table in bytes                        NAXIS2  =                  128 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                   64 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                  226 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1D      '                                                            MAXVAL1 =   1.769182615475E-01 / maximum value of T weights                     MINVAL1 =  -9.309373410869E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1D      '                                                            MAXVAL2 =   1.769182615475E-01 / maximum value of Q weights                     MINVAL2 =  -9.309373410869E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1D      '                                                            MAXVAL3 =   1.769182615475E-01 / maximum value of U weights                     MINVAL3 =  -9.309373410869E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?ƥA?ƥA?ƥAuuu?ensqut>squt>sq?hUģ"_?hUģ"_?hUģ"_SFPOSFPOSFPOW@W@W@?Q`~\?Q`~\?Q`~\\C\C\C?aO΍?aO΍?aO΍˿bnbnbn?c]l?c]l?c]lbA6@bA6@bA6@?`:m>/?`:m>/?`:m>/\u\u\u?X$?X$?X$RMdοRMdοRMd?KBOa?KBOa?KBOaASq;ASq;ASq;?0o+!j?0o+!j?0o+!jܾםUMםUMםUM*3*3*3?8N=?8N=?8N=@d+@d+@d+?CeId?CeId?CeIdEC#EC#EC#?FY:	?FY:	?FY:	FF)pXFF)pXFF)pX?EZ5J?EZ5J?EZ5JD	5D	5D	5?BJ]f=}?BJ]f=}?BJ]f=}@@nش@@nش@@nش?<fE?<fE?<fE7y#7y#7y#?2
?2
?2
,4O$˿,4O$˿,4O$?$P0?$P0?$P0gBagBagBa?4
?4
?4
[|b[|b[|b?i1y?i1y?i1yUdYUdYUdY? OT? OT? OT"OʘtX"OʘtX"OʘtX?#%2?#%2?#%2%o%o%o?%L?%L?%L%	&%	&%	&?%Ψ8}?%Ψ8}?%Ψ8}%FMUl%FMUl%FMUl?$M\a?$M\a?$M\a"q$"q$"q$? A? A? Ap
p
p
jJKwjJKwjJKw?11T?11T?11T\)i\)i\)i?.^4D?.^4D?.^4D?Ų?Ų?ŲĿ'r'r'r?0Whb9?0Whb9?0Whb931A31A31A?5҂`o?5҂`o?5҂`oӿ73ɋ73ɋ73ɋ?7wi8?7wi8?7wi86cxA6cxA6cxA?3:?3:?3:/h[/h[/h[?#T?#T?#T	C
	C
	C
?$u3~?$u3~?$u3~.Yd|.Yd|.Yd|?18o.*?18o.*?18o.*03#I03#I03#I?'/?'/?'/{{{+ZY+ZY+ZY?#e*3?#e*3?#e*3-
-
-
?.KX?م?.KX?م?.KX?م&^`&^`&^`?Y:'>'>'? C-? C-? C-))Hc))Hc))Hc?&./>?&./>?&./>ѿCɿCɿCɿ/:2/:2/:2?'h?'h?'h'̲'̲'̲?t?t?t?	oxC?	oxC?	oxC%S4?:_%S4?:_%S4?:_?(hwY?(hwY?(hwYg*Jg*Jg*JV*71V*71V*71?#ʗAs?#ʗAs?#ʗAs(=F(=F(=F?6
?6
?6
>i>i>iԿ"Y"Y"Y?(Jݔ?(Jݔ?(Jݔܿÿ6ÿ6ÿ6;;;?$6=?$6=?$6=,"6yB,"6yB,"6yBhealpy-1.10.3/healpy/data/weight_ring_n00128.fits0000664000175000017500000004160013010374155021626 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:04:27' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   24 / width of table in bytes                        NAXIS2  =                  256 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                  128 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                  454 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1D      '                                                            MAXVAL1 =   1.770797556810E-01 / maximum value of T weights                     MINVAL1 =  -9.340929615201E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1D      '                                                            MAXVAL2 =   1.770797556810E-01 / maximum value of Q weights                     MINVAL2 =  -9.340929615201E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1D      '                                                            MAXVAL3 =   1.770797556810E-01 / maximum value of U weights                     MINVAL3 =  -9.340929615201E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?ƪ~h?ƪ~h?ƪ~hڿڿ?	'?	'?	'n~ĝn~ĝn~ĝ?Ȩv?Ȩv?Ȩvllllll?
?
?
򱿉]V+q]V+q]V+q?,^A1?,^A1?,^A1xKTxKTxKT?mksc?mksc?mksc\7\7\7?5	L?5	L?5	L?GQ1s?GQ1s?GQ1sXW:&?pXW:&?pXW:&?p?`6ؿ$M?`6ؿ$M?`6ؿ$Mbv9ܿbv9ܿbv9?c9~b[?c9~b[?c9~b[bSWbSWbSW?apP:W &?apP:W &?apP:W &^8^8^8?Yfb?Yfb?YfbTVL;LTVL;LTVL;L?MZ.?MZ.?MZ.BHrBHrBHr?/}%?/}%?/}%?	18?	18?	182eqP5T;2eqP5T;2eqP5T;??,ĥA??,ĥA??,ĥADQ]fDQ]fDQ]f?Gy=?Gy=?Gy=߿I# `GI# `GI# `G?IQ놌?IQ놌?IQ놌HMܜLVqHMܜLVqHMܜLVq?FA45?FA45?FA45CdzXyCdzXyCdzXy??????8>1J"8>1J"8>1J"?0KMG?0KMG?0KMG  ~  ~  ~>vݐW>vݐW>vݐW?gk*d0r?gk*d0r?gk*d0r'}9Y)'}9Y)'}9Y)?02E;D?02E;D?02E;D4H
_4H
_4H
_?6ߠX?6ߠX?6ߠXο8)GY8)GY8)GY?8kH\?8kH\?8kH\7R
97R
97R
9?6ur?6ur?6ur3̤53̤53̤5?05í,?05í,?05í,*RY!*RY!*RY!?#A}t?#A}t?#A}t::?Ϳ::?Ϳ::??o?o?o>4vK>4vK>4vK?lnǘL?lnǘL?lnǘL!OD\!OD\!OD\?%34oS?%34oS?%34oS(,ÿ(,ÿ(,?*jn=?*jn=?*jn=+Y:
+Y:
+Y:
?+ht@f?+ht@f?+ht@f*Q*Q*Q?)7rz??)7rz??)7rz?޿'+{Rѿ'+{Rѿ'+{R?$_/B?$_/B?$_/B!>sp!>sp!>sp?=c?=c?=cy?ty?ty?t?psK?psK?psK>ڀll>ڀll>ڀll>BP>	E>BP>	E>BP>	EZ2Z2Z2?_	3
?_	3
?_	3
ǖjɿǖjɿǖj?%uA?%uA?%uAԿԿ?l`D;?l`D;?l`D;\bnP\bnP\bnP?RZ?RZ?RZ ;G ;G ;G? \? \? \ B+ B+ B+?1,m?1,m?1,m~H~H~H?D>Lw?D>Lw?D>Lw;,\,;,\,;,\,?p`2?p`2?p`2ÿkgkgkg?"q?"q?"q޻J޻J޻J?l/Q?l/Q?l/QgJD"gJD"gJD"?2$?2$?2$
Gd
Gd
Gd?zCM?zCM?zCM!	!	!	?f?f?fþVH9VH9VH9>\Yg>\Yg>\YgH[H[H[>CLh7k>CLh7k>CLh7kݎ!Iݎ!Iݎ!I>M<>M<>M׵Os>׵Os>׵OsNjNjNj>夏f|R*>夏f|R*>夏f|R*/M/M/M>&<$>&<$>&<$>[kL>[kL>[kLY	5Y	5Y	5>	C7>	C7>	C7_٪_٪_٪>Y?>Y?>Y?skҰ%skҰ%skҰ%?@2?@2?@2	N<	N<	N~>~>~vy쳾vy쳾vy>P?>P?>P?h"Đzh"Đzh"Đzkudkudkud>s``>s``>s``ƿT
T
T
?f
X?f
X?f
Xa{a{a{?3GZ?3GZ?3GZÿ(%~(%~(%~?¤؞?¤؞?¤؞iAysiAysiAys>-nDj;>-nDj;>-nDj;>.P>.P>.PLcvLcvLcv?X4+?X4+?X4+\g5ѿ\g5ѿ\g5?ՠZU?ՠZU?ՠZU,MF,MF,MF>
{ڄ>
{ڄ>
{ڄ?M?M?Mq]q]q]?IVJ
?IVJ
?IVJ
?P?P?P4EKϿ4EKϿ4EK>>D->>D->>D-W8|W8|W8|kǾkǾk?1b?1b?1bxvxvxv?BLs??BLs??BLs?&QM&QM&QM>>5{>>5{>>5{>9xyf>9xyf>9xyf@@@?7̉p?7̉p?7̉pu(+8u(+8u(+8>(X>(X>(X>
NFP>
NFP>
NFPXߋVjXߋVjXߋVj?(׫?(׫?(׫uuu>5&F>5&F>5&Fɾ[֮_^[֮_^[֮_^Zsz0Zsz0Zsz0?BA?BA?BAxljHxljHxljH>$S>$S>$Sˆ{Xˆ{Xˆ{XYӾYӾY?V?V?V&ن&ن&ن>]Oę>]Oę>]Oę$t$t$tǃg%ǃg%ǃg%?![
t?![
t?![
tciuciuciu>34<>34<>34<>♪M>♪M>♪Mjjj?;?;?;ی
Lyی
Lyی
Ly>1n>1n>1n>FP>FP>FPƿquaquaqua?:/&?:/&?:/&jjj_Lh>_Lh>_Lh>>*pw>*pw>*pwFu|Fu|Fu|?ln?ln?lnᇾ?8y?8y?8y^갾^갾^?.EN:?.EN:?.EN:ݘ.Dݘ.Dݘ.D>/&>/&>/&>㎻w>㎻w>㎻wg
ƿg
ƿg
?ΊM?ΊM?ΊM~Rۙ~~Rۙ~~Rۙ~%ȻN%ȻN%ȻN>
%T>
%T>
%TWqWqWq>%%>%%>%%r־r־r־<{C<{C<{C?oݼ?oݼ?oݼD(ID(ID(I>3j>3j>3j>>>u"륿u"륿u"?O?O?O?ľ?ľ?ľ鴳M鴳M鴳M?ı!4?ı!4?ı!4¿)7h;)7h;)7h;>ս>ս>ս>kǖs>kǖs>kǖsJo5ݿJo5ݿJo5?0a?0a?0a۾*Lm*Lm*Lmp11zp11zp11z?qW?qW?qWk?k?k?>j}>j}>j}>r81>r81>r81WǍWǍWǍ?؃4;?؃4;?؃4;0n
0n
0n
?NQB+?NQB+?NQB+?&?&?&] (] (] (healpy-1.10.3/healpy/data/weight_ring_n00256.fits0000664000175000017500000005500013010374155021627 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:04:38' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   24 / width of table in bytes                        NAXIS2  =                  512 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                  256 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                  768 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1D      '                                                            MAXVAL1 =   1.636298040653E-01 / maximum value of T weights                     MINVAL1 =  -6.857585732208E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1D      '                                                            MAXVAL2 =   1.636298040653E-01 / maximum value of Q weights                     MINVAL2 =  -6.857585732208E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1D      '                                                            MAXVAL3 =   1.636298040653E-01 / maximum value of U weights                     MINVAL3 =  -6.857585732208E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?HE]?HE]?HE]/~VH/~VH/~VH?P,L?P,L?P,L|H9A|H9A|H9Ajpjpjp?zͼp(?zͼp(?zͼp(wZ,3wZ,3wZ,3?ibW>?ibW>?ibW>6<6<6aߘ
>aߘ
>aߘ
?OX~?OX~?OX~#K_
S#K_
S#K_
S?"qFAN?"qFAN?"qFAN7_7_7_5'l{5'l{5'l{?0ό`?0ό`?0ό` q׿ q׿ q?TDL?TDL?TDLjz:jz:jz:?ʙg?ʙg?ʙg7m47m47m4?I	?I	?I	MS:{MS:{MS:{
|srY
|srY
|srY?ڎZcT?ڎZcT?ڎZcT$$$?3?3?3>pvF>pvF>pvFķǿķǿķ?Tl,?Tl,?Tl,^~%?>^~%?>^~%??Vn3?Vn3?Vn3QQQ?nj?nj?nj}a}a}a, Q󐾤, Q󐾤, Q?]z?]z?]zojojoj?
h?
h?
h*e*e*e_:_:_:?y-f'?y-f'?y-f'BLX=BLX=BLX=?ј?ј?јIOIOIOGزGزGز?cfP?cfP?cfPq7بq7بq7ب>FO@$>FO@$>FO@$侻XJBXJBXJB:޾:޾:?>?>?>ҡOҡOҡO>&RO>&RO>&RO>כowT>כowT>כowT?BƸk?BƸk?BƸkB"iB"iB"i>|Qo>|Qo>|Qo>l1>l1>l1(((?!?!?! 7G 7G 7G>ꂄ8>ꂄ8>ꂄ8>,(74>,(74>,(74[t݈[t݈[t݈>3p>3p>3pү]Tү]Tү]T>גQ>גQ>גQ>e'ͤ>e'ͤ>e'ͤ=ɛǾ=ɛǾ=ɛ>أXU>أXU>أXUuݣuݣuݣ>#>#>#*	w*	w*	w>jH?>jH?>jH?'''V[43V[43V[43>D֦w>D֦w>D֦wflpflpflp>i3\>i3\>i3\}o}o}ohbhbhb>	*>	*>	*ľ9p9p9p>86>86>86\>˾\>˾\>˾#t-b9#t-b9#t-b9>m>m>mԾ
$\
$\
$\>Lx>Lx>Lx,I>,I>,I>,7#,7#,7#>ڄU>ڄU>ڄŪ{̄{̄{>BJos>BJos>BJosZ MZ MZ M>;	L>;	L>;	LJFJFJF>pd>pd>pd3߼3߼3߼ދc@Xދc@Xދc@X>I&>I&>I&3\R3\R3\R>4o>4o>4oNhXNhXNhX۸ԯS۸ԯS۸ԯS>,"=>,"=>,"=E˅E˅E˅>X5
>X5
>X5
HH"
HH"
HH"
װzװzװz>7>7>7t@
t@
t@
>2ψ>2ψ>2ψH'#NH'#NH'#N>u<>u<>u<Z!~[Z!~[Z!~[>s Z>s Z>s ZpqPpqPpqPQ$68KQ$68KQ$68K>?_>?_>?_|ߋ"|ߋ"|ߋ">}!>}!>}!݀	W݀	W݀	WF#F#F#>Q尅h>Q尅h>Q尅hzizzizziz>Ra2P>Ra2P>Ra2Pپ+섁+섁+섁>{Z>{Z>{Z>0r>0r>0rŁaŁaŁa>hPh>hPh>hPhn%on%on%o>ʶg9>ʶg9>ʶg9>;\>;\>;\G˽G˽G˽>ͫ+ܱ|>ͫ+ܱ|>ͫ+ܱ|UUU>XkT>XkT>XkT><$><$><$¾N$N$N$>		>		>		yuyuyu>dwf>dwf>dwfξt[Mct[Mct[Mc֡֡֡>39I>39I>39Ix
ɾx
ɾx
>R$>R$>R$ӠC9ӠC9ӠC9"ӵ"ӵ"ӵ>,v>,v>,v2`2`2`>+nl>+nl>+nlPbPbPb>^M>^M>^M>ӈE9>ӈE9>ӈE9z'z'z'>"S>"S>"S琾奼b奼b奼b>
1u
>
1u
>
1u
>[q:%>[q:%>[q:%ʾ́|́|́|>l>l>lnC8wnC8wnC8w>r>r>rᬾ@XG@XG@XG9`]9`]9`]>j>j>jE8E8E8>cf>cf>cf(((>ɸ"
>ɸ"
>ɸ"
>͞=F>͞=F>͞=F{f,
{f,
{f,
>p#ל>p#ל>p#ל訑ᜍ־訑ᜍ־訑ᜍ>ᔴE4{>ᔴE4{>ᔴE4{ƑگƑگƑگ@	D@	D@	D>R)>R)>R))`m|/)`m|/)`m|/>p>p>p]D:]D:]D:>[>[>[>Λ/ R>Λ/ R>Λ/ R"w٣韾"w٣韾"w٣>~0>~0>~0^GQ,Ҿ^GQ,Ҿ^GQ,>ʄذ>ʄذ>ʄذhؾhؾhؾƗ
2	Ɨ
2	Ɨ
2	>7,>7,>7,111>N3dΠ>N3dΠ>N3dΠCPCPCP>>>>>>>>>GìfGìfGìf>>>ž_n_n_n>ӌO8>ӌO8>ӌO8;RmRmRm>r\K>r\K>r\K>i-N>i-N>i-Ntfs̾tfs̾tfs>mjT>mjT>mjT<<<>yG>yG>yGGz4Gz4Gz4QQQ>"D>"D>"Dhinhinhin?,9l?,9l?,9lWidWidWid?T?T?TʾەgmPەgmPەgmP8'6@O8'6@O8'6@O	N	N	N?YTT?YTT?YTTƿ5@dϿ5@dϿ5@d?
p.A?
p.A?
p.A-{-{-{>~7>~7>~7>hu>hu>huˏ}ˏ}ˏ}>=յ>=յ>=յ^J ^J ^J >7Lyp>7Lyp>7Lyp+h+h+h(((>3Z&>3Z&>3Z&xoxoxo>G:ݛn>G:ݛn>G:ݛnUbUbUb>Ŷ>Ŷ>Ŷ>
:>
:>
:ȥR2LȥR2LȥR2L>ށ>ށ>ށۢtqLۢtqLۢtqL>tăD>tăD>tăD>[D#>[D#>[D#;}1uع}1uع}1uع>^7gU>^7gU>^7gUoc{܀oc{܀oc{܀>4;>4;>4;>=Jw>=Jw>=JwE,E,E,>Nԟ>Nԟ>NԟڝgQ)ڝgQ)ڝgQ)>&:?">&:?">&:?">`	>`	>`	*}W|*}W|*}W|>ޮUM!	>ޮUM!	>ޮUM!	Evc@Evc@Evc@x<$mSx<$mSx<$mS>jIq>jIq>jIq/L/L/L>e">e">e"U1t U1t U1t x쪾x쪾x>###e>e>e>ʈ&4e>ʈ&4e>ʈ&4e꾸`W`W`W>d>d>dqqq>{ӿ>{ӿ>{ӿ>΅dyb>΅dyb>΅dybױVױVױV>q8QE>q8QE>q8QEOq)HOq)HOq)H\䨾\䨾\>I=c?>I=c?>I=c?EÆEÆEÆ>TnNĿ>TnNĿ>TnNĿ>%
>%
>%
JL5%JL5%JL5%>6n#{>6n#{>6n#{|!|!|!N$m=N$m=N$m=>[>[>[ʾ٥C*٥C*٥C*>֟q>֟q>֟q>tZ!41>tZ!41>tZ!413b7\q3b7\q3b7\q>\ju>\ju>\jut#߾t#߾t#߾*+<*+<*+<>]CE>]CE>]CEcO]>cO]>cO]Ѿ@`uuv@`uuv@`uuv>]>]>]>[+>[+>[+;^w;^w;^w>K@>K@>K@:[N7:[N7:[N7Ԧc	[Ԧc	[Ԧc	[>7j>>7j>>7j>O*ѳO*ѳO*ѳ$`$`$`><7><7><7~.~.~.>Yh5>Yh5>Yh5>B^>B^>B^˾DR!?DR!?DR!?>>>>;!be
>;!be
>;!be
kоkоk>8fi>8fi>8fibԾbԾbԾ1x,ɾ1x,ɾ1x,>zTT>zTT>zTT@%u@%u@%u1Ue׳1Ue׳1Ue׳>i!>i!>i!xlҾxlҾxlҾNiNiNi>a@>a@>a@ϾW.jpeW.jpeW.jpe>o>o>o>h+>h+>h+{{{>>>>w>w>wdĒdĒdĒ>+j8>+j8>+j8>&39	2>&39	2>&39	2>vsY>vsY>vsYD~D~D~>@y>@y>@y'侂'侂'侮ooo>7T^>7T^>7T^"Dʾ"Dʾ"Dʾ%ޟ%ޟ%ޟ>
ƒ?R>
ƒ?R>
ƒ?RzֈAȾzֈAȾzֈAȾzIszIszIs>s|%z>s|%z>s|%zh;bh;bh;bǾǾ>|>|>|˾ddd)~)~)~>z'
J>z'
J>z'
Jhªhªhª,&,&,&>U[Ma>U[Ma>U[MaRe&6Re&6Re&6˻˻˻>16>16>16FFFOMOMOM>|NL>|NL>|NL`Hخ`Hخ`Hخ000> A]> A]> A]׾;;;mşEMmşEMmşEM>=ۂZc>=ۂZc>=ۂZc?JTGƾ?JTGƾ?JTGƾn_xn_xn_x>uHO>uHO>uHO000/h/h/h>û~">û~">û~"+tﾯ+tﾯ+tﾖ}B:|i}B:|i}B:|i>8m
>8m
>8m
4kݾ4kݾ4kݾ*#*#*#>~:&>~:&>~:&D{fiD{fiD{fisT
sT
sT
>*->*->*-3澾3澾3澾vv|ξvv|ξvv|>-Yܧ>-Yܧ>-Yܧsssw0w0w0>yK=T>yK=T>yK=T"C"C"CdNdNdN>7J>7J>7J?N?N?NeAeAeA>Hf[x>Hf[x>Hf[xϾ]]]IFIFIF>J1.D)<>J1.D)<>J1.D)Se^(>Se^(>Se^(>2	8>2	8>2	8B放B放B>ǂ>ǂ>ǂ>./>./>./,5},5},5}>]RǗ>]RǗ>]RǗ>}̔6>}̔6>}̔6`ݾ`ݾ`>	R>	R>	R>d">>d">>d">kF6_kF6_kF6_>S^h>S^h>S^h>ԺD7U>ԺD7U>ԺD7U ! ! !>o>o>o>@9?>@9?>@9?ͥQͥQͥQsHPsHPsHP>Z9=4M>Z9=4M>Z9=4M8$kz]8$kz]8$kz]*4*4*4>V`>V`>V`j}j}j}yךCyךCyךC>φh/>φh/>φh/FتFتFت=lо=lо=l>9 ni	>9 ni	>9 ni	EY7EY7EY7YYY>GnD>GnD>GnD>Q?t>Q?t>Q?tǙǙǙ>˸Q>˸Q>˸Q>']@B>']@B>']@Bžv2ev2ev2e>hל@>hל@>hל@>@?
7>@?
7>@?
7>jE >jE >jE 龶l\l\l\>42jP>42jP>42jP>Y>Y>Y:::}B}B}B>oĿif>oĿif>oĿifTTT^y^y^y>97>97>97mjL˾mjL˾mjL˾M
fM
fM
f>:8>:8>:8Ŧ#Ŧ#Ŧ#sz:sz:sz:>m6{>m6{>m6{S'FS'FS'F龴łѽwłѽwłѽw>S7>S7>S7>R@>R@>R@0j0j0j>5:
>5:
>5:
>T)H>T)H>T)HaÓؾaÓؾaÓ>^r>^r>^r>eL>eL>eL۾;ԛվ;ԛվ;ԛ>{;NO>{;NO>{;NO>;WD>;WD>;WDFFF   >>>fjVfjVfjVe;e;e;>/9GX>/9GX>/9GXhealpy-1.10.3/healpy/data/weight_ring_n00512.fits0000664000175000017500000010340013010374155021620 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:04:54' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                24576 / width of table in bytes                        NAXIS2  =                    1 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                  512 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                 1700 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1024D   '                                                            MAXVAL1 =   1.728855013929E-01 / maximum value of T weights                     MINVAL1 =  -8.531867588429E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1024D   '                                                            MAXVAL2 =   1.728855013929E-01 / maximum value of Q weights                     MINVAL2 =  -8.531867588429E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1024D   '                                                            MAXVAL3 =   1.728855013929E-01 / maximum value of U weights                     MINVAL3 =  -8.531867588429E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?!7տqک;e?0bh/𿝃9?(a7}Q[?WKƖ?`ZdFGnIm$Y?qPG,yoY;BA?h0䬟]̚؁I?FdJ?2ɣ*Oo?V'6sWQM?TWߗF"MՎ?=5U
+6Ӽɿ75in$?Cf1ֽGgx=?Fg̳֦A5tH?5hз~:%A"d_?4R=:va?<?*Úi=>ܿm}?lZl%:>SbƩ?*Iz.e*ec=I?%oo_3Y-?RPc?-qGk?"1$2d4?"*B9DD?BJ>5mF6?[.]ſrSQ?*T*z
rȹ?ig@=:h8To9?Beϝ%Ӹ=o?o'F
z1?
ƚ[cֱ,>vUp
5|?{urSx?7U.$o%>鉇z'>^:t f?	՞Vؕly1?
bU>-U>jWuI>$5Z;&9u?g_~v?O.ћyP]>nkN
vӾlpŖ>/Ϳ6j?]wſ{)!>]dV>J)P_?k/>Nkq5n>+|> 5<.]BJo>RuhhF:>ƥo>W^"ZrC/>@ўMǺ+d6z4>=. ,E>Z6=1BA>ػy)p\^>qxosD/>Ž;u>賟1^\im >_ˋ7b
U>20~E>\Ǿ>-@}A>%m1p>f⠳Z>TA֏?׷9>RnkdԴn?pǚz>b2Jj&?>rhof^>k㨭8>n>x4̈́)>\Ͼ^lh>0$20>ދPYQ1ժ+0>島(u|A>ّᓾbL#>_9%M4	F܄>F=>j#[OY>u)v+Ȑ}>RGve>~b/>1VǛ|׭T>>^ShP	e>[إYjr>Te1ОUfR+0?_>ˊHh>Գh{>u%s&4>>bߺu,>M
ĒL>UHQ>ᔞ᱄KgI>ڣ%Udfx1M>eͰ8))x>}x^?a)>F:̾Cq>Z/>RUZHΨP>zΎA}D
t >v<~h`>jRn#q>xd>-;Pۋ~p7>]rDVQ5>w",#>(ž93	澽>?ٜq>kE4Rmܚhj>фO@>vsC\V"?P>ß08>lsQho̶ZPk>-ӎ">E ݲ*O\>Ao
ˊqu>h> 
L:#趩>k.,Y)~>j3IR+S8>ѥz}о3irKHM>ɢK.eSk_>l⡱>>JZ>X&dl><'_zs4>/;^54>_SQT "p>׃xZ7aUJ{>ó{--k%5[>>Vպe>ئkv>>YD#`u>g=L^>ٯر#=>Us&?>ӪnǾH;E>,Ȑ
><
=ԛf>bKӶcd>k{բ8;e4>.xi߾{e(>-f>WjoFN{[>HJ=ɾAO>ԑ3]Ԩ٫ǫ>fuǒ/ZA>g%N.gU8߾q+>ƓKI@,>$CӾN>YSYrva>L%Jna->ϪھʽLI(>揧XҔ\<>DH΀;
n`>@
'[9f>AX*9>vL<*N>,ľB:Yp>ѵpӠ+>~pXą2'~>*z>bT٦`!bd>v5PKSd>$!6ǎ>ωuѝzE;>I~Bawm.U4V>p/e1>orT8>K\žJz=B>ϫH?;;7m>3P{%Y>lm+P@X>ͳp/#ʝ] /V>9O.!1H>Ϫ>bgD>£}OFBJ2>9*uᮤb7>˒\kU~J$2j>qۦ\v%a>9;>n7E%XW0> ҔTǞ>ʭs˗>Sz< >OLnMGEL>^$cQ>뾴![>CH,zśd>jpm~T)>Wǒ0>Äv0/
>D-6{$ =[>wO8Cv>
Ȭ$>ɚ BDI>TzʹeWPU>h;BcN-P>~+8/>D*lݬ>39]{c>ǣo>t>ȻJ/,>Kо"[{>UO:Vlξ!}>g}*>k'gVS>cξ[>2vw7Ip>dbѹz_>_\3ɾz7=>qBa>>7qJ]l$>|.~KKIy>2+O@qW>3ƠB2>O>=p}z>('Es
>3瀾))s>oxT/}>˨%#jW>
;$.б>\cho(>E'\ə1i;>ׂ:>0PU#zɂ[>+6KAV>W
6/xu>)m[LJ	&\>2U\ė\>tYc9"-4>e邾Ftw>x=qm>rٓ:>_>_/fw]X>kpr0G>e|оf=KYh=
>0	'9>W[J>W,rJ>C)
>1:?X],g$?Ёv>/Aa0!0O>žHrU_>Bq1\ľEyF>
k*uta`M.>[QD_->0@(`n>Fp^>%w|>rľʩtJ>ϓ
#b>ި㶾*uEO>܉-DZǘ0?>
4а;>ȓ{l>y1uA>Ǚ^JD:g>yU^Kԛ>ޤ
x	@1>O}dR_0l>>/F>
% rn-J>*iD1)ѴU>flLM7{>%6AQr>Ù	#w>pԈ@H>Ll!۾@SKX>>U*c!e>؂L]3P>˛UݾDŽҦ>wNZhpc`*>N^ct֜>n_^Ȳ_k}>wWD73{bb>sIk+ò,">.7Nacos*>KػMI^u&>`h1!͋>89ιƀrt0>bH3."euB> +y%ڶz>ƞ7ݾ8>"+C$#0'tľG>	mŃD}>ij+|龽PJ>j	F<>sMaĈGvH>o4N¾ٔ	2N	>v͊dX
>{Wwն,>s, >txb0>_`¸Fw>2f2¹FNkO'*:>
,iôr#(s>}La)]׃
>Flyȿ>“׸,>Nfʝ3H&>7S"7>B. >.d~~&qx>tY
u3K>m>ECS#)>8FX4j>kbrdC':Ut >?s}~#>,Z @վA>jIyh8>\}%MMoN>iYqm3>.ߔ^Cjш>ai>l>Tnu>IV?~>a7+B>Xc?>fB>0'Ѿ8>ƗPϜ5[C>Sv>Ю~H>u. o/u>)@i[
>tV3,>'Rm#}O0>%
b~N]>&]վr韔5x|>{ẎF
wy>Xk>7C˾_ l>>76oOr>ΟNC>>ܾo=ϛ>7s5׸Il7S>L{e;IA>j5b>;>']eƢ'>Nug]5a>և~#~N]Y>.GO0>!̾!'v>1qLѾ.{#ԖzG> d%ጙ>b˧Rȝ'gBT>$Ⱥ,B>ľ>7be1U>m饾ލ;>:;k5>0F>N@ؾ=xI>%)@hẾaDwg_>!@x `M7>À[>6۪j>!x @boF Pn:>HG!I>mc>PDO&>SPeߎz>RRf!g0Xj>I*]>9i%%c>nsھIflr>kr.g>IC>;&;¾ɏui>(,B%])<ݴyj>?gɁ?y>_A(>;徼ML#d>x/:xDg>>#d徳Q^x~> O7>dW>1%-*a>&5˾@Ԟvjyc{>1N>ܻE>צlA}> Es&oݾ35>dǾ!>9}9>Wa6&>ˤWN;r>Ku}澴fHݧA_mJؤ9>>+쳊E^h<>RpIs9A~޾{`>}Q1>|>7L#>G]l~>1h>UgGSȅ8>VSᾜƾ,k
>jQ^㾳b3w`lj>
!վ瘐>{>r#Ҩqf>a6qlEv>\P꾱x]{@>>wоhdm>;Z-BN>:7cqb>(T)>sEGɟH|0>vY'
7"e#b">'&jݾ4.>g;>k_zۇ>)Wb
>vR2Ni#>%P/6by7g>5Kdž41n@:>U㠾E+>yc>jhh۾.^>X6>J,['arm2>x)f_=٦Y>@"(Fx`t5bQ;>]Ⱦב=U>H>H(]>#!%>+ȑWxN>_پa<3Ac>%RTeoC
&t>$>k2վ7HnR>`Hp	>Mnq羺S>jE>Ax`S]>u 꾔	CRuXe)=>pX*ܫ1S>bRp)>R>0Dg0>P%l>kZ4>Nl%h`%]tF>Iᾦ+!|d4$Az?>%dn2ɻ>>NL㌫r>ү>c_Oj:v*y>GR>Ӗ:B,Y><+辔P罾Wbk>+/XK!ƾ$8%>4NsH|>vt>:׏dy->K6>(NM9$q>./>RĠ{ARE>iЭ@9Dg `k>#BXJ2~lZ>+)>' [>P*>uǻv{>in>
G|(n>
>xsqg辵;.z>Yþr
8>ob0>i">A(}3
>˻>r?Q>aB>z4zƉty>L-#r͕->T	Pņ%(Sj>(p%:C&[)>im>,jh^PT>^I5>b|vm>s>'Yz۪>q31~+>g?!7տqک;e?0bh/𿝃9?(a7}Q[?WKƖ?`ZdFGnIm$Y?qPG,yoY;BA?h0䬟]̚؁I?FdJ?2ɣ*Oo?V'6sWQM?TWߗF"MՎ?=5U
+6Ӽɿ75in$?Cf1ֽGgx=?Fg̳֦A5tH?5hз~:%A"d_?4R=:va?<?*Úi=>ܿm}?lZl%:>SbƩ?*Iz.e*ec=I?%oo_3Y-?RPc?-qGk?"1$2d4?"*B9DD?BJ>5mF6?[.]ſrSQ?*T*z
rȹ?ig@=:h8To9?Beϝ%Ӹ=o?o'F
z1?
ƚ[cֱ,>vUp
5|?{urSx?7U.$o%>鉇z'>^:t f?	՞Vؕly1?
bU>-U>jWuI>$5Z;&9u?g_~v?O.ћyP]>nkN
vӾlpŖ>/Ϳ6j?]wſ{)!>]dV>J)P_?k/>Nkq5n>+|> 5<.]BJo>RuhhF:>ƥo>W^"ZrC/>@ўMǺ+d6z4>=. ,E>Z6=1BA>ػy)p\^>qxosD/>Ž;u>賟1^\im >_ˋ7b
U>20~E>\Ǿ>-@}A>%m1p>f⠳Z>TA֏?׷9>RnkdԴn?pǚz>b2Jj&?>rhof^>k㨭8>n>x4̈́)>\Ͼ^lh>0$20>ދPYQ1ժ+0>島(u|A>ّᓾbL#>_9%M4	F܄>F=>j#[OY>u)v+Ȑ}>RGve>~b/>1VǛ|׭T>>^ShP	e>[إYjr>Te1ОUfR+0?_>ˊHh>Գh{>u%s&4>>bߺu,>M
ĒL>UHQ>ᔞ᱄KgI>ڣ%Udfx1M>eͰ8))x>}x^?a)>F:̾Cq>Z/>RUZHΨP>zΎA}D
t >v<~h`>jRn#q>xd>-;Pۋ~p7>]rDVQ5>w",#>(ž93	澽>?ٜq>kE4Rmܚhj>фO@>vsC\V"?P>ß08>lsQho̶ZPk>-ӎ">E ݲ*O\>Ao
ˊqu>h> 
L:#趩>k.,Y)~>j3IR+S8>ѥz}о3irKHM>ɢK.eSk_>l⡱>>JZ>X&dl><'_zs4>/;^54>_SQT "p>׃xZ7aUJ{>ó{--k%5[>>Vպe>ئkv>>YD#`u>g=L^>ٯر#=>Us&?>ӪnǾH;E>,Ȑ
><
=ԛf>bKӶcd>k{բ8;e4>.xi߾{e(>-f>WjoFN{[>HJ=ɾAO>ԑ3]Ԩ٫ǫ>fuǒ/ZA>g%N.gU8߾q+>ƓKI@,>$CӾN>YSYrva>L%Jna->ϪھʽLI(>揧XҔ\<>DH΀;
n`>@
'[9f>AX*9>vL<*N>,ľB:Yp>ѵpӠ+>~pXą2'~>*z>bT٦`!bd>v5PKSd>$!6ǎ>ωuѝzE;>I~Bawm.U4V>p/e1>orT8>K\žJz=B>ϫH?;;7m>3P{%Y>lm+P@X>ͳp/#ʝ] /V>9O.!1H>Ϫ>bgD>£}OFBJ2>9*uᮤb7>˒\kU~J$2j>qۦ\v%a>9;>n7E%XW0> ҔTǞ>ʭs˗>Sz< >OLnMGEL>^$cQ>뾴![>CH,zśd>jpm~T)>Wǒ0>Äv0/
>D-6{$ =[>wO8Cv>
Ȭ$>ɚ BDI>TzʹeWPU>h;BcN-P>~+8/>D*lݬ>39]{c>ǣo>t>ȻJ/,>Kо"[{>UO:Vlξ!}>g}*>k'gVS>cξ[>2vw7Ip>dbѹz_>_\3ɾz7=>qBa>>7qJ]l$>|.~KKIy>2+O@qW>3ƠB2>O>=p}z>('Es
>3瀾))s>oxT/}>˨%#jW>
;$.б>\cho(>E'\ə1i;>ׂ:>0PU#zɂ[>+6KAV>W
6/xu>)m[LJ	&\>2U\ė\>tYc9"-4>e邾Ftw>x=qm>rٓ:>_>_/fw]X>kpr0G>e|оf=KYh=
>0	'9>W[J>W,rJ>C)
>1:?X],g$?Ёv>/Aa0!0O>žHrU_>Bq1\ľEyF>
k*uta`M.>[QD_->0@(`n>Fp^>%w|>rľʩtJ>ϓ
#b>ި㶾*uEO>܉-DZǘ0?>
4а;>ȓ{l>y1uA>Ǚ^JD:g>yU^Kԛ>ޤ
x	@1>O}dR_0l>>/F>
% rn-J>*iD1)ѴU>flLM7{>%6AQr>Ù	#w>pԈ@H>Ll!۾@SKX>>U*c!e>؂L]3P>˛UݾDŽҦ>wNZhpc`*>N^ct֜>n_^Ȳ_k}>wWD73{bb>sIk+ò,">.7Nacos*>KػMI^u&>`h1!͋>89ιƀrt0>bH3."euB> +y%ڶz>ƞ7ݾ8>"+C$#0'tľG>	mŃD}>ij+|龽PJ>j	F<>sMaĈGvH>o4N¾ٔ	2N	>v͊dX
>{Wwն,>s, >txb0>_`¸Fw>2f2¹FNkO'*:>
,iôr#(s>}La)]׃
>Flyȿ>“׸,>Nfʝ3H&>7S"7>B. >.d~~&qx>tY
u3K>m>ECS#)>8FX4j>kbrdC':Ut >?s}~#>,Z @վA>jIyh8>\}%MMoN>iYqm3>.ߔ^Cjш>ai>l>Tnu>IV?~>a7+B>Xc?>fB>0'Ѿ8>ƗPϜ5[C>Sv>Ю~H>u. o/u>)@i[
>tV3,>'Rm#}O0>%
b~N]>&]վr韔5x|>{ẎF
wy>Xk>7C˾_ l>>76oOr>ΟNC>>ܾo=ϛ>7s5׸Il7S>L{e;IA>j5b>;>']eƢ'>Nug]5a>և~#~N]Y>.GO0>!̾!'v>1qLѾ.{#ԖzG> d%ጙ>b˧Rȝ'gBT>$Ⱥ,B>ľ>7be1U>m饾ލ;>:;k5>0F>N@ؾ=xI>%)@hẾaDwg_>!@x `M7>À[>6۪j>!x @boF Pn:>HG!I>mc>PDO&>SPeߎz>RRf!g0Xj>I*]>9i%%c>nsھIflr>kr.g>IC>;&;¾ɏui>(,B%])<ݴyj>?gɁ?y>_A(>;徼ML#d>x/:xDg>>#d徳Q^x~> O7>dW>1%-*a>&5˾@Ԟvjyc{>1N>ܻE>צlA}> Es&oݾ35>dǾ!>9}9>Wa6&>ˤWN;r>Ku}澴fHݧA_mJؤ9>>+쳊E^h<>RpIs9A~޾{`>}Q1>|>7L#>G]l~>1h>UgGSȅ8>VSᾜƾ,k
>jQ^㾳b3w`lj>
!վ瘐>{>r#Ҩqf>a6qlEv>\P꾱x]{@>>wоhdm>;Z-BN>:7cqb>(T)>sEGɟH|0>vY'
7"e#b">'&jݾ4.>g;>k_zۇ>)Wb
>vR2Ni#>%P/6by7g>5Kdž41n@:>U㠾E+>yc>jhh۾.^>X6>J,['arm2>x)f_=٦Y>@"(Fx`t5bQ;>]Ⱦב=U>H>H(]>#!%>+ȑWxN>_پa<3Ac>%RTeoC
&t>$>k2վ7HnR>`Hp	>Mnq羺S>jE>Ax`S]>u 꾔	CRuXe)=>pX*ܫ1S>bRp)>R>0Dg0>P%l>kZ4>Nl%h`%]tF>Iᾦ+!|d4$Az?>%dn2ɻ>>NL㌫r>ү>c_Oj:v*y>GR>Ӗ:B,Y><+辔P罾Wbk>+/XK!ƾ$8%>4NsH|>vt>:׏dy->K6>(NM9$q>./>RĠ{ARE>iЭ@9Dg `k>#BXJ2~lZ>+)>' [>P*>uǻv{>in>
G|(n>
>xsqg辵;.z>Yþr
8>ob0>i">A(}3
>˻>r?Q>aB>z4zƉty>L-#r͕->T	Pņ%(Sj>(p%:C&[)>im>,jh^PT>^I5>b|vm>s>'Yz۪>q31~+>g?!7տqک;e?0bh/𿝃9?(a7}Q[?WKƖ?`ZdFGnIm$Y?qPG,yoY;BA?h0䬟]̚؁I?FdJ?2ɣ*Oo?V'6sWQM?TWߗF"MՎ?=5U
+6Ӽɿ75in$?Cf1ֽGgx=?Fg̳֦A5tH?5hз~:%A"d_?4R=:va?<?*Úi=>ܿm}?lZl%:>SbƩ?*Iz.e*ec=I?%oo_3Y-?RPc?-qGk?"1$2d4?"*B9DD?BJ>5mF6?[.]ſrSQ?*T*z
rȹ?ig@=:h8To9?Beϝ%Ӹ=o?o'F
z1?
ƚ[cֱ,>vUp
5|?{urSx?7U.$o%>鉇z'>^:t f?	՞Vؕly1?
bU>-U>jWuI>$5Z;&9u?g_~v?O.ћyP]>nkN
vӾlpŖ>/Ϳ6j?]wſ{)!>]dV>J)P_?k/>Nkq5n>+|> 5<.]BJo>RuhhF:>ƥo>W^"ZrC/>@ўMǺ+d6z4>=. ,E>Z6=1BA>ػy)p\^>qxosD/>Ž;u>賟1^\im >_ˋ7b
U>20~E>\Ǿ>-@}A>%m1p>f⠳Z>TA֏?׷9>RnkdԴn?pǚz>b2Jj&?>rhof^>k㨭8>n>x4̈́)>\Ͼ^lh>0$20>ދPYQ1ժ+0>島(u|A>ّᓾbL#>_9%M4	F܄>F=>j#[OY>u)v+Ȑ}>RGve>~b/>1VǛ|׭T>>^ShP	e>[إYjr>Te1ОUfR+0?_>ˊHh>Գh{>u%s&4>>bߺu,>M
ĒL>UHQ>ᔞ᱄KgI>ڣ%Udfx1M>eͰ8))x>}x^?a)>F:̾Cq>Z/>RUZHΨP>zΎA}D
t >v<~h`>jRn#q>xd>-;Pۋ~p7>]rDVQ5>w",#>(ž93	澽>?ٜq>kE4Rmܚhj>фO@>vsC\V"?P>ß08>lsQho̶ZPk>-ӎ">E ݲ*O\>Ao
ˊqu>h> 
L:#趩>k.,Y)~>j3IR+S8>ѥz}о3irKHM>ɢK.eSk_>l⡱>>JZ>X&dl><'_zs4>/;^54>_SQT "p>׃xZ7aUJ{>ó{--k%5[>>Vպe>ئkv>>YD#`u>g=L^>ٯر#=>Us&?>ӪnǾH;E>,Ȑ
><
=ԛf>bKӶcd>k{բ8;e4>.xi߾{e(>-f>WjoFN{[>HJ=ɾAO>ԑ3]Ԩ٫ǫ>fuǒ/ZA>g%N.gU8߾q+>ƓKI@,>$CӾN>YSYrva>L%Jna->ϪھʽLI(>揧XҔ\<>DH΀;
n`>@
'[9f>AX*9>vL<*N>,ľB:Yp>ѵpӠ+>~pXą2'~>*z>bT٦`!bd>v5PKSd>$!6ǎ>ωuѝzE;>I~Bawm.U4V>p/e1>orT8>K\žJz=B>ϫH?;;7m>3P{%Y>lm+P@X>ͳp/#ʝ] /V>9O.!1H>Ϫ>bgD>£}OFBJ2>9*uᮤb7>˒\kU~J$2j>qۦ\v%a>9;>n7E%XW0> ҔTǞ>ʭs˗>Sz< >OLnMGEL>^$cQ>뾴![>CH,zśd>jpm~T)>Wǒ0>Äv0/
>D-6{$ =[>wO8Cv>
Ȭ$>ɚ BDI>TzʹeWPU>h;BcN-P>~+8/>D*lݬ>39]{c>ǣo>t>ȻJ/,>Kо"[{>UO:Vlξ!}>g}*>k'gVS>cξ[>2vw7Ip>dbѹz_>_\3ɾz7=>qBa>>7qJ]l$>|.~KKIy>2+O@qW>3ƠB2>O>=p}z>('Es
>3瀾))s>oxT/}>˨%#jW>
;$.б>\cho(>E'\ə1i;>ׂ:>0PU#zɂ[>+6KAV>W
6/xu>)m[LJ	&\>2U\ė\>tYc9"-4>e邾Ftw>x=qm>rٓ:>_>_/fw]X>kpr0G>e|оf=KYh=
>0	'9>W[J>W,rJ>C)
>1:?X],g$?Ёv>/Aa0!0O>žHrU_>Bq1\ľEyF>
k*uta`M.>[QD_->0@(`n>Fp^>%w|>rľʩtJ>ϓ
#b>ި㶾*uEO>܉-DZǘ0?>
4а;>ȓ{l>y1uA>Ǚ^JD:g>yU^Kԛ>ޤ
x	@1>O}dR_0l>>/F>
% rn-J>*iD1)ѴU>flLM7{>%6AQr>Ù	#w>pԈ@H>Ll!۾@SKX>>U*c!e>؂L]3P>˛UݾDŽҦ>wNZhpc`*>N^ct֜>n_^Ȳ_k}>wWD73{bb>sIk+ò,">.7Nacos*>KػMI^u&>`h1!͋>89ιƀrt0>bH3."euB> +y%ڶz>ƞ7ݾ8>"+C$#0'tľG>	mŃD}>ij+|龽PJ>j	F<>sMaĈGvH>o4N¾ٔ	2N	>v͊dX
>{Wwն,>s, >txb0>_`¸Fw>2f2¹FNkO'*:>
,iôr#(s>}La)]׃
>Flyȿ>“׸,>Nfʝ3H&>7S"7>B. >.d~~&qx>tY
u3K>m>ECS#)>8FX4j>kbrdC':Ut >?s}~#>,Z @վA>jIyh8>\}%MMoN>iYqm3>.ߔ^Cjш>ai>l>Tnu>IV?~>a7+B>Xc?>fB>0'Ѿ8>ƗPϜ5[C>Sv>Ю~H>u. o/u>)@i[
>tV3,>'Rm#}O0>%
b~N]>&]վr韔5x|>{ẎF
wy>Xk>7C˾_ l>>76oOr>ΟNC>>ܾo=ϛ>7s5׸Il7S>L{e;IA>j5b>;>']eƢ'>Nug]5a>և~#~N]Y>.GO0>!̾!'v>1qLѾ.{#ԖzG> d%ጙ>b˧Rȝ'gBT>$Ⱥ,B>ľ>7be1U>m饾ލ;>:;k5>0F>N@ؾ=xI>%)@hẾaDwg_>!@x `M7>À[>6۪j>!x @boF Pn:>HG!I>mc>PDO&>SPeߎz>RRf!g0Xj>I*]>9i%%c>nsھIflr>kr.g>IC>;&;¾ɏui>(,B%])<ݴyj>?gɁ?y>_A(>;徼ML#d>x/:xDg>>#d徳Q^x~> O7>dW>1%-*a>&5˾@Ԟvjyc{>1N>ܻE>צlA}> Es&oݾ35>dǾ!>9}9>Wa6&>ˤWN;r>Ku}澴fHݧA_mJؤ9>>+쳊E^h<>RpIs9A~޾{`>}Q1>|>7L#>G]l~>1h>UgGSȅ8>VSᾜƾ,k
>jQ^㾳b3w`lj>
!վ瘐>{>r#Ҩqf>a6qlEv>\P꾱x]{@>>wоhdm>;Z-BN>:7cqb>(T)>sEGɟH|0>vY'
7"e#b">'&jݾ4.>g;>k_zۇ>)Wb
>vR2Ni#>%P/6by7g>5Kdž41n@:>U㠾E+>yc>jhh۾.^>X6>J,['arm2>x)f_=٦Y>@"(Fx`t5bQ;>]Ⱦב=U>H>H(]>#!%>+ȑWxN>_پa<3Ac>%RTeoC
&t>$>k2վ7HnR>`Hp	>Mnq羺S>jE>Ax`S]>u 꾔	CRuXe)=>pX*ܫ1S>bRp)>R>0Dg0>P%l>kZ4>Nl%h`%]tF>Iᾦ+!|d4$Az?>%dn2ɻ>>NL㌫r>ү>c_Oj:v*y>GR>Ӗ:B,Y><+辔P罾Wbk>+/XK!ƾ$8%>4NsH|>vt>:׏dy->K6>(NM9$q>./>RĠ{ARE>iЭ@9Dg `k>#BXJ2~lZ>+)>' [>P*>uǻv{>in>
G|(n>
>xsqg辵;.z>Yþr
8>ob0>i">A(}3
>˻>r?Q>aB>z4zƉty>L-#r͕->T	Pņ%(Sj>(p%:C&[)>im>,jh^PT>^I5>b|vm>s>'Yz۪>q31~+>ghealpy-1.10.3/healpy/data/weight_ring_n01024.fits0000664000175000017500000016610013010374155021625 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:15:45' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                24576 / width of table in bytes                        NAXIS2  =                    2 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                 1024 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                 3500 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1024D   '                                                            MAXVAL1 =   1.748933828406E-01 / maximum value of T weights                     MINVAL1 =  -8.915246089061E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1024D   '                                                            MAXVAL2 =   1.748933828406E-01 / maximum value of Q weights                     MINVAL2 =  -8.915246089061E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1024D   '                                                            MAXVAL3 =   1.748933828406E-01 / maximum value of U weights                     MINVAL3 =  -8.915246089061E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?b%6Ҳp?/a #2?NfտHW?~dױiR?N~72W?`)ׂi
n}@?lR9Zke˛?g¹Db>
S4?WYhEnJ߾?BV]N>*x?RFS)-wm?QrRQDLiq?B2+}>aCt?1-5w=WI+W?BFWbc/CQ<ʠ?B1͇ڿ=d8V?4_Xup#z ڎgg?#`Jy1/G ?5jk79NY?58ˎ72/6?)Xyre ކ	*?lN>fV&K^?,\iM.M?-u%(f[v?!G)gS-m.-g-?D/%՜_?bP*?p3f;u@)ryvtO>}8Z\K ?x&+?h{{6I[8?fDپ>Jj> /yKg>?}垴o?GݺoSۣ>,?Lw>l-.>#m
/~V?͞?<<ٓ
B>6
uI>S>n-4kڙF%>odG?m4t{>*Wd~`>ūH8>rV 7>\9S0o>t9HHVZ>!g.B>ʁ=>)kۑfׄ>(Xv60>nq)U
>g&Βu[y>x8޲>i2l靅kFcO>OH%>@ft:>'@mOw>ʖ1>B'u
>f
RM.1":>'a3Ć>)P@<>PeT>yKد5 ^>w,EWW>R9z򡯁W>@|VyO]ZP>!>>{GD9Uҩ>.V4-)g>ZhG.mdP>WAdQG>E?kL{{mbOH>t
F>*gEj_z u>L<喊js>ٌ8^>žrzRIW fH>S+eY<	>Æ|ea.>J9d5?	>+~|/BlA1E|>~
Ja{` >t*ӸP'o>ܟQ0gj:k~>}qEm|">q7q/|k>g$y>ݴ&܈ϾτS>`h%>wNX
ܝ>Fhq8>2hӬҾ~'>NҜ{>̟>̊ Yȝ|>f>|33P!L%>ߓRC!M><>>jb!`百tI>Z͟.=X>>$B+=3ZK>He>[{yT]>XgPվS/mW`>ֲG"Lޏ*>w>iо(ɣ$>٣7h=>aFHʾn+]I;	j>ц9*ž$}h>SqVya>xڛJ+>RV!PPglq>i'L"Ʃk>pDc9̾ީ\.i>ށl		yA%>ԮY'݌3>‚>pM@9Y>BSоۧ2?\>Ҍ1x>zd҇3> f(u+>jƚۚ>rH1剒>ސkyڳc>ףzX7Bke>Z~mվ}qbH4!>@8"hل-O>lJ36>ن7׾VZYDg>h^mH%ם>8ю̾יԥ>׽}_3>ز4 P0>^X>ĴƖ>RHS>֏BnݾL>ҿR1˔h2>)zqWEm۹>ɒUWtљV[>ԆgURH5ȅ>PV>d]?xW8VY>>ĺԾ=j>Ѧvt0DФ&+`>K޾n.>i{ʾ0s>(]>DUKwdH4>Gyb%">yk^*Ґbl>L"#͒ŗ@>+D^ᾱ|SW_>x-΂>uWDW3>LaͲ\W>"lH帾۔S0>|>+'[+]D>˰ٛKc>N'+Z9{c>L7GվÙ9s_>iTnO>jG{}l$6K>{5:Vi4Z>63kX9>cIYeY,>b:Qҙ5>wB<AZk>gn]O>ĉZ[k>;ʾp]>IV>PZXt@D>I;Qb}R3>C"n<+D0?,>poqƗ>^ᾰKDru|>D==u(>7Iʷ>tX^p0>^h,H
>moh
߾i@A?NyVfZ>gtt>8>&ݾʍ >~5jo!>.3>k3T8~>qu۾[-S>IO42O\>B>8 $ȸ]|>þ#vDSy>mOT图Ivi6OI>%[N@JE=>o>Ծ"[>#;>W>uPоm>%@ax0>+b;ħ>c	°Lc>6.k`c>G@>>@iZ!B>0<FVPŞ@[vA>gXDC>>{craJ;{l)>`)>᩵C_[w>j>*xܷ;>Lf4f'}>@Q񆾣l?<>؝xAƾ Z>No!Q>E
=>צ>°aO>'d>;81k!>=y3fu>7IvCc&R>ª&ɾ~Ά#*>CBھq`>Ѥ>Qf$>aY
W<:X&E>Ot4x>-㤾aQ$>/o'A&6>l>|E,E"kF>Fn9ɟ*+>< eg>7^B+wPՇ>lPOe[>"A%R>M=	Rn>!‹
<	>wٜBD>FtRcd>
@>޲G >鿾-ϳ_>a6־:^M>ƍeLN͎>9
d>~m}>J9
B>~qU`;5ŭ>فm 'NL>>54Hf%>kHU>4*u-У
To>?sk\^]?>@mTM>k'%s*`>Y෰-S->5m1a~ȾLb>2*vJ+>>+qE/]>Qa
+h_>$:->'m3~^׾x>Ry|Yfĩ>9 V>^(\R
%!1>'Ck*
>86=xlQ>B)>ɤ\I#3C>g	N)]>@mNfSށ>W+-%[#>uS5>gI.bIa^վ]>L>|r?}dmy>Zz	><Ʌr[N>yg)↭/>S:7>`C2
>/21¾1>uu?꾸VӚB>fWIƴ_>Ae"ď$FE>:jqXD7ݾ=']>d.<,Pcq,>D*ժxF>P|j2
t>΢?쾱)><¤z>7P>ơ,u>?mK{#>ZL3b>|P1>Y_/A^>Ծ,DOP>>%69оkb>$vP>2"#X2rb>x"W|zӯ>.F쿾H
>ܬ{@>4p>C7D?s| wZp>
u?|{C>;R*>VjkP>*t2YwS9>/^SSZN>{۴ʾBc{87>1%˽¾}iD7>֔D`.>fs>̖h>kqbA$I>J|xT)9`>e.>w5'q]+hJCV>P꓾r>].gґt>wrWI>".ώl>UFN>"~L o*Y>s|A>uY쾜0]e>2#2b>:0Ѿ'-0>9HͿ>w.ooh>HXGBĈ>q؍93XQQ}>4d	'X>z⾯7G>GhOؾu>MYj>4
h¸>}xB}>T!>aT@}8XZ>JF}>鞄c>о+?Tg	>Bz^1t?-V>"mh9_UI>xpҾc8u>J]{Bh|\Bv>-CU?>{6?h>s-	x>hp>ovn>*$1y>cf
6o(NCI*mP>b$ҾefK>ިξ9-L>=/>u>DA$ב39>_e7>?q޾ſs>c$ܾz8Z]ppvAl>[EZn4>!km1>>T뾬H]>.:`>{	(>[W>Fl}'>i=9qՃ>U­Ty>kuE5ۯ)>
Hy#Cm>%M
Ҿd:>3$Q%C>YڲK)Y,>F`x]aPjp#]%>k(7J-Ͷ7>$gIϾ,qC>{5=>9D~;>ʞ@=t;>o츥yo>ƼȾ$8=>qn(u^d:ҾoC;ܢu>VI_~>qr>kYd}>0`W2W>p$d뾩Yf>+T_!6L>0$x>-iVn9m>	i>hYh>vIjF-TM;>֙m@>>Ц49>eٻ3ϾzO>*wf+Dbe>+۾/t>Dmp2$>iʌ-1XK>?eAfbCK>Gb>{ؽaH?fd>i7wk{Py?>\Lwu>gV>LޙTNH>aԸ`ޖ>_`!>0kʾk S0>ƿ6At$>}at ;삿zsl>]澓e>0"۾=>8OѾp7>&?h](\̵>0
٪>Mh'd>NоVx>;kLͦ>=*A˾o$>M$p(N۾bx[¸">1%[h}r >#\5%>>ಭеoD>yh9P2lD%>pR̦꾦ُR|A>0EE fIR>&jRf>?r
$>)ڡ>+:¼ub">ifFǾ?>d?e>l*ȥe!4>J30q>Eh>1_/H%ke\>T7=Pp>8o>:_Q$׾hE׾>;P|վ">g|	CC>KFA+>!¡r|ٞ~><T>)\rCp.M_>Z{x};>tP[檾0z#>c`aCi>5/7~
>MT
L澩8q˸O>*ˀaoYl>VsP\9>$wݾ1]>I;+2Rd>&IY¾JLv>U~Yɬ>$<>>ѾZ P~>M^Ѿ6U>^qXqa>MM14WQ>0]xLh>poʎ8L<>ԳHʒ>v(H|?z>\4@(>UnlLw^>'sz
 >ȋ΢0?2>zRWK>bMN9>нVV>#V*d,>ҵ
@~>
η
1c>Ҹ$E$-WK>Ыkhƾ|AgiP>fZ}^{l^TձO>hTn`A?b%6Ҳp?/a #2?NfտHW?~dױiR?N~72W?`)ׂi
n}@?lR9Zke˛?g¹Db>
S4?WYhEnJ߾?BV]N>*x?RFS)-wm?QrRQDLiq?B2+}>aCt?1-5w=WI+W?BFWbc/CQ<ʠ?B1͇ڿ=d8V?4_Xup#z ڎgg?#`Jy1/G ?5jk79NY?58ˎ72/6?)Xyre ކ	*?lN>fV&K^?,\iM.M?-u%(f[v?!G)gS-m.-g-?D/%՜_?bP*?p3f;u@)ryvtO>}8Z\K ?x&+?h{{6I[8?fDپ>Jj> /yKg>?}垴o?GݺoSۣ>,?Lw>l-.>#m
/~V?͞?<<ٓ
B>6
uI>S>n-4kڙF%>odG?m4t{>*Wd~`>ūH8>rV 7>\9S0o>t9HHVZ>!g.B>ʁ=>)kۑfׄ>(Xv60>nq)U
>g&Βu[y>x8޲>i2l靅kFcO>OH%>@ft:>'@mOw>ʖ1>B'u
>f
RM.1":>'a3Ć>)P@<>PeT>yKد5 ^>w,EWW>R9z򡯁W>@|VyO]ZP>!>>{GD9Uҩ>.V4-)g>ZhG.mdP>WAdQG>E?kL{{mbOH>t
F>*gEj_z u>L<喊js>ٌ8^>žrzRIW fH>S+eY<	>Æ|ea.>J9d5?	>+~|/BlA1E|>~
Ja{` >t*ӸP'o>ܟQ0gj:k~>}qEm|">q7q/|k>g$y>ݴ&܈ϾτS>`h%>wNX
ܝ>Fhq8>2hӬҾ~'>NҜ{>̟>̊ Yȝ|>f>|33P!L%>ߓRC!M><>>jb!`百tI>Z͟.=X>>$B+=3ZK>He>[{yT]>XgPվS/mW`>ֲG"Lޏ*>w>iо(ɣ$>٣7h=>aFHʾn+]I;	j>ц9*ž$}h>SqVya>xڛJ+>RV!PPglq>i'L"Ʃk>pDc9̾ީ\.i>ށl		yA%>ԮY'݌3>‚>pM@9Y>BSоۧ2?\>Ҍ1x>zd҇3> f(u+>jƚۚ>rH1剒>ސkyڳc>ףzX7Bke>Z~mվ}qbH4!>@8"hل-O>lJ36>ن7׾VZYDg>h^mH%ם>8ю̾יԥ>׽}_3>ز4 P0>^X>ĴƖ>RHS>֏BnݾL>ҿR1˔h2>)zqWEm۹>ɒUWtљV[>ԆgURH5ȅ>PV>d]?xW8VY>>ĺԾ=j>Ѧvt0DФ&+`>K޾n.>i{ʾ0s>(]>DUKwdH4>Gyb%">yk^*Ґbl>L"#͒ŗ@>+D^ᾱ|SW_>x-΂>uWDW3>LaͲ\W>"lH帾۔S0>|>+'[+]D>˰ٛKc>N'+Z9{c>L7GվÙ9s_>iTnO>jG{}l$6K>{5:Vi4Z>63kX9>cIYeY,>b:Qҙ5>wB<AZk>gn]O>ĉZ[k>;ʾp]>IV>PZXt@D>I;Qb}R3>C"n<+D0?,>poqƗ>^ᾰKDru|>D==u(>7Iʷ>tX^p0>^h,H
>moh
߾i@A?NyVfZ>gtt>8>&ݾʍ >~5jo!>.3>k3T8~>qu۾[-S>IO42O\>B>8 $ȸ]|>þ#vDSy>mOT图Ivi6OI>%[N@JE=>o>Ծ"[>#;>W>uPоm>%@ax0>+b;ħ>c	°Lc>6.k`c>G@>>@iZ!B>0<FVPŞ@[vA>gXDC>>{craJ;{l)>`)>᩵C_[w>j>*xܷ;>Lf4f'}>@Q񆾣l?<>؝xAƾ Z>No!Q>E
=>צ>°aO>'d>;81k!>=y3fu>7IvCc&R>ª&ɾ~Ά#*>CBھq`>Ѥ>Qf$>aY
W<:X&E>Ot4x>-㤾aQ$>/o'A&6>l>|E,E"kF>Fn9ɟ*+>< eg>7^B+wPՇ>lPOe[>"A%R>M=	Rn>!‹
<	>wٜBD>FtRcd>
@>޲G >鿾-ϳ_>a6־:^M>ƍeLN͎>9
d>~m}>J9
B>~qU`;5ŭ>فm 'NL>>54Hf%>kHU>4*u-У
To>?sk\^]?>@mTM>k'%s*`>Y෰-S->5m1a~ȾLb>2*vJ+>>+qE/]>Qa
+h_>$:->'m3~^׾x>Ry|Yfĩ>9 V>^(\R
%!1>'Ck*
>86=xlQ>B)>ɤ\I#3C>g	N)]>@mNfSށ>W+-%[#>uS5>gI.bIa^վ]>L>|r?}dmy>Zz	><Ʌr[N>yg)↭/>S:7>`C2
>/21¾1>uu?꾸VӚB>fWIƴ_>Ae"ď$FE>:jqXD7ݾ=']>d.<,Pcq,>D*ժxF>P|j2
t>΢?쾱)><¤z>7P>ơ,u>?mK{#>ZL3b>|P1>Y_/A^>Ծ,DOP>>%69оkb>$vP>2"#X2rb>x"W|zӯ>.F쿾H
>ܬ{@>4p>C7D?s| wZp>
u?|{C>;R*>VjkP>*t2YwS9>/^SSZN>{۴ʾBc{87>1%˽¾}iD7>֔D`.>fs>̖h>kqbA$I>J|xT)9`>e.>w5'q]+hJCV>P꓾r>].gґt>wrWI>".ώl>UFN>"~L o*Y>s|A>uY쾜0]e>2#2b>:0Ѿ'-0>9HͿ>w.ooh>HXGBĈ>q؍93XQQ}>4d	'X>z⾯7G>GhOؾu>MYj>4
h¸>}xB}>T!>aT@}8XZ>JF}>鞄c>о+?Tg	>Bz^1t?-V>"mh9_UI>xpҾc8u>J]{Bh|\Bv>-CU?>{6?h>s-	x>hp>ovn>*$1y>cf
6o(NCI*mP>b$ҾefK>ިξ9-L>=/>u>DA$ב39>_e7>?q޾ſs>c$ܾz8Z]ppvAl>[EZn4>!km1>>T뾬H]>.:`>{	(>[W>Fl}'>i=9qՃ>U­Ty>kuE5ۯ)>
Hy#Cm>%M
Ҿd:>3$Q%C>YڲK)Y,>F`x]aPjp#]%>k(7J-Ͷ7>$gIϾ,qC>{5=>9D~;>ʞ@=t;>o츥yo>ƼȾ$8=>qn(u^d:ҾoC;ܢu>VI_~>qr>kYd}>0`W2W>p$d뾩Yf>+T_!6L>0$x>-iVn9m>	i>hYh>vIjF-TM;>֙m@>>Ц49>eٻ3ϾzO>*wf+Dbe>+۾/t>Dmp2$>iʌ-1XK>?eAfbCK>Gb>{ؽaH?fd>i7wk{Py?>\Lwu>gV>LޙTNH>aԸ`ޖ>_`!>0kʾk S0>ƿ6At$>}at ;삿zsl>]澓e>0"۾=>8OѾp7>&?h](\̵>0
٪>Mh'd>NоVx>;kLͦ>=*A˾o$>M$p(N۾bx[¸">1%[h}r >#\5%>>ಭеoD>yh9P2lD%>pR̦꾦ُR|A>0EE fIR>&jRf>?r
$>)ڡ>+:¼ub">ifFǾ?>d?e>l*ȥe!4>J30q>Eh>1_/H%ke\>T7=Pp>8o>:_Q$׾hE׾>;P|վ">g|	CC>KFA+>!¡r|ٞ~><T>)\rCp.M_>Z{x};>tP[檾0z#>c`aCi>5/7~
>MT
L澩8q˸O>*ˀaoYl>VsP\9>$wݾ1]>I;+2Rd>&IY¾JLv>U~Yɬ>$<>>ѾZ P~>M^Ѿ6U>^qXqa>MM14WQ>0]xLh>poʎ8L<>ԳHʒ>v(H|?z>\4@(>UnlLw^>'sz
 >ȋ΢0?2>zRWK>bMN9>нVV>#V*d,>ҵ
@~>
η
1c>Ҹ$E$-WK>Ыkhƾ|AgiP>fZ}^{l^TձO>hTn`A?b%6Ҳp?/a #2?NfտHW?~dױiR?N~72W?`)ׂi
n}@?lR9Zke˛?g¹Db>
S4?WYhEnJ߾?BV]N>*x?RFS)-wm?QrRQDLiq?B2+}>aCt?1-5w=WI+W?BFWbc/CQ<ʠ?B1͇ڿ=d8V?4_Xup#z ڎgg?#`Jy1/G ?5jk79NY?58ˎ72/6?)Xyre ކ	*?lN>fV&K^?,\iM.M?-u%(f[v?!G)gS-m.-g-?D/%՜_?bP*?p3f;u@)ryvtO>}8Z\K ?x&+?h{{6I[8?fDپ>Jj> /yKg>?}垴o?GݺoSۣ>,?Lw>l-.>#m
/~V?͞?<<ٓ
B>6
uI>S>n-4kڙF%>odG?m4t{>*Wd~`>ūH8>rV 7>\9S0o>t9HHVZ>!g.B>ʁ=>)kۑfׄ>(Xv60>nq)U
>g&Βu[y>x8޲>i2l靅kFcO>OH%>@ft:>'@mOw>ʖ1>B'u
>f
RM.1":>'a3Ć>)P@<>PeT>yKد5 ^>w,EWW>R9z򡯁W>@|VyO]ZP>!>>{GD9Uҩ>.V4-)g>ZhG.mdP>WAdQG>E?kL{{mbOH>t
F>*gEj_z u>L<喊js>ٌ8^>žrzRIW fH>S+eY<	>Æ|ea.>J9d5?	>+~|/BlA1E|>~
Ja{` >t*ӸP'o>ܟQ0gj:k~>}qEm|">q7q/|k>g$y>ݴ&܈ϾτS>`h%>wNX
ܝ>Fhq8>2hӬҾ~'>NҜ{>̟>̊ Yȝ|>f>|33P!L%>ߓRC!M><>>jb!`百tI>Z͟.=X>>$B+=3ZK>He>[{yT]>XgPվS/mW`>ֲG"Lޏ*>w>iо(ɣ$>٣7h=>aFHʾn+]I;	j>ц9*ž$}h>SqVya>xڛJ+>RV!PPglq>i'L"Ʃk>pDc9̾ީ\.i>ށl		yA%>ԮY'݌3>‚>pM@9Y>BSоۧ2?\>Ҍ1x>zd҇3> f(u+>jƚۚ>rH1剒>ސkyڳc>ףzX7Bke>Z~mվ}qbH4!>@8"hل-O>lJ36>ن7׾VZYDg>h^mH%ם>8ю̾יԥ>׽}_3>ز4 P0>^X>ĴƖ>RHS>֏BnݾL>ҿR1˔h2>)zqWEm۹>ɒUWtљV[>ԆgURH5ȅ>PV>d]?xW8VY>>ĺԾ=j>Ѧvt0DФ&+`>K޾n.>i{ʾ0s>(]>DUKwdH4>Gyb%">yk^*Ґbl>L"#͒ŗ@>+D^ᾱ|SW_>x-΂>uWDW3>LaͲ\W>"lH帾۔S0>|>+'[+]D>˰ٛKc>N'+Z9{c>L7GվÙ9s_>iTnO>jG{}l$6K>{5:Vi4Z>63kX9>cIYeY,>b:Qҙ5>wB<AZk>gn]O>ĉZ[k>;ʾp]>IV>PZXt@D>I;Qb}R3>C"n<+D0?,>poqƗ>^ᾰKDru|>D==u(>7Iʷ>tX^p0>^h,H
>moh
߾i@A?NyVfZ>gtt>8>&ݾʍ >~5jo!>.3>k3T8~>qu۾[-S>IO42O\>B>8 $ȸ]|>þ#vDSy>mOT图Ivi6OI>%[N@JE=>o>Ծ"[>#;>W>uPоm>%@ax0>+b;ħ>c	°Lc>6.k`c>G@>>@iZ!B>0<FVPŞ@[vA>gXDC>>{craJ;{l)>`)>᩵C_[w>j>*xܷ;>Lf4f'}>@Q񆾣l?<>؝xAƾ Z>No!Q>E
=>צ>°aO>'d>;81k!>=y3fu>7IvCc&R>ª&ɾ~Ά#*>CBھq`>Ѥ>Qf$>aY
W<:X&E>Ot4x>-㤾aQ$>/o'A&6>l>|E,E"kF>Fn9ɟ*+>< eg>7^B+wPՇ>lPOe[>"A%R>M=	Rn>!‹
<	>wٜBD>FtRcd>
@>޲G >鿾-ϳ_>a6־:^M>ƍeLN͎>9
d>~m}>J9
B>~qU`;5ŭ>فm 'NL>>54Hf%>kHU>4*u-У
To>?sk\^]?>@mTM>k'%s*`>Y෰-S->5m1a~ȾLb>2*vJ+>>+qE/]>Qa
+h_>$:->'m3~^׾x>Ry|Yfĩ>9 V>^(\R
%!1>'Ck*
>86=xlQ>B)>ɤ\I#3C>g	N)]>@mNfSށ>W+-%[#>uS5>gI.bIa^վ]>L>|r?}dmy>Zz	><Ʌr[N>yg)↭/>S:7>`C2
>/21¾1>uu?꾸VӚB>fWIƴ_>Ae"ď$FE>:jqXD7ݾ=']>d.<,Pcq,>D*ժxF>P|j2
t>΢?쾱)><¤z>7P>ơ,u>?mK{#>ZL3b>|P1>Y_/A^>Ծ,DOP>>%69оkb>$vP>2"#X2rb>x"W|zӯ>.F쿾H
>ܬ{@>4p>C7D?s| wZp>
u?|{C>;R*>VjkP>*t2YwS9>/^SSZN>{۴ʾBc{87>1%˽¾}iD7>֔D`.>fs>̖h>kqbA$I>J|xT)9`>e.>w5'q]+hJCV>P꓾r>].gґt>wrWI>".ώl>UFN>"~L o*Y>s|A>uY쾜0]e>2#2b>:0Ѿ'-0>9HͿ>w.ooh>HXGBĈ>q؍93XQQ}>4d	'X>z⾯7G>GhOؾu>MYj>4
h¸>}xB}>T!>aT@}8XZ>JF}>鞄c>о+?Tg	>Bz^1t?-V>"mh9_UI>xpҾc8u>J]{Bh|\Bv>-CU?>{6?h>s-	x>hp>ovn>*$1y>cf
6o(NCI*mP>b$ҾefK>ިξ9-L>=/>u>DA$ב39>_e7>?q޾ſs>c$ܾz8Z]ppvAl>[EZn4>!km1>>T뾬H]>.:`>{	(>[W>Fl}'>i=9qՃ>U­Ty>kuE5ۯ)>
Hy#Cm>%M
Ҿd:>3$Q%C>YڲK)Y,>F`x]aPjp#]%>k(7J-Ͷ7>$gIϾ,qC>{5=>9D~;>ʞ@=t;>o츥yo>ƼȾ$8=>qn(u^d:ҾoC;ܢu>VI_~>qr>kYd}>0`W2W>p$d뾩Yf>+T_!6L>0$x>-iVn9m>	i>hYh>vIjF-TM;>֙m@>>Ц49>eٻ3ϾzO>*wf+Dbe>+۾/t>Dmp2$>iʌ-1XK>?eAfbCK>Gb>{ؽaH?fd>i7wk{Py?>\Lwu>gV>LޙTNH>aԸ`ޖ>_`!>0kʾk S0>ƿ6At$>}at ;삿zsl>]澓e>0"۾=>8OѾp7>&?h](\̵>0
٪>Mh'd>NоVx>;kLͦ>=*A˾o$>M$p(N۾bx[¸">1%[h}r >#\5%>>ಭеoD>yh9P2lD%>pR̦꾦ُR|A>0EE fIR>&jRf>?r
$>)ڡ>+:¼ub">ifFǾ?>d?e>l*ȥe!4>J30q>Eh>1_/H%ke\>T7=Pp>8o>:_Q$׾hE׾>;P|վ">g|	CC>KFA+>!¡r|ٞ~><T>)\rCp.M_>Z{x};>tP[檾0z#>c`aCi>5/7~
>MT
L澩8q˸O>*ˀaoYl>VsP\9>$wݾ1]>I;+2Rd>&IY¾JLv>U~Yɬ>$<>>ѾZ P~>M^Ѿ6U>^qXqa>MM14WQ>0]xLh>poʎ8L<>ԳHʒ>v(H|?z>\4@(>UnlLw^>'sz
 >ȋ΢0?2>zRWK>bMN9>нVV>#V*d,>ҵ
@~>
η
1c>Ҹ$E$-WK>Ыkhƾ|AgiP>fZ}^{l^TձO>hTn`A>5ԀiE"&(N/>wot堙M>;Վ4x(>֟;<.>ׅ׊]]>V'i[<4X>XQƆAՔw~>ԧ:=Q'ӑdW0T>UTKMW>2˲j}>E_ruĮq>82ZfA>Wz&׾3?>%v6!>mڐИGL
>лRnF>t@	IQ}>R±||	>a3֐)&Wn>?6Kf_>YB#j->7,ޗh,L>>?R>9Xa/lY>x⎾I>-poS5,>l@7s`a,+>*yŷu>A>j#>LCCJX^X	>d
Ei'_sꠥX>}UKxNo^
>mCg$gB>dģ]@/>NjvPmOX>!P1
ڽ-(>ڦoطzRt]J>g>ao3e>!(b>>
3Ib4kV>0^澦K_᠓>Ȃ}_u"X L>Ї,0*g<>*JI"	f@>OIоt!н>,&"S
>ƖྃsT3ݾO>3K@\B*~>l'0>F+/O>jK*&J>}mO5b/(㾕%Ք1>
IeBJ;/>Q!qCTR=r>lR2>q$>S?I_>)vx~p>Gž5dR>̱"f!U(zp2	>>It6>g뾟ɋ>O8w">N&.#:h>|1]>,9
>~ɖfpk>/ߙξZCƠ>Uiw9">p;$>aUC^>Lk=5>hZѠ&>t\Cz>A{6l, $]>>ZAaK>m3#0>dzXnԺ%>ޖ5`Ѿ̱8/>Uڟ|z>>1!ᾫC6'^>rg5оo@Yk>M30-7>TWLrw9N>
61[2>>]>sWY𲾟/)#>'\b$?°>N3`>p6GȾl
(d{.Y^#>F矄2F6>]'aUP>tq쾉;>SNb,$>>	p󾩥7R>s\>o94ŋ
[>}vZdF%|>>{1H{x4>)U|_҄Hz ȱ >FD *	ͮ>;=+r>w+̾Wʾ9ѿO>?J<iy4h>_N>eZ5>T{.">7n`
`_d>ij;̀>
>biu뾚-x>ۆD١%>u$ZlF>]~JQ>#-
lNΉ>h&+>GY>-L*.p$!>>oi9ھ>&v̅>-5p$Ͼĝ7j>5Yl.q>#o侠Gj>`?>5&-Ak_I>TI4%/6I7k>E,ǁ)؄>#tǬng> A#&Q>U>X{Wƌ9Eu5>p.38k
G*>BSozbԁҊF>dʾj{-_7>81-q\>(m>Ⳝ5ʾj7>83+^͟>N<Fov
ᾑ@xm>	 oo߶.>v!o4=>`Y>2x_p>}?V>?>uzg⃾]/>53
>X ϾzwɾY>uxF/5XD>M3w&t|U>IpX .>H%3C>ϝqP>xvǰ>gaJ|>a;T`>5wUffr㊈->*iG?>d>̾s4?&;>ܾ'>?K*6c2kʥZ>h
߾N@&>ڈ#	{֢Y&>vVY>Yؽ}%϶>uYCa.>/q,x4%>Vs~iw>ď7r>z1cD_!r>@;>gdZ>N,λ!>?ྥY>󞳦><]-^mTPfӾ@>
?;>\|Hvn龓'
y>8[cG8>V:fg
d⾐y׸>t61\@L>I82/a c>!D`L4E
j2W>~>DQp?9m>,|&*>&㾅  m꾐6;>Pi|iU,)>>8.9߫>3>gS6ǜ>zYCw>HlR;
n>iR7$F辤:|y>E|aMLWf&
N>d:[
Cҥs>^>bi_勞>"'o>?i~N4>~
v3nQ$-0>}&WSѯG>.>=|hm<>1c|d>}{-ٚ>WJx*>2fU4*I `R%>y]ٞ?-4?2>.fRq	>Xoξ[>Ԣ~|eW쾐t>@&Xf65$U>Ж"ɾRl4#XLgCd>aej>/f>շeܩ>rw~޾Bcy>bx>&~)E>%B-gϾ"`ʾjg;d>:1-^>('b;ᾍ-M>R!c.>֪`/	}1\z>u~20>p?>C2+8Lg>VeLؒ[C>R*[[>齅Fz%M3>V8СB;s<>%y>8Gm>`!t
v{>@99>d
k>3p:оG0M>^2(ĈD/c,gr>Nkq>qx2þ>\8,>V
-Yad>VXQ>gA>g([>|>#d5(q=;2W>DJS&`>@\[>s4 =i`s7>IRʋ21y>rf[Ht>LvҪ }(>5|7o8қLvpe>akxUE1p->L]}>w_7yQ>eiLMm,>cĔz>
N$,D^=>U
?8atf>C(ɾzV>Y0>.TpXv^>EnMSj~>r]>OV;w>pmI~kLM>T1,5){>mk$>77q$=>఺v _}!>U ~X>|i>{3`ྞVpA><TİWa>	s@&7>
0l70BF`N>kɚb\/>r$>eʝ9.me> &[FtoѤ>}+v75N7a>4q9>

wN
>3$'ffgJ>Iw"{6>_>u>s{݃L?[^Wv>4l.:N0>ߕyDhRO~6(L>%;,^S>mE>:G=>v'w'9U-WdjF˃>N.>Q8ᾢ;}>x_ab$WX3>YuXS>=9U>=`|P͢>y뾈De}^q>s@.꾠;i	>zx> 酵Hs]>7
羊JFYhd@nc>(xEq7Ul
>PR>=nbс
>׾q;xgqK>
($/>T3>G`
%j>m꾋r'Xn,#>{eÎ'>Rw>o2K03j>ܔdyQ̾[{>S% Yofi>I$>夬z8@>r*yBr%>BNɽYeI?>1m/>P2+[>oaXD{b1-f?>`aUkqs>t'>LnQ-D>ӱ+gd);쾗j8/>s_G]{0b>B8>E3
/>1>_zܰ_%s>sFre{>Oվϳhlc>D7>~6Ex=U%8ً&VC%n>(礂UG>S>ag>L%:)@`k>Qāt,>5>d{䱾>[F\pYv.j=$>v~k>'.>{a֣q>V>py=ľ^><.x0C>gO!>G`>}:n+XdؐYW>CH!h >zm3z>$KϾچc>)WZ#=徘,Ʀ>SXJ]eݾl58>VBiľ֙>O:>^6o,>3z|op?
t4>0꾟qπ>y`ߋ	>4ig|o c>^mllZQd0hj>wؤc	u^Fbi>Pp~{>æլE>sA]>ȗ53>g徟>s>َX^>Nzܾr,7>lVg`ݏ`n>3SwҾ.	ݼ>a"̂>/Aw[><&WXE05G>$気դ]E>qm9LK>g\噾Ƥ>@*#>dιh*r,T>IJEsPHw3z>__^IG!/{>)F#3>aL~>N>	;HsYfO@> ,K6苾d]d=>ԣ7G>JTx>G>3&y>|ΧZEɾX<>	⾜e!T>m->m
ksNʾw?4*>>R>p>F^s>A/쾐c[Ṯe>5߷š,‰H>
>*R*J?s4>2w&"N`QkZ>XאѾ
Ba}/P+>PQUv0)>&VS>fU辠LVJ>9ؾtK.
R
KE
>at%Yf,jeo>0^,/D>̧v>i
$f"Yt>&!jC$v&>7KW8hG=u6A>֬4!}B>i#>,8 >VE}A=x%>YccK%>eKM(><3OKibu@>]A8>yPgӐۭ>p侊>NA3R>PQ,>rw`ϧ>@dKO.>
Q>r&`cm?#>U	~?#Kz>s!+C(E>x
>(^L
BХs>.W_K;>k{񹾜+,w>ǢI^ྏ}	ھ\Ix>E=G	3F>>{2>PFr8OpPj@>,6^>eքOjD>wiɫ"bAY!!0>+{y77>}.n>=0̷<=>Wb*>cS':pv >+6'xd.A[]>%>g/#%>|2>j[-qR>6V^>ekˉd!,eRP>ֻZ辐1Ɇ)aԏ>2+8$澝 >{"y>4l-bY>y*>ia*		v> 0Xa"N*>M#y	%>xğp>3.Ne>'9m>pZ5%z>f ~,>rxz{3>s4">Dkb2-,oS>Cd(vN>u:$5d/T>a7t~ۘ1C>F%;B)ڟ>ll. >y%;	u>'hn>zB뾝xW>"\`rJAԾp$2>șʩMWE]>`O>5~q@g>քHoQ>y i>lbhv}/>Еn!3"kv>/
z>fϾg(X>R~Z>+N^ztPm>!vG]YX>sJڱh[34-J>]Vv>/ś>v"P׸O`>¹RyzȾ:]<>"]>rRlW_>#R>1'_YE>C`)t|Jv>xc>5ԀiE"&(N/>wot堙M>;Վ4x(>֟;<.>ׅ׊]]>V'i[<4X>XQƆAՔw~>ԧ:=Q'ӑdW0T>UTKMW>2˲j}>E_ruĮq>82ZfA>Wz&׾3?>%v6!>mڐИGL
>лRnF>t@	IQ}>R±||	>a3֐)&Wn>?6Kf_>YB#j->7,ޗh,L>>?R>9Xa/lY>x⎾I>-poS5,>l@7s`a,+>*yŷu>A>j#>LCCJX^X	>d
Ei'_sꠥX>}UKxNo^
>mCg$gB>dģ]@/>NjvPmOX>!P1
ڽ-(>ڦoطzRt]J>g>ao3e>!(b>>
3Ib4kV>0^澦K_᠓>Ȃ}_u"X L>Ї,0*g<>*JI"	f@>OIоt!н>,&"S
>ƖྃsT3ݾO>3K@\B*~>l'0>F+/O>jK*&J>}mO5b/(㾕%Ք1>
IeBJ;/>Q!qCTR=r>lR2>q$>S?I_>)vx~p>Gž5dR>̱"f!U(zp2	>>It6>g뾟ɋ>O8w">N&.#:h>|1]>,9
>~ɖfpk>/ߙξZCƠ>Uiw9">p;$>aUC^>Lk=5>hZѠ&>t\Cz>A{6l, $]>>ZAaK>m3#0>dzXnԺ%>ޖ5`Ѿ̱8/>Uڟ|z>>1!ᾫC6'^>rg5оo@Yk>M30-7>TWLrw9N>
61[2>>]>sWY𲾟/)#>'\b$?°>N3`>p6GȾl
(d{.Y^#>F矄2F6>]'aUP>tq쾉;>SNb,$>>	p󾩥7R>s\>o94ŋ
[>}vZdF%|>>{1H{x4>)U|_҄Hz ȱ >FD *	ͮ>;=+r>w+̾Wʾ9ѿO>?J<iy4h>_N>eZ5>T{.">7n`
`_d>ij;̀>
>biu뾚-x>ۆD١%>u$ZlF>]~JQ>#-
lNΉ>h&+>GY>-L*.p$!>>oi9ھ>&v̅>-5p$Ͼĝ7j>5Yl.q>#o侠Gj>`?>5&-Ak_I>TI4%/6I7k>E,ǁ)؄>#tǬng> A#&Q>U>X{Wƌ9Eu5>p.38k
G*>BSozbԁҊF>dʾj{-_7>81-q\>(m>Ⳝ5ʾj7>83+^͟>N<Fov
ᾑ@xm>	 oo߶.>v!o4=>`Y>2x_p>}?V>?>uzg⃾]/>53
>X ϾzwɾY>uxF/5XD>M3w&t|U>IpX .>H%3C>ϝqP>xvǰ>gaJ|>a;T`>5wUffr㊈->*iG?>d>̾s4?&;>ܾ'>?K*6c2kʥZ>h
߾N@&>ڈ#	{֢Y&>vVY>Yؽ}%϶>uYCa.>/q,x4%>Vs~iw>ď7r>z1cD_!r>@;>gdZ>N,λ!>?ྥY>󞳦><]-^mTPfӾ@>
?;>\|Hvn龓'
y>8[cG8>V:fg
d⾐y׸>t61\@L>I82/a c>!D`L4E
j2W>~>DQp?9m>,|&*>&㾅  m꾐6;>Pi|iU,)>>8.9߫>3>gS6ǜ>zYCw>HlR;
n>iR7$F辤:|y>E|aMLWf&
N>d:[
Cҥs>^>bi_勞>"'o>?i~N4>~
v3nQ$-0>}&WSѯG>.>=|hm<>1c|d>}{-ٚ>WJx*>2fU4*I `R%>y]ٞ?-4?2>.fRq	>Xoξ[>Ԣ~|eW쾐t>@&Xf65$U>Ж"ɾRl4#XLgCd>aej>/f>շeܩ>rw~޾Bcy>bx>&~)E>%B-gϾ"`ʾjg;d>:1-^>('b;ᾍ-M>R!c.>֪`/	}1\z>u~20>p?>C2+8Lg>VeLؒ[C>R*[[>齅Fz%M3>V8СB;s<>%y>8Gm>`!t
v{>@99>d
k>3p:оG0M>^2(ĈD/c,gr>Nkq>qx2þ>\8,>V
-Yad>VXQ>gA>g([>|>#d5(q=;2W>DJS&`>@\[>s4 =i`s7>IRʋ21y>rf[Ht>LvҪ }(>5|7o8қLvpe>akxUE1p->L]}>w_7yQ>eiLMm,>cĔz>
N$,D^=>U
?8atf>C(ɾzV>Y0>.TpXv^>EnMSj~>r]>OV;w>pmI~kLM>T1,5){>mk$>77q$=>఺v _}!>U ~X>|i>{3`ྞVpA><TİWa>	s@&7>
0l70BF`N>kɚb\/>r$>eʝ9.me> &[FtoѤ>}+v75N7a>4q9>

wN
>3$'ffgJ>Iw"{6>_>u>s{݃L?[^Wv>4l.:N0>ߕyDhRO~6(L>%;,^S>mE>:G=>v'w'9U-WdjF˃>N.>Q8ᾢ;}>x_ab$WX3>YuXS>=9U>=`|P͢>y뾈De}^q>s@.꾠;i	>zx> 酵Hs]>7
羊JFYhd@nc>(xEq7Ul
>PR>=nbс
>׾q;xgqK>
($/>T3>G`
%j>m꾋r'Xn,#>{eÎ'>Rw>o2K03j>ܔdyQ̾[{>S% Yofi>I$>夬z8@>r*yBr%>BNɽYeI?>1m/>P2+[>oaXD{b1-f?>`aUkqs>t'>LnQ-D>ӱ+gd);쾗j8/>s_G]{0b>B8>E3
/>1>_zܰ_%s>sFre{>Oվϳhlc>D7>~6Ex=U%8ً&VC%n>(礂UG>S>ag>L%:)@`k>Qāt,>5>d{䱾>[F\pYv.j=$>v~k>'.>{a֣q>V>py=ľ^><.x0C>gO!>G`>}:n+XdؐYW>CH!h >zm3z>$KϾچc>)WZ#=徘,Ʀ>SXJ]eݾl58>VBiľ֙>O:>^6o,>3z|op?
t4>0꾟qπ>y`ߋ	>4ig|o c>^mllZQd0hj>wؤc	u^Fbi>Pp~{>æլE>sA]>ȗ53>g徟>s>َX^>Nzܾr,7>lVg`ݏ`n>3SwҾ.	ݼ>a"̂>/Aw[><&WXE05G>$気դ]E>qm9LK>g\噾Ƥ>@*#>dιh*r,T>IJEsPHw3z>__^IG!/{>)F#3>aL~>N>	;HsYfO@> ,K6苾d]d=>ԣ7G>JTx>G>3&y>|ΧZEɾX<>	⾜e!T>m->m
ksNʾw?4*>>R>p>F^s>A/쾐c[Ṯe>5߷š,‰H>
>*R*J?s4>2w&"N`QkZ>XאѾ
Ba}/P+>PQUv0)>&VS>fU辠LVJ>9ؾtK.
R
KE
>at%Yf,jeo>0^,/D>̧v>i
$f"Yt>&!jC$v&>7KW8hG=u6A>֬4!}B>i#>,8 >VE}A=x%>YccK%>eKM(><3OKibu@>]A8>yPgӐۭ>p侊>NA3R>PQ,>rw`ϧ>@dKO.>
Q>r&`cm?#>U	~?#Kz>s!+C(E>x
>(^L
BХs>.W_K;>k{񹾜+,w>ǢI^ྏ}	ھ\Ix>E=G	3F>>{2>PFr8OpPj@>,6^>eքOjD>wiɫ"bAY!!0>+{y77>}.n>=0̷<=>Wb*>cS':pv >+6'xd.A[]>%>g/#%>|2>j[-qR>6V^>ekˉd!,eRP>ֻZ辐1Ɇ)aԏ>2+8$澝 >{"y>4l-bY>y*>ia*		v> 0Xa"N*>M#y	%>xğp>3.Ne>'9m>pZ5%z>f ~,>rxz{3>s4">Dkb2-,oS>Cd(vN>u:$5d/T>a7t~ۘ1C>F%;B)ڟ>ll. >y%;	u>'hn>zB뾝xW>"\`rJAԾp$2>șʩMWE]>`O>5~q@g>քHoQ>y i>lbhv}/>Еn!3"kv>/
z>fϾg(X>R~Z>+N^ztPm>!vG]YX>sJڱh[34-J>]Vv>/ś>v"P׸O`>¹RyzȾ:]<>"]>rRlW_>#R>1'_YE>C`)t|Jv>xc>5ԀiE"&(N/>wot堙M>;Վ4x(>֟;<.>ׅ׊]]>V'i[<4X>XQƆAՔw~>ԧ:=Q'ӑdW0T>UTKMW>2˲j}>E_ruĮq>82ZfA>Wz&׾3?>%v6!>mڐИGL
>лRnF>t@	IQ}>R±||	>a3֐)&Wn>?6Kf_>YB#j->7,ޗh,L>>?R>9Xa/lY>x⎾I>-poS5,>l@7s`a,+>*yŷu>A>j#>LCCJX^X	>d
Ei'_sꠥX>}UKxNo^
>mCg$gB>dģ]@/>NjvPmOX>!P1
ڽ-(>ڦoطzRt]J>g>ao3e>!(b>>
3Ib4kV>0^澦K_᠓>Ȃ}_u"X L>Ї,0*g<>*JI"	f@>OIоt!н>,&"S
>ƖྃsT3ݾO>3K@\B*~>l'0>F+/O>jK*&J>}mO5b/(㾕%Ք1>
IeBJ;/>Q!qCTR=r>lR2>q$>S?I_>)vx~p>Gž5dR>̱"f!U(zp2	>>It6>g뾟ɋ>O8w">N&.#:h>|1]>,9
>~ɖfpk>/ߙξZCƠ>Uiw9">p;$>aUC^>Lk=5>hZѠ&>t\Cz>A{6l, $]>>ZAaK>m3#0>dzXnԺ%>ޖ5`Ѿ̱8/>Uڟ|z>>1!ᾫC6'^>rg5оo@Yk>M30-7>TWLrw9N>
61[2>>]>sWY𲾟/)#>'\b$?°>N3`>p6GȾl
(d{.Y^#>F矄2F6>]'aUP>tq쾉;>SNb,$>>	p󾩥7R>s\>o94ŋ
[>}vZdF%|>>{1H{x4>)U|_҄Hz ȱ >FD *	ͮ>;=+r>w+̾Wʾ9ѿO>?J<iy4h>_N>eZ5>T{.">7n`
`_d>ij;̀>
>biu뾚-x>ۆD١%>u$ZlF>]~JQ>#-
lNΉ>h&+>GY>-L*.p$!>>oi9ھ>&v̅>-5p$Ͼĝ7j>5Yl.q>#o侠Gj>`?>5&-Ak_I>TI4%/6I7k>E,ǁ)؄>#tǬng> A#&Q>U>X{Wƌ9Eu5>p.38k
G*>BSozbԁҊF>dʾj{-_7>81-q\>(m>Ⳝ5ʾj7>83+^͟>N<Fov
ᾑ@xm>	 oo߶.>v!o4=>`Y>2x_p>}?V>?>uzg⃾]/>53
>X ϾzwɾY>uxF/5XD>M3w&t|U>IpX .>H%3C>ϝqP>xvǰ>gaJ|>a;T`>5wUffr㊈->*iG?>d>̾s4?&;>ܾ'>?K*6c2kʥZ>h
߾N@&>ڈ#	{֢Y&>vVY>Yؽ}%϶>uYCa.>/q,x4%>Vs~iw>ď7r>z1cD_!r>@;>gdZ>N,λ!>?ྥY>󞳦><]-^mTPfӾ@>
?;>\|Hvn龓'
y>8[cG8>V:fg
d⾐y׸>t61\@L>I82/a c>!D`L4E
j2W>~>DQp?9m>,|&*>&㾅  m꾐6;>Pi|iU,)>>8.9߫>3>gS6ǜ>zYCw>HlR;
n>iR7$F辤:|y>E|aMLWf&
N>d:[
Cҥs>^>bi_勞>"'o>?i~N4>~
v3nQ$-0>}&WSѯG>.>=|hm<>1c|d>}{-ٚ>WJx*>2fU4*I `R%>y]ٞ?-4?2>.fRq	>Xoξ[>Ԣ~|eW쾐t>@&Xf65$U>Ж"ɾRl4#XLgCd>aej>/f>շeܩ>rw~޾Bcy>bx>&~)E>%B-gϾ"`ʾjg;d>:1-^>('b;ᾍ-M>R!c.>֪`/	}1\z>u~20>p?>C2+8Lg>VeLؒ[C>R*[[>齅Fz%M3>V8СB;s<>%y>8Gm>`!t
v{>@99>d
k>3p:оG0M>^2(ĈD/c,gr>Nkq>qx2þ>\8,>V
-Yad>VXQ>gA>g([>|>#d5(q=;2W>DJS&`>@\[>s4 =i`s7>IRʋ21y>rf[Ht>LvҪ }(>5|7o8қLvpe>akxUE1p->L]}>w_7yQ>eiLMm,>cĔz>
N$,D^=>U
?8atf>C(ɾzV>Y0>.TpXv^>EnMSj~>r]>OV;w>pmI~kLM>T1,5){>mk$>77q$=>఺v _}!>U ~X>|i>{3`ྞVpA><TİWa>	s@&7>
0l70BF`N>kɚb\/>r$>eʝ9.me> &[FtoѤ>}+v75N7a>4q9>

wN
>3$'ffgJ>Iw"{6>_>u>s{݃L?[^Wv>4l.:N0>ߕyDhRO~6(L>%;,^S>mE>:G=>v'w'9U-WdjF˃>N.>Q8ᾢ;}>x_ab$WX3>YuXS>=9U>=`|P͢>y뾈De}^q>s@.꾠;i	>zx> 酵Hs]>7
羊JFYhd@nc>(xEq7Ul
>PR>=nbс
>׾q;xgqK>
($/>T3>G`
%j>m꾋r'Xn,#>{eÎ'>Rw>o2K03j>ܔdyQ̾[{>S% Yofi>I$>夬z8@>r*yBr%>BNɽYeI?>1m/>P2+[>oaXD{b1-f?>`aUkqs>t'>LnQ-D>ӱ+gd);쾗j8/>s_G]{0b>B8>E3
/>1>_zܰ_%s>sFre{>Oվϳhlc>D7>~6Ex=U%8ً&VC%n>(礂UG>S>ag>L%:)@`k>Qāt,>5>d{䱾>[F\pYv.j=$>v~k>'.>{a֣q>V>py=ľ^><.x0C>gO!>G`>}:n+XdؐYW>CH!h >zm3z>$KϾچc>)WZ#=徘,Ʀ>SXJ]eݾl58>VBiľ֙>O:>^6o,>3z|op?
t4>0꾟qπ>y`ߋ	>4ig|o c>^mllZQd0hj>wؤc	u^Fbi>Pp~{>æլE>sA]>ȗ53>g徟>s>َX^>Nzܾr,7>lVg`ݏ`n>3SwҾ.	ݼ>a"̂>/Aw[><&WXE05G>$気դ]E>qm9LK>g\噾Ƥ>@*#>dιh*r,T>IJEsPHw3z>__^IG!/{>)F#3>aL~>N>	;HsYfO@> ,K6苾d]d=>ԣ7G>JTx>G>3&y>|ΧZEɾX<>	⾜e!T>m->m
ksNʾw?4*>>R>p>F^s>A/쾐c[Ṯe>5߷š,‰H>
>*R*J?s4>2w&"N`QkZ>XאѾ
Ba}/P+>PQUv0)>&VS>fU辠LVJ>9ؾtK.
R
KE
>at%Yf,jeo>0^,/D>̧v>i
$f"Yt>&!jC$v&>7KW8hG=u6A>֬4!}B>i#>,8 >VE}A=x%>YccK%>eKM(><3OKibu@>]A8>yPgӐۭ>p侊>NA3R>PQ,>rw`ϧ>@dKO.>
Q>r&`cm?#>U	~?#Kz>s!+C(E>x
>(^L
BХs>.W_K;>k{񹾜+,w>ǢI^ྏ}	ھ\Ix>E=G	3F>>{2>PFr8OpPj@>,6^>eքOjD>wiɫ"bAY!!0>+{y77>}.n>=0̷<=>Wb*>cS':pv >+6'xd.A[]>%>g/#%>|2>j[-qR>6V^>ekˉd!,eRP>ֻZ辐1Ɇ)aԏ>2+8$澝 >{"y>4l-bY>y*>ia*		v> 0Xa"N*>M#y	%>xğp>3.Ne>'9m>pZ5%z>f ~,>rxz{3>s4">Dkb2-,oS>Cd(vN>u:$5d/T>a7t~ۘ1C>F%;B)ڟ>ll. >y%;	u>'hn>zB뾝xW>"\`rJAԾp$2>șʩMWE]>`O>5~q@g>քHoQ>y i>lbhv}/>Еn!3"kv>/
z>fϾg(X>R~Z>+N^ztPm>!vG]YX>sJڱh[34-J>]Vv>/ś>v"P׸O`>¹RyzȾ:]<>"]>rRlW_>#R>1'_YE>C`)t|Jv>xchealpy-1.10.3/healpy/data/weight_ring_n02048.fits0000664000175000017500000032560013010374155021636 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:08:01' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                24576 / width of table in bytes                        NAXIS2  =                    4 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                 2048 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                 6144 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1024D   '                                                            MAXVAL1 =   1.634779014281E-01 / maximum value of T weights                     MINVAL1 =  -6.831377479844E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1024D   '                                                            MAXVAL2 =   1.634779014281E-01 / maximum value of Q weights                     MINVAL2 =  -6.831377479844E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1024D   '                                                            MAXVAL3 =   1.634779014281E-01 / maximum value of U weights                     MINVAL3 =  -6.831377479844E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ? P?}&?q.{N]k?{:w``Q"?hd?\ٿ.u|[/nY?bߡm]3%?Gf Tq?7.YP
gc:p?R Rz:aG]gR???;1S8YF"hު?C$k%2GLL"@QK^#?9b$X=պp?5+p'@	?4j3?$ZWb?3.g),?0
,C(OyW~e?
qt?w}'sV*?'-b'ھ߲n+?Zy.u#ka,? 2yGes)0:pT̎?ɻ/wb	l?FXBmH>­6.l$?l
$(`0?Ģ?/݋ZI0?V
:)>eH?	
NhpvbmC?LRM̒}>iH_d92?
kдB}a>܇J>=b"t?rCXZ3 `	5?$Cפ?KvF-H7$ⅾj ?Rj'	 [>!J>`~"4hȒ^}?)۾ޘEO{>d`>逕x&'Z>9jH۾P.ƾT>:b}I_6k>&ľ'l>	t;ut>ӿľ9\3
>'x%(	>ث&><#iѾ>aӃ>tT>s{JDl>L$OUZо6\9<>koղپ1sC><*	IqYBEfl>pOʾ'ˢ>@>?Ɠ/<;>K}>Ca>-@jA삃2x*>S=U}ΰ{>m坊/>jMЊc>Oyh޹Ё>:ʉ0>
%@.IFlJ>S#4Kܺ>+Gl>ϘByE>QRL$j>3#>ێ.z=?jg>n{E
Oxh>^iU'hl>{=N	w@Ftwq>Mp]n	>wVg>ZA?_	^>e9ݼ{>E6>bԕ*0#>တQe"ݾҚ8{m>}Q$o5'PR*ܾ˲K$> 1*;>[V7>:ƾn4;{e>߃ydL $K>!N>뷩{7PW>;gw%׾^Q\>R!ƛ>haӤXYNF<>YyCTO*nD>"pۡ˸A>늸[roGB>mQi&؁P>h;>'C80hgX>roQyޓ2>2ҳC>Ǐ5ֺf@]%>2}]Q^\`6
uf->^о_TQ>ĩMAng>79
;>>n>q{F>c"Җ=jl>:=>sA߶+f>ԒnCbNS>jp?ns>(Ejqm},K|>)ϾNg>ZFFMC`'>*`G	qñKD>ѩϾ^>vPUY>u~8ᡆ>q#9HY>^'>VCimz>Щ2ųy[3q>T1WФbr>Zrwk$֖>h-N<
t]>m1pbglWé홙>ΪP)ȋs˨(X|>iͻ3X>s^Ѿ& T>"&17wep#>xkn7>4fCij>RqĐ\4D74>-tb'u>Wwdm%٤`>qݏKL7>{>g"|k,>ʋ4zR!Ca>+*ŝ0>"2[>X&=Xվcjk>Tj>ۯȠb>۫QI3>CRPϾ=55n>>cb(> >Ƣf&7Xi>:&>xA\Rw>&ٳU$r>_>)툑ĔŒ2\i>mx<,kܾ<& +>ZCŘ7>{gt>7,30lcҾ!>yfnBY>p4rnw`"j>߰Y5#so+>ơLP>Ҋ|U.\>o'kXG>tҖ>Nrј>A醷j9-콷R>R눪yt3>d*[{m+v>_]>-ʾRSh>64>tm1a0>ξVž'Hti>j~>S`h;*>onY0;TQa>j5r>_K_<>sq`I`2>
ߙn};>ǭdc2չ
Y04\>
௾K-"
>o\&>hkӾ,&=5>hGᾺ;&%>&>Y0ݣ>oR)&گ>vljY>uSȾFt_>򾛪û
>,پU@>SGcJc|!??>gOǾ˂[>wt>0}d>;08>>qZLPy>Dξ#{>j/1>KE꾺i0;)>Xu	["\Pd>M?QZԾ|}>6m쾑]{+/}T>Į>;K;!(M>F+sO
)>Mf.>mxO.۾@Ggv>u`EVW@xpZ>lQ>|^1xi">#;rܞ6zmx>ػΥ_~M>"U{3++>`II U>> $Y>ߌvJeD>U5av>ƏM-J}>#R9V\>v2&>g<*:Y>jb0$.Ф>@Ŧ)TY>nˋf?.>;,ʾbmڭ>v.>l	XAm(!>hx+ﾱjt>6,a>l>/G$>--eNȣ~>^|p>Z"ݰx*>=8%H1߾#&>ľxJ>ߛ/Xuk	B>[{5)>{(d^E7V3>I=꾰K>7`n>9lLY5Qg>o,[-H>kum%>j䅾tQA>j!i4߾plF><ྱl>iF'C^9l>:R㾱]N>߅8ɾ|X?H9w>:0“ts'>ÿb>erme>	-+ &@>d֡_>a,މ6Z>OWZ]]1{>k2­<>_N#b)F>ĕ#/lɾ9_>YѯL^rC_>Huc@9O0'><4lqU~>9,>_ԑ{>!my >/QAѾ4Ǧ>cT>%X|h:ϋ\>S\Dݛ?S>>\5i"UD>ol"uͻξfHZ,>lJmeM>f;쾖5XS$>Iƚy*>2%3Ѿj|>vz
!Z>>r7ߐZ+;>-~hz>>'!!>HXПޜ>Sr*~6>{tр>C_~'.v0C<>
Tྪj0_.T>D%j
R
S0s<Z>/TNS>qdwB[~yʆZI
>\M@ٺ>*G#>wj/h|
)*n>7Q꾥[p6s>wDE>ĝ&>7<>֐Ef>u{Ԉ4>k;iBH-hР>"0D詾v7:=+>3mBnmRd1JRx{~>5MSg0>٫v>[
>"m..q>9B9>r^d'5I*w>ĝb߾q	x>
>m	_>qH4kD'{>xy>_҅j>^U'nSB,kR>(21>(a#yd07%
|}>ᾥX=>//DM}v־A6>R[>=/jv>Z%ɖϠf?u>ryV9́P>L|PW>qMIoоҊ>q-Ӵ̾Z.	x>iD
>
 K|>	$`ʉ5~>@IV;R6
>O3>n ?*ֶ~t8ף>ZE^feA>$^DU?&,u>8 |o%:/~>r}g6-*>`D-x>r5@	Hlˠ>\4ȵ>3>Z>˜O&gn><])!vE>w)E>]̾?C>сFwW"8[y]>tRfô>[/]cQ??CQ7>gGw>M~5Te>n+8r9ag>gؾ`N#TE=nt_>
nMlAq"i>+ObW>r`3о8>MAF6#a>^r>N	)vr>TzTV_E>v
s\>7U88"V>`v6Z
aOkLj;>DC þ<Ѿyjv|&>JMz{~W>rngqr>f%QuU$>T۾nWe:]6Nb>|û侞v-w>>M>\:'7}v|F>2bE꾜,>BYG>|IqHs>S\8A^co>2nfy>)[PU>Y`&g ~+h>|X	F;5>{kGׁoa>CMuQ8ӎJ>m
izϨ|)n>Zj

U>i5L~ʤԾm>ᾝ  O>-
Ng(N"pkTt%>P}B8UV>T@l>[By>+M!۾KW>oU>xڀ$D^Jd	>M?١D>੃S>rھK$I>)-^.
*>m-HԽ>Լzmry>qa7y@d`>>%Mq탾Z>½y'k#r7fk+Z>kd>]')؝A>%3??tFuwm=G>\dh?>[kVh3:V?>2)Ц'lX2>X>b~is
>T:I+{>EZ>v4W^ē0>^yw91>}{>"Whsk>`~7"JjL>ow>UWJ龖&I>bI^G>B#;׏u>;5/Fua.T>J[1Y=dM K>"Os4O'>4XUQJQv>]}>RYt.{=F<>%(׾G>6pB4)n^&x쾅Lo+>FE\Tբ
>.zOe~쾊?:>ɒ9Lf%>>Axb>\jQo>q[붥bfZ.:>
s
>q4M!!>@8g>}d>:>{rsGܾYn>JEM2>s扴>?@3q*S>8.z'.%>d=>W;?>+?F7>Y/B>xP`n6>S*)dF>o@A=`f>f4aQl>,(wC)S>埀$8L#XqN`|>C۾
OQͧ>'(+վ|/E?y`jc>Z+LAH>$xjsU5h=^>fMls8>8+gY6{w>^;^}c>[aNǦ՘X}61>!h\>tY3I>M7cifGىJ>j9>eƿ>eЋc6O>9=r>;)bS>qkj{ƾk3Ja>yA󠾾+*>y;#>wRܾhgRb>Fd4H>s#+Y>}Tz]n\t9-;>98E-J>i\1$1>E{8Lw-2>72B$b>[uL|@j>,վb?J~W>=N䐾ȥ!]>3(җ+>J_AWRu>^
V|pT6+>PZT>
&3>{/߾fbo\>;d_' ,e>lSv~qElu-0Q>Zк671h>eLZDzP䏶ro>b9#E>Я*u^v|+!y>C?`yKG5>442q|WGz/>Ų72\rU>`&	jGIFF}N[>N'9tྐtH/	>wy@b:I^
>潾WDh>duڝ$? P?}&?q.{N]k?{:w``Q"?hd?\ٿ.u|[/nY?bߡm]3%?Gf Tq?7.YP
gc:p?R Rz:aG]gR???;1S8YF"hު?C$k%2GLL"@QK^#?9b$X=պp?5+p'@	?4j3?$ZWb?3.g),?0
,C(OyW~e?
qt?w}'sV*?'-b'ھ߲n+?Zy.u#ka,? 2yGes)0:pT̎?ɻ/wb	l?FXBmH>­6.l$?l
$(`0?Ģ?/݋ZI0?V
:)>eH?	
NhpvbmC?LRM̒}>iH_d92?
kдB}a>܇J>=b"t?rCXZ3 `	5?$Cפ?KvF-H7$ⅾj ?Rj'	 [>!J>`~"4hȒ^}?)۾ޘEO{>d`>逕x&'Z>9jH۾P.ƾT>:b}I_6k>&ľ'l>	t;ut>ӿľ9\3
>'x%(	>ث&><#iѾ>aӃ>tT>s{JDl>L$OUZо6\9<>koղپ1sC><*	IqYBEfl>pOʾ'ˢ>@>?Ɠ/<;>K}>Ca>-@jA삃2x*>S=U}ΰ{>m坊/>jMЊc>Oyh޹Ё>:ʉ0>
%@.IFlJ>S#4Kܺ>+Gl>ϘByE>QRL$j>3#>ێ.z=?jg>n{E
Oxh>^iU'hl>{=N	w@Ftwq>Mp]n	>wVg>ZA?_	^>e9ݼ{>E6>bԕ*0#>တQe"ݾҚ8{m>}Q$o5'PR*ܾ˲K$> 1*;>[V7>:ƾn4;{e>߃ydL $K>!N>뷩{7PW>;gw%׾^Q\>R!ƛ>haӤXYNF<>YyCTO*nD>"pۡ˸A>늸[roGB>mQi&؁P>h;>'C80hgX>roQyޓ2>2ҳC>Ǐ5ֺf@]%>2}]Q^\`6
uf->^о_TQ>ĩMAng>79
;>>n>q{F>c"Җ=jl>:=>sA߶+f>ԒnCbNS>jp?ns>(Ejqm},K|>)ϾNg>ZFFMC`'>*`G	qñKD>ѩϾ^>vPUY>u~8ᡆ>q#9HY>^'>VCimz>Щ2ųy[3q>T1WФbr>Zrwk$֖>h-N<
t]>m1pbglWé홙>ΪP)ȋs˨(X|>iͻ3X>s^Ѿ& T>"&17wep#>xkn7>4fCij>RqĐ\4D74>-tb'u>Wwdm%٤`>qݏKL7>{>g"|k,>ʋ4zR!Ca>+*ŝ0>"2[>X&=Xվcjk>Tj>ۯȠb>۫QI3>CRPϾ=55n>>cb(> >Ƣf&7Xi>:&>xA\Rw>&ٳU$r>_>)툑ĔŒ2\i>mx<,kܾ<& +>ZCŘ7>{gt>7,30lcҾ!>yfnBY>p4rnw`"j>߰Y5#so+>ơLP>Ҋ|U.\>o'kXG>tҖ>Nrј>A醷j9-콷R>R눪yt3>d*[{m+v>_]>-ʾRSh>64>tm1a0>ξVž'Hti>j~>S`h;*>onY0;TQa>j5r>_K_<>sq`I`2>
ߙn};>ǭdc2չ
Y04\>
௾K-"
>o\&>hkӾ,&=5>hGᾺ;&%>&>Y0ݣ>oR)&گ>vljY>uSȾFt_>򾛪û
>,پU@>SGcJc|!??>gOǾ˂[>wt>0}d>;08>>qZLPy>Dξ#{>j/1>KE꾺i0;)>Xu	["\Pd>M?QZԾ|}>6m쾑]{+/}T>Į>;K;!(M>F+sO
)>Mf.>mxO.۾@Ggv>u`EVW@xpZ>lQ>|^1xi">#;rܞ6zmx>ػΥ_~M>"U{3++>`II U>> $Y>ߌvJeD>U5av>ƏM-J}>#R9V\>v2&>g<*:Y>jb0$.Ф>@Ŧ)TY>nˋf?.>;,ʾbmڭ>v.>l	XAm(!>hx+ﾱjt>6,a>l>/G$>--eNȣ~>^|p>Z"ݰx*>=8%H1߾#&>ľxJ>ߛ/Xuk	B>[{5)>{(d^E7V3>I=꾰K>7`n>9lLY5Qg>o,[-H>kum%>j䅾tQA>j!i4߾plF><ྱl>iF'C^9l>:R㾱]N>߅8ɾ|X?H9w>:0“ts'>ÿb>erme>	-+ &@>d֡_>a,މ6Z>OWZ]]1{>k2­<>_N#b)F>ĕ#/lɾ9_>YѯL^rC_>Huc@9O0'><4lqU~>9,>_ԑ{>!my >/QAѾ4Ǧ>cT>%X|h:ϋ\>S\Dݛ?S>>\5i"UD>ol"uͻξfHZ,>lJmeM>f;쾖5XS$>Iƚy*>2%3Ѿj|>vz
!Z>>r7ߐZ+;>-~hz>>'!!>HXПޜ>Sr*~6>{tр>C_~'.v0C<>
Tྪj0_.T>D%j
R
S0s<Z>/TNS>qdwB[~yʆZI
>\M@ٺ>*G#>wj/h|
)*n>7Q꾥[p6s>wDE>ĝ&>7<>֐Ef>u{Ԉ4>k;iBH-hР>"0D詾v7:=+>3mBnmRd1JRx{~>5MSg0>٫v>[
>"m..q>9B9>r^d'5I*w>ĝb߾q	x>
>m	_>qH4kD'{>xy>_҅j>^U'nSB,kR>(21>(a#yd07%
|}>ᾥX=>//DM}v־A6>R[>=/jv>Z%ɖϠf?u>ryV9́P>L|PW>qMIoоҊ>q-Ӵ̾Z.	x>iD
>
 K|>	$`ʉ5~>@IV;R6
>O3>n ?*ֶ~t8ף>ZE^feA>$^DU?&,u>8 |o%:/~>r}g6-*>`D-x>r5@	Hlˠ>\4ȵ>3>Z>˜O&gn><])!vE>w)E>]̾?C>сFwW"8[y]>tRfô>[/]cQ??CQ7>gGw>M~5Te>n+8r9ag>gؾ`N#TE=nt_>
nMlAq"i>+ObW>r`3о8>MAF6#a>^r>N	)vr>TzTV_E>v
s\>7U88"V>`v6Z
aOkLj;>DC þ<Ѿyjv|&>JMz{~W>rngqr>f%QuU$>T۾nWe:]6Nb>|û侞v-w>>M>\:'7}v|F>2bE꾜,>BYG>|IqHs>S\8A^co>2nfy>)[PU>Y`&g ~+h>|X	F;5>{kGׁoa>CMuQ8ӎJ>m
izϨ|)n>Zj

U>i5L~ʤԾm>ᾝ  O>-
Ng(N"pkTt%>P}B8UV>T@l>[By>+M!۾KW>oU>xڀ$D^Jd	>M?١D>੃S>rھK$I>)-^.
*>m-HԽ>Լzmry>qa7y@d`>>%Mq탾Z>½y'k#r7fk+Z>kd>]')؝A>%3??tFuwm=G>\dh?>[kVh3:V?>2)Ц'lX2>X>b~is
>T:I+{>EZ>v4W^ē0>^yw91>}{>"Whsk>`~7"JjL>ow>UWJ龖&I>bI^G>B#;׏u>;5/Fua.T>J[1Y=dM K>"Os4O'>4XUQJQv>]}>RYt.{=F<>%(׾G>6pB4)n^&x쾅Lo+>FE\Tբ
>.zOe~쾊?:>ɒ9Lf%>>Axb>\jQo>q[붥bfZ.:>
s
>q4M!!>@8g>}d>:>{rsGܾYn>JEM2>s扴>?@3q*S>8.z'.%>d=>W;?>+?F7>Y/B>xP`n6>S*)dF>o@A=`f>f4aQl>,(wC)S>埀$8L#XqN`|>C۾
OQͧ>'(+վ|/E?y`jc>Z+LAH>$xjsU5h=^>fMls8>8+gY6{w>^;^}c>[aNǦ՘X}61>!h\>tY3I>M7cifGىJ>j9>eƿ>eЋc6O>9=r>;)bS>qkj{ƾk3Ja>yA󠾾+*>y;#>wRܾhgRb>Fd4H>s#+Y>}Tz]n\t9-;>98E-J>i\1$1>E{8Lw-2>72B$b>[uL|@j>,վb?J~W>=N䐾ȥ!]>3(җ+>J_AWRu>^
V|pT6+>PZT>
&3>{/߾fbo\>;d_' ,e>lSv~qElu-0Q>Zк671h>eLZDzP䏶ro>b9#E>Я*u^v|+!y>C?`yKG5>442q|WGz/>Ų72\rU>`&	jGIFF}N[>N'9tྐtH/	>wy@b:I^
>潾WDh>duڝ$? P?}&?q.{N]k?{:w``Q"?hd?\ٿ.u|[/nY?bߡm]3%?Gf Tq?7.YP
gc:p?R Rz:aG]gR???;1S8YF"hު?C$k%2GLL"@QK^#?9b$X=պp?5+p'@	?4j3?$ZWb?3.g),?0
,C(OyW~e?
qt?w}'sV*?'-b'ھ߲n+?Zy.u#ka,? 2yGes)0:pT̎?ɻ/wb	l?FXBmH>­6.l$?l
$(`0?Ģ?/݋ZI0?V
:)>eH?	
NhpvbmC?LRM̒}>iH_d92?
kдB}a>܇J>=b"t?rCXZ3 `	5?$Cפ?KvF-H7$ⅾj ?Rj'	 [>!J>`~"4hȒ^}?)۾ޘEO{>d`>逕x&'Z>9jH۾P.ƾT>:b}I_6k>&ľ'l>	t;ut>ӿľ9\3
>'x%(	>ث&><#iѾ>aӃ>tT>s{JDl>L$OUZо6\9<>koղپ1sC><*	IqYBEfl>pOʾ'ˢ>@>?Ɠ/<;>K}>Ca>-@jA삃2x*>S=U}ΰ{>m坊/>jMЊc>Oyh޹Ё>:ʉ0>
%@.IFlJ>S#4Kܺ>+Gl>ϘByE>QRL$j>3#>ێ.z=?jg>n{E
Oxh>^iU'hl>{=N	w@Ftwq>Mp]n	>wVg>ZA?_	^>e9ݼ{>E6>bԕ*0#>တQe"ݾҚ8{m>}Q$o5'PR*ܾ˲K$> 1*;>[V7>:ƾn4;{e>߃ydL $K>!N>뷩{7PW>;gw%׾^Q\>R!ƛ>haӤXYNF<>YyCTO*nD>"pۡ˸A>늸[roGB>mQi&؁P>h;>'C80hgX>roQyޓ2>2ҳC>Ǐ5ֺf@]%>2}]Q^\`6
uf->^о_TQ>ĩMAng>79
;>>n>q{F>c"Җ=jl>:=>sA߶+f>ԒnCbNS>jp?ns>(Ejqm},K|>)ϾNg>ZFFMC`'>*`G	qñKD>ѩϾ^>vPUY>u~8ᡆ>q#9HY>^'>VCimz>Щ2ųy[3q>T1WФbr>Zrwk$֖>h-N<
t]>m1pbglWé홙>ΪP)ȋs˨(X|>iͻ3X>s^Ѿ& T>"&17wep#>xkn7>4fCij>RqĐ\4D74>-tb'u>Wwdm%٤`>qݏKL7>{>g"|k,>ʋ4zR!Ca>+*ŝ0>"2[>X&=Xվcjk>Tj>ۯȠb>۫QI3>CRPϾ=55n>>cb(> >Ƣf&7Xi>:&>xA\Rw>&ٳU$r>_>)툑ĔŒ2\i>mx<,kܾ<& +>ZCŘ7>{gt>7,30lcҾ!>yfnBY>p4rnw`"j>߰Y5#so+>ơLP>Ҋ|U.\>o'kXG>tҖ>Nrј>A醷j9-콷R>R눪yt3>d*[{m+v>_]>-ʾRSh>64>tm1a0>ξVž'Hti>j~>S`h;*>onY0;TQa>j5r>_K_<>sq`I`2>
ߙn};>ǭdc2չ
Y04\>
௾K-"
>o\&>hkӾ,&=5>hGᾺ;&%>&>Y0ݣ>oR)&گ>vljY>uSȾFt_>򾛪û
>,پU@>SGcJc|!??>gOǾ˂[>wt>0}d>;08>>qZLPy>Dξ#{>j/1>KE꾺i0;)>Xu	["\Pd>M?QZԾ|}>6m쾑]{+/}T>Į>;K;!(M>F+sO
)>Mf.>mxO.۾@Ggv>u`EVW@xpZ>lQ>|^1xi">#;rܞ6zmx>ػΥ_~M>"U{3++>`II U>> $Y>ߌvJeD>U5av>ƏM-J}>#R9V\>v2&>g<*:Y>jb0$.Ф>@Ŧ)TY>nˋf?.>;,ʾbmڭ>v.>l	XAm(!>hx+ﾱjt>6,a>l>/G$>--eNȣ~>^|p>Z"ݰx*>=8%H1߾#&>ľxJ>ߛ/Xuk	B>[{5)>{(d^E7V3>I=꾰K>7`n>9lLY5Qg>o,[-H>kum%>j䅾tQA>j!i4߾plF><ྱl>iF'C^9l>:R㾱]N>߅8ɾ|X?H9w>:0“ts'>ÿb>erme>	-+ &@>d֡_>a,މ6Z>OWZ]]1{>k2­<>_N#b)F>ĕ#/lɾ9_>YѯL^rC_>Huc@9O0'><4lqU~>9,>_ԑ{>!my >/QAѾ4Ǧ>cT>%X|h:ϋ\>S\Dݛ?S>>\5i"UD>ol"uͻξfHZ,>lJmeM>f;쾖5XS$>Iƚy*>2%3Ѿj|>vz
!Z>>r7ߐZ+;>-~hz>>'!!>HXПޜ>Sr*~6>{tр>C_~'.v0C<>
Tྪj0_.T>D%j
R
S0s<Z>/TNS>qdwB[~yʆZI
>\M@ٺ>*G#>wj/h|
)*n>7Q꾥[p6s>wDE>ĝ&>7<>֐Ef>u{Ԉ4>k;iBH-hР>"0D詾v7:=+>3mBnmRd1JRx{~>5MSg0>٫v>[
>"m..q>9B9>r^d'5I*w>ĝb߾q	x>
>m	_>qH4kD'{>xy>_҅j>^U'nSB,kR>(21>(a#yd07%
|}>ᾥX=>//DM}v־A6>R[>=/jv>Z%ɖϠf?u>ryV9́P>L|PW>qMIoоҊ>q-Ӵ̾Z.	x>iD
>
 K|>	$`ʉ5~>@IV;R6
>O3>n ?*ֶ~t8ף>ZE^feA>$^DU?&,u>8 |o%:/~>r}g6-*>`D-x>r5@	Hlˠ>\4ȵ>3>Z>˜O&gn><])!vE>w)E>]̾?C>сFwW"8[y]>tRfô>[/]cQ??CQ7>gGw>M~5Te>n+8r9ag>gؾ`N#TE=nt_>
nMlAq"i>+ObW>r`3о8>MAF6#a>^r>N	)vr>TzTV_E>v
s\>7U88"V>`v6Z
aOkLj;>DC þ<Ѿyjv|&>JMz{~W>rngqr>f%QuU$>T۾nWe:]6Nb>|û侞v-w>>M>\:'7}v|F>2bE꾜,>BYG>|IqHs>S\8A^co>2nfy>)[PU>Y`&g ~+h>|X	F;5>{kGׁoa>CMuQ8ӎJ>m
izϨ|)n>Zj

U>i5L~ʤԾm>ᾝ  O>-
Ng(N"pkTt%>P}B8UV>T@l>[By>+M!۾KW>oU>xڀ$D^Jd	>M?١D>੃S>rھK$I>)-^.
*>m-HԽ>Լzmry>qa7y@d`>>%Mq탾Z>½y'k#r7fk+Z>kd>]')؝A>%3??tFuwm=G>\dh?>[kVh3:V?>2)Ц'lX2>X>b~is
>T:I+{>EZ>v4W^ē0>^yw91>}{>"Whsk>`~7"JjL>ow>UWJ龖&I>bI^G>B#;׏u>;5/Fua.T>J[1Y=dM K>"Os4O'>4XUQJQv>]}>RYt.{=F<>%(׾G>6pB4)n^&x쾅Lo+>FE\Tբ
>.zOe~쾊?:>ɒ9Lf%>>Axb>\jQo>q[붥bfZ.:>
s
>q4M!!>@8g>}d>:>{rsGܾYn>JEM2>s扴>?@3q*S>8.z'.%>d=>W;?>+?F7>Y/B>xP`n6>S*)dF>o@A=`f>f4aQl>,(wC)S>埀$8L#XqN`|>C۾
OQͧ>'(+վ|/E?y`jc>Z+LAH>$xjsU5h=^>fMls8>8+gY6{w>^;^}c>[aNǦ՘X}61>!h\>tY3I>M7cifGىJ>j9>eƿ>eЋc6O>9=r>;)bS>qkj{ƾk3Ja>yA󠾾+*>y;#>wRܾhgRb>Fd4H>s#+Y>}Tz]n\t9-;>98E-J>i\1$1>E{8Lw-2>72B$b>[uL|@j>,վb?J~W>=N䐾ȥ!]>3(җ+>J_AWRu>^
V|pT6+>PZT>
&3>{/߾fbo\>;d_' ,e>lSv~qElu-0Q>Zк671h>eLZDzP䏶ro>b9#E>Я*u^v|+!y>C?`yKG5>442q|WGz/>Ų72\rU>`&	jGIFF}N[>N'9tྐtH/	>wy@b:I^
>潾WDh>duڝ$W9ygkt>(V񆾐.ΰ#>h־C`0pp؛+Ύ>d*c!Y->)]=M^礄 >j;~`L*>i/>MߑDK~͐>Co'kv>(MZ>Yв6^v|>V:	֐T>~}KC>a5#L^>cU=\2k#>|!|_>f*F྆K>6~]q_]ѹx%>y0]8f>j \оU>&2>Dssu>wy3c>m4/AsZ>h>{>uw>p[OOn>n>spս.3~>t'3i>qx%5TL>%Rbf̪$g>rd>rUDRY͍X>Ւ~s$)>q"TxS>sqprm$oI>6}Ͼ0sPo>o7y>t~xmTھq4D>,[˔>mq)`>u>הqhA>Eˈ1Y–>l5Z@>uvdR2a>Fc$Ⱦ>j篹>u/#L0Skyl>7= n\xQ>i뉳
>umQ"㾈Y>}"4P>iH*2{S>u˝,>Iw.jJ?>ho_sc>ut"lNMjd>V[^g,G>hZO*>u+>><>pE
^>iKCz>t(z>n(`8>i*,IS>sOp><,>A|I>jCOo>smwI B>J^ľ"^r>l>r*C_~&w>
.ER؍>my >q+eB.
>!3C.w>o1}U>o,$o)>̰+5\P>pȒ>mM@k7>?q鷋߾PM>qTZO>j-]ΧhR>@u$HU>rzCX2>f{Hs$Y|>?Vʁ{>t,ZjR>c/>KSL!ܾdp>uP*+>_-?Aﾁ&t>Q^6OCȠ>w)!>W,įdEN>|B+
>xț->N@ZE~JfmI>s6!+[ >zL>9Y!|>wuHa9>{(u
'fszpm><+g>}Zp8T%I)o?ƾx8[2>/O	y6&nP>~|Ҵ5aVƔums^l>l1;|o?.~>G]׾`!n^.r8ۭn>n1mt>
@an*e{!p3 ]>/䐛}JNj:>DFžk.t!+Ⱦj\b>Ox>w;pMYd^aɸ>lh0Ir>>Zs?{[Z>~QQ86Dk:u>/?Vud8`M9'>{6zm>GM࠾xOİ팇
˱/(>x&0-ЇD>a[,5zx>J',%f>uceVK3{>%_}93Y\>[4v>qmy0(2C">zNp}>d[d>lFE^ o>P~أ>k@|t>e'煵j#\`>7QD8=/l>qXƣ>ZrO<|#>qFqPt>tY밮\>D+lxћ+~Q>
Y:}@@~>wO91E#u2`=v2>(% `.G6/>z=MWdqJOO>V(Xv^>}jEc݋jFdPr>lѧ?D>?Tε>Ëkasa`L>|SϠ+~/N>fV| q5P029>xwNCwhD>}{Au9f؎>z?>t|N>%ܾ]_>"ny]T>y	6>T,Y>p>s/Kz>U;D|êQT>cOZ0>h!v}v'>:1Ž(~b->lC;/>]z+>˵gwXvbw>r`r>BM;ΝvG'[>'LuCA>vK&F>~#mqph>{iZp-0>y,S_<9ir>|/etɘ>|`fi<GϾ_+.>yjP%ؾxE>b5υq5|XDP!>uHcROZǛe>Rsuh|5>FHN>p~G;oġ>uھyB^">`C·9,>g.Ӂ{(1U>KB!|] H>jq>XtSwM~@]>4NlW~_*'>q>!`_ur?d>~mP,e%>v+ύFyXT/*[jkr=΅>{,zYȾ G>y
&dC3ھ`wx >xCv%߮>|vr5Fo7?o[LC݁Ay>sM~{i>~D9Xi榾t3o>JCŷ>m!,'c6ξ{x%g>ޗo6xBM>w>b`>a@EwŢ>~ZO劎{:[>lS`:>H}/'\~so3n>}2T,}}
>s<5DGNel{C|l>z[嫾}X>wGpmlaJ0`L'>v=d}K!>z[ħKhlVϧC>Fw>rE+p{fR>|NE璎s6Z>Nr>i&>dy!k>|uw4%XV>c|kH>[u(ڥKv>|Y/UzTE>n|4@'|9># p3R[;>zZQ<{Gl>s~V%|<ھdAŦ>wT	{'wV>wXξg8(+P2k>rtlؾz)>z'EA>j`
[x,d>{0\uK^ĺ>`X~>\Kvt9
=>zMsxpuH0>lmkpb>"}9nE/`>xj`z$mHJJR>s
0Wb\:>u0$ʾzB>vT{|g"ME>piK̗px%1>yZ79q9ge>O,|^>e>PuV.^>y>PuUkÁX>dbR>P@@-)q|B>x̾wٺ>o~GީDdf~j>u~x^>t&xla|6-kT*r>q[x5:p>w)˾merU>;"lI>g2uo	ϱO>x7X:ksH`)>`|=La>Ul$|q.#F>w(˔vSts>l,1Vg6tjΝdg;"Fd,>t`?wчv>r^ `ރT#7h>pTIv_>uȾ8k")o>:k7/>f^2bQt)>v{uMr~܁>`>Qӑo
 f>v
 Nuhh~>l&S6/C0cH>s,M^vTv(>r_툾aexJj7>mESu$@y>u%1V"Mm+4=#>LH92>a臻6q		>uLDrn`J>c
><圦};i~;>t
"ǼtJ}>n`%-TFƿmZϼs2>pX!'t8>s\@Sf]ǧ>I>e$A?rގ3>t[p<љE>[N>QS$Rlji>sXgsKb2>inC>[a$7,>pjtcS>q&~|&b(V=*g8 `>h0r
j>seQl|Dq>>T.>>Wfʾm i@_>s@󋎾q|E>fb6729#Hbe#".M>p7_s'"d>oGb_%4T<~D`>hD.>q娧>rY[Ⱦjh>QVv^>>W)7l>raszXpJg>e5/z9pOa.>ox^r<9>nP2/^lvA50|Q>fl9۾p!źB>q(j4x>R/e(b>S<ܾjCJpV>q\5puJ)>erJ*;=]pr~x@>m '†,qX#h>S>n7̾`y
(43%_>c#3)o>(
>p-w~þjO>>W@Bdw>I3Vڹmf_/>pgp2?2p>g3p5OM^ ~UTY>iC1pKiSu>nq>
c;4v>8ZQ 7$>\lmNkC$>p1R+$l*fu>_-){>>YfaM#j>l.Aoq:)>i_X{faAr>c"mC>nbjz3kg )T>R>N)yzeޝcɂ>mB/~mgZM3>dZG輠rTr=>goDTzmki>k]Yb}ff>9Ŧ.3>X?i\ľh>mjwhХP;>_QWШ"ǒ\rW}>iks;mKlr4>hsVA[dȽ%>-_>_iQ>lLX0[gkCۛ>WX>8SK/ƾa.Dm>jFEcľl!yU>f3i\TWs7Be՟>b!TejkIzC>k	&3e&D>Q&C>G$F;UYbnhq>jp2rj;fKz>dɑ\N/Jc+j_QJ>j\~ic.ݪ>KGޔy>M^Uctò>j@&;iCZ\>bhjH@QN}>ci_i'nb(y4'>G#r>Oc@nO>iiX*v{>aF΁G6hUOjd:>cosL'i5%>i?a>GOc>N= @|c.#â>iseZiF(i>b:sW(Iv¸L.F>bΩBliye>il|qb>L5+>J#^bO:C>iQ`}־i>cR(OMF}">a1#i#"5>>j
Jud(C>RS_>B	Fv`,TD>hr섾j||2%>e-K8TSEI9x&>_ƿ]hpn
>j?f\{-a>W
5N>)j]@=T">h=k}@>gǍ[~=Ӱbi>Z}gN>kJ	!iaF>_L3qfW->fk߾ljr>jfTźb[>C2̎l>S~f/͂>lźl3
`x>d~ܣNuPM:>d߾l1K>m6v9ɾgI% >U"Pp>CN+]jcl,o1U*>iXx+o[@=x**>`TDD l7uii>p>!M	l1N<>auP1.z\!aUT>kILbvGpǛ5>ol-gep>>G+ 
>VliD>qUF޾q
P~>ik񵁾T,`MU#K>g?"۾q(Du>rGmM>^V>7#ۗ!dpv>p캾sR-k>p[Qd
 >2lΧ>a	#Zp@;7g>tfp7Ds	@?>j~H#PW
?X1
P_>n7t+R/p8~>]fAE>J>!lھj˼0,>tgYh%ꆾv=x%>s.X]f*zn>b>f'־s>w@WbvL7>mT5PQ~f'ž_;P1]>rKe-x]y@>x]	rU0>a	˦>P-p>xCIwzX->v[Cj2$>>>i֏w>>|HyWzB^%>rr(W3a/^(>u!^}Y|44]>}7"wd70>gv0s%>Irq->|Yӫx}2$>|̱rDS*>I^8h>irzg
hn>G&͓
>xϗIeEŘA[
rS>>vզӡc>a-V>ri}-{#q[&><&>$6#@{h%>cLZ$/>c/-i{(T>-я۾RoS>ȱ[tT"B>u{bJ݌>Tyď>~'Rce>rBhs?>9E/Z>II9b>w? !>'U
y$vw>0qJA%m|>;~X1>jM(>kNNkȹcu>\ګF	>>VwI}Rnu>4`5>{Ƿg8Z>.w]`>!µsaΡѾi\ >f|rP?9>ޭ};qmAE>,
߾[
|k>܉>@2|ӾYX>_nI$R>~8m>_]PvtNN>(nj4`>tRuxɝ0>r2>y,oכB>DP羘ği>
DԾ;>OD祥>O.N>zc{'42o>`\o{ǾMLnϾl>?ˌ@bҾ8Ѹ<>9_?)sB>@8/|RdZ}/gZV>_&%+owDy>_y\d>g-I:qAщ>`qXF,W>#˾x0>ߚ=6>eC-tܾɭ>E^{
~>[&?>"M>m2
쭛>:2AGǤ>to2B!> ,>YQD:>Ϸ=>Zd
^Y>mgY>KB>H뾼Ien}>A.Yƃv}4\>'| %'>TXKC4>?*7C64)2,>r=V~O%4DƾW9ygkt>(V񆾐.ΰ#>h־C`0pp؛+Ύ>d*c!Y->)]=M^礄 >j;~`L*>i/>MߑDK~͐>Co'kv>(MZ>Yв6^v|>V:	֐T>~}KC>a5#L^>cU=\2k#>|!|_>f*F྆K>6~]q_]ѹx%>y0]8f>j \оU>&2>Dssu>wy3c>m4/AsZ>h>{>uw>p[OOn>n>spս.3~>t'3i>qx%5TL>%Rbf̪$g>rd>rUDRY͍X>Ւ~s$)>q"TxS>sqprm$oI>6}Ͼ0sPo>o7y>t~xmTھq4D>,[˔>mq)`>u>הqhA>Eˈ1Y–>l5Z@>uvdR2a>Fc$Ⱦ>j篹>u/#L0Skyl>7= n\xQ>i뉳
>umQ"㾈Y>}"4P>iH*2{S>u˝,>Iw.jJ?>ho_sc>ut"lNMjd>V[^g,G>hZO*>u+>><>pE
^>iKCz>t(z>n(`8>i*,IS>sOp><,>A|I>jCOo>smwI B>J^ľ"^r>l>r*C_~&w>
.ER؍>my >q+eB.
>!3C.w>o1}U>o,$o)>̰+5\P>pȒ>mM@k7>?q鷋߾PM>qTZO>j-]ΧhR>@u$HU>rzCX2>f{Hs$Y|>?Vʁ{>t,ZjR>c/>KSL!ܾdp>uP*+>_-?Aﾁ&t>Q^6OCȠ>w)!>W,įdEN>|B+
>xț->N@ZE~JfmI>s6!+[ >zL>9Y!|>wuHa9>{(u
'fszpm><+g>}Zp8T%I)o?ƾx8[2>/O	y6&nP>~|Ҵ5aVƔums^l>l1;|o?.~>G]׾`!n^.r8ۭn>n1mt>
@an*e{!p3 ]>/䐛}JNj:>DFžk.t!+Ⱦj\b>Ox>w;pMYd^aɸ>lh0Ir>>Zs?{[Z>~QQ86Dk:u>/?Vud8`M9'>{6zm>GM࠾xOİ팇
˱/(>x&0-ЇD>a[,5zx>J',%f>uceVK3{>%_}93Y\>[4v>qmy0(2C">zNp}>d[d>lFE^ o>P~أ>k@|t>e'煵j#\`>7QD8=/l>qXƣ>ZrO<|#>qFqPt>tY밮\>D+lxћ+~Q>
Y:}@@~>wO91E#u2`=v2>(% `.G6/>z=MWdqJOO>V(Xv^>}jEc݋jFdPr>lѧ?D>?Tε>Ëkasa`L>|SϠ+~/N>fV| q5P029>xwNCwhD>}{Au9f؎>z?>t|N>%ܾ]_>"ny]T>y	6>T,Y>p>s/Kz>U;D|êQT>cOZ0>h!v}v'>:1Ž(~b->lC;/>]z+>˵gwXvbw>r`r>BM;ΝvG'[>'LuCA>vK&F>~#mqph>{iZp-0>y,S_<9ir>|/etɘ>|`fi<GϾ_+.>yjP%ؾxE>b5υq5|XDP!>uHcROZǛe>Rsuh|5>FHN>p~G;oġ>uھyB^">`C·9,>g.Ӂ{(1U>KB!|] H>jq>XtSwM~@]>4NlW~_*'>q>!`_ur?d>~mP,e%>v+ύFyXT/*[jkr=΅>{,zYȾ G>y
&dC3ھ`wx >xCv%߮>|vr5Fo7?o[LC݁Ay>sM~{i>~D9Xi榾t3o>JCŷ>m!,'c6ξ{x%g>ޗo6xBM>w>b`>a@EwŢ>~ZO劎{:[>lS`:>H}/'\~so3n>}2T,}}
>s<5DGNel{C|l>z[嫾}X>wGpmlaJ0`L'>v=d}K!>z[ħKhlVϧC>Fw>rE+p{fR>|NE璎s6Z>Nr>i&>dy!k>|uw4%XV>c|kH>[u(ڥKv>|Y/UzTE>n|4@'|9># p3R[;>zZQ<{Gl>s~V%|<ھdAŦ>wT	{'wV>wXξg8(+P2k>rtlؾz)>z'EA>j`
[x,d>{0\uK^ĺ>`X~>\Kvt9
=>zMsxpuH0>lmkpb>"}9nE/`>xj`z$mHJJR>s
0Wb\:>u0$ʾzB>vT{|g"ME>piK̗px%1>yZ79q9ge>O,|^>e>PuV.^>y>PuUkÁX>dbR>P@@-)q|B>x̾wٺ>o~GީDdf~j>u~x^>t&xla|6-kT*r>q[x5:p>w)˾merU>;"lI>g2uo	ϱO>x7X:ksH`)>`|=La>Ul$|q.#F>w(˔vSts>l,1Vg6tjΝdg;"Fd,>t`?wчv>r^ `ރT#7h>pTIv_>uȾ8k")o>:k7/>f^2bQt)>v{uMr~܁>`>Qӑo
 f>v
 Nuhh~>l&S6/C0cH>s,M^vTv(>r_툾aexJj7>mESu$@y>u%1V"Mm+4=#>LH92>a臻6q		>uLDrn`J>c
><圦};i~;>t
"ǼtJ}>n`%-TFƿmZϼs2>pX!'t8>s\@Sf]ǧ>I>e$A?rގ3>t[p<љE>[N>QS$Rlji>sXgsKb2>inC>[a$7,>pjtcS>q&~|&b(V=*g8 `>h0r
j>seQl|Dq>>T.>>Wfʾm i@_>s@󋎾q|E>fb6729#Hbe#".M>p7_s'"d>oGb_%4T<~D`>hD.>q娧>rY[Ⱦjh>QVv^>>W)7l>raszXpJg>e5/z9pOa.>ox^r<9>nP2/^lvA50|Q>fl9۾p!źB>q(j4x>R/e(b>S<ܾjCJpV>q\5puJ)>erJ*;=]pr~x@>m '†,qX#h>S>n7̾`y
(43%_>c#3)o>(
>p-w~þjO>>W@Bdw>I3Vڹmf_/>pgp2?2p>g3p5OM^ ~UTY>iC1pKiSu>nq>
c;4v>8ZQ 7$>\lmNkC$>p1R+$l*fu>_-){>>YfaM#j>l.Aoq:)>i_X{faAr>c"mC>nbjz3kg )T>R>N)yzeޝcɂ>mB/~mgZM3>dZG輠rTr=>goDTzmki>k]Yb}ff>9Ŧ.3>X?i\ľh>mjwhХP;>_QWШ"ǒ\rW}>iks;mKlr4>hsVA[dȽ%>-_>_iQ>lLX0[gkCۛ>WX>8SK/ƾa.Dm>jFEcľl!yU>f3i\TWs7Be՟>b!TejkIzC>k	&3e&D>Q&C>G$F;UYbnhq>jp2rj;fKz>dɑ\N/Jc+j_QJ>j\~ic.ݪ>KGޔy>M^Uctò>j@&;iCZ\>bhjH@QN}>ci_i'nb(y4'>G#r>Oc@nO>iiX*v{>aF΁G6hUOjd:>cosL'i5%>i?a>GOc>N= @|c.#â>iseZiF(i>b:sW(Iv¸L.F>bΩBliye>il|qb>L5+>J#^bO:C>iQ`}־i>cR(OMF}">a1#i#"5>>j
Jud(C>RS_>B	Fv`,TD>hr섾j||2%>e-K8TSEI9x&>_ƿ]hpn
>j?f\{-a>W
5N>)j]@=T">h=k}@>gǍ[~=Ӱbi>Z}gN>kJ	!iaF>_L3qfW->fk߾ljr>jfTźb[>C2̎l>S~f/͂>lźl3
`x>d~ܣNuPM:>d߾l1K>m6v9ɾgI% >U"Pp>CN+]jcl,o1U*>iXx+o[@=x**>`TDD l7uii>p>!M	l1N<>auP1.z\!aUT>kILbvGpǛ5>ol-gep>>G+ 
>VliD>qUF޾q
P~>ik񵁾T,`MU#K>g?"۾q(Du>rGmM>^V>7#ۗ!dpv>p캾sR-k>p[Qd
 >2lΧ>a	#Zp@;7g>tfp7Ds	@?>j~H#PW
?X1
P_>n7t+R/p8~>]fAE>J>!lھj˼0,>tgYh%ꆾv=x%>s.X]f*zn>b>f'־s>w@WbvL7>mT5PQ~f'ž_;P1]>rKe-x]y@>x]	rU0>a	˦>P-p>xCIwzX->v[Cj2$>>>i֏w>>|HyWzB^%>rr(W3a/^(>u!^}Y|44]>}7"wd70>gv0s%>Irq->|Yӫx}2$>|̱rDS*>I^8h>irzg
hn>G&͓
>xϗIeEŘA[
rS>>vզӡc>a-V>ri}-{#q[&><&>$6#@{h%>cLZ$/>c/-i{(T>-я۾RoS>ȱ[tT"B>u{bJ݌>Tyď>~'Rce>rBhs?>9E/Z>II9b>w? !>'U
y$vw>0qJA%m|>;~X1>jM(>kNNkȹcu>\ګF	>>VwI}Rnu>4`5>{Ƿg8Z>.w]`>!µsaΡѾi\ >f|rP?9>ޭ};qmAE>,
߾[
|k>܉>@2|ӾYX>_nI$R>~8m>_]PvtNN>(nj4`>tRuxɝ0>r2>y,oכB>DP羘ği>
DԾ;>OD祥>O.N>zc{'42o>`\o{ǾMLnϾl>?ˌ@bҾ8Ѹ<>9_?)sB>@8/|RdZ}/gZV>_&%+owDy>_y\d>g-I:qAщ>`qXF,W>#˾x0>ߚ=6>eC-tܾɭ>E^{
~>[&?>"M>m2
쭛>:2AGǤ>to2B!> ,>YQD:>Ϸ=>Zd
^Y>mgY>KB>H뾼Ien}>A.Yƃv}4\>'| %'>TXKC4>?*7C64)2,>r=V~O%4DƾW9ygkt>(V񆾐.ΰ#>h־C`0pp؛+Ύ>d*c!Y->)]=M^礄 >j;~`L*>i/>MߑDK~͐>Co'kv>(MZ>Yв6^v|>V:	֐T>~}KC>a5#L^>cU=\2k#>|!|_>f*F྆K>6~]q_]ѹx%>y0]8f>j \оU>&2>Dssu>wy3c>m4/AsZ>h>{>uw>p[OOn>n>spս.3~>t'3i>qx%5TL>%Rbf̪$g>rd>rUDRY͍X>Ւ~s$)>q"TxS>sqprm$oI>6}Ͼ0sPo>o7y>t~xmTھq4D>,[˔>mq)`>u>הqhA>Eˈ1Y–>l5Z@>uvdR2a>Fc$Ⱦ>j篹>u/#L0Skyl>7= n\xQ>i뉳
>umQ"㾈Y>}"4P>iH*2{S>u˝,>Iw.jJ?>ho_sc>ut"lNMjd>V[^g,G>hZO*>u+>><>pE
^>iKCz>t(z>n(`8>i*,IS>sOp><,>A|I>jCOo>smwI B>J^ľ"^r>l>r*C_~&w>
.ER؍>my >q+eB.
>!3C.w>o1}U>o,$o)>̰+5\P>pȒ>mM@k7>?q鷋߾PM>qTZO>j-]ΧhR>@u$HU>rzCX2>f{Hs$Y|>?Vʁ{>t,ZjR>c/>KSL!ܾdp>uP*+>_-?Aﾁ&t>Q^6OCȠ>w)!>W,įdEN>|B+
>xț->N@ZE~JfmI>s6!+[ >zL>9Y!|>wuHa9>{(u
'fszpm><+g>}Zp8T%I)o?ƾx8[2>/O	y6&nP>~|Ҵ5aVƔums^l>l1;|o?.~>G]׾`!n^.r8ۭn>n1mt>
@an*e{!p3 ]>/䐛}JNj:>DFžk.t!+Ⱦj\b>Ox>w;pMYd^aɸ>lh0Ir>>Zs?{[Z>~QQ86Dk:u>/?Vud8`M9'>{6zm>GM࠾xOİ팇
˱/(>x&0-ЇD>a[,5zx>J',%f>uceVK3{>%_}93Y\>[4v>qmy0(2C">zNp}>d[d>lFE^ o>P~أ>k@|t>e'煵j#\`>7QD8=/l>qXƣ>ZrO<|#>qFqPt>tY밮\>D+lxћ+~Q>
Y:}@@~>wO91E#u2`=v2>(% `.G6/>z=MWdqJOO>V(Xv^>}jEc݋jFdPr>lѧ?D>?Tε>Ëkasa`L>|SϠ+~/N>fV| q5P029>xwNCwhD>}{Au9f؎>z?>t|N>%ܾ]_>"ny]T>y	6>T,Y>p>s/Kz>U;D|êQT>cOZ0>h!v}v'>:1Ž(~b->lC;/>]z+>˵gwXvbw>r`r>BM;ΝvG'[>'LuCA>vK&F>~#mqph>{iZp-0>y,S_<9ir>|/etɘ>|`fi<GϾ_+.>yjP%ؾxE>b5υq5|XDP!>uHcROZǛe>Rsuh|5>FHN>p~G;oġ>uھyB^">`C·9,>g.Ӂ{(1U>KB!|] H>jq>XtSwM~@]>4NlW~_*'>q>!`_ur?d>~mP,e%>v+ύFyXT/*[jkr=΅>{,zYȾ G>y
&dC3ھ`wx >xCv%߮>|vr5Fo7?o[LC݁Ay>sM~{i>~D9Xi榾t3o>JCŷ>m!,'c6ξ{x%g>ޗo6xBM>w>b`>a@EwŢ>~ZO劎{:[>lS`:>H}/'\~so3n>}2T,}}
>s<5DGNel{C|l>z[嫾}X>wGpmlaJ0`L'>v=d}K!>z[ħKhlVϧC>Fw>rE+p{fR>|NE璎s6Z>Nr>i&>dy!k>|uw4%XV>c|kH>[u(ڥKv>|Y/UzTE>n|4@'|9># p3R[;>zZQ<{Gl>s~V%|<ھdAŦ>wT	{'wV>wXξg8(+P2k>rtlؾz)>z'EA>j`
[x,d>{0\uK^ĺ>`X~>\Kvt9
=>zMsxpuH0>lmkpb>"}9nE/`>xj`z$mHJJR>s
0Wb\:>u0$ʾzB>vT{|g"ME>piK̗px%1>yZ79q9ge>O,|^>e>PuV.^>y>PuUkÁX>dbR>P@@-)q|B>x̾wٺ>o~GީDdf~j>u~x^>t&xla|6-kT*r>q[x5:p>w)˾merU>;"lI>g2uo	ϱO>x7X:ksH`)>`|=La>Ul$|q.#F>w(˔vSts>l,1Vg6tjΝdg;"Fd,>t`?wчv>r^ `ރT#7h>pTIv_>uȾ8k")o>:k7/>f^2bQt)>v{uMr~܁>`>Qӑo
 f>v
 Nuhh~>l&S6/C0cH>s,M^vTv(>r_툾aexJj7>mESu$@y>u%1V"Mm+4=#>LH92>a臻6q		>uLDrn`J>c
><圦};i~;>t
"ǼtJ}>n`%-TFƿmZϼs2>pX!'t8>s\@Sf]ǧ>I>e$A?rގ3>t[p<љE>[N>QS$Rlji>sXgsKb2>inC>[a$7,>pjtcS>q&~|&b(V=*g8 `>h0r
j>seQl|Dq>>T.>>Wfʾm i@_>s@󋎾q|E>fb6729#Hbe#".M>p7_s'"d>oGb_%4T<~D`>hD.>q娧>rY[Ⱦjh>QVv^>>W)7l>raszXpJg>e5/z9pOa.>ox^r<9>nP2/^lvA50|Q>fl9۾p!źB>q(j4x>R/e(b>S<ܾjCJpV>q\5puJ)>erJ*;=]pr~x@>m '†,qX#h>S>n7̾`y
(43%_>c#3)o>(
>p-w~þjO>>W@Bdw>I3Vڹmf_/>pgp2?2p>g3p5OM^ ~UTY>iC1pKiSu>nq>
c;4v>8ZQ 7$>\lmNkC$>p1R+$l*fu>_-){>>YfaM#j>l.Aoq:)>i_X{faAr>c"mC>nbjz3kg )T>R>N)yzeޝcɂ>mB/~mgZM3>dZG輠rTr=>goDTzmki>k]Yb}ff>9Ŧ.3>X?i\ľh>mjwhХP;>_QWШ"ǒ\rW}>iks;mKlr4>hsVA[dȽ%>-_>_iQ>lLX0[gkCۛ>WX>8SK/ƾa.Dm>jFEcľl!yU>f3i\TWs7Be՟>b!TejkIzC>k	&3e&D>Q&C>G$F;UYbnhq>jp2rj;fKz>dɑ\N/Jc+j_QJ>j\~ic.ݪ>KGޔy>M^Uctò>j@&;iCZ\>bhjH@QN}>ci_i'nb(y4'>G#r>Oc@nO>iiX*v{>aF΁G6hUOjd:>cosL'i5%>i?a>GOc>N= @|c.#â>iseZiF(i>b:sW(Iv¸L.F>bΩBliye>il|qb>L5+>J#^bO:C>iQ`}־i>cR(OMF}">a1#i#"5>>j
Jud(C>RS_>B	Fv`,TD>hr섾j||2%>e-K8TSEI9x&>_ƿ]hpn
>j?f\{-a>W
5N>)j]@=T">h=k}@>gǍ[~=Ӱbi>Z}gN>kJ	!iaF>_L3qfW->fk߾ljr>jfTźb[>C2̎l>S~f/͂>lźl3
`x>d~ܣNuPM:>d߾l1K>m6v9ɾgI% >U"Pp>CN+]jcl,o1U*>iXx+o[@=x**>`TDD l7uii>p>!M	l1N<>auP1.z\!aUT>kILbvGpǛ5>ol-gep>>G+ 
>VliD>qUF޾q
P~>ik񵁾T,`MU#K>g?"۾q(Du>rGmM>^V>7#ۗ!dpv>p캾sR-k>p[Qd
 >2lΧ>a	#Zp@;7g>tfp7Ds	@?>j~H#PW
?X1
P_>n7t+R/p8~>]fAE>J>!lھj˼0,>tgYh%ꆾv=x%>s.X]f*zn>b>f'־s>w@WbvL7>mT5PQ~f'ž_;P1]>rKe-x]y@>x]	rU0>a	˦>P-p>xCIwzX->v[Cj2$>>>i֏w>>|HyWzB^%>rr(W3a/^(>u!^}Y|44]>}7"wd70>gv0s%>Irq->|Yӫx}2$>|̱rDS*>I^8h>irzg
hn>G&͓
>xϗIeEŘA[
rS>>vզӡc>a-V>ri}-{#q[&><&>$6#@{h%>cLZ$/>c/-i{(T>-я۾RoS>ȱ[tT"B>u{bJ݌>Tyď>~'Rce>rBhs?>9E/Z>II9b>w? !>'U
y$vw>0qJA%m|>;~X1>jM(>kNNkȹcu>\ګF	>>VwI}Rnu>4`5>{Ƿg8Z>.w]`>!µsaΡѾi\ >f|rP?9>ޭ};qmAE>,
߾[
|k>܉>@2|ӾYX>_nI$R>~8m>_]PvtNN>(nj4`>tRuxɝ0>r2>y,oכB>DP羘ği>
DԾ;>OD祥>O.N>zc{'42o>`\o{ǾMLnϾl>?ˌ@bҾ8Ѹ<>9_?)sB>@8/|RdZ}/gZV>_&%+owDy>_y\d>g-I:qAщ>`qXF,W>#˾x0>ߚ=6>eC-tܾɭ>E^{
~>[&?>"M>m2
쭛>:2AGǤ>to2B!> ,>YQD:>Ϸ=>Zd
^Y>mgY>KB>H뾼Ien}>A.Yƃv}4\>'| %'>TXKC4>?*7C64)2,>r=V~O%4Dƾhq>_kJܾR&>-~Mu&%8>Isf/վM#eCr\ʅ	>Ŷ(-Pj>eEcf@sٕ>LQ> d*Ll>TX"M>~nR>}Q=@>Ir=Rp(GҞy>A_[þd5i{#>6TVjZM2݈>+κfVG>S@ZYi-P1>=퓫ue2c澘z>9-$ƾw;H0<>پ*VJk>u\>>\9価8Y>XWx(SRї/>/jZ2rQ=>փb,JD>Xa>ENZUZᾓ0Y>*3{pՈ>gb!?>e5^Hh>fiB9s9AR9> Q˾JŎ~>ua
l"Ҿw~ϟd>q		>DƢn7Rs>jCky]>[eƾH&>jB1~>2`'wϏ$A>]'6&
d>iS" þ@w3b>ㇰQͤ>Θx\Q0o>">eN#w	v>jM:}>ھgLewI
3>ŏBH'c>+}>m3ހ>ҠQc>1REP,>+>P
IL|r/9">=žzΡã,w
qr>`f}>q>+,W,>M}YQ|>|j0Z+>	۲Y>{@MIF>sܿ/\>%ջ}	-h>WW>tMU(>QC[V>wO7;tN[g7x;A>J|RՀ'ږ>Tվͤ@^F/w^>>&
S>L%뾇z&.>\vesq>whb޾+Uih>Cn%o>s/$%>v c`ݵ>"C>|c>h|x4c>ogL龏e>#WOz>ID^>95i"+:>(aWPr`B[RS?!>W4WȾ-O:>Dzcպ8G}j>B3;>yk#kx>R<k>u=K
pQkhuÄ>z=]f>f\q?hs~T>B-s4,>f`rF:
3sQ$")w>kz+>J>Q9q(d&6sБ%"O>t&qH;8>e+g1nQBuY1@>z*m>hDݹ7wHMU>JOfq9en>!3&+`70
]{3>:Yw!Ga@X>Z@H>ʻ
l^>:?h-;2&>"V	>FG(-m9$>BltmX>y=>bH
L#v&>?YEl>q7z>p[%>z`U}D;>bC뗲>xjf'V>>qt޹-LoM>`L3H>I&8>4
@wUcc&bk>tke9N@>mjORȞt`w>MҾ9Dj>0&?7?}݉*>,~n/2>v>dSo\+k5Fz4>x޾6O_>dōp>v/"?྆ZS-r:>u܏|R5ʾIa֠r-y>qo%;gpv>ąDϾ?ғo>-Z
/	n}H
;>1ag\nJ&>q`>lM6w;N>AgۮğM:8>B=C>|" NVb>)!qޢkc>쾆>~=Y*1s!|ţ8>loɾe>nv;>pȽѰ|>'Hs{dG0Bi:DsI}>-MѾQtuA3>6y?:e$83atXA>KpzG>v/.>`Ul*eV.Ʃz>bi`2Їh>LV
5;>zIR_.Q>nmDʾpPlCQ>\q7㾄Ps>x4q>Vv@SD>I}߷7>R|#>xX՚a(]{>lсrlVpO">q>#k&Svz>v?}
>]
(Â>\\|'tJ4>1dA>{A':&coa>CmbV1۾tĖHa>.A߾Ӗh>pbUũjU>ko]v1r>ZR"Aq>eDkоf]pRQ>{`t5u.{->EFvi>Xc(ws>v;
j?\[[>|ugy
x&Ӿq0zċ>,=]Vv>p.}N>iW3f;>Ctuʢs_Ŭ>;ށS/EP>xY9
>LD>V/J}yn>0S{|.vY>H
>z({
G>}ܦPddt'wᓃ>Dӛ5ϾxC>]aV >u2^徂&5 A^>ݦ^dVfrXr>n>т?xA>hX)4i>pep>>~/\)lm7ym+z>sY!vO&>ox8>ix(>Iup@Zg^>)f@{Lv>q2kw9>et(ŷsuK>`=r:o#d3>@"O 6(>rn =>cd4 ^E>Km4rWwaCc%>Z⾁3>q0>d[R!-Of>rյqN3e`>>L)޾c)n>p[A-El>gʾkI{a>0jI5n:nojO>Un7Z>k$HE>m:+jY>N'jKgop=Ycq>&UOR9Ę>c1>r,AiHbg}6>~MV\B˫0tDYsV>o֔|lV_>Q?.>vzE%.֎hZ>zag8$:2fA'bxk.)>`pwKWAhr>zrߚ⾁sb2>u
V8>Wlڂk}h<>fڌAqž:󁾀jFlQJ>l[>k5,SL/ɍ>~(8^Qc*qCC >S&Ӿ|j>T)u(>uf[-)/?z>y[)Y%
ad#y\z>7udv՚Sߞ>|5TVP>p3>d9~لs@>w20gah(oB_
>[9j|
/>Xʳh>tJٜ4>x>)T(yn>QilItMZί(T>|7dPP>lͶ>iL/y :>}]֊|H_^墦rՁ)3>38yLm>*7r
Z6>x*l#N2->s3\>Yƣ[|}xߩS>|gY+jEk( N7>u &]i|9:T>X0>t)FwL>=wP9y^a>.p^.־ccH>}Ǿ}#}>bi2qfەGT>x$(^W!{w )>zNruCI_.(O>|NEx;};e>dDM(>p*HZl">yG~kl!7)$ݳwJ=>>op2Ǿr{^"a_4G>|Pھ}ų@!c>cu>pR>fyj>xyqSJqIGwa>|1Ѣq3LIؾbyUl>} |q>_W>rU0p(L?>vu	G>CRcxy>~;kW-h"&>~`tؾzT>NI>uS&ژN>r%>[t+{|pL>|ӟb#pk
>~2?w"v>);.K>xV~4&l
>kh٩>iMTN*}QG>y|^ԧEsԾu7>~?,q7m)a>|c?.¾{V+>Yh0>s)sL->U#dzͯRr>|zꣾblpU>~f
uӚ;F*M>yM
}07Â/>g"F6>m 0}}n>w'z>&X…cxW>}nj>l+;iE>}ojkw#|>%»>wD̈}|>l!)">g,'26}
r؅>x_Q8,7>VxXv֔`>}s5lbgP >|ғVsxd}fkX>9>"h>v`#ooo}r0>l?>gX(]i|š͏>x K2 q72vAC>}0 k%;/hѵc>|i=!w\%_=FjBX>w> ˁ|ʲ#5L>h>ky?\in}a,>vB>8x)j1^>|.&!ee nc>}4M6tRʕN+>yJ{D3MX>`S
6>qrΣ>YCVzco>yWξTI[w^sʵ>}A0o
PKcKkP>{
Ǿx4V>:>v˹|fD>i
.#>jTx#E|}a>ul%.Ś>Cwpxi@Nw0>{
ˌ`I{ܾpfA{j>|ԑ9濾rCdZ\*>z~ÄvxC@\>M$E0})>tپ|eQk>ke77Υ>gR19{/->u@9>;ǮC߾w:Lz>z/%g`p'H>|Ƃqn\^&{͉>zT^{=x5-	>CȺq9L~>u;AZ?i{՝(>htKf>jռ|>t|o>P}Bx8>yc)V1p۾rA?z>|	`lTKaCe1>{i)h(uH;V}9`>>w.?2zO ,j>^>qaq|UY>oKx>b]QzS>vd{hh>?z^EvzGu7`~Zzp -J>{pXw	a`ȌhԐ>zy:vSkh-E8>v*\zm֘^>`٭L>p{Y>pf8>bzeb
X
>v
Ys>(RfvyGn[]8FҼxqJ4^>{t;1m;dy ^>zFE^t'CAw`xF>w0y*^]>V[>>rU{Bs>i,`>>h-`y~{ 8`~>s	F>S䤊i%"xף>wt畕EhӾt6q>z)cn>{K5Q
xpi?B`&`>zk
uIMA29&$>vl	y,<l)>W:7>rD3mJ(zP7>iQ=>h׶vzwJ>r_i>WRU9;뛾yzԯ>vCP0>uupK>y*sr_]}zp}>z2˂k#,f0:@>zEVbs|"&S>x%f8w֨U>;;y>uqy¸>`N-6>p!zo1,^6>k?>fEE4]zbTr>rF>T.`8xӧ>v$M-"+ؾu^>y/i^3[8AqhYU>z|Ah{!UhZ>zu[2}qD𳁃\'J^>y)&6̘u6MU5tmM>vpnxx+A>QQ+]y>s>)y1.y>cnb/^>mCʾzuz->m.>dIkym1.>rr
>Sx!횾xG;;[U>v7AgNu>>x}B
V@}J־rJE&/$>yW?ldl{n(>zD0*mH5cuyJL>yܾrcS˚T>x*d;uʏkݽu}$>u֮qxp>R">rby~HY>bO L>npW&z
a'>j&A>fgd#y	1>q-\>[`Ѿx`5!>tFfh;>CG)̾vT"9
>vj־>T2']tʿ/2>x{&sf'XLq,爖>yjl5оd#dlTu>yꗟkkeKwg>y4ľq4dGR[4Q>x9wsRFo*d>w	iv9>2ڃ5>tvwP}:>S/g>rQyo->aHEi>oNQy	Đ>h-y>iײyY>nF1>brHL׾y'hI>qr>W1'x?(G>t1w
	8>BUvֺȶ>vZa1>v*t>wˮlQIrh,%>xaо^'Zpf;!Iq>y8JeJRnkhkJ>ykF\찾j5k?fմ>y9}ob6ž`b,i>x&sr%5kU$ѼlE>w>Ut1B'>vU
޾uD> )-">u!ɹrپv8w>Jm뤡`>sr+e[wC!>WI;^)T>qm)x)l|>aw>>o-]ys~n>e>jVy&ҭ=>j_27W>fe"1y\>nr(RHS>aة8x),>q|>Zx	j$>rbk3>QRmw?rbT>t"ں>@u\j4d:
^u.g?.b>vc/Bh#s	>w8[6QdDZrX澪hq>_kJܾR&>-~Mu&%8>Isf/վM#eCr\ʅ	>Ŷ(-Pj>eEcf@sٕ>LQ> d*Ll>TX"M>~nR>}Q=@>Ir=Rp(GҞy>A_[þd5i{#>6TVjZM2݈>+κfVG>S@ZYi-P1>=퓫ue2c澘z>9-$ƾw;H0<>پ*VJk>u\>>\9価8Y>XWx(SRї/>/jZ2rQ=>փb,JD>Xa>ENZUZᾓ0Y>*3{pՈ>gb!?>e5^Hh>fiB9s9AR9> Q˾JŎ~>ua
l"Ҿw~ϟd>q		>DƢn7Rs>jCky]>[eƾH&>jB1~>2`'wϏ$A>]'6&
d>iS" þ@w3b>ㇰQͤ>Θx\Q0o>">eN#w	v>jM:}>ھgLewI
3>ŏBH'c>+}>m3ހ>ҠQc>1REP,>+>P
IL|r/9">=žzΡã,w
qr>`f}>q>+,W,>M}YQ|>|j0Z+>	۲Y>{@MIF>sܿ/\>%ջ}	-h>WW>tMU(>QC[V>wO7;tN[g7x;A>J|RՀ'ږ>Tվͤ@^F/w^>>&
S>L%뾇z&.>\vesq>whb޾+Uih>Cn%o>s/$%>v c`ݵ>"C>|c>h|x4c>ogL龏e>#WOz>ID^>95i"+:>(aWPr`B[RS?!>W4WȾ-O:>Dzcպ8G}j>B3;>yk#kx>R<k>u=K
pQkhuÄ>z=]f>f\q?hs~T>B-s4,>f`rF:
3sQ$")w>kz+>J>Q9q(d&6sБ%"O>t&qH;8>e+g1nQBuY1@>z*m>hDݹ7wHMU>JOfq9en>!3&+`70
]{3>:Yw!Ga@X>Z@H>ʻ
l^>:?h-;2&>"V	>FG(-m9$>BltmX>y=>bH
L#v&>?YEl>q7z>p[%>z`U}D;>bC뗲>xjf'V>>qt޹-LoM>`L3H>I&8>4
@wUcc&bk>tke9N@>mjORȞt`w>MҾ9Dj>0&?7?}݉*>,~n/2>v>dSo\+k5Fz4>x޾6O_>dōp>v/"?྆ZS-r:>u܏|R5ʾIa֠r-y>qo%;gpv>ąDϾ?ғo>-Z
/	n}H
;>1ag\nJ&>q`>lM6w;N>AgۮğM:8>B=C>|" NVb>)!qޢkc>쾆>~=Y*1s!|ţ8>loɾe>nv;>pȽѰ|>'Hs{dG0Bi:DsI}>-MѾQtuA3>6y?:e$83atXA>KpzG>v/.>`Ul*eV.Ʃz>bi`2Їh>LV
5;>zIR_.Q>nmDʾpPlCQ>\q7㾄Ps>x4q>Vv@SD>I}߷7>R|#>xX՚a(]{>lсrlVpO">q>#k&Svz>v?}
>]
(Â>\\|'tJ4>1dA>{A':&coa>CmbV1۾tĖHa>.A߾Ӗh>pbUũjU>ko]v1r>ZR"Aq>eDkоf]pRQ>{`t5u.{->EFvi>Xc(ws>v;
j?\[[>|ugy
x&Ӿq0zċ>,=]Vv>p.}N>iW3f;>Ctuʢs_Ŭ>;ށS/EP>xY9
>LD>V/J}yn>0S{|.vY>H
>z({
G>}ܦPddt'wᓃ>Dӛ5ϾxC>]aV >u2^徂&5 A^>ݦ^dVfrXr>n>т?xA>hX)4i>pep>>~/\)lm7ym+z>sY!vO&>ox8>ix(>Iup@Zg^>)f@{Lv>q2kw9>et(ŷsuK>`=r:o#d3>@"O 6(>rn =>cd4 ^E>Km4rWwaCc%>Z⾁3>q0>d[R!-Of>rյqN3e`>>L)޾c)n>p[A-El>gʾkI{a>0jI5n:nojO>Un7Z>k$HE>m:+jY>N'jKgop=Ycq>&UOR9Ę>c1>r,AiHbg}6>~MV\B˫0tDYsV>o֔|lV_>Q?.>vzE%.֎hZ>zag8$:2fA'bxk.)>`pwKWAhr>zrߚ⾁sb2>u
V8>Wlڂk}h<>fڌAqž:󁾀jFlQJ>l[>k5,SL/ɍ>~(8^Qc*qCC >S&Ӿ|j>T)u(>uf[-)/?z>y[)Y%
ad#y\z>7udv՚Sߞ>|5TVP>p3>d9~لs@>w20gah(oB_
>[9j|
/>Xʳh>tJٜ4>x>)T(yn>QilItMZί(T>|7dPP>lͶ>iL/y :>}]֊|H_^墦rՁ)3>38yLm>*7r
Z6>x*l#N2->s3\>Yƣ[|}xߩS>|gY+jEk( N7>u &]i|9:T>X0>t)FwL>=wP9y^a>.p^.־ccH>}Ǿ}#}>bi2qfەGT>x$(^W!{w )>zNruCI_.(O>|NEx;};e>dDM(>p*HZl">yG~kl!7)$ݳwJ=>>op2Ǿr{^"a_4G>|Pھ}ų@!c>cu>pR>fyj>xyqSJqIGwa>|1Ѣq3LIؾbyUl>} |q>_W>rU0p(L?>vu	G>CRcxy>~;kW-h"&>~`tؾzT>NI>uS&ژN>r%>[t+{|pL>|ӟb#pk
>~2?w"v>);.K>xV~4&l
>kh٩>iMTN*}QG>y|^ԧEsԾu7>~?,q7m)a>|c?.¾{V+>Yh0>s)sL->U#dzͯRr>|zꣾblpU>~f
uӚ;F*M>yM
}07Â/>g"F6>m 0}}n>w'z>&X…cxW>}nj>l+;iE>}ojkw#|>%»>wD̈}|>l!)">g,'26}
r؅>x_Q8,7>VxXv֔`>}s5lbgP >|ғVsxd}fkX>9>"h>v`#ooo}r0>l?>gX(]i|š͏>x K2 q72vAC>}0 k%;/hѵc>|i=!w\%_=FjBX>w> ˁ|ʲ#5L>h>ky?\in}a,>vB>8x)j1^>|.&!ee nc>}4M6tRʕN+>yJ{D3MX>`S
6>qrΣ>YCVzco>yWξTI[w^sʵ>}A0o
PKcKkP>{
Ǿx4V>:>v˹|fD>i
.#>jTx#E|}a>ul%.Ś>Cwpxi@Nw0>{
ˌ`I{ܾpfA{j>|ԑ9濾rCdZ\*>z~ÄvxC@\>M$E0})>tپ|eQk>ke77Υ>gR19{/->u@9>;ǮC߾w:Lz>z/%g`p'H>|Ƃqn\^&{͉>zT^{=x5-	>CȺq9L~>u;AZ?i{՝(>htKf>jռ|>t|o>P}Bx8>yc)V1p۾rA?z>|	`lTKaCe1>{i)h(uH;V}9`>>w.?2zO ,j>^>qaq|UY>oKx>b]QzS>vd{hh>?z^EvzGu7`~Zzp -J>{pXw	a`ȌhԐ>zy:vSkh-E8>v*\zm֘^>`٭L>p{Y>pf8>bzeb
X
>v
Ys>(RfvyGn[]8FҼxqJ4^>{t;1m;dy ^>zFE^t'CAw`xF>w0y*^]>V[>>rU{Bs>i,`>>h-`y~{ 8`~>s	F>S䤊i%"xף>wt畕EhӾt6q>z)cn>{K5Q
xpi?B`&`>zk
uIMA29&$>vl	y,<l)>W:7>rD3mJ(zP7>iQ=>h׶vzwJ>r_i>WRU9;뛾yzԯ>vCP0>uupK>y*sr_]}zp}>z2˂k#,f0:@>zEVbs|"&S>x%f8w֨U>;;y>uqy¸>`N-6>p!zo1,^6>k?>fEE4]zbTr>rF>T.`8xӧ>v$M-"+ؾu^>y/i^3[8AqhYU>z|Ah{!UhZ>zu[2}qD𳁃\'J^>y)&6̘u6MU5tmM>vpnxx+A>QQ+]y>s>)y1.y>cnb/^>mCʾzuz->m.>dIkym1.>rr
>Sx!횾xG;;[U>v7AgNu>>x}B
V@}J־rJE&/$>yW?ldl{n(>zD0*mH5cuyJL>yܾrcS˚T>x*d;uʏkݽu}$>u֮qxp>R">rby~HY>bO L>npW&z
a'>j&A>fgd#y	1>q-\>[`Ѿx`5!>tFfh;>CG)̾vT"9
>vj־>T2']tʿ/2>x{&sf'XLq,爖>yjl5оd#dlTu>yꗟkkeKwg>y4ľq4dGR[4Q>x9wsRFo*d>w	iv9>2ڃ5>tvwP}:>S/g>rQyo->aHEi>oNQy	Đ>h-y>iײyY>nF1>brHL׾y'hI>qr>W1'x?(G>t1w
	8>BUvֺȶ>vZa1>v*t>wˮlQIrh,%>xaо^'Zpf;!Iq>y8JeJRnkhkJ>ykF\찾j5k?fմ>y9}ob6ž`b,i>x&sr%5kU$ѼlE>w>Ut1B'>vU
޾uD> )-">u!ɹrپv8w>Jm뤡`>sr+e[wC!>WI;^)T>qm)x)l|>aw>>o-]ys~n>e>jVy&ҭ=>j_27W>fe"1y\>nr(RHS>aة8x),>q|>Zx	j$>rbk3>QRmw?rbT>t"ں>@u\j4d:
^u.g?.b>vc/Bh#s	>w8[6QdDZrX澪hq>_kJܾR&>-~Mu&%8>Isf/վM#eCr\ʅ	>Ŷ(-Pj>eEcf@sٕ>LQ> d*Ll>TX"M>~nR>}Q=@>Ir=Rp(GҞy>A_[þd5i{#>6TVjZM2݈>+κfVG>S@ZYi-P1>=퓫ue2c澘z>9-$ƾw;H0<>پ*VJk>u\>>\9価8Y>XWx(SRї/>/jZ2rQ=>փb,JD>Xa>ENZUZᾓ0Y>*3{pՈ>gb!?>e5^Hh>fiB9s9AR9> Q˾JŎ~>ua
l"Ҿw~ϟd>q		>DƢn7Rs>jCky]>[eƾH&>jB1~>2`'wϏ$A>]'6&
d>iS" þ@w3b>ㇰQͤ>Θx\Q0o>">eN#w	v>jM:}>ھgLewI
3>ŏBH'c>+}>m3ހ>ҠQc>1REP,>+>P
IL|r/9">=žzΡã,w
qr>`f}>q>+,W,>M}YQ|>|j0Z+>	۲Y>{@MIF>sܿ/\>%ջ}	-h>WW>tMU(>QC[V>wO7;tN[g7x;A>J|RՀ'ږ>Tվͤ@^F/w^>>&
S>L%뾇z&.>\vesq>whb޾+Uih>Cn%o>s/$%>v c`ݵ>"C>|c>h|x4c>ogL龏e>#WOz>ID^>95i"+:>(aWPr`B[RS?!>W4WȾ-O:>Dzcպ8G}j>B3;>yk#kx>R<k>u=K
pQkhuÄ>z=]f>f\q?hs~T>B-s4,>f`rF:
3sQ$")w>kz+>J>Q9q(d&6sБ%"O>t&qH;8>e+g1nQBuY1@>z*m>hDݹ7wHMU>JOfq9en>!3&+`70
]{3>:Yw!Ga@X>Z@H>ʻ
l^>:?h-;2&>"V	>FG(-m9$>BltmX>y=>bH
L#v&>?YEl>q7z>p[%>z`U}D;>bC뗲>xjf'V>>qt޹-LoM>`L3H>I&8>4
@wUcc&bk>tke9N@>mjORȞt`w>MҾ9Dj>0&?7?}݉*>,~n/2>v>dSo\+k5Fz4>x޾6O_>dōp>v/"?྆ZS-r:>u܏|R5ʾIa֠r-y>qo%;gpv>ąDϾ?ғo>-Z
/	n}H
;>1ag\nJ&>q`>lM6w;N>AgۮğM:8>B=C>|" NVb>)!qޢkc>쾆>~=Y*1s!|ţ8>loɾe>nv;>pȽѰ|>'Hs{dG0Bi:DsI}>-MѾQtuA3>6y?:e$83atXA>KpzG>v/.>`Ul*eV.Ʃz>bi`2Їh>LV
5;>zIR_.Q>nmDʾpPlCQ>\q7㾄Ps>x4q>Vv@SD>I}߷7>R|#>xX՚a(]{>lсrlVpO">q>#k&Svz>v?}
>]
(Â>\\|'tJ4>1dA>{A':&coa>CmbV1۾tĖHa>.A߾Ӗh>pbUũjU>ko]v1r>ZR"Aq>eDkоf]pRQ>{`t5u.{->EFvi>Xc(ws>v;
j?\[[>|ugy
x&Ӿq0zċ>,=]Vv>p.}N>iW3f;>Ctuʢs_Ŭ>;ށS/EP>xY9
>LD>V/J}yn>0S{|.vY>H
>z({
G>}ܦPddt'wᓃ>Dӛ5ϾxC>]aV >u2^徂&5 A^>ݦ^dVfrXr>n>т?xA>hX)4i>pep>>~/\)lm7ym+z>sY!vO&>ox8>ix(>Iup@Zg^>)f@{Lv>q2kw9>et(ŷsuK>`=r:o#d3>@"O 6(>rn =>cd4 ^E>Km4rWwaCc%>Z⾁3>q0>d[R!-Of>rյqN3e`>>L)޾c)n>p[A-El>gʾkI{a>0jI5n:nojO>Un7Z>k$HE>m:+jY>N'jKgop=Ycq>&UOR9Ę>c1>r,AiHbg}6>~MV\B˫0tDYsV>o֔|lV_>Q?.>vzE%.֎hZ>zag8$:2fA'bxk.)>`pwKWAhr>zrߚ⾁sb2>u
V8>Wlڂk}h<>fڌAqž:󁾀jFlQJ>l[>k5,SL/ɍ>~(8^Qc*qCC >S&Ӿ|j>T)u(>uf[-)/?z>y[)Y%
ad#y\z>7udv՚Sߞ>|5TVP>p3>d9~لs@>w20gah(oB_
>[9j|
/>Xʳh>tJٜ4>x>)T(yn>QilItMZί(T>|7dPP>lͶ>iL/y :>}]֊|H_^墦rՁ)3>38yLm>*7r
Z6>x*l#N2->s3\>Yƣ[|}xߩS>|gY+jEk( N7>u &]i|9:T>X0>t)FwL>=wP9y^a>.p^.־ccH>}Ǿ}#}>bi2qfەGT>x$(^W!{w )>zNruCI_.(O>|NEx;};e>dDM(>p*HZl">yG~kl!7)$ݳwJ=>>op2Ǿr{^"a_4G>|Pھ}ų@!c>cu>pR>fyj>xyqSJqIGwa>|1Ѣq3LIؾbyUl>} |q>_W>rU0p(L?>vu	G>CRcxy>~;kW-h"&>~`tؾzT>NI>uS&ژN>r%>[t+{|pL>|ӟb#pk
>~2?w"v>);.K>xV~4&l
>kh٩>iMTN*}QG>y|^ԧEsԾu7>~?,q7m)a>|c?.¾{V+>Yh0>s)sL->U#dzͯRr>|zꣾblpU>~f
uӚ;F*M>yM
}07Â/>g"F6>m 0}}n>w'z>&X…cxW>}nj>l+;iE>}ojkw#|>%»>wD̈}|>l!)">g,'26}
r؅>x_Q8,7>VxXv֔`>}s5lbgP >|ғVsxd}fkX>9>"h>v`#ooo}r0>l?>gX(]i|š͏>x K2 q72vAC>}0 k%;/hѵc>|i=!w\%_=FjBX>w> ˁ|ʲ#5L>h>ky?\in}a,>vB>8x)j1^>|.&!ee nc>}4M6tRʕN+>yJ{D3MX>`S
6>qrΣ>YCVzco>yWξTI[w^sʵ>}A0o
PKcKkP>{
Ǿx4V>:>v˹|fD>i
.#>jTx#E|}a>ul%.Ś>Cwpxi@Nw0>{
ˌ`I{ܾpfA{j>|ԑ9濾rCdZ\*>z~ÄvxC@\>M$E0})>tپ|eQk>ke77Υ>gR19{/->u@9>;ǮC߾w:Lz>z/%g`p'H>|Ƃqn\^&{͉>zT^{=x5-	>CȺq9L~>u;AZ?i{՝(>htKf>jռ|>t|o>P}Bx8>yc)V1p۾rA?z>|	`lTKaCe1>{i)h(uH;V}9`>>w.?2zO ,j>^>qaq|UY>oKx>b]QzS>vd{hh>?z^EvzGu7`~Zzp -J>{pXw	a`ȌhԐ>zy:vSkh-E8>v*\zm֘^>`٭L>p{Y>pf8>bzeb
X
>v
Ys>(RfvyGn[]8FҼxqJ4^>{t;1m;dy ^>zFE^t'CAw`xF>w0y*^]>V[>>rU{Bs>i,`>>h-`y~{ 8`~>s	F>S䤊i%"xף>wt畕EhӾt6q>z)cn>{K5Q
xpi?B`&`>zk
uIMA29&$>vl	y,<l)>W:7>rD3mJ(zP7>iQ=>h׶vzwJ>r_i>WRU9;뛾yzԯ>vCP0>uupK>y*sr_]}zp}>z2˂k#,f0:@>zEVbs|"&S>x%f8w֨U>;;y>uqy¸>`N-6>p!zo1,^6>k?>fEE4]zbTr>rF>T.`8xӧ>v$M-"+ؾu^>y/i^3[8AqhYU>z|Ah{!UhZ>zu[2}qD𳁃\'J^>y)&6̘u6MU5tmM>vpnxx+A>QQ+]y>s>)y1.y>cnb/^>mCʾzuz->m.>dIkym1.>rr
>Sx!횾xG;;[U>v7AgNu>>x}B
V@}J־rJE&/$>yW?ldl{n(>zD0*mH5cuyJL>yܾrcS˚T>x*d;uʏkݽu}$>u֮qxp>R">rby~HY>bO L>npW&z
a'>j&A>fgd#y	1>q-\>[`Ѿx`5!>tFfh;>CG)̾vT"9
>vj־>T2']tʿ/2>x{&sf'XLq,爖>yjl5оd#dlTu>yꗟkkeKwg>y4ľq4dGR[4Q>x9wsRFo*d>w	iv9>2ڃ5>tvwP}:>S/g>rQyo->aHEi>oNQy	Đ>h-y>iײyY>nF1>brHL׾y'hI>qr>W1'x?(G>t1w
	8>BUvֺȶ>vZa1>v*t>wˮlQIrh,%>xaо^'Zpf;!Iq>y8JeJRnkhkJ>ykF\찾j5k?fմ>y9}ob6ž`b,i>x&sr%5kU$ѼlE>w>Ut1B'>vU
޾uD> )-">u!ɹrپv8w>Jm뤡`>sr+e[wC!>WI;^)T>qm)x)l|>aw>>o-]ys~n>e>jVy&ҭ=>j_27W>fe"1y\>nr(RHS>aة8x),>q|>Zx	j$>rbk3>QRmw?rbT>t"ں>@u\j4d:
^u.g?.b>vc/Bh#s	>w8[6QdDZrX>wOHJY4оq/O>xW`?bodC>xLxf˾dZcFlR@>x͍ygg?Yi1q2>xа;j}|{f L>x[WmW#TbB*>xw&zog2/l_w%-s.>x"&3q+NYF0>w_@r?9^S56*X5L>w5b|s6cۥ#J+>v1tEW>J2->vDQpt]Z3 j2^K$>uYBu~8.>)u>t&HJHv/>@ߎpB>s\Bv5b1>J=U.>s.h/̍v_q>Q>rnNP5wSAh>U
t>q,w5?>ZQL>p\ptwGs>]Bޖ3>p25nxv>`
G>nB?Kwx#{x#>bQpb>>m!;x:4F>cַʹU!>l7l3xHym>e=
9>jK^5xOz\>f>i:xPTI>g1	">hăiþxL-(>h!9`>gw6fXxD
x>ihgr>fvb
.x8%>jzF>eXPx+ܿT>kUwy>d?SC.x/9>lW_
B>cFx
H>l/֊>cG~?|w,YP>m9J>bشwf#w94>myU_h>b5uw;Zn>m&}ւ>aZawռ{t>n6;>a㞼ɼwXn76>aGBwH>nNW>a&Gw|t>nS]c>aC9uȾw>Ԡ!Q>nDʲ>a)ů+wn>n#{^>aMpGݾw>m4N(>az
#wʢU%>mh|>aץ~񮥾w-'>mMTE>b=3MwrZv>l>bčw+d>l^F>cIqwE!b>kȮ|>cNwA>kS>dnwĐ:V>j_ft'>eq>U
wƑb7>i8>fNM~wƕO>hT,>g=ھwެ>gz[v->h<>pw<>f֙-7<>iKHwZz;>eUv$i>jgUxOwMa>d.u%>k{fw^)[>bb?>l?woS}b>a13R>nK{GwI2>_;D4F>oE]SwZQ>[NDTl>pGZ&v஋ۨ>XS(֋>p1Xvg!C>T">qQfTvIc4M(>P[@>r9
h:u邐g
>HS>r'&ZuzJ2>@R>s|nӮIt>*">-ALz u>t.ƓVXtk,NAHM>tbƾsɟ|:7ar)0>u2;
ȬsEsmE<>uorK=y"OY*3>v"BvqnLUܰ>vM=پp{~7G*ZcU>v+itmn$+_?K>w+l9hbg+k>wB$5־jC+.7e7py>wU.;g#8Sgz>wPH@l:ddꋾj|J^t>w/+bxm	E>>vϔJ^]w`ݾoT`>v.׳xWR=pj Z>v|wP鹯c톾r
R>u~Z-D@@sli>t}3F'O8U*t
{`>sۄq>1b-W#tUU>rg|t>Gpz˳ϾuUΏ}>qQU>S(Nv6sd>pY+>ZFvJ'fj>m^j>`)lvz/q>j~iSԉ>d31[þw/{#D
>g9,:	>h+=ewp>cD
>kf?zv{X>__O>nٸ;}vk`e>W;iIǂ>p;þuyOc>M]>rN~!ľtoE>8҃-Gz>s$ǫ8souR'+HSx>ten
rUGmߕ>u{bqIL9W̾T+I)+>v5䓼q3oQ@:]25U.>v^ko}cT]T
>v>F޾g"LgB>v6Ecn۾k<>vͬjپ]&HoU,(7sh>vST&O@qb
o>uMES~ԾDer>t:rs)6>DnuIbH>qIR>TsEvyG>nH%$>^y_v'O>jOF>dN!vR1>f$@v>hZGJv4uHG>a3>mamXsv?WK>W6B>pO-6uw|>IϲX>rt̡֘tZpbҞ>^%wQ>s%~RrxվCqu(VϾq(nU"MO>v
en6n|`ݿ4$>vcii]3ev+L]>vdqfk;ƾj|?>vq8]e;)o;Ew>u̺P4zR&ٛPq`&>tC,t8$蚿c|s]>sTR>91CjtTt4>qB=O>RMpޣ)u +)>n#(>^оvito)>iy>e"|#=ξv3
>dNq]%>j0vQY>\.>ow5u2c>P"ap>qgzR]tf>(ch>s	{grG^D'u5Xp'"cRW&dh_}>vt-lZEaޞG>vvBg~g',Hg4P`>vi
`Am[	a>u<\2T&q=>tcHs0->:;՚=tF^>q" b1^>T5u'f>mIs>aJT:vZ:$>gGY>gX~ѩvYl>a*u<Ő>m"6u4u>T\pR>qȍ"t.X>9>s5סyWr@UF>t<=p/ԒVԁX>uy3žl!jbcy>vTAжeCҾh!K>v+^)*nSn,>ubˉyO* ƾqZ>s$a3a&߾sE 7>q9>M0uMak:>n5UCr>];0vgkG>hk2_>e׍2dv@hB>b&
>l@O|qhuW%V>Ukk	>pP>t`n{>7Ug>s0s٨?r`8IC>t&0p3mWY|3_a>uUCjl
9䅾d(e_?>v7uceu9fj]!4v>uϠGX{#prB>t
ʾ@|(Qr*&>rH5>@mgts9>p^@RVoU>Xi0T!uۻ?>jjP?>co۾v(n>c {>j/uNP>Wx>pxYtk>><7ղ>r7rYC>tV˝&MpR$MZMnQ%>u=ݖiU1FLdqV>v-hb/
_l
.>uT#w%	9q>t!;/(1-srJ}J>q_>LabuqE>n9>T>^,uy>gM>>gO
̜
uJ
>^޸@e>n?~dݾu;B>KA4/X>rsVd!7j.l5̴d>t+aLpӅRcU^]'j>u@&9k<,cce>v¾c靾j!>Q>uljV
p*~R>t=b+2|s3uP>r9&V>Jzjt0(sY>n'QlI>^!uޢ%>f	E>g=]#~ulM.>]:B>n:
t{kwc>FV>rR3arג<&8>toQpYgkum+i4e=`>u?u".(PtPC1qܒG>shg؏>%
usE;@>pׂY>URN12umnâ;>j{3>c_Qu4+2>bSF`V>k^X+uLZD6>S->q,sT}=0o>sXtq'{R7L:>uDZ>dkME㈾b#6?>uƊrch5@ ja>>uY)yT%pߜ>sͬo 7?sBg>qDP.}އ>RAu1F8>kbVodg(uu}|>czE>j
PcuQ>Tuc<*>p쵾s/$k>vU
>s$u52t2kI3bh>uZTbՉk=eu>u3)v.R0@ ¾q!>sM>sN>54ishp>pl8=>U
ӴuNr>jB;wBG>cDue]>a2>lR~մtڇ>OtF>qFPIsuu%e21r>tgߤp&GYƾX=p>ur,h'ҳʾe)>uSN_\D
mnJM>tXFk/r9›>rx.<2>B=gtzhr>nuo">]yg3L;up>fW>guuvR|L>Ys>ontex>5rt#FlOgJaDT>u$ʾcduPhjCy>u~S/S66hq\u>sZ9yO>j6Jsh]F>pnRο>V'RuMnrM>iM2>e*!EuG͆>_z/">mN/tHJ2ZD>Ev}G>r9ȪrLoiD3?Zo>t_LHQDm2ϊn_le>uxeEfh灣j>uFԴMV.pk"A>ssھ1tҾs^S}51>pva>Sʾu97>j`Lj>d/ҹu^c{>`H>lrtm]>I>7`>q-rsB'5 >t_l	n'Ifҋ^+Ka>u}~ezfw2lRh۞b(>u>qJVX(pc3oO>sg݈?As`Ze"6>pؘY>Tp#;u^ >iR$U&>dz3Ou],hi>`
3->mcXBSt}>EMFe>r3
TJr#`rFx3>tvCվm0~J~`HL)>u~d+mFi㾨jG>uZSѵIpg(>s72>#.&s 䮗>pHڽ'>XgxƴuC+>gδ=>f_Ff.u^Ƕ>[)83>ot
*R^>6o>rAQqZɓѓP94>tܞBj`Gbɪ>u{]'ah.﫾l>Q->t&J3q_he>ram#>BrqftSl>m-O;w>_Yulwi>dLr>ipVZ\uAm*q>T*PMpɮp{s4Zپ"eGH>sjpw:FX[9~>u<)Dygv,qUfeƥ>uJEZloq,>sξ0- )sR50>q5>RDn+tEl%>iqeK>d8LuhI>`X%>mQvtZRtr>C~7k>rD?mq\rI{_>tKl#=Ga|!>ul#1ĸpbvEHPkt}QNFqe{`>r>>{s@оt*;Z>nwp>^,C$2<(uZ@>d؇>i:gǾt1ab>TxK>p3s#͙3'!>s.
of,u9bZhf+YgO޺>u-NXzbsxtp
e>siΏ5H8s@m:>p0|>Uuc>h%\D>e6uJ3>\i!!>nUsUX>6_>r-+q$nAQ"A9T>t@xmjpca%>uYđOƾ_`$|zmRJ>tCp7B,_6rSZ>qpr[>LA锾tTwvhP>kwc>ba.&>l2IOþt4>I$UK>qn%ުr;?E!AU>tb!dlꬾ`ԃ7y>uYwo#b?!zjA2>tO#Krqr3>rz(>?H;t%7Kn>m4>^ֆuOi>d.J>i1vtFj>R; U|>q
Ns
r}5?sQ>s0w;nĸf\v>uAN`-eIh
4j`>tpD9TZ|Fp1>sc->'IN~?,s{>c>ok.^Jv>Z=u0(l4>fD@+[>gLu(>VǰGS>pN>XsNқ2ҚItB>sve3pu`˘X9" >uJ3egg"f=n>u!wF(VX2hxoPT>s)*U+exsA+Y>p^K!>VdVu	->g_!@>f!D`u.e(>Zls>oWB5sr>'9>s|P'p@DN^TJz>t/hI×teh粌>u8f?~[Rp#־nKˢu>sW&2:Z[rV(g>p=0>S8k`(Bt	#	c>i4:
>d$֝au@Kg>][^j
>nD'Iksj]>7r>r@|q'4߾Qڤay>t\Ria=d&h{>uEmO^*\nm=!>tQ>= ˾rѲ˛>qE7>P%Yutj>j<#
q>c:uIP+>_;h@>m^
Ⱦt(r>@eMb>rg2qnS;IOh>t]UajBԾc'kƣ>uK)&u̾`M,m>t:eK.BB9탾rLpEZ>q'+>MKltnZ>jcXR>bTCuM{k>`t7KH>lz:Lt;VZ>BF>ra4ތqf3wPVP>th1|iI\>z	q3>wOHJY4оq/O>xW`?bodC>xLxf˾dZcFlR@>x͍ygg?Yi1q2>xа;j}|{f L>x[WmW#TbB*>xw&zog2/l_w%-s.>x"&3q+NYF0>w_@r?9^S56*X5L>w5b|s6cۥ#J+>v1tEW>J2->vDQpt]Z3 j2^K$>uYBu~8.>)u>t&HJHv/>@ߎpB>s\Bv5b1>J=U.>s.h/̍v_q>Q>rnNP5wSAh>U
t>q,w5?>ZQL>p\ptwGs>]Bޖ3>p25nxv>`
G>nB?Kwx#{x#>bQpb>>m!;x:4F>cַʹU!>l7l3xHym>e=
9>jK^5xOz\>f>i:xPTI>g1	">hăiþxL-(>h!9`>gw6fXxD
x>ihgr>fvb
.x8%>jzF>eXPx+ܿT>kUwy>d?SC.x/9>lW_
B>cFx
H>l/֊>cG~?|w,YP>m9J>bشwf#w94>myU_h>b5uw;Zn>m&}ւ>aZawռ{t>n6;>a㞼ɼwXn76>aGBwH>nNW>a&Gw|t>nS]c>aC9uȾw>Ԡ!Q>nDʲ>a)ů+wn>n#{^>aMpGݾw>m4N(>az
#wʢU%>mh|>aץ~񮥾w-'>mMTE>b=3MwrZv>l>bčw+d>l^F>cIqwE!b>kȮ|>cNwA>kS>dnwĐ:V>j_ft'>eq>U
wƑb7>i8>fNM~wƕO>hT,>g=ھwެ>gz[v->h<>pw<>f֙-7<>iKHwZz;>eUv$i>jgUxOwMa>d.u%>k{fw^)[>bb?>l?woS}b>a13R>nK{GwI2>_;D4F>oE]SwZQ>[NDTl>pGZ&v஋ۨ>XS(֋>p1Xvg!C>T">qQfTvIc4M(>P[@>r9
h:u邐g
>HS>r'&ZuzJ2>@R>s|nӮIt>*">-ALz u>t.ƓVXtk,NAHM>tbƾsɟ|:7ar)0>u2;
ȬsEsmE<>uorK=y"OY*3>v"BvqnLUܰ>vM=پp{~7G*ZcU>v+itmn$+_?K>w+l9hbg+k>wB$5־jC+.7e7py>wU.;g#8Sgz>wPH@l:ddꋾj|J^t>w/+bxm	E>>vϔJ^]w`ݾoT`>v.׳xWR=pj Z>v|wP鹯c톾r
R>u~Z-D@@sli>t}3F'O8U*t
{`>sۄq>1b-W#tUU>rg|t>Gpz˳ϾuUΏ}>qQU>S(Nv6sd>pY+>ZFvJ'fj>m^j>`)lvz/q>j~iSԉ>d31[þw/{#D
>g9,:	>h+=ewp>cD
>kf?zv{X>__O>nٸ;}vk`e>W;iIǂ>p;þuyOc>M]>rN~!ľtoE>8҃-Gz>s$ǫ8souR'+HSx>ten
rUGmߕ>u{bqIL9W̾T+I)+>v5䓼q3oQ@:]25U.>v^ko}cT]T
>v>F޾g"LgB>v6Ecn۾k<>vͬjپ]&HoU,(7sh>vST&O@qb
o>uMES~ԾDer>t:rs)6>DnuIbH>qIR>TsEvyG>nH%$>^y_v'O>jOF>dN!vR1>f$@v>hZGJv4uHG>a3>mamXsv?WK>W6B>pO-6uw|>IϲX>rt̡֘tZpbҞ>^%wQ>s%~RrxվCqu(VϾq(nU"MO>v
en6n|`ݿ4$>vcii]3ev+L]>vdqfk;ƾj|?>vq8]e;)o;Ew>u̺P4zR&ٛPq`&>tC,t8$蚿c|s]>sTR>91CjtTt4>qB=O>RMpޣ)u +)>n#(>^оvito)>iy>e"|#=ξv3
>dNq]%>j0vQY>\.>ow5u2c>P"ap>qgzR]tf>(ch>s	{grG^D'u5Xp'"cRW&dh_}>vt-lZEaޞG>vvBg~g',Hg4P`>vi
`Am[	a>u<\2T&q=>tcHs0->:;՚=tF^>q" b1^>T5u'f>mIs>aJT:vZ:$>gGY>gX~ѩvYl>a*u<Ő>m"6u4u>T\pR>qȍ"t.X>9>s5סyWr@UF>t<=p/ԒVԁX>uy3žl!jbcy>vTAжeCҾh!K>v+^)*nSn,>ubˉyO* ƾqZ>s$a3a&߾sE 7>q9>M0uMak:>n5UCr>];0vgkG>hk2_>e׍2dv@hB>b&
>l@O|qhuW%V>Ukk	>pP>t`n{>7Ug>s0s٨?r`8IC>t&0p3mWY|3_a>uUCjl
9䅾d(e_?>v7uceu9fj]!4v>uϠGX{#prB>t
ʾ@|(Qr*&>rH5>@mgts9>p^@RVoU>Xi0T!uۻ?>jjP?>co۾v(n>c {>j/uNP>Wx>pxYtk>><7ղ>r7rYC>tV˝&MpR$MZMnQ%>u=ݖiU1FLdqV>v-hb/
_l
.>uT#w%	9q>t!;/(1-srJ}J>q_>LabuqE>n9>T>^,uy>gM>>gO
̜
uJ
>^޸@e>n?~dݾu;B>KA4/X>rsVd!7j.l5̴d>t+aLpӅRcU^]'j>u@&9k<,cce>v¾c靾j!>Q>uljV
p*~R>t=b+2|s3uP>r9&V>Jzjt0(sY>n'QlI>^!uޢ%>f	E>g=]#~ulM.>]:B>n:
t{kwc>FV>rR3arג<&8>toQpYgkum+i4e=`>u?u".(PtPC1qܒG>shg؏>%
usE;@>pׂY>URN12umnâ;>j{3>c_Qu4+2>bSF`V>k^X+uLZD6>S->q,sT}=0o>sXtq'{R7L:>uDZ>dkME㈾b#6?>uƊrch5@ ja>>uY)yT%pߜ>sͬo 7?sBg>qDP.}އ>RAu1F8>kbVodg(uu}|>czE>j
PcuQ>Tuc<*>p쵾s/$k>vU
>s$u52t2kI3bh>uZTbՉk=eu>u3)v.R0@ ¾q!>sM>sN>54ishp>pl8=>U
ӴuNr>jB;wBG>cDue]>a2>lR~մtڇ>OtF>qFPIsuu%e21r>tgߤp&GYƾX=p>ur,h'ҳʾe)>uSN_\D
mnJM>tXFk/r9›>rx.<2>B=gtzhr>nuo">]yg3L;up>fW>guuvR|L>Ys>ontex>5rt#FlOgJaDT>u$ʾcduPhjCy>u~S/S66hq\u>sZ9yO>j6Jsh]F>pnRο>V'RuMnrM>iM2>e*!EuG͆>_z/">mN/tHJ2ZD>Ev}G>r9ȪrLoiD3?Zo>t_LHQDm2ϊn_le>uxeEfh灣j>uFԴMV.pk"A>ssھ1tҾs^S}51>pva>Sʾu97>j`Lj>d/ҹu^c{>`H>lrtm]>I>7`>q-rsB'5 >t_l	n'Ifҋ^+Ka>u}~ezfw2lRh۞b(>u>qJVX(pc3oO>sg݈?As`Ze"6>pؘY>Tp#;u^ >iR$U&>dz3Ou],hi>`
3->mcXBSt}>EMFe>r3
TJr#`rFx3>tvCվm0~J~`HL)>u~d+mFi㾨jG>uZSѵIpg(>s72>#.&s 䮗>pHڽ'>XgxƴuC+>gδ=>f_Ff.u^Ƕ>[)83>ot
*R^>6o>rAQqZɓѓP94>tܞBj`Gbɪ>u{]'ah.﫾l>Q->t&J3q_he>ram#>BrqftSl>m-O;w>_Yulwi>dLr>ipVZ\uAm*q>T*PMpɮp{s4Zپ"eGH>sjpw:FX[9~>u<)Dygv,qUfeƥ>uJEZloq,>sξ0- )sR50>q5>RDn+tEl%>iqeK>d8LuhI>`X%>mQvtZRtr>C~7k>rD?mq\rI{_>tKl#=Ga|!>ul#1ĸpbvEHPkt}QNFqe{`>r>>{s@оt*;Z>nwp>^,C$2<(uZ@>d؇>i:gǾt1ab>TxK>p3s#͙3'!>s.
of,u9bZhf+YgO޺>u-NXzbsxtp
e>siΏ5H8s@m:>p0|>Uuc>h%\D>e6uJ3>\i!!>nUsUX>6_>r-+q$nAQ"A9T>t@xmjpca%>uYđOƾ_`$|zmRJ>tCp7B,_6rSZ>qpr[>LA锾tTwvhP>kwc>ba.&>l2IOþt4>I$UK>qn%ުr;?E!AU>tb!dlꬾ`ԃ7y>uYwo#b?!zjA2>tO#Krqr3>rz(>?H;t%7Kn>m4>^ֆuOi>d.J>i1vtFj>R; U|>q
Ns
r}5?sQ>s0w;nĸf\v>uAN`-eIh
4j`>tpD9TZ|Fp1>sc->'IN~?,s{>c>ok.^Jv>Z=u0(l4>fD@+[>gLu(>VǰGS>pN>XsNқ2ҚItB>sve3pu`˘X9" >uJ3egg"f=n>u!wF(VX2hxoPT>s)*U+exsA+Y>p^K!>VdVu	->g_!@>f!D`u.e(>Zls>oWB5sr>'9>s|P'p@DN^TJz>t/hI×teh粌>u8f?~[Rp#־nKˢu>sW&2:Z[rV(g>p=0>S8k`(Bt	#	c>i4:
>d$֝au@Kg>][^j
>nD'Iksj]>7r>r@|q'4߾Qڤay>t\Ria=d&h{>uEmO^*\nm=!>tQ>= ˾rѲ˛>qE7>P%Yutj>j<#
q>c:uIP+>_;h@>m^
Ⱦt(r>@eMb>rg2qnS;IOh>t]UajBԾc'kƣ>uK)&u̾`M,m>t:eK.BB9탾rLpEZ>q'+>MKltnZ>jcXR>bTCuM{k>`t7KH>lz:Lt;VZ>BF>ra4ތqf3wPVP>th1|iI\>z	q3>wOHJY4оq/O>xW`?bodC>xLxf˾dZcFlR@>x͍ygg?Yi1q2>xа;j}|{f L>x[WmW#TbB*>xw&zog2/l_w%-s.>x"&3q+NYF0>w_@r?9^S56*X5L>w5b|s6cۥ#J+>v1tEW>J2->vDQpt]Z3 j2^K$>uYBu~8.>)u>t&HJHv/>@ߎpB>s\Bv5b1>J=U.>s.h/̍v_q>Q>rnNP5wSAh>U
t>q,w5?>ZQL>p\ptwGs>]Bޖ3>p25nxv>`
G>nB?Kwx#{x#>bQpb>>m!;x:4F>cַʹU!>l7l3xHym>e=
9>jK^5xOz\>f>i:xPTI>g1	">hăiþxL-(>h!9`>gw6fXxD
x>ihgr>fvb
.x8%>jzF>eXPx+ܿT>kUwy>d?SC.x/9>lW_
B>cFx
H>l/֊>cG~?|w,YP>m9J>bشwf#w94>myU_h>b5uw;Zn>m&}ւ>aZawռ{t>n6;>a㞼ɼwXn76>aGBwH>nNW>a&Gw|t>nS]c>aC9uȾw>Ԡ!Q>nDʲ>a)ů+wn>n#{^>aMpGݾw>m4N(>az
#wʢU%>mh|>aץ~񮥾w-'>mMTE>b=3MwrZv>l>bčw+d>l^F>cIqwE!b>kȮ|>cNwA>kS>dnwĐ:V>j_ft'>eq>U
wƑb7>i8>fNM~wƕO>hT,>g=ھwެ>gz[v->h<>pw<>f֙-7<>iKHwZz;>eUv$i>jgUxOwMa>d.u%>k{fw^)[>bb?>l?woS}b>a13R>nK{GwI2>_;D4F>oE]SwZQ>[NDTl>pGZ&v஋ۨ>XS(֋>p1Xvg!C>T">qQfTvIc4M(>P[@>r9
h:u邐g
>HS>r'&ZuzJ2>@R>s|nӮIt>*">-ALz u>t.ƓVXtk,NAHM>tbƾsɟ|:7ar)0>u2;
ȬsEsmE<>uorK=y"OY*3>v"BvqnLUܰ>vM=پp{~7G*ZcU>v+itmn$+_?K>w+l9hbg+k>wB$5־jC+.7e7py>wU.;g#8Sgz>wPH@l:ddꋾj|J^t>w/+bxm	E>>vϔJ^]w`ݾoT`>v.׳xWR=pj Z>v|wP鹯c톾r
R>u~Z-D@@sli>t}3F'O8U*t
{`>sۄq>1b-W#tUU>rg|t>Gpz˳ϾuUΏ}>qQU>S(Nv6sd>pY+>ZFvJ'fj>m^j>`)lvz/q>j~iSԉ>d31[þw/{#D
>g9,:	>h+=ewp>cD
>kf?zv{X>__O>nٸ;}vk`e>W;iIǂ>p;þuyOc>M]>rN~!ľtoE>8҃-Gz>s$ǫ8souR'+HSx>ten
rUGmߕ>u{bqIL9W̾T+I)+>v5䓼q3oQ@:]25U.>v^ko}cT]T
>v>F޾g"LgB>v6Ecn۾k<>vͬjپ]&HoU,(7sh>vST&O@qb
o>uMES~ԾDer>t:rs)6>DnuIbH>qIR>TsEvyG>nH%$>^y_v'O>jOF>dN!vR1>f$@v>hZGJv4uHG>a3>mamXsv?WK>W6B>pO-6uw|>IϲX>rt̡֘tZpbҞ>^%wQ>s%~RrxվCqu(VϾq(nU"MO>v
en6n|`ݿ4$>vcii]3ev+L]>vdqfk;ƾj|?>vq8]e;)o;Ew>u̺P4zR&ٛPq`&>tC,t8$蚿c|s]>sTR>91CjtTt4>qB=O>RMpޣ)u +)>n#(>^оvito)>iy>e"|#=ξv3
>dNq]%>j0vQY>\.>ow5u2c>P"ap>qgzR]tf>(ch>s	{grG^D'u5Xp'"cRW&dh_}>vt-lZEaޞG>vvBg~g',Hg4P`>vi
`Am[	a>u<\2T&q=>tcHs0->:;՚=tF^>q" b1^>T5u'f>mIs>aJT:vZ:$>gGY>gX~ѩvYl>a*u<Ő>m"6u4u>T\pR>qȍ"t.X>9>s5סyWr@UF>t<=p/ԒVԁX>uy3žl!jbcy>vTAжeCҾh!K>v+^)*nSn,>ubˉyO* ƾqZ>s$a3a&߾sE 7>q9>M0uMak:>n5UCr>];0vgkG>hk2_>e׍2dv@hB>b&
>l@O|qhuW%V>Ukk	>pP>t`n{>7Ug>s0s٨?r`8IC>t&0p3mWY|3_a>uUCjl
9䅾d(e_?>v7uceu9fj]!4v>uϠGX{#prB>t
ʾ@|(Qr*&>rH5>@mgts9>p^@RVoU>Xi0T!uۻ?>jjP?>co۾v(n>c {>j/uNP>Wx>pxYtk>><7ղ>r7rYC>tV˝&MpR$MZMnQ%>u=ݖiU1FLdqV>v-hb/
_l
.>uT#w%	9q>t!;/(1-srJ}J>q_>LabuqE>n9>T>^,uy>gM>>gO
̜
uJ
>^޸@e>n?~dݾu;B>KA4/X>rsVd!7j.l5̴d>t+aLpӅRcU^]'j>u@&9k<,cce>v¾c靾j!>Q>uljV
p*~R>t=b+2|s3uP>r9&V>Jzjt0(sY>n'QlI>^!uޢ%>f	E>g=]#~ulM.>]:B>n:
t{kwc>FV>rR3arג<&8>toQpYgkum+i4e=`>u?u".(PtPC1qܒG>shg؏>%
usE;@>pׂY>URN12umnâ;>j{3>c_Qu4+2>bSF`V>k^X+uLZD6>S->q,sT}=0o>sXtq'{R7L:>uDZ>dkME㈾b#6?>uƊrch5@ ja>>uY)yT%pߜ>sͬo 7?sBg>qDP.}އ>RAu1F8>kbVodg(uu}|>czE>j
PcuQ>Tuc<*>p쵾s/$k>vU
>s$u52t2kI3bh>uZTbՉk=eu>u3)v.R0@ ¾q!>sM>sN>54ishp>pl8=>U
ӴuNr>jB;wBG>cDue]>a2>lR~մtڇ>OtF>qFPIsuu%e21r>tgߤp&GYƾX=p>ur,h'ҳʾe)>uSN_\D
mnJM>tXFk/r9›>rx.<2>B=gtzhr>nuo">]yg3L;up>fW>guuvR|L>Ys>ontex>5rt#FlOgJaDT>u$ʾcduPhjCy>u~S/S66hq\u>sZ9yO>j6Jsh]F>pnRο>V'RuMnrM>iM2>e*!EuG͆>_z/">mN/tHJ2ZD>Ev}G>r9ȪrLoiD3?Zo>t_LHQDm2ϊn_le>uxeEfh灣j>uFԴMV.pk"A>ssھ1tҾs^S}51>pva>Sʾu97>j`Lj>d/ҹu^c{>`H>lrtm]>I>7`>q-rsB'5 >t_l	n'Ifҋ^+Ka>u}~ezfw2lRh۞b(>u>qJVX(pc3oO>sg݈?As`Ze"6>pؘY>Tp#;u^ >iR$U&>dz3Ou],hi>`
3->mcXBSt}>EMFe>r3
TJr#`rFx3>tvCվm0~J~`HL)>u~d+mFi㾨jG>uZSѵIpg(>s72>#.&s 䮗>pHڽ'>XgxƴuC+>gδ=>f_Ff.u^Ƕ>[)83>ot
*R^>6o>rAQqZɓѓP94>tܞBj`Gbɪ>u{]'ah.﫾l>Q->t&J3q_he>ram#>BrqftSl>m-O;w>_Yulwi>dLr>ipVZ\uAm*q>T*PMpɮp{s4Zپ"eGH>sjpw:FX[9~>u<)Dygv,qUfeƥ>uJEZloq,>sξ0- )sR50>q5>RDn+tEl%>iqeK>d8LuhI>`X%>mQvtZRtr>C~7k>rD?mq\rI{_>tKl#=Ga|!>ul#1ĸpbvEHPkt}QNFqe{`>r>>{s@оt*;Z>nwp>^,C$2<(uZ@>d؇>i:gǾt1ab>TxK>p3s#͙3'!>s.
of,u9bZhf+YgO޺>u-NXzbsxtp
e>siΏ5H8s@m:>p0|>Uuc>h%\D>e6uJ3>\i!!>nUsUX>6_>r-+q$nAQ"A9T>t@xmjpca%>uYđOƾ_`$|zmRJ>tCp7B,_6rSZ>qpr[>LA锾tTwvhP>kwc>ba.&>l2IOþt4>I$UK>qn%ުr;?E!AU>tb!dlꬾ`ԃ7y>uYwo#b?!zjA2>tO#Krqr3>rz(>?H;t%7Kn>m4>^ֆuOi>d.J>i1vtFj>R; U|>q
Ns
r}5?sQ>s0w;nĸf\v>uAN`-eIh
4j`>tpD9TZ|Fp1>sc->'IN~?,s{>c>ok.^Jv>Z=u0(l4>fD@+[>gLu(>VǰGS>pN>XsNқ2ҚItB>sve3pu`˘X9" >uJ3egg"f=n>u!wF(VX2hxoPT>s)*U+exsA+Y>p^K!>VdVu	->g_!@>f!D`u.e(>Zls>oWB5sr>'9>s|P'p@DN^TJz>t/hI×teh粌>u8f?~[Rp#־nKˢu>sW&2:Z[rV(g>p=0>S8k`(Bt	#	c>i4:
>d$֝au@Kg>][^j
>nD'Iksj]>7r>r@|q'4߾Qڤay>t\Ria=d&h{>uEmO^*\nm=!>tQ>= ˾rѲ˛>qE7>P%Yutj>j<#
q>c:uIP+>_;h@>m^
Ⱦt(r>@eMb>rg2qnS;IOh>t]UajBԾc'kƣ>uK)&u̾`M,m>t:eK.BB9탾rLpEZ>q'+>MKltnZ>jcXR>bTCuM{k>`t7KH>lz:Lt;VZ>BF>ra4ތqf3wPVP>th1|iI\>z	q3healpy-1.10.3/healpy/data/weight_ring_n04096.fits0000664000175000017500000062500013010374155021640 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-17T23:24:43' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                24576 / width of table in bytes                        NAXIS2  =                    8 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                 4096 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                12288 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1024D   '                                                            MAXVAL1 =   1.634655721049E-01 / maximum value of T weights                     MINVAL1 =  -6.829251779909E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1024D   '                                                            MAXVAL2 =   1.634655721049E-01 / maximum value of Q weights                     MINVAL2 =  -6.829251779909E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1024D   '                                                            MAXVAL3 =   1.634655721049E-01 / maximum value of U weights                     MINVAL3 =  -6.829251779909E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?p9
{R3?jj&{{gZk!?{쓫HwOp?h*~l3-Z0[H5i?b3Q]#!?G4g6?8,qPťr?RlG?S)C?H?<'jF*)q\|\ت50>?,Lu,ֿ
d?9[B?yοu?q˂
9fV>H`??	sjRXd?O0f8H?̀J?
e^I^Hh?8q,\97K?
IbI
դt
>G֤>K¢VĿͶ?
dd
ڿH>ڶ4]>^.x]?;q	a.pSW?BD(d>~l#Sj>IsS܍?	٩hF>">9Xy?(Θ()Fi>T2pb>1thc9>l55Q7<_خ> P{䨾c=];1>GuyX>bC׾>ULytld>>/
B|߻M>ň/gB>zKT>ݭk[Y/Ni{_>t,n->]a?>Tn)4L>3\BCr1	,.1y>ɔپF,>r90- >!.!Q1C>g>ϋR%zq:*>`%$>Ā?e>X~.U_>#5*ˊn®i>"[OLṘS>V]VȂ|r7>Kzɠ/͢>">tF.=>@rA7Q{a>kP#>L0 C^>焘^FS?m>;hxM>g^uO<12G"5>:kmI㢿V>8;?3	u*o>>&ONX)>ba>CjF>PAj7>+aA#>՜[|(򸃁>໢ X#b۴q>wqqhᎦIl=>٨ Z`d>XCĄ_ >64.>!XبŽ>}ؒRn>s>VjEev>T!oZN>PR6>׀?hɾGN65MhMbF>QE,>i2\ղX>ڃE-rKa'>}D&0>U ւ
b:0>l|5ry>\'"{*>|Tt%֢>if	-VC>`9wXs>"_4痾eL>,"We@@>	6>^nˌѷI6>ն
Zmς/}>	B>ƥOmf>g(9jþn	3>KB{,t>я=־qΛaХ>$K4nBҲ>ĥr>׻D0N˅z>ҸO
w'^/>b^
2>[nN,/'>z|22re>Š>V4(X8P+>Zl*sAk¾lK+>ͱXЌoJ>aߕӻIQԱ?7\-A>!DA}13)>
G>8Z_ʽ˚">HQmBPŃ5i1
>1C>"zX͟F!3>˒vQp62ب{>1e	́*>Ńw]]WJ쾾M֯>EWʜmD%>;a+>C5gEjv>_uBfV.yCk8>?	fZ>ɝuw]wɾa˔7T>jNϾK<>/J >yL:Ce!>P*xȕrm'>hc>q>iN$H@{~>	>9mPF5~>Lj}hS{>jӊf"y>7K$J%b>~nn01}ڸ+>)kuq>p6Ծc3㾹6=4fXp
R>LI>gҁd>_BϐʾjU>ӆwL>a=kêҴ>Åoq;8۾>ZZE]>ɾ Hb>(5d]ݚ>0Ŀ?|>|6$$b>)6!9>樮dyC>jÙ#>RD򱤾.j=)fP̓5>펾'
$Qr>'ţھ~f@#x>ш)SDY>)}OَW䭰5>8IDV>K<Q>|rl侻W>[ ׾dx@>p>C>:%du12Ro>O:B92B>\0xnjTIqg>edwޑx8>d*J>K	E`T2N>ְ4ܓ-@Oe>8e^n>,:F-aa>\@Z,K(%;s4
V->ѨkC9;{j{>?<%U$,2>hl~/!>MU}ھnnWH
>~tؾ*PL>&>(hBʤ^YH>0E1>/H>O㠼	^>y!CS
_׾kx>nҾwdl>3^q8 7@EQ$>*,2Vlm>Y[>qmH‘y>SzvC>O`p>Mv k1{>j+q@um>j~q>8[;
S|Fr4ky+9>>\L`G>[Bhs1R(N>9d+PdX]>`]>Ƴo@>Քt\^8H>&Xa>oS)iy|ˀn>3:2/΋ZZ>.	((>y?d`J8	*2&>>cGύ>h"Z߾_>&n/y{P3ʆ|>>ç澲s>A!1_B?Tewԕ>ϐ@--3>澚RDa>0(OJ>սoq#m{> <{1d>|`6#o>$˾` >G>5!*V-~k>?2>(8xr~<>4lP2׾nt>U)ҾE>5fӾ9j}/׼6>Ԯ`(>2>xƵоCe>Ń@̒M>73f>ޣw-1}/>SÞ/[r=.)F>.ġK
U>Y=TdK.n>y9M\>^fwxд>(E)&>6m>9#+4ds>KWt\Jj>,gPU>
AH[Yeu>ŝ0L;S/9(Y>NvG	C^>>\|I\P%>@li$LӾК3>D>b	>`nh>0
{>;Zi>!;	6>$x9>j,T>ήj
l!>}8PƾwdD>H\qu(iZo&>M׋(Y0򾾞]O>_CNi 73>tF>fsD.SR>_jYr>һ}>jI 3>*Ϣ؀ucA۾jڸ朕>0YnL.9>-ll^eZkz>*W>9o_1ؾZA>'8('9
@> X7>a$du>`ڻn¾>x>{&yx>]2Ҿ}Ϣ?>V
Pф->D|>^	z>J[BVwGsN}>oZzd~c>L/_'>j6*1"=+>Wv뾥yx>PO>oujUzm>7]ߛ [
]g>YW>dže% >pAݾtjv@&ue>r+wM{>bU1y\pՇU>M+$fr>+9>}ي&[r֙J>1YjGw>_l?>!v-pkk>r	Ve?"
>Ű{`꾦\>7g=}l2z?->4%aԘT[>݃_UկXd]Uܙ
.ɐe
>kE>?$ڏ$rOe7>TTﾠI>y*#S>r#E;2|>W۾6㯾w٬>#44
S$>(K꾅-ʉw2hi>A9[[2>%D>V\.о0MOo>EsIQ*w>m#>9O2MrS[>CpEJ)1>gtD>HaY>HXᘚb9TqD),>.0=9Ь">6w*|(G >'a5Sf>POB>p,蘾oQ>)Uez>-y
i>*[P6ս>S->0[>
ANk(>c}Rvd1dXe>oϾqđ(Q*>ds><;#׻0>>wGAپBZ|>y59|>oQ<>Bw4ؾ8i!E>F#<Ѭ\ j>Xr~#99>EK'.:7٤,ݾ~$>LHA\U>3վbRpm߬x>DžhQ-?!>5
6>}gi(ה>d>xΏ,=>2FHFQ1%>	)jAO>Rp5𾠆8>e\᭾ʜ
s>Ԕ_$#~T-_>?VL〤Gw|9[P<>nƾɳ??>FqY>$e{\>}"؏~>rTZu>^<ۛ<>,s	Sq#D8Z>ր5쾟F; >x@߼O,a>^6?v>>:岓>7+*l?1X>I>=Vz)E*>[G
>xGWc D_oU>(5[㏾N޾>kp!]u>7r|(}>:;Dswϯ>E:S+Q>;پ|9bɾ)NҸ
>zz0n(na7K>9f->Pz=-%8>4,ž%8>B>YSGA%?>w90
qs>e41>Fr`q:
*>9Lǝ*c=/gtYn6:>ck+
`KQ>T7y	5xoߏ>=ኾ;7>bwÓ
>UPd_`>RG^-A>TCL;\N:>1l@у+,>bujz>R
\ž~Q>7pFks
>a7>؃l-wC#۠ >i+j>x>U_|}0z$>OZn>;J8t>n@ć[>'CX8>a3>A޲뾘m3>bh[OT@#GrL15>C\G9s>\{vZ3,®>dH쾘0Z7>Y(/>PH1mkYTB>fdpN>$Y"R>~'6,/?S}>T$Nھ9`T7>cP@Z>yO_2M>ȾpϿKN>8~,S>)a3rld>aK>@RNP>v֝ji>%&ei>z s?2>3э7z>gXn;m7'>d%΋H>y*ؾ)!ξiST>\nt*pL>g!xMYxE>+) d ->7¾.v)ⲕ>.侔Kg>F>v^9辑T>'5v8YK>l
>яgp}d>(`w=	⑾aG@d4>Z^	_a>CكB{{:~dy>9]jK,!>ߓ'gRϲ-ᾉ;oi>*avʪ>n>qnЏľp>(Yl7Ns+}l&>q\ R>Nt$U#>@^bgWBK0Pkt\>Zxݾ>ؠ~><˾y]>7Axq><*ɾbYs;d>ZVPmYv%>J>gs>*񓾐uh>uU`>yh>:v!W/&>5
V/>WVɿ,>ҡ!|;Ө9LRr>\t7龓Җ~>m-ѾlVGuGA>;sۮ0p>)G>W7Ⱦh>#2>zX5p>xjᾐ;FԮk6>߹BоuTP>\)Ǟ>yݾSG>?
h#v'>%%h4yfE>hT9s;~ -),?p9
{R3?jj&{{gZk!?{쓫HwOp?h*~l3-Z0[H5i?b3Q]#!?G4g6?8,qPťr?RlG?S)C?H?<'jF*)q\|\ت50>?,Lu,ֿ
d?9[B?yοu?q˂
9fV>H`??	sjRXd?O0f8H?̀J?
e^I^Hh?8q,\97K?
IbI
դt
>G֤>K¢VĿͶ?
dd
ڿH>ڶ4]>^.x]?;q	a.pSW?BD(d>~l#Sj>IsS܍?	٩hF>">9Xy?(Θ()Fi>T2pb>1thc9>l55Q7<_خ> P{䨾c=];1>GuyX>bC׾>ULytld>>/
B|߻M>ň/gB>zKT>ݭk[Y/Ni{_>t,n->]a?>Tn)4L>3\BCr1	,.1y>ɔپF,>r90- >!.!Q1C>g>ϋR%zq:*>`%$>Ā?e>X~.U_>#5*ˊn®i>"[OLṘS>V]VȂ|r7>Kzɠ/͢>">tF.=>@rA7Q{a>kP#>L0 C^>焘^FS?m>;hxM>g^uO<12G"5>:kmI㢿V>8;?3	u*o>>&ONX)>ba>CjF>PAj7>+aA#>՜[|(򸃁>໢ X#b۴q>wqqhᎦIl=>٨ Z`d>XCĄ_ >64.>!XبŽ>}ؒRn>s>VjEev>T!oZN>PR6>׀?hɾGN65MhMbF>QE,>i2\ղX>ڃE-rKa'>}D&0>U ւ
b:0>l|5ry>\'"{*>|Tt%֢>if	-VC>`9wXs>"_4痾eL>,"We@@>	6>^nˌѷI6>ն
Zmς/}>	B>ƥOmf>g(9jþn	3>KB{,t>я=־qΛaХ>$K4nBҲ>ĥr>׻D0N˅z>ҸO
w'^/>b^
2>[nN,/'>z|22re>Š>V4(X8P+>Zl*sAk¾lK+>ͱXЌoJ>aߕӻIQԱ?7\-A>!DA}13)>
G>8Z_ʽ˚">HQmBPŃ5i1
>1C>"zX͟F!3>˒vQp62ب{>1e	́*>Ńw]]WJ쾾M֯>EWʜmD%>;a+>C5gEjv>_uBfV.yCk8>?	fZ>ɝuw]wɾa˔7T>jNϾK<>/J >yL:Ce!>P*xȕrm'>hc>q>iN$H@{~>	>9mPF5~>Lj}hS{>jӊf"y>7K$J%b>~nn01}ڸ+>)kuq>p6Ծc3㾹6=4fXp
R>LI>gҁd>_BϐʾjU>ӆwL>a=kêҴ>Åoq;8۾>ZZE]>ɾ Hb>(5d]ݚ>0Ŀ?|>|6$$b>)6!9>樮dyC>jÙ#>RD򱤾.j=)fP̓5>펾'
$Qr>'ţھ~f@#x>ш)SDY>)}OَW䭰5>8IDV>K<Q>|rl侻W>[ ׾dx@>p>C>:%du12Ro>O:B92B>\0xnjTIqg>edwޑx8>d*J>K	E`T2N>ְ4ܓ-@Oe>8e^n>,:F-aa>\@Z,K(%;s4
V->ѨkC9;{j{>?<%U$,2>hl~/!>MU}ھnnWH
>~tؾ*PL>&>(hBʤ^YH>0E1>/H>O㠼	^>y!CS
_׾kx>nҾwdl>3^q8 7@EQ$>*,2Vlm>Y[>qmH‘y>SzvC>O`p>Mv k1{>j+q@um>j~q>8[;
S|Fr4ky+9>>\L`G>[Bhs1R(N>9d+PdX]>`]>Ƴo@>Քt\^8H>&Xa>oS)iy|ˀn>3:2/΋ZZ>.	((>y?d`J8	*2&>>cGύ>h"Z߾_>&n/y{P3ʆ|>>ç澲s>A!1_B?Tewԕ>ϐ@--3>澚RDa>0(OJ>սoq#m{> <{1d>|`6#o>$˾` >G>5!*V-~k>?2>(8xr~<>4lP2׾nt>U)ҾE>5fӾ9j}/׼6>Ԯ`(>2>xƵоCe>Ń@̒M>73f>ޣw-1}/>SÞ/[r=.)F>.ġK
U>Y=TdK.n>y9M\>^fwxд>(E)&>6m>9#+4ds>KWt\Jj>,gPU>
AH[Yeu>ŝ0L;S/9(Y>NvG	C^>>\|I\P%>@li$LӾК3>D>b	>`nh>0
{>;Zi>!;	6>$x9>j,T>ήj
l!>}8PƾwdD>H\qu(iZo&>M׋(Y0򾾞]O>_CNi 73>tF>fsD.SR>_jYr>һ}>jI 3>*Ϣ؀ucA۾jڸ朕>0YnL.9>-ll^eZkz>*W>9o_1ؾZA>'8('9
@> X7>a$du>`ڻn¾>x>{&yx>]2Ҿ}Ϣ?>V
Pф->D|>^	z>J[BVwGsN}>oZzd~c>L/_'>j6*1"=+>Wv뾥yx>PO>oujUzm>7]ߛ [
]g>YW>dže% >pAݾtjv@&ue>r+wM{>bU1y\pՇU>M+$fr>+9>}ي&[r֙J>1YjGw>_l?>!v-pkk>r	Ve?"
>Ű{`꾦\>7g=}l2z?->4%aԘT[>݃_UկXd]Uܙ
.ɐe
>kE>?$ڏ$rOe7>TTﾠI>y*#S>r#E;2|>W۾6㯾w٬>#44
S$>(K꾅-ʉw2hi>A9[[2>%D>V\.о0MOo>EsIQ*w>m#>9O2MrS[>CpEJ)1>gtD>HaY>HXᘚb9TqD),>.0=9Ь">6w*|(G >'a5Sf>POB>p,蘾oQ>)Uez>-y
i>*[P6ս>S->0[>
ANk(>c}Rvd1dXe>oϾqđ(Q*>ds><;#׻0>>wGAپBZ|>y59|>oQ<>Bw4ؾ8i!E>F#<Ѭ\ j>Xr~#99>EK'.:7٤,ݾ~$>LHA\U>3վbRpm߬x>DžhQ-?!>5
6>}gi(ה>d>xΏ,=>2FHFQ1%>	)jAO>Rp5𾠆8>e\᭾ʜ
s>Ԕ_$#~T-_>?VL〤Gw|9[P<>nƾɳ??>FqY>$e{\>}"؏~>rTZu>^<ۛ<>,s	Sq#D8Z>ր5쾟F; >x@߼O,a>^6?v>>:岓>7+*l?1X>I>=Vz)E*>[G
>xGWc D_oU>(5[㏾N޾>kp!]u>7r|(}>:;Dswϯ>E:S+Q>;پ|9bɾ)NҸ
>zz0n(na7K>9f->Pz=-%8>4,ž%8>B>YSGA%?>w90
qs>e41>Fr`q:
*>9Lǝ*c=/gtYn6:>ck+
`KQ>T7y	5xoߏ>=ኾ;7>bwÓ
>UPd_`>RG^-A>TCL;\N:>1l@у+,>bujz>R
\ž~Q>7pFks
>a7>؃l-wC#۠ >i+j>x>U_|}0z$>OZn>;J8t>n@ć[>'CX8>a3>A޲뾘m3>bh[OT@#GrL15>C\G9s>\{vZ3,®>dH쾘0Z7>Y(/>PH1mkYTB>fdpN>$Y"R>~'6,/?S}>T$Nھ9`T7>cP@Z>yO_2M>ȾpϿKN>8~,S>)a3rld>aK>@RNP>v֝ji>%&ei>z s?2>3э7z>gXn;m7'>d%΋H>y*ؾ)!ξiST>\nt*pL>g!xMYxE>+) d ->7¾.v)ⲕ>.侔Kg>F>v^9辑T>'5v8YK>l
>яgp}d>(`w=	⑾aG@d4>Z^	_a>CكB{{:~dy>9]jK,!>ߓ'gRϲ-ᾉ;oi>*avʪ>n>qnЏľp>(Yl7Ns+}l&>q\ R>Nt$U#>@^bgWBK0Pkt\>Zxݾ>ؠ~><˾y]>7Axq><*ɾbYs;d>ZVPmYv%>J>gs>*񓾐uh>uU`>yh>:v!W/&>5
V/>WVɿ,>ҡ!|;Ө9LRr>\t7龓Җ~>m-ѾlVGuGA>;sۮ0p>)G>W7Ⱦh>#2>zX5p>xjᾐ;FԮk6>߹BоuTP>\)Ǟ>yݾSG>?
h#v'>%%h4yfE>hT9s;~ -),?p9
{R3?jj&{{gZk!?{쓫HwOp?h*~l3-Z0[H5i?b3Q]#!?G4g6?8,qPťr?RlG?S)C?H?<'jF*)q\|\ت50>?,Lu,ֿ
d?9[B?yοu?q˂
9fV>H`??	sjRXd?O0f8H?̀J?
e^I^Hh?8q,\97K?
IbI
դt
>G֤>K¢VĿͶ?
dd
ڿH>ڶ4]>^.x]?;q	a.pSW?BD(d>~l#Sj>IsS܍?	٩hF>">9Xy?(Θ()Fi>T2pb>1thc9>l55Q7<_خ> P{䨾c=];1>GuyX>bC׾>ULytld>>/
B|߻M>ň/gB>zKT>ݭk[Y/Ni{_>t,n->]a?>Tn)4L>3\BCr1	,.1y>ɔپF,>r90- >!.!Q1C>g>ϋR%zq:*>`%$>Ā?e>X~.U_>#5*ˊn®i>"[OLṘS>V]VȂ|r7>Kzɠ/͢>">tF.=>@rA7Q{a>kP#>L0 C^>焘^FS?m>;hxM>g^uO<12G"5>:kmI㢿V>8;?3	u*o>>&ONX)>ba>CjF>PAj7>+aA#>՜[|(򸃁>໢ X#b۴q>wqqhᎦIl=>٨ Z`d>XCĄ_ >64.>!XبŽ>}ؒRn>s>VjEev>T!oZN>PR6>׀?hɾGN65MhMbF>QE,>i2\ղX>ڃE-rKa'>}D&0>U ւ
b:0>l|5ry>\'"{*>|Tt%֢>if	-VC>`9wXs>"_4痾eL>,"We@@>	6>^nˌѷI6>ն
Zmς/}>	B>ƥOmf>g(9jþn	3>KB{,t>я=־qΛaХ>$K4nBҲ>ĥr>׻D0N˅z>ҸO
w'^/>b^
2>[nN,/'>z|22re>Š>V4(X8P+>Zl*sAk¾lK+>ͱXЌoJ>aߕӻIQԱ?7\-A>!DA}13)>
G>8Z_ʽ˚">HQmBPŃ5i1
>1C>"zX͟F!3>˒vQp62ب{>1e	́*>Ńw]]WJ쾾M֯>EWʜmD%>;a+>C5gEjv>_uBfV.yCk8>?	fZ>ɝuw]wɾa˔7T>jNϾK<>/J >yL:Ce!>P*xȕrm'>hc>q>iN$H@{~>	>9mPF5~>Lj}hS{>jӊf"y>7K$J%b>~nn01}ڸ+>)kuq>p6Ծc3㾹6=4fXp
R>LI>gҁd>_BϐʾjU>ӆwL>a=kêҴ>Åoq;8۾>ZZE]>ɾ Hb>(5d]ݚ>0Ŀ?|>|6$$b>)6!9>樮dyC>jÙ#>RD򱤾.j=)fP̓5>펾'
$Qr>'ţھ~f@#x>ш)SDY>)}OَW䭰5>8IDV>K<Q>|rl侻W>[ ׾dx@>p>C>:%du12Ro>O:B92B>\0xnjTIqg>edwޑx8>d*J>K	E`T2N>ְ4ܓ-@Oe>8e^n>,:F-aa>\@Z,K(%;s4
V->ѨkC9;{j{>?<%U$,2>hl~/!>MU}ھnnWH
>~tؾ*PL>&>(hBʤ^YH>0E1>/H>O㠼	^>y!CS
_׾kx>nҾwdl>3^q8 7@EQ$>*,2Vlm>Y[>qmH‘y>SzvC>O`p>Mv k1{>j+q@um>j~q>8[;
S|Fr4ky+9>>\L`G>[Bhs1R(N>9d+PdX]>`]>Ƴo@>Քt\^8H>&Xa>oS)iy|ˀn>3:2/΋ZZ>.	((>y?d`J8	*2&>>cGύ>h"Z߾_>&n/y{P3ʆ|>>ç澲s>A!1_B?Tewԕ>ϐ@--3>澚RDa>0(OJ>սoq#m{> <{1d>|`6#o>$˾` >G>5!*V-~k>?2>(8xr~<>4lP2׾nt>U)ҾE>5fӾ9j}/׼6>Ԯ`(>2>xƵоCe>Ń@̒M>73f>ޣw-1}/>SÞ/[r=.)F>.ġK
U>Y=TdK.n>y9M\>^fwxд>(E)&>6m>9#+4ds>KWt\Jj>,gPU>
AH[Yeu>ŝ0L;S/9(Y>NvG	C^>>\|I\P%>@li$LӾК3>D>b	>`nh>0
{>;Zi>!;	6>$x9>j,T>ήj
l!>}8PƾwdD>H\qu(iZo&>M׋(Y0򾾞]O>_CNi 73>tF>fsD.SR>_jYr>һ}>jI 3>*Ϣ؀ucA۾jڸ朕>0YnL.9>-ll^eZkz>*W>9o_1ؾZA>'8('9
@> X7>a$du>`ڻn¾>x>{&yx>]2Ҿ}Ϣ?>V
Pф->D|>^	z>J[BVwGsN}>oZzd~c>L/_'>j6*1"=+>Wv뾥yx>PO>oujUzm>7]ߛ [
]g>YW>dže% >pAݾtjv@&ue>r+wM{>bU1y\pՇU>M+$fr>+9>}ي&[r֙J>1YjGw>_l?>!v-pkk>r	Ve?"
>Ű{`꾦\>7g=}l2z?->4%aԘT[>݃_UկXd]Uܙ
.ɐe
>kE>?$ڏ$rOe7>TTﾠI>y*#S>r#E;2|>W۾6㯾w٬>#44
S$>(K꾅-ʉw2hi>A9[[2>%D>V\.о0MOo>EsIQ*w>m#>9O2MrS[>CpEJ)1>gtD>HaY>HXᘚb9TqD),>.0=9Ь">6w*|(G >'a5Sf>POB>p,蘾oQ>)Uez>-y
i>*[P6ս>S->0[>
ANk(>c}Rvd1dXe>oϾqđ(Q*>ds><;#׻0>>wGAپBZ|>y59|>oQ<>Bw4ؾ8i!E>F#<Ѭ\ j>Xr~#99>EK'.:7٤,ݾ~$>LHA\U>3վbRpm߬x>DžhQ-?!>5
6>}gi(ה>d>xΏ,=>2FHFQ1%>	)jAO>Rp5𾠆8>e\᭾ʜ
s>Ԕ_$#~T-_>?VL〤Gw|9[P<>nƾɳ??>FqY>$e{\>}"؏~>rTZu>^<ۛ<>,s	Sq#D8Z>ր5쾟F; >x@߼O,a>^6?v>>:岓>7+*l?1X>I>=Vz)E*>[G
>xGWc D_oU>(5[㏾N޾>kp!]u>7r|(}>:;Dswϯ>E:S+Q>;پ|9bɾ)NҸ
>zz0n(na7K>9f->Pz=-%8>4,ž%8>B>YSGA%?>w90
qs>e41>Fr`q:
*>9Lǝ*c=/gtYn6:>ck+
`KQ>T7y	5xoߏ>=ኾ;7>bwÓ
>UPd_`>RG^-A>TCL;\N:>1l@у+,>bujz>R
\ž~Q>7pFks
>a7>؃l-wC#۠ >i+j>x>U_|}0z$>OZn>;J8t>n@ć[>'CX8>a3>A޲뾘m3>bh[OT@#GrL15>C\G9s>\{vZ3,®>dH쾘0Z7>Y(/>PH1mkYTB>fdpN>$Y"R>~'6,/?S}>T$Nھ9`T7>cP@Z>yO_2M>ȾpϿKN>8~,S>)a3rld>aK>@RNP>v֝ji>%&ei>z s?2>3э7z>gXn;m7'>d%΋H>y*ؾ)!ξiST>\nt*pL>g!xMYxE>+) d ->7¾.v)ⲕ>.侔Kg>F>v^9辑T>'5v8YK>l
>яgp}d>(`w=	⑾aG@d4>Z^	_a>CكB{{:~dy>9]jK,!>ߓ'gRϲ-ᾉ;oi>*avʪ>n>qnЏľp>(Yl7Ns+}l&>q\ R>Nt$U#>@^bgWBK0Pkt\>Zxݾ>ؠ~><˾y]>7Axq><*ɾbYs;d>ZVPmYv%>J>gs>*񓾐uh>uU`>yh>:v!W/&>5
V/>WVɿ,>ҡ!|;Ө9LRr>\t7龓Җ~>m-ѾlVGuGA>;sۮ0p>)G>W7Ⱦh>#2>zX5p>xjᾐ;FԮk6>߹BоuTP>\)Ǟ>yݾSG>?
h#v'>%%h4yfE>hT9s;~ -),>NA佻>k*(6>	؃rC>4Kǭ>qyB`7{E>PlQP&#FY>jt0>Dw^>qrT0UЍeSH+yn>{T־ҫq[>kryX6\]vcSkx>jioz>HFy_RM	S%E>4,#>~Z>c/
.\L@d>
׭澌#>sXU>zyz/ξB;># I//
;>F>-r>v>t՗q7sYElIlc>)Q5UI>Lun2^}y>`%{p	>=>9#ᾅƁ>-HZ(v6P>zJj>q@xo(bYK>O7un%7>ez{8>]Nq7N>n]pxOU>jd&I@Ε>KvvK1VuX#>jeb侐0G[>âSN[>uxG>[iK>oQLI#>aZe.!XV50>-13}L]V=>r
,w>wC`>aRg9P:>LV8>e;ft}k>+K}jg"N,{>xaJ>Э|n`Qy+6PY>~1"_jtd>4?fl%&
`t*>ؾ>zm>kWb#;x>wƤ1>iRs
@>{]mn*澋6BK>che?MA6;b>f	+^>yiAw\z'ow>-j$n		0>`f1Rݾp@埝>fu>Mz3uN&>
kq澉Ҿ>u
{>q*P'gR؎쾅C9/3b>`?6>}t5{e>8Jͱs%T>(c>>ű[=uWs0=r5Mz>}4][%>I;ZdB}p>BQC>~9HV[>Y*-qQT>ZE
G>r(h>rKqq8Ε]>NitE>V@~>~*tdqG(>T_|4uƽ\+U>"Z]u~>p{KUos99r>tqkf&>W4R*ؾ~Zv>B F>{nRU>^V{C?%s>oG">p Z>s@
~nd95R>Pa>}EK4>
o5ܾz'o^
|>@r
i8zʓ>gƾo9Yiqr6u><+v>]PA?[X}	66>]#{%)t:>zKn>]zбUlw>mP1Qu>n>>rlIj:.>IMɥ}?}>PNO>|GKk50<>QpǾy(.S[E>J1%N޾Z.>+DoMqf "F>{@Q'nG@}>P>R.N{6ϕ>6+/jM>yɠZ>XkJ; y>
gԨ>o2\s>pN)]>S|GUS׀>y>=8<y>K֡ξzrpоTt8>VuHD俔>ZD.p-ݴnm0:XD> p۾ù>GHaYxxVxnNu>Lw{C>zV
>N`BӾ.C
>jF'ھ|	>qd!=>kM3ȝX_>t}f}gy>^-W>v_,>qɝ9{.GAB+->~>%F|fo>s-,O+r}8!
g@ح>~I*>bGtPtE%>袿7"Y>|,>7U(b|$lDC>0廭׾t-%>s%V)>cذc	)>(ן|g>e"C>rqH%,g>:Ud}{T>#>92<>zyQz>{Q>I0g
^RA>
-#_M(>!Wik\pAl>!!;8"x>~ XwN_C|$x5A>h.A3w>voV>Tv"͛K~룎>|қp->mnn>kQRCL>{~a֨No>X">u~7¾3>-(xZj6Cs>|QJn57>a3!pp]ebN}>{f待&>AʸaiSr%YTي> wI|ƒ
b>zT‡elyxW>G{UM5M;*>s9i	>_?Ծk)>XmZ>fUez>o/UL4>b("| ~ C>K26M>v'3yP>Ae{uHpWRRPvOs>|v8uUD>ikpSlgnhX>Ƣ]0K8>}]OZ
g73c>w?>2e˾yɺQ>^ Ǿ>q,N>aVd~80>ާń(S>cZj>o95n
lpm&>o\;z=H>C[KT>v^omwet}P>NT`t1NT `k'>{"{H较e/b>!yjC!hX+MJ4>+S(<>|qZ:X{W:rdӉ>gVpxF0>v+>1;ԾxYy>Z	Vr0]1>pPy1>`]?FTA}n@=
>	O]վ~xIY>cɅd>mj5Dl>(yTj)>Gr>tQᢖV>D5csFw▞O]>z-ecsJZ>݂k[0eL >~baj`3(>|
!\aތ3¾p9,c>583v(>w#=/,x]%EvdJ>Q8%rx[{>qeۼ>Xx{Pn	1>9)`b*~F࿆7>fu=\;>haƅ~;>
O.վy2>S~>rCWW{FːS*>O/F}t"/8BO>w\_s0>
C.na;3X_PQ>{x&' k>|rR+bèׯ|kD.>~N,mQ>xD1쓾Ius$+Ե>=O"K>sJtH_>G}%TwݩB,~>Ry8~F
l`>k{[>a{U{m0>p|_e{3 <>`T4P>lq_T~^I>'wv"Adu>@ۛ>s8Fs?^>'lLrE/N1+Qu>wmhty">}3|i1bQ!>{
_r>z%pw\Cw͵md/>~jVY¾>uLr}8FT?@sg'>(Pվl{m`>qIz%>PiΈ3wÏC>Gj|>hb3]>cV{(S>syn΋+>[hyI}I:>m#զ}Yj>:|	wup A
>6³B >s%l}O8I>~h.!pZ
O$"w>w"`K&~E(n1o>|=NWh&^MbB#1 =>zqSGMK^>y1|['/k=Q<>}]7>uBmq2<:@Vraʣ>~ʞϗ~>OZK>qZ`A>Jƭ2#v>B[o>¾皾{V^>hN(6B>`IFR?yz_A>{ȝ6x*/>^2h->is|0N>J2$um2G>D<>qBk`}J
>}訡f;qp=[$vBt1YLl>u
[X~~d>{l)!j4fNX/\R	>x@q}y"?Ca0ZCg5ZU>z'n~sXk>uANo׋V}e>|{Ѿ}!OE>r5s]	>+=jsN>}Z{f>lYnT>Uq𽉾v,Av>~)s:ھy5>c|`>cGdyh=}`>~Xu2'ví>U:X>kVPң{v\>}AUsC/+>/>q-Wrɾ|VaZ>|sʷotpKHA%>t~U}yj0>zR;g*^,J>wx}k>w?f]dg`>y 3X}R`>t/w{'n|> >q.ܨ>/X`rg>|vizP>kjm>Tvd'u(ʯ>}μ^x}yח>coW8>bJExcvᅺ>}$yu}>Wss>ivٱ%־yޤJ>|UD:r0>p"WAH{O|`8>{#PoqW
MA9q&>s&叄F|%5Xs>yuDhwpWX>uL|qGj>wVhVa*m4cbm}K>wΓ|7|T>tԈu޾S`e]$굾j97~>y6'{|YiA>qBz1ezϣ4zHc>mˏ0>DPs|Rk>{y䁃x>g2	]>X!DǾuk`>{R/-SvfeH>`RI>cDY*wk
b$>{KcuϾt@=jz>R1x>i	þx>zщqmZ<]>2@E>oM7zz,>y6aYmcnMvBfxߜ>r`[Fzs>x1Fgt%{<>vTɾ`Pc2a'k>vdIv	z	>t(,OT6s켾gdž>xܬzRFr>qB=lqmwe~4.>y=',y\йC>n#&O>6@#
q>p=>y6}x>h}2E>RzXo#J޾vj<>b'`Q>^hq㽾uZScxm>zR-t~R>Y`,C>dTվvk|>y[k	
rSx=>I'~C>jP
Tjվx 6¿>y2ox/>	;#y>o6,eډx݂->x"jњP9F=|>qQzy">vǐiϾe{NV)wM>s(>Qy
u>u(*Av_`ԕU0>uYcvyv9>sLwATT~fE6>v$O+6yZK0E>q=C!KËCc{,jR>ws$xRk>n7>fjo:G(>xp#{SwIE@b>iM)Ë>HeѾq>>xW~v's>db	vV>V'ǞǾsP%8n>x+(ut~rQ>^ge'>`
Dt>x-)^rVF>ToWtx>e>	>v>xl>~p/Q	>D`c>i.*vRv{|>w4pmQW=Ɛz>m3͎w>vf]iVBCƔ>VH>p`x3S->uUѾe!\S*=>rL
VkxG>th$6`R
⁾\W!<>s5*x9Y95~>r!%]W&>bq?>tXdͻw,±>qI8ޤM?g5dZfU>u~woft7>oD(5/
jDX>v׾v@<>kTU>,9{3n(">w#''{uhuI>grKȀ>H}($p)3!>wt&&9tˁ>cqmfS
>TB3r
Sk>w@RUs@J5l>^b>]EsDӋa>wzr7c~>V#I>bi'tMݒ>w4A
pܸ+r>LnJ*'>f|Ou'st3>vӾne>8.>im<%:v%!^VkZWbB>lA7vQ7Չ>ubg>g|:CJ^Rf>o`xtvy+s>t}2g`d;b"ϾQ2AQ>po9Hv˜s>sx윑j`JCdXtU{F>r'PvʤWZ>rXs\6Cv-N>q fSuH6b{z>s8U}vWrS9>o:ROqOG
f	-/>tNu.I>lq|=3ACJ¾h
j>u%F#u]_8>jHv
>0(bkXuž>u,f)t(/>g.16R>AQm),>ulGs}>d5+8>Nyp	]>uXss>a4q*>U9&6qXI>vXbފr,>\aoK>[)İqq>uOMJcӾq-h>V]8>`g᡾ru>u;=ap !)u>Pfw>	f>cjnJs[KĹ>uuԿ噾n
c?>Eu>es"^>u8$XknP>2yF>g^tV>t
ipE@Y4>j>PtM<>tAg,};9fUR>l?ptZڏQA>s|SMdӾGE!q>m)5u*fc>rwmpb=dkPK>ou&VP>rZ7Jd_&-Ut>p/ߟs/u$%
>q[X^3Z̿prZBmn
>q9ɗEq5uAS`;>p;mVs^n>qgIt18R>oztQr4aok!>rUqtYN1>m-mݗ>NA佻>k*(6>	؃rC>4Kǭ>qyB`7{E>PlQP&#FY>jt0>Dw^>qrT0UЍeSH+yn>{T־ҫq[>kryX6\]vcSkx>jioz>HFy_RM	S%E>4,#>~Z>c/
.\L@d>
׭澌#>sXU>zyz/ξB;># I//
;>F>-r>v>t՗q7sYElIlc>)Q5UI>Lun2^}y>`%{p	>=>9#ᾅƁ>-HZ(v6P>zJj>q@xo(bYK>O7un%7>ez{8>]Nq7N>n]pxOU>jd&I@Ε>KvvK1VuX#>jeb侐0G[>âSN[>uxG>[iK>oQLI#>aZe.!XV50>-13}L]V=>r
,w>wC`>aRg9P:>LV8>e;ft}k>+K}jg"N,{>xaJ>Э|n`Qy+6PY>~1"_jtd>4?fl%&
`t*>ؾ>zm>kWb#;x>wƤ1>iRs
@>{]mn*澋6BK>che?MA6;b>f	+^>yiAw\z'ow>-j$n		0>`f1Rݾp@埝>fu>Mz3uN&>
kq澉Ҿ>u
{>q*P'gR؎쾅C9/3b>`?6>}t5{e>8Jͱs%T>(c>>ű[=uWs0=r5Mz>}4][%>I;ZdB}p>BQC>~9HV[>Y*-qQT>ZE
G>r(h>rKqq8Ε]>NitE>V@~>~*tdqG(>T_|4uƽ\+U>"Z]u~>p{KUos99r>tqkf&>W4R*ؾ~Zv>B F>{nRU>^V{C?%s>oG">p Z>s@
~nd95R>Pa>}EK4>
o5ܾz'o^
|>@r
i8zʓ>gƾo9Yiqr6u><+v>]PA?[X}	66>]#{%)t:>zKn>]zбUlw>mP1Qu>n>>rlIj:.>IMɥ}?}>PNO>|GKk50<>QpǾy(.S[E>J1%N޾Z.>+DoMqf "F>{@Q'nG@}>P>R.N{6ϕ>6+/jM>yɠZ>XkJ; y>
gԨ>o2\s>pN)]>S|GUS׀>y>=8<y>K֡ξzrpоTt8>VuHD俔>ZD.p-ݴnm0:XD> p۾ù>GHaYxxVxnNu>Lw{C>zV
>N`BӾ.C
>jF'ھ|	>qd!=>kM3ȝX_>t}f}gy>^-W>v_,>qɝ9{.GAB+->~>%F|fo>s-,O+r}8!
g@ح>~I*>bGtPtE%>袿7"Y>|,>7U(b|$lDC>0廭׾t-%>s%V)>cذc	)>(ן|g>e"C>rqH%,g>:Ud}{T>#>92<>zyQz>{Q>I0g
^RA>
-#_M(>!Wik\pAl>!!;8"x>~ XwN_C|$x5A>h.A3w>voV>Tv"͛K~룎>|қp->mnn>kQRCL>{~a֨No>X">u~7¾3>-(xZj6Cs>|QJn57>a3!pp]ebN}>{f待&>AʸaiSr%YTي> wI|ƒ
b>zT‡elyxW>G{UM5M;*>s9i	>_?Ծk)>XmZ>fUez>o/UL4>b("| ~ C>K26M>v'3yP>Ae{uHpWRRPvOs>|v8uUD>ikpSlgnhX>Ƣ]0K8>}]OZ
g73c>w?>2e˾yɺQ>^ Ǿ>q,N>aVd~80>ާń(S>cZj>o95n
lpm&>o\;z=H>C[KT>v^omwet}P>NT`t1NT `k'>{"{H较e/b>!yjC!hX+MJ4>+S(<>|qZ:X{W:rdӉ>gVpxF0>v+>1;ԾxYy>Z	Vr0]1>pPy1>`]?FTA}n@=
>	O]վ~xIY>cɅd>mj5Dl>(yTj)>Gr>tQᢖV>D5csFw▞O]>z-ecsJZ>݂k[0eL >~baj`3(>|
!\aތ3¾p9,c>583v(>w#=/,x]%EvdJ>Q8%rx[{>qeۼ>Xx{Pn	1>9)`b*~F࿆7>fu=\;>haƅ~;>
O.վy2>S~>rCWW{FːS*>O/F}t"/8BO>w\_s0>
C.na;3X_PQ>{x&' k>|rR+bèׯ|kD.>~N,mQ>xD1쓾Ius$+Ե>=O"K>sJtH_>G}%TwݩB,~>Ry8~F
l`>k{[>a{U{m0>p|_e{3 <>`T4P>lq_T~^I>'wv"Adu>@ۛ>s8Fs?^>'lLrE/N1+Qu>wmhty">}3|i1bQ!>{
_r>z%pw\Cw͵md/>~jVY¾>uLr}8FT?@sg'>(Pվl{m`>qIz%>PiΈ3wÏC>Gj|>hb3]>cV{(S>syn΋+>[hyI}I:>m#զ}Yj>:|	wup A
>6³B >s%l}O8I>~h.!pZ
O$"w>w"`K&~E(n1o>|=NWh&^MbB#1 =>zqSGMK^>y1|['/k=Q<>}]7>uBmq2<:@Vraʣ>~ʞϗ~>OZK>qZ`A>Jƭ2#v>B[o>¾皾{V^>hN(6B>`IFR?yz_A>{ȝ6x*/>^2h->is|0N>J2$um2G>D<>qBk`}J
>}訡f;qp=[$vBt1YLl>u
[X~~d>{l)!j4fNX/\R	>x@q}y"?Ca0ZCg5ZU>z'n~sXk>uANo׋V}e>|{Ѿ}!OE>r5s]	>+=jsN>}Z{f>lYnT>Uq𽉾v,Av>~)s:ھy5>c|`>cGdyh=}`>~Xu2'ví>U:X>kVPң{v\>}AUsC/+>/>q-Wrɾ|VaZ>|sʷotpKHA%>t~U}yj0>zR;g*^,J>wx}k>w?f]dg`>y 3X}R`>t/w{'n|> >q.ܨ>/X`rg>|vizP>kjm>Tvd'u(ʯ>}μ^x}yח>coW8>bJExcvᅺ>}$yu}>Wss>ivٱ%־yޤJ>|UD:r0>p"WAH{O|`8>{#PoqW
MA9q&>s&叄F|%5Xs>yuDhwpWX>uL|qGj>wVhVa*m4cbm}K>wΓ|7|T>tԈu޾S`e]$굾j97~>y6'{|YiA>qBz1ezϣ4zHc>mˏ0>DPs|Rk>{y䁃x>g2	]>X!DǾuk`>{R/-SvfeH>`RI>cDY*wk
b$>{KcuϾt@=jz>R1x>i	þx>zщqmZ<]>2@E>oM7zz,>y6aYmcnMvBfxߜ>r`[Fzs>x1Fgt%{<>vTɾ`Pc2a'k>vdIv	z	>t(,OT6s켾gdž>xܬzRFr>qB=lqmwe~4.>y=',y\йC>n#&O>6@#
q>p=>y6}x>h}2E>RzXo#J޾vj<>b'`Q>^hq㽾uZScxm>zR-t~R>Y`,C>dTվvk|>y[k	
rSx=>I'~C>jP
Tjվx 6¿>y2ox/>	;#y>o6,eډx݂->x"jњP9F=|>qQzy">vǐiϾe{NV)wM>s(>Qy
u>u(*Av_`ԕU0>uYcvyv9>sLwATT~fE6>v$O+6yZK0E>q=C!KËCc{,jR>ws$xRk>n7>fjo:G(>xp#{SwIE@b>iM)Ë>HeѾq>>xW~v's>db	vV>V'ǞǾsP%8n>x+(ut~rQ>^ge'>`
Dt>x-)^rVF>ToWtx>e>	>v>xl>~p/Q	>D`c>i.*vRv{|>w4pmQW=Ɛz>m3͎w>vf]iVBCƔ>VH>p`x3S->uUѾe!\S*=>rL
VkxG>th$6`R
⁾\W!<>s5*x9Y95~>r!%]W&>bq?>tXdͻw,±>qI8ޤM?g5dZfU>u~woft7>oD(5/
jDX>v׾v@<>kTU>,9{3n(">w#''{uhuI>grKȀ>H}($p)3!>wt&&9tˁ>cqmfS
>TB3r
Sk>w@RUs@J5l>^b>]EsDӋa>wzr7c~>V#I>bi'tMݒ>w4A
pܸ+r>LnJ*'>f|Ou'st3>vӾne>8.>im<%:v%!^VkZWbB>lA7vQ7Չ>ubg>g|:CJ^Rf>o`xtvy+s>t}2g`d;b"ϾQ2AQ>po9Hv˜s>sx윑j`JCdXtU{F>r'PvʤWZ>rXs\6Cv-N>q fSuH6b{z>s8U}vWrS9>o:ROqOG
f	-/>tNu.I>lq|=3ACJ¾h
j>u%F#u]_8>jHv
>0(bkXuž>u,f)t(/>g.16R>AQm),>ulGs}>d5+8>Nyp	]>uXss>a4q*>U9&6qXI>vXbފr,>\aoK>[)İqq>uOMJcӾq-h>V]8>`g᡾ru>u;=ap !)u>Pfw>	f>cjnJs[KĹ>uuԿ噾n
c?>Eu>es"^>u8$XknP>2yF>g^tV>t
ipE@Y4>j>PtM<>tAg,};9fUR>l?ptZڏQA>s|SMdӾGE!q>m)5u*fc>rwmpb=dkPK>ou&VP>rZ7Jd_&-Ut>p/ߟs/u$%
>q[X^3Z̿prZBmn
>q9ɗEq5uAS`;>p;mVs^n>qgIt18R>oztQr4aok!>rUqtYN1>m-mݗ>NA佻>k*(6>	؃rC>4Kǭ>qyB`7{E>PlQP&#FY>jt0>Dw^>qrT0UЍeSH+yn>{T־ҫq[>kryX6\]vcSkx>jioz>HFy_RM	S%E>4,#>~Z>c/
.\L@d>
׭澌#>sXU>zyz/ξB;># I//
;>F>-r>v>t՗q7sYElIlc>)Q5UI>Lun2^}y>`%{p	>=>9#ᾅƁ>-HZ(v6P>zJj>q@xo(bYK>O7un%7>ez{8>]Nq7N>n]pxOU>jd&I@Ε>KvvK1VuX#>jeb侐0G[>âSN[>uxG>[iK>oQLI#>aZe.!XV50>-13}L]V=>r
,w>wC`>aRg9P:>LV8>e;ft}k>+K}jg"N,{>xaJ>Э|n`Qy+6PY>~1"_jtd>4?fl%&
`t*>ؾ>zm>kWb#;x>wƤ1>iRs
@>{]mn*澋6BK>che?MA6;b>f	+^>yiAw\z'ow>-j$n		0>`f1Rݾp@埝>fu>Mz3uN&>
kq澉Ҿ>u
{>q*P'gR؎쾅C9/3b>`?6>}t5{e>8Jͱs%T>(c>>ű[=uWs0=r5Mz>}4][%>I;ZdB}p>BQC>~9HV[>Y*-qQT>ZE
G>r(h>rKqq8Ε]>NitE>V@~>~*tdqG(>T_|4uƽ\+U>"Z]u~>p{KUos99r>tqkf&>W4R*ؾ~Zv>B F>{nRU>^V{C?%s>oG">p Z>s@
~nd95R>Pa>}EK4>
o5ܾz'o^
|>@r
i8zʓ>gƾo9Yiqr6u><+v>]PA?[X}	66>]#{%)t:>zKn>]zбUlw>mP1Qu>n>>rlIj:.>IMɥ}?}>PNO>|GKk50<>QpǾy(.S[E>J1%N޾Z.>+DoMqf "F>{@Q'nG@}>P>R.N{6ϕ>6+/jM>yɠZ>XkJ; y>
gԨ>o2\s>pN)]>S|GUS׀>y>=8<y>K֡ξzrpоTt8>VuHD俔>ZD.p-ݴnm0:XD> p۾ù>GHaYxxVxnNu>Lw{C>zV
>N`BӾ.C
>jF'ھ|	>qd!=>kM3ȝX_>t}f}gy>^-W>v_,>qɝ9{.GAB+->~>%F|fo>s-,O+r}8!
g@ح>~I*>bGtPtE%>袿7"Y>|,>7U(b|$lDC>0廭׾t-%>s%V)>cذc	)>(ן|g>e"C>rqH%,g>:Ud}{T>#>92<>zyQz>{Q>I0g
^RA>
-#_M(>!Wik\pAl>!!;8"x>~ XwN_C|$x5A>h.A3w>voV>Tv"͛K~룎>|қp->mnn>kQRCL>{~a֨No>X">u~7¾3>-(xZj6Cs>|QJn57>a3!pp]ebN}>{f待&>AʸaiSr%YTي> wI|ƒ
b>zT‡elyxW>G{UM5M;*>s9i	>_?Ծk)>XmZ>fUez>o/UL4>b("| ~ C>K26M>v'3yP>Ae{uHpWRRPvOs>|v8uUD>ikpSlgnhX>Ƣ]0K8>}]OZ
g73c>w?>2e˾yɺQ>^ Ǿ>q,N>aVd~80>ާń(S>cZj>o95n
lpm&>o\;z=H>C[KT>v^omwet}P>NT`t1NT `k'>{"{H较e/b>!yjC!hX+MJ4>+S(<>|qZ:X{W:rdӉ>gVpxF0>v+>1;ԾxYy>Z	Vr0]1>pPy1>`]?FTA}n@=
>	O]վ~xIY>cɅd>mj5Dl>(yTj)>Gr>tQᢖV>D5csFw▞O]>z-ecsJZ>݂k[0eL >~baj`3(>|
!\aތ3¾p9,c>583v(>w#=/,x]%EvdJ>Q8%rx[{>qeۼ>Xx{Pn	1>9)`b*~F࿆7>fu=\;>haƅ~;>
O.վy2>S~>rCWW{FːS*>O/F}t"/8BO>w\_s0>
C.na;3X_PQ>{x&' k>|rR+bèׯ|kD.>~N,mQ>xD1쓾Ius$+Ե>=O"K>sJtH_>G}%TwݩB,~>Ry8~F
l`>k{[>a{U{m0>p|_e{3 <>`T4P>lq_T~^I>'wv"Adu>@ۛ>s8Fs?^>'lLrE/N1+Qu>wmhty">}3|i1bQ!>{
_r>z%pw\Cw͵md/>~jVY¾>uLr}8FT?@sg'>(Pվl{m`>qIz%>PiΈ3wÏC>Gj|>hb3]>cV{(S>syn΋+>[hyI}I:>m#զ}Yj>:|	wup A
>6³B >s%l}O8I>~h.!pZ
O$"w>w"`K&~E(n1o>|=NWh&^MbB#1 =>zqSGMK^>y1|['/k=Q<>}]7>uBmq2<:@Vraʣ>~ʞϗ~>OZK>qZ`A>Jƭ2#v>B[o>¾皾{V^>hN(6B>`IFR?yz_A>{ȝ6x*/>^2h->is|0N>J2$um2G>D<>qBk`}J
>}訡f;qp=[$vBt1YLl>u
[X~~d>{l)!j4fNX/\R	>x@q}y"?Ca0ZCg5ZU>z'n~sXk>uANo׋V}e>|{Ѿ}!OE>r5s]	>+=jsN>}Z{f>lYnT>Uq𽉾v,Av>~)s:ھy5>c|`>cGdyh=}`>~Xu2'ví>U:X>kVPң{v\>}AUsC/+>/>q-Wrɾ|VaZ>|sʷotpKHA%>t~U}yj0>zR;g*^,J>wx}k>w?f]dg`>y 3X}R`>t/w{'n|> >q.ܨ>/X`rg>|vizP>kjm>Tvd'u(ʯ>}μ^x}yח>coW8>bJExcvᅺ>}$yu}>Wss>ivٱ%־yޤJ>|UD:r0>p"WAH{O|`8>{#PoqW
MA9q&>s&叄F|%5Xs>yuDhwpWX>uL|qGj>wVhVa*m4cbm}K>wΓ|7|T>tԈu޾S`e]$굾j97~>y6'{|YiA>qBz1ezϣ4zHc>mˏ0>DPs|Rk>{y䁃x>g2	]>X!DǾuk`>{R/-SvfeH>`RI>cDY*wk
b$>{KcuϾt@=jz>R1x>i	þx>zщqmZ<]>2@E>oM7zz,>y6aYmcnMvBfxߜ>r`[Fzs>x1Fgt%{<>vTɾ`Pc2a'k>vdIv	z	>t(,OT6s켾gdž>xܬzRFr>qB=lqmwe~4.>y=',y\йC>n#&O>6@#
q>p=>y6}x>h}2E>RzXo#J޾vj<>b'`Q>^hq㽾uZScxm>zR-t~R>Y`,C>dTվvk|>y[k	
rSx=>I'~C>jP
Tjվx 6¿>y2ox/>	;#y>o6,eډx݂->x"jњP9F=|>qQzy">vǐiϾe{NV)wM>s(>Qy
u>u(*Av_`ԕU0>uYcvyv9>sLwATT~fE6>v$O+6yZK0E>q=C!KËCc{,jR>ws$xRk>n7>fjo:G(>xp#{SwIE@b>iM)Ë>HeѾq>>xW~v's>db	vV>V'ǞǾsP%8n>x+(ut~rQ>^ge'>`
Dt>x-)^rVF>ToWtx>e>	>v>xl>~p/Q	>D`c>i.*vRv{|>w4pmQW=Ɛz>m3͎w>vf]iVBCƔ>VH>p`x3S->uUѾe!\S*=>rL
VkxG>th$6`R
⁾\W!<>s5*x9Y95~>r!%]W&>bq?>tXdͻw,±>qI8ޤM?g5dZfU>u~woft7>oD(5/
jDX>v׾v@<>kTU>,9{3n(">w#''{uhuI>grKȀ>H}($p)3!>wt&&9tˁ>cqmfS
>TB3r
Sk>w@RUs@J5l>^b>]EsDӋa>wzr7c~>V#I>bi'tMݒ>w4A
pܸ+r>LnJ*'>f|Ou'st3>vӾne>8.>im<%:v%!^VkZWbB>lA7vQ7Չ>ubg>g|:CJ^Rf>o`xtvy+s>t}2g`d;b"ϾQ2AQ>po9Hv˜s>sx윑j`JCdXtU{F>r'PvʤWZ>rXs\6Cv-N>q fSuH6b{z>s8U}vWrS9>o:ROqOG
f	-/>tNu.I>lq|=3ACJ¾h
j>u%F#u]_8>jHv
>0(bkXuž>u,f)t(/>g.16R>AQm),>ulGs}>d5+8>Nyp	]>uXss>a4q*>U9&6qXI>vXbފr,>\aoK>[)İqq>uOMJcӾq-h>V]8>`g᡾ru>u;=ap !)u>Pfw>	f>cjnJs[KĹ>uuԿ噾n
c?>Eu>es"^>u8$XknP>2yF>g^tV>t
ipE@Y4>j>PtM<>tAg,};9fUR>l?ptZڏQA>s|SMdӾGE!q>m)5u*fc>rwmpb=dkPK>ou&VP>rZ7Jd_&-Ut>p/ߟs/u$%
>q[X^3Z̿prZBmn
>q9ɗEq5uAS`;>p;mVs^n>qgIt18R>oztQr4aok!>rUqtYN1>m-mݗI[ʼnֺchvzm>r0Étn5.>lf@IeB->s&rstV!>jKEiL0=euf3'h>su7l&so	>hPM7=OhL>sesX#>>fU)Y>0_FL=j>s}frZ>dz>@E6!ICky݃vY>t۠rp)>c9xo>GĜB޾lyDIW>t0rq{֜>a}q>NM`m,H1">t%*܍qnGf>_z1w!>R0
u7n|+>t#r6֡OpD^W>\7:w>V,at7ͫ׾p][b>XXTe>YC08p`W#_i>tXHo?K>UO[0>\/!Fup*H>s)Ӿnf!V>R3>^b%qiH$3>s³BɾmlPMl[>OaMܴE>`ypqd9(>s[W3lRZFg8>IB>aqZ>skRk:‚Fc>DA>ceqQ />s8gDCCj'OA>=+>d(Ͼr]k>sosiS>3|ڇw>e#,*h*r9m*>r+;h>#h)'>f
"žr[Pݱ0>r4~5	gKOah=A>f]iTrv{6n:>rN!f-&i=x>gѪr[9!>reFlke'2%0>hXھrVx>qѸudAnaN7Pt>hi]rCec>qY}پce:}f>©:>i?ri@>qUUhfbffB^7s$>j%rO>q;#a7I`E°+Q^>jA2@.rNE%>p5 a%j彾HP>jt$8ʾr`;>pەaҾ`e8TBK+R>kSor79(>pnX_W,ϾM{>kD6rt>p9܋|kA^^`rO_,>kUK
r	z&l>pvus]LueP@0>l%fO8ruLU>oR\U#Q~>lU4srz_C>o^k[xrʾRK;>l{\œrm(/>o)Zgx+Rϗ >l8&8оr^g@>nǸHZϒVoSeiRr%>l[<rODr2>n^.Y~lXp;r@~w,>nO>Y
/TQ%M>l2N۾r0i>n9ɀwXT-ϺT?hз	>l/qr!#:t>m-=Xp[wTR|>l!JԾr;b>mԃ=\XJtCTLC>l!r2#5>mfx0VX>Ԓ
ؾT+7 _>li]ϡq.U>mRqXL:S\>lByD`q$0>mDNXsY-q]S݊&Z>l+3qЫ-{>mC]־X`S.W>kڸ2$q!sJ>m17Y{P.ˎR0%?>k_q8!G>m0Y}[:R:z>kQ(0վq7%>máRZbQL]
>kOq>mOJuZIMPyͯ[>jZ^	qxn>mv%[^Ou>jC-hqdSzR>n!㣾\,g;M
4>iGwKqNaĴ>nK]ɾ]GhJqp>i_q7Ì>nz% ^\sH]n"9>hKjq`b{D>n;	_hEBJMv>hS<3B4qDž>nᚭ.*`c@B04]>gz}þpPy>o؃:`-F?'dv>gyJ8pyk>oR-5ҾaUcx95ˠ[-(>fli+pn=>o0 a2ZJmo>e{(mpvAn>oK&b&8;t[N>d6pID$>oV;gchzVh
>dI&JpHq>p5d&H>
CT>c4=o9Ta>p2郾d^go>)Pw>bDp+5oG:)>pIp~ھe]>5x>aE03ǾnY>p]Oi^fxz©>>-h>`7"n.	4>pmqڙ5gB;<>C$h3>^5pJ#Ѿm', >pyB
hȔ>H>[Ⱦl*N/>p%Q9hQCC>M͝an>Yf]!l
]]>p( i)>Qs!:Ȃm>Vϗ7"kD?`>p{+LjfS,0>T
J>T7GOj^B">pn Dk%?U<>V.R"B>QFw'ie=F>pZkݕ(D>Ycq>L%HeI[hWd">p<3f4lG>\var	>Fg5g9v>p.ؾm1/n>^B>@4*e?z~g>oŢ΃mG)>`!>3R햡Bdy/=>oK!e)nPe&>b"{Ҡ>e͌AcM>ndwkn5d>cy㌐;faΩc>nbo+܇m>dS|~6tE7`Cgi>mE}־ozVJ>fB?k]:\>lb%6Zoc<>gS,FIaY§~#>kbboȯ׎T0>hePu#V|,>jC,oEƱ>i>$ؾT)2RU9>i~FoF>jxcWLQb?>gv.om-_Ih>k/:VSDg ^>f+h-	o
ED>l䠗T_+^wA8pWzf>d'Ϩnkm>mJ2sa\7:6.
>bSAmӠZi>mZcܺKp>$HW}W>`I>%l>nmW4dqݫ><9C2	>]3 pk(ơg>n@%zfXp>Gڬ>Y5jжT8>n3>QQgĚR`*>PM*L>UY>oQiz
E>nhKWΜi8{_>TV>PrFg>nӵM+jyKv>Yԣ>G/A	fIz3/>nxѽkB{B>]^Mqm><8,_Ƿdpk3>mk{ʾl
os>`G> |NDBbmf L>m&o	0$mLd/>bՖAc}(8gb`ACњ>l+wAm߀>dü/vʾ@ O0s[:>j{nfnK8JVtL6>in_Ԫ>h9t'zR[^DQIS>g&f1nF0#L>i_ѾWTH޽4<>f
U8Amr6P>kn\t;'Qm>c݋mO|D>l{~"`xU>9e>aB$]4lo!gT>l׿|SѾc>2@;  y>^
nӾkHp\>mEe!:B\>D4{6^>Y9J~i9i>m/IXNg+6>P ̏O>SKľh)}!S\>mԄNjh6&m>U_ k>KAf2Lt>mL'TjM>i>[Oꆓ>>◘0cվc2å>l%Kk6ebO>`Lv")>ӄ7aSa~>lcY}lz
>bEa393EN]v6z>j:5mʶOE|>ee;FBW#ښR>i'he_mf
:>g+pQcsAQu>g>!mV޻Wd>h0zWdƾFD=N*>eCp@l dm>jk^]ax|2Ow/>bpapھl}@a>kW^aw8٭> >_r=tyj)>lFId	+y[>AX
9>YbbW.iR_1.k>lrVfZx>OP"d>R+a̾g^Le>mRh^[w>V?_41>H+
we
&D>lۺxHj7cñ>\ts>4{B7bf8>kRτ'kX
9r>aB4!^ާaU>jW>l9in>c2֑BY]\,Xd>hkFl?>fl4:uP;9QtHI>fdl׾lR>hBWW&DQv>d!ޗOl0q>j.3S^'jq$~>a8!
ξkt>kj b$t>4߈E!>[zil:n>l*Rdϗ*>>IPNo
>TnŘg$>le8XgMS >TWP>JŜ0e\>lEAiEfAn>[>
>61Pb/3>k;L+߾j9>`Rw#	#
s]IDp_>iLekF>cDp3ϾV	>gqlC>fU7w$R_P3Mw>ea+k랉1>hYy8@w:=!e>bkOakɏ4>j`@[`z)\>N]7W>^o(iP>koFrTc;>DC”.>VEg([Pm>kޔ6ffas>R[~_!@>L׾f
Ee$>ka$hޤ>Z6y(>7Z	,aq$N>jăcjL>`._4&#㪅\q%S>i6!&kQܠ>cGK'Tp}~>gaXdwkd_M>f/@Tm+HO{=y>d3^mnAkE38
">he3\E`+4ر|b>`1Ij(곊>j{ka֓4Su>64>YsxhT6|>kOIr؛dFL>MTG|>Q~]b0eϪ)m>ka0)gD5>WMU!Tn>@"b"Vu>j8i?8>_TܾLw]_dv>i,E/j
5>c?	ﱉD~_ݾUy<>fT{k@?LQ0>fEclSaǾHOV2>cf[Xjym>hP$[k/H&:>`T@h,ir>j=ta$@
>;r(
T->XW|Ig%x+>kd+e6Sj#{ >PgNX֫d_v>j6n}gm,>Yw8v>5uz!.a=K2%>iB"bоidzbI>`ݨԾ2'Z+uDT>g:Wŵji2K>dqď̄L۸'P)>e<DjmO>gSWߞt&>B;,mS>azobi+VJ>icd`Bs>*J?p>[r5ʾhg+>jXdTva!>J"(^>Qp6eZ7'6>jF8Ӿg	Җ,Ā>W;ʔR>=H"۾aƑ>i׳i3MFU>`cy3(&WeZ^>g*T}je%>ceK .8QH>e&rj5L>g)W2VarcS0پi,>i0ɍ-`Q+%>/PϵS>>Zbgu<	]>jS	d5
|>MUW>OHS8d:)y7>jYHgC>XέO^>4:`,w>i=+iUOs>`?r7`"{۾X (>gtjK.0>d}6APduEiKKJzD>c3jHiZ>gzZ0rb1$eP޼>_{ݾhH>i5]aO+>AQP>U9f[>>jS?>DAb)Ǿbv>im碱,hT1>]mQ\pF![Ԇ>>g2g׾i%2	>cJ+$5IwQN2_>d]zjW_xT>fĎWW!7h٧L>`qh;=>hBZ`ɱ0X>7\yf>W^fnR>i]{dvG֨T>QW;k>Hq4;cLNd>i4c8Ǿg̘Jt>\D?_G=S\֐8>g'Lli|&%>bpPGT#ZþR	g">dR[:c;infB>fe	2tW^Ŕ[82Sm>`ghNhͿ}w>>h̶O	`2l>8jYv>Wzt AfPI>iuֻdȋ.4>R-sH>FQ;b_4>iYEqgDr>]4ن5ӌ	[J֏>ge/߃ľi*k>cIlM$K$bcV~OԋB?>d	A
'i{j(>f\YCZ>*>^.Vi9&an#K>B_>S©V1]e:=(>iQ~eūl>Uhf(>=M
T`$>h,hsJ7>`E{I6pjW%)68>f%in>dRR[TEn?֥>b"V6i	?>gQ9.]	]|>#R<(>YEȯfEK>icU1cHS>N]0>K9pc0g}>i;%뒳qg=P=H>[Ƭ=Qm\\KF>gVU7i(w>b_!VJzUO2ΆI>c\վiR'\N>f
Y#Uuܑ>]HҾg>hj)^
b&Y[>FBZ?`>Q(~dTEku>iWi3f;T>Xt>0<g<{Ph3Y_>a>^1CkR\+}Nm>dy"
iS)f>efcCV̬5t;G>_R)N;h6>h1:~˾a41fXa>A
>S,kXdMz>iJYkegÉ>V@ D>7}ZEM`Pn>hԿ9hkta>a>.@ߕS#c~>di>Q>elV/a7)Q_>`5ɀh"C6V>had)2@a%>A	J<>StI)d&>i2ik	k/eaN>V_q{J>6$ko'_m>g	Behh,}>a5
l[hBM!Tc.RF>d/#Ni#Nv>esZѾW";JH<2Z&	)>^ڣgUѕ!>h3ka>DM~p>Qcd(6>i.I[ʼnֺchvzm>r0Étn5.>lf@IeB->s&rstV!>jKEiL0=euf3'h>su7l&so	>hPM7=OhL>sesX#>>fU)Y>0_FL=j>s}frZ>dz>@E6!ICky݃vY>t۠rp)>c9xo>GĜB޾lyDIW>t0rq{֜>a}q>NM`m,H1">t%*܍qnGf>_z1w!>R0
u7n|+>t#r6֡OpD^W>\7:w>V,at7ͫ׾p][b>XXTe>YC08p`W#_i>tXHo?K>UO[0>\/!Fup*H>s)Ӿnf!V>R3>^b%qiH$3>s³BɾmlPMl[>OaMܴE>`ypqd9(>s[W3lRZFg8>IB>aqZ>skRk:‚Fc>DA>ceqQ />s8gDCCj'OA>=+>d(Ͼr]k>sosiS>3|ڇw>e#,*h*r9m*>r+;h>#h)'>f
"žr[Pݱ0>r4~5	gKOah=A>f]iTrv{6n:>rN!f-&i=x>gѪr[9!>reFlke'2%0>hXھrVx>qѸudAnaN7Pt>hi]rCec>qY}پce:}f>©:>i?ri@>qUUhfbffB^7s$>j%rO>q;#a7I`E°+Q^>jA2@.rNE%>p5 a%j彾HP>jt$8ʾr`;>pەaҾ`e8TBK+R>kSor79(>pnX_W,ϾM{>kD6rt>p9܋|kA^^`rO_,>kUK
r	z&l>pvus]LueP@0>l%fO8ruLU>oR\U#Q~>lU4srz_C>o^k[xrʾRK;>l{\œrm(/>o)Zgx+Rϗ >l8&8оr^g@>nǸHZϒVoSeiRr%>l[<rODr2>n^.Y~lXp;r@~w,>nO>Y
/TQ%M>l2N۾r0i>n9ɀwXT-ϺT?hз	>l/qr!#:t>m-=Xp[wTR|>l!JԾr;b>mԃ=\XJtCTLC>l!r2#5>mfx0VX>Ԓ
ؾT+7 _>li]ϡq.U>mRqXL:S\>lByD`q$0>mDNXsY-q]S݊&Z>l+3qЫ-{>mC]־X`S.W>kڸ2$q!sJ>m17Y{P.ˎR0%?>k_q8!G>m0Y}[:R:z>kQ(0վq7%>máRZbQL]
>kOq>mOJuZIMPyͯ[>jZ^	qxn>mv%[^Ou>jC-hqdSzR>n!㣾\,g;M
4>iGwKqNaĴ>nK]ɾ]GhJqp>i_q7Ì>nz% ^\sH]n"9>hKjq`b{D>n;	_hEBJMv>hS<3B4qDž>nᚭ.*`c@B04]>gz}þpPy>o؃:`-F?'dv>gyJ8pyk>oR-5ҾaUcx95ˠ[-(>fli+pn=>o0 a2ZJmo>e{(mpvAn>oK&b&8;t[N>d6pID$>oV;gchzVh
>dI&JpHq>p5d&H>
CT>c4=o9Ta>p2郾d^go>)Pw>bDp+5oG:)>pIp~ھe]>5x>aE03ǾnY>p]Oi^fxz©>>-h>`7"n.	4>pmqڙ5gB;<>C$h3>^5pJ#Ѿm', >pyB
hȔ>H>[Ⱦl*N/>p%Q9hQCC>M͝an>Yf]!l
]]>p( i)>Qs!:Ȃm>Vϗ7"kD?`>p{+LjfS,0>T
J>T7GOj^B">pn Dk%?U<>V.R"B>QFw'ie=F>pZkݕ(D>Ycq>L%HeI[hWd">p<3f4lG>\var	>Fg5g9v>p.ؾm1/n>^B>@4*e?z~g>oŢ΃mG)>`!>3R햡Bdy/=>oK!e)nPe&>b"{Ҡ>e͌AcM>ndwkn5d>cy㌐;faΩc>nbo+܇m>dS|~6tE7`Cgi>mE}־ozVJ>fB?k]:\>lb%6Zoc<>gS,FIaY§~#>kbboȯ׎T0>hePu#V|,>jC,oEƱ>i>$ؾT)2RU9>i~FoF>jxcWLQb?>gv.om-_Ih>k/:VSDg ^>f+h-	o
ED>l䠗T_+^wA8pWzf>d'Ϩnkm>mJ2sa\7:6.
>bSAmӠZi>mZcܺKp>$HW}W>`I>%l>nmW4dqݫ><9C2	>]3 pk(ơg>n@%zfXp>Gڬ>Y5jжT8>n3>QQgĚR`*>PM*L>UY>oQiz
E>nhKWΜi8{_>TV>PrFg>nӵM+jyKv>Yԣ>G/A	fIz3/>nxѽkB{B>]^Mqm><8,_Ƿdpk3>mk{ʾl
os>`G> |NDBbmf L>m&o	0$mLd/>bՖAc}(8gb`ACњ>l+wAm߀>dü/vʾ@ O0s[:>j{nfnK8JVtL6>in_Ԫ>h9t'zR[^DQIS>g&f1nF0#L>i_ѾWTH޽4<>f
U8Amr6P>kn\t;'Qm>c݋mO|D>l{~"`xU>9e>aB$]4lo!gT>l׿|SѾc>2@;  y>^
nӾkHp\>mEe!:B\>D4{6^>Y9J~i9i>m/IXNg+6>P ̏O>SKľh)}!S\>mԄNjh6&m>U_ k>KAf2Lt>mL'TjM>i>[Oꆓ>>◘0cվc2å>l%Kk6ebO>`Lv")>ӄ7aSa~>lcY}lz
>bEa393EN]v6z>j:5mʶOE|>ee;FBW#ښR>i'he_mf
:>g+pQcsAQu>g>!mV޻Wd>h0zWdƾFD=N*>eCp@l dm>jk^]ax|2Ow/>bpapھl}@a>kW^aw8٭> >_r=tyj)>lFId	+y[>AX
9>YbbW.iR_1.k>lrVfZx>OP"d>R+a̾g^Le>mRh^[w>V?_41>H+
we
&D>lۺxHj7cñ>\ts>4{B7bf8>kRτ'kX
9r>aB4!^ާaU>jW>l9in>c2֑BY]\,Xd>hkFl?>fl4:uP;9QtHI>fdl׾lR>hBWW&DQv>d!ޗOl0q>j.3S^'jq$~>a8!
ξkt>kj b$t>4߈E!>[zil:n>l*Rdϗ*>>IPNo
>TnŘg$>le8XgMS >TWP>JŜ0e\>lEAiEfAn>[>
>61Pb/3>k;L+߾j9>`Rw#	#
s]IDp_>iLekF>cDp3ϾV	>gqlC>fU7w$R_P3Mw>ea+k랉1>hYy8@w:=!e>bkOakɏ4>j`@[`z)\>N]7W>^o(iP>koFrTc;>DC”.>VEg([Pm>kޔ6ffas>R[~_!@>L׾f
Ee$>ka$hޤ>Z6y(>7Z	,aq$N>jăcjL>`._4&#㪅\q%S>i6!&kQܠ>cGK'Tp}~>gaXdwkd_M>f/@Tm+HO{=y>d3^mnAkE38
">he3\E`+4ر|b>`1Ij(곊>j{ka֓4Su>64>YsxhT6|>kOIr؛dFL>MTG|>Q~]b0eϪ)m>ka0)gD5>WMU!Tn>@"b"Vu>j8i?8>_TܾLw]_dv>i,E/j
5>c?	ﱉD~_ݾUy<>fT{k@?LQ0>fEclSaǾHOV2>cf[Xjym>hP$[k/H&:>`T@h,ir>j=ta$@
>;r(
T->XW|Ig%x+>kd+e6Sj#{ >PgNX֫d_v>j6n}gm,>Yw8v>5uz!.a=K2%>iB"bоidzbI>`ݨԾ2'Z+uDT>g:Wŵji2K>dqď̄L۸'P)>e<DjmO>gSWߞt&>B;,mS>azobi+VJ>icd`Bs>*J?p>[r5ʾhg+>jXdTva!>J"(^>Qp6eZ7'6>jF8Ӿg	Җ,Ā>W;ʔR>=H"۾aƑ>i׳i3MFU>`cy3(&WeZ^>g*T}je%>ceK .8QH>e&rj5L>g)W2VarcS0پi,>i0ɍ-`Q+%>/PϵS>>Zbgu<	]>jS	d5
|>MUW>OHS8d:)y7>jYHgC>XέO^>4:`,w>i=+iUOs>`?r7`"{۾X (>gtjK.0>d}6APduEiKKJzD>c3jHiZ>gzZ0rb1$eP޼>_{ݾhH>i5]aO+>AQP>U9f[>>jS?>DAb)Ǿbv>im碱,hT1>]mQ\pF![Ԇ>>g2g׾i%2	>cJ+$5IwQN2_>d]zjW_xT>fĎWW!7h٧L>`qh;=>hBZ`ɱ0X>7\yf>W^fnR>i]{dvG֨T>QW;k>Hq4;cLNd>i4c8Ǿg̘Jt>\D?_G=S\֐8>g'Lli|&%>bpPGT#ZþR	g">dR[:c;infB>fe	2tW^Ŕ[82Sm>`ghNhͿ}w>>h̶O	`2l>8jYv>Wzt AfPI>iuֻdȋ.4>R-sH>FQ;b_4>iYEqgDr>]4ن5ӌ	[J֏>ge/߃ľi*k>cIlM$K$bcV~OԋB?>d	A
'i{j(>f\YCZ>*>^.Vi9&an#K>B_>S©V1]e:=(>iQ~eūl>Uhf(>=M
T`$>h,hsJ7>`E{I6pjW%)68>f%in>dRR[TEn?֥>b"V6i	?>gQ9.]	]|>#R<(>YEȯfEK>icU1cHS>N]0>K9pc0g}>i;%뒳qg=P=H>[Ƭ=Qm\\KF>gVU7i(w>b_!VJzUO2ΆI>c\վiR'\N>f
Y#Uuܑ>]HҾg>hj)^
b&Y[>FBZ?`>Q(~dTEku>iWi3f;T>Xt>0<g<{Ph3Y_>a>^1CkR\+}Nm>dy"
iS)f>efcCV̬5t;G>_R)N;h6>h1:~˾a41fXa>A
>S,kXdMz>iJYkegÉ>V@ D>7}ZEM`Pn>hԿ9hkta>a>.@ߕS#c~>di>Q>elV/a7)Q_>`5ɀh"C6V>had)2@a%>A	J<>StI)d&>i2ik	k/eaN>V_q{J>6$ko'_m>g	Behh,}>a5
l[hBM!Tc.RF>d/#Ni#Nv>esZѾW";JH<2Z&	)>^ڣgUѕ!>h3ka>DM~p>Qcd(6>i.I[ʼnֺchvzm>r0Étn5.>lf@IeB->s&rstV!>jKEiL0=euf3'h>su7l&so	>hPM7=OhL>sesX#>>fU)Y>0_FL=j>s}frZ>dz>@E6!ICky݃vY>t۠rp)>c9xo>GĜB޾lyDIW>t0rq{֜>a}q>NM`m,H1">t%*܍qnGf>_z1w!>R0
u7n|+>t#r6֡OpD^W>\7:w>V,at7ͫ׾p][b>XXTe>YC08p`W#_i>tXHo?K>UO[0>\/!Fup*H>s)Ӿnf!V>R3>^b%qiH$3>s³BɾmlPMl[>OaMܴE>`ypqd9(>s[W3lRZFg8>IB>aqZ>skRk:‚Fc>DA>ceqQ />s8gDCCj'OA>=+>d(Ͼr]k>sosiS>3|ڇw>e#,*h*r9m*>r+;h>#h)'>f
"žr[Pݱ0>r4~5	gKOah=A>f]iTrv{6n:>rN!f-&i=x>gѪr[9!>reFlke'2%0>hXھrVx>qѸudAnaN7Pt>hi]rCec>qY}پce:}f>©:>i?ri@>qUUhfbffB^7s$>j%rO>q;#a7I`E°+Q^>jA2@.rNE%>p5 a%j彾HP>jt$8ʾr`;>pەaҾ`e8TBK+R>kSor79(>pnX_W,ϾM{>kD6rt>p9܋|kA^^`rO_,>kUK
r	z&l>pvus]LueP@0>l%fO8ruLU>oR\U#Q~>lU4srz_C>o^k[xrʾRK;>l{\œrm(/>o)Zgx+Rϗ >l8&8оr^g@>nǸHZϒVoSeiRr%>l[<rODr2>n^.Y~lXp;r@~w,>nO>Y
/TQ%M>l2N۾r0i>n9ɀwXT-ϺT?hз	>l/qr!#:t>m-=Xp[wTR|>l!JԾr;b>mԃ=\XJtCTLC>l!r2#5>mfx0VX>Ԓ
ؾT+7 _>li]ϡq.U>mRqXL:S\>lByD`q$0>mDNXsY-q]S݊&Z>l+3qЫ-{>mC]־X`S.W>kڸ2$q!sJ>m17Y{P.ˎR0%?>k_q8!G>m0Y}[:R:z>kQ(0վq7%>máRZbQL]
>kOq>mOJuZIMPyͯ[>jZ^	qxn>mv%[^Ou>jC-hqdSzR>n!㣾\,g;M
4>iGwKqNaĴ>nK]ɾ]GhJqp>i_q7Ì>nz% ^\sH]n"9>hKjq`b{D>n;	_hEBJMv>hS<3B4qDž>nᚭ.*`c@B04]>gz}þpPy>o؃:`-F?'dv>gyJ8pyk>oR-5ҾaUcx95ˠ[-(>fli+pn=>o0 a2ZJmo>e{(mpvAn>oK&b&8;t[N>d6pID$>oV;gchzVh
>dI&JpHq>p5d&H>
CT>c4=o9Ta>p2郾d^go>)Pw>bDp+5oG:)>pIp~ھe]>5x>aE03ǾnY>p]Oi^fxz©>>-h>`7"n.	4>pmqڙ5gB;<>C$h3>^5pJ#Ѿm', >pyB
hȔ>H>[Ⱦl*N/>p%Q9hQCC>M͝an>Yf]!l
]]>p( i)>Qs!:Ȃm>Vϗ7"kD?`>p{+LjfS,0>T
J>T7GOj^B">pn Dk%?U<>V.R"B>QFw'ie=F>pZkݕ(D>Ycq>L%HeI[hWd">p<3f4lG>\var	>Fg5g9v>p.ؾm1/n>^B>@4*e?z~g>oŢ΃mG)>`!>3R햡Bdy/=>oK!e)nPe&>b"{Ҡ>e͌AcM>ndwkn5d>cy㌐;faΩc>nbo+܇m>dS|~6tE7`Cgi>mE}־ozVJ>fB?k]:\>lb%6Zoc<>gS,FIaY§~#>kbboȯ׎T0>hePu#V|,>jC,oEƱ>i>$ؾT)2RU9>i~FoF>jxcWLQb?>gv.om-_Ih>k/:VSDg ^>f+h-	o
ED>l䠗T_+^wA8pWzf>d'Ϩnkm>mJ2sa\7:6.
>bSAmӠZi>mZcܺKp>$HW}W>`I>%l>nmW4dqݫ><9C2	>]3 pk(ơg>n@%zfXp>Gڬ>Y5jжT8>n3>QQgĚR`*>PM*L>UY>oQiz
E>nhKWΜi8{_>TV>PrFg>nӵM+jyKv>Yԣ>G/A	fIz3/>nxѽkB{B>]^Mqm><8,_Ƿdpk3>mk{ʾl
os>`G> |NDBbmf L>m&o	0$mLd/>bՖAc}(8gb`ACњ>l+wAm߀>dü/vʾ@ O0s[:>j{nfnK8JVtL6>in_Ԫ>h9t'zR[^DQIS>g&f1nF0#L>i_ѾWTH޽4<>f
U8Amr6P>kn\t;'Qm>c݋mO|D>l{~"`xU>9e>aB$]4lo!gT>l׿|SѾc>2@;  y>^
nӾkHp\>mEe!:B\>D4{6^>Y9J~i9i>m/IXNg+6>P ̏O>SKľh)}!S\>mԄNjh6&m>U_ k>KAf2Lt>mL'TjM>i>[Oꆓ>>◘0cվc2å>l%Kk6ebO>`Lv")>ӄ7aSa~>lcY}lz
>bEa393EN]v6z>j:5mʶOE|>ee;FBW#ښR>i'he_mf
:>g+pQcsAQu>g>!mV޻Wd>h0zWdƾFD=N*>eCp@l dm>jk^]ax|2Ow/>bpapھl}@a>kW^aw8٭> >_r=tyj)>lFId	+y[>AX
9>YbbW.iR_1.k>lrVfZx>OP"d>R+a̾g^Le>mRh^[w>V?_41>H+
we
&D>lۺxHj7cñ>\ts>4{B7bf8>kRτ'kX
9r>aB4!^ާaU>jW>l9in>c2֑BY]\,Xd>hkFl?>fl4:uP;9QtHI>fdl׾lR>hBWW&DQv>d!ޗOl0q>j.3S^'jq$~>a8!
ξkt>kj b$t>4߈E!>[zil:n>l*Rdϗ*>>IPNo
>TnŘg$>le8XgMS >TWP>JŜ0e\>lEAiEfAn>[>
>61Pb/3>k;L+߾j9>`Rw#	#
s]IDp_>iLekF>cDp3ϾV	>gqlC>fU7w$R_P3Mw>ea+k랉1>hYy8@w:=!e>bkOakɏ4>j`@[`z)\>N]7W>^o(iP>koFrTc;>DC”.>VEg([Pm>kޔ6ffas>R[~_!@>L׾f
Ee$>ka$hޤ>Z6y(>7Z	,aq$N>jăcjL>`._4&#㪅\q%S>i6!&kQܠ>cGK'Tp}~>gaXdwkd_M>f/@Tm+HO{=y>d3^mnAkE38
">he3\E`+4ر|b>`1Ij(곊>j{ka֓4Su>64>YsxhT6|>kOIr؛dFL>MTG|>Q~]b0eϪ)m>ka0)gD5>WMU!Tn>@"b"Vu>j8i?8>_TܾLw]_dv>i,E/j
5>c?	ﱉD~_ݾUy<>fT{k@?LQ0>fEclSaǾHOV2>cf[Xjym>hP$[k/H&:>`T@h,ir>j=ta$@
>;r(
T->XW|Ig%x+>kd+e6Sj#{ >PgNX֫d_v>j6n}gm,>Yw8v>5uz!.a=K2%>iB"bоidzbI>`ݨԾ2'Z+uDT>g:Wŵji2K>dqď̄L۸'P)>e<DjmO>gSWߞt&>B;,mS>azobi+VJ>icd`Bs>*J?p>[r5ʾhg+>jXdTva!>J"(^>Qp6eZ7'6>jF8Ӿg	Җ,Ā>W;ʔR>=H"۾aƑ>i׳i3MFU>`cy3(&WeZ^>g*T}je%>ceK .8QH>e&rj5L>g)W2VarcS0پi,>i0ɍ-`Q+%>/PϵS>>Zbgu<	]>jS	d5
|>MUW>OHS8d:)y7>jYHgC>XέO^>4:`,w>i=+iUOs>`?r7`"{۾X (>gtjK.0>d}6APduEiKKJzD>c3jHiZ>gzZ0rb1$eP޼>_{ݾhH>i5]aO+>AQP>U9f[>>jS?>DAb)Ǿbv>im碱,hT1>]mQ\pF![Ԇ>>g2g׾i%2	>cJ+$5IwQN2_>d]zjW_xT>fĎWW!7h٧L>`qh;=>hBZ`ɱ0X>7\yf>W^fnR>i]{dvG֨T>QW;k>Hq4;cLNd>i4c8Ǿg̘Jt>\D?_G=S\֐8>g'Lli|&%>bpPGT#ZþR	g">dR[:c;infB>fe	2tW^Ŕ[82Sm>`ghNhͿ}w>>h̶O	`2l>8jYv>Wzt AfPI>iuֻdȋ.4>R-sH>FQ;b_4>iYEqgDr>]4ن5ӌ	[J֏>ge/߃ľi*k>cIlM$K$bcV~OԋB?>d	A
'i{j(>f\YCZ>*>^.Vi9&an#K>B_>S©V1]e:=(>iQ~eūl>Uhf(>=M
T`$>h,hsJ7>`E{I6pjW%)68>f%in>dRR[TEn?֥>b"V6i	?>gQ9.]	]|>#R<(>YEȯfEK>icU1cHS>N]0>K9pc0g}>i;%뒳qg=P=H>[Ƭ=Qm\\KF>gVU7i(w>b_!VJzUO2ΆI>c\վiR'\N>f
Y#Uuܑ>]HҾg>hj)^
b&Y[>FBZ?`>Q(~dTEku>iWi3f;T>Xt>0<g<{Ph3Y_>a>^1CkR\+}Nm>dy"
iS)f>efcCV̬5t;G>_R)N;h6>h1:~˾a41fXa>A
>S,kXdMz>iJYkegÉ>V@ D>7}ZEM`Pn>hԿ9hkta>a>.@ߕS#c~>di>Q>elV/a7)Q_>`5ɀh"C6V>had)2@a%>A	J<>StI)d&>i2ik	k/eaN>V_q{J>6$ko'_m>g	Behh,}>a5
l[hBM!Tc.RF>d/#Ni#Nv>esZѾW";JH<2Z&	)>^ڣgUѕ!>h3ka>DM~p>Qcd(6>i.fFq>XX:X>("]@R>gbW
hK{dhh>b%mG᫜9'P$#5"b>c`P{h3>f}y16YKgR>[0)fO>>h81@b*
7>L'Nv>KVݨ9b8s->h ˾f,>\	ȶ4RY?>f^thc>cIC؇PA;FpZ>aphuQl|3>g~6^o8.>1>V$dоe$Khk>h	Xed^%>SG>?צľ`]>h3{zh\>`(?SN>dӹ־hJ]s>eo>٭W$#Fؾ0fw
<>^j:g\ǭqP>hwcc%bJ4i>Gw5>O]X1cO+`}>hFXf:ٝ>ZoDnwqZa0r<>ftXG&h痆M>cPh	=]FzkG:>aSohY>g~о^XC>4F*Q>VA0de;NE>h#{d}Mv>U.eI3>8aG5Ǿ_~f>gƦh>v>aq=*E227PFAX>cffhWIN>f\MHOZ0|9rDkvY>ZƅPvf)
^>hdnscnb"@>P^Ӟ1>FhF{	gk9>_FC[c7H#U5#	[>d{Th>eI[Vbyqm2n،>^1\/gLԌ>hkWba1>IK f>MubG)>h?3fB8>\wLvTS$1C,X-8>e1h\=v>dn{[^SNC>,[JC>`6%ugm>hбa/a4>DHXӖV>Q%9ɾc!s>h«9颾fl1>ZY#{1͜Y,"~X>f<ii׾h=>c0
)R	YQ"BTl1>`͝'gi3>gX`؇I>Aӣf>R@z`c񎨿Z>h6^~f8g
>YOWx=`N}ZDa\>fbQmh>cŞMQCB9A)>`{+>hY^>gΰ`	C>A>R%cR&>h8fR`]>ZUA0:Z	s/E8>f>H%`hI>d
RX
@qu>`XcHgj!w>hjV@a6>DR>P!hf|>[/ y"eX_h>e_V
hXvj>d6LTg{cV8PM>_0YLXxg~>hsűL־b.To>J**ȷc>L *pbI޿>hS>gXږ>^|(J50B''Ut5h>d3Ce~UNW(BB#&Z\>\-Jjf΍W>h)?zc୅>QT[ >D˾aq>hܨHqh>abC3w\KQ*w>c	^壾h$sh>fL:M&\OT7>%>W
혈OeBc>i"&վe)ew`Y>V&
_>1J]8D>g:|h1_%+>cA^|Oe@⌾F,L7%>a򯺾hU[mJT>h͡`H:>B1r_>Qc!:(>h9f,9x>\/Ң'P
#+DPWn>edYi(wGu>eP؎V7V/>>]og->£>hucyuM>P&>Dxr	Va*WP>h?Maab4 E?P7c)>cM	/)ؾh.>ga4^.Hy>3/k>U?R,޾eV@>i@ܽf#8y_]>YPb>
轾Z"*>f>i;~>dU!_TAB~:\CH>_ WRg>hѫpb1ai>N0^3Õ>HITaؔ>h)fhLcS0>a]9վC'uQ$,>c
i#
6>gsNpm^%hO]>3*FXCw>U
he6\>ikQ
8fdNpYI'>Y(=ykZ]ҊGb3>fJis~ە>e(nUU4@:>^iݬQg{3>iB	;cȽ6J^>QgQƹײ>Cf18aØ>hfE
!hmx`>bLpqJ84{4L15S7>bWPi1#>hN&W`{>A4D*L>R:
dT>inႪg{ɓ*>^;3e[%!iX>fŀ
s ZESZ>JR>YqAfojm>iȃdeٖ&[>WQH#`>(T\>gXP߾iX.>dFzTþT[3):ӓiɋ<>_~ hJ]>i{ecG'>Q#xf>DJ7&aN^>>h"Oi?b>>b\LL0GJ8}?>bV:vi68l>>hCaϙ>Eȿm>Pb4cCV>iKꉾhz鱧>`i
@:`(S,膹
>d[XdiM>h|yr_ D>5j]hx>U@ep1$E>jg|Ex>\&T85XlToP>f2Sۻ#j9l>gĉZ`1z(=OSF>Z?Ʈf=7qQ>jN)
fg>Yo>gnjWZ>f$QgWQuA.`>]9
g4?*>jYmd`e9͕>U%>6An_mx>h^l*jU1>eiT7gx=D󫪹>`pJVwh >jOdd0'm>R_l>AqZ6Na^>izjGc[>dXJ@Q03)FDjeœ>a>[%
iY1G>jAtnQd
^t)>PW9>F>ib_p-
	>iԷ%j>b?۩>cˇҬO?X=Hw>b`n?xi˦
Z>j@
Dc-Q>N3S>IdXbɮM>i͇fjF1B~>c=&oM4^fJbKU>bK^Ѿj7>jT%?Nctf>Md?o:>J!
ܾc8>j>KljhWmq>c|yvMTpK4"
zP>c $$jX"6>j:돾c?'J>M0	>KޓfBc">jk+].qɾj&2>c.	Nij(ҾJmb>cFZ9jwq|}>jGdgH?>O\>Il8dbA!>j|=:k>dZ:?ZPZs GO>b^jx\H>k8˾dq{>Q>F$bg>jkȾks/>e:RľC[wF>b~jR9w#4>keãu>T*R]U>A>]a"]r\>j+UJk{fg>f\;U3;~6	6>`pS,eiWYߦ>l/~:&g&
4>Wi'n>4P(x`9a>i4ljJXc>g'uYsi8'ڛYV>^qMRiPv>lhs1>[k>p:萖\bG,>h)~lB>i6
@^!ǖ>Ii>Z/hJ!"N:>lEJimk>`R*;31+TLXV>g8Ylgtv>j141aM:H>?`p>U)fA>lc7kxR>c/FoARR>e?f3lU%/>l9	Lds!}Y>Mo>Niaqd3h>lklbT>eLGnپR#'G
ð>cW^.kd>mp;GogYK;~>Vdۄ;>>SsDaӃ>k[32mK>hoZ@S)][v>`g8DjK->n5HQ9&(j*z>^ޅܧV\X]>ifhky:HcaM
>95Og5>X?h8>nJ?l̴>ckGG3koSE8s$ʆ>fmG>mŢeҡ>QV>L+@dbX>mofnĬ>>hߘݽdVط
@;M>bZFl"qh>o8n'j
w>\ob>"{;`O>k`*JoN2>k]azP%K>0OlX>['}
-i[9q>ojm}B>c`lExUN˭>g:dH凾oI@ >nu)f5>Qo)i>L/Mle|>n9joݤ>ibоXlBlSbzm[
9H>pRn$%kЧ\t>`
o#__A-]>keN0psX>m&hcLIȄ>AI|]F>XɽliV 1>pT\LoB3>fQ	bP7>fXoU9>p+j0LX7>Y?P>>~dc5S>nw\^bp\>m:a	h>3ձ>_w2M$Zll>qSyorc>e-ѕgsFNUo V(z>i\pݝ>pivwU>U7X->JĈ3fR9>pF<`qm.h>l)l^6EN)U(->bC;"nQa>qi)ot3>dMEd>Byp[#>kVmqF>qȬuIh>R񻰑>Plhh!	 >>qȽm׾qk駈>mȭ^;	e4fgS>c2Ѿp/]>rig&+pVP&>d51}<~3W\r.>mrVk>q{?ZKiճ2>Sɗ>Q>EYh>>qߜrrfK>n8/ٙ`8]0cl6pgI>s*C;*q=P>f^6ChG[̩X>mi>
r+v>r0olL0e>Wah>LF|h[>r#߾;s˸j>pX&֎bG!Q=	}>b'}pw>smsr]GcQ>iNMO!GlfWj{ƒ>lߕsz7h>t5o%.A\	>_O@>?g2Dfo>r4&Ltj>re }\gi3(>A :Z>_Z$p2>t]딾tPs>nt'm-Z#[AMʇ>jbk7sLP>urAUrE$y>eG(뉾(`kfc>q?6ľuk2;>tgmf=ʙ>UDh>T#>mpBʚ>tIv+i>rR~K6Ծd^!ǻqT>e=վr>vOL`u!p>mSe>±ShYNw5>po'v	OP>wfr+a>cCE[>2
ahzҢ>t,δ4PwA>urm\ݲ>Q9>>\WV޾qpD%>w/̉	xw>sMl{d?$74LJe>iGu?׀>xd'zv#	\Z>oPnG_RWTqǘ 
xTkE>y?T}td0M>e )E>4v9jcU>v0ʻܾz0J>x?	K6po+&&>U>>]BZe|`rr>yyFPJz)5>uݭS(hITO k>jbb
ؾvfE>{wpz)y>rƩ[$Z
0
>rzB>|^PxL8>lQ"->4iTE}:=v>w3TT}+AU7>|L+Ou
,j>aX>TN$rk%DIge>{~T]>>zډ.lvps>I<%>fWQ3CӾwW>~cq'>xMf$h+t#G5cB>qƒZ|ZY08>y`f~=L>tq,ZZdb0IT>wScPB!-\U>Ⱦ|hJx>pKQ8|oR>|17 >#?P}y>f%.>XM|Mv[J>m@.>Juq3#>TҠ>iS|ڈu9}>[n߾q1e3|>sLP9t>f=X3>|hLg13Nܾ`<=">z|uk@t>UyQX>y6ի
Vb󠴾nՃ]+>F%UrH`>ܾO>t>1Q)HwuB>BB~N=h> Ӹh>nٌt>a|_t2V->ŊZ,@t>TPȾZ#}>b?!>pIlOװ
>\GPI=dl>^.|9a>A7|>yʰ{#>g+8`"SP>h_xc͊5X2>ne\UT>\쾐+;>*kzrǖ@oMl\^E>8ل׾>]Rd'r>W7g2^{0JU>tZR3:^>;o#<>2
1}?JQ=qN>.Ⱦsт>?O&՞uk>:V>`7X_l:>w9*Cn>͜>߬E{>V.~U>xM3\I1L>ZzXLRBĤ>U%/R>@.$>I^e񿾠nB>
澬M1W25>WW㶾+6hI>{Wde>,evM$G>Qkj>vpEub:>qu̾9Q̫>̤{cVpJZk>NLJ;޾ZZhs>fFq>XX:X>("]@R>gbW
hK{dhh>b%mG᫜9'P$#5"b>c`P{h3>f}y16YKgR>[0)fO>>h81@b*
7>L'Nv>KVݨ9b8s->h ˾f,>\	ȶ4RY?>f^thc>cIC؇PA;FpZ>aphuQl|3>g~6^o8.>1>V$dоe$Khk>h	Xed^%>SG>?צľ`]>h3{zh\>`(?SN>dӹ־hJ]s>eo>٭W$#Fؾ0fw
<>^j:g\ǭqP>hwcc%bJ4i>Gw5>O]X1cO+`}>hFXf:ٝ>ZoDnwqZa0r<>ftXG&h痆M>cPh	=]FzkG:>aSohY>g~о^XC>4F*Q>VA0de;NE>h#{d}Mv>U.eI3>8aG5Ǿ_~f>gƦh>v>aq=*E227PFAX>cffhWIN>f\MHOZ0|9rDkvY>ZƅPvf)
^>hdnscnb"@>P^Ӟ1>FhF{	gk9>_FC[c7H#U5#	[>d{Th>eI[Vbyqm2n،>^1\/gLԌ>hkWba1>IK f>MubG)>h?3fB8>\wLvTS$1C,X-8>e1h\=v>dn{[^SNC>,[JC>`6%ugm>hбa/a4>DHXӖV>Q%9ɾc!s>h«9颾fl1>ZY#{1͜Y,"~X>f<ii׾h=>c0
)R	YQ"BTl1>`͝'gi3>gX`؇I>Aӣf>R@z`c񎨿Z>h6^~f8g
>YOWx=`N}ZDa\>fbQmh>cŞMQCB9A)>`{+>hY^>gΰ`	C>A>R%cR&>h8fR`]>ZUA0:Z	s/E8>f>H%`hI>d
RX
@qu>`XcHgj!w>hjV@a6>DR>P!hf|>[/ y"eX_h>e_V
hXvj>d6LTg{cV8PM>_0YLXxg~>hsűL־b.To>J**ȷc>L *pbI޿>hS>gXږ>^|(J50B''Ut5h>d3Ce~UNW(BB#&Z\>\-Jjf΍W>h)?zc୅>QT[ >D˾aq>hܨHqh>abC3w\KQ*w>c	^壾h$sh>fL:M&\OT7>%>W
혈OeBc>i"&վe)ew`Y>V&
_>1J]8D>g:|h1_%+>cA^|Oe@⌾F,L7%>a򯺾hU[mJT>h͡`H:>B1r_>Qc!:(>h9f,9x>\/Ң'P
#+DPWn>edYi(wGu>eP؎V7V/>>]og->£>hucyuM>P&>Dxr	Va*WP>h?Maab4 E?P7c)>cM	/)ؾh.>ga4^.Hy>3/k>U?R,޾eV@>i@ܽf#8y_]>YPb>
轾Z"*>f>i;~>dU!_TAB~:\CH>_ WRg>hѫpb1ai>N0^3Õ>HITaؔ>h)fhLcS0>a]9վC'uQ$,>c
i#
6>gsNpm^%hO]>3*FXCw>U
he6\>ikQ
8fdNpYI'>Y(=ykZ]ҊGb3>fJis~ە>e(nUU4@:>^iݬQg{3>iB	;cȽ6J^>QgQƹײ>Cf18aØ>hfE
!hmx`>bLpqJ84{4L15S7>bWPi1#>hN&W`{>A4D*L>R:
dT>inႪg{ɓ*>^;3e[%!iX>fŀ
s ZESZ>JR>YqAfojm>iȃdeٖ&[>WQH#`>(T\>gXP߾iX.>dFzTþT[3):ӓiɋ<>_~ hJ]>i{ecG'>Q#xf>DJ7&aN^>>h"Oi?b>>b\LL0GJ8}?>bV:vi68l>>hCaϙ>Eȿm>Pb4cCV>iKꉾhz鱧>`i
@:`(S,膹
>d[XdiM>h|yr_ D>5j]hx>U@ep1$E>jg|Ex>\&T85XlToP>f2Sۻ#j9l>gĉZ`1z(=OSF>Z?Ʈf=7qQ>jN)
fg>Yo>gnjWZ>f$QgWQuA.`>]9
g4?*>jYmd`e9͕>U%>6An_mx>h^l*jU1>eiT7gx=D󫪹>`pJVwh >jOdd0'm>R_l>AqZ6Na^>izjGc[>dXJ@Q03)FDjeœ>a>[%
iY1G>jAtnQd
^t)>PW9>F>ib_p-
	>iԷ%j>b?۩>cˇҬO?X=Hw>b`n?xi˦
Z>j@
Dc-Q>N3S>IdXbɮM>i͇fjF1B~>c=&oM4^fJbKU>bK^Ѿj7>jT%?Nctf>Md?o:>J!
ܾc8>j>KljhWmq>c|yvMTpK4"
zP>c $$jX"6>j:돾c?'J>M0	>KޓfBc">jk+].qɾj&2>c.	Nij(ҾJmb>cFZ9jwq|}>jGdgH?>O\>Il8dbA!>j|=:k>dZ:?ZPZs GO>b^jx\H>k8˾dq{>Q>F$bg>jkȾks/>e:RľC[wF>b~jR9w#4>keãu>T*R]U>A>]a"]r\>j+UJk{fg>f\;U3;~6	6>`pS,eiWYߦ>l/~:&g&
4>Wi'n>4P(x`9a>i4ljJXc>g'uYsi8'ڛYV>^qMRiPv>lhs1>[k>p:萖\bG,>h)~lB>i6
@^!ǖ>Ii>Z/hJ!"N:>lEJimk>`R*;31+TLXV>g8Ylgtv>j141aM:H>?`p>U)fA>lc7kxR>c/FoARR>e?f3lU%/>l9	Lds!}Y>Mo>Niaqd3h>lklbT>eLGnپR#'G
ð>cW^.kd>mp;GogYK;~>Vdۄ;>>SsDaӃ>k[32mK>hoZ@S)][v>`g8DjK->n5HQ9&(j*z>^ޅܧV\X]>ifhky:HcaM
>95Og5>X?h8>nJ?l̴>ckGG3koSE8s$ʆ>fmG>mŢeҡ>QV>L+@dbX>mofnĬ>>hߘݽdVط
@;M>bZFl"qh>o8n'j
w>\ob>"{;`O>k`*JoN2>k]azP%K>0OlX>['}
-i[9q>ojm}B>c`lExUN˭>g:dH凾oI@ >nu)f5>Qo)i>L/Mle|>n9joݤ>ibоXlBlSbzm[
9H>pRn$%kЧ\t>`
o#__A-]>keN0psX>m&hcLIȄ>AI|]F>XɽliV 1>pT\LoB3>fQ	bP7>fXoU9>p+j0LX7>Y?P>>~dc5S>nw\^bp\>m:a	h>3ձ>_w2M$Zll>qSyorc>e-ѕgsFNUo V(z>i\pݝ>pivwU>U7X->JĈ3fR9>pF<`qm.h>l)l^6EN)U(->bC;"nQa>qi)ot3>dMEd>Byp[#>kVmqF>qȬuIh>R񻰑>Plhh!	 >>qȽm׾qk駈>mȭ^;	e4fgS>c2Ѿp/]>rig&+pVP&>d51}<~3W\r.>mrVk>q{?ZKiճ2>Sɗ>Q>EYh>>qߜrrfK>n8/ٙ`8]0cl6pgI>s*C;*q=P>f^6ChG[̩X>mi>
r+v>r0olL0e>Wah>LF|h[>r#߾;s˸j>pX&֎bG!Q=	}>b'}pw>smsr]GcQ>iNMO!GlfWj{ƒ>lߕsz7h>t5o%.A\	>_O@>?g2Dfo>r4&Ltj>re }\gi3(>A :Z>_Z$p2>t]딾tPs>nt'm-Z#[AMʇ>jbk7sLP>urAUrE$y>eG(뉾(`kfc>q?6ľuk2;>tgmf=ʙ>UDh>T#>mpBʚ>tIv+i>rR~K6Ծd^!ǻqT>e=վr>vOL`u!p>mSe>±ShYNw5>po'v	OP>wfr+a>cCE[>2
ahzҢ>t,δ4PwA>urm\ݲ>Q9>>\WV޾qpD%>w/̉	xw>sMl{d?$74LJe>iGu?׀>xd'zv#	\Z>oPnG_RWTqǘ 
xTkE>y?T}td0M>e )E>4v9jcU>v0ʻܾz0J>x?	K6po+&&>U>>]BZe|`rr>yyFPJz)5>uݭS(hITO k>jbb
ؾvfE>{wpz)y>rƩ[$Z
0
>rzB>|^PxL8>lQ"->4iTE}:=v>w3TT}+AU7>|L+Ou
,j>aX>TN$rk%DIge>{~T]>>zډ.lvps>I<%>fWQ3CӾwW>~cq'>xMf$h+t#G5cB>qƒZ|ZY08>y`f~=L>tq,ZZdb0IT>wScPB!-\U>Ⱦ|hJx>pKQ8|oR>|17 >#?P}y>f%.>XM|Mv[J>m@.>Juq3#>TҠ>iS|ڈu9}>[n߾q1e3|>sLP9t>f=X3>|hLg13Nܾ`<=">z|uk@t>UyQX>y6ի
Vb󠴾nՃ]+>F%UrH`>ܾO>t>1Q)HwuB>BB~N=h> Ӹh>nٌt>a|_t2V->ŊZ,@t>TPȾZ#}>b?!>pIlOװ
>\GPI=dl>^.|9a>A7|>yʰ{#>g+8`"SP>h_xc͊5X2>ne\UT>\쾐+;>*kzrǖ@oMl\^E>8ل׾>]Rd'r>W7g2^{0JU>tZR3:^>;o#<>2
1}?JQ=qN>.Ⱦsт>?O&՞uk>:V>`7X_l:>w9*Cn>͜>߬E{>V.~U>xM3\I1L>ZzXLRBĤ>U%/R>@.$>I^e񿾠nB>
澬M1W25>WW㶾+6hI>{Wde>,evM$G>Qkj>vpEub:>qu̾9Q̫>̤{cVpJZk>NLJ;޾ZZhs>fFq>XX:X>("]@R>gbW
hK{dhh>b%mG᫜9'P$#5"b>c`P{h3>f}y16YKgR>[0)fO>>h81@b*
7>L'Nv>KVݨ9b8s->h ˾f,>\	ȶ4RY?>f^thc>cIC؇PA;FpZ>aphuQl|3>g~6^o8.>1>V$dоe$Khk>h	Xed^%>SG>?צľ`]>h3{zh\>`(?SN>dӹ־hJ]s>eo>٭W$#Fؾ0fw
<>^j:g\ǭqP>hwcc%bJ4i>Gw5>O]X1cO+`}>hFXf:ٝ>ZoDnwqZa0r<>ftXG&h痆M>cPh	=]FzkG:>aSohY>g~о^XC>4F*Q>VA0de;NE>h#{d}Mv>U.eI3>8aG5Ǿ_~f>gƦh>v>aq=*E227PFAX>cffhWIN>f\MHOZ0|9rDkvY>ZƅPvf)
^>hdnscnb"@>P^Ӟ1>FhF{	gk9>_FC[c7H#U5#	[>d{Th>eI[Vbyqm2n،>^1\/gLԌ>hkWba1>IK f>MubG)>h?3fB8>\wLvTS$1C,X-8>e1h\=v>dn{[^SNC>,[JC>`6%ugm>hбa/a4>DHXӖV>Q%9ɾc!s>h«9颾fl1>ZY#{1͜Y,"~X>f<ii׾h=>c0
)R	YQ"BTl1>`͝'gi3>gX`؇I>Aӣf>R@z`c񎨿Z>h6^~f8g
>YOWx=`N}ZDa\>fbQmh>cŞMQCB9A)>`{+>hY^>gΰ`	C>A>R%cR&>h8fR`]>ZUA0:Z	s/E8>f>H%`hI>d
RX
@qu>`XcHgj!w>hjV@a6>DR>P!hf|>[/ y"eX_h>e_V
hXvj>d6LTg{cV8PM>_0YLXxg~>hsűL־b.To>J**ȷc>L *pbI޿>hS>gXږ>^|(J50B''Ut5h>d3Ce~UNW(BB#&Z\>\-Jjf΍W>h)?zc୅>QT[ >D˾aq>hܨHqh>abC3w\KQ*w>c	^壾h$sh>fL:M&\OT7>%>W
혈OeBc>i"&վe)ew`Y>V&
_>1J]8D>g:|h1_%+>cA^|Oe@⌾F,L7%>a򯺾hU[mJT>h͡`H:>B1r_>Qc!:(>h9f,9x>\/Ң'P
#+DPWn>edYi(wGu>eP؎V7V/>>]og->£>hucyuM>P&>Dxr	Va*WP>h?Maab4 E?P7c)>cM	/)ؾh.>ga4^.Hy>3/k>U?R,޾eV@>i@ܽf#8y_]>YPb>
轾Z"*>f>i;~>dU!_TAB~:\CH>_ WRg>hѫpb1ai>N0^3Õ>HITaؔ>h)fhLcS0>a]9վC'uQ$,>c
i#
6>gsNpm^%hO]>3*FXCw>U
he6\>ikQ
8fdNpYI'>Y(=ykZ]ҊGb3>fJis~ە>e(nUU4@:>^iݬQg{3>iB	;cȽ6J^>QgQƹײ>Cf18aØ>hfE
!hmx`>bLpqJ84{4L15S7>bWPi1#>hN&W`{>A4D*L>R:
dT>inႪg{ɓ*>^;3e[%!iX>fŀ
s ZESZ>JR>YqAfojm>iȃdeٖ&[>WQH#`>(T\>gXP߾iX.>dFzTþT[3):ӓiɋ<>_~ hJ]>i{ecG'>Q#xf>DJ7&aN^>>h"Oi?b>>b\LL0GJ8}?>bV:vi68l>>hCaϙ>Eȿm>Pb4cCV>iKꉾhz鱧>`i
@:`(S,膹
>d[XdiM>h|yr_ D>5j]hx>U@ep1$E>jg|Ex>\&T85XlToP>f2Sۻ#j9l>gĉZ`1z(=OSF>Z?Ʈf=7qQ>jN)
fg>Yo>gnjWZ>f$QgWQuA.`>]9
g4?*>jYmd`e9͕>U%>6An_mx>h^l*jU1>eiT7gx=D󫪹>`pJVwh >jOdd0'm>R_l>AqZ6Na^>izjGc[>dXJ@Q03)FDjeœ>a>[%
iY1G>jAtnQd
^t)>PW9>F>ib_p-
	>iԷ%j>b?۩>cˇҬO?X=Hw>b`n?xi˦
Z>j@
Dc-Q>N3S>IdXbɮM>i͇fjF1B~>c=&oM4^fJbKU>bK^Ѿj7>jT%?Nctf>Md?o:>J!
ܾc8>j>KljhWmq>c|yvMTpK4"
zP>c $$jX"6>j:돾c?'J>M0	>KޓfBc">jk+].qɾj&2>c.	Nij(ҾJmb>cFZ9jwq|}>jGdgH?>O\>Il8dbA!>j|=:k>dZ:?ZPZs GO>b^jx\H>k8˾dq{>Q>F$bg>jkȾks/>e:RľC[wF>b~jR9w#4>keãu>T*R]U>A>]a"]r\>j+UJk{fg>f\;U3;~6	6>`pS,eiWYߦ>l/~:&g&
4>Wi'n>4P(x`9a>i4ljJXc>g'uYsi8'ڛYV>^qMRiPv>lhs1>[k>p:萖\bG,>h)~lB>i6
@^!ǖ>Ii>Z/hJ!"N:>lEJimk>`R*;31+TLXV>g8Ylgtv>j141aM:H>?`p>U)fA>lc7kxR>c/FoARR>e?f3lU%/>l9	Lds!}Y>Mo>Niaqd3h>lklbT>eLGnپR#'G
ð>cW^.kd>mp;GogYK;~>Vdۄ;>>SsDaӃ>k[32mK>hoZ@S)][v>`g8DjK->n5HQ9&(j*z>^ޅܧV\X]>ifhky:HcaM
>95Og5>X?h8>nJ?l̴>ckGG3koSE8s$ʆ>fmG>mŢeҡ>QV>L+@dbX>mofnĬ>>hߘݽdVط
@;M>bZFl"qh>o8n'j
w>\ob>"{;`O>k`*JoN2>k]azP%K>0OlX>['}
-i[9q>ojm}B>c`lExUN˭>g:dH凾oI@ >nu)f5>Qo)i>L/Mle|>n9joݤ>ibоXlBlSbzm[
9H>pRn$%kЧ\t>`
o#__A-]>keN0psX>m&hcLIȄ>AI|]F>XɽliV 1>pT\LoB3>fQ	bP7>fXoU9>p+j0LX7>Y?P>>~dc5S>nw\^bp\>m:a	h>3ձ>_w2M$Zll>qSyorc>e-ѕgsFNUo V(z>i\pݝ>pivwU>U7X->JĈ3fR9>pF<`qm.h>l)l^6EN)U(->bC;"nQa>qi)ot3>dMEd>Byp[#>kVmqF>qȬuIh>R񻰑>Plhh!	 >>qȽm׾qk駈>mȭ^;	e4fgS>c2Ѿp/]>rig&+pVP&>d51}<~3W\r.>mrVk>q{?ZKiճ2>Sɗ>Q>EYh>>qߜrrfK>n8/ٙ`8]0cl6pgI>s*C;*q=P>f^6ChG[̩X>mi>
r+v>r0olL0e>Wah>LF|h[>r#߾;s˸j>pX&֎bG!Q=	}>b'}pw>smsr]GcQ>iNMO!GlfWj{ƒ>lߕsz7h>t5o%.A\	>_O@>?g2Dfo>r4&Ltj>re }\gi3(>A :Z>_Z$p2>t]딾tPs>nt'm-Z#[AMʇ>jbk7sLP>urAUrE$y>eG(뉾(`kfc>q?6ľuk2;>tgmf=ʙ>UDh>T#>mpBʚ>tIv+i>rR~K6Ծd^!ǻqT>e=վr>vOL`u!p>mSe>±ShYNw5>po'v	OP>wfr+a>cCE[>2
ahzҢ>t,δ4PwA>urm\ݲ>Q9>>\WV޾qpD%>w/̉	xw>sMl{d?$74LJe>iGu?׀>xd'zv#	\Z>oPnG_RWTqǘ 
xTkE>y?T}td0M>e )E>4v9jcU>v0ʻܾz0J>x?	K6po+&&>U>>]BZe|`rr>yyFPJz)5>uݭS(hITO k>jbb
ؾvfE>{wpz)y>rƩ[$Z
0
>rzB>|^PxL8>lQ"->4iTE}:=v>w3TT}+AU7>|L+Ou
,j>aX>TN$rk%DIge>{~T]>>zډ.lvps>I<%>fWQ3CӾwW>~cq'>xMf$h+t#G5cB>qƒZ|ZY08>y`f~=L>tq,ZZdb0IT>wScPB!-\U>Ⱦ|hJx>pKQ8|oR>|17 >#?P}y>f%.>XM|Mv[J>m@.>Juq3#>TҠ>iS|ڈu9}>[n߾q1e3|>sLP9t>f=X3>|hLg13Nܾ`<=">z|uk@t>UyQX>y6ի
Vb󠴾nՃ]+>F%UrH`>ܾO>t>1Q)HwuB>BB~N=h> Ӹh>nٌt>a|_t2V->ŊZ,@t>TPȾZ#}>b?!>pIlOװ
>\GPI=dl>^.|9a>A7|>yʰ{#>g+8`"SP>h_xc͊5X2>ne\UT>\쾐+;>*kzrǖ@oMl\^E>8ل׾>]Rd'r>W7g2^{0JU>tZR3:^>;o#<>2
1}?JQ=qN>.Ⱦsт>?O&՞uk>:V>`7X_l:>w9*Cn>͜>߬E{>V.~U>xM3\I1L>ZzXLRBĤ>U%/R>@.$>I^e񿾠nB>
澬M1W25>WW㶾+6hI>{Wde>,evM$G>Qkj>vpEub:>qu̾9Q̫>̤{cVpJZk>NLJ;޾ZZhs>^>5*Nl1>Wf1v5$~N>LSM{]ﾩcν>.S%
>#ɾ,eW>KΥ>Pu3
u>s0׾-8>)Iͩ-B>!s>
({x>*þۖ>LrBw>Mf3m>!bþO>jfҾx>Xባ=Vr(pU[>H~}x>n2yrXf>"I(C8=[>Nt0ofb>|ƺػ>_pL3>>⭜@α*>$Q]㬾O	.>a$1>vKsJB>^<*=
>Vt-u_0>5bo&6x>@Q"ps>|Q̳JS?ߴ#u>6q>p@=%U3>nGtW	P>g0[O>g:#dM>72dē2R>:)7ƾqr!P9>w㾂3i>S-6KL>uW w(˾@Ab8qJHe߃>aþ6wZ>͈]w->Zc)>g⎱z /V}>~.[u>xf	vchm׾^}sQ>ve?")>Shؾy\/@$>g5n>Q{!rs&B>|S~,~7*R$>y0ӞjL\ʾ@z[>pWYBz:P_rr>}3qDx㊟>kV5>$ldx(>xƩ4{Gla>wʫkǾkri>#dn>iI\lvW
&>zav$,M>kD@zؾ0WȾg:x[N>tg>x,^YQ,>u3/jx`>0q
>f9sfX90>wasծt{HS0!>h>_9o$4PZzeœ?>s6&/v?z>s3.er~r
>e	49r!q3>u/꿇q >cC.|>1W<f@f:>rWԚpt&3>pZG̾`$B,>gPyfr+U>s9kLmw>YC4|w>NʝliEZw'>qԪ=qU֣>i@@Q }1UJGu>j׾q{\I>po	Le2>B(驃>[%xl,sf!>q)rn-?$H>ay^aZa?>mV~INpaA(
z>jR5dYNwkBY%:<>dhPnD6n&>nfu%>N@l>R5zg8RL>n%ؖzlSN/G>a.1~g[!>iuվHmg)Q>hPXvھ;N>a|jtP
>kxd,1]>Jz$*>Q
ea!>kCڪh˔>->]Ғ2
xO[y=I>gjbи7>dâeľQ-s-FЫgF#>bP'Zi!rD>hs:޾_>K>38>V!Դ!ek>h/0,bxd]>Sh>@S`e>SX>g^G	fڣ	>^䁖#6x;fTr>dme
gdC>c@=gR
5!ݾ?h^>_Nf/>euq5 [vA>0kN)al>T񃵾cP8>fiՄa.z>N^6>C>_%>e.ucK;/>WQcTgd=>^YDXqJԞ8W>`.xW"d;*;>a"վR@=L2qy>Yhb>bXvX;ٮ>.(>RHHqa2l>c]KW>F#(Y>Ep+]UI>b8^`dwvQ>QB]p">/ @W
>a/aIl
>VA&پ#jpDyQf+9K>`¬y>a+*>ZQP@QVH#Z>\	c˭aTO^>\NJ:.<[0T>XG)`@>^|QM|,!!l>T_N_>_u(UѾTTg>!_H&>P݌]]*>_,f^VV>7T5>Iw]Z>_e-*\)Xw>B~&ٿ>Bcg
XqUi>^gkrYXc>G>8^WU@xH>]&ZQ#">LQ4V=>+sE{7Sg>\)/wϾ[,!Jژ>O˩F]0>j0ھQy$Q7>[jH;~[K1>Q9(}~oO>Z4[0Tn>R1˵2$Q!K{]X>YѩRZ*	>R8d/p;H~d>WC}Z!>S>hlɾ3[og۾FO~(>WܑZY$>Sh"H6QEDYW>>V4U[Ykq>S`7XkCCoA(>UPYq
>S,z?/8<
-B8I"7>Uk3A	Xߌ>RZx7CǾBVĕ#>TΏw+X,]w>RQ
ܾ6?1ÖEBv#>T]<Wo>QsM4
TB/=G>T8rW
XJL>P;R1>`pCc8ֆ>T,7Vy6&>OU*8EM>T1^Uۄi>MeV!Fdwk>T@75OU* mz>KsQ
x1ˮTHNyS>TR)RT`wUp\>H>m>HӾJ.=k>T[L#St_g;>E> ,L%!k>TQE3SR`!>B'ZD>.hINW]s>T+cQ\zg>6Y	OnoN!>SЖQJOH"|>4n0+2M>=;(pPC8>SW٦KZI>'Cc>B]IQ@L>RbkϾGsv>>F\%Rs>Qe'C(f;>I}gR:S}V>P ׽=pn1
a>L~:!0ϾR7njR>LˀZ2pY;m
ƹ>N<)Qq>HlEYTm
BkGhFE>PcnrP.>C`wp>SҞFj1>PjMNhoD!><`J>/O_Jn`>~>PدJJ0xFS>:C2MTh>PD[/Eu>
(dc>BN-*á@7^"_"tсE;r>GPv
4Oْl>J;3;C߾58o$>Jb)ѾO"i>EԠkѭ(q@r>MLSEL2>@>hEۻ>N6DIM80>2PX3>5-8%<\I݆b>M~z7DAp>^Kq>@2̋}7L&녪>K^ DG
<^$| 
>EY񅙾Lϋ%>F+z߾8%(pX>I8<}}fKqw>AFD,=B(ST>KnJGH^&c>43<3>0>JBǾF?;>KB!m1CY<>I/>=K(¾Ir>HRl9|پ$G>Dp6	M1J)v>Dg$[nR8W,T>H":ajFHW>	;:׾BlYU->I8D,},>+!?U>4ɾF+8>H{=)@>@=RH+>Dopþ./[52g+|)
>E:>)[e_&=zʾ?49	{>GÏDp"uBk>.sj$EU>1Y8Da;>G ΍`&\=>pk>?:2GkB>C>;,Cfa13>DZDⷾFG^>;_Cϸ>Y`(h?+	e>Fdͪ=B_>'Ϟbz:>2~Q1D*Ci.>EJȫG8OJVYY>@Z`E}>Ar!IR^04
}G>D#Ja9Dy>4=+> udJ%@geDT>EpD>>>AO(	>7ktD!_-x>Bu
04Az<D)poz>:cژ=cF:4ro>CM@]u:">%;̥H>100B5vw>BG4pʱRd>><ϙC|~0]>< w|?U!6
w]>BƝ=A1>,	d>)f}@d?>Bt+I&6w0Jx(\	>:'Bg->=huоL63">A~"@n>.HP=y#>%Ej>6olC>AῺ6qzO`fnj>8A,><\KiFF1H>@ƛl?#0:>,u[>$z/!(=ӭekt>@x^q4sO3>8b@Bӫ>:
wk5_r6(2K7)>@$:y=@43>(I1>'J?=0F@>?lz2FVb;!:>9#w@ eR>6"0	c3h&j_>?g:<-> J5`>,$=V/(q>=9א]+%ID!:Hc>:A>Cv82>2PX>uH3fQ6c=*>>Sζ6rTc*>"F1>1$ž=ZHco_>9\"' Qhϓ*\۞&>;zݑo;M-Uw>)$> Y8ް֪_>5?羾4.Y%+0
&-82jwQ>;ӎK6ơ!>ق@f>,#zL3:ˠ>8M#eکs?q$z{>819ӥ_I>*q2>O56\ㆲ>:ZLw0>u/6Ž9s>3/ΣC:N3>2^2½'h0^&A>9|+ܾ4^>ei)g>+yA~ľ8,˜>67ΘϪFƾ%{5^>7mT`7<,K2>$_>p465͈.>7؍)Ϙ>zL­(Y>34Kž8Ff>-Ȥ>?Ǘž1pn>7:rҾ0A2!=$XD>/ᷘ(7~|M>2 г{'R++ت>67]A3:*>J	E>'Y6XS>4 *;fδ#s͎x>5v.4UPsF>!MF>.3춋Ay>4þ$t;BnaO>2'5Lq>'e#y|n>z_1h>58)AvA@?<#
>0[0E4_H6>+J$=c4^'i.RQh>4o!C-=
X>+9m.4Slq>.[.ljt)x>3×=/T>Lގ4>'";3uD>0'}_ZA>[%i$>2<0FLRb>q;o>#4?>2xva>0n,;Kݨ}"6c>1/p0͑>H/:> 7j1z=0m>0#:wQvld>1cX0yph>U1>ZI
0Gn>0_s]3Ez@w>0#uc0:.Z>Nl~6>
پ/o8y>0
K`:UAd‹]#>.V[I:/IaF>dǎ>˺ bo.(
/:J-N.G">Zq>]c@-d(>.(!dǮ4k~3ye;
>,$؄w-OȂ,>,@?8>1',Mӛ,>,W@۾8g8>+]R<,9a>n>ZqN>?Qؾ+wsZ>+F޾lH"m>+zg8[**p>>$>E+Csb>)K+R*8(I_>
7>Eu*٬^H>'{aZTΜ2>*BH*(&3gQ>HV>~a^˾*bEE>%L
A,w>*8Fw
$&T-=V{g> اk)F1>#Te+C#y!Z2	>)Vv!\սsf>"S(<`> n&c}:=;u߶"f>(7v#ݾtsP,J>#~sB׾'~>Ks~>v-O"$:>&派.cz6XF>$"뇉ݾ%OzY>7^>Սʺj$1bj>$2JXB@>%')6#6S>qk>U$~"%5[,>!ֳ5 I&Z >%WFS $Z0=nf>t%$IZ>¿F=1Yՙھ&˒+>$<뮐E݇^3H> dg=#{oޔ>=>>&LO!/&b>"}ž7/zϾ6p>!}
!C(ۣnz>3>9~"@>7mq?d<ub>"aɾCc=r?Q>Le!ٓ3>a=ߠ:iЂd_>!NDd`"kK|!>Jp= uV;C"K>6>Ȱ
:04h$>+NV-]
^>c} 'W&tW=x>譠F">Kvj8'km >LqhA|S`g>L1>"-9o=|e4>:
?&8R>al#{l=/&>V]%ub>{߭-
0>YUOvMx!>{Lt5>_=֮Cs{KcN>{->j029>K{KbBin	^>5*Nl1>Wf1v5$~N>LSM{]ﾩcν>.S%
>#ɾ,eW>KΥ>Pu3
u>s0׾-8>)Iͩ-B>!s>
({x>*þۖ>LrBw>Mf3m>!bþO>jfҾx>Xባ=Vr(pU[>H~}x>n2yrXf>"I(C8=[>Nt0ofb>|ƺػ>_pL3>>⭜@α*>$Q]㬾O	.>a$1>vKsJB>^<*=
>Vt-u_0>5bo&6x>@Q"ps>|Q̳JS?ߴ#u>6q>p@=%U3>nGtW	P>g0[O>g:#dM>72dē2R>:)7ƾqr!P9>w㾂3i>S-6KL>uW w(˾@Ab8qJHe߃>aþ6wZ>͈]w->Zc)>g⎱z /V}>~.[u>xf	vchm׾^}sQ>ve?")>Shؾy\/@$>g5n>Q{!rs&B>|S~,~7*R$>y0ӞjL\ʾ@z[>pWYBz:P_rr>}3qDx㊟>kV5>$ldx(>xƩ4{Gla>wʫkǾkri>#dn>iI\lvW
&>zav$,M>kD@zؾ0WȾg:x[N>tg>x,^YQ,>u3/jx`>0q
>f9sfX90>wasծt{HS0!>h>_9o$4PZzeœ?>s6&/v?z>s3.er~r
>e	49r!q3>u/꿇q >cC.|>1W<f@f:>rWԚpt&3>pZG̾`$B,>gPyfr+U>s9kLmw>YC4|w>NʝliEZw'>qԪ=qU֣>i@@Q }1UJGu>j׾q{\I>po	Le2>B(驃>[%xl,sf!>q)rn-?$H>ay^aZa?>mV~INpaA(
z>jR5dYNwkBY%:<>dhPnD6n&>nfu%>N@l>R5zg8RL>n%ؖzlSN/G>a.1~g[!>iuվHmg)Q>hPXvھ;N>a|jtP
>kxd,1]>Jz$*>Q
ea!>kCڪh˔>->]Ғ2
xO[y=I>gjbи7>dâeľQ-s-FЫgF#>bP'Zi!rD>hs:޾_>K>38>V!Դ!ek>h/0,bxd]>Sh>@S`e>SX>g^G	fڣ	>^䁖#6x;fTr>dme
gdC>c@=gR
5!ݾ?h^>_Nf/>euq5 [vA>0kN)al>T񃵾cP8>fiՄa.z>N^6>C>_%>e.ucK;/>WQcTgd=>^YDXqJԞ8W>`.xW"d;*;>a"վR@=L2qy>Yhb>bXvX;ٮ>.(>RHHqa2l>c]KW>F#(Y>Ep+]UI>b8^`dwvQ>QB]p">/ @W
>a/aIl
>VA&پ#jpDyQf+9K>`¬y>a+*>ZQP@QVH#Z>\	c˭aTO^>\NJ:.<[0T>XG)`@>^|QM|,!!l>T_N_>_u(UѾTTg>!_H&>P݌]]*>_,f^VV>7T5>Iw]Z>_e-*\)Xw>B~&ٿ>Bcg
XqUi>^gkrYXc>G>8^WU@xH>]&ZQ#">LQ4V=>+sE{7Sg>\)/wϾ[,!Jژ>O˩F]0>j0ھQy$Q7>[jH;~[K1>Q9(}~oO>Z4[0Tn>R1˵2$Q!K{]X>YѩRZ*	>R8d/p;H~d>WC}Z!>S>hlɾ3[og۾FO~(>WܑZY$>Sh"H6QEDYW>>V4U[Ykq>S`7XkCCoA(>UPYq
>S,z?/8<
-B8I"7>Uk3A	Xߌ>RZx7CǾBVĕ#>TΏw+X,]w>RQ
ܾ6?1ÖEBv#>T]<Wo>QsM4
TB/=G>T8rW
XJL>P;R1>`pCc8ֆ>T,7Vy6&>OU*8EM>T1^Uۄi>MeV!Fdwk>T@75OU* mz>KsQ
x1ˮTHNyS>TR)RT`wUp\>H>m>HӾJ.=k>T[L#St_g;>E> ,L%!k>TQE3SR`!>B'ZD>.hINW]s>T+cQ\zg>6Y	OnoN!>SЖQJOH"|>4n0+2M>=;(pPC8>SW٦KZI>'Cc>B]IQ@L>RbkϾGsv>>F\%Rs>Qe'C(f;>I}gR:S}V>P ׽=pn1
a>L~:!0ϾR7njR>LˀZ2pY;m
ƹ>N<)Qq>HlEYTm
BkGhFE>PcnrP.>C`wp>SҞFj1>PjMNhoD!><`J>/O_Jn`>~>PدJJ0xFS>:C2MTh>PD[/Eu>
(dc>BN-*á@7^"_"tсE;r>GPv
4Oْl>J;3;C߾58o$>Jb)ѾO"i>EԠkѭ(q@r>MLSEL2>@>hEۻ>N6DIM80>2PX3>5-8%<\I݆b>M~z7DAp>^Kq>@2̋}7L&녪>K^ DG
<^$| 
>EY񅙾Lϋ%>F+z߾8%(pX>I8<}}fKqw>AFD,=B(ST>KnJGH^&c>43<3>0>JBǾF?;>KB!m1CY<>I/>=K(¾Ir>HRl9|پ$G>Dp6	M1J)v>Dg$[nR8W,T>H":ajFHW>	;:׾BlYU->I8D,},>+!?U>4ɾF+8>H{=)@>@=RH+>Dopþ./[52g+|)
>E:>)[e_&=zʾ?49	{>GÏDp"uBk>.sj$EU>1Y8Da;>G ΍`&\=>pk>?:2GkB>C>;,Cfa13>DZDⷾFG^>;_Cϸ>Y`(h?+	e>Fdͪ=B_>'Ϟbz:>2~Q1D*Ci.>EJȫG8OJVYY>@Z`E}>Ar!IR^04
}G>D#Ja9Dy>4=+> udJ%@geDT>EpD>>>AO(	>7ktD!_-x>Bu
04Az<D)poz>:cژ=cF:4ro>CM@]u:">%;̥H>100B5vw>BG4pʱRd>><ϙC|~0]>< w|?U!6
w]>BƝ=A1>,	d>)f}@d?>Bt+I&6w0Jx(\	>:'Bg->=huоL63">A~"@n>.HP=y#>%Ej>6olC>AῺ6qzO`fnj>8A,><\KiFF1H>@ƛl?#0:>,u[>$z/!(=ӭekt>@x^q4sO3>8b@Bӫ>:
wk5_r6(2K7)>@$:y=@43>(I1>'J?=0F@>?lz2FVb;!:>9#w@ eR>6"0	c3h&j_>?g:<-> J5`>,$=V/(q>=9א]+%ID!:Hc>:A>Cv82>2PX>uH3fQ6c=*>>Sζ6rTc*>"F1>1$ž=ZHco_>9\"' Qhϓ*\۞&>;zݑo;M-Uw>)$> Y8ް֪_>5?羾4.Y%+0
&-82jwQ>;ӎK6ơ!>ق@f>,#zL3:ˠ>8M#eکs?q$z{>819ӥ_I>*q2>O56\ㆲ>:ZLw0>u/6Ž9s>3/ΣC:N3>2^2½'h0^&A>9|+ܾ4^>ei)g>+yA~ľ8,˜>67ΘϪFƾ%{5^>7mT`7<,K2>$_>p465͈.>7؍)Ϙ>zL­(Y>34Kž8Ff>-Ȥ>?Ǘž1pn>7:rҾ0A2!=$XD>/ᷘ(7~|M>2 г{'R++ت>67]A3:*>J	E>'Y6XS>4 *;fδ#s͎x>5v.4UPsF>!MF>.3춋Ay>4þ$t;BnaO>2'5Lq>'e#y|n>z_1h>58)AvA@?<#
>0[0E4_H6>+J$=c4^'i.RQh>4o!C-=
X>+9m.4Slq>.[.ljt)x>3×=/T>Lގ4>'";3uD>0'}_ZA>[%i$>2<0FLRb>q;o>#4?>2xva>0n,;Kݨ}"6c>1/p0͑>H/:> 7j1z=0m>0#:wQvld>1cX0yph>U1>ZI
0Gn>0_s]3Ez@w>0#uc0:.Z>Nl~6>
پ/o8y>0
K`:UAd‹]#>.V[I:/IaF>dǎ>˺ bo.(
/:J-N.G">Zq>]c@-d(>.(!dǮ4k~3ye;
>,$؄w-OȂ,>,@?8>1',Mӛ,>,W@۾8g8>+]R<,9a>n>ZqN>?Qؾ+wsZ>+F޾lH"m>+zg8[**p>>$>E+Csb>)K+R*8(I_>
7>Eu*٬^H>'{aZTΜ2>*BH*(&3gQ>HV>~a^˾*bEE>%L
A,w>*8Fw
$&T-=V{g> اk)F1>#Te+C#y!Z2	>)Vv!\սsf>"S(<`> n&c}:=;u߶"f>(7v#ݾtsP,J>#~sB׾'~>Ks~>v-O"$:>&派.cz6XF>$"뇉ݾ%OzY>7^>Սʺj$1bj>$2JXB@>%')6#6S>qk>U$~"%5[,>!ֳ5 I&Z >%WFS $Z0=nf>t%$IZ>¿F=1Yՙھ&˒+>$<뮐E݇^3H> dg=#{oޔ>=>>&LO!/&b>"}ž7/zϾ6p>!}
!C(ۣnz>3>9~"@>7mq?d<ub>"aɾCc=r?Q>Le!ٓ3>a=ߠ:iЂd_>!NDd`"kK|!>Jp= uV;C"K>6>Ȱ
:04h$>+NV-]
^>c} 'W&tW=x>譠F">Kvj8'km >LqhA|S`g>L1>"-9o=|e4>:
?&8R>al#{l=/&>V]%ub>{߭-
0>YUOvMx!>{Lt5>_=֮Cs{KcN>{->j029>K{KbBin	^>5*Nl1>Wf1v5$~N>LSM{]ﾩcν>.S%
>#ɾ,eW>KΥ>Pu3
u>s0׾-8>)Iͩ-B>!s>
({x>*þۖ>LrBw>Mf3m>!bþO>jfҾx>Xባ=Vr(pU[>H~}x>n2yrXf>"I(C8=[>Nt0ofb>|ƺػ>_pL3>>⭜@α*>$Q]㬾O	.>a$1>vKsJB>^<*=
>Vt-u_0>5bo&6x>@Q"ps>|Q̳JS?ߴ#u>6q>p@=%U3>nGtW	P>g0[O>g:#dM>72dē2R>:)7ƾqr!P9>w㾂3i>S-6KL>uW w(˾@Ab8qJHe߃>aþ6wZ>͈]w->Zc)>g⎱z /V}>~.[u>xf	vchm׾^}sQ>ve?")>Shؾy\/@$>g5n>Q{!rs&B>|S~,~7*R$>y0ӞjL\ʾ@z[>pWYBz:P_rr>}3qDx㊟>kV5>$ldx(>xƩ4{Gla>wʫkǾkri>#dn>iI\lvW
&>zav$,M>kD@zؾ0WȾg:x[N>tg>x,^YQ,>u3/jx`>0q
>f9sfX90>wasծt{HS0!>h>_9o$4PZzeœ?>s6&/v?z>s3.er~r
>e	49r!q3>u/꿇q >cC.|>1W<f@f:>rWԚpt&3>pZG̾`$B,>gPyfr+U>s9kLmw>YC4|w>NʝliEZw'>qԪ=qU֣>i@@Q }1UJGu>j׾q{\I>po	Le2>B(驃>[%xl,sf!>q)rn-?$H>ay^aZa?>mV~INpaA(
z>jR5dYNwkBY%:<>dhPnD6n&>nfu%>N@l>R5zg8RL>n%ؖzlSN/G>a.1~g[!>iuվHmg)Q>hPXvھ;N>a|jtP
>kxd,1]>Jz$*>Q
ea!>kCڪh˔>->]Ғ2
xO[y=I>gjbи7>dâeľQ-s-FЫgF#>bP'Zi!rD>hs:޾_>K>38>V!Դ!ek>h/0,bxd]>Sh>@S`e>SX>g^G	fڣ	>^䁖#6x;fTr>dme
gdC>c@=gR
5!ݾ?h^>_Nf/>euq5 [vA>0kN)al>T񃵾cP8>fiՄa.z>N^6>C>_%>e.ucK;/>WQcTgd=>^YDXqJԞ8W>`.xW"d;*;>a"վR@=L2qy>Yhb>bXvX;ٮ>.(>RHHqa2l>c]KW>F#(Y>Ep+]UI>b8^`dwvQ>QB]p">/ @W
>a/aIl
>VA&پ#jpDyQf+9K>`¬y>a+*>ZQP@QVH#Z>\	c˭aTO^>\NJ:.<[0T>XG)`@>^|QM|,!!l>T_N_>_u(UѾTTg>!_H&>P݌]]*>_,f^VV>7T5>Iw]Z>_e-*\)Xw>B~&ٿ>Bcg
XqUi>^gkrYXc>G>8^WU@xH>]&ZQ#">LQ4V=>+sE{7Sg>\)/wϾ[,!Jژ>O˩F]0>j0ھQy$Q7>[jH;~[K1>Q9(}~oO>Z4[0Tn>R1˵2$Q!K{]X>YѩRZ*	>R8d/p;H~d>WC}Z!>S>hlɾ3[og۾FO~(>WܑZY$>Sh"H6QEDYW>>V4U[Ykq>S`7XkCCoA(>UPYq
>S,z?/8<
-B8I"7>Uk3A	Xߌ>RZx7CǾBVĕ#>TΏw+X,]w>RQ
ܾ6?1ÖEBv#>T]<Wo>QsM4
TB/=G>T8rW
XJL>P;R1>`pCc8ֆ>T,7Vy6&>OU*8EM>T1^Uۄi>MeV!Fdwk>T@75OU* mz>KsQ
x1ˮTHNyS>TR)RT`wUp\>H>m>HӾJ.=k>T[L#St_g;>E> ,L%!k>TQE3SR`!>B'ZD>.hINW]s>T+cQ\zg>6Y	OnoN!>SЖQJOH"|>4n0+2M>=;(pPC8>SW٦KZI>'Cc>B]IQ@L>RbkϾGsv>>F\%Rs>Qe'C(f;>I}gR:S}V>P ׽=pn1
a>L~:!0ϾR7njR>LˀZ2pY;m
ƹ>N<)Qq>HlEYTm
BkGhFE>PcnrP.>C`wp>SҞFj1>PjMNhoD!><`J>/O_Jn`>~>PدJJ0xFS>:C2MTh>PD[/Eu>
(dc>BN-*á@7^"_"tсE;r>GPv
4Oْl>J;3;C߾58o$>Jb)ѾO"i>EԠkѭ(q@r>MLSEL2>@>hEۻ>N6DIM80>2PX3>5-8%<\I݆b>M~z7DAp>^Kq>@2̋}7L&녪>K^ DG
<^$| 
>EY񅙾Lϋ%>F+z߾8%(pX>I8<}}fKqw>AFD,=B(ST>KnJGH^&c>43<3>0>JBǾF?;>KB!m1CY<>I/>=K(¾Ir>HRl9|پ$G>Dp6	M1J)v>Dg$[nR8W,T>H":ajFHW>	;:׾BlYU->I8D,},>+!?U>4ɾF+8>H{=)@>@=RH+>Dopþ./[52g+|)
>E:>)[e_&=zʾ?49	{>GÏDp"uBk>.sj$EU>1Y8Da;>G ΍`&\=>pk>?:2GkB>C>;,Cfa13>DZDⷾFG^>;_Cϸ>Y`(h?+	e>Fdͪ=B_>'Ϟbz:>2~Q1D*Ci.>EJȫG8OJVYY>@Z`E}>Ar!IR^04
}G>D#Ja9Dy>4=+> udJ%@geDT>EpD>>>AO(	>7ktD!_-x>Bu
04Az<D)poz>:cژ=cF:4ro>CM@]u:">%;̥H>100B5vw>BG4pʱRd>><ϙC|~0]>< w|?U!6
w]>BƝ=A1>,	d>)f}@d?>Bt+I&6w0Jx(\	>:'Bg->=huоL63">A~"@n>.HP=y#>%Ej>6olC>AῺ6qzO`fnj>8A,><\KiFF1H>@ƛl?#0:>,u[>$z/!(=ӭekt>@x^q4sO3>8b@Bӫ>:
wk5_r6(2K7)>@$:y=@43>(I1>'J?=0F@>?lz2FVb;!:>9#w@ eR>6"0	c3h&j_>?g:<-> J5`>,$=V/(q>=9א]+%ID!:Hc>:A>Cv82>2PX>uH3fQ6c=*>>Sζ6rTc*>"F1>1$ž=ZHco_>9\"' Qhϓ*\۞&>;zݑo;M-Uw>)$> Y8ް֪_>5?羾4.Y%+0
&-82jwQ>;ӎK6ơ!>ق@f>,#zL3:ˠ>8M#eکs?q$z{>819ӥ_I>*q2>O56\ㆲ>:ZLw0>u/6Ž9s>3/ΣC:N3>2^2½'h0^&A>9|+ܾ4^>ei)g>+yA~ľ8,˜>67ΘϪFƾ%{5^>7mT`7<,K2>$_>p465͈.>7؍)Ϙ>zL­(Y>34Kž8Ff>-Ȥ>?Ǘž1pn>7:rҾ0A2!=$XD>/ᷘ(7~|M>2 г{'R++ت>67]A3:*>J	E>'Y6XS>4 *;fδ#s͎x>5v.4UPsF>!MF>.3춋Ay>4þ$t;BnaO>2'5Lq>'e#y|n>z_1h>58)AvA@?<#
>0[0E4_H6>+J$=c4^'i.RQh>4o!C-=
X>+9m.4Slq>.[.ljt)x>3×=/T>Lގ4>'";3uD>0'}_ZA>[%i$>2<0FLRb>q;o>#4?>2xva>0n,;Kݨ}"6c>1/p0͑>H/:> 7j1z=0m>0#:wQvld>1cX0yph>U1>ZI
0Gn>0_s]3Ez@w>0#uc0:.Z>Nl~6>
پ/o8y>0
K`:UAd‹]#>.V[I:/IaF>dǎ>˺ bo.(
/:J-N.G">Zq>]c@-d(>.(!dǮ4k~3ye;
>,$؄w-OȂ,>,@?8>1',Mӛ,>,W@۾8g8>+]R<,9a>n>ZqN>?Qؾ+wsZ>+F޾lH"m>+zg8[**p>>$>E+Csb>)K+R*8(I_>
7>Eu*٬^H>'{aZTΜ2>*BH*(&3gQ>HV>~a^˾*bEE>%L
A,w>*8Fw
$&T-=V{g> اk)F1>#Te+C#y!Z2	>)Vv!\սsf>"S(<`> n&c}:=;u߶"f>(7v#ݾtsP,J>#~sB׾'~>Ks~>v-O"$:>&派.cz6XF>$"뇉ݾ%OzY>7^>Սʺj$1bj>$2JXB@>%')6#6S>qk>U$~"%5[,>!ֳ5 I&Z >%WFS $Z0=nf>t%$IZ>¿F=1Yՙھ&˒+>$<뮐E݇^3H> dg=#{oޔ>=>>&LO!/&b>"}ž7/zϾ6p>!}
!C(ۣnz>3>9~"@>7mq?d<ub>"aɾCc=r?Q>Le!ٓ3>a=ߠ:iЂd_>!NDd`"kK|!>Jp= uV;C"K>6>Ȱ
:04h$>+NV-]
^>c} 'W&tW=x>譠F">Kvj8'km >LqhA|S`g>L1>"-9o=|e4>:
?&8R>al#{l=/&>V]%ub>{߭-
0>YUOvMx!>{Lt5>_=֮Cs{KcN>{->j029>K{KbBin	=ƌ{>
b1*rX+>&f=!y)0ďuLb>eP=68>|"%Qu>Ηb>3v
f6!>-„nT:?j@u>
'CV0=ϟ-|>PPؾbW>
H|j=YؾTh
_M>BM5Ca6J>	QBY= yJ%>l(G;n>
`HC8)\YQ
#>>E*Fؽyvh3V>U>N!Jf==D
u>
?./<)7z
f>^FfB;/F4@>'>n0=S`˥Ni>ӝ b!]8>
F"W6=ٔr'>lf>z=Dѵ.>
m3՟q9%Xk꧁>B.`Q=-/K=*ɳ		8
L>X`=2Tؘ)N>Q7
9sOe>V.|w
=_m=NQsgޠ>K1t%nEE/pؽt>bVJltATxΙOP]=vJZw=$چ=$,=:m@QK,=aȽֲ6'=d=.Hֵi6;ҩڟH=;ê=s=mI	jg\=+l*ƽƆ{=*X5=p`뙺Dc]ea=Q0н#C/=^=ג.׽i=TZML@.ք(P=%֜GL+=Jx{'d=L=.d)!ҋA=圈+0¶drv(=,sDR_N=tWft9=F\=@~5٨ƛ+=QᾋH+ϽXx=kω=º#V2=@w˨b|=Vu"9uljh}d=ѷXJ鼽=ŭ5=ES=+
m=si37|)=sIPis.t>
=ٷE=`7=>i=bշHɽ3ڶVF=0N+
y'v(=Ѽl=M.jM=UnZ΋>=?	DPy\3B=ݚ.yAYN
%1L=z8Z׽m{fk=~=Kw]q=Hp#=qVŸN=zB}ʎlt.=JAvMF|9f?=1NϽTf=iG=&p|'R=*jV=ݮlxտsE>t_'\s]:j>R#`<-׽|Z><\h	^=xaO=4lSvX=_m=Kݾ*/m>1q۽T/ǽyM}>?zc#|{=IzQF]>R䞾vJ`F=,i=0h`>BZ5ðĴHs
>.렀Ydq"@3)f>eNDRY=Ѫ"ry>.r	ϖ)-=-qq9)=L!@	֘>>4z޾&XCj>.'-fLu>
H8[=k(W!>"Wo?0=OR"
=W鮚)^>	NOdޫ99!r׷./>	3mFb+:>'	
jiBE=P[>qfj8> }=K2d͕>Q*t\qdXk Yz2ӽWE>fLq$=_>	n!>)	$Q=//$:rY	>TA׽ā0O$~kL>v`J@
7>NeMRYK1c>
5־,K"=Ȟ>`}#Co>^e=ՔFHBFFxi>2P}*Q6EwJnK>N&A+νT@>a&>S=&,">24
biM*>	䐔=obira>9
X63T>Uc,"xX5bܳ.>IQE{ԇ6V)=ा͸>shq
ԍ	>o>3>Nnsr#>=
ZΙ>1B
KwA cX>^Lƾژ<-7Q->FWp~B=ZT>
{wn>NH=+ѝ
>IT9<` {y>AvcNp@k/wo>LX-2{
WO=q+>¬1þ@84
%>י:p>u7Sw>Aq=vI@ta>gȘ2F?i	>i.FT
~ Kƅ0>pYX/b)'=⊙3>NKJ?*>
ۤ>\&^TA>;ص=KU]>^;~RZ#qZL>2+ݾA7[@GQ>t*:A[m=4>]?c[:>Ī<>1{Y t%1>Ane=mxy\MS>0k
l9y1Z>h*U/,>_oERU=6z>|UU{iO>
>
m
-eD>.r=h_w52v>]
i}G]sG>!ȇig!82@>IdL
%r"`a>&<Ĝ>V9Ŋ>Ag7$>c=\>9פ4"]>~@x'=	rf2@g~Xf>eBwJB{(-@J>3Ⱦ}43{xy=	ܮ>f=7|m>蒱
e>	#P[KP&>nhh|X=0Eൾ,y>
᠅|^]>cÀq[O<
>==(S$:<z7gP>GpSJ]Jˈ>[x/z>*?  >-A>
^Ɇ">w:.>\A*1l
>K)o$aYhî㬵> w:qlxS>:	.nS)=/_A>Zy	 q<>ērM>Ϣo O "z>8q:>ʊоF>";R5Q> [dT\Wv-Y>!"iBsq+̆Ƥ> HbL
NntAM=Cx>ʧ @Q5>/>aSPT!ws:>~dK'>C \A>,1(_=ܢڻϾWSq> aoݾ"֭׬>!1:U	6	n>!N5Bj6Dׂ>ڷ7 C5>˘>Qmm"O9v>>f( !r5>k2=h=ξ : Vc9jp>"敾M(7>"iS3z'h–4>!34ex[w=нH8>//"c>	VX'> "yUAA>~H>w/c"%C>
l=6wp c>!hٛR	qHAĔ>"1hPi.jxz}̑"w>"~w~~Z>!~ok™ Q8	=S{>uv@"π>.{„>qI־#~Tf1fE>$lɽ>%O~"B[>Λ=ဩe x]>"!+{FnN@T>#xRh{uw
>#trbB%B%K>"x,m Љp=>V4#.>>ھ$!{=>T>{L#ҷ0>s6)=A>q"7GvO>!	n8(Qy2WNl>#nO?;u.d嫾NmQ>$}a!csp5j/
>#8B'>ci>""on;"$1o=">h2Ծ$Og	x>H&>fW"$Me>	|>5Jx$,k_> %=
d"JBR>"t2/<
4(	xAT>$
@:Ͷɰ>%5wMxoW>$j I$p9)K 8k>>"1#Yb=6?^x`>D$]$R>+>QH6%B^>o"h>^XX%
R,> \=#oQp[>"VeOOҾ ̫q7V>$ϤjQrZD3c>%A{nN\g8́7>%S0jA;3>$[)"w I$=ljt>"E$H>s.ƉA>sA&JhP>ek>
]&7Gr>+[i>
6
d~%`Q[>!t
~	W6=*J[ھ#X/T>$](NJľ ْH>%p)kİJU>&"oxze>&UHVCd*g
`>%6o"u=nAih_>"lD%.?P>@ښ>Ξʾ&4>s>+B&O>q0~>GIm4&sEp\> ܬ=.E%>#ߟN}"BZG>%բ`R\9,T[&>'	W\
O;-i>'UdNȾڔRE&Bx!\$2_&	s>%C{፾$"{I=tˡD>#_d&'"\Z	>1k> \뿾'[>4VM>޿'D>4p>p'7ҡ(,>!.>-P&%DPzƜ>$}tLtrK#ְ>& fJY\T!WI.>'~
jB4]4L>(XW:V2־wо~>'gUSs I|v|R5y#>&AH #D2>@f}>%"͇%rS=1>"K:'Ld{>ypu>`(?.n>qGW>S+(u4'">'*@>8X'YCLb>!5>VX&X~>$n=ČgR$Ѣ,>&$`wO2~"WxB>'X(M!KOBL>(kiZ-p&>(Trܡk`tz棓>(:rž"@cB>\*>&D
$ɽ`ٌ;9>%*@}ɋQ&S*=Io>";3(BΚ) j>%2>	-)CcУN>>peϾ)?*>x	>`y
(ѝ1>!!)>ʚePd'LA>$moT[=wkm&1@#>&mmK^}$G#>("cdG	!^y8$>)*,?}ɾ;!>)-m]a>)	" O'n۾>(8j!ɾ#$ȁ>'GkV%l&h&ؾ'Q=ΕqH># }0O(lhc>
tkq>!|4U)	]>iqN>T*"
>u`T>%ɾ)(\[> oE>^n)c>#
Q3>^KK)Y(W`֝H>%bOo=eS*>6&=z>'G.Id|9$>(
"A "(G>)̢8~{< .MD,h>*_(FFLPɨI>*,,ul&	Α>*:KF!IվȒl>)".=$)ҽ~:He>(iɖ&&8rF
U7Z>&{W`'lu	=>ܞ&>%a)CܬV>fQ
Y
>#|*8֠U>;Qt2>  a*/>#2
>Yb{_*z>'J	">|_ّ*öWز>!Xj].>5"=y*A9>#X6p>Jrd2A)]?$>%ƷV=$3lB(&>'t=nQ0&U7>(srԱl$O[L>*|iu&Р޾"֝]g>*En=Kpe G4>+NP­g=/Z>+w
MNhZ>+QU)!Ox
>*ś#{		_L>*#Oj%l wӽj>)";S`*' iѽ8W͢>'n|%(Vg=.ZXf>&gsd)0D1	>J>$hd)*^H(>
 >"B+eS
>Zk> љÔ(+>hC>Ox~y+.{J>+>Ü&{K+嫏E> ш鶈>4/p+YE>#:Aj>g
%n+^̊>$Ո K>bd*DJw-`c>&zf2=Nc)M{>'>0=Iԑ((8^z>)/P_+n&)#V>*=0>%^(>+OT̢#Ôerg>+<0Ӿpǧ]"	ҡ>,4whRܪ=ƌ{>
b1*rX+>&f=!y)0ďuLb>eP=68>|"%Qu>Ηb>3v
f6!>-„nT:?j@u>
'CV0=ϟ-|>PPؾbW>
H|j=YؾTh
_M>BM5Ca6J>	QBY= yJ%>l(G;n>
`HC8)\YQ
#>>E*Fؽyvh3V>U>N!Jf==D
u>
?./<)7z
f>^FfB;/F4@>'>n0=S`˥Ni>ӝ b!]8>
F"W6=ٔr'>lf>z=Dѵ.>
m3՟q9%Xk꧁>B.`Q=-/K=*ɳ		8
L>X`=2Tؘ)N>Q7
9sOe>V.|w
=_m=NQsgޠ>K1t%nEE/pؽt>bVJltATxΙOP]=vJZw=$چ=$,=:m@QK,=aȽֲ6'=d=.Hֵi6;ҩڟH=;ê=s=mI	jg\=+l*ƽƆ{=*X5=p`뙺Dc]ea=Q0н#C/=^=ג.׽i=TZML@.ք(P=%֜GL+=Jx{'d=L=.d)!ҋA=圈+0¶drv(=,sDR_N=tWft9=F\=@~5٨ƛ+=QᾋH+ϽXx=kω=º#V2=@w˨b|=Vu"9uljh}d=ѷXJ鼽=ŭ5=ES=+
m=si37|)=sIPis.t>
=ٷE=`7=>i=bշHɽ3ڶVF=0N+
y'v(=Ѽl=M.jM=UnZ΋>=?	DPy\3B=ݚ.yAYN
%1L=z8Z׽m{fk=~=Kw]q=Hp#=qVŸN=zB}ʎlt.=JAvMF|9f?=1NϽTf=iG=&p|'R=*jV=ݮlxտsE>t_'\s]:j>R#`<-׽|Z><\h	^=xaO=4lSvX=_m=Kݾ*/m>1q۽T/ǽyM}>?zc#|{=IzQF]>R䞾vJ`F=,i=0h`>BZ5ðĴHs
>.렀Ydq"@3)f>eNDRY=Ѫ"ry>.r	ϖ)-=-qq9)=L!@	֘>>4z޾&XCj>.'-fLu>
H8[=k(W!>"Wo?0=OR"
=W鮚)^>	NOdޫ99!r׷./>	3mFb+:>'	
jiBE=P[>qfj8> }=K2d͕>Q*t\qdXk Yz2ӽWE>fLq$=_>	n!>)	$Q=//$:rY	>TA׽ā0O$~kL>v`J@
7>NeMRYK1c>
5־,K"=Ȟ>`}#Co>^e=ՔFHBFFxi>2P}*Q6EwJnK>N&A+νT@>a&>S=&,">24
biM*>	䐔=obira>9
X63T>Uc,"xX5bܳ.>IQE{ԇ6V)=ा͸>shq
ԍ	>o>3>Nnsr#>=
ZΙ>1B
KwA cX>^Lƾژ<-7Q->FWp~B=ZT>
{wn>NH=+ѝ
>IT9<` {y>AvcNp@k/wo>LX-2{
WO=q+>¬1þ@84
%>י:p>u7Sw>Aq=vI@ta>gȘ2F?i	>i.FT
~ Kƅ0>pYX/b)'=⊙3>NKJ?*>
ۤ>\&^TA>;ص=KU]>^;~RZ#qZL>2+ݾA7[@GQ>t*:A[m=4>]?c[:>Ī<>1{Y t%1>Ane=mxy\MS>0k
l9y1Z>h*U/,>_oERU=6z>|UU{iO>
>
m
-eD>.r=h_w52v>]
i}G]sG>!ȇig!82@>IdL
%r"`a>&<Ĝ>V9Ŋ>Ag7$>c=\>9פ4"]>~@x'=	rf2@g~Xf>eBwJB{(-@J>3Ⱦ}43{xy=	ܮ>f=7|m>蒱
e>	#P[KP&>nhh|X=0Eൾ,y>
᠅|^]>cÀq[O<
>==(S$:<z7gP>GpSJ]Jˈ>[x/z>*?  >-A>
^Ɇ">w:.>\A*1l
>K)o$aYhî㬵> w:qlxS>:	.nS)=/_A>Zy	 q<>ērM>Ϣo O "z>8q:>ʊоF>";R5Q> [dT\Wv-Y>!"iBsq+̆Ƥ> HbL
NntAM=Cx>ʧ @Q5>/>aSPT!ws:>~dK'>C \A>,1(_=ܢڻϾWSq> aoݾ"֭׬>!1:U	6	n>!N5Bj6Dׂ>ڷ7 C5>˘>Qmm"O9v>>f( !r5>k2=h=ξ : Vc9jp>"敾M(7>"iS3z'h–4>!34ex[w=нH8>//"c>	VX'> "yUAA>~H>w/c"%C>
l=6wp c>!hٛR	qHAĔ>"1hPi.jxz}̑"w>"~w~~Z>!~ok™ Q8	=S{>uv@"π>.{„>qI־#~Tf1fE>$lɽ>%O~"B[>Λ=ဩe x]>"!+{FnN@T>#xRh{uw
>#trbB%B%K>"x,m Љp=>V4#.>>ھ$!{=>T>{L#ҷ0>s6)=A>q"7GvO>!	n8(Qy2WNl>#nO?;u.d嫾NmQ>$}a!csp5j/
>#8B'>ci>""on;"$1o=">h2Ծ$Og	x>H&>fW"$Me>	|>5Jx$,k_> %=
d"JBR>"t2/<
4(	xAT>$
@:Ͷɰ>%5wMxoW>$j I$p9)K 8k>>"1#Yb=6?^x`>D$]$R>+>QH6%B^>o"h>^XX%
R,> \=#oQp[>"VeOOҾ ̫q7V>$ϤjQrZD3c>%A{nN\g8́7>%S0jA;3>$[)"w I$=ljt>"E$H>s.ƉA>sA&JhP>ek>
]&7Gr>+[i>
6
d~%`Q[>!t
~	W6=*J[ھ#X/T>$](NJľ ْH>%p)kİJU>&"oxze>&UHVCd*g
`>%6o"u=nAih_>"lD%.?P>@ښ>Ξʾ&4>s>+B&O>q0~>GIm4&sEp\> ܬ=.E%>#ߟN}"BZG>%բ`R\9,T[&>'	W\
O;-i>'UdNȾڔRE&Bx!\$2_&	s>%C{፾$"{I=tˡD>#_d&'"\Z	>1k> \뿾'[>4VM>޿'D>4p>p'7ҡ(,>!.>-P&%DPzƜ>$}tLtrK#ְ>& fJY\T!WI.>'~
jB4]4L>(XW:V2־wо~>'gUSs I|v|R5y#>&AH #D2>@f}>%"͇%rS=1>"K:'Ld{>ypu>`(?.n>qGW>S+(u4'">'*@>8X'YCLb>!5>VX&X~>$n=ČgR$Ѣ,>&$`wO2~"WxB>'X(M!KOBL>(kiZ-p&>(Trܡk`tz棓>(:rž"@cB>\*>&D
$ɽ`ٌ;9>%*@}ɋQ&S*=Io>";3(BΚ) j>%2>	-)CcУN>>peϾ)?*>x	>`y
(ѝ1>!!)>ʚePd'LA>$moT[=wkm&1@#>&mmK^}$G#>("cdG	!^y8$>)*,?}ɾ;!>)-m]a>)	" O'n۾>(8j!ɾ#$ȁ>'GkV%l&h&ؾ'Q=ΕqH># }0O(lhc>
tkq>!|4U)	]>iqN>T*"
>u`T>%ɾ)(\[> oE>^n)c>#
Q3>^KK)Y(W`֝H>%bOo=eS*>6&=z>'G.Id|9$>(
"A "(G>)̢8~{< .MD,h>*_(FFLPɨI>*,,ul&	Α>*:KF!IվȒl>)".=$)ҽ~:He>(iɖ&&8rF
U7Z>&{W`'lu	=>ܞ&>%a)CܬV>fQ
Y
>#|*8֠U>;Qt2>  a*/>#2
>Yb{_*z>'J	">|_ّ*öWز>!Xj].>5"=y*A9>#X6p>Jrd2A)]?$>%ƷV=$3lB(&>'t=nQ0&U7>(srԱl$O[L>*|iu&Р޾"֝]g>*En=Kpe G4>+NP­g=/Z>+w
MNhZ>+QU)!Ox
>*ś#{		_L>*#Oj%l wӽj>)";S`*' iѽ8W͢>'n|%(Vg=.ZXf>&gsd)0D1	>J>$hd)*^H(>
 >"B+eS
>Zk> љÔ(+>hC>Ox~y+.{J>+>Ü&{K+嫏E> ш鶈>4/p+YE>#:Aj>g
%n+^̊>$Ո K>bd*DJw-`c>&zf2=Nc)M{>'>0=Iԑ((8^z>)/P_+n&)#V>*=0>%^(>+OT̢#Ôerg>+<0Ӿpǧ]"	ҡ>,4whRܪ=ƌ{>
b1*rX+>&f=!y)0ďuLb>eP=68>|"%Qu>Ηb>3v
f6!>-„nT:?j@u>
'CV0=ϟ-|>PPؾbW>
H|j=YؾTh
_M>BM5Ca6J>	QBY= yJ%>l(G;n>
`HC8)\YQ
#>>E*Fؽyvh3V>U>N!Jf==D
u>
?./<)7z
f>^FfB;/F4@>'>n0=S`˥Ni>ӝ b!]8>
F"W6=ٔr'>lf>z=Dѵ.>
m3՟q9%Xk꧁>B.`Q=-/K=*ɳ		8
L>X`=2Tؘ)N>Q7
9sOe>V.|w
=_m=NQsgޠ>K1t%nEE/pؽt>bVJltATxΙOP]=vJZw=$چ=$,=:m@QK,=aȽֲ6'=d=.Hֵi6;ҩڟH=;ê=s=mI	jg\=+l*ƽƆ{=*X5=p`뙺Dc]ea=Q0н#C/=^=ג.׽i=TZML@.ք(P=%֜GL+=Jx{'d=L=.d)!ҋA=圈+0¶drv(=,sDR_N=tWft9=F\=@~5٨ƛ+=QᾋH+ϽXx=kω=º#V2=@w˨b|=Vu"9uljh}d=ѷXJ鼽=ŭ5=ES=+
m=si37|)=sIPis.t>
=ٷE=`7=>i=bշHɽ3ڶVF=0N+
y'v(=Ѽl=M.jM=UnZ΋>=?	DPy\3B=ݚ.yAYN
%1L=z8Z׽m{fk=~=Kw]q=Hp#=qVŸN=zB}ʎlt.=JAvMF|9f?=1NϽTf=iG=&p|'R=*jV=ݮlxտsE>t_'\s]:j>R#`<-׽|Z><\h	^=xaO=4lSvX=_m=Kݾ*/m>1q۽T/ǽyM}>?zc#|{=IzQF]>R䞾vJ`F=,i=0h`>BZ5ðĴHs
>.렀Ydq"@3)f>eNDRY=Ѫ"ry>.r	ϖ)-=-qq9)=L!@	֘>>4z޾&XCj>.'-fLu>
H8[=k(W!>"Wo?0=OR"
=W鮚)^>	NOdޫ99!r׷./>	3mFb+:>'	
jiBE=P[>qfj8> }=K2d͕>Q*t\qdXk Yz2ӽWE>fLq$=_>	n!>)	$Q=//$:rY	>TA׽ā0O$~kL>v`J@
7>NeMRYK1c>
5־,K"=Ȟ>`}#Co>^e=ՔFHBFFxi>2P}*Q6EwJnK>N&A+νT@>a&>S=&,">24
biM*>	䐔=obira>9
X63T>Uc,"xX5bܳ.>IQE{ԇ6V)=ा͸>shq
ԍ	>o>3>Nnsr#>=
ZΙ>1B
KwA cX>^Lƾژ<-7Q->FWp~B=ZT>
{wn>NH=+ѝ
>IT9<` {y>AvcNp@k/wo>LX-2{
WO=q+>¬1þ@84
%>י:p>u7Sw>Aq=vI@ta>gȘ2F?i	>i.FT
~ Kƅ0>pYX/b)'=⊙3>NKJ?*>
ۤ>\&^TA>;ص=KU]>^;~RZ#qZL>2+ݾA7[@GQ>t*:A[m=4>]?c[:>Ī<>1{Y t%1>Ane=mxy\MS>0k
l9y1Z>h*U/,>_oERU=6z>|UU{iO>
>
m
-eD>.r=h_w52v>]
i}G]sG>!ȇig!82@>IdL
%r"`a>&<Ĝ>V9Ŋ>Ag7$>c=\>9פ4"]>~@x'=	rf2@g~Xf>eBwJB{(-@J>3Ⱦ}43{xy=	ܮ>f=7|m>蒱
e>	#P[KP&>nhh|X=0Eൾ,y>
᠅|^]>cÀq[O<
>==(S$:<z7gP>GpSJ]Jˈ>[x/z>*?  >-A>
^Ɇ">w:.>\A*1l
>K)o$aYhî㬵> w:qlxS>:	.nS)=/_A>Zy	 q<>ērM>Ϣo O "z>8q:>ʊоF>";R5Q> [dT\Wv-Y>!"iBsq+̆Ƥ> HbL
NntAM=Cx>ʧ @Q5>/>aSPT!ws:>~dK'>C \A>,1(_=ܢڻϾWSq> aoݾ"֭׬>!1:U	6	n>!N5Bj6Dׂ>ڷ7 C5>˘>Qmm"O9v>>f( !r5>k2=h=ξ : Vc9jp>"敾M(7>"iS3z'h–4>!34ex[w=нH8>//"c>	VX'> "yUAA>~H>w/c"%C>
l=6wp c>!hٛR	qHAĔ>"1hPi.jxz}̑"w>"~w~~Z>!~ok™ Q8	=S{>uv@"π>.{„>qI־#~Tf1fE>$lɽ>%O~"B[>Λ=ဩe x]>"!+{FnN@T>#xRh{uw
>#trbB%B%K>"x,m Љp=>V4#.>>ھ$!{=>T>{L#ҷ0>s6)=A>q"7GvO>!	n8(Qy2WNl>#nO?;u.d嫾NmQ>$}a!csp5j/
>#8B'>ci>""on;"$1o=">h2Ծ$Og	x>H&>fW"$Me>	|>5Jx$,k_> %=
d"JBR>"t2/<
4(	xAT>$
@:Ͷɰ>%5wMxoW>$j I$p9)K 8k>>"1#Yb=6?^x`>D$]$R>+>QH6%B^>o"h>^XX%
R,> \=#oQp[>"VeOOҾ ̫q7V>$ϤjQrZD3c>%A{nN\g8́7>%S0jA;3>$[)"w I$=ljt>"E$H>s.ƉA>sA&JhP>ek>
]&7Gr>+[i>
6
d~%`Q[>!t
~	W6=*J[ھ#X/T>$](NJľ ْH>%p)kİJU>&"oxze>&UHVCd*g
`>%6o"u=nAih_>"lD%.?P>@ښ>Ξʾ&4>s>+B&O>q0~>GIm4&sEp\> ܬ=.E%>#ߟN}"BZG>%բ`R\9,T[&>'	W\
O;-i>'UdNȾڔRE&Bx!\$2_&	s>%C{፾$"{I=tˡD>#_d&'"\Z	>1k> \뿾'[>4VM>޿'D>4p>p'7ҡ(,>!.>-P&%DPzƜ>$}tLtrK#ְ>& fJY\T!WI.>'~
jB4]4L>(XW:V2־wо~>'gUSs I|v|R5y#>&AH #D2>@f}>%"͇%rS=1>"K:'Ld{>ypu>`(?.n>qGW>S+(u4'">'*@>8X'YCLb>!5>VX&X~>$n=ČgR$Ѣ,>&$`wO2~"WxB>'X(M!KOBL>(kiZ-p&>(Trܡk`tz棓>(:rž"@cB>\*>&D
$ɽ`ٌ;9>%*@}ɋQ&S*=Io>";3(BΚ) j>%2>	-)CcУN>>peϾ)?*>x	>`y
(ѝ1>!!)>ʚePd'LA>$moT[=wkm&1@#>&mmK^}$G#>("cdG	!^y8$>)*,?}ɾ;!>)-m]a>)	" O'n۾>(8j!ɾ#$ȁ>'GkV%l&h&ؾ'Q=ΕqH># }0O(lhc>
tkq>!|4U)	]>iqN>T*"
>u`T>%ɾ)(\[> oE>^n)c>#
Q3>^KK)Y(W`֝H>%bOo=eS*>6&=z>'G.Id|9$>(
"A "(G>)̢8~{< .MD,h>*_(FFLPɨI>*,,ul&	Α>*:KF!IվȒl>)".=$)ҽ~:He>(iɖ&&8rF
U7Z>&{W`'lu	=>ܞ&>%a)CܬV>fQ
Y
>#|*8֠U>;Qt2>  a*/>#2
>Yb{_*z>'J	">|_ّ*öWز>!Xj].>5"=y*A9>#X6p>Jrd2A)]?$>%ƷV=$3lB(&>'t=nQ0&U7>(srԱl$O[L>*|iu&Р޾"֝]g>*En=Kpe G4>+NP­g=/Z>+w
MNhZ>+QU)!Ox
>*ś#{		_L>*#Oj%l wӽj>)";S`*' iѽ8W͢>'n|%(Vg=.ZXf>&gsd)0D1	>J>$hd)*^H(>
 >"B+eS
>Zk> љÔ(+>hC>Ox~y+.{J>+>Ü&{K+嫏E> ш鶈>4/p+YE>#:Aj>g
%n+^̊>$Ո K>bd*DJw-`c>&zf2=Nc)M{>'>0=Iԑ((8^z>)/P_+n&)#V>*=0>%^(>+OT̢#Ôerg>+<0Ӿpǧ]"	ҡ>,4whRܪ 6	
>,x|3%3d;Q,>,$S	f>,r*Q!ic@5>,-}#%)B"~j9Y>+xT*R$EtAa.>+&cw&5{V	&<>*jڥp'hj)]>)DY(=u$%q5>(Yq)
=)>'vh^Z*.>>&C&l:C+i/F>y>$ù,̨>Fm)@>#Ĕ,b
6>EL>"+N绾,ϼ	>cUN> ۾-t(>ֵ>E$7þ-1Nn>;e8E>V?-.5S> ͥ
>'W-5o>"?$U>/x,N>#{>aES,U>$"y >1gdm,W>%!>U&䋾+$9>'#=F;zUپ+M
>(=b*̈N*[:y>)FK9=үO#)Ɏ#">)ڊMSUX(߅6>*y:6HY( ޺>+F]ihm~
',^B>+feXϏ&D+>,^Wp]`T.%Rb>,)"d$Yܕ"x>-+&%['*#[Hߋ\>-vjG["X):>-0}L!Q>-O *CHM Ien>-5
сS
+~v=^>.	vbNPپjpף>.,Y BX0>.Hվ!㿖pI{eu>-Nf"o}'rھ?O>->O׾#Q!C<.n>-@^$'x0хɾ@WU>-|UDӾ$cY/ξMmF">-FB{D%>A'1>-
?>*&bCؾ	H2T>,0'
j
hv+Y>,Z)˾'"n~mt>,8ʋpо(;{CفՊ>+Dk(/>O->+*B)EhV0A}H6k>+Jש)B>*\y*+mڅy?
+*>*P"{[*C=f7ó>*RRu4*8L=ީt@>).<+JC=߭JO>)t^w+0j|0=+>)^8h`+3=85>>)PR,,k̰O="жE>(Zŷ/,l=`zG>(|Nts,ڽ>=>(6+?, hY>Ps>'So-
5l>J	>'Je޾-:
=0F>w9>'{A
"Ծ-blJ)>eKU>'DF-AĸmM>	07>'4B5vu- 9>սC>&-۴>G>&8z-!s>
Dz>&QZϾ-y>
Z>&|_.ΒI>h{>&cLb".'59>]\ͥ>&Px.9'r>>&BܒGG.Heěk> rw>&:Ѿ.Uiv>B|Ȩ>&7CS.`WK@K*>TɥF>&:jn.i#Ak>W:^>&CG.oh!I>JQ䱣>&Qa.t^4xN>-[>&e.vbm>~>&q2~h.vt*>Ғ9՘>&.tȼ>Dd>&&1C/.p
ÿ>>>&$q].h_x>
g>'d5.^Q[>qI1>'P*۞.R	&R(>Z>'B]T.B`ݣ>
#>'ȋF..(Y(>>(y'.MUq\>S=l>(Rփ-2zb>ՔL	>(y{\-Z>e>>(P-^L;>%%g>>)AMF=->(`ٱ`>)#o-f7P=b~rS>)-3'=>*N#,O΢b=nDt>*ڄ_R,
=a>+
.[,w"r=	p%">+o,+=:R>+晦+؊ԲƎN>,6;+}^qd">,fa/$+Y=>,c|*?ڟ>-_p+*8\atnk>-<ľ))QŪ*D.:>.)1=d%L6i>.x߫	()(	ХVW>.<*~(	ӓ4 >/"(qN;'X(!urr`\>/pc&ZHv&v3>/MOtǾ%DԾM(>/S*c%0DvǾ8`M>0C!H $>OmEyN>00^9#X?#0䋕gy>0C6W"fTm->0Q8O!fiMUDG1>0Zs Yh0]",þ~>:OQ!I>0Y&PBM.!"2z>0N-\a($e.>0;?Ӏ@[즾%$	,R>0!wLj:Xd&7Ǎc?>/y'F>/ܐͻ~5Br.(P,9Y>/=i!e )R1v?>.mVgsd*KE>.1>
o֫~FC¾+;kQA>-y8Խ" w,>,~=QOԛ,J)#@>,Q̸=k\-Rz>+TP*=-.y֭V0>* 1m>XϾ/!β6>)
>ou/Ǐ>'.>+u0I2>&珻>hվ0Pv)W>%Fyn>0z>#><_0X>"P{>f˾0> X->!+#0m>>"˞ھ0I]#>vG	,>$qPL0}T	>½Gj>&]V{L0P_g>Ƀ>'F{0أ>
\>(Ҿ/Z%>q
Ԧ>*WF.R@=I|۟>+4=־-Y[-U=⩳޳Q>,E,DTKX`>-Y]u+~A[.x.t>.pƾ*q26c־ע_'L>/vgb)Ɂ+ǂ=>04l>Ѿ'n4Gی/>0}c'2%*1AȾIcc>0**#)oh[]>0,.!
q
 xr>0'GDm"R>0љE2PI;A$;0O>0/?=&^>0t&=4\(UMX>0"3aU
:U*X">/o<
cd롡2̾+欼o>.g2޽w!O-mPw|'>-/@E2=uO0.]2>+.=VZ/zæ>**Ӗ/>
v!W04Z\~	>(a9G>Za1Ծ0>SZ>&isg>H;0%Wa>$G>_Å0+A/>!?s> 瞿#1)_h>Y0>#G\H05>1ɏ>%90OVgB>&&>'–lJ0kv$sa>
é>)JR־/of>20->+a.̝Fr=x	w>-MĜ,-h@bI拶ТG>.e;=+œas]#>/`#v)<8P
ʭi>0|kؒ'~Kž>0cΎ%{TI!-F(
>1my%"Dz 7mf+Zw>1)=$m A\d"rC>1?!C9!ま%L6 g>0gڕ'iG>0!!+9`*<|>0qw
ؠƛ4{,B&>.q~}&.
S>-	yG=@x/r<>+ވ>?q1#%0d2#>(O8;>Sy?0ٽB>&nO>(䪲l1%춏>#Jv>{e}71F(> AA(>"G[|ʾ19f>H:bbɟ>%6e0z>I>(Kht0SA>%k>*LWҾ0=s>,ἝIN.x҉#wv>.x!Q,*VdS>0#l*_݇E=0c>0mz$ʾ'y=k=֙>1#޷;%(I1F1_o>1Z5~-!_48!6 >1\0-M(%A>1*^_@B!'&ӂ>0L><
pw*>0%oX\F$,{]p>.*MD=4Ⱦ. >,u\}>[0N	>*4&(FW>LA0K|d>'nvdp>q	v1McY^>$T}H>MÒ1xnߏ> "U;>#(5҄1gN|/>>>>&nt]1s>L*">)l'|	0\8Z>d+>,K/V=D->.ahe-ny}Z>0!̧ɾ+*b!,阺>0	z(S"P(7>1QǾ%;Mυq>1f~!AAž"XJA>1/sӾw>&H!G?+>16e?ɾUh\)wOn>0(i<,¾h,I,\>7>/CeeAKI.Z9U>-SxA=bQPپ0OO{>*)>rkR1s8$>'ca>+:L1x>$[m> Zž1vp> C
)h>#O1f1譛>Ϧa>'B1't>:m+>*XU0h3%=I>-Xx.?v]&>/R<,W˾&O>0XC)Tzrk΢>1eKcޥ%GYF>1WIݾ!&|"xkf>1_1ؾ;-@&OG>1R,6p,;
f* O>0j?$a-#R2r>/e>ґ=V_U/mդ>,޺.>Me7q0rƑ6>),̠s>>1lwb>&4G/5>SI1o>",3>"x`41J||>k[>&I2Z21^^QAe>%h>*ky0wUX>R	>-!#/B΁ν̽>0,nmvL>0\#2)A<GS0Bn>1q%lUBR4|uI>1QD!"^o#^>1vb
(@x[>1>TE~fC0+ɲ>0ea{1/.M-f5>.d3=_/0Y>+UA-6>[Nma1W#>'Ÿu>%7z1ʐll>#uPx>!ڬ=1&>B
J>&D7dCɾ1r>;y>*4	dW0}>.s>-iQ/LN3+I)I0a>0&9U,>7^&>1&HǎY)?23|>1N8^$ٍ@ d0>1r )
-y%6n>1Ur&>6)i.>1,a;ߛD->0
N]'Ⱦ/2
N>-:Tu>rj-j1?,w>)OJ>Ye|1B7,>%cศ> 32NH> 5>$p"ξ1`>އ3RP>)Q#1.	H>f:]@>-k0z=z>0	۰~->ȑހվ[(>1)8i)jE>1+7\>%)S W>29¾ $j5%YYvc>1п!&v*%)LI@>1LC
f˦ka-^b>/Yҙ=ӧJ0Si>,
b8>li1b7]>(x>sN1;Y>$
>!*Nxñ2K׊b>>&%m1ֽ><䋵>+17ܟ0߽=tXLS>.&_-..{Uf>0gQ
3+hh?*_%>1-F;*'
g:%H`Mp>2 o" y$>2	_Gbuֹ(>1mX
֠,ot>0O"LBaK0'1>-oX^>Sw1X+B
>)_\!>!i20B>$f>!DL2/Ÿ}]>+ \j(>&*Gx1>N>7>+c(맼0i2=_XU>/$tb.⡾)$bV2@O>0_+cؾ`i7>1K&etD]qR>22pg$1~lV*~xv>1@|k5iX*W.5p},e>/ O=ꯪ0z?>,8=>8G1V?{>')>eK"2>)w;>"T&J>$a^m02'
R>$n->)>³1{+>TzX>-ag־0=6wU8r>0*08,={SL>1{8b(erӾ%yl>2@yd#:#Ru >2;_ľ`#(Ԅ
p>1%u
Sڬ-X*7>0ab]=E>0q*v>-355T>j5za.1_>(I>ch2GB9>#4{^>#t32EP>/w^_>(㫣1tM>
KYb,>-z}Ĵ50`aʼn;{>0ö-|dE%CW>1eK(c=؋o4^>2UJTʄ"Ψ|r#r
>2FV)j1#>1,1dL-~{>08=Ďb0>,
>@V о1<2>'P@_N>jMp׾2f6->!څ<|>$!=2;ET>XffA>*av1c>ҙ@u>./n/̩۩,zd>1?+
&[P>2ŵ&g=Ⱦ ^Eut>2tpH Q?&w	>2֤"2T+rW>1VCr/Dv>.]>r
J(1{T9ve>*0>O2Q >$|m>"p>2s")	 6	
>,x|3%3d;Q,>,$S	f>,r*Q!ic@5>,-}#%)B"~j9Y>+xT*R$EtAa.>+&cw&5{V	&<>*jڥp'hj)]>)DY(=u$%q5>(Yq)
=)>'vh^Z*.>>&C&l:C+i/F>y>$ù,̨>Fm)@>#Ĕ,b
6>EL>"+N绾,ϼ	>cUN> ۾-t(>ֵ>E$7þ-1Nn>;e8E>V?-.5S> ͥ
>'W-5o>"?$U>/x,N>#{>aES,U>$"y >1gdm,W>%!>U&䋾+$9>'#=F;zUپ+M
>(=b*̈N*[:y>)FK9=үO#)Ɏ#">)ڊMSUX(߅6>*y:6HY( ޺>+F]ihm~
',^B>+feXϏ&D+>,^Wp]`T.%Rb>,)"d$Yܕ"x>-+&%['*#[Hߋ\>-vjG["X):>-0}L!Q>-O *CHM Ien>-5
сS
+~v=^>.	vbNPپjpף>.,Y BX0>.Hվ!㿖pI{eu>-Nf"o}'rھ?O>->O׾#Q!C<.n>-@^$'x0хɾ@WU>-|UDӾ$cY/ξMmF">-FB{D%>A'1>-
?>*&bCؾ	H2T>,0'
j
hv+Y>,Z)˾'"n~mt>,8ʋpо(;{CفՊ>+Dk(/>O->+*B)EhV0A}H6k>+Jש)B>*\y*+mڅy?
+*>*P"{[*C=f7ó>*RRu4*8L=ީt@>).<+JC=߭JO>)t^w+0j|0=+>)^8h`+3=85>>)PR,,k̰O="жE>(Zŷ/,l=`zG>(|Nts,ڽ>=>(6+?, hY>Ps>'So-
5l>J	>'Je޾-:
=0F>w9>'{A
"Ծ-blJ)>eKU>'DF-AĸmM>	07>'4B5vu- 9>սC>&-۴>G>&8z-!s>
Dz>&QZϾ-y>
Z>&|_.ΒI>h{>&cLb".'59>]\ͥ>&Px.9'r>>&BܒGG.Heěk> rw>&:Ѿ.Uiv>B|Ȩ>&7CS.`WK@K*>TɥF>&:jn.i#Ak>W:^>&CG.oh!I>JQ䱣>&Qa.t^4xN>-[>&e.vbm>~>&q2~h.vt*>Ғ9՘>&.tȼ>Dd>&&1C/.p
ÿ>>>&$q].h_x>
g>'d5.^Q[>qI1>'P*۞.R	&R(>Z>'B]T.B`ݣ>
#>'ȋF..(Y(>>(y'.MUq\>S=l>(Rփ-2zb>ՔL	>(y{\-Z>e>>(P-^L;>%%g>>)AMF=->(`ٱ`>)#o-f7P=b~rS>)-3'=>*N#,O΢b=nDt>*ڄ_R,
=a>+
.[,w"r=	p%">+o,+=:R>+晦+؊ԲƎN>,6;+}^qd">,fa/$+Y=>,c|*?ڟ>-_p+*8\atnk>-<ľ))QŪ*D.:>.)1=d%L6i>.x߫	()(	ХVW>.<*~(	ӓ4 >/"(qN;'X(!urr`\>/pc&ZHv&v3>/MOtǾ%DԾM(>/S*c%0DvǾ8`M>0C!H $>OmEyN>00^9#X?#0䋕gy>0C6W"fTm->0Q8O!fiMUDG1>0Zs Yh0]",þ~>:OQ!I>0Y&PBM.!"2z>0N-\a($e.>0;?Ӏ@[즾%$	,R>0!wLj:Xd&7Ǎc?>/y'F>/ܐͻ~5Br.(P,9Y>/=i!e )R1v?>.mVgsd*KE>.1>
o֫~FC¾+;kQA>-y8Խ" w,>,~=QOԛ,J)#@>,Q̸=k\-Rz>+TP*=-.y֭V0>* 1m>XϾ/!β6>)
>ou/Ǐ>'.>+u0I2>&珻>hվ0Pv)W>%Fyn>0z>#><_0X>"P{>f˾0> X->!+#0m>>"˞ھ0I]#>vG	,>$qPL0}T	>½Gj>&]V{L0P_g>Ƀ>'F{0أ>
\>(Ҿ/Z%>q
Ԧ>*WF.R@=I|۟>+4=־-Y[-U=⩳޳Q>,E,DTKX`>-Y]u+~A[.x.t>.pƾ*q26c־ע_'L>/vgb)Ɂ+ǂ=>04l>Ѿ'n4Gی/>0}c'2%*1AȾIcc>0**#)oh[]>0,.!
q
 xr>0'GDm"R>0љE2PI;A$;0O>0/?=&^>0t&=4\(UMX>0"3aU
:U*X">/o<
cd롡2̾+欼o>.g2޽w!O-mPw|'>-/@E2=uO0.]2>+.=VZ/zæ>**Ӗ/>
v!W04Z\~	>(a9G>Za1Ծ0>SZ>&isg>H;0%Wa>$G>_Å0+A/>!?s> 瞿#1)_h>Y0>#G\H05>1ɏ>%90OVgB>&&>'–lJ0kv$sa>
é>)JR־/of>20->+a.̝Fr=x	w>-MĜ,-h@bI拶ТG>.e;=+œas]#>/`#v)<8P
ʭi>0|kؒ'~Kž>0cΎ%{TI!-F(
>1my%"Dz 7mf+Zw>1)=$m A\d"rC>1?!C9!ま%L6 g>0gڕ'iG>0!!+9`*<|>0qw
ؠƛ4{,B&>.q~}&.
S>-	yG=@x/r<>+ވ>?q1#%0d2#>(O8;>Sy?0ٽB>&nO>(䪲l1%춏>#Jv>{e}71F(> AA(>"G[|ʾ19f>H:bbɟ>%6e0z>I>(Kht0SA>%k>*LWҾ0=s>,ἝIN.x҉#wv>.x!Q,*VdS>0#l*_݇E=0c>0mz$ʾ'y=k=֙>1#޷;%(I1F1_o>1Z5~-!_48!6 >1\0-M(%A>1*^_@B!'&ӂ>0L><
pw*>0%oX\F$,{]p>.*MD=4Ⱦ. >,u\}>[0N	>*4&(FW>LA0K|d>'nvdp>q	v1McY^>$T}H>MÒ1xnߏ> "U;>#(5҄1gN|/>>>>&nt]1s>L*">)l'|	0\8Z>d+>,K/V=D->.ahe-ny}Z>0!̧ɾ+*b!,阺>0	z(S"P(7>1QǾ%;Mυq>1f~!AAž"XJA>1/sӾw>&H!G?+>16e?ɾUh\)wOn>0(i<,¾h,I,\>7>/CeeAKI.Z9U>-SxA=bQPپ0OO{>*)>rkR1s8$>'ca>+:L1x>$[m> Zž1vp> C
)h>#O1f1譛>Ϧa>'B1't>:m+>*XU0h3%=I>-Xx.?v]&>/R<,W˾&O>0XC)Tzrk΢>1eKcޥ%GYF>1WIݾ!&|"xkf>1_1ؾ;-@&OG>1R,6p,;
f* O>0j?$a-#R2r>/e>ґ=V_U/mդ>,޺.>Me7q0rƑ6>),̠s>>1lwb>&4G/5>SI1o>",3>"x`41J||>k[>&I2Z21^^QAe>%h>*ky0wUX>R	>-!#/B΁ν̽>0,nmvL>0\#2)A<GS0Bn>1q%lUBR4|uI>1QD!"^o#^>1vb
(@x[>1>TE~fC0+ɲ>0ea{1/.M-f5>.d3=_/0Y>+UA-6>[Nma1W#>'Ÿu>%7z1ʐll>#uPx>!ڬ=1&>B
J>&D7dCɾ1r>;y>*4	dW0}>.s>-iQ/LN3+I)I0a>0&9U,>7^&>1&HǎY)?23|>1N8^$ٍ@ d0>1r )
-y%6n>1Ur&>6)i.>1,a;ߛD->0
N]'Ⱦ/2
N>-:Tu>rj-j1?,w>)OJ>Ye|1B7,>%cศ> 32NH> 5>$p"ξ1`>އ3RP>)Q#1.	H>f:]@>-k0z=z>0	۰~->ȑހվ[(>1)8i)jE>1+7\>%)S W>29¾ $j5%YYvc>1п!&v*%)LI@>1LC
f˦ka-^b>/Yҙ=ӧJ0Si>,
b8>li1b7]>(x>sN1;Y>$
>!*Nxñ2K׊b>>&%m1ֽ><䋵>+17ܟ0߽=tXLS>.&_-..{Uf>0gQ
3+hh?*_%>1-F;*'
g:%H`Mp>2 o" y$>2	_Gbuֹ(>1mX
֠,ot>0O"LBaK0'1>-oX^>Sw1X+B
>)_\!>!i20B>$f>!DL2/Ÿ}]>+ \j(>&*Gx1>N>7>+c(맼0i2=_XU>/$tb.⡾)$bV2@O>0_+cؾ`i7>1K&etD]qR>22pg$1~lV*~xv>1@|k5iX*W.5p},e>/ O=ꯪ0z?>,8=>8G1V?{>')>eK"2>)w;>"T&J>$a^m02'
R>$n->)>³1{+>TzX>-ag־0=6wU8r>0*08,={SL>1{8b(erӾ%yl>2@yd#:#Ru >2;_ľ`#(Ԅ
p>1%u
Sڬ-X*7>0ab]=E>0q*v>-355T>j5za.1_>(I>ch2GB9>#4{^>#t32EP>/w^_>(㫣1tM>
KYb,>-z}Ĵ50`aʼn;{>0ö-|dE%CW>1eK(c=؋o4^>2UJTʄ"Ψ|r#r
>2FV)j1#>1,1dL-~{>08=Ďb0>,
>@V о1<2>'P@_N>jMp׾2f6->!څ<|>$!=2;ET>XffA>*av1c>ҙ@u>./n/̩۩,zd>1?+
&[P>2ŵ&g=Ⱦ ^Eut>2tpH Q?&w	>2֤"2T+rW>1VCr/Dv>.]>r
J(1{T9ve>*0>O2Q >$|m>"p>2s")	 6	
>,x|3%3d;Q,>,$S	f>,r*Q!ic@5>,-}#%)B"~j9Y>+xT*R$EtAa.>+&cw&5{V	&<>*jڥp'hj)]>)DY(=u$%q5>(Yq)
=)>'vh^Z*.>>&C&l:C+i/F>y>$ù,̨>Fm)@>#Ĕ,b
6>EL>"+N绾,ϼ	>cUN> ۾-t(>ֵ>E$7þ-1Nn>;e8E>V?-.5S> ͥ
>'W-5o>"?$U>/x,N>#{>aES,U>$"y >1gdm,W>%!>U&䋾+$9>'#=F;zUپ+M
>(=b*̈N*[:y>)FK9=үO#)Ɏ#">)ڊMSUX(߅6>*y:6HY( ޺>+F]ihm~
',^B>+feXϏ&D+>,^Wp]`T.%Rb>,)"d$Yܕ"x>-+&%['*#[Hߋ\>-vjG["X):>-0}L!Q>-O *CHM Ien>-5
сS
+~v=^>.	vbNPپjpף>.,Y BX0>.Hվ!㿖pI{eu>-Nf"o}'rھ?O>->O׾#Q!C<.n>-@^$'x0хɾ@WU>-|UDӾ$cY/ξMmF">-FB{D%>A'1>-
?>*&bCؾ	H2T>,0'
j
hv+Y>,Z)˾'"n~mt>,8ʋpо(;{CفՊ>+Dk(/>O->+*B)EhV0A}H6k>+Jש)B>*\y*+mڅy?
+*>*P"{[*C=f7ó>*RRu4*8L=ީt@>).<+JC=߭JO>)t^w+0j|0=+>)^8h`+3=85>>)PR,,k̰O="жE>(Zŷ/,l=`zG>(|Nts,ڽ>=>(6+?, hY>Ps>'So-
5l>J	>'Je޾-:
=0F>w9>'{A
"Ծ-blJ)>eKU>'DF-AĸmM>	07>'4B5vu- 9>սC>&-۴>G>&8z-!s>
Dz>&QZϾ-y>
Z>&|_.ΒI>h{>&cLb".'59>]\ͥ>&Px.9'r>>&BܒGG.Heěk> rw>&:Ѿ.Uiv>B|Ȩ>&7CS.`WK@K*>TɥF>&:jn.i#Ak>W:^>&CG.oh!I>JQ䱣>&Qa.t^4xN>-[>&e.vbm>~>&q2~h.vt*>Ғ9՘>&.tȼ>Dd>&&1C/.p
ÿ>>>&$q].h_x>
g>'d5.^Q[>qI1>'P*۞.R	&R(>Z>'B]T.B`ݣ>
#>'ȋF..(Y(>>(y'.MUq\>S=l>(Rփ-2zb>ՔL	>(y{\-Z>e>>(P-^L;>%%g>>)AMF=->(`ٱ`>)#o-f7P=b~rS>)-3'=>*N#,O΢b=nDt>*ڄ_R,
=a>+
.[,w"r=	p%">+o,+=:R>+晦+؊ԲƎN>,6;+}^qd">,fa/$+Y=>,c|*?ڟ>-_p+*8\atnk>-<ľ))QŪ*D.:>.)1=d%L6i>.x߫	()(	ХVW>.<*~(	ӓ4 >/"(qN;'X(!urr`\>/pc&ZHv&v3>/MOtǾ%DԾM(>/S*c%0DvǾ8`M>0C!H $>OmEyN>00^9#X?#0䋕gy>0C6W"fTm->0Q8O!fiMUDG1>0Zs Yh0]",þ~>:OQ!I>0Y&PBM.!"2z>0N-\a($e.>0;?Ӏ@[즾%$	,R>0!wLj:Xd&7Ǎc?>/y'F>/ܐͻ~5Br.(P,9Y>/=i!e )R1v?>.mVgsd*KE>.1>
o֫~FC¾+;kQA>-y8Խ" w,>,~=QOԛ,J)#@>,Q̸=k\-Rz>+TP*=-.y֭V0>* 1m>XϾ/!β6>)
>ou/Ǐ>'.>+u0I2>&珻>hվ0Pv)W>%Fyn>0z>#><_0X>"P{>f˾0> X->!+#0m>>"˞ھ0I]#>vG	,>$qPL0}T	>½Gj>&]V{L0P_g>Ƀ>'F{0أ>
\>(Ҿ/Z%>q
Ԧ>*WF.R@=I|۟>+4=־-Y[-U=⩳޳Q>,E,DTKX`>-Y]u+~A[.x.t>.pƾ*q26c־ע_'L>/vgb)Ɂ+ǂ=>04l>Ѿ'n4Gی/>0}c'2%*1AȾIcc>0**#)oh[]>0,.!
q
 xr>0'GDm"R>0љE2PI;A$;0O>0/?=&^>0t&=4\(UMX>0"3aU
:U*X">/o<
cd롡2̾+欼o>.g2޽w!O-mPw|'>-/@E2=uO0.]2>+.=VZ/zæ>**Ӗ/>
v!W04Z\~	>(a9G>Za1Ծ0>SZ>&isg>H;0%Wa>$G>_Å0+A/>!?s> 瞿#1)_h>Y0>#G\H05>1ɏ>%90OVgB>&&>'–lJ0kv$sa>
é>)JR־/of>20->+a.̝Fr=x	w>-MĜ,-h@bI拶ТG>.e;=+œas]#>/`#v)<8P
ʭi>0|kؒ'~Kž>0cΎ%{TI!-F(
>1my%"Dz 7mf+Zw>1)=$m A\d"rC>1?!C9!ま%L6 g>0gڕ'iG>0!!+9`*<|>0qw
ؠƛ4{,B&>.q~}&.
S>-	yG=@x/r<>+ވ>?q1#%0d2#>(O8;>Sy?0ٽB>&nO>(䪲l1%춏>#Jv>{e}71F(> AA(>"G[|ʾ19f>H:bbɟ>%6e0z>I>(Kht0SA>%k>*LWҾ0=s>,ἝIN.x҉#wv>.x!Q,*VdS>0#l*_݇E=0c>0mz$ʾ'y=k=֙>1#޷;%(I1F1_o>1Z5~-!_48!6 >1\0-M(%A>1*^_@B!'&ӂ>0L><
pw*>0%oX\F$,{]p>.*MD=4Ⱦ. >,u\}>[0N	>*4&(FW>LA0K|d>'nvdp>q	v1McY^>$T}H>MÒ1xnߏ> "U;>#(5҄1gN|/>>>>&nt]1s>L*">)l'|	0\8Z>d+>,K/V=D->.ahe-ny}Z>0!̧ɾ+*b!,阺>0	z(S"P(7>1QǾ%;Mυq>1f~!AAž"XJA>1/sӾw>&H!G?+>16e?ɾUh\)wOn>0(i<,¾h,I,\>7>/CeeAKI.Z9U>-SxA=bQPپ0OO{>*)>rkR1s8$>'ca>+:L1x>$[m> Zž1vp> C
)h>#O1f1譛>Ϧa>'B1't>:m+>*XU0h3%=I>-Xx.?v]&>/R<,W˾&O>0XC)Tzrk΢>1eKcޥ%GYF>1WIݾ!&|"xkf>1_1ؾ;-@&OG>1R,6p,;
f* O>0j?$a-#R2r>/e>ґ=V_U/mդ>,޺.>Me7q0rƑ6>),̠s>>1lwb>&4G/5>SI1o>",3>"x`41J||>k[>&I2Z21^^QAe>%h>*ky0wUX>R	>-!#/B΁ν̽>0,nmvL>0\#2)A<GS0Bn>1q%lUBR4|uI>1QD!"^o#^>1vb
(@x[>1>TE~fC0+ɲ>0ea{1/.M-f5>.d3=_/0Y>+UA-6>[Nma1W#>'Ÿu>%7z1ʐll>#uPx>!ڬ=1&>B
J>&D7dCɾ1r>;y>*4	dW0}>.s>-iQ/LN3+I)I0a>0&9U,>7^&>1&HǎY)?23|>1N8^$ٍ@ d0>1r )
-y%6n>1Ur&>6)i.>1,a;ߛD->0
N]'Ⱦ/2
N>-:Tu>rj-j1?,w>)OJ>Ye|1B7,>%cศ> 32NH> 5>$p"ξ1`>އ3RP>)Q#1.	H>f:]@>-k0z=z>0	۰~->ȑހվ[(>1)8i)jE>1+7\>%)S W>29¾ $j5%YYvc>1п!&v*%)LI@>1LC
f˦ka-^b>/Yҙ=ӧJ0Si>,
b8>li1b7]>(x>sN1;Y>$
>!*Nxñ2K׊b>>&%m1ֽ><䋵>+17ܟ0߽=tXLS>.&_-..{Uf>0gQ
3+hh?*_%>1-F;*'
g:%H`Mp>2 o" y$>2	_Gbuֹ(>1mX
֠,ot>0O"LBaK0'1>-oX^>Sw1X+B
>)_\!>!i20B>$f>!DL2/Ÿ}]>+ \j(>&*Gx1>N>7>+c(맼0i2=_XU>/$tb.⡾)$bV2@O>0_+cؾ`i7>1K&etD]qR>22pg$1~lV*~xv>1@|k5iX*W.5p},e>/ O=ꯪ0z?>,8=>8G1V?{>')>eK"2>)w;>"T&J>$a^m02'
R>$n->)>³1{+>TzX>-ag־0=6wU8r>0*08,={SL>1{8b(erӾ%yl>2@yd#:#Ru >2;_ľ`#(Ԅ
p>1%u
Sڬ-X*7>0ab]=E>0q*v>-355T>j5za.1_>(I>ch2GB9>#4{^>#t32EP>/w^_>(㫣1tM>
KYb,>-z}Ĵ50`aʼn;{>0ö-|dE%CW>1eK(c=؋o4^>2UJTʄ"Ψ|r#r
>2FV)j1#>1,1dL-~{>08=Ďb0>,
>@V о1<2>'P@_N>jMp׾2f6->!څ<|>$!=2;ET>XffA>*av1c>ҙ@u>./n/̩۩,zd>1?+
&[P>2ŵ&g=Ⱦ ^Eut>2tpH Q?&w	>2֤"2T+rW>1VCr/Dv>.]>r
J(1{T9ve>*0>O2Q >$|m>"p>2s")	>YCX>(`1=[h1ܩ >rS>-b0ӡ}cRy>0e-BM҈
Vh>1薜D(3#2>2|V#B;"*Q7$Fmn>2SJ]B<*lf4>1oag…	/;h">/'Y=xP1M݋>+0y\aHJ>JY=Ѿ2IR$C>%g5t>!Y͑2nN)E=*>'ʪ|2讖>>-ME0¨E=̠X>0Jx-R7'V\|>19(t?2=XK>2ꖾ"Cq%:u>2`_#)*֢؆u>1q\I ]l/vv>/i?=5&λ1tw>*Կ`w>if2g(#<>$@2k>"fw2I#>bk#%>(18@>">-f&0VF
9W>0Cx0,(HTg>2,{ɢ':(օZ]>2Z xJD%&ٱ z>2Bo'stʾ,Wu)Ơ>1@>%lNܾ0dG>.Nm5>	&h1m>)>Cm]S2Ԃ>"_K>$ӧ*@2y>/>N>*'C1~=>/[.]/FZ8?&>1iW*6HTk=!>2_$ev[3#<6X:`>2ėbP);Q
?>1B.Iy>0: 8'=Ƙ1SP>+c;>ve2n˒>%Jc>!2>gP>ZP(BNM2
lHb>|-<>.
058GZP>1&,V.fyA>2WU&4\ `[>2zw[վ's>25rGX@h-{3<>0ҵp9==01>-?>=s2D->'m@	> 'R62W> u{1+>'-52OnǶ>W]uPF>-&F,>0\O=*	\q>0y'-v\cJݾS0p">2:Nq&T'?ZFyq>2Ñ /-~^	&D1š8>2_tHUI9,lR/%>1y:gE$ꏉ0΋/i>-ѥ哼>4$29>'Ŋ>CBYݾ2ȝ{> r>&N2e">N>,g01Tʵ.=D>>0l|-؋7ھ3r>2CșP5'⤢)žs7>2fZ0 w۽ʾ'|'>2b
 ,|Ay-4?2d>1JŽ~߫0So>-)A?>{N2WZ{Q>'rYWq> Ws@2m<> =	n>'(32UqP >8x>-J40v^͖!>1ͪ-c>2rռ&ݝ;!#\>2soPp_(\}>20I=Swr1RvW>,f'Q>A)a2t>%)5w>"6 m2S13>3?>)V&WOL*27t>x>/ 
!l0Z;90+|>1Y+xc
C>2UQ&$az̾#*^>2_A1fd*/Vy	>1w^AY?0>/W>\&і1f>*F;>h:IY{2t
F>#8iQ>%"2[>>.vw>+6f1*=AZ= >0U<_.TH
Qb)>2:puE(?HFj!>2VW!ciҾ&ݑVa@>2oOEL^-SH[>1*S5􄽥{,Ż21']/>-oc}>iZ:2Э>&Őj>!MjԾ2+[>p(
>(2Aiݠ>
JI>.6GfD0sG7k>1-;+]٥5vp>2cb$ؾ#4E9>2@Vɾhlf*3b>17[u˟Q:08*>/Ϭ>1%L?۾2*'K_>)iH>@Oy2U>"UQ>&&=AS=2)H!U>dX>,d1M:wC=1r*>0s-ڰ*pi[~>2j4V'W@!
>2 K}nL(3_%>2P-E
9!.l,>0ol=չ>Tپ1qXZ>+q.>>cT2'DY1l>$	F>$+K 2dz9>\)B>+TV3]1F6I=*{:>0w	V@/<=-q>2H UZ)/U{Cx>3\2M!Pй'5˘>2flhvo-Pꪟ>1+=s=9"1\|'T>,~Ȃ(>[Q} 2/>%>"Eb
2V3C>Rw邏+>*JMBrR2
CN>m_>0zI0uÐC>2_$c*R/NWF>2z;"a\8֕&SgS>2_zC/cj-?|M>1Da4'+1/%>-N>p$2`>&Y2G6>"/32ϼŻ>3#Q>)2-qDf
>W߱m>/c01q!CԾHfA>2	'-y*a-pU+>3F%?L"ץ&>2æD
N=-%\i}jU>1TqǓ`e鑾1."w>->YB2>&!>"#[_3-\~>Š>)2-5ȃ>æW>0rA0%8?PWK>2$%M*(ڎqE~{8>3
9*"WΛR|&~)>2
d&Y3ZV-:[T>19}=)ws1Xc>-2%s>ɡӂm2=
|>&*!5B>"GJ3
'X>H>*|ܡ2ؐJH=kPXU>0[ڥ޾/\[UK>2Si)\Y+ACFw>3WV!I/
V'uY>2?ʵ'ܳ.jfy>0B8=n1.帾1[R>,Ea,o>2^qko>$I>$AD*2|>߹Z->+\(1ގ!==%>0.8?)+,kd>2`NG@'=\Ѿ ߂	;x>3!%5Ce)Ȟ>2gMϫQQ(/v>0r=h78>"2O)4D>*ɖ>cz
3w>"8 >&1"p2Pbz>b->-wXth1Q5j\g¼?%>1bx9-EiƾXJ>2o̾%8P!#0O(h>3<:ɾ/3+H>2hTM.L03>/j2P>
jLFqb2v>(pG> "L
N3*,k'> DL->(M2&>
~>/\oӾ00%o>2!2:#8+'e˅"ld>3W?#4%,Y2>2c#RL-c'|>1`J?=Ne&!1ean>-V-|>	H2bh>%y>#Q
.32>͵:>+J``1YuI=b8>0Lid/?Zbw>2U7뎾(YQ\( Lo(>31
_Hl],)hmIM>2vr1E݌/ӓr>0ra͋>Y'x'2+D>*>1Chx3)g3>"]ֳj>&X2,=gD>^">.%0œ1%],f[l
>1,6p18V|>3&$ǻ-$xE>3ؓR>,_ݮ>1G%tS1(綸>.Lb1>]Z2ίb>&xG
]>"@~i3/>2>*&8423&uOb>pP>0x?/=>2H)=`Ijg
>39MH ft(ZΧ>2ץ
keK{/>0 HV=`_`W2#ͪ>*ٟM>d*c6ľ3/N;>"'Le>&&~;l^2mDK>qc>.,9Dh1,@kJ:&j+>1=֓,.q͟>3ZA$~fо$ժ>B>3
$wh[8,q>1Tt߶)mv1?U>-^7>E+g2 >&v6>"m~^3/ȿs>c>+2i2	/=dQ6Q+>0Ծ/N}Ⱦʨ)>2~T°(,ul!
b>3?
k)G`)ȍ4>2jde@906̛>0=;Ɲ9a>#Z2hX$Y>)Ɯ>k>3AED>!o>(&FG濾2G>D<>/Rv'02>/Ҟh>2u쀑++tw9nÎ>35杞">S;ھ&Ub>2}0,SIgP.0S>14cky=Hxd?1ƹO>,wڪS>PGuj3pۼ>$jj:k9>%!
3[>\R
>-,E1.=͡`>1gL'[-[M<g<>2H%T/#d">3.Vb)܉"Ҿ+T>1g/_\ϩF.1
{W>.Fsx>*i2сP>'?E>"5lƾ3@U=9>~+_>*D%29=X!&z>0?}r/%Xc4v`>2/ַ(&ʆ ͽ/V>3Jj.|2)Wȣ9>2xFӸvQaV0=7 )J>0C![v>^e̾2u>)9>cؾ3K9Ƅ> J=>(z}C(2{?/>#Pȕ>/pV	{0${=>2>	*DL*<?o[K>3Ez;" ֳu'`a!>2!C%OL=.ݼ>0͗T=wX52~>+M>>SQ"394[dE>#NԲ>&M#z2`f$>+?>.]a41K&fu>1ŏib,mGtFsfl>3)=A$gś=%B,
r>3BS2-E>1nr13fen1A>-gᡍ>J*63s5>%mG>$@z,\3-l5>7I>,}ap1r=n8X>1F3.&9$ɥ$>2pZ*n&_-#F >3=2%"5kV+t>2Xt)k1o>.Օƽ>
X_2Y!>'@N>"Wׄ3Iv[
 >"pH>*Hrپ25wo={l	(>0u/tɕ0
>2T|(u}
!pjZ>3QS]'턼*B>2_OCþ0Өp>0;;r>	Eu2a>(r(> m(3TQmF>f?H>)
<-2>n9>0Hv@0EU>3+>2Pqs)a*<~H>3UL:
 ;޾(N>2+CӾ0TsW>0~>'|w2f&jъ>*+@b>E 3TTHj>!J/m>(;}W(N2e@	g>B_>/_eHq0Ҳ+5c)>2EQ'mz*۾mIfBm>3PG0پ"Ujձ'3o>2$_;/)T>0zx=#μ2%(́>+TV >@`K3KZ>"K>'Ӥ2i^>'%k>.D15ԽF>2l+$L|`>3D(+B#O"|&nb>3	=2Q9	.JH]>1B*=$cݾ10>,R'K$>V -n3;xF0>#iN>%'3YJ%>q>-z5D1hA,/Z!>1ҫd8,1u\9'Z>32
;$sD%Y6t>3Zaګ-y7?>1
j%$=HPm+1'/>-.
6>R#3(h>$ocr>$5pT13+eQJ;>6UzH>-ܪ1	I+=q.k>1$=E-s*Rf,>3+,%t=}Bd$\Vwj>357uM`,!]k>1Ƀݭ>v
1fL>-oJhm>3y}>%8E|>#(S3>)-Ͻ>UݳF'>,YF1䂁8=a;,~>1H4{*.B,˾s,>3=.&W+4ľ#r5>3Env|>O,
KP>1v!p1+>.{8>O0J2I>&)^>#tt3Ki>=<t>+v2]צw=[o>13E.bOC;q>2Uپ'!c" g*>3Pt|23+V?2>2)
bнLEs0$:>/$͆4>sK2j%>'}vd>"7t^
¾3Tl[+>\Tv>+
0\2=V=˄l`>0*L8/fGkqE-}x	y>2O8'Ii7!yx>3W8*|kv>2NΏk%D0JL;>/r>:%-3[2ees5>($V>!~٫a3Z>qkJ>*s762^^X>&q܈">0q/O6G4>2kҾ(g!2(A0>3[qY*:>2jI(fcb]0ت>/<&>
X2ײ(>(B>!;AE3\[>\س>*AM2f
>Ə>0\w/d2f&tt7qV&ã>7վ>YCX>(`1=[h1ܩ >rS>-b0ӡ}cRy>0e-BM҈
Vh>1薜D(3#2>2|V#B;"*Q7$Fmn>2SJ]B<*lf4>1oag…	/;h">/'Y=xP1M݋>+0y\aHJ>JY=Ѿ2IR$C>%g5t>!Y͑2nN)E=*>'ʪ|2讖>>-ME0¨E=̠X>0Jx-R7'V\|>19(t?2=XK>2ꖾ"Cq%:u>2`_#)*֢؆u>1q\I ]l/vv>/i?=5&λ1tw>*Կ`w>if2g(#<>$@2k>"fw2I#>bk#%>(18@>">-f&0VF
9W>0Cx0,(HTg>2,{ɢ':(օZ]>2Z xJD%&ٱ z>2Bo'stʾ,Wu)Ơ>1@>%lNܾ0dG>.Nm5>	&h1m>)>Cm]S2Ԃ>"_K>$ӧ*@2y>/>N>*'C1~=>/[.]/FZ8?&>1iW*6HTk=!>2_$ev[3#<6X:`>2ėbP);Q
?>1B.Iy>0: 8'=Ƙ1SP>+c;>ve2n˒>%Jc>!2>gP>ZP(BNM2
lHb>|-<>.
058GZP>1&,V.fyA>2WU&4\ `[>2zw[վ's>25rGX@h-{3<>0ҵp9==01>-?>=s2D->'m@	> 'R62W> u{1+>'-52OnǶ>W]uPF>-&F,>0\O=*	\q>0y'-v\cJݾS0p">2:Nq&T'?ZFyq>2Ñ /-~^	&D1š8>2_tHUI9,lR/%>1y:gE$ꏉ0΋/i>-ѥ哼>4$29>'Ŋ>CBYݾ2ȝ{> r>&N2e">N>,g01Tʵ.=D>>0l|-؋7ھ3r>2CșP5'⤢)žs7>2fZ0 w۽ʾ'|'>2b
 ,|Ay-4?2d>1JŽ~߫0So>-)A?>{N2WZ{Q>'rYWq> Ws@2m<> =	n>'(32UqP >8x>-J40v^͖!>1ͪ-c>2rռ&ݝ;!#\>2soPp_(\}>20I=Swr1RvW>,f'Q>A)a2t>%)5w>"6 m2S13>3?>)V&WOL*27t>x>/ 
!l0Z;90+|>1Y+xc
C>2UQ&$az̾#*^>2_A1fd*/Vy	>1w^AY?0>/W>\&і1f>*F;>h:IY{2t
F>#8iQ>%"2[>>.vw>+6f1*=AZ= >0U<_.TH
Qb)>2:puE(?HFj!>2VW!ciҾ&ݑVa@>2oOEL^-SH[>1*S5􄽥{,Ż21']/>-oc}>iZ:2Э>&Őj>!MjԾ2+[>p(
>(2Aiݠ>
JI>.6GfD0sG7k>1-;+]٥5vp>2cb$ؾ#4E9>2@Vɾhlf*3b>17[u˟Q:08*>/Ϭ>1%L?۾2*'K_>)iH>@Oy2U>"UQ>&&=AS=2)H!U>dX>,d1M:wC=1r*>0s-ڰ*pi[~>2j4V'W@!
>2 K}nL(3_%>2P-E
9!.l,>0ol=չ>Tپ1qXZ>+q.>>cT2'DY1l>$	F>$+K 2dz9>\)B>+TV3]1F6I=*{:>0w	V@/<=-q>2H UZ)/U{Cx>3\2M!Pй'5˘>2flhvo-Pꪟ>1+=s=9"1\|'T>,~Ȃ(>[Q} 2/>%>"Eb
2V3C>Rw邏+>*JMBrR2
CN>m_>0zI0uÐC>2_$c*R/NWF>2z;"a\8֕&SgS>2_zC/cj-?|M>1Da4'+1/%>-N>p$2`>&Y2G6>"/32ϼŻ>3#Q>)2-qDf
>W߱m>/c01q!CԾHfA>2	'-y*a-pU+>3F%?L"ץ&>2æD
N=-%\i}jU>1TqǓ`e鑾1."w>->YB2>&!>"#[_3-\~>Š>)2-5ȃ>æW>0rA0%8?PWK>2$%M*(ڎqE~{8>3
9*"WΛR|&~)>2
d&Y3ZV-:[T>19}=)ws1Xc>-2%s>ɡӂm2=
|>&*!5B>"GJ3
'X>H>*|ܡ2ؐJH=kPXU>0[ڥ޾/\[UK>2Si)\Y+ACFw>3WV!I/
V'uY>2?ʵ'ܳ.jfy>0B8=n1.帾1[R>,Ea,o>2^qko>$I>$AD*2|>߹Z->+\(1ގ!==%>0.8?)+,kd>2`NG@'=\Ѿ ߂	;x>3!%5Ce)Ȟ>2gMϫQQ(/v>0r=h78>"2O)4D>*ɖ>cz
3w>"8 >&1"p2Pbz>b->-wXth1Q5j\g¼?%>1bx9-EiƾXJ>2o̾%8P!#0O(h>3<:ɾ/3+H>2hTM.L03>/j2P>
jLFqb2v>(pG> "L
N3*,k'> DL->(M2&>
~>/\oӾ00%o>2!2:#8+'e˅"ld>3W?#4%,Y2>2c#RL-c'|>1`J?=Ne&!1ean>-V-|>	H2bh>%y>#Q
.32>͵:>+J``1YuI=b8>0Lid/?Zbw>2U7뎾(YQ\( Lo(>31
_Hl],)hmIM>2vr1E݌/ӓr>0ra͋>Y'x'2+D>*>1Chx3)g3>"]ֳj>&X2,=gD>^">.%0œ1%],f[l
>1,6p18V|>3&$ǻ-$xE>3ؓR>,_ݮ>1G%tS1(綸>.Lb1>]Z2ίb>&xG
]>"@~i3/>2>*&8423&uOb>pP>0x?/=>2H)=`Ijg
>39MH ft(ZΧ>2ץ
keK{/>0 HV=`_`W2#ͪ>*ٟM>d*c6ľ3/N;>"'Le>&&~;l^2mDK>qc>.,9Dh1,@kJ:&j+>1=֓,.q͟>3ZA$~fо$ժ>B>3
$wh[8,q>1Tt߶)mv1?U>-^7>E+g2 >&v6>"m~^3/ȿs>c>+2i2	/=dQ6Q+>0Ծ/N}Ⱦʨ)>2~T°(,ul!
b>3?
k)G`)ȍ4>2jde@906̛>0=;Ɲ9a>#Z2hX$Y>)Ɯ>k>3AED>!o>(&FG濾2G>D<>/Rv'02>/Ҟh>2u쀑++tw9nÎ>35杞">S;ھ&Ub>2}0,SIgP.0S>14cky=Hxd?1ƹO>,wڪS>PGuj3pۼ>$jj:k9>%!
3[>\R
>-,E1.=͡`>1gL'[-[M<g<>2H%T/#d">3.Vb)܉"Ҿ+T>1g/_\ϩF.1
{W>.Fsx>*i2сP>'?E>"5lƾ3@U=9>~+_>*D%29=X!&z>0?}r/%Xc4v`>2/ַ(&ʆ ͽ/V>3Jj.|2)Wȣ9>2xFӸvQaV0=7 )J>0C![v>^e̾2u>)9>cؾ3K9Ƅ> J=>(z}C(2{?/>#Pȕ>/pV	{0${=>2>	*DL*<?o[K>3Ez;" ֳu'`a!>2!C%OL=.ݼ>0͗T=wX52~>+M>>SQ"394[dE>#NԲ>&M#z2`f$>+?>.]a41K&fu>1ŏib,mGtFsfl>3)=A$gś=%B,
r>3BS2-E>1nr13fen1A>-gᡍ>J*63s5>%mG>$@z,\3-l5>7I>,}ap1r=n8X>1F3.&9$ɥ$>2pZ*n&_-#F >3=2%"5kV+t>2Xt)k1o>.Օƽ>
X_2Y!>'@N>"Wׄ3Iv[
 >"pH>*Hrپ25wo={l	(>0u/tɕ0
>2T|(u}
!pjZ>3QS]'턼*B>2_OCþ0Өp>0;;r>	Eu2a>(r(> m(3TQmF>f?H>)
<-2>n9>0Hv@0EU>3+>2Pqs)a*<~H>3UL:
 ;޾(N>2+CӾ0TsW>0~>'|w2f&jъ>*+@b>E 3TTHj>!J/m>(;}W(N2e@	g>B_>/_eHq0Ҳ+5c)>2EQ'mz*۾mIfBm>3PG0پ"Ujձ'3o>2$_;/)T>0zx=#μ2%(́>+TV >@`K3KZ>"K>'Ӥ2i^>'%k>.D15ԽF>2l+$L|`>3D(+B#O"|&nb>3	=2Q9	.JH]>1B*=$cݾ10>,R'K$>V -n3;xF0>#iN>%'3YJ%>q>-z5D1hA,/Z!>1ҫd8,1u\9'Z>32
;$sD%Y6t>3Zaګ-y7?>1
j%$=HPm+1'/>-.
6>R#3(h>$ocr>$5pT13+eQJ;>6UzH>-ܪ1	I+=q.k>1$=E-s*Rf,>3+,%t=}Bd$\Vwj>357uM`,!]k>1Ƀݭ>v
1fL>-oJhm>3y}>%8E|>#(S3>)-Ͻ>UݳF'>,YF1䂁8=a;,~>1H4{*.B,˾s,>3=.&W+4ľ#r5>3Env|>O,
KP>1v!p1+>.{8>O0J2I>&)^>#tt3Ki>=<t>+v2]צw=[o>13E.bOC;q>2Uپ'!c" g*>3Pt|23+V?2>2)
bнLEs0$:>/$͆4>sK2j%>'}vd>"7t^
¾3Tl[+>\Tv>+
0\2=V=˄l`>0*L8/fGkqE-}x	y>2O8'Ii7!yx>3W8*|kv>2NΏk%D0JL;>/r>:%-3[2ees5>($V>!~٫a3Z>qkJ>*s762^^X>&q܈">0q/O6G4>2kҾ(g!2(A0>3[qY*:>2jI(fcb]0ت>/<&>
X2ײ(>(B>!;AE3\[>\س>*AM2f
>Ə>0\w/d2f&tt7qV&ã>7վ>YCX>(`1=[h1ܩ >rS>-b0ӡ}cRy>0e-BM҈
Vh>1薜D(3#2>2|V#B;"*Q7$Fmn>2SJ]B<*lf4>1oag…	/;h">/'Y=xP1M݋>+0y\aHJ>JY=Ѿ2IR$C>%g5t>!Y͑2nN)E=*>'ʪ|2讖>>-ME0¨E=̠X>0Jx-R7'V\|>19(t?2=XK>2ꖾ"Cq%:u>2`_#)*֢؆u>1q\I ]l/vv>/i?=5&λ1tw>*Կ`w>if2g(#<>$@2k>"fw2I#>bk#%>(18@>">-f&0VF
9W>0Cx0,(HTg>2,{ɢ':(օZ]>2Z xJD%&ٱ z>2Bo'stʾ,Wu)Ơ>1@>%lNܾ0dG>.Nm5>	&h1m>)>Cm]S2Ԃ>"_K>$ӧ*@2y>/>N>*'C1~=>/[.]/FZ8?&>1iW*6HTk=!>2_$ev[3#<6X:`>2ėbP);Q
?>1B.Iy>0: 8'=Ƙ1SP>+c;>ve2n˒>%Jc>!2>gP>ZP(BNM2
lHb>|-<>.
058GZP>1&,V.fyA>2WU&4\ `[>2zw[վ's>25rGX@h-{3<>0ҵp9==01>-?>=s2D->'m@	> 'R62W> u{1+>'-52OnǶ>W]uPF>-&F,>0\O=*	\q>0y'-v\cJݾS0p">2:Nq&T'?ZFyq>2Ñ /-~^	&D1š8>2_tHUI9,lR/%>1y:gE$ꏉ0΋/i>-ѥ哼>4$29>'Ŋ>CBYݾ2ȝ{> r>&N2e">N>,g01Tʵ.=D>>0l|-؋7ھ3r>2CșP5'⤢)žs7>2fZ0 w۽ʾ'|'>2b
 ,|Ay-4?2d>1JŽ~߫0So>-)A?>{N2WZ{Q>'rYWq> Ws@2m<> =	n>'(32UqP >8x>-J40v^͖!>1ͪ-c>2rռ&ݝ;!#\>2soPp_(\}>20I=Swr1RvW>,f'Q>A)a2t>%)5w>"6 m2S13>3?>)V&WOL*27t>x>/ 
!l0Z;90+|>1Y+xc
C>2UQ&$az̾#*^>2_A1fd*/Vy	>1w^AY?0>/W>\&і1f>*F;>h:IY{2t
F>#8iQ>%"2[>>.vw>+6f1*=AZ= >0U<_.TH
Qb)>2:puE(?HFj!>2VW!ciҾ&ݑVa@>2oOEL^-SH[>1*S5􄽥{,Ż21']/>-oc}>iZ:2Э>&Őj>!MjԾ2+[>p(
>(2Aiݠ>
JI>.6GfD0sG7k>1-;+]٥5vp>2cb$ؾ#4E9>2@Vɾhlf*3b>17[u˟Q:08*>/Ϭ>1%L?۾2*'K_>)iH>@Oy2U>"UQ>&&=AS=2)H!U>dX>,d1M:wC=1r*>0s-ڰ*pi[~>2j4V'W@!
>2 K}nL(3_%>2P-E
9!.l,>0ol=չ>Tپ1qXZ>+q.>>cT2'DY1l>$	F>$+K 2dz9>\)B>+TV3]1F6I=*{:>0w	V@/<=-q>2H UZ)/U{Cx>3\2M!Pй'5˘>2flhvo-Pꪟ>1+=s=9"1\|'T>,~Ȃ(>[Q} 2/>%>"Eb
2V3C>Rw邏+>*JMBrR2
CN>m_>0zI0uÐC>2_$c*R/NWF>2z;"a\8֕&SgS>2_zC/cj-?|M>1Da4'+1/%>-N>p$2`>&Y2G6>"/32ϼŻ>3#Q>)2-qDf
>W߱m>/c01q!CԾHfA>2	'-y*a-pU+>3F%?L"ץ&>2æD
N=-%\i}jU>1TqǓ`e鑾1."w>->YB2>&!>"#[_3-\~>Š>)2-5ȃ>æW>0rA0%8?PWK>2$%M*(ڎqE~{8>3
9*"WΛR|&~)>2
d&Y3ZV-:[T>19}=)ws1Xc>-2%s>ɡӂm2=
|>&*!5B>"GJ3
'X>H>*|ܡ2ؐJH=kPXU>0[ڥ޾/\[UK>2Si)\Y+ACFw>3WV!I/
V'uY>2?ʵ'ܳ.jfy>0B8=n1.帾1[R>,Ea,o>2^qko>$I>$AD*2|>߹Z->+\(1ގ!==%>0.8?)+,kd>2`NG@'=\Ѿ ߂	;x>3!%5Ce)Ȟ>2gMϫQQ(/v>0r=h78>"2O)4D>*ɖ>cz
3w>"8 >&1"p2Pbz>b->-wXth1Q5j\g¼?%>1bx9-EiƾXJ>2o̾%8P!#0O(h>3<:ɾ/3+H>2hTM.L03>/j2P>
jLFqb2v>(pG> "L
N3*,k'> DL->(M2&>
~>/\oӾ00%o>2!2:#8+'e˅"ld>3W?#4%,Y2>2c#RL-c'|>1`J?=Ne&!1ean>-V-|>	H2bh>%y>#Q
.32>͵:>+J``1YuI=b8>0Lid/?Zbw>2U7뎾(YQ\( Lo(>31
_Hl],)hmIM>2vr1E݌/ӓr>0ra͋>Y'x'2+D>*>1Chx3)g3>"]ֳj>&X2,=gD>^">.%0œ1%],f[l
>1,6p18V|>3&$ǻ-$xE>3ؓR>,_ݮ>1G%tS1(綸>.Lb1>]Z2ίb>&xG
]>"@~i3/>2>*&8423&uOb>pP>0x?/=>2H)=`Ijg
>39MH ft(ZΧ>2ץ
keK{/>0 HV=`_`W2#ͪ>*ٟM>d*c6ľ3/N;>"'Le>&&~;l^2mDK>qc>.,9Dh1,@kJ:&j+>1=֓,.q͟>3ZA$~fо$ժ>B>3
$wh[8,q>1Tt߶)mv1?U>-^7>E+g2 >&v6>"m~^3/ȿs>c>+2i2	/=dQ6Q+>0Ծ/N}Ⱦʨ)>2~T°(,ul!
b>3?
k)G`)ȍ4>2jde@906̛>0=;Ɲ9a>#Z2hX$Y>)Ɯ>k>3AED>!o>(&FG濾2G>D<>/Rv'02>/Ҟh>2u쀑++tw9nÎ>35杞">S;ھ&Ub>2}0,SIgP.0S>14cky=Hxd?1ƹO>,wڪS>PGuj3pۼ>$jj:k9>%!
3[>\R
>-,E1.=͡`>1gL'[-[M<g<>2H%T/#d">3.Vb)܉"Ҿ+T>1g/_\ϩF.1
{W>.Fsx>*i2сP>'?E>"5lƾ3@U=9>~+_>*D%29=X!&z>0?}r/%Xc4v`>2/ַ(&ʆ ͽ/V>3Jj.|2)Wȣ9>2xFӸvQaV0=7 )J>0C![v>^e̾2u>)9>cؾ3K9Ƅ> J=>(z}C(2{?/>#Pȕ>/pV	{0${=>2>	*DL*<?o[K>3Ez;" ֳu'`a!>2!C%OL=.ݼ>0͗T=wX52~>+M>>SQ"394[dE>#NԲ>&M#z2`f$>+?>.]a41K&fu>1ŏib,mGtFsfl>3)=A$gś=%B,
r>3BS2-E>1nr13fen1A>-gᡍ>J*63s5>%mG>$@z,\3-l5>7I>,}ap1r=n8X>1F3.&9$ɥ$>2pZ*n&_-#F >3=2%"5kV+t>2Xt)k1o>.Օƽ>
X_2Y!>'@N>"Wׄ3Iv[
 >"pH>*Hrپ25wo={l	(>0u/tɕ0
>2T|(u}
!pjZ>3QS]'턼*B>2_OCþ0Өp>0;;r>	Eu2a>(r(> m(3TQmF>f?H>)
<-2>n9>0Hv@0EU>3+>2Pqs)a*<~H>3UL:
 ;޾(N>2+CӾ0TsW>0~>'|w2f&jъ>*+@b>E 3TTHj>!J/m>(;}W(N2e@	g>B_>/_eHq0Ҳ+5c)>2EQ'mz*۾mIfBm>3PG0پ"Ujձ'3o>2$_;/)T>0zx=#μ2%(́>+TV >@`K3KZ>"K>'Ӥ2i^>'%k>.D15ԽF>2l+$L|`>3D(+B#O"|&nb>3	=2Q9	.JH]>1B*=$cݾ10>,R'K$>V -n3;xF0>#iN>%'3YJ%>q>-z5D1hA,/Z!>1ҫd8,1u\9'Z>32
;$sD%Y6t>3Zaګ-y7?>1
j%$=HPm+1'/>-.
6>R#3(h>$ocr>$5pT13+eQJ;>6UzH>-ܪ1	I+=q.k>1$=E-s*Rf,>3+,%t=}Bd$\Vwj>357uM`,!]k>1Ƀݭ>v
1fL>-oJhm>3y}>%8E|>#(S3>)-Ͻ>UݳF'>,YF1䂁8=a;,~>1H4{*.B,˾s,>3=.&W+4ľ#r5>3Env|>O,
KP>1v!p1+>.{8>O0J2I>&)^>#tt3Ki>=<t>+v2]צw=[o>13E.bOC;q>2Uپ'!c" g*>3Pt|23+V?2>2)
bнLEs0$:>/$͆4>sK2j%>'}vd>"7t^
¾3Tl[+>\Tv>+
0\2=V=˄l`>0*L8/fGkqE-}x	y>2O8'Ii7!yx>3W8*|kv>2NΏk%D0JL;>/r>:%-3[2ees5>($V>!~٫a3Z>qkJ>*s762^^X>&q܈">0q/O6G4>2kҾ(g!2(A0>3[qY*:>2jI(fcb]0ت>/<&>
X2ײ(>(B>!;AE3\[>\س>*AM2f
>Ə>0\w/d2f&tt7qV&ã>7վhealpy-1.10.3/healpy/data/weight_ring_n08192.fits0000664000175000017500000142340013010374155021642 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2005-08-18T00:57:38' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                24576 / width of table in bytes                        NAXIS2  =                   16 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   NSIDE   =                 8192 / Resolution parameter for HEALPIX               CREATOR = 'QUAD_RING'          / Software creating the FITS file                VERSION = '1.3.0   '           / Version of the simulation software             MAX-LPOL=                24576 / Maximum multipole l used in map synthesis      COMMENT                                                                         COMMENT -----------------------------------------------                         COMMENT Data Description Specific Keywords                                      COMMENT -----------------------------------------------                         COMMENT                                                                         COMMENT contains D_weight for the north hemisphere of HEALPIX                   COMMENT each ring has to be multiplied by (1+D_weight)                          COMMENT in order to improve the quadrature when analyzing a map                 COMMENT                                                                         COMMENT computed by SVD using DGESDD  from Lapack library                       COMMENT                                                                         TTYPE1  = 'TEMPERATURE WEIGHTS' / Temperature weights                           TUNIT1  = '1       '           / unit                                           TFORM1  = '1024D   '                                                            MAXVAL1 =   1.634629503848E-01 / maximum value of T weights                     MINVAL1 =  -6.828799286753E-02 / minimum value of T weights                     COMMENT                                                                         TTYPE2  = 'Q-POLARISATION WEIGHTS' / Q Polarisation weights                     TUNIT2  = '1       '           / unit                                           TFORM2  = '1024D   '                                                            MAXVAL2 =   1.634629503848E-01 / maximum value of Q weights                     MINVAL2 =  -6.828799286753E-02 / minimum value of Q weights                     COMMENT                                                                         TTYPE3  = 'U-POLARISATION WEIGHTS' / U Polarisation weights                     TUNIT3  = '1       '           / unit                                           TFORM3  = '1024D   '                                                            MAXVAL3 =   1.634629503848E-01 / maximum value of U weights                     MINVAL3 =  -6.828799286753E-02 / minimum value of U weights                     COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ?ZQ_{RhT?iBg{fik4?{
1w?hF-PF,g[Ml4m?b] k%jӽ?G)_BV?851Pgc?R{¿G8eH?ceg?<pS@&,F+]Y?Cz8K!z2aBn.c?9.}i=,?4ڡ<09Q'c?4>?흿3}/UQ?#:?})oRF]?0TH(3?	3"G?y,-]'2n?'xDZp$🾬T?Iտ$;?	w+l>~6?/JxZ$Ck?,V?.=gD0u>?h9m0`>uevck>2;a3;?
`,>ـNע>#Km(>?_W?u?r+6>&'Ff?S}"MZZ[?/f¿[љ>f%o#)>U4f׾t?)d̾&>)nk؅>>9ƚI>pUp/,&g>PXԾhĉ9I>_O鿐
ߑ>srejd(ǁ>(>E*f>ί,aw$3ѓ>z>ާ-u+Pv>hh6߅NX>	9FW<>dؔ&g[ܛ>*Ոߐ⼹J(1r">\˾#	N>Wb#Ѹ䚢a@>12 5>VMG>#5/c>x>١X>'H(*Qȸyhİ7>u#oϾ?J;>Q᷿}ۤLU9W9>zTAP?%>B.>zپ+R>ƥUy>U>k~?>A#2}>aЌ4!uv)>ȧ.Fjˆ2kG>odؾ˄)`9>,J]".U,(>$>lۖ7뫾ڼ9	><5O>ۋ><ҕ(;"64>RDH>qy23	.#O>~>h3WH
>51Oa>[q^!y?FRv>ΐ޳UA()>΄0ׂ>8kSP=1>T׾`?>i;ū>1;;+>ܗRFоms6]R>C#O!Y,>겎?ńc;ɳ(DE>ٻ/eڤ߼^s>Σ,[>[4#H2>ڛvˈ`к!'>^>%nfR>(+cx΢pԾ$5HY>ГOOtY
>Gk)(v]˾Aei>Ԏ2yQ'mf>MGSP3xv̛
9q>6vC"h>ZNk>2DnXYnm>Օ@'|H2>-5>Ȍv`̾JG[>Wk'uܾKg[Ǝ-p>Yx2ADe >HHFΣa1S\>҅L^V'9DcD>‘㜬>A5Dd%#|>һR?x̣[s>gH%>x޾>k56|/Ln)>6Vn?/>x[:J;1{Y>{D(K@=H>bٝ.>ː ƽ/S#>5< ׾)c螝>,CKF>70>LÓNo5mlob>0)ľ%>[*Jl?&xBc>]	6e1\m
>äPn'_
qg>.zҾɃy
>$~>_:itV>˜YBlÜ$~]>hS
>>2r-В#>ȥl2r澸dV)[$>ıu>tWЀ>|SVQkU>>T8eU>>MKh—o67S>ȗfsHߞ>;,>\[
K->@u3oVOu->#uu&!
UU>{gxM羲p^X>H1>jm>}5¯Uv~J>{GO>;hP›E/X>i|@6>g1
F>)^{*xeE>NZ?oM⾨d>{RhM9>aXk,y徶/P>M|d>r>|XǾ2H>.Axtn>tr	>ѩ7k|e>kԌ$CӤWd#W>#`C?1> aNO$'*Q>A=Ҿu*+>ZuG>R!ho>YRBU(6>=+_.>	X
8`>e{9)ͤM$6>Уq+A>MX-	 8>y)>f>:ÆY
>EIH\߾b>’>7=?zy>+~؎E>{ql>iʾOz"S>%\Q>#F&bB>0T?ck)kٷ6n>GQSWV>V>-OA/~>/Hɻf,	>>iZ>]vѾA4>"p.4`0LӠ>uGW=_Lkk>"/on!>-x?>n%"0Cm>o:$5G>*x1>IJ>w8/d>![bK%]	J>>xWYvfTvN>lE<Ծtm>M>.پpp$`&콫N>3PjAlD>7H>O	C;HX|>:(LuY>'E>`6:_>N&8]Ծwan >߾g{Ú>ہ5V#^Hľ8ܝ^>2jb>|ը>,ݾ#˲H>
^>60>fc5>Oer`鍟}>NIGeƭH>**ꌾjzʓ38o!>$Vѽ&0&>j[>`/:inB>n2ƾ2t.><˟ϘP>l:\qmPYy>_TF?7>fFg>S~D澲̈́>&p	׫>Ns ӘH
>ꏘX}i]Gk>'	vl>`>ě$qNe><߉Z0a!>/l>>q&4zR[>ۗs9BsbE>rRܾ5>JJkleH#>qgs7S>w>>xI3oE>񻪞F_"Y2>Ũ>}:/%2$>RsؾT\9.L*>!)?q
r>O;@\hlMN|Ž[.>0
MD>j_
bMv[>lUZt
>nTE>?o@ʂ;>'ߧ*	>xGD7>EW
uվ%E4nҒVFw [>61ퟩ7IUI>91sFX>O9>tx/>P޵I@^&>j]-"d>Jrj>€1_!hsV]gx>XG>̝TNڎ'>FN:HXJ-L4>RTw>QsL|s>-E9>4$^>ew:>ST$}>c&yUL>%`T,>H^jY1;o^>9NB:Fz>ֳw;wGjjsp>zDEf{&>:k
>i`Α[>Ĵ2i}Xu>>>k𾧋W>Ϻځ].c,+{B>O(ؾy;)*>29$B߾[4c꾕M}ZDn>>w:Oj[>O5h>kpW7>j0ᾤ5M<>F>ͼ?]ă>I?-oMv鸾$O>Kl`>qhAj0ds꾌M|Id>2Z	>|bg69	c>P#0k>a#>5Z6dB)߼>e؋XNw_#>w3r>ٯWkv
U55>k#&x|{L¨;>>i[ԝt
>fز۾n"׾xZ'Dz>oTJ>dw7>sd0a|>04
FO\mvz>-yB>^:ܑ8>\Fy^rP>ߓSczm9F>"wx@{>B>$(MByG
зYٚ>7̊nCb>^!R>i6R>K+n $>lm~w>8|#qC!>A
oWU+>MƞZ>uiqxblgȤ>z6y>a:ݶ?>v2I7PҮ>18xdh>7_>ꤡbb>rD>?gZAg}?>rxLr>Q
꾅^~5M><|J<4>eK@m>9Zo۾?
8p>9A<(>Sw2>!2/X>[#ˑ>`r
>?ԯؾ>?@'ƫTD%j`>}ྡBp[>6wMҺqdQ>]>=^OFE>/kG>xT4ejN>P⭾.l=1>z>0ޜ?j'mT>lK>l&I
	>>m&{w꾠nkk_>ٹK`v>4{_,>Fr=>Sm˱%zV5
>׾%]}>bM>pin>h?gXH>Qd-^E^>=+Nvz7Yb>jɾFάȍ?^-:>/t\V>)FjSNDь+>h;yXAb>@2%>xD6K8>_;kҲ%
r>uS!>xݾ	!>yyZӚ?nœ[5>_K[W>ƾ}]>{1jq+>UЅ>ZIϾ“!8>0оj
wl>w>"U߾{x{B>CKDegPM>@/?-)4> -g#U$k@W>_8H#9>td~!5bd>݅4Kx9:>AT>wFپQq>v}CV9>r׷l>F
A}->6u?5DenkC.g>/۔>Jyݚ5)/Ic>/%:o2>^P>[ӓ=y^>fFښ0T(/>Pyb>[2eE{>Qss>/rd>A0u Cc?>*7]X~u~>Q]h%XrE>˴)rqaQͺªG;P>KCᾗl0>&uf>vyz2]p>-Ȅ>p}>@]*6gl>NN+r[)7sp`y>6tw]%þ-b*>	31bXWX>!i,:>YAľw.`>f澔3c>}L@>a^(>cs>R}/wU0Y>.LUAe>Y_F>څc]2Ѿ{9>jmK)>EAVh`E#"|h>%]>۾r`Xv>s=,6H'>ɑ$f,z`ߘ>nPA9>r)w)Z>SJfh޳>KվRٟ>{jӮu
@'=o>k:>6>UtaHq>k z>{}q>J!]!*>`&1e>g2:>;a:.>#EE>7DܾGZxfi>2ۭ>'Իi`ڃ-n>7sFBn*c9>>ȭzS>q}QF4A>RYlbH]>m܂DO>:g}9Kc>ěNV"VdTZT>kr+u0>M݁ľuU>GZH1>h>K{JPeʑtAf>+Bq>->zrd1>{))
˾,tAt>|fz
c>Ha}>43!=F?>;&۲Bt+I>-}(]>N;֓ƾbyJK뾄ܰz>v~,ɏ-r>ie}>k3iEtI)>8c'T`Y>o#r>/5ʾn:>:fo
Nɾ$^3]L}W>|ZIdVd>9x8uSA%}V] >JlC)>G=>2<=T>AB	&zkVy>w
x䌾S>>:u"2rQK>T Wt>9`7?ZQ_{RhT?iBg{fik4?{
1w?hF-PF,g[Ml4m?b] k%jӽ?G)_BV?851Pgc?R{¿G8eH?ceg?<pS@&,F+]Y?Cz8K!z2aBn.c?9.}i=,?4ڡ<09Q'c?4>?흿3}/UQ?#:?})oRF]?0TH(3?	3"G?y,-]'2n?'xDZp$🾬T?Iտ$;?	w+l>~6?/JxZ$Ck?,V?.=gD0u>?h9m0`>uevck>2;a3;?
`,>ـNע>#Km(>?_W?u?r+6>&'Ff?S}"MZZ[?/f¿[љ>f%o#)>U4f׾t?)d̾&>)nk؅>>9ƚI>pUp/,&g>PXԾhĉ9I>_O鿐
ߑ>srejd(ǁ>(>E*f>ί,aw$3ѓ>z>ާ-u+Pv>hh6߅NX>	9FW<>dؔ&g[ܛ>*Ոߐ⼹J(1r">\˾#	N>Wb#Ѹ䚢a@>12 5>VMG>#5/c>x>١X>'H(*Qȸyhİ7>u#oϾ?J;>Q᷿}ۤLU9W9>zTAP?%>B.>zپ+R>ƥUy>U>k~?>A#2}>aЌ4!uv)>ȧ.Fjˆ2kG>odؾ˄)`9>,J]".U,(>$>lۖ7뫾ڼ9	><5O>ۋ><ҕ(;"64>RDH>qy23	.#O>~>h3WH
>51Oa>[q^!y?FRv>ΐ޳UA()>΄0ׂ>8kSP=1>T׾`?>i;ū>1;;+>ܗRFоms6]R>C#O!Y,>겎?ńc;ɳ(DE>ٻ/eڤ߼^s>Σ,[>[4#H2>ڛvˈ`к!'>^>%nfR>(+cx΢pԾ$5HY>ГOOtY
>Gk)(v]˾Aei>Ԏ2yQ'mf>MGSP3xv̛
9q>6vC"h>ZNk>2DnXYnm>Օ@'|H2>-5>Ȍv`̾JG[>Wk'uܾKg[Ǝ-p>Yx2ADe >HHFΣa1S\>҅L^V'9DcD>‘㜬>A5Dd%#|>һR?x̣[s>gH%>x޾>k56|/Ln)>6Vn?/>x[:J;1{Y>{D(K@=H>bٝ.>ː ƽ/S#>5< ׾)c螝>,CKF>70>LÓNo5mlob>0)ľ%>[*Jl?&xBc>]	6e1\m
>äPn'_
qg>.zҾɃy
>$~>_:itV>˜YBlÜ$~]>hS
>>2r-В#>ȥl2r澸dV)[$>ıu>tWЀ>|SVQkU>>T8eU>>MKh—o67S>ȗfsHߞ>;,>\[
K->@u3oVOu->#uu&!
UU>{gxM羲p^X>H1>jm>}5¯Uv~J>{GO>;hP›E/X>i|@6>g1
F>)^{*xeE>NZ?oM⾨d>{RhM9>aXk,y徶/P>M|d>r>|XǾ2H>.Axtn>tr	>ѩ7k|e>kԌ$CӤWd#W>#`C?1> aNO$'*Q>A=Ҿu*+>ZuG>R!ho>YRBU(6>=+_.>	X
8`>e{9)ͤM$6>Уq+A>MX-	 8>y)>f>:ÆY
>EIH\߾b>’>7=?zy>+~؎E>{ql>iʾOz"S>%\Q>#F&bB>0T?ck)kٷ6n>GQSWV>V>-OA/~>/Hɻf,	>>iZ>]vѾA4>"p.4`0LӠ>uGW=_Lkk>"/on!>-x?>n%"0Cm>o:$5G>*x1>IJ>w8/d>![bK%]	J>>xWYvfTvN>lE<Ծtm>M>.پpp$`&콫N>3PjAlD>7H>O	C;HX|>:(LuY>'E>`6:_>N&8]Ծwan >߾g{Ú>ہ5V#^Hľ8ܝ^>2jb>|ը>,ݾ#˲H>
^>60>fc5>Oer`鍟}>NIGeƭH>**ꌾjzʓ38o!>$Vѽ&0&>j[>`/:inB>n2ƾ2t.><˟ϘP>l:\qmPYy>_TF?7>fFg>S~D澲̈́>&p	׫>Ns ӘH
>ꏘX}i]Gk>'	vl>`>ě$qNe><߉Z0a!>/l>>q&4zR[>ۗs9BsbE>rRܾ5>JJkleH#>qgs7S>w>>xI3oE>񻪞F_"Y2>Ũ>}:/%2$>RsؾT\9.L*>!)?q
r>O;@\hlMN|Ž[.>0
MD>j_
bMv[>lUZt
>nTE>?o@ʂ;>'ߧ*	>xGD7>EW
uվ%E4nҒVFw [>61ퟩ7IUI>91sFX>O9>tx/>P޵I@^&>j]-"d>Jrj>€1_!hsV]gx>XG>̝TNڎ'>FN:HXJ-L4>RTw>QsL|s>-E9>4$^>ew:>ST$}>c&yUL>%`T,>H^jY1;o^>9NB:Fz>ֳw;wGjjsp>zDEf{&>:k
>i`Α[>Ĵ2i}Xu>>>k𾧋W>Ϻځ].c,+{B>O(ؾy;)*>29$B߾[4c꾕M}ZDn>>w:Oj[>O5h>kpW7>j0ᾤ5M<>F>ͼ?]ă>I?-oMv鸾$O>Kl`>qhAj0ds꾌M|Id>2Z	>|bg69	c>P#0k>a#>5Z6dB)߼>e؋XNw_#>w3r>ٯWkv
U55>k#&x|{L¨;>>i[ԝt
>fز۾n"׾xZ'Dz>oTJ>dw7>sd0a|>04
FO\mvz>-yB>^:ܑ8>\Fy^rP>ߓSczm9F>"wx@{>B>$(MByG
зYٚ>7̊nCb>^!R>i6R>K+n $>lm~w>8|#qC!>A
oWU+>MƞZ>uiqxblgȤ>z6y>a:ݶ?>v2I7PҮ>18xdh>7_>ꤡbb>rD>?gZAg}?>rxLr>Q
꾅^~5M><|J<4>eK@m>9Zo۾?
8p>9A<(>Sw2>!2/X>[#ˑ>`r
>?ԯؾ>?@'ƫTD%j`>}ྡBp[>6wMҺqdQ>]>=^OFE>/kG>xT4ejN>P⭾.l=1>z>0ޜ?j'mT>lK>l&I
	>>m&{w꾠nkk_>ٹK`v>4{_,>Fr=>Sm˱%zV5
>׾%]}>bM>pin>h?gXH>Qd-^E^>=+Nvz7Yb>jɾFάȍ?^-:>/t\V>)FjSNDь+>h;yXAb>@2%>xD6K8>_;kҲ%
r>uS!>xݾ	!>yyZӚ?nœ[5>_K[W>ƾ}]>{1jq+>UЅ>ZIϾ“!8>0оj
wl>w>"U߾{x{B>CKDegPM>@/?-)4> -g#U$k@W>_8H#9>td~!5bd>݅4Kx9:>AT>wFپQq>v}CV9>r׷l>F
A}->6u?5DenkC.g>/۔>Jyݚ5)/Ic>/%:o2>^P>[ӓ=y^>fFښ0T(/>Pyb>[2eE{>Qss>/rd>A0u Cc?>*7]X~u~>Q]h%XrE>˴)rqaQͺªG;P>KCᾗl0>&uf>vyz2]p>-Ȅ>p}>@]*6gl>NN+r[)7sp`y>6tw]%þ-b*>	31bXWX>!i,:>YAľw.`>f澔3c>}L@>a^(>cs>R}/wU0Y>.LUAe>Y_F>څc]2Ѿ{9>jmK)>EAVh`E#"|h>%]>۾r`Xv>s=,6H'>ɑ$f,z`ߘ>nPA9>r)w)Z>SJfh޳>KվRٟ>{jӮu
@'=o>k:>6>UtaHq>k z>{}q>J!]!*>`&1e>g2:>;a:.>#EE>7DܾGZxfi>2ۭ>'Իi`ڃ-n>7sFBn*c9>>ȭzS>q}QF4A>RYlbH]>m܂DO>:g}9Kc>ěNV"VdTZT>kr+u0>M݁ľuU>GZH1>h>K{JPeʑtAf>+Bq>->zrd1>{))
˾,tAt>|fz
c>Ha}>43!=F?>;&۲Bt+I>-}(]>N;֓ƾbyJK뾄ܰz>v~,ɏ-r>ie}>k3iEtI)>8c'T`Y>o#r>/5ʾn:>:fo
Nɾ$^3]L}W>|ZIdVd>9x8uSA%}V] >JlC)>G=>2<=T>AB	&zkVy>w
x䌾S>>:u"2rQK>T Wt>9`7?ZQ_{RhT?iBg{fik4?{
1w?hF-PF,g[Ml4m?b] k%jӽ?G)_BV?851Pgc?R{¿G8eH?ceg?<pS@&,F+]Y?Cz8K!z2aBn.c?9.}i=,?4ڡ<09Q'c?4>?흿3}/UQ?#:?})oRF]?0TH(3?	3"G?y,-]'2n?'xDZp$🾬T?Iտ$;?	w+l>~6?/JxZ$Ck?,V?.=gD0u>?h9m0`>uevck>2;a3;?
`,>ـNע>#Km(>?_W?u?r+6>&'Ff?S}"MZZ[?/f¿[љ>f%o#)>U4f׾t?)d̾&>)nk؅>>9ƚI>pUp/,&g>PXԾhĉ9I>_O鿐
ߑ>srejd(ǁ>(>E*f>ί,aw$3ѓ>z>ާ-u+Pv>hh6߅NX>	9FW<>dؔ&g[ܛ>*Ոߐ⼹J(1r">\˾#	N>Wb#Ѹ䚢a@>12 5>VMG>#5/c>x>١X>'H(*Qȸyhİ7>u#oϾ?J;>Q᷿}ۤLU9W9>zTAP?%>B.>zپ+R>ƥUy>U>k~?>A#2}>aЌ4!uv)>ȧ.Fjˆ2kG>odؾ˄)`9>,J]".U,(>$>lۖ7뫾ڼ9	><5O>ۋ><ҕ(;"64>RDH>qy23	.#O>~>h3WH
>51Oa>[q^!y?FRv>ΐ޳UA()>΄0ׂ>8kSP=1>T׾`?>i;ū>1;;+>ܗRFоms6]R>C#O!Y,>겎?ńc;ɳ(DE>ٻ/eڤ߼^s>Σ,[>[4#H2>ڛvˈ`к!'>^>%nfR>(+cx΢pԾ$5HY>ГOOtY
>Gk)(v]˾Aei>Ԏ2yQ'mf>MGSP3xv̛
9q>6vC"h>ZNk>2DnXYnm>Օ@'|H2>-5>Ȍv`̾JG[>Wk'uܾKg[Ǝ-p>Yx2ADe >HHFΣa1S\>҅L^V'9DcD>‘㜬>A5Dd%#|>һR?x̣[s>gH%>x޾>k56|/Ln)>6Vn?/>x[:J;1{Y>{D(K@=H>bٝ.>ː ƽ/S#>5< ׾)c螝>,CKF>70>LÓNo5mlob>0)ľ%>[*Jl?&xBc>]	6e1\m
>äPn'_
qg>.zҾɃy
>$~>_:itV>˜YBlÜ$~]>hS
>>2r-В#>ȥl2r澸dV)[$>ıu>tWЀ>|SVQkU>>T8eU>>MKh—o67S>ȗfsHߞ>;,>\[
K->@u3oVOu->#uu&!
UU>{gxM羲p^X>H1>jm>}5¯Uv~J>{GO>;hP›E/X>i|@6>g1
F>)^{*xeE>NZ?oM⾨d>{RhM9>aXk,y徶/P>M|d>r>|XǾ2H>.Axtn>tr	>ѩ7k|e>kԌ$CӤWd#W>#`C?1> aNO$'*Q>A=Ҿu*+>ZuG>R!ho>YRBU(6>=+_.>	X
8`>e{9)ͤM$6>Уq+A>MX-	 8>y)>f>:ÆY
>EIH\߾b>’>7=?zy>+~؎E>{ql>iʾOz"S>%\Q>#F&bB>0T?ck)kٷ6n>GQSWV>V>-OA/~>/Hɻf,	>>iZ>]vѾA4>"p.4`0LӠ>uGW=_Lkk>"/on!>-x?>n%"0Cm>o:$5G>*x1>IJ>w8/d>![bK%]	J>>xWYvfTvN>lE<Ծtm>M>.پpp$`&콫N>3PjAlD>7H>O	C;HX|>:(LuY>'E>`6:_>N&8]Ծwan >߾g{Ú>ہ5V#^Hľ8ܝ^>2jb>|ը>,ݾ#˲H>
^>60>fc5>Oer`鍟}>NIGeƭH>**ꌾjzʓ38o!>$Vѽ&0&>j[>`/:inB>n2ƾ2t.><˟ϘP>l:\qmPYy>_TF?7>fFg>S~D澲̈́>&p	׫>Ns ӘH
>ꏘX}i]Gk>'	vl>`>ě$qNe><߉Z0a!>/l>>q&4zR[>ۗs9BsbE>rRܾ5>JJkleH#>qgs7S>w>>xI3oE>񻪞F_"Y2>Ũ>}:/%2$>RsؾT\9.L*>!)?q
r>O;@\hlMN|Ž[.>0
MD>j_
bMv[>lUZt
>nTE>?o@ʂ;>'ߧ*	>xGD7>EW
uվ%E4nҒVFw [>61ퟩ7IUI>91sFX>O9>tx/>P޵I@^&>j]-"d>Jrj>€1_!hsV]gx>XG>̝TNڎ'>FN:HXJ-L4>RTw>QsL|s>-E9>4$^>ew:>ST$}>c&yUL>%`T,>H^jY1;o^>9NB:Fz>ֳw;wGjjsp>zDEf{&>:k
>i`Α[>Ĵ2i}Xu>>>k𾧋W>Ϻځ].c,+{B>O(ؾy;)*>29$B߾[4c꾕M}ZDn>>w:Oj[>O5h>kpW7>j0ᾤ5M<>F>ͼ?]ă>I?-oMv鸾$O>Kl`>qhAj0ds꾌M|Id>2Z	>|bg69	c>P#0k>a#>5Z6dB)߼>e؋XNw_#>w3r>ٯWkv
U55>k#&x|{L¨;>>i[ԝt
>fز۾n"׾xZ'Dz>oTJ>dw7>sd0a|>04
FO\mvz>-yB>^:ܑ8>\Fy^rP>ߓSczm9F>"wx@{>B>$(MByG
зYٚ>7̊nCb>^!R>i6R>K+n $>lm~w>8|#qC!>A
oWU+>MƞZ>uiqxblgȤ>z6y>a:ݶ?>v2I7PҮ>18xdh>7_>ꤡbb>rD>?gZAg}?>rxLr>Q
꾅^~5M><|J<4>eK@m>9Zo۾?
8p>9A<(>Sw2>!2/X>[#ˑ>`r
>?ԯؾ>?@'ƫTD%j`>}ྡBp[>6wMҺqdQ>]>=^OFE>/kG>xT4ejN>P⭾.l=1>z>0ޜ?j'mT>lK>l&I
	>>m&{w꾠nkk_>ٹK`v>4{_,>Fr=>Sm˱%zV5
>׾%]}>bM>pin>h?gXH>Qd-^E^>=+Nvz7Yb>jɾFάȍ?^-:>/t\V>)FjSNDь+>h;yXAb>@2%>xD6K8>_;kҲ%
r>uS!>xݾ	!>yyZӚ?nœ[5>_K[W>ƾ}]>{1jq+>UЅ>ZIϾ“!8>0оj
wl>w>"U߾{x{B>CKDegPM>@/?-)4> -g#U$k@W>_8H#9>td~!5bd>݅4Kx9:>AT>wFپQq>v}CV9>r׷l>F
A}->6u?5DenkC.g>/۔>Jyݚ5)/Ic>/%:o2>^P>[ӓ=y^>fFښ0T(/>Pyb>[2eE{>Qss>/rd>A0u Cc?>*7]X~u~>Q]h%XrE>˴)rqaQͺªG;P>KCᾗl0>&uf>vyz2]p>-Ȅ>p}>@]*6gl>NN+r[)7sp`y>6tw]%þ-b*>	31bXWX>!i,:>YAľw.`>f澔3c>}L@>a^(>cs>R}/wU0Y>.LUAe>Y_F>څc]2Ѿ{9>jmK)>EAVh`E#"|h>%]>۾r`Xv>s=,6H'>ɑ$f,z`ߘ>nPA9>r)w)Z>SJfh޳>KվRٟ>{jӮu
@'=o>k:>6>UtaHq>k z>{}q>J!]!*>`&1e>g2:>;a:.>#EE>7DܾGZxfi>2ۭ>'Իi`ڃ-n>7sFBn*c9>>ȭzS>q}QF4A>RYlbH]>m܂DO>:g}9Kc>ěNV"VdTZT>kr+u0>M݁ľuU>GZH1>h>K{JPeʑtAf>+Bq>->zrd1>{))
˾,tAt>|fz
c>Ha}>43!=F?>;&۲Bt+I>-}(]>N;֓ƾbyJK뾄ܰz>v~,ɏ-r>ie}>k3iEtI)>8c'T`Y>o#r>/5ʾn:>:fo
Nɾ$^3]L}W>|ZIdVd>9x8uSA%}V] >JlC)>G=>2<=T>AB	&zkVy>w
x䌾S>>:u"2rQK>T Wt>9`7Q6U>f(޾pnsm>)	ʔ>Mex&PʼK2>Q8ᾐJ->Z	>eniybz>p^Tr)7>p
_>~G
|Cn>UGuEQT]>#W	KtW]v>ф	d~vRBuxzl">XC>Lj8[;>ä!|9_I>{;wO>r/ľ>*KCTX>]h>hM8po>/߭voi`lMk>àǟ>>Ӿi:|6p*?c>mrgD>4G>[!^%v&@>]H`k![>rJ87G>y*lywd>ֱdS㾄6X®1עp->	"a(!v>#`gw[dt+}D>3{
%ʢKR>XqR!kqP(X>ן)^*>|;u>l^J,M$>jKP>	>cN#*>GY701>G/1ξA faV>99۸>VbKny

MVz:&J0>[7]Җ?E>FɍFK>HRGo?I2>3կ3>t:,_>tt	;>~f9"Yo>CS
W>*$n_.7DK[>s,x$N.n5h>5	%xbʁ>ڙ _^mT8Jo>rܾ@J^L>}NJ/>c/'g+h>N-μsK:w>i$d>z3H>{1*>ͼZ(+Q:WE>.&mr{ݢ>F^AaqćPlFtʬ->[۾)W>~?j-1S>_Gu86G>ve0h)>oipF MљJ>RIJ:	+Ӣ'>XmƔ>~(ǂn]h;>zj(CzlMd`u.j>[
)v>Oqf;=Ⱦy)u>k"n"_-G>~J2>TOۢlN0.96>3F>n腾6>o
t>ty^'rV>d/+:'u7>!iWk;>^)tr^lo[|6m>I7ܚs>ʇt
YT,T`}Е0>lV⾈l!s>x}4>e(&ntxp;>P4M>cy|>y@1%ɾ9٠>a\|hqV+*#$>NUi>g3Tm't,fR>X.[	.	>*~>gѾnM>ZaZt>sS?>nR
BmTN>3T꾁$<>Qi[7>|}J-x/$҆h> M:w-	eYdZZ<>SP%3+<>9FBbS$~vžwa>⟳/I>{l>Ut<>%kK'n>kr&e̿>sF-y>I&"E~!B#>Ewv){>Bxqrm
Q2>4,ʮN6Z>փGT~PN!K{
(T>UÈ>v@[>cvU
	>C+4BgG>ay>vi{/[}_>|ھyb*ZxmSȺOj>yNxZU(EV>^'̾j"`crnF>1*5ǯ>}FՔ>J?}">@N>q}0
>jln dą>)Fa)R^#>Q{2p>yfޢ":Ш֦>>vL`uoyaZ> ԰hc>|ߨ{#aм4neu\(g>	߾bi>y>PHAn@aS}>1loπ>jn3~ڀ>piwԕyQ1>At}Ծ|_*2ގ>@B>{w߾;3?>W?gdqJjh_gS)>/-A6>N_+~SOBӾw
z>}-VD>uS>^u5l>hŪ㾀슶Á>bj>sc_`X־!Ȇ>zr1xITH-`[>}Vmξ=A>nrjS=n`>X;`<
EI>{&S5|fyh>q_y徂)ޱ>qhf'>eO~\߾yq>*~>Vq=Z>u#'ZL3>q~fU>}TcCG)q{u >yvڋvԾ6>xo9F><+>{"T.>rվ{9>k,>jv3p>ݾ{s.!
>D_dp>wh|]q'>@Δq=]UaÅU">)6>~no[:=s|Nޮ$>s
"9˰>uLp>RG\Jվ|L;>O)S6>eȱi=>nVU0 >EPpx~UZ'f1e>x@
h$6>,u%mWfp
xF>`¾/@>{U(n{POCu>KMﾁPV>rex>[8FJT#} >{[}ʩt->`-XV{>q4TﾁT=#>5_tUupE p>ywpԻ>P04vhuCaRjT"m@>+ʋn$>x)
Hs
>ox;->bDSg}s>k?W{aE!>VY+>r7-|a>N
5Ls.G=>ƾSuBJ>zT-uK>}[F&cی~m=`H>0Hz8/%m>vR?>&Z%Іxw\/ueuھx.>j6Yk>e쥟}OS>.yeE|>Kz3#J>s0N8>l^g*pۡLƾZZK>{(P0*ʾϖ+>{HYb]npk8HprԿW>`|(2>t	e>DíB))x t>PXB"}]6>fUэ>hgρ1~p5>+IswPV>7gO9b>tO0>"˾mG0kr`rb>{po<5`>yfעU^qK0>-!™&^>r誥>Pˤ5Dx=>'>B{o3Y>bR:/>j7c}9"?>w4u3켾7k]>uXKyVjFD_>}uiu'bp7}>{GcOu)8>wʉ<{N$291q5=>u_j>~M-S>pGp>V)/8-
x2>msI}z[:>^Z͏e>l,'}O:>saH9B>7>udmE%xX>{ʾf~?e^Y
>{wLrx>v' ̾Brzi>~D}kh->mZF>Z3xz_>	>Axb:/>XD>mF4t#}Le>~iξqַpuEEڊ; b>vipƾZf \mo>zW;czefݟ>{D+AGR~%)ܒ>t9N홾2[:==rS
Fp>~RU|~e>jb>]Ѧx4wc>~Uw*k:>SɁR/$>n.}|8CV>}=˾p{䥾MG;>v8(d~
    yB鸝?a8-o`g!/>z*=i}cr>sarܾǔ!þsR>}^ξz0M6>h)Q xl>`QFnxg>~Gu	u@i>Omm>o&m|Ua>|%n7rnĚm̾Q.>vT}ĔҠ>xy&^iKB6IhSIK>z]5|R>r>$G4>"6O#=sc!>|+\yվ`>f&Fzp>a?TxfH>}-?PthB~O>I@dy>oN)ؾ{7>{"}Ml(1SDN>uߟO|'>w
ʹG['ܮb2hU2>zs%^{OO>qE^AF">2Qsn+.E>|Miϲxګ1]>d{>aӆ4xP0>|Tl̆sr>DhXy7J>o)Ub@{*?b>z6x	j1FTDkm>uqG7|4v)>v$a KX,iil>y`0{n>pvB>8MEqrhE_>{9R\w>c8wyR]>bJe{w$F>{ENsw>@9|SC>oAqTzSH>ya?Si1ixU5ǽ8>u7)/{tk4>u]zEVB
x-h5:i>y::zPhI>ot|>z0+w87[e>bC Yn>b	4L7w3~7>zL3Mrp:^$>=@}>oCbĢy>xpy	hþUˬ5>tW?ztb3UľhlH>xj+K_KyOz>n*\N>=S.vr*[>z7p&v3@ѓ>avZ>aZԖپv.>zT}:q{J><>9rB>nG)UZy9^AU!>w	2hDUP%>t;gu.z	-#z>t+[kU<ؾg>wZ/AxtPw>mrf2y>;;wȲqe>yqp=v)>aJ髏>a!nϕ7uq;e>yf#5ƾqjɢT><5>mW`N@xU%>wiNpg=+ۊTH>s$!y_X&Z!>s:S2aU'CIgd>wݏi签xWhQ>m\w>8vmоqsB->xҲCurk>a9>l#>`Mz&Ou;@>xGq<
cׅ>?
cF$>l4UϨw۞K>vl8gsK*߾RUgV>rq%x+>sjVξUcvf߾eA#J>vf+'w?>m͔ '>21wiؾpZUVj>x.Levu-̀>amT'>^}pȪ"tgW>x4%Dq5/>Bx
}1>j3w'4>v|,g:@"ӾP`O>r;&x4}t^>s.pV"܏dc4>ukQwQ.|>m#h(>&%o7@
>w4t>aZ;>[s5>w:〦xpKؓ>EjI>icXMvlN^>veO>gbLupv>qoQjw|kzu>sʓXY>m^۾cN>tljv>mE8Cu%=4:j'm홼>v+2Htl>bk:{>XzrEyw>w`5N4pBCe>JQDa>g먗5u#>uˉCGS:h_C/K;FnP>pv;&>rBX+ZQ$Zkag-uB>tҸawvs/B[>my"x^Fk	^>v4tw>d>c^&/*p>UK%>r	=,8>v*ΞVqݠ*o>OY>e~t9t>u<Ͼi^3>@
>oB12v>Q>r=ѐ\U_@?>s1Y.ƌvz8*>nI+5Bi~>uc 2tR3@>dd2d׉>QѲRtq|F:>vKߴmq5}
>R
@i>c75tEW>u;d/ic1jې?>m9} uK>rUn_apt\Z>rC=ߡuB0>nZdB*>_g(҄6>to߼FVt2($>eH|.>>KXB)s"p0>uTqdQȴ>V
rܷ>aľs(w[3>tL^pjFh.pTI>kGo"~t6>>ra/BV`B){c>qB[mu7iƒ>oo/I?	)eVەW">s>j`xtjw>fAlXC?>BV6m*>t-dq^*>Y!>^ezr3P7>tkBh'kNAٖ>0`#>hrt+S	>s0bQ$
>p.Duut
;#>phggRQYךb-;B ^>r撲̾ǾsIl>h>S$Xr>1W`kP%>tRJ/q叇>]Ӏy/>Y=q*e p>t]a;mPQ>Ai
y`>ff#s^Ngon>sPdBbH
<>nDcEtA~V>pze1:Uqyés兜>iy	PG}hg>sdоrޮm>`.9
>Sz
p
w;[>sIn^{>K~HV>c`פr{c>s)fJ\e;_dV>kAse>ph8~Z*X`JZд$c>pgsz>k$	.8K`Ff>^u>r֙Ii[r+"'>b+>K˜.mb\I>s8\o3h1>R88>`re@eqK̯>rfhfEpxi'>hĽ+s=A>q/?Mm^:8ETa9>odv`sE1\||>l/qGj-$cI_q>q3nrF9
O>d_w>>X׏+jMHޗ>s2~psv>X:Ze;S>Z)
Ypf~0>ryNis)>4y:s'>e@?r;T)>qtȾa L:=>lEfvrq>m7:dhQX`P]s|d>p>_s,rKsB>g/j	>EٻhF>r]0+_p2C>];_>T		9oRnZe#vQ6U>f(޾pnsm>)	ʔ>Mex&PʼK2>Q8ᾐJ->Z	>eniybz>p^Tr)7>p
_>~G
|Cn>UGuEQT]>#W	KtW]v>ф	d~vRBuxzl">XC>Lj8[;>ä!|9_I>{;wO>r/ľ>*KCTX>]h>hM8po>/߭voi`lMk>àǟ>>Ӿi:|6p*?c>mrgD>4G>[!^%v&@>]H`k![>rJ87G>y*lywd>ֱdS㾄6X®1עp->	"a(!v>#`gw[dt+}D>3{
%ʢKR>XqR!kqP(X>ן)^*>|;u>l^J,M$>jKP>	>cN#*>GY701>G/1ξA faV>99۸>VbKny

MVz:&J0>[7]Җ?E>FɍFK>HRGo?I2>3կ3>t:,_>tt	;>~f9"Yo>CS
W>*$n_.7DK[>s,x$N.n5h>5	%xbʁ>ڙ _^mT8Jo>rܾ@J^L>}NJ/>c/'g+h>N-μsK:w>i$d>z3H>{1*>ͼZ(+Q:WE>.&mr{ݢ>F^AaqćPlFtʬ->[۾)W>~?j-1S>_Gu86G>ve0h)>oipF MљJ>RIJ:	+Ӣ'>XmƔ>~(ǂn]h;>zj(CzlMd`u.j>[
)v>Oqf;=Ⱦy)u>k"n"_-G>~J2>TOۢlN0.96>3F>n腾6>o
t>ty^'rV>d/+:'u7>!iWk;>^)tr^lo[|6m>I7ܚs>ʇt
YT,T`}Е0>lV⾈l!s>x}4>e(&ntxp;>P4M>cy|>y@1%ɾ9٠>a\|hqV+*#$>NUi>g3Tm't,fR>X.[	.	>*~>gѾnM>ZaZt>sS?>nR
BmTN>3T꾁$<>Qi[7>|}J-x/$҆h> M:w-	eYdZZ<>SP%3+<>9FBbS$~vžwa>⟳/I>{l>Ut<>%kK'n>kr&e̿>sF-y>I&"E~!B#>Ewv){>Bxqrm
Q2>4,ʮN6Z>փGT~PN!K{
(T>UÈ>v@[>cvU
	>C+4BgG>ay>vi{/[}_>|ھyb*ZxmSȺOj>yNxZU(EV>^'̾j"`crnF>1*5ǯ>}FՔ>J?}">@N>q}0
>jln dą>)Fa)R^#>Q{2p>yfޢ":Ш֦>>vL`uoyaZ> ԰hc>|ߨ{#aм4neu\(g>	߾bi>y>PHAn@aS}>1loπ>jn3~ڀ>piwԕyQ1>At}Ծ|_*2ގ>@B>{w߾;3?>W?gdqJjh_gS)>/-A6>N_+~SOBӾw
z>}-VD>uS>^u5l>hŪ㾀슶Á>bj>sc_`X־!Ȇ>zr1xITH-`[>}Vmξ=A>nrjS=n`>X;`<
EI>{&S5|fyh>q_y徂)ޱ>qhf'>eO~\߾yq>*~>Vq=Z>u#'ZL3>q~fU>}TcCG)q{u >yvڋvԾ6>xo9F><+>{"T.>rվ{9>k,>jv3p>ݾ{s.!
>D_dp>wh|]q'>@Δq=]UaÅU">)6>~no[:=s|Nޮ$>s
"9˰>uLp>RG\Jվ|L;>O)S6>eȱi=>nVU0 >EPpx~UZ'f1e>x@
h$6>,u%mWfp
xF>`¾/@>{U(n{POCu>KMﾁPV>rex>[8FJT#} >{[}ʩt->`-XV{>q4TﾁT=#>5_tUupE p>ywpԻ>P04vhuCaRjT"m@>+ʋn$>x)
Hs
>ox;->bDSg}s>k?W{aE!>VY+>r7-|a>N
5Ls.G=>ƾSuBJ>zT-uK>}[F&cی~m=`H>0Hz8/%m>vR?>&Z%Іxw\/ueuھx.>j6Yk>e쥟}OS>.yeE|>Kz3#J>s0N8>l^g*pۡLƾZZK>{(P0*ʾϖ+>{HYb]npk8HprԿW>`|(2>t	e>DíB))x t>PXB"}]6>fUэ>hgρ1~p5>+IswPV>7gO9b>tO0>"˾mG0kr`rb>{po<5`>yfעU^qK0>-!™&^>r誥>Pˤ5Dx=>'>B{o3Y>bR:/>j7c}9"?>w4u3켾7k]>uXKyVjFD_>}uiu'bp7}>{GcOu)8>wʉ<{N$291q5=>u_j>~M-S>pGp>V)/8-
x2>msI}z[:>^Z͏e>l,'}O:>saH9B>7>udmE%xX>{ʾf~?e^Y
>{wLrx>v' ̾Brzi>~D}kh->mZF>Z3xz_>	>Axb:/>XD>mF4t#}Le>~iξqַpuEEڊ; b>vipƾZf \mo>zW;czefݟ>{D+AGR~%)ܒ>t9N홾2[:==rS
Fp>~RU|~e>jb>]Ѧx4wc>~Uw*k:>SɁR/$>n.}|8CV>}=˾p{䥾MG;>v8(d~
    yB鸝?a8-o`g!/>z*=i}cr>sarܾǔ!þsR>}^ξz0M6>h)Q xl>`QFnxg>~Gu	u@i>Omm>o&m|Ua>|%n7rnĚm̾Q.>vT}ĔҠ>xy&^iKB6IhSIK>z]5|R>r>$G4>"6O#=sc!>|+\yվ`>f&Fzp>a?TxfH>}-?PthB~O>I@dy>oN)ؾ{7>{"}Ml(1SDN>uߟO|'>w
ʹG['ܮb2hU2>zs%^{OO>qE^AF">2Qsn+.E>|Miϲxګ1]>d{>aӆ4xP0>|Tl̆sr>DhXy7J>o)Ub@{*?b>z6x	j1FTDkm>uqG7|4v)>v$a KX,iil>y`0{n>pvB>8MEqrhE_>{9R\w>c8wyR]>bJe{w$F>{ENsw>@9|SC>oAqTzSH>ya?Si1ixU5ǽ8>u7)/{tk4>u]zEVB
x-h5:i>y::zPhI>ot|>z0+w87[e>bC Yn>b	4L7w3~7>zL3Mrp:^$>=@}>oCbĢy>xpy	hþUˬ5>tW?ztb3UľhlH>xj+K_KyOz>n*\N>=S.vr*[>z7p&v3@ѓ>avZ>aZԖپv.>zT}:q{J><>9rB>nG)UZy9^AU!>w	2hDUP%>t;gu.z	-#z>t+[kU<ؾg>wZ/AxtPw>mrf2y>;;wȲqe>yqp=v)>aJ髏>a!nϕ7uq;e>yf#5ƾqjɢT><5>mW`N@xU%>wiNpg=+ۊTH>s$!y_X&Z!>s:S2aU'CIgd>wݏi签xWhQ>m\w>8vmоqsB->xҲCurk>a9>l#>`Mz&Ou;@>xGq<
cׅ>?
cF$>l4UϨw۞K>vl8gsK*߾RUgV>rq%x+>sjVξUcvf߾eA#J>vf+'w?>m͔ '>21wiؾpZUVj>x.Levu-̀>amT'>^}pȪ"tgW>x4%Dq5/>Bx
}1>j3w'4>v|,g:@"ӾP`O>r;&x4}t^>s.pV"܏dc4>ukQwQ.|>m#h(>&%o7@
>w4t>aZ;>[s5>w:〦xpKؓ>EjI>icXMvlN^>veO>gbLupv>qoQjw|kzu>sʓXY>m^۾cN>tljv>mE8Cu%=4:j'm홼>v+2Htl>bk:{>XzrEyw>w`5N4pBCe>JQDa>g먗5u#>uˉCGS:h_C/K;FnP>pv;&>rBX+ZQ$Zkag-uB>tҸawvs/B[>my"x^Fk	^>v4tw>d>c^&/*p>UK%>r	=,8>v*ΞVqݠ*o>OY>e~t9t>u<Ͼi^3>@
>oB12v>Q>r=ѐ\U_@?>s1Y.ƌvz8*>nI+5Bi~>uc 2tR3@>dd2d׉>QѲRtq|F:>vKߴmq5}
>R
@i>c75tEW>u;d/ic1jې?>m9} uK>rUn_apt\Z>rC=ߡuB0>nZdB*>_g(҄6>to߼FVt2($>eH|.>>KXB)s"p0>uTqdQȴ>V
rܷ>aľs(w[3>tL^pjFh.pTI>kGo"~t6>>ra/BV`B){c>qB[mu7iƒ>oo/I?	)eVەW">s>j`xtjw>fAlXC?>BV6m*>t-dq^*>Y!>^ezr3P7>tkBh'kNAٖ>0`#>hrt+S	>s0bQ$
>p.Duut
;#>phggRQYךb-;B ^>r撲̾ǾsIl>h>S$Xr>1W`kP%>tRJ/q叇>]Ӏy/>Y=q*e p>t]a;mPQ>Ai
y`>ff#s^Ngon>sPdBbH
<>nDcEtA~V>pze1:Uqyés兜>iy	PG}hg>sdоrޮm>`.9
>Sz
p
w;[>sIn^{>K~HV>c`פr{c>s)fJ\e;_dV>kAse>ph8~Z*X`JZд$c>pgsz>k$	.8K`Ff>^u>r֙Ii[r+"'>b+>K˜.mb\I>s8\o3h1>R88>`re@eqK̯>rfhfEpxi'>hĽ+s=A>q/?Mm^:8ETa9>odv`sE1\||>l/qGj-$cI_q>q3nrF9
O>d_w>>X׏+jMHޗ>s2~psv>X:Ze;S>Z)
Ypf~0>ryNis)>4y:s'>e@?r;T)>qtȾa L:=>lEfvrq>m7:dhQX`P]s|d>p>_s,rKsB>g/j	>EٻhF>r]0+_p2C>];_>T		9oRnZe#vQ6U>f(޾pnsm>)	ʔ>Mex&PʼK2>Q8ᾐJ->Z	>eniybz>p^Tr)7>p
_>~G
|Cn>UGuEQT]>#W	KtW]v>ф	d~vRBuxzl">XC>Lj8[;>ä!|9_I>{;wO>r/ľ>*KCTX>]h>hM8po>/߭voi`lMk>àǟ>>Ӿi:|6p*?c>mrgD>4G>[!^%v&@>]H`k![>rJ87G>y*lywd>ֱdS㾄6X®1עp->	"a(!v>#`gw[dt+}D>3{
%ʢKR>XqR!kqP(X>ן)^*>|;u>l^J,M$>jKP>	>cN#*>GY701>G/1ξA faV>99۸>VbKny

MVz:&J0>[7]Җ?E>FɍFK>HRGo?I2>3կ3>t:,_>tt	;>~f9"Yo>CS
W>*$n_.7DK[>s,x$N.n5h>5	%xbʁ>ڙ _^mT8Jo>rܾ@J^L>}NJ/>c/'g+h>N-μsK:w>i$d>z3H>{1*>ͼZ(+Q:WE>.&mr{ݢ>F^AaqćPlFtʬ->[۾)W>~?j-1S>_Gu86G>ve0h)>oipF MљJ>RIJ:	+Ӣ'>XmƔ>~(ǂn]h;>zj(CzlMd`u.j>[
)v>Oqf;=Ⱦy)u>k"n"_-G>~J2>TOۢlN0.96>3F>n腾6>o
t>ty^'rV>d/+:'u7>!iWk;>^)tr^lo[|6m>I7ܚs>ʇt
YT,T`}Е0>lV⾈l!s>x}4>e(&ntxp;>P4M>cy|>y@1%ɾ9٠>a\|hqV+*#$>NUi>g3Tm't,fR>X.[	.	>*~>gѾnM>ZaZt>sS?>nR
BmTN>3T꾁$<>Qi[7>|}J-x/$҆h> M:w-	eYdZZ<>SP%3+<>9FBbS$~vžwa>⟳/I>{l>Ut<>%kK'n>kr&e̿>sF-y>I&"E~!B#>Ewv){>Bxqrm
Q2>4,ʮN6Z>փGT~PN!K{
(T>UÈ>v@[>cvU
	>C+4BgG>ay>vi{/[}_>|ھyb*ZxmSȺOj>yNxZU(EV>^'̾j"`crnF>1*5ǯ>}FՔ>J?}">@N>q}0
>jln dą>)Fa)R^#>Q{2p>yfޢ":Ш֦>>vL`uoyaZ> ԰hc>|ߨ{#aм4neu\(g>	߾bi>y>PHAn@aS}>1loπ>jn3~ڀ>piwԕyQ1>At}Ծ|_*2ގ>@B>{w߾;3?>W?gdqJjh_gS)>/-A6>N_+~SOBӾw
z>}-VD>uS>^u5l>hŪ㾀슶Á>bj>sc_`X־!Ȇ>zr1xITH-`[>}Vmξ=A>nrjS=n`>X;`<
EI>{&S5|fyh>q_y徂)ޱ>qhf'>eO~\߾yq>*~>Vq=Z>u#'ZL3>q~fU>}TcCG)q{u >yvڋvԾ6>xo9F><+>{"T.>rվ{9>k,>jv3p>ݾ{s.!
>D_dp>wh|]q'>@Δq=]UaÅU">)6>~no[:=s|Nޮ$>s
"9˰>uLp>RG\Jվ|L;>O)S6>eȱi=>nVU0 >EPpx~UZ'f1e>x@
h$6>,u%mWfp
xF>`¾/@>{U(n{POCu>KMﾁPV>rex>[8FJT#} >{[}ʩt->`-XV{>q4TﾁT=#>5_tUupE p>ywpԻ>P04vhuCaRjT"m@>+ʋn$>x)
Hs
>ox;->bDSg}s>k?W{aE!>VY+>r7-|a>N
5Ls.G=>ƾSuBJ>zT-uK>}[F&cی~m=`H>0Hz8/%m>vR?>&Z%Іxw\/ueuھx.>j6Yk>e쥟}OS>.yeE|>Kz3#J>s0N8>l^g*pۡLƾZZK>{(P0*ʾϖ+>{HYb]npk8HprԿW>`|(2>t	e>DíB))x t>PXB"}]6>fUэ>hgρ1~p5>+IswPV>7gO9b>tO0>"˾mG0kr`rb>{po<5`>yfעU^qK0>-!™&^>r誥>Pˤ5Dx=>'>B{o3Y>bR:/>j7c}9"?>w4u3켾7k]>uXKyVjFD_>}uiu'bp7}>{GcOu)8>wʉ<{N$291q5=>u_j>~M-S>pGp>V)/8-
x2>msI}z[:>^Z͏e>l,'}O:>saH9B>7>udmE%xX>{ʾf~?e^Y
>{wLrx>v' ̾Brzi>~D}kh->mZF>Z3xz_>	>Axb:/>XD>mF4t#}Le>~iξqַpuEEڊ; b>vipƾZf \mo>zW;czefݟ>{D+AGR~%)ܒ>t9N홾2[:==rS
Fp>~RU|~e>jb>]Ѧx4wc>~Uw*k:>SɁR/$>n.}|8CV>}=˾p{䥾MG;>v8(d~
    yB鸝?a8-o`g!/>z*=i}cr>sarܾǔ!þsR>}^ξz0M6>h)Q xl>`QFnxg>~Gu	u@i>Omm>o&m|Ua>|%n7rnĚm̾Q.>vT}ĔҠ>xy&^iKB6IhSIK>z]5|R>r>$G4>"6O#=sc!>|+\yվ`>f&Fzp>a?TxfH>}-?PthB~O>I@dy>oN)ؾ{7>{"}Ml(1SDN>uߟO|'>w
ʹG['ܮb2hU2>zs%^{OO>qE^AF">2Qsn+.E>|Miϲxګ1]>d{>aӆ4xP0>|Tl̆sr>DhXy7J>o)Ub@{*?b>z6x	j1FTDkm>uqG7|4v)>v$a KX,iil>y`0{n>pvB>8MEqrhE_>{9R\w>c8wyR]>bJe{w$F>{ENsw>@9|SC>oAqTzSH>ya?Si1ixU5ǽ8>u7)/{tk4>u]zEVB
x-h5:i>y::zPhI>ot|>z0+w87[e>bC Yn>b	4L7w3~7>zL3Mrp:^$>=@}>oCbĢy>xpy	hþUˬ5>tW?ztb3UľhlH>xj+K_KyOz>n*\N>=S.vr*[>z7p&v3@ѓ>avZ>aZԖپv.>zT}:q{J><>9rB>nG)UZy9^AU!>w	2hDUP%>t;gu.z	-#z>t+[kU<ؾg>wZ/AxtPw>mrf2y>;;wȲqe>yqp=v)>aJ髏>a!nϕ7uq;e>yf#5ƾqjɢT><5>mW`N@xU%>wiNpg=+ۊTH>s$!y_X&Z!>s:S2aU'CIgd>wݏi签xWhQ>m\w>8vmоqsB->xҲCurk>a9>l#>`Mz&Ou;@>xGq<
cׅ>?
cF$>l4UϨw۞K>vl8gsK*߾RUgV>rq%x+>sjVξUcvf߾eA#J>vf+'w?>m͔ '>21wiؾpZUVj>x.Levu-̀>amT'>^}pȪ"tgW>x4%Dq5/>Bx
}1>j3w'4>v|,g:@"ӾP`O>r;&x4}t^>s.pV"܏dc4>ukQwQ.|>m#h(>&%o7@
>w4t>aZ;>[s5>w:〦xpKؓ>EjI>icXMvlN^>veO>gbLupv>qoQjw|kzu>sʓXY>m^۾cN>tljv>mE8Cu%=4:j'm홼>v+2Htl>bk:{>XzrEyw>w`5N4pBCe>JQDa>g먗5u#>uˉCGS:h_C/K;FnP>pv;&>rBX+ZQ$Zkag-uB>tҸawvs/B[>my"x^Fk	^>v4tw>d>c^&/*p>UK%>r	=,8>v*ΞVqݠ*o>OY>e~t9t>u<Ͼi^3>@
>oB12v>Q>r=ѐ\U_@?>s1Y.ƌvz8*>nI+5Bi~>uc 2tR3@>dd2d׉>QѲRtq|F:>vKߴmq5}
>R
@i>c75tEW>u;d/ic1jې?>m9} uK>rUn_apt\Z>rC=ߡuB0>nZdB*>_g(҄6>to߼FVt2($>eH|.>>KXB)s"p0>uTqdQȴ>V
rܷ>aľs(w[3>tL^pjFh.pTI>kGo"~t6>>ra/BV`B){c>qB[mu7iƒ>oo/I?	)eVەW">s>j`xtjw>fAlXC?>BV6m*>t-dq^*>Y!>^ezr3P7>tkBh'kNAٖ>0`#>hrt+S	>s0bQ$
>p.Duut
;#>phggRQYךb-;B ^>r撲̾ǾsIl>h>S$Xr>1W`kP%>tRJ/q叇>]Ӏy/>Y=q*e p>t]a;mPQ>Ai
y`>ff#s^Ngon>sPdBbH
<>nDcEtA~V>pze1:Uqyés兜>iy	PG}hg>sdоrޮm>`.9
>Sz
p
w;[>sIn^{>K~HV>c`פr{c>s)fJ\e;_dV>kAse>ph8~Z*X`JZд$c>pgsz>k$	.8K`Ff>^u>r֙Ii[r+"'>b+>K˜.mb\I>s8\o3h1>R88>`re@eqK̯>rfhfEpxi'>hĽ+s=A>q/?Mm^:8ETa9>odv`sE1\||>l/qGj-$cI_q>q3nrF9
O>d_w>>X׏+jMHޗ>s2~psv>X:Ze;S>Z)
Ypf~0>ryNis)>4y:s'>e@?r;T)>qtȾa L:=>lEfvrq>m7:dhQX`P]s|d>p>_s,rKsB>g/j	>EٻhF>r]0+_p2C>];_>T		9oRnZe#v>rˇ2Oپk
&L>Fo>bMqSZ2>q1!VdEtJ==z>iK5~rZw>o&28W{qY|$;>ob%r4_K>izF?G5U-ՂKbdxH^>>qrkp>a~;@*>J%"ko>r8ֿm 7>QXv>^u;pFO>qQ2>fG?>/>f?٠/qI(>pZڻ(]UdRZ>m~lq->jNHGZ~Gazn>pN{Ⱦq"tI>d,K>7>Vh}>qaQnx$.>X,0>W7˧|FnŽ2>q
/h~)oN>;c>c~Ϛpڇ4yE>p}IbaiV]E)>j,qO>l	Smxr[P>oRj3lq7p>f-^ѸeHq?y>p劵
ogI >^H៓>O%V*оkX+>qck@ׅjG@n>L$~>_ڵ.o`Bt>p	td_>dv[ni(i)>fR_vq:0ϴ>nEhYt_mASΆ>la!Yq>h6oBmWWa?>pzp0F񇛅>bS'>>bAI}h4׋h>p!f6l {>UNtW>W[km7K+H>pn>gI
Gw>3ScDaap3ɴ>o5yNdW`<eվG9
d>i\2Ji*pٛ&>k~PH[{'Ɉ>mApc<=]>e6Z?#^d>pC*z[mDW>\j->x>O7'jU&b4>piko,Q>Iocc>^z>nWb>otcc_5Ҿ*p^D>e9Fip@Cm>li+X
r;S"^n>k"Kd&pZS}>g1RFAi`Ⱦ`Ҝ>n5i7nbN9>a..P>;y\a}gnj>p-t̀kj]0>T]>VXG6ؾkǨ
/>pQfH࠽k>5/PU>bynX%x>m8#_2D: D/>g|xop 8>jwQDajY?7x@!>lGvL/dosAvj>d5k
R!ycA@>nQؾlB>\|3' 6>Jh{>o‰2hҳ!>K;>[ڎ3lxS>n&ZcG[g
>d?oKnDZ!J>kﰤ!JYXV-(PG跡^>iU';%oXǙ,>gL.Em-ľ^-ߞQ&>lrRm
>a۞'>0#<#e>n_]Ej'L >Vb%m=>RD.Ni<
=>n_sSQfPjW>?`x>`qmN>m42g`뀾;2xS>e/팾n>i&u6@SMtžU!U>j@,*lIn]0>e;4hNaHY&>m! ljv)>^kZ9>B70fq/>nV<)(sh/3>Q=/>W-zsjFȚ9>mEcR>&d~Z7>a=.7mn>kg̴S\o{!Gt>fi,7n=*>gcM04X	>jõKg>mA?f>b>e0N"bx1qr>mŞOj^ 8>Y}G'>JkIg[ĜT>mx77f)ÍX>Hĺo
>Z׿jD@C>ldAhaߠerK f>c{1l>jDʢ4WJPNpb>g+J@"mSBӐ>f'SDuf[es>j]C4l"sx>`Nh>*ë*3c,>lRi^2VYR>U">>PugVE >l$jeCՉ>AL,:>]Ujj%M>k7T`
0<3l>c9)lY>h](SB0R3u>hW(l~܀>d|֬M;aݾ^z>jr:jS5O>^xs>9w,Dþd,0>lLsѾh4~F>Rl>S28#}qh,[>l"ўc2>6
t}>^,sj֤	,>jwڔ]Ps>MҊ'p>ddVQl
8f7>gf4Y2Q	B8KT"3->h6>e.k̂>cgw1Ɨ _~sL>jG޾i]>[*k>A0Rd"k>kj	f+#>Oin>T11.ؾh3e>kY%GbĔ>)9>_3%j[-#>i}{lɘZ1)B݋U>dULk|A0K>fP֤嶾MwUy-6>h$?j[>aˁ"n[8.`#p3tg>j]pӾi\>Y}_2>D0	gd>k1ѻ+GeD)>KׯH>U,/h
$>jyaݿ{>uu
>`9Qpj(_D,>h{IͧX%tE*D}[}>d	VJ1j?Џtg>en0ξJqDaV&be>g延1sjBi>a':+U$`=>i_EphGh1>X؊a>E<쵭d{%F>j'͛(De꿼>I_x?>VC롧gkƬ>i8+``h>:V>`1QZiT>g^=WӾFYI.0>dcY,ljSB˫>d(nH¯*-V::]->g:i`>`:.`	
̛`nM>ilng9H>W)>F]E%td3O>j
,da,%js>H7D`>VgEJ	->iZf/``߉<>[n6>_i%0>ggVs
_iEQy>cFL.i¤>dQ*#u6H4Uf,>fk
iyt>`?ü-kԵ2__aO>ho)5g03g=>VA{[v>E9lRic>i{י>d*E}Z>HLor>UGBf*%^>hgC`.v@>,>^bqhzTh#>g%V]p{V⾏8cDW#	I>c_Ͼi58q>df\Kxhƭ>`,GZW+.^!*j>h>(Df܆:->WO1P>C+X>ϾchSm=t>hwT&d5>I`<>SeeU<>hk}ھ`8Zl!>B`>]U#awg"/?$>f|;LWaaHOA>b_&hM|>cvk"վJBoHS&4:bb>e/ھh:h,;>`Qq=%DjWa\mإ.>ge.f5>Wϥg1U>?*hžb$<_EHA>ha\,(dM,>K->R.e-?>hrd`w`m>+	*e>[i4hg/f>f@)!XZW<|=>a"hGC>d}e!MmRdQ]T0I>d?gޢ>`YGߤ1ޘZG>f4Bdf1>Y\'>7/
?aBz>gJ<_d,7>O7R>Od4
^uI>g}M Ѿ`t#Ԛ>6J:>YIf]nQ>f8/YXL02>`zdgzu>dI$fPȡM !>cQĕ0g>a,!;/'	mWfR@>e 6fye+Z>Z$>)hT^__2>g$YTdly >>QtT>Jh*@c>gQ/c+ay8ۦ@>@D]~c>V*:j9eh8Ay>frكa3 [_—ۖ֫9>^63dxf1b~>dJ)ʾR~FEڭ%>bitRgԢq%>a̭mC(0ˆT+)t>dĺ^fj>\-=+j\8ʍ>faJeݾd">T;L*H@>CsNUa}8>fIɾb$ޅ;>F@uLXu>RϧdHy.>f_T]>K>h;c >Zۤ+ei9#6>dRG?U8y?;vQ>`֓Ff>b
knI*ZվP{>c/UߟfORq>^춆k+TY/n9*>ete˽>WX́X>7'v`"~>fRTgb7>LShc>M}7bNyG>f8u_3>5>WAӮҒdзr>e):()X.[7,>^~V{IeSc>c5VϾPMڌ$JI>b/E0fM4>`t{.5=~~?U0vG>dRReC2:X>ZL>>&lʷ\3-ʞ>eicxB~>R*M[>E";LnaY̖>e`0 [an>C'6DCa>RVc1>eS5[S_>=5>Z}veIu21>cڧ:T2Zt|@b	>`q$ieT`>a>GPPz>bHHeX9>]%%vv(zw$prXNlP>dvd >O>VtC>6ʓ^pn>eb]?b&.>Lč>LI:aq׾b_EO>eN8\^̮>6-j$>Ueqc>dZɻW
1[(vR
>\%Yle5S>bUPRCG	t>a.Ce1K>`ME@3iEShP>cCl#SdME>Y1i=JMZsp=>d3i.jپc6"H>RU>A9e5d`.-3>et;-`W+g}>Em&s<>P6$TϾbw4Ky>dV웶[SXCD>#f$>Wc+7>ch˷ETqO.7Nǰ>^)ZIdXY>arp)J3"K~>a%Q;d|6Żi>]l]58c`UEG>cV
/ˠǾc:>WAmۥ>'!:2-[_?68>dU9V޻b>Ps#>EˆӾ5`;>d]]8_b\C>@{7>RhQbvҺw>cHY1H=M`^>Y%"-c՜UE>bm-R^2V?rB>^uBdTd>`HFkth!Ny>aYaȾd!Wb;>[n+@`\JVS$T"W.>c5[oNc/3@A>ULM¹>2_Y\]kB>da>Fk>L`g4>HW#n`NA>dQ3Ͼ]2[]>:mWQ>SKͫf+br^lJ>cTcj@Wi<}*H>Y]VcBb>a]cQ%HqAe>^U'+c5AT[>_FlpNCv=P>aV)c>ZJ?("IH+6Vg=L>bоbmS%>TNNN>5DbNL\^}O>c7`z\S>J?kk8>IMh"ꎾ`}0Y!>cp	\l>7$0h>Su>@b,#>b1VCOl=Ccd>Y׬Rc.Q]*>ae6PXXhP׾B!H>>^?ľc{]wUF!>^ҐʾBz)WP*u>a=T]׾c6$>YKo,eV\T
>b-
b&ez>S}T̟6>5R+ƹ[։>c5#`Hl>IEL\>HHH`"ZQ$>c*nߦؾ\&>6FE2q>RXľaEɑ>bs VO.?ϭ`>X`	'Ob)aR>aƵPAZ
A&>]KqcmWT>^E2NlhB̛fNh>`Ũ/bd*J>YZ_:$n#z^XUsm>b+Va@j>S2>2gP`վZm>br`/>Jk#>F}	;O_,^P>b~>[
=>9>Qk"a8>b-?fVĭ1?P^1>W[b@[>`EPՒ%=0
>\i-hPbjM>^LeDND09VK>`#.eblc\
T>Y
]-*gѾSw>aҘYpȾa'z>TOr|έ>)Oh_YB<: >bHg|`%7W>Lo~[]#>Cܫ]FWUh>bpݾ\b>l2v>?AM>PԾ`c
>aD_W1iFW>hw'>U)*m5a5(_>`K"~R\]5}̓>Z^G@G$y-ƬG[x>^8.76b')>Z7εB6k=#ؠQb>`abqa~>UIB>녾W.zC{%>a}kW`Mi[>Oi)>>?[NFr>bo"]+H)>CQ{>KQ	M_Q>a
"#XӼx0%>+e+ >SUP`nZ>a 3SR'E3>XUGaIQ2>_]8*L8Bh78>\(aN+ߥ>[#?-_ON@$xff>_ɏ3awA\>W@euSPTE-8>alf`>R B>20(̝Y9>a6Yw^1ޣ>Hhj>E:~]^$>aZ-ZiN>9ךV>PN50`r'>apHUUqaQh>`GePߺ77v,>Y/asUb.>]~4FzG}cB>Z>]
~a]=}W>Y=Ǿj4JoQ7
uX>`<`il>Tז9Vͱӏ>`žd=_KPy*>N'>;saH3\+?i>CDw>I8g5]]:m;>a'fwX;:M*>0f*>Q|j>rˇ2Oپk
&L>Fo>bMqSZ2>q1!VdEtJ==z>iK5~rZw>o&28W{qY|$;>ob%r4_K>izF?G5U-ՂKbdxH^>>qrkp>a~;@*>J%"ko>r8ֿm 7>QXv>^u;pFO>qQ2>fG?>/>f?٠/qI(>pZڻ(]UdRZ>m~lq->jNHGZ~Gazn>pN{Ⱦq"tI>d,K>7>Vh}>qaQnx$.>X,0>W7˧|FnŽ2>q
/h~)oN>;c>c~Ϛpڇ4yE>p}IbaiV]E)>j,qO>l	Smxr[P>oRj3lq7p>f-^ѸeHq?y>p劵
ogI >^H៓>O%V*оkX+>qck@ׅjG@n>L$~>_ڵ.o`Bt>p	td_>dv[ni(i)>fR_vq:0ϴ>nEhYt_mASΆ>la!Yq>h6oBmWWa?>pzp0F񇛅>bS'>>bAI}h4׋h>p!f6l {>UNtW>W[km7K+H>pn>gI
Gw>3ScDaap3ɴ>o5yNdW`<eվG9
d>i\2Ji*pٛ&>k~PH[{'Ɉ>mApc<=]>e6Z?#^d>pC*z[mDW>\j->x>O7'jU&b4>piko,Q>Iocc>^z>nWb>otcc_5Ҿ*p^D>e9Fip@Cm>li+X
r;S"^n>k"Kd&pZS}>g1RFAi`Ⱦ`Ҝ>n5i7nbN9>a..P>;y\a}gnj>p-t̀kj]0>T]>VXG6ؾkǨ
/>pQfH࠽k>5/PU>bynX%x>m8#_2D: D/>g|xop 8>jwQDajY?7x@!>lGvL/dosAvj>d5k
R!ycA@>nQؾlB>\|3' 6>Jh{>o‰2hҳ!>K;>[ڎ3lxS>n&ZcG[g
>d?oKnDZ!J>kﰤ!JYXV-(PG跡^>iU';%oXǙ,>gL.Em-ľ^-ߞQ&>lrRm
>a۞'>0#<#e>n_]Ej'L >Vb%m=>RD.Ni<
=>n_sSQfPjW>?`x>`qmN>m42g`뀾;2xS>e/팾n>i&u6@SMtžU!U>j@,*lIn]0>e;4hNaHY&>m! ljv)>^kZ9>B70fq/>nV<)(sh/3>Q=/>W-zsjFȚ9>mEcR>&d~Z7>a=.7mn>kg̴S\o{!Gt>fi,7n=*>gcM04X	>jõKg>mA?f>b>e0N"bx1qr>mŞOj^ 8>Y}G'>JkIg[ĜT>mx77f)ÍX>Hĺo
>Z׿jD@C>ldAhaߠerK f>c{1l>jDʢ4WJPNpb>g+J@"mSBӐ>f'SDuf[es>j]C4l"sx>`Nh>*ë*3c,>lRi^2VYR>U">>PugVE >l$jeCՉ>AL,:>]Ujj%M>k7T`
0<3l>c9)lY>h](SB0R3u>hW(l~܀>d|֬M;aݾ^z>jr:jS5O>^xs>9w,Dþd,0>lLsѾh4~F>Rl>S28#}qh,[>l"ўc2>6
t}>^,sj֤	,>jwڔ]Ps>MҊ'p>ddVQl
8f7>gf4Y2Q	B8KT"3->h6>e.k̂>cgw1Ɨ _~sL>jG޾i]>[*k>A0Rd"k>kj	f+#>Oin>T11.ؾh3e>kY%GbĔ>)9>_3%j[-#>i}{lɘZ1)B݋U>dULk|A0K>fP֤嶾MwUy-6>h$?j[>aˁ"n[8.`#p3tg>j]pӾi\>Y}_2>D0	gd>k1ѻ+GeD)>KׯH>U,/h
$>jyaݿ{>uu
>`9Qpj(_D,>h{IͧX%tE*D}[}>d	VJ1j?Џtg>en0ξJqDaV&be>g延1sjBi>a':+U$`=>i_EphGh1>X؊a>E<쵭d{%F>j'͛(De꿼>I_x?>VC롧gkƬ>i8+``h>:V>`1QZiT>g^=WӾFYI.0>dcY,ljSB˫>d(nH¯*-V::]->g:i`>`:.`	
̛`nM>ilng9H>W)>F]E%td3O>j
,da,%js>H7D`>VgEJ	->iZf/``߉<>[n6>_i%0>ggVs
_iEQy>cFL.i¤>dQ*#u6H4Uf,>fk
iyt>`?ü-kԵ2__aO>ho)5g03g=>VA{[v>E9lRic>i{י>d*E}Z>HLor>UGBf*%^>hgC`.v@>,>^bqhzTh#>g%V]p{V⾏8cDW#	I>c_Ͼi58q>df\Kxhƭ>`,GZW+.^!*j>h>(Df܆:->WO1P>C+X>ϾchSm=t>hwT&d5>I`<>SeeU<>hk}ھ`8Zl!>B`>]U#awg"/?$>f|;LWaaHOA>b_&hM|>cvk"վJBoHS&4:bb>e/ھh:h,;>`Qq=%DjWa\mإ.>ge.f5>Wϥg1U>?*hžb$<_EHA>ha\,(dM,>K->R.e-?>hrd`w`m>+	*e>[i4hg/f>f@)!XZW<|=>a"hGC>d}e!MmRdQ]T0I>d?gޢ>`YGߤ1ޘZG>f4Bdf1>Y\'>7/
?aBz>gJ<_d,7>O7R>Od4
^uI>g}M Ѿ`t#Ԛ>6J:>YIf]nQ>f8/YXL02>`zdgzu>dI$fPȡM !>cQĕ0g>a,!;/'	mWfR@>e 6fye+Z>Z$>)hT^__2>g$YTdly >>QtT>Jh*@c>gQ/c+ay8ۦ@>@D]~c>V*:j9eh8Ay>frكa3 [_—ۖ֫9>^63dxf1b~>dJ)ʾR~FEڭ%>bitRgԢq%>a̭mC(0ˆT+)t>dĺ^fj>\-=+j\8ʍ>faJeݾd">T;L*H@>CsNUa}8>fIɾb$ޅ;>F@uLXu>RϧdHy.>f_T]>K>h;c >Zۤ+ei9#6>dRG?U8y?;vQ>`֓Ff>b
knI*ZվP{>c/UߟfORq>^춆k+TY/n9*>ete˽>WX́X>7'v`"~>fRTgb7>LShc>M}7bNyG>f8u_3>5>WAӮҒdзr>e):()X.[7,>^~V{IeSc>c5VϾPMڌ$JI>b/E0fM4>`t{.5=~~?U0vG>dRReC2:X>ZL>>&lʷ\3-ʞ>eicxB~>R*M[>E";LnaY̖>e`0 [an>C'6DCa>RVc1>eS5[S_>=5>Z}veIu21>cڧ:T2Zt|@b	>`q$ieT`>a>GPPz>bHHeX9>]%%vv(zw$prXNlP>dvd >O>VtC>6ʓ^pn>eb]?b&.>Lč>LI:aq׾b_EO>eN8\^̮>6-j$>Ueqc>dZɻW
1[(vR
>\%Yle5S>bUPRCG	t>a.Ce1K>`ME@3iEShP>cCl#SdME>Y1i=JMZsp=>d3i.jپc6"H>RU>A9e5d`.-3>et;-`W+g}>Em&s<>P6$TϾbw4Ky>dV웶[SXCD>#f$>Wc+7>ch˷ETqO.7Nǰ>^)ZIdXY>arp)J3"K~>a%Q;d|6Żi>]l]58c`UEG>cV
/ˠǾc:>WAmۥ>'!:2-[_?68>dU9V޻b>Ps#>EˆӾ5`;>d]]8_b\C>@{7>RhQbvҺw>cHY1H=M`^>Y%"-c՜UE>bm-R^2V?rB>^uBdTd>`HFkth!Ny>aYaȾd!Wb;>[n+@`\JVS$T"W.>c5[oNc/3@A>ULM¹>2_Y\]kB>da>Fk>L`g4>HW#n`NA>dQ3Ͼ]2[]>:mWQ>SKͫf+br^lJ>cTcj@Wi<}*H>Y]VcBb>a]cQ%HqAe>^U'+c5AT[>_FlpNCv=P>aV)c>ZJ?("IH+6Vg=L>bоbmS%>TNNN>5DbNL\^}O>c7`z\S>J?kk8>IMh"ꎾ`}0Y!>cp	\l>7$0h>Su>@b,#>b1VCOl=Ccd>Y׬Rc.Q]*>ae6PXXhP׾B!H>>^?ľc{]wUF!>^ҐʾBz)WP*u>a=T]׾c6$>YKo,eV\T
>b-
b&ez>S}T̟6>5R+ƹ[։>c5#`Hl>IEL\>HHH`"ZQ$>c*nߦؾ\&>6FE2q>RXľaEɑ>bs VO.?ϭ`>X`	'Ob)aR>aƵPAZ
A&>]KqcmWT>^E2NlhB̛fNh>`Ũ/bd*J>YZ_:$n#z^XUsm>b+Va@j>S2>2gP`վZm>br`/>Jk#>F}	;O_,^P>b~>[
=>9>Qk"a8>b-?fVĭ1?P^1>W[b@[>`EPՒ%=0
>\i-hPbjM>^LeDND09VK>`#.eblc\
T>Y
]-*gѾSw>aҘYpȾa'z>TOr|έ>)Oh_YB<: >bHg|`%7W>Lo~[]#>Cܫ]FWUh>bpݾ\b>l2v>?AM>PԾ`c
>aD_W1iFW>hw'>U)*m5a5(_>`K"~R\]5}̓>Z^G@G$y-ƬG[x>^8.76b')>Z7εB6k=#ؠQb>`abqa~>UIB>녾W.zC{%>a}kW`Mi[>Oi)>>?[NFr>bo"]+H)>CQ{>KQ	M_Q>a
"#XӼx0%>+e+ >SUP`nZ>a 3SR'E3>XUGaIQ2>_]8*L8Bh78>\(aN+ߥ>[#?-_ON@$xff>_ɏ3awA\>W@euSPTE-8>alf`>R B>20(̝Y9>a6Yw^1ޣ>Hhj>E:~]^$>aZ-ZiN>9ךV>PN50`r'>apHUUqaQh>`GePߺ77v,>Y/asUb.>]~4FzG}cB>Z>]
~a]=}W>Y=Ǿj4JoQ7
uX>`<`il>Tז9Vͱӏ>`žd=_KPy*>N'>;saH3\+?i>CDw>I8g5]]:m;>a'fwX;:M*>0f*>Q|j>rˇ2Oپk
&L>Fo>bMqSZ2>q1!VdEtJ==z>iK5~rZw>o&28W{qY|$;>ob%r4_K>izF?G5U-ՂKbdxH^>>qrkp>a~;@*>J%"ko>r8ֿm 7>QXv>^u;pFO>qQ2>fG?>/>f?٠/qI(>pZڻ(]UdRZ>m~lq->jNHGZ~Gazn>pN{Ⱦq"tI>d,K>7>Vh}>qaQnx$.>X,0>W7˧|FnŽ2>q
/h~)oN>;c>c~Ϛpڇ4yE>p}IbaiV]E)>j,qO>l	Smxr[P>oRj3lq7p>f-^ѸeHq?y>p劵
ogI >^H៓>O%V*оkX+>qck@ׅjG@n>L$~>_ڵ.o`Bt>p	td_>dv[ni(i)>fR_vq:0ϴ>nEhYt_mASΆ>la!Yq>h6oBmWWa?>pzp0F񇛅>bS'>>bAI}h4׋h>p!f6l {>UNtW>W[km7K+H>pn>gI
Gw>3ScDaap3ɴ>o5yNdW`<eվG9
d>i\2Ji*pٛ&>k~PH[{'Ɉ>mApc<=]>e6Z?#^d>pC*z[mDW>\j->x>O7'jU&b4>piko,Q>Iocc>^z>nWb>otcc_5Ҿ*p^D>e9Fip@Cm>li+X
r;S"^n>k"Kd&pZS}>g1RFAi`Ⱦ`Ҝ>n5i7nbN9>a..P>;y\a}gnj>p-t̀kj]0>T]>VXG6ؾkǨ
/>pQfH࠽k>5/PU>bynX%x>m8#_2D: D/>g|xop 8>jwQDajY?7x@!>lGvL/dosAvj>d5k
R!ycA@>nQؾlB>\|3' 6>Jh{>o‰2hҳ!>K;>[ڎ3lxS>n&ZcG[g
>d?oKnDZ!J>kﰤ!JYXV-(PG跡^>iU';%oXǙ,>gL.Em-ľ^-ߞQ&>lrRm
>a۞'>0#<#e>n_]Ej'L >Vb%m=>RD.Ni<
=>n_sSQfPjW>?`x>`qmN>m42g`뀾;2xS>e/팾n>i&u6@SMtžU!U>j@,*lIn]0>e;4hNaHY&>m! ljv)>^kZ9>B70fq/>nV<)(sh/3>Q=/>W-zsjFȚ9>mEcR>&d~Z7>a=.7mn>kg̴S\o{!Gt>fi,7n=*>gcM04X	>jõKg>mA?f>b>e0N"bx1qr>mŞOj^ 8>Y}G'>JkIg[ĜT>mx77f)ÍX>Hĺo
>Z׿jD@C>ldAhaߠerK f>c{1l>jDʢ4WJPNpb>g+J@"mSBӐ>f'SDuf[es>j]C4l"sx>`Nh>*ë*3c,>lRi^2VYR>U">>PugVE >l$jeCՉ>AL,:>]Ujj%M>k7T`
0<3l>c9)lY>h](SB0R3u>hW(l~܀>d|֬M;aݾ^z>jr:jS5O>^xs>9w,Dþd,0>lLsѾh4~F>Rl>S28#}qh,[>l"ўc2>6
t}>^,sj֤	,>jwڔ]Ps>MҊ'p>ddVQl
8f7>gf4Y2Q	B8KT"3->h6>e.k̂>cgw1Ɨ _~sL>jG޾i]>[*k>A0Rd"k>kj	f+#>Oin>T11.ؾh3e>kY%GbĔ>)9>_3%j[-#>i}{lɘZ1)B݋U>dULk|A0K>fP֤嶾MwUy-6>h$?j[>aˁ"n[8.`#p3tg>j]pӾi\>Y}_2>D0	gd>k1ѻ+GeD)>KׯH>U,/h
$>jyaݿ{>uu
>`9Qpj(_D,>h{IͧX%tE*D}[}>d	VJ1j?Џtg>en0ξJqDaV&be>g延1sjBi>a':+U$`=>i_EphGh1>X؊a>E<쵭d{%F>j'͛(De꿼>I_x?>VC롧gkƬ>i8+``h>:V>`1QZiT>g^=WӾFYI.0>dcY,ljSB˫>d(nH¯*-V::]->g:i`>`:.`	
̛`nM>ilng9H>W)>F]E%td3O>j
,da,%js>H7D`>VgEJ	->iZf/``߉<>[n6>_i%0>ggVs
_iEQy>cFL.i¤>dQ*#u6H4Uf,>fk
iyt>`?ü-kԵ2__aO>ho)5g03g=>VA{[v>E9lRic>i{י>d*E}Z>HLor>UGBf*%^>hgC`.v@>,>^bqhzTh#>g%V]p{V⾏8cDW#	I>c_Ͼi58q>df\Kxhƭ>`,GZW+.^!*j>h>(Df܆:->WO1P>C+X>ϾchSm=t>hwT&d5>I`<>SeeU<>hk}ھ`8Zl!>B`>]U#awg"/?$>f|;LWaaHOA>b_&hM|>cvk"վJBoHS&4:bb>e/ھh:h,;>`Qq=%DjWa\mإ.>ge.f5>Wϥg1U>?*hžb$<_EHA>ha\,(dM,>K->R.e-?>hrd`w`m>+	*e>[i4hg/f>f@)!XZW<|=>a"hGC>d}e!MmRdQ]T0I>d?gޢ>`YGߤ1ޘZG>f4Bdf1>Y\'>7/
?aBz>gJ<_d,7>O7R>Od4
^uI>g}M Ѿ`t#Ԛ>6J:>YIf]nQ>f8/YXL02>`zdgzu>dI$fPȡM !>cQĕ0g>a,!;/'	mWfR@>e 6fye+Z>Z$>)hT^__2>g$YTdly >>QtT>Jh*@c>gQ/c+ay8ۦ@>@D]~c>V*:j9eh8Ay>frكa3 [_—ۖ֫9>^63dxf1b~>dJ)ʾR~FEڭ%>bitRgԢq%>a̭mC(0ˆT+)t>dĺ^fj>\-=+j\8ʍ>faJeݾd">T;L*H@>CsNUa}8>fIɾb$ޅ;>F@uLXu>RϧdHy.>f_T]>K>h;c >Zۤ+ei9#6>dRG?U8y?;vQ>`֓Ff>b
knI*ZվP{>c/UߟfORq>^춆k+TY/n9*>ete˽>WX́X>7'v`"~>fRTgb7>LShc>M}7bNyG>f8u_3>5>WAӮҒdзr>e):()X.[7,>^~V{IeSc>c5VϾPMڌ$JI>b/E0fM4>`t{.5=~~?U0vG>dRReC2:X>ZL>>&lʷ\3-ʞ>eicxB~>R*M[>E";LnaY̖>e`0 [an>C'6DCa>RVc1>eS5[S_>=5>Z}veIu21>cڧ:T2Zt|@b	>`q$ieT`>a>GPPz>bHHeX9>]%%vv(zw$prXNlP>dvd >O>VtC>6ʓ^pn>eb]?b&.>Lč>LI:aq׾b_EO>eN8\^̮>6-j$>Ueqc>dZɻW
1[(vR
>\%Yle5S>bUPRCG	t>a.Ce1K>`ME@3iEShP>cCl#SdME>Y1i=JMZsp=>d3i.jپc6"H>RU>A9e5d`.-3>et;-`W+g}>Em&s<>P6$TϾbw4Ky>dV웶[SXCD>#f$>Wc+7>ch˷ETqO.7Nǰ>^)ZIdXY>arp)J3"K~>a%Q;d|6Żi>]l]58c`UEG>cV
/ˠǾc:>WAmۥ>'!:2-[_?68>dU9V޻b>Ps#>EˆӾ5`;>d]]8_b\C>@{7>RhQbvҺw>cHY1H=M`^>Y%"-c՜UE>bm-R^2V?rB>^uBdTd>`HFkth!Ny>aYaȾd!Wb;>[n+@`\JVS$T"W.>c5[oNc/3@A>ULM¹>2_Y\]kB>da>Fk>L`g4>HW#n`NA>dQ3Ͼ]2[]>:mWQ>SKͫf+br^lJ>cTcj@Wi<}*H>Y]VcBb>a]cQ%HqAe>^U'+c5AT[>_FlpNCv=P>aV)c>ZJ?("IH+6Vg=L>bоbmS%>TNNN>5DbNL\^}O>c7`z\S>J?kk8>IMh"ꎾ`}0Y!>cp	\l>7$0h>Su>@b,#>b1VCOl=Ccd>Y׬Rc.Q]*>ae6PXXhP׾B!H>>^?ľc{]wUF!>^ҐʾBz)WP*u>a=T]׾c6$>YKo,eV\T
>b-
b&ez>S}T̟6>5R+ƹ[։>c5#`Hl>IEL\>HHH`"ZQ$>c*nߦؾ\&>6FE2q>RXľaEɑ>bs VO.?ϭ`>X`	'Ob)aR>aƵPAZ
A&>]KqcmWT>^E2NlhB̛fNh>`Ũ/bd*J>YZ_:$n#z^XUsm>b+Va@j>S2>2gP`վZm>br`/>Jk#>F}	;O_,^P>b~>[
=>9>Qk"a8>b-?fVĭ1?P^1>W[b@[>`EPՒ%=0
>\i-hPbjM>^LeDND09VK>`#.eblc\
T>Y
]-*gѾSw>aҘYpȾa'z>TOr|έ>)Oh_YB<: >bHg|`%7W>Lo~[]#>Cܫ]FWUh>bpݾ\b>l2v>?AM>PԾ`c
>aD_W1iFW>hw'>U)*m5a5(_>`K"~R\]5}̓>Z^G@G$y-ƬG[x>^8.76b')>Z7εB6k=#ؠQb>`abqa~>UIB>녾W.zC{%>a}kW`Mi[>Oi)>>?[NFr>bo"]+H)>CQ{>KQ	M_Q>a
"#XӼx0%>+e+ >SUP`nZ>a 3SR'E3>XUGaIQ2>_]8*L8Bh78>\(aN+ߥ>[#?-_ON@$xff>_ɏ3awA\>W@euSPTE-8>alf`>R B>20(̝Y9>a6Yw^1ޣ>Hhj>E:~]^$>aZ-ZiN>9ךV>PN50`r'>apHUUqaQh>`GePߺ77v,>Y/asUb.>]~4FzG}cB>Z>]
~a]=}W>Y=Ǿj4JoQ7
uX>`<`il>Tז9Vͱӏ>`žd=_KPy*>N'>;saH3\+?i>CDw>I8g5]]:m;>a'fwX;:M*>0f*>Q|j`k
>`l]S`"8KGSB">VG}`>6>^a$LJ>:l6[>Z9ia`U>[YT#wA✙DDiJqf>]Ѯ٣`焔>We׃)	lPRP	>`Ӊi` v>R?>$^=KV
Z>`I˾]_л>KoQO>@sXaZ`>`."Z?|>@n>K0¾]ڶ>`$r6Vҽ>%Cwq>Ry_l^>_QR53΄'Lx	>V
zD`g>]YI+'JbrZEA=>Zu`Ǝɧ>Z)>?nJLKyIi>]e`hѶ>VGv"YltSR3%l>_ـZ_Mn>Q->)cXVty>`co \'ō>Ik>AA.Zaj'Vx>`Yo;>>>KTxm50]81&>`9!UfF>"L$4>R\*\D{_>m:\>^YQSf9(S+>VX9`4>|>\BINH@8`>Z~پ`Y`5>YcGC>7YJ4Մ>\Q^Ԋ`>U5о#pdƁQϧ/m>^ԌGD춾^%E'b>QjԢ>&
ξVT#>`\x&Y>I>?EY

>`+̈́p/YxS>?%>Iǭ؜\Rr
>_ԋfUy>&b/_>Qk;^X:U>^mӔQdȾ"pzFz>UuSd_u3`e>\hMAJ.bо=t(>XXQ_>Y
E(@g`w2HaC>[v_%.>V-"+i fP7>]ZI۾^aJ(>R9	x>HžT}@T>_֘M\p(hL>Kt>:!ȴvX&bo_>_Y̪[>>BW#^Y_>FD@\Z{!B>_X	VAK>1OpE-]"uq>^P&!R3!oֿ3x>SVQɾ^>\<UM'F5 ̻.>W:P_5-u>ZRNȭD ɷMDYў>Z (_<"o>W\5ctM*	q>\a45۾^EzB>Sz0ɎپQmܾRuF->]1A\5P>NT2D>0)OV#ww[>^-/dZ}>FG#X>AƘOY -.:>^
,WU&>:PG^>J}h	!['7 >^;5'TOג0>{f6D>QF]5CX>\	7P?>;& ˀl>T߽[[^;d[V>Z"H\=Xr>WX 9^Z#R'>X\ml?DľGejfʘ>ZybG^+<-z>U@a+n|վO00*>\\
"][EPS >Q#>hSSjV`C>]ۖv
[hg2E>KT>6k[VXz&M>^)`mYq>C$sB'6N>C Y=оYGI/ϧ>^?7nVDgp>4}>D>Lh[]"6>]FUxR6>5q+o>Q_ U\ԩfN'>[F
Nj{݂-V,p>UB]E>YsFS??[C>W`˯]Ԯc>WT,6XZ-#n]^
	u'0>TOXT9&`kGOr|>[|z\G8>P>t(GGʾSI
{Uv>\%uZ>.y>JHc];>7!T:VFc>]y!FXc(\o>BM,>CZA+X>]V>8:DUBT>4@ó9>Kw}ZO>\AL5=R܏>	u͉F>QDJ<\ Ӫe>[E^N#{;hھ+ l*a>Tk5kD)\I{G>YgLcF=-Q>W ]$^i>W(=l`TtYVq'\‹T>T:lAu*W
-MP*`>[n/پ[GxP>Q
sj>	&VxRK7΢g>\)[ZQ6T>K*n>3_1/U2t^>\\&wXRf>CUo'>A5įWnFN>\U!Mg>7T0	>H
d $Y匎>\-5S%>]:[>OD1[x*>[PBOt 	~/2N>R2\g4>Y{ZعH :7F7F>U*
\qv>Wh{WYbvݾ\K0>T3z﫬JYg |Z>Y\[l>R6fjʾ<9ZPm@>[uspZq>MF>&bXSYj`ҾZ>[#ZO!Xȗe4>FX,>:QMUN!&>\TC#?bVٍx>?Ȫ'>DZ2X}Xrr>[N2K]T4"@f>0_A>KYʦ&>[#N+Q`fr=2r>P]|Zwޫ>YLL!͓*3E;7>Sr'@oi[yoI>XB76E
C;i(\K>Uܡ2,[Ĭ$>V/u7I=QDdkm>Wyɾ+[}8>SBh.JK=!G>Yq[Z6>PW˾	ZsPK>ZYr  \>K+>*WdSJ'y>[:LAAWcs>Etg+^>;}wxU߃Ss>[k)J־U=>=bq>Dsa2WjO!>[(MSc>.fqRh>Jî1PY+>ZpTlrPք=+{R>PHg5Z1L>YJօʾK?oҾ(*jG>R㟂
Z>W0AEn:p>U+([
ʈ>U
<>T=/aC$B>WDZ;
>S.l0Iapa>XsvZ9FN0>Q	x!ĤJO\3^>YND|Y,eno>LNM>$76rR?Xy>Zp^֪ZW}HN>F<#>7JCqT]×:V>Zv拘aUGe`C>@Jc:>AVkE>Zz9WiS׏cls>3i, >HHW9Wb"'>Z@̺%Qrp >sՕd>MeY(D*>Y(;M݈fTq>QYt[7[Y3>W/G)83>9n>SpپZXX: ci>V>ҾB~!>?}>U0؁ZX">TLqiT7f2vE7.[>W/+GQYR18>R
&I~`LtKHvۋ,
>Xs4e۾Y6W5>O@FMM=s	P0xT>YZ.X>>IнLM#>+v9Ŋ#Rz8CU>Y⦢9`V~c>DNP4>:¦T}\TK>Z
T`b|_><ϊ>BizV1
r>Y'RrE;>0]ȗT>H\W>YIh6IP)P>Ffc>MzTXT
>XdoL\`X%(KBp>Q5]YOv>W+T
G-\g3.Za>S''Y^>UMAD>cNy>TOqtY.	>SܩS`c7qBT߾Dτ/Z)>Vy
-YU>Q3R:(C^XT3IwCz>WEڸX7>>O&XD߃Ni弫!>X@WdOq9>JM#3>&n͘Q
Ŕ>Y:۳Vnxe>E)xXu>6Sm&SrPOUO>YYD+T2>?3}͸>@_ƔUn>YCֳ{S0?r>4>ER	-Vy8>X1OQʯ*%>"%>J(8Wr>X*JZRcMѕZƽ%{>O!~W-p;e)gI;#O)ci;ʡ>QsXӟx+{>Uh	SfGEpYn!>TjU>P@Wn
>T$XaN>RoՕ3yEցZh>V=ڐX}kK >P?!OYJwZr>WC˾WJGR>MMx:=t0vQN^>XDYV=GJ >H>(N>bQP3>XxvU9>DwX=>6H/!S
C"m>X_zT;<>>Ru/$*>@Jr[TkfL=>X"RY'Q>4DЗA>E.'UzH3>X4X燾Ph>$7[>IwMV͝T>WF
OM56Z影poC(>MӾWZA>VG˹捾IT
V$Fv҆>PARX=>Uw8DܬuҌ"3f.>R`Y9XH>TRڠ@9$eվ=;j`>Ss4XD>R'W6>CUXݓ>U7оWBp>Q!vel*bx4G3>V(ӲW}J{V>Nט"(7Ky]]`>V|xV#>Jphx>	9TfOje>WʾU̡q׊>Fy>.$oQdjQ_>Wں{T*8R_>B#摮a`>8=yRn*>Wx[2SL乜>;V->@V8zT2[&n>Wys
Qȩcq>2<`ص>D(UJt5>Wt.NKP)@>"$3G>HEV-U_>V袾LjMݥ>LVflI>V.U]HN"N&d>PyaWM4m%>U!1wD(FD2/Ⱦ>QO7YپW_x/>SNg@65:Y>R>UWG>RV@D]8YAw{8>T#w0tWep>Q3=Gf
0?f	EhI,l>U")ZWt>O6j޽X^}dޠI ՟>U𖲰Vr>KVs=Úer߾Lݭ,>V;Z큾Utm>H*''3>#"~1uO$Uf>VN Tܥo>Dc5݀/>1IQT7>W.ΜSM8>@{ͺ>:8d
R{kT\>W62Rq6vo>8USN>@ӾSYJ>W
6Q_	3u[>0nd>Du^VMaO.
f>!
=YE>H*rߥUyy>V42K =`熎>KtZ_V[di>UhqDHU-Ͼ
֢>N >վVшR^u>T9LEE و{`.Ȩ->PpMOV΁)d>S3MKA@.6a>Q6UrVO>REHoi;J>>To|>RyV=>QaR,5K47B5f`>S׽Vp]n>P	>:(4Fz>T:)þV>M0w/sݦtNIGh!m>UgKRU>J%En>P>tL@d>UeKT쎰[>Fv>$2vNNOY>V=@EPT&9>CXc>1\RJPh7U>Vl=SSA>@?.TF>8k=ӄQan>Vvu	R
^[>91:>?@%_P-RނO>VZuP3VZ>2E>Bv#SVb[?ϾO: r>'hB>EKTu;FL>UjzL{e>>H%U
~1gH>U2p\I衃5r>KU ѾU
>T5E4Fx"M)pם>N8D{UӔ"u>SΕ7CNF0ׇ\>PGM=VF>RHPξ@6&!>QU(V(*>Q#?:j0uh߾RF$JVAb>PդlA94fA#
 (>S>a܏U开*">O{vB+{\Dn/ξ>SѼ;iUQ$k>M0$mQQ™G/.{>TiUuj>J&C˾IoT&%>T*z)T	>HmC>%1L7;ܖ>UA#VS[Ʒ>EEe6=>'gNuP>Uq?S0z̹>Bwqy]K>1h:PC|:>UHxRa(+>?2[>7wdQ3lxD>UH`Q{^)>9bR>M>=<%R
O>Um8XPM\C>3\6>A^,nX0Rz]>UeZNL>+T+'Y>D=I~ӾSmI}>UPgikL>
DVB>:KcY>FaJYySǁaN>TpT)JH4t>>HV/Ti>TDBs%HW45
aN>K$+GT>SmܾEwo"g>M)JL
UL>SOMÚӾU+@rS>Rb=s˾@4H;>PkUQ1<1m9F@>Q6MNU5밈e>P:6	Ӄ{>q+'>QUH>OF1OQAYg>R6+T*%$>Mb$p(ĶBD0j7L>SnTVܛ6>KӃ_J6xF8k2>S3:TKIǶ1>IډDNDʰ	HP*r>SܾS&?>G*>t2JIJ>TJ'/Se
>E-> :%bL 5(:|>TR˶R^>CpdfT>*l4EMkO>T	AR@ 9 %>A2m>1^(fOq/>TCQ>=/Pl>6l2g<,Pra7;>T5=
P㿣>9O<>:lnZQ
]>T;1ȾP$rx}+>4Ά>?BL]PQx]?S'>Th%Ne>0)dF>AK_R>X,?>Tk2M`6>'B(i>C1XoREtƱ>T-}`k
>`l]S`"8KGSB">VG}`>6>^a$LJ>:l6[>Z9ia`U>[YT#wA✙DDiJqf>]Ѯ٣`焔>We׃)	lPRP	>`Ӊi` v>R?>$^=KV
Z>`I˾]_л>KoQO>@sXaZ`>`."Z?|>@n>K0¾]ڶ>`$r6Vҽ>%Cwq>Ry_l^>_QR53΄'Lx	>V
zD`g>]YI+'JbrZEA=>Zu`Ǝɧ>Z)>?nJLKyIi>]e`hѶ>VGv"YltSR3%l>_ـZ_Mn>Q->)cXVty>`co \'ō>Ik>AA.Zaj'Vx>`Yo;>>>KTxm50]81&>`9!UfF>"L$4>R\*\D{_>m:\>^YQSf9(S+>VX9`4>|>\BINH@8`>Z~پ`Y`5>YcGC>7YJ4Մ>\Q^Ԋ`>U5о#pdƁQϧ/m>^ԌGD춾^%E'b>QjԢ>&
ξVT#>`\x&Y>I>?EY

>`+̈́p/YxS>?%>Iǭ؜\Rr
>_ԋfUy>&b/_>Qk;^X:U>^mӔQdȾ"pzFz>UuSd_u3`e>\hMAJ.bо=t(>XXQ_>Y
E(@g`w2HaC>[v_%.>V-"+i fP7>]ZI۾^aJ(>R9	x>HžT}@T>_֘M\p(hL>Kt>:!ȴvX&bo_>_Y̪[>>BW#^Y_>FD@\Z{!B>_X	VAK>1OpE-]"uq>^P&!R3!oֿ3x>SVQɾ^>\<UM'F5 ̻.>W:P_5-u>ZRNȭD ɷMDYў>Z (_<"o>W\5ctM*	q>\a45۾^EzB>Sz0ɎپQmܾRuF->]1A\5P>NT2D>0)OV#ww[>^-/dZ}>FG#X>AƘOY -.:>^
,WU&>:PG^>J}h	!['7 >^;5'TOג0>{f6D>QF]5CX>\	7P?>;& ˀl>T߽[[^;d[V>Z"H\=Xr>WX 9^Z#R'>X\ml?DľGejfʘ>ZybG^+<-z>U@a+n|վO00*>\\
"][EPS >Q#>hSSjV`C>]ۖv
[hg2E>KT>6k[VXz&M>^)`mYq>C$sB'6N>C Y=оYGI/ϧ>^?7nVDgp>4}>D>Lh[]"6>]FUxR6>5q+o>Q_ U\ԩfN'>[F
Nj{݂-V,p>UB]E>YsFS??[C>W`˯]Ԯc>WT,6XZ-#n]^
	u'0>TOXT9&`kGOr|>[|z\G8>P>t(GGʾSI
{Uv>\%uZ>.y>JHc];>7!T:VFc>]y!FXc(\o>BM,>CZA+X>]V>8:DUBT>4@ó9>Kw}ZO>\AL5=R܏>	u͉F>QDJ<\ Ӫe>[E^N#{;hھ+ l*a>Tk5kD)\I{G>YgLcF=-Q>W ]$^i>W(=l`TtYVq'\‹T>T:lAu*W
-MP*`>[n/پ[GxP>Q
sj>	&VxRK7΢g>\)[ZQ6T>K*n>3_1/U2t^>\\&wXRf>CUo'>A5įWnFN>\U!Mg>7T0	>H
d $Y匎>\-5S%>]:[>OD1[x*>[PBOt 	~/2N>R2\g4>Y{ZعH :7F7F>U*
\qv>Wh{WYbvݾ\K0>T3z﫬JYg |Z>Y\[l>R6fjʾ<9ZPm@>[uspZq>MF>&bXSYj`ҾZ>[#ZO!Xȗe4>FX,>:QMUN!&>\TC#?bVٍx>?Ȫ'>DZ2X}Xrr>[N2K]T4"@f>0_A>KYʦ&>[#N+Q`fr=2r>P]|Zwޫ>YLL!͓*3E;7>Sr'@oi[yoI>XB76E
C;i(\K>Uܡ2,[Ĭ$>V/u7I=QDdkm>Wyɾ+[}8>SBh.JK=!G>Yq[Z6>PW˾	ZsPK>ZYr  \>K+>*WdSJ'y>[:LAAWcs>Etg+^>;}wxU߃Ss>[k)J־U=>=bq>Dsa2WjO!>[(MSc>.fqRh>Jî1PY+>ZpTlrPք=+{R>PHg5Z1L>YJօʾK?oҾ(*jG>R㟂
Z>W0AEn:p>U+([
ʈ>U
<>T=/aC$B>WDZ;
>S.l0Iapa>XsvZ9FN0>Q	x!ĤJO\3^>YND|Y,eno>LNM>$76rR?Xy>Zp^֪ZW}HN>F<#>7JCqT]×:V>Zv拘aUGe`C>@Jc:>AVkE>Zz9WiS׏cls>3i, >HHW9Wb"'>Z@̺%Qrp >sՕd>MeY(D*>Y(;M݈fTq>QYt[7[Y3>W/G)83>9n>SpپZXX: ci>V>ҾB~!>?}>U0؁ZX">TLqiT7f2vE7.[>W/+GQYR18>R
&I~`LtKHvۋ,
>Xs4e۾Y6W5>O@FMM=s	P0xT>YZ.X>>IнLM#>+v9Ŋ#Rz8CU>Y⦢9`V~c>DNP4>:¦T}\TK>Z
T`b|_><ϊ>BizV1
r>Y'RrE;>0]ȗT>H\W>YIh6IP)P>Ffc>MzTXT
>XdoL\`X%(KBp>Q5]YOv>W+T
G-\g3.Za>S''Y^>UMAD>cNy>TOqtY.	>SܩS`c7qBT߾Dτ/Z)>Vy
-YU>Q3R:(C^XT3IwCz>WEڸX7>>O&XD߃Ni弫!>X@WdOq9>JM#3>&n͘Q
Ŕ>Y:۳Vnxe>E)xXu>6Sm&SrPOUO>YYD+T2>?3}͸>@_ƔUn>YCֳ{S0?r>4>ER	-Vy8>X1OQʯ*%>"%>J(8Wr>X*JZRcMѕZƽ%{>O!~W-p;e)gI;#O)ci;ʡ>QsXӟx+{>Uh	SfGEpYn!>TjU>P@Wn
>T$XaN>RoՕ3yEցZh>V=ڐX}kK >P?!OYJwZr>WC˾WJGR>MMx:=t0vQN^>XDYV=GJ >H>(N>bQP3>XxvU9>DwX=>6H/!S
C"m>X_zT;<>>Ru/$*>@Jr[TkfL=>X"RY'Q>4DЗA>E.'UzH3>X4X燾Ph>$7[>IwMV͝T>WF
OM56Z影poC(>MӾWZA>VG˹捾IT
V$Fv҆>PARX=>Uw8DܬuҌ"3f.>R`Y9XH>TRڠ@9$eվ=;j`>Ss4XD>R'W6>CUXݓ>U7оWBp>Q!vel*bx4G3>V(ӲW}J{V>Nט"(7Ky]]`>V|xV#>Jphx>	9TfOje>WʾU̡q׊>Fy>.$oQdjQ_>Wں{T*8R_>B#摮a`>8=yRn*>Wx[2SL乜>;V->@V8zT2[&n>Wys
Qȩcq>2<`ص>D(UJt5>Wt.NKP)@>"$3G>HEV-U_>V袾LjMݥ>LVflI>V.U]HN"N&d>PyaWM4m%>U!1wD(FD2/Ⱦ>QO7YپW_x/>SNg@65:Y>R>UWG>RV@D]8YAw{8>T#w0tWep>Q3=Gf
0?f	EhI,l>U")ZWt>O6j޽X^}dޠI ՟>U𖲰Vr>KVs=Úer߾Lݭ,>V;Z큾Utm>H*''3>#"~1uO$Uf>VN Tܥo>Dc5݀/>1IQT7>W.ΜSM8>@{ͺ>:8d
R{kT\>W62Rq6vo>8USN>@ӾSYJ>W
6Q_	3u[>0nd>Du^VMaO.
f>!
=YE>H*rߥUyy>V42K =`熎>KtZ_V[di>UhqDHU-Ͼ
֢>N >վVшR^u>T9LEE و{`.Ȩ->PpMOV΁)d>S3MKA@.6a>Q6UrVO>REHoi;J>>To|>RyV=>QaR,5K47B5f`>S׽Vp]n>P	>:(4Fz>T:)þV>M0w/sݦtNIGh!m>UgKRU>J%En>P>tL@d>UeKT쎰[>Fv>$2vNNOY>V=@EPT&9>CXc>1\RJPh7U>Vl=SSA>@?.TF>8k=ӄQan>Vvu	R
^[>91:>?@%_P-RނO>VZuP3VZ>2E>Bv#SVb[?ϾO: r>'hB>EKTu;FL>UjzL{e>>H%U
~1gH>U2p\I衃5r>KU ѾU
>T5E4Fx"M)pם>N8D{UӔ"u>SΕ7CNF0ׇ\>PGM=VF>RHPξ@6&!>QU(V(*>Q#?:j0uh߾RF$JVAb>PդlA94fA#
 (>S>a܏U开*">O{vB+{\Dn/ξ>SѼ;iUQ$k>M0$mQQ™G/.{>TiUuj>J&C˾IoT&%>T*z)T	>HmC>%1L7;ܖ>UA#VS[Ʒ>EEe6=>'gNuP>Uq?S0z̹>Bwqy]K>1h:PC|:>UHxRa(+>?2[>7wdQ3lxD>UH`Q{^)>9bR>M>=<%R
O>Um8XPM\C>3\6>A^,nX0Rz]>UeZNL>+T+'Y>D=I~ӾSmI}>UPgikL>
DVB>:KcY>FaJYySǁaN>TpT)JH4t>>HV/Ti>TDBs%HW45
aN>K$+GT>SmܾEwo"g>M)JL
UL>SOMÚӾU+@rS>Rb=s˾@4H;>PkUQ1<1m9F@>Q6MNU5밈e>P:6	Ӄ{>q+'>QUH>OF1OQAYg>R6+T*%$>Mb$p(ĶBD0j7L>SnTVܛ6>KӃ_J6xF8k2>S3:TKIǶ1>IډDNDʰ	HP*r>SܾS&?>G*>t2JIJ>TJ'/Se
>E-> :%bL 5(:|>TR˶R^>CpdfT>*l4EMkO>T	AR@ 9 %>A2m>1^(fOq/>TCQ>=/Pl>6l2g<,Pra7;>T5=
P㿣>9O<>:lnZQ
]>T;1ȾP$rx}+>4Ά>?BL]PQx]?S'>Th%Ne>0)dF>AK_R>X,?>Tk2M`6>'B(i>C1XoREtƱ>T-}`k
>`l]S`"8KGSB">VG}`>6>^a$LJ>:l6[>Z9ia`U>[YT#wA✙DDiJqf>]Ѯ٣`焔>We׃)	lPRP	>`Ӊi` v>R?>$^=KV
Z>`I˾]_л>KoQO>@sXaZ`>`."Z?|>@n>K0¾]ڶ>`$r6Vҽ>%Cwq>Ry_l^>_QR53΄'Lx	>V
zD`g>]YI+'JbrZEA=>Zu`Ǝɧ>Z)>?nJLKyIi>]e`hѶ>VGv"YltSR3%l>_ـZ_Mn>Q->)cXVty>`co \'ō>Ik>AA.Zaj'Vx>`Yo;>>>KTxm50]81&>`9!UfF>"L$4>R\*\D{_>m:\>^YQSf9(S+>VX9`4>|>\BINH@8`>Z~پ`Y`5>YcGC>7YJ4Մ>\Q^Ԋ`>U5о#pdƁQϧ/m>^ԌGD춾^%E'b>QjԢ>&
ξVT#>`\x&Y>I>?EY

>`+̈́p/YxS>?%>Iǭ؜\Rr
>_ԋfUy>&b/_>Qk;^X:U>^mӔQdȾ"pzFz>UuSd_u3`e>\hMAJ.bо=t(>XXQ_>Y
E(@g`w2HaC>[v_%.>V-"+i fP7>]ZI۾^aJ(>R9	x>HžT}@T>_֘M\p(hL>Kt>:!ȴvX&bo_>_Y̪[>>BW#^Y_>FD@\Z{!B>_X	VAK>1OpE-]"uq>^P&!R3!oֿ3x>SVQɾ^>\<UM'F5 ̻.>W:P_5-u>ZRNȭD ɷMDYў>Z (_<"o>W\5ctM*	q>\a45۾^EzB>Sz0ɎپQmܾRuF->]1A\5P>NT2D>0)OV#ww[>^-/dZ}>FG#X>AƘOY -.:>^
,WU&>:PG^>J}h	!['7 >^;5'TOג0>{f6D>QF]5CX>\	7P?>;& ˀl>T߽[[^;d[V>Z"H\=Xr>WX 9^Z#R'>X\ml?DľGejfʘ>ZybG^+<-z>U@a+n|վO00*>\\
"][EPS >Q#>hSSjV`C>]ۖv
[hg2E>KT>6k[VXz&M>^)`mYq>C$sB'6N>C Y=оYGI/ϧ>^?7nVDgp>4}>D>Lh[]"6>]FUxR6>5q+o>Q_ U\ԩfN'>[F
Nj{݂-V,p>UB]E>YsFS??[C>W`˯]Ԯc>WT,6XZ-#n]^
	u'0>TOXT9&`kGOr|>[|z\G8>P>t(GGʾSI
{Uv>\%uZ>.y>JHc];>7!T:VFc>]y!FXc(\o>BM,>CZA+X>]V>8:DUBT>4@ó9>Kw}ZO>\AL5=R܏>	u͉F>QDJ<\ Ӫe>[E^N#{;hھ+ l*a>Tk5kD)\I{G>YgLcF=-Q>W ]$^i>W(=l`TtYVq'\‹T>T:lAu*W
-MP*`>[n/پ[GxP>Q
sj>	&VxRK7΢g>\)[ZQ6T>K*n>3_1/U2t^>\\&wXRf>CUo'>A5įWnFN>\U!Mg>7T0	>H
d $Y匎>\-5S%>]:[>OD1[x*>[PBOt 	~/2N>R2\g4>Y{ZعH :7F7F>U*
\qv>Wh{WYbvݾ\K0>T3z﫬JYg |Z>Y\[l>R6fjʾ<9ZPm@>[uspZq>MF>&bXSYj`ҾZ>[#ZO!Xȗe4>FX,>:QMUN!&>\TC#?bVٍx>?Ȫ'>DZ2X}Xrr>[N2K]T4"@f>0_A>KYʦ&>[#N+Q`fr=2r>P]|Zwޫ>YLL!͓*3E;7>Sr'@oi[yoI>XB76E
C;i(\K>Uܡ2,[Ĭ$>V/u7I=QDdkm>Wyɾ+[}8>SBh.JK=!G>Yq[Z6>PW˾	ZsPK>ZYr  \>K+>*WdSJ'y>[:LAAWcs>Etg+^>;}wxU߃Ss>[k)J־U=>=bq>Dsa2WjO!>[(MSc>.fqRh>Jî1PY+>ZpTlrPք=+{R>PHg5Z1L>YJօʾK?oҾ(*jG>R㟂
Z>W0AEn:p>U+([
ʈ>U
<>T=/aC$B>WDZ;
>S.l0Iapa>XsvZ9FN0>Q	x!ĤJO\3^>YND|Y,eno>LNM>$76rR?Xy>Zp^֪ZW}HN>F<#>7JCqT]×:V>Zv拘aUGe`C>@Jc:>AVkE>Zz9WiS׏cls>3i, >HHW9Wb"'>Z@̺%Qrp >sՕd>MeY(D*>Y(;M݈fTq>QYt[7[Y3>W/G)83>9n>SpپZXX: ci>V>ҾB~!>?}>U0؁ZX">TLqiT7f2vE7.[>W/+GQYR18>R
&I~`LtKHvۋ,
>Xs4e۾Y6W5>O@FMM=s	P0xT>YZ.X>>IнLM#>+v9Ŋ#Rz8CU>Y⦢9`V~c>DNP4>:¦T}\TK>Z
T`b|_><ϊ>BizV1
r>Y'RrE;>0]ȗT>H\W>YIh6IP)P>Ffc>MzTXT
>XdoL\`X%(KBp>Q5]YOv>W+T
G-\g3.Za>S''Y^>UMAD>cNy>TOqtY.	>SܩS`c7qBT߾Dτ/Z)>Vy
-YU>Q3R:(C^XT3IwCz>WEڸX7>>O&XD߃Ni弫!>X@WdOq9>JM#3>&n͘Q
Ŕ>Y:۳Vnxe>E)xXu>6Sm&SrPOUO>YYD+T2>?3}͸>@_ƔUn>YCֳ{S0?r>4>ER	-Vy8>X1OQʯ*%>"%>J(8Wr>X*JZRcMѕZƽ%{>O!~W-p;e)gI;#O)ci;ʡ>QsXӟx+{>Uh	SfGEpYn!>TjU>P@Wn
>T$XaN>RoՕ3yEցZh>V=ڐX}kK >P?!OYJwZr>WC˾WJGR>MMx:=t0vQN^>XDYV=GJ >H>(N>bQP3>XxvU9>DwX=>6H/!S
C"m>X_zT;<>>Ru/$*>@Jr[TkfL=>X"RY'Q>4DЗA>E.'UzH3>X4X燾Ph>$7[>IwMV͝T>WF
OM56Z影poC(>MӾWZA>VG˹捾IT
V$Fv҆>PARX=>Uw8DܬuҌ"3f.>R`Y9XH>TRڠ@9$eվ=;j`>Ss4XD>R'W6>CUXݓ>U7оWBp>Q!vel*bx4G3>V(ӲW}J{V>Nט"(7Ky]]`>V|xV#>Jphx>	9TfOje>WʾU̡q׊>Fy>.$oQdjQ_>Wں{T*8R_>B#摮a`>8=yRn*>Wx[2SL乜>;V->@V8zT2[&n>Wys
Qȩcq>2<`ص>D(UJt5>Wt.NKP)@>"$3G>HEV-U_>V袾LjMݥ>LVflI>V.U]HN"N&d>PyaWM4m%>U!1wD(FD2/Ⱦ>QO7YپW_x/>SNg@65:Y>R>UWG>RV@D]8YAw{8>T#w0tWep>Q3=Gf
0?f	EhI,l>U")ZWt>O6j޽X^}dޠI ՟>U𖲰Vr>KVs=Úer߾Lݭ,>V;Z큾Utm>H*''3>#"~1uO$Uf>VN Tܥo>Dc5݀/>1IQT7>W.ΜSM8>@{ͺ>:8d
R{kT\>W62Rq6vo>8USN>@ӾSYJ>W
6Q_	3u[>0nd>Du^VMaO.
f>!
=YE>H*rߥUyy>V42K =`熎>KtZ_V[di>UhqDHU-Ͼ
֢>N >վVшR^u>T9LEE و{`.Ȩ->PpMOV΁)d>S3MKA@.6a>Q6UrVO>REHoi;J>>To|>RyV=>QaR,5K47B5f`>S׽Vp]n>P	>:(4Fz>T:)þV>M0w/sݦtNIGh!m>UgKRU>J%En>P>tL@d>UeKT쎰[>Fv>$2vNNOY>V=@EPT&9>CXc>1\RJPh7U>Vl=SSA>@?.TF>8k=ӄQan>Vvu	R
^[>91:>?@%_P-RނO>VZuP3VZ>2E>Bv#SVb[?ϾO: r>'hB>EKTu;FL>UjzL{e>>H%U
~1gH>U2p\I衃5r>KU ѾU
>T5E4Fx"M)pם>N8D{UӔ"u>SΕ7CNF0ׇ\>PGM=VF>RHPξ@6&!>QU(V(*>Q#?:j0uh߾RF$JVAb>PդlA94fA#
 (>S>a܏U开*">O{vB+{\Dn/ξ>SѼ;iUQ$k>M0$mQQ™G/.{>TiUuj>J&C˾IoT&%>T*z)T	>HmC>%1L7;ܖ>UA#VS[Ʒ>EEe6=>'gNuP>Uq?S0z̹>Bwqy]K>1h:PC|:>UHxRa(+>?2[>7wdQ3lxD>UH`Q{^)>9bR>M>=<%R
O>Um8XPM\C>3\6>A^,nX0Rz]>UeZNL>+T+'Y>D=I~ӾSmI}>UPgikL>
DVB>:KcY>FaJYySǁaN>TpT)JH4t>>HV/Ti>TDBs%HW45
aN>K$+GT>SmܾEwo"g>M)JL
UL>SOMÚӾU+@rS>Rb=s˾@4H;>PkUQ1<1m9F@>Q6MNU5밈e>P:6	Ӄ{>q+'>QUH>OF1OQAYg>R6+T*%$>Mb$p(ĶBD0j7L>SnTVܛ6>KӃ_J6xF8k2>S3:TKIǶ1>IډDNDʰ	HP*r>SܾS&?>G*>t2JIJ>TJ'/Se
>E-> :%bL 5(:|>TR˶R^>CpdfT>*l4EMkO>T	AR@ 9 %>A2m>1^(fOq/>TCQ>=/Pl>6l2g<,Pra7;>T5=
P㿣>9O<>:lnZQ
]>T;1ȾP$rx}+>4Ά>?BL]PQx]?S'>Th%Ne>0)dF>AK_R>X,?>Tk2M`6>'B(i>C1XoREtƱ>T-}KYb>ya9>E܉ISq>SRYI
>Gי>GlɑΒSu_>w>S}GdTj:$>I"jS0>SpBۈE-vm$->JsHSVћ>R'6Dwq$
7>LDBTdwq>R-IeB&[BU,游>MU]T:RH>QK|@=8&v2fn>N̾TH2z>QC=<"B26N4m.b>P(<96TH(-x>PzMhW8.@?:5>PcT;ǝw>O(K4Q)T#B	>>NaCg1rԏ?R@N	>QxqSN%[_>Mb2*wBN	Y>R~^SS%K>KW1#.CD v>RcB^-S
[>J.+M.XmEwm%`>RxԾSRA*x>HSEqܾFF&>R:%"SP$>G:4+Fj=RIcHTgXț>S27־R
*>E~>BIEb>SaҹgRU,V>D1ΡY> M.Jt#>S1QTU>Bw>'jǗL>SxQ\
m*5>A"qD>-ql¾M*>Sn)Qxfx>?2jZ>2(vN.z>S;όBP-p><&	X>5<ľO#*E>S?]-P)=\G0>9I>8:BKPGp>S13UyOV?|yݝ>68p>;E=(Pi`B>S`NFsNSw>3+pU>=5ً
P{<>S&txMK]Q>0&bss>@H!mQ (>Sj:(L;ia
>*wA>AG ^`Qn
#s>SDK)^>$Gg>BшQU?">SMJ	Y^!>=P>CQafm>RG|¾Hl.C>/Ћ	>E@G1R,MDp>R%=wGR>a>F+OKR]Rn1>Rz%ȶFR2B<>G1dͲR&
>R<0EE;[Go>H)a RjK>QqoD8)NxP%>I
vľRI7Z(>Q-o	CzF{Ǿ z?x>I<[O'R7U<>QlϾBbR֟%$ޡJDm>JX/:*Ry(>Q!b.H(;AO$
՗)qPY>KMR	hQv>PM;@>Ͷ$-9>LEcULSv=>PXO>`y<߾1y>L?"i¾S
y^~>P4/־MllS
%>O:FFP5-=s΂
>N/p
ZSWҨ>O!R8D7nZ>N4R>Ny~6PRʾ8]e>O@1R
>MӬq4f.C{:Rid>OQ]k'R|>M+.22vоP
CRюe,H>LD0Rd>ݴ>PIz+-dR<>Ki-ކ^?D?-8J>Py	GR6!Y>K9k׮*gۈ@&%f7>P'a_1Rfοm>J]'9AC#>P̮PmRv}>I&*#(iAp>PhR[$G>IVe%m [CB>Q
HľR=^9$>H⌲`5C0* >Q.5־R N|>H"g
^HC.`>QI}4rjR\nH>G %
BDOx>Q`K6QP>FGJt;$6þDm>QuZ#fQì-h>Fni(/G$G4!EN1>Q&E穾Q3Y@~>EȽ1EHNW>Ql1Q2J>E_au=c|4EF.1[>QJpQdLP#>Ds%>SFf>Qf҇QEp6>Dd	W>	V4F2>QھQ%L
>CZ>$GJd/|>Qyv|پQ^2>C~kE>|zG>Q*lP/dc>C('>
ǾGj
s>Q}3YP`C8>B>WZH,@>Qr'PA;k&+>BKv&>g1IHkj>QNP>A1> 

 H״>Qv5qPy3\8>ANð>!	H>Q)P`Gjb>AK/>#'7ǾI>QA?h>$Dn,)I-)qZ>Q⨾P1TŒ->@cxN9>%?p牾IOL|X>QˡibPMP>@)*>&=ahgImqN_N>QȌdnPr>@H(>&(w־I
j>QFPOpcI>@{P>'!"ľIRp.>Qk۾O(D`y!>?سd>(/gIPY\>QMfO͡/>?P>(#BXjIj>Qzy2OGd*~.>?MLy>()I[2׏>QЇQ5Owi>?7s>)'RI3:>QoCObK>>Ҟ>)OuNIx">Q@}OO >>l>)VZIl3B}>Qc
sOAJ>>ϛK2>)Cv2p"IsLԙ>Q3e
O6=[j>>M&4>)^I5>Q%}㜾O-4Gc>>5[h>(ԑdIs>Q|VnO(Ɯ>>[x7>(rQsoܾO'
>?>'4N.{I9"u>Qi(EO'u>?'gV+"IO$>Q^éof-O+Á>?xzl&>&$C~ǾHH>QTBO3>?q:N>%OkH5v>QHV[~O;*0
>@KX>%I$.Hݩ(>Q;IJhOHG>@5W>$lCHR(>Q/OcBOW췳FP>@hJx>#
Hxe>Q!GOh%D>@Ұ :>![fFGԖZ=~>Q`IudO|=[>@
.5> ӵGT>Q`dHOg.>A"`W>TdxGC}K2>P?Om>Akl>YJFhA#>PO–q>Að>*qɀ	F9L>PGMCO҇>B]/>wpuF@!oq%>P>-O#s>Bb-Tl4>AQp7Em>`8>PyǾPݓp>B櫘j>
![EvJx>POlPC\>CRә>=}E	'>Pt5WiP(Wx>C ]}p=d탾DY(>PYN
l"P8^WM>C	­=Hr\D[k9_>P=L݌zPG΃{>DVD+39[q`CCb	.>Ph☺PV@A'>D|>y)S"C#iz>O/Pe"AU>E8a*
YYB)_>OM
Psz|>E{>iA>>>OiZPGŹ9>F%ٽmЂ?PAZu2m>O>P!>Frvf@hOb>NĝP^R>G`J!Ri}@~h>NePψP	R>Gru$<
>ZUO>N8bP>Ha2{':&=TW{	>MvPs>H*w*GN
;آ#2G>M)^?P퉭>I!-n:Jfo>L8BPk}>Ibt0Tx8Xn>,>L3ތCGP8b>J[vPi1I7SN>KiP&<æ>JD(3x*.5M(>Kp\PMii>K-c,5X4Ѿ3Vg>J"kjP[u1Y>Kg7f>1W
>I!wEًP&>L䆽8ݵs/rf>I;2܅
PNͤY>LA:Q<+0@ >H$)Px0>ML4OZҾGX6P`?}>Mot*>3qOWp#Ĕ>G6V`PDTV>MH(@Q#X1>F5cʾP"ju>NA6@¿J|q>EZʸUOXm>NQҾAԏʾ	ؼ>Dt٢=OcG>N;T4BMn>CBc߾O?0>OJ@Cl9=T82y:>Bw׾N+>OID6>
FFu>A) ܾNWj>OBEn>]2>@w[?&\ݾMə8>P嘮FM\>!	_
>>VM=Seu>P\ZSG*Z}Y>%M`0>P+J?HKg>*Ş>:mAKl">P5>gH7;O>/#{O>7"+ƾK1MX>>P8bI_MUB>2}>5p
(۾JfR6b>P6_;J`\>5
}>2{yd\I4>P+qվKJL>7J2>/%dþHO*G>PcоKˮ6\>:S.s>*rt&G$\U>P{Lr~=>$zcF.Kޚ>O꥜M*(~>?$&>m`3*GEYEjk>Oh]yM
x>@p
>Dfo
ܿ>OGPNm>BD=PAChC1qdO>NoԙNHp>C;д|AA>7
>MauNU/~">Di.~ʇH'P@Yw>M^m{'O?5Z>E SYǼ	c)>oос]>LrʼO}e>F%";G7>K5 zOep>G%]hl,	C84MT>K%-7O>H,Qё1&'?Ȝ5~9>J֝OÄ>Ifx|Fi4H"G02N;>IgbOī>Jr%l7gu
ꐾ."vl>G3ӵOGԄ>KsZ'x:{ܾ'cd>F~>7OCx>L9S=Yc Q >E}N*3k>Lgpj@CO.>D%sNNv>M't
,AxYCԩ>BglM}>NmϾC&s!>ö>A5&hZM@gN3>NF/J{>?EicoL~J>NنM.Q/E^->#>xˉ>;3ꎾK^v>OuUGnGXp>*޺ɖ>8jFJ3onH>O89HN7Ff\>0jA>4wI
>O<ߓIjcҕ>4)T>1OC쐾Ha%Fp>O#˥Jsa9>8[tb>+G͈ٟ>NAYؾKd29H>;>#Z7IR^E
P>NJ_6L;cm>?
@#>񓱧D1>>Nܒ4L>A4?a`=l'B>MX. ׾Moz>B҈XN{L@鞩2̝>LƢ:3Nڌ>D_59Z>B9~>K7pNv	yQ>E<_%'վ:Vo>JGzt;Niw>G?
o׾-%)W˾68Y\>IDxqBN[M>HX2R2rq>HqNt>>IS26-v,f.
d>G"ވNZnKs>J=:ؚl$s>E,60dN6	Y!>Kd>_i{|*g>C?-M@
8>LhA	s_r|w>B9
9mM
a>MEG۾B)na2>KG>@ZJ>%L:F/%>MlDٞN>#><(pXK?E,>N-_\oFn%>'ꚜ>8T=J>Nag
G,U/>0f]g>4Pc9ɾH,
7>NiH>4e [4>/*پGZ%[>NFH`V.J,4>9>&Ku&E~>Mٶ'K?+dk+)>=G5ܖMk>DCnۃD"\I>MpL+;Wm>@<~/=)B%>LؾLC:>B9-K'LjuM}n>Dj:>vș=;_;>Jm@4fMw7Q>F FY)c1z7sES>IKNh>GڊZc1uw2ǕRIw>HN
_2:j=>IS;u6'k a+ݛ__">Fy*M(|>J`1z<:BnY.!Ʀ(Sc>DWMfs/9>KtX?!Ձھ+d>BёﺾLHb~>LVCSA>`=*/>@I	QKJ'B>MjgCV=>Q><=.ԇJ65-F>MQg޾E}>>'V)>8VFIC
>MrG;k*>0mU>3%hH>>M4Ď4%Hġ>5#~>,
k?FO2|#>MpTzxJ;`Ki>:_SBW>!}EDiĊxg~>MΟьKA_>?2<:P:>
PƤҾBW#g_>La/!TL-6m{>AѺT̃`@G>KmaDLݣ>CCӍa6W8;f,eT>J<&پMPE1+>Eդ
4M)~bt6X4o!>H_׊QM
>Gc^N~2VXK¾1;˷>G&3iMnnQ>I)7Ž'%Ѕ>ED]MՔ
>JtV!C/9jML{S6>K@-n0;q$>@K:As>L_N>B\>DCE><]hJp[>LuS<	DE
d4>&s>7ёIҮn8>M:-ɾFa>0Y[;>2,,eMGWM]>M8hG*۾Ht<>6eEʸ>(춤	fKYb>ya9>E܉ISq>SRYI
>Gי>GlɑΒSu_>w>S}GdTj:$>I"jS0>SpBۈE-vm$->JsHSVћ>R'6Dwq$
7>LDBTdwq>R-IeB&[BU,游>MU]T:RH>QK|@=8&v2fn>N̾TH2z>QC=<"B26N4m.b>P(<96TH(-x>PzMhW8.@?:5>PcT;ǝw>O(K4Q)T#B	>>NaCg1rԏ?R@N	>QxqSN%[_>Mb2*wBN	Y>R~^SS%K>KW1#.CD v>RcB^-S
[>J.+M.XmEwm%`>RxԾSRA*x>HSEqܾFF&>R:%"SP$>G:4+Fj=RIcHTgXț>S27־R
*>E~>BIEb>SaҹgRU,V>D1ΡY> M.Jt#>S1QTU>Bw>'jǗL>SxQ\
m*5>A"qD>-ql¾M*>Sn)Qxfx>?2jZ>2(vN.z>S;όBP-p><&	X>5<ľO#*E>S?]-P)=\G0>9I>8:BKPGp>S13UyOV?|yݝ>68p>;E=(Pi`B>S`NFsNSw>3+pU>=5ً
P{<>S&txMK]Q>0&bss>@H!mQ (>Sj:(L;ia
>*wA>AG ^`Qn
#s>SDK)^>$Gg>BшQU?">SMJ	Y^!>=P>CQafm>RG|¾Hl.C>/Ћ	>E@G1R,MDp>R%=wGR>a>F+OKR]Rn1>Rz%ȶFR2B<>G1dͲR&
>R<0EE;[Go>H)a RjK>QqoD8)NxP%>I
vľRI7Z(>Q-o	CzF{Ǿ z?x>I<[O'R7U<>QlϾBbR֟%$ޡJDm>JX/:*Ry(>Q!b.H(;AO$
՗)qPY>KMR	hQv>PM;@>Ͷ$-9>LEcULSv=>PXO>`y<߾1y>L?"i¾S
y^~>P4/־MllS
%>O:FFP5-=s΂
>N/p
ZSWҨ>O!R8D7nZ>N4R>Ny~6PRʾ8]e>O@1R
>MӬq4f.C{:Rid>OQ]k'R|>M+.22vоP
CRюe,H>LD0Rd>ݴ>PIz+-dR<>Ki-ކ^?D?-8J>Py	GR6!Y>K9k׮*gۈ@&%f7>P'a_1Rfοm>J]'9AC#>P̮PmRv}>I&*#(iAp>PhR[$G>IVe%m [CB>Q
HľR=^9$>H⌲`5C0* >Q.5־R N|>H"g
^HC.`>QI}4rjR\nH>G %
BDOx>Q`K6QP>FGJt;$6þDm>QuZ#fQì-h>Fni(/G$G4!EN1>Q&E穾Q3Y@~>EȽ1EHNW>Ql1Q2J>E_au=c|4EF.1[>QJpQdLP#>Ds%>SFf>Qf҇QEp6>Dd	W>	V4F2>QھQ%L
>CZ>$GJd/|>Qyv|پQ^2>C~kE>|zG>Q*lP/dc>C('>
ǾGj
s>Q}3YP`C8>B>WZH,@>Qr'PA;k&+>BKv&>g1IHkj>QNP>A1> 

 H״>Qv5qPy3\8>ANð>!	H>Q)P`Gjb>AK/>#'7ǾI>QA?h>$Dn,)I-)qZ>Q⨾P1TŒ->@cxN9>%?p牾IOL|X>QˡibPMP>@)*>&=ahgImqN_N>QȌdnPr>@H(>&(w־I
j>QFPOpcI>@{P>'!"ľIRp.>Qk۾O(D`y!>?سd>(/gIPY\>QMfO͡/>?P>(#BXjIj>Qzy2OGd*~.>?MLy>()I[2׏>QЇQ5Owi>?7s>)'RI3:>QoCObK>>Ҟ>)OuNIx">Q@}OO >>l>)VZIl3B}>Qc
sOAJ>>ϛK2>)Cv2p"IsLԙ>Q3e
O6=[j>>M&4>)^I5>Q%}㜾O-4Gc>>5[h>(ԑdIs>Q|VnO(Ɯ>>[x7>(rQsoܾO'
>?>'4N.{I9"u>Qi(EO'u>?'gV+"IO$>Q^éof-O+Á>?xzl&>&$C~ǾHH>QTBO3>?q:N>%OkH5v>QHV[~O;*0
>@KX>%I$.Hݩ(>Q;IJhOHG>@5W>$lCHR(>Q/OcBOW췳FP>@hJx>#
Hxe>Q!GOh%D>@Ұ :>![fFGԖZ=~>Q`IudO|=[>@
.5> ӵGT>Q`dHOg.>A"`W>TdxGC}K2>P?Om>Akl>YJFhA#>PO–q>Að>*qɀ	F9L>PGMCO҇>B]/>wpuF@!oq%>P>-O#s>Bb-Tl4>AQp7Em>`8>PyǾPݓp>B櫘j>
![EvJx>POlPC\>CRә>=}E	'>Pt5WiP(Wx>C ]}p=d탾DY(>PYN
l"P8^WM>C	­=Hr\D[k9_>P=L݌zPG΃{>DVD+39[q`CCb	.>Ph☺PV@A'>D|>y)S"C#iz>O/Pe"AU>E8a*
YYB)_>OM
Psz|>E{>iA>>>OiZPGŹ9>F%ٽmЂ?PAZu2m>O>P!>Frvf@hOb>NĝP^R>G`J!Ri}@~h>NePψP	R>Gru$<
>ZUO>N8bP>Ha2{':&=TW{	>MvPs>H*w*GN
;آ#2G>M)^?P퉭>I!-n:Jfo>L8BPk}>Ibt0Tx8Xn>,>L3ތCGP8b>J[vPi1I7SN>KiP&<æ>JD(3x*.5M(>Kp\PMii>K-c,5X4Ѿ3Vg>J"kjP[u1Y>Kg7f>1W
>I!wEًP&>L䆽8ݵs/rf>I;2܅
PNͤY>LA:Q<+0@ >H$)Px0>ML4OZҾGX6P`?}>Mot*>3qOWp#Ĕ>G6V`PDTV>MH(@Q#X1>F5cʾP"ju>NA6@¿J|q>EZʸUOXm>NQҾAԏʾ	ؼ>Dt٢=OcG>N;T4BMn>CBc߾O?0>OJ@Cl9=T82y:>Bw׾N+>OID6>
FFu>A) ܾNWj>OBEn>]2>@w[?&\ݾMə8>P嘮FM\>!	_
>>VM=Seu>P\ZSG*Z}Y>%M`0>P+J?HKg>*Ş>:mAKl">P5>gH7;O>/#{O>7"+ƾK1MX>>P8bI_MUB>2}>5p
(۾JfR6b>P6_;J`\>5
}>2{yd\I4>P+qվKJL>7J2>/%dþHO*G>PcоKˮ6\>:S.s>*rt&G$\U>P{Lr~=>$zcF.Kޚ>O꥜M*(~>?$&>m`3*GEYEjk>Oh]yM
x>@p
>Dfo
ܿ>OGPNm>BD=PAChC1qdO>NoԙNHp>C;д|AA>7
>MauNU/~">Di.~ʇH'P@Yw>M^m{'O?5Z>E SYǼ	c)>oос]>LrʼO}e>F%";G7>K5 zOep>G%]hl,	C84MT>K%-7O>H,Qё1&'?Ȝ5~9>J֝OÄ>Ifx|Fi4H"G02N;>IgbOī>Jr%l7gu
ꐾ."vl>G3ӵOGԄ>KsZ'x:{ܾ'cd>F~>7OCx>L9S=Yc Q >E}N*3k>Lgpj@CO.>D%sNNv>M't
,AxYCԩ>BglM}>NmϾC&s!>ö>A5&hZM@gN3>NF/J{>?EicoL~J>NنM.Q/E^->#>xˉ>;3ꎾK^v>OuUGnGXp>*޺ɖ>8jFJ3onH>O89HN7Ff\>0jA>4wI
>O<ߓIjcҕ>4)T>1OC쐾Ha%Fp>O#˥Jsa9>8[tb>+G͈ٟ>NAYؾKd29H>;>#Z7IR^E
P>NJ_6L;cm>?
@#>񓱧D1>>Nܒ4L>A4?a`=l'B>MX. ׾Moz>B҈XN{L@鞩2̝>LƢ:3Nڌ>D_59Z>B9~>K7pNv	yQ>E<_%'վ:Vo>JGzt;Niw>G?
o׾-%)W˾68Y\>IDxqBN[M>HX2R2rq>HqNt>>IS26-v,f.
d>G"ވNZnKs>J=:ؚl$s>E,60dN6	Y!>Kd>_i{|*g>C?-M@
8>LhA	s_r|w>B9
9mM
a>MEG۾B)na2>KG>@ZJ>%L:F/%>MlDٞN>#><(pXK?E,>N-_\oFn%>'ꚜ>8T=J>Nag
G,U/>0f]g>4Pc9ɾH,
7>NiH>4e [4>/*پGZ%[>NFH`V.J,4>9>&Ku&E~>Mٶ'K?+dk+)>=G5ܖMk>DCnۃD"\I>MpL+;Wm>@<~/=)B%>LؾLC:>B9-K'LjuM}n>Dj:>vș=;_;>Jm@4fMw7Q>F FY)c1z7sES>IKNh>GڊZc1uw2ǕRIw>HN
_2:j=>IS;u6'k a+ݛ__">Fy*M(|>J`1z<:BnY.!Ʀ(Sc>DWMfs/9>KtX?!Ձھ+d>BёﺾLHb~>LVCSA>`=*/>@I	QKJ'B>MjgCV=>Q><=.ԇJ65-F>MQg޾E}>>'V)>8VFIC
>MrG;k*>0mU>3%hH>>M4Ď4%Hġ>5#~>,
k?FO2|#>MpTzxJ;`Ki>:_SBW>!}EDiĊxg~>MΟьKA_>?2<:P:>
PƤҾBW#g_>La/!TL-6m{>AѺT̃`@G>KmaDLݣ>CCӍa6W8;f,eT>J<&پMPE1+>Eդ
4M)~bt6X4o!>H_׊QM
>Gc^N~2VXK¾1;˷>G&3iMnnQ>I)7Ž'%Ѕ>ED]MՔ
>JtV!C/9jML{S6>K@-n0;q$>@K:As>L_N>B\>DCE><]hJp[>LuS<	DE
d4>&s>7ёIҮn8>M:-ɾFa>0Y[;>2,,eMGWM]>M8hG*۾Ht<>6eEʸ>(춤	fKYb>ya9>E܉ISq>SRYI
>Gי>GlɑΒSu_>w>S}GdTj:$>I"jS0>SpBۈE-vm$->JsHSVћ>R'6Dwq$
7>LDBTdwq>R-IeB&[BU,游>MU]T:RH>QK|@=8&v2fn>N̾TH2z>QC=<"B26N4m.b>P(<96TH(-x>PzMhW8.@?:5>PcT;ǝw>O(K4Q)T#B	>>NaCg1rԏ?R@N	>QxqSN%[_>Mb2*wBN	Y>R~^SS%K>KW1#.CD v>RcB^-S
[>J.+M.XmEwm%`>RxԾSRA*x>HSEqܾFF&>R:%"SP$>G:4+Fj=RIcHTgXț>S27־R
*>E~>BIEb>SaҹgRU,V>D1ΡY> M.Jt#>S1QTU>Bw>'jǗL>SxQ\
m*5>A"qD>-ql¾M*>Sn)Qxfx>?2jZ>2(vN.z>S;όBP-p><&	X>5<ľO#*E>S?]-P)=\G0>9I>8:BKPGp>S13UyOV?|yݝ>68p>;E=(Pi`B>S`NFsNSw>3+pU>=5ً
P{<>S&txMK]Q>0&bss>@H!mQ (>Sj:(L;ia
>*wA>AG ^`Qn
#s>SDK)^>$Gg>BшQU?">SMJ	Y^!>=P>CQafm>RG|¾Hl.C>/Ћ	>E@G1R,MDp>R%=wGR>a>F+OKR]Rn1>Rz%ȶFR2B<>G1dͲR&
>R<0EE;[Go>H)a RjK>QqoD8)NxP%>I
vľRI7Z(>Q-o	CzF{Ǿ z?x>I<[O'R7U<>QlϾBbR֟%$ޡJDm>JX/:*Ry(>Q!b.H(;AO$
՗)qPY>KMR	hQv>PM;@>Ͷ$-9>LEcULSv=>PXO>`y<߾1y>L?"i¾S
y^~>P4/־MllS
%>O:FFP5-=s΂
>N/p
ZSWҨ>O!R8D7nZ>N4R>Ny~6PRʾ8]e>O@1R
>MӬq4f.C{:Rid>OQ]k'R|>M+.22vоP
CRюe,H>LD0Rd>ݴ>PIz+-dR<>Ki-ކ^?D?-8J>Py	GR6!Y>K9k׮*gۈ@&%f7>P'a_1Rfοm>J]'9AC#>P̮PmRv}>I&*#(iAp>PhR[$G>IVe%m [CB>Q
HľR=^9$>H⌲`5C0* >Q.5־R N|>H"g
^HC.`>QI}4rjR\nH>G %
BDOx>Q`K6QP>FGJt;$6þDm>QuZ#fQì-h>Fni(/G$G4!EN1>Q&E穾Q3Y@~>EȽ1EHNW>Ql1Q2J>E_au=c|4EF.1[>QJpQdLP#>Ds%>SFf>Qf҇QEp6>Dd	W>	V4F2>QھQ%L
>CZ>$GJd/|>Qyv|پQ^2>C~kE>|zG>Q*lP/dc>C('>
ǾGj
s>Q}3YP`C8>B>WZH,@>Qr'PA;k&+>BKv&>g1IHkj>QNP>A1> 

 H״>Qv5qPy3\8>ANð>!	H>Q)P`Gjb>AK/>#'7ǾI>QA?h>$Dn,)I-)qZ>Q⨾P1TŒ->@cxN9>%?p牾IOL|X>QˡibPMP>@)*>&=ahgImqN_N>QȌdnPr>@H(>&(w־I
j>QFPOpcI>@{P>'!"ľIRp.>Qk۾O(D`y!>?سd>(/gIPY\>QMfO͡/>?P>(#BXjIj>Qzy2OGd*~.>?MLy>()I[2׏>QЇQ5Owi>?7s>)'RI3:>QoCObK>>Ҟ>)OuNIx">Q@}OO >>l>)VZIl3B}>Qc
sOAJ>>ϛK2>)Cv2p"IsLԙ>Q3e
O6=[j>>M&4>)^I5>Q%}㜾O-4Gc>>5[h>(ԑdIs>Q|VnO(Ɯ>>[x7>(rQsoܾO'
>?>'4N.{I9"u>Qi(EO'u>?'gV+"IO$>Q^éof-O+Á>?xzl&>&$C~ǾHH>QTBO3>?q:N>%OkH5v>QHV[~O;*0
>@KX>%I$.Hݩ(>Q;IJhOHG>@5W>$lCHR(>Q/OcBOW췳FP>@hJx>#
Hxe>Q!GOh%D>@Ұ :>![fFGԖZ=~>Q`IudO|=[>@
.5> ӵGT>Q`dHOg.>A"`W>TdxGC}K2>P?Om>Akl>YJFhA#>PO–q>Að>*qɀ	F9L>PGMCO҇>B]/>wpuF@!oq%>P>-O#s>Bb-Tl4>AQp7Em>`8>PyǾPݓp>B櫘j>
![EvJx>POlPC\>CRә>=}E	'>Pt5WiP(Wx>C ]}p=d탾DY(>PYN
l"P8^WM>C	­=Hr\D[k9_>P=L݌zPG΃{>DVD+39[q`CCb	.>Ph☺PV@A'>D|>y)S"C#iz>O/Pe"AU>E8a*
YYB)_>OM
Psz|>E{>iA>>>OiZPGŹ9>F%ٽmЂ?PAZu2m>O>P!>Frvf@hOb>NĝP^R>G`J!Ri}@~h>NePψP	R>Gru$<
>ZUO>N8bP>Ha2{':&=TW{	>MvPs>H*w*GN
;آ#2G>M)^?P퉭>I!-n:Jfo>L8BPk}>Ibt0Tx8Xn>,>L3ތCGP8b>J[vPi1I7SN>KiP&<æ>JD(3x*.5M(>Kp\PMii>K-c,5X4Ѿ3Vg>J"kjP[u1Y>Kg7f>1W
>I!wEًP&>L䆽8ݵs/rf>I;2܅
PNͤY>LA:Q<+0@ >H$)Px0>ML4OZҾGX6P`?}>Mot*>3qOWp#Ĕ>G6V`PDTV>MH(@Q#X1>F5cʾP"ju>NA6@¿J|q>EZʸUOXm>NQҾAԏʾ	ؼ>Dt٢=OcG>N;T4BMn>CBc߾O?0>OJ@Cl9=T82y:>Bw׾N+>OID6>
FFu>A) ܾNWj>OBEn>]2>@w[?&\ݾMə8>P嘮FM\>!	_
>>VM=Seu>P\ZSG*Z}Y>%M`0>P+J?HKg>*Ş>:mAKl">P5>gH7;O>/#{O>7"+ƾK1MX>>P8bI_MUB>2}>5p
(۾JfR6b>P6_;J`\>5
}>2{yd\I4>P+qվKJL>7J2>/%dþHO*G>PcоKˮ6\>:S.s>*rt&G$\U>P{Lr~=>$zcF.Kޚ>O꥜M*(~>?$&>m`3*GEYEjk>Oh]yM
x>@p
>Dfo
ܿ>OGPNm>BD=PAChC1qdO>NoԙNHp>C;д|AA>7
>MauNU/~">Di.~ʇH'P@Yw>M^m{'O?5Z>E SYǼ	c)>oос]>LrʼO}e>F%";G7>K5 zOep>G%]hl,	C84MT>K%-7O>H,Qё1&'?Ȝ5~9>J֝OÄ>Ifx|Fi4H"G02N;>IgbOī>Jr%l7gu
ꐾ."vl>G3ӵOGԄ>KsZ'x:{ܾ'cd>F~>7OCx>L9S=Yc Q >E}N*3k>Lgpj@CO.>D%sNNv>M't
,AxYCԩ>BglM}>NmϾC&s!>ö>A5&hZM@gN3>NF/J{>?EicoL~J>NنM.Q/E^->#>xˉ>;3ꎾK^v>OuUGnGXp>*޺ɖ>8jFJ3onH>O89HN7Ff\>0jA>4wI
>O<ߓIjcҕ>4)T>1OC쐾Ha%Fp>O#˥Jsa9>8[tb>+G͈ٟ>NAYؾKd29H>;>#Z7IR^E
P>NJ_6L;cm>?
@#>񓱧D1>>Nܒ4L>A4?a`=l'B>MX. ׾Moz>B҈XN{L@鞩2̝>LƢ:3Nڌ>D_59Z>B9~>K7pNv	yQ>E<_%'վ:Vo>JGzt;Niw>G?
o׾-%)W˾68Y\>IDxqBN[M>HX2R2rq>HqNt>>IS26-v,f.
d>G"ވNZnKs>J=:ؚl$s>E,60dN6	Y!>Kd>_i{|*g>C?-M@
8>LhA	s_r|w>B9
9mM
a>MEG۾B)na2>KG>@ZJ>%L:F/%>MlDٞN>#><(pXK?E,>N-_\oFn%>'ꚜ>8T=J>Nag
G,U/>0f]g>4Pc9ɾH,
7>NiH>4e [4>/*پGZ%[>NFH`V.J,4>9>&Ku&E~>Mٶ'K?+dk+)>=G5ܖMk>DCnۃD"\I>MpL+;Wm>@<~/=)B%>LؾLC:>B9-K'LjuM}n>Dj:>vș=;_;>Jm@4fMw7Q>F FY)c1z7sES>IKNh>GڊZc1uw2ǕRIw>HN
_2:j=>IS;u6'k a+ݛ__">Fy*M(|>J`1z<:BnY.!Ʀ(Sc>DWMfs/9>KtX?!Ձھ+d>BёﺾLHb~>LVCSA>`=*/>@I	QKJ'B>MjgCV=>Q><=.ԇJ65-F>MQg޾E}>>'V)>8VFIC
>MrG;k*>0mU>3%hH>>M4Ď4%Hġ>5#~>,
k?FO2|#>MpTzxJ;`Ki>:_SBW>!}EDiĊxg~>MΟьKA_>?2<:P:>
PƤҾBW#g_>La/!TL-6m{>AѺT̃`@G>KmaDLݣ>CCӍa6W8;f,eT>J<&پMPE1+>Eդ
4M)~bt6X4o!>H_׊QM
>Gc^N~2VXK¾1;˷>G&3iMnnQ>I)7Ž'%Ѕ>ED]MՔ
>JtV!C/9jML{S6>K@-n0;q$>@K:As>L_N>B\>DCE><]hJp[>LuS<	DE
d4>&s>7ёIҮn8>M:-ɾFa>0Y[;>2,,eMGWM]>M8hG*۾Ht<>6eEʸ>(춤	fEk<&>L@CJbx>;P>hXw8CCA>LQv"K9K>@bT=ʥ3@*>Kj*tLM>BHg@9w<<=>J7L|>D
C&C&S)M72P>HC[)M~ԍ>FZs1Er覽1oZd{>FTL]>HSsȾ7b^F&_?w>D%
NL}#>J:B+qK*>KAj}@t)=C;9>@amJ5>LF6lCJ> B>:J[I>L92E}ڠ>*_R>4s}G7^>LzGs}!6>3zݨ;>-AVﯾEލP>L`OAI"P$t>9Yӝ)4>!(ϾCe
@>LֵaJJv>>	>7DA6Ӳpo>K:8K&>BHovвx<J>IbÀ"LAWL]>DxȾ%ږ7{>HhOL>F0;G14{!0-i{>F}z{ELg>Htq'7a5=oP$#Vt>DDC"I|H=AZx)sc>A2}hKJ(>K'v.AbŸo>_4Aτ>=G J=ӄ
>KŞCߩ>#Bmx/>7YH|GL^䝄F*ǻK>01$ICF\^>L`V3BHY<>6p>%;ODR&J7>KzԾI&\r><4>iL_A\vR>K&9g	ʾJ]㮃>A:^;(ujo=7h&>I.,>K/>CRa#^<7
7P>HJyGɾL4B>F(Go09s06t>FFs\vL.T;E3>H#Q7)yb$8Vh>Cp,K@{<>I}=j*;X	x>A4̾Jлo?>JN}A2dJ>lbYV>K
5D>9>&wJb>5`XGDٸG>LumF>21!>.8unEE>K,{H~qS>8{Jy>B{YBq3>KR_>e!J	IJj>?1e=.
~@*d+>J>1QK#oG>B}/Cθ<'\9(y[>HK>EXh
+	l3>K.(>Fr hKE6>GNؾ5<'lW|\>DTZݼ
KN4>I_h;W/$V>A@7¾JK_>J|y@Q>G/	1>Ka@x/Cʹ?>%+Rb>6!IGY>KmG‘FAF>1>7r>-$EBC.c>KɊCHNkL3>8]ԭ>K¾B>{H>J	:I>?8pǽԿN!$5u?^f>Ip}EnJI?1*>BfϾ jD8B
@:>HKjL
>Eo/UyX0!G>E|-Kq2>GN610W4"	>C6VlK}/p>IjԽNھ=},Bc>@*8$I9/>Jm.B{C>u&P>9;RHM5>KY'uD㝌>,xX>24UسF%`)>Kw|`G9qmL>5ʹl>$8MNƾC@>KVcAImNn>{E](@s/
>I9lDJl@`:>A%:G>HUyZo~K0m-|>D>7~+[ kML2DX>F,&:AKY>G[5g`%P1/>C;ʳ3Jf8>HЪGk<#MM
v>@`uAdIԩ>JQXtA/)݄>4)2>93tH+LpJk>KߒEDRu[>+j>2zFEc>K6&X!Gōʜ>5تm>#ؽӾC-sI>J
H>>=:1=a=5Q?Ȱ>I:㜾JQGp>A1xaGf
K">D7o.;>.U0Ɂ^u>Eo8Kq>GSyA7[ n?>BJ0IJlN->I.<^M>}S+W=^
ۼ>>RSBI kfo>Jj
"B\ v>![wU>6ʋG0b>JꎇsEtd6>1B/>-E:[DNB>JեGɤ>9ggF>J%A@k>J	QIӳV>@6GB*9^);Œ>H~G]ξJB]SK>CyTp &ŷҥ4Ɲu>FP
*F_J毣>F;.$3ӕ7m'=upY>C!ݾJyI>Hc};y=fGMj>@1qyIhe>I㸈CAy1I>t,.>8ƃȾG"7h>Jsn`DjƇy>-ȆX>0O@pEc9>J# ˾G'!V>7G]>a;nBfk(j>JZIxp >?X99)<:>H{B"JBsϑ>BIq$s<4SW>F^7Jwb1>EBʑ3 n:4(G>C1}
վJYB+>H%8%굾;\uo;wq`;?>@_F@j@I9idHn>I_?XAf8v>'v6>8[hMKGT}lb>JEDK>.xG>/}'ϾDv,G>J~:G4Y>74C]>nľA{u(I>IF$I>V>?vP˃4Uх׾;[H/w>HQL-J4fH>Cl2EeZ(k b2VJ7|>E$JZ>FK{4}#;e>BI&͍>Hvx[=Jٍ+ fցh>=4{UH	>IcINhBXY
I>"\ 奀>5qv{3F`L	h>JhEs[|>2fI{>(bTCq~PkS>JoxGMr܀>;FZ><4?a>HxMI>Q>Ain8qQ37x^>>FYdPJDHi>D1P0I,,r8>DRJ'6GE>GWh5&98Oq"\H-	V>@QPI#wF>I)MSi2@<>u>8³ZG>S_>JvD Y>-Oo1{>/8NG4D=>J&ȹEF޸T>7
BHd>0mA>IB5\Hᠢ>@Dȸ
~Qjc?:C>Gt)I׹>Cs諯+ľ0	d>Dʲ_J)>F>$6i>A`kʾIKיM*>H) ?kJK>/"!>:n>XG >IT4?{Cj$T [>)%a>1lfID &eH>J{)Fe>6c*U=><2Axߦ>IDH;q3>?X\Z:%>G,ŸIYm*h>COٮw)u:1pI>DW:&I>FV#\6a)C)þ8>A`4ŸI-y1>HW1?.y>`p>:f^GczM`B>I_ξCa+;^>*/)?>0}DAم>IKG{yFjzxE>6p䶥 >HSAJ>IIJH/l`>?LY޾99h>G#N!ÍIVȘ>C
p+GB04>DKlU$SI+0>F97z;un`K>@/#H^aL>H5Kž@HߐM>b>8h:$Fx>IiL9DfG_>.9>-P٠߾Cë1aZ>IOŏFl>9>.h*>2Kw#?'94Q>Hxh<Hب6>@MdQxC[6e>F?-숍IGK)>D5Ѿ1 2P)/5m>CNIn>GRtƚ:bپ?ԅ/>=+^_H	H>I
&Aw'>!M>44)NEW>I<6E8d>3cK̠C>$>v~BT5>I#>#Gܶ>Gt4ϾIBC;>BD'\]V1đ3>D3IM
>E␿N6$ْT~,>@HɎ>HA=U?tT-V>z̀>8ږVRFmi>IlwC#">-g>-.6 C(>IbIF3g>9br>?MճP>H!$NjHW<>Am Ln(K5zsȢ>Ef#I}>DG2vbO*%3>B;"\I$LA>G*u;5WGS(r>IQOB'h`>'iث>1S
DxR->If5E펚]>6h#>ŹEp#@So}>Hr%;|:?>@xZ	At:7(\R>FAy
¾IP>Dߕ=Ӿ03OԾ)뉾ZZ>BiW
Fj:(CƽҲ>=.Ҟ G&$'>H[MAh2I>#zeE>3Dڰ>ISEsNH8>5y>'үؾAa+>HzDG@>>:(
lRj_8M$qz>FfX(I+	>C{T.mJb+Qxm>CݡIի>FƔz]:UK!>=nUaG.M˩~>H*{#AJ2>#p>³1>3^XwʾD%>I:&IE]HԸ>4TE>څ!Ƀ@᳖W>HdF`JG>?#wڭ8tg>F3I9y>Coj A/s)9DZ>Bmb†HM"#>F艓:ᨎJ6U>HV}B:TL>%‡>0>1x8"DT°>I텲(ERz>6H:R0>5.F@2>HnttH:>@33HPZ6;p\>E5wIWF>DR!r!1%{2z8>A5#H6>GA:> \)FXX>Hɼ4B߮>+5io>.)5R~Cb]&k>HB&ƑFM8>G>8ݝ0>Jɾ=9>GzŬHeN
>A]2P"\,|3
o9U(>D'B޾IQ@h>E>3GOa5"&NTʩa>@~2)1ؾH	4>G)?u(>xs YT>6Ӗ$ EE%L>Hc|D}u>1NՕ>%Յ%ӾA@>H|a*G%C>F|TH;E>B3&l,:'޾,P-0>C(\uH!
>FdM?9<cm!><ǟG&ƛ@h>HhHA
H>%lZZ>1+DIR̶>H6.En!:l>69Q>+9=?RSI>GrHTuή>@Vj*jbxh94jI>D?kH.2>D©Ծ30
 ʾ E|n>@NO,9HM6>G-ѓ#>pQG>	\>6?JEWx>H+8C%>1O}D>%c_A_:6B>HR\>"GLv><'+cO\s9:!>F3sHnm>CS
ӊ-?Dy*v>Bz~H[I2=>Fw:4Y]>;3dZɆF%>Hp3BBXX0A>)fJo>.Fb׾C=L>H@w{Fё>8.h>Z]<5k>G
hMH96:>ABM%tTΝɾ1;=բ>CҾ͵~5HS&>E5'7&
	&\Z>>XjGT*b>G8̾@lZ
>!?X>20RDMNu\>HOE#S>5R$5>3h?1}q>G	:~@b^}Lw$4*j>D)Eky H>DyLa4^W9S.2A>@Esd
G]5Z>Gw?&R>e>5A%CD8Qiq>H)aDejT>3Nv[c#> zŇ@7>GG`\^>>Ҫ
w/76Ws:>E3ȏH>D5w2x^2"]	?>@CG>G9q_{>K1>?+>6,EZ>\<>HCD	>1}>#oPھA#뜨&V>GLG_r>=i bk7!$^>EqwEH?>C0^1|^$5XoH>A=PtG[_>G	)={n>
c9J>7LKExS>Hx,(վC+>1Y}n
>$d{A?[>G4ؾG	]A>=د$"K^XF7=*>Eo gQHri>Cn1s$SH>A,߂tGt+w>GeP=W9d>+ڏ>6zJEUHː>Horn~C̑4>1aW>#E\aA;>GΗ-uG6>>)Q0=J6t
d'x>E,E,vyHlm>C~W 2^I!
in>@c(Gam*>G-/>GѾ>XJn>6&ʗ>5G#DI>HjD/?0>3,jv> !$p@aC!&>G(
ӁXGN@4>?j˳Fl84(>DxHgr^iM>Dz.~43aپŒ>?G^tH(>Gv
h@,>U@>XTX>3DD>Ha_%Di&K>5r)1y>ظEk<&>L@CJbx>;P>hXw8CCA>LQv"K9K>@bT=ʥ3@*>Kj*tLM>BHg@9w<<=>J7L|>D
C&C&S)M72P>HC[)M~ԍ>FZs1Er覽1oZd{>FTL]>HSsȾ7b^F&_?w>D%
NL}#>J:B+qK*>KAj}@t)=C;9>@amJ5>LF6lCJ> B>:J[I>L92E}ڠ>*_R>4s}G7^>LzGs}!6>3zݨ;>-AVﯾEލP>L`OAI"P$t>9Yӝ)4>!(ϾCe
@>LֵaJJv>>	>7DA6Ӳpo>K:8K&>BHovвx<J>IbÀ"LAWL]>DxȾ%ږ7{>HhOL>F0;G14{!0-i{>F}z{ELg>Htq'7a5=oP$#Vt>DDC"I|H=AZx)sc>A2}hKJ(>K'v.AbŸo>_4Aτ>=G J=ӄ
>KŞCߩ>#Bmx/>7YH|GL^䝄F*ǻK>01$ICF\^>L`V3BHY<>6p>%;ODR&J7>KzԾI&\r><4>iL_A\vR>K&9g	ʾJ]㮃>A:^;(ujo=7h&>I.,>K/>CRa#^<7
7P>HJyGɾL4B>F(Go09s06t>FFs\vL.T;E3>H#Q7)yb$8Vh>Cp,K@{<>I}=j*;X	x>A4̾Jлo?>JN}A2dJ>lbYV>K
5D>9>&wJb>5`XGDٸG>LumF>21!>.8unEE>K,{H~qS>8{Jy>B{YBq3>KR_>e!J	IJj>?1e=.
~@*d+>J>1QK#oG>B}/Cθ<'\9(y[>HK>EXh
+	l3>K.(>Fr hKE6>GNؾ5<'lW|\>DTZݼ
KN4>I_h;W/$V>A@7¾JK_>J|y@Q>G/	1>Ka@x/Cʹ?>%+Rb>6!IGY>KmG‘FAF>1>7r>-$EBC.c>KɊCHNkL3>8]ԭ>K¾B>{H>J	:I>?8pǽԿN!$5u?^f>Ip}EnJI?1*>BfϾ jD8B
@:>HKjL
>Eo/UyX0!G>E|-Kq2>GN610W4"	>C6VlK}/p>IjԽNھ=},Bc>@*8$I9/>Jm.B{C>u&P>9;RHM5>KY'uD㝌>,xX>24UسF%`)>Kw|`G9qmL>5ʹl>$8MNƾC@>KVcAImNn>{E](@s/
>I9lDJl@`:>A%:G>HUyZo~K0m-|>D>7~+[ kML2DX>F,&:AKY>G[5g`%P1/>C;ʳ3Jf8>HЪGk<#MM
v>@`uAdIԩ>JQXtA/)݄>4)2>93tH+LpJk>KߒEDRu[>+j>2zFEc>K6&X!Gōʜ>5تm>#ؽӾC-sI>J
H>>=:1=a=5Q?Ȱ>I:㜾JQGp>A1xaGf
K">D7o.;>.U0Ɂ^u>Eo8Kq>GSyA7[ n?>BJ0IJlN->I.<^M>}S+W=^
ۼ>>RSBI kfo>Jj
"B\ v>![wU>6ʋG0b>JꎇsEtd6>1B/>-E:[DNB>JեGɤ>9ggF>J%A@k>J	QIӳV>@6GB*9^);Œ>H~G]ξJB]SK>CyTp &ŷҥ4Ɲu>FP
*F_J毣>F;.$3ӕ7m'=upY>C!ݾJyI>Hc};y=fGMj>@1qyIhe>I㸈CAy1I>t,.>8ƃȾG"7h>Jsn`DjƇy>-ȆX>0O@pEc9>J# ˾G'!V>7G]>a;nBfk(j>JZIxp >?X99)<:>H{B"JBsϑ>BIq$s<4SW>F^7Jwb1>EBʑ3 n:4(G>C1}
վJYB+>H%8%굾;\uo;wq`;?>@_F@j@I9idHn>I_?XAf8v>'v6>8[hMKGT}lb>JEDK>.xG>/}'ϾDv,G>J~:G4Y>74C]>nľA{u(I>IF$I>V>?vP˃4Uх׾;[H/w>HQL-J4fH>Cl2EeZ(k b2VJ7|>E$JZ>FK{4}#;e>BI&͍>Hvx[=Jٍ+ fցh>=4{UH	>IcINhBXY
I>"\ 奀>5qv{3F`L	h>JhEs[|>2fI{>(bTCq~PkS>JoxGMr܀>;FZ><4?a>HxMI>Q>Ain8qQ37x^>>FYdPJDHi>D1P0I,,r8>DRJ'6GE>GWh5&98Oq"\H-	V>@QPI#wF>I)MSi2@<>u>8³ZG>S_>JvD Y>-Oo1{>/8NG4D=>J&ȹEF޸T>7
BHd>0mA>IB5\Hᠢ>@Dȸ
~Qjc?:C>Gt)I׹>Cs諯+ľ0	d>Dʲ_J)>F>$6i>A`kʾIKיM*>H) ?kJK>/"!>:n>XG >IT4?{Cj$T [>)%a>1lfID &eH>J{)Fe>6c*U=><2Axߦ>IDH;q3>?X\Z:%>G,ŸIYm*h>COٮw)u:1pI>DW:&I>FV#\6a)C)þ8>A`4ŸI-y1>HW1?.y>`p>:f^GczM`B>I_ξCa+;^>*/)?>0}DAم>IKG{yFjzxE>6p䶥 >HSAJ>IIJH/l`>?LY޾99h>G#N!ÍIVȘ>C
p+GB04>DKlU$SI+0>F97z;un`K>@/#H^aL>H5Kž@HߐM>b>8h:$Fx>IiL9DfG_>.9>-P٠߾Cë1aZ>IOŏFl>9>.h*>2Kw#?'94Q>Hxh<Hب6>@MdQxC[6e>F?-숍IGK)>D5Ѿ1 2P)/5m>CNIn>GRtƚ:bپ?ԅ/>=+^_H	H>I
&Aw'>!M>44)NEW>I<6E8d>3cK̠C>$>v~BT5>I#>#Gܶ>Gt4ϾIBC;>BD'\]V1đ3>D3IM
>E␿N6$ْT~,>@HɎ>HA=U?tT-V>z̀>8ږVRFmi>IlwC#">-g>-.6 C(>IbIF3g>9br>?MճP>H!$NjHW<>Am Ln(K5zsȢ>Ef#I}>DG2vbO*%3>B;"\I$LA>G*u;5WGS(r>IQOB'h`>'iث>1S
DxR->If5E펚]>6h#>ŹEp#@So}>Hr%;|:?>@xZ	At:7(\R>FAy
¾IP>Dߕ=Ӿ03OԾ)뉾ZZ>BiW
Fj:(CƽҲ>=.Ҟ G&$'>H[MAh2I>#zeE>3Dڰ>ISEsNH8>5y>'үؾAa+>HzDG@>>:(
lRj_8M$qz>FfX(I+	>C{T.mJb+Qxm>CݡIի>FƔz]:UK!>=nUaG.M˩~>H*{#AJ2>#p>³1>3^XwʾD%>I:&IE]HԸ>4TE>څ!Ƀ@᳖W>HdF`JG>?#wڭ8tg>F3I9y>Coj A/s)9DZ>Bmb†HM"#>F艓:ᨎJ6U>HV}B:TL>%‡>0>1x8"DT°>I텲(ERz>6H:R0>5.F@2>HnttH:>@33HPZ6;p\>E5wIWF>DR!r!1%{2z8>A5#H6>GA:> \)FXX>Hɼ4B߮>+5io>.)5R~Cb]&k>HB&ƑFM8>G>8ݝ0>Jɾ=9>GzŬHeN
>A]2P"\,|3
o9U(>D'B޾IQ@h>E>3GOa5"&NTʩa>@~2)1ؾH	4>G)?u(>xs YT>6Ӗ$ EE%L>Hc|D}u>1NՕ>%Յ%ӾA@>H|a*G%C>F|TH;E>B3&l,:'޾,P-0>C(\uH!
>FdM?9<cm!><ǟG&ƛ@h>HhHA
H>%lZZ>1+DIR̶>H6.En!:l>69Q>+9=?RSI>GrHTuή>@Vj*jbxh94jI>D?kH.2>D©Ծ30
 ʾ E|n>@NO,9HM6>G-ѓ#>pQG>	\>6?JEWx>H+8C%>1O}D>%c_A_:6B>HR\>"GLv><'+cO\s9:!>F3sHnm>CS
ӊ-?Dy*v>Bz~H[I2=>Fw:4Y]>;3dZɆF%>Hp3BBXX0A>)fJo>.Fb׾C=L>H@w{Fё>8.h>Z]<5k>G
hMH96:>ABM%tTΝɾ1;=բ>CҾ͵~5HS&>E5'7&
	&\Z>>XjGT*b>G8̾@lZ
>!?X>20RDMNu\>HOE#S>5R$5>3h?1}q>G	:~@b^}Lw$4*j>D)Eky H>DyLa4^W9S.2A>@Esd
G]5Z>Gw?&R>e>5A%CD8Qiq>H)aDejT>3Nv[c#> zŇ@7>GG`\^>>Ҫ
w/76Ws:>E3ȏH>D5w2x^2"]	?>@CG>G9q_{>K1>?+>6,EZ>\<>HCD	>1}>#oPھA#뜨&V>GLG_r>=i bk7!$^>EqwEH?>C0^1|^$5XoH>A=PtG[_>G	)={n>
c9J>7LKExS>Hx,(վC+>1Y}n
>$d{A?[>G4ؾG	]A>=د$"K^XF7=*>Eo gQHri>Cn1s$SH>A,߂tGt+w>GeP=W9d>+ڏ>6zJEUHː>Horn~C̑4>1aW>#E\aA;>GΗ-uG6>>)Q0=J6t
d'x>E,E,vyHlm>C~W 2^I!
in>@c(Gam*>G-/>GѾ>XJn>6&ʗ>5G#DI>HjD/?0>3,jv> !$p@aC!&>G(
ӁXGN@4>?j˳Fl84(>DxHgr^iM>Dz.~43aپŒ>?G^tH(>Gv
h@,>U@>XTX>3DD>Ha_%Di&K>5r)1y>ظEk<&>L@CJbx>;P>hXw8CCA>LQv"K9K>@bT=ʥ3@*>Kj*tLM>BHg@9w<<=>J7L|>D
C&C&S)M72P>HC[)M~ԍ>FZs1Er覽1oZd{>FTL]>HSsȾ7b^F&_?w>D%
NL}#>J:B+qK*>KAj}@t)=C;9>@amJ5>LF6lCJ> B>:J[I>L92E}ڠ>*_R>4s}G7^>LzGs}!6>3zݨ;>-AVﯾEލP>L`OAI"P$t>9Yӝ)4>!(ϾCe
@>LֵaJJv>>	>7DA6Ӳpo>K:8K&>BHovвx<J>IbÀ"LAWL]>DxȾ%ږ7{>HhOL>F0;G14{!0-i{>F}z{ELg>Htq'7a5=oP$#Vt>DDC"I|H=AZx)sc>A2}hKJ(>K'v.AbŸo>_4Aτ>=G J=ӄ
>KŞCߩ>#Bmx/>7YH|GL^䝄F*ǻK>01$ICF\^>L`V3BHY<>6p>%;ODR&J7>KzԾI&\r><4>iL_A\vR>K&9g	ʾJ]㮃>A:^;(ujo=7h&>I.,>K/>CRa#^<7
7P>HJyGɾL4B>F(Go09s06t>FFs\vL.T;E3>H#Q7)yb$8Vh>Cp,K@{<>I}=j*;X	x>A4̾Jлo?>JN}A2dJ>lbYV>K
5D>9>&wJb>5`XGDٸG>LumF>21!>.8unEE>K,{H~qS>8{Jy>B{YBq3>KR_>e!J	IJj>?1e=.
~@*d+>J>1QK#oG>B}/Cθ<'\9(y[>HK>EXh
+	l3>K.(>Fr hKE6>GNؾ5<'lW|\>DTZݼ
KN4>I_h;W/$V>A@7¾JK_>J|y@Q>G/	1>Ka@x/Cʹ?>%+Rb>6!IGY>KmG‘FAF>1>7r>-$EBC.c>KɊCHNkL3>8]ԭ>K¾B>{H>J	:I>?8pǽԿN!$5u?^f>Ip}EnJI?1*>BfϾ jD8B
@:>HKjL
>Eo/UyX0!G>E|-Kq2>GN610W4"	>C6VlK}/p>IjԽNھ=},Bc>@*8$I9/>Jm.B{C>u&P>9;RHM5>KY'uD㝌>,xX>24UسF%`)>Kw|`G9qmL>5ʹl>$8MNƾC@>KVcAImNn>{E](@s/
>I9lDJl@`:>A%:G>HUyZo~K0m-|>D>7~+[ kML2DX>F,&:AKY>G[5g`%P1/>C;ʳ3Jf8>HЪGk<#MM
v>@`uAdIԩ>JQXtA/)݄>4)2>93tH+LpJk>KߒEDRu[>+j>2zFEc>K6&X!Gōʜ>5تm>#ؽӾC-sI>J
H>>=:1=a=5Q?Ȱ>I:㜾JQGp>A1xaGf
K">D7o.;>.U0Ɂ^u>Eo8Kq>GSyA7[ n?>BJ0IJlN->I.<^M>}S+W=^
ۼ>>RSBI kfo>Jj
"B\ v>![wU>6ʋG0b>JꎇsEtd6>1B/>-E:[DNB>JեGɤ>9ggF>J%A@k>J	QIӳV>@6GB*9^);Œ>H~G]ξJB]SK>CyTp &ŷҥ4Ɲu>FP
*F_J毣>F;.$3ӕ7m'=upY>C!ݾJyI>Hc};y=fGMj>@1qyIhe>I㸈CAy1I>t,.>8ƃȾG"7h>Jsn`DjƇy>-ȆX>0O@pEc9>J# ˾G'!V>7G]>a;nBfk(j>JZIxp >?X99)<:>H{B"JBsϑ>BIq$s<4SW>F^7Jwb1>EBʑ3 n:4(G>C1}
վJYB+>H%8%굾;\uo;wq`;?>@_F@j@I9idHn>I_?XAf8v>'v6>8[hMKGT}lb>JEDK>.xG>/}'ϾDv,G>J~:G4Y>74C]>nľA{u(I>IF$I>V>?vP˃4Uх׾;[H/w>HQL-J4fH>Cl2EeZ(k b2VJ7|>E$JZ>FK{4}#;e>BI&͍>Hvx[=Jٍ+ fցh>=4{UH	>IcINhBXY
I>"\ 奀>5qv{3F`L	h>JhEs[|>2fI{>(bTCq~PkS>JoxGMr܀>;FZ><4?a>HxMI>Q>Ain8qQ37x^>>FYdPJDHi>D1P0I,,r8>DRJ'6GE>GWh5&98Oq"\H-	V>@QPI#wF>I)MSi2@<>u>8³ZG>S_>JvD Y>-Oo1{>/8NG4D=>J&ȹEF޸T>7
BHd>0mA>IB5\Hᠢ>@Dȸ
~Qjc?:C>Gt)I׹>Cs諯+ľ0	d>Dʲ_J)>F>$6i>A`kʾIKיM*>H) ?kJK>/"!>:n>XG >IT4?{Cj$T [>)%a>1lfID &eH>J{)Fe>6c*U=><2Axߦ>IDH;q3>?X\Z:%>G,ŸIYm*h>COٮw)u:1pI>DW:&I>FV#\6a)C)þ8>A`4ŸI-y1>HW1?.y>`p>:f^GczM`B>I_ξCa+;^>*/)?>0}DAم>IKG{yFjzxE>6p䶥 >HSAJ>IIJH/l`>?LY޾99h>G#N!ÍIVȘ>C
p+GB04>DKlU$SI+0>F97z;un`K>@/#H^aL>H5Kž@HߐM>b>8h:$Fx>IiL9DfG_>.9>-P٠߾Cë1aZ>IOŏFl>9>.h*>2Kw#?'94Q>Hxh<Hب6>@MdQxC[6e>F?-숍IGK)>D5Ѿ1 2P)/5m>CNIn>GRtƚ:bپ?ԅ/>=+^_H	H>I
&Aw'>!M>44)NEW>I<6E8d>3cK̠C>$>v~BT5>I#>#Gܶ>Gt4ϾIBC;>BD'\]V1đ3>D3IM
>E␿N6$ْT~,>@HɎ>HA=U?tT-V>z̀>8ږVRFmi>IlwC#">-g>-.6 C(>IbIF3g>9br>?MճP>H!$NjHW<>Am Ln(K5zsȢ>Ef#I}>DG2vbO*%3>B;"\I$LA>G*u;5WGS(r>IQOB'h`>'iث>1S
DxR->If5E펚]>6h#>ŹEp#@So}>Hr%;|:?>@xZ	At:7(\R>FAy
¾IP>Dߕ=Ӿ03OԾ)뉾ZZ>BiW
Fj:(CƽҲ>=.Ҟ G&$'>H[MAh2I>#zeE>3Dڰ>ISEsNH8>5y>'үؾAa+>HzDG@>>:(
lRj_8M$qz>FfX(I+	>C{T.mJb+Qxm>CݡIի>FƔz]:UK!>=nUaG.M˩~>H*{#AJ2>#p>³1>3^XwʾD%>I:&IE]HԸ>4TE>څ!Ƀ@᳖W>HdF`JG>?#wڭ8tg>F3I9y>Coj A/s)9DZ>Bmb†HM"#>F艓:ᨎJ6U>HV}B:TL>%‡>0>1x8"DT°>I텲(ERz>6H:R0>5.F@2>HnttH:>@33HPZ6;p\>E5wIWF>DR!r!1%{2z8>A5#H6>GA:> \)FXX>Hɼ4B߮>+5io>.)5R~Cb]&k>HB&ƑFM8>G>8ݝ0>Jɾ=9>GzŬHeN
>A]2P"\,|3
o9U(>D'B޾IQ@h>E>3GOa5"&NTʩa>@~2)1ؾH	4>G)?u(>xs YT>6Ӗ$ EE%L>Hc|D}u>1NՕ>%Յ%ӾA@>H|a*G%C>F|TH;E>B3&l,:'޾,P-0>C(\uH!
>FdM?9<cm!><ǟG&ƛ@h>HhHA
H>%lZZ>1+DIR̶>H6.En!:l>69Q>+9=?RSI>GrHTuή>@Vj*jbxh94jI>D?kH.2>D©Ծ30
 ʾ E|n>@NO,9HM6>G-ѓ#>pQG>	\>6?JEWx>H+8C%>1O}D>%c_A_:6B>HR\>"GLv><'+cO\s9:!>F3sHnm>CS
ӊ-?Dy*v>Bz~H[I2=>Fw:4Y]>;3dZɆF%>Hp3BBXX0A>)fJo>.Fb׾C=L>H@w{Fё>8.h>Z]<5k>G
hMH96:>ABM%tTΝɾ1;=բ>CҾ͵~5HS&>E5'7&
	&\Z>>XjGT*b>G8̾@lZ
>!?X>20RDMNu\>HOE#S>5R$5>3h?1}q>G	:~@b^}Lw$4*j>D)Eky H>DyLa4^W9S.2A>@Esd
G]5Z>Gw?&R>e>5A%CD8Qiq>H)aDejT>3Nv[c#> zŇ@7>GG`\^>>Ҫ
w/76Ws:>E3ȏH>D5w2x^2"]	?>@CG>G9q_{>K1>?+>6,EZ>\<>HCD	>1}>#oPھA#뜨&V>GLG_r>=i bk7!$^>EqwEH?>C0^1|^$5XoH>A=PtG[_>G	)={n>
c9J>7LKExS>Hx,(վC+>1Y}n
>$d{A?[>G4ؾG	]A>=د$"K^XF7=*>Eo gQHri>Cn1s$SH>A,߂tGt+w>GeP=W9d>+ڏ>6zJEUHː>Horn~C̑4>1aW>#E\aA;>GΗ-uG6>>)Q0=J6t
d'x>E,E,vyHlm>C~W 2^I!
in>@c(Gam*>G-/>GѾ>XJn>6&ʗ>5G#DI>HjD/?0>3,jv> !$p@aC!&>G(
ӁXGN@4>?j˳Fl84(>DxHgr^iM>Dz.~43aپŒ>?G^tH(>Gv
h@,>U@>XTX>3DD>Ha_%Di&K>5r)1y>ظ>1H>G #(G>@Ϲ"1 M2t>CUHT
>E8'6	n>Z>=W
Ŕ۾FNՇ>Gl4AUw>%W\>0allC;GmS>H>5֑Eڒ^p>85|6=Q23;V)>FpؾG>>BMR)Y,ϟf>BsVҾHFi)>F^b:_=
80/>9y(&_EcE.>H!uoþBH>.쬟b>(S/A57Ы>G9PF'B>Ed}`H<;->Cyx[E1h*j䡾#HcŢF>@քwAGg>>Fgd>t`>>5Ma.SDYl>HGsǾDM},>376>^XǕ?*	>G3ɘ
Gh3>@T7'~) Aܾ2&>C,vHE!@6[۠Tc>=r&Fޏτ>GUEAuɴ]>>/:+d$B6>H#&E,>9$:=^4&:KP>F8	þHe>B$-"N+(c>A;GΗ9t>FV歾<8g>	`"~>7(4LE*0>H0C(9ξ>2I&L>!ԗUپ@Yd>G^M(G&S>?1b,Z3t>D!5H4t,8>DႾ5XO;[Vl>=8FSޅ,t>Gn$iABO$˰'>&!91Y>/(p_B5(P>H "hEt>9i=!Dh:hT>E`1H[߆>BBξ.
ؾ'&i>Alad̾GsI^j>F ,=B/>7s>6 F5DӢ>H,in9DﵛS>3>L˳?mn3>GG[ud>@qx!B1:Y>C|@H4Jn>EQ91Q7^j>lǗh>;yʷYF8R+>GhRþB.=6>+[M>)ǝFžA>Gz_+PFej
>E֖MH >C7L{2Ƒb>?쐡xG'rB>GAt@;[	r> D>2lоC,>H!:E?	y*,>7>I޾;>F1@FaGJώo>B5,-4)ZT)ec>AdGh(l>FuU(<&C>
'tv>6{H_pD?^>>HBuRDg>3z>E?K'?$Z/>F]5GbV>@$q#`Kx0Ḽ>C&tH$K>E U9J	F~>:nxEbZ>G:eBBv&>/ĸ$>%phlHA1>GFAh>>cVKnN4_8C>D9H[$2R>DG95"Ʒ~*O>=WvF2[	>G-x۾AM!y>)a>,ȾB+	
G>GBCF9:>;Z%흾7-	>E\Hps">CiL830TVASZ>?KxxF-)t>G\ǰ@-+>#G>0NxCLJ6>GQ|tE@>95.~ 9Yz,>Eoe(GL?@>C"	0hH";E>@<)GKQo>G[?+E
>6S>2KeCd>H袓sE8>7yP9=ƨz:^U~>EBDYz˾G:>Bٌ.CҾ&*6|A>AG}8`<>F!ھ>|x>٣>3		D=>HD㐂Z>6̈́RO><r؂;,F>F;!
GV;>B8[/,B(7^>Arz
"G">F=2ϐ0>G>4VDB>H|DyE_=>66e.>
M|'FW[5Gêz>BXT+VycԾ)$$>Ab(SG!p6>F<{{=j>|<>4\DM#>HkGD[6//dH>
O ?!
FThGƂ/O>B!,'.1qԾ(p׶>A{G9>FF"ޗ=B>VBG_>4o#WD,Wa>H'Dؖ=~>6@+9>nom;)>F1OܒG&s>Bb6c-ƪS&FNf(>A,*fGФ >F>++h>_ħ>3m	p%^C_>HU;FwE'at|>7H/=S̝3':z>E[`GPEj>BWme0MƜUX#ՕK>@k|y%GRP>GXxA@y> \m>1!,CWG>H
9eTE>9C.24Ϋ,4I9g>E}|۾H
	>CG2Pڕ6Eھ/2qi>?Gb}>Gl+s@mY>%a귎>/«WKB.A>GcpF%%:l>;k)ľ[76Xְ>DiWH%d,>DKrD4^Jp|">=d/'JǾF>G4XAj%>+CSd>)G(jƚnFt{>>DږhqoW3LM>Cu{H$c>E/c/I7EW>:tXEWWk>HwyWCB<<>1&Q>!@L@G4:FOGW$u%>@uj#-/0/j&>B̏	Gk>FiI;zW>\ĩ>6dј۾DI>H0!zDa1N!>5*UR>9:=wbI>F~X/G4S>B4GA.Z,}'>AAG ' >FW06o?O<>效%@>2P舾C+>H"a\EDU>9Εn!{D8ݱu>EpqȄH,ȓ>Cv3dq@UkZ>>Fتܷ>GKAT&>))y">*9ҷAќV|>GgUFˠ>>Eٸfn32o>C[H67/d>EfSWc18i4i>9E8d>H-b	Cm:>2R>"?&aZd>FʪNG6k#>A՜T(%`1$+w>>A'/pG>FxBI>.A!>*S>3ۗ0¾C"n>H?\0־EuXn>8G_F=`jL9i$M>Eq1H;>>C* 3-?"P>>TFE6>GBArc!>*zЧ>)j0ARӥ?>GǕ]F>Q%>?"REs[M2>L>CPqH?@vr>EBc:Ҟh=z|V"<>8Us^EThO[?D>HS(ƑDI$O]>4EN>!+k=b⭱9>FZdϾHזF>B|JD.n7%!e>@60G|tw>G_{F@m߮ɟ[>"+>096ľBݳ>H(/e\ξFc5fN>D+?"(Hd{k;>EfK7u-I3.>:ʜCNF
=>HIFNʾC>2WC)%>z?}|T>G A'GسA$>Af(l*U*Kb-<>Aŧ4G>G z?yV<>C>2]hO)C:|>HTTѪ$Fi>;!\|1فQ7JHՂx>E(eHwkY
Ec>D٦sWȾ6$.O>;ڇFPdF(>HQC8C['>1J> 'pP@cxc>GG'똾Gu>A'm3)~+*%R>AZ*GQ7>G3M^?S\n&>">2CӐ8C!>}>HdU/ھFE]F44>;Ni:A6-)n>D4QHݤ4>E!#[U7`5=-hFu>;t\־F)m>HurjCʵE>2[>>X?
,>G3ԴH"1v>BIy5,Y'yJdi>AOСWGs>G	#@P2>#Ԟ}	>0B5MB8b>HR%OѾF>=#5dL4RG>DQⲃH<>E_9ń,ZV=鵘
Y-R>8!xEdBY>Hx9DˁCJ>6*>
A0]Ff
H%>CLkn25YH 	u|۶>?VGG[D>H->Jm
B*9Yݝ>,"0>(u1&jIAӀ19>GZ'VxGW>@b]#s0Ga>BJھHlE8>G M>2I>uV>4!WӾD:p*>H,ӾF3ب>:'!I7Ǚ8>EWjHɩwߦ>EAx
7}rKv1f>;19B¾FL9d>HaD5BR>4Z=;>!i/>`/~>GfHVG>C
wJ;0yg]#)>@Z5G
hͻ>H,]EmAѮ>)I&*p>*ՉO̾BBܨ>H?HG;SF>@%eѾ"UO[0L>C7flPH>GZ>M}X>eub>42HاQuFnn%>;|5e_Xؾ7R(>EGfH8>E*\8vzǗk>:G`jF"Ac>H%>0D2q>5hX>d
=	q*:>Fݚ:X㴾HtKY>C:22(T^^>?8G}>HٗϾB k}>/%>% @|')>HbdYkHVB
>A&Co/)a8%Ⱦ*
@1	U>Bch\[HlZ:=>G:D#7@:>$+Is>0RgίC6%>HrG]qR>?w!AYƾ3z|H>D94(Hdo>GޔO=U>z2>5DwKI>I!uFuju5m>;![U30C78I!>EqI6y$>EAd(8bh&3F>:FDcF@r>I94iE8m[D>6ٿ3>
hj8FY+II-C5>DFվ4Uh*>>jgޗνG[QZ}>IkheCc>2byT> qMɾ@#n>G쩻$RHCw>C,60Fr$ʁ<>A5žH2Y5+>H6gBv5J>,uijy2>(x^׾A|2,>H'fҖH4A>A˾(vEK,[97>BppH(>HA{;A>$>0OtپCIטLGӤ.>@XdrW jm2>>CA](I:Ċ>GMݾ?Q֏>ݣ>3n3DpM)e>IbTGc
.>=S1o¿&A5e>DZ 闾I6Fo>GT
4D>6T	@Ep5>I׆FSE;>;m5*&kCz8BWzp[>E2ZFIQڴ>Fr!::f-P=&EIC>97oﯾFDyV}>IjhSǾF$	]t&>9ڮ=&7U:d>FqI|E>E8G_m>;(wF|>I
kEr
>7s>
Ԍ<#+'G;D1Ib9ؑ>EH6^{얋>=a|G}\̾=w>IβE㧳>58k>>6>`>G|d7IԺ>Dy>4qT[ 	~@>?HG~>I,|D7S_>3a\|T>-੾?h<>HM>I>Dh+3"2PoK>@AY%HE;>I<ӾDAGֲ>2>	> ?@~>Hi)a͹ICre>D= q2,	hqd!>@MʾH)>`>IhIC:Da-o
>1;E>"k_@'%v>Ht9VI
i>Ct=1̕#9>AM.HF>IiVCt>1iA+>#o#~aA>H̡=l0IҹIH
>CaUf1WyUw2#H>A.eH">I￾Cӥ>1]%<>#e
;5A5o*z>HzEȾIkh>DP{1|1#|~M|>A16!M:oH9PaX>IuoDʥ>1Z># A$<>H^ӡNJyUi=P>D='5o2J)j
"˱>ARH5>J&BrɾDgcX6A>2l
i8>!O[椾@>Hrl;J=N>D"2( Lo>@H٥l}e>JWh'žDz>3D|>;n
%@V>H|ފJq_@>El47Hkh	+>@G5#þH].|>Jg;E]_7>5ؑ>:M?+W>HԾJ)Ŝ>ER4e5w/K>?Cc@`HoU9?Z>Jŀ?'ՙF{Ũ>6ܙa>:첝!>yoe>HCUJRG>F`5\s7xnp	4뭴>=
əH;,z>J#F7Ry>95C>*~gG'E8K
jX7>G)md:N¥߽5>;xjӾGlr>K!G
9L:>;<,,۽z?#:A`ї->G4rYDAK-Ǻh>1H>G #(G>@Ϲ"1 M2t>CUHT
>E8'6	n>Z>=W
Ŕ۾FNՇ>Gl4AUw>%W\>0allC;GmS>H>5֑Eڒ^p>85|6=Q23;V)>FpؾG>>BMR)Y,ϟf>BsVҾHFi)>F^b:_=
80/>9y(&_EcE.>H!uoþBH>.쬟b>(S/A57Ы>G9PF'B>Ed}`H<;->Cyx[E1h*j䡾#HcŢF>@քwAGg>>Fgd>t`>>5Ma.SDYl>HGsǾDM},>376>^XǕ?*	>G3ɘ
Gh3>@T7'~) Aܾ2&>C,vHE!@6[۠Tc>=r&Fޏτ>GUEAuɴ]>>/:+d$B6>H#&E,>9$:=^4&:KP>F8	þHe>B$-"N+(c>A;GΗ9t>FV歾<8g>	`"~>7(4LE*0>H0C(9ξ>2I&L>!ԗUپ@Yd>G^M(G&S>?1b,Z3t>D!5H4t,8>DႾ5XO;[Vl>=8FSޅ,t>Gn$iABO$˰'>&!91Y>/(p_B5(P>H "hEt>9i=!Dh:hT>E`1H[߆>BBξ.
ؾ'&i>Alad̾GsI^j>F ,=B/>7s>6 F5DӢ>H,in9DﵛS>3>L˳?mn3>GG[ud>@qx!B1:Y>C|@H4Jn>EQ91Q7^j>lǗh>;yʷYF8R+>GhRþB.=6>+[M>)ǝFžA>Gz_+PFej
>E֖MH >C7L{2Ƒb>?쐡xG'rB>GAt@;[	r> D>2lоC,>H!:E?	y*,>7>I޾;>F1@FaGJώo>B5,-4)ZT)ec>AdGh(l>FuU(<&C>
'tv>6{H_pD?^>>HBuRDg>3z>E?K'?$Z/>F]5GbV>@$q#`Kx0Ḽ>C&tH$K>E U9J	F~>:nxEbZ>G:eBBv&>/ĸ$>%phlHA1>GFAh>>cVKnN4_8C>D9H[$2R>DG95"Ʒ~*O>=WvF2[	>G-x۾AM!y>)a>,ȾB+	
G>GBCF9:>;Z%흾7-	>E\Hps">CiL830TVASZ>?KxxF-)t>G\ǰ@-+>#G>0NxCLJ6>GQ|tE@>95.~ 9Yz,>Eoe(GL?@>C"	0hH";E>@<)GKQo>G[?+E
>6S>2KeCd>H袓sE8>7yP9=ƨz:^U~>EBDYz˾G:>Bٌ.CҾ&*6|A>AG}8`<>F!ھ>|x>٣>3		D=>HD㐂Z>6̈́RO><r؂;,F>F;!
GV;>B8[/,B(7^>Arz
"G">F=2ϐ0>G>4VDB>H|DyE_=>66e.>
M|'FW[5Gêz>BXT+VycԾ)$$>Ab(SG!p6>F<{{=j>|<>4\DM#>HkGD[6//dH>
O ?!
FThGƂ/O>B!,'.1qԾ(p׶>A{G9>FF"ޗ=B>VBG_>4o#WD,Wa>H'Dؖ=~>6@+9>nom;)>F1OܒG&s>Bb6c-ƪS&FNf(>A,*fGФ >F>++h>_ħ>3m	p%^C_>HU;FwE'at|>7H/=S̝3':z>E[`GPEj>BWme0MƜUX#ՕK>@k|y%GRP>GXxA@y> \m>1!,CWG>H
9eTE>9C.24Ϋ,4I9g>E}|۾H
	>CG2Pڕ6Eھ/2qi>?Gb}>Gl+s@mY>%a귎>/«WKB.A>GcpF%%:l>;k)ľ[76Xְ>DiWH%d,>DKrD4^Jp|">=d/'JǾF>G4XAj%>+CSd>)G(jƚnFt{>>DږhqoW3LM>Cu{H$c>E/c/I7EW>:tXEWWk>HwyWCB<<>1&Q>!@L@G4:FOGW$u%>@uj#-/0/j&>B̏	Gk>FiI;zW>\ĩ>6dј۾DI>H0!zDa1N!>5*UR>9:=wbI>F~X/G4S>B4GA.Z,}'>AAG ' >FW06o?O<>效%@>2P舾C+>H"a\EDU>9Εn!{D8ݱu>EpqȄH,ȓ>Cv3dq@UkZ>>Fتܷ>GKAT&>))y">*9ҷAќV|>GgUFˠ>>Eٸfn32o>C[H67/d>EfSWc18i4i>9E8d>H-b	Cm:>2R>"?&aZd>FʪNG6k#>A՜T(%`1$+w>>A'/pG>FxBI>.A!>*S>3ۗ0¾C"n>H?\0־EuXn>8G_F=`jL9i$M>Eq1H;>>C* 3-?"P>>TFE6>GBArc!>*zЧ>)j0ARӥ?>GǕ]F>Q%>?"REs[M2>L>CPqH?@vr>EBc:Ҟh=z|V"<>8Us^EThO[?D>HS(ƑDI$O]>4EN>!+k=b⭱9>FZdϾHזF>B|JD.n7%!e>@60G|tw>G_{F@m߮ɟ[>"+>096ľBݳ>H(/e\ξFc5fN>D+?"(Hd{k;>EfK7u-I3.>:ʜCNF
=>HIFNʾC>2WC)%>z?}|T>G A'GسA$>Af(l*U*Kb-<>Aŧ4G>G z?yV<>C>2]hO)C:|>HTTѪ$Fi>;!\|1فQ7JHՂx>E(eHwkY
Ec>D٦sWȾ6$.O>;ڇFPdF(>HQC8C['>1J> 'pP@cxc>GG'똾Gu>A'm3)~+*%R>AZ*GQ7>G3M^?S\n&>">2CӐ8C!>}>HdU/ھFE]F44>;Ni:A6-)n>D4QHݤ4>E!#[U7`5=-hFu>;t\־F)m>HurjCʵE>2[>>X?
,>G3ԴH"1v>BIy5,Y'yJdi>AOСWGs>G	#@P2>#Ԟ}	>0B5MB8b>HR%OѾF>=#5dL4RG>DQⲃH<>E_9ń,ZV=鵘
Y-R>8!xEdBY>Hx9DˁCJ>6*>
A0]Ff
H%>CLkn25YH 	u|۶>?VGG[D>H->Jm
B*9Yݝ>,"0>(u1&jIAӀ19>GZ'VxGW>@b]#s0Ga>BJھHlE8>G M>2I>uV>4!WӾD:p*>H,ӾF3ب>:'!I7Ǚ8>EWjHɩwߦ>EAx
7}rKv1f>;19B¾FL9d>HaD5BR>4Z=;>!i/>`/~>GfHVG>C
wJ;0yg]#)>@Z5G
hͻ>H,]EmAѮ>)I&*p>*ՉO̾BBܨ>H?HG;SF>@%eѾ"UO[0L>C7flPH>GZ>M}X>eub>42HاQuFnn%>;|5e_Xؾ7R(>EGfH8>E*\8vzǗk>:G`jF"Ac>H%>0D2q>5hX>d
=	q*:>Fݚ:X㴾HtKY>C:22(T^^>?8G}>HٗϾB k}>/%>% @|')>HbdYkHVB
>A&Co/)a8%Ⱦ*
@1	U>Bch\[HlZ:=>G:D#7@:>$+Is>0RgίC6%>HrG]qR>?w!AYƾ3z|H>D94(Hdo>GޔO=U>z2>5DwKI>I!uFuju5m>;![U30C78I!>EqI6y$>EAd(8bh&3F>:FDcF@r>I94iE8m[D>6ٿ3>
hj8FY+II-C5>DFվ4Uh*>>jgޗνG[QZ}>IkheCc>2byT> qMɾ@#n>G쩻$RHCw>C,60Fr$ʁ<>A5žH2Y5+>H6gBv5J>,uijy2>(x^׾A|2,>H'fҖH4A>A˾(vEK,[97>BppH(>HA{;A>$>0OtپCIטLGӤ.>@XdrW jm2>>CA](I:Ċ>GMݾ?Q֏>ݣ>3n3DpM)e>IbTGc
.>=S1o¿&A5e>DZ 闾I6Fo>GT
4D>6T	@Ep5>I׆FSE;>;m5*&kCz8BWzp[>E2ZFIQڴ>Fr!::f-P=&EIC>97oﯾFDyV}>IjhSǾF$	]t&>9ڮ=&7U:d>FqI|E>E8G_m>;(wF|>I
kEr
>7s>
Ԍ<#+'G;D1Ib9ؑ>EH6^{얋>=a|G}\̾=w>IβE㧳>58k>>6>`>G|d7IԺ>Dy>4qT[ 	~@>?HG~>I,|D7S_>3a\|T>-੾?h<>HM>I>Dh+3"2PoK>@AY%HE;>I<ӾDAGֲ>2>	> ?@~>Hi)a͹ICre>D= q2,	hqd!>@MʾH)>`>IhIC:Da-o
>1;E>"k_@'%v>Ht9VI
i>Ct=1̕#9>AM.HF>IiVCt>1iA+>#o#~aA>H̡=l0IҹIH
>CaUf1WyUw2#H>A.eH">I￾Cӥ>1]%<>#e
;5A5o*z>HzEȾIkh>DP{1|1#|~M|>A16!M:oH9PaX>IuoDʥ>1Z># A$<>H^ӡNJyUi=P>D='5o2J)j
"˱>ARH5>J&BrɾDgcX6A>2l
i8>!O[椾@>Hrl;J=N>D"2( Lo>@H٥l}e>JWh'žDz>3D|>;n
%@V>H|ފJq_@>El47Hkh	+>@G5#þH].|>Jg;E]_7>5ؑ>:M?+W>HԾJ)Ŝ>ER4e5w/K>?Cc@`HoU9?Z>Jŀ?'ՙF{Ũ>6ܙa>:첝!>yoe>HCUJRG>F`5\s7xnp	4뭴>=
əH;,z>J#F7Ry>95C>*~gG'E8K
jX7>G)md:N¥߽5>;xjӾGlr>K!G
9L:>;<,,۽z?#:A`ї->G4rYDAK-Ǻh>1H>G #(G>@Ϲ"1 M2t>CUHT
>E8'6	n>Z>=W
Ŕ۾FNՇ>Gl4AUw>%W\>0allC;GmS>H>5֑Eڒ^p>85|6=Q23;V)>FpؾG>>BMR)Y,ϟf>BsVҾHFi)>F^b:_=
80/>9y(&_EcE.>H!uoþBH>.쬟b>(S/A57Ы>G9PF'B>Ed}`H<;->Cyx[E1h*j䡾#HcŢF>@քwAGg>>Fgd>t`>>5Ma.SDYl>HGsǾDM},>376>^XǕ?*	>G3ɘ
Gh3>@T7'~) Aܾ2&>C,vHE!@6[۠Tc>=r&Fޏτ>GUEAuɴ]>>/:+d$B6>H#&E,>9$:=^4&:KP>F8	þHe>B$-"N+(c>A;GΗ9t>FV歾<8g>	`"~>7(4LE*0>H0C(9ξ>2I&L>!ԗUپ@Yd>G^M(G&S>?1b,Z3t>D!5H4t,8>DႾ5XO;[Vl>=8FSޅ,t>Gn$iABO$˰'>&!91Y>/(p_B5(P>H "hEt>9i=!Dh:hT>E`1H[߆>BBξ.
ؾ'&i>Alad̾GsI^j>F ,=B/>7s>6 F5DӢ>H,in9DﵛS>3>L˳?mn3>GG[ud>@qx!B1:Y>C|@H4Jn>EQ91Q7^j>lǗh>;yʷYF8R+>GhRþB.=6>+[M>)ǝFžA>Gz_+PFej
>E֖MH >C7L{2Ƒb>?쐡xG'rB>GAt@;[	r> D>2lоC,>H!:E?	y*,>7>I޾;>F1@FaGJώo>B5,-4)ZT)ec>AdGh(l>FuU(<&C>
'tv>6{H_pD?^>>HBuRDg>3z>E?K'?$Z/>F]5GbV>@$q#`Kx0Ḽ>C&tH$K>E U9J	F~>:nxEbZ>G:eBBv&>/ĸ$>%phlHA1>GFAh>>cVKnN4_8C>D9H[$2R>DG95"Ʒ~*O>=WvF2[	>G-x۾AM!y>)a>,ȾB+	
G>GBCF9:>;Z%흾7-	>E\Hps">CiL830TVASZ>?KxxF-)t>G\ǰ@-+>#G>0NxCLJ6>GQ|tE@>95.~ 9Yz,>Eoe(GL?@>C"	0hH";E>@<)GKQo>G[?+E
>6S>2KeCd>H袓sE8>7yP9=ƨz:^U~>EBDYz˾G:>Bٌ.CҾ&*6|A>AG}8`<>F!ھ>|x>٣>3		D=>HD㐂Z>6̈́RO><r؂;,F>F;!
GV;>B8[/,B(7^>Arz
"G">F=2ϐ0>G>4VDB>H|DyE_=>66e.>
M|'FW[5Gêz>BXT+VycԾ)$$>Ab(SG!p6>F<{{=j>|<>4\DM#>HkGD[6//dH>
O ?!
FThGƂ/O>B!,'.1qԾ(p׶>A{G9>FF"ޗ=B>VBG_>4o#WD,Wa>H'Dؖ=~>6@+9>nom;)>F1OܒG&s>Bb6c-ƪS&FNf(>A,*fGФ >F>++h>_ħ>3m	p%^C_>HU;FwE'at|>7H/=S̝3':z>E[`GPEj>BWme0MƜUX#ՕK>@k|y%GRP>GXxA@y> \m>1!,CWG>H
9eTE>9C.24Ϋ,4I9g>E}|۾H
	>CG2Pڕ6Eھ/2qi>?Gb}>Gl+s@mY>%a귎>/«WKB.A>GcpF%%:l>;k)ľ[76Xְ>DiWH%d,>DKrD4^Jp|">=d/'JǾF>G4XAj%>+CSd>)G(jƚnFt{>>DږhqoW3LM>Cu{H$c>E/c/I7EW>:tXEWWk>HwyWCB<<>1&Q>!@L@G4:FOGW$u%>@uj#-/0/j&>B̏	Gk>FiI;zW>\ĩ>6dј۾DI>H0!zDa1N!>5*UR>9:=wbI>F~X/G4S>B4GA.Z,}'>AAG ' >FW06o?O<>效%@>2P舾C+>H"a\EDU>9Εn!{D8ݱu>EpqȄH,ȓ>Cv3dq@UkZ>>Fتܷ>GKAT&>))y">*9ҷAќV|>GgUFˠ>>Eٸfn32o>C[H67/d>EfSWc18i4i>9E8d>H-b	Cm:>2R>"?&aZd>FʪNG6k#>A՜T(%`1$+w>>A'/pG>FxBI>.A!>*S>3ۗ0¾C"n>H?\0־EuXn>8G_F=`jL9i$M>Eq1H;>>C* 3-?"P>>TFE6>GBArc!>*zЧ>)j0ARӥ?>GǕ]F>Q%>?"REs[M2>L>CPqH?@vr>EBc:Ҟh=z|V"<>8Us^EThO[?D>HS(ƑDI$O]>4EN>!+k=b⭱9>FZdϾHזF>B|JD.n7%!e>@60G|tw>G_{F@m߮ɟ[>"+>096ľBݳ>H(/e\ξFc5fN>D+?"(Hd{k;>EfK7u-I3.>:ʜCNF
=>HIFNʾC>2WC)%>z?}|T>G A'GسA$>Af(l*U*Kb-<>Aŧ4G>G z?yV<>C>2]hO)C:|>HTTѪ$Fi>;!\|1فQ7JHՂx>E(eHwkY
Ec>D٦sWȾ6$.O>;ڇFPdF(>HQC8C['>1J> 'pP@cxc>GG'똾Gu>A'm3)~+*%R>AZ*GQ7>G3M^?S\n&>">2CӐ8C!>}>HdU/ھFE]F44>;Ni:A6-)n>D4QHݤ4>E!#[U7`5=-hFu>;t\־F)m>HurjCʵE>2[>>X?
,>G3ԴH"1v>BIy5,Y'yJdi>AOСWGs>G	#@P2>#Ԟ}	>0B5MB8b>HR%OѾF>=#5dL4RG>DQⲃH<>E_9ń,ZV=鵘
Y-R>8!xEdBY>Hx9DˁCJ>6*>
A0]Ff
H%>CLkn25YH 	u|۶>?VGG[D>H->Jm
B*9Yݝ>,"0>(u1&jIAӀ19>GZ'VxGW>@b]#s0Ga>BJھHlE8>G M>2I>uV>4!WӾD:p*>H,ӾF3ب>:'!I7Ǚ8>EWjHɩwߦ>EAx
7}rKv1f>;19B¾FL9d>HaD5BR>4Z=;>!i/>`/~>GfHVG>C
wJ;0yg]#)>@Z5G
hͻ>H,]EmAѮ>)I&*p>*ՉO̾BBܨ>H?HG;SF>@%eѾ"UO[0L>C7flPH>GZ>M}X>eub>42HاQuFnn%>;|5e_Xؾ7R(>EGfH8>E*\8vzǗk>:G`jF"Ac>H%>0D2q>5hX>d
=	q*:>Fݚ:X㴾HtKY>C:22(T^^>?8G}>HٗϾB k}>/%>% @|')>HbdYkHVB
>A&Co/)a8%Ⱦ*
@1	U>Bch\[HlZ:=>G:D#7@:>$+Is>0RgίC6%>HrG]qR>?w!AYƾ3z|H>D94(Hdo>GޔO=U>z2>5DwKI>I!uFuju5m>;![U30C78I!>EqI6y$>EAd(8bh&3F>:FDcF@r>I94iE8m[D>6ٿ3>
hj8FY+II-C5>DFվ4Uh*>>jgޗνG[QZ}>IkheCc>2byT> qMɾ@#n>G쩻$RHCw>C,60Fr$ʁ<>A5žH2Y5+>H6gBv5J>,uijy2>(x^׾A|2,>H'fҖH4A>A˾(vEK,[97>BppH(>HA{;A>$>0OtپCIטLGӤ.>@XdrW jm2>>CA](I:Ċ>GMݾ?Q֏>ݣ>3n3DpM)e>IbTGc
.>=S1o¿&A5e>DZ 闾I6Fo>GT
4D>6T	@Ep5>I׆FSE;>;m5*&kCz8BWzp[>E2ZFIQڴ>Fr!::f-P=&EIC>97oﯾFDyV}>IjhSǾF$	]t&>9ڮ=&7U:d>FqI|E>E8G_m>;(wF|>I
kEr
>7s>
Ԍ<#+'G;D1Ib9ؑ>EH6^{얋>=a|G}\̾=w>IβE㧳>58k>>6>`>G|d7IԺ>Dy>4qT[ 	~@>?HG~>I,|D7S_>3a\|T>-੾?h<>HM>I>Dh+3"2PoK>@AY%HE;>I<ӾDAGֲ>2>	> ?@~>Hi)a͹ICre>D= q2,	hqd!>@MʾH)>`>IhIC:Da-o
>1;E>"k_@'%v>Ht9VI
i>Ct=1̕#9>AM.HF>IiVCt>1iA+>#o#~aA>H̡=l0IҹIH
>CaUf1WyUw2#H>A.eH">I￾Cӥ>1]%<>#e
;5A5o*z>HzEȾIkh>DP{1|1#|~M|>A16!M:oH9PaX>IuoDʥ>1Z># A$<>H^ӡNJyUi=P>D='5o2J)j
"˱>ARH5>J&BrɾDgcX6A>2l
i8>!O[椾@>Hrl;J=N>D"2( Lo>@H٥l}e>JWh'žDz>3D|>;n
%@V>H|ފJq_@>El47Hkh	+>@G5#þH].|>Jg;E]_7>5ؑ>:M?+W>HԾJ)Ŝ>ER4e5w/K>?Cc@`HoU9?Z>Jŀ?'ՙF{Ũ>6ܙa>:첝!>yoe>HCUJRG>F`5\s7xnp	4뭴>=
əH;,z>J#F7Ry>95C>*~gG'E8K
jX7>G)md:N¥߽5>;xjӾGlr>K!G
9L:>;<,,۽z?#:A`ї->G4rYDAK-Ǻh>H{u=1Sb>F`Z>8.%lFBQ>K6kmHp
9o>>yt34>7tSނ>Fh[߾K5Vl>HX@,ȇ>dmWE)>5܍Ep>K.D9(IN{#r>@0=׾4&#t>EcRwK}<#D>I000AOl>#>2J]־DRҢ>J˚yJ$D>Bs;B'H`D0OkA_>D+L/ݾJӷ<$>J"CNUJ3>,!6eb>,\WC_y󖾽>JrʾJıp$>D,qE0Zξ'Z䕱>BטJQLi>K;%0gE>2QK>#V$A	ht
>I(̈K'*C>E%=51⩂P4B>@Q4ξIS1b>Kێ_sF.Ek>7A>"Hlx?4QB>I9GѥK:>GD:M7~yBZ><⟯HiЙ>L/h$Hn{V
>GW1[Lg{>I6)?D>+f>7SWFk>L
Ib%b>Au멾4_T1>EʓK,N>J@܋Bs3^>&Ir؞5>1JϾD0>KgFK;
Gj>CĆ,ӄ|_,>CӠ{uKOOڕ>KZ+EW>14vɛ>&e`SBDlv>JV)L1t>FOWa5Z\l>A*"C5J5>LrGOAE>8~>
.B?Gi>Is法gLu>Hh+;5NH)<>Lv7=I!
>?q
R8jL>G{| LjD\>JSHAy7>!|z*>4tFBJ\>LIi6K0>Ct7V%)Cp0dKy"R>DݎؾL#"2>L;Ex>11a%a>( Z'CN81,>K-kJ~L͢M	 >FI,5[wv|>A*JV>M6ߎþH/*:0>9pwAӟ>ieYn+?Us>I4JMo{<\O>Iq<>UjH=7Xw!x>;.6|ھH}a>MvJ`JQ1O~>ANkJ9SoN6As>GBwuӾME>Kܩ֦CaY>'>1GQDwE>9>L{ӹ
Ld>E^@sؾ1V&)k>CܶҾL/bix.>Mp	y{G=4>6P>Jg_AG#Y>KC找Ma:i>HVf;v!ݽ3>>I{RsJ+{>N.{5J>@Bu"Ov9X>HSlN‹>KxB#6Ή>4ŧFcŌn>M(~'MO>E/9о->DM1H>MHG;xx>5{kz>!ibBfM>LOSþNtmP>I=~;]*:/>@{J>NP	SK4>@/i./歠:m[U>I	3N˛툺>L+eCP?>$V+>4^0rGT9|>N1IƾMg>Eivn1!Nub7+Ea#>D
M^s>NPG־HR\?>7ō>FB|Ya>L'PKQɾO4W>Jz=6>H߲.=glkZT>>DQcJn>OVlH
LW4>BH}{gBdJ7˽N>H3y۾Oxa>M:ɾEABge^>-eQ>0QƾFU>NNOOKL;>H1\G6
$Mn>ؾ"x"Q>CIbMQqMmT>O㮭kJva3>=Gs=پ@!	rj>Kn<(hO<>Lj$jB'@>6"Wj>9;dѾIHn_K>O:NN>Eg9W',_91>qKE>F_N%(7>OYHja8[|>6k(*"># ^C)s>MlHGP-f!ɾ>K˷|>K+νFem>@%cȾK
d>PJG*M^+NR*>B@^oFr78s
>Iad!ꜾPQuy>O,ɥȾFo=>0VP>0COH]P7>ItE9WaW^M>CրM>P!OLher>@((:*1>I;2.>Kq+P$Ǣ>NqiD9 z>&1$hf>5K7HҬNN
>PC!	P48TO>H[/n4R	j>Ͼ({>EN8gHO2>P%b;Kzi>=磟$
>ʩЦA_NR>M+t.PJw>NO[,CZ>SQ>CfK,>9.zqUJp<8>Pj|,uξP5(>Go#1sŻ0D&>G
ӸXP/0N-r>PBWKrր>;mU>}CN
$>NpoQ>rZY>N*#PBz64>t<>Q))EyEپPL!yh>Fě.2ĩvS>HD1Bf	P*)>Q#TkѾJ$EX>:-^>+BD>Od|1QHOL>NYrLDI>>L>Qf޾Pä>GW-A3d>I@Q?
O>Qp-KN
zE>:E,tZ*> {\Dv4>PiY>cyQ'O>NhZaB=>O>?

mM1H8>QQPጪI>GB$/W7:3B1>>I?LWLhQM
v#>Q_,L,eB>;ʥk*>pD@$>P5K RGJӱ>O{7XC3ep'>_->>35ΒM-’d>R+BQg;G>H9ܾ2+[r1>HnjQ{
RO>RR\J+MWs>>hoUF>m8~5Cq4>P5Ȕ&RX=>PKEg
<>!A*e>;
xL^ط!>RhKJ2mRt=x>JY6@68-&Aqֵ>G}t]ҾQ6'wV>RIؾOx,>AX0=w'2BI:>OmS7?>Q9:Gt<>+v7Q>7ҵSKp!>R7wRЎb>MJ`B);ҳ."#>FHuyQQۥ>SgxP姀a>Dx>$5?0艪>NVJ:SHV~>R5JFo>4D..>18PIUHm>Rj*S3 >PžAu΋LfK>Cw|̮Pγ#>S׭
NyaR3">HX¿6+V)u#9~>LUOSPe>S`*N>=d<i>"-/1FbS>QOwT>pyEA>QdUF(+X>^*>?Ӵ,BbO'St>T;UJSd.>L	4̾7/HC/mrg>I3URǩK#>T8EmQEv>CV&ɽ5ABl(>Q
5vT"Hʈ3>SkōT\KHyu>2t2>5p06.Ln>ShoT0>PϋJ(cAY*mP
>E[$2Rgd>U*LlH-SK>ItӔ,tU/+;nA>Nd2o*T~mڞ>T|*ҾPgM(>@"#>!dv7Hiah>SU{9(>S3fJþHF>$Ͱ@>?kuPzߙ^>UE8U"I->PJk="
d,)Iͻ>J9 SسIp>VvES+Z>GUφxJAAn>Q]=5U}>U^5mO"q]>:,^>07{KҶ0[M>TΓ;VD>S=G@	>mU>C;þR"4
>V}ǾUb5>Od9Nk0¾2䚢>MB!nU?	Z1dI>VzSmsom>FW,>&Dm-.>Rʔ0#xhWj8>VľO櫛>8:>4W5U65bWB>SkF4=qL>E?A6SW0
sb>W~/VG>PBA85;j>O9x&Vge0>XC`T@W~[>GHx[E>S:JrsX:n">W&CQ"P[>:#_>4
lxOP>VuB~XEWY>T꧕OdH0>~E>EiIT-fm>XMW1ȩh>Q-wO"7^,WR'W\>Yo<:UÝu>J>_ToE,H>TEv#Yb&G>XsR{4>?,e>1z+"ҦOq>WATZ2Z>VO:Ljw>"a>D'{ITH]OR>Yӯ`Y[p0>S;	BS&`+A>N`yWC0YO>Z9gYX5->O*wT,<ѾBMm>T3[PZkgh)>Z΅PQyU#$>EW>"
%hMwTҳ>W3׾[Zl>YdcCQ@#U|>4`t>@;Slۦ>Zڜ[i>VaBI
1̾-WZ>KyW̊\>\y6'Z!>S6Y<]%1:L.[>R􏈖[[
>]#i?\X9u5>Mr^եJH>Wa#7]8c>\GP{Uu'>Cy#>2]pQ6x>[&E)W^J#F>Z]QGpf>.͹mÜF>E7BKFV|>]dɾ^6n>WT
2H Q@>P-E9(ZP>_VuÊо]Ek>T/+;A#V@MzE>Ub̽S(]B V>_٨PZs>O$Q'*K(5NL>YYf`<>_EW"3q޾Wgiy>DB8>4ŎS}n>]XV񜝾`Ud>]TS8S5">2ϑ>Fw5SXeѭ>`X?#p`/8L>ZPþL3?!T^E>Q.%]4*~>aQ'`Gd>WA0m4A~4?(>VR=)`\`cai>a91ɾ^abA>Rq
R&1U0ҾKa>[ead`#>ay[&^~5>K;L>+ξS&/z>`5bfm>a'.JqWι>?">ClSYALnt>aڹc[Z>`#QS!-Y>>P%/jM^%>c==b-y>]LqzK2fq>VCȹKafq>d+gbdo'p>Y#O@?@0YFu}h>\ccn:H&>dEaT{o>ThY>v0Qƒi>`ϭd龜T>dF#_k>NSFm>4"KȾX%Ѹuf>ce'>dszξ[	>BnW>Gsܾ^Er.>e&]YU@f5">c*3DAܱWVV>$rү8>RbeV*>fܒiaf#>a/?žQ1ڠ>YsxKܾdag7>h0@f4e>_0}G5֢sFpʹ>`
?g
B2>ieŬi.w>[Wӹ4(ݭRi>ciuѾd);,>Vd>YZâ_>fEfj޷->ilIimbD>P*	_>BΎr<`Հ>i,lFg>iaQg2`z>C.6[>Q$
怪dBMN>k,0:mR4F>h_^d]k+
>#We!G~>Y#ۜDtgj
E>n1'Ѿn6L>goWx=P5>睙>` kRl>pgZ^nO" Y>eբ3Q#
9ʾK!S[4>d⥯(&n+>qHi^n<4r>c)ƁCV!VVRN>i-}K,q&Z=>qtI̾mS>a^> gߎFX%_}Y>md%r>rdu)le1q>\6&$>:.bU*dD_>q1@t-)Ջ0>sNskHs>VSمb>P/Ӿjx7>s[-uw>syk񂂾joQ>M_$;>Z:}o#>u͎sxGqg^:>7ű$T>c*=*Ur^d\>xZnهKx$X^[>sOվelC0ZԷ">iӌE=v:Li*O>{ pPz`Kb/C>s
6bP7OcvF>pM~y~2r_e|d>s?a]o@^]Q">tTk~X0\">l}t~_>sESߤfl>y.q:4>!G.b"p)>sz&~@R`&pz;`>&
^4$LF2>
xvx;y%>ssSi(h>:e1>wpV+>C7!dFU>Ebe(F wh=>rx/S%>Z;deMց^}Yq >wc(r*>qXH=>lq꾆ڨF>EĴ3;F>lE:>o>zǟ0q1L>*Q,r&,>?_2>hk(g>BH>A5:j>C'tt=dW@>}X1Xg>@cҽ>A>_J'4AQ>H{u=1Sb>F`Z>8.%lFBQ>K6kmHp
9o>>yt34>7tSނ>Fh[߾K5Vl>HX@,ȇ>dmWE)>5܍Ep>K.D9(IN{#r>@0=׾4&#t>EcRwK}<#D>I000AOl>#>2J]־DRҢ>J˚yJ$D>Bs;B'H`D0OkA_>D+L/ݾJӷ<$>J"CNUJ3>,!6eb>,\WC_y󖾽>JrʾJıp$>D,qE0Zξ'Z䕱>BטJQLi>K;%0gE>2QK>#V$A	ht
>I(̈K'*C>E%=51⩂P4B>@Q4ξIS1b>Kێ_sF.Ek>7A>"Hlx?4QB>I9GѥK:>GD:M7~yBZ><⟯HiЙ>L/h$Hn{V
>GW1[Lg{>I6)?D>+f>7SWFk>L
Ib%b>Au멾4_T1>EʓK,N>J@܋Bs3^>&Ir؞5>1JϾD0>KgFK;
Gj>CĆ,ӄ|_,>CӠ{uKOOڕ>KZ+EW>14vɛ>&e`SBDlv>JV)L1t>FOWa5Z\l>A*"C5J5>LrGOAE>8~>
.B?Gi>Is法gLu>Hh+;5NH)<>Lv7=I!
>?q
R8jL>G{| LjD\>JSHAy7>!|z*>4tFBJ\>LIi6K0>Ct7V%)Cp0dKy"R>DݎؾL#"2>L;Ex>11a%a>( Z'CN81,>K-kJ~L͢M	 >FI,5[wv|>A*JV>M6ߎþH/*:0>9pwAӟ>ieYn+?Us>I4JMo{<\O>Iq<>UjH=7Xw!x>;.6|ھH}a>MvJ`JQ1O~>ANkJ9SoN6As>GBwuӾME>Kܩ֦CaY>'>1GQDwE>9>L{ӹ
Ld>E^@sؾ1V&)k>CܶҾL/bix.>Mp	y{G=4>6P>Jg_AG#Y>KC找Ma:i>HVf;v!ݽ3>>I{RsJ+{>N.{5J>@Bu"Ov9X>HSlN‹>KxB#6Ή>4ŧFcŌn>M(~'MO>E/9о->DM1H>MHG;xx>5{kz>!ibBfM>LOSþNtmP>I=~;]*:/>@{J>NP	SK4>@/i./歠:m[U>I	3N˛툺>L+eCP?>$V+>4^0rGT9|>N1IƾMg>Eivn1!Nub7+Ea#>D
M^s>NPG־HR\?>7ō>FB|Ya>L'PKQɾO4W>Jz=6>H߲.=glkZT>>DQcJn>OVlH
LW4>BH}{gBdJ7˽N>H3y۾Oxa>M:ɾEABge^>-eQ>0QƾFU>NNOOKL;>H1\G6
$Mn>ؾ"x"Q>CIbMQqMmT>O㮭kJva3>=Gs=پ@!	rj>Kn<(hO<>Lj$jB'@>6"Wj>9;dѾIHn_K>O:NN>Eg9W',_91>qKE>F_N%(7>OYHja8[|>6k(*"># ^C)s>MlHGP-f!ɾ>K˷|>K+νFem>@%cȾK
d>PJG*M^+NR*>B@^oFr78s
>Iad!ꜾPQuy>O,ɥȾFo=>0VP>0COH]P7>ItE9WaW^M>CրM>P!OLher>@((:*1>I;2.>Kq+P$Ǣ>NqiD9 z>&1$hf>5K7HҬNN
>PC!	P48TO>H[/n4R	j>Ͼ({>EN8gHO2>P%b;Kzi>=磟$
>ʩЦA_NR>M+t.PJw>NO[,CZ>SQ>CfK,>9.zqUJp<8>Pj|,uξP5(>Go#1sŻ0D&>G
ӸXP/0N-r>PBWKrր>;mU>}CN
$>NpoQ>rZY>N*#PBz64>t<>Q))EyEپPL!yh>Fě.2ĩvS>HD1Bf	P*)>Q#TkѾJ$EX>:-^>+BD>Od|1QHOL>NYrLDI>>L>Qf޾Pä>GW-A3d>I@Q?
O>Qp-KN
zE>:E,tZ*> {\Dv4>PiY>cyQ'O>NhZaB=>O>?

mM1H8>QQPጪI>GB$/W7:3B1>>I?LWLhQM
v#>Q_,L,eB>;ʥk*>pD@$>P5K RGJӱ>O{7XC3ep'>_->>35ΒM-’d>R+BQg;G>H9ܾ2+[r1>HnjQ{
RO>RR\J+MWs>>hoUF>m8~5Cq4>P5Ȕ&RX=>PKEg
<>!A*e>;
xL^ط!>RhKJ2mRt=x>JY6@68-&Aqֵ>G}t]ҾQ6'wV>RIؾOx,>AX0=w'2BI:>OmS7?>Q9:Gt<>+v7Q>7ҵSKp!>R7wRЎb>MJ`B);ҳ."#>FHuyQQۥ>SgxP姀a>Dx>$5?0艪>NVJ:SHV~>R5JFo>4D..>18PIUHm>Rj*S3 >PžAu΋LfK>Cw|̮Pγ#>S׭
NyaR3">HX¿6+V)u#9~>LUOSPe>S`*N>=d<i>"-/1FbS>QOwT>pyEA>QdUF(+X>^*>?Ӵ,BbO'St>T;UJSd.>L	4̾7/HC/mrg>I3URǩK#>T8EmQEv>CV&ɽ5ABl(>Q
5vT"Hʈ3>SkōT\KHyu>2t2>5p06.Ln>ShoT0>PϋJ(cAY*mP
>E[$2Rgd>U*LlH-SK>ItӔ,tU/+;nA>Nd2o*T~mڞ>T|*ҾPgM(>@"#>!dv7Hiah>SU{9(>S3fJþHF>$Ͱ@>?kuPzߙ^>UE8U"I->PJk="
d,)Iͻ>J9 SسIp>VvES+Z>GUφxJAAn>Q]=5U}>U^5mO"q]>:,^>07{KҶ0[M>TΓ;VD>S=G@	>mU>C;þR"4
>V}ǾUb5>Od9Nk0¾2䚢>MB!nU?	Z1dI>VzSmsom>FW,>&Dm-.>Rʔ0#xhWj8>VľO櫛>8:>4W5U65bWB>SkF4=qL>E?A6SW0
sb>W~/VG>PBA85;j>O9x&Vge0>XC`T@W~[>GHx[E>S:JrsX:n">W&CQ"P[>:#_>4
lxOP>VuB~XEWY>T꧕OdH0>~E>EiIT-fm>XMW1ȩh>Q-wO"7^,WR'W\>Yo<:UÝu>J>_ToE,H>TEv#Yb&G>XsR{4>?,e>1z+"ҦOq>WATZ2Z>VO:Ljw>"a>D'{ITH]OR>Yӯ`Y[p0>S;	BS&`+A>N`yWC0YO>Z9gYX5->O*wT,<ѾBMm>T3[PZkgh)>Z΅PQyU#$>EW>"
%hMwTҳ>W3׾[Zl>YdcCQ@#U|>4`t>@;Slۦ>Zڜ[i>VaBI
1̾-WZ>KyW̊\>\y6'Z!>S6Y<]%1:L.[>R􏈖[[
>]#i?\X9u5>Mr^եJH>Wa#7]8c>\GP{Uu'>Cy#>2]pQ6x>[&E)W^J#F>Z]QGpf>.͹mÜF>E7BKFV|>]dɾ^6n>WT
2H Q@>P-E9(ZP>_VuÊо]Ek>T/+;A#V@MzE>Ub̽S(]B V>_٨PZs>O$Q'*K(5NL>YYf`<>_EW"3q޾Wgiy>DB8>4ŎS}n>]XV񜝾`Ud>]TS8S5">2ϑ>Fw5SXeѭ>`X?#p`/8L>ZPþL3?!T^E>Q.%]4*~>aQ'`Gd>WA0m4A~4?(>VR=)`\`cai>a91ɾ^abA>Rq
R&1U0ҾKa>[ead`#>ay[&^~5>K;L>+ξS&/z>`5bfm>a'.JqWι>?">ClSYALnt>aڹc[Z>`#QS!-Y>>P%/jM^%>c==b-y>]LqzK2fq>VCȹKafq>d+gbdo'p>Y#O@?@0YFu}h>\ccn:H&>dEaT{o>ThY>v0Qƒi>`ϭd龜T>dF#_k>NSFm>4"KȾX%Ѹuf>ce'>dszξ[	>BnW>Gsܾ^Er.>e&]YU@f5">c*3DAܱWVV>$rү8>RbeV*>fܒiaf#>a/?žQ1ڠ>YsxKܾdag7>h0@f4e>_0}G5֢sFpʹ>`
?g
B2>ieŬi.w>[Wӹ4(ݭRi>ciuѾd);,>Vd>YZâ_>fEfj޷->ilIimbD>P*	_>BΎr<`Հ>i,lFg>iaQg2`z>C.6[>Q$
怪dBMN>k,0:mR4F>h_^d]k+
>#We!G~>Y#ۜDtgj
E>n1'Ѿn6L>goWx=P5>睙>` kRl>pgZ^nO" Y>eբ3Q#
9ʾK!S[4>d⥯(&n+>qHi^n<4r>c)ƁCV!VVRN>i-}K,q&Z=>qtI̾mS>a^> gߎFX%_}Y>md%r>rdu)le1q>\6&$>:.bU*dD_>q1@t-)Ջ0>sNskHs>VSمb>P/Ӿjx7>s[-uw>syk񂂾joQ>M_$;>Z:}o#>u͎sxGqg^:>7ű$T>c*=*Ur^d\>xZnهKx$X^[>sOվelC0ZԷ">iӌE=v:Li*O>{ pPz`Kb/C>s
6bP7OcvF>pM~y~2r_e|d>s?a]o@^]Q">tTk~X0\">l}t~_>sESߤfl>y.q:4>!G.b"p)>sz&~@R`&pz;`>&
^4$LF2>
xvx;y%>ssSi(h>:e1>wpV+>C7!dFU>Ebe(F wh=>rx/S%>Z;deMց^}Yq >wc(r*>qXH=>lq꾆ڨF>EĴ3;F>lE:>o>zǟ0q1L>*Q,r&,>?_2>hk(g>BH>A5:j>C'tt=dW@>}X1Xg>@cҽ>A>_J'4AQ>H{u=1Sb>F`Z>8.%lFBQ>K6kmHp
9o>>yt34>7tSނ>Fh[߾K5Vl>HX@,ȇ>dmWE)>5܍Ep>K.D9(IN{#r>@0=׾4&#t>EcRwK}<#D>I000AOl>#>2J]־DRҢ>J˚yJ$D>Bs;B'H`D0OkA_>D+L/ݾJӷ<$>J"CNUJ3>,!6eb>,\WC_y󖾽>JrʾJıp$>D,qE0Zξ'Z䕱>BטJQLi>K;%0gE>2QK>#V$A	ht
>I(̈K'*C>E%=51⩂P4B>@Q4ξIS1b>Kێ_sF.Ek>7A>"Hlx?4QB>I9GѥK:>GD:M7~yBZ><⟯HiЙ>L/h$Hn{V
>GW1[Lg{>I6)?D>+f>7SWFk>L
Ib%b>Au멾4_T1>EʓK,N>J@܋Bs3^>&Ir؞5>1JϾD0>KgFK;
Gj>CĆ,ӄ|_,>CӠ{uKOOڕ>KZ+EW>14vɛ>&e`SBDlv>JV)L1t>FOWa5Z\l>A*"C5J5>LrGOAE>8~>
.B?Gi>Is法gLu>Hh+;5NH)<>Lv7=I!
>?q
R8jL>G{| LjD\>JSHAy7>!|z*>4tFBJ\>LIi6K0>Ct7V%)Cp0dKy"R>DݎؾL#"2>L;Ex>11a%a>( Z'CN81,>K-kJ~L͢M	 >FI,5[wv|>A*JV>M6ߎþH/*:0>9pwAӟ>ieYn+?Us>I4JMo{<\O>Iq<>UjH=7Xw!x>;.6|ھH}a>MvJ`JQ1O~>ANkJ9SoN6As>GBwuӾME>Kܩ֦CaY>'>1GQDwE>9>L{ӹ
Ld>E^@sؾ1V&)k>CܶҾL/bix.>Mp	y{G=4>6P>Jg_AG#Y>KC找Ma:i>HVf;v!ݽ3>>I{RsJ+{>N.{5J>@Bu"Ov9X>HSlN‹>KxB#6Ή>4ŧFcŌn>M(~'MO>E/9о->DM1H>MHG;xx>5{kz>!ibBfM>LOSþNtmP>I=~;]*:/>@{J>NP	SK4>@/i./歠:m[U>I	3N˛툺>L+eCP?>$V+>4^0rGT9|>N1IƾMg>Eivn1!Nub7+Ea#>D
M^s>NPG־HR\?>7ō>FB|Ya>L'PKQɾO4W>Jz=6>H߲.=glkZT>>DQcJn>OVlH
LW4>BH}{gBdJ7˽N>H3y۾Oxa>M:ɾEABge^>-eQ>0QƾFU>NNOOKL;>H1\G6
$Mn>ؾ"x"Q>CIbMQqMmT>O㮭kJva3>=Gs=پ@!	rj>Kn<(hO<>Lj$jB'@>6"Wj>9;dѾIHn_K>O:NN>Eg9W',_91>qKE>F_N%(7>OYHja8[|>6k(*"># ^C)s>MlHGP-f!ɾ>K˷|>K+νFem>@%cȾK
d>PJG*M^+NR*>B@^oFr78s
>Iad!ꜾPQuy>O,ɥȾFo=>0VP>0COH]P7>ItE9WaW^M>CրM>P!OLher>@((:*1>I;2.>Kq+P$Ǣ>NqiD9 z>&1$hf>5K7HҬNN
>PC!	P48TO>H[/n4R	j>Ͼ({>EN8gHO2>P%b;Kzi>=磟$
>ʩЦA_NR>M+t.PJw>NO[,CZ>SQ>CfK,>9.zqUJp<8>Pj|,uξP5(>Go#1sŻ0D&>G
ӸXP/0N-r>PBWKrր>;mU>}CN
$>NpoQ>rZY>N*#PBz64>t<>Q))EyEپPL!yh>Fě.2ĩvS>HD1Bf	P*)>Q#TkѾJ$EX>:-^>+BD>Od|1QHOL>NYrLDI>>L>Qf޾Pä>GW-A3d>I@Q?
O>Qp-KN
zE>:E,tZ*> {\Dv4>PiY>cyQ'O>NhZaB=>O>?

mM1H8>QQPጪI>GB$/W7:3B1>>I?LWLhQM
v#>Q_,L,eB>;ʥk*>pD@$>P5K RGJӱ>O{7XC3ep'>_->>35ΒM-’d>R+BQg;G>H9ܾ2+[r1>HnjQ{
RO>RR\J+MWs>>hoUF>m8~5Cq4>P5Ȕ&RX=>PKEg
<>!A*e>;
xL^ط!>RhKJ2mRt=x>JY6@68-&Aqֵ>G}t]ҾQ6'wV>RIؾOx,>AX0=w'2BI:>OmS7?>Q9:Gt<>+v7Q>7ҵSKp!>R7wRЎb>MJ`B);ҳ."#>FHuyQQۥ>SgxP姀a>Dx>$5?0艪>NVJ:SHV~>R5JFo>4D..>18PIUHm>Rj*S3 >PžAu΋LfK>Cw|̮Pγ#>S׭
NyaR3">HX¿6+V)u#9~>LUOSPe>S`*N>=d<i>"-/1FbS>QOwT>pyEA>QdUF(+X>^*>?Ӵ,BbO'St>T;UJSd.>L	4̾7/HC/mrg>I3URǩK#>T8EmQEv>CV&ɽ5ABl(>Q
5vT"Hʈ3>SkōT\KHyu>2t2>5p06.Ln>ShoT0>PϋJ(cAY*mP
>E[$2Rgd>U*LlH-SK>ItӔ,tU/+;nA>Nd2o*T~mڞ>T|*ҾPgM(>@"#>!dv7Hiah>SU{9(>S3fJþHF>$Ͱ@>?kuPzߙ^>UE8U"I->PJk="
d,)Iͻ>J9 SسIp>VvES+Z>GUφxJAAn>Q]=5U}>U^5mO"q]>:,^>07{KҶ0[M>TΓ;VD>S=G@	>mU>C;þR"4
>V}ǾUb5>Od9Nk0¾2䚢>MB!nU?	Z1dI>VzSmsom>FW,>&Dm-.>Rʔ0#xhWj8>VľO櫛>8:>4W5U65bWB>SkF4=qL>E?A6SW0
sb>W~/VG>PBA85;j>O9x&Vge0>XC`T@W~[>GHx[E>S:JrsX:n">W&CQ"P[>:#_>4
lxOP>VuB~XEWY>T꧕OdH0>~E>EiIT-fm>XMW1ȩh>Q-wO"7^,WR'W\>Yo<:UÝu>J>_ToE,H>TEv#Yb&G>XsR{4>?,e>1z+"ҦOq>WATZ2Z>VO:Ljw>"a>D'{ITH]OR>Yӯ`Y[p0>S;	BS&`+A>N`yWC0YO>Z9gYX5->O*wT,<ѾBMm>T3[PZkgh)>Z΅PQyU#$>EW>"
%hMwTҳ>W3׾[Zl>YdcCQ@#U|>4`t>@;Slۦ>Zڜ[i>VaBI
1̾-WZ>KyW̊\>\y6'Z!>S6Y<]%1:L.[>R􏈖[[
>]#i?\X9u5>Mr^եJH>Wa#7]8c>\GP{Uu'>Cy#>2]pQ6x>[&E)W^J#F>Z]QGpf>.͹mÜF>E7BKFV|>]dɾ^6n>WT
2H Q@>P-E9(ZP>_VuÊо]Ek>T/+;A#V@MzE>Ub̽S(]B V>_٨PZs>O$Q'*K(5NL>YYf`<>_EW"3q޾Wgiy>DB8>4ŎS}n>]XV񜝾`Ud>]TS8S5">2ϑ>Fw5SXeѭ>`X?#p`/8L>ZPþL3?!T^E>Q.%]4*~>aQ'`Gd>WA0m4A~4?(>VR=)`\`cai>a91ɾ^abA>Rq
R&1U0ҾKa>[ead`#>ay[&^~5>K;L>+ξS&/z>`5bfm>a'.JqWι>?">ClSYALnt>aڹc[Z>`#QS!-Y>>P%/jM^%>c==b-y>]LqzK2fq>VCȹKafq>d+gbdo'p>Y#O@?@0YFu}h>\ccn:H&>dEaT{o>ThY>v0Qƒi>`ϭd龜T>dF#_k>NSFm>4"KȾX%Ѹuf>ce'>dszξ[	>BnW>Gsܾ^Er.>e&]YU@f5">c*3DAܱWVV>$rү8>RbeV*>fܒiaf#>a/?žQ1ڠ>YsxKܾdag7>h0@f4e>_0}G5֢sFpʹ>`
?g
B2>ieŬi.w>[Wӹ4(ݭRi>ciuѾd);,>Vd>YZâ_>fEfj޷->ilIimbD>P*	_>BΎr<`Հ>i,lFg>iaQg2`z>C.6[>Q$
怪dBMN>k,0:mR4F>h_^d]k+
>#We!G~>Y#ۜDtgj
E>n1'Ѿn6L>goWx=P5>睙>` kRl>pgZ^nO" Y>eբ3Q#
9ʾK!S[4>d⥯(&n+>qHi^n<4r>c)ƁCV!VVRN>i-}K,q&Z=>qtI̾mS>a^> gߎFX%_}Y>md%r>rdu)le1q>\6&$>:.bU*dD_>q1@t-)Ջ0>sNskHs>VSمb>P/Ӿjx7>s[-uw>syk񂂾joQ>M_$;>Z:}o#>u͎sxGqg^:>7ű$T>c*=*Ur^d\>xZnهKx$X^[>sOվelC0ZԷ">iӌE=v:Li*O>{ pPz`Kb/C>s
6bP7OcvF>pM~y~2r_e|d>s?a]o@^]Q">tTk~X0\">l}t~_>sESߤfl>y.q:4>!G.b"p)>sz&~@R`&pz;`>&
^4$LF2>
xvx;y%>ssSi(h>:e1>wpV+>C7!dFU>Ebe(F wh=>rx/S%>Z;deMց^}Yq >wc(r*>qXH=>lq꾆ڨF>EĴ3;F>lE:>o>zǟ0q1L>*Q,r&,>?_2>hk(g>BH>A5:j>C'tt=dW@>}X1Xg>@cҽ>A>_J'4AQ޾j懎">7)UЪ.b>p%k{'>D7XRy4c>־`>jT-5%>#?A>m	/쾐:X>.Vdq>G
p5ھ	rՈ>vB[>sWJ>
	ξk
L>JcU$d?Ĝ>bXԽ>u߀Ҿ
+>Eӹ7C>z Fy_)>\x>w/YtxXu9`>2I[>2Onz(W_WׄZ>xܾm>1B>xQ5+^OdׄVZ2>yrD8Kj{>5}xO>p躓S5t%l%>y[0jHCv!>~nc^zqvZ?n8>dn>OF_pͺ>yw*x|>yG3p
vK>Q͚~;>`}[u\LrË">xޒJyY37>t@v' eg&0>g`sLGTk>wjuu8>nCV/u2T66>lrtNo>u~qܹg2>dKPԾ%J5aدP4LM>pK&޾sˮ>rAI;vkQ~>VN&Y>MËV~g~(>q9Ӛr?P/.>oE|b~.V>,4A>]'9ľl
tװ>q5,npmA>>g!¾S;e-VJ:[W>enN)fp>p;ţk >_QLfK.۾~AVV[k8_>iElpd*H>LPЃc>ML3	cO@>kzmTlŏ>g(v鞾X&!"1ú>\aַgI6\>k} 3hʪu>`RpS_@jXQG>c{XpijMr>iEJ:c*+>Q@:>>`9 ^GFކ*>fbFH޾hp+>dl(XoWS>)\>U&_cXȱ>g4ei>]tkB*~UsKSL.>`itUe9Y>f]Ծ`(>O#`D6u>9
DJ'ZK},>cee>b<”&UT3br={exu>S)Tadژ(>d ?VbuQ>X2߬<8GHʾLn>^4
3#c rx>c,TP^\ ~>ED*!>ADDbY
>b?*Zپc}ա>^,+MØ.>y{c>U_rf`@>b9e]2_E3>R4*B"MUfQ/"G!B>^]*վa'*>`'s|TqB>0Sj>J؍"O[KwJ9a ~ahX`Ep>V:?<ܑC͝W6>XX5k`@͊>`0E~
X)>CUP\>;u'U[@>^:oо_d->Yh*BG8Y0e˚~>SQ\љ~k>_B=YK/>Ju9> #YhPa(>[.3ξ^vL=ٔ>Y`MfBH}z>MVYН">]E1Y%Kv>O4sGޅ>AJRY>XV\S-$>YuNP462J>#w>G־VV>[ρmYr^
>PDac˾*ԛþE;m#/>UZ6->YLTv2P>/L4x>CzyT
lI>Z+*vX`<>P=1y,PB82>S8ȾYp5D>XhGPc>1|>Al_cpS^mb[z>XƼ `|W43B>P+	U1N4AKF>R8hX.X4F>Vh{N=>/;X/>A ȾRK=>WоV8>M$:+;A|yl>R|qW%pC>U~ܞ0GLmA>&`B5q*KRp+&>VIVGTlZZ>J7|ŬC:uG\1>R}@8}V<c>SlH< >q1>DB*kR+X+>UC>gR>Ew|	Z=gPEgG~>R!+EZUIM>QC(R
Awbk-ۡ>GsGR[pi>TyԈPx>@HyZQ.m>%?I⽾IcToL>SB^rTn.>N<%DY:D$g/0!H>K2jĆS/]&>SYOTrL$Y H>3yh>6!L
$Y>S4HRt?Xc>HG	k([OgM5NiS*j:>Qc׷E{S>6>AVqP;+>Rѧ;OP!@>A"th:>k?>оD~s>P2tRWf|?w>MQkP=;.˶';P>GȰ\Q8*>Q[@aI$>2SJ>4DkN\ȾJbM>QtvP6>F
=RE!tw.L|t
QkU>NiA<\`%5z6qr>B@Y|EѾNL>Q9ՈFKJe>91F>%9CBgwE,>PGPYe>GxR/X 4lwz>I36xPWIt>N}d CS
MJ>)8>=9Kt
H>P?rzKy><)	JO&>YCNCaY.,>MЙLOf>GÞH_1ı>0_!m>G$,oN$j>MSvaC	/>|N>;U)p)JAѳ>N-J@ K*>;{ɵ>ҖvBt>Lq!оMόh>F/mC/T]Ҁz1\R->F4ǂjM/Ԇ>K~M>A8)N>&>>Med)H;!2>6hrce>"3זDC\Xs>Kv
K?/>C_-$E˧5BdO>G"4L{>I;ȵMv7R>@,i%iyI%>KWݾD箛g>.@w>/Gd+Di=[>K]hJIbZ>?mSʯ]ȐԾ;>>HL `K'>E&2<{{'9:~	>CZǫҘJ@rݬ>IAW@b9>~s,>8g־F}|>JwQ^EG>48d>"C4AU*>IG=<@еÐoш6sVGͫ>E-KHIp֫>E\/4yʾ4G
!` 5Χ>AjHnok>H5v[*@;G(>"JT>5FC*Edgj>I
aMDp6c>3st> (`@ȞSF>GEw1pGjyi>>-d6I#S):1>E(6FHW"6>C1|犓t#஑>AsY߾G'>Fp]o<;-Fy>fԝ>7CE3_>GNپBVm!>,>).sA
)G>G4avþE8Z>8β]=8/7:?TAZw>EktlskF\G>@ $C"㙖0Ec>By)+FT?>C?>׾4.D-ξ$>=G&A>
E~ۼt>E<`<ݪL>2>4`L޾Cl5޴>F7}73A,u>-=\Q>%xy@Osc>E3ҍ'C\>7)5'&=!3m9 Z*>DEyE9Ȫb#>>=F]9 
.0_0a>A*AEy|TS>A#`0|r" <[җ>="c&Dːu{>CR7C	=.y>6bCL\VH>Dޖ-=]>!WmDPQ>.A">Dl,APJRIx>0!>~?w<9>D!߾BEy`>6ni=s6#O>BX*~ɾCN-><%mϾT:03P#K|>@S.D(E>@9=g/5ܾCwt>A_@3b_Qʼ>8A"GBR>BX@8*ml>
:7ڭU>2οAFvD>C59q=>#N}>){q?x>C&eܾ@$>ww_>.9vrQ>|-:z>BRyQ&AOͯ4>3zj}=2v?%6|6e>A^%*BcѮn>8>0?
B?n12ŅN>@`tϾBb"eQ2`>;
!UxgRپ*K
>>EsB[>>@;M*a	
޾ '&]>;5!gBK7>@)4D7z1>Hۇ>7;OSGAh3>@▨e4ɻd^=V@>3.v?@]
>APZu7Nw>^5!>00mG4B?%XX>A}LJ:ZeuP> UXZ>)
}<Ɖ>Ap'>!vlo:nNV`L>A1ӽ>oN>-^>b7wj@&>@D?6r>1y`h>
#5A
>@D}OӮ@~>3nVŕz2̯>?FFmܾ@E`+.>6
07'ھ0_>=F5@d^y$>7Ǟ?m9{u+A>$l>96,ʾ N[B&4>:K@Ism@>:b8$)%%G,"`}͙>9M5:@=">;Tk}.g($׾r->7i
?ߐ.=><0,mk>6K\8ľ?6Ps>4⺷?y>{><2ݾ00Av2!R>30j=|NS>=;1*GJm_>2XLgzQ=V:>=`5w2z5r\=A1V>1=J7F;s>=oj3&|q=ؼ{`>0C:<9
>=gc3/t:>O>.H;ȏ>=RoQ+=4<#q>
Q!J">-X
1;
D>=3vd_4Tlo>Re(>,,s.:Qk>=oZ4wJr>9v}>+=F\K:723oQ>	\>*l9C8><2l4r)q>&i>*3T+9> u>*9w/ >\>*&e9Zȧ>;ݴ`=33j$>q>*a9KY
D*>;7!uL368>_>+SԾ9HrZ>;=u Sa2
>V, >+.rq9T*Ū>:^
2#>go>,@/9gӡt>:|R1G8^=#>.(93,i>:
]U0n=ܘ/5>/V2F-9Yi>9s(.hg&l	Ni>0ja'F|9Ը'>8E,PL4rS>14?9MtZ>8H#(̾*e]Mξ`eA>2fHlľ9柣Rl>7GѾ'¾?>2!1{L9Sse>6+9K$
,~Ul>3ܓ-eƾ9ا>5'!jH7犾w>4sܾ9Xv>4 rW!>5N:;9n;(>33S
yR(7%?ɔ>6J􎫾9>1#?PS+t#(Oac>6'lG8w:r>0!qmUӷV$+l
T>7夐1P7r>,r	=i/")>D2g>8J$6v'D>(S>(O_~1!>8I_5U'>$kޅ3>/S2#[(>8\깾48xq>+->l]p3w>80 \2>C>k#U~=>#T:5$8>7dM0w%7>t>(KE}Ҿ6G2Î>7
p?i-1==>,@6حQ>5n>̾(G=O@0s>0UA:Ѿ7DgYc>4zo#.ߨjdF>2+b7^P>2Ҵ̾J Pq>317;>0޺vQO
բd%:Ox>5Qɾ6ho>,@%0.+
g~>5k/&5OK1A>'gP>V&I/|5NZ>6ƌѾ3*&>!%Yd>H~1)1i>6F1źVnG><`'>!ⱄJ3!>6'".?>Ei)>'՘Q!4QZ>53)`9@>-N]5c>3Pپ"'>xD>1	75k>1 Q;׸Ė =,>2ь5[0Sd>.2Ry]
^Vh'+Q%"p6>4pP@ZB4v>(v=ACG/ľ-Ͽ>5C5Z2>!4>#E81
 e}]>5lKU0o1>\R;>"GKK3N a)>4|щI+6f*=r[aϥ>(؍+s4[ߜ7>3i׾$͌=	J>.zhow\4'>1.y[t>6ʾ>Y>1"ݲ:ʾ4II=>-vrzž|&%
>3(蓾3gu/bb>&׈Kz=wLѳ,Z>4lH51.^>-
H>oo0 )	>4uC|.T;W>
yG|>#*2	 w>3 >'l%77>+4/0	30>1)g)`DHu>0g2D¾4ُ#o>.d?Ɍ#ZJ>2]	Pc39ǐ}>'=eߟ۾*屩6>3^i1PsurB>ͩv>!O0W-1B>3?,{<>(\1>$f]2haû>2l%tWj­>+q?~l3m5Ԣ>0(*Ro9sJ&>0oW3D|j懎">7)UЪ.b>p%k{'>D7XRy4c>־`>jT-5%>#?A>m	/쾐:X>.Vdq>G
p5ھ	rՈ>vB[>sWJ>
	ξk
L>JcU$d?Ĝ>bXԽ>u߀Ҿ
+>Eӹ7C>z Fy_)>\x>w/YtxXu9`>2I[>2Onz(W_WׄZ>xܾm>1B>xQ5+^OdׄVZ2>yrD8Kj{>5}xO>p躓S5t%l%>y[0jHCv!>~nc^zqvZ?n8>dn>OF_pͺ>yw*x|>yG3p
vK>Q͚~;>`}[u\LrË">xޒJyY37>t@v' eg&0>g`sLGTk>wjuu8>nCV/u2T66>lrtNo>u~qܹg2>dKPԾ%J5aدP4LM>pK&޾sˮ>rAI;vkQ~>VN&Y>MËV~g~(>q9Ӛr?P/.>oE|b~.V>,4A>]'9ľl
tװ>q5,npmA>>g!¾S;e-VJ:[W>enN)fp>p;ţk >_QLfK.۾~AVV[k8_>iElpd*H>LPЃc>ML3	cO@>kzmTlŏ>g(v鞾X&!"1ú>\aַgI6\>k} 3hʪu>`RpS_@jXQG>c{XpijMr>iEJ:c*+>Q@:>>`9 ^GFކ*>fbFH޾hp+>dl(XoWS>)\>U&_cXȱ>g4ei>]tkB*~UsKSL.>`itUe9Y>f]Ծ`(>O#`D6u>9
DJ'ZK},>cee>b<”&UT3br={exu>S)Tadژ(>d ?VbuQ>X2߬<8GHʾLn>^4
3#c rx>c,TP^\ ~>ED*!>ADDbY
>b?*Zپc}ա>^,+MØ.>y{c>U_rf`@>b9e]2_E3>R4*B"MUfQ/"G!B>^]*վa'*>`'s|TqB>0Sj>J؍"O[KwJ9a ~ahX`Ep>V:?<ܑC͝W6>XX5k`@͊>`0E~
X)>CUP\>;u'U[@>^:oо_d->Yh*BG8Y0e˚~>SQ\љ~k>_B=YK/>Ju9> #YhPa(>[.3ξ^vL=ٔ>Y`MfBH}z>MVYН">]E1Y%Kv>O4sGޅ>AJRY>XV\S-$>YuNP462J>#w>G־VV>[ρmYr^
>PDac˾*ԛþE;m#/>UZ6->YLTv2P>/L4x>CzyT
lI>Z+*vX`<>P=1y,PB82>S8ȾYp5D>XhGPc>1|>Al_cpS^mb[z>XƼ `|W43B>P+	U1N4AKF>R8hX.X4F>Vh{N=>/;X/>A ȾRK=>WоV8>M$:+;A|yl>R|qW%pC>U~ܞ0GLmA>&`B5q*KRp+&>VIVGTlZZ>J7|ŬC:uG\1>R}@8}V<c>SlH< >q1>DB*kR+X+>UC>gR>Ew|	Z=gPEgG~>R!+EZUIM>QC(R
Awbk-ۡ>GsGR[pi>TyԈPx>@HyZQ.m>%?I⽾IcToL>SB^rTn.>N<%DY:D$g/0!H>K2jĆS/]&>SYOTrL$Y H>3yh>6!L
$Y>S4HRt?Xc>HG	k([OgM5NiS*j:>Qc׷E{S>6>AVqP;+>Rѧ;OP!@>A"th:>k?>оD~s>P2tRWf|?w>MQkP=;.˶';P>GȰ\Q8*>Q[@aI$>2SJ>4DkN\ȾJbM>QtvP6>F
=RE!tw.L|t
QkU>NiA<\`%5z6qr>B@Y|EѾNL>Q9ՈFKJe>91F>%9CBgwE,>PGPYe>GxR/X 4lwz>I36xPWIt>N}d CS
MJ>)8>=9Kt
H>P?rzKy><)	JO&>YCNCaY.,>MЙLOf>GÞH_1ı>0_!m>G$,oN$j>MSvaC	/>|N>;U)p)JAѳ>N-J@ K*>;{ɵ>ҖvBt>Lq!оMόh>F/mC/T]Ҁz1\R->F4ǂjM/Ԇ>K~M>A8)N>&>>Med)H;!2>6hrce>"3זDC\Xs>Kv
K?/>C_-$E˧5BdO>G"4L{>I;ȵMv7R>@,i%iyI%>KWݾD箛g>.@w>/Gd+Di=[>K]hJIbZ>?mSʯ]ȐԾ;>>HL `K'>E&2<{{'9:~	>CZǫҘJ@rݬ>IAW@b9>~s,>8g־F}|>JwQ^EG>48d>"C4AU*>IG=<@еÐoш6sVGͫ>E-KHIp֫>E\/4yʾ4G
!` 5Χ>AjHnok>H5v[*@;G(>"JT>5FC*Edgj>I
aMDp6c>3st> (`@ȞSF>GEw1pGjyi>>-d6I#S):1>E(6FHW"6>C1|犓t#஑>AsY߾G'>Fp]o<;-Fy>fԝ>7CE3_>GNپBVm!>,>).sA
)G>G4avþE8Z>8β]=8/7:?TAZw>EktlskF\G>@ $C"㙖0Ec>By)+FT?>C?>׾4.D-ξ$>=G&A>
E~ۼt>E<`<ݪL>2>4`L޾Cl5޴>F7}73A,u>-=\Q>%xy@Osc>E3ҍ'C\>7)5'&=!3m9 Z*>DEyE9Ȫb#>>=F]9 
.0_0a>A*AEy|TS>A#`0|r" <[җ>="c&Dːu{>CR7C	=.y>6bCL\VH>Dޖ-=]>!WmDPQ>.A">Dl,APJRIx>0!>~?w<9>D!߾BEy`>6ni=s6#O>BX*~ɾCN-><%mϾT:03P#K|>@S.D(E>@9=g/5ܾCwt>A_@3b_Qʼ>8A"GBR>BX@8*ml>
:7ڭU>2οAFvD>C59q=>#N}>){q?x>C&eܾ@$>ww_>.9vrQ>|-:z>BRyQ&AOͯ4>3zj}=2v?%6|6e>A^%*BcѮn>8>0?
B?n12ŅN>@`tϾBb"eQ2`>;
!UxgRپ*K
>>EsB[>>@;M*a	
޾ '&]>;5!gBK7>@)4D7z1>Hۇ>7;OSGAh3>@▨e4ɻd^=V@>3.v?@]
>APZu7Nw>^5!>00mG4B?%XX>A}LJ:ZeuP> UXZ>)
}<Ɖ>Ap'>!vlo:nNV`L>A1ӽ>oN>-^>b7wj@&>@D?6r>1y`h>
#5A
>@D}OӮ@~>3nVŕz2̯>?FFmܾ@E`+.>6
07'ھ0_>=F5@d^y$>7Ǟ?m9{u+A>$l>96,ʾ N[B&4>:K@Ism@>:b8$)%%G,"`}͙>9M5:@=">;Tk}.g($׾r->7i
?ߐ.=><0,mk>6K\8ľ?6Ps>4⺷?y>{><2ݾ00Av2!R>30j=|NS>=;1*GJm_>2XLgzQ=V:>=`5w2z5r\=A1V>1=J7F;s>=oj3&|q=ؼ{`>0C:<9
>=gc3/t:>O>.H;ȏ>=RoQ+=4<#q>
Q!J">-X
1;
D>=3vd_4Tlo>Re(>,,s.:Qk>=oZ4wJr>9v}>+=F\K:723oQ>	\>*l9C8><2l4r)q>&i>*3T+9> u>*9w/ >\>*&e9Zȧ>;ݴ`=33j$>q>*a9KY
D*>;7!uL368>_>+SԾ9HrZ>;=u Sa2
>V, >+.rq9T*Ū>:^
2#>go>,@/9gӡt>:|R1G8^=#>.(93,i>:
]U0n=ܘ/5>/V2F-9Yi>9s(.hg&l	Ni>0ja'F|9Ը'>8E,PL4rS>14?9MtZ>8H#(̾*e]Mξ`eA>2fHlľ9柣Rl>7GѾ'¾?>2!1{L9Sse>6+9K$
,~Ul>3ܓ-eƾ9ا>5'!jH7犾w>4sܾ9Xv>4 rW!>5N:;9n;(>33S
yR(7%?ɔ>6J􎫾9>1#?PS+t#(Oac>6'lG8w:r>0!qmUӷV$+l
T>7夐1P7r>,r	=i/")>D2g>8J$6v'D>(S>(O_~1!>8I_5U'>$kޅ3>/S2#[(>8\깾48xq>+->l]p3w>80 \2>C>k#U~=>#T:5$8>7dM0w%7>t>(KE}Ҿ6G2Î>7
p?i-1==>,@6حQ>5n>̾(G=O@0s>0UA:Ѿ7DgYc>4zo#.ߨjdF>2+b7^P>2Ҵ̾J Pq>317;>0޺vQO
բd%:Ox>5Qɾ6ho>,@%0.+
g~>5k/&5OK1A>'gP>V&I/|5NZ>6ƌѾ3*&>!%Yd>H~1)1i>6F1źVnG><`'>!ⱄJ3!>6'".?>Ei)>'՘Q!4QZ>53)`9@>-N]5c>3Pپ"'>xD>1	75k>1 Q;׸Ė =,>2ь5[0Sd>.2Ry]
^Vh'+Q%"p6>4pP@ZB4v>(v=ACG/ľ-Ͽ>5C5Z2>!4>#E81
 e}]>5lKU0o1>\R;>"GKK3N a)>4|щI+6f*=r[aϥ>(؍+s4[ߜ7>3i׾$͌=	J>.zhow\4'>1.y[t>6ʾ>Y>1"ݲ:ʾ4II=>-vrzž|&%
>3(蓾3gu/bb>&׈Kz=wLѳ,Z>4lH51.^>-
H>oo0 )	>4uC|.T;W>
yG|>#*2	 w>3 >'l%77>+4/0	30>1)g)`DHu>0g2D¾4ُ#o>.d?Ɍ#ZJ>2]	Pc39ǐ}>'=eߟ۾*屩6>3^i1PsurB>ͩv>!O0W-1B>3?,{<>(\1>$f]2haû>2l%tWj­>+q?~l3m5Ԣ>0(*Ro9sJ&>0oW3D|j懎">7)UЪ.b>p%k{'>D7XRy4c>־`>jT-5%>#?A>m	/쾐:X>.Vdq>G
p5ھ	rՈ>vB[>sWJ>
	ξk
L>JcU$d?Ĝ>bXԽ>u߀Ҿ
+>Eӹ7C>z Fy_)>\x>w/YtxXu9`>2I[>2Onz(W_WׄZ>xܾm>1B>xQ5+^OdׄVZ2>yrD8Kj{>5}xO>p躓S5t%l%>y[0jHCv!>~nc^zqvZ?n8>dn>OF_pͺ>yw*x|>yG3p
vK>Q͚~;>`}[u\LrË">xޒJyY37>t@v' eg&0>g`sLGTk>wjuu8>nCV/u2T66>lrtNo>u~qܹg2>dKPԾ%J5aدP4LM>pK&޾sˮ>rAI;vkQ~>VN&Y>MËV~g~(>q9Ӛr?P/.>oE|b~.V>,4A>]'9ľl
tװ>q5,npmA>>g!¾S;e-VJ:[W>enN)fp>p;ţk >_QLfK.۾~AVV[k8_>iElpd*H>LPЃc>ML3	cO@>kzmTlŏ>g(v鞾X&!"1ú>\aַgI6\>k} 3hʪu>`RpS_@jXQG>c{XpijMr>iEJ:c*+>Q@:>>`9 ^GFކ*>fbFH޾hp+>dl(XoWS>)\>U&_cXȱ>g4ei>]tkB*~UsKSL.>`itUe9Y>f]Ծ`(>O#`D6u>9
DJ'ZK},>cee>b<”&UT3br={exu>S)Tadژ(>d ?VbuQ>X2߬<8GHʾLn>^4
3#c rx>c,TP^\ ~>ED*!>ADDbY
>b?*Zپc}ա>^,+MØ.>y{c>U_rf`@>b9e]2_E3>R4*B"MUfQ/"G!B>^]*վa'*>`'s|TqB>0Sj>J؍"O[KwJ9a ~ahX`Ep>V:?<ܑC͝W6>XX5k`@͊>`0E~
X)>CUP\>;u'U[@>^:oо_d->Yh*BG8Y0e˚~>SQ\љ~k>_B=YK/>Ju9> #YhPa(>[.3ξ^vL=ٔ>Y`MfBH}z>MVYН">]E1Y%Kv>O4sGޅ>AJRY>XV\S-$>YuNP462J>#w>G־VV>[ρmYr^
>PDac˾*ԛþE;m#/>UZ6->YLTv2P>/L4x>CzyT
lI>Z+*vX`<>P=1y,PB82>S8ȾYp5D>XhGPc>1|>Al_cpS^mb[z>XƼ `|W43B>P+	U1N4AKF>R8hX.X4F>Vh{N=>/;X/>A ȾRK=>WоV8>M$:+;A|yl>R|qW%pC>U~ܞ0GLmA>&`B5q*KRp+&>VIVGTlZZ>J7|ŬC:uG\1>R}@8}V<c>SlH< >q1>DB*kR+X+>UC>gR>Ew|	Z=gPEgG~>R!+EZUIM>QC(R
Awbk-ۡ>GsGR[pi>TyԈPx>@HyZQ.m>%?I⽾IcToL>SB^rTn.>N<%DY:D$g/0!H>K2jĆS/]&>SYOTrL$Y H>3yh>6!L
$Y>S4HRt?Xc>HG	k([OgM5NiS*j:>Qc׷E{S>6>AVqP;+>Rѧ;OP!@>A"th:>k?>оD~s>P2tRWf|?w>MQkP=;.˶';P>GȰ\Q8*>Q[@aI$>2SJ>4DkN\ȾJbM>QtvP6>F
=RE!tw.L|t
QkU>NiA<\`%5z6qr>B@Y|EѾNL>Q9ՈFKJe>91F>%9CBgwE,>PGPYe>GxR/X 4lwz>I36xPWIt>N}d CS
MJ>)8>=9Kt
H>P?rzKy><)	JO&>YCNCaY.,>MЙLOf>GÞH_1ı>0_!m>G$,oN$j>MSvaC	/>|N>;U)p)JAѳ>N-J@ K*>;{ɵ>ҖvBt>Lq!оMόh>F/mC/T]Ҁz1\R->F4ǂjM/Ԇ>K~M>A8)N>&>>Med)H;!2>6hrce>"3זDC\Xs>Kv
K?/>C_-$E˧5BdO>G"4L{>I;ȵMv7R>@,i%iyI%>KWݾD箛g>.@w>/Gd+Di=[>K]hJIbZ>?mSʯ]ȐԾ;>>HL `K'>E&2<{{'9:~	>CZǫҘJ@rݬ>IAW@b9>~s,>8g־F}|>JwQ^EG>48d>"C4AU*>IG=<@еÐoш6sVGͫ>E-KHIp֫>E\/4yʾ4G
!` 5Χ>AjHnok>H5v[*@;G(>"JT>5FC*Edgj>I
aMDp6c>3st> (`@ȞSF>GEw1pGjyi>>-d6I#S):1>E(6FHW"6>C1|犓t#஑>AsY߾G'>Fp]o<;-Fy>fԝ>7CE3_>GNپBVm!>,>).sA
)G>G4avþE8Z>8β]=8/7:?TAZw>EktlskF\G>@ $C"㙖0Ec>By)+FT?>C?>׾4.D-ξ$>=G&A>
E~ۼt>E<`<ݪL>2>4`L޾Cl5޴>F7}73A,u>-=\Q>%xy@Osc>E3ҍ'C\>7)5'&=!3m9 Z*>DEyE9Ȫb#>>=F]9 
.0_0a>A*AEy|TS>A#`0|r" <[җ>="c&Dːu{>CR7C	=.y>6bCL\VH>Dޖ-=]>!WmDPQ>.A">Dl,APJRIx>0!>~?w<9>D!߾BEy`>6ni=s6#O>BX*~ɾCN-><%mϾT:03P#K|>@S.D(E>@9=g/5ܾCwt>A_@3b_Qʼ>8A"GBR>BX@8*ml>
:7ڭU>2οAFvD>C59q=>#N}>){q?x>C&eܾ@$>ww_>.9vrQ>|-:z>BRyQ&AOͯ4>3zj}=2v?%6|6e>A^%*BcѮn>8>0?
B?n12ŅN>@`tϾBb"eQ2`>;
!UxgRپ*K
>>EsB[>>@;M*a	
޾ '&]>;5!gBK7>@)4D7z1>Hۇ>7;OSGAh3>@▨e4ɻd^=V@>3.v?@]
>APZu7Nw>^5!>00mG4B?%XX>A}LJ:ZeuP> UXZ>)
}<Ɖ>Ap'>!vlo:nNV`L>A1ӽ>oN>-^>b7wj@&>@D?6r>1y`h>
#5A
>@D}OӮ@~>3nVŕz2̯>?FFmܾ@E`+.>6
07'ھ0_>=F5@d^y$>7Ǟ?m9{u+A>$l>96,ʾ N[B&4>:K@Ism@>:b8$)%%G,"`}͙>9M5:@=">;Tk}.g($׾r->7i
?ߐ.=><0,mk>6K\8ľ?6Ps>4⺷?y>{><2ݾ00Av2!R>30j=|NS>=;1*GJm_>2XLgzQ=V:>=`5w2z5r\=A1V>1=J7F;s>=oj3&|q=ؼ{`>0C:<9
>=gc3/t:>O>.H;ȏ>=RoQ+=4<#q>
Q!J">-X
1;
D>=3vd_4Tlo>Re(>,,s.:Qk>=oZ4wJr>9v}>+=F\K:723oQ>	\>*l9C8><2l4r)q>&i>*3T+9> u>*9w/ >\>*&e9Zȧ>;ݴ`=33j$>q>*a9KY
D*>;7!uL368>_>+SԾ9HrZ>;=u Sa2
>V, >+.rq9T*Ū>:^
2#>go>,@/9gӡt>:|R1G8^=#>.(93,i>:
]U0n=ܘ/5>/V2F-9Yi>9s(.hg&l	Ni>0ja'F|9Ը'>8E,PL4rS>14?9MtZ>8H#(̾*e]Mξ`eA>2fHlľ9柣Rl>7GѾ'¾?>2!1{L9Sse>6+9K$
,~Ul>3ܓ-eƾ9ا>5'!jH7犾w>4sܾ9Xv>4 rW!>5N:;9n;(>33S
yR(7%?ɔ>6J􎫾9>1#?PS+t#(Oac>6'lG8w:r>0!qmUӷV$+l
T>7夐1P7r>,r	=i/")>D2g>8J$6v'D>(S>(O_~1!>8I_5U'>$kޅ3>/S2#[(>8\깾48xq>+->l]p3w>80 \2>C>k#U~=>#T:5$8>7dM0w%7>t>(KE}Ҿ6G2Î>7
p?i-1==>,@6حQ>5n>̾(G=O@0s>0UA:Ѿ7DgYc>4zo#.ߨjdF>2+b7^P>2Ҵ̾J Pq>317;>0޺vQO
բd%:Ox>5Qɾ6ho>,@%0.+
g~>5k/&5OK1A>'gP>V&I/|5NZ>6ƌѾ3*&>!%Yd>H~1)1i>6F1źVnG><`'>!ⱄJ3!>6'".?>Ei)>'՘Q!4QZ>53)`9@>-N]5c>3Pپ"'>xD>1	75k>1 Q;׸Ė =,>2ь5[0Sd>.2Ry]
^Vh'+Q%"p6>4pP@ZB4v>(v=ACG/ľ-Ͽ>5C5Z2>!4>#E81
 e}]>5lKU0o1>\R;>"GKK3N a)>4|щI+6f*=r[aϥ>(؍+s4[ߜ7>3i׾$͌=	J>.zhow\4'>1.y[t>6ʾ>Y>1"ݲ:ʾ4II=>-vrzž|&%
>3(蓾3gu/bb>&׈Kz=wLѳ,Z>4lH51.^>-
H>oo0 )	>4uC|.T;W>
yG|>#*2	 w>3 >'l%77>+4/0	30>1)g)`DHu>0g2D¾4ُ#o>.d?Ɍ#ZJ>2]	Pc39ǐ}>'=eߟ۾*屩6>3^i1PsurB>ͩv>!O0W-1B>3?,{<>(\1>$f]2haû>2l%tWj­>+q?~l3m5Ԣ>0(*Ro9sJ&>0oW3D|>*Sѽ)F,%Kp>2R<1]>">1>
t!G,">33%.|X>ӟ޳{c> 3Ⱦ1):B\">2E,ATt'u!~C>(lŒT2>XDu>0m$'L`>/&L!2ܿQ>+`t[bm5<#ʨ
6>1`ŵ&1^Bm>#7O~>va+5%>2q.977S>s$0@‘>2f"Z&	;ܒ
М>(228>0\<
~zrꁱ>.O2Bpy&>)AƸC9$r	I>1	?0.=> d+>06o,@1Z>2,9H+4;E>	CiD>!O0یP"r>1*S2#Nzf&>*3gu@[1[2.>-0zfK׾[e5>0$	1]4fŵ>%C_j=q(&i>1+A$
$.2^>_>E.}ZF>1hN~H&
 =l>&d71M2	e>.XiS1c>-21]&v|>'g`½(NZ,%[kJ>0/)u>프k>R48,rJ>1@:Q
(;=q5Σ>#l_0tX>/?s,;[g>,|؊ 1\p>(j,Y#`sT>0vW0۾/нLl>}>6J!+)>\>0E(G#&E00Nu&#>.Ć
iv
_>>+^Eɾ0ů>'*ƽ+C_ر#Rˣ>04Oi.9^A>uB>K벾+W<>0}о'L,=x|>#օf^k0)ڭ>-@[G`YjX>+kҾ0Wha>%vjꏳ$Bx>0%<,{X>JVQ>,Y7ҳ>0oq$l%Dy:9ܘ!L>%_|k0#>+TD$Kօ>-,1W/Yb>"rh=`2'1$A>0~W)Lea>>[\>-DMiS>.WѾ Jڽk2zT>(
qH^/63v>'ז3+;!IAύ>.@>A-_>"S]>P}*Be>/o'ž%r6T0=+>#*wP־..\>+D3b*5@"?w>+Kj.vS">"j!g=h֥&*IC>/*[C)<+%*>Q^>X-
8YS>-7-4)T3 1-Nz>(=Wɾ.G{Y>&.eGsC6D86"P%o>.5+E]h`>q.^>6*[>.4G,"lk쟕t}>%`E.@.uE'>(w!A
Ҕ"&e<;>,wG,¬> >
(ZHo>.0%7%,
Eo=D5>"clj%)-I	>*7-IPGBc>*Oi7-;8x> ,E#=r#&Cg>-~	&x->_H> *ΘҾ,w>*5Iu6l)پ!땼Ī>)rҸ\--)>"il:=Ǭ,$cP>-tZ^'֘dQ>:
 ;~>WH:+{z>+8R[*)4?>(afʾ-W]=>#)iY]=z^޾#
>,ξ'ƥ>Ϻ|>}R++#쿭>+1,38:@s0>'2b,p>#K+yIe+׾#nl>,[4'ɜ۫)>Ee>z*	d]g>*
+ž鏾VL>']ڲ,anv>"{4.=cɾ#|r>,S;L'7 t>	wM>Xr8
*CH>*Bv:{쥦2F>'ϫPa+h-<>!P U=Z֘#Y_\>,dz	&,S>nu>mP*~>)[lАmC0eiƸ>(j͸)l+AUf> -Ns?=oQ
$ї >+!r$
=(,[> QIG+ƔI/>(E>}ƪVVʹ>)58]׾*LQw$>!Y>P&;>+bwD"s]x*=CUW>"\![Y+G`2>&#PCn	sK[>*	{篾(q	Nd>D|>s\'Ĝ6*>* Ol `PB>$ ޾+U-s>#|_o:Ouaꂱ >>*?#&ɖ>2&u>K)5Uグ$>)O/
:H>&Qþ*Yni> fv!=|%#>*{a#4-=> ϾG*1}$>&Tž
 Er:c
>(	ࣾ(oş>s->
x&lpP>)CJWkLH[y>#m~&$*Y2	>#! S*'˽ T0R:>)j$I%d&>	tT2@>f_}(j>'W~t˾X>&	,)Q8ךp>6Je>6ϟ$tX>)RO4Z!ZX72g=X;>!{A)IY;>${EQRDYsy;9C#>)'KS&٧ŝ>hV>'ֈˁ>(G͖)sҏ
	\>%Mk*l):>e=9ڝ#KWT>)"3ӁQB3=p_> xJlj)LI}>$N)~0A|Τ>(~ņ<&$ßD>Y>%A'01WW>'y$[
7*a>%l(ɤVn>`= =E[#C`5>) )ۓ!}.=NOT> 2qž(pG>#Im?)KE>U(>(bg>?
%[0>'>:-j'_NpK>'ѾmY+&.xT>%F'	G
>	У\>;M!$<O>( qP9$ź횢_m`>"62}+(*>!Z9㚜t{̾V>(xHLT߾#rt;w>#Y(	>+'w>%?
_:-1ž1?>'L&xR67>_-s>Lb̾%pr!>'[Km"Qʥ=>$`|'M>bL=Ń"'9o>(1*a km2ňs> 6((+nh>"0Bu9Dl+Vv>'`7w#Ql>U!$>Y'PΑ>$k$}c>yDe`;7k>&ؗf%7>tW	>o:4̾%~>&t-		
>$hR⡾'E>#ƂK>:FN##a>'4žCxIqT$>!Jȶ'ѮR> w~܊ /
e>'+!?,=@A}>,1u2Ͼ'UAHn>#|4g
8d߀C>&Em|$":>71>-p&^>$;}=?':}Pd>%l%^AJ>D1l><$wh>&6:
4ݾόF>$M&!:>07>*q#k͍|>&ߤejI)n>"/')Z>+(=ӜX!T`>'ȸ ")=S_s%F>d&
[>!^6>5>&yg{-!CG=H&>]IΟU&F~*Y>"#6	!{|L[Miۅ>&If#d{@>>;ֻ!%Mjm>#/疾
t{Wz>%L$t0>
>K%L5N>$a<H>"U>$g釾%1:-->p>
U
3S$>%xw@z3:pM	:t?F>#)0R%i>\>O#>%g
D?r4	!8:k+>"'泾%ʺcR>N=&
lG z	֗>!CSپ&:>ㆁV=H!7x->&cp`㎼m#k> M᫭]&<V>ʰλ=3؁U +s7>&ɝgy<(D>>̾&1>2:C[h1F>%JƤk=Ò>;wG%k1*> $f&\ɽ*’Qj>%b# ]=\fq>IY%
wY> uB-Va>V
>%ċ" HsI=~s2
>F!oH%,> ̢%%Ⱦ ßb=jgՌv>wL%o Ӣ> _Uȧb>%q#w߾ |S=cJiT>y"	'%fƻ5> =d\.܌Z>%\ ӽt;
=s,>`b\4%P8> wIm((e>%Dj^C d'=B>_z%;> {蕽J3f2V>@>%67z)9 R3,]p=j0>u6'<%2H > 4!RM8+kU.>%--t5ۓ=9Tx>XBT%%]}F*>3c#JڌԜO?G>%NH?q鼵=M0>]i:=%CX'>!"G|=s#l1>%qǓ(+Ƚ֏3>dU۾$,i>R=>+M#,S(>$rU¾bb\VmaX> =$Ϧ.>XP!w=u'~! gM睆>$w.x:yEs5> ?o$lH?>~Ž={*!+ >$]R{;OiAފl>!*pž$*O_]>W!.>1!F\>#[ДaK.ŕL>"Y;C׾#$*>+01>IvX"YL>#A~WKmAs{|>#+	"٘}>
.@ğ>J
)Ծ#\N x">"d,<	OľX>#S!߬;>1>S!#T3>!H("5z\:_aFM>$ӪY f/ =x*I>f!3$:`>EυV譾yY8>$JZna=\\/c>>dԀ$I
N>$6gEaíȽ	EY>q/$h+>u=EE n>#qz|ӲcNG>!Y{E,#m>D1n>*`Δ"׆>"2Sv
9͕>""ZR̹>)>{A#M>!!;QAzHy>#uH޲E \V=۷
0>JiN#3>•L	Y邾^fq>#,k5oPR=:+'K>Nݾ#o>gq=?_C1"I>#ENa,b"dh> ,EKվ#u0>qJn>[!&>#׏H"	~q,>!Ҿ"b':/>
ȵG>4Re2!U"+m}>!>s/ƾzov>##^_O tH={0>j`@#yGz€>h.!	V>#];#Cj=>#i>d
h=q3!Nvo>#H7r
N@:15N> ˓H$"zN>{xf>	]f!u)>"@(M~h>"b"{!*u1>#]>-Hx#
H>˺XCa?V*q"˂>#UU6=.'	 >vڌ[1#\1_>MD=/HƾwT>#1þ]@ x> 'T"73N>zgw>	`e!'>!ʝNU
uoP F>"r?M *W>N!>W"}%z>ڽ7Xpk'PM>DUee>#/5~7rܹ@gu>v#B2>a=,y[n>"h;nM2@ɾ_EvT>!-Dw莾!ڕߩ>Ö>g-H"%T7> 
(OI/ym5>"Śh4}==$-u>5.#'>9m+=bI.%_õ>"⿐MѾ/]cڅ>{V"Z%s>x"=,>f>Va!J`>!nzOǾ	KZ߉>":HIv 綜Y=}2%ql>0@"7>uLCĽCj
fr>"jW*yCPc>\bU"5-&>9|F>v  P>!,
,-)WD~>!a"̾ j*.>yθ>e=I"MW>pb};Pžmq>"f=jpI!v|9>U"q[>N݌>4"v 2e>!ƪ/
},m>! D Pqv|>ge[>,"oVj&>P@D.\uX
>"6j~s/^c'>7о"7l>7 F4>^ ‹>!EFhZ
]cH9>!Ñ+y =	+>8b]޾"o0!d>X
νN2;'C>"n҃p}Tr/b>*Sѽ)F,%Kp>2R<1]>">1>
t!G,">33%.|X>ӟ޳{c> 3Ⱦ1):B\">2E,ATt'u!~C>(lŒT2>XDu>0m$'L`>/&L!2ܿQ>+`t[bm5<#ʨ
6>1`ŵ&1^Bm>#7O~>va+5%>2q.977S>s$0@‘>2f"Z&	;ܒ
М>(228>0\<
~zrꁱ>.O2Bpy&>)AƸC9$r	I>1	?0.=> d+>06o,@1Z>2,9H+4;E>	CiD>!O0یP"r>1*S2#Nzf&>*3gu@[1[2.>-0zfK׾[e5>0$	1]4fŵ>%C_j=q(&i>1+A$
$.2^>_>E.}ZF>1hN~H&
 =l>&d71M2	e>.XiS1c>-21]&v|>'g`½(NZ,%[kJ>0/)u>프k>R48,rJ>1@:Q
(;=q5Σ>#l_0tX>/?s,;[g>,|؊ 1\p>(j,Y#`sT>0vW0۾/нLl>}>6J!+)>\>0E(G#&E00Nu&#>.Ć
iv
_>>+^Eɾ0ů>'*ƽ+C_ر#Rˣ>04Oi.9^A>uB>K벾+W<>0}о'L,=x|>#օf^k0)ڭ>-@[G`YjX>+kҾ0Wha>%vjꏳ$Bx>0%<,{X>JVQ>,Y7ҳ>0oq$l%Dy:9ܘ!L>%_|k0#>+TD$Kօ>-,1W/Yb>"rh=`2'1$A>0~W)Lea>>[\>-DMiS>.WѾ Jڽk2zT>(
qH^/63v>'ז3+;!IAύ>.@>A-_>"S]>P}*Be>/o'ž%r6T0=+>#*wP־..\>+D3b*5@"?w>+Kj.vS">"j!g=h֥&*IC>/*[C)<+%*>Q^>X-
8YS>-7-4)T3 1-Nz>(=Wɾ.G{Y>&.eGsC6D86"P%o>.5+E]h`>q.^>6*[>.4G,"lk쟕t}>%`E.@.uE'>(w!A
Ҕ"&e<;>,wG,¬> >
(ZHo>.0%7%,
Eo=D5>"clj%)-I	>*7-IPGBc>*Oi7-;8x> ,E#=r#&Cg>-~	&x->_H> *ΘҾ,w>*5Iu6l)پ!땼Ī>)rҸ\--)>"il:=Ǭ,$cP>-tZ^'֘dQ>:
 ;~>WH:+{z>+8R[*)4?>(afʾ-W]=>#)iY]=z^޾#
>,ξ'ƥ>Ϻ|>}R++#쿭>+1,38:@s0>'2b,p>#K+yIe+׾#nl>,[4'ɜ۫)>Ee>z*	d]g>*
+ž鏾VL>']ڲ,anv>"{4.=cɾ#|r>,S;L'7 t>	wM>Xr8
*CH>*Bv:{쥦2F>'ϫPa+h-<>!P U=Z֘#Y_\>,dz	&,S>nu>mP*~>)[lАmC0eiƸ>(j͸)l+AUf> -Ns?=oQ
$ї >+!r$
=(,[> QIG+ƔI/>(E>}ƪVVʹ>)58]׾*LQw$>!Y>P&;>+bwD"s]x*=CUW>"\![Y+G`2>&#PCn	sK[>*	{篾(q	Nd>D|>s\'Ĝ6*>* Ol `PB>$ ޾+U-s>#|_o:Ouaꂱ >>*?#&ɖ>2&u>K)5Uグ$>)O/
:H>&Qþ*Yni> fv!=|%#>*{a#4-=> ϾG*1}$>&Tž
 Er:c
>(	ࣾ(oş>s->
x&lpP>)CJWkLH[y>#m~&$*Y2	>#! S*'˽ T0R:>)j$I%d&>	tT2@>f_}(j>'W~t˾X>&	,)Q8ךp>6Je>6ϟ$tX>)RO4Z!ZX72g=X;>!{A)IY;>${EQRDYsy;9C#>)'KS&٧ŝ>hV>'ֈˁ>(G͖)sҏ
	\>%Mk*l):>e=9ڝ#KWT>)"3ӁQB3=p_> xJlj)LI}>$N)~0A|Τ>(~ņ<&$ßD>Y>%A'01WW>'y$[
7*a>%l(ɤVn>`= =E[#C`5>) )ۓ!}.=NOT> 2qž(pG>#Im?)KE>U(>(bg>?
%[0>'>:-j'_NpK>'ѾmY+&.xT>%F'	G
>	У\>;M!$<O>( qP9$ź횢_m`>"62}+(*>!Z9㚜t{̾V>(xHLT߾#rt;w>#Y(	>+'w>%?
_:-1ž1?>'L&xR67>_-s>Lb̾%pr!>'[Km"Qʥ=>$`|'M>bL=Ń"'9o>(1*a km2ňs> 6((+nh>"0Bu9Dl+Vv>'`7w#Ql>U!$>Y'PΑ>$k$}c>yDe`;7k>&ؗf%7>tW	>o:4̾%~>&t-		
>$hR⡾'E>#ƂK>:FN##a>'4žCxIqT$>!Jȶ'ѮR> w~܊ /
e>'+!?,=@A}>,1u2Ͼ'UAHn>#|4g
8d߀C>&Em|$":>71>-p&^>$;}=?':}Pd>%l%^AJ>D1l><$wh>&6:
4ݾόF>$M&!:>07>*q#k͍|>&ߤejI)n>"/')Z>+(=ӜX!T`>'ȸ ")=S_s%F>d&
[>!^6>5>&yg{-!CG=H&>]IΟU&F~*Y>"#6	!{|L[Miۅ>&If#d{@>>;ֻ!%Mjm>#/疾
t{Wz>%L$t0>
>K%L5N>$a<H>"U>$g釾%1:-->p>
U
3S$>%xw@z3:pM	:t?F>#)0R%i>\>O#>%g
D?r4	!8:k+>"'泾%ʺcR>N=&
lG z	֗>!CSپ&:>ㆁV=H!7x->&cp`㎼m#k> M᫭]&<V>ʰλ=3؁U +s7>&ɝgy<(D>>̾&1>2:C[h1F>%JƤk=Ò>;wG%k1*> $f&\ɽ*’Qj>%b# ]=\fq>IY%
wY> uB-Va>V
>%ċ" HsI=~s2
>F!oH%,> ̢%%Ⱦ ßb=jgՌv>wL%o Ӣ> _Uȧb>%q#w߾ |S=cJiT>y"	'%fƻ5> =d\.܌Z>%\ ӽt;
=s,>`b\4%P8> wIm((e>%Dj^C d'=B>_z%;> {蕽J3f2V>@>%67z)9 R3,]p=j0>u6'<%2H > 4!RM8+kU.>%--t5ۓ=9Tx>XBT%%]}F*>3c#JڌԜO?G>%NH?q鼵=M0>]i:=%CX'>!"G|=s#l1>%qǓ(+Ƚ֏3>dU۾$,i>R=>+M#,S(>$rU¾bb\VmaX> =$Ϧ.>XP!w=u'~! gM睆>$w.x:yEs5> ?o$lH?>~Ž={*!+ >$]R{;OiAފl>!*pž$*O_]>W!.>1!F\>#[ДaK.ŕL>"Y;C׾#$*>+01>IvX"YL>#A~WKmAs{|>#+	"٘}>
.@ğ>J
)Ծ#\N x">"d,<	OľX>#S!߬;>1>S!#T3>!H("5z\:_aFM>$ӪY f/ =x*I>f!3$:`>EυV譾yY8>$JZna=\\/c>>dԀ$I
N>$6gEaíȽ	EY>q/$h+>u=EE n>#qz|ӲcNG>!Y{E,#m>D1n>*`Δ"׆>"2Sv
9͕>""ZR̹>)>{A#M>!!;QAzHy>#uH޲E \V=۷
0>JiN#3>•L	Y邾^fq>#,k5oPR=:+'K>Nݾ#o>gq=?_C1"I>#ENa,b"dh> ,EKվ#u0>qJn>[!&>#׏H"	~q,>!Ҿ"b':/>
ȵG>4Re2!U"+m}>!>s/ƾzov>##^_O tH={0>j`@#yGz€>h.!	V>#];#Cj=>#i>d
h=q3!Nvo>#H7r
N@:15N> ˓H$"zN>{xf>	]f!u)>"@(M~h>"b"{!*u1>#]>-Hx#
H>˺XCa?V*q"˂>#UU6=.'	 >vڌ[1#\1_>MD=/HƾwT>#1þ]@ x> 'T"73N>zgw>	`e!'>!ʝNU
uoP F>"r?M *W>N!>W"}%z>ڽ7Xpk'PM>DUee>#/5~7rܹ@gu>v#B2>a=,y[n>"h;nM2@ɾ_EvT>!-Dw莾!ڕߩ>Ö>g-H"%T7> 
(OI/ym5>"Śh4}==$-u>5.#'>9m+=bI.%_õ>"⿐MѾ/]cڅ>{V"Z%s>x"=,>f>Va!J`>!nzOǾ	KZ߉>":HIv 綜Y=}2%ql>0@"7>uLCĽCj
fr>"jW*yCPc>\bU"5-&>9|F>v  P>!,
,-)WD~>!a"̾ j*.>yθ>e=I"MW>pb};Pžmq>"f=jpI!v|9>U"q[>N݌>4"v 2e>!ƪ/
},m>! D Pqv|>ge[>,"oVj&>P@D.\uX
>"6j~s/^c'>7о"7l>7 F4>^ ‹>!EFhZ
]cH9>!Ñ+y =	+>8b]޾"o0!d>X
νN2;'C>"n҃p}Tr/b>*Sѽ)F,%Kp>2R<1]>">1>
t!G,">33%.|X>ӟ޳{c> 3Ⱦ1):B\">2E,ATt'u!~C>(lŒT2>XDu>0m$'L`>/&L!2ܿQ>+`t[bm5<#ʨ
6>1`ŵ&1^Bm>#7O~>va+5%>2q.977S>s$0@‘>2f"Z&	;ܒ
М>(228>0\<
~zrꁱ>.O2Bpy&>)AƸC9$r	I>1	?0.=> d+>06o,@1Z>2,9H+4;E>	CiD>!O0یP"r>1*S2#Nzf&>*3gu@[1[2.>-0zfK׾[e5>0$	1]4fŵ>%C_j=q(&i>1+A$
$.2^>_>E.}ZF>1hN~H&
 =l>&d71M2	e>.XiS1c>-21]&v|>'g`½(NZ,%[kJ>0/)u>프k>R48,rJ>1@:Q
(;=q5Σ>#l_0tX>/?s,;[g>,|؊ 1\p>(j,Y#`sT>0vW0۾/нLl>}>6J!+)>\>0E(G#&E00Nu&#>.Ć
iv
_>>+^Eɾ0ů>'*ƽ+C_ر#Rˣ>04Oi.9^A>uB>K벾+W<>0}о'L,=x|>#օf^k0)ڭ>-@[G`YjX>+kҾ0Wha>%vjꏳ$Bx>0%<,{X>JVQ>,Y7ҳ>0oq$l%Dy:9ܘ!L>%_|k0#>+TD$Kօ>-,1W/Yb>"rh=`2'1$A>0~W)Lea>>[\>-DMiS>.WѾ Jڽk2zT>(
qH^/63v>'ז3+;!IAύ>.@>A-_>"S]>P}*Be>/o'ž%r6T0=+>#*wP־..\>+D3b*5@"?w>+Kj.vS">"j!g=h֥&*IC>/*[C)<+%*>Q^>X-
8YS>-7-4)T3 1-Nz>(=Wɾ.G{Y>&.eGsC6D86"P%o>.5+E]h`>q.^>6*[>.4G,"lk쟕t}>%`E.@.uE'>(w!A
Ҕ"&e<;>,wG,¬> >
(ZHo>.0%7%,
Eo=D5>"clj%)-I	>*7-IPGBc>*Oi7-;8x> ,E#=r#&Cg>-~	&x->_H> *ΘҾ,w>*5Iu6l)پ!땼Ī>)rҸ\--)>"il:=Ǭ,$cP>-tZ^'֘dQ>:
 ;~>WH:+{z>+8R[*)4?>(afʾ-W]=>#)iY]=z^޾#
>,ξ'ƥ>Ϻ|>}R++#쿭>+1,38:@s0>'2b,p>#K+yIe+׾#nl>,[4'ɜ۫)>Ee>z*	d]g>*
+ž鏾VL>']ڲ,anv>"{4.=cɾ#|r>,S;L'7 t>	wM>Xr8
*CH>*Bv:{쥦2F>'ϫPa+h-<>!P U=Z֘#Y_\>,dz	&,S>nu>mP*~>)[lАmC0eiƸ>(j͸)l+AUf> -Ns?=oQ
$ї >+!r$
=(,[> QIG+ƔI/>(E>}ƪVVʹ>)58]׾*LQw$>!Y>P&;>+bwD"s]x*=CUW>"\![Y+G`2>&#PCn	sK[>*	{篾(q	Nd>D|>s\'Ĝ6*>* Ol `PB>$ ޾+U-s>#|_o:Ouaꂱ >>*?#&ɖ>2&u>K)5Uグ$>)O/
:H>&Qþ*Yni> fv!=|%#>*{a#4-=> ϾG*1}$>&Tž
 Er:c
>(	ࣾ(oş>s->
x&lpP>)CJWkLH[y>#m~&$*Y2	>#! S*'˽ T0R:>)j$I%d&>	tT2@>f_}(j>'W~t˾X>&	,)Q8ךp>6Je>6ϟ$tX>)RO4Z!ZX72g=X;>!{A)IY;>${EQRDYsy;9C#>)'KS&٧ŝ>hV>'ֈˁ>(G͖)sҏ
	\>%Mk*l):>e=9ڝ#KWT>)"3ӁQB3=p_> xJlj)LI}>$N)~0A|Τ>(~ņ<&$ßD>Y>%A'01WW>'y$[
7*a>%l(ɤVn>`= =E[#C`5>) )ۓ!}.=NOT> 2qž(pG>#Im?)KE>U(>(bg>?
%[0>'>:-j'_NpK>'ѾmY+&.xT>%F'	G
>	У\>;M!$<O>( qP9$ź횢_m`>"62}+(*>!Z9㚜t{̾V>(xHLT߾#rt;w>#Y(	>+'w>%?
_:-1ž1?>'L&xR67>_-s>Lb̾%pr!>'[Km"Qʥ=>$`|'M>bL=Ń"'9o>(1*a km2ňs> 6((+nh>"0Bu9Dl+Vv>'`7w#Ql>U!$>Y'PΑ>$k$}c>yDe`;7k>&ؗf%7>tW	>o:4̾%~>&t-		
>$hR⡾'E>#ƂK>:FN##a>'4žCxIqT$>!Jȶ'ѮR> w~܊ /
e>'+!?,=@A}>,1u2Ͼ'UAHn>#|4g
8d߀C>&Em|$":>71>-p&^>$;}=?':}Pd>%l%^AJ>D1l><$wh>&6:
4ݾόF>$M&!:>07>*q#k͍|>&ߤejI)n>"/')Z>+(=ӜX!T`>'ȸ ")=S_s%F>d&
[>!^6>5>&yg{-!CG=H&>]IΟU&F~*Y>"#6	!{|L[Miۅ>&If#d{@>>;ֻ!%Mjm>#/疾
t{Wz>%L$t0>
>K%L5N>$a<H>"U>$g釾%1:-->p>
U
3S$>%xw@z3:pM	:t?F>#)0R%i>\>O#>%g
D?r4	!8:k+>"'泾%ʺcR>N=&
lG z	֗>!CSپ&:>ㆁV=H!7x->&cp`㎼m#k> M᫭]&<V>ʰλ=3؁U +s7>&ɝgy<(D>>̾&1>2:C[h1F>%JƤk=Ò>;wG%k1*> $f&\ɽ*’Qj>%b# ]=\fq>IY%
wY> uB-Va>V
>%ċ" HsI=~s2
>F!oH%,> ̢%%Ⱦ ßb=jgՌv>wL%o Ӣ> _Uȧb>%q#w߾ |S=cJiT>y"	'%fƻ5> =d\.܌Z>%\ ӽt;
=s,>`b\4%P8> wIm((e>%Dj^C d'=B>_z%;> {蕽J3f2V>@>%67z)9 R3,]p=j0>u6'<%2H > 4!RM8+kU.>%--t5ۓ=9Tx>XBT%%]}F*>3c#JڌԜO?G>%NH?q鼵=M0>]i:=%CX'>!"G|=s#l1>%qǓ(+Ƚ֏3>dU۾$,i>R=>+M#,S(>$rU¾bb\VmaX> =$Ϧ.>XP!w=u'~! gM睆>$w.x:yEs5> ?o$lH?>~Ž={*!+ >$]R{;OiAފl>!*pž$*O_]>W!.>1!F\>#[ДaK.ŕL>"Y;C׾#$*>+01>IvX"YL>#A~WKmAs{|>#+	"٘}>
.@ğ>J
)Ծ#\N x">"d,<	OľX>#S!߬;>1>S!#T3>!H("5z\:_aFM>$ӪY f/ =x*I>f!3$:`>EυV譾yY8>$JZna=\\/c>>dԀ$I
N>$6gEaíȽ	EY>q/$h+>u=EE n>#qz|ӲcNG>!Y{E,#m>D1n>*`Δ"׆>"2Sv
9͕>""ZR̹>)>{A#M>!!;QAzHy>#uH޲E \V=۷
0>JiN#3>•L	Y邾^fq>#,k5oPR=:+'K>Nݾ#o>gq=?_C1"I>#ENa,b"dh> ,EKվ#u0>qJn>[!&>#׏H"	~q,>!Ҿ"b':/>
ȵG>4Re2!U"+m}>!>s/ƾzov>##^_O tH={0>j`@#yGz€>h.!	V>#];#Cj=>#i>d
h=q3!Nvo>#H7r
N@:15N> ˓H$"zN>{xf>	]f!u)>"@(M~h>"b"{!*u1>#]>-Hx#
H>˺XCa?V*q"˂>#UU6=.'	 >vڌ[1#\1_>MD=/HƾwT>#1þ]@ x> 'T"73N>zgw>	`e!'>!ʝNU
uoP F>"r?M *W>N!>W"}%z>ڽ7Xpk'PM>DUee>#/5~7rܹ@gu>v#B2>a=,y[n>"h;nM2@ɾ_EvT>!-Dw莾!ڕߩ>Ö>g-H"%T7> 
(OI/ym5>"Śh4}==$-u>5.#'>9m+=bI.%_õ>"⿐MѾ/]cڅ>{V"Z%s>x"=,>f>Va!J`>!nzOǾ	KZ߉>":HIv 綜Y=}2%ql>0@"7>uLCĽCj
fr>"jW*yCPc>\bU"5-&>9|F>v  P>!,
,-)WD~>!a"̾ j*.>yθ>e=I"MW>pb};Pžmq>"f=jpI!v|9>U"q[>N݌>4"v 2e>!ƪ/
},m>! D Pqv|>ge[>,"oVj&>P@D.\uX
>"6j~s/^c'>7о"7l>7 F4>^ ‹>!EFhZ
]cH9>!Ñ+y =	+>8b]޾"o0!d>X
νN2;'C>"n҃p}Tr/b>IJoi9!K\b>>
?d&U!+e3> R(W}bGyM\l>"ݯK\m=4‡@>u8"f$e(>*p*-G=_6.
>"W!۾ǾH> {9 N>	
> Vݓq!UI>5u@ >"Inx2搽>?S"A>N>1F2ξ $,>!,'n^w@`@5{>!aם7NS=~(>-[e")'د1>{pok=v/n~W9/>"
CҷDsS.L>>ݾ!)̔ܫm>$vن[>`!d$LQFd>A~,>snX>"Q^7R'jVhE>wU!b)C>]"8>e2#E}> a:
؅͛;\*>!k?0Wr=4=>-8g"=w>lCqR=q"Ba">!6"B~	 > =:3< ',>ϱsC>s0f!W5Uc>Ns9ȭ|=@oԔ>!x0!j>u.!y{J^>
κ>cvє )sOM&> 
#u5>!	ƾw3l=ݎvt>:F\!!y>T0'Q=<>S3l> CWay9>!&A߾7?(x=>T5>~8=	!-->aqz=%Hn/>!z3Q
`e:> _Gg ZI<<>AU^>
Yd!h6>3`ԞȾߥ>!H~zEV>km )^S+>
le>yBn!!Zas%>Q"!x.!>!FY
f> о!*%G><>	]Ͼ 5=ս>3Kb$Mz>!Ŭx՟0:>hn=	v!fd4`>dP->ڣXl tyt> Hn9(u5>!e3
J%G}=s1>݇h߾!~O>9z>}l1eǦ> ]fЂ#70>!*46#B6=嘚=
>	e!5>~WS=n]ꪴ> վ
zx
b
ۚ> υ߾ַ0=fX&>-zW!9rB>PJTl=TFRm>/e> OA
ږf> Чƾ1;ю=?e%>斝!r)>m=e&rԾcg]f> pn
@> iHsē=$>ΥSO!f>p>äe"=5^`JF > 	@
!;ch> P[=?cd>!\:>l=!y1
h> 8y$I$y&ԟ|A> .؞G'A}=nm>{9YL:!M~>L=IP3!{> Z!Sj	E;YZς> jXd=л>P5+x!9*">=eo}j6> d9pO>> kH=S|F1>wuI!G[%>
/j>QjJEF4>H[5q!(ՙr0i(=~>!q|QHc6$Aiz> ^Q->	2\>6uy 
.>s(Tan>!"	q66.E>[# 	>
@u>V^F w9Hdl>j?j)G8w=>!("+J;si>Ւ Ii>PNs%]>S-C웾 _z/>|&ׂCƁy$ױl> ++jA.̤>:R>v;~qzqJ=,>*F3B!	U>wgX"=}'!<B> w(=¾
He@> Z
> ]uKh(=|\_>V*#D BG>͖Ҏ=·&7%Ⴓ>yAQciH
û,B> 1Es&[J&>vRǙRѾ pƮ>q>
k Wz>>`X;Ľ:(U> Zsvwg9_5>Lwc9dC>p>N *>*ADy:j.B> ɪAkUPs>ҧE|"=;p>_
,ET 㝄R[>j~a0=Ş
ת>a̳kȫ@<	1> -M[=fls_>ft S.E%i>`><	W>$Rk]11,B|z5> 8xҾ\ZPy >g-:ϾffO>Z>=C wcu>@ַE=ѐeSw>a> i]iQN	۲D> 
t*!E=_
Ei(> 4>>0sFES+>sP1R6t_c`\Of> /JUg~ 8y>(m{n 	wZ>
Q,s>y \~/>Y)~V5	&+.> 7cO?>vm
ź|x=#y># >>|'S3=%XЋR>y=_9྾~x`> S)a[+;!r>X_[>
RS>m4ľ KXsL> g`Tmd6H>p9Ia=4Dg	>bPľ r	
G>qp>&Azք<%iib> }FlnL>\ֿ*ހ>]o>PƜ"
 oJӈ{>_g4.=D51Z.dP~> 	|gI
b> !4ЦS
~=ёa>~}1d Ux\>si>
oMv>+Qz쒾GF> ~ժ|u˥tUk>qIn?=b\>IY )g>A$b=0z-RYL>W^)׾Rb־[p> xGb̾Ky-QCM;>:v5¾')#>oU> SOqZ>5M=-D~>-&\
lDT3x*> aXa+{m.[>Ͼ =6ô>
n>
ʪhľBm>'Gg!ݎ] B50nyp9SfF>=Àk=PFET>0-ľ YA(>Ei>J0iSc>lVI.kBIIj> c֫[T*z=">v<
W6=~ܶ>
X dQ>[= 	ܣϾu@*5>R߽!R~bg> _?cD5Rj>
[YľB>
b2>ID7־ X>315=#")߾!`o>JҾH&[3> O\4;by-К0>:b'ݾ	>퀌>gD-վ EnV>(l.=ebվƒ>~O74 > ;u<:I.>ҕXA>xV">Y0Ɵ] 2_>Ì=瓭>	vEȲQ13"(> +,hKn$*?ib>y¾dž>ʼIN>1N ){^>6th=vjL7-> '|zexWO> )㢾l>T<t{}U> tm> +Zr*>=3ˌk>e۬EϒIAx> --,L)1J;yD%xK>#:t"N,;>а3>5i / z>)=/us#w{=ܨ>̈)5ӥo{>?:g> /7˾k>'c1=6/K=>[sV /RQ%U>6*8=[X`Y>YK3> *[G-%S`>>O|CD=FU>UzP@ ^>/>yzV2BC>НfMt֝> G.BǬf!>Л(ƻF3G=_ftpȍ>,QÔx>P{>
s8,A_+CH!>"ŕgF4@X>\{P8H
԰
o~o,>BmME򍠽ں,>[:bu־ҔD	tK>{#7f>;=?tʾ
>pN)"I/Q+#> Q]3;^aG{}>M4Y>*=G>29p]\ OH>Y#fD>qRPOiҘ>ӺuQo:co>k{Y:VQ$v>r"I=v>\d&s>
>
z9Z,>@#=
ȡI%>xw	^hV>#j1
*G\>R-Ow!>>orH wx>Š-~t=A`ugR>F*za_i3B6htF>+1	}ZpRc8~B>v. U=TML>[DkHm>~~>	R-þ꾡k3>
0 =LSǾmpMo>5c6`Ⱦ>&H5v擽Pa+T>Z>;>:>-Et]G9>ޏ=)"搦J1>W#h!4"> ܝsrp>n=N'Qr>Θqݾ
>	"^}Q>s=ZB@>57VV=[2\3#>dͰw(	>~O0[,cN[>0D䳂=_f>(q܆:>KD$>@"¾cP>lƬ7^\(^->gSVis,hE>J!6e2"Dt==y>ȱStq>~>PF|yۅ>%{:Lj`6)p3QL>Bwo*xm`,>8H,]-0@>`>w\">*ت̾3>57~=FV?-9>3{6Kþ5H@>z۸KzBdԀ>0|#Җ'>kӒSyL>ˡa9>)SLy? .>]?=$nɒ5%>4}@+8jĦ+>	$o897de
>,پRGJۇ>i(b >juLC>ߋscueX>N=]kn+tE4>,?f]}>szƏG՝ڞ%>{%&^nܽw?d>5|vd>st=<>OIE>^^v=١*̞*>%V|
6R>Mg*,վFaΣ	>ɩĞrm"?
'o>O	*:>[>{Ivg%>cm>杣@[{6>{!!7^o,N>l0X3
%׸+>!1Vҁ2`J_M>f}e=ZѶ=#>Dx<wf>fG>FKu g>i(+>E~ܾA1>fFt>hIxaJ<н0E>Ju@W*=({>uϓ*>
0#>M-iг:/>=av=9EھlE>2нب־*o>m=.l]X)>:XcCտ=`>EcԾ*ǁn>f*`>AoodYU{>$$?t=6@Z{B98d>%Yd;_&A:>b)+m
ak>TDQ˸B\M>S}_Ϲtg=7>+vXl.96Χ>A3^(>fOv(>Y1R!=߰"M]n=C9t>VHgcAa#>Zq8Ͼ%WN"a>sP呾n=⑉u>
𪱜
s>1]S>xwQT؋>_u=
ӵ%{~>r;ⲝCBʤƁw>|1b͆n1>+o0o+=(1[>aآf>=>kh4>vBPÛ@Ե>'~=j	,
o>~ĩBþo	I(>OFL7:
!uҔݽ9m>*aR=8>ϬZϐ>۞
>4ow<>w|Uk=䥾F࿾c>tʫ')yF>*Z}Ʌ:L}>Eھ8Gޚ>Q=b^Ɣ=ԁ2>IJoi9!K\b>>
?d&U!+e3> R(W}bGyM\l>"ݯK\m=4‡@>u8"f$e(>*p*-G=_6.
>"W!۾ǾH> {9 N>	
> Vݓq!UI>5u@ >"Inx2搽>?S"A>N>1F2ξ $,>!,'n^w@`@5{>!aם7NS=~(>-[e")'د1>{pok=v/n~W9/>"
CҷDsS.L>>ݾ!)̔ܫm>$vن[>`!d$LQFd>A~,>snX>"Q^7R'jVhE>wU!b)C>]"8>e2#E}> a:
؅͛;\*>!k?0Wr=4=>-8g"=w>lCqR=q"Ba">!6"B~	 > =:3< ',>ϱsC>s0f!W5Uc>Ns9ȭ|=@oԔ>!x0!j>u.!y{J^>
κ>cvє )sOM&> 
#u5>!	ƾw3l=ݎvt>:F\!!y>T0'Q=<>S3l> CWay9>!&A߾7?(x=>T5>~8=	!-->aqz=%Hn/>!z3Q
`e:> _Gg ZI<<>AU^>
Yd!h6>3`ԞȾߥ>!H~zEV>km )^S+>
le>yBn!!Zas%>Q"!x.!>!FY
f> о!*%G><>	]Ͼ 5=ս>3Kb$Mz>!Ŭx՟0:>hn=	v!fd4`>dP->ڣXl tyt> Hn9(u5>!e3
J%G}=s1>݇h߾!~O>9z>}l1eǦ> ]fЂ#70>!*46#B6=嘚=
>	e!5>~WS=n]ꪴ> վ
zx
b
ۚ> υ߾ַ0=fX&>-zW!9rB>PJTl=TFRm>/e> OA
ږf> Чƾ1;ю=?e%>斝!r)>m=e&rԾcg]f> pn
@> iHsē=$>ΥSO!f>p>äe"=5^`JF > 	@
!;ch> P[=?cd>!\:>l=!y1
h> 8y$I$y&ԟ|A> .؞G'A}=nm>{9YL:!M~>L=IP3!{> Z!Sj	E;YZς> jXd=л>P5+x!9*">=eo}j6> d9pO>> kH=S|F1>wuI!G[%>
/j>QjJEF4>H[5q!(ՙr0i(=~>!q|QHc6$Aiz> ^Q->	2\>6uy 
.>s(Tan>!"	q66.E>[# 	>
@u>V^F w9Hdl>j?j)G8w=>!("+J;si>Ւ Ii>PNs%]>S-C웾 _z/>|&ׂCƁy$ױl> ++jA.̤>:R>v;~qzqJ=,>*F3B!	U>wgX"=}'!<B> w(=¾
He@> Z
> ]uKh(=|\_>V*#D BG>͖Ҏ=·&7%Ⴓ>yAQciH
û,B> 1Es&[J&>vRǙRѾ pƮ>q>
k Wz>>`X;Ľ:(U> Zsvwg9_5>Lwc9dC>p>N *>*ADy:j.B> ɪAkUPs>ҧE|"=;p>_
,ET 㝄R[>j~a0=Ş
ת>a̳kȫ@<	1> -M[=fls_>ft S.E%i>`><	W>$Rk]11,B|z5> 8xҾ\ZPy >g-:ϾffO>Z>=C wcu>@ַE=ѐeSw>a> i]iQN	۲D> 
t*!E=_
Ei(> 4>>0sFES+>sP1R6t_c`\Of> /JUg~ 8y>(m{n 	wZ>
Q,s>y \~/>Y)~V5	&+.> 7cO?>vm
ź|x=#y># >>|'S3=%XЋR>y=_9྾~x`> S)a[+;!r>X_[>
RS>m4ľ KXsL> g`Tmd6H>p9Ia=4Dg	>bPľ r	
G>qp>&Azք<%iib> }FlnL>\ֿ*ހ>]o>PƜ"
 oJӈ{>_g4.=D51Z.dP~> 	|gI
b> !4ЦS
~=ёa>~}1d Ux\>si>
oMv>+Qz쒾GF> ~ժ|u˥tUk>qIn?=b\>IY )g>A$b=0z-RYL>W^)׾Rb־[p> xGb̾Ky-QCM;>:v5¾')#>oU> SOqZ>5M=-D~>-&\
lDT3x*> aXa+{m.[>Ͼ =6ô>
n>
ʪhľBm>'Gg!ݎ] B50nyp9SfF>=Àk=PFET>0-ľ YA(>Ei>J0iSc>lVI.kBIIj> c֫[T*z=">v<
W6=~ܶ>
X dQ>[= 	ܣϾu@*5>R߽!R~bg> _?cD5Rj>
[YľB>
b2>ID7־ X>315=#")߾!`o>JҾH&[3> O\4;by-К0>:b'ݾ	>퀌>gD-վ EnV>(l.=ebվƒ>~O74 > ;u<:I.>ҕXA>xV">Y0Ɵ] 2_>Ì=瓭>	vEȲQ13"(> +,hKn$*?ib>y¾dž>ʼIN>1N ){^>6th=vjL7-> '|zexWO> )㢾l>T<t{}U> tm> +Zr*>=3ˌk>e۬EϒIAx> --,L)1J;yD%xK>#:t"N,;>а3>5i / z>)=/us#w{=ܨ>̈)5ӥo{>?:g> /7˾k>'c1=6/K=>[sV /RQ%U>6*8=[X`Y>YK3> *[G-%S`>>O|CD=FU>UzP@ ^>/>yzV2BC>НfMt֝> G.BǬf!>Л(ƻF3G=_ftpȍ>,QÔx>P{>
s8,A_+CH!>"ŕgF4@X>\{P8H
԰
o~o,>BmME򍠽ں,>[:bu־ҔD	tK>{#7f>;=?tʾ
>pN)"I/Q+#> Q]3;^aG{}>M4Y>*=G>29p]\ OH>Y#fD>qRPOiҘ>ӺuQo:co>k{Y:VQ$v>r"I=v>\d&s>
>
z9Z,>@#=
ȡI%>xw	^hV>#j1
*G\>R-Ow!>>orH wx>Š-~t=A`ugR>F*za_i3B6htF>+1	}ZpRc8~B>v. U=TML>[DkHm>~~>	R-þ꾡k3>
0 =LSǾmpMo>5c6`Ⱦ>&H5v擽Pa+T>Z>;>:>-Et]G9>ޏ=)"搦J1>W#h!4"> ܝsrp>n=N'Qr>Θqݾ
>	"^}Q>s=ZB@>57VV=[2\3#>dͰw(	>~O0[,cN[>0D䳂=_f>(q܆:>KD$>@"¾cP>lƬ7^\(^->gSVis,hE>J!6e2"Dt==y>ȱStq>~>PF|yۅ>%{:Lj`6)p3QL>Bwo*xm`,>8H,]-0@>`>w\">*ت̾3>57~=FV?-9>3{6Kþ5H@>z۸KzBdԀ>0|#Җ'>kӒSyL>ˡa9>)SLy? .>]?=$nɒ5%>4}@+8jĦ+>	$o897de
>,پRGJۇ>i(b >juLC>ߋscueX>N=]kn+tE4>,?f]}>szƏG՝ڞ%>{%&^nܽw?d>5|vd>st=<>OIE>^^v=١*̞*>%V|
6R>Mg*,վFaΣ	>ɩĞrm"?
'o>O	*:>[>{Ivg%>cm>杣@[{6>{!!7^o,N>l0X3
%׸+>!1Vҁ2`J_M>f}e=ZѶ=#>Dx<wf>fG>FKu g>i(+>E~ܾA1>fFt>hIxaJ<н0E>Ju@W*=({>uϓ*>
0#>M-iг:/>=av=9EھlE>2нب־*o>m=.l]X)>:XcCտ=`>EcԾ*ǁn>f*`>AoodYU{>$$?t=6@Z{B98d>%Yd;_&A:>b)+m
ak>TDQ˸B\M>S}_Ϲtg=7>+vXl.96Χ>A3^(>fOv(>Y1R!=߰"M]n=C9t>VHgcAa#>Zq8Ͼ%WN"a>sP呾n=⑉u>
𪱜
s>1]S>xwQT؋>_u=
ӵ%{~>r;ⲝCBʤƁw>|1b͆n1>+o0o+=(1[>aآf>=>kh4>vBPÛ@Ե>'~=j	,
o>~ĩBþo	I(>OFL7:
!uҔݽ9m>*aR=8>ϬZϐ>۞
>4ow<>w|Uk=䥾F࿾c>tʫ')yF>*Z}Ʌ:L}>Eھ8Gޚ>Q=b^Ɣ=ԁ2>IJoi9!K\b>>
?d&U!+e3> R(W}bGyM\l>"ݯK\m=4‡@>u8"f$e(>*p*-G=_6.
>"W!۾ǾH> {9 N>	
> Vݓq!UI>5u@ >"Inx2搽>?S"A>N>1F2ξ $,>!,'n^w@`@5{>!aם7NS=~(>-[e")'د1>{pok=v/n~W9/>"
CҷDsS.L>>ݾ!)̔ܫm>$vن[>`!d$LQFd>A~,>snX>"Q^7R'jVhE>wU!b)C>]"8>e2#E}> a:
؅͛;\*>!k?0Wr=4=>-8g"=w>lCqR=q"Ba">!6"B~	 > =:3< ',>ϱsC>s0f!W5Uc>Ns9ȭ|=@oԔ>!x0!j>u.!y{J^>
κ>cvє )sOM&> 
#u5>!	ƾw3l=ݎvt>:F\!!y>T0'Q=<>S3l> CWay9>!&A߾7?(x=>T5>~8=	!-->aqz=%Hn/>!z3Q
`e:> _Gg ZI<<>AU^>
Yd!h6>3`ԞȾߥ>!H~zEV>km )^S+>
le>yBn!!Zas%>Q"!x.!>!FY
f> о!*%G><>	]Ͼ 5=ս>3Kb$Mz>!Ŭx՟0:>hn=	v!fd4`>dP->ڣXl tyt> Hn9(u5>!e3
J%G}=s1>݇h߾!~O>9z>}l1eǦ> ]fЂ#70>!*46#B6=嘚=
>	e!5>~WS=n]ꪴ> վ
zx
b
ۚ> υ߾ַ0=fX&>-zW!9rB>PJTl=TFRm>/e> OA
ږf> Чƾ1;ю=?e%>斝!r)>m=e&rԾcg]f> pn
@> iHsē=$>ΥSO!f>p>äe"=5^`JF > 	@
!;ch> P[=?cd>!\:>l=!y1
h> 8y$I$y&ԟ|A> .؞G'A}=nm>{9YL:!M~>L=IP3!{> Z!Sj	E;YZς> jXd=л>P5+x!9*">=eo}j6> d9pO>> kH=S|F1>wuI!G[%>
/j>QjJEF4>H[5q!(ՙr0i(=~>!q|QHc6$Aiz> ^Q->	2\>6uy 
.>s(Tan>!"	q66.E>[# 	>
@u>V^F w9Hdl>j?j)G8w=>!("+J;si>Ւ Ii>PNs%]>S-C웾 _z/>|&ׂCƁy$ױl> ++jA.̤>:R>v;~qzqJ=,>*F3B!	U>wgX"=}'!<B> w(=¾
He@> Z
> ]uKh(=|\_>V*#D BG>͖Ҏ=·&7%Ⴓ>yAQciH
û,B> 1Es&[J&>vRǙRѾ pƮ>q>
k Wz>>`X;Ľ:(U> Zsvwg9_5>Lwc9dC>p>N *>*ADy:j.B> ɪAkUPs>ҧE|"=;p>_
,ET 㝄R[>j~a0=Ş
ת>a̳kȫ@<	1> -M[=fls_>ft S.E%i>`><	W>$Rk]11,B|z5> 8xҾ\ZPy >g-:ϾffO>Z>=C wcu>@ַE=ѐeSw>a> i]iQN	۲D> 
t*!E=_
Ei(> 4>>0sFES+>sP1R6t_c`\Of> /JUg~ 8y>(m{n 	wZ>
Q,s>y \~/>Y)~V5	&+.> 7cO?>vm
ź|x=#y># >>|'S3=%XЋR>y=_9྾~x`> S)a[+;!r>X_[>
RS>m4ľ KXsL> g`Tmd6H>p9Ia=4Dg	>bPľ r	
G>qp>&Azք<%iib> }FlnL>\ֿ*ހ>]o>PƜ"
 oJӈ{>_g4.=D51Z.dP~> 	|gI
b> !4ЦS
~=ёa>~}1d Ux\>si>
oMv>+Qz쒾GF> ~ժ|u˥tUk>qIn?=b\>IY )g>A$b=0z-RYL>W^)׾Rb־[p> xGb̾Ky-QCM;>:v5¾')#>oU> SOqZ>5M=-D~>-&\
lDT3x*> aXa+{m.[>Ͼ =6ô>
n>
ʪhľBm>'Gg!ݎ] B50nyp9SfF>=Àk=PFET>0-ľ YA(>Ei>J0iSc>lVI.kBIIj> c֫[T*z=">v<
W6=~ܶ>
X dQ>[= 	ܣϾu@*5>R߽!R~bg> _?cD5Rj>
[YľB>
b2>ID7־ X>315=#")߾!`o>JҾH&[3> O\4;by-К0>:b'ݾ	>퀌>gD-վ EnV>(l.=ebվƒ>~O74 > ;u<:I.>ҕXA>xV">Y0Ɵ] 2_>Ì=瓭>	vEȲQ13"(> +,hKn$*?ib>y¾dž>ʼIN>1N ){^>6th=vjL7-> '|zexWO> )㢾l>T<t{}U> tm> +Zr*>=3ˌk>e۬EϒIAx> --,L)1J;yD%xK>#:t"N,;>а3>5i / z>)=/us#w{=ܨ>̈)5ӥo{>?:g> /7˾k>'c1=6/K=>[sV /RQ%U>6*8=[X`Y>YK3> *[G-%S`>>O|CD=FU>UzP@ ^>/>yzV2BC>НfMt֝> G.BǬf!>Л(ƻF3G=_ftpȍ>,QÔx>P{>
s8,A_+CH!>"ŕgF4@X>\{P8H
԰
o~o,>BmME򍠽ں,>[:bu־ҔD	tK>{#7f>;=?tʾ
>pN)"I/Q+#> Q]3;^aG{}>M4Y>*=G>29p]\ OH>Y#fD>qRPOiҘ>ӺuQo:co>k{Y:VQ$v>r"I=v>\d&s>
>
z9Z,>@#=
ȡI%>xw	^hV>#j1
*G\>R-Ow!>>orH wx>Š-~t=A`ugR>F*za_i3B6htF>+1	}ZpRc8~B>v. U=TML>[DkHm>~~>	R-þ꾡k3>
0 =LSǾmpMo>5c6`Ⱦ>&H5v擽Pa+T>Z>;>:>-Et]G9>ޏ=)"搦J1>W#h!4"> ܝsrp>n=N'Qr>Θqݾ
>	"^}Q>s=ZB@>57VV=[2\3#>dͰw(	>~O0[,cN[>0D䳂=_f>(q܆:>KD$>@"¾cP>lƬ7^\(^->gSVis,hE>J!6e2"Dt==y>ȱStq>~>PF|yۅ>%{:Lj`6)p3QL>Bwo*xm`,>8H,]-0@>`>w\">*ت̾3>57~=FV?-9>3{6Kþ5H@>z۸KzBdԀ>0|#Җ'>kӒSyL>ˡa9>)SLy? .>]?=$nɒ5%>4}@+8jĦ+>	$o897de
>,پRGJۇ>i(b >juLC>ߋscueX>N=]kn+tE4>,?f]}>szƏG՝ڞ%>{%&^nܽw?d>5|vd>st=<>OIE>^^v=١*̞*>%V|
6R>Mg*,վFaΣ	>ɩĞrm"?
'o>O	*:>[>{Ivg%>cm>杣@[{6>{!!7^o,N>l0X3
%׸+>!1Vҁ2`J_M>f}e=ZѶ=#>Dx<wf>fG>FKu g>i(+>E~ܾA1>fFt>hIxaJ<н0E>Ju@W*=({>uϓ*>
0#>M-iг:/>=av=9EھlE>2нب־*o>m=.l]X)>:XcCտ=`>EcԾ*ǁn>f*`>AoodYU{>$$?t=6@Z{B98d>%Yd;_&A:>b)+m
ak>TDQ˸B\M>S}_Ϲtg=7>+vXl.96Χ>A3^(>fOv(>Y1R!=߰"M]n=C9t>VHgcAa#>Zq8Ͼ%WN"a>sP呾n=⑉u>
𪱜
s>1]S>xwQT؋>_u=
ӵ%{~>r;ⲝCBʤƁw>|1b͆n1>+o0o+=(1[>aآf>=>kh4>vBPÛ@Ե>'~=j	,
o>~ĩBþo	I(>OFL7:
!uҔݽ9m>*aR=8>ϬZϐ>۞
>4ow<>w|Uk=䥾F࿾c>tʫ')yF>*Z}Ʌ:L}>Eھ8Gޚ>Q=b^Ɣ=ԁ2>ER.4>W#o>Wm9G&4>PZ]=|pTGo >2_Vxp3^ wDx>/7?57)ۯ<<>Ya%*t"
	*;30e2>x6>XwXȾ+,v=>ƍ>3/ӸG!z[>C=&Lc0׾.	FS>Bթݤfzk> n[(W.3>3[:?'U*C>lxbH=㞞z>,2ξ{B>7|2j>/$KȾVh>z8aI=4c >[-wt}9	p>[ۧj0	DŽ>9';(Ax>LWWw͝K==$x2>{:Xxw>[e>Y ̥a>Ԍ%=yDYD
>vqZebA>nT&
%a'B->A^e|K+>JVL=2[Di>#Ǿ+Yhl!>۪>$`h&>bٛм>KIm=E\6>1/jXԾ>FϾpyLr>oo	]+>'t4DJrdOΎz_#>)[qgg=nx#>B;^~PQ>^S2Cj>	[BH5ku>]6:=B>fW<}l>^)pq/<'>O
d`{ۣdֳ>>2Cr$->Pf=hm[>5,OU>_|)>5@LM6>loM>GQm >ʦ5=EQL+fk>a%KlG	c/F>gf%i{sσ~>XԌ
<=#G!:>c*`x=>	%Vg+>o,M}z>k<=e9l5C>_*%Qūiq>d	n5QNGI>]X]R4:H_>!@W."8fp.wRE>F~=K|ˡ>ouU4>
>G9&e>FQ&6>,?=~#Yߍ4>\	2+0>_Xܜ@1<>i~G6C~>%sT`8[Sq>@uT`
=JfO>jUK(RHҘ>>EC 4t\>pe-w>.00|dZe>p=پ2ua%(>%dҍ 7>0 =#
{K[i>t9a8>+F@BK=Qix>u!hΈ>ѯ%>TXP-(7P>űP}>11]#>|4L=综}3>՟3RLN@vc-&>P*2	8Zz=XӾ>ȾG	#\$>> )`>9h(]Ž\p>5䈾Q=9Rw,v>WANJp>m,j>aFn>μb9=k#=o'e>̨%^t Z%m>1;% otIj/(>U=	>Sx80ϒp(C>||7_4=o~U>svS%Y>brk>6Ǥ&D>߆O>_S>X*;>q<,=5<^nʹ:>Ċݰݽ3,y{p2>S4fXVCr>A5o8ܾ8+1]`k>
Ծc,o16	>hv]
l=mט.>9?\ ?,n>\Y.>`;Tu>IwW>H
,N>٬?=N`D&>a9(8hw?c>ɟV͠6X5MJ>Z6پb*>sط޾ڽDх7>>3/0u5=SHP>!r>^c>Au/0ؚ>*tG>6||&>d_hx=Geڱ>3(>ur[,5z>Y^(?0] _>a1}'Ecw	>K}ӾJLg>Tiʅ6=ٗ>Tb噆|=-q'A>daB>:;>U9:M>ď=)s\;آ>ֹ:=k70CmPQ&Kt?>;n)f	C Xй>mzQ>1{C O>)S&f)=o> þp1>Mb>{2J@>KJ>A `ľjF`>֛-`=)K:m}䛪>s,!ȷhg>igFWO>tĀ¾6p$
6Tb>7h]dJξ׶-w>rXHKRx>^]UWJ.=G7>cRR|v>I:S>bU6,/wڧ>2{>/7ƾ8>B=*W OF>
l$"ө܏н+gE_{>_$)+}x
(G>h՞/Z>NM.c>ͤ>sƾB*=2>"ԹC-UYm>בY>w]+IݾΣ>fq>

cx@Ҁ=^>ȅ}y3= E
;4>t=oiTEƾqE

>C^n/.Ɵ!x>	bV0&6~:f>5ѓ(5`>Y;{0 n7>>}EھB)=XJ>>}P]=h>q¶+e>	>0[A>P>`^[=ߜ'>qξ= Ag>4։ԶS!([u>B$/K&&><
xDտ	z8)(>!A{)Rm	:>l+43ɚ>͗G0-s!=֏F<>yZ3_X=.sA>u3,>	Ĩq̏>I^Ծ;X5>GQ_>.\#2ޫ&>^lW=|k*9h>\]\{.>է\Of@Ư>e릗y֪>z0>THaK@{@#|>)Vemuiɉ>2+zZS,yw;`t1>P<=K=5{ys>J	jp@>F{ļ>8.>>ⅰ>	id/w߾'1@$[j>y=Z_2D>eʹf;=\zgfN/>Wzk	F.Y*v>[#aSye )=T>b*رd1R
*fE>fё['|?J>k,4¾hU>{Dx6j=jJ">tYMo=GB>r;>q>`ټj>K>J)h>ƍE=ĆQ7>lZ=MޗhnO3Z,M5>HϾI gܫoD>PҜR^E\G>kvҾdE!%pU>K$M͘(~/D>H>bgH\= -2>k|Z<n=:>-2nc<^>kHFa>LQ־gB>]$`>4u_7K)7->'>K;>GuP((>ܲ =9hBӠ>+,c/M38>([H>HM.%"SX|h>QҬSD+Ӎ>jn&DvSpJ>:./~jis+q>8֎[|%b/>n*C=И-և>nA
C
@;=2>3Ows>oIm>>d	uBx>VYPQ>3oD~>4>;Z\׼8>U=<[O>>O	
-.t[yӪ>"bӨ`+R.>}P2Ͼ0|>M,)`T
)P>]kɴ3Z#94>H.ЌƟRd>Hj΋@Ԡ7`>5n:=L}>}̾~<]>Yg9>F'Au>!OqE>׹ElC+>|c>	VA
'>+OS>T'W	>_`==Wpr>lY ZAq	ްu>2ƽw5-5P1>!R ]U>Dg	ƾυ-2"Y>[q1>>cgYFݾ=@8s B>B[0$R hL%>4]\l8=xE5^>`;sw=Ê>~yRI>E8j?>-2dN">
7ce>
_K>CF>:>#Kl>/0̥=#fo7Ts>WB:4=LAac>ƑaQ;dᗬTwf9>nHi/
[,s>'26q[1Ƞ>CqGNҟ
νh>M>kWfs
ۭk>ë<hK6&3xy>lUBjሽx??=>k3])X֤=H>殸$	^?=5>SD
\Yow5<>q
!>ZL:A4Ƨc>
&+L>k}Y/i>(G>)T;Rf%ul>]>^Ժľ/->K\s=	cΌmR>(sh,_=4Y>*	[F@~5Ox>r:)Z*uA>A7IپxMӰ>D4
s!r_
8H>KQkfbyhn
>ҬX5ft[k>T0pj]['noD'>s-m|-xA7S=nP-y>0ivF=NV>\o;PJ=73y->V^W>KX$>`@[Eg>
!þl>
cX2٧GXQ>_>ģeC^%>E-g=/a9M>'6==f>Z>e=>Jb|f>,{+'%M@>Zeq-ɽސeKEJ>k0D
KZ3>)~
pNuRߘ>O:ǯd	"6>@㕾{j߽7XH>X͏Ay޴J21>CHQ!V9>ΣW>h=Ҝz7Y>/ΑK=r)>xv@VR18>2#>v@->@>o'>Z/^Ҿ9bLG>+>
B.[ǾAO|>FP_8>X`k$;@R>Ud>cqt0 >Y/t3Q=]S[j*(>wiG='Oɾ^iI.>FצQt-=	~;
f'p9}>f׽v1lrXS>5^xFck4K>(s#ԾrR4H9T>C6¾	4d@	Q~D>rO7.\+lv>r#UYɾ>po%l>6yhĺhIjY>Wwlk|Ћ%`>eо
"ʚu=PND,>xx07KQ3={u>Y>\
T>U
u>5.>6x.1>UOE>ob]5hX
E>
	YG1>>
z1p:T[>>>Gh೾x>0t>،V]1ul>F=">--{==pm]46$>h&=
bm*Z[&ȏ>SūDڰX؂b>,t7<'3zw3>sEԾHDn+vy->@;?GZ>o@)KwND@tB
úC#>LT!>Ug^|^ژ
ƾF)>
,U]t {^)j>'ݾ7F~LX!b>x
ѯ3:=ㄼ>"ƾIq=/TD(>!t2"=>׭]>fe6m>H>~P5h>a.>t=#HbI>
GD?>GE ݾxKnv>Û)QԽ>魋>;.B
־,>ȳ`>VOSFVb\>#=T4'=l[sJ>ޒQ=٣]1Ԛ"S>9qA?b)DC>b'ww&HOd7>X߰xdžN);mi>a(<`ge`>ER.4>W#o>Wm9G&4>PZ]=|pTGo >2_Vxp3^ wDx>/7?57)ۯ<<>Ya%*t"
	*;30e2>x6>XwXȾ+,v=>ƍ>3/ӸG!z[>C=&Lc0׾.	FS>Bթݤfzk> n[(W.3>3[:?'U*C>lxbH=㞞z>,2ξ{B>7|2j>/$KȾVh>z8aI=4c >[-wt}9	p>[ۧj0	DŽ>9';(Ax>LWWw͝K==$x2>{:Xxw>[e>Y ̥a>Ԍ%=yDYD
>vqZebA>nT&
%a'B->A^e|K+>JVL=2[Di>#Ǿ+Yhl!>۪>$`h&>bٛм>KIm=E\6>1/jXԾ>FϾpyLr>oo	]+>'t4DJrdOΎz_#>)[qgg=nx#>B;^~PQ>^S2Cj>	[BH5ku>]6:=B>fW<}l>^)pq/<'>O
d`{ۣdֳ>>2Cr$->Pf=hm[>5,OU>_|)>5@LM6>loM>GQm >ʦ5=EQL+fk>a%KlG	c/F>gf%i{sσ~>XԌ
<=#G!:>c*`x=>	%Vg+>o,M}z>k<=e9l5C>_*%Qūiq>d	n5QNGI>]X]R4:H_>!@W."8fp.wRE>F~=K|ˡ>ouU4>
>G9&e>FQ&6>,?=~#Yߍ4>\	2+0>_Xܜ@1<>i~G6C~>%sT`8[Sq>@uT`
=JfO>jUK(RHҘ>>EC 4t\>pe-w>.00|dZe>p=پ2ua%(>%dҍ 7>0 =#
{K[i>t9a8>+F@BK=Qix>u!hΈ>ѯ%>TXP-(7P>űP}>11]#>|4L=综}3>՟3RLN@vc-&>P*2	8Zz=XӾ>ȾG	#\$>> )`>9h(]Ž\p>5䈾Q=9Rw,v>WANJp>m,j>aFn>μb9=k#=o'e>̨%^t Z%m>1;% otIj/(>U=	>Sx80ϒp(C>||7_4=o~U>svS%Y>brk>6Ǥ&D>߆O>_S>X*;>q<,=5<^nʹ:>Ċݰݽ3,y{p2>S4fXVCr>A5o8ܾ8+1]`k>
Ծc,o16	>hv]
l=mט.>9?\ ?,n>\Y.>`;Tu>IwW>H
,N>٬?=N`D&>a9(8hw?c>ɟV͠6X5MJ>Z6پb*>sط޾ڽDх7>>3/0u5=SHP>!r>^c>Au/0ؚ>*tG>6||&>d_hx=Geڱ>3(>ur[,5z>Y^(?0] _>a1}'Ecw	>K}ӾJLg>Tiʅ6=ٗ>Tb噆|=-q'A>daB>:;>U9:M>ď=)s\;آ>ֹ:=k70CmPQ&Kt?>;n)f	C Xй>mzQ>1{C O>)S&f)=o> þp1>Mb>{2J@>KJ>A `ľjF`>֛-`=)K:m}䛪>s,!ȷhg>igFWO>tĀ¾6p$
6Tb>7h]dJξ׶-w>rXHKRx>^]UWJ.=G7>cRR|v>I:S>bU6,/wڧ>2{>/7ƾ8>B=*W OF>
l$"ө܏н+gE_{>_$)+}x
(G>h՞/Z>NM.c>ͤ>sƾB*=2>"ԹC-UYm>בY>w]+IݾΣ>fq>

cx@Ҁ=^>ȅ}y3= E
;4>t=oiTEƾqE

>C^n/.Ɵ!x>	bV0&6~:f>5ѓ(5`>Y;{0 n7>>}EھB)=XJ>>}P]=h>q¶+e>	>0[A>P>`^[=ߜ'>qξ= Ag>4։ԶS!([u>B$/K&&><
xDտ	z8)(>!A{)Rm	:>l+43ɚ>͗G0-s!=֏F<>yZ3_X=.sA>u3,>	Ĩq̏>I^Ծ;X5>GQ_>.\#2ޫ&>^lW=|k*9h>\]\{.>է\Of@Ư>e릗y֪>z0>THaK@{@#|>)Vemuiɉ>2+zZS,yw;`t1>P<=K=5{ys>J	jp@>F{ļ>8.>>ⅰ>	id/w߾'1@$[j>y=Z_2D>eʹf;=\zgfN/>Wzk	F.Y*v>[#aSye )=T>b*رd1R
*fE>fё['|?J>k,4¾hU>{Dx6j=jJ">tYMo=GB>r;>q>`ټj>K>J)h>ƍE=ĆQ7>lZ=MޗhnO3Z,M5>HϾI gܫoD>PҜR^E\G>kvҾdE!%pU>K$M͘(~/D>H>bgH\= -2>k|Z<n=:>-2nc<^>kHFa>LQ־gB>]$`>4u_7K)7->'>K;>GuP((>ܲ =9hBӠ>+,c/M38>([H>HM.%"SX|h>QҬSD+Ӎ>jn&DvSpJ>:./~jis+q>8֎[|%b/>n*C=И-և>nA
C
@;=2>3Ows>oIm>>d	uBx>VYPQ>3oD~>4>;Z\׼8>U=<[O>>O	
-.t[yӪ>"bӨ`+R.>}P2Ͼ0|>M,)`T
)P>]kɴ3Z#94>H.ЌƟRd>Hj΋@Ԡ7`>5n:=L}>}̾~<]>Yg9>F'Au>!OqE>׹ElC+>|c>	VA
'>+OS>T'W	>_`==Wpr>lY ZAq	ްu>2ƽw5-5P1>!R ]U>Dg	ƾυ-2"Y>[q1>>cgYFݾ=@8s B>B[0$R hL%>4]\l8=xE5^>`;sw=Ê>~yRI>E8j?>-2dN">
7ce>
_K>CF>:>#Kl>/0̥=#fo7Ts>WB:4=LAac>ƑaQ;dᗬTwf9>nHi/
[,s>'26q[1Ƞ>CqGNҟ
νh>M>kWfs
ۭk>ë<hK6&3xy>lUBjሽx??=>k3])X֤=H>殸$	^?=5>SD
\Yow5<>q
!>ZL:A4Ƨc>
&+L>k}Y/i>(G>)T;Rf%ul>]>^Ժľ/->K\s=	cΌmR>(sh,_=4Y>*	[F@~5Ox>r:)Z*uA>A7IپxMӰ>D4
s!r_
8H>KQkfbyhn
>ҬX5ft[k>T0pj]['noD'>s-m|-xA7S=nP-y>0ivF=NV>\o;PJ=73y->V^W>KX$>`@[Eg>
!þl>
cX2٧GXQ>_>ģeC^%>E-g=/a9M>'6==f>Z>e=>Jb|f>,{+'%M@>Zeq-ɽސeKEJ>k0D
KZ3>)~
pNuRߘ>O:ǯd	"6>@㕾{j߽7XH>X͏Ay޴J21>CHQ!V9>ΣW>h=Ҝz7Y>/ΑK=r)>xv@VR18>2#>v@->@>o'>Z/^Ҿ9bLG>+>
B.[ǾAO|>FP_8>X`k$;@R>Ud>cqt0 >Y/t3Q=]S[j*(>wiG='Oɾ^iI.>FצQt-=	~;
f'p9}>f׽v1lrXS>5^xFck4K>(s#ԾrR4H9T>C6¾	4d@	Q~D>rO7.\+lv>r#UYɾ>po%l>6yhĺhIjY>Wwlk|Ћ%`>eо
"ʚu=PND,>xx07KQ3={u>Y>\
T>U
u>5.>6x.1>UOE>ob]5hX
E>
	YG1>>
z1p:T[>>>Gh೾x>0t>،V]1ul>F=">--{==pm]46$>h&=
bm*Z[&ȏ>SūDڰX؂b>,t7<'3zw3>sEԾHDn+vy->@;?GZ>o@)KwND@tB
úC#>LT!>Ug^|^ژ
ƾF)>
,U]t {^)j>'ݾ7F~LX!b>x
ѯ3:=ㄼ>"ƾIq=/TD(>!t2"=>׭]>fe6m>H>~P5h>a.>t=#HbI>
GD?>GE ݾxKnv>Û)QԽ>魋>;.B
־,>ȳ`>VOSFVb\>#=T4'=l[sJ>ޒQ=٣]1Ԛ"S>9qA?b)DC>b'ww&HOd7>X߰xdžN);mi>a(<`ge`>ER.4>W#o>Wm9G&4>PZ]=|pTGo >2_Vxp3^ wDx>/7?57)ۯ<<>Ya%*t"
	*;30e2>x6>XwXȾ+,v=>ƍ>3/ӸG!z[>C=&Lc0׾.	FS>Bթݤfzk> n[(W.3>3[:?'U*C>lxbH=㞞z>,2ξ{B>7|2j>/$KȾVh>z8aI=4c >[-wt}9	p>[ۧj0	DŽ>9';(Ax>LWWw͝K==$x2>{:Xxw>[e>Y ̥a>Ԍ%=yDYD
>vqZebA>nT&
%a'B->A^e|K+>JVL=2[Di>#Ǿ+Yhl!>۪>$`h&>bٛм>KIm=E\6>1/jXԾ>FϾpyLr>oo	]+>'t4DJrdOΎz_#>)[qgg=nx#>B;^~PQ>^S2Cj>	[BH5ku>]6:=B>fW<}l>^)pq/<'>O
d`{ۣdֳ>>2Cr$->Pf=hm[>5,OU>_|)>5@LM6>loM>GQm >ʦ5=EQL+fk>a%KlG	c/F>gf%i{sσ~>XԌ
<=#G!:>c*`x=>	%Vg+>o,M}z>k<=e9l5C>_*%Qūiq>d	n5QNGI>]X]R4:H_>!@W."8fp.wRE>F~=K|ˡ>ouU4>
>G9&e>FQ&6>,?=~#Yߍ4>\	2+0>_Xܜ@1<>i~G6C~>%sT`8[Sq>@uT`
=JfO>jUK(RHҘ>>EC 4t\>pe-w>.00|dZe>p=پ2ua%(>%dҍ 7>0 =#
{K[i>t9a8>+F@BK=Qix>u!hΈ>ѯ%>TXP-(7P>űP}>11]#>|4L=综}3>՟3RLN@vc-&>P*2	8Zz=XӾ>ȾG	#\$>> )`>9h(]Ž\p>5䈾Q=9Rw,v>WANJp>m,j>aFn>μb9=k#=o'e>̨%^t Z%m>1;% otIj/(>U=	>Sx80ϒp(C>||7_4=o~U>svS%Y>brk>6Ǥ&D>߆O>_S>X*;>q<,=5<^nʹ:>Ċݰݽ3,y{p2>S4fXVCr>A5o8ܾ8+1]`k>
Ծc,o16	>hv]
l=mט.>9?\ ?,n>\Y.>`;Tu>IwW>H
,N>٬?=N`D&>a9(8hw?c>ɟV͠6X5MJ>Z6پb*>sط޾ڽDх7>>3/0u5=SHP>!r>^c>Au/0ؚ>*tG>6||&>d_hx=Geڱ>3(>ur[,5z>Y^(?0] _>a1}'Ecw	>K}ӾJLg>Tiʅ6=ٗ>Tb噆|=-q'A>daB>:;>U9:M>ď=)s\;آ>ֹ:=k70CmPQ&Kt?>;n)f	C Xй>mzQ>1{C O>)S&f)=o> þp1>Mb>{2J@>KJ>A `ľjF`>֛-`=)K:m}䛪>s,!ȷhg>igFWO>tĀ¾6p$
6Tb>7h]dJξ׶-w>rXHKRx>^]UWJ.=G7>cRR|v>I:S>bU6,/wڧ>2{>/7ƾ8>B=*W OF>
l$"ө܏н+gE_{>_$)+}x
(G>h՞/Z>NM.c>ͤ>sƾB*=2>"ԹC-UYm>בY>w]+IݾΣ>fq>

cx@Ҁ=^>ȅ}y3= E
;4>t=oiTEƾqE

>C^n/.Ɵ!x>	bV0&6~:f>5ѓ(5`>Y;{0 n7>>}EھB)=XJ>>}P]=h>q¶+e>	>0[A>P>`^[=ߜ'>qξ= Ag>4։ԶS!([u>B$/K&&><
xDտ	z8)(>!A{)Rm	:>l+43ɚ>͗G0-s!=֏F<>yZ3_X=.sA>u3,>	Ĩq̏>I^Ծ;X5>GQ_>.\#2ޫ&>^lW=|k*9h>\]\{.>է\Of@Ư>e릗y֪>z0>THaK@{@#|>)Vemuiɉ>2+zZS,yw;`t1>P<=K=5{ys>J	jp@>F{ļ>8.>>ⅰ>	id/w߾'1@$[j>y=Z_2D>eʹf;=\zgfN/>Wzk	F.Y*v>[#aSye )=T>b*رd1R
*fE>fё['|?J>k,4¾hU>{Dx6j=jJ">tYMo=GB>r;>q>`ټj>K>J)h>ƍE=ĆQ7>lZ=MޗhnO3Z,M5>HϾI gܫoD>PҜR^E\G>kvҾdE!%pU>K$M͘(~/D>H>bgH\= -2>k|Z<n=:>-2nc<^>kHFa>LQ־gB>]$`>4u_7K)7->'>K;>GuP((>ܲ =9hBӠ>+,c/M38>([H>HM.%"SX|h>QҬSD+Ӎ>jn&DvSpJ>:./~jis+q>8֎[|%b/>n*C=И-և>nA
C
@;=2>3Ows>oIm>>d	uBx>VYPQ>3oD~>4>;Z\׼8>U=<[O>>O	
-.t[yӪ>"bӨ`+R.>}P2Ͼ0|>M,)`T
)P>]kɴ3Z#94>H.ЌƟRd>Hj΋@Ԡ7`>5n:=L}>}̾~<]>Yg9>F'Au>!OqE>׹ElC+>|c>	VA
'>+OS>T'W	>_`==Wpr>lY ZAq	ްu>2ƽw5-5P1>!R ]U>Dg	ƾυ-2"Y>[q1>>cgYFݾ=@8s B>B[0$R hL%>4]\l8=xE5^>`;sw=Ê>~yRI>E8j?>-2dN">
7ce>
_K>CF>:>#Kl>/0̥=#fo7Ts>WB:4=LAac>ƑaQ;dᗬTwf9>nHi/
[,s>'26q[1Ƞ>CqGNҟ
νh>M>kWfs
ۭk>ë<hK6&3xy>lUBjሽx??=>k3])X֤=H>殸$	^?=5>SD
\Yow5<>q
!>ZL:A4Ƨc>
&+L>k}Y/i>(G>)T;Rf%ul>]>^Ժľ/->K\s=	cΌmR>(sh,_=4Y>*	[F@~5Ox>r:)Z*uA>A7IپxMӰ>D4
s!r_
8H>KQkfbyhn
>ҬX5ft[k>T0pj]['noD'>s-m|-xA7S=nP-y>0ivF=NV>\o;PJ=73y->V^W>KX$>`@[Eg>
!þl>
cX2٧GXQ>_>ģeC^%>E-g=/a9M>'6==f>Z>e=>Jb|f>,{+'%M@>Zeq-ɽސeKEJ>k0D
KZ3>)~
pNuRߘ>O:ǯd	"6>@㕾{j߽7XH>X͏Ay޴J21>CHQ!V9>ΣW>h=Ҝz7Y>/ΑK=r)>xv@VR18>2#>v@->@>o'>Z/^Ҿ9bLG>+>
B.[ǾAO|>FP_8>X`k$;@R>Ud>cqt0 >Y/t3Q=]S[j*(>wiG='Oɾ^iI.>FצQt-=	~;
f'p9}>f׽v1lrXS>5^xFck4K>(s#ԾrR4H9T>C6¾	4d@	Q~D>rO7.\+lv>r#UYɾ>po%l>6yhĺhIjY>Wwlk|Ћ%`>eо
"ʚu=PND,>xx07KQ3={u>Y>\
T>U
u>5.>6x.1>UOE>ob]5hX
E>
	YG1>>
z1p:T[>>>Gh೾x>0t>،V]1ul>F=">--{==pm]46$>h&=
bm*Z[&ȏ>SūDڰX؂b>,t7<'3zw3>sEԾHDn+vy->@;?GZ>o@)KwND@tB
úC#>LT!>Ug^|^ژ
ƾF)>
,U]t {^)j>'ݾ7F~LX!b>x
ѯ3:=ㄼ>"ƾIq=/TD(>!t2"=>׭]>fe6m>H>~P5h>a.>t=#HbI>
GD?>GE ݾxKnv>Û)QԽ>魋>;.B
־,>ȳ`>VOSFVb\>#=T4'=l[sJ>ޒQ=٣]1Ԛ"S>9qA?b)DC>b'ww&HOd7>X߰xdžN);mi>a(<`ge`>rnUPm*/>
	a	Ǭ^GhP{>4ys-/BE>,+zAf\!>R!(+L€>gIc|F>^$p̄hѬ>6vG0;>R#f>K<4LGr>9vHuD1=;ѹ>0y|Cw=LuZD>qYǟO=';k>2na
ٗ>)k+6\w>hW>8g>NAA>+BQޯ$Y,>sS$Ӛ>&W/LU>K*$>
Խk۸n>Hl8,>+
Ӿ5R]>8>-~e1\>!'49=]O*	Eإ,K>;˜=rZܾ(.>郺V=ecXTn>?=ˮ%hCg>27P}䍾[g5i>%OۯBaX3L~>FWgmzFj>Ol+ڽ-r~>6~t˾jj-9yk>֬L"XRw$Q>q16[_( Z>2M2>\>)-#-eY3>x&WI	$C:M>t_|K+{ue>$X̺AsKEc`9>1ғBRCpxQ>*d'ҽLحxS>ɾ`sbWOC>[.0yf!ꞯl>_|r閠=#	W>&3Ǵ=FJ>Nhb^Ո=)>~^ 53AA=0>rW~i=hw>nSx9Y>ttPa;>78JVU*?>(>E20
OR>V3M>zՌ<	>
˘ds>L
i0":>
7 ,n>
ׁUm#.>"et>:3[l>s?ml>+>R\kn>>Frw?>E؃>[cD~W"4>z==0tsט>'M.Y="MR9p>on[d=#&">sh=t
fKcN
>H<=ݛ zc©!>l>`#]=l2c-r>^ӼN~Y]~MR2E>9LsQnxbя>s9{؄F>$
t}ivnj?m.>>/Z+L3vck>T)3jdƾ>0Im_­6>ѶJB۾8<>S3	q?Y/>r4(9۾ɋ>>> K2
?L
r9B>gRrc~]>%#E	QoB3>l/l "NJ/v>tb\\:>T~}SIU>fZ2"^f>!!= zQ">Oik׾?jeeoҿ>{,xr;".#>ؾ~2Pl3>ZzMtI>Ex%,_<69>O
y$	s>TaE /=s>-~Ό=żcX>LuO'D=:~d>AQ^_k=PL0>1&c[i9=;=td>r"`ULk=s
9p>@@ꬾkߓ	=c>n]@+ʋ=>7GJ/=lJzM>5N!(:04+'>F >Nb&d>"l>Yn&mg>$.5$>Sl	t5K
>$>3v,>-ER>¾Uw>WRU>lG!pU>
Ӊ>9þ
H@>cs^>(ؠRj>V>)m]E$D>
7>
>[Iꇑ>1cQ>4 "sS>/>\U'c>=>
&!lc>L>QZR׉>|iEs>KE>TDw>bоǀ>гY>|Ƃ?cnn>G<΂>^a0>pR
>Fjw=#>&rO_>3fs\YlaW>38	>&\'9Dp{>A'|> AIhQžY>QO.4=@ξ!}?H>z6=Mey$G$7>G>G=hF4vZ>TdgV=J~C3u~>BY=?amK>L1=.i;O>3#=`"rU>u,?*=ޜb>t.=4([
ŏ>bѐ.=gBGݾd>((=1!NҾMp9>]f&=Dܢ[b>؟=Ȁ!8jB>Nn=☕T+>	=1\GԾX}$>!P=Ѳ־>;>:j9=RV4>^5M=l:9BF
>i-=+%fzj|>0 >=l_`6>
J/b=J~M+El63>ԉN\&=&]-|2>I-/=gH:!Nk>ܘ\G=Kͤ:2*>J"h2>&/j6Ͼߣ(>5dVn6Цe>C2XÅtHy>NmR"3¾Oț?>W]mE%aFs>_}SJb#%#H>e9;]3SF_L>h$B[A&Ju־?'9>jܕJɪY$
бŀ>jךɗOSܑ>iH1[D
膾>_>e׽jUaYlV>`T
KcHƀZD%C>Y!J|PĂ>136HO>PY)aզ>EzP5+nմ<>8!Ԛ_z3onq\ϭ>);I/ΐ+g0늪mm>g:sEmO>0=k\X>iy7=X&f>ٚ'=y)z=}>`oj=ɯ9V6Nc>A=ɄpB&>Y~=]B3~>fr=2qԍԾ'@@X>Dtn=DpM.Q->nc4=ܑƇz:U>y=.,>n:n=ك(g
E>`>=o|(Jƭ>prmdj=QFm䮶>=9=*Bizd>zz=휲!}k1&s>#+=G4 ٥g>~a]=rӾ<>S
W~=ea"W>
82H=AGgK>ɢ{y=mSl $(>n=w9[xk;k[>1)=Bb~L>o4=|ց7>oҭ=Z^Xt(x>07w=B!>DZ>w	SFA8Ƿ5~>pD>-`V܉I>
!>@
ɾs=S!>>A]hq}ԓ>0J	>'0`Ct9>N>@/O*.>C>]~pM'ϞrN>mc>>g(1`$G>C?~T>	m3Ҿr;>/>
"7*>/ѿ>@ܾDC>
*<ٱ^C>Fl 2>\8/ >ן&TI>Xz!f>~S>c0ľjy>
Hѽ>lJyj>Đ0Z>EN/Ӿ7s4>>6&L{QdCl>#$u>v+/=`>2\j>m`=wGz>,@c>N)} I>n$>J}ja>
߀M)v>9;{aH&I=-7>Ϧq=$V>dgSe˚ʾ=0>	Ʉ? =8\}>R hƔo4=,dxi>{'k@(I=ؔ>"8O4`1='ϲe{>,lQKf=-x>E7#*e=uk>>1npV>*.p!)J>	>gp3֘>m.ZeEI>+&:g
&̛>/٪(t )BUW]>:>پg;^>Q{:~(>ֿD;:>b->XU&s	G>M=#@
>adnDg)L>ظlyOƾ
6gǰ>b*j;@OG>y/^$ؾFHe>
}T`@"qSH>	dZ
9aokGh>N˨V?>Ps&ɾoݟ>q|or|;u>CLT-d~,*>Dz.y?$>UUgσ6p>5Q>9)	nM>h\BE7Ȱ^>:ʼHn^þ>|}>+O^">_d=v>U#B>Tr=ڙPvvN>e8="17u>ڹ=8ɾ'->1	=_c~>k=kIX̾
_>ȶ>)=^i|>e`M>ok1OX>ʴ>V'
X>IА>	9xFL>]>V
	掦h>rI>8c׾2"Y>I>av=y>	Hn- l>>Y>9ƕGy_>M=>4r7j>a|>[3}mե=k+W>/zHМ^p)=Hѝ>5;!=uCp5>-y3E1!=gD.>F2{Z=I`Eh>cz|D{>䙧,ЁOgԞ_
>geZ۟=Ǧv>)U9"s4šb>P+aH{](h>l`V_]>f!C^ľ?LJ*R>Tvd׾Ms,>NDz(Ⱦ`ڜ@{ry{z>Sf߾c\?0>R2
ZNO?>ۍ߾yc+Rxh9>YHpkЅc\/d>DYr:!>ҽM־@50x>KoCy4b'ela8.K>ep|>›ƒw>˛t֥+q쾠>J=,r?>wh=V&&ORD!>#=?i.ZTZ>ybe=pI^AփN>Tw<=s,\0>*ww>bJߧ">!P>:+65'>(&)>
re"u
JZ>
f=v>
j㝾qD>v,>uӛ-RyB>GX>?ųLcm2>MM70>>=6Ti.hF=aiA>|q{=k5>:M(=>}T/e=Ap,֦>O־]Kwdg-e>ЪN4;Mx|>9վW'K߀>s5Qt9+^
,!t~Y>"9(Ș̾pد8>:M`N>UP܏U]>I3U*=j>Bh
ks>fK~Ǿ	˾rp>uN{آ<<}zt>W6:7X(>P;vF 2`>(*K35+N>TN%9o>Y#9Y!pe8]7p%|>6SXȴ=8ǧw:Sz>l.ܒ=dצؾ,>J=Q7ڴ|)+>>x8ھTض>6Ͼ
;o>j"_I>
{YugFvV>J1>6<觃32>
vmueL>-[@K2t>8&|>Nee>6>95ܠs=P,@l>XŘS%:2=!y_0>`y??
="\=>8Y
F+x뽱9SQU>n؅;ikLx39>z*
u+{If]k:m>X
="
oHE>P-lgv:.C>Z掑MKu7squ>+yT"HfcR>!ubJkj
־t>X	[`	{xO>{"tq*GlgcDmu>iT*Ap9V(r.>6d8tzU(>Dj=\B=m ԰þ\J>rnUPm*/>
	a	Ǭ^GhP{>4ys-/BE>,+zAf\!>R!(+L€>gIc|F>^$p̄hѬ>6vG0;>R#f>K<4LGr>9vHuD1=;ѹ>0y|Cw=LuZD>qYǟO=';k>2na
ٗ>)k+6\w>hW>8g>NAA>+BQޯ$Y,>sS$Ӛ>&W/LU>K*$>
Խk۸n>Hl8,>+
Ӿ5R]>8>-~e1\>!'49=]O*	Eإ,K>;˜=rZܾ(.>郺V=ecXTn>?=ˮ%hCg>27P}䍾[g5i>%OۯBaX3L~>FWgmzFj>Ol+ڽ-r~>6~t˾jj-9yk>֬L"XRw$Q>q16[_( Z>2M2>\>)-#-eY3>x&WI	$C:M>t_|K+{ue>$X̺AsKEc`9>1ғBRCpxQ>*d'ҽLحxS>ɾ`sbWOC>[.0yf!ꞯl>_|r閠=#	W>&3Ǵ=FJ>Nhb^Ո=)>~^ 53AA=0>rW~i=hw>nSx9Y>ttPa;>78JVU*?>(>E20
OR>V3M>zՌ<	>
˘ds>L
i0":>
7 ,n>
ׁUm#.>"et>:3[l>s?ml>+>R\kn>>Frw?>E؃>[cD~W"4>z==0tsט>'M.Y="MR9p>on[d=#&">sh=t
fKcN
>H<=ݛ zc©!>l>`#]=l2c-r>^ӼN~Y]~MR2E>9LsQnxbя>s9{؄F>$
t}ivnj?m.>>/Z+L3vck>T)3jdƾ>0Im_­6>ѶJB۾8<>S3	q?Y/>r4(9۾ɋ>>> K2
?L
r9B>gRrc~]>%#E	QoB3>l/l "NJ/v>tb\\:>T~}SIU>fZ2"^f>!!= zQ">Oik׾?jeeoҿ>{,xr;".#>ؾ~2Pl3>ZzMtI>Ex%,_<69>O
y$	s>TaE /=s>-~Ό=żcX>LuO'D=:~d>AQ^_k=PL0>1&c[i9=;=td>r"`ULk=s
9p>@@ꬾkߓ	=c>n]@+ʋ=>7GJ/=lJzM>5N!(:04+'>F >Nb&d>"l>Yn&mg>$.5$>Sl	t5K
>$>3v,>-ER>¾Uw>WRU>lG!pU>
Ӊ>9þ
H@>cs^>(ؠRj>V>)m]E$D>
7>
>[Iꇑ>1cQ>4 "sS>/>\U'c>=>
&!lc>L>QZR׉>|iEs>KE>TDw>bоǀ>гY>|Ƃ?cnn>G<΂>^a0>pR
>Fjw=#>&rO_>3fs\YlaW>38	>&\'9Dp{>A'|> AIhQžY>QO.4=@ξ!}?H>z6=Mey$G$7>G>G=hF4vZ>TdgV=J~C3u~>BY=?amK>L1=.i;O>3#=`"rU>u,?*=ޜb>t.=4([
ŏ>bѐ.=gBGݾd>((=1!NҾMp9>]f&=Dܢ[b>؟=Ȁ!8jB>Nn=☕T+>	=1\GԾX}$>!P=Ѳ־>;>:j9=RV4>^5M=l:9BF
>i-=+%fzj|>0 >=l_`6>
J/b=J~M+El63>ԉN\&=&]-|2>I-/=gH:!Nk>ܘ\G=Kͤ:2*>J"h2>&/j6Ͼߣ(>5dVn6Цe>C2XÅtHy>NmR"3¾Oț?>W]mE%aFs>_}SJb#%#H>e9;]3SF_L>h$B[A&Ju־?'9>jܕJɪY$
бŀ>jךɗOSܑ>iH1[D
膾>_>e׽jUaYlV>`T
KcHƀZD%C>Y!J|PĂ>136HO>PY)aզ>EzP5+nմ<>8!Ԛ_z3onq\ϭ>);I/ΐ+g0늪mm>g:sEmO>0=k\X>iy7=X&f>ٚ'=y)z=}>`oj=ɯ9V6Nc>A=ɄpB&>Y~=]B3~>fr=2qԍԾ'@@X>Dtn=DpM.Q->nc4=ܑƇz:U>y=.,>n:n=ك(g
E>`>=o|(Jƭ>prmdj=QFm䮶>=9=*Bizd>zz=휲!}k1&s>#+=G4 ٥g>~a]=rӾ<>S
W~=ea"W>
82H=AGgK>ɢ{y=mSl $(>n=w9[xk;k[>1)=Bb~L>o4=|ց7>oҭ=Z^Xt(x>07w=B!>DZ>w	SFA8Ƿ5~>pD>-`V܉I>
!>@
ɾs=S!>>A]hq}ԓ>0J	>'0`Ct9>N>@/O*.>C>]~pM'ϞrN>mc>>g(1`$G>C?~T>	m3Ҿr;>/>
"7*>/ѿ>@ܾDC>
*<ٱ^C>Fl 2>\8/ >ן&TI>Xz!f>~S>c0ľjy>
Hѽ>lJyj>Đ0Z>EN/Ӿ7s4>>6&L{QdCl>#$u>v+/=`>2\j>m`=wGz>,@c>N)} I>n$>J}ja>
߀M)v>9;{aH&I=-7>Ϧq=$V>dgSe˚ʾ=0>	Ʉ? =8\}>R hƔo4=,dxi>{'k@(I=ؔ>"8O4`1='ϲe{>,lQKf=-x>E7#*e=uk>>1npV>*.p!)J>	>gp3֘>m.ZeEI>+&:g
&̛>/٪(t )BUW]>:>پg;^>Q{:~(>ֿD;:>b->XU&s	G>M=#@
>adnDg)L>ظlyOƾ
6gǰ>b*j;@OG>y/^$ؾFHe>
}T`@"qSH>	dZ
9aokGh>N˨V?>Ps&ɾoݟ>q|or|;u>CLT-d~,*>Dz.y?$>UUgσ6p>5Q>9)	nM>h\BE7Ȱ^>:ʼHn^þ>|}>+O^">_d=v>U#B>Tr=ڙPvvN>e8="17u>ڹ=8ɾ'->1	=_c~>k=kIX̾
_>ȶ>)=^i|>e`M>ok1OX>ʴ>V'
X>IА>	9xFL>]>V
	掦h>rI>8c׾2"Y>I>av=y>	Hn- l>>Y>9ƕGy_>M=>4r7j>a|>[3}mե=k+W>/zHМ^p)=Hѝ>5;!=uCp5>-y3E1!=gD.>F2{Z=I`Eh>cz|D{>䙧,ЁOgԞ_
>geZ۟=Ǧv>)U9"s4šb>P+aH{](h>l`V_]>f!C^ľ?LJ*R>Tvd׾Ms,>NDz(Ⱦ`ڜ@{ry{z>Sf߾c\?0>R2
ZNO?>ۍ߾yc+Rxh9>YHpkЅc\/d>DYr:!>ҽM־@50x>KoCy4b'ela8.K>ep|>›ƒw>˛t֥+q쾠>J=,r?>wh=V&&ORD!>#=?i.ZTZ>ybe=pI^AփN>Tw<=s,\0>*ww>bJߧ">!P>:+65'>(&)>
re"u
JZ>
f=v>
j㝾qD>v,>uӛ-RyB>GX>?ųLcm2>MM70>>=6Ti.hF=aiA>|q{=k5>:M(=>}T/e=Ap,֦>O־]Kwdg-e>ЪN4;Mx|>9վW'K߀>s5Qt9+^
,!t~Y>"9(Ș̾pد8>:M`N>UP܏U]>I3U*=j>Bh
ks>fK~Ǿ	˾rp>uN{آ<<}zt>W6:7X(>P;vF 2`>(*K35+N>TN%9o>Y#9Y!pe8]7p%|>6SXȴ=8ǧw:Sz>l.ܒ=dצؾ,>J=Q7ڴ|)+>>x8ھTض>6Ͼ
;o>j"_I>
{YugFvV>J1>6<觃32>
vmueL>-[@K2t>8&|>Nee>6>95ܠs=P,@l>XŘS%:2=!y_0>`y??
="\=>8Y
F+x뽱9SQU>n؅;ikLx39>z*
u+{If]k:m>X
="
oHE>P-lgv:.C>Z掑MKu7squ>+yT"HfcR>!ubJkj
־t>X	[`	{xO>{"tq*GlgcDmu>iT*Ap9V(r.>6d8tzU(>Dj=\B=m ԰þ\J>rnUPm*/>
	a	Ǭ^GhP{>4ys-/BE>,+zAf\!>R!(+L€>gIc|F>^$p̄hѬ>6vG0;>R#f>K<4LGr>9vHuD1=;ѹ>0y|Cw=LuZD>qYǟO=';k>2na
ٗ>)k+6\w>hW>8g>NAA>+BQޯ$Y,>sS$Ӛ>&W/LU>K*$>
Խk۸n>Hl8,>+
Ӿ5R]>8>-~e1\>!'49=]O*	Eإ,K>;˜=rZܾ(.>郺V=ecXTn>?=ˮ%hCg>27P}䍾[g5i>%OۯBaX3L~>FWgmzFj>Ol+ڽ-r~>6~t˾jj-9yk>֬L"XRw$Q>q16[_( Z>2M2>\>)-#-eY3>x&WI	$C:M>t_|K+{ue>$X̺AsKEc`9>1ғBRCpxQ>*d'ҽLحxS>ɾ`sbWOC>[.0yf!ꞯl>_|r閠=#	W>&3Ǵ=FJ>Nhb^Ո=)>~^ 53AA=0>rW~i=hw>nSx9Y>ttPa;>78JVU*?>(>E20
OR>V3M>zՌ<	>
˘ds>L
i0":>
7 ,n>
ׁUm#.>"et>:3[l>s?ml>+>R\kn>>Frw?>E؃>[cD~W"4>z==0tsט>'M.Y="MR9p>on[d=#&">sh=t
fKcN
>H<=ݛ zc©!>l>`#]=l2c-r>^ӼN~Y]~MR2E>9LsQnxbя>s9{؄F>$
t}ivnj?m.>>/Z+L3vck>T)3jdƾ>0Im_­6>ѶJB۾8<>S3	q?Y/>r4(9۾ɋ>>> K2
?L
r9B>gRrc~]>%#E	QoB3>l/l "NJ/v>tb\\:>T~}SIU>fZ2"^f>!!= zQ">Oik׾?jeeoҿ>{,xr;".#>ؾ~2Pl3>ZzMtI>Ex%,_<69>O
y$	s>TaE /=s>-~Ό=żcX>LuO'D=:~d>AQ^_k=PL0>1&c[i9=;=td>r"`ULk=s
9p>@@ꬾkߓ	=c>n]@+ʋ=>7GJ/=lJzM>5N!(:04+'>F >Nb&d>"l>Yn&mg>$.5$>Sl	t5K
>$>3v,>-ER>¾Uw>WRU>lG!pU>
Ӊ>9þ
H@>cs^>(ؠRj>V>)m]E$D>
7>
>[Iꇑ>1cQ>4 "sS>/>\U'c>=>
&!lc>L>QZR׉>|iEs>KE>TDw>bоǀ>гY>|Ƃ?cnn>G<΂>^a0>pR
>Fjw=#>&rO_>3fs\YlaW>38	>&\'9Dp{>A'|> AIhQžY>QO.4=@ξ!}?H>z6=Mey$G$7>G>G=hF4vZ>TdgV=J~C3u~>BY=?amK>L1=.i;O>3#=`"rU>u,?*=ޜb>t.=4([
ŏ>bѐ.=gBGݾd>((=1!NҾMp9>]f&=Dܢ[b>؟=Ȁ!8jB>Nn=☕T+>	=1\GԾX}$>!P=Ѳ־>;>:j9=RV4>^5M=l:9BF
>i-=+%fzj|>0 >=l_`6>
J/b=J~M+El63>ԉN\&=&]-|2>I-/=gH:!Nk>ܘ\G=Kͤ:2*>J"h2>&/j6Ͼߣ(>5dVn6Цe>C2XÅtHy>NmR"3¾Oț?>W]mE%aFs>_}SJb#%#H>e9;]3SF_L>h$B[A&Ju־?'9>jܕJɪY$
бŀ>jךɗOSܑ>iH1[D
膾>_>e׽jUaYlV>`T
KcHƀZD%C>Y!J|PĂ>136HO>PY)aզ>EzP5+nմ<>8!Ԛ_z3onq\ϭ>);I/ΐ+g0늪mm>g:sEmO>0=k\X>iy7=X&f>ٚ'=y)z=}>`oj=ɯ9V6Nc>A=ɄpB&>Y~=]B3~>fr=2qԍԾ'@@X>Dtn=DpM.Q->nc4=ܑƇz:U>y=.,>n:n=ك(g
E>`>=o|(Jƭ>prmdj=QFm䮶>=9=*Bizd>zz=휲!}k1&s>#+=G4 ٥g>~a]=rӾ<>S
W~=ea"W>
82H=AGgK>ɢ{y=mSl $(>n=w9[xk;k[>1)=Bb~L>o4=|ց7>oҭ=Z^Xt(x>07w=B!>DZ>w	SFA8Ƿ5~>pD>-`V܉I>
!>@
ɾs=S!>>A]hq}ԓ>0J	>'0`Ct9>N>@/O*.>C>]~pM'ϞrN>mc>>g(1`$G>C?~T>	m3Ҿr;>/>
"7*>/ѿ>@ܾDC>
*<ٱ^C>Fl 2>\8/ >ן&TI>Xz!f>~S>c0ľjy>
Hѽ>lJyj>Đ0Z>EN/Ӿ7s4>>6&L{QdCl>#$u>v+/=`>2\j>m`=wGz>,@c>N)} I>n$>J}ja>
߀M)v>9;{aH&I=-7>Ϧq=$V>dgSe˚ʾ=0>	Ʉ? =8\}>R hƔo4=,dxi>{'k@(I=ؔ>"8O4`1='ϲe{>,lQKf=-x>E7#*e=uk>>1npV>*.p!)J>	>gp3֘>m.ZeEI>+&:g
&̛>/٪(t )BUW]>:>پg;^>Q{:~(>ֿD;:>b->XU&s	G>M=#@
>adnDg)L>ظlyOƾ
6gǰ>b*j;@OG>y/^$ؾFHe>
}T`@"qSH>	dZ
9aokGh>N˨V?>Ps&ɾoݟ>q|or|;u>CLT-d~,*>Dz.y?$>UUgσ6p>5Q>9)	nM>h\BE7Ȱ^>:ʼHn^þ>|}>+O^">_d=v>U#B>Tr=ڙPvvN>e8="17u>ڹ=8ɾ'->1	=_c~>k=kIX̾
_>ȶ>)=^i|>e`M>ok1OX>ʴ>V'
X>IА>	9xFL>]>V
	掦h>rI>8c׾2"Y>I>av=y>	Hn- l>>Y>9ƕGy_>M=>4r7j>a|>[3}mե=k+W>/zHМ^p)=Hѝ>5;!=uCp5>-y3E1!=gD.>F2{Z=I`Eh>cz|D{>䙧,ЁOgԞ_
>geZ۟=Ǧv>)U9"s4šb>P+aH{](h>l`V_]>f!C^ľ?LJ*R>Tvd׾Ms,>NDz(Ⱦ`ڜ@{ry{z>Sf߾c\?0>R2
ZNO?>ۍ߾yc+Rxh9>YHpkЅc\/d>DYr:!>ҽM־@50x>KoCy4b'ela8.K>ep|>›ƒw>˛t֥+q쾠>J=,r?>wh=V&&ORD!>#=?i.ZTZ>ybe=pI^AփN>Tw<=s,\0>*ww>bJߧ">!P>:+65'>(&)>
re"u
JZ>
f=v>
j㝾qD>v,>uӛ-RyB>GX>?ųLcm2>MM70>>=6Ti.hF=aiA>|q{=k5>:M(=>}T/e=Ap,֦>O־]Kwdg-e>ЪN4;Mx|>9վW'K߀>s5Qt9+^
,!t~Y>"9(Ș̾pد8>:M`N>UP܏U]>I3U*=j>Bh
ks>fK~Ǿ	˾rp>uN{آ<<}zt>W6:7X(>P;vF 2`>(*K35+N>TN%9o>Y#9Y!pe8]7p%|>6SXȴ=8ǧw:Sz>l.ܒ=dצؾ,>J=Q7ڴ|)+>>x8ھTض>6Ͼ
;o>j"_I>
{YugFvV>J1>6<觃32>
vmueL>-[@K2t>8&|>Nee>6>95ܠs=P,@l>XŘS%:2=!y_0>`y??
="\=>8Y
F+x뽱9SQU>n؅;ikLx39>z*
u+{If]k:m>X
="
oHE>P-lgv:.C>Z掑MKu7squ>+yT"HfcR>!ubJkj
־t>X	[`	{xO>{"tq*GlgcDmu>iT*Ap9V(r.>6d8tzU(>Dj=\B=m ԰þ\J>B($]=ľ]^>>=hsU>h>͛o-w%h(~>t2Q>
2ò1ʢ)>P8>	ݠ!7w0">֋9>}0!vں>
5AYz>s-M>3vz>Z\}t>@3|h>N޾ذ>xFwpE_,=8_'>=9Ⱦ:Cz;=5BJ墭>^H]odJ=
w"yW>ls1|>C2J">e%zM߽eh>!蘗~M7>~˽cGKkl	&>oYp!B_sC>I
̾	"<*>&HLF>:*Ybã31t>JIJf<*.eY>Aafud:sRPPK>BTqt=6tq>s!oJ=
en;s%c>lh=GUZ!w>V?>c$eCkRŸ>а>|H9>:|>k#Tgwe>roß>9=F%>'ҎP	>B``;h>K1>;w|>fr?
ξ~׳5<=7>W`xSz;=`άY>_pվ,m5`Lj&>2;U\vˮ>,&5v64>Ju|0L,taKk0e>k*6¾t:ܕ>̶GTb"

`9C>
 g
f޻L0>^	b>F0P1s KG~*>䇽ɳAUlC>H~}lt1v`7>%xBY۬j͔N>dB=Ս-W&>Rkp)=I<+8lH>ħ=)m
4`B%s>6٪r>	/_aIUY>d>
ψ3訾0r_a>
bP>2Ҿs
>vR>_bC%>5>s<=9̢>Y*mr=MT^>͕#z4MPJ[q>	^~"U>ڵ=+x[>ߥrPР+_@hNe>\;ľc'/!4	UVD>T#Dpv-Yqiɦ>0yj~u͹OXG>l
3.h[0Q+>֍Cս)ep#>Y=T>*1l=;DUF~߶c>jNIM=[UF6l/>\ g=8%*a>@;>z)fu-G>l[>
\]NaU>
4ݪ+>7/d)>+U|/>x KE?>c^Vt>jl{jG=|_+W>y	0w=Rj>/jS4-XN>$ۻr%+>cA;tP~>Cm!`6~>얾%
ew,E>si
H;YbоC>tbJ>o+LaGݨ>fUŋq[ T,Vt>.Zjc*(=́F҈>Fَ=SdhǾ#m>o=O
*H>?u5@=uw C 6
>B>E}qaTͨ>ëW3>+4ؕ6)>ړK;v>xzq]$>_U>H\,=$U>?Ey`o=(dƊ>xqN=2>YI}CU#>u/+e>'i׾zu|(׮V+>ճﮈ_8>xξq|ò
>HϾu[4>y"%%TZj1O">ɛRn_|XHJ>1#}D^	>d؅=5"pyl>xv=a.Ͼ&"&Q>+;J=Hh{>8>,3Z(>uJ>@ ,>
Sѩ>~2)?>Q>b*u*ѕ=XĨ>@zo8=gC>-[8Tjӊi=$b>1?I(Pؽwn>dbM#ZH>U8xRyC'2Ӳz\>Ҿ)8Lo>ƣ{XΓD,H>C9оZrz+\#9 >E(YϽT6W}֥>q꾽v\>4Q
=0eã>w>=	)Ѿ>Q>Iq,DʾE>p>]!放wS>
e`>};s>w>EzHkG=?>,[`R=ུ1>qΑR@%(ݗsO>GT;Q?sXo>$0
2r>g&𮊾DY
^u>նمn{em9ʾ.aI>6౾;MCyo>ѽ)K]dZ>>>樧ޤ"o8>ZR=Ӽ0R>낡?=v8iy>fZ>;`QEk397>ٜb'>	
!>jbc4Z>Ʋ#>mtB$=s}>O~ѾQod =羳J>.,;K"ccz21
>{r	`4j&>o
Ś1a=,
͇e>ҩ?P5P>kH5D`VS><쓽Ǿ<>a9QϣD]A{q>=ڙgm)49Bc8>S&x=A`2 B>}rQ>lQ.1>=8Y>p#m">H,s>P[iE^>ؑ>ti7_=k6*>l}%E&J'=hxn>ΔxT2FK6z>0!PY=>"H]>(ࣾ#<_Ⱦ
уD>pQʾʀu`>FI򩱾P]XE>'P#Jַv׾^E>px=ߎ~`Ը>*տ=gnE>a">k>qQY\=>">	SnΌ\4>>&$RU`D>8ن>iCo:g=bǕ>ɦbV!I=rz>9Z] 0c>Qi2Sua>b]!6Ɣ[C>Rx](fIѾ
g/3>	巾ѷ.1+>;;u/5=ľc_>Lu>-@
_z>4v=oE־q;>8EO='3{r"c>յ%pY>ƘczI{yO>gU	o>8C5>$F5{M>qJyCcy4>ͷ1>pu"=1'>s(ɝ--=99ե>H't`K>L>~Nj>oaڄ>K/!E468T	QS>a[4dH>,(Ϡ*o5.t>=O9!D\R>%1Gy	v+623>%&H=MV+׾Fc>=S(^>aEg>'ҟ&LEG>
&>$uo>j!>Ӟgs=C=x*>	Q
'_y={"jL>'5\ dlÜN{>EbR7H)>Dy†>dAȾD.D3 i>Xz*~+>콌rvi9Og>PŒJ(!ͥ>U=qC:o>=OT=`l,!6s>҈p%>¶DCx>
>:vBJ,x>E=Y>_=F>BO۾&!m$=pKt>}17-W%F	8J2o@sv&>=1\ȴ~~	Ȥ7s~n	 >c׳:6]y
_
>5;3*n	" >2o!TؾWq>V%L=I@@2
>;aԝ>r>i{U>}B=>SZ0>>
6<\l>Kc4>˔e>W{D1:Y}=i>s{="
ǴQN>.,o%Q>ͼ,D3򮩝i>b>۾g0|&
ӊ>Rz,Z(fR>>X_Ɂ{#`U>l4R=.$>c*l=VBƾV~>t
>.$T0>
r3>WVV>d0m>CFH‧=2Vr>Vٍ2֬e=Šz̴>SiӛOTo>I?Le@%>t/&.W?
D9׾DΧ>nc]5	'&({>C-OBaiǧ>5~뮽	6<>O={\Fh>k=<ڬaxU>A$.>Bh<"bw>:@<>Ncۮ>
85>&z$=|Z>ӱ،g=s*z}7>Z?>}I9t&>V)1}f:nvp>}zuNan[Ovݔ>āz	
9"
x

>(1z8EAݸ>̣%V.2>]j=l~bξ+U/>IoNn=%c'.
>!s>	<WIQ>h9j>SztZ>`d>ޘ*J=C~>[Qs=3lq5=>ޤF`66!
&J>}ː4+6w>5ʾ0a1Ns_	$>G'=þhU><	%%Q{Wfg+w<α>6ƽĞ8jS>;'=pA
]I%}>~1~>t	?8
`F>Yt>
Pm~>-fN>6*{=M4˩X>9IҾeA-=H>mÄCډ=>X~?оad>[A5蟾A0>R۸A8
)#[>:dN*]GX2IBq>vfwHɰmվJzbE>[ƩfO=]&`p>%s;\7=EL5?>Ye>56d>	k(P>V`ᑋ>xr.Z>Y>b/.=o>ʁUC︦$3ZOc>yş=þq׷˽u`>؁ξ'1U#>*2UO-־-%>lb9+1SnQ5Ư>Kx|$N/|h>=9ՕY!G>P ==V	 >Ђ		>Pܾb>ߎ;>IrMB>yjcϮ>5QEɾ&&P"F=
S0>9>ɾ6,ц{>SNǾy6y?KYn>-]vxھ&سn\>jNr
yqs56>nAIDJJ\*D>`SvGLƠD>Xa=
*ƙ̾gC>Ȓ=)l2>ƟR>	ZsM
{>C?<>W&``>.zT>P\u=k
>܆Aƾd	Df>ǡF^vX>/fwh.ϋ


׮p>!\2(
nА
w>E1iVZ	>XgJ8Ν]BE1>6lUZ=Hč
>>Rv>(Sl)>"|>vi-&>	a:>{Z<=rئ>ٺ%f00vf= >7Y3_
/AVZh>+ǃhRh>zKApd	
P%>zh~7{SH>'D,c5Kw>k镟8Ngu,>x*=xx|HnΎk>0&8>HVG(g׾ڤl/>=r>lG e>ݮq>T[{\=錶>!aK6֏ʿ8P>PG:>
\Ndz$2nehj>]$
MO>gF(&!wÂW>ʘ)	bw!
证>y{OL=!k2 @>-Ѭ>nڄO{GǏ>27>>"Ǽ>	bV>k(|=Ϛ!z>c[sHU-=ُtÐ>\!@pؘEO7>V֑0*#Ա>eBҾ
T!K(m>mL1l>B($]=ľ]^>>=hsU>h>͛o-w%h(~>t2Q>
2ò1ʢ)>P8>	ݠ!7w0">֋9>}0!vں>
5AYz>s-M>3vz>Z\}t>@3|h>N޾ذ>xFwpE_,=8_'>=9Ⱦ:Cz;=5BJ墭>^H]odJ=
w"yW>ls1|>C2J">e%zM߽eh>!蘗~M7>~˽cGKkl	&>oYp!B_sC>I
̾	"<*>&HLF>:*Ybã31t>JIJf<*.eY>Aafud:sRPPK>BTqt=6tq>s!oJ=
en;s%c>lh=GUZ!w>V?>c$eCkRŸ>а>|H9>:|>k#Tgwe>roß>9=F%>'ҎP	>B``;h>K1>;w|>fr?
ξ~׳5<=7>W`xSz;=`άY>_pվ,m5`Lj&>2;U\vˮ>,&5v64>Ju|0L,taKk0e>k*6¾t:ܕ>̶GTb"

`9C>
 g
f޻L0>^	b>F0P1s KG~*>䇽ɳAUlC>H~}lt1v`7>%xBY۬j͔N>dB=Ս-W&>Rkp)=I<+8lH>ħ=)m
4`B%s>6٪r>	/_aIUY>d>
ψ3訾0r_a>
bP>2Ҿs
>vR>_bC%>5>s<=9̢>Y*mr=MT^>͕#z4MPJ[q>	^~"U>ڵ=+x[>ߥrPР+_@hNe>\;ľc'/!4	UVD>T#Dpv-Yqiɦ>0yj~u͹OXG>l
3.h[0Q+>֍Cս)ep#>Y=T>*1l=;DUF~߶c>jNIM=[UF6l/>\ g=8%*a>@;>z)fu-G>l[>
\]NaU>
4ݪ+>7/d)>+U|/>x KE?>c^Vt>jl{jG=|_+W>y	0w=Rj>/jS4-XN>$ۻr%+>cA;tP~>Cm!`6~>얾%
ew,E>si
H;YbоC>tbJ>o+LaGݨ>fUŋq[ T,Vt>.Zjc*(=́F҈>Fَ=SdhǾ#m>o=O
*H>?u5@=uw C 6
>B>E}qaTͨ>ëW3>+4ؕ6)>ړK;v>xzq]$>_U>H\,=$U>?Ey`o=(dƊ>xqN=2>YI}CU#>u/+e>'i׾zu|(׮V+>ճﮈ_8>xξq|ò
>HϾu[4>y"%%TZj1O">ɛRn_|XHJ>1#}D^	>d؅=5"pyl>xv=a.Ͼ&"&Q>+;J=Hh{>8>,3Z(>uJ>@ ,>
Sѩ>~2)?>Q>b*u*ѕ=XĨ>@zo8=gC>-[8Tjӊi=$b>1?I(Pؽwn>dbM#ZH>U8xRyC'2Ӳz\>Ҿ)8Lo>ƣ{XΓD,H>C9оZrz+\#9 >E(YϽT6W}֥>q꾽v\>4Q
=0eã>w>=	)Ѿ>Q>Iq,DʾE>p>]!放wS>
e`>};s>w>EzHkG=?>,[`R=ུ1>qΑR@%(ݗsO>GT;Q?sXo>$0
2r>g&𮊾DY
^u>նمn{em9ʾ.aI>6౾;MCyo>ѽ)K]dZ>>>樧ޤ"o8>ZR=Ӽ0R>낡?=v8iy>fZ>;`QEk397>ٜb'>	
!>jbc4Z>Ʋ#>mtB$=s}>O~ѾQod =羳J>.,;K"ccz21
>{r	`4j&>o
Ś1a=,
͇e>ҩ?P5P>kH5D`VS><쓽Ǿ<>a9QϣD]A{q>=ڙgm)49Bc8>S&x=A`2 B>}rQ>lQ.1>=8Y>p#m">H,s>P[iE^>ؑ>ti7_=k6*>l}%E&J'=hxn>ΔxT2FK6z>0!PY=>"H]>(ࣾ#<_Ⱦ
уD>pQʾʀu`>FI򩱾P]XE>'P#Jַv׾^E>px=ߎ~`Ը>*տ=gnE>a">k>qQY\=>">	SnΌ\4>>&$RU`D>8ن>iCo:g=bǕ>ɦbV!I=rz>9Z] 0c>Qi2Sua>b]!6Ɣ[C>Rx](fIѾ
g/3>	巾ѷ.1+>;;u/5=ľc_>Lu>-@
_z>4v=oE־q;>8EO='3{r"c>յ%pY>ƘczI{yO>gU	o>8C5>$F5{M>qJyCcy4>ͷ1>pu"=1'>s(ɝ--=99ե>H't`K>L>~Nj>oaڄ>K/!E468T	QS>a[4dH>,(Ϡ*o5.t>=O9!D\R>%1Gy	v+623>%&H=MV+׾Fc>=S(^>aEg>'ҟ&LEG>
&>$uo>j!>Ӟgs=C=x*>	Q
'_y={"jL>'5\ dlÜN{>EbR7H)>Dy†>dAȾD.D3 i>Xz*~+>콌rvi9Og>PŒJ(!ͥ>U=qC:o>=OT=`l,!6s>҈p%>¶DCx>
>:vBJ,x>E=Y>_=F>BO۾&!m$=pKt>}17-W%F	8J2o@sv&>=1\ȴ~~	Ȥ7s~n	 >c׳:6]y
_
>5;3*n	" >2o!TؾWq>V%L=I@@2
>;aԝ>r>i{U>}B=>SZ0>>
6<\l>Kc4>˔e>W{D1:Y}=i>s{="
ǴQN>.,o%Q>ͼ,D3򮩝i>b>۾g0|&
ӊ>Rz,Z(fR>>X_Ɂ{#`U>l4R=.$>c*l=VBƾV~>t
>.$T0>
r3>WVV>d0m>CFH‧=2Vr>Vٍ2֬e=Šz̴>SiӛOTo>I?Le@%>t/&.W?
D9׾DΧ>nc]5	'&({>C-OBaiǧ>5~뮽	6<>O={\Fh>k=<ڬaxU>A$.>Bh<"bw>:@<>Ncۮ>
85>&z$=|Z>ӱ،g=s*z}7>Z?>}I9t&>V)1}f:nvp>}zuNan[Ovݔ>āz	
9"
x

>(1z8EAݸ>̣%V.2>]j=l~bξ+U/>IoNn=%c'.
>!s>	<WIQ>h9j>SztZ>`d>ޘ*J=C~>[Qs=3lq5=>ޤF`66!
&J>}ː4+6w>5ʾ0a1Ns_	$>G'=þhU><	%%Q{Wfg+w<α>6ƽĞ8jS>;'=pA
]I%}>~1~>t	?8
`F>Yt>
Pm~>-fN>6*{=M4˩X>9IҾeA-=H>mÄCډ=>X~?оad>[A5蟾A0>R۸A8
)#[>:dN*]GX2IBq>vfwHɰmվJzbE>[ƩfO=]&`p>%s;\7=EL5?>Ye>56d>	k(P>V`ᑋ>xr.Z>Y>b/.=o>ʁUC︦$3ZOc>yş=þq׷˽u`>؁ξ'1U#>*2UO-־-%>lb9+1SnQ5Ư>Kx|$N/|h>=9ՕY!G>P ==V	 >Ђ		>Pܾb>ߎ;>IrMB>yjcϮ>5QEɾ&&P"F=
S0>9>ɾ6,ц{>SNǾy6y?KYn>-]vxھ&سn\>jNr
yqs56>nAIDJJ\*D>`SvGLƠD>Xa=
*ƙ̾gC>Ȓ=)l2>ƟR>	ZsM
{>C?<>W&``>.zT>P\u=k
>܆Aƾd	Df>ǡF^vX>/fwh.ϋ


׮p>!\2(
nА
w>E1iVZ	>XgJ8Ν]BE1>6lUZ=Hč
>>Rv>(Sl)>"|>vi-&>	a:>{Z<=rئ>ٺ%f00vf= >7Y3_
/AVZh>+ǃhRh>zKApd	
P%>zh~7{SH>'D,c5Kw>k镟8Ngu,>x*=xx|HnΎk>0&8>HVG(g׾ڤl/>=r>lG e>ݮq>T[{\=錶>!aK6֏ʿ8P>PG:>
\Ndz$2nehj>]$
MO>gF(&!wÂW>ʘ)	bw!
证>y{OL=!k2 @>-Ѭ>nڄO{GǏ>27>>"Ǽ>	bV>k(|=Ϛ!z>c[sHU-=ُtÐ>\!@pؘEO7>V֑0*#Ա>eBҾ
T!K(m>mL1l>B($]=ľ]^>>=hsU>h>͛o-w%h(~>t2Q>
2ò1ʢ)>P8>	ݠ!7w0">֋9>}0!vں>
5AYz>s-M>3vz>Z\}t>@3|h>N޾ذ>xFwpE_,=8_'>=9Ⱦ:Cz;=5BJ墭>^H]odJ=
w"yW>ls1|>C2J">e%zM߽eh>!蘗~M7>~˽cGKkl	&>oYp!B_sC>I
̾	"<*>&HLF>:*Ybã31t>JIJf<*.eY>Aafud:sRPPK>BTqt=6tq>s!oJ=
en;s%c>lh=GUZ!w>V?>c$eCkRŸ>а>|H9>:|>k#Tgwe>roß>9=F%>'ҎP	>B``;h>K1>;w|>fr?
ξ~׳5<=7>W`xSz;=`άY>_pվ,m5`Lj&>2;U\vˮ>,&5v64>Ju|0L,taKk0e>k*6¾t:ܕ>̶GTb"

`9C>
 g
f޻L0>^	b>F0P1s KG~*>䇽ɳAUlC>H~}lt1v`7>%xBY۬j͔N>dB=Ս-W&>Rkp)=I<+8lH>ħ=)m
4`B%s>6٪r>	/_aIUY>d>
ψ3訾0r_a>
bP>2Ҿs
>vR>_bC%>5>s<=9̢>Y*mr=MT^>͕#z4MPJ[q>	^~"U>ڵ=+x[>ߥrPР+_@hNe>\;ľc'/!4	UVD>T#Dpv-Yqiɦ>0yj~u͹OXG>l
3.h[0Q+>֍Cս)ep#>Y=T>*1l=;DUF~߶c>jNIM=[UF6l/>\ g=8%*a>@;>z)fu-G>l[>
\]NaU>
4ݪ+>7/d)>+U|/>x KE?>c^Vt>jl{jG=|_+W>y	0w=Rj>/jS4-XN>$ۻr%+>cA;tP~>Cm!`6~>얾%
ew,E>si
H;YbоC>tbJ>o+LaGݨ>fUŋq[ T,Vt>.Zjc*(=́F҈>Fَ=SdhǾ#m>o=O
*H>?u5@=uw C 6
>B>E}qaTͨ>ëW3>+4ؕ6)>ړK;v>xzq]$>_U>H\,=$U>?Ey`o=(dƊ>xqN=2>YI}CU#>u/+e>'i׾zu|(׮V+>ճﮈ_8>xξq|ò
>HϾu[4>y"%%TZj1O">ɛRn_|XHJ>1#}D^	>d؅=5"pyl>xv=a.Ͼ&"&Q>+;J=Hh{>8>,3Z(>uJ>@ ,>
Sѩ>~2)?>Q>b*u*ѕ=XĨ>@zo8=gC>-[8Tjӊi=$b>1?I(Pؽwn>dbM#ZH>U8xRyC'2Ӳz\>Ҿ)8Lo>ƣ{XΓD,H>C9оZrz+\#9 >E(YϽT6W}֥>q꾽v\>4Q
=0eã>w>=	)Ѿ>Q>Iq,DʾE>p>]!放wS>
e`>};s>w>EzHkG=?>,[`R=ུ1>qΑR@%(ݗsO>GT;Q?sXo>$0
2r>g&𮊾DY
^u>նمn{em9ʾ.aI>6౾;MCyo>ѽ)K]dZ>>>樧ޤ"o8>ZR=Ӽ0R>낡?=v8iy>fZ>;`QEk397>ٜb'>	
!>jbc4Z>Ʋ#>mtB$=s}>O~ѾQod =羳J>.,;K"ccz21
>{r	`4j&>o
Ś1a=,
͇e>ҩ?P5P>kH5D`VS><쓽Ǿ<>a9QϣD]A{q>=ڙgm)49Bc8>S&x=A`2 B>}rQ>lQ.1>=8Y>p#m">H,s>P[iE^>ؑ>ti7_=k6*>l}%E&J'=hxn>ΔxT2FK6z>0!PY=>"H]>(ࣾ#<_Ⱦ
уD>pQʾʀu`>FI򩱾P]XE>'P#Jַv׾^E>px=ߎ~`Ը>*տ=gnE>a">k>qQY\=>">	SnΌ\4>>&$RU`D>8ن>iCo:g=bǕ>ɦbV!I=rz>9Z] 0c>Qi2Sua>b]!6Ɣ[C>Rx](fIѾ
g/3>	巾ѷ.1+>;;u/5=ľc_>Lu>-@
_z>4v=oE־q;>8EO='3{r"c>յ%pY>ƘczI{yO>gU	o>8C5>$F5{M>qJyCcy4>ͷ1>pu"=1'>s(ɝ--=99ե>H't`K>L>~Nj>oaڄ>K/!E468T	QS>a[4dH>,(Ϡ*o5.t>=O9!D\R>%1Gy	v+623>%&H=MV+׾Fc>=S(^>aEg>'ҟ&LEG>
&>$uo>j!>Ӟgs=C=x*>	Q
'_y={"jL>'5\ dlÜN{>EbR7H)>Dy†>dAȾD.D3 i>Xz*~+>콌rvi9Og>PŒJ(!ͥ>U=qC:o>=OT=`l,!6s>҈p%>¶DCx>
>:vBJ,x>E=Y>_=F>BO۾&!m$=pKt>}17-W%F	8J2o@sv&>=1\ȴ~~	Ȥ7s~n	 >c׳:6]y
_
>5;3*n	" >2o!TؾWq>V%L=I@@2
>;aԝ>r>i{U>}B=>SZ0>>
6<\l>Kc4>˔e>W{D1:Y}=i>s{="
ǴQN>.,o%Q>ͼ,D3򮩝i>b>۾g0|&
ӊ>Rz,Z(fR>>X_Ɂ{#`U>l4R=.$>c*l=VBƾV~>t
>.$T0>
r3>WVV>d0m>CFH‧=2Vr>Vٍ2֬e=Šz̴>SiӛOTo>I?Le@%>t/&.W?
D9׾DΧ>nc]5	'&({>C-OBaiǧ>5~뮽	6<>O={\Fh>k=<ڬaxU>A$.>Bh<"bw>:@<>Ncۮ>
85>&z$=|Z>ӱ،g=s*z}7>Z?>}I9t&>V)1}f:nvp>}zuNan[Ovݔ>āz	
9"
x

>(1z8EAݸ>̣%V.2>]j=l~bξ+U/>IoNn=%c'.
>!s>	<WIQ>h9j>SztZ>`d>ޘ*J=C~>[Qs=3lq5=>ޤF`66!
&J>}ː4+6w>5ʾ0a1Ns_	$>G'=þhU><	%%Q{Wfg+w<α>6ƽĞ8jS>;'=pA
]I%}>~1~>t	?8
`F>Yt>
Pm~>-fN>6*{=M4˩X>9IҾeA-=H>mÄCډ=>X~?оad>[A5蟾A0>R۸A8
)#[>:dN*]GX2IBq>vfwHɰmվJzbE>[ƩfO=]&`p>%s;\7=EL5?>Ye>56d>	k(P>V`ᑋ>xr.Z>Y>b/.=o>ʁUC︦$3ZOc>yş=þq׷˽u`>؁ξ'1U#>*2UO-־-%>lb9+1SnQ5Ư>Kx|$N/|h>=9ՕY!G>P ==V	 >Ђ		>Pܾb>ߎ;>IrMB>yjcϮ>5QEɾ&&P"F=
S0>9>ɾ6,ц{>SNǾy6y?KYn>-]vxھ&سn\>jNr
yqs56>nAIDJJ\*D>`SvGLƠD>Xa=
*ƙ̾gC>Ȓ=)l2>ƟR>	ZsM
{>C?<>W&``>.zT>P\u=k
>܆Aƾd	Df>ǡF^vX>/fwh.ϋ


׮p>!\2(
nА
w>E1iVZ	>XgJ8Ν]BE1>6lUZ=Hč
>>Rv>(Sl)>"|>vi-&>	a:>{Z<=rئ>ٺ%f00vf= >7Y3_
/AVZh>+ǃhRh>zKApd	
P%>zh~7{SH>'D,c5Kw>k镟8Ngu,>x*=xx|HnΎk>0&8>HVG(g׾ڤl/>=r>lG e>ݮq>T[{\=錶>!aK6֏ʿ8P>PG:>
\Ndz$2nehj>]$
MO>gF(&!wÂW>ʘ)	bw!
证>y{OL=!k2 @>-Ѭ>nڄO{GǏ>27>>"Ǽ>	bV>k(|=Ϛ!z>c[sHU-=ُtÐ>\!@pؘEO7>V֑0*#Ա>eBҾ
T!K(m>mL1l.]joH#v>TMӱRrپHS>_F"=
/Kؙ`v@>&FXCA= [-
g>{>>@kҾ->@8Pl>?4)׾[>{>Yh>/բsKz&m4ݬb,c^1%>ӒsQyH?FK>c*ڨ뗣zD>Nͩ.o6Ɏ>Ơf|j'Y@>GI^Wss>nX-T=x{gO4Yw>?>щp(>
6>Db\wDz>J	>5{vĢfx=)>8{۽yO>zCm]'Q>N%믑q7!]AP>5iھy+@[WX>+AȽ`Dʾ-ďȃ>en2eAw"v8 >,V=ꐼkr>Y%,>wM1P
8>
4Ŗa>ʳtu`:P>+>DDlC=[/S >
܎оjuɽ~er>&_~yM">ZY*S<5Gg>p%!Ѿl1mGֶD>0 2RϾ~E>wErn=zAIsŎi>uB%q=jqRݗep>9-g>ܖԾZ@>Vһ>B`pU)6u>ڨɖ>ۙZm1Na=\>
־cOSYW`>DRB+pzQ<>86$?P}ݩ>busf.Dp>yx8]?8"=.޾@W>`X S=ի ퟾H>WA`m=jH#MHޏ>Ss?>
@ܘSbߍI>	:c>~hLRZ=ھe=ξ>
EQ{=&N>ZqTwm8>]Ͼ#>ݫ
MsPȾ&[>f/Nvp]R ce>2kXqQd^>
݇\=oW<>#\>Y~|߾}'>K](>oB<<<"]>p$M>;Rp#=׎>Z3#uپ3Ҭ>d9lmH˾^~ٔBl?)le>4;᩾Zs>.%̾ߝA/P>`K3u`SW~,g>¯cOaLᅾcJl>l?$dz=r#q>X#>qz,"s>z=7ɕVr=ox~]>Xv2eo=ٓO¿>RKҏ%~>vD^"]w{e>8w>
J_N+	L>q^-&Gɾn)e;O/>PVewMbf>b1Z=5qyD\6>!>BL9r> .R>>Ѯ}>X*þNּ=Sp>:ˠប`>-a%pBB^>UrSy;.q+^ki>kgM%R@׃>˔Yl!|	/0>9
=Dԥ|79U	>Eh1S=4f'0tT>+->7 Ќ>~ >Mᶾb=ش>rKՍ}XHu>5Xo*ɐ/͊>"GȾ	r՟,>>LC
5VM[>$P(qzDC.|~>ٶ#ɿ%>&U=gTv;x>#]@)b>CQW2S>q׵?>C{-M8=ⰸ>H@?8_z=	J>7g6$v2{5ʽZ+u>TWl6l'>"FSlR';Q)%>EJ6xJI0|ar>p:@ӽO8!t>EE
=4A8Ӏ>({>he
{	>
$gz>柿xWV!y5>w<>ɔ"?VD=<9S>;Mk_vr1>l"d`=# y$%>K
	>F>_v(QƎK>#cIy<»d>e=|W^C~>B(A>RWFi%>
	W>ľ	d풂#>J>dǾsp=➞i>4e,ZZkl8Hr,2>pپ
D#'>b/Rjhu>^Ab3C䓱#>1=
chan/>42^>L>
Z"C>>=]\3]>Ze3>4j=_>̙=rEOw!e%.>qړXwg-@&\>vŲ
.H㚰>Qy!˴vpSxU>}aJH6hGNL>?o(ɽ=V?3+4>]>3]>|A>T?=:IT=;vJ>TQ`=䇌e>-
xT˶>XHebDܾ`>tZ)TH>$"ѝ?БbNפ>1	N|yt<>"=*iv\>j@7ygD>
by>Ih>5_=&"%-ʇW=uISw>wa)^,U?]DB>anG\OP+
Z>)/QCVsL>5L!R1UT>ka![=*' v~>$ =^H],Φ>Ept>ZiheC'>L>i$t&Ut0=Hz>3*B\x7܍Vp'lv>.xV:!p>Wk`*GX=<
0->(wX4`t*TaQ{>FsSk$*}2>lfv,s=usľD|>2K>:,i%~sNuh>'>H}X>/m>7IJf<<=K0>q__ywwSj)ju>KZ4Q!;S>9n˾
}`x欎_Q>O75O"%XV
->j7$l$r^ھHdh>@=uѾ'L>Mx]p>\45,op>
>fע¾s=^?>kYԾծI=M7>Myge"j5C]UEg>JǾ(
Ŝ&>CUW
42c^>֦ms .D9>"F4g=rCW|Le9$_>%cM>*tP/z>ܺ>
;đBt@#>VFMz>k8j]c=9Z=2>2Hz^M5'~
ן>*:c\(->|bE[Fhe>iU	nc7>낖.Ӯ0&>QS]=E7>rϮ>ZmM߭N>|>ȡ;A1=JBz>-ެ=w>Ζ-@R16-\O>0s	"X'о
ޕO}
K>JGU#Q#s>s\_|z-g|>!+=nXƘ_Ϙe>ۘS>
$`wBu>x5m>v߾9ՠ>ER@?>}9PlJ,={1<>E;2TLl>?]2[Ei>W:Ai
B
b
*T>B餽W58Y^>:Ak8Θˆ\Q0>6i=]ڊmv >c%>	˾u"&>	5Ĉl>}Jlt
y~=E>i>iE#:
Dp>Y׭*#cn,k>PN0xQe
ɢEJ>ԾB?#P	>qi잽{6*>[g>(zg=bB4o>m良>eJ ٩/S>
Qo>	w|mAn$>

>aJkGL3
_=SQE>i;4z[4fԟ>~k
L֢>7,0xII>9,BX7>
Ce=x7x3E>)6>xbi>TP>8Bt9
>!q>#|\o=OrV1L>n=n;S_RS
k>koAMjI5[E>eOrNS>9>TOEkg	>LD='O0@
>v=Xv83>8>q4jj>*>#׾b#<=;n >#Xl0翩5>"GC7$X+>cYG`H>Ucd/u'l<݇m?$8z>	
%= 12C~><6>	ɿM;@Y>kn>	NQŮO;=i6>Gp秾q/r#>蔾bRp	>iL[bqz6W`q>ygC]!+^xq>sTyIJģx>L~}L=hg9;3
>_>Ld،>
;>Yw$=Kr>:idkZp|`*>>mxP;>Tt:yD3.>LVǢ{(aÒ>PUfFUADc`>=f߽Ӭ[駾n>ʭU>4="Gj|E%H>ԊM>Q&oKV>X^>mx;=^1.h>2Y¾>QM
D0>1^ Uj>9?9\Вx
Y=>kzg߾(t,#ԩ>b
_>?׾@很l>׫a=X>"qSug/>
u[M>Hټ̙V>Ub@N>:i=1to`>-ӊݽmMJgPF>T"WW_jd>3$Ŧ)ֱ,T
-J>C3"4F>OY>䞠'S1Ծ=؝q=Y23T^>T>3>w>(N0:-#=3-Ύ>#CP@4Aa>
6?2*z?>;ȿvV
#!R>ˉEg@ޙ>}v_I7bXD>rɊ\=fҾkI>n7>5a&d(>2>lbF|gq=6?/>e*r|4S3¹>9zU\:~>N&
n
>Ha{ʾ 겕&>z%ig+>nP
>Wt=<7hONd>J߾>e!KM?>	c[>qʾLl=p`9; >B=ؕڌZ	X>p.b?þ&gڄ;>j܌P?Ln8#>jeƾ&7>?.>lֽZ&\ JK>={~aRx> nA>
`j s՞">=^X+>]8

'^G=mt+t>ksE9R.½UU>8P{Dֱ-+Bs>;G
=sUAL|">@8ɾy 4=>ɷnZK)9C>pT=={Wȝ>g
>Ie	Ͼ߱>k{>M"jT}1&>OpMe'Q>r}9$z>]߽}<`(/Ye>oJ1b=A:20>#6>*dUf4>_i;9D>el|¾yZ+q>
t?.>g?X=?>x=GĐI>M햾MĽ\rTQ>I9ԓI~q	GSd>ȃ{2<$mҾAՆ>/IgُAS\ib>Mŕl=y@ۯ1i>5>P9۾LHc>
>NCt8a~R+=%ϧ>hKڐR=ym6>Leއ9}2-U>&o	lBy
Ru4S>37|]8c>zW!ds[)>Z%=nո%g_>up>qꧦO@>
zP>Х
A2=
rf>VD?ȹ'>?޺$o>H	s?/Oac>wGse@8>RXcA|?5ގ>1d	{Y.HL`邔->9`>=kWd9\e>/>/A$8eeQ>?a&>Y%47G= 5->:Lj _>eˣ?'qpٵ>`;
ɲ$^Z.]joH#v>TMӱRrپHS>_F"=
/Kؙ`v@>&FXCA= [-
g>{>>@kҾ->@8Pl>?4)׾[>{>Yh>/բsKz&m4ݬb,c^1%>ӒsQyH?FK>c*ڨ뗣zD>Nͩ.o6Ɏ>Ơf|j'Y@>GI^Wss>nX-T=x{gO4Yw>?>щp(>
6>Db\wDz>J	>5{vĢfx=)>8{۽yO>zCm]'Q>N%믑q7!]AP>5iھy+@[WX>+AȽ`Dʾ-ďȃ>en2eAw"v8 >,V=ꐼkr>Y%,>wM1P
8>
4Ŗa>ʳtu`:P>+>DDlC=[/S >
܎оjuɽ~er>&_~yM">ZY*S<5Gg>p%!Ѿl1mGֶD>0 2RϾ~E>wErn=zAIsŎi>uB%q=jqRݗep>9-g>ܖԾZ@>Vһ>B`pU)6u>ڨɖ>ۙZm1Na=\>
־cOSYW`>DRB+pzQ<>86$?P}ݩ>busf.Dp>yx8]?8"=.޾@W>`X S=ի ퟾H>WA`m=jH#MHޏ>Ss?>
@ܘSbߍI>	:c>~hLRZ=ھe=ξ>
EQ{=&N>ZqTwm8>]Ͼ#>ݫ
MsPȾ&[>f/Nvp]R ce>2kXqQd^>
݇\=oW<>#\>Y~|߾}'>K](>oB<<<"]>p$M>;Rp#=׎>Z3#uپ3Ҭ>d9lmH˾^~ٔBl?)le>4;᩾Zs>.%̾ߝA/P>`K3u`SW~,g>¯cOaLᅾcJl>l?$dz=r#q>X#>qz,"s>z=7ɕVr=ox~]>Xv2eo=ٓO¿>RKҏ%~>vD^"]w{e>8w>
J_N+	L>q^-&Gɾn)e;O/>PVewMbf>b1Z=5qyD\6>!>BL9r> .R>>Ѯ}>X*þNּ=Sp>:ˠប`>-a%pBB^>UrSy;.q+^ki>kgM%R@׃>˔Yl!|	/0>9
=Dԥ|79U	>Eh1S=4f'0tT>+->7 Ќ>~ >Mᶾb=ش>rKՍ}XHu>5Xo*ɐ/͊>"GȾ	r՟,>>LC
5VM[>$P(qzDC.|~>ٶ#ɿ%>&U=gTv;x>#]@)b>CQW2S>q׵?>C{-M8=ⰸ>H@?8_z=	J>7g6$v2{5ʽZ+u>TWl6l'>"FSlR';Q)%>EJ6xJI0|ar>p:@ӽO8!t>EE
=4A8Ӏ>({>he
{	>
$gz>柿xWV!y5>w<>ɔ"?VD=<9S>;Mk_vr1>l"d`=# y$%>K
	>F>_v(QƎK>#cIy<»d>e=|W^C~>B(A>RWFi%>
	W>ľ	d풂#>J>dǾsp=➞i>4e,ZZkl8Hr,2>pپ
D#'>b/Rjhu>^Ab3C䓱#>1=
chan/>42^>L>
Z"C>>=]\3]>Ze3>4j=_>̙=rEOw!e%.>qړXwg-@&\>vŲ
.H㚰>Qy!˴vpSxU>}aJH6hGNL>?o(ɽ=V?3+4>]>3]>|A>T?=:IT=;vJ>TQ`=䇌e>-
xT˶>XHebDܾ`>tZ)TH>$"ѝ?БbNפ>1	N|yt<>"=*iv\>j@7ygD>
by>Ih>5_=&"%-ʇW=uISw>wa)^,U?]DB>anG\OP+
Z>)/QCVsL>5L!R1UT>ka![=*' v~>$ =^H],Φ>Ept>ZiheC'>L>i$t&Ut0=Hz>3*B\x7܍Vp'lv>.xV:!p>Wk`*GX=<
0->(wX4`t*TaQ{>FsSk$*}2>lfv,s=usľD|>2K>:,i%~sNuh>'>H}X>/m>7IJf<<=K0>q__ywwSj)ju>KZ4Q!;S>9n˾
}`x欎_Q>O75O"%XV
->j7$l$r^ھHdh>@=uѾ'L>Mx]p>\45,op>
>fע¾s=^?>kYԾծI=M7>Myge"j5C]UEg>JǾ(
Ŝ&>CUW
42c^>֦ms .D9>"F4g=rCW|Le9$_>%cM>*tP/z>ܺ>
;đBt@#>VFMz>k8j]c=9Z=2>2Hz^M5'~
ן>*:c\(->|bE[Fhe>iU	nc7>낖.Ӯ0&>QS]=E7>rϮ>ZmM߭N>|>ȡ;A1=JBz>-ެ=w>Ζ-@R16-\O>0s	"X'о
ޕO}
K>JGU#Q#s>s\_|z-g|>!+=nXƘ_Ϙe>ۘS>
$`wBu>x5m>v߾9ՠ>ER@?>}9PlJ,={1<>E;2TLl>?]2[Ei>W:Ai
B
b
*T>B餽W58Y^>:Ak8Θˆ\Q0>6i=]ڊmv >c%>	˾u"&>	5Ĉl>}Jlt
y~=E>i>iE#:
Dp>Y׭*#cn,k>PN0xQe
ɢEJ>ԾB?#P	>qi잽{6*>[g>(zg=bB4o>m良>eJ ٩/S>
Qo>	w|mAn$>

>aJkGL3
_=SQE>i;4z[4fԟ>~k
L֢>7,0xII>9,BX7>
Ce=x7x3E>)6>xbi>TP>8Bt9
>!q>#|\o=OrV1L>n=n;S_RS
k>koAMjI5[E>eOrNS>9>TOEkg	>LD='O0@
>v=Xv83>8>q4jj>*>#׾b#<=;n >#Xl0翩5>"GC7$X+>cYG`H>Ucd/u'l<݇m?$8z>	
%= 12C~><6>	ɿM;@Y>kn>	NQŮO;=i6>Gp秾q/r#>蔾bRp	>iL[bqz6W`q>ygC]!+^xq>sTyIJģx>L~}L=hg9;3
>_>Ld،>
;>Yw$=Kr>:idkZp|`*>>mxP;>Tt:yD3.>LVǢ{(aÒ>PUfFUADc`>=f߽Ӭ[駾n>ʭU>4="Gj|E%H>ԊM>Q&oKV>X^>mx;=^1.h>2Y¾>QM
D0>1^ Uj>9?9\Вx
Y=>kzg߾(t,#ԩ>b
_>?׾@很l>׫a=X>"qSug/>
u[M>Hټ̙V>Ub@N>:i=1to`>-ӊݽmMJgPF>T"WW_jd>3$Ŧ)ֱ,T
-J>C3"4F>OY>䞠'S1Ծ=؝q=Y23T^>T>3>w>(N0:-#=3-Ύ>#CP@4Aa>
6?2*z?>;ȿvV
#!R>ˉEg@ޙ>}v_I7bXD>rɊ\=fҾkI>n7>5a&d(>2>lbF|gq=6?/>e*r|4S3¹>9zU\:~>N&
n
>Ha{ʾ 겕&>z%ig+>nP
>Wt=<7hONd>J߾>e!KM?>	c[>qʾLl=p`9; >B=ؕڌZ	X>p.b?þ&gڄ;>j܌P?Ln8#>jeƾ&7>?.>lֽZ&\ JK>={~aRx> nA>
`j s՞">=^X+>]8

'^G=mt+t>ksE9R.½UU>8P{Dֱ-+Bs>;G
=sUAL|">@8ɾy 4=>ɷnZK)9C>pT=={Wȝ>g
>Ie	Ͼ߱>k{>M"jT}1&>OpMe'Q>r}9$z>]߽}<`(/Ye>oJ1b=A:20>#6>*dUf4>_i;9D>el|¾yZ+q>
t?.>g?X=?>x=GĐI>M햾MĽ\rTQ>I9ԓI~q	GSd>ȃ{2<$mҾAՆ>/IgُAS\ib>Mŕl=y@ۯ1i>5>P9۾LHc>
>NCt8a~R+=%ϧ>hKڐR=ym6>Leއ9}2-U>&o	lBy
Ru4S>37|]8c>zW!ds[)>Z%=nո%g_>up>qꧦO@>
zP>Х
A2=
rf>VD?ȹ'>?޺$o>H	s?/Oac>wGse@8>RXcA|?5ގ>1d	{Y.HL`邔->9`>=kWd9\e>/>/A$8eeQ>?a&>Y%47G= 5->:Lj _>eˣ?'qpٵ>`;
ɲ$^Z.]joH#v>TMӱRrپHS>_F"=
/Kؙ`v@>&FXCA= [-
g>{>>@kҾ->@8Pl>?4)׾[>{>Yh>/բsKz&m4ݬb,c^1%>ӒsQyH?FK>c*ڨ뗣zD>Nͩ.o6Ɏ>Ơf|j'Y@>GI^Wss>nX-T=x{gO4Yw>?>щp(>
6>Db\wDz>J	>5{vĢfx=)>8{۽yO>zCm]'Q>N%믑q7!]AP>5iھy+@[WX>+AȽ`Dʾ-ďȃ>en2eAw"v8 >,V=ꐼkr>Y%,>wM1P
8>
4Ŗa>ʳtu`:P>+>DDlC=[/S >
܎оjuɽ~er>&_~yM">ZY*S<5Gg>p%!Ѿl1mGֶD>0 2RϾ~E>wErn=zAIsŎi>uB%q=jqRݗep>9-g>ܖԾZ@>Vһ>B`pU)6u>ڨɖ>ۙZm1Na=\>
־cOSYW`>DRB+pzQ<>86$?P}ݩ>busf.Dp>yx8]?8"=.޾@W>`X S=ի ퟾H>WA`m=jH#MHޏ>Ss?>
@ܘSbߍI>	:c>~hLRZ=ھe=ξ>
EQ{=&N>ZqTwm8>]Ͼ#>ݫ
MsPȾ&[>f/Nvp]R ce>2kXqQd^>
݇\=oW<>#\>Y~|߾}'>K](>oB<<<"]>p$M>;Rp#=׎>Z3#uپ3Ҭ>d9lmH˾^~ٔBl?)le>4;᩾Zs>.%̾ߝA/P>`K3u`SW~,g>¯cOaLᅾcJl>l?$dz=r#q>X#>qz,"s>z=7ɕVr=ox~]>Xv2eo=ٓO¿>RKҏ%~>vD^"]w{e>8w>
J_N+	L>q^-&Gɾn)e;O/>PVewMbf>b1Z=5qyD\6>!>BL9r> .R>>Ѯ}>X*þNּ=Sp>:ˠប`>-a%pBB^>UrSy;.q+^ki>kgM%R@׃>˔Yl!|	/0>9
=Dԥ|79U	>Eh1S=4f'0tT>+->7 Ќ>~ >Mᶾb=ش>rKՍ}XHu>5Xo*ɐ/͊>"GȾ	r՟,>>LC
5VM[>$P(qzDC.|~>ٶ#ɿ%>&U=gTv;x>#]@)b>CQW2S>q׵?>C{-M8=ⰸ>H@?8_z=	J>7g6$v2{5ʽZ+u>TWl6l'>"FSlR';Q)%>EJ6xJI0|ar>p:@ӽO8!t>EE
=4A8Ӏ>({>he
{	>
$gz>柿xWV!y5>w<>ɔ"?VD=<9S>;Mk_vr1>l"d`=# y$%>K
	>F>_v(QƎK>#cIy<»d>e=|W^C~>B(A>RWFi%>
	W>ľ	d풂#>J>dǾsp=➞i>4e,ZZkl8Hr,2>pپ
D#'>b/Rjhu>^Ab3C䓱#>1=
chan/>42^>L>
Z"C>>=]\3]>Ze3>4j=_>̙=rEOw!e%.>qړXwg-@&\>vŲ
.H㚰>Qy!˴vpSxU>}aJH6hGNL>?o(ɽ=V?3+4>]>3]>|A>T?=:IT=;vJ>TQ`=䇌e>-
xT˶>XHebDܾ`>tZ)TH>$"ѝ?БbNפ>1	N|yt<>"=*iv\>j@7ygD>
by>Ih>5_=&"%-ʇW=uISw>wa)^,U?]DB>anG\OP+
Z>)/QCVsL>5L!R1UT>ka![=*' v~>$ =^H],Φ>Ept>ZiheC'>L>i$t&Ut0=Hz>3*B\x7܍Vp'lv>.xV:!p>Wk`*GX=<
0->(wX4`t*TaQ{>FsSk$*}2>lfv,s=usľD|>2K>:,i%~sNuh>'>H}X>/m>7IJf<<=K0>q__ywwSj)ju>KZ4Q!;S>9n˾
}`x欎_Q>O75O"%XV
->j7$l$r^ھHdh>@=uѾ'L>Mx]p>\45,op>
>fע¾s=^?>kYԾծI=M7>Myge"j5C]UEg>JǾ(
Ŝ&>CUW
42c^>֦ms .D9>"F4g=rCW|Le9$_>%cM>*tP/z>ܺ>
;đBt@#>VFMz>k8j]c=9Z=2>2Hz^M5'~
ן>*:c\(->|bE[Fhe>iU	nc7>낖.Ӯ0&>QS]=E7>rϮ>ZmM߭N>|>ȡ;A1=JBz>-ެ=w>Ζ-@R16-\O>0s	"X'о
ޕO}
K>JGU#Q#s>s\_|z-g|>!+=nXƘ_Ϙe>ۘS>
$`wBu>x5m>v߾9ՠ>ER@?>}9PlJ,={1<>E;2TLl>?]2[Ei>W:Ai
B
b
*T>B餽W58Y^>:Ak8Θˆ\Q0>6i=]ڊmv >c%>	˾u"&>	5Ĉl>}Jlt
y~=E>i>iE#:
Dp>Y׭*#cn,k>PN0xQe
ɢEJ>ԾB?#P	>qi잽{6*>[g>(zg=bB4o>m良>eJ ٩/S>
Qo>	w|mAn$>

>aJkGL3
_=SQE>i;4z[4fԟ>~k
L֢>7,0xII>9,BX7>
Ce=x7x3E>)6>xbi>TP>8Bt9
>!q>#|\o=OrV1L>n=n;S_RS
k>koAMjI5[E>eOrNS>9>TOEkg	>LD='O0@
>v=Xv83>8>q4jj>*>#׾b#<=;n >#Xl0翩5>"GC7$X+>cYG`H>Ucd/u'l<݇m?$8z>	
%= 12C~><6>	ɿM;@Y>kn>	NQŮO;=i6>Gp秾q/r#>蔾bRp	>iL[bqz6W`q>ygC]!+^xq>sTyIJģx>L~}L=hg9;3
>_>Ld،>
;>Yw$=Kr>:idkZp|`*>>mxP;>Tt:yD3.>LVǢ{(aÒ>PUfFUADc`>=f߽Ӭ[駾n>ʭU>4="Gj|E%H>ԊM>Q&oKV>X^>mx;=^1.h>2Y¾>QM
D0>1^ Uj>9?9\Вx
Y=>kzg߾(t,#ԩ>b
_>?׾@很l>׫a=X>"qSug/>
u[M>Hټ̙V>Ub@N>:i=1to`>-ӊݽmMJgPF>T"WW_jd>3$Ŧ)ֱ,T
-J>C3"4F>OY>䞠'S1Ծ=؝q=Y23T^>T>3>w>(N0:-#=3-Ύ>#CP@4Aa>
6?2*z?>;ȿvV
#!R>ˉEg@ޙ>}v_I7bXD>rɊ\=fҾkI>n7>5a&d(>2>lbF|gq=6?/>e*r|4S3¹>9zU\:~>N&
n
>Ha{ʾ 겕&>z%ig+>nP
>Wt=<7hONd>J߾>e!KM?>	c[>qʾLl=p`9; >B=ؕڌZ	X>p.b?þ&gڄ;>j܌P?Ln8#>jeƾ&7>?.>lֽZ&\ JK>={~aRx> nA>
`j s՞">=^X+>]8

'^G=mt+t>ksE9R.½UU>8P{Dֱ-+Bs>;G
=sUAL|">@8ɾy 4=>ɷnZK)9C>pT=={Wȝ>g
>Ie	Ͼ߱>k{>M"jT}1&>OpMe'Q>r}9$z>]߽}<`(/Ye>oJ1b=A:20>#6>*dUf4>_i;9D>el|¾yZ+q>
t?.>g?X=?>x=GĐI>M햾MĽ\rTQ>I9ԓI~q	GSd>ȃ{2<$mҾAՆ>/IgُAS\ib>Mŕl=y@ۯ1i>5>P9۾LHc>
>NCt8a~R+=%ϧ>hKڐR=ym6>Leއ9}2-U>&o	lBy
Ru4S>37|]8c>zW!ds[)>Z%=nո%g_>up>qꧦO@>
zP>Х
A2=
rf>VD?ȹ'>?޺$o>H	s?/Oac>wGse@8>RXcA|?5ގ>1d	{Y.HL`邔->9`>=kWd9\e>/>/A$8eeQ>?a&>Y%47G= 5->:Lj _>eˣ?'qpٵ>`;
ɲ$^Z>b<%~p-j> L=ś*v>>mrMگ>(*">GwԾVZ> ٶv>%tU^8=FٓK>Ծ>f1u>
N+#:x"l>sş!OfB2?>dy4IB>L=1ۡ@poŘ>>>ǂR.q>
F8>!Hi]!I=VJ'>Wf.wj{$>霨LZZB:C.>{iy\cHη>Eeɾ9	v<m>
e`ｹpkugH3j>P=c}j5#fy>>>
,'bA^e>h->]sK+P]=>&lOXD/!c>kxrMXwn	ay>eܾN3>l,HC_kC>S=a
Cx¾^L*F>@\>aĒ.=w>
wR_P>Sf怡G\=_A>JpL@u>CM[x1>NFfRK\\%4C	>r*s
"o>$W6 r׾&D̹>tu=ek/>*h}x>+~5NJ>/C+>5&:AˢW=?KPB>^lU_S
d>Xr o,DiR d>7殡t'EA8>[N&=`a̾2>N'y>mSMKC}]>@!>H-<n=|!>t+"={,>ӁF)d
S>6|5un>{h?H>YB	Et>7j,=B^Fݧ{ʯ>p7O>
(6b:L՗r>E4bUQ$=p3<>78$ܽR>IX	wko>Z=
fk7VP>ֈl9)s?zx>#1y=ߛnɍD8>Ki>{~jm
~Kn>#><>*rYU7\=
kWl>NžϽ$ :i>QYnƤ>?U򠾾
}r>w"׾tDz>{-_ۿ9CT>,r=@*=>Wm/WdqgB>q0Y1p>+ED._4=+\>8\A܂>s1J|KJ%Nq>?s	'Dݾ!#Gt6>Ėt
A=YA`>{=
e3>tŵ>Kn(><7>zZk"_=߭iǗ>:aBuʿdM>KF]] e>bN[ףo_->WJB&>+Da
ŋwqAP>.2=sO G4M>2"`">
\_[&K$>6-/N=i>؞߾h".*oL>2|[٭3
`I_i>D9|kzC>KPG`
3ɾ51()>wD{={]B	 >7\!@>R	W>
"">E*y4]SJ=ۅ?G{>)o0<1䫟v z>7hˢhЫ'>
Y,iIxr>xʯ%ͽo=/@q>n=)n	ѾTp8N>VEa>^^g'>^Fh;>=\P){A>]DX>MJ*#=E׆>~Lؾ䱮OgfE>.B[y_U|>}-h:yñSROx>oE&݌Ҿ9F>=2?`>q2>sa\pYn˨> s/>PgӷKW=Wm>`Nu߾2F;>4XDN$]z­6	r)V>K؊˗=J!sD;>s/-.&>E~O=렏W%*piv>(xw>D3a5>N>>C$lNYM=mN&>L-[E(,vf>U}:t6TF8>c2
jn1.}u>jXy*U F>TiE=zھ=H>]%>q6>`@Y>\R9>!$,;޾S|n@p>q:Z>@}^!fj=#N,
>HkTfb=~>/(kcaľ"I^q>zl˾ATi΀ʹ>:o4)~4G>=E3>ؾӘz>ǯ̾^%̦>s>Kݍ	/Iƻ=I>^bؾK_Bδ=>[þ!CD	>[dZ#>Y'ԎV12þ`>=Ir[gA>R>!ls}g>	P)>hgE=G,>R,P2k(3[w>Sa[r >
Ǯо#ܑy~>Ghy>N`B=`
R<)KZ>HY24>۷
H>
塚ڗ>(:$J=VvB'>?-4"d>e9>7Q?XC>_ݸT9'+(`.>OSW]+R,{w>oݻȣ_Y>`
X=(8Hg>1f>Kq>)>>>>o~=$N>TIXY8 =>	2䩈Ͼ{sTg%c>qv"I?>6ʽ≵bJQIx>J=Wsc
+]>D;>|ٽP>g	Gŗ>:]:j=C1>_9Dcl*1>˾ƀ)	`@B>;*e(ǨM7>fR޽g[ߗŽ`>߸m=1¾S
6>ND>)-sB,p$>	h>YȠ4=>Q>\m'NIe~d?l!ھ>e˺c!Л9C;>JYsg+ic>DA
/kin)>k#0=T6n4la4 w>D%>[jYq>Yۤ>i+ҾI=oȓ>PsJX7nT>nʗS|,ntwqT>r3rox4ѱ>3vhJA+:@^R>,.=_ƾBw>.>6>%FDXP\>9>憳2Th>oq>@f|+/_=9h>îܠKhVM-G>8^b~X\n>n8zzEM7>_i=JdU0j6F>5_6D=7RC>Ag˶>
V6ղsI>n:>-|=޸^>ɴw"ڮ=>,tߘ)Ӿ>ܾ^mӵ>vW]d%בGfHV>ma=4v/"„.>u$76a>
'о&4>[>ӚQ>B_+(;=)Y'>REѪit[}4>)e$c/@u	g8rR]>6gN|kXP>^
sg~-z]9>}ry=]|ٹblUd>>!aIkβS>	Oyt>]5:Fp= "d>yIMNaZ>-9e	/nKh0>`L<
3's߾V?^>@ʽŗVܾ0@,>ǙU=j;
"˾h>\5<>/9>z>op>ϗd.}!=R"L>otZ#ѽG
G8<>M^rѾwPA0>Rm5rʊY>(BýZm>>jB݌=/[%1_*>mfF>Iz;ՏG>
0z|>"ml=.!;V>žK(͈>J}[Ο<3ɾ$Ws)>ht׾i:\ii><'oG|X$;>edX=
% q><@>뿋gUˎQQ}>8j>zRu>˥
>J<4/
_mk=x\>Ex4lR69>?ʼnL&oMmԾ5ِ>e͗}sү;>?2vĸpbp;i>woX=S(lFV>ݲ>$hxuo>%We>!FuPb=՗4$Mb>T}KiN^1	~">*OؾT{J
7l2u>E=K- Y>lO:ڬc>=M
Z>Ιw{%>M޵wϾO;>{(+>Fka%= 1>PI@1>ְn'"AciTd>RQsP'>ySP'x|k,7q(>8S!=^@e>tm6:>
%U7	†>ώa;>_+H'M
=>WD	:Cmv	>ȴ~!	Vq>V(ܻ=Q.[>K4Կ׾8VX>z=5H4yj>E[s>Ӭ;k?Io"\>;k>d]luOn_C=2˧R=>؇A6IZ	֝u>XYŬk|W>Aa3h	[ljhG>T`*~w4tm5>>~j=9BZ6#
>pTz>/:h?G9>
&b9>Q<ܾʠ]z=Ӱ>Zm9X?w"Wʽ:>	$CWDѾd>#
z/(`:>h}a6W+>_=n-kM>0>d'u,O>>Qgǘ=k\J(>u:\iRh	y*>ퟕܲPr뎾ؒ8>a)*>967-M=#Ku>h[=]~SGL>$_JI>lV>
w!?x>fRо	&t=#j?>a,KC2]->AJjҊ[)
y?>z+[<
+$i}$s>q˽%&2>pSؖf=~G)N_}#>ˁ>pu&ŭ~>h>W-^k4G=JTo>.Li>9ޕMvq>e"!lFоwdASE`><1惄@>-ZR=
̊.>-^_v>7jݾYjY>BK>):KLi>wtM>o+h̜n*`Epa+>w>`jL	2^:>L" f"}>W0'2n3ig>
'C*>tQ4
=C>>֒>m TI5> eSG2cNey>o'>=4x=}ϲ>+
%sUa(T>09rSwMep	f>mxLG@m>V%!ټXjWU{>)Z=4c!2BV>'0B>
12zw:>J>^4w/"=ռ`Ӎ>TDIY5(Ɩl>
 ePCBa
dbƒq>~׈!*IPdHkP>|:_V9.B>|O=?@PU7">^3t>!2_9>VED>8کx=i*>^\KZRAGD>ܾǥx;D>Ҳ2Z{q>yR[㓇n{->ݶ#d=1kޑ<>f>\ 6"rz->j1l>ӋZp6G=Fp>]Ŀ0ͼZ>̚)C͛J1n5q>tPf,>VWˁ'H>6S=B>|H>
bO>Y>3wmOTcM&=tuGw>s~\bsd>N햾
C"B>%NY	cd=xQ>)
	ӽ;~[( >ua=;ku>ĭH0>
xvWf>ѷa>ר'$Z==>\3H85b.Žy>V +If^+)>"($>b<%~p-j> L=ś*v>>mrMگ>(*">GwԾVZ> ٶv>%tU^8=FٓK>Ծ>f1u>
N+#:x"l>sş!OfB2?>dy4IB>L=1ۡ@poŘ>>>ǂR.q>
F8>!Hi]!I=VJ'>Wf.wj{$>霨LZZB:C.>{iy\cHη>Eeɾ9	v<m>
e`ｹpkugH3j>P=c}j5#fy>>>
,'bA^e>h->]sK+P]=>&lOXD/!c>kxrMXwn	ay>eܾN3>l,HC_kC>S=a
Cx¾^L*F>@\>aĒ.=w>
wR_P>Sf怡G\=_A>JpL@u>CM[x1>NFfRK\\%4C	>r*s
"o>$W6 r׾&D̹>tu=ek/>*h}x>+~5NJ>/C+>5&:AˢW=?KPB>^lU_S
d>Xr o,DiR d>7殡t'EA8>[N&=`a̾2>N'y>mSMKC}]>@!>H-<n=|!>t+"={,>ӁF)d
S>6|5un>{h?H>YB	Et>7j,=B^Fݧ{ʯ>p7O>
(6b:L՗r>E4bUQ$=p3<>78$ܽR>IX	wko>Z=
fk7VP>ֈl9)s?zx>#1y=ߛnɍD8>Ki>{~jm
~Kn>#><>*rYU7\=
kWl>NžϽ$ :i>QYnƤ>?U򠾾
}r>w"׾tDz>{-_ۿ9CT>,r=@*=>Wm/WdqgB>q0Y1p>+ED._4=+\>8\A܂>s1J|KJ%Nq>?s	'Dݾ!#Gt6>Ėt
A=YA`>{=
e3>tŵ>Kn(><7>zZk"_=߭iǗ>:aBuʿdM>KF]] e>bN[ףo_->WJB&>+Da
ŋwqAP>.2=sO G4M>2"`">
\_[&K$>6-/N=i>؞߾h".*oL>2|[٭3
`I_i>D9|kzC>KPG`
3ɾ51()>wD{={]B	 >7\!@>R	W>
"">E*y4]SJ=ۅ?G{>)o0<1䫟v z>7hˢhЫ'>
Y,iIxr>xʯ%ͽo=/@q>n=)n	ѾTp8N>VEa>^^g'>^Fh;>=\P){A>]DX>MJ*#=E׆>~Lؾ䱮OgfE>.B[y_U|>}-h:yñSROx>oE&݌Ҿ9F>=2?`>q2>sa\pYn˨> s/>PgӷKW=Wm>`Nu߾2F;>4XDN$]z­6	r)V>K؊˗=J!sD;>s/-.&>E~O=렏W%*piv>(xw>D3a5>N>>C$lNYM=mN&>L-[E(,vf>U}:t6TF8>c2
jn1.}u>jXy*U F>TiE=zھ=H>]%>q6>`@Y>\R9>!$,;޾S|n@p>q:Z>@}^!fj=#N,
>HkTfb=~>/(kcaľ"I^q>zl˾ATi΀ʹ>:o4)~4G>=E3>ؾӘz>ǯ̾^%̦>s>Kݍ	/Iƻ=I>^bؾK_Bδ=>[þ!CD	>[dZ#>Y'ԎV12þ`>=Ir[gA>R>!ls}g>	P)>hgE=G,>R,P2k(3[w>Sa[r >
Ǯо#ܑy~>Ghy>N`B=`
R<)KZ>HY24>۷
H>
塚ڗ>(:$J=VvB'>?-4"d>e9>7Q?XC>_ݸT9'+(`.>OSW]+R,{w>oݻȣ_Y>`
X=(8Hg>1f>Kq>)>>>>o~=$N>TIXY8 =>	2䩈Ͼ{sTg%c>qv"I?>6ʽ≵bJQIx>J=Wsc
+]>D;>|ٽP>g	Gŗ>:]:j=C1>_9Dcl*1>˾ƀ)	`@B>;*e(ǨM7>fR޽g[ߗŽ`>߸m=1¾S
6>ND>)-sB,p$>	h>YȠ4=>Q>\m'NIe~d?l!ھ>e˺c!Л9C;>JYsg+ic>DA
/kin)>k#0=T6n4la4 w>D%>[jYq>Yۤ>i+ҾI=oȓ>PsJX7nT>nʗS|,ntwqT>r3rox4ѱ>3vhJA+:@^R>,.=_ƾBw>.>6>%FDXP\>9>憳2Th>oq>@f|+/_=9h>îܠKhVM-G>8^b~X\n>n8zzEM7>_i=JdU0j6F>5_6D=7RC>Ag˶>
V6ղsI>n:>-|=޸^>ɴw"ڮ=>,tߘ)Ӿ>ܾ^mӵ>vW]d%בGfHV>ma=4v/"„.>u$76a>
'о&4>[>ӚQ>B_+(;=)Y'>REѪit[}4>)e$c/@u	g8rR]>6gN|kXP>^
sg~-z]9>}ry=]|ٹblUd>>!aIkβS>	Oyt>]5:Fp= "d>yIMNaZ>-9e	/nKh0>`L<
3's߾V?^>@ʽŗVܾ0@,>ǙU=j;
"˾h>\5<>/9>z>op>ϗd.}!=R"L>otZ#ѽG
G8<>M^rѾwPA0>Rm5rʊY>(BýZm>>jB݌=/[%1_*>mfF>Iz;ՏG>
0z|>"ml=.!;V>žK(͈>J}[Ο<3ɾ$Ws)>ht׾i:\ii><'oG|X$;>edX=
% q><@>뿋gUˎQQ}>8j>zRu>˥
>J<4/
_mk=x\>Ex4lR69>?ʼnL&oMmԾ5ِ>e͗}sү;>?2vĸpbp;i>woX=S(lFV>ݲ>$hxuo>%We>!FuPb=՗4$Mb>T}KiN^1	~">*OؾT{J
7l2u>E=K- Y>lO:ڬc>=M
Z>Ιw{%>M޵wϾO;>{(+>Fka%= 1>PI@1>ְn'"AciTd>RQsP'>ySP'x|k,7q(>8S!=^@e>tm6:>
%U7	†>ώa;>_+H'M
=>WD	:Cmv	>ȴ~!	Vq>V(ܻ=Q.[>K4Կ׾8VX>z=5H4yj>E[s>Ӭ;k?Io"\>;k>d]luOn_C=2˧R=>؇A6IZ	֝u>XYŬk|W>Aa3h	[ljhG>T`*~w4tm5>>~j=9BZ6#
>pTz>/:h?G9>
&b9>Q<ܾʠ]z=Ӱ>Zm9X?w"Wʽ:>	$CWDѾd>#
z/(`:>h}a6W+>_=n-kM>0>d'u,O>>Qgǘ=k\J(>u:\iRh	y*>ퟕܲPr뎾ؒ8>a)*>967-M=#Ku>h[=]~SGL>$_JI>lV>
w!?x>fRо	&t=#j?>a,KC2]->AJjҊ[)
y?>z+[<
+$i}$s>q˽%&2>pSؖf=~G)N_}#>ˁ>pu&ŭ~>h>W-^k4G=JTo>.Li>9ޕMvq>e"!lFоwdASE`><1惄@>-ZR=
̊.>-^_v>7jݾYjY>BK>):KLi>wtM>o+h̜n*`Epa+>w>`jL	2^:>L" f"}>W0'2n3ig>
'C*>tQ4
=C>>֒>m TI5> eSG2cNey>o'>=4x=}ϲ>+
%sUa(T>09rSwMep	f>mxLG@m>V%!ټXjWU{>)Z=4c!2BV>'0B>
12zw:>J>^4w/"=ռ`Ӎ>TDIY5(Ɩl>
 ePCBa
dbƒq>~׈!*IPdHkP>|:_V9.B>|O=?@PU7">^3t>!2_9>VED>8کx=i*>^\KZRAGD>ܾǥx;D>Ҳ2Z{q>yR[㓇n{->ݶ#d=1kޑ<>f>\ 6"rz->j1l>ӋZp6G=Fp>]Ŀ0ͼZ>̚)C͛J1n5q>tPf,>VWˁ'H>6S=B>|H>
bO>Y>3wmOTcM&=tuGw>s~\bsd>N햾
C"B>%NY	cd=xQ>)
	ӽ;~[( >ua=;ku>ĭH0>
xvWf>ѷa>ר'$Z==>\3H85b.Žy>V +If^+)>"($>b<%~p-j> L=ś*v>>mrMگ>(*">GwԾVZ> ٶv>%tU^8=FٓK>Ծ>f1u>
N+#:x"l>sş!OfB2?>dy4IB>L=1ۡ@poŘ>>>ǂR.q>
F8>!Hi]!I=VJ'>Wf.wj{$>霨LZZB:C.>{iy\cHη>Eeɾ9	v<m>
e`ｹpkugH3j>P=c}j5#fy>>>
,'bA^e>h->]sK+P]=>&lOXD/!c>kxrMXwn	ay>eܾN3>l,HC_kC>S=a
Cx¾^L*F>@\>aĒ.=w>
wR_P>Sf怡G\=_A>JpL@u>CM[x1>NFfRK\\%4C	>r*s
"o>$W6 r׾&D̹>tu=ek/>*h}x>+~5NJ>/C+>5&:AˢW=?KPB>^lU_S
d>Xr o,DiR d>7殡t'EA8>[N&=`a̾2>N'y>mSMKC}]>@!>H-<n=|!>t+"={,>ӁF)d
S>6|5un>{h?H>YB	Et>7j,=B^Fݧ{ʯ>p7O>
(6b:L՗r>E4bUQ$=p3<>78$ܽR>IX	wko>Z=
fk7VP>ֈl9)s?zx>#1y=ߛnɍD8>Ki>{~jm
~Kn>#><>*rYU7\=
kWl>NžϽ$ :i>QYnƤ>?U򠾾
}r>w"׾tDz>{-_ۿ9CT>,r=@*=>Wm/WdqgB>q0Y1p>+ED._4=+\>8\A܂>s1J|KJ%Nq>?s	'Dݾ!#Gt6>Ėt
A=YA`>{=
e3>tŵ>Kn(><7>zZk"_=߭iǗ>:aBuʿdM>KF]] e>bN[ףo_->WJB&>+Da
ŋwqAP>.2=sO G4M>2"`">
\_[&K$>6-/N=i>؞߾h".*oL>2|[٭3
`I_i>D9|kzC>KPG`
3ɾ51()>wD{={]B	 >7\!@>R	W>
"">E*y4]SJ=ۅ?G{>)o0<1䫟v z>7hˢhЫ'>
Y,iIxr>xʯ%ͽo=/@q>n=)n	ѾTp8N>VEa>^^g'>^Fh;>=\P){A>]DX>MJ*#=E׆>~Lؾ䱮OgfE>.B[y_U|>}-h:yñSROx>oE&݌Ҿ9F>=2?`>q2>sa\pYn˨> s/>PgӷKW=Wm>`Nu߾2F;>4XDN$]z­6	r)V>K؊˗=J!sD;>s/-.&>E~O=렏W%*piv>(xw>D3a5>N>>C$lNYM=mN&>L-[E(,vf>U}:t6TF8>c2
jn1.}u>jXy*U F>TiE=zھ=H>]%>q6>`@Y>\R9>!$,;޾S|n@p>q:Z>@}^!fj=#N,
>HkTfb=~>/(kcaľ"I^q>zl˾ATi΀ʹ>:o4)~4G>=E3>ؾӘz>ǯ̾^%̦>s>Kݍ	/Iƻ=I>^bؾK_Bδ=>[þ!CD	>[dZ#>Y'ԎV12þ`>=Ir[gA>R>!ls}g>	P)>hgE=G,>R,P2k(3[w>Sa[r >
Ǯо#ܑy~>Ghy>N`B=`
R<)KZ>HY24>۷
H>
塚ڗ>(:$J=VvB'>?-4"d>e9>7Q?XC>_ݸT9'+(`.>OSW]+R,{w>oݻȣ_Y>`
X=(8Hg>1f>Kq>)>>>>o~=$N>TIXY8 =>	2䩈Ͼ{sTg%c>qv"I?>6ʽ≵bJQIx>J=Wsc
+]>D;>|ٽP>g	Gŗ>:]:j=C1>_9Dcl*1>˾ƀ)	`@B>;*e(ǨM7>fR޽g[ߗŽ`>߸m=1¾S
6>ND>)-sB,p$>	h>YȠ4=>Q>\m'NIe~d?l!ھ>e˺c!Л9C;>JYsg+ic>DA
/kin)>k#0=T6n4la4 w>D%>[jYq>Yۤ>i+ҾI=oȓ>PsJX7nT>nʗS|,ntwqT>r3rox4ѱ>3vhJA+:@^R>,.=_ƾBw>.>6>%FDXP\>9>憳2Th>oq>@f|+/_=9h>îܠKhVM-G>8^b~X\n>n8zzEM7>_i=JdU0j6F>5_6D=7RC>Ag˶>
V6ղsI>n:>-|=޸^>ɴw"ڮ=>,tߘ)Ӿ>ܾ^mӵ>vW]d%בGfHV>ma=4v/"„.>u$76a>
'о&4>[>ӚQ>B_+(;=)Y'>REѪit[}4>)e$c/@u	g8rR]>6gN|kXP>^
sg~-z]9>}ry=]|ٹblUd>>!aIkβS>	Oyt>]5:Fp= "d>yIMNaZ>-9e	/nKh0>`L<
3's߾V?^>@ʽŗVܾ0@,>ǙU=j;
"˾h>\5<>/9>z>op>ϗd.}!=R"L>otZ#ѽG
G8<>M^rѾwPA0>Rm5rʊY>(BýZm>>jB݌=/[%1_*>mfF>Iz;ՏG>
0z|>"ml=.!;V>žK(͈>J}[Ο<3ɾ$Ws)>ht׾i:\ii><'oG|X$;>edX=
% q><@>뿋gUˎQQ}>8j>zRu>˥
>J<4/
_mk=x\>Ex4lR69>?ʼnL&oMmԾ5ِ>e͗}sү;>?2vĸpbp;i>woX=S(lFV>ݲ>$hxuo>%We>!FuPb=՗4$Mb>T}KiN^1	~">*OؾT{J
7l2u>E=K- Y>lO:ڬc>=M
Z>Ιw{%>M޵wϾO;>{(+>Fka%= 1>PI@1>ְn'"AciTd>RQsP'>ySP'x|k,7q(>8S!=^@e>tm6:>
%U7	†>ώa;>_+H'M
=>WD	:Cmv	>ȴ~!	Vq>V(ܻ=Q.[>K4Կ׾8VX>z=5H4yj>E[s>Ӭ;k?Io"\>;k>d]luOn_C=2˧R=>؇A6IZ	֝u>XYŬk|W>Aa3h	[ljhG>T`*~w4tm5>>~j=9BZ6#
>pTz>/:h?G9>
&b9>Q<ܾʠ]z=Ӱ>Zm9X?w"Wʽ:>	$CWDѾd>#
z/(`:>h}a6W+>_=n-kM>0>d'u,O>>Qgǘ=k\J(>u:\iRh	y*>ퟕܲPr뎾ؒ8>a)*>967-M=#Ku>h[=]~SGL>$_JI>lV>
w!?x>fRо	&t=#j?>a,KC2]->AJjҊ[)
y?>z+[<
+$i}$s>q˽%&2>pSؖf=~G)N_}#>ˁ>pu&ŭ~>h>W-^k4G=JTo>.Li>9ޕMvq>e"!lFоwdASE`><1惄@>-ZR=
̊.>-^_v>7jݾYjY>BK>):KLi>wtM>o+h̜n*`Epa+>w>`jL	2^:>L" f"}>W0'2n3ig>
'C*>tQ4
=C>>֒>m TI5> eSG2cNey>o'>=4x=}ϲ>+
%sUa(T>09rSwMep	f>mxLG@m>V%!ټXjWU{>)Z=4c!2BV>'0B>
12zw:>J>^4w/"=ռ`Ӎ>TDIY5(Ɩl>
 ePCBa
dbƒq>~׈!*IPdHkP>|:_V9.B>|O=?@PU7">^3t>!2_9>VED>8کx=i*>^\KZRAGD>ܾǥx;D>Ҳ2Z{q>yR[㓇n{->ݶ#d=1kޑ<>f>\ 6"rz->j1l>ӋZp6G=Fp>]Ŀ0ͼZ>̚)C͛J1n5q>tPf,>VWˁ'H>6S=B>|H>
bO>Y>3wmOTcM&=tuGw>s~\bsd>N햾
C"B>%NY	cd=xQ>)
	ӽ;~[( >ua=;ku>ĭH0>
xvWf>ѷa>ר'$Z==>\3H85b.Žy>V +If^+)>"($healpy-1.10.3/healpy/src/0000775000175000017500000000000013031130324015365 5ustar  zoncazonca00000000000000healpy-1.10.3/healpy/src/_common.pxd0000664000175000017500000001155613010374155017552 0ustar  zoncazonca00000000000000import numpy as np
cimport numpy as np
from libcpp cimport bool
from libcpp.vector cimport vector

ctypedef unsigned size_t
ctypedef size_t tsize

cdef extern from "stddef.h":
    ctypedef long ptrdiff_t
ctypedef ptrdiff_t tdiff

cdef extern from "datatypes.h":
    ctypedef int int64

cdef extern from "xcomplex.h":
    cdef cppclass xcomplex[T]:
       T re, im

cdef extern from "arr.h":    
    cdef cppclass arr[T]:
        arr()
        arr(T *ptr, tsize sz)
        void allocAndFill (tsize sz, T &inival)
        tsize size()
        T &operator[] (tsize n)
    cdef cppclass fix_arr[T, int]:
        pass

cdef extern from "rangeset.h":
    cdef cppclass rangeset[T]:
        tsize size()
        int64 nval()
        T ivbegin(tdiff i)
        T ivend(tdiff i)

cdef extern from "vec3.h":
    cdef cppclass vec3:
        double x, y, z
        vec3()
        vec3(double xc, double yc, double zc)
 
cdef extern from "pointing.h":
    cdef cppclass pointing:
        pointing()
        pointing(vec3 inp)
        void normalize()
        double theta
        double phi

cdef extern from "healpix_base.h":
    ctypedef int val_4 "4"
    ctypedef int val_8 "8"
    cdef enum Healpix_Ordering_Scheme:
        RING, NEST
    cdef cppclass nside_dummy:
        pass
    cdef nside_dummy SET_NSIDE

    cdef cppclass T_Healpix_Base[I]:
       int nside2order(I nside)
       I npix2nside(I npix)
       T_Healpix_Base()
       T_Healpix_Base(int order, Healpix_Ordering_Scheme scheme)
       T_Healpix_Base(I nside, Healpix_Ordering_Scheme scheme, nside_dummy)
       void Set(int order, Healpix_Ordering_Scheme scheme)
       void SetNside(I nside, Healpix_Ordering_Scheme scheme)
       double ring2z(I ring)
       I pix2ring(I pix)
       I xyf2pix(int ix, int iy, int face_num)
       void pix2xyf(I pix, int &ix, int &iy, int &face_num)
       I nest2ring(I pix)
       I ring2nest(I pix)
       I nest2peano(I pix)
       I peano2nest(I pix)
       I zphi2pix(double z, double phi)
       I ang2pix(pointing &ang)
       I vec2pix(vec3 &vec)
       void pix2zphi(I pix, double &z, double &phi)
       pointing pix2ang(I pix)
       vec3 pix2vec(I pix)
       void get_ring_info(I ring, I &startpix, I &ringpix, double &costheta,
                          double &sintheta, bool &shifted)
       void get_ring_info2(I ring, I &startpix, I &ringpix, double &theta,
                           bool &shifted)
       void get_ring_info_small(I ring, I &startpix, I &ringpix, bool &shifted)
       void neighbors(I pix, fix_arr[I,val_8] &result)
       void get_interpol(pointing &ptg, fix_arr[I,val_4] &pix,
                         fix_arr[double,val_4] &wgt)
       int Order()
       I Nside()
       I Npix()
       Healpix_Ordering_Scheme Scheme()
       bool conformable(T_Healpix_Base &other)
       void swap(T_Healpix_Base &other)
       double max_pixrad()
       double max_pixrad(I ring)
       void boundaries(I pix, size_t step, vector[vec3] &out)
       arr[int] swap_cycles()
       void query_disc(pointing ptg, double radius, rangeset[I]& pixset) 
       void query_disc_inclusive(pointing ptg, double radius,
                                 rangeset[I]& pixset, int fact)
       void query_polygon(vector[pointing] vert, rangeset[I]& pixset) except +
       void query_polygon_inclusive(vector[pointing] vert,
                                    rangeset[I]& pixset, int fact) except +
       void query_strip(double theta1, double theta2, bool inclusive,
                        rangeset[I]& pixset)

cdef extern from "healpix_map.h":
    cdef cppclass Healpix_Map[T]:
        Healpix_Map()
        void Set(arr[T] &data, Healpix_Ordering_Scheme scheme)
        T average()
        void Add(T x)

cdef extern from "alm.h":
    cdef cppclass Alm[T]:
        Alm()
        Alm(int lmax_, int mmax_)
        void Set (int lmax_, int mmax_)
        void Set (arr[T] &data, int lmax_, int mmax_)
        tsize Num_Alms (int l, int m)

cdef inline Healpix_Map[double]* ndarray2map(np.ndarray[np.float64_t, ndim=1, mode='c'] array, Healpix_Ordering_Scheme scheme) except *:
    """ View a contiguous ndarray as a Healpix Map. """
    # To ensure that the output map is a view of the input array, the latter
    # is forced to be contiguous, of correct type and dimensions (otherwise, an
    # exception is raised).
    cdef arr[double] *a = new arr[double](&array[0], array.size)
    cdef Healpix_Map[double] *map = new Healpix_Map[double]()
    map.Set(a[0], scheme)
    del a # a does not own its buffer, so it won't be deallocated
    return map

cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:
    """ View a contiguous ndarray as an Alm. """
    cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
    cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
    alm.Set(a[0], lmax, mmax)
    del a
    return alm
healpy-1.10.3/healpy/src/_healpy_fitsio_lib.cc0000664000175000017500000000613613010374155021537 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpy.
 *
 *  Healpy is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpy is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpy; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about Healpy, see http://code.google.com/p/healpy
 */
/*

   This module provides Healpix functions to Python.

   It uses the healpix_cxx library.

*/

#include 

#include 
#include 

#include "numpy/arrayobject.h"

#include "healpix_data_io.h"
#include "arr.h"
#include "_healpy_utils.h"

/***********************************************************************
    healpy_pixwin

       input: nside, data_path, pol=False

       output: W(l), the pixel window function
*/
static PyObject *healpy_pixwin(PyObject *self, PyObject *args, PyObject *kwds)
{
  int nside;
  char * datapath=NULL;
  int polarisation = 0; /* not polarised by default */

  static const char* kwlist[] = {"","", "pol", NULL};

  if (!PyArg_ParseTupleAndKeywords(args, kwds, "is|i", (char **)kwlist,
                                   &nside, &datapath, &polarisation))
    return NULL;

  healpyAssertValue((nside&(nside-1))==0,
    "Wrong nside value (must be a power of 2, less than 2**30)");

  arr pw_temp, pw_pol;
  read_pixwin(datapath, nside, pw_temp, pw_pol);

  npy_intp szpw;

  szpw = pw_temp.size();

  PyArrayObject *pixwin_temp =
    (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&szpw, PyArray_DOUBLE);
  if( !pixwin_temp )
    return NULL;

  PyArrayObject *pixwin_pol =
    (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&szpw, PyArray_DOUBLE);
  if( !pixwin_pol )
    return NULL;

  for(int i=0; i= 3
static PyModuleDef moduledef = {
	PyModuleDef_HEAD_INIT,
	"_healpy_sph_transform_lib",
	NULL, -1, methods
};
#endif

PyMODINIT_FUNC
#if PY_MAJOR_VERSION < 3
init_healpy_fitsio_lib(void)
#else
PyInit__healpy_fitsio_lib(void)
#endif
{
  import_array();

#if PY_MAJOR_VERSION < 3
	Py_InitModule("_healpy_fitsio_lib", methods);
#else
	return PyModule_Create(&moduledef);
#endif
}
healpy-1.10.3/healpy/src/_healpy_pixel_lib.cc0000664000175000017500000004726013010374155021366 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpy.
 *
 *  Healpy is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpy is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpy; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about Healpy, see http://code.google.com/p/healpy
 */
/*

   This module provides Healpix functions to Python.
   It uses the healpix_cxx library.

*/

#include 

#include "arr.h"
#include "healpix_base.h"
#include "healpix_map.h"
#include "_healpy_utils.h"

#include "numpy/arrayobject.h"
#include "numpy/ufuncobject.h"
#include "numpy/noprefix.h"

/*
   ang2pix
*/
templatestatic void
  ufunc_ang2pix(char **args, intp *dimensions, intp *steps, void *func)
{
  intp n=dimensions[0];

  intp is1=steps[0],is2=steps[1],is3=steps[2], os=steps[3];
  char *ip1=args[0], *ip2=args[1], *ip3=args[2], *op=args[3];

  Healpix_Base2 hb;
  long oldnside=-1;

  for(intp i=0; i static void
  ufunc_pix2ang(char **args, intp *dimensions, intp *steps, void *func)
{
  register intp i, n=dimensions[0];
  register intp is1=steps[0],is2=steps[1],os1=steps[2],os2=steps[3];
  char *ip1=args[0], *ip2=args[1], *op1=args[2], *op2=args[3];

  Healpix_Base2 hb;
  long oldnside=-1;

  for(i=0; istatic void
  ufunc_xyf2pix(char **args, intp *dimensions, intp *steps, void *func)
{
  intp n=dimensions[0];

  intp is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3], os=steps[4];
  char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *op=args[4];

  Healpix_Base2 hb;
  long oldnside=-1;

  for(intp i=0; i static void
  ufunc_pix2xyf(char **args, intp *dimensions, intp *steps, void *func)
{
  register intp i, n=dimensions[0];
  register intp is1=steps[0],is2=steps[1],os1=steps[2],os2=steps[3],os3=steps[4];
  char *ip1=args[0], *ip2=args[1], *op1=args[2], *op2=args[3], *op3=args[4];

  Healpix_Base2 hb;
  long oldnside=-1;

  for(i=0; i static void
  ufunc_pix2vec(char **args, intp *dimensions, intp *steps, void *func)
{
  register intp i, n=dimensions[0];
  register intp is1=steps[0],is2=steps[1],os1=steps[2],os2=steps[3],os3=steps[4];
  char *ip1=args[0], *ip2=args[1], *op1=args[2], *op2=args[3], *op3=args[4];

  Healpix_Base2 hb;
  long oldnside=-1;

  for(i=0; i static void
  ufunc_vec2pix(char **args, intp *dimensions, intp *steps, void *func)
{
  register intp i, n=dimensions[0];
  register intp is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os1=steps[4];
  char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *op1=args[4];

  Healpix_Base2 hb;
  long oldnside=-1;

  for(i=0; i static void
  ufunc_get_interpol(char **args, intp *dimensions, intp *steps, void *func)
{
  register intp i, n=dimensions[0];
  register intp is1=steps[0],is2=steps[1],is3=steps[2],
    os1=steps[3],os2=steps[4],os3=steps[5],os4=steps[6],
    os5=steps[7],os6=steps[8],os7=steps[9],os8=steps[10];
  char *ip1=args[0], *ip2=args[1], *ip3=args[2],
    *op1=args[3],*op2=args[4],*op3=args[5],*op4=args[6],
    *op5=args[7],*op6=args[8],*op7=args[9],*op8=args[10];

  Healpix_Base2 hb;
  long oldnside=-1;

  for(i=0; i pix;
      fix_arr wgt;
      long nside = *(long*)ip1;
      if (nside!=oldnside)
        { oldnside=nside; hb.SetNside(nside, scheme); }
      try {
        pointing ptg = pointing(*(double*)ip2, *(double*)ip3);
        ptg.normalize();
        hb.get_interpol(ptg, pix, wgt);
        *(long*)op1 = (long)pix[0];
        *(long*)op2 = (long)pix[1];
        *(long*)op3 = (long)pix[2];
        *(long*)op4 = (long)pix[3];
        *(double*)op5 = wgt[0];
        *(double*)op6 = wgt[1];
        *(double*)op7 = wgt[2];
        *(double*)op8 = wgt[3];
      } catch (PlanckError &e) {
        *(long*)op1 = -1;
        *(long*)op2 = -1;
        *(long*)op3 = -1;
        *(long*)op4 = -1;
        *(double*)op5 = NAN;
        *(double*)op6 = NAN;
        *(double*)op7 = NAN;
        *(double*)op8 = NAN;
      }
    }
}


/*
  get_neighbors
*/
template static void
  ufunc_get_neighbors(char **args, intp *dimensions, intp *steps, void *func)
{
  register intp i, n=dimensions[0];
  register intp is1=steps[0],is2=steps[1],
    os1=steps[2],os2=steps[3],os3=steps[4],os4=steps[5],
    os5=steps[6],os6=steps[7],os7=steps[8],os8=steps[9];
  char *ip1=args[0], *ip2=args[1],
    *op1=args[2],*op2=args[3],*op3=args[4],*op4=args[5],
    *op5=args[6],*op6=args[7],*op7=args[8],*op8=args[9];

  Healpix_Base2 hb;
  for(i=0; i pix;
      hb.SetNside(*(long*)ip1, scheme);
      try {
        hb.neighbors(*(long*)ip2, pix);
        *(long*)op1 = (long)pix[0];
        *(long*)op2 = (long)pix[1];
        *(long*)op3 = (long)pix[2];
        *(long*)op4 = (long)pix[3];
        *(long*)op5 = (long)pix[4];
        *(long*)op6 = (long)pix[5];
        *(long*)op7 = (long)pix[6];
        *(long*)op8 = (long)pix[7];
      } catch (PlanckError & e) {
        *(long*)op1 = -1;
        *(long*)op2 = -1;
        *(long*)op3 = -1;
        *(long*)op4 = -1;
        *(long*)op5 = -1;
        *(long*)op6 = -1;
        *(long*)op7 = -1;
        *(long*)op8 = -1;
      }
    }
}

/*
  max_pixrad
*/
static void
  ufunc_max_pixrad(char **args, intp *dimensions, intp *steps, void *func)
{
  register intp i, n=dimensions[0];
  register intp is1=steps[0],os1=steps[1];
  char *ip1=args[0], *op1=args[1];

  Healpix_Base2 hb;
  long oldnside=-1;

  for(i=0; inest swapping, etc.\n"
  "\n"
  "Available ufunc: _ang2pix_ring, _ang2pix_nest, _pix2ang_ring,\n"
  "                 _pix2ang_nest, _ring2nest, _nest2ring,\n"
  "                 _get_interpol_ring, _get_interpol_nest.");

/* to define the ufunc */
static PyUFuncGenericFunction ang2pix_ring_functions[] = {
  ufunc_ang2pix
};
static PyUFuncGenericFunction ang2pix_nest_functions[] = {
  ufunc_ang2pix
};
static PyUFuncGenericFunction pix2ang_ring_functions[] = {
  ufunc_pix2ang
};
static PyUFuncGenericFunction pix2ang_nest_functions[] = {
  ufunc_pix2ang
};
static PyUFuncGenericFunction xyf2pix_ring_functions[] = {
  ufunc_xyf2pix
};
static PyUFuncGenericFunction xyf2pix_nest_functions[] = {
  ufunc_xyf2pix
};
static PyUFuncGenericFunction pix2xyf_ring_functions[] = {
  ufunc_pix2xyf
};
static PyUFuncGenericFunction pix2xyf_nest_functions[] = {
  ufunc_pix2xyf
};
static PyUFuncGenericFunction vec2pix_ring_functions[] = {
  ufunc_vec2pix
};
static PyUFuncGenericFunction vec2pix_nest_functions[] = {
  ufunc_vec2pix
};
static PyUFuncGenericFunction pix2vec_ring_functions[] = {
  ufunc_pix2vec
};
static PyUFuncGenericFunction pix2vec_nest_functions[] = {
  ufunc_pix2vec
};
static PyUFuncGenericFunction ring2nest_functions[] = {
  ufunc_ring2nest
};
static PyUFuncGenericFunction nest2ring_functions[] = {
  ufunc_nest2ring
};
static PyUFuncGenericFunction get_interpol_ring_functions[] = {
  ufunc_get_interpol
};
static PyUFuncGenericFunction get_interpol_nest_functions[] = {
  ufunc_get_interpol
};
static PyUFuncGenericFunction get_neighbors_ring_functions[] = {
  ufunc_get_neighbors
};
static PyUFuncGenericFunction get_neighbors_nest_functions[] = {
  ufunc_get_neighbors
};
static PyUFuncGenericFunction max_pixrad_functions[] = {
  ufunc_max_pixrad
};


static void * blank_data[] = { (void *)NULL };

static char ang2pix_signatures[] = {
  PyArray_LONG, PyArray_DOUBLE, PyArray_DOUBLE, PyArray_LONG
};
static char pix2ang_signatures[] = {
  PyArray_LONG, PyArray_LONG, PyArray_DOUBLE, PyArray_DOUBLE
};
static char xyf2pix_signatures[] = {
  PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG
};
static char pix2xyf_signatures[] = {
  PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG
};
static char pix2vec_signatures[] = {
  PyArray_LONG, PyArray_LONG, PyArray_DOUBLE, PyArray_DOUBLE, PyArray_DOUBLE
};
static char vec2pix_signatures[] = {
  PyArray_LONG, PyArray_DOUBLE, PyArray_DOUBLE, PyArray_DOUBLE, PyArray_LONG
};
static char ring2nest_signatures[] = {
  PyArray_LONG, PyArray_LONG, PyArray_LONG
};
static char get_interpol_signatures[] = {
  PyArray_LONG, PyArray_DOUBLE, PyArray_DOUBLE,
  PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG,
  PyArray_DOUBLE, PyArray_DOUBLE, PyArray_DOUBLE, PyArray_DOUBLE
};
static char get_neighbors_ring_signatures[] = {
  PyArray_LONG, PyArray_LONG, // input
  PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG, // output
  PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG // output
};
static char get_neighbors_nest_signatures[] = {
  PyArray_LONG, PyArray_LONG, // input
  PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG, // output
  PyArray_LONG, PyArray_LONG, PyArray_LONG, PyArray_LONG // output
};
static char max_pixrad_signatures[] = {
  PyArray_LONG, PyArray_DOUBLE  
};

#if PY_MAJOR_VERSION >= 3
static PyModuleDef moduledef = {
  PyModuleDef_HEAD_INIT,
  "_healpy_pixel_lib",
  NULL, -1, NULL
};
#endif

#if PY_MAJOR_VERSION < 3
#define FREE_MODULE_AND_FAIL do { return; } while(0)
#else
#define FREE_MODULE_AND_FAIL do { Py_DECREF(m); return NULL; } while(0)
#endif

PyMODINIT_FUNC
#if PY_MAJOR_VERSION < 3
init_healpy_pixel_lib(void)
#else
PyInit__healpy_pixel_lib(void)
#endif
{
  PyObject *m;

  import_array();
  import_ufunc();

#if PY_MAJOR_VERSION < 3
  m = Py_InitModule3("_healpy_pixel_lib", NULL, docstring);
	if (!m) return;
#else
	m = PyModule_Create(&moduledef);
	if (!m) return NULL;
#endif

  if (PyModule_AddObject(m, "_ang2pix_ring", PyUFunc_FromFuncAndData(
      ang2pix_ring_functions, blank_data,
      ang2pix_signatures, 1,
      3, 1, PyUFunc_None, CP_("_ang2pix_ring"),
      CP_("nside,theta,phi [rad] -> ipix (RING)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_ang2pix_nest", PyUFunc_FromFuncAndData(
      ang2pix_nest_functions, blank_data,
      ang2pix_signatures, 1,
      3, 1, PyUFunc_None, CP_("_ang2pix_nest"),
      CP_("nside,theta,phi [rad] -> ipix (NEST)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_pix2ang_ring", PyUFunc_FromFuncAndData(
      pix2ang_ring_functions, blank_data,
      pix2ang_signatures, 1,
      2, 2, PyUFunc_None, CP_("_pix2ang_ring"),
      CP_("nside,ipix -> theta,phi [rad] (RING)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_pix2ang_nest", PyUFunc_FromFuncAndData(
      pix2ang_nest_functions, blank_data,
      pix2ang_signatures, 1,
      2, 2, PyUFunc_None, CP_("_pix2ang_nest"),
      CP_("nside,ipix -> theta,phi [rad] (NEST)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  //=========

  if (PyModule_AddObject(m, "_xyf2pix_ring", PyUFunc_FromFuncAndData(
      xyf2pix_ring_functions, blank_data,
      xyf2pix_signatures, 1,
      4, 1, PyUFunc_None, CP_("_xyf2pix_ring"),
      CP_("nside,x,y,face -> ipix (RING)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_xyf2pix_nest", PyUFunc_FromFuncAndData(
      xyf2pix_nest_functions, blank_data,
      xyf2pix_signatures, 1,
      4, 1, PyUFunc_None, CP_("_xyf2pix_nest"),
      CP_("nside,x,y,face -> ipix (NEST)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_pix2xyf_ring", PyUFunc_FromFuncAndData(
      pix2xyf_ring_functions, blank_data,
      pix2xyf_signatures, 1,
      2, 3, PyUFunc_None, CP_("_pix2xyf_ring"),
      CP_("nside,ipix -> x,y,face (RING)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_pix2xyf_nest", PyUFunc_FromFuncAndData(
      pix2xyf_nest_functions, blank_data,
      pix2xyf_signatures, 1,
      2, 3, PyUFunc_None, CP_("_pix2xyf_nest"),
      CP_("nside,ipix -> x,y,face (NEST)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  //=========

  if (PyModule_AddObject(m, "_vec2pix_ring", PyUFunc_FromFuncAndData(
      vec2pix_ring_functions, blank_data,
      vec2pix_signatures, 1,
      4, 1, PyUFunc_None, CP_("_vec2pix_ring"),
      CP_("nside,x,y,z -> ipix (RING)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_vec2pix_nest", PyUFunc_FromFuncAndData(
      vec2pix_nest_functions, blank_data,
      vec2pix_signatures, 1,
      4, 1, PyUFunc_None, CP_("_vec2pix_nest"),
      CP_("nside,x,y,z -> ipix (NEST)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_pix2vec_ring", PyUFunc_FromFuncAndData(
      pix2vec_ring_functions, blank_data,
      pix2vec_signatures, 1,
      2, 3, PyUFunc_None, CP_("_pix2vec_ring"),
      CP_("nside,ipix -> x,y,z (RING)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_pix2vec_nest", PyUFunc_FromFuncAndData(
      pix2vec_nest_functions, blank_data,
      pix2vec_signatures, 1,
      2, 3, PyUFunc_None, CP_("_pix2vec_nest"),
      CP_("nside,ipix -> x,y,z (NEST)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  //=============

  if (PyModule_AddObject(m, "_ring2nest", PyUFunc_FromFuncAndData(
      ring2nest_functions, blank_data,
      ring2nest_signatures, 1,
      2, 1, PyUFunc_None, CP_("_ring2nest"),
      CP_("ipix(ring) -> ipix(nest)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_nest2ring", PyUFunc_FromFuncAndData(
      nest2ring_functions, blank_data,
      ring2nest_signatures, 1,
      2, 1, PyUFunc_None, CP_("_nest2ring"),
      CP_("ipix(nest) -> ipix(ring)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_get_interpol_ring", PyUFunc_FromFuncAndData(
      get_interpol_ring_functions, blank_data,
      get_interpol_signatures, 1,
      3, 8, PyUFunc_None, CP_("_get_interpol_ring"),
      CP_("nside,theta,phi->4 nearest pixels+4weights"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_get_interpol_nest", PyUFunc_FromFuncAndData(
      get_interpol_nest_functions, blank_data,
      get_interpol_signatures, 1,
      3, 8, PyUFunc_None, CP_("_get_interpol_nest"),
      CP_("nside,theta,phi->4 nearest pixels+4weights"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_get_neighbors_ring", PyUFunc_FromFuncAndData(
      get_neighbors_ring_functions, blank_data,
      get_neighbors_ring_signatures, 1,
      2, 8, PyUFunc_None, CP_("_get_neigbors_ring"),
      CP_("nside, ipix [rad] -> 8 neighbors"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "_get_neighbors_nest", PyUFunc_FromFuncAndData(
      get_neighbors_nest_functions, blank_data,
      get_neighbors_nest_signatures, 1,
      2, 8, PyUFunc_None, CP_("_get_neigbors_nest"),
      CP_("nside, ipix [rad] -> 8 neighbors"),0)) < 0)
    FREE_MODULE_AND_FAIL;


  if (PyModule_AddObject(m, "_max_pixrad", PyUFunc_FromFuncAndData(
      max_pixrad_functions, blank_data,
      max_pixrad_signatures, 1,
      1, 1, PyUFunc_None, CP_("max_pixrad"),
      CP_("nside -> max_distance to pixel corners from center)"),0)) < 0)
    FREE_MODULE_AND_FAIL;

  if (PyModule_AddObject(m, "UNSEEN", PyFloat_FromDouble(Healpix_undef)) < 0)
    FREE_MODULE_AND_FAIL;

#if PY_MAJOR_VERSION >= 3
  return m;
#endif
}
healpy-1.10.3/healpy/src/_healpy_sph_transform_lib.cc0000664000175000017500000007402413010374155023130 0ustar  zoncazonca00000000000000/*
 *  This file is part of Healpy.
 *
 *  Healpy is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Healpy is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Healpy; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *  For more information about Healpy, see http://code.google.com/p/healpy
 */
/*

   This module provides Healpix functions to Python.
   It uses the healpix_cxx library.

*/

#include 

#include "numpy/arrayobject.h"

#include 
#include 

#include "arr.h"
#include "alm.h"
#include "lsconstants.h"
#include "healpix_map.h"
#include "xcomplex.h"
#include "alm_healpix_tools.h"
#include "powspec.h"
#include "alm_powspec_tools.h"
#include "healpix_data_io.h"
#include "_healpy_utils.h"

#define IS_DEBUG_ON 0

/* Some helpful macro */
#define XMALLOC(X,Y,Z) if( !(X = (Y*)malloc(Z*sizeof(Y))) ) { PyErr_NoMemory(); goto fail;}
#define XNEW(X,Y,Z) if( !(X = new Y[Z]) ) { PyErr_NoMemory(); goto fail; }
#define XFREE(X) if( X ) free(X);
#define XDELETE(X) if( X ) delete[] X;
#define DBGPRINTF(X,...) if( IS_DEBUG_ON ) printf(X, ## __VA_ARGS__)


static long nside2npix(long nside)
{
  return 12*nside*nside;
}

static long npix2nside(long npix)
{
  long nside;
  long npix2;
  nside = (long)floor(sqrt(npix/12.));
  npix2 = 12*nside*nside;
  if( npix2 == npix )
    return nside;
  else
    return -1;
}


/* Helper functions */

/*
static void getij(long n, long idx, long *i, long *j)
{
  *i = (long)ceil(((2*n+1)-sqrt((2*n+1)*(2*n+1)-8*(idx-n)))/2);
  *j = idx - (*i)*(2*n+1- (*i) )/2;
}
*/

static long getidx(long n, long i, long j)
{
  long tmp;
  if( i > j )
    {tmp = j; j=i; i=tmp;}
  return i*(2*n-1-i)/2+j;
}


static long getn(long s)
{
  long x;
  x = (long)floor((-1+sqrt(1+8*s))/2);
  if( (x*(x+1)/2) != s )
    return -1;
  else
    return x;
}

static void cholesky(int n, double *data, double *res)
{
  int i,j,k;
  double sum;

  for( j=0; jj)
            {
              sum = data[getidx(n,i,j)];
              for( k=0; kflags&NPY_C_CONTIGUOUS,
    "Array must be C contiguous for this operation.");

  if( polarisation )
    healpyAssertValue(mapQin->flags&mapUin->flags&NPY_C_CONTIGUOUS,
                      "Array must be C contiguous for this operation.");

  /* Check type of data : must be double ('d') */
  healpyAssertType(mapIin->descr->type == 'd',
    "Type must be Float64 for this function");

  if( polarisation )
    {
    healpyAssertType(mapQin->descr->type == 'd',
      "Type must be Float64 for this function");
    healpyAssertType(mapUin->descr->type == 'd',
      "Type must be Float64 for this function");
    }

  /* Check number of dimension : must be 1 */
  healpyAssertType(mapIin->nd==1,"Array must be 1D.");
  npix = mapIin->dimensions[0];

  if( polarisation )
    {
    healpyAssertType((mapQin->nd==1)&&(mapUin->nd==1),"Array must be 1D.");
    healpyAssertType((mapQin->dimensions[0]==npix)&&
                     (mapQin->dimensions[0]==npix),
                      "All maps must have same dimension.");
    }

  /* Check that the number of pixel is ok (12*nside^2) */
  nside = npix2nside(npix);
  healpyAssertValue(nside>=0,"Number of pixel not valid for healpix map.");

  /* lmax and mmax */
  if( lmax < 0 )
    lmax = 3*nside-1;
  if( mmax <0 || mmax > lmax )
    mmax = lmax;

  Healpix_Map mapI, mapQ, mapU;
  {
  arr arr_map((double*)mapIin->data, npix);
  mapI.Set(arr_map, RING);
  }

  if(polarisation)
    {
    arr arr_map((double*)mapQin->data, npix);
    mapQ.Set(arr_map, RING);
    }

  if( polarisation )
    {
    arr arr_map((double*)mapUin->data, npix);
    mapU.Set(arr_map, RING);
    }

  npy_intp szalm = Alm >::Num_Alms(lmax,mmax);

  PyArrayObject *almIout = (PyArrayObject*)PyArray_SimpleNew
    (1, (npy_intp*)&szalm, PyArray_CDOUBLE);
  if( !almIout ) return NULL;

  PyArrayObject *almGout=NULL, *almCout=NULL;
  if( polarisation )
    {
      almGout = (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&szalm,
                                                  PyArray_CDOUBLE);
      if( !almGout ) {
        Py_DECREF(almIout);
        return NULL;
      }
      almCout = (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&szalm,
                                                  PyArray_CDOUBLE);
      if( !almCout ) {
        Py_DECREF(almIout);
        Py_DECREF(almGout);
        return NULL;
      }
    }

  Alm< xcomplex > almIalm;
  {
    arr< xcomplex > alm_arr((xcomplex*)almIout->data, szalm);
    almIalm.Set(alm_arr, lmax, mmax);
  }

  Alm< xcomplex > almGalm;
  if( polarisation )
    {
      arr< xcomplex > alm_arr((xcomplex*)almGout->data, szalm);
      almGalm.Set(alm_arr, lmax, mmax);
    }

  Alm< xcomplex > almCalm;
  if( polarisation )
    {
      arr< xcomplex > alm_arr((xcomplex*)almCout->data, szalm);
      almCalm.Set(alm_arr, lmax, mmax);
    }

  arr weight;

  if( use_weights )
    {
      read_weight_ring(datapath, nside, weight);
      for (tsize m=0; mflags&NPY_C_CONTIGUOUS,
                      "Array must be C contiguous for this operation.");
  if( polarisation )
    healpyAssertValue(almGin->flags&almCin->flags&NPY_C_CONTIGUOUS,
                          "Array must be C contiguous for this operation.");

  /* Check type of data : must be double, real ('d') or complex ('D') */
  healpyAssertType(almIin->descr->type == 'D',
                      "Type must be Complex for this function");
  if( polarisation )
    {
      healpyAssertType(almGin->descr->type == 'D',
                          "Type must be Complex for this function");
      healpyAssertType(almCin->descr->type == 'D',
                          "Type must be Complex for this function");
    }

  /* Check number of dimension : must be 1 */
  healpyAssertType(almIin->nd==1,"The a_lm must be a 1D array.");
  if( polarisation )
    {
    healpyAssertType(almGin->nd==1,"The a_lm must be a 1D array.");
    healpyAssertType(almCin->nd==1,"The a_lm must be a 1D array.");
    }

  /* Need to have lmax and mmax defined */
  if( lmax < 0 )
    {
      /* Check that the dimension is compatible with lmax=mmax */
      long imax = almIin->dimensions[0] - 1;
      double ell = (-3.+sqrt(9.+8.*imax))/2.;
      healpyAssertType(ell==floor(ell),
        "Wrong alm size (or give lmax and mmax)");
      lmax=(int)floor(ell);
      mmax = lmax;
    }
  if( mmax < 0 || mmax > lmax)
    mmax = lmax;

  /* Check lmax and mmax are ok compared to alm.size */
  int szalm = Alm< xcomplex >::Num_Alms(lmax,mmax);
  healpyAssertValue(almIin->dimensions[0]==szalm,"Wrong alm size.");
  if( polarisation )
    {
    healpyAssertValue(almGin->dimensions[0]==szalm,"Wrong alm size.");
    healpyAssertValue(almCin->dimensions[0]==szalm,"Wrong alm size.");
    }

  /* Now we can build an Alm and give it to alm2map_iter */
  Alm< xcomplex > almIalm;
  {
    arr< xcomplex > alm_arr((xcomplex*)almIin->data, szalm);
    almIalm.Set(alm_arr, lmax, mmax);
  }
  Alm< xcomplex > almGalm;
  if( polarisation )
    {
      arr< xcomplex > alm_arr((xcomplex*)almGin->data, szalm);
      almGalm.Set(alm_arr, lmax, mmax);
    }
  Alm< xcomplex > almCalm;
  if( polarisation )
    {
      arr< xcomplex > alm_arr((xcomplex*)almCin->data, szalm);
      almCalm.Set(alm_arr, lmax, mmax);
    }

  /* We must prepare the map */

  npy_intp npix = nside2npix(nside);
  PyArrayObject *mapIout = NULL;
  mapIout = (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&npix,
                                              PyArray_DOUBLE);
  if( !mapIout )
    return NULL;

  PyArrayObject *mapQout = NULL;
  if( polarisation )
    {
      mapQout = (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&npix,
                                                  PyArray_DOUBLE);
      if( !mapQout )
        return NULL;
    }

  PyArrayObject *mapUout = NULL;
  if( polarisation )
    {
      mapUout = (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&npix,
                                                  PyArray_DOUBLE);
      if( !mapUout )
        return NULL;
    }

  Healpix_Map mapI;
  {
    arr arr_map((double*)mapIout->data, npix);
    mapI.Set(arr_map, RING);
  }

  Healpix_Map mapQ;
  if( polarisation )
    {
      arr arr_map((double*)mapQout->data, npix);
      mapQ.Set(arr_map, RING);
    }
  Healpix_Map mapU;
  if( polarisation )
    {
      arr arr_map((double*)mapUout->data, npix);
      mapU.Set(arr_map, RING);
    }

  /* We now call alm2map */

  if( !polarisation )
    {
      double offset = almIalm(0,0).real()/sqrt(fourpi);
      xcomplex almI00 = almIalm(0,0);
      almIalm(0,0) = 0;
      alm2map(almIalm,mapI);
      mapI.Add(offset);
      almIalm(0,0) = almI00;
    }
  else
    {
      double offset = almIalm(0,0).real()/sqrt(fourpi);
      xcomplex almI00 = almIalm(0,0);
      almIalm(0,0) = 0;
      alm2map_pol(almIalm,almGalm,almCalm,mapI,mapQ,mapU);
      mapI.Add(offset);
      almIalm(0,0) = almI00;
    }

  /* We now return the map */
  if( !polarisation )
    return Py_BuildValue("N",mapIout);
  else
    return Py_BuildValue("NNN",mapIout,mapQout,mapUout);
}

/***********************************************************************
    alm2map_der1

       input: alm, nside,

       output: map in RING scheme
*/
static PyObject *healpy_alm2map_der1(PyObject *self, PyObject *args,
        PyObject *kwds) {
  PyArrayObject *almIin = NULL;
  int nside = 64;
  int lmax = -1;
  int mmax = -1;

  static const char* kwlist[] = {"","nside", "lmax", "mmax", NULL};

  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|iii", (char **)kwlist,
           &PyArray_Type, &almIin,
           &nside,
           &lmax,
           &mmax)) {
    return NULL;
  }

  /* Check array is contiguous */
  healpyAssertValue(almIin->flags & NPY_C_CONTIGUOUS,
    "Array must be C contiguous for this operation.");

  /* Check type of data : must be double, real ('d') or complex ('D') */
  healpyAssertType(almIin->descr->type == 'D',
    "Type must be Complex for this function");

  /* Check number of dimension : must be 1 */
  healpyAssertValue(almIin->nd==1, "The map must be a 1D array");

  /* Need to have lmax and mmax defined */
  if( lmax < 0 ) {
      /* Check that the dimension is compatible with lmax=mmax */
      long imax = almIin->dimensions[0] - 1;
      double ell = (-3.+sqrt(9.+8.*imax))/2.;
      healpyAssertValue(ell == floor(ell),
        "Wrong alm size (or give lmax and mmax).");
      lmax=(int)floor(ell);
      mmax = lmax;
  }
  if( mmax < 0 || mmax > lmax) {
    mmax = lmax;
  }

  /* Check lmax and mmax are ok compared to alm.size */
  int szalm = Alm< xcomplex >::Num_Alms(lmax,mmax);
  healpyAssertValue(almIin->dimensions[0] == szalm,"Wrong alm size.");

  /* Now we can build an Alm and give it to alm2map_iter */
  Alm< xcomplex > almIalm;
  {
    arr< xcomplex > alm_arr((xcomplex*)almIin->data, szalm);
    almIalm.Set(alm_arr, lmax, mmax);
  }

  /* We must prepare the map */

  npy_intp npix = nside2npix(nside);

  PyArrayObject *mapIout = NULL;
  mapIout = (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&npix,
                PyArray_DOUBLE);
  if( !mapIout )
    return NULL;
  Healpix_Map mapI;
  {
    arr arr_map((double*)mapIout->data, npix);
    mapI.Set(arr_map, RING);
  }

  PyArrayObject *mapDtheta = NULL;
  mapDtheta = (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&npix,
                PyArray_DOUBLE);
  if( !mapDtheta )
    return NULL;
  Healpix_Map mapDt;
  {
    arr arr_map((double*)mapDtheta->data, npix);
    mapDt.Set(arr_map, RING);
  }

  PyArrayObject *mapDphi = NULL;
  mapDphi = (PyArrayObject*)PyArray_SimpleNew(1, (npy_intp*)&npix,
                PyArray_DOUBLE);
  if( !mapDphi )
    return NULL;
  Healpix_Map mapDp;
  {
    arr arr_map((double*)mapDphi->data, npix);
    mapDp.Set(arr_map, RING);
  }


  /* We now call alm2map_der1 */

  double offset = almIalm(0,0).real()/sqrt(fourpi);
  xcomplex almI00 = almIalm(0,0);
  almIalm(0,0) = 0;
  alm2map_der1(almIalm,mapI,mapDt,mapDp);
  mapI.Add(offset);
  almIalm(0,0) = almI00;

  return Py_BuildValue("NNN",mapIout,mapDtheta,mapDphi);
}

/*  Functions needed to create alm from cl
    in the polarised case.
    The idea is as follow:
      - this function take as argument a sequence of n(n+1)/2 arrays,
        where n is the number of components
      - these arrays represents the symetric correlation matrices
        of n components
      - this functions use the cholesky decomposition to compute
        the

 */
/***********************************************************************
    synalm

       input: a sequence of Cl(i,j) where 0<=i,j=j are given.

       output: alm
*/
static PyObject *healpy_synalm(PyObject *self, PyObject *args,
                               PyObject *kwds)
{
  int lmax=-1, mmax=-1;
  int ncl, nalm;
  const double sqrt_two = sqrt(2.);

  /* Take also a sequence of unit variance random vectors for the alm. */

  static const char* kwlist[] = {"","", "", "", NULL};

  PyObject *t = NULL;
  PyObject *u = NULL;
  DBGPRINTF("Parsing keyword\n");
  if( !PyArg_ParseTupleAndKeywords(args, kwds, "OOii", (char **)kwlist,
                                   &t,
                                   &u,
                                   &lmax, &mmax) )
    return NULL;

  DBGPRINTF("Checking sequence\n");
  if( (!PySequence_Check(t)) || (!PySequence_Check(u)) )
    return NULL;

  ncl = PySequence_Size(t);
  nalm = getn(ncl);
  DBGPRINTF("Sequence size: ncl=%d, nalm=%d\n", ncl, nalm);
  healpyAssertType((nalm>0)&&(PySequence_Size(u)==nalm),
                      "First argument must be a sequence with "
                      "n(n+1)/2 elements, and second argument "
                      "a sequence with n elements.");

  DBGPRINTF("Allocating memory\n");
  /* Memory allocation */
  PyArrayObject **cls = NULL;
  PyArrayObject **alms = NULL;
  Alm< xcomplex > *almalms = NULL;
  double *mat = NULL;
  double *res = NULL;
  XMALLOC(cls, PyArrayObject*, ncl);
  XMALLOC(alms, PyArrayObject*, nalm);
  XNEW(almalms, Alm< xcomplex >, nalm);
  XMALLOC(mat, double, ncl);
  XMALLOC(res, double, ncl);

  /*  From now on, I should do a 'goto fail' to return from the function
      in order to free allocated memory */
  /* Get the cls objects.
     If an object is None, set the array to NULL
  */
  for( int i=0; ilmax )
    mmax=lmax;

  DBGPRINTF("lmax=%d, mmax=%d\n", lmax, mmax);

  /* Now, I check the arrays cls and alms are 1D and complex for alms */
  DBGPRINTF("Check dimension and size of cls\n");
  for( int i=0; ind != 1)
          //|| ((cls[i]->descr->type != 'd') && (cls[i]->descr->type != 'f')) )
          || (cls[i]->descr->type != 'd') )
        {
          PyErr_SetString(PyExc_TypeError,
                      "Type of cls must be float64 and arrays must be 1D.");
          goto fail;
        }
    }
  DBGPRINTF("Check dimension and size of alms\n");
  for( int i=0; ind != 1) || (alms[i]->descr->type != 'D') )
        {
          PyErr_SetString(PyExc_TypeError,
                      "Type of alms must be complex128 and arrays must be 1D.");
          goto fail;
        }
    }

  /* Now, I check that all alms have the same size and that it is compatible with
     lmax and mmax */
  DBGPRINTF("Check alms have identical size\n");
  int szalm;
  szalm = -1;
  for( int i=0; idimensions[0];
      else if( alms[i]->dimensions[0] != szalm )
        {
          PyErr_SetString(PyExc_ValueError,
                          "All alms arrays must have same size.");
          goto fail;
        }
    }
  if( szalm != int(Alm< xcomplex >::Num_Alms(lmax,mmax)) )
    {
      PyErr_SetString(PyExc_ValueError,
                      "lmax and mmax are not compatible with size of alms.");
      goto fail;
    }
  DBGPRINTF("Alms have all size %d\n", szalm);

  /* Set the objects Alm */
  DBGPRINTF("Set alm objects\n");
  for( int i=0; i > * alm_arr;
      alm_arr = new arr< xcomplex >((xcomplex*)alms[i]->data, szalm);
      DBGPRINTF("Set...\n");
      almalms[i].Set(*alm_arr, lmax, mmax);
      delete alm_arr;
    }


  /* Now, I can loop over l,
     for each l, I make the Cholesky decomposition of the correlation matrix
     given by the cls[*][l]
  */
  DBGPRINTF("Start loop over l\n");
  for( int l=0; l<=lmax; l++ )
    {
      DBGPRINTF("l=%d\n", l);
      /* fill the matrix of cls */
      for( int i=0; idimensions[0] < l )
            mat[i] = 0.0;
          else
            {
              if( cls[i]->descr->type == 'f' )
                mat[i] = (double)(*((float*)PyArray_GETPTR1(cls[i],l)));
              else
                mat[i] = *((double*)PyArray_GETPTR1(cls[i],l));
            }
        }

      /* Make the Cholesky decomposition */
      cholesky(nalm, mat, res);

      if( l == 400 )
        {
          DBGPRINTF("matrice: ");
          for( int i=0; i=0; i-- )
        {
          double x;
          x = 0.0;
          almalms[i](l,0)=xcomplex(almalms[i](l,0).real(),0.0);
          for( int j=0; j<=i; j++ )
            x += res[getidx(nalm,i,j)]*almalms[j](l,0).real();
          almalms[i](l,0)=xcomplex(x,0.);
          DBGPRINTF(" %lg %lg ;", almalms[i](l,0).real(), almalms[i](l,0).imag());
        }
      DBGPRINTF("\n");

      /* m > 1 */
      for( int m=1; m<=l; m++ )
        {
          DBGPRINTF("   m=%d: ", m);
          for( int i=nalm-1; i>=0; i-- )
            {
              double xr, xi;
              xi = xr = 0.0;
              for( int j=0; j<=i; j++ )
                {
                  xr += res[getidx(nalm,i,j)]*almalms[j](l,m).real();
                  xi += res[getidx(nalm,i,j)]*almalms[j](l,m).imag();
                  DBGPRINTF("(res[%d]=%lg, alm=%lg,%lg) %lg %lg", (int)getidx(nalm,i,j),
                            res[getidx(nalm,i,j)],
                            almalms[j](l,m).real(), almalms[j](l,m).imag(),
                            xr, xi);
                }
              almalms[i](l,m)=xcomplex(xr/sqrt_two,xi/sqrt_two);
              DBGPRINTF(" xre,xim[%d]: %lg %lg ;", i,
                        almalms[i](l,m).real(), almalms[i](l,m).imag());
            }
          DBGPRINTF("\n");
      }
   }

  /* Should be finished now... */
  XFREE(cls);
  XFREE(alms);
  XDELETE(almalms);
  XFREE(mat);
  XFREE(res);
  Py_INCREF(Py_None);
  return Py_None;

  /* To be done before returning */
 fail:
  XFREE(cls);
  XFREE(alms);
  XDELETE(almalms);
  XFREE(mat);
  XFREE(res);

  return NULL;
}

PyObject *healpy_getn(PyObject *self, PyObject *args)
{
  long s;
  healpyAssertType (PyArg_ParseTuple(args, "l", &s),
    "This function takes an integer as argument.");
  long n = getn(s);
  return Py_BuildValue("l",n);
}

static PyMethodDef methods[] = {
  {"_map2alm", (PyCFunction)healpy_map2alm, METH_VARARGS | METH_KEYWORDS,
   "Compute alm or cl from an input map.\n"
   "The input map is assumed to be ordered in RING.\n"
   "anafast(map,lmax=3*nside-1,mmax=lmax,cl=False,\n"
   "        iter=3,use_weights=False,data_path=None"},
  {"_alm2map", (PyCFunction)healpy_alm2map, METH_VARARGS | METH_KEYWORDS,
   "Compute a map from alm.\n"
   "The output map is ordered in RING scheme.\n"
   "alm2map(alm,nside=64,lmax=-1,mmax=-1)"},
  {"_alm2map_der1", (PyCFunction)healpy_alm2map_der1, METH_VARARGS | METH_KEYWORDS,
   "Compute a map and derivatives from alm.\n"
   "The output map is ordered in RING scheme.\n"
   "alm2map_der1(alm,nside=64,lmax=-1,mmax=-1)"},
  {"_synalm", (PyCFunction)healpy_synalm, METH_VARARGS | METH_KEYWORDS,
   "Compute alm's given cl's and unit variance random arrays.\n"},
  {"_getn", healpy_getn, METH_VARARGS,
   "Compute number n such that n(n+1)/2 is equal to the argument.\n"},
  {NULL, NULL, 0, NULL} /* Sentinel */
};

#if PY_MAJOR_VERSION >= 3
static PyModuleDef moduledef = {
  PyModuleDef_HEAD_INIT,
  "_healpy_sph_transform_lib",
  NULL, -1, methods
};
#endif

PyMODINIT_FUNC
#if PY_MAJOR_VERSION < 3
init_healpy_sph_transform_lib(void)
#else
PyInit__healpy_sph_transform_lib(void)
#endif
{
  import_array();

#if PY_MAJOR_VERSION < 3
  Py_InitModule("_healpy_sph_transform_lib", methods);
#else
  return PyModule_Create(&moduledef);
#endif
}
healpy-1.10.3/healpy/src/_healpy_utils.h0000664000175000017500000000053613010374155020414 0ustar  zoncazonca00000000000000#ifndef HEALPY_UTILS_H
#define HEALPY_UTILS_H

#define healpyAssertType(testval,msg) \
do { if (testval); else { PyErr_SetString(PyExc_TypeError, msg); return NULL; } } while(0)
#define healpyAssertValue(testval,msg) \
do { if (testval); else { PyErr_SetString(PyExc_ValueError, msg); return NULL; } } while(0)

#define CP_(str)(char *)(str)

#endif
healpy-1.10.3/healpy/src/_pixelfunc.cpp0000664000175000017500000126450713010376627020263 0ustar  zoncazonca00000000000000/* Generated by Cython 0.24 */

#define PY_SSIZE_T_CLEAN
#include "Python.h"
#ifndef Py_PYTHON_H
    #error Python headers needed to compile C extensions, please install development version of Python.
#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
    #error Cython requires Python 2.6+ or Python 3.2+.
#else
#define CYTHON_ABI "0_24"
#include 
#ifndef offsetof
  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
  #ifndef __stdcall
    #define __stdcall
  #endif
  #ifndef __cdecl
    #define __cdecl
  #endif
  #ifndef __fastcall
    #define __fastcall
  #endif
#endif
#ifndef DL_IMPORT
  #define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
  #define DL_EXPORT(t) t
#endif
#ifndef PY_LONG_LONG
  #define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
  #define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
  #define CYTHON_COMPILING_IN_PYPY 1
  #define CYTHON_COMPILING_IN_CPYTHON 0
#else
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_CPYTHON 1
#endif
#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000
  #define CYTHON_USE_PYLONG_INTERNALS 1
#endif
#if CYTHON_USE_PYLONG_INTERNALS
  #include "longintrepr.h"
  #undef SHIFT
  #undef BASE
  #undef MASK
#endif
#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
  #define Py_OptimizeFlag 0
#endif
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
#if PY_MAJOR_VERSION < 3
  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyClass_Type
#else
  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyType_Type
#endif
#ifndef Py_TPFLAGS_CHECKTYPES
  #define Py_TPFLAGS_CHECKTYPES 0
#endif
#ifndef Py_TPFLAGS_HAVE_INDEX
  #define Py_TPFLAGS_HAVE_INDEX 0
#endif
#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#ifndef Py_TPFLAGS_HAVE_FINALIZE
  #define Py_TPFLAGS_HAVE_FINALIZE 0
#endif
#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
  #define CYTHON_PEP393_ENABLED 1
  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
                                              0 : _PyUnicode_Ready((PyObject *)(op)))
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
#else
  #define CYTHON_PEP393_ENABLED 0
  #define __Pyx_PyUnicode_READY(op)       (0)
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
#endif
#if CYTHON_COMPILING_IN_PYPY
  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
#else
  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
  #define PyObject_Malloc(s)   PyMem_Malloc(s)
  #define PyObject_Free(p)     PyMem_Free(p)
  #define PyObject_Realloc(p)  PyMem_Realloc(p)
#endif
#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
#else
  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
#endif
#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
  #define PyObject_ASCII(o)            PyObject_Repr(o)
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBaseString_Type            PyUnicode_Type
  #define PyStringObject               PyUnicodeObject
  #define PyString_Type                PyUnicode_Type
  #define PyString_Check               PyUnicode_Check
  #define PyString_CheckExact          PyUnicode_CheckExact
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
#else
  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
#endif
#ifndef PySet_CheckExact
  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
#endif
#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
#if PY_MAJOR_VERSION >= 3
  #define PyIntObject                  PyLongObject
  #define PyInt_Type                   PyLong_Type
  #define PyInt_Check(op)              PyLong_Check(op)
  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
  #define PyInt_FromString             PyLong_FromString
  #define PyInt_FromUnicode            PyLong_FromUnicode
  #define PyInt_FromLong               PyLong_FromLong
  #define PyInt_FromSize_t             PyLong_FromSize_t
  #define PyInt_FromSsize_t            PyLong_FromSsize_t
  #define PyInt_AsLong                 PyLong_AsLong
  #define PyInt_AS_LONG                PyLong_AS_LONG
  #define PyInt_AsSsize_t              PyLong_AsSsize_t
  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
  #define PyNumber_Int                 PyNumber_Long
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBoolObject                 PyLongObject
#endif
#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
  #ifndef PyUnicode_InternFromString
    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
  #endif
#endif
#if PY_VERSION_HEX < 0x030200A4
  typedef long Py_hash_t;
  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
#else
  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
#else
  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
#endif
#if PY_VERSION_HEX >= 0x030500B1
#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
typedef struct {
    unaryfunc am_await;
    unaryfunc am_aiter;
    unaryfunc am_anext;
} __Pyx_PyAsyncMethodsStruct;
#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
#else
#define __Pyx_PyType_AsAsync(obj) NULL
#endif
#ifndef CYTHON_RESTRICT
  #if defined(__GNUC__)
    #define CYTHON_RESTRICT __restrict__
  #elif defined(_MSC_VER) && _MSC_VER >= 1400
    #define CYTHON_RESTRICT __restrict
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_RESTRICT restrict
  #else
    #define CYTHON_RESTRICT
  #endif
#endif
#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)

#ifndef __cplusplus
  #error "Cython files generated with the C++ option must be compiled with a C++ compiler."
#endif
#ifndef CYTHON_INLINE
  #define CYTHON_INLINE inline
#endif
template
void __Pyx_call_destructor(T& x) {
    x.~T();
}
template
class __Pyx_FakeReference {
  public:
    __Pyx_FakeReference() : ptr(NULL) { }
    __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { }
    T *operator->() { return ptr; }
    operator T&() { return *ptr; }
  private:
    T *ptr;
};

#if defined(WIN32) || defined(MS_WINDOWS)
  #define _USE_MATH_DEFINES
#endif
#include 
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
  float value;
  memset(&value, 0xFF, sizeof(value));
  return value;
}
#endif


#define __PYX_ERR(f_index, lineno, Ln_error) \
{ \
  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
}

#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
#else
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
#endif

#ifndef __PYX_EXTERN_C
  #ifdef __cplusplus
    #define __PYX_EXTERN_C extern "C"
  #else
    #define __PYX_EXTERN_C extern
  #endif
#endif

#define __PYX_HAVE__healpy___pixelfunc
#define __PYX_HAVE_API__healpy___pixelfunc
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "numpy/arrayobject.h"
#include "numpy/ufuncobject.h"
#include 
#include "ios"
#include "new"
#include "stdexcept"
#include "typeinfo"
#include "stddef.h"
#include "datatypes.h"
#include "xcomplex.h"
#include "arr.h"
#include "rangeset.h"
#include "vec3.h"
#include "pointing.h"
#include "healpix_base.h"
#include "healpix_map.h"
#include "alm.h"
#ifdef _OPENMP
#include 
#endif /* _OPENMP */

#ifdef PYREX_WITHOUT_ASSERTIONS
#define CYTHON_WITHOUT_ASSERTIONS
#endif

#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define CYTHON_UNUSED __attribute__ ((__unused__))
#   else
#     define CYTHON_UNUSED
#   endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
#   define CYTHON_UNUSED __attribute__ ((__unused__))
# else
#   define CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_NCP_UNUSED
# if CYTHON_COMPILING_IN_CPYTHON
#  define CYTHON_NCP_UNUSED
# else
#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;

#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
#define __PYX_DEFAULT_STRING_ENCODING ""
#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#define __Pyx_uchar_cast(c) ((unsigned char)c)
#define __Pyx_long_cast(x) ((long)x)
#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
    (sizeof(type) < sizeof(Py_ssize_t))  ||\
    (sizeof(type) > sizeof(Py_ssize_t) &&\
          likely(v < (type)PY_SSIZE_T_MAX ||\
                 v == (type)PY_SSIZE_T_MAX)  &&\
          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
                                v == (type)PY_SSIZE_T_MIN)))  ||\
    (sizeof(type) == sizeof(Py_ssize_t) &&\
          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
                               v == (type)PY_SSIZE_T_MAX)))  )
#if defined (__cplusplus) && __cplusplus >= 201103L
    #include 
    #define __Pyx_sst_abs(value) std::abs(value)
#elif SIZEOF_INT >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) abs(value)
#elif SIZEOF_LONG >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) labs(value)
#elif defined (_MSC_VER) && defined (_M_X64)
    #define __Pyx_sst_abs(value) _abs64(value)
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define __Pyx_sst_abs(value) llabs(value)
#elif defined (__GNUC__)
    #define __Pyx_sst_abs(value) __builtin_llabs(value)
#else
    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
#endif
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
#define __Pyx_PyBytes_FromString        PyBytes_FromString
#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
#if PY_MAJOR_VERSION < 3
    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#else
    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
#endif
#define __Pyx_PyObject_AsSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
#if PY_MAJOR_VERSION < 3
static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
{
    const Py_UNICODE *u_end = u;
    while (*u_end++) ;
    return (size_t)(u_end - u - 1);
}
#else
#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
#endif
#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
#if CYTHON_COMPILING_IN_CPYTHON
#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
#else
#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#endif
#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
#else
#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
#endif
#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
static int __Pyx_sys_getdefaultencoding_not_ascii;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
    PyObject* sys;
    PyObject* default_encoding = NULL;
    PyObject* ascii_chars_u = NULL;
    PyObject* ascii_chars_b = NULL;
    const char* default_encoding_c;
    sys = PyImport_ImportModule("sys");
    if (!sys) goto bad;
    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
    Py_DECREF(sys);
    if (!default_encoding) goto bad;
    default_encoding_c = PyBytes_AsString(default_encoding);
    if (!default_encoding_c) goto bad;
    if (strcmp(default_encoding_c, "ascii") == 0) {
        __Pyx_sys_getdefaultencoding_not_ascii = 0;
    } else {
        char ascii_chars[128];
        int c;
        for (c = 0; c < 128; c++) {
            ascii_chars[c] = c;
        }
        __Pyx_sys_getdefaultencoding_not_ascii = 1;
        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
        if (!ascii_chars_u) goto bad;
        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
            PyErr_Format(
                PyExc_ValueError,
                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
                default_encoding_c);
            goto bad;
        }
        Py_DECREF(ascii_chars_u);
        Py_DECREF(ascii_chars_b);
    }
    Py_DECREF(default_encoding);
    return 0;
bad:
    Py_XDECREF(default_encoding);
    Py_XDECREF(ascii_chars_u);
    Py_XDECREF(ascii_chars_b);
    return -1;
}
#endif
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
#else
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
static char* __PYX_DEFAULT_STRING_ENCODING;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
    PyObject* sys;
    PyObject* default_encoding = NULL;
    char* default_encoding_c;
    sys = PyImport_ImportModule("sys");
    if (!sys) goto bad;
    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
    Py_DECREF(sys);
    if (!default_encoding) goto bad;
    default_encoding_c = PyBytes_AsString(default_encoding);
    if (!default_encoding_c) goto bad;
    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
    Py_DECREF(default_encoding);
    return 0;
bad:
    Py_XDECREF(default_encoding);
    return -1;
}
#endif
#endif


/* Test for GCC > 2.95 */
#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
  #define likely(x)   __builtin_expect(!!(x), 1)
  #define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
  #define likely(x)   (x)
  #define unlikely(x) (x)
#endif /* __GNUC__ */

static PyObject *__pyx_m;
static PyObject *__pyx_d;
static PyObject *__pyx_b;
static PyObject *__pyx_empty_tuple;
static PyObject *__pyx_empty_bytes;
static PyObject *__pyx_empty_unicode;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
static const char *__pyx_filename;

/* None.proto */
#if !defined(CYTHON_CCOMPLEX)
  #if defined(__cplusplus)
    #define CYTHON_CCOMPLEX 1
  #elif defined(_Complex_I)
    #define CYTHON_CCOMPLEX 1
  #else
    #define CYTHON_CCOMPLEX 0
  #endif
#endif
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    #include 
  #else
    #include 
  #endif
#endif
#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
  #undef _Complex_I
  #define _Complex_I 1.0fj
#endif


static const char *__pyx_f[] = {
  "healpy/src/_pixelfunc.pyx",
  "__init__.pxd",
  "healpy/src/_common.pxd",
  "type.pxd",
};
/* BufferFormatStructs.proto */
#define IS_UNSIGNED(type) (((type) -1) > 0)
struct __Pyx_StructField_;
#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
typedef struct {
  const char* name;
  struct __Pyx_StructField_* fields;
  size_t size;
  size_t arraysize[8];
  int ndim;
  char typegroup;
  char is_unsigned;
  int flags;
} __Pyx_TypeInfo;
typedef struct __Pyx_StructField_ {
  __Pyx_TypeInfo* type;
  const char* name;
  size_t offset;
} __Pyx_StructField;
typedef struct {
  __Pyx_StructField* field;
  size_t parent_offset;
} __Pyx_BufFmt_StackElem;
typedef struct {
  __Pyx_StructField root;
  __Pyx_BufFmt_StackElem* head;
  size_t fmt_offset;
  size_t new_count, enc_count;
  size_t struct_alignment;
  int is_complex;
  char enc_type;
  char new_packmode;
  char enc_packmode;
  char is_valid_array;
} __Pyx_BufFmt_Context;


/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":725
 * # in Cython to enable them only on the right systems.
 * 
 * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t
 */
typedef npy_int8 __pyx_t_5numpy_int8_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":726
 * 
 * ctypedef npy_int8       int8_t
 * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int32      int32_t
 * ctypedef npy_int64      int64_t
 */
typedef npy_int16 __pyx_t_5numpy_int16_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":727
 * ctypedef npy_int8       int8_t
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int64      int64_t
 * #ctypedef npy_int96      int96_t
 */
typedef npy_int32 __pyx_t_5numpy_int32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":728
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t
 * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_int96      int96_t
 * #ctypedef npy_int128     int128_t
 */
typedef npy_int64 __pyx_t_5numpy_int64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":732
 * #ctypedef npy_int128     int128_t
 * 
 * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t
 */
typedef npy_uint8 __pyx_t_5numpy_uint8_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":733
 * 
 * ctypedef npy_uint8      uint8_t
 * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint32     uint32_t
 * ctypedef npy_uint64     uint64_t
 */
typedef npy_uint16 __pyx_t_5numpy_uint16_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":734
 * ctypedef npy_uint8      uint8_t
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint64     uint64_t
 * #ctypedef npy_uint96     uint96_t
 */
typedef npy_uint32 __pyx_t_5numpy_uint32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":735
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t
 * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_uint96     uint96_t
 * #ctypedef npy_uint128    uint128_t
 */
typedef npy_uint64 __pyx_t_5numpy_uint64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":739
 * #ctypedef npy_uint128    uint128_t
 * 
 * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_float64    float64_t
 * #ctypedef npy_float80    float80_t
 */
typedef npy_float32 __pyx_t_5numpy_float32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":740
 * 
 * ctypedef npy_float32    float32_t
 * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_float80    float80_t
 * #ctypedef npy_float128   float128_t
 */
typedef npy_float64 __pyx_t_5numpy_float64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":749
 * # The int types are mapped a bit surprising --
 * # numpy.int corresponds to 'l' and numpy.long to 'q'
 * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longlong   long_t
 * ctypedef npy_longlong   longlong_t
 */
typedef npy_long __pyx_t_5numpy_int_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":750
 * # numpy.int corresponds to 'l' and numpy.long to 'q'
 * ctypedef npy_long       int_t
 * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longlong   longlong_t
 * 
 */
typedef npy_longlong __pyx_t_5numpy_long_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":751
 * ctypedef npy_long       int_t
 * ctypedef npy_longlong   long_t
 * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_ulong      uint_t
 */
typedef npy_longlong __pyx_t_5numpy_longlong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":753
 * ctypedef npy_longlong   longlong_t
 * 
 * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
 * ctypedef npy_ulonglong  ulong_t
 * ctypedef npy_ulonglong  ulonglong_t
 */
typedef npy_ulong __pyx_t_5numpy_uint_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":754
 * 
 * ctypedef npy_ulong      uint_t
 * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
 * ctypedef npy_ulonglong  ulonglong_t
 * 
 */
typedef npy_ulonglong __pyx_t_5numpy_ulong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":755
 * ctypedef npy_ulong      uint_t
 * ctypedef npy_ulonglong  ulong_t
 * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_intp       intp_t
 */
typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":757
 * ctypedef npy_ulonglong  ulonglong_t
 * 
 * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uintp      uintp_t
 * 
 */
typedef npy_intp __pyx_t_5numpy_intp_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":758
 * 
 * ctypedef npy_intp       intp_t
 * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_double     float_t
 */
typedef npy_uintp __pyx_t_5numpy_uintp_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":760
 * ctypedef npy_uintp      uintp_t
 * 
 * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
 * ctypedef npy_double     double_t
 * ctypedef npy_longdouble longdouble_t
 */
typedef npy_double __pyx_t_5numpy_float_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":761
 * 
 * ctypedef npy_double     float_t
 * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longdouble longdouble_t
 * 
 */
typedef npy_double __pyx_t_5numpy_double_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":762
 * ctypedef npy_double     float_t
 * ctypedef npy_double     double_t
 * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_cfloat      cfloat_t
 */
typedef npy_longdouble __pyx_t_5numpy_longdouble_t;

/* "_common.pxd":6
 * from libcpp.vector cimport vector
 * 
 * ctypedef unsigned size_t             # <<<<<<<<<<<<<<
 * ctypedef size_t tsize
 * 
 */
typedef unsigned int __pyx_t_7_common_size_t;

/* "_common.pxd":7
 * 
 * ctypedef unsigned size_t
 * ctypedef size_t tsize             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "stddef.h":
 */
typedef size_t __pyx_t_7_common_tsize;

/* "_common.pxd":11
 * cdef extern from "stddef.h":
 *     ctypedef long ptrdiff_t
 * ctypedef ptrdiff_t tdiff             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "datatypes.h":
 */
typedef ptrdiff_t __pyx_t_7_common_tdiff;
/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    typedef ::std::complex< float > __pyx_t_float_complex;
  #else
    typedef float _Complex __pyx_t_float_complex;
  #endif
#else
    typedef struct { float real, imag; } __pyx_t_float_complex;
#endif

/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    typedef ::std::complex< double > __pyx_t_double_complex;
  #else
    typedef double _Complex __pyx_t_double_complex;
  #endif
#else
    typedef struct { double real, imag; } __pyx_t_double_complex;
#endif


/*--- Type declarations ---*/

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":764
 * ctypedef npy_longdouble longdouble_t
 * 
 * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
 * ctypedef npy_cdouble     cdouble_t
 * ctypedef npy_clongdouble clongdouble_t
 */
typedef npy_cfloat __pyx_t_5numpy_cfloat_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":765
 * 
 * ctypedef npy_cfloat      cfloat_t
 * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
 * ctypedef npy_clongdouble clongdouble_t
 * 
 */
typedef npy_cdouble __pyx_t_5numpy_cdouble_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":766
 * ctypedef npy_cfloat      cfloat_t
 * ctypedef npy_cdouble     cdouble_t
 * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_cdouble     complex_t
 */
typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":768
 * ctypedef npy_clongdouble clongdouble_t
 * 
 * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew1(a):
 */
typedef npy_cdouble __pyx_t_5numpy_complex_t;

/* --- Runtime support code (head) --- */
/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
  #define CYTHON_REFNANNY 0
#endif
#if CYTHON_REFNANNY
  typedef struct {
    void (*INCREF)(void*, PyObject*, int);
    void (*DECREF)(void*, PyObject*, int);
    void (*GOTREF)(void*, PyObject*, int);
    void (*GIVEREF)(void*, PyObject*, int);
    void* (*SetupContext)(const char*, int, const char*);
    void (*FinishContext)(void**);
  } __Pyx_RefNannyAPIStruct;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
#ifdef WITH_THREAD
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          if (acquire_gil) {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
              PyGILState_Release(__pyx_gilstate_save);\
          } else {\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
          }
#else
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
#endif
  #define __Pyx_RefNannyFinishContext()\
          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
#else
  #define __Pyx_RefNannyDeclarations
  #define __Pyx_RefNannySetupContext(name, acquire_gil)
  #define __Pyx_RefNannyFinishContext()
  #define __Pyx_INCREF(r) Py_INCREF(r)
  #define __Pyx_DECREF(r) Py_DECREF(r)
  #define __Pyx_GOTREF(r)
  #define __Pyx_GIVEREF(r)
  #define __Pyx_XINCREF(r) Py_XINCREF(r)
  #define __Pyx_XDECREF(r) Py_XDECREF(r)
  #define __Pyx_XGOTREF(r)
  #define __Pyx_XGIVEREF(r)
#endif
#define __Pyx_XDECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_XDECREF(tmp);\
    } while (0)
#define __Pyx_DECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_DECREF(tmp);\
    } while (0)
#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)

/* PyObjectGetAttrStr.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_getattr))
        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
    return PyObject_GetAttr(obj, attr_name);
}
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif

/* GetBuiltinName.proto */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);

/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);

/* RaiseDoubleKeywords.proto */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);

/* ParseKeywords.proto */
static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
    const char* function_name);

/* ArgTypeTest.proto */
static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
    const char *name, int exact);

/* BufferFormatCheck.proto */
static CYTHON_INLINE int  __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
                              __Pyx_BufFmt_StackElem* stack,
                              __Pyx_TypeInfo* type); // PROTO

/* PyObjectCall.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif

/* PyThreadStateGet.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
#define __Pyx_PyThreadState_assign  __pyx_tstate = PyThreadState_GET();
#else
#define __Pyx_PyThreadState_declare
#define __Pyx_PyThreadState_assign
#endif

/* PyErrFetchRestore.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
#endif

/* RaiseException.proto */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);

/* GetModuleGlobalName.proto */
static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);

/* ExtTypeTest.proto */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);

/* BufferIndexError.proto */
static void __Pyx_RaiseBufferIndexError(int axis);

#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)
/* PyObjectCallMethO.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif

/* PyObjectCallOneArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);

/* PyNumberPow2.proto */
#define __Pyx_PyNumber_InPlacePowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 1)
#define __Pyx_PyNumber_PowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 0)
static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace);

/* WriteUnraisableException.proto */
static void __Pyx_WriteUnraisable(const char *name, int clineno,
                                  int lineno, const char *filename,
                                  int full_traceback, int nogil);

/* DictGetItem.proto */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
    PyObject *value;
    value = PyDict_GetItemWithError(d, key);
    if (unlikely(!value)) {
        if (!PyErr_Occurred()) {
            PyObject* args = PyTuple_Pack(1, key);
            if (likely(args))
                PyErr_SetObject(PyExc_KeyError, args);
            Py_XDECREF(args);
        }
        return NULL;
    }
    Py_INCREF(value);
    return value;
}
#else
    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#endif

/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);

/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);

/* RaiseNoneIterError.proto */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);

#define __Pyx_BufPtrCContig1d(type, buf, i0, s0) ((type)buf + i0)
/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);

/* CodeObjectCache.proto */
typedef struct {
    PyCodeObject* code_object;
    int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
    int count;
    int max_count;
    __Pyx_CodeObjectCacheEntry* entries;
};
static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
static PyCodeObject *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);

/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename);

/* BufferStructDeclare.proto */
typedef struct {
  Py_ssize_t shape, strides, suboffsets;
} __Pyx_Buf_DimInfo;
typedef struct {
  size_t refcount;
  Py_buffer pybuffer;
} __Pyx_Buffer;
typedef struct {
  __Pyx_Buffer *rcbuffer;
  char *data;
  __Pyx_Buf_DimInfo diminfo[8];
} __Pyx_LocalBuf_ND;

#if PY_MAJOR_VERSION < 3
    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
    static void __Pyx_ReleaseBuffer(Py_buffer *view);
#else
    #define __Pyx_GetBuffer PyObject_GetBuffer
    #define __Pyx_ReleaseBuffer PyBuffer_Release
#endif


/* None.proto */
static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0};
static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1};

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);

/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    #define __Pyx_CREAL(z) ((z).real())
    #define __Pyx_CIMAG(z) ((z).imag())
  #else
    #define __Pyx_CREAL(z) (__real__(z))
    #define __Pyx_CIMAG(z) (__imag__(z))
  #endif
#else
    #define __Pyx_CREAL(z) ((z).real)
    #define __Pyx_CIMAG(z) ((z).imag)
#endif
#if defined(__cplusplus) && CYTHON_CCOMPLEX         && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
    #define __Pyx_SET_CREAL(z,x) ((z).real(x))
    #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
#else
    #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
    #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
#endif

/* None.proto */
static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);

/* None.proto */
#if CYTHON_CCOMPLEX
    #define __Pyx_c_eqf(a, b)   ((a)==(b))
    #define __Pyx_c_sumf(a, b)  ((a)+(b))
    #define __Pyx_c_difff(a, b) ((a)-(b))
    #define __Pyx_c_prodf(a, b) ((a)*(b))
    #define __Pyx_c_quotf(a, b) ((a)/(b))
    #define __Pyx_c_negf(a)     (-(a))
  #ifdef __cplusplus
    #define __Pyx_c_is_zerof(z) ((z)==(float)0)
    #define __Pyx_c_conjf(z)    (::std::conj(z))
    #if 1
        #define __Pyx_c_absf(z)     (::std::abs(z))
        #define __Pyx_c_powf(a, b)  (::std::pow(a, b))
    #endif
  #else
    #define __Pyx_c_is_zerof(z) ((z)==0)
    #define __Pyx_c_conjf(z)    (conjf(z))
    #if 1
        #define __Pyx_c_absf(z)     (cabsf(z))
        #define __Pyx_c_powf(a, b)  (cpowf(a, b))
    #endif
 #endif
#else
    static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex);
    static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex);
    #if 1
        static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex);
        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex);
    #endif
#endif

/* None.proto */
static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);

/* None.proto */
#if CYTHON_CCOMPLEX
    #define __Pyx_c_eq(a, b)   ((a)==(b))
    #define __Pyx_c_sum(a, b)  ((a)+(b))
    #define __Pyx_c_diff(a, b) ((a)-(b))
    #define __Pyx_c_prod(a, b) ((a)*(b))
    #define __Pyx_c_quot(a, b) ((a)/(b))
    #define __Pyx_c_neg(a)     (-(a))
  #ifdef __cplusplus
    #define __Pyx_c_is_zero(z) ((z)==(double)0)
    #define __Pyx_c_conj(z)    (::std::conj(z))
    #if 1
        #define __Pyx_c_abs(z)     (::std::abs(z))
        #define __Pyx_c_pow(a, b)  (::std::pow(a, b))
    #endif
  #else
    #define __Pyx_c_is_zero(z) ((z)==0)
    #define __Pyx_c_conj(z)    (conj(z))
    #if 1
        #define __Pyx_c_abs(z)     (cabs(z))
        #define __Pyx_c_pow(a, b)  (cpow(a, b))
    #endif
 #endif
#else
    static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex);
    static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex);
    #if 1
        static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex);
        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex);
    #endif
#endif

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);

/* CIntFromPy.proto */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE int64 __Pyx_PyInt_As_int64(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE Py_intptr_t __Pyx_PyInt_As_Py_intptr_t(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);

/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);

/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(void);

/* PyIdentifierFromString.proto */
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif

/* ModuleImport.proto */
static PyObject *__Pyx_ImportModule(const char *name);

/* TypeImport.proto */
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);

/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);


/* Module declarations from 'cpython.buffer' */

/* Module declarations from 'libc.string' */

/* Module declarations from 'libc.stdio' */

/* Module declarations from '__builtin__' */

/* Module declarations from 'cpython.type' */
static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;

/* Module declarations from 'cpython' */

/* Module declarations from 'cpython.object' */

/* Module declarations from 'cpython.ref' */

/* Module declarations from 'libc.stdlib' */

/* Module declarations from 'numpy' */

/* Module declarations from 'numpy' */
static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/

/* Module declarations from 'libcpp' */

/* Module declarations from 'cython' */

/* Module declarations from 'libcpp.vector' */

/* Module declarations from '_common' */

/* Module declarations from 'healpy._pixelfunc' */
static bool __pyx_f_6healpy_10_pixelfunc_isnsideok(int); /*proto*/
static __Pyx_TypeInfo __Pyx_TypeInfo_nn_int64 = { "int64", NULL, sizeof(int64), { 0 }, 0, IS_UNSIGNED(int64) ? 'U' : 'I', IS_UNSIGNED(int64), 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo_nn_bool = { "bool", NULL, sizeof(bool), { 0 }, 0, IS_UNSIGNED(bool) ? 'U' : 'I', IS_UNSIGNED(bool), 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float64_t = { "float64_t", NULL, sizeof(__pyx_t_5numpy_float64_t), { 0 }, 0, 'R', 0, 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo___pyx_t_double_complex = { "double complex", NULL, sizeof(__pyx_t_double_complex), { 0 }, 0, 'C', 0, 0 };
#define __Pyx_MODULE_NAME "healpy._pixelfunc"
int __pyx_module_is_main_healpy___pixelfunc = 0;

/* Implementation of 'healpy._pixelfunc' */
static PyObject *__pyx_builtin_ValueError;
static PyObject *__pyx_builtin_range;
static PyObject *__pyx_builtin_round;
static PyObject *__pyx_builtin_RuntimeError;
static const char __pyx_k_i[] = "i";
static const char __pyx_k_hb[] = "hb";
static const char __pyx_k_np[] = "np";
static const char __pyx_k_num[] = "num";
static const char __pyx_k_pix[] = "pix";
static const char __pyx_k_bool[] = "bool";
static const char __pyx_k_log2[] = "log2";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_nest[] = "nest";
static const char __pyx_k_ring[] = "ring";
static const char __pyx_k_size[] = "size";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_dtype[] = "dtype";
static const char __pyx_k_empty[] = "empty";
static const char __pyx_k_float[] = "float";
static const char __pyx_k_int64[] = "int64";
static const char __pyx_k_nside[] = "nside";
static const char __pyx_k_numpy[] = "numpy";
static const char __pyx_k_range[] = "range";
static const char __pyx_k_round[] = "round";
static const char __pyx_k_import[] = "__import__";
static const char __pyx_k_scheme[] = "scheme";
static const char __pyx_k_ringpix[] = "ringpix";
static const char __pyx_k_shifted[] = "shifted";
static const char __pyx_k_costheta[] = "costheta";
static const char __pyx_k_pix2ring[] = "pix2ring";
static const char __pyx_k_ringinfo[] = "ringinfo";
static const char __pyx_k_sintheta[] = "sintheta";
static const char __pyx_k_startpix[] = "startpix";
static const char __pyx_k_ValueError[] = "ValueError";
static const char __pyx_k_RuntimeError[] = "RuntimeError";
static const char __pyx_k_ringinfo_line_9[] = "ringinfo (line 9)";
static const char __pyx_k_pix2ring_line_58[] = "pix2ring (line 58)";
static const char __pyx_k_healpy__pixelfunc[] = "healpy._pixelfunc";
static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
static const char __pyx_k_Get_information_for_rings_Rings[] = "Get information for rings\n\n    Rings are specified by a positive integer, 1 <= ring <= 4*nside-1.\n\n    Parameters\n    ----------\n    nside : int\n      The healpix nside parameter, must be a power of 2, less than 2**30\n    ring : int, scalar or array-like\n      The ring number\n\n    Returns\n    -------\n    startpix : int64, length equal to that of *ring*\n      Starting pixel identifier (NEST ordering)\n    ringpix : int64, length equal to that of *ring*\n      Number of pixels in ring\n    costheta : float, length equal to that of *ring*\n      Cosine of the co-latitude\n    sintheta : float, length equal to that of *ring*\n      Sine of the co-latitude\n    shifted : bool, length equal to that of *ring*\n      If True, the center of the first pixel is not at phi=0\n\n    Example\n    -------\n    >>> import healpy as hp\n    >>> import numpy as np\n    >>> nside = 2\n    >>> hp.ringinfo(nside, np.arange(4*nside-1))\n    (array([ 0,  0,  4, 12, 20, 28, 36]), array([0, 4, 8, 8, 8, 8, 8]), array([ 1.        ,  0.91666667,  0.66666667,  0.33333333,  0.        ,\n           -0.33333333, -0.66666667]), array([ 0.        ,  0.39965263,  0.74535599,  0.94280904,  1.        ,\n            0.94280904,  0.74535599]), array([ True,  True,  True, False,  True, False,  True], dtype=bool))\n    ";
static const char __pyx_k_home_zonca_zonca_p_software_hea[] = "/home/zonca/zonca/p/software/healpy/healpy/src/_pixelfunc.pyx";
static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
static const char __pyx_k_Convert_pixel_identifier_to_ring[] = "Convert pixel identifier to ring number\n\n    Rings are specified by a positive integer, 1 <= ring <= 4*nside-1.\n\n    Parameters\n    ----------\n    nside : int\n      The healpix nside parameter, must be a power of 2, less than 2**30\n    pix : int64, scalar or array-like\n      The pixel identifier(s)\n    nest : bool\n      Is *pix* specified in the NEST ordering scheme?\n\n    Returns\n    -------\n    ring : int, length equal to that of *pix*\n      Ring number\n\n    Example\n    -------\n    >>> import healpy as hp\n    >>> import numpy as np\n    >>> nside = 2\n    >>> hp.pix2ring(nside, np.arange(hp.nside2npix(nside)))\n    array([1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4,\n           4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,\n           7, 7])\n    ";
static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
static const char __pyx_k_Wrong_nside_value_must_be_a_powe[] = "Wrong nside value, must be a power of 2, less than 2**30";
static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
static PyObject *__pyx_kp_u_Convert_pixel_identifier_to_ring;
static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
static PyObject *__pyx_kp_u_Get_information_for_rings_Rings;
static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
static PyObject *__pyx_n_s_RuntimeError;
static PyObject *__pyx_n_s_ValueError;
static PyObject *__pyx_kp_s_Wrong_nside_value_must_be_a_powe;
static PyObject *__pyx_n_s_bool;
static PyObject *__pyx_n_s_costheta;
static PyObject *__pyx_n_s_dtype;
static PyObject *__pyx_n_s_empty;
static PyObject *__pyx_n_s_float;
static PyObject *__pyx_n_s_hb;
static PyObject *__pyx_n_s_healpy__pixelfunc;
static PyObject *__pyx_kp_s_home_zonca_zonca_p_software_hea;
static PyObject *__pyx_n_s_i;
static PyObject *__pyx_n_s_import;
static PyObject *__pyx_n_s_int64;
static PyObject *__pyx_n_s_log2;
static PyObject *__pyx_n_s_main;
static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
static PyObject *__pyx_n_s_nest;
static PyObject *__pyx_n_s_np;
static PyObject *__pyx_n_s_nside;
static PyObject *__pyx_n_s_num;
static PyObject *__pyx_n_s_numpy;
static PyObject *__pyx_n_s_pix;
static PyObject *__pyx_n_s_pix2ring;
static PyObject *__pyx_kp_u_pix2ring_line_58;
static PyObject *__pyx_n_s_range;
static PyObject *__pyx_n_s_ring;
static PyObject *__pyx_n_s_ringinfo;
static PyObject *__pyx_kp_u_ringinfo_line_9;
static PyObject *__pyx_n_s_ringpix;
static PyObject *__pyx_n_s_round;
static PyObject *__pyx_n_s_scheme;
static PyObject *__pyx_n_s_shifted;
static PyObject *__pyx_n_s_sintheta;
static PyObject *__pyx_n_s_size;
static PyObject *__pyx_n_s_startpix;
static PyObject *__pyx_n_s_test;
static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
static PyObject *__pyx_pf_6healpy_10_pixelfunc_ringinfo(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyArrayObject *__pyx_v_ring); /* proto */
static PyObject *__pyx_pf_6healpy_10_pixelfunc_2pix2ring(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyArrayObject *__pyx_v_pix, PyObject *__pyx_v_nest); /* proto */
static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
static PyObject *__pyx_int_2;
static PyObject *__pyx_tuple_;
static PyObject *__pyx_tuple__2;
static PyObject *__pyx_tuple__3;
static PyObject *__pyx_tuple__4;
static PyObject *__pyx_tuple__5;
static PyObject *__pyx_tuple__6;
static PyObject *__pyx_tuple__7;
static PyObject *__pyx_tuple__8;
static PyObject *__pyx_tuple__9;
static PyObject *__pyx_tuple__11;
static PyObject *__pyx_codeobj__10;
static PyObject *__pyx_codeobj__12;

/* "healpy/src/_pixelfunc.pyx":9
 * from _common cimport int64, Healpix_Ordering_Scheme, RING, NEST, SET_NSIDE, T_Healpix_Base
 * 
 * def ringinfo(nside, np.ndarray[int64, ndim=1] ring not None):             # <<<<<<<<<<<<<<
 *     """Get information for rings
 * 
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_10_pixelfunc_1ringinfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_10_pixelfunc_ringinfo[] = "ringinfo(nside, ndarray ring)\nGet information for rings\n\n    Rings are specified by a positive integer, 1 <= ring <= 4*nside-1.\n\n    Parameters\n    ----------\n    nside : int\n      The healpix nside parameter, must be a power of 2, less than 2**30\n    ring : int, scalar or array-like\n      The ring number\n\n    Returns\n    -------\n    startpix : int64, length equal to that of *ring*\n      Starting pixel identifier (NEST ordering)\n    ringpix : int64, length equal to that of *ring*\n      Number of pixels in ring\n    costheta : float, length equal to that of *ring*\n      Cosine of the co-latitude\n    sintheta : float, length equal to that of *ring*\n      Sine of the co-latitude\n    shifted : bool, length equal to that of *ring*\n      If True, the center of the first pixel is not at phi=0\n\n    Example\n    -------\n    >>> import healpy as hp\n    >>> import numpy as np\n    >>> nside = 2\n    >>> hp.ringinfo(nside, np.arange(4*nside-1))\n    (array([ 0,  0,  4, 12, 20, 28, 36]), array([0, 4, 8, 8, 8, 8, 8]), array([ 1.        ,  0.91666667,  0.66666667,  0.33333333,  0.        ,\n           -0.33333333, -0.66666667]), array([ 0.        ,  0.39965263,  0.74535599,  0.94280904,  1.        ,\n            0.94280904,  0.74535599]), array([ True,  True,  True, False,  True, False,  True], dtype=bool))\n    ";
static PyMethodDef __pyx_mdef_6healpy_10_pixelfunc_1ringinfo = {"ringinfo", (PyCFunction)__pyx_pw_6healpy_10_pixelfunc_1ringinfo, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_10_pixelfunc_ringinfo};
static PyObject *__pyx_pw_6healpy_10_pixelfunc_1ringinfo(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nside = 0;
  PyArrayObject *__pyx_v_ring = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ringinfo (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nside,&__pyx_n_s_ring,0};
    PyObject* values[2] = {0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nside)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ring)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("ringinfo", 1, 2, 2, 1); __PYX_ERR(0, 9, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ringinfo") < 0)) __PYX_ERR(0, 9, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
    }
    __pyx_v_nside = values[0];
    __pyx_v_ring = ((PyArrayObject *)values[1]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ringinfo", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 9, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._pixelfunc.ringinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ring), __pyx_ptype_5numpy_ndarray, 0, "ring", 0))) __PYX_ERR(0, 9, __pyx_L1_error)
  __pyx_r = __pyx_pf_6healpy_10_pixelfunc_ringinfo(__pyx_self, __pyx_v_nside, __pyx_v_ring);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_10_pixelfunc_ringinfo(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyArrayObject *__pyx_v_ring) {
  enum Healpix_Ordering_Scheme __pyx_v_scheme;
  T_Healpix_Base  __pyx_v_hb;
  npy_intp __pyx_v_num;
  PyArrayObject *__pyx_v_startpix = 0;
  PyArrayObject *__pyx_v_ringpix = 0;
  PyArrayObject *__pyx_v_costheta = 0;
  PyArrayObject *__pyx_v_sintheta = 0;
  PyArrayObject *__pyx_v_shifted = 0;
  npy_intp __pyx_v_i;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_costheta;
  __Pyx_Buffer __pyx_pybuffer_costheta;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_ring;
  __Pyx_Buffer __pyx_pybuffer_ring;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_ringpix;
  __Pyx_Buffer __pyx_pybuffer_ringpix;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_shifted;
  __Pyx_Buffer __pyx_pybuffer_shifted;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_sintheta;
  __Pyx_Buffer __pyx_pybuffer_sintheta;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_startpix;
  __Pyx_Buffer __pyx_pybuffer_startpix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int64 __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyArrayObject *__pyx_t_9 = NULL;
  PyArrayObject *__pyx_t_10 = NULL;
  PyArrayObject *__pyx_t_11 = NULL;
  PyArrayObject *__pyx_t_12 = NULL;
  PyArrayObject *__pyx_t_13 = NULL;
  npy_intp __pyx_t_14;
  npy_intp __pyx_t_15;
  Py_ssize_t __pyx_t_16;
  Py_ssize_t __pyx_t_17;
  Py_ssize_t __pyx_t_18;
  Py_ssize_t __pyx_t_19;
  Py_ssize_t __pyx_t_20;
  Py_ssize_t __pyx_t_21;
  __Pyx_RefNannySetupContext("ringinfo", 0);
  __pyx_pybuffer_startpix.pybuffer.buf = NULL;
  __pyx_pybuffer_startpix.refcount = 0;
  __pyx_pybuffernd_startpix.data = NULL;
  __pyx_pybuffernd_startpix.rcbuffer = &__pyx_pybuffer_startpix;
  __pyx_pybuffer_ringpix.pybuffer.buf = NULL;
  __pyx_pybuffer_ringpix.refcount = 0;
  __pyx_pybuffernd_ringpix.data = NULL;
  __pyx_pybuffernd_ringpix.rcbuffer = &__pyx_pybuffer_ringpix;
  __pyx_pybuffer_costheta.pybuffer.buf = NULL;
  __pyx_pybuffer_costheta.refcount = 0;
  __pyx_pybuffernd_costheta.data = NULL;
  __pyx_pybuffernd_costheta.rcbuffer = &__pyx_pybuffer_costheta;
  __pyx_pybuffer_sintheta.pybuffer.buf = NULL;
  __pyx_pybuffer_sintheta.refcount = 0;
  __pyx_pybuffernd_sintheta.data = NULL;
  __pyx_pybuffernd_sintheta.rcbuffer = &__pyx_pybuffer_sintheta;
  __pyx_pybuffer_shifted.pybuffer.buf = NULL;
  __pyx_pybuffer_shifted.refcount = 0;
  __pyx_pybuffernd_shifted.data = NULL;
  __pyx_pybuffernd_shifted.rcbuffer = &__pyx_pybuffer_shifted;
  __pyx_pybuffer_ring.pybuffer.buf = NULL;
  __pyx_pybuffer_ring.refcount = 0;
  __pyx_pybuffernd_ring.data = NULL;
  __pyx_pybuffernd_ring.rcbuffer = &__pyx_pybuffer_ring;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ring.rcbuffer->pybuffer, (PyObject*)__pyx_v_ring, &__Pyx_TypeInfo_nn_int64, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 9, __pyx_L1_error)
  }
  __pyx_pybuffernd_ring.diminfo[0].strides = __pyx_pybuffernd_ring.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ring.diminfo[0].shape = __pyx_pybuffernd_ring.rcbuffer->pybuffer.shape[0];

  /* "healpy/src/_pixelfunc.pyx":44
 *             0.94280904,  0.74535599]), array([ True,  True,  True, False,  True, False,  True], dtype=bool))
 *     """
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef Healpix_Ordering_Scheme scheme = NEST
 */
  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_nside); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L1_error)
  __pyx_t_2 = ((!(__pyx_f_6healpy_10_pixelfunc_isnsideok(__pyx_t_1) != 0)) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_pixelfunc.pyx":45
 *     """
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme = NEST
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 45, __pyx_L1_error)

    /* "healpy/src/_pixelfunc.pyx":44
 *             0.94280904,  0.74535599]), array([ True,  True,  True, False,  True, False,  True], dtype=bool))
 *     """
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef Healpix_Ordering_Scheme scheme = NEST
 */
  }

  /* "healpy/src/_pixelfunc.pyx":46
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef Healpix_Ordering_Scheme scheme = NEST             # <<<<<<<<<<<<<<
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     num = ring.shape[0]
 */
  __pyx_v_scheme = NEST;

  /* "healpy/src/_pixelfunc.pyx":47
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef Healpix_Ordering_Scheme scheme = NEST
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)             # <<<<<<<<<<<<<<
 *     num = ring.shape[0]
 *     cdef np.ndarray[int64, ndim=1] startpix = np.empty(num, dtype=np.int64)
 */
  __pyx_t_4 = __Pyx_PyInt_As_int64(__pyx_v_nside); if (unlikely((__pyx_t_4 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 47, __pyx_L1_error)
  __pyx_v_hb = T_Healpix_Base (__pyx_t_4, __pyx_v_scheme, SET_NSIDE);

  /* "healpy/src/_pixelfunc.pyx":48
 *     cdef Healpix_Ordering_Scheme scheme = NEST
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     num = ring.shape[0]             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[int64, ndim=1] startpix = np.empty(num, dtype=np.int64)
 *     cdef np.ndarray[int64, ndim=1] ringpix = np.empty(num, dtype=np.int64)
 */
  __pyx_v_num = (__pyx_v_ring->dimensions[0]);

  /* "healpy/src/_pixelfunc.pyx":49
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     num = ring.shape[0]
 *     cdef np.ndarray[int64, ndim=1] startpix = np.empty(num, dtype=np.int64)             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[int64, ndim=1] ringpix = np.empty(num, dtype=np.int64)
 *     cdef np.ndarray[double, ndim=1] costheta = np.empty(num, dtype=np.float)
 */
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_num); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int64); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 49, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_8);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_startpix.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn_int64, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
      __pyx_v_startpix = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_startpix.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 49, __pyx_L1_error)
    } else {__pyx_pybuffernd_startpix.diminfo[0].strides = __pyx_pybuffernd_startpix.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_startpix.diminfo[0].shape = __pyx_pybuffernd_startpix.rcbuffer->pybuffer.shape[0];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_startpix = ((PyArrayObject *)__pyx_t_8);
  __pyx_t_8 = 0;

  /* "healpy/src/_pixelfunc.pyx":50
 *     num = ring.shape[0]
 *     cdef np.ndarray[int64, ndim=1] startpix = np.empty(num, dtype=np.int64)
 *     cdef np.ndarray[int64, ndim=1] ringpix = np.empty(num, dtype=np.int64)             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[double, ndim=1] costheta = np.empty(num, dtype=np.float)
 *     cdef np.ndarray[double, ndim=1] sintheta = np.empty(num, dtype=np.float)
 */
  __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_num); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_8);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8);
  __pyx_t_8 = 0;
  __pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 50, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 50, __pyx_L1_error)
  __pyx_t_10 = ((PyArrayObject *)__pyx_t_7);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ringpix.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn_int64, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
      __pyx_v_ringpix = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ringpix.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 50, __pyx_L1_error)
    } else {__pyx_pybuffernd_ringpix.diminfo[0].strides = __pyx_pybuffernd_ringpix.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ringpix.diminfo[0].shape = __pyx_pybuffernd_ringpix.rcbuffer->pybuffer.shape[0];
    }
  }
  __pyx_t_10 = 0;
  __pyx_v_ringpix = ((PyArrayObject *)__pyx_t_7);
  __pyx_t_7 = 0;

  /* "healpy/src/_pixelfunc.pyx":51
 *     cdef np.ndarray[int64, ndim=1] startpix = np.empty(num, dtype=np.int64)
 *     cdef np.ndarray[int64, ndim=1] ringpix = np.empty(num, dtype=np.int64)
 *     cdef np.ndarray[double, ndim=1] costheta = np.empty(num, dtype=np.float)             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[double, ndim=1] sintheta = np.empty(num, dtype=np.float)
 *     cdef np.ndarray[bool, ndim=1, cast=True] shifted = np.empty(num, dtype=np.bool)
 */
  __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __pyx_t_7 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_num); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
  __pyx_t_7 = 0;
  __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 51, __pyx_L1_error)
  __pyx_t_11 = ((PyArrayObject *)__pyx_t_5);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_costheta.rcbuffer->pybuffer, (PyObject*)__pyx_t_11, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
      __pyx_v_costheta = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_costheta.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 51, __pyx_L1_error)
    } else {__pyx_pybuffernd_costheta.diminfo[0].strides = __pyx_pybuffernd_costheta.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_costheta.diminfo[0].shape = __pyx_pybuffernd_costheta.rcbuffer->pybuffer.shape[0];
    }
  }
  __pyx_t_11 = 0;
  __pyx_v_costheta = ((PyArrayObject *)__pyx_t_5);
  __pyx_t_5 = 0;

  /* "healpy/src/_pixelfunc.pyx":52
 *     cdef np.ndarray[int64, ndim=1] ringpix = np.empty(num, dtype=np.int64)
 *     cdef np.ndarray[double, ndim=1] costheta = np.empty(num, dtype=np.float)
 *     cdef np.ndarray[double, ndim=1] sintheta = np.empty(num, dtype=np.float)             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[bool, ndim=1, cast=True] shifted = np.empty(num, dtype=np.bool)
 *     for i in range(num):
 */
  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_num); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
  __pyx_t_5 = 0;
  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 52, __pyx_L1_error)
  __pyx_t_12 = ((PyArrayObject *)__pyx_t_3);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sintheta.rcbuffer->pybuffer, (PyObject*)__pyx_t_12, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
      __pyx_v_sintheta = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sintheta.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 52, __pyx_L1_error)
    } else {__pyx_pybuffernd_sintheta.diminfo[0].strides = __pyx_pybuffernd_sintheta.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sintheta.diminfo[0].shape = __pyx_pybuffernd_sintheta.rcbuffer->pybuffer.shape[0];
    }
  }
  __pyx_t_12 = 0;
  __pyx_v_sintheta = ((PyArrayObject *)__pyx_t_3);
  __pyx_t_3 = 0;

  /* "healpy/src/_pixelfunc.pyx":53
 *     cdef np.ndarray[double, ndim=1] costheta = np.empty(num, dtype=np.float)
 *     cdef np.ndarray[double, ndim=1] sintheta = np.empty(num, dtype=np.float)
 *     cdef np.ndarray[bool, ndim=1, cast=True] shifted = np.empty(num, dtype=np.bool)             # <<<<<<<<<<<<<<
 *     for i in range(num):
 *         hb.get_ring_info(ring[i], startpix[i], ringpix[i], costheta[i], sintheta[i], shifted[i])
 */
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_num); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_bool); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 53, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 53, __pyx_L1_error)
  __pyx_t_13 = ((PyArrayObject *)__pyx_t_8);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_shifted.rcbuffer->pybuffer, (PyObject*)__pyx_t_13, &__Pyx_TypeInfo_nn_bool, PyBUF_FORMAT| PyBUF_STRIDES, 1, 1, __pyx_stack) == -1)) {
      __pyx_v_shifted = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_shifted.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 53, __pyx_L1_error)
    } else {__pyx_pybuffernd_shifted.diminfo[0].strides = __pyx_pybuffernd_shifted.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_shifted.diminfo[0].shape = __pyx_pybuffernd_shifted.rcbuffer->pybuffer.shape[0];
    }
  }
  __pyx_t_13 = 0;
  __pyx_v_shifted = ((PyArrayObject *)__pyx_t_8);
  __pyx_t_8 = 0;

  /* "healpy/src/_pixelfunc.pyx":54
 *     cdef np.ndarray[double, ndim=1] sintheta = np.empty(num, dtype=np.float)
 *     cdef np.ndarray[bool, ndim=1, cast=True] shifted = np.empty(num, dtype=np.bool)
 *     for i in range(num):             # <<<<<<<<<<<<<<
 *         hb.get_ring_info(ring[i], startpix[i], ringpix[i], costheta[i], sintheta[i], shifted[i])
 *     return startpix, ringpix, costheta, sintheta, shifted
 */
  __pyx_t_14 = __pyx_v_num;
  for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
    __pyx_v_i = __pyx_t_15;

    /* "healpy/src/_pixelfunc.pyx":55
 *     cdef np.ndarray[bool, ndim=1, cast=True] shifted = np.empty(num, dtype=np.bool)
 *     for i in range(num):
 *         hb.get_ring_info(ring[i], startpix[i], ringpix[i], costheta[i], sintheta[i], shifted[i])             # <<<<<<<<<<<<<<
 *     return startpix, ringpix, costheta, sintheta, shifted
 * 
 */
    __pyx_t_16 = __pyx_v_i;
    __pyx_t_1 = -1;
    if (__pyx_t_16 < 0) {
      __pyx_t_16 += __pyx_pybuffernd_ring.diminfo[0].shape;
      if (unlikely(__pyx_t_16 < 0)) __pyx_t_1 = 0;
    } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_ring.diminfo[0].shape)) __pyx_t_1 = 0;
    if (unlikely(__pyx_t_1 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_1);
      __PYX_ERR(0, 55, __pyx_L1_error)
    }
    __pyx_t_17 = __pyx_v_i;
    __pyx_t_1 = -1;
    if (__pyx_t_17 < 0) {
      __pyx_t_17 += __pyx_pybuffernd_startpix.diminfo[0].shape;
      if (unlikely(__pyx_t_17 < 0)) __pyx_t_1 = 0;
    } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_startpix.diminfo[0].shape)) __pyx_t_1 = 0;
    if (unlikely(__pyx_t_1 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_1);
      __PYX_ERR(0, 55, __pyx_L1_error)
    }
    __pyx_t_18 = __pyx_v_i;
    __pyx_t_1 = -1;
    if (__pyx_t_18 < 0) {
      __pyx_t_18 += __pyx_pybuffernd_ringpix.diminfo[0].shape;
      if (unlikely(__pyx_t_18 < 0)) __pyx_t_1 = 0;
    } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_ringpix.diminfo[0].shape)) __pyx_t_1 = 0;
    if (unlikely(__pyx_t_1 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_1);
      __PYX_ERR(0, 55, __pyx_L1_error)
    }
    __pyx_t_19 = __pyx_v_i;
    __pyx_t_1 = -1;
    if (__pyx_t_19 < 0) {
      __pyx_t_19 += __pyx_pybuffernd_costheta.diminfo[0].shape;
      if (unlikely(__pyx_t_19 < 0)) __pyx_t_1 = 0;
    } else if (unlikely(__pyx_t_19 >= __pyx_pybuffernd_costheta.diminfo[0].shape)) __pyx_t_1 = 0;
    if (unlikely(__pyx_t_1 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_1);
      __PYX_ERR(0, 55, __pyx_L1_error)
    }
    __pyx_t_20 = __pyx_v_i;
    __pyx_t_1 = -1;
    if (__pyx_t_20 < 0) {
      __pyx_t_20 += __pyx_pybuffernd_sintheta.diminfo[0].shape;
      if (unlikely(__pyx_t_20 < 0)) __pyx_t_1 = 0;
    } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_sintheta.diminfo[0].shape)) __pyx_t_1 = 0;
    if (unlikely(__pyx_t_1 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_1);
      __PYX_ERR(0, 55, __pyx_L1_error)
    }
    __pyx_t_21 = __pyx_v_i;
    __pyx_t_1 = -1;
    if (__pyx_t_21 < 0) {
      __pyx_t_21 += __pyx_pybuffernd_shifted.diminfo[0].shape;
      if (unlikely(__pyx_t_21 < 0)) __pyx_t_1 = 0;
    } else if (unlikely(__pyx_t_21 >= __pyx_pybuffernd_shifted.diminfo[0].shape)) __pyx_t_1 = 0;
    if (unlikely(__pyx_t_1 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_1);
      __PYX_ERR(0, 55, __pyx_L1_error)
    }
    __pyx_v_hb.get_ring_info((*__Pyx_BufPtrStrided1d(int64 *, __pyx_pybuffernd_ring.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_ring.diminfo[0].strides)), (*__Pyx_BufPtrStrided1d(int64 *, __pyx_pybuffernd_startpix.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_startpix.diminfo[0].strides)), (*__Pyx_BufPtrStrided1d(int64 *, __pyx_pybuffernd_ringpix.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_ringpix.diminfo[0].strides)), (*__Pyx_BufPtrStrided1d(double *, __pyx_pybuffernd_costheta.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_costheta.diminfo[0].strides)), (*__Pyx_BufPtrStrided1d(double *, __pyx_pybuffernd_sintheta.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_sintheta.diminfo[0].strides)), (*__Pyx_BufPtrStrided1d(bool *, __pyx_pybuffernd_shifted.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_shifted.diminfo[0].strides)));
  }

  /* "healpy/src/_pixelfunc.pyx":56
 *     for i in range(num):
 *         hb.get_ring_info(ring[i], startpix[i], ringpix[i], costheta[i], sintheta[i], shifted[i])
 *     return startpix, ringpix, costheta, sintheta, shifted             # <<<<<<<<<<<<<<
 * 
 * def pix2ring(nside, np.ndarray[int64, ndim=1] pix not None, nest=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_8 = PyTuple_New(5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 56, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_INCREF(((PyObject *)__pyx_v_startpix));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_startpix));
  PyTuple_SET_ITEM(__pyx_t_8, 0, ((PyObject *)__pyx_v_startpix));
  __Pyx_INCREF(((PyObject *)__pyx_v_ringpix));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_ringpix));
  PyTuple_SET_ITEM(__pyx_t_8, 1, ((PyObject *)__pyx_v_ringpix));
  __Pyx_INCREF(((PyObject *)__pyx_v_costheta));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_costheta));
  PyTuple_SET_ITEM(__pyx_t_8, 2, ((PyObject *)__pyx_v_costheta));
  __Pyx_INCREF(((PyObject *)__pyx_v_sintheta));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_sintheta));
  PyTuple_SET_ITEM(__pyx_t_8, 3, ((PyObject *)__pyx_v_sintheta));
  __Pyx_INCREF(((PyObject *)__pyx_v_shifted));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_shifted));
  PyTuple_SET_ITEM(__pyx_t_8, 4, ((PyObject *)__pyx_v_shifted));
  __pyx_r = __pyx_t_8;
  __pyx_t_8 = 0;
  goto __pyx_L0;

  /* "healpy/src/_pixelfunc.pyx":9
 * from _common cimport int64, Healpix_Ordering_Scheme, RING, NEST, SET_NSIDE, T_Healpix_Base
 * 
 * def ringinfo(nside, np.ndarray[int64, ndim=1] ring not None):             # <<<<<<<<<<<<<<
 *     """Get information for rings
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_costheta.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ring.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ringpix.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_shifted.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sintheta.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_startpix.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._pixelfunc.ringinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_costheta.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ring.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ringpix.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_shifted.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sintheta.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_startpix.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_startpix);
  __Pyx_XDECREF((PyObject *)__pyx_v_ringpix);
  __Pyx_XDECREF((PyObject *)__pyx_v_costheta);
  __Pyx_XDECREF((PyObject *)__pyx_v_sintheta);
  __Pyx_XDECREF((PyObject *)__pyx_v_shifted);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_pixelfunc.pyx":58
 *     return startpix, ringpix, costheta, sintheta, shifted
 * 
 * def pix2ring(nside, np.ndarray[int64, ndim=1] pix not None, nest=False):             # <<<<<<<<<<<<<<
 *     """Convert pixel identifier to ring number
 * 
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_10_pixelfunc_3pix2ring(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_10_pixelfunc_2pix2ring[] = "pix2ring(nside, ndarray pix, nest=False)\nConvert pixel identifier to ring number\n\n    Rings are specified by a positive integer, 1 <= ring <= 4*nside-1.\n\n    Parameters\n    ----------\n    nside : int\n      The healpix nside parameter, must be a power of 2, less than 2**30\n    pix : int64, scalar or array-like\n      The pixel identifier(s)\n    nest : bool\n      Is *pix* specified in the NEST ordering scheme?\n\n    Returns\n    -------\n    ring : int, length equal to that of *pix*\n      Ring number\n\n    Example\n    -------\n    >>> import healpy as hp\n    >>> import numpy as np\n    >>> nside = 2\n    >>> hp.pix2ring(nside, np.arange(hp.nside2npix(nside)))\n    array([1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4,\n           4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,\n           7, 7])\n    ";
static PyMethodDef __pyx_mdef_6healpy_10_pixelfunc_3pix2ring = {"pix2ring", (PyCFunction)__pyx_pw_6healpy_10_pixelfunc_3pix2ring, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_10_pixelfunc_2pix2ring};
static PyObject *__pyx_pw_6healpy_10_pixelfunc_3pix2ring(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nside = 0;
  PyArrayObject *__pyx_v_pix = 0;
  PyObject *__pyx_v_nest = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("pix2ring (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nside,&__pyx_n_s_pix,&__pyx_n_s_nest,0};
    PyObject* values[3] = {0,0,0};
    values[2] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nside)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pix)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("pix2ring", 0, 2, 3, 1); __PYX_ERR(0, 58, __pyx_L3_error)
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nest);
          if (value) { values[2] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "pix2ring") < 0)) __PYX_ERR(0, 58, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nside = values[0];
    __pyx_v_pix = ((PyArrayObject *)values[1]);
    __pyx_v_nest = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("pix2ring", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 58, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._pixelfunc.pix2ring", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pix), __pyx_ptype_5numpy_ndarray, 0, "pix", 0))) __PYX_ERR(0, 58, __pyx_L1_error)
  __pyx_r = __pyx_pf_6healpy_10_pixelfunc_2pix2ring(__pyx_self, __pyx_v_nside, __pyx_v_pix, __pyx_v_nest);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_10_pixelfunc_2pix2ring(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyArrayObject *__pyx_v_pix, PyObject *__pyx_v_nest) {
  enum Healpix_Ordering_Scheme __pyx_v_scheme;
  T_Healpix_Base  __pyx_v_hb;
  npy_intp __pyx_v_num;
  PyArrayObject *__pyx_v_ring = 0;
  npy_intp __pyx_v_i;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_pix;
  __Pyx_Buffer __pyx_pybuffer_pix;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_ring;
  __Pyx_Buffer __pyx_pybuffer_ring;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int64 __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyArrayObject *__pyx_t_9 = NULL;
  npy_intp __pyx_t_10;
  npy_intp __pyx_t_11;
  Py_ssize_t __pyx_t_12;
  Py_ssize_t __pyx_t_13;
  __Pyx_RefNannySetupContext("pix2ring", 0);
  __pyx_pybuffer_ring.pybuffer.buf = NULL;
  __pyx_pybuffer_ring.refcount = 0;
  __pyx_pybuffernd_ring.data = NULL;
  __pyx_pybuffernd_ring.rcbuffer = &__pyx_pybuffer_ring;
  __pyx_pybuffer_pix.pybuffer.buf = NULL;
  __pyx_pybuffer_pix.refcount = 0;
  __pyx_pybuffernd_pix.data = NULL;
  __pyx_pybuffernd_pix.rcbuffer = &__pyx_pybuffer_pix;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_pix.rcbuffer->pybuffer, (PyObject*)__pyx_v_pix, &__Pyx_TypeInfo_nn_int64, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 58, __pyx_L1_error)
  }
  __pyx_pybuffernd_pix.diminfo[0].strides = __pyx_pybuffernd_pix.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_pix.diminfo[0].shape = __pyx_pybuffernd_pix.rcbuffer->pybuffer.shape[0];

  /* "healpy/src/_pixelfunc.pyx":88
 *     """
 * 
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef Healpix_Ordering_Scheme scheme
 */
  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_nside); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 88, __pyx_L1_error)
  __pyx_t_2 = ((!(__pyx_f_6healpy_10_pixelfunc_isnsideok(__pyx_t_1) != 0)) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_pixelfunc.pyx":89
 * 
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 89, __pyx_L1_error)

    /* "healpy/src/_pixelfunc.pyx":88
 *     """
 * 
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef Healpix_Ordering_Scheme scheme
 */
  }

  /* "healpy/src/_pixelfunc.pyx":91
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_nest); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 91, __pyx_L1_error)
  if (__pyx_t_2) {

    /* "healpy/src/_pixelfunc.pyx":92
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 *         scheme = NEST             # <<<<<<<<<<<<<<
 *     else:
 *         scheme = RING
 */
    __pyx_v_scheme = NEST;

    /* "healpy/src/_pixelfunc.pyx":91
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
    goto __pyx_L4;
  }

  /* "healpy/src/_pixelfunc.pyx":94
 *         scheme = NEST
 *     else:
 *         scheme = RING             # <<<<<<<<<<<<<<
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     num = pix.shape[0]
 */
  /*else*/ {
    __pyx_v_scheme = RING;
  }
  __pyx_L4:;

  /* "healpy/src/_pixelfunc.pyx":95
 *     else:
 *         scheme = RING
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)             # <<<<<<<<<<<<<<
 *     num = pix.shape[0]
 *     cdef np.ndarray[int64, ndim=1] ring = np.empty(num, dtype=np.int64)
 */
  __pyx_t_4 = __Pyx_PyInt_As_int64(__pyx_v_nside); if (unlikely((__pyx_t_4 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L1_error)
  __pyx_v_hb = T_Healpix_Base (__pyx_t_4, __pyx_v_scheme, SET_NSIDE);

  /* "healpy/src/_pixelfunc.pyx":96
 *         scheme = RING
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     num = pix.shape[0]             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[int64, ndim=1] ring = np.empty(num, dtype=np.int64)
 *     for i in range(num):
 */
  __pyx_v_num = (__pyx_v_pix->dimensions[0]);

  /* "healpy/src/_pixelfunc.pyx":97
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     num = pix.shape[0]
 *     cdef np.ndarray[int64, ndim=1] ring = np.empty(num, dtype=np.int64)             # <<<<<<<<<<<<<<
 *     for i in range(num):
 *         ring[i] = hb.pix2ring(pix[i])
 */
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_num); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_int64); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 97, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_8);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ring.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn_int64, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
      __pyx_v_ring = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ring.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 97, __pyx_L1_error)
    } else {__pyx_pybuffernd_ring.diminfo[0].strides = __pyx_pybuffernd_ring.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ring.diminfo[0].shape = __pyx_pybuffernd_ring.rcbuffer->pybuffer.shape[0];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_ring = ((PyArrayObject *)__pyx_t_8);
  __pyx_t_8 = 0;

  /* "healpy/src/_pixelfunc.pyx":98
 *     num = pix.shape[0]
 *     cdef np.ndarray[int64, ndim=1] ring = np.empty(num, dtype=np.int64)
 *     for i in range(num):             # <<<<<<<<<<<<<<
 *         ring[i] = hb.pix2ring(pix[i])
 *     return ring
 */
  __pyx_t_10 = __pyx_v_num;
  for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
    __pyx_v_i = __pyx_t_11;

    /* "healpy/src/_pixelfunc.pyx":99
 *     cdef np.ndarray[int64, ndim=1] ring = np.empty(num, dtype=np.int64)
 *     for i in range(num):
 *         ring[i] = hb.pix2ring(pix[i])             # <<<<<<<<<<<<<<
 *     return ring
 * 
 */
    __pyx_t_12 = __pyx_v_i;
    __pyx_t_1 = -1;
    if (__pyx_t_12 < 0) {
      __pyx_t_12 += __pyx_pybuffernd_pix.diminfo[0].shape;
      if (unlikely(__pyx_t_12 < 0)) __pyx_t_1 = 0;
    } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_pix.diminfo[0].shape)) __pyx_t_1 = 0;
    if (unlikely(__pyx_t_1 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_1);
      __PYX_ERR(0, 99, __pyx_L1_error)
    }
    __pyx_t_13 = __pyx_v_i;
    __pyx_t_1 = -1;
    if (__pyx_t_13 < 0) {
      __pyx_t_13 += __pyx_pybuffernd_ring.diminfo[0].shape;
      if (unlikely(__pyx_t_13 < 0)) __pyx_t_1 = 0;
    } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_ring.diminfo[0].shape)) __pyx_t_1 = 0;
    if (unlikely(__pyx_t_1 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_1);
      __PYX_ERR(0, 99, __pyx_L1_error)
    }
    *__Pyx_BufPtrStrided1d(int64 *, __pyx_pybuffernd_ring.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_ring.diminfo[0].strides) = __pyx_v_hb.pix2ring((*__Pyx_BufPtrStrided1d(int64 *, __pyx_pybuffernd_pix.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_pix.diminfo[0].strides)));
  }

  /* "healpy/src/_pixelfunc.pyx":100
 *     for i in range(num):
 *         ring[i] = hb.pix2ring(pix[i])
 *     return ring             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ring));
  __pyx_r = ((PyObject *)__pyx_v_ring);
  goto __pyx_L0;

  /* "healpy/src/_pixelfunc.pyx":58
 *     return startpix, ringpix, costheta, sintheta, shifted
 * 
 * def pix2ring(nside, np.ndarray[int64, ndim=1] pix not None, nest=False):             # <<<<<<<<<<<<<<
 *     """Convert pixel identifier to ring number
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_pix.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ring.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._pixelfunc.pix2ring", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_pix.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ring.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ring);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_pixelfunc.pyx":103
 * 
 * 
 * cdef bool isnsideok(int nside):             # <<<<<<<<<<<<<<
 *     if nside < 0 or nside != 2**int(round(np.log2(nside))):
 *         return False
 */

static bool __pyx_f_6healpy_10_pixelfunc_isnsideok(int __pyx_v_nside) {
  bool __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  __Pyx_RefNannySetupContext("isnsideok", 0);

  /* "healpy/src/_pixelfunc.pyx":104
 * 
 * cdef bool isnsideok(int nside):
 *     if nside < 0 or nside != 2**int(round(np.log2(nside))):             # <<<<<<<<<<<<<<
 *         return False
 *     else:
 */
  __pyx_t_2 = ((__pyx_v_nside < 0) != 0);
  if (!__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nside); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_log2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_nside); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_7 = NULL;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_7)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
    }
  }
  if (!__pyx_t_7) {
    __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 104, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_GOTREF(__pyx_t_4);
  } else {
    __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 104, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
    __Pyx_GIVEREF(__pyx_t_5);
    PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
    __pyx_t_5 = 0;
    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 104, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
  __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_round, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyNumber_Int(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyNumber_PowerOf2(__pyx_int_2, __pyx_t_6, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 104, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_1 = __pyx_t_2;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {

    /* "healpy/src/_pixelfunc.pyx":105
 * cdef bool isnsideok(int nside):
 *     if nside < 0 or nside != 2**int(round(np.log2(nside))):
 *         return False             # <<<<<<<<<<<<<<
 *     else:
 *         return True
 */
    __pyx_r = 0;
    goto __pyx_L0;

    /* "healpy/src/_pixelfunc.pyx":104
 * 
 * cdef bool isnsideok(int nside):
 *     if nside < 0 or nside != 2**int(round(np.log2(nside))):             # <<<<<<<<<<<<<<
 *         return False
 *     else:
 */
  }

  /* "healpy/src/_pixelfunc.pyx":107
 *         return False
 *     else:
 *         return True             # <<<<<<<<<<<<<<
 * 
 * 
 */
  /*else*/ {
    __pyx_r = 1;
    goto __pyx_L0;
  }

  /* "healpy/src/_pixelfunc.pyx":103
 * 
 * 
 * cdef bool isnsideok(int nside):             # <<<<<<<<<<<<<<
 *     if nside < 0 or nside != 2**int(round(np.log2(nside))):
 *         return False
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_WriteUnraisable("healpy._pixelfunc.isnsideok", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":197
 *         # experimental exception made for __getbuffer__ and __releasebuffer__
 *         # -- the details of this may change.
 *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
 *             # This implementation of getbuffer is geared towards Cython
 *             # requirements, and does not yet fullfill the PEP.
 */

/* Python wrapper */
static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
  int __pyx_v_copy_shape;
  int __pyx_v_i;
  int __pyx_v_ndim;
  int __pyx_v_endian_detector;
  int __pyx_v_little_endian;
  int __pyx_v_t;
  char *__pyx_v_f;
  PyArray_Descr *__pyx_v_descr = 0;
  int __pyx_v_offset;
  int __pyx_v_hasfields;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  char *__pyx_t_7;
  __Pyx_RefNannySetupContext("__getbuffer__", 0);
  if (__pyx_v_info != NULL) {
    __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(__pyx_v_info->obj);
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":203
 *             # of flags
 * 
 *             if info == NULL: return             # <<<<<<<<<<<<<<
 * 
 *             cdef int copy_shape, i, ndim
 */
  __pyx_t_1 = ((__pyx_v_info == NULL) != 0);
  if (__pyx_t_1) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":206
 * 
 *             cdef int copy_shape, i, ndim
 *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)
 * 
 */
  __pyx_v_endian_detector = 1;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":207
 *             cdef int copy_shape, i, ndim
 *             cdef int endian_detector = 1
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
 * 
 *             ndim = PyArray_NDIM(self)
 */
  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":209
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)
 * 
 *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":211
 *             ndim = PyArray_NDIM(self)
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 copy_shape = 1
 *             else:
 */
  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":212
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 copy_shape = 1             # <<<<<<<<<<<<<<
 *             else:
 *                 copy_shape = 0
 */
    __pyx_v_copy_shape = 1;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":211
 *             ndim = PyArray_NDIM(self)
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 copy_shape = 1
 *             else:
 */
    goto __pyx_L4;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":214
 *                 copy_shape = 1
 *             else:
 *                 copy_shape = 0             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 */
  /*else*/ {
    __pyx_v_copy_shape = 0;
  }
  __pyx_L4:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L6_bool_binop_done;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":217
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 */
  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L6_bool_binop_done:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":218
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(1, 218, __pyx_L1_error)

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L9_bool_binop_done;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":221
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 * 
 */
  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L9_bool_binop_done:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":222
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
 * 
 *             info.buf = PyArray_DATA(self)
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 222, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(1, 222, __pyx_L1_error)

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":224
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 * 
 *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
 *             info.ndim = ndim
 *             if copy_shape:
 */
  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":225
 * 
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim             # <<<<<<<<<<<<<<
 *             if copy_shape:
 *                 # Allocate new buffer for strides and shape info.
 */
  __pyx_v_info->ndim = __pyx_v_ndim;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":226
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim
 *             if copy_shape:             # <<<<<<<<<<<<<<
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 */
  __pyx_t_1 = (__pyx_v_copy_shape != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":229
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)             # <<<<<<<<<<<<<<
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):
 */
    __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2)));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":230
 *                 # This is allocated as one block, strides first.
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)
 *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 */
    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":231
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):             # <<<<<<<<<<<<<<
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 */
    __pyx_t_4 = __pyx_v_ndim;
    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
      __pyx_v_i = __pyx_t_5;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":232
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 *             else:
 */
      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":233
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
 *             else:
 *                 info.strides = PyArray_STRIDES(self)
 */
      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":226
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim
 *             if copy_shape:             # <<<<<<<<<<<<<<
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 */
    goto __pyx_L11;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":235
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 *             else:
 *                 info.strides = PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL
 */
  /*else*/ {
    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":236
 *             else:
 *                 info.strides = PyArray_STRIDES(self)
 *                 info.shape = PyArray_DIMS(self)             # <<<<<<<<<<<<<<
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)
 */
    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
  }
  __pyx_L11:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":237
 *                 info.strides = PyArray_STRIDES(self)
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
 *             info.itemsize = PyArray_ITEMSIZE(self)
 *             info.readonly = not PyArray_ISWRITEABLE(self)
 */
  __pyx_v_info->suboffsets = NULL;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":238
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
 *             info.readonly = not PyArray_ISWRITEABLE(self)
 * 
 */
  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":239
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)
 *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
 * 
 *             cdef int t
 */
  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":242
 * 
 *             cdef int t
 *             cdef char* f = NULL             # <<<<<<<<<<<<<<
 *             cdef dtype descr = self.descr
 *             cdef int offset
 */
  __pyx_v_f = NULL;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":243
 *             cdef int t
 *             cdef char* f = NULL
 *             cdef dtype descr = self.descr             # <<<<<<<<<<<<<<
 *             cdef int offset
 * 
 */
  __pyx_t_3 = ((PyObject *)__pyx_v_self->descr);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
  __pyx_t_3 = 0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":246
 *             cdef int offset
 * 
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)             # <<<<<<<<<<<<<<
 * 
 *             if not hasfields and not copy_shape:
 */
  __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":248
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
 * 
 *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
 *                 # do not call releasebuffer
 *                 info.obj = None
 */
  __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L15_bool_binop_done;
  }
  __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L15_bool_binop_done:;
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":250
 *             if not hasfields and not copy_shape:
 *                 # do not call releasebuffer
 *                 info.obj = None             # <<<<<<<<<<<<<<
 *             else:
 *                 # need to call releasebuffer
 */
    __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(Py_None);
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj);
    __pyx_v_info->obj = Py_None;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":248
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
 * 
 *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
 *                 # do not call releasebuffer
 *                 info.obj = None
 */
    goto __pyx_L14;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":253
 *             else:
 *                 # need to call releasebuffer
 *                 info.obj = self             # <<<<<<<<<<<<<<
 * 
 *             if not hasfields:
 */
  /*else*/ {
    __Pyx_INCREF(((PyObject *)__pyx_v_self));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj);
    __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
  }
  __pyx_L14:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":255
 *                 info.obj = self
 * 
 *             if not hasfields:             # <<<<<<<<<<<<<<
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 */
  __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":256
 * 
 *             if not hasfields:
 *                 t = descr.type_num             # <<<<<<<<<<<<<<
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 */
    __pyx_t_4 = __pyx_v_descr->type_num;
    __pyx_v_t = __pyx_t_4;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
    if (!__pyx_t_2) {
      goto __pyx_L20_next_or;
    } else {
    }
    __pyx_t_2 = (__pyx_v_little_endian != 0);
    if (!__pyx_t_2) {
    } else {
      __pyx_t_1 = __pyx_t_2;
      goto __pyx_L19_bool_binop_done;
    }
    __pyx_L20_next_or:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":258
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"
 */
    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
    if (__pyx_t_2) {
    } else {
      __pyx_t_1 = __pyx_t_2;
      goto __pyx_L19_bool_binop_done;
    }
    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
    __pyx_t_1 = __pyx_t_2;
    __pyx_L19_bool_binop_done:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    if (__pyx_t_1) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":259
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 259, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(1, 259, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":260
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"
 */
    switch (__pyx_v_t) {
      case NPY_BYTE:
      __pyx_v_f = ((char *)"b");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":261
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"
 */
      case NPY_UBYTE:
      __pyx_v_f = ((char *)"B");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":262
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"
 */
      case NPY_SHORT:
      __pyx_v_f = ((char *)"h");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":263
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"
 */
      case NPY_USHORT:
      __pyx_v_f = ((char *)"H");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":264
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"
 */
      case NPY_INT:
      __pyx_v_f = ((char *)"i");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":265
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"
 */
      case NPY_UINT:
      __pyx_v_f = ((char *)"I");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":266
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"
 */
      case NPY_LONG:
      __pyx_v_f = ((char *)"l");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":267
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 */
      case NPY_ULONG:
      __pyx_v_f = ((char *)"L");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":268
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"
 */
      case NPY_LONGLONG:
      __pyx_v_f = ((char *)"q");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":269
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"
 */
      case NPY_ULONGLONG:
      __pyx_v_f = ((char *)"Q");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":270
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 */
      case NPY_FLOAT:
      __pyx_v_f = ((char *)"f");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":271
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 */
      case NPY_DOUBLE:
      __pyx_v_f = ((char *)"d");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":272
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 */
      case NPY_LONGDOUBLE:
      __pyx_v_f = ((char *)"g");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":273
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 */
      case NPY_CFLOAT:
      __pyx_v_f = ((char *)"Zf");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":274
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 *                 elif t == NPY_OBJECT:      f = "O"
 */
      case NPY_CDOUBLE:
      __pyx_v_f = ((char *)"Zd");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":275
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_OBJECT:      f = "O"
 *                 else:
 */
      case NPY_CLONGDOUBLE:
      __pyx_v_f = ((char *)"Zg");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":276
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 */
      case NPY_OBJECT:
      __pyx_v_f = ((char *)"O");
      break;
      default:

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":278
 *                 elif t == NPY_OBJECT:      f = "O"
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
 *                 info.format = f
 *                 return
 */
      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GIVEREF(__pyx_t_6);
      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
      __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __PYX_ERR(1, 278, __pyx_L1_error)
      break;
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":279
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *                 info.format = f             # <<<<<<<<<<<<<<
 *                 return
 *             else:
 */
    __pyx_v_info->format = __pyx_v_f;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":280
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *                 info.format = f
 *                 return             # <<<<<<<<<<<<<<
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 */
    __pyx_r = 0;
    goto __pyx_L0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":255
 *                 info.obj = self
 * 
 *             if not hasfields:             # <<<<<<<<<<<<<<
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":282
 *                 return
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0
 */
  /*else*/ {
    __pyx_v_info->format = ((char *)malloc(0xFF));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":283
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
 *                 offset = 0
 *                 f = _util_dtypestring(descr, info.format + 1,
 */
    (__pyx_v_info->format[0]) = '^';

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":284
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0             # <<<<<<<<<<<<<<
 *                 f = _util_dtypestring(descr, info.format + 1,
 *                                       info.format + _buffer_format_string_len,
 */
    __pyx_v_offset = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":285
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0
 *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
 *                                       info.format + _buffer_format_string_len,
 *                                       &offset)
 */
    __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(1, 285, __pyx_L1_error)
    __pyx_v_f = __pyx_t_7;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":288
 *                                       info.format + _buffer_format_string_len,
 *                                       &offset)
 *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 */
    (__pyx_v_f[0]) = '\x00';
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":197
 *         # experimental exception made for __getbuffer__ and __releasebuffer__
 *         # -- the details of this may change.
 *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
 *             # This implementation of getbuffer is geared towards Cython
 *             # requirements, and does not yet fullfill the PEP.
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) {
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL;
  }
  goto __pyx_L2;
  __pyx_L0:;
  if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) {
    __Pyx_GOTREF(Py_None);
    __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL;
  }
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":290
 *                 f[0] = c'\0' # Terminate format string
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 */

/* Python wrapper */
static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("__releasebuffer__", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":291
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":292
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)             # <<<<<<<<<<<<<<
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 stdlib.free(info.strides)
 */
    free(__pyx_v_info->format);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":291
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":293
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.strides)
 *                 # info.shape was stored after info.strides in the same block
 */
  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":294
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 stdlib.free(info.strides)             # <<<<<<<<<<<<<<
 *                 # info.shape was stored after info.strides in the same block
 * 
 */
    free(__pyx_v_info->strides);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":293
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.strides)
 *                 # info.shape was stored after info.strides in the same block
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":290
 *                 f[0] = c'\0' # Terminate format string
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 */

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":770
 * ctypedef npy_cdouble     complex_t
 * 
 * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(1, a)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":771
 * 
 * cdef inline object PyArray_MultiIterNew1(a):
 *     return PyArray_MultiIterNew(1, a)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":770
 * ctypedef npy_cdouble     complex_t
 * 
 * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(1, a)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":773
 *     return PyArray_MultiIterNew(1, a)
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":774
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):
 *     return PyArray_MultiIterNew(2, a, b)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 774, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":773
 *     return PyArray_MultiIterNew(1, a)
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":776
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":777
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):
 *     return PyArray_MultiIterNew(3, a, b,  c)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 777, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":776
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":779
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":780
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
 *     return PyArray_MultiIterNew(4, a, b, c,  d)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 780, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":779
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":782
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":783
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)             # <<<<<<<<<<<<<<
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 783, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":782
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":785
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
 *     # Recursive utility function used in __getbuffer__ to get format
 *     # string. The new location in the format string is returned.
 */

static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
  PyArray_Descr *__pyx_v_child = 0;
  int __pyx_v_endian_detector;
  int __pyx_v_little_endian;
  PyObject *__pyx_v_fields = 0;
  PyObject *__pyx_v_childname = NULL;
  PyObject *__pyx_v_new_offset = NULL;
  PyObject *__pyx_v_t = NULL;
  char *__pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  Py_ssize_t __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_t_6;
  int __pyx_t_7;
  long __pyx_t_8;
  char *__pyx_t_9;
  __Pyx_RefNannySetupContext("_util_dtypestring", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":790
 * 
 *     cdef dtype child
 *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
 *     cdef bint little_endian = ((&endian_detector)[0] != 0)
 *     cdef tuple fields
 */
  __pyx_v_endian_detector = 1;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":791
 *     cdef dtype child
 *     cdef int endian_detector = 1
 *     cdef bint little_endian = ((&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
 *     cdef tuple fields
 * 
 */
  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":794
 *     cdef tuple fields
 * 
 *     for childname in descr.names:             # <<<<<<<<<<<<<<
 *         fields = descr.fields[childname]
 *         child, new_offset = fields
 */
  if (unlikely(__pyx_v_descr->names == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(1, 794, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
  for (;;) {
    if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
    #if CYTHON_COMPILING_IN_CPYTHON
    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 794, __pyx_L1_error)
    #else
    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 794, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    #endif
    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":795
 * 
 *     for childname in descr.names:
 *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
 *         child, new_offset = fields
 * 
 */
    if (unlikely(__pyx_v_descr->fields == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(1, 795, __pyx_L1_error)
    }
    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 795, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 795, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
    __pyx_t_3 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":796
 *     for childname in descr.names:
 *         fields = descr.fields[childname]
 *         child, new_offset = fields             # <<<<<<<<<<<<<<
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 */
    if (likely(__pyx_v_fields != Py_None)) {
      PyObject* sequence = __pyx_v_fields;
      #if CYTHON_COMPILING_IN_CPYTHON
      Py_ssize_t size = Py_SIZE(sequence);
      #else
      Py_ssize_t size = PySequence_Size(sequence);
      #endif
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(1, 796, __pyx_L1_error)
      }
      #if CYTHON_COMPILING_IN_CPYTHON
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      #else
      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 796, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 796, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      #endif
    } else {
      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 796, __pyx_L1_error)
    }
    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 796, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
    __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
    __pyx_t_4 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":798
 *         child, new_offset = fields
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 */
    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 798, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":799
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 799, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(1, 799, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":798
 *         child, new_offset = fields
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
    if (!__pyx_t_7) {
      goto __pyx_L8_next_or;
    } else {
    }
    __pyx_t_7 = (__pyx_v_little_endian != 0);
    if (!__pyx_t_7) {
    } else {
      __pyx_t_6 = __pyx_t_7;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_L8_next_or:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":802
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
 *             raise ValueError(u"Non-native byte order not supported")
 *             # One could encode it in the format string and have Cython
 */
    __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
    if (__pyx_t_7) {
    } else {
      __pyx_t_6 = __pyx_t_7;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
    __pyx_t_6 = __pyx_t_7;
    __pyx_L7_bool_binop_done:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":803
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *             # One could encode it in the format string and have Cython
 *             # complain instead, BUT: < and > in format strings also imply
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 803, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(1, 803, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":813
 * 
 *         # Output padding bytes
 *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
 *             f[0] = 120 # "x"; pad byte
 *             f += 1
 */
    while (1) {
      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (!__pyx_t_6) break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":814
 *         # Output padding bytes
 *         while offset[0] < new_offset:
 *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
 *             f += 1
 *             offset[0] += 1
 */
      (__pyx_v_f[0]) = 0x78;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":815
 *         while offset[0] < new_offset:
 *             f[0] = 120 # "x"; pad byte
 *             f += 1             # <<<<<<<<<<<<<<
 *             offset[0] += 1
 * 
 */
      __pyx_v_f = (__pyx_v_f + 1);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":816
 *             f[0] = 120 # "x"; pad byte
 *             f += 1
 *             offset[0] += 1             # <<<<<<<<<<<<<<
 * 
 *         offset[0] += child.itemsize
 */
      __pyx_t_8 = 0;
      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":818
 *             offset[0] += 1
 * 
 *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
 * 
 *         if not PyDataType_HASFIELDS(child):
 */
    __pyx_t_8 = 0;
    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":820
 *         offset[0] += child.itemsize
 * 
 *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
 *             t = child.type_num
 *             if end - f < 5:
 */
    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":821
 * 
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num             # <<<<<<<<<<<<<<
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")
 */
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 821, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
      __pyx_t_4 = 0;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":822
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num
 *             if end - f < 5:             # <<<<<<<<<<<<<<
 *                 raise RuntimeError(u"Format string allocated too short.")
 * 
 */
      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
      if (__pyx_t_6) {

        /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":823
 *             t = child.type_num
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 */
        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 823, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __PYX_ERR(1, 823, __pyx_L1_error)

        /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":822
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num
 *             if end - f < 5:             # <<<<<<<<<<<<<<
 *                 raise RuntimeError(u"Format string allocated too short.")
 * 
 */
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":826
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 826, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 826, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 826, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 98;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":827
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 827, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 827, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 827, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 66;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":828
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 828, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 828, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 828, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x68;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":829
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 829, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 829, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 829, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 72;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":830
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 830, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 830, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 830, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x69;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":831
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 831, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 831, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 831, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 73;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":832
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 832, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 832, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 832, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x6C;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":833
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 833, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 833, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 833, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 76;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":834
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 834, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 834, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x71;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":835
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 835, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 835, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 81;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":836
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 836, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 836, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 836, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x66;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":837
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 837, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 837, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x64;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":838
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 838, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 838, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 838, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x67;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":839
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 839, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 839, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x66;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":840
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 840, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 840, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 840, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x64;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":841
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 *             else:
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 841, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 841, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x67;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":842
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 842, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 842, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 842, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 79;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":844
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
 *             f += 1
 *         else:
 */
      /*else*/ {
        __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_3);
        PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
        __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __PYX_ERR(1, 844, __pyx_L1_error)
      }
      __pyx_L15:;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":845
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *             f += 1             # <<<<<<<<<<<<<<
 *         else:
 *             # Cython ignores struct boundary information ("T{...}"),
 */
      __pyx_v_f = (__pyx_v_f + 1);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":820
 *         offset[0] += child.itemsize
 * 
 *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
 *             t = child.type_num
 *             if end - f < 5:
 */
      goto __pyx_L13;
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":849
 *             # Cython ignores struct boundary information ("T{...}"),
 *             # so don't output it
 *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
 *     return f
 * 
 */
    /*else*/ {
      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(1, 849, __pyx_L1_error)
      __pyx_v_f = __pyx_t_9;
    }
    __pyx_L13:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":794
 *     cdef tuple fields
 * 
 *     for childname in descr.names:             # <<<<<<<<<<<<<<
 *         fields = descr.fields[childname]
 *         child, new_offset = fields
 */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":850
 *             # so don't output it
 *             f = _util_dtypestring(child, f, end, offset)
 *     return f             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __pyx_r = __pyx_v_f;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":785
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
 *     # Recursive utility function used in __getbuffer__ to get format
 *     # string. The new location in the format string is returned.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_child);
  __Pyx_XDECREF(__pyx_v_fields);
  __Pyx_XDECREF(__pyx_v_childname);
  __Pyx_XDECREF(__pyx_v_new_offset);
  __Pyx_XDECREF(__pyx_v_t);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":966
 * 
 * 
 * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
 *      cdef PyObject* baseptr
 *      if base is None:
 */

static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
  PyObject *__pyx_v_baseptr;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  __Pyx_RefNannySetupContext("set_array_base", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":968
 * cdef inline void set_array_base(ndarray arr, object base):
 *      cdef PyObject* baseptr
 *      if base is None:             # <<<<<<<<<<<<<<
 *          baseptr = NULL
 *      else:
 */
  __pyx_t_1 = (__pyx_v_base == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":969
 *      cdef PyObject* baseptr
 *      if base is None:
 *          baseptr = NULL             # <<<<<<<<<<<<<<
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!
 */
    __pyx_v_baseptr = NULL;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":968
 * cdef inline void set_array_base(ndarray arr, object base):
 *      cdef PyObject* baseptr
 *      if base is None:             # <<<<<<<<<<<<<<
 *          baseptr = NULL
 *      else:
 */
    goto __pyx_L3;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":971
 *          baseptr = NULL
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!             # <<<<<<<<<<<<<<
 *          baseptr = base
 *      Py_XDECREF(arr.base)
 */
  /*else*/ {
    Py_INCREF(__pyx_v_base);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":972
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!
 *          baseptr = base             # <<<<<<<<<<<<<<
 *      Py_XDECREF(arr.base)
 *      arr.base = baseptr
 */
    __pyx_v_baseptr = ((PyObject *)__pyx_v_base);
  }
  __pyx_L3:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":973
 *          Py_INCREF(base) # important to do this before decref below!
 *          baseptr = base
 *      Py_XDECREF(arr.base)             # <<<<<<<<<<<<<<
 *      arr.base = baseptr
 * 
 */
  Py_XDECREF(__pyx_v_arr->base);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":974
 *          baseptr = base
 *      Py_XDECREF(arr.base)
 *      arr.base = baseptr             # <<<<<<<<<<<<<<
 * 
 * cdef inline object get_array_base(ndarray arr):
 */
  __pyx_v_arr->base = __pyx_v_baseptr;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":966
 * 
 * 
 * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
 *      cdef PyObject* baseptr
 *      if base is None:
 */

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":976
 *      arr.base = baseptr
 * 
 * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
 *     if arr.base is NULL:
 *         return None
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("get_array_base", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":977
 * 
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:             # <<<<<<<<<<<<<<
 *         return None
 *     else:
 */
  __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":978
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:
 *         return None             # <<<<<<<<<<<<<<
 *     else:
 *         return arr.base
 */
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_None);
    __pyx_r = Py_None;
    goto __pyx_L0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":977
 * 
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:             # <<<<<<<<<<<<<<
 *         return None
 *     else:
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":980
 *         return None
 *     else:
 *         return arr.base             # <<<<<<<<<<<<<<
 */
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(((PyObject *)__pyx_v_arr->base));
    __pyx_r = ((PyObject *)__pyx_v_arr->base);
    goto __pyx_L0;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":976
 *      arr.base = baseptr
 * 
 * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
 *     if arr.base is NULL:
 *         return None
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "_common.pxd":124
 *         tsize Num_Alms (int l, int m)
 * 
 * cdef inline Healpix_Map[double]* ndarray2map(np.ndarray[np.float64_t, ndim=1, mode='c'] array, Healpix_Ordering_Scheme scheme) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as a Healpix Map. """
 *     # To ensure that the output map is a view of the input array, the latter
 */

static CYTHON_INLINE Healpix_Map  *__pyx_f_7_common_ndarray2map(PyArrayObject *__pyx_v_array, enum Healpix_Ordering_Scheme __pyx_v_scheme) {
  arr  *__pyx_v_a;
  Healpix_Map  *__pyx_v_map;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_array;
  __Pyx_Buffer __pyx_pybuffer_array;
  Healpix_Map  *__pyx_r;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  __Pyx_RefNannySetupContext("ndarray2map", 0);
  __pyx_pybuffer_array.pybuffer.buf = NULL;
  __pyx_pybuffer_array.refcount = 0;
  __pyx_pybuffernd_array.data = NULL;
  __pyx_pybuffernd_array.rcbuffer = &__pyx_pybuffer_array;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_array.rcbuffer->pybuffer, (PyObject*)__pyx_v_array, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float64_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) __PYX_ERR(2, 124, __pyx_L1_error)
  }
  __pyx_pybuffernd_array.diminfo[0].strides = __pyx_pybuffernd_array.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_array.diminfo[0].shape = __pyx_pybuffernd_array.rcbuffer->pybuffer.shape[0];

  /* "_common.pxd":129
 *     # is forced to be contiguous, of correct type and dimensions (otherwise, an
 *     # exception is raised).
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)             # <<<<<<<<<<<<<<
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)
 */
  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_pybuffernd_array.diminfo[0].shape;
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_pybuffernd_array.diminfo[0].shape)) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(2, 129, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_array), __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 129, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_a = new arr ((&(*__Pyx_BufPtrCContig1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_array.rcbuffer->pybuffer.buf, __pyx_t_1, __pyx_pybuffernd_array.diminfo[0].strides))), __pyx_t_4);

  /* "_common.pxd":130
 *     # exception is raised).
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()             # <<<<<<<<<<<<<<
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated
 */
  __pyx_v_map = new Healpix_Map ();

  /* "_common.pxd":131
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)             # <<<<<<<<<<<<<<
 *     del a # a does not own its buffer, so it won't be deallocated
 *     return map
 */
  __pyx_v_map->Set((__pyx_v_a[0]), __pyx_v_scheme);

  /* "_common.pxd":132
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated             # <<<<<<<<<<<<<<
 *     return map
 * 
 */
  delete __pyx_v_a;

  /* "_common.pxd":133
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated
 *     return map             # <<<<<<<<<<<<<<
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:
 */
  __pyx_r = __pyx_v_map;
  goto __pyx_L0;

  /* "_common.pxd":124
 *         tsize Num_Alms (int l, int m)
 * 
 * cdef inline Healpix_Map[double]* ndarray2map(np.ndarray[np.float64_t, ndim=1, mode='c'] array, Healpix_Ordering_Scheme scheme) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as a Healpix Map. """
 *     # To ensure that the output map is a view of the input array, the latter
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("_common.ndarray2map", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "_common.pxd":135
 *     return map
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 */

static CYTHON_INLINE Alm >  *__pyx_f_7_common_ndarray2alm(PyArrayObject *__pyx_v_array, int __pyx_v_lmax, int __pyx_v_mmax) {
  arr >  *__pyx_v_a;
  Alm >  *__pyx_v_alm;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_array;
  __Pyx_Buffer __pyx_pybuffer_array;
  Alm >  *__pyx_r;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  __Pyx_RefNannySetupContext("ndarray2alm", 0);
  __pyx_pybuffer_array.pybuffer.buf = NULL;
  __pyx_pybuffer_array.refcount = 0;
  __pyx_pybuffernd_array.data = NULL;
  __pyx_pybuffernd_array.rcbuffer = &__pyx_pybuffer_array;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_array.rcbuffer->pybuffer, (PyObject*)__pyx_v_array, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) __PYX_ERR(2, 135, __pyx_L1_error)
  }
  __pyx_pybuffernd_array.diminfo[0].strides = __pyx_pybuffernd_array.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_array.diminfo[0].shape = __pyx_pybuffernd_array.rcbuffer->pybuffer.shape[0];

  /* "_common.pxd":137
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)             # <<<<<<<<<<<<<<
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)
 */
  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_pybuffernd_array.diminfo[0].shape;
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_pybuffernd_array.diminfo[0].shape)) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(2, 137, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_array), __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 137, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 137, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_a = new arr > (((xcomplex  *)(&(*__Pyx_BufPtrCContig1d(__pyx_t_double_complex *, __pyx_pybuffernd_array.rcbuffer->pybuffer.buf, __pyx_t_1, __pyx_pybuffernd_array.diminfo[0].strides)))), __pyx_t_4);

  /* "_common.pxd":138
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()             # <<<<<<<<<<<<<<
 *     alm.Set(a[0], lmax, mmax)
 *     del a
 */
  __pyx_v_alm = new Alm > ();

  /* "_common.pxd":139
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)             # <<<<<<<<<<<<<<
 *     del a
 *     return alm
 */
  __pyx_v_alm->Set((__pyx_v_a[0]), __pyx_v_lmax, __pyx_v_mmax);

  /* "_common.pxd":140
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)
 *     del a             # <<<<<<<<<<<<<<
 *     return alm
 */
  delete __pyx_v_a;

  /* "_common.pxd":141
 *     alm.Set(a[0], lmax, mmax)
 *     del a
 *     return alm             # <<<<<<<<<<<<<<
 */
  __pyx_r = __pyx_v_alm;
  goto __pyx_L0;

  /* "_common.pxd":135
 *     return map
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("_common.ndarray2alm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyMethodDef __pyx_methods[] = {
  {0, 0, 0, 0}
};

#if PY_MAJOR_VERSION >= 3
static struct PyModuleDef __pyx_moduledef = {
  #if PY_VERSION_HEX < 0x03020000
    { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
  #else
    PyModuleDef_HEAD_INIT,
  #endif
    "_pixelfunc",
    0, /* m_doc */
    -1, /* m_size */
    __pyx_methods /* m_methods */,
    NULL, /* m_reload */
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};
#endif

static __Pyx_StringTabEntry __pyx_string_tab[] = {
  {&__pyx_kp_u_Convert_pixel_identifier_to_ring, __pyx_k_Convert_pixel_identifier_to_ring, sizeof(__pyx_k_Convert_pixel_identifier_to_ring), 0, 1, 0, 0},
  {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
  {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
  {&__pyx_kp_u_Get_information_for_rings_Rings, __pyx_k_Get_information_for_rings_Rings, sizeof(__pyx_k_Get_information_for_rings_Rings), 0, 1, 0, 0},
  {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
  {&__pyx_kp_s_Wrong_nside_value_must_be_a_powe, __pyx_k_Wrong_nside_value_must_be_a_powe, sizeof(__pyx_k_Wrong_nside_value_must_be_a_powe), 0, 0, 1, 0},
  {&__pyx_n_s_bool, __pyx_k_bool, sizeof(__pyx_k_bool), 0, 0, 1, 1},
  {&__pyx_n_s_costheta, __pyx_k_costheta, sizeof(__pyx_k_costheta), 0, 0, 1, 1},
  {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1},
  {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1},
  {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1},
  {&__pyx_n_s_hb, __pyx_k_hb, sizeof(__pyx_k_hb), 0, 0, 1, 1},
  {&__pyx_n_s_healpy__pixelfunc, __pyx_k_healpy__pixelfunc, sizeof(__pyx_k_healpy__pixelfunc), 0, 0, 1, 1},
  {&__pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_k_home_zonca_zonca_p_software_hea, sizeof(__pyx_k_home_zonca_zonca_p_software_hea), 0, 0, 1, 0},
  {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
  {&__pyx_n_s_int64, __pyx_k_int64, sizeof(__pyx_k_int64), 0, 0, 1, 1},
  {&__pyx_n_s_log2, __pyx_k_log2, sizeof(__pyx_k_log2), 0, 0, 1, 1},
  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
  {&__pyx_n_s_nest, __pyx_k_nest, sizeof(__pyx_k_nest), 0, 0, 1, 1},
  {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
  {&__pyx_n_s_nside, __pyx_k_nside, sizeof(__pyx_k_nside), 0, 0, 1, 1},
  {&__pyx_n_s_num, __pyx_k_num, sizeof(__pyx_k_num), 0, 0, 1, 1},
  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
  {&__pyx_n_s_pix, __pyx_k_pix, sizeof(__pyx_k_pix), 0, 0, 1, 1},
  {&__pyx_n_s_pix2ring, __pyx_k_pix2ring, sizeof(__pyx_k_pix2ring), 0, 0, 1, 1},
  {&__pyx_kp_u_pix2ring_line_58, __pyx_k_pix2ring_line_58, sizeof(__pyx_k_pix2ring_line_58), 0, 1, 0, 0},
  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
  {&__pyx_n_s_ring, __pyx_k_ring, sizeof(__pyx_k_ring), 0, 0, 1, 1},
  {&__pyx_n_s_ringinfo, __pyx_k_ringinfo, sizeof(__pyx_k_ringinfo), 0, 0, 1, 1},
  {&__pyx_kp_u_ringinfo_line_9, __pyx_k_ringinfo_line_9, sizeof(__pyx_k_ringinfo_line_9), 0, 1, 0, 0},
  {&__pyx_n_s_ringpix, __pyx_k_ringpix, sizeof(__pyx_k_ringpix), 0, 0, 1, 1},
  {&__pyx_n_s_round, __pyx_k_round, sizeof(__pyx_k_round), 0, 0, 1, 1},
  {&__pyx_n_s_scheme, __pyx_k_scheme, sizeof(__pyx_k_scheme), 0, 0, 1, 1},
  {&__pyx_n_s_shifted, __pyx_k_shifted, sizeof(__pyx_k_shifted), 0, 0, 1, 1},
  {&__pyx_n_s_sintheta, __pyx_k_sintheta, sizeof(__pyx_k_sintheta), 0, 0, 1, 1},
  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
  {&__pyx_n_s_startpix, __pyx_k_startpix, sizeof(__pyx_k_startpix), 0, 0, 1, 1},
  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
  {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
  {0, 0, 0, 0, 0, 0, 0}
};
static int __Pyx_InitCachedBuiltins(void) {
  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 45, __pyx_L1_error)
  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 54, __pyx_L1_error)
  __pyx_builtin_round = __Pyx_GetBuiltinName(__pyx_n_s_round); if (!__pyx_builtin_round) __PYX_ERR(0, 104, __pyx_L1_error)
  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 799, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

static int __Pyx_InitCachedConstants(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);

  /* "healpy/src/_pixelfunc.pyx":45
 *     """
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme = NEST
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Wrong_nside_value_must_be_a_powe); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 45, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

  /* "healpy/src/_pixelfunc.pyx":89
 * 
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */
  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Wrong_nside_value_must_be_a_powe); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 89, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__2);
  __Pyx_GIVEREF(__pyx_tuple__2);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":218
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 */
  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__3);
  __Pyx_GIVEREF(__pyx_tuple__3);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":222
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
 * 
 *             info.buf = PyArray_DATA(self)
 */
  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__4);
  __Pyx_GIVEREF(__pyx_tuple__4);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":259
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 */
  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 259, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__5);
  __Pyx_GIVEREF(__pyx_tuple__5);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":799
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 */
  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 799, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__6);
  __Pyx_GIVEREF(__pyx_tuple__6);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":803
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *             # One could encode it in the format string and have Cython
 *             # complain instead, BUT: < and > in format strings also imply
 */
  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 803, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__7);
  __Pyx_GIVEREF(__pyx_tuple__7);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":823
 *             t = child.type_num
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 */
  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 823, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__8);
  __Pyx_GIVEREF(__pyx_tuple__8);

  /* "healpy/src/_pixelfunc.pyx":9
 * from _common cimport int64, Healpix_Ordering_Scheme, RING, NEST, SET_NSIDE, T_Healpix_Base
 * 
 * def ringinfo(nside, np.ndarray[int64, ndim=1] ring not None):             # <<<<<<<<<<<<<<
 *     """Get information for rings
 * 
 */
  __pyx_tuple__9 = PyTuple_Pack(11, __pyx_n_s_nside, __pyx_n_s_ring, __pyx_n_s_scheme, __pyx_n_s_hb, __pyx_n_s_num, __pyx_n_s_startpix, __pyx_n_s_ringpix, __pyx_n_s_costheta, __pyx_n_s_sintheta, __pyx_n_s_shifted, __pyx_n_s_i); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__9);
  __Pyx_GIVEREF(__pyx_tuple__9);
  __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(2, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_ringinfo, 9, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 9, __pyx_L1_error)

  /* "healpy/src/_pixelfunc.pyx":58
 *     return startpix, ringpix, costheta, sintheta, shifted
 * 
 * def pix2ring(nside, np.ndarray[int64, ndim=1] pix not None, nest=False):             # <<<<<<<<<<<<<<
 *     """Convert pixel identifier to ring number
 * 
 */
  __pyx_tuple__11 = PyTuple_Pack(8, __pyx_n_s_nside, __pyx_n_s_pix, __pyx_n_s_nest, __pyx_n_s_scheme, __pyx_n_s_hb, __pyx_n_s_num, __pyx_n_s_ring, __pyx_n_s_i); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);
  __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 8, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_pix2ring, 58, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 58, __pyx_L1_error)
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_InitGlobals(void) {
  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

#if PY_MAJOR_VERSION < 3
PyMODINIT_FUNC init_pixelfunc(void); /*proto*/
PyMODINIT_FUNC init_pixelfunc(void)
#else
PyMODINIT_FUNC PyInit__pixelfunc(void); /*proto*/
PyMODINIT_FUNC PyInit__pixelfunc(void)
#endif
{
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannyDeclarations
  #if CYTHON_REFNANNY
  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
  if (!__Pyx_RefNanny) {
      PyErr_Clear();
      __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
      if (!__Pyx_RefNanny)
          Py_FatalError("failed to import 'refnanny' module");
  }
  #endif
  __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__pixelfunc(void)", 0);
  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
  #ifdef __Pyx_CyFunction_USED
  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_FusedFunction_USED
  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Coroutine_USED
  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Generator_USED
  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_StopAsyncIteration_USED
  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  /*--- Library function declarations ---*/
  /*--- Threads initialization code ---*/
  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
  #ifdef WITH_THREAD /* Python build with threading support? */
  PyEval_InitThreads();
  #endif
  #endif
  /*--- Module creation code ---*/
  #if PY_MAJOR_VERSION < 3
  __pyx_m = Py_InitModule4("_pixelfunc", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
  #else
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  #endif
  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
  Py_INCREF(__pyx_d);
  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
  #if CYTHON_COMPILING_IN_PYPY
  Py_INCREF(__pyx_b);
  #endif
  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  /*--- Initialize various global constants etc. ---*/
  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  if (__pyx_module_is_main_healpy___pixelfunc) {
    if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  }
  #if PY_MAJOR_VERSION >= 3
  {
    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
    if (!PyDict_GetItemString(modules, "healpy._pixelfunc")) {
      if (unlikely(PyDict_SetItemString(modules, "healpy._pixelfunc", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
    }
  }
  #endif
  /*--- Builtin init code ---*/
  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Constants init code ---*/
  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Global init code ---*/
  /*--- Variable export code ---*/
  /*--- Function export code ---*/
  /*--- Type init code ---*/
  /*--- Type import code ---*/
  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", 
  #if CYTHON_COMPILING_IN_PYPY
  sizeof(PyTypeObject),
  #else
  sizeof(PyHeapTypeObject),
  #endif
  0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(3, 9, __pyx_L1_error)
  __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(1, 155, __pyx_L1_error)
  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(1, 168, __pyx_L1_error)
  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(1, 172, __pyx_L1_error)
  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(1, 181, __pyx_L1_error)
  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(1, 861, __pyx_L1_error)
  /*--- Variable import code ---*/
  /*--- Function import code ---*/
  /*--- Execution code ---*/
  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif

  /* "healpy/src/_pixelfunc.pyx":3
 * # Wrapper around the geometry methods in Healpix_base class
 * 
 * import numpy as np             # <<<<<<<<<<<<<<
 * cimport numpy as np
 * from libcpp cimport bool
 */
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_pixelfunc.pyx":9
 * from _common cimport int64, Healpix_Ordering_Scheme, RING, NEST, SET_NSIDE, T_Healpix_Base
 * 
 * def ringinfo(nside, np.ndarray[int64, ndim=1] ring not None):             # <<<<<<<<<<<<<<
 *     """Get information for rings
 * 
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_10_pixelfunc_1ringinfo, NULL, __pyx_n_s_healpy__pixelfunc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ringinfo, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_pixelfunc.pyx":58
 *     return startpix, ringpix, costheta, sintheta, shifted
 * 
 * def pix2ring(nside, np.ndarray[int64, ndim=1] pix not None, nest=False):             # <<<<<<<<<<<<<<
 *     """Convert pixel identifier to ring number
 * 
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_10_pixelfunc_3pix2ring, NULL, __pyx_n_s_healpy__pixelfunc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pix2ring, __pyx_t_1) < 0) __PYX_ERR(0, 58, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_pixelfunc.pyx":1
 * # Wrapper around the geometry methods in Healpix_base class             # <<<<<<<<<<<<<<
 * 
 * import numpy as np
 */
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_kp_u_ringinfo_line_9, __pyx_kp_u_Get_information_for_rings_Rings) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_t_1, __pyx_kp_u_pix2ring_line_58, __pyx_kp_u_Convert_pixel_identifier_to_ring) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "_common.pxd":135
 *     return map
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 */

  /*--- Wrapped vars code ---*/

  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  if (__pyx_m) {
    if (__pyx_d) {
      __Pyx_AddTraceback("init healpy._pixelfunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
    }
    Py_DECREF(__pyx_m); __pyx_m = 0;
  } else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_ImportError, "init healpy._pixelfunc");
  }
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #if PY_MAJOR_VERSION < 3
  return;
  #else
  return __pyx_m;
  #endif
}

/* --- Runtime support code --- */
/* Refnanny */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
    PyObject *m = NULL, *p = NULL;
    void *r = NULL;
    m = PyImport_ImportModule((char *)modname);
    if (!m) goto end;
    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
    if (!p) goto end;
    r = PyLong_AsVoidPtr(p);
end:
    Py_XDECREF(p);
    Py_XDECREF(m);
    return (__Pyx_RefNannyAPIStruct *)r;
}
#endif

/* GetBuiltinName */
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
    if (unlikely(!result)) {
        PyErr_Format(PyExc_NameError,
#if PY_MAJOR_VERSION >= 3
            "name '%U' is not defined", name);
#else
            "name '%.200s' is not defined", PyString_AS_STRING(name));
#endif
    }
    return result;
}

/* RaiseArgTupleInvalid */
static void __Pyx_RaiseArgtupleInvalid(
    const char* func_name,
    int exact,
    Py_ssize_t num_min,
    Py_ssize_t num_max,
    Py_ssize_t num_found)
{
    Py_ssize_t num_expected;
    const char *more_or_less;
    if (num_found < num_min) {
        num_expected = num_min;
        more_or_less = "at least";
    } else {
        num_expected = num_max;
        more_or_less = "at most";
    }
    if (exact) {
        more_or_less = "exactly";
    }
    PyErr_Format(PyExc_TypeError,
                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 func_name, more_or_less, num_expected,
                 (num_expected == 1) ? "" : "s", num_found);
}

/* RaiseDoubleKeywords */
static void __Pyx_RaiseDoubleKeywordsError(
    const char* func_name,
    PyObject* kw_name)
{
    PyErr_Format(PyExc_TypeError,
        #if PY_MAJOR_VERSION >= 3
        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
        #else
        "%s() got multiple values for keyword argument '%s'", func_name,
        PyString_AsString(kw_name));
        #endif
}

/* ParseKeywords */
static int __Pyx_ParseOptionalKeywords(
    PyObject *kwds,
    PyObject **argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    const char* function_name)
{
    PyObject *key = 0, *value = 0;
    Py_ssize_t pos = 0;
    PyObject*** name;
    PyObject*** first_kw_arg = argnames + num_pos_args;
    while (PyDict_Next(kwds, &pos, &key, &value)) {
        name = first_kw_arg;
        while (*name && (**name != key)) name++;
        if (*name) {
            values[name-argnames] = value;
            continue;
        }
        name = first_kw_arg;
        #if PY_MAJOR_VERSION < 3
        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
            while (*name) {
                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                        && _PyString_Eq(**name, key)) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    if ((**argname == key) || (
                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
                             && _PyString_Eq(**argname, key))) {
                        goto arg_passed_twice;
                    }
                    argname++;
                }
            }
        } else
        #endif
        if (likely(PyUnicode_Check(key))) {
            while (*name) {
                int cmp = (**name == key) ? 0 :
                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
                #endif
                    PyUnicode_Compare(**name, key);
                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                if (cmp == 0) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    int cmp = (**argname == key) ? 0 :
                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
                    #endif
                        PyUnicode_Compare(**argname, key);
                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                    if (cmp == 0) goto arg_passed_twice;
                    argname++;
                }
            }
        } else
            goto invalid_keyword_type;
        if (kwds2) {
            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
        } else {
            goto invalid_keyword;
        }
    }
    return 0;
arg_passed_twice:
    __Pyx_RaiseDoubleKeywordsError(function_name, key);
    goto bad;
invalid_keyword_type:
    PyErr_Format(PyExc_TypeError,
        "%.200s() keywords must be strings", function_name);
    goto bad;
invalid_keyword:
    PyErr_Format(PyExc_TypeError,
    #if PY_MAJOR_VERSION < 3
        "%.200s() got an unexpected keyword argument '%.200s'",
        function_name, PyString_AsString(key));
    #else
        "%s() got an unexpected keyword argument '%U'",
        function_name, key);
    #endif
bad:
    return -1;
}

/* ArgTypeTest */
static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
    PyErr_Format(PyExc_TypeError,
        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
        name, type->tp_name, Py_TYPE(obj)->tp_name);
}
static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
    const char *name, int exact)
{
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (none_allowed && obj == Py_None) return 1;
    else if (exact) {
        if (likely(Py_TYPE(obj) == type)) return 1;
        #if PY_MAJOR_VERSION == 2
        else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
        #endif
    }
    else {
        if (likely(PyObject_TypeCheck(obj, type))) return 1;
    }
    __Pyx_RaiseArgumentTypeInvalid(name, obj, type);
    return 0;
}

/* BufferFormatCheck */
static CYTHON_INLINE int __Pyx_IsLittleEndian(void) {
  unsigned int n = 1;
  return *(unsigned char*)(&n) != 0;
}
static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
                              __Pyx_BufFmt_StackElem* stack,
                              __Pyx_TypeInfo* type) {
  stack[0].field = &ctx->root;
  stack[0].parent_offset = 0;
  ctx->root.type = type;
  ctx->root.name = "buffer dtype";
  ctx->root.offset = 0;
  ctx->head = stack;
  ctx->head->field = &ctx->root;
  ctx->fmt_offset = 0;
  ctx->head->parent_offset = 0;
  ctx->new_packmode = '@';
  ctx->enc_packmode = '@';
  ctx->new_count = 1;
  ctx->enc_count = 0;
  ctx->enc_type = 0;
  ctx->is_complex = 0;
  ctx->is_valid_array = 0;
  ctx->struct_alignment = 0;
  while (type->typegroup == 'S') {
    ++ctx->head;
    ctx->head->field = type->fields;
    ctx->head->parent_offset = 0;
    type = type->fields->type;
  }
}
static int __Pyx_BufFmt_ParseNumber(const char** ts) {
    int count;
    const char* t = *ts;
    if (*t < '0' || *t > '9') {
      return -1;
    } else {
        count = *t++ - '0';
        while (*t >= '0' && *t < '9') {
            count *= 10;
            count += *t++ - '0';
        }
    }
    *ts = t;
    return count;
}
static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
    int number = __Pyx_BufFmt_ParseNumber(ts);
    if (number == -1)
        PyErr_Format(PyExc_ValueError,\
                     "Does not understand character buffer dtype format string ('%c')", **ts);
    return number;
}
static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
  PyErr_Format(PyExc_ValueError,
               "Unexpected format string character: '%c'", ch);
}
static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
  switch (ch) {
    case 'c': return "'char'";
    case 'b': return "'signed char'";
    case 'B': return "'unsigned char'";
    case 'h': return "'short'";
    case 'H': return "'unsigned short'";
    case 'i': return "'int'";
    case 'I': return "'unsigned int'";
    case 'l': return "'long'";
    case 'L': return "'unsigned long'";
    case 'q': return "'long long'";
    case 'Q': return "'unsigned long long'";
    case 'f': return (is_complex ? "'complex float'" : "'float'");
    case 'd': return (is_complex ? "'complex double'" : "'double'");
    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
    case 'T': return "a struct";
    case 'O': return "Python object";
    case 'P': return "a pointer";
    case 's': case 'p': return "a string";
    case 0: return "end";
    default: return "unparseable format string";
  }
}
static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return 2;
    case 'i': case 'I': case 'l': case 'L': return 4;
    case 'q': case 'Q': return 8;
    case 'f': return (is_complex ? 8 : 4);
    case 'd': return (is_complex ? 16 : 8);
    case 'g': {
      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
      return 0;
    }
    case 'O': case 'P': return sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
  switch (ch) {
    case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(short);
    case 'i': case 'I': return sizeof(int);
    case 'l': case 'L': return sizeof(long);
    #ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
    #endif
    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
    case 'O': case 'P': return sizeof(void*);
    default: {
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
  }
}
typedef struct { char c; short x; } __Pyx_st_short;
typedef struct { char c; int x; } __Pyx_st_int;
typedef struct { char c; long x; } __Pyx_st_long;
typedef struct { char c; float x; } __Pyx_st_float;
typedef struct { char c; double x; } __Pyx_st_double;
typedef struct { char c; long double x; } __Pyx_st_longdouble;
typedef struct { char c; void *x; } __Pyx_st_void_p;
#ifdef HAVE_LONG_LONG
typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
#endif
static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
#ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
#endif
    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
/* These are for computing the padding at the end of the struct to align
   on the first member of the struct. This will probably the same as above,
   but we don't have any guarantees.
 */
typedef struct { short x; char c; } __Pyx_pad_short;
typedef struct { int x; char c; } __Pyx_pad_int;
typedef struct { long x; char c; } __Pyx_pad_long;
typedef struct { float x; char c; } __Pyx_pad_float;
typedef struct { double x; char c; } __Pyx_pad_double;
typedef struct { long double x; char c; } __Pyx_pad_longdouble;
typedef struct { void *x; char c; } __Pyx_pad_void_p;
#ifdef HAVE_LONG_LONG
typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
#endif
static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
#ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
#endif
    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
  switch (ch) {
    case 'c':
        return 'H';
    case 'b': case 'h': case 'i':
    case 'l': case 'q': case 's': case 'p':
        return 'I';
    case 'B': case 'H': case 'I': case 'L': case 'Q':
        return 'U';
    case 'f': case 'd': case 'g':
        return (is_complex ? 'C' : 'R');
    case 'O':
        return 'O';
    case 'P':
        return 'P';
    default: {
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
  }
}
static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
    const char* expected;
    const char* quote;
    if (ctx->head == NULL) {
      expected = "end";
      quote = "";
    } else {
      expected = ctx->head->field->type->name;
      quote = "'";
    }
    PyErr_Format(PyExc_ValueError,
                 "Buffer dtype mismatch, expected %s%s%s but got %s",
                 quote, expected, quote,
                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
  } else {
    __Pyx_StructField* field = ctx->head->field;
    __Pyx_StructField* parent = (ctx->head - 1)->field;
    PyErr_Format(PyExc_ValueError,
                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
                 parent->type->name, field->name);
  }
}
static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
  char group;
  size_t size, offset, arraysize = 1;
  if (ctx->enc_type == 0) return 0;
  if (ctx->head->field->type->arraysize[0]) {
    int i, ndim = 0;
    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
        ndim = 1;
        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
            PyErr_Format(PyExc_ValueError,
                         "Expected a dimension of size %zu, got %zu",
                         ctx->head->field->type->arraysize[0], ctx->enc_count);
            return -1;
        }
    }
    if (!ctx->is_valid_array) {
      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
                   ctx->head->field->type->ndim, ndim);
      return -1;
    }
    for (i = 0; i < ctx->head->field->type->ndim; i++) {
      arraysize *= ctx->head->field->type->arraysize[i];
    }
    ctx->is_valid_array = 0;
    ctx->enc_count = 1;
  }
  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
  do {
    __Pyx_StructField* field = ctx->head->field;
    __Pyx_TypeInfo* type = field->type;
    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
    } else {
      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
    }
    if (ctx->enc_packmode == '@') {
      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
      size_t align_mod_offset;
      if (align_at == 0) return -1;
      align_mod_offset = ctx->fmt_offset % align_at;
      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
      if (ctx->struct_alignment == 0)
          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
                                                                 ctx->is_complex);
    }
    if (type->size != size || type->typegroup != group) {
      if (type->typegroup == 'C' && type->fields != NULL) {
        size_t parent_offset = ctx->head->parent_offset + field->offset;
        ++ctx->head;
        ctx->head->field = type->fields;
        ctx->head->parent_offset = parent_offset;
        continue;
      }
      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
      } else {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return -1;
      }
    }
    offset = ctx->head->parent_offset + field->offset;
    if (ctx->fmt_offset != offset) {
      PyErr_Format(PyExc_ValueError,
                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
      return -1;
    }
    ctx->fmt_offset += size;
    if (arraysize)
      ctx->fmt_offset += (arraysize - 1) * size;
    --ctx->enc_count;
    while (1) {
      if (field == &ctx->root) {
        ctx->head = NULL;
        if (ctx->enc_count != 0) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return -1;
        }
        break;
      }
      ctx->head->field = ++field;
      if (field->type == NULL) {
        --ctx->head;
        field = ctx->head->field;
        continue;
      } else if (field->type->typegroup == 'S') {
        size_t parent_offset = ctx->head->parent_offset + field->offset;
        if (field->type->fields->type == NULL) continue;
        field = field->type->fields;
        ++ctx->head;
        ctx->head->field = field;
        ctx->head->parent_offset = parent_offset;
        break;
      } else {
        break;
      }
    }
  } while (ctx->enc_count);
  ctx->enc_type = 0;
  ctx->is_complex = 0;
  return 0;
}
static CYTHON_INLINE PyObject *
__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
{
    const char *ts = *tsp;
    int i = 0, number;
    int ndim = ctx->head->field->type->ndim;
;
    ++ts;
    if (ctx->new_count != 1) {
        PyErr_SetString(PyExc_ValueError,
                        "Cannot handle repeated arrays in format string");
        return NULL;
    }
    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
    while (*ts && *ts != ')') {
        switch (*ts) {
            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
            default:  break;
        }
        number = __Pyx_BufFmt_ExpectNumber(&ts);
        if (number == -1) return NULL;
        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
            return PyErr_Format(PyExc_ValueError,
                        "Expected a dimension of size %zu, got %d",
                        ctx->head->field->type->arraysize[i], number);
        if (*ts != ',' && *ts != ')')
            return PyErr_Format(PyExc_ValueError,
                                "Expected a comma in format string, got '%c'", *ts);
        if (*ts == ',') ts++;
        i++;
    }
    if (i != ndim)
        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
                            ctx->head->field->type->ndim, i);
    if (!*ts) {
        PyErr_SetString(PyExc_ValueError,
                        "Unexpected end of format string, expected ')'");
        return NULL;
    }
    ctx->is_valid_array = 1;
    ctx->new_count = 1;
    *tsp = ++ts;
    return Py_None;
}
static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
  int got_Z = 0;
  while (1) {
    switch(*ts) {
      case 0:
        if (ctx->enc_type != 0 && ctx->head == NULL) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return NULL;
        }
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        if (ctx->head != NULL) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return NULL;
        }
        return ts;
      case ' ':
      case '\r':
      case '\n':
        ++ts;
        break;
      case '<':
        if (!__Pyx_IsLittleEndian()) {
          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
          return NULL;
        }
        ctx->new_packmode = '=';
        ++ts;
        break;
      case '>':
      case '!':
        if (__Pyx_IsLittleEndian()) {
          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
          return NULL;
        }
        ctx->new_packmode = '=';
        ++ts;
        break;
      case '=':
      case '@':
      case '^':
        ctx->new_packmode = *ts++;
        break;
      case 'T':
        {
          const char* ts_after_sub;
          size_t i, struct_count = ctx->new_count;
          size_t struct_alignment = ctx->struct_alignment;
          ctx->new_count = 1;
          ++ts;
          if (*ts != '{') {
            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
            return NULL;
          }
          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
          ctx->enc_type = 0;
          ctx->enc_count = 0;
          ctx->struct_alignment = 0;
          ++ts;
          ts_after_sub = ts;
          for (i = 0; i != struct_count; ++i) {
            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
            if (!ts_after_sub) return NULL;
          }
          ts = ts_after_sub;
          if (struct_alignment) ctx->struct_alignment = struct_alignment;
        }
        break;
      case '}':
        {
          size_t alignment = ctx->struct_alignment;
          ++ts;
          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
          ctx->enc_type = 0;
          if (alignment && ctx->fmt_offset % alignment) {
            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
          }
        }
        return ts;
      case 'x':
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        ctx->fmt_offset += ctx->new_count;
        ctx->new_count = 1;
        ctx->enc_count = 0;
        ctx->enc_type = 0;
        ctx->enc_packmode = ctx->new_packmode;
        ++ts;
        break;
      case 'Z':
        got_Z = 1;
        ++ts;
        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
          return NULL;
        }
      case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
      case 'l': case 'L': case 'q': case 'Q':
      case 'f': case 'd': case 'g':
      case 'O': case 'p':
        if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&
            ctx->enc_packmode == ctx->new_packmode) {
          ctx->enc_count += ctx->new_count;
          ctx->new_count = 1;
          got_Z = 0;
          ++ts;
          break;
        }
      case 's':
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        ctx->enc_count = ctx->new_count;
        ctx->enc_packmode = ctx->new_packmode;
        ctx->enc_type = *ts;
        ctx->is_complex = got_Z;
        ++ts;
        ctx->new_count = 1;
        got_Z = 0;
        break;
      case ':':
        ++ts;
        while(*ts != ':') ++ts;
        ++ts;
        break;
      case '(':
        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
        break;
      default:
        {
          int number = __Pyx_BufFmt_ExpectNumber(&ts);
          if (number == -1) return NULL;
          ctx->new_count = (size_t)number;
        }
    }
  }
}
static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
  buf->buf = NULL;
  buf->obj = NULL;
  buf->strides = __Pyx_zeros;
  buf->shape = __Pyx_zeros;
  buf->suboffsets = __Pyx_minusones;
}
static CYTHON_INLINE int __Pyx_GetBufferAndValidate(
        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
{
  if (obj == Py_None || obj == NULL) {
    __Pyx_ZeroBuffer(buf);
    return 0;
  }
  buf->buf = NULL;
  if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail;
  if (buf->ndim != nd) {
    PyErr_Format(PyExc_ValueError,
                 "Buffer has wrong number of dimensions (expected %d, got %d)",
                 nd, buf->ndim);
    goto fail;
  }
  if (!cast) {
    __Pyx_BufFmt_Context ctx;
    __Pyx_BufFmt_Init(&ctx, stack, dtype);
    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
  }
  if ((unsigned)buf->itemsize != dtype->size) {
    PyErr_Format(PyExc_ValueError,
      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
    goto fail;
  }
  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
  return 0;
fail:;
  __Pyx_ZeroBuffer(buf);
  return -1;
}
static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
  if (info->buf == NULL) return;
  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
  __Pyx_ReleaseBuffer(info);
}

/* PyObjectCall */
  #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *result;
    ternaryfunc call = func->ob_type->tp_call;
    if (unlikely(!call))
        return PyObject_Call(func, arg, kw);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = (*call)(func, arg, kw);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyErrFetchRestore */
  #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    tmp_type = tstate->curexc_type;
    tmp_value = tstate->curexc_value;
    tmp_tb = tstate->curexc_traceback;
    tstate->curexc_type = type;
    tstate->curexc_value = value;
    tstate->curexc_traceback = tb;
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
}
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
    *type = tstate->curexc_type;
    *value = tstate->curexc_value;
    *tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
}
#endif

/* RaiseException */
  #if PY_MAJOR_VERSION < 3
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
                        CYTHON_UNUSED PyObject *cause) {
    __Pyx_PyThreadState_declare
    Py_XINCREF(type);
    if (!value || value == Py_None)
        value = NULL;
    else
        Py_INCREF(value);
    if (!tb || tb == Py_None)
        tb = NULL;
    else {
        Py_INCREF(tb);
        if (!PyTraceBack_Check(tb)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: arg 3 must be a traceback or None");
            goto raise_error;
        }
    }
    if (PyType_Check(type)) {
#if CYTHON_COMPILING_IN_PYPY
        if (!value) {
            Py_INCREF(Py_None);
            value = Py_None;
        }
#endif
        PyErr_NormalizeException(&type, &value, &tb);
    } else {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto raise_error;
        }
        value = type;
        type = (PyObject*) Py_TYPE(type);
        Py_INCREF(type);
        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: exception class must be a subclass of BaseException");
            goto raise_error;
        }
    }
    __Pyx_PyThreadState_assign
    __Pyx_ErrRestore(type, value, tb);
    return;
raise_error:
    Py_XDECREF(value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
    return;
}
#else
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
    PyObject* owned_instance = NULL;
    if (tb == Py_None) {
        tb = 0;
    } else if (tb && !PyTraceBack_Check(tb)) {
        PyErr_SetString(PyExc_TypeError,
            "raise: arg 3 must be a traceback or None");
        goto bad;
    }
    if (value == Py_None)
        value = 0;
    if (PyExceptionInstance_Check(type)) {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto bad;
        }
        value = type;
        type = (PyObject*) Py_TYPE(value);
    } else if (PyExceptionClass_Check(type)) {
        PyObject *instance_class = NULL;
        if (value && PyExceptionInstance_Check(value)) {
            instance_class = (PyObject*) Py_TYPE(value);
            if (instance_class != type) {
                int is_subclass = PyObject_IsSubclass(instance_class, type);
                if (!is_subclass) {
                    instance_class = NULL;
                } else if (unlikely(is_subclass == -1)) {
                    goto bad;
                } else {
                    type = instance_class;
                }
            }
        }
        if (!instance_class) {
            PyObject *args;
            if (!value)
                args = PyTuple_New(0);
            else if (PyTuple_Check(value)) {
                Py_INCREF(value);
                args = value;
            } else
                args = PyTuple_Pack(1, value);
            if (!args)
                goto bad;
            owned_instance = PyObject_Call(type, args, NULL);
            Py_DECREF(args);
            if (!owned_instance)
                goto bad;
            value = owned_instance;
            if (!PyExceptionInstance_Check(value)) {
                PyErr_Format(PyExc_TypeError,
                             "calling %R should have returned an instance of "
                             "BaseException, not %R",
                             type, Py_TYPE(value));
                goto bad;
            }
        }
    } else {
        PyErr_SetString(PyExc_TypeError,
            "raise: exception class must be a subclass of BaseException");
        goto bad;
    }
#if PY_VERSION_HEX >= 0x03030000
    if (cause) {
#else
    if (cause && cause != Py_None) {
#endif
        PyObject *fixed_cause;
        if (cause == Py_None) {
            fixed_cause = NULL;
        } else if (PyExceptionClass_Check(cause)) {
            fixed_cause = PyObject_CallObject(cause, NULL);
            if (fixed_cause == NULL)
                goto bad;
        } else if (PyExceptionInstance_Check(cause)) {
            fixed_cause = cause;
            Py_INCREF(fixed_cause);
        } else {
            PyErr_SetString(PyExc_TypeError,
                            "exception causes must derive from "
                            "BaseException");
            goto bad;
        }
        PyException_SetCause(value, fixed_cause);
    }
    PyErr_SetObject(type, value);
    if (tb) {
#if CYTHON_COMPILING_IN_PYPY
        PyObject *tmp_type, *tmp_value, *tmp_tb;
        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
        Py_INCREF(tb);
        PyErr_Restore(tmp_type, tmp_value, tb);
        Py_XDECREF(tmp_tb);
#else
        PyThreadState *tstate = PyThreadState_GET();
        PyObject* tmp_tb = tstate->curexc_traceback;
        if (tb != tmp_tb) {
            Py_INCREF(tb);
            tstate->curexc_traceback = tb;
            Py_XDECREF(tmp_tb);
        }
#endif
    }
bad:
    Py_XDECREF(owned_instance);
    return;
}
#endif

/* GetModuleGlobalName */
    static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
    PyObject *result;
#if CYTHON_COMPILING_IN_CPYTHON
    result = PyDict_GetItem(__pyx_d, name);
    if (likely(result)) {
        Py_INCREF(result);
    } else {
#else
    result = PyObject_GetItem(__pyx_d, name);
    if (!result) {
        PyErr_Clear();
#endif
        result = __Pyx_GetBuiltinName(name);
    }
    return result;
}

/* ExtTypeTest */
      static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (likely(PyObject_TypeCheck(obj, type)))
        return 1;
    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
                 Py_TYPE(obj)->tp_name, type->tp_name);
    return 0;
}

/* BufferIndexError */
      static void __Pyx_RaiseBufferIndexError(int axis) {
  PyErr_Format(PyExc_IndexError,
     "Out of bounds on buffer access (axis %d)", axis);
}

/* PyObjectCallMethO */
      #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
    PyObject *self, *result;
    PyCFunction cfunc;
    cfunc = PyCFunction_GET_FUNCTION(func);
    self = PyCFunction_GET_SELF(func);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = cfunc(self, arg);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallOneArg */
      #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_New(1);
    if (unlikely(!args)) return NULL;
    Py_INCREF(arg);
    PyTuple_SET_ITEM(args, 0, arg);
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
#ifdef __Pyx_CyFunction_USED
    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
#else
    if (likely(PyCFunction_Check(func))) {
#endif
        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
            return __Pyx_PyObject_CallMethO(func, arg);
        }
    }
    return __Pyx__PyObject_CallOneArg(func, arg);
}
#else
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_Pack(1, arg);
    if (unlikely(!args)) return NULL;
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
#endif

/* PyNumberPow2 */
        static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace) {
#if CYTHON_COMPILING_IN_CPYTHON
    Py_ssize_t shiftby;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_CheckExact(exp))) {
        shiftby = PyInt_AS_LONG(exp);
    } else
#endif
    if (likely(PyLong_CheckExact(exp))) {
        #if CYTHON_USE_PYLONG_INTERNALS
        const Py_ssize_t size = Py_SIZE(exp);
        if (likely(size == 1)) {
            shiftby = ((PyLongObject*)exp)->ob_digit[0];
        } else if (size == 0) {
            return PyInt_FromLong(1L);
        } else if (unlikely(size < 0)) {
            goto fallback;
        } else {
            shiftby = PyLong_AsSsize_t(exp);
        }
        #else
        shiftby = PyLong_AsSsize_t(exp);
        #endif
    } else {
        goto fallback;
    }
    if (likely(shiftby >= 0)) {
        if ((size_t)shiftby <= sizeof(long) * 8 - 2) {
            long value = 1L << shiftby;
            return PyInt_FromLong(value);
        } else if ((size_t)shiftby <= sizeof(unsigned PY_LONG_LONG) * 8 - 1) {
            unsigned PY_LONG_LONG value = ((unsigned PY_LONG_LONG)1) << shiftby;
            return PyLong_FromUnsignedLongLong(value);
        } else {
            PyObject *one = PyInt_FromLong(1L);
            if (unlikely(!one)) return NULL;
            return PyNumber_Lshift(one, exp);
        }
    } else if (shiftby == -1 && PyErr_Occurred()) {
        PyErr_Clear();
    }
fallback:
#endif
    return (inplace ? PyNumber_InPlacePower : PyNumber_Power)(two, exp, none);
}

/* WriteUnraisableException */
        static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
                                  CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
                                  int full_traceback, CYTHON_UNUSED int nogil) {
    PyObject *old_exc, *old_val, *old_tb;
    PyObject *ctx;
    __Pyx_PyThreadState_declare
#ifdef WITH_THREAD
    PyGILState_STATE state;
    if (nogil)
        state = PyGILState_Ensure();
#ifdef _MSC_VER
    else state = (PyGILState_STATE)-1;
#endif
#endif
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
    if (full_traceback) {
        Py_XINCREF(old_exc);
        Py_XINCREF(old_val);
        Py_XINCREF(old_tb);
        __Pyx_ErrRestore(old_exc, old_val, old_tb);
        PyErr_PrintEx(1);
    }
    #if PY_MAJOR_VERSION < 3
    ctx = PyString_FromString(name);
    #else
    ctx = PyUnicode_FromString(name);
    #endif
    __Pyx_ErrRestore(old_exc, old_val, old_tb);
    if (!ctx) {
        PyErr_WriteUnraisable(Py_None);
    } else {
        PyErr_WriteUnraisable(ctx);
        Py_DECREF(ctx);
    }
#ifdef WITH_THREAD
    if (nogil)
        PyGILState_Release(state);
#endif
}

/* RaiseTooManyValuesToUnpack */
        static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
}

/* RaiseNeedMoreValuesToUnpack */
        static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
    PyErr_Format(PyExc_ValueError,
                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
                 index, (index == 1) ? "" : "s");
}

/* RaiseNoneIterError */
        static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}

/* Import */
        static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
    #if PY_VERSION_HEX < 0x03030000
    PyObject *py_import;
    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
    if (!py_import)
        goto bad;
    #endif
    if (from_list)
        list = from_list;
    else {
        empty_list = PyList_New(0);
        if (!empty_list)
            goto bad;
        list = empty_list;
    }
    global_dict = PyModule_GetDict(__pyx_m);
    if (!global_dict)
        goto bad;
    empty_dict = PyDict_New();
    if (!empty_dict)
        goto bad;
    {
        #if PY_MAJOR_VERSION >= 3
        if (level == -1) {
            if (strchr(__Pyx_MODULE_NAME, '.')) {
                #if PY_VERSION_HEX < 0x03030000
                PyObject *py_level = PyInt_FromLong(1);
                if (!py_level)
                    goto bad;
                module = PyObject_CallFunctionObjArgs(py_import,
                    name, global_dict, empty_dict, list, py_level, NULL);
                Py_DECREF(py_level);
                #else
                module = PyImport_ImportModuleLevelObject(
                    name, global_dict, empty_dict, list, 1);
                #endif
                if (!module) {
                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
                        goto bad;
                    PyErr_Clear();
                }
            }
            level = 0;
        }
        #endif
        if (!module) {
            #if PY_VERSION_HEX < 0x03030000
            PyObject *py_level = PyInt_FromLong(level);
            if (!py_level)
                goto bad;
            module = PyObject_CallFunctionObjArgs(py_import,
                name, global_dict, empty_dict, list, py_level, NULL);
            Py_DECREF(py_level);
            #else
            module = PyImport_ImportModuleLevelObject(
                name, global_dict, empty_dict, list, level);
            #endif
        }
    }
bad:
    #if PY_VERSION_HEX < 0x03030000
    Py_XDECREF(py_import);
    #endif
    Py_XDECREF(empty_list);
    Py_XDECREF(empty_dict);
    return module;
}

/* CodeObjectCache */
        static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
    int start = 0, mid = 0, end = count - 1;
    if (end >= 0 && code_line > entries[end].code_line) {
        return count;
    }
    while (start < end) {
        mid = start + (end - start) / 2;
        if (code_line < entries[mid].code_line) {
            end = mid;
        } else if (code_line > entries[mid].code_line) {
             start = mid + 1;
        } else {
            return mid;
        }
    }
    if (code_line <= entries[mid].code_line) {
        return mid;
    } else {
        return mid + 1;
    }
}
static PyCodeObject *__pyx_find_code_object(int code_line) {
    PyCodeObject* code_object;
    int pos;
    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
        return NULL;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
        return NULL;
    }
    code_object = __pyx_code_cache.entries[pos].code_object;
    Py_INCREF(code_object);
    return code_object;
}
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
    int pos, i;
    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
    if (unlikely(!code_line)) {
        return;
    }
    if (unlikely(!entries)) {
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
        if (likely(entries)) {
            __pyx_code_cache.entries = entries;
            __pyx_code_cache.max_count = 64;
            __pyx_code_cache.count = 1;
            entries[0].code_line = code_line;
            entries[0].code_object = code_object;
            Py_INCREF(code_object);
        }
        return;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
        PyCodeObject* tmp = entries[pos].code_object;
        entries[pos].code_object = code_object;
        Py_DECREF(tmp);
        return;
    }
    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
        int new_max = __pyx_code_cache.max_count + 64;
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
            __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
        if (unlikely(!entries)) {
            return;
        }
        __pyx_code_cache.entries = entries;
        __pyx_code_cache.max_count = new_max;
    }
    for (i=__pyx_code_cache.count; i>pos; i--) {
        entries[i] = entries[i-1];
    }
    entries[pos].code_line = code_line;
    entries[pos].code_object = code_object;
    __pyx_code_cache.count++;
    Py_INCREF(code_object);
}

/* AddTraceback */
        #include "compile.h"
#include "frameobject.h"
#include "traceback.h"
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
            const char *funcname, int c_line,
            int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyObject *py_srcfile = 0;
    PyObject *py_funcname = 0;
    #if PY_MAJOR_VERSION < 3
    py_srcfile = PyString_FromString(filename);
    #else
    py_srcfile = PyUnicode_FromString(filename);
    #endif
    if (!py_srcfile) goto bad;
    if (c_line) {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #else
        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #endif
    }
    else {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromString(funcname);
        #else
        py_funcname = PyUnicode_FromString(funcname);
        #endif
    }
    if (!py_funcname) goto bad;
    py_code = __Pyx_PyCode_New(
        0,
        0,
        0,
        0,
        0,
        __pyx_empty_bytes, /*PyObject *code,*/
        __pyx_empty_tuple, /*PyObject *consts,*/
        __pyx_empty_tuple, /*PyObject *names,*/
        __pyx_empty_tuple, /*PyObject *varnames,*/
        __pyx_empty_tuple, /*PyObject *freevars,*/
        __pyx_empty_tuple, /*PyObject *cellvars,*/
        py_srcfile,   /*PyObject *filename,*/
        py_funcname,  /*PyObject *name,*/
        py_line,
        __pyx_empty_bytes  /*PyObject *lnotab*/
    );
    Py_DECREF(py_srcfile);
    Py_DECREF(py_funcname);
    return py_code;
bad:
    Py_XDECREF(py_srcfile);
    Py_XDECREF(py_funcname);
    return NULL;
}
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyFrameObject *py_frame = 0;
    py_code = __pyx_find_code_object(c_line ? c_line : py_line);
    if (!py_code) {
        py_code = __Pyx_CreateCodeObjectForTraceback(
            funcname, c_line, py_line, filename);
        if (!py_code) goto bad;
        __pyx_insert_code_object(c_line ? c_line : py_line, py_code);
    }
    py_frame = PyFrame_New(
        PyThreadState_GET(), /*PyThreadState *tstate,*/
        py_code,             /*PyCodeObject *code,*/
        __pyx_d,      /*PyObject *globals,*/
        0                    /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    py_frame->f_lineno = py_line;
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}

#if PY_MAJOR_VERSION < 3
static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
    return -1;
}
static void __Pyx_ReleaseBuffer(Py_buffer *view) {
    PyObject *obj = view->obj;
    if (!obj) return;
    if (PyObject_CheckBuffer(obj)) {
        PyBuffer_Release(view);
        return;
    }
        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; }
    Py_DECREF(obj);
    view->obj = NULL;
}
#endif


        /* CIntFromPyVerify */
        #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
    {\
        func_type value = func_value;\
        if (sizeof(target_type) < sizeof(func_type)) {\
            if (unlikely(value != (func_type) (target_type) value)) {\
                func_type zero = 0;\
                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
                    return (target_type) -1;\
                if (is_unsigned && unlikely(value < zero))\
                    goto raise_neg_overflow;\
                else\
                    goto raise_overflow;\
            }\
        }\
        return (target_type) value;\
    }

/* CIntToPy */
        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) {
    const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(Py_intptr_t) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(Py_intptr_t) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
    const int neg_one = (int) -1, const_zero = (int) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(int) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(int) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(int),
                                     little, !is_unsigned);
    }
}

/* None */
        #if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      return ::std::complex< float >(x, y);
    }
  #else
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      return x + y*(__pyx_t_float_complex)_Complex_I;
    }
  #endif
#else
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      __pyx_t_float_complex z;
      z.real = x;
      z.imag = y;
      return z;
    }
#endif

/* None */
        #if CYTHON_CCOMPLEX
#else
    static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
       return (a.real == b.real) && (a.imag == b.imag);
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real + b.real;
        z.imag = a.imag + b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real - b.real;
        z.imag = a.imag - b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real * b.real - a.imag * b.imag;
        z.imag = a.real * b.imag + a.imag * b.real;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        float denom = b.real * b.real + b.imag * b.imag;
        z.real = (a.real * b.real + a.imag * b.imag) / denom;
        z.imag = (a.imag * b.real - a.real * b.imag) / denom;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) {
        __pyx_t_float_complex z;
        z.real = -a.real;
        z.imag = -a.imag;
        return z;
    }
    static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) {
       return (a.real == 0) && (a.imag == 0);
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) {
        __pyx_t_float_complex z;
        z.real =  a.real;
        z.imag = -a.imag;
        return z;
    }
    #if 1
        static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) {
          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
            return sqrtf(z.real*z.real + z.imag*z.imag);
          #else
            return hypotf(z.real, z.imag);
          #endif
        }
        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
            __pyx_t_float_complex z;
            float r, lnr, theta, z_r, z_theta;
            if (b.imag == 0 && b.real == (int)b.real) {
                if (b.real < 0) {
                    float denom = a.real * a.real + a.imag * a.imag;
                    a.real = a.real / denom;
                    a.imag = -a.imag / denom;
                    b.real = -b.real;
                }
                switch ((int)b.real) {
                    case 0:
                        z.real = 1;
                        z.imag = 0;
                        return z;
                    case 1:
                        return a;
                    case 2:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(a, a);
                    case 3:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(z, a);
                    case 4:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(z, z);
                }
            }
            if (a.imag == 0) {
                if (a.real == 0) {
                    return a;
                }
                r = a.real;
                theta = 0;
            } else {
                r = __Pyx_c_absf(a);
                theta = atan2f(a.imag, a.real);
            }
            lnr = logf(r);
            z_r = expf(lnr * b.real - theta * b.imag);
            z_theta = theta * b.real + lnr * b.imag;
            z.real = z_r * cosf(z_theta);
            z.imag = z_r * sinf(z_theta);
            return z;
        }
    #endif
#endif

/* None */
        #if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      return ::std::complex< double >(x, y);
    }
  #else
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      return x + y*(__pyx_t_double_complex)_Complex_I;
    }
  #endif
#else
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      __pyx_t_double_complex z;
      z.real = x;
      z.imag = y;
      return z;
    }
#endif

/* None */
        #if CYTHON_CCOMPLEX
#else
    static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) {
       return (a.real == b.real) && (a.imag == b.imag);
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real + b.real;
        z.imag = a.imag + b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real - b.real;
        z.imag = a.imag - b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real * b.real - a.imag * b.imag;
        z.imag = a.real * b.imag + a.imag * b.real;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        double denom = b.real * b.real + b.imag * b.imag;
        z.real = (a.real * b.real + a.imag * b.imag) / denom;
        z.imag = (a.imag * b.real - a.real * b.imag) / denom;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) {
        __pyx_t_double_complex z;
        z.real = -a.real;
        z.imag = -a.imag;
        return z;
    }
    static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) {
       return (a.real == 0) && (a.imag == 0);
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) {
        __pyx_t_double_complex z;
        z.real =  a.real;
        z.imag = -a.imag;
        return z;
    }
    #if 1
        static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) {
          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
            return sqrt(z.real*z.real + z.imag*z.imag);
          #else
            return hypot(z.real, z.imag);
          #endif
        }
        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) {
            __pyx_t_double_complex z;
            double r, lnr, theta, z_r, z_theta;
            if (b.imag == 0 && b.real == (int)b.real) {
                if (b.real < 0) {
                    double denom = a.real * a.real + a.imag * a.imag;
                    a.real = a.real / denom;
                    a.imag = -a.imag / denom;
                    b.real = -b.real;
                }
                switch ((int)b.real) {
                    case 0:
                        z.real = 1;
                        z.imag = 0;
                        return z;
                    case 1:
                        return a;
                    case 2:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(a, a);
                    case 3:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(z, a);
                    case 4:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(z, z);
                }
            }
            if (a.imag == 0) {
                if (a.real == 0) {
                    return a;
                }
                r = a.real;
                theta = 0;
            } else {
                r = __Pyx_c_abs(a);
                theta = atan2(a.imag, a.real);
            }
            lnr = log(r);
            z_r = exp(lnr * b.real - theta * b.imag);
            z_theta = theta * b.real + lnr * b.imag;
            z.real = z_r * cos(z_theta);
            z.imag = z_r * sin(z_theta);
            return z;
        }
    #endif
#endif

/* CIntToPy */
        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
    const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NPY_TYPES) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
                                     little, !is_unsigned);
    }
}

/* CIntFromPy */
        static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
    const int neg_one = (int) -1, const_zero = (int) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(int) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (int) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int) 0;
                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
                case 2:
                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (int) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(int) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int) 0;
                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(int) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            int val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (int) -1;
        }
    } else {
        int val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (int) -1;
        val = __Pyx_PyInt_As_int(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to int");
    return (int) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to int");
    return (int) -1;
}

/* CIntFromPy */
        static CYTHON_INLINE int64 __Pyx_PyInt_As_int64(PyObject *x) {
    const int64 neg_one = (int64) -1, const_zero = (int64) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(int64) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(int64, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (int64) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int64) 0;
                case  1: __PYX_VERIFY_RETURN_INT(int64, digit, digits[0])
                case 2:
                    if (8 * sizeof(int64) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) >= 2 * PyLong_SHIFT) {
                            return (int64) (((((int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int64) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) >= 3 * PyLong_SHIFT) {
                            return (int64) (((((((int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int64) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) >= 4 * PyLong_SHIFT) {
                            return (int64) (((((((((int64)digits[3]) << PyLong_SHIFT) | (int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (int64) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(int64) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int64, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(int64) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int64, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int64) 0;
                case -1: __PYX_VERIFY_RETURN_INT(int64, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(int64,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(int64) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 2 * PyLong_SHIFT) {
                            return (int64) (((int64)-1)*(((((int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(int64) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 2 * PyLong_SHIFT) {
                            return (int64) ((((((int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(int64) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 3 * PyLong_SHIFT) {
                            return (int64) (((int64)-1)*(((((((int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int64) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 3 * PyLong_SHIFT) {
                            return (int64) ((((((((int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(int64) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 4 * PyLong_SHIFT) {
                            return (int64) (((int64)-1)*(((((((((int64)digits[3]) << PyLong_SHIFT) | (int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int64) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 4 * PyLong_SHIFT) {
                            return (int64) ((((((((((int64)digits[3]) << PyLong_SHIFT) | (int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(int64) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int64, long, PyLong_AsLong(x))
            } else if (sizeof(int64) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int64, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            int64 val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (int64) -1;
        }
    } else {
        int64 val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (int64) -1;
        val = __Pyx_PyInt_As_int64(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to int64");
    return (int64) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to int64");
    return (int64) -1;
}

/* CIntFromPy */
        static CYTHON_INLINE Py_intptr_t __Pyx_PyInt_As_Py_intptr_t(PyObject *x) {
    const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(Py_intptr_t) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (Py_intptr_t) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (Py_intptr_t) 0;
                case  1: __PYX_VERIFY_RETURN_INT(Py_intptr_t, digit, digits[0])
                case 2:
                    if (8 * sizeof(Py_intptr_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) >= 2 * PyLong_SHIFT) {
                            return (Py_intptr_t) (((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(Py_intptr_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) >= 3 * PyLong_SHIFT) {
                            return (Py_intptr_t) (((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(Py_intptr_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) >= 4 * PyLong_SHIFT) {
                            return (Py_intptr_t) (((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (Py_intptr_t) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (Py_intptr_t) 0;
                case -1: __PYX_VERIFY_RETURN_INT(Py_intptr_t, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(Py_intptr_t,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(Py_intptr_t) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) {
                            return (Py_intptr_t) (((Py_intptr_t)-1)*(((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(Py_intptr_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) {
                            return (Py_intptr_t) ((((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) {
                            return (Py_intptr_t) (((Py_intptr_t)-1)*(((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(Py_intptr_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) {
                            return (Py_intptr_t) ((((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) - 1 > 4 * PyLong_SHIFT) {
                            return (Py_intptr_t) (((Py_intptr_t)-1)*(((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(Py_intptr_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(Py_intptr_t) - 1 > 4 * PyLong_SHIFT) {
                            return (Py_intptr_t) ((((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(Py_intptr_t) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, long, PyLong_AsLong(x))
            } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            Py_intptr_t val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (Py_intptr_t) -1;
        }
    } else {
        Py_intptr_t val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (Py_intptr_t) -1;
        val = __Pyx_PyInt_As_Py_intptr_t(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to Py_intptr_t");
    return (Py_intptr_t) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to Py_intptr_t");
    return (Py_intptr_t) -1;
}

/* CIntFromPy */
        static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
    const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(size_t) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (size_t) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (size_t) 0;
                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
                case 2:
                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
                            return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
                            return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
                            return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (size_t) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(size_t) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (size_t) 0;
                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                            return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                            return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
                            return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(size_t) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            size_t val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (size_t) -1;
        }
    } else {
        size_t val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (size_t) -1;
        val = __Pyx_PyInt_As_size_t(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to size_t");
    return (size_t) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to size_t");
    return (size_t) -1;
}

/* CIntToPy */
        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
    const long neg_one = (long) -1, const_zero = (long) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(long) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(long) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(long),
                                     little, !is_unsigned);
    }
}

/* CIntFromPy */
        static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
    const long neg_one = (long) -1, const_zero = (long) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(long) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (long) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (long) 0;
                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
                case 2:
                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (long) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(long) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (long) 0;
                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(long) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            long val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (long) -1;
        }
    } else {
        long val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (long) -1;
        val = __Pyx_PyInt_As_long(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to long");
    return (long) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to long");
    return (long) -1;
}

/* CheckBinaryVersion */
        static int __Pyx_check_binary_version(void) {
    char ctversion[4], rtversion[4];
    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
        char message[200];
        PyOS_snprintf(message, sizeof(message),
                      "compiletime version %s of module '%.100s' "
                      "does not match runtime version %s",
                      ctversion, __Pyx_MODULE_NAME, rtversion);
        return PyErr_WarnEx(NULL, message, 1);
    }
    return 0;
}

/* ModuleImport */
        #ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
    PyObject *py_name = 0;
    PyObject *py_module = 0;
    py_name = __Pyx_PyIdentifier_FromString(name);
    if (!py_name)
        goto bad;
    py_module = PyImport_Import(py_name);
    Py_DECREF(py_name);
    return py_module;
bad:
    Py_XDECREF(py_name);
    return 0;
}
#endif

/* TypeImport */
        #ifndef __PYX_HAVE_RT_ImportType
#define __PYX_HAVE_RT_ImportType
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
    size_t size, int strict)
{
    PyObject *py_module = 0;
    PyObject *result = 0;
    PyObject *py_name = 0;
    char warning[200];
    Py_ssize_t basicsize;
#ifdef Py_LIMITED_API
    PyObject *py_basicsize;
#endif
    py_module = __Pyx_ImportModule(module_name);
    if (!py_module)
        goto bad;
    py_name = __Pyx_PyIdentifier_FromString(class_name);
    if (!py_name)
        goto bad;
    result = PyObject_GetAttr(py_module, py_name);
    Py_DECREF(py_name);
    py_name = 0;
    Py_DECREF(py_module);
    py_module = 0;
    if (!result)
        goto bad;
    if (!PyType_Check(result)) {
        PyErr_Format(PyExc_TypeError,
            "%.200s.%.200s is not a type object",
            module_name, class_name);
        goto bad;
    }
#ifndef Py_LIMITED_API
    basicsize = ((PyTypeObject *)result)->tp_basicsize;
#else
    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
    if (!py_basicsize)
        goto bad;
    basicsize = PyLong_AsSsize_t(py_basicsize);
    Py_DECREF(py_basicsize);
    py_basicsize = 0;
    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
        goto bad;
#endif
    if (!strict && (size_t)basicsize > size) {
        PyOS_snprintf(warning, sizeof(warning),
            "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd",
            module_name, class_name, basicsize, size);
        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
    }
    else if ((size_t)basicsize != size) {
        PyErr_Format(PyExc_ValueError,
            "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd",
            module_name, class_name, basicsize, size);
        goto bad;
    }
    return (PyTypeObject *)result;
bad:
    Py_XDECREF(py_module);
    Py_XDECREF(result);
    return NULL;
}
#endif

/* InitStrings */
        static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
    while (t->p) {
        #if PY_MAJOR_VERSION < 3
        if (t->is_unicode) {
            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
        } else if (t->intern) {
            *t->p = PyString_InternFromString(t->s);
        } else {
            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
        }
        #else
        if (t->is_unicode | t->is_str) {
            if (t->intern) {
                *t->p = PyUnicode_InternFromString(t->s);
            } else if (t->encoding) {
                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
            } else {
                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
            }
        } else {
            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
        }
        #endif
        if (!*t->p)
            return -1;
        ++t;
    }
    return 0;
}

static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
}
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {
    Py_ssize_t ignore;
    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
}
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
    if (
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
            __Pyx_sys_getdefaultencoding_not_ascii &&
#endif
            PyUnicode_Check(o)) {
#if PY_VERSION_HEX < 0x03030000
        char* defenc_c;
        PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
        if (!defenc) return NULL;
        defenc_c = PyBytes_AS_STRING(defenc);
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        {
            char* end = defenc_c + PyBytes_GET_SIZE(defenc);
            char* c;
            for (c = defenc_c; c < end; c++) {
                if ((unsigned char) (*c) >= 128) {
                    PyUnicode_AsASCIIString(o);
                    return NULL;
                }
            }
        }
#endif
        *length = PyBytes_GET_SIZE(defenc);
        return defenc_c;
#else
        if (__Pyx_PyUnicode_READY(o) == -1) return NULL;
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        if (PyUnicode_IS_ASCII(o)) {
            *length = PyUnicode_GET_LENGTH(o);
            return PyUnicode_AsUTF8(o);
        } else {
            PyUnicode_AsASCIIString(o);
            return NULL;
        }
#else
        return PyUnicode_AsUTF8AndSize(o, length);
#endif
#endif
    } else
#endif
#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
    if (PyByteArray_Check(o)) {
        *length = PyByteArray_GET_SIZE(o);
        return PyByteArray_AS_STRING(o);
    } else
#endif
    {
        char* result;
        int r = PyBytes_AsStringAndSize(o, &result, length);
        if (unlikely(r < 0)) {
            return NULL;
        } else {
            return result;
        }
    }
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
   int is_true = x == Py_True;
   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
   else return PyObject_IsTrue(x);
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
  PyNumberMethods *m;
  const char *name = NULL;
  PyObject *res = NULL;
#if PY_MAJOR_VERSION < 3
  if (PyInt_Check(x) || PyLong_Check(x))
#else
  if (PyLong_Check(x))
#endif
    return __Pyx_NewRef(x);
  m = Py_TYPE(x)->tp_as_number;
#if PY_MAJOR_VERSION < 3
  if (m && m->nb_int) {
    name = "int";
    res = PyNumber_Int(x);
  }
  else if (m && m->nb_long) {
    name = "long";
    res = PyNumber_Long(x);
  }
#else
  if (m && m->nb_int) {
    name = "int";
    res = PyNumber_Long(x);
  }
#endif
  if (res) {
#if PY_MAJOR_VERSION < 3
    if (!PyInt_Check(res) && !PyLong_Check(res)) {
#else
    if (!PyLong_Check(res)) {
#endif
      PyErr_Format(PyExc_TypeError,
                   "__%.4s__ returned non-%.4s (type %.200s)",
                   name, name, Py_TYPE(res)->tp_name);
      Py_DECREF(res);
      return NULL;
    }
  }
  else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_TypeError,
                    "an integer is required");
  }
  return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
  Py_ssize_t ival;
  PyObject *x;
#if PY_MAJOR_VERSION < 3
  if (likely(PyInt_CheckExact(b))) {
    if (sizeof(Py_ssize_t) >= sizeof(long))
        return PyInt_AS_LONG(b);
    else
        return PyInt_AsSsize_t(x);
  }
#endif
  if (likely(PyLong_CheckExact(b))) {
    #if CYTHON_USE_PYLONG_INTERNALS
    const digit* digits = ((PyLongObject*)b)->ob_digit;
    const Py_ssize_t size = Py_SIZE(b);
    if (likely(__Pyx_sst_abs(size) <= 1)) {
        ival = likely(size) ? digits[0] : 0;
        if (size == -1) ival = -ival;
        return ival;
    } else {
      switch (size) {
         case 2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
      }
    }
    #endif
    return PyLong_AsSsize_t(b);
  }
  x = PyNumber_Index(b);
  if (!x) return -1;
  ival = PyInt_AsSsize_t(x);
  Py_DECREF(x);
  return ival;
}
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
    return PyInt_FromSize_t(ival);
}


#endif /* Py_PYTHON_H */
healpy-1.10.3/healpy/src/_pixelfunc.pyx0000664000175000017500000000753713010374155020310 0ustar  zoncazonca00000000000000# Wrapper around the geometry methods in Healpix_base class

import numpy as np
cimport numpy as np
from libcpp cimport bool
cimport cython
from _common cimport int64, Healpix_Ordering_Scheme, RING, NEST, SET_NSIDE, T_Healpix_Base

def ringinfo(nside, np.ndarray[int64, ndim=1] ring not None):
    """Get information for rings

    Rings are specified by a positive integer, 1 <= ring <= 4*nside-1.

    Parameters
    ----------
    nside : int
      The healpix nside parameter, must be a power of 2, less than 2**30
    ring : int, scalar or array-like
      The ring number

    Returns
    -------
    startpix : int64, length equal to that of *ring*
      Starting pixel identifier (NEST ordering)
    ringpix : int64, length equal to that of *ring*
      Number of pixels in ring
    costheta : float, length equal to that of *ring*
      Cosine of the co-latitude
    sintheta : float, length equal to that of *ring*
      Sine of the co-latitude
    shifted : bool, length equal to that of *ring*
      If True, the center of the first pixel is not at phi=0

    Example
    -------
    >>> import healpy as hp
    >>> import numpy as np
    >>> nside = 2
    >>> hp.ringinfo(nside, np.arange(4*nside-1))
    (array([ 0,  0,  4, 12, 20, 28, 36]), array([0, 4, 8, 8, 8, 8, 8]), array([ 1.        ,  0.91666667,  0.66666667,  0.33333333,  0.        ,
           -0.33333333, -0.66666667]), array([ 0.        ,  0.39965263,  0.74535599,  0.94280904,  1.        ,
            0.94280904,  0.74535599]), array([ True,  True,  True, False,  True, False,  True], dtype=bool))
    """
    if not isnsideok(nside):
        raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
    cdef Healpix_Ordering_Scheme scheme = NEST
    cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
    num = ring.shape[0]
    cdef np.ndarray[int64, ndim=1] startpix = np.empty(num, dtype=np.int64)
    cdef np.ndarray[int64, ndim=1] ringpix = np.empty(num, dtype=np.int64)
    cdef np.ndarray[double, ndim=1] costheta = np.empty(num, dtype=np.float)
    cdef np.ndarray[double, ndim=1] sintheta = np.empty(num, dtype=np.float)
    cdef np.ndarray[bool, ndim=1, cast=True] shifted = np.empty(num, dtype=np.bool)
    for i in range(num):
        hb.get_ring_info(ring[i], startpix[i], ringpix[i], costheta[i], sintheta[i], shifted[i])
    return startpix, ringpix, costheta, sintheta, shifted

def pix2ring(nside, np.ndarray[int64, ndim=1] pix not None, nest=False):
    """Convert pixel identifier to ring number

    Rings are specified by a positive integer, 1 <= ring <= 4*nside-1.

    Parameters
    ----------
    nside : int
      The healpix nside parameter, must be a power of 2, less than 2**30
    pix : int64, scalar or array-like
      The pixel identifier(s)
    nest : bool
      Is *pix* specified in the NEST ordering scheme?

    Returns
    -------
    ring : int, length equal to that of *pix*
      Ring number

    Example
    -------
    >>> import healpy as hp
    >>> import numpy as np
    >>> nside = 2
    >>> hp.pix2ring(nside, np.arange(hp.nside2npix(nside)))
    array([1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4,
           4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,
           7, 7])
    """

    if not isnsideok(nside):
        raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
    cdef Healpix_Ordering_Scheme scheme
    if nest:
        scheme = NEST
    else:
        scheme = RING
    cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
    num = pix.shape[0]
    cdef np.ndarray[int64, ndim=1] ring = np.empty(num, dtype=np.int64)
    for i in range(num):
        ring[i] = hb.pix2ring(pix[i])
    return ring


cdef bool isnsideok(int nside):
    if nside < 0 or nside != 2**int(round(np.log2(nside))):
        return False
    else:
        return True


healpy-1.10.3/healpy/src/_query_disc.cpp0000664000175000017500000155346713010376616020441 0ustar  zoncazonca00000000000000/* Generated by Cython 0.24 */

#define PY_SSIZE_T_CLEAN
#include "Python.h"
#ifndef Py_PYTHON_H
    #error Python headers needed to compile C extensions, please install development version of Python.
#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
    #error Cython requires Python 2.6+ or Python 3.2+.
#else
#define CYTHON_ABI "0_24"
#include 
#ifndef offsetof
  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
  #ifndef __stdcall
    #define __stdcall
  #endif
  #ifndef __cdecl
    #define __cdecl
  #endif
  #ifndef __fastcall
    #define __fastcall
  #endif
#endif
#ifndef DL_IMPORT
  #define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
  #define DL_EXPORT(t) t
#endif
#ifndef PY_LONG_LONG
  #define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
  #define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
  #define CYTHON_COMPILING_IN_PYPY 1
  #define CYTHON_COMPILING_IN_CPYTHON 0
#else
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_CPYTHON 1
#endif
#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000
  #define CYTHON_USE_PYLONG_INTERNALS 1
#endif
#if CYTHON_USE_PYLONG_INTERNALS
  #include "longintrepr.h"
  #undef SHIFT
  #undef BASE
  #undef MASK
#endif
#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
  #define Py_OptimizeFlag 0
#endif
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
#if PY_MAJOR_VERSION < 3
  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyClass_Type
#else
  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyType_Type
#endif
#ifndef Py_TPFLAGS_CHECKTYPES
  #define Py_TPFLAGS_CHECKTYPES 0
#endif
#ifndef Py_TPFLAGS_HAVE_INDEX
  #define Py_TPFLAGS_HAVE_INDEX 0
#endif
#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#ifndef Py_TPFLAGS_HAVE_FINALIZE
  #define Py_TPFLAGS_HAVE_FINALIZE 0
#endif
#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
  #define CYTHON_PEP393_ENABLED 1
  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
                                              0 : _PyUnicode_Ready((PyObject *)(op)))
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
#else
  #define CYTHON_PEP393_ENABLED 0
  #define __Pyx_PyUnicode_READY(op)       (0)
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
#endif
#if CYTHON_COMPILING_IN_PYPY
  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
#else
  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
  #define PyObject_Malloc(s)   PyMem_Malloc(s)
  #define PyObject_Free(p)     PyMem_Free(p)
  #define PyObject_Realloc(p)  PyMem_Realloc(p)
#endif
#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
#else
  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
#endif
#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
  #define PyObject_ASCII(o)            PyObject_Repr(o)
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBaseString_Type            PyUnicode_Type
  #define PyStringObject               PyUnicodeObject
  #define PyString_Type                PyUnicode_Type
  #define PyString_Check               PyUnicode_Check
  #define PyString_CheckExact          PyUnicode_CheckExact
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
#else
  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
#endif
#ifndef PySet_CheckExact
  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
#endif
#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
#if PY_MAJOR_VERSION >= 3
  #define PyIntObject                  PyLongObject
  #define PyInt_Type                   PyLong_Type
  #define PyInt_Check(op)              PyLong_Check(op)
  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
  #define PyInt_FromString             PyLong_FromString
  #define PyInt_FromUnicode            PyLong_FromUnicode
  #define PyInt_FromLong               PyLong_FromLong
  #define PyInt_FromSize_t             PyLong_FromSize_t
  #define PyInt_FromSsize_t            PyLong_FromSsize_t
  #define PyInt_AsLong                 PyLong_AsLong
  #define PyInt_AS_LONG                PyLong_AS_LONG
  #define PyInt_AsSsize_t              PyLong_AsSsize_t
  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
  #define PyNumber_Int                 PyNumber_Long
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBoolObject                 PyLongObject
#endif
#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
  #ifndef PyUnicode_InternFromString
    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
  #endif
#endif
#if PY_VERSION_HEX < 0x030200A4
  typedef long Py_hash_t;
  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
#else
  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
#else
  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
#endif
#if PY_VERSION_HEX >= 0x030500B1
#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
typedef struct {
    unaryfunc am_await;
    unaryfunc am_aiter;
    unaryfunc am_anext;
} __Pyx_PyAsyncMethodsStruct;
#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
#else
#define __Pyx_PyType_AsAsync(obj) NULL
#endif
#ifndef CYTHON_RESTRICT
  #if defined(__GNUC__)
    #define CYTHON_RESTRICT __restrict__
  #elif defined(_MSC_VER) && _MSC_VER >= 1400
    #define CYTHON_RESTRICT __restrict
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_RESTRICT restrict
  #else
    #define CYTHON_RESTRICT
  #endif
#endif
#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)

#ifndef __cplusplus
  #error "Cython files generated with the C++ option must be compiled with a C++ compiler."
#endif
#ifndef CYTHON_INLINE
  #define CYTHON_INLINE inline
#endif
template
void __Pyx_call_destructor(T& x) {
    x.~T();
}
template
class __Pyx_FakeReference {
  public:
    __Pyx_FakeReference() : ptr(NULL) { }
    __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { }
    T *operator->() { return ptr; }
    operator T&() { return *ptr; }
  private:
    T *ptr;
};

#if defined(WIN32) || defined(MS_WINDOWS)
  #define _USE_MATH_DEFINES
#endif
#include 
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
  float value;
  memset(&value, 0xFF, sizeof(value));
  return value;
}
#endif


#define __PYX_ERR(f_index, lineno, Ln_error) \
{ \
  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
}

#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
#else
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
#endif

#ifndef __PYX_EXTERN_C
  #ifdef __cplusplus
    #define __PYX_EXTERN_C extern "C"
  #else
    #define __PYX_EXTERN_C extern
  #endif
#endif

#define __PYX_HAVE__healpy___query_disc
#define __PYX_HAVE_API__healpy___query_disc
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "numpy/arrayobject.h"
#include "numpy/ufuncobject.h"
#include 
#include "ios"
#include "new"
#include "stdexcept"
#include "typeinfo"
#include "stddef.h"
#include "datatypes.h"
#include "xcomplex.h"
#include "arr.h"
#include "rangeset.h"
#include "vec3.h"
#include "pointing.h"
#include "healpix_base.h"
#include "healpix_map.h"
#include "alm.h"
#ifdef _OPENMP
#include 
#endif /* _OPENMP */

#ifdef PYREX_WITHOUT_ASSERTIONS
#define CYTHON_WITHOUT_ASSERTIONS
#endif

#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define CYTHON_UNUSED __attribute__ ((__unused__))
#   else
#     define CYTHON_UNUSED
#   endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
#   define CYTHON_UNUSED __attribute__ ((__unused__))
# else
#   define CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_NCP_UNUSED
# if CYTHON_COMPILING_IN_CPYTHON
#  define CYTHON_NCP_UNUSED
# else
#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;

#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
#define __PYX_DEFAULT_STRING_ENCODING ""
#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#define __Pyx_uchar_cast(c) ((unsigned char)c)
#define __Pyx_long_cast(x) ((long)x)
#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
    (sizeof(type) < sizeof(Py_ssize_t))  ||\
    (sizeof(type) > sizeof(Py_ssize_t) &&\
          likely(v < (type)PY_SSIZE_T_MAX ||\
                 v == (type)PY_SSIZE_T_MAX)  &&\
          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
                                v == (type)PY_SSIZE_T_MIN)))  ||\
    (sizeof(type) == sizeof(Py_ssize_t) &&\
          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
                               v == (type)PY_SSIZE_T_MAX)))  )
#if defined (__cplusplus) && __cplusplus >= 201103L
    #include 
    #define __Pyx_sst_abs(value) std::abs(value)
#elif SIZEOF_INT >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) abs(value)
#elif SIZEOF_LONG >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) labs(value)
#elif defined (_MSC_VER) && defined (_M_X64)
    #define __Pyx_sst_abs(value) _abs64(value)
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define __Pyx_sst_abs(value) llabs(value)
#elif defined (__GNUC__)
    #define __Pyx_sst_abs(value) __builtin_llabs(value)
#else
    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
#endif
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
#define __Pyx_PyBytes_FromString        PyBytes_FromString
#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
#if PY_MAJOR_VERSION < 3
    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#else
    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
#endif
#define __Pyx_PyObject_AsSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
#if PY_MAJOR_VERSION < 3
static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
{
    const Py_UNICODE *u_end = u;
    while (*u_end++) ;
    return (size_t)(u_end - u - 1);
}
#else
#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
#endif
#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
#if CYTHON_COMPILING_IN_CPYTHON
#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
#else
#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#endif
#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
#else
#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
#endif
#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
static int __Pyx_sys_getdefaultencoding_not_ascii;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
    PyObject* sys;
    PyObject* default_encoding = NULL;
    PyObject* ascii_chars_u = NULL;
    PyObject* ascii_chars_b = NULL;
    const char* default_encoding_c;
    sys = PyImport_ImportModule("sys");
    if (!sys) goto bad;
    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
    Py_DECREF(sys);
    if (!default_encoding) goto bad;
    default_encoding_c = PyBytes_AsString(default_encoding);
    if (!default_encoding_c) goto bad;
    if (strcmp(default_encoding_c, "ascii") == 0) {
        __Pyx_sys_getdefaultencoding_not_ascii = 0;
    } else {
        char ascii_chars[128];
        int c;
        for (c = 0; c < 128; c++) {
            ascii_chars[c] = c;
        }
        __Pyx_sys_getdefaultencoding_not_ascii = 1;
        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
        if (!ascii_chars_u) goto bad;
        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
            PyErr_Format(
                PyExc_ValueError,
                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
                default_encoding_c);
            goto bad;
        }
        Py_DECREF(ascii_chars_u);
        Py_DECREF(ascii_chars_b);
    }
    Py_DECREF(default_encoding);
    return 0;
bad:
    Py_XDECREF(default_encoding);
    Py_XDECREF(ascii_chars_u);
    Py_XDECREF(ascii_chars_b);
    return -1;
}
#endif
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
#else
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
static char* __PYX_DEFAULT_STRING_ENCODING;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
    PyObject* sys;
    PyObject* default_encoding = NULL;
    char* default_encoding_c;
    sys = PyImport_ImportModule("sys");
    if (!sys) goto bad;
    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
    Py_DECREF(sys);
    if (!default_encoding) goto bad;
    default_encoding_c = PyBytes_AsString(default_encoding);
    if (!default_encoding_c) goto bad;
    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
    Py_DECREF(default_encoding);
    return 0;
bad:
    Py_XDECREF(default_encoding);
    return -1;
}
#endif
#endif


/* Test for GCC > 2.95 */
#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
  #define likely(x)   __builtin_expect(!!(x), 1)
  #define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
  #define likely(x)   (x)
  #define unlikely(x) (x)
#endif /* __GNUC__ */

static PyObject *__pyx_m;
static PyObject *__pyx_d;
static PyObject *__pyx_b;
static PyObject *__pyx_empty_tuple;
static PyObject *__pyx_empty_bytes;
static PyObject *__pyx_empty_unicode;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
static const char *__pyx_filename;

/* None.proto */
#if !defined(CYTHON_CCOMPLEX)
  #if defined(__cplusplus)
    #define CYTHON_CCOMPLEX 1
  #elif defined(_Complex_I)
    #define CYTHON_CCOMPLEX 1
  #else
    #define CYTHON_CCOMPLEX 0
  #endif
#endif
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    #include 
  #else
    #include 
  #endif
#endif
#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
  #undef _Complex_I
  #define _Complex_I 1.0fj
#endif


static const char *__pyx_f[] = {
  "healpy/src/_query_disc.pyx",
  "__init__.pxd",
  "healpy/src/_common.pxd",
  "type.pxd",
};
/* BufferFormatStructs.proto */
#define IS_UNSIGNED(type) (((type) -1) > 0)
struct __Pyx_StructField_;
#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
typedef struct {
  const char* name;
  struct __Pyx_StructField_* fields;
  size_t size;
  size_t arraysize[8];
  int ndim;
  char typegroup;
  char is_unsigned;
  int flags;
} __Pyx_TypeInfo;
typedef struct __Pyx_StructField_ {
  __Pyx_TypeInfo* type;
  const char* name;
  size_t offset;
} __Pyx_StructField;
typedef struct {
  __Pyx_StructField* field;
  size_t parent_offset;
} __Pyx_BufFmt_StackElem;
typedef struct {
  __Pyx_StructField root;
  __Pyx_BufFmt_StackElem* head;
  size_t fmt_offset;
  size_t new_count, enc_count;
  size_t struct_alignment;
  int is_complex;
  char enc_type;
  char new_packmode;
  char enc_packmode;
  char is_valid_array;
} __Pyx_BufFmt_Context;


/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":725
 * # in Cython to enable them only on the right systems.
 * 
 * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t
 */
typedef npy_int8 __pyx_t_5numpy_int8_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":726
 * 
 * ctypedef npy_int8       int8_t
 * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int32      int32_t
 * ctypedef npy_int64      int64_t
 */
typedef npy_int16 __pyx_t_5numpy_int16_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":727
 * ctypedef npy_int8       int8_t
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int64      int64_t
 * #ctypedef npy_int96      int96_t
 */
typedef npy_int32 __pyx_t_5numpy_int32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":728
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t
 * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_int96      int96_t
 * #ctypedef npy_int128     int128_t
 */
typedef npy_int64 __pyx_t_5numpy_int64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":732
 * #ctypedef npy_int128     int128_t
 * 
 * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t
 */
typedef npy_uint8 __pyx_t_5numpy_uint8_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":733
 * 
 * ctypedef npy_uint8      uint8_t
 * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint32     uint32_t
 * ctypedef npy_uint64     uint64_t
 */
typedef npy_uint16 __pyx_t_5numpy_uint16_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":734
 * ctypedef npy_uint8      uint8_t
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint64     uint64_t
 * #ctypedef npy_uint96     uint96_t
 */
typedef npy_uint32 __pyx_t_5numpy_uint32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":735
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t
 * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_uint96     uint96_t
 * #ctypedef npy_uint128    uint128_t
 */
typedef npy_uint64 __pyx_t_5numpy_uint64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":739
 * #ctypedef npy_uint128    uint128_t
 * 
 * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_float64    float64_t
 * #ctypedef npy_float80    float80_t
 */
typedef npy_float32 __pyx_t_5numpy_float32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":740
 * 
 * ctypedef npy_float32    float32_t
 * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_float80    float80_t
 * #ctypedef npy_float128   float128_t
 */
typedef npy_float64 __pyx_t_5numpy_float64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":749
 * # The int types are mapped a bit surprising --
 * # numpy.int corresponds to 'l' and numpy.long to 'q'
 * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longlong   long_t
 * ctypedef npy_longlong   longlong_t
 */
typedef npy_long __pyx_t_5numpy_int_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":750
 * # numpy.int corresponds to 'l' and numpy.long to 'q'
 * ctypedef npy_long       int_t
 * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longlong   longlong_t
 * 
 */
typedef npy_longlong __pyx_t_5numpy_long_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":751
 * ctypedef npy_long       int_t
 * ctypedef npy_longlong   long_t
 * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_ulong      uint_t
 */
typedef npy_longlong __pyx_t_5numpy_longlong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":753
 * ctypedef npy_longlong   longlong_t
 * 
 * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
 * ctypedef npy_ulonglong  ulong_t
 * ctypedef npy_ulonglong  ulonglong_t
 */
typedef npy_ulong __pyx_t_5numpy_uint_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":754
 * 
 * ctypedef npy_ulong      uint_t
 * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
 * ctypedef npy_ulonglong  ulonglong_t
 * 
 */
typedef npy_ulonglong __pyx_t_5numpy_ulong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":755
 * ctypedef npy_ulong      uint_t
 * ctypedef npy_ulonglong  ulong_t
 * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_intp       intp_t
 */
typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":757
 * ctypedef npy_ulonglong  ulonglong_t
 * 
 * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uintp      uintp_t
 * 
 */
typedef npy_intp __pyx_t_5numpy_intp_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":758
 * 
 * ctypedef npy_intp       intp_t
 * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_double     float_t
 */
typedef npy_uintp __pyx_t_5numpy_uintp_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":760
 * ctypedef npy_uintp      uintp_t
 * 
 * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
 * ctypedef npy_double     double_t
 * ctypedef npy_longdouble longdouble_t
 */
typedef npy_double __pyx_t_5numpy_float_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":761
 * 
 * ctypedef npy_double     float_t
 * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longdouble longdouble_t
 * 
 */
typedef npy_double __pyx_t_5numpy_double_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":762
 * ctypedef npy_double     float_t
 * ctypedef npy_double     double_t
 * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_cfloat      cfloat_t
 */
typedef npy_longdouble __pyx_t_5numpy_longdouble_t;

/* "_common.pxd":6
 * from libcpp.vector cimport vector
 * 
 * ctypedef unsigned size_t             # <<<<<<<<<<<<<<
 * ctypedef size_t tsize
 * 
 */
typedef unsigned int __pyx_t_7_common_size_t;

/* "_common.pxd":7
 * 
 * ctypedef unsigned size_t
 * ctypedef size_t tsize             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "stddef.h":
 */
typedef size_t __pyx_t_7_common_tsize;

/* "_common.pxd":11
 * cdef extern from "stddef.h":
 *     ctypedef long ptrdiff_t
 * ctypedef ptrdiff_t tdiff             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "datatypes.h":
 */
typedef ptrdiff_t __pyx_t_7_common_tdiff;
/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    typedef ::std::complex< float > __pyx_t_float_complex;
  #else
    typedef float _Complex __pyx_t_float_complex;
  #endif
#else
    typedef struct { float real, imag; } __pyx_t_float_complex;
#endif

/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    typedef ::std::complex< double > __pyx_t_double_complex;
  #else
    typedef double _Complex __pyx_t_double_complex;
  #endif
#else
    typedef struct { double real, imag; } __pyx_t_double_complex;
#endif


/*--- Type declarations ---*/

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":764
 * ctypedef npy_longdouble longdouble_t
 * 
 * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
 * ctypedef npy_cdouble     cdouble_t
 * ctypedef npy_clongdouble clongdouble_t
 */
typedef npy_cfloat __pyx_t_5numpy_cfloat_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":765
 * 
 * ctypedef npy_cfloat      cfloat_t
 * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
 * ctypedef npy_clongdouble clongdouble_t
 * 
 */
typedef npy_cdouble __pyx_t_5numpy_cdouble_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":766
 * ctypedef npy_cfloat      cfloat_t
 * ctypedef npy_cdouble     cdouble_t
 * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_cdouble     complex_t
 */
typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":768
 * ctypedef npy_clongdouble clongdouble_t
 * 
 * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew1(a):
 */
typedef npy_cdouble __pyx_t_5numpy_complex_t;
struct __pyx_opt_args_6healpy_11_query_disc_pixset_to_array;

/* "healpy/src/_query_disc.pyx":324
 * @cython.boundscheck(False)
 * @cython.wraparound(False)
 * cdef pixset_to_array(rangeset[int64] &pixset, buff=None):             # <<<<<<<<<<<<<<
 *     cdef int64 i, n
 *     n = pixset.nval()
 */
struct __pyx_opt_args_6healpy_11_query_disc_pixset_to_array {
  int __pyx_n;
  PyObject *buff;
};

/* --- Runtime support code (head) --- */
/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
  #define CYTHON_REFNANNY 0
#endif
#if CYTHON_REFNANNY
  typedef struct {
    void (*INCREF)(void*, PyObject*, int);
    void (*DECREF)(void*, PyObject*, int);
    void (*GOTREF)(void*, PyObject*, int);
    void (*GIVEREF)(void*, PyObject*, int);
    void* (*SetupContext)(const char*, int, const char*);
    void (*FinishContext)(void**);
  } __Pyx_RefNannyAPIStruct;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
#ifdef WITH_THREAD
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          if (acquire_gil) {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
              PyGILState_Release(__pyx_gilstate_save);\
          } else {\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
          }
#else
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
#endif
  #define __Pyx_RefNannyFinishContext()\
          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
#else
  #define __Pyx_RefNannyDeclarations
  #define __Pyx_RefNannySetupContext(name, acquire_gil)
  #define __Pyx_RefNannyFinishContext()
  #define __Pyx_INCREF(r) Py_INCREF(r)
  #define __Pyx_DECREF(r) Py_DECREF(r)
  #define __Pyx_GOTREF(r)
  #define __Pyx_GIVEREF(r)
  #define __Pyx_XINCREF(r) Py_XINCREF(r)
  #define __Pyx_XDECREF(r) Py_XDECREF(r)
  #define __Pyx_XGOTREF(r)
  #define __Pyx_XGIVEREF(r)
#endif
#define __Pyx_XDECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_XDECREF(tmp);\
    } while (0)
#define __Pyx_DECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_DECREF(tmp);\
    } while (0)
#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)

/* PyObjectGetAttrStr.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_getattr))
        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
    return PyObject_GetAttr(obj, attr_name);
}
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif

/* GetBuiltinName.proto */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);

/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);

/* RaiseDoubleKeywords.proto */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);

/* ParseKeywords.proto */
static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
    const char* function_name);

/* ArgTypeTest.proto */
static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
    const char *name, int exact);

/* BufferFormatCheck.proto */
static CYTHON_INLINE int  __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
                              __Pyx_BufFmt_StackElem* stack,
                              __Pyx_TypeInfo* type); // PROTO

/* PyObjectCall.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif

/* PyThreadStateGet.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
#define __Pyx_PyThreadState_assign  __pyx_tstate = PyThreadState_GET();
#else
#define __Pyx_PyThreadState_declare
#define __Pyx_PyThreadState_assign
#endif

/* PyErrFetchRestore.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
#endif

/* RaiseException.proto */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);

/* GetItemInt.proto */
#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                                                     int is_list, int wraparound, int boundscheck);

/* GetModuleGlobalName.proto */
static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);

/* ExtTypeTest.proto */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);

/* BufferIndexError.proto */
static void __Pyx_RaiseBufferIndexError(int axis);

#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1)
#define __Pyx_BufPtrStrided3d(type, buf, i0, s0, i1, s1, i2, s2) (type)((char*)buf + i0 * s0 + i1 * s1 + i2 * s2)
/* PyObjectCallMethO.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif

/* PyObjectCallOneArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);

/* BufferFallbackError.proto */
static void __Pyx_RaiseBufferFallbackError(void);

/* SliceObject.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
        PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,
        PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
        int has_cstart, int has_cstop, int wraparound);

#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)
/* DictGetItem.proto */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
    PyObject *value;
    value = PyDict_GetItemWithError(d, key);
    if (unlikely(!value)) {
        if (!PyErr_Occurred()) {
            PyObject* args = PyTuple_Pack(1, key);
            if (likely(args))
                PyErr_SetObject(PyExc_KeyError, args);
            Py_XDECREF(args);
        }
        return NULL;
    }
    Py_INCREF(value);
    return value;
}
#else
    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#endif

/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);

/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);

/* RaiseNoneIterError.proto */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);

#define __Pyx_BufPtrCContig1d(type, buf, i0, s0) ((type)buf + i0)
/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);

/* CodeObjectCache.proto */
typedef struct {
    PyCodeObject* code_object;
    int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
    int count;
    int max_count;
    __Pyx_CodeObjectCacheEntry* entries;
};
static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
static PyCodeObject *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);

/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename);

/* BufferStructDeclare.proto */
typedef struct {
  Py_ssize_t shape, strides, suboffsets;
} __Pyx_Buf_DimInfo;
typedef struct {
  size_t refcount;
  Py_buffer pybuffer;
} __Pyx_Buffer;
typedef struct {
  __Pyx_Buffer *rcbuffer;
  char *data;
  __Pyx_Buf_DimInfo diminfo[8];
} __Pyx_LocalBuf_ND;

#if PY_MAJOR_VERSION < 3
    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
    static void __Pyx_ReleaseBuffer(Py_buffer *view);
#else
    #define __Pyx_GetBuffer PyObject_GetBuffer
    #define __Pyx_ReleaseBuffer PyBuffer_Release
#endif


/* None.proto */
static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0};
static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1};

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);

/* CppExceptionConversion.proto */
#ifndef __Pyx_CppExn2PyErr
#include 
#include 
#include 
#include 
static void __Pyx_CppExn2PyErr() {
  try {
    if (PyErr_Occurred())
      ; // let the latest Python exn pass through and ignore the current one
    else
      throw;
  } catch (const std::bad_alloc& exn) {
    PyErr_SetString(PyExc_MemoryError, exn.what());
  } catch (const std::bad_cast& exn) {
    PyErr_SetString(PyExc_TypeError, exn.what());
  } catch (const std::domain_error& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
  } catch (const std::invalid_argument& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
  } catch (const std::ios_base::failure& exn) {
    PyErr_SetString(PyExc_IOError, exn.what());
  } catch (const std::out_of_range& exn) {
    PyErr_SetString(PyExc_IndexError, exn.what());
  } catch (const std::overflow_error& exn) {
    PyErr_SetString(PyExc_OverflowError, exn.what());
  } catch (const std::range_error& exn) {
    PyErr_SetString(PyExc_ArithmeticError, exn.what());
  } catch (const std::underflow_error& exn) {
    PyErr_SetString(PyExc_ArithmeticError, exn.what());
  } catch (const std::exception& exn) {
    PyErr_SetString(PyExc_RuntimeError, exn.what());
  }
  catch (...)
  {
    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
  }
}
#endif

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64(int64 value);

/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    #define __Pyx_CREAL(z) ((z).real())
    #define __Pyx_CIMAG(z) ((z).imag())
  #else
    #define __Pyx_CREAL(z) (__real__(z))
    #define __Pyx_CIMAG(z) (__imag__(z))
  #endif
#else
    #define __Pyx_CREAL(z) ((z).real)
    #define __Pyx_CIMAG(z) ((z).imag)
#endif
#if defined(__cplusplus) && CYTHON_CCOMPLEX         && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
    #define __Pyx_SET_CREAL(z,x) ((z).real(x))
    #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
#else
    #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
    #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
#endif

/* None.proto */
static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);

/* None.proto */
#if CYTHON_CCOMPLEX
    #define __Pyx_c_eqf(a, b)   ((a)==(b))
    #define __Pyx_c_sumf(a, b)  ((a)+(b))
    #define __Pyx_c_difff(a, b) ((a)-(b))
    #define __Pyx_c_prodf(a, b) ((a)*(b))
    #define __Pyx_c_quotf(a, b) ((a)/(b))
    #define __Pyx_c_negf(a)     (-(a))
  #ifdef __cplusplus
    #define __Pyx_c_is_zerof(z) ((z)==(float)0)
    #define __Pyx_c_conjf(z)    (::std::conj(z))
    #if 1
        #define __Pyx_c_absf(z)     (::std::abs(z))
        #define __Pyx_c_powf(a, b)  (::std::pow(a, b))
    #endif
  #else
    #define __Pyx_c_is_zerof(z) ((z)==0)
    #define __Pyx_c_conjf(z)    (conjf(z))
    #if 1
        #define __Pyx_c_absf(z)     (cabsf(z))
        #define __Pyx_c_powf(a, b)  (cpowf(a, b))
    #endif
 #endif
#else
    static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex);
    static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex);
    #if 1
        static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex);
        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex);
    #endif
#endif

/* None.proto */
static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);

/* None.proto */
#if CYTHON_CCOMPLEX
    #define __Pyx_c_eq(a, b)   ((a)==(b))
    #define __Pyx_c_sum(a, b)  ((a)+(b))
    #define __Pyx_c_diff(a, b) ((a)-(b))
    #define __Pyx_c_prod(a, b) ((a)*(b))
    #define __Pyx_c_quot(a, b) ((a)/(b))
    #define __Pyx_c_neg(a)     (-(a))
  #ifdef __cplusplus
    #define __Pyx_c_is_zero(z) ((z)==(double)0)
    #define __Pyx_c_conj(z)    (::std::conj(z))
    #if 1
        #define __Pyx_c_abs(z)     (::std::abs(z))
        #define __Pyx_c_pow(a, b)  (::std::pow(a, b))
    #endif
  #else
    #define __Pyx_c_is_zero(z) ((z)==0)
    #define __Pyx_c_conj(z)    (conj(z))
    #if 1
        #define __Pyx_c_abs(z)     (cabs(z))
        #define __Pyx_c_pow(a, b)  (cpow(a, b))
    #endif
 #endif
#else
    static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex);
    static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex);
    #if 1
        static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex);
        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex);
    #endif
#endif

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);

/* CIntFromPy.proto */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE int64 __Pyx_PyInt_As_int64(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);

/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(void);

/* PyIdentifierFromString.proto */
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif

/* ModuleImport.proto */
static PyObject *__Pyx_ImportModule(const char *name);

/* TypeImport.proto */
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);

/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);


/* Module declarations from 'cpython.buffer' */

/* Module declarations from 'libc.string' */

/* Module declarations from 'libc.stdio' */

/* Module declarations from '__builtin__' */

/* Module declarations from 'cpython.type' */
static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;

/* Module declarations from 'cpython' */

/* Module declarations from 'cpython.object' */

/* Module declarations from 'cpython.ref' */

/* Module declarations from 'libc.stdlib' */

/* Module declarations from 'numpy' */

/* Module declarations from 'numpy' */
static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/

/* Module declarations from 'libcpp' */

/* Module declarations from 'libcpp.vector' */

/* Module declarations from 'cython' */

/* Module declarations from '_common' */

/* Module declarations from 'healpy._query_disc' */
static PyObject *__pyx_f_6healpy_11_query_disc_pixset_to_array(rangeset  &, struct __pyx_opt_args_6healpy_11_query_disc_pixset_to_array *__pyx_optional_args); /*proto*/
static bool __pyx_f_6healpy_11_query_disc_isnsideok(int); /*proto*/
static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t = { "int64_t", NULL, sizeof(__pyx_t_5numpy_int64_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int64_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int64_t), 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float64_t = { "float64_t", NULL, sizeof(__pyx_t_5numpy_float64_t), { 0 }, 0, 'R', 0, 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo___pyx_t_double_complex = { "double complex", NULL, sizeof(__pyx_t_double_complex), { 0 }, 0, 'C', 0, 0 };
#define __Pyx_MODULE_NAME "healpy._query_disc"
int __pyx_module_is_main_healpy___query_disc = 0;

/* Implementation of 'healpy._query_disc' */
static PyObject *__pyx_builtin_ValueError;
static PyObject *__pyx_builtin_range;
static PyObject *__pyx_builtin_RuntimeError;
static const char __pyx_k_i[] = "i";
static const char __pyx_k_j[] = "j";
static const char __pyx_k_n[] = "n";
static const char __pyx_k_v[] = "v";
static const char __pyx_k_hb[] = "hb";
static const char __pyx_k_np[] = "np";
static const char __pyx_k_int[] = "int";
static const char __pyx_k_out[] = "out";
static const char __pyx_k_pix[] = "pix";
static const char __pyx_k_ptg[] = "ptg";
static const char __pyx_k_vec[] = "vec";
static const char __pyx_k_buff[] = "buff";
static const char __pyx_k_fact[] = "fact";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_ndim[] = "ndim";
static const char __pyx_k_nest[] = "nest";
static const char __pyx_k_npix[] = "npix";
static const char __pyx_k_size[] = "size";
static const char __pyx_k_step[] = "step";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_vert[] = "vert";
static const char __pyx_k_dtype[] = "dtype";
static const char __pyx_k_empty[] = "empty";
static const char __pyx_k_float[] = "float";
static const char __pyx_k_int64[] = "int64";
static const char __pyx_k_nside[] = "nside";
static const char __pyx_k_numpy[] = "numpy";
static const char __pyx_k_range[] = "range";
static const char __pyx_k_astype[] = "astype";
static const char __pyx_k_bounds[] = "bounds";
static const char __pyx_k_factor[] = "factor";
static const char __pyx_k_import[] = "__import__";
static const char __pyx_k_pixset[] = "pixset";
static const char __pyx_k_radius[] = "radius";
static const char __pyx_k_scheme[] = "scheme";
static const char __pyx_k_theta1[] = "theta1";
static const char __pyx_k_theta2[] = "theta2";
static const char __pyx_k_asarray[] = "asarray";
static const char __pyx_k_maxnpix[] = "maxnpix";
static const char __pyx_k_can_cast[] = "can_cast";
static const char __pyx_k_isscalar[] = "isscalar";
static const char __pyx_k_vertices[] = "vertices";
static const char __pyx_k_inclusive[] = "inclusive";
static const char __pyx_k_ValueError[] = "ValueError";
static const char __pyx_k_boundaries[] = "boundaries";
static const char __pyx_k_query_disc[] = "query_disc";
static const char __pyx_k_query_strip[] = "query_strip";
static const char __pyx_k_RuntimeError[] = "RuntimeError";
static const char __pyx_k_query_polygon[] = "query_polygon";
static const char __pyx_k_boundaries_single[] = "_boundaries_single";
static const char __pyx_k_healpy__query_disc[] = "healpy._query_disc";
static const char __pyx_k_boundaries_line_236[] = "boundaries (line 236)";
static const char __pyx_k_boundaries_multiple[] = "_boundaries_multiple";
static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
static const char __pyx_k_Pixel_identifier_is_too_large[] = "Pixel identifier is too large";
static const char __pyx_k_Array_has_to_be_one_dimensional[] = "Array has to be one dimensional";
static const char __pyx_k_home_zonca_zonca_p_software_hea[] = "/home/zonca/zonca/p/software/healpy/healpy/src/_query_disc.pyx";
static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
static const char __pyx_k_Array_of_pixels_has_to_be_intege[] = "Array of pixels has to be integers";
static const char __pyx_k_Buffer_too_small_to_contain_retu[] = "Buffer too small to contain return value";
static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
static const char __pyx_k_Returns_an_array_containing_vect[] = "Returns an array containing vectors to the boundary of\n    the nominated pixel.\n\n    The returned array has shape (3, 4*step), the elements of\n    which are the x,y,z positions on the unit sphere of the\n    pixel boundary.  In order to get vector positions for just\n    the corners, specify step=1.\n\n    Parameters\n    ----------\n    nside : int\n      The nside of the Healpix map.\n    pix : int\n      Pixel identifier\n    step : int, optional\n      Number of elements for each side of the pixel.\n    nest : bool, optional\n      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering\n\n    Returns\n    -------\n    boundary : float, array\n      x,y,z for positions on the boundary of the pixel\n\n    Example\n    -------\n    # Get corners of HEALPixel 5 in nside=2, RINGS ordering.\n\n    >>> import healpy as hp\n    >>> import numpy as np\n    >>> nside = 2\n    >>> corners = hp.boundaries(nside, 5)\n\n    # Now convert to phi,theta representation:\n    >>> phi_theta = hp.vec2ang(np.transpose(corners))\n\n    >>> corners = hp.boundaries(nside, np.array([5,5]))\n\n    # doctest moved to test_query_disc.py\n    ";
static const char __pyx_k_Wrong_nside_value_must_be_a_powe[] = "Wrong nside value, must be a power of 2, less than 2**30";
static const char __pyx_k_fact_must_be_a_power_of_2_less_t[] = "fact must be a power of 2, less than 2**30 when nest is True (fact=%d)";
static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
static PyObject *__pyx_kp_s_Array_has_to_be_one_dimensional;
static PyObject *__pyx_kp_s_Array_of_pixels_has_to_be_intege;
static PyObject *__pyx_kp_s_Buffer_too_small_to_contain_retu;
static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
static PyObject *__pyx_kp_s_Pixel_identifier_is_too_large;
static PyObject *__pyx_kp_u_Returns_an_array_containing_vect;
static PyObject *__pyx_n_s_RuntimeError;
static PyObject *__pyx_n_s_ValueError;
static PyObject *__pyx_kp_s_Wrong_nside_value_must_be_a_powe;
static PyObject *__pyx_n_s_asarray;
static PyObject *__pyx_n_s_astype;
static PyObject *__pyx_n_s_boundaries;
static PyObject *__pyx_kp_u_boundaries_line_236;
static PyObject *__pyx_n_s_boundaries_multiple;
static PyObject *__pyx_n_s_boundaries_single;
static PyObject *__pyx_n_s_bounds;
static PyObject *__pyx_n_s_buff;
static PyObject *__pyx_n_s_can_cast;
static PyObject *__pyx_n_s_dtype;
static PyObject *__pyx_n_s_empty;
static PyObject *__pyx_n_s_fact;
static PyObject *__pyx_kp_s_fact_must_be_a_power_of_2_less_t;
static PyObject *__pyx_n_s_factor;
static PyObject *__pyx_n_s_float;
static PyObject *__pyx_n_s_hb;
static PyObject *__pyx_n_s_healpy__query_disc;
static PyObject *__pyx_kp_s_home_zonca_zonca_p_software_hea;
static PyObject *__pyx_n_s_i;
static PyObject *__pyx_n_s_import;
static PyObject *__pyx_n_s_inclusive;
static PyObject *__pyx_n_s_int;
static PyObject *__pyx_n_s_int64;
static PyObject *__pyx_n_s_isscalar;
static PyObject *__pyx_n_s_j;
static PyObject *__pyx_n_s_main;
static PyObject *__pyx_n_s_maxnpix;
static PyObject *__pyx_n_s_n;
static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
static PyObject *__pyx_n_s_ndim;
static PyObject *__pyx_n_s_nest;
static PyObject *__pyx_n_s_np;
static PyObject *__pyx_n_s_npix;
static PyObject *__pyx_n_s_nside;
static PyObject *__pyx_n_s_numpy;
static PyObject *__pyx_n_s_out;
static PyObject *__pyx_n_s_pix;
static PyObject *__pyx_n_s_pixset;
static PyObject *__pyx_n_s_ptg;
static PyObject *__pyx_n_s_query_disc;
static PyObject *__pyx_n_s_query_polygon;
static PyObject *__pyx_n_s_query_strip;
static PyObject *__pyx_n_s_radius;
static PyObject *__pyx_n_s_range;
static PyObject *__pyx_n_s_scheme;
static PyObject *__pyx_n_s_size;
static PyObject *__pyx_n_s_step;
static PyObject *__pyx_n_s_test;
static PyObject *__pyx_n_s_theta1;
static PyObject *__pyx_n_s_theta2;
static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
static PyObject *__pyx_n_s_v;
static PyObject *__pyx_n_s_vec;
static PyObject *__pyx_n_s_vert;
static PyObject *__pyx_n_s_vertices;
static PyObject *__pyx_pf_6healpy_11_query_disc_query_disc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_vec, PyObject *__pyx_v_radius, PyObject *__pyx_v_inclusive, PyObject *__pyx_v_fact, PyObject *__pyx_v_nest, PyArrayObject *__pyx_v_buff); /* proto */
static PyObject *__pyx_pf_6healpy_11_query_disc_2query_polygon(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_vertices, PyObject *__pyx_v_inclusive, PyObject *__pyx_v_fact, PyObject *__pyx_v_nest, PyArrayObject *__pyx_v_buff); /* proto */
static PyObject *__pyx_pf_6healpy_11_query_disc_4query_strip(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_theta1, PyObject *__pyx_v_theta2, PyObject *__pyx_v_inclusive, PyObject *__pyx_v_nest, PyArrayObject *__pyx_v_buff); /* proto */
static PyObject *__pyx_pf_6healpy_11_query_disc_6_boundaries_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_pix, PyObject *__pyx_v_step, PyObject *__pyx_v_nest); /* proto */
static PyObject *__pyx_pf_6healpy_11_query_disc_8_boundaries_multiple(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_pix, PyObject *__pyx_v_step, PyObject *__pyx_v_nest); /* proto */
static PyObject *__pyx_pf_6healpy_11_query_disc_10boundaries(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_pix, PyObject *__pyx_v_step, PyObject *__pyx_v_nest); /* proto */
static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
static PyObject *__pyx_int_1;
static PyObject *__pyx_int_3;
static PyObject *__pyx_int_4;
static PyObject *__pyx_int_12;
static PyObject *__pyx_tuple_;
static PyObject *__pyx_tuple__2;
static PyObject *__pyx_tuple__3;
static PyObject *__pyx_tuple__4;
static PyObject *__pyx_tuple__5;
static PyObject *__pyx_tuple__6;
static PyObject *__pyx_tuple__7;
static PyObject *__pyx_tuple__8;
static PyObject *__pyx_tuple__9;
static PyObject *__pyx_tuple__10;
static PyObject *__pyx_tuple__11;
static PyObject *__pyx_tuple__12;
static PyObject *__pyx_tuple__13;
static PyObject *__pyx_tuple__14;
static PyObject *__pyx_tuple__15;
static PyObject *__pyx_tuple__16;
static PyObject *__pyx_tuple__17;
static PyObject *__pyx_tuple__19;
static PyObject *__pyx_tuple__21;
static PyObject *__pyx_tuple__23;
static PyObject *__pyx_tuple__25;
static PyObject *__pyx_tuple__27;
static PyObject *__pyx_codeobj__18;
static PyObject *__pyx_codeobj__20;
static PyObject *__pyx_codeobj__22;
static PyObject *__pyx_codeobj__24;
static PyObject *__pyx_codeobj__26;
static PyObject *__pyx_codeobj__28;

/* "healpy/src/_query_disc.pyx":13
 * @cython.boundscheck(False)
 * @cython.wraparound(False)
 * def query_disc(nside, vec, radius, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """Returns pixels whose centers lie within the disk defined by
 *     *vec* and *radius* (in radians) (if *inclusive* is False), or which
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_11_query_disc_1query_disc(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_11_query_disc_query_disc[] = "query_disc(nside, vec, radius, inclusive=False, fact=4, nest=False, ndarray buff=None)\nReturns pixels whose centers lie within the disk defined by\n    *vec* and *radius* (in radians) (if *inclusive* is False), or which\n    overlap with this disk (if *inclusive* is True).\n\n    Parameters\n    ----------\n    nside : int\n      The nside of the Healpix map.\n    vec : float, sequence of 3 elements\n      The coordinates of unit vector defining the disk center.\n    radius : float\n      The radius (in radians) of the disk\n    inclusive : bool, optional\n      If False, return the exact set of pixels whose pixel centers lie \n      within the disk; if True, return all pixels that overlap with the disk,\n      and maybe a few more. Default: False\n    fact : int, optional\n      Only used when inclusive=True. The overlapping test will be done at\n      the resolution fact*nside. For NESTED ordering, fact must be a power of 2, less than 2**30,\n      else it can be any positive integer. Default: 4.\n    nest: bool, optional\n      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering\n    buff: int array, optional\n      if provided, this numpy array is used to contain the return values and must be\n      at least long enough to do so\n\n    Returns\n    -------\n    ipix : int, array\n      The pixels which lie within the given disk.\n\n    Note\n    ----\n    This method is more efficient in the RING scheme.\n    For inclusive=True, the algorithm may return some pixels which don't overlap\n    with the disk at all. The higher fact is chosen, the fewer false positives\n    are returned, at the cost of increased run time.\n    ";
static PyMethodDef __pyx_mdef_6healpy_11_query_disc_1query_disc = {"query_disc", (PyCFunction)__pyx_pw_6healpy_11_query_disc_1query_disc, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_11_query_disc_query_disc};
static PyObject *__pyx_pw_6healpy_11_query_disc_1query_disc(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nside = 0;
  PyObject *__pyx_v_vec = 0;
  PyObject *__pyx_v_radius = 0;
  PyObject *__pyx_v_inclusive = 0;
  PyObject *__pyx_v_fact = 0;
  PyObject *__pyx_v_nest = 0;
  PyArrayObject *__pyx_v_buff = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("query_disc (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nside,&__pyx_n_s_vec,&__pyx_n_s_radius,&__pyx_n_s_inclusive,&__pyx_n_s_fact,&__pyx_n_s_nest,&__pyx_n_s_buff,0};
    PyObject* values[7] = {0,0,0,0,0,0,0};
    values[3] = ((PyObject *)Py_False);
    values[4] = ((PyObject *)__pyx_int_4);
    values[5] = ((PyObject *)Py_False);
    values[6] = (PyObject *)((PyArrayObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nside)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_vec)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("query_disc", 0, 3, 7, 1); __PYX_ERR(0, 13, __pyx_L3_error)
        }
        case  2:
        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_radius)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("query_disc", 0, 3, 7, 2); __PYX_ERR(0, 13, __pyx_L3_error)
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inclusive);
          if (value) { values[3] = value; kw_args--; }
        }
        case  4:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fact);
          if (value) { values[4] = value; kw_args--; }
        }
        case  5:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nest);
          if (value) { values[5] = value; kw_args--; }
        }
        case  6:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_buff);
          if (value) { values[6] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "query_disc") < 0)) __PYX_ERR(0, 13, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nside = values[0];
    __pyx_v_vec = values[1];
    __pyx_v_radius = values[2];
    __pyx_v_inclusive = values[3];
    __pyx_v_fact = values[4];
    __pyx_v_nest = values[5];
    __pyx_v_buff = ((PyArrayObject *)values[6]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("query_disc", 0, 3, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 13, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._query_disc.query_disc", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_buff), __pyx_ptype_5numpy_ndarray, 1, "buff", 0))) __PYX_ERR(0, 13, __pyx_L1_error)
  __pyx_r = __pyx_pf_6healpy_11_query_disc_query_disc(__pyx_self, __pyx_v_nside, __pyx_v_vec, __pyx_v_radius, __pyx_v_inclusive, __pyx_v_fact, __pyx_v_nest, __pyx_v_buff);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_11_query_disc_query_disc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_vec, PyObject *__pyx_v_radius, PyObject *__pyx_v_inclusive, PyObject *__pyx_v_fact, PyObject *__pyx_v_nest, PyArrayObject *__pyx_v_buff) {
  vec3 __pyx_v_v;
  enum Healpix_Ordering_Scheme __pyx_v_scheme;
  T_Healpix_Base  __pyx_v_hb;
  rangeset  __pyx_v_pixset;
  int __pyx_v_factor;
  pointing __pyx_v_ptg;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_buff;
  __Pyx_Buffer __pyx_pybuffer_buff;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  double __pyx_t_4;
  double __pyx_t_5;
  double __pyx_t_6;
  int64 __pyx_t_7;
  int __pyx_t_8;
  PyObject *__pyx_t_9 = NULL;
  struct __pyx_opt_args_6healpy_11_query_disc_pixset_to_array __pyx_t_10;
  __Pyx_RefNannySetupContext("query_disc", 0);
  __pyx_pybuffer_buff.pybuffer.buf = NULL;
  __pyx_pybuffer_buff.refcount = 0;
  __pyx_pybuffernd_buff.data = NULL;
  __pyx_pybuffernd_buff.rcbuffer = &__pyx_pybuffer_buff;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_buff.rcbuffer->pybuffer, (PyObject*)__pyx_v_buff, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 13, __pyx_L1_error)
  }
  __pyx_pybuffernd_buff.diminfo[0].strides = __pyx_pybuffernd_buff.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_buff.diminfo[0].shape = __pyx_pybuffernd_buff.rcbuffer->pybuffer.shape[0];

  /* "healpy/src/_query_disc.pyx":53
 *     """
 *     # Check Nside value
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef vec3 v = vec3(vec[0], vec[1], vec[2])
 */
  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_nside); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L1_error)
  __pyx_t_2 = ((!(__pyx_f_6healpy_11_query_disc_isnsideok(__pyx_t_1) != 0)) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":54
 *     # Check Nside value
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     cdef vec3 v = vec3(vec[0], vec[1], vec[2])
 *     cdef Healpix_Ordering_Scheme scheme
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 54, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 54, __pyx_L1_error)

    /* "healpy/src/_query_disc.pyx":53
 *     """
 *     # Check Nside value
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef vec3 v = vec3(vec[0], vec[1], vec[2])
 */
  }

  /* "healpy/src/_query_disc.pyx":55
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     cdef vec3 v = vec3(vec[0], vec[1], vec[2])             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_vec, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_vec, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_vec, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_v = vec3(__pyx_t_4, __pyx_t_5, __pyx_t_6);

  /* "healpy/src/_query_disc.pyx":57
 *     cdef vec3 v = vec3(vec[0], vec[1], vec[2])
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_nest); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 57, __pyx_L1_error)
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":58
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 *         scheme = NEST             # <<<<<<<<<<<<<<
 *     else:
 *         scheme = RING
 */
    __pyx_v_scheme = NEST;

    /* "healpy/src/_query_disc.pyx":57
 *     cdef vec3 v = vec3(vec[0], vec[1], vec[2])
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
    goto __pyx_L4;
  }

  /* "healpy/src/_query_disc.pyx":60
 *         scheme = NEST
 *     else:
 *         scheme = RING             # <<<<<<<<<<<<<<
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     cdef rangeset[int64] pixset
 */
  /*else*/ {
    __pyx_v_scheme = RING;
  }
  __pyx_L4:;

  /* "healpy/src/_query_disc.pyx":61
 *     else:
 *         scheme = RING
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)             # <<<<<<<<<<<<<<
 *     cdef rangeset[int64] pixset
 *     cdef int factor = fact
 */
  __pyx_t_7 = __Pyx_PyInt_As_int64(__pyx_v_nside); if (unlikely((__pyx_t_7 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L1_error)
  __pyx_v_hb = T_Healpix_Base (__pyx_t_7, __pyx_v_scheme, SET_NSIDE);

  /* "healpy/src/_query_disc.pyx":63
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     cdef rangeset[int64] pixset
 *     cdef int factor = fact             # <<<<<<<<<<<<<<
 *     cdef pointing ptg = pointing(v)
 *     ptg.normalize()
 */
  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_fact); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L1_error)
  __pyx_v_factor = __pyx_t_1;

  /* "healpy/src/_query_disc.pyx":64
 *     cdef rangeset[int64] pixset
 *     cdef int factor = fact
 *     cdef pointing ptg = pointing(v)             # <<<<<<<<<<<<<<
 *     ptg.normalize()
 *     if inclusive:
 */
  __pyx_v_ptg = pointing(__pyx_v_v);

  /* "healpy/src/_query_disc.pyx":65
 *     cdef int factor = fact
 *     cdef pointing ptg = pointing(v)
 *     ptg.normalize()             # <<<<<<<<<<<<<<
 *     if inclusive:
 *         factor = abs(fact)
 */
  __pyx_v_ptg.normalize();

  /* "healpy/src/_query_disc.pyx":66
 *     cdef pointing ptg = pointing(v)
 *     ptg.normalize()
 *     if inclusive:             # <<<<<<<<<<<<<<
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 */
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_inclusive); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 66, __pyx_L1_error)
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":67
 *     ptg.normalize()
 *     if inclusive:
 *         factor = abs(fact)             # <<<<<<<<<<<<<<
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 */
    __pyx_t_3 = PyNumber_Absolute(__pyx_v_fact); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 67, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_factor = __pyx_t_1;

    /* "healpy/src/_query_disc.pyx":68
 *     if inclusive:
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):             # <<<<<<<<<<<<<<
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 *                              'nest is True (fact=%d)' % (fact))
 */
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_nest); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 68, __pyx_L1_error)
    if (__pyx_t_8) {
    } else {
      __pyx_t_2 = __pyx_t_8;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_8 = ((__pyx_v_factor == 0) != 0);
    if (!__pyx_t_8) {
    } else {
      __pyx_t_2 = __pyx_t_8;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_8 = (((__pyx_v_factor & (__pyx_v_factor - 1)) != 0) != 0);
    __pyx_t_2 = __pyx_t_8;
    __pyx_L7_bool_binop_done:;
    if (__pyx_t_2) {

      /* "healpy/src/_query_disc.pyx":70
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 *                              'nest is True (fact=%d)' % (fact))             # <<<<<<<<<<<<<<
 *         hb.query_disc_inclusive(ptg, radius, pixset, factor)
 *     else:
 */
      __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_fact_must_be_a_power_of_2_less_t, __pyx_v_fact); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 70, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);

      /* "healpy/src/_query_disc.pyx":69
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '             # <<<<<<<<<<<<<<
 *                              'nest is True (fact=%d)' % (fact))
 *         hb.query_disc_inclusive(ptg, radius, pixset, factor)
 */
      __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 69, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __Pyx_GIVEREF(__pyx_t_3);
      PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_3);
      __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(0, 69, __pyx_L1_error)

      /* "healpy/src/_query_disc.pyx":68
 *     if inclusive:
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):             # <<<<<<<<<<<<<<
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 *                              'nest is True (fact=%d)' % (fact))
 */
    }

    /* "healpy/src/_query_disc.pyx":71
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 *                              'nest is True (fact=%d)' % (fact))
 *         hb.query_disc_inclusive(ptg, radius, pixset, factor)             # <<<<<<<<<<<<<<
 *     else:
 *         hb.query_disc(ptg, radius, pixset)
 */
    __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_v_radius); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L1_error)
    __pyx_v_hb.query_disc_inclusive(__pyx_v_ptg, __pyx_t_6, __pyx_v_pixset, __pyx_v_factor);

    /* "healpy/src/_query_disc.pyx":66
 *     cdef pointing ptg = pointing(v)
 *     ptg.normalize()
 *     if inclusive:             # <<<<<<<<<<<<<<
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 */
    goto __pyx_L5;
  }

  /* "healpy/src/_query_disc.pyx":73
 *         hb.query_disc_inclusive(ptg, radius, pixset, factor)
 *     else:
 *         hb.query_disc(ptg, radius, pixset)             # <<<<<<<<<<<<<<
 * 
 *     return pixset_to_array(pixset, buff)
 */
  /*else*/ {
    __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_v_radius); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 73, __pyx_L1_error)
    __pyx_v_hb.query_disc(__pyx_v_ptg, __pyx_t_6, __pyx_v_pixset);
  }
  __pyx_L5:;

  /* "healpy/src/_query_disc.pyx":75
 *         hb.query_disc(ptg, radius, pixset)
 * 
 *     return pixset_to_array(pixset, buff)             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_10.__pyx_n = 1;
  __pyx_t_10.buff = ((PyObject *)__pyx_v_buff);
  __pyx_t_3 = __pyx_f_6healpy_11_query_disc_pixset_to_array(__pyx_v_pixset, &__pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 75, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "healpy/src/_query_disc.pyx":13
 * @cython.boundscheck(False)
 * @cython.wraparound(False)
 * def query_disc(nside, vec, radius, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """Returns pixels whose centers lie within the disk defined by
 *     *vec* and *radius* (in radians) (if *inclusive* is False), or which
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_9);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_buff.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._query_disc.query_disc", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_buff.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_query_disc.pyx":78
 * 
 * 
 * def query_polygon(nside, vertices, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """ Returns the pixels whose centers lie within the convex polygon
 *     defined by the *vertices* array (if *inclusive* is False), or which
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_11_query_disc_3query_polygon(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_11_query_disc_2query_polygon[] = "query_polygon(nside, vertices, inclusive=False, fact=4, nest=False, ndarray buff=None)\n Returns the pixels whose centers lie within the convex polygon \n    defined by the *vertices* array (if *inclusive* is False), or which \n    overlap with this polygon (if *inclusive* is True).\n\n    Parameters\n    ----------\n    nside : int\n      The nside of the Healpix map.\n    vertices : float, array-like\n      Vertex array containing the vertices of the polygon, shape (N, 3).\n    inclusive : bool, optional\n      If False, return the exact set of pixels whose pixel centers lie\n      within the polygon; if True, return all pixels that overlap with the\n      polygon, and maybe a few more. Default: False.\n    fact : int, optional\n      Only used when inclusive=True. The overlapping test will be done at\n      the resolution fact*nside. For NESTED ordering, fact must be a power of 2, less than 2**30,\n      else it can be any positive integer. Default: 4.\n    nest: bool, optional\n      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering\n    buff: int array, optional\n      if provided, this numpy array is used to contain the return values and must be\n      at least long enough to do so\n      \n    Returns\n    -------\n    ipix : int, array\n      The pixels which lie within the given polygon.\n\n    Note\n    ----\n    This method is more efficient in the RING scheme.\n    For inclusive=True, the algorithm may return some pixels which don't overlap\n    with the disk at all. The higher fact is chosen, the fewer false positives\n    are returned, at the cost of increased run time.\n    ";
static PyMethodDef __pyx_mdef_6healpy_11_query_disc_3query_polygon = {"query_polygon", (PyCFunction)__pyx_pw_6healpy_11_query_disc_3query_polygon, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_11_query_disc_2query_polygon};
static PyObject *__pyx_pw_6healpy_11_query_disc_3query_polygon(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nside = 0;
  PyObject *__pyx_v_vertices = 0;
  PyObject *__pyx_v_inclusive = 0;
  PyObject *__pyx_v_fact = 0;
  PyObject *__pyx_v_nest = 0;
  PyArrayObject *__pyx_v_buff = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("query_polygon (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nside,&__pyx_n_s_vertices,&__pyx_n_s_inclusive,&__pyx_n_s_fact,&__pyx_n_s_nest,&__pyx_n_s_buff,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[2] = ((PyObject *)Py_False);
    values[3] = ((PyObject *)__pyx_int_4);
    values[4] = ((PyObject *)Py_False);
    values[5] = (PyObject *)((PyArrayObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nside)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_vertices)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("query_polygon", 0, 2, 6, 1); __PYX_ERR(0, 78, __pyx_L3_error)
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inclusive);
          if (value) { values[2] = value; kw_args--; }
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fact);
          if (value) { values[3] = value; kw_args--; }
        }
        case  4:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nest);
          if (value) { values[4] = value; kw_args--; }
        }
        case  5:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_buff);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "query_polygon") < 0)) __PYX_ERR(0, 78, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nside = values[0];
    __pyx_v_vertices = values[1];
    __pyx_v_inclusive = values[2];
    __pyx_v_fact = values[3];
    __pyx_v_nest = values[4];
    __pyx_v_buff = ((PyArrayObject *)values[5]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("query_polygon", 0, 2, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 78, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._query_disc.query_polygon", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_buff), __pyx_ptype_5numpy_ndarray, 1, "buff", 0))) __PYX_ERR(0, 78, __pyx_L1_error)
  __pyx_r = __pyx_pf_6healpy_11_query_disc_2query_polygon(__pyx_self, __pyx_v_nside, __pyx_v_vertices, __pyx_v_inclusive, __pyx_v_fact, __pyx_v_nest, __pyx_v_buff);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_11_query_disc_2query_polygon(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_vertices, PyObject *__pyx_v_inclusive, PyObject *__pyx_v_fact, PyObject *__pyx_v_nest, PyArrayObject *__pyx_v_buff) {
  std::vector  __pyx_v_vert;
  pointing __pyx_v_ptg;
  PyObject *__pyx_v_v = NULL;
  enum Healpix_Ordering_Scheme __pyx_v_scheme;
  T_Healpix_Base  __pyx_v_hb;
  rangeset  __pyx_v_pixset;
  int __pyx_v_factor;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_buff;
  __Pyx_Buffer __pyx_pybuffer_buff;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  PyObject *(*__pyx_t_5)(PyObject *);
  PyObject *__pyx_t_6 = NULL;
  double __pyx_t_7;
  double __pyx_t_8;
  double __pyx_t_9;
  int64 __pyx_t_10;
  int __pyx_t_11;
  struct __pyx_opt_args_6healpy_11_query_disc_pixset_to_array __pyx_t_12;
  __Pyx_RefNannySetupContext("query_polygon", 0);
  __pyx_pybuffer_buff.pybuffer.buf = NULL;
  __pyx_pybuffer_buff.refcount = 0;
  __pyx_pybuffernd_buff.data = NULL;
  __pyx_pybuffernd_buff.rcbuffer = &__pyx_pybuffer_buff;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_buff.rcbuffer->pybuffer, (PyObject*)__pyx_v_buff, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 78, __pyx_L1_error)
  }
  __pyx_pybuffernd_buff.diminfo[0].strides = __pyx_pybuffernd_buff.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_buff.diminfo[0].shape = __pyx_pybuffernd_buff.rcbuffer->pybuffer.shape[0];

  /* "healpy/src/_query_disc.pyx":116
 *     """
 *     # Check Nside value
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     # Create vector of vertices
 */
  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_nside); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L1_error)
  __pyx_t_2 = ((!(__pyx_f_6healpy_11_query_disc_isnsideok(__pyx_t_1) != 0)) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":117
 *     # Check Nside value
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     # Create vector of vertices
 *     cdef vector[pointing] vert
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 117, __pyx_L1_error)

    /* "healpy/src/_query_disc.pyx":116
 *     """
 *     # Check Nside value
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     # Create vector of vertices
 */
  }

  /* "healpy/src/_query_disc.pyx":121
 *     cdef vector[pointing] vert
 *     cdef pointing ptg
 *     for v in vertices:             # <<<<<<<<<<<<<<
 *         ptg = pointing(vec3(v[0], v[1], v[2]))
 *         ptg.normalize()
 */
  if (likely(PyList_CheckExact(__pyx_v_vertices)) || PyTuple_CheckExact(__pyx_v_vertices)) {
    __pyx_t_3 = __pyx_v_vertices; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
    __pyx_t_5 = NULL;
  } else {
    __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_vertices); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 121, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_5)) {
      if (likely(PyList_CheckExact(__pyx_t_3))) {
        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 121, __pyx_L1_error)
        #else
        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 121, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        #endif
      } else {
        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 121, __pyx_L1_error)
        #else
        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 121, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_6);
        #endif
      }
    } else {
      __pyx_t_6 = __pyx_t_5(__pyx_t_3);
      if (unlikely(!__pyx_t_6)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 121, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_6);
    }
    __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_6);
    __pyx_t_6 = 0;

    /* "healpy/src/_query_disc.pyx":122
 *     cdef pointing ptg
 *     for v in vertices:
 *         ptg = pointing(vec3(v[0], v[1], v[2]))             # <<<<<<<<<<<<<<
 *         ptg.normalize()
 *         vert.push_back(ptg)
 */
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 122, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_7 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 122, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_8 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_v, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 122, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_9 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_v_ptg = pointing(vec3(__pyx_t_7, __pyx_t_8, __pyx_t_9));

    /* "healpy/src/_query_disc.pyx":123
 *     for v in vertices:
 *         ptg = pointing(vec3(v[0], v[1], v[2]))
 *         ptg.normalize()             # <<<<<<<<<<<<<<
 *         vert.push_back(ptg)
 *     # Create the Healpix_Base2 structure
 */
    __pyx_v_ptg.normalize();

    /* "healpy/src/_query_disc.pyx":124
 *         ptg = pointing(vec3(v[0], v[1], v[2]))
 *         ptg.normalize()
 *         vert.push_back(ptg)             # <<<<<<<<<<<<<<
 *     # Create the Healpix_Base2 structure
 *     cdef Healpix_Ordering_Scheme scheme
 */
    try {
      __pyx_v_vert.push_back(__pyx_v_ptg);
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 124, __pyx_L1_error)
    }

    /* "healpy/src/_query_disc.pyx":121
 *     cdef vector[pointing] vert
 *     cdef pointing ptg
 *     for v in vertices:             # <<<<<<<<<<<<<<
 *         ptg = pointing(vec3(v[0], v[1], v[2]))
 *         ptg.normalize()
 */
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /* "healpy/src/_query_disc.pyx":127
 *     # Create the Healpix_Base2 structure
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_nest); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 127, __pyx_L1_error)
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":128
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 *         scheme = NEST             # <<<<<<<<<<<<<<
 *     else:
 *         scheme = RING
 */
    __pyx_v_scheme = NEST;

    /* "healpy/src/_query_disc.pyx":127
 *     # Create the Healpix_Base2 structure
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
    goto __pyx_L6;
  }

  /* "healpy/src/_query_disc.pyx":130
 *         scheme = NEST
 *     else:
 *         scheme = RING             # <<<<<<<<<<<<<<
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     # Call query_polygon
 */
  /*else*/ {
    __pyx_v_scheme = RING;
  }
  __pyx_L6:;

  /* "healpy/src/_query_disc.pyx":131
 *     else:
 *         scheme = RING
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)             # <<<<<<<<<<<<<<
 *     # Call query_polygon
 *     cdef rangeset[int64] pixset
 */
  __pyx_t_10 = __Pyx_PyInt_As_int64(__pyx_v_nside); if (unlikely((__pyx_t_10 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 131, __pyx_L1_error)
  __pyx_v_hb = T_Healpix_Base (__pyx_t_10, __pyx_v_scheme, SET_NSIDE);

  /* "healpy/src/_query_disc.pyx":135
 *     cdef rangeset[int64] pixset
 *     cdef int factor
 *     if inclusive:             # <<<<<<<<<<<<<<
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 */
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_inclusive); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 135, __pyx_L1_error)
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":136
 *     cdef int factor
 *     if inclusive:
 *         factor = abs(fact)             # <<<<<<<<<<<<<<
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 */
    __pyx_t_3 = PyNumber_Absolute(__pyx_v_fact); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 136, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_factor = __pyx_t_1;

    /* "healpy/src/_query_disc.pyx":137
 *     if inclusive:
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):             # <<<<<<<<<<<<<<
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 *                              'nest is True (fact=%d)' % (fact))
 */
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_nest); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 137, __pyx_L1_error)
    if (__pyx_t_11) {
    } else {
      __pyx_t_2 = __pyx_t_11;
      goto __pyx_L9_bool_binop_done;
    }
    __pyx_t_11 = ((__pyx_v_factor == 0) != 0);
    if (!__pyx_t_11) {
    } else {
      __pyx_t_2 = __pyx_t_11;
      goto __pyx_L9_bool_binop_done;
    }
    __pyx_t_11 = (((__pyx_v_factor & (__pyx_v_factor - 1)) != 0) != 0);
    __pyx_t_2 = __pyx_t_11;
    __pyx_L9_bool_binop_done:;
    if (__pyx_t_2) {

      /* "healpy/src/_query_disc.pyx":139
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 *                              'nest is True (fact=%d)' % (fact))             # <<<<<<<<<<<<<<
 *         hb.query_polygon_inclusive(vert, pixset, factor)
 *     else:
 */
      __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_fact_must_be_a_power_of_2_less_t, __pyx_v_fact); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 139, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);

      /* "healpy/src/_query_disc.pyx":138
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '             # <<<<<<<<<<<<<<
 *                              'nest is True (fact=%d)' % (fact))
 *         hb.query_polygon_inclusive(vert, pixset, factor)
 */
      __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 138, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_GIVEREF(__pyx_t_3);
      PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
      __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(0, 138, __pyx_L1_error)

      /* "healpy/src/_query_disc.pyx":137
 *     if inclusive:
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):             # <<<<<<<<<<<<<<
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 *                              'nest is True (fact=%d)' % (fact))
 */
    }

    /* "healpy/src/_query_disc.pyx":140
 *             raise ValueError('fact must be a power of 2, less than 2**30 when '
 *                              'nest is True (fact=%d)' % (fact))
 *         hb.query_polygon_inclusive(vert, pixset, factor)             # <<<<<<<<<<<<<<
 *     else:
 *         hb.query_polygon(vert, pixset)
 */
    try {
      __pyx_v_hb.query_polygon_inclusive(__pyx_v_vert, __pyx_v_pixset, __pyx_v_factor);
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 140, __pyx_L1_error)
    }

    /* "healpy/src/_query_disc.pyx":135
 *     cdef rangeset[int64] pixset
 *     cdef int factor
 *     if inclusive:             # <<<<<<<<<<<<<<
 *         factor = abs(fact)
 *         if nest and (factor == 0 or (factor & (factor - 1) != 0)):
 */
    goto __pyx_L7;
  }

  /* "healpy/src/_query_disc.pyx":142
 *         hb.query_polygon_inclusive(vert, pixset, factor)
 *     else:
 *         hb.query_polygon(vert, pixset)             # <<<<<<<<<<<<<<
 * 
 *     return pixset_to_array(pixset, buff)
 */
  /*else*/ {
    try {
      __pyx_v_hb.query_polygon(__pyx_v_vert, __pyx_v_pixset);
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 142, __pyx_L1_error)
    }
  }
  __pyx_L7:;

  /* "healpy/src/_query_disc.pyx":144
 *         hb.query_polygon(vert, pixset)
 * 
 *     return pixset_to_array(pixset, buff)             # <<<<<<<<<<<<<<
 * 
 * def query_strip(nside, theta1, theta2, inclusive = False, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_12.__pyx_n = 1;
  __pyx_t_12.buff = ((PyObject *)__pyx_v_buff);
  __pyx_t_3 = __pyx_f_6healpy_11_query_disc_pixset_to_array(__pyx_v_pixset, &__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 144, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "healpy/src/_query_disc.pyx":78
 * 
 * 
 * def query_polygon(nside, vertices, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """ Returns the pixels whose centers lie within the convex polygon
 *     defined by the *vertices* array (if *inclusive* is False), or which
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_buff.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._query_disc.query_polygon", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_buff.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF(__pyx_v_v);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_query_disc.pyx":146
 *     return pixset_to_array(pixset, buff)
 * 
 * def query_strip(nside, theta1, theta2, inclusive = False, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """Returns pixels whose centers lie within the colatitude range
 *     defined by *theta1* and *theta2* (if inclusive is False), or which
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_11_query_disc_5query_strip(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_11_query_disc_4query_strip[] = "query_strip(nside, theta1, theta2, inclusive=False, nest=False, ndarray buff=None)\nReturns pixels whose centers lie within the colatitude range\n    defined by *theta1* and *theta2* (if inclusive is False), or which \n    overlap with this region (if *inclusive* is True). If theta1 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inclusive);
          if (value) { values[3] = value; kw_args--; }
        }
        case  4:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nest);
          if (value) { values[4] = value; kw_args--; }
        }
        case  5:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_buff);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "query_strip") < 0)) __PYX_ERR(0, 146, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nside = values[0];
    __pyx_v_theta1 = values[1];
    __pyx_v_theta2 = values[2];
    __pyx_v_inclusive = values[3];
    __pyx_v_nest = values[4];
    __pyx_v_buff = ((PyArrayObject *)values[5]);
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("query_strip", 0, 3, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 146, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._query_disc.query_strip", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_buff), __pyx_ptype_5numpy_ndarray, 1, "buff", 0))) __PYX_ERR(0, 146, __pyx_L1_error)
  __pyx_r = __pyx_pf_6healpy_11_query_disc_4query_strip(__pyx_self, __pyx_v_nside, __pyx_v_theta1, __pyx_v_theta2, __pyx_v_inclusive, __pyx_v_nest, __pyx_v_buff);

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_11_query_disc_4query_strip(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_theta1, PyObject *__pyx_v_theta2, PyObject *__pyx_v_inclusive, PyObject *__pyx_v_nest, PyArrayObject *__pyx_v_buff) {
  enum Healpix_Ordering_Scheme __pyx_v_scheme;
  T_Healpix_Base  __pyx_v_hb;
  rangeset  __pyx_v_pixset;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_buff;
  __Pyx_Buffer __pyx_pybuffer_buff;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int64 __pyx_t_4;
  double __pyx_t_5;
  double __pyx_t_6;
  struct __pyx_opt_args_6healpy_11_query_disc_pixset_to_array __pyx_t_7;
  __Pyx_RefNannySetupContext("query_strip", 0);
  __pyx_pybuffer_buff.pybuffer.buf = NULL;
  __pyx_pybuffer_buff.refcount = 0;
  __pyx_pybuffernd_buff.data = NULL;
  __pyx_pybuffernd_buff.rcbuffer = &__pyx_pybuffer_buff;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_buff.rcbuffer->pybuffer, (PyObject*)__pyx_v_buff, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 146, __pyx_L1_error)
  }
  __pyx_pybuffernd_buff.diminfo[0].strides = __pyx_pybuffernd_buff.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_buff.diminfo[0].shape = __pyx_pybuffernd_buff.rcbuffer->pybuffer.shape[0];

  /* "healpy/src/_query_disc.pyx":177
 *     """
 *     # Check Nside value
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     # Create the Healpix_Base2 structure
 */
  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_nside); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 177, __pyx_L1_error)
  __pyx_t_2 = ((!(__pyx_f_6healpy_11_query_disc_isnsideok(__pyx_t_1) != 0)) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":178
 *     # Check Nside value
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     # Create the Healpix_Base2 structure
 *     cdef Healpix_Ordering_Scheme scheme
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 178, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 178, __pyx_L1_error)

    /* "healpy/src/_query_disc.pyx":177
 *     """
 *     # Check Nside value
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     # Create the Healpix_Base2 structure
 */
  }

  /* "healpy/src/_query_disc.pyx":181
 *     # Create the Healpix_Base2 structure
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_nest); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 181, __pyx_L1_error)
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":182
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 *         scheme = NEST             # <<<<<<<<<<<<<<
 *     else:
 *         scheme = RING
 */
    __pyx_v_scheme = NEST;

    /* "healpy/src/_query_disc.pyx":181
 *     # Create the Healpix_Base2 structure
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
    goto __pyx_L4;
  }

  /* "healpy/src/_query_disc.pyx":184
 *         scheme = NEST
 *     else:
 *         scheme = RING             # <<<<<<<<<<<<<<
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     # Call query_polygon
 */
  /*else*/ {
    __pyx_v_scheme = RING;
  }
  __pyx_L4:;

  /* "healpy/src/_query_disc.pyx":185
 *     else:
 *         scheme = RING
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)             # <<<<<<<<<<<<<<
 *     # Call query_polygon
 *     cdef rangeset[int64] pixset
 */
  __pyx_t_4 = __Pyx_PyInt_As_int64(__pyx_v_nside); if (unlikely((__pyx_t_4 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 185, __pyx_L1_error)
  __pyx_v_hb = T_Healpix_Base (__pyx_t_4, __pyx_v_scheme, SET_NSIDE);

  /* "healpy/src/_query_disc.pyx":188
 *     # Call query_polygon
 *     cdef rangeset[int64] pixset
 *     hb.query_strip(theta1, theta2, inclusive, pixset)             # <<<<<<<<<<<<<<
 * 
 *     return pixset_to_array(pixset, buff)
 */
  __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_theta1); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L1_error)
  __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_v_theta2); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_inclusive); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L1_error)
  __pyx_v_hb.query_strip(__pyx_t_5, __pyx_t_6, __pyx_t_2, __pyx_v_pixset);

  /* "healpy/src/_query_disc.pyx":190
 *     hb.query_strip(theta1, theta2, inclusive, pixset)
 * 
 *     return pixset_to_array(pixset, buff)             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_7.__pyx_n = 1;
  __pyx_t_7.buff = ((PyObject *)__pyx_v_buff);
  __pyx_t_3 = __pyx_f_6healpy_11_query_disc_pixset_to_array(__pyx_v_pixset, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "healpy/src/_query_disc.pyx":146
 *     return pixset_to_array(pixset, buff)
 * 
 * def query_strip(nside, theta1, theta2, inclusive = False, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """Returns pixels whose centers lie within the colatitude range
 *     defined by *theta1* and *theta2* (if inclusive is False), or which
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_buff.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._query_disc.query_strip", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_buff.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_query_disc.pyx":193
 * 
 * 
 * def _boundaries_single(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_11_query_disc_7_boundaries_single(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_11_query_disc_6_boundaries_single[] = "_boundaries_single(nside, pix, step=1, nest=False)";
static PyMethodDef __pyx_mdef_6healpy_11_query_disc_7_boundaries_single = {"_boundaries_single", (PyCFunction)__pyx_pw_6healpy_11_query_disc_7_boundaries_single, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_11_query_disc_6_boundaries_single};
static PyObject *__pyx_pw_6healpy_11_query_disc_7_boundaries_single(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nside = 0;
  PyObject *__pyx_v_pix = 0;
  PyObject *__pyx_v_step = 0;
  PyObject *__pyx_v_nest = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_boundaries_single (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nside,&__pyx_n_s_pix,&__pyx_n_s_step,&__pyx_n_s_nest,0};
    PyObject* values[4] = {0,0,0,0};
    values[2] = ((PyObject *)__pyx_int_1);
    values[3] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nside)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pix)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("_boundaries_single", 0, 2, 4, 1); __PYX_ERR(0, 193, __pyx_L3_error)
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_step);
          if (value) { values[2] = value; kw_args--; }
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nest);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_boundaries_single") < 0)) __PYX_ERR(0, 193, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nside = values[0];
    __pyx_v_pix = values[1];
    __pyx_v_step = values[2];
    __pyx_v_nest = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_boundaries_single", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 193, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._query_disc._boundaries_single", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_11_query_disc_6_boundaries_single(__pyx_self, __pyx_v_nside, __pyx_v_pix, __pyx_v_step, __pyx_v_nest);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_11_query_disc_6_boundaries_single(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_pix, PyObject *__pyx_v_step, PyObject *__pyx_v_nest) {
  enum Healpix_Ordering_Scheme __pyx_v_scheme;
  T_Healpix_Base  __pyx_v_hb;
  std::vector  __pyx_v_bounds;
  size_t __pyx_v_n;
  PyArrayObject *__pyx_v_out = 0;
  size_t __pyx_v_i;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_out;
  __Pyx_Buffer __pyx_pybuffer_out;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int64 __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyArrayObject *__pyx_t_9 = NULL;
  size_t __pyx_t_10;
  double __pyx_t_11;
  Py_ssize_t __pyx_t_12;
  size_t __pyx_t_13;
  int __pyx_t_14;
  Py_ssize_t __pyx_t_15;
  size_t __pyx_t_16;
  Py_ssize_t __pyx_t_17;
  size_t __pyx_t_18;
  __Pyx_RefNannySetupContext("_boundaries_single", 0);
  __pyx_pybuffer_out.pybuffer.buf = NULL;
  __pyx_pybuffer_out.refcount = 0;
  __pyx_pybuffernd_out.data = NULL;
  __pyx_pybuffernd_out.rcbuffer = &__pyx_pybuffer_out;

  /* "healpy/src/_query_disc.pyx":195
 * def _boundaries_single(nside, pix, step=1, nest=False):
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_nest); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 195, __pyx_L1_error)
  if (__pyx_t_1) {

    /* "healpy/src/_query_disc.pyx":196
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 *         scheme = NEST             # <<<<<<<<<<<<<<
 *     else:
 *         scheme = RING
 */
    __pyx_v_scheme = NEST;

    /* "healpy/src/_query_disc.pyx":195
 * def _boundaries_single(nside, pix, step=1, nest=False):
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
    goto __pyx_L3;
  }

  /* "healpy/src/_query_disc.pyx":198
 *         scheme = NEST
 *     else:
 *         scheme = RING             # <<<<<<<<<<<<<<
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     cdef vector[vec3] bounds
 */
  /*else*/ {
    __pyx_v_scheme = RING;
  }
  __pyx_L3:;

  /* "healpy/src/_query_disc.pyx":199
 *     else:
 *         scheme = RING
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)             # <<<<<<<<<<<<<<
 *     cdef vector[vec3] bounds
 *     if pix >= (12*nside*nside):
 */
  __pyx_t_2 = __Pyx_PyInt_As_int64(__pyx_v_nside); if (unlikely((__pyx_t_2 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L1_error)
  __pyx_v_hb = T_Healpix_Base (__pyx_t_2, __pyx_v_scheme, SET_NSIDE);

  /* "healpy/src/_query_disc.pyx":201
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     cdef vector[vec3] bounds
 *     if pix >= (12*nside*nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Pixel identifier is too large')
 *     hb.boundaries(pix, step, bounds)
 */
  __pyx_t_3 = PyNumber_Multiply(__pyx_int_12, __pyx_v_nside); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_v_nside); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyObject_RichCompare(__pyx_v_pix, __pyx_t_4, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 201, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_1) {

    /* "healpy/src/_query_disc.pyx":202
 *     cdef vector[vec3] bounds
 *     if pix >= (12*nside*nside):
 *         raise ValueError('Pixel identifier is too large')             # <<<<<<<<<<<<<<
 *     hb.boundaries(pix, step, bounds)
 *     cdef size_t n = bounds.size()
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 202, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 202, __pyx_L1_error)

    /* "healpy/src/_query_disc.pyx":201
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     cdef vector[vec3] bounds
 *     if pix >= (12*nside*nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Pixel identifier is too large')
 *     hb.boundaries(pix, step, bounds)
 */
  }

  /* "healpy/src/_query_disc.pyx":203
 *     if pix >= (12*nside*nside):
 *         raise ValueError('Pixel identifier is too large')
 *     hb.boundaries(pix, step, bounds)             # <<<<<<<<<<<<<<
 *     cdef size_t n = bounds.size()
 *     cdef np.ndarray[double, ndim = 2] out = np.empty((3, n), dtype=np.float)
 */
  __pyx_t_2 = __Pyx_PyInt_As_int64(__pyx_v_pix); if (unlikely((__pyx_t_2 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_v_step); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 203, __pyx_L1_error)
  __pyx_v_hb.boundaries(__pyx_t_2, __pyx_t_5, __pyx_v_bounds);

  /* "healpy/src/_query_disc.pyx":204
 *         raise ValueError('Pixel identifier is too large')
 *     hb.boundaries(pix, step, bounds)
 *     cdef size_t n = bounds.size()             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[double, ndim = 2] out = np.empty((3, n), dtype=np.float)
 *     for i in range(n):
 */
  __pyx_v_n = __pyx_v_bounds.size();

  /* "healpy/src/_query_disc.pyx":205
 *     hb.boundaries(pix, step, bounds)
 *     cdef size_t n = bounds.size()
 *     cdef np.ndarray[double, ndim = 2] out = np.empty((3, n), dtype=np.float)             # <<<<<<<<<<<<<<
 *     for i in range(n):
 *         out[0,i] = bounds[i].x
 */
  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_3);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
  __pyx_t_6 = 0;
  __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 205, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_8);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_out.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_out = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_out.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 205, __pyx_L1_error)
    } else {__pyx_pybuffernd_out.diminfo[0].strides = __pyx_pybuffernd_out.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_out.diminfo[0].shape = __pyx_pybuffernd_out.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_out.diminfo[1].strides = __pyx_pybuffernd_out.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_out.diminfo[1].shape = __pyx_pybuffernd_out.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_out = ((PyArrayObject *)__pyx_t_8);
  __pyx_t_8 = 0;

  /* "healpy/src/_query_disc.pyx":206
 *     cdef size_t n = bounds.size()
 *     cdef np.ndarray[double, ndim = 2] out = np.empty((3, n), dtype=np.float)
 *     for i in range(n):             # <<<<<<<<<<<<<<
 *         out[0,i] = bounds[i].x
 *         out[1,i] = bounds[i].y
 */
  __pyx_t_5 = __pyx_v_n;
  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_5; __pyx_t_10+=1) {
    __pyx_v_i = __pyx_t_10;

    /* "healpy/src/_query_disc.pyx":207
 *     cdef np.ndarray[double, ndim = 2] out = np.empty((3, n), dtype=np.float)
 *     for i in range(n):
 *         out[0,i] = bounds[i].x             # <<<<<<<<<<<<<<
 *         out[1,i] = bounds[i].y
 *         out[2,i] = bounds[i].z
 */
    __pyx_t_11 = (__pyx_v_bounds[__pyx_v_i]).x;
    __pyx_t_12 = 0;
    __pyx_t_13 = __pyx_v_i;
    __pyx_t_14 = -1;
    if (__pyx_t_12 < 0) {
      __pyx_t_12 += __pyx_pybuffernd_out.diminfo[0].shape;
      if (unlikely(__pyx_t_12 < 0)) __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_out.diminfo[0].shape)) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_13 >= (size_t)__pyx_pybuffernd_out.diminfo[1].shape)) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 207, __pyx_L1_error)
    }
    *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_out.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_out.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_out.diminfo[1].strides) = __pyx_t_11;

    /* "healpy/src/_query_disc.pyx":208
 *     for i in range(n):
 *         out[0,i] = bounds[i].x
 *         out[1,i] = bounds[i].y             # <<<<<<<<<<<<<<
 *         out[2,i] = bounds[i].z
 *     return out
 */
    __pyx_t_11 = (__pyx_v_bounds[__pyx_v_i]).y;
    __pyx_t_15 = 1;
    __pyx_t_16 = __pyx_v_i;
    __pyx_t_14 = -1;
    if (__pyx_t_15 < 0) {
      __pyx_t_15 += __pyx_pybuffernd_out.diminfo[0].shape;
      if (unlikely(__pyx_t_15 < 0)) __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_out.diminfo[0].shape)) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_out.diminfo[1].shape)) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 208, __pyx_L1_error)
    }
    *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_out.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_out.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_out.diminfo[1].strides) = __pyx_t_11;

    /* "healpy/src/_query_disc.pyx":209
 *         out[0,i] = bounds[i].x
 *         out[1,i] = bounds[i].y
 *         out[2,i] = bounds[i].z             # <<<<<<<<<<<<<<
 *     return out
 * 
 */
    __pyx_t_11 = (__pyx_v_bounds[__pyx_v_i]).z;
    __pyx_t_17 = 2;
    __pyx_t_18 = __pyx_v_i;
    __pyx_t_14 = -1;
    if (__pyx_t_17 < 0) {
      __pyx_t_17 += __pyx_pybuffernd_out.diminfo[0].shape;
      if (unlikely(__pyx_t_17 < 0)) __pyx_t_14 = 0;
    } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_out.diminfo[0].shape)) __pyx_t_14 = 0;
    if (unlikely(__pyx_t_18 >= (size_t)__pyx_pybuffernd_out.diminfo[1].shape)) __pyx_t_14 = 1;
    if (unlikely(__pyx_t_14 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_14);
      __PYX_ERR(0, 209, __pyx_L1_error)
    }
    *__Pyx_BufPtrStrided2d(double *, __pyx_pybuffernd_out.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_out.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_out.diminfo[1].strides) = __pyx_t_11;
  }

  /* "healpy/src/_query_disc.pyx":210
 *         out[1,i] = bounds[i].y
 *         out[2,i] = bounds[i].z
 *     return out             # <<<<<<<<<<<<<<
 * 
 * def _boundaries_multiple(nside, pix, step=1, nest=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_out));
  __pyx_r = ((PyObject *)__pyx_v_out);
  goto __pyx_L0;

  /* "healpy/src/_query_disc.pyx":193
 * 
 * 
 * def _boundaries_single(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_out.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._query_disc._boundaries_single", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_out.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_out);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_query_disc.pyx":212
 *     return out
 * 
 * def _boundaries_multiple(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_11_query_disc_9_boundaries_multiple(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_11_query_disc_8_boundaries_multiple[] = "_boundaries_multiple(nside, pix, step=1, nest=False)";
static PyMethodDef __pyx_mdef_6healpy_11_query_disc_9_boundaries_multiple = {"_boundaries_multiple", (PyCFunction)__pyx_pw_6healpy_11_query_disc_9_boundaries_multiple, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_11_query_disc_8_boundaries_multiple};
static PyObject *__pyx_pw_6healpy_11_query_disc_9_boundaries_multiple(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nside = 0;
  PyObject *__pyx_v_pix = 0;
  PyObject *__pyx_v_step = 0;
  PyObject *__pyx_v_nest = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_boundaries_multiple (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nside,&__pyx_n_s_pix,&__pyx_n_s_step,&__pyx_n_s_nest,0};
    PyObject* values[4] = {0,0,0,0};
    values[2] = ((PyObject *)__pyx_int_1);
    values[3] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nside)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pix)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("_boundaries_multiple", 0, 2, 4, 1); __PYX_ERR(0, 212, __pyx_L3_error)
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_step);
          if (value) { values[2] = value; kw_args--; }
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nest);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_boundaries_multiple") < 0)) __PYX_ERR(0, 212, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nside = values[0];
    __pyx_v_pix = values[1];
    __pyx_v_step = values[2];
    __pyx_v_nest = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("_boundaries_multiple", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 212, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._query_disc._boundaries_multiple", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_11_query_disc_8_boundaries_multiple(__pyx_self, __pyx_v_nside, __pyx_v_pix, __pyx_v_step, __pyx_v_nest);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_11_query_disc_8_boundaries_multiple(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_pix, PyObject *__pyx_v_step, PyObject *__pyx_v_nest) {
  enum Healpix_Ordering_Scheme __pyx_v_scheme;
  T_Healpix_Base  __pyx_v_hb;
  size_t __pyx_v_npix;
  size_t __pyx_v_n;
  size_t __pyx_v_maxnpix;
  PyArrayObject *__pyx_v_out = 0;
  std::vector  __pyx_v_bounds;
  size_t __pyx_v_j;
  size_t __pyx_v_i;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_out;
  __Pyx_Buffer __pyx_pybuffer_out;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int64 __pyx_t_2;
  Py_ssize_t __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  size_t __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyArrayObject *__pyx_t_10 = NULL;
  size_t __pyx_t_11;
  size_t __pyx_t_12;
  size_t __pyx_t_13;
  double __pyx_t_14;
  size_t __pyx_t_15;
  Py_ssize_t __pyx_t_16;
  size_t __pyx_t_17;
  int __pyx_t_18;
  size_t __pyx_t_19;
  Py_ssize_t __pyx_t_20;
  size_t __pyx_t_21;
  size_t __pyx_t_22;
  Py_ssize_t __pyx_t_23;
  size_t __pyx_t_24;
  __Pyx_RefNannySetupContext("_boundaries_multiple", 0);
  __pyx_pybuffer_out.pybuffer.buf = NULL;
  __pyx_pybuffer_out.refcount = 0;
  __pyx_pybuffernd_out.data = NULL;
  __pyx_pybuffernd_out.rcbuffer = &__pyx_pybuffer_out;

  /* "healpy/src/_query_disc.pyx":214
 * def _boundaries_multiple(nside, pix, step=1, nest=False):
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_nest); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 214, __pyx_L1_error)
  if (__pyx_t_1) {

    /* "healpy/src/_query_disc.pyx":215
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 *         scheme = NEST             # <<<<<<<<<<<<<<
 *     else:
 *         scheme = RING
 */
    __pyx_v_scheme = NEST;

    /* "healpy/src/_query_disc.pyx":214
 * def _boundaries_multiple(nside, pix, step=1, nest=False):
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:             # <<<<<<<<<<<<<<
 *         scheme = NEST
 *     else:
 */
    goto __pyx_L3;
  }

  /* "healpy/src/_query_disc.pyx":217
 *         scheme = NEST
 *     else:
 *         scheme = RING             # <<<<<<<<<<<<<<
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     cdef size_t npix = len(pix)
 */
  /*else*/ {
    __pyx_v_scheme = RING;
  }
  __pyx_L3:;

  /* "healpy/src/_query_disc.pyx":218
 *     else:
 *         scheme = RING
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)             # <<<<<<<<<<<<<<
 *     cdef size_t npix = len(pix)
 *     cdef size_t n = step * 4
 */
  __pyx_t_2 = __Pyx_PyInt_As_int64(__pyx_v_nside); if (unlikely((__pyx_t_2 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 218, __pyx_L1_error)
  __pyx_v_hb = T_Healpix_Base (__pyx_t_2, __pyx_v_scheme, SET_NSIDE);

  /* "healpy/src/_query_disc.pyx":219
 *         scheme = RING
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     cdef size_t npix = len(pix)             # <<<<<<<<<<<<<<
 *     cdef size_t n = step * 4
 *     cdef size_t maxnpix = 12*nside*nside
 */
  __pyx_t_3 = PyObject_Length(__pyx_v_pix); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 219, __pyx_L1_error)
  __pyx_v_npix = __pyx_t_3;

  /* "healpy/src/_query_disc.pyx":220
 *     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
 *     cdef size_t npix = len(pix)
 *     cdef size_t n = step * 4             # <<<<<<<<<<<<<<
 *     cdef size_t maxnpix = 12*nside*nside
 *     cdef np.ndarray[double, ndim = 3] out = np.empty((npix, 3, n), dtype=np.float)
 */
  __pyx_t_4 = PyNumber_Multiply(__pyx_v_step, __pyx_int_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 220, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_n = __pyx_t_5;

  /* "healpy/src/_query_disc.pyx":221
 *     cdef size_t npix = len(pix)
 *     cdef size_t n = step * 4
 *     cdef size_t maxnpix = 12*nside*nside             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[double, ndim = 3] out = np.empty((npix, 3, n), dtype=np.float)
 *     cdef vector[vec3] bounds
 */
  __pyx_t_4 = PyNumber_Multiply(__pyx_int_12, __pyx_v_nside); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_6 = PyNumber_Multiply(__pyx_t_4, __pyx_v_nside); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 221, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_maxnpix = __pyx_t_5;

  /* "healpy/src/_query_disc.pyx":222
 *     cdef size_t n = step * 4
 *     cdef size_t maxnpix = 12*nside*nside
 *     cdef np.ndarray[double, ndim = 3] out = np.empty((npix, 3, n), dtype=np.float)             # <<<<<<<<<<<<<<
 *     cdef vector[vec3] bounds
 * 
 */
  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyInt_FromSize_t(__pyx_v_npix); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_n); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_int_3);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7);
  __pyx_t_6 = 0;
  __pyx_t_7 = 0;
  __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_8);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8);
  __pyx_t_8 = 0;
  __pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (!(likely(((__pyx_t_9) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_9, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 222, __pyx_L1_error)
  __pyx_t_10 = ((PyArrayObject *)__pyx_t_9);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_out.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_out = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_out.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 222, __pyx_L1_error)
    } else {__pyx_pybuffernd_out.diminfo[0].strides = __pyx_pybuffernd_out.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_out.diminfo[0].shape = __pyx_pybuffernd_out.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_out.diminfo[1].strides = __pyx_pybuffernd_out.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_out.diminfo[1].shape = __pyx_pybuffernd_out.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_out.diminfo[2].strides = __pyx_pybuffernd_out.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_out.diminfo[2].shape = __pyx_pybuffernd_out.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_10 = 0;
  __pyx_v_out = ((PyArrayObject *)__pyx_t_9);
  __pyx_t_9 = 0;

  /* "healpy/src/_query_disc.pyx":225
 *     cdef vector[vec3] bounds
 * 
 *     for j in range(npix):             # <<<<<<<<<<<<<<
 *         if pix[j] >= maxnpix:
 *             raise ValueError('Pixel identifier is too large')
 */
  __pyx_t_5 = __pyx_v_npix;
  for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_5; __pyx_t_11+=1) {
    __pyx_v_j = __pyx_t_11;

    /* "healpy/src/_query_disc.pyx":226
 * 
 *     for j in range(npix):
 *         if pix[j] >= maxnpix:             # <<<<<<<<<<<<<<
 *             raise ValueError('Pixel identifier is too large')
 * 
 */
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_pix, __pyx_v_j, size_t, 0, __Pyx_PyInt_FromSize_t, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 226, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_8 = __Pyx_PyInt_FromSize_t(__pyx_v_maxnpix); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 226, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_7 = PyObject_RichCompare(__pyx_t_9, __pyx_t_8, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 226, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (__pyx_t_1) {

      /* "healpy/src/_query_disc.pyx":227
 *     for j in range(npix):
 *         if pix[j] >= maxnpix:
 *             raise ValueError('Pixel identifier is too large')             # <<<<<<<<<<<<<<
 * 
 *         hb.boundaries(pix[j], step, bounds)
 */
      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 227, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __PYX_ERR(0, 227, __pyx_L1_error)

      /* "healpy/src/_query_disc.pyx":226
 * 
 *     for j in range(npix):
 *         if pix[j] >= maxnpix:             # <<<<<<<<<<<<<<
 *             raise ValueError('Pixel identifier is too large')
 * 
 */
    }

    /* "healpy/src/_query_disc.pyx":229
 *             raise ValueError('Pixel identifier is too large')
 * 
 *         hb.boundaries(pix[j], step, bounds)             # <<<<<<<<<<<<<<
 *         for i in range(n):
 *             out[j, 0, i] = bounds[i].x
 */
    __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_pix, __pyx_v_j, size_t, 0, __Pyx_PyInt_FromSize_t, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 229, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_2 = __Pyx_PyInt_As_int64(__pyx_t_7); if (unlikely((__pyx_t_2 == (int64)-1) && PyErr_Occurred())) __PYX_ERR(0, 229, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_12 = __Pyx_PyInt_As_size_t(__pyx_v_step); if (unlikely((__pyx_t_12 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 229, __pyx_L1_error)
    __pyx_v_hb.boundaries(__pyx_t_2, __pyx_t_12, __pyx_v_bounds);

    /* "healpy/src/_query_disc.pyx":230
 * 
 *         hb.boundaries(pix[j], step, bounds)
 *         for i in range(n):             # <<<<<<<<<<<<<<
 *             out[j, 0, i] = bounds[i].x
 *             out[j, 1, i] = bounds[i].y
 */
    __pyx_t_12 = __pyx_v_n;
    for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) {
      __pyx_v_i = __pyx_t_13;

      /* "healpy/src/_query_disc.pyx":231
 *         hb.boundaries(pix[j], step, bounds)
 *         for i in range(n):
 *             out[j, 0, i] = bounds[i].x             # <<<<<<<<<<<<<<
 *             out[j, 1, i] = bounds[i].y
 *             out[j, 2, i] = bounds[i].z
 */
      __pyx_t_14 = (__pyx_v_bounds[__pyx_v_i]).x;
      __pyx_t_15 = __pyx_v_j;
      __pyx_t_16 = 0;
      __pyx_t_17 = __pyx_v_i;
      __pyx_t_18 = -1;
      if (unlikely(__pyx_t_15 >= (size_t)__pyx_pybuffernd_out.diminfo[0].shape)) __pyx_t_18 = 0;
      if (__pyx_t_16 < 0) {
        __pyx_t_16 += __pyx_pybuffernd_out.diminfo[1].shape;
        if (unlikely(__pyx_t_16 < 0)) __pyx_t_18 = 1;
      } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_out.diminfo[1].shape)) __pyx_t_18 = 1;
      if (unlikely(__pyx_t_17 >= (size_t)__pyx_pybuffernd_out.diminfo[2].shape)) __pyx_t_18 = 2;
      if (unlikely(__pyx_t_18 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_18);
        __PYX_ERR(0, 231, __pyx_L1_error)
      }
      *__Pyx_BufPtrStrided3d(double *, __pyx_pybuffernd_out.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_out.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_out.diminfo[1].strides, __pyx_t_17, __pyx_pybuffernd_out.diminfo[2].strides) = __pyx_t_14;

      /* "healpy/src/_query_disc.pyx":232
 *         for i in range(n):
 *             out[j, 0, i] = bounds[i].x
 *             out[j, 1, i] = bounds[i].y             # <<<<<<<<<<<<<<
 *             out[j, 2, i] = bounds[i].z
 *     return out
 */
      __pyx_t_14 = (__pyx_v_bounds[__pyx_v_i]).y;
      __pyx_t_19 = __pyx_v_j;
      __pyx_t_20 = 1;
      __pyx_t_21 = __pyx_v_i;
      __pyx_t_18 = -1;
      if (unlikely(__pyx_t_19 >= (size_t)__pyx_pybuffernd_out.diminfo[0].shape)) __pyx_t_18 = 0;
      if (__pyx_t_20 < 0) {
        __pyx_t_20 += __pyx_pybuffernd_out.diminfo[1].shape;
        if (unlikely(__pyx_t_20 < 0)) __pyx_t_18 = 1;
      } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_out.diminfo[1].shape)) __pyx_t_18 = 1;
      if (unlikely(__pyx_t_21 >= (size_t)__pyx_pybuffernd_out.diminfo[2].shape)) __pyx_t_18 = 2;
      if (unlikely(__pyx_t_18 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_18);
        __PYX_ERR(0, 232, __pyx_L1_error)
      }
      *__Pyx_BufPtrStrided3d(double *, __pyx_pybuffernd_out.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_out.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_out.diminfo[1].strides, __pyx_t_21, __pyx_pybuffernd_out.diminfo[2].strides) = __pyx_t_14;

      /* "healpy/src/_query_disc.pyx":233
 *             out[j, 0, i] = bounds[i].x
 *             out[j, 1, i] = bounds[i].y
 *             out[j, 2, i] = bounds[i].z             # <<<<<<<<<<<<<<
 *     return out
 * 
 */
      __pyx_t_14 = (__pyx_v_bounds[__pyx_v_i]).z;
      __pyx_t_22 = __pyx_v_j;
      __pyx_t_23 = 2;
      __pyx_t_24 = __pyx_v_i;
      __pyx_t_18 = -1;
      if (unlikely(__pyx_t_22 >= (size_t)__pyx_pybuffernd_out.diminfo[0].shape)) __pyx_t_18 = 0;
      if (__pyx_t_23 < 0) {
        __pyx_t_23 += __pyx_pybuffernd_out.diminfo[1].shape;
        if (unlikely(__pyx_t_23 < 0)) __pyx_t_18 = 1;
      } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_out.diminfo[1].shape)) __pyx_t_18 = 1;
      if (unlikely(__pyx_t_24 >= (size_t)__pyx_pybuffernd_out.diminfo[2].shape)) __pyx_t_18 = 2;
      if (unlikely(__pyx_t_18 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_18);
        __PYX_ERR(0, 233, __pyx_L1_error)
      }
      *__Pyx_BufPtrStrided3d(double *, __pyx_pybuffernd_out.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_out.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_out.diminfo[1].strides, __pyx_t_24, __pyx_pybuffernd_out.diminfo[2].strides) = __pyx_t_14;
    }
  }

  /* "healpy/src/_query_disc.pyx":234
 *             out[j, 1, i] = bounds[i].y
 *             out[j, 2, i] = bounds[i].z
 *     return out             # <<<<<<<<<<<<<<
 * 
 * def boundaries(nside, pix, step=1, nest=False):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_out));
  __pyx_r = ((PyObject *)__pyx_v_out);
  goto __pyx_L0;

  /* "healpy/src/_query_disc.pyx":212
 *     return out
 * 
 * def _boundaries_multiple(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_out.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._query_disc._boundaries_multiple", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_out.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_out);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_query_disc.pyx":236
 *     return out
 * 
 * def boundaries(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     """Returns an array containing vectors to the boundary of
 *     the nominated pixel.
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_11_query_disc_11boundaries(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_11_query_disc_10boundaries[] = "boundaries(nside, pix, step=1, nest=False)\nReturns an array containing vectors to the boundary of\n    the nominated pixel.\n\n    The returned array has shape (3, 4*step), the elements of\n    which are the x,y,z positions on the unit sphere of the\n    pixel boundary.  In order to get vector positions for just\n    the corners, specify step=1.\n\n    Parameters\n    ----------\n    nside : int\n      The nside of the Healpix map.\n    pix : int\n      Pixel identifier\n    step : int, optional\n      Number of elements for each side of the pixel.\n    nest : bool, optional\n      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering\n\n    Returns\n    -------\n    boundary : float, array\n      x,y,z for positions on the boundary of the pixel\n\n    Example\n    -------\n    # Get corners of HEALPixel 5 in nside=2, RINGS ordering.\n\n    >>> import healpy as hp\n    >>> import numpy as np\n    >>> nside = 2\n    >>> corners = hp.boundaries(nside, 5)\n\n    # Now convert to phi,theta representation:\n    >>> phi_theta = hp.vec2ang(np.transpose(corners))\n\n    >>> corners = hp.boundaries(nside, np.array([5,5]))\n\n    # doctest moved to test_query_disc.py\n    ";
static PyMethodDef __pyx_mdef_6healpy_11_query_disc_11boundaries = {"boundaries", (PyCFunction)__pyx_pw_6healpy_11_query_disc_11boundaries, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_11_query_disc_10boundaries};
static PyObject *__pyx_pw_6healpy_11_query_disc_11boundaries(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_nside = 0;
  PyObject *__pyx_v_pix = 0;
  PyObject *__pyx_v_step = 0;
  PyObject *__pyx_v_nest = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("boundaries (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nside,&__pyx_n_s_pix,&__pyx_n_s_step,&__pyx_n_s_nest,0};
    PyObject* values[4] = {0,0,0,0};
    values[2] = ((PyObject *)__pyx_int_1);
    values[3] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nside)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pix)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("boundaries", 0, 2, 4, 1); __PYX_ERR(0, 236, __pyx_L3_error)
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_step);
          if (value) { values[2] = value; kw_args--; }
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nest);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "boundaries") < 0)) __PYX_ERR(0, 236, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_nside = values[0];
    __pyx_v_pix = values[1];
    __pyx_v_step = values[2];
    __pyx_v_nest = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("boundaries", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 236, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._query_disc.boundaries", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_11_query_disc_10boundaries(__pyx_self, __pyx_v_nside, __pyx_v_pix, __pyx_v_step, __pyx_v_nest);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_11_query_disc_10boundaries(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nside, PyObject *__pyx_v_pix, PyObject *__pyx_v_step, PyObject *__pyx_v_nest) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  Py_ssize_t __pyx_t_7;
  PyObject *__pyx_t_8 = NULL;
  int __pyx_t_9;
  PyObject *__pyx_t_10 = NULL;
  __Pyx_RefNannySetupContext("boundaries", 0);
  __Pyx_INCREF(__pyx_v_pix);

  /* "healpy/src/_query_disc.pyx":278
 *     """
 * 
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     if np.isscalar(pix):
 */
  __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_nside); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 278, __pyx_L1_error)
  __pyx_t_2 = ((!(__pyx_f_6healpy_11_query_disc_isnsideok(__pyx_t_1) != 0)) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":279
 * 
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     if np.isscalar(pix):
 *         if not np.can_cast(type(pix), np.int):
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 279, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 279, __pyx_L1_error)

    /* "healpy/src/_query_disc.pyx":278
 *     """
 * 
 *     if not isnsideok(nside):             # <<<<<<<<<<<<<<
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     if np.isscalar(pix):
 */
  }

  /* "healpy/src/_query_disc.pyx":280
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     if np.isscalar(pix):             # <<<<<<<<<<<<<<
 *         if not np.can_cast(type(pix), np.int):
 *             raise ValueError('Array of pixels has to be integers')
 */
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 280, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isscalar); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 280, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = NULL;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_5, function);
    }
  }
  if (!__pyx_t_4) {
    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_pix); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
  } else {
    __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
    __Pyx_INCREF(__pyx_v_pix);
    __Pyx_GIVEREF(__pyx_v_pix);
    PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_pix);
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 280, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":281
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     if np.isscalar(pix):
 *         if not np.can_cast(type(pix), np.int):             # <<<<<<<<<<<<<<
 *             raise ValueError('Array of pixels has to be integers')
 *         return _boundaries_single(nside, pix, step=step, nest=nest)
 */
    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_can_cast); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = NULL;
    __pyx_t_7 = 0;
    if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
      if (likely(__pyx_t_5)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_5);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_6, function);
        __pyx_t_7 = 1;
      }
    }
    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (__pyx_t_5) {
      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
    }
    __Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_v_pix)));
    __Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_v_pix)));
    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, ((PyObject *)Py_TYPE(__pyx_v_pix)));
    __Pyx_GIVEREF(__pyx_t_4);
    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4);
    __pyx_t_4 = 0;
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 281, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_9 = ((!__pyx_t_2) != 0);
    if (__pyx_t_9) {

      /* "healpy/src/_query_disc.pyx":282
 *     if np.isscalar(pix):
 *         if not np.can_cast(type(pix), np.int):
 *             raise ValueError('Array of pixels has to be integers')             # <<<<<<<<<<<<<<
 *         return _boundaries_single(nside, pix, step=step, nest=nest)
 *     else:
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 282, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(0, 282, __pyx_L1_error)

      /* "healpy/src/_query_disc.pyx":281
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     if np.isscalar(pix):
 *         if not np.can_cast(type(pix), np.int):             # <<<<<<<<<<<<<<
 *             raise ValueError('Array of pixels has to be integers')
 *         return _boundaries_single(nside, pix, step=step, nest=nest)
 */
    }

    /* "healpy/src/_query_disc.pyx":283
 *         if not np.can_cast(type(pix), np.int):
 *             raise ValueError('Array of pixels has to be integers')
 *         return _boundaries_single(nside, pix, step=step, nest=nest)             # <<<<<<<<<<<<<<
 *     else:
 *         pix = np.asarray(pix)
 */
    __Pyx_XDECREF(__pyx_r);
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_boundaries_single); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 283, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 283, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_v_nside);
    __Pyx_GIVEREF(__pyx_v_nside);
    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_nside);
    __Pyx_INCREF(__pyx_v_pix);
    __Pyx_GIVEREF(__pyx_v_pix);
    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_pix);
    __pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 283, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_step, __pyx_v_step) < 0) __PYX_ERR(0, 283, __pyx_L1_error)
    if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_nest, __pyx_v_nest) < 0) __PYX_ERR(0, 283, __pyx_L1_error)
    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 283, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_r = __pyx_t_4;
    __pyx_t_4 = 0;
    goto __pyx_L0;

    /* "healpy/src/_query_disc.pyx":280
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
 *     if np.isscalar(pix):             # <<<<<<<<<<<<<<
 *         if not np.can_cast(type(pix), np.int):
 *             raise ValueError('Array of pixels has to be integers')
 */
  }

  /* "healpy/src/_query_disc.pyx":285
 *         return _boundaries_single(nside, pix, step=step, nest=nest)
 *     else:
 *         pix = np.asarray(pix)             # <<<<<<<<<<<<<<
 *         if np.can_cast(pix.dtype, np.int):
 *             if pix.ndim!=1:
 */
  /*else*/ {
    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 285, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_asarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 285, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = NULL;
    if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
      if (likely(__pyx_t_8)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_8);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_6, function);
      }
    }
    if (!__pyx_t_8) {
      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_pix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
    } else {
      __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8); __pyx_t_8 = NULL;
      __Pyx_INCREF(__pyx_v_pix);
      __Pyx_GIVEREF(__pyx_v_pix);
      PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_pix);
      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 285, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF_SET(__pyx_v_pix, __pyx_t_4);
    __pyx_t_4 = 0;

    /* "healpy/src/_query_disc.pyx":286
 *     else:
 *         pix = np.asarray(pix)
 *         if np.can_cast(pix.dtype, np.int):             # <<<<<<<<<<<<<<
 *             if pix.ndim!=1:
 *                 raise ValueError('Array has to be one dimensional')
 */
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_can_cast); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_pix, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_int); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = NULL;
    __pyx_t_7 = 0;
    if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
      if (likely(__pyx_t_8)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_8);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_3, function);
        __pyx_t_7 = 1;
      }
    }
    __pyx_t_10 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    if (__pyx_t_8) {
      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
    }
    __Pyx_GIVEREF(__pyx_t_6);
    PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_7, __pyx_t_6);
    __Pyx_GIVEREF(__pyx_t_5);
    PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_7, __pyx_t_5);
    __pyx_t_6 = 0;
    __pyx_t_5 = 0;
    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 286, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (__pyx_t_9) {

      /* "healpy/src/_query_disc.pyx":287
 *         pix = np.asarray(pix)
 *         if np.can_cast(pix.dtype, np.int):
 *             if pix.ndim!=1:             # <<<<<<<<<<<<<<
 *                 raise ValueError('Array has to be one dimensional')
 *             return _boundaries_multiple(nside, pix.astype(np.int), step=step, nest=nest)
 */
      __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_pix, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 287, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_int_1, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 287, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_9) {

        /* "healpy/src/_query_disc.pyx":288
 *         if np.can_cast(pix.dtype, np.int):
 *             if pix.ndim!=1:
 *                 raise ValueError('Array has to be one dimensional')             # <<<<<<<<<<<<<<
 *             return _boundaries_multiple(nside, pix.astype(np.int), step=step, nest=nest)
 *         else:
 */
        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __PYX_ERR(0, 288, __pyx_L1_error)

        /* "healpy/src/_query_disc.pyx":287
 *         pix = np.asarray(pix)
 *         if np.can_cast(pix.dtype, np.int):
 *             if pix.ndim!=1:             # <<<<<<<<<<<<<<
 *                 raise ValueError('Array has to be one dimensional')
 *             return _boundaries_multiple(nside, pix.astype(np.int), step=step, nest=nest)
 */
      }

      /* "healpy/src/_query_disc.pyx":289
 *             if pix.ndim!=1:
 *                 raise ValueError('Array has to be one dimensional')
 *             return _boundaries_multiple(nside, pix.astype(np.int), step=step, nest=nest)             # <<<<<<<<<<<<<<
 *         else:
 *             raise ValueError('Array of pixels has to be integers')
 */
      __Pyx_XDECREF(__pyx_r);
      __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_boundaries_multiple); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_pix, __pyx_n_s_astype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      __pyx_t_5 = NULL;
      if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_10))) {
        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_10);
        if (likely(__pyx_t_5)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
          __Pyx_INCREF(__pyx_t_5);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_10, function);
        }
      }
      if (!__pyx_t_5) {
        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 289, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
        __Pyx_GOTREF(__pyx_t_4);
      } else {
        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 289, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
        __Pyx_GIVEREF(__pyx_t_6);
        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6);
        __pyx_t_6 = 0;
        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 289, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      }
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_INCREF(__pyx_v_nside);
      __Pyx_GIVEREF(__pyx_v_nside);
      PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_v_nside);
      __Pyx_GIVEREF(__pyx_t_4);
      PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_4);
      __pyx_t_4 = 0;
      __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_step, __pyx_v_step) < 0) __PYX_ERR(0, 289, __pyx_L1_error)
      if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_nest, __pyx_v_nest) < 0) __PYX_ERR(0, 289, __pyx_L1_error)
      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 289, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_r = __pyx_t_8;
      __pyx_t_8 = 0;
      goto __pyx_L0;

      /* "healpy/src/_query_disc.pyx":286
 *     else:
 *         pix = np.asarray(pix)
 *         if np.can_cast(pix.dtype, np.int):             # <<<<<<<<<<<<<<
 *             if pix.ndim!=1:
 *                 raise ValueError('Array has to be one dimensional')
 */
    }

    /* "healpy/src/_query_disc.pyx":291
 *             return _boundaries_multiple(nside, pix.astype(np.int), step=step, nest=nest)
 *         else:
 *             raise ValueError('Array of pixels has to be integers')             # <<<<<<<<<<<<<<
 * 
 * # Try to implement pix2ang
 */
    /*else*/ {
      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 291, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __PYX_ERR(0, 291, __pyx_L1_error)
    }
  }

  /* "healpy/src/_query_disc.pyx":236
 *     return out
 * 
 * def boundaries(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     """Returns an array containing vectors to the boundary of
 *     the nominated pixel.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("healpy._query_disc.boundaries", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_pix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_query_disc.pyx":324
 * @cython.boundscheck(False)
 * @cython.wraparound(False)
 * cdef pixset_to_array(rangeset[int64] &pixset, buff=None):             # <<<<<<<<<<<<<<
 *     cdef int64 i, n
 *     n = pixset.nval()
 */

static PyObject *__pyx_f_6healpy_11_query_disc_pixset_to_array(rangeset  &__pyx_v_pixset, struct __pyx_opt_args_6healpy_11_query_disc_pixset_to_array *__pyx_optional_args) {
  PyObject *__pyx_v_buff = ((PyObject *)Py_None);
  int64 __pyx_v_i;
  int64 __pyx_v_n;
  PyArrayObject *__pyx_v_ipix = 0;
  int64 __pyx_v_a;
  int64 __pyx_v_b;
  int64 __pyx_v_ii;
  int64 __pyx_v_ip;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_ipix;
  __Pyx_Buffer __pyx_pybuffer_ipix;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyArrayObject *__pyx_t_8 = NULL;
  int __pyx_t_9;
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  PyObject *__pyx_t_12 = NULL;
  Py_ssize_t __pyx_t_13;
  int64 __pyx_t_14;
  int64 __pyx_t_15;
  int64 __pyx_t_16;
  int64 __pyx_t_17;
  Py_ssize_t __pyx_t_18;
  __Pyx_RefNannySetupContext("pixset_to_array", 0);
  if (__pyx_optional_args) {
    if (__pyx_optional_args->__pyx_n > 0) {
      __pyx_v_buff = __pyx_optional_args->buff;
    }
  }
  __pyx_pybuffer_ipix.pybuffer.buf = NULL;
  __pyx_pybuffer_ipix.refcount = 0;
  __pyx_pybuffernd_ipix.data = NULL;
  __pyx_pybuffernd_ipix.rcbuffer = &__pyx_pybuffer_ipix;

  /* "healpy/src/_query_disc.pyx":326
 * cdef pixset_to_array(rangeset[int64] &pixset, buff=None):
 *     cdef int64 i, n
 *     n = pixset.nval()             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[np.int64_t, ndim=1] ipix
 * 
 */
  __pyx_v_n = __pyx_v_pixset.nval();

  /* "healpy/src/_query_disc.pyx":329
 *     cdef np.ndarray[np.int64_t, ndim=1] ipix
 * 
 *     if buff is None :             # <<<<<<<<<<<<<<
 *        ipix = np.empty(n, dtype=np.int64)
 *     else :
 */
  __pyx_t_1 = (__pyx_v_buff == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_query_disc.pyx":330
 * 
 *     if buff is None :
 *        ipix = np.empty(n, dtype=np.int64)             # <<<<<<<<<<<<<<
 *     else :
 *        if n>=len(buff) :
 */
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyInt_From_int64(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GIVEREF(__pyx_t_3);
    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
    __pyx_t_3 = 0;
    __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 330, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 330, __pyx_L1_error)
    __pyx_t_8 = ((PyArrayObject *)__pyx_t_7);
    {
      __Pyx_BufFmt_StackElem __pyx_stack[1];
      __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ipix.rcbuffer->pybuffer);
      __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ipix.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack);
      if (unlikely(__pyx_t_9 < 0)) {
        PyErr_Fetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
        if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ipix.rcbuffer->pybuffer, (PyObject*)__pyx_v_ipix, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
          Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12);
          __Pyx_RaiseBufferFallbackError();
        } else {
          PyErr_Restore(__pyx_t_10, __pyx_t_11, __pyx_t_12);
        }
      }
      __pyx_pybuffernd_ipix.diminfo[0].strides = __pyx_pybuffernd_ipix.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ipix.diminfo[0].shape = __pyx_pybuffernd_ipix.rcbuffer->pybuffer.shape[0];
      if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 330, __pyx_L1_error)
    }
    __pyx_t_8 = 0;
    __pyx_v_ipix = ((PyArrayObject *)__pyx_t_7);
    __pyx_t_7 = 0;

    /* "healpy/src/_query_disc.pyx":329
 *     cdef np.ndarray[np.int64_t, ndim=1] ipix
 * 
 *     if buff is None :             # <<<<<<<<<<<<<<
 *        ipix = np.empty(n, dtype=np.int64)
 *     else :
 */
    goto __pyx_L3;
  }

  /* "healpy/src/_query_disc.pyx":332
 *        ipix = np.empty(n, dtype=np.int64)
 *     else :
 *        if n>=len(buff) :             # <<<<<<<<<<<<<<
 *            raise ValueError("Buffer too small to contain return value")
 *        ipix = buff[:n]
 */
  /*else*/ {
    __pyx_t_13 = PyObject_Length(__pyx_v_buff); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 332, __pyx_L1_error)
    __pyx_t_2 = ((__pyx_v_n >= __pyx_t_13) != 0);
    if (__pyx_t_2) {

      /* "healpy/src/_query_disc.pyx":333
 *     else :
 *        if n>=len(buff) :
 *            raise ValueError("Buffer too small to contain return value")             # <<<<<<<<<<<<<<
 *        ipix = buff[:n]
 * 
 */
      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 333, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_Raise(__pyx_t_7, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __PYX_ERR(0, 333, __pyx_L1_error)

      /* "healpy/src/_query_disc.pyx":332
 *        ipix = np.empty(n, dtype=np.int64)
 *     else :
 *        if n>=len(buff) :             # <<<<<<<<<<<<<<
 *            raise ValueError("Buffer too small to contain return value")
 *        ipix = buff[:n]
 */
    }

    /* "healpy/src/_query_disc.pyx":334
 *        if n>=len(buff) :
 *            raise ValueError("Buffer too small to contain return value")
 *        ipix = buff[:n]             # <<<<<<<<<<<<<<
 * 
 *     cdef int64 a, b, ii, ip
 */
    __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_v_buff, 0, __pyx_v_n, NULL, NULL, NULL, 0, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 334, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 334, __pyx_L1_error)
    __pyx_t_8 = ((PyArrayObject *)__pyx_t_7);
    {
      __Pyx_BufFmt_StackElem __pyx_stack[1];
      __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ipix.rcbuffer->pybuffer);
      __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ipix.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack);
      if (unlikely(__pyx_t_9 < 0)) {
        PyErr_Fetch(&__pyx_t_12, &__pyx_t_11, &__pyx_t_10);
        if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ipix.rcbuffer->pybuffer, (PyObject*)__pyx_v_ipix, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
          Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_10);
          __Pyx_RaiseBufferFallbackError();
        } else {
          PyErr_Restore(__pyx_t_12, __pyx_t_11, __pyx_t_10);
        }
      }
      __pyx_pybuffernd_ipix.diminfo[0].strides = __pyx_pybuffernd_ipix.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ipix.diminfo[0].shape = __pyx_pybuffernd_ipix.rcbuffer->pybuffer.shape[0];
      if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 334, __pyx_L1_error)
    }
    __pyx_t_8 = 0;
    __pyx_v_ipix = ((PyArrayObject *)__pyx_t_7);
    __pyx_t_7 = 0;
  }
  __pyx_L3:;

  /* "healpy/src/_query_disc.pyx":337
 * 
 *     cdef int64 a, b, ii, ip
 *     ii = 0             # <<<<<<<<<<<<<<
 *     n = pixset.size()
 *     for i in range(n):
 */
  __pyx_v_ii = 0;

  /* "healpy/src/_query_disc.pyx":338
 *     cdef int64 a, b, ii, ip
 *     ii = 0
 *     n = pixset.size()             # <<<<<<<<<<<<<<
 *     for i in range(n):
 *         a = pixset.ivbegin(i)
 */
  __pyx_v_n = __pyx_v_pixset.size();

  /* "healpy/src/_query_disc.pyx":339
 *     ii = 0
 *     n = pixset.size()
 *     for i in range(n):             # <<<<<<<<<<<<<<
 *         a = pixset.ivbegin(i)
 *         b = pixset.ivend(i)
 */
  __pyx_t_14 = __pyx_v_n;
  for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
    __pyx_v_i = __pyx_t_15;

    /* "healpy/src/_query_disc.pyx":340
 *     n = pixset.size()
 *     for i in range(n):
 *         a = pixset.ivbegin(i)             # <<<<<<<<<<<<<<
 *         b = pixset.ivend(i)
 *         for ip in range(a, b):
 */
    __pyx_v_a = __pyx_v_pixset.ivbegin(__pyx_v_i);

    /* "healpy/src/_query_disc.pyx":341
 *     for i in range(n):
 *         a = pixset.ivbegin(i)
 *         b = pixset.ivend(i)             # <<<<<<<<<<<<<<
 *         for ip in range(a, b):
 *             ipix[ii] = ip
 */
    __pyx_v_b = __pyx_v_pixset.ivend(__pyx_v_i);

    /* "healpy/src/_query_disc.pyx":342
 *         a = pixset.ivbegin(i)
 *         b = pixset.ivend(i)
 *         for ip in range(a, b):             # <<<<<<<<<<<<<<
 *             ipix[ii] = ip
 *             ii += 1
 */
    __pyx_t_16 = __pyx_v_b;
    for (__pyx_t_17 = __pyx_v_a; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) {
      __pyx_v_ip = __pyx_t_17;

      /* "healpy/src/_query_disc.pyx":343
 *         b = pixset.ivend(i)
 *         for ip in range(a, b):
 *             ipix[ii] = ip             # <<<<<<<<<<<<<<
 *             ii += 1
 *     return ipix
 */
      __pyx_t_18 = __pyx_v_ii;
      *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int64_t *, __pyx_pybuffernd_ipix.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_ipix.diminfo[0].strides) = __pyx_v_ip;

      /* "healpy/src/_query_disc.pyx":344
 *         for ip in range(a, b):
 *             ipix[ii] = ip
 *             ii += 1             # <<<<<<<<<<<<<<
 *     return ipix
 * 
 */
      __pyx_v_ii = (__pyx_v_ii + 1);
    }
  }

  /* "healpy/src/_query_disc.pyx":345
 *             ipix[ii] = ip
 *             ii += 1
 *     return ipix             # <<<<<<<<<<<<<<
 * 
 * cdef bool isnsideok(int nside):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_ipix));
  __pyx_r = ((PyObject *)__pyx_v_ipix);
  goto __pyx_L0;

  /* "healpy/src/_query_disc.pyx":324
 * @cython.boundscheck(False)
 * @cython.wraparound(False)
 * cdef pixset_to_array(rangeset[int64] &pixset, buff=None):             # <<<<<<<<<<<<<<
 *     cdef int64 i, n
 *     n = pixset.nval()
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ipix.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._query_disc.pixset_to_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ipix.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ipix);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_query_disc.pyx":347
 *     return ipix
 * 
 * cdef bool isnsideok(int nside):             # <<<<<<<<<<<<<<
 *      return nside > 0 and ((nside & (nside -1))==0)
 * 
 */

static bool __pyx_f_6healpy_11_query_disc_isnsideok(int __pyx_v_nside) {
  bool __pyx_r;
  __Pyx_RefNannyDeclarations
  bool __pyx_t_1;
  int __pyx_t_2;
  __Pyx_RefNannySetupContext("isnsideok", 0);

  /* "healpy/src/_query_disc.pyx":348
 * 
 * cdef bool isnsideok(int nside):
 *      return nside > 0 and ((nside & (nside -1))==0)             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __pyx_t_2 = (__pyx_v_nside > 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L3_bool_binop_done;
  }
  __pyx_t_2 = ((__pyx_v_nside & (__pyx_v_nside - 1)) == 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L3_bool_binop_done:;
  __pyx_r = __pyx_t_1;
  goto __pyx_L0;

  /* "healpy/src/_query_disc.pyx":347
 *     return ipix
 * 
 * cdef bool isnsideok(int nside):             # <<<<<<<<<<<<<<
 *      return nside > 0 and ((nside & (nside -1))==0)
 * 
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":197
 *         # experimental exception made for __getbuffer__ and __releasebuffer__
 *         # -- the details of this may change.
 *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
 *             # This implementation of getbuffer is geared towards Cython
 *             # requirements, and does not yet fullfill the PEP.
 */

/* Python wrapper */
static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
  int __pyx_v_copy_shape;
  int __pyx_v_i;
  int __pyx_v_ndim;
  int __pyx_v_endian_detector;
  int __pyx_v_little_endian;
  int __pyx_v_t;
  char *__pyx_v_f;
  PyArray_Descr *__pyx_v_descr = 0;
  int __pyx_v_offset;
  int __pyx_v_hasfields;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  char *__pyx_t_7;
  __Pyx_RefNannySetupContext("__getbuffer__", 0);
  if (__pyx_v_info != NULL) {
    __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(__pyx_v_info->obj);
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":203
 *             # of flags
 * 
 *             if info == NULL: return             # <<<<<<<<<<<<<<
 * 
 *             cdef int copy_shape, i, ndim
 */
  __pyx_t_1 = ((__pyx_v_info == NULL) != 0);
  if (__pyx_t_1) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":206
 * 
 *             cdef int copy_shape, i, ndim
 *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)
 * 
 */
  __pyx_v_endian_detector = 1;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":207
 *             cdef int copy_shape, i, ndim
 *             cdef int endian_detector = 1
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
 * 
 *             ndim = PyArray_NDIM(self)
 */
  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":209
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)
 * 
 *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":211
 *             ndim = PyArray_NDIM(self)
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 copy_shape = 1
 *             else:
 */
  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":212
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 copy_shape = 1             # <<<<<<<<<<<<<<
 *             else:
 *                 copy_shape = 0
 */
    __pyx_v_copy_shape = 1;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":211
 *             ndim = PyArray_NDIM(self)
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 copy_shape = 1
 *             else:
 */
    goto __pyx_L4;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":214
 *                 copy_shape = 1
 *             else:
 *                 copy_shape = 0             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 */
  /*else*/ {
    __pyx_v_copy_shape = 0;
  }
  __pyx_L4:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L6_bool_binop_done;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":217
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 */
  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L6_bool_binop_done:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":218
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(1, 218, __pyx_L1_error)

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L9_bool_binop_done;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":221
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 * 
 */
  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L9_bool_binop_done:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":222
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
 * 
 *             info.buf = PyArray_DATA(self)
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 222, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(1, 222, __pyx_L1_error)

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":224
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 * 
 *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
 *             info.ndim = ndim
 *             if copy_shape:
 */
  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":225
 * 
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim             # <<<<<<<<<<<<<<
 *             if copy_shape:
 *                 # Allocate new buffer for strides and shape info.
 */
  __pyx_v_info->ndim = __pyx_v_ndim;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":226
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim
 *             if copy_shape:             # <<<<<<<<<<<<<<
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 */
  __pyx_t_1 = (__pyx_v_copy_shape != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":229
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)             # <<<<<<<<<<<<<<
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):
 */
    __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2)));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":230
 *                 # This is allocated as one block, strides first.
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)
 *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 */
    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":231
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):             # <<<<<<<<<<<<<<
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 */
    __pyx_t_4 = __pyx_v_ndim;
    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
      __pyx_v_i = __pyx_t_5;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":232
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 *             else:
 */
      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":233
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
 *             else:
 *                 info.strides = PyArray_STRIDES(self)
 */
      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":226
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim
 *             if copy_shape:             # <<<<<<<<<<<<<<
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 */
    goto __pyx_L11;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":235
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 *             else:
 *                 info.strides = PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL
 */
  /*else*/ {
    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":236
 *             else:
 *                 info.strides = PyArray_STRIDES(self)
 *                 info.shape = PyArray_DIMS(self)             # <<<<<<<<<<<<<<
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)
 */
    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
  }
  __pyx_L11:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":237
 *                 info.strides = PyArray_STRIDES(self)
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
 *             info.itemsize = PyArray_ITEMSIZE(self)
 *             info.readonly = not PyArray_ISWRITEABLE(self)
 */
  __pyx_v_info->suboffsets = NULL;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":238
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
 *             info.readonly = not PyArray_ISWRITEABLE(self)
 * 
 */
  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":239
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)
 *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
 * 
 *             cdef int t
 */
  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":242
 * 
 *             cdef int t
 *             cdef char* f = NULL             # <<<<<<<<<<<<<<
 *             cdef dtype descr = self.descr
 *             cdef int offset
 */
  __pyx_v_f = NULL;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":243
 *             cdef int t
 *             cdef char* f = NULL
 *             cdef dtype descr = self.descr             # <<<<<<<<<<<<<<
 *             cdef int offset
 * 
 */
  __pyx_t_3 = ((PyObject *)__pyx_v_self->descr);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
  __pyx_t_3 = 0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":246
 *             cdef int offset
 * 
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)             # <<<<<<<<<<<<<<
 * 
 *             if not hasfields and not copy_shape:
 */
  __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":248
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
 * 
 *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
 *                 # do not call releasebuffer
 *                 info.obj = None
 */
  __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L15_bool_binop_done;
  }
  __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L15_bool_binop_done:;
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":250
 *             if not hasfields and not copy_shape:
 *                 # do not call releasebuffer
 *                 info.obj = None             # <<<<<<<<<<<<<<
 *             else:
 *                 # need to call releasebuffer
 */
    __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(Py_None);
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj);
    __pyx_v_info->obj = Py_None;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":248
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
 * 
 *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
 *                 # do not call releasebuffer
 *                 info.obj = None
 */
    goto __pyx_L14;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":253
 *             else:
 *                 # need to call releasebuffer
 *                 info.obj = self             # <<<<<<<<<<<<<<
 * 
 *             if not hasfields:
 */
  /*else*/ {
    __Pyx_INCREF(((PyObject *)__pyx_v_self));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj);
    __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
  }
  __pyx_L14:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":255
 *                 info.obj = self
 * 
 *             if not hasfields:             # <<<<<<<<<<<<<<
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 */
  __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":256
 * 
 *             if not hasfields:
 *                 t = descr.type_num             # <<<<<<<<<<<<<<
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 */
    __pyx_t_4 = __pyx_v_descr->type_num;
    __pyx_v_t = __pyx_t_4;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
    if (!__pyx_t_2) {
      goto __pyx_L20_next_or;
    } else {
    }
    __pyx_t_2 = (__pyx_v_little_endian != 0);
    if (!__pyx_t_2) {
    } else {
      __pyx_t_1 = __pyx_t_2;
      goto __pyx_L19_bool_binop_done;
    }
    __pyx_L20_next_or:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":258
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"
 */
    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
    if (__pyx_t_2) {
    } else {
      __pyx_t_1 = __pyx_t_2;
      goto __pyx_L19_bool_binop_done;
    }
    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
    __pyx_t_1 = __pyx_t_2;
    __pyx_L19_bool_binop_done:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    if (__pyx_t_1) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":259
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 259, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(1, 259, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":260
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"
 */
    switch (__pyx_v_t) {
      case NPY_BYTE:
      __pyx_v_f = ((char *)"b");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":261
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"
 */
      case NPY_UBYTE:
      __pyx_v_f = ((char *)"B");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":262
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"
 */
      case NPY_SHORT:
      __pyx_v_f = ((char *)"h");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":263
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"
 */
      case NPY_USHORT:
      __pyx_v_f = ((char *)"H");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":264
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"
 */
      case NPY_INT:
      __pyx_v_f = ((char *)"i");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":265
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"
 */
      case NPY_UINT:
      __pyx_v_f = ((char *)"I");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":266
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"
 */
      case NPY_LONG:
      __pyx_v_f = ((char *)"l");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":267
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 */
      case NPY_ULONG:
      __pyx_v_f = ((char *)"L");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":268
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"
 */
      case NPY_LONGLONG:
      __pyx_v_f = ((char *)"q");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":269
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"
 */
      case NPY_ULONGLONG:
      __pyx_v_f = ((char *)"Q");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":270
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 */
      case NPY_FLOAT:
      __pyx_v_f = ((char *)"f");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":271
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 */
      case NPY_DOUBLE:
      __pyx_v_f = ((char *)"d");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":272
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 */
      case NPY_LONGDOUBLE:
      __pyx_v_f = ((char *)"g");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":273
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 */
      case NPY_CFLOAT:
      __pyx_v_f = ((char *)"Zf");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":274
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 *                 elif t == NPY_OBJECT:      f = "O"
 */
      case NPY_CDOUBLE:
      __pyx_v_f = ((char *)"Zd");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":275
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_OBJECT:      f = "O"
 *                 else:
 */
      case NPY_CLONGDOUBLE:
      __pyx_v_f = ((char *)"Zg");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":276
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 */
      case NPY_OBJECT:
      __pyx_v_f = ((char *)"O");
      break;
      default:

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":278
 *                 elif t == NPY_OBJECT:      f = "O"
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
 *                 info.format = f
 *                 return
 */
      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GIVEREF(__pyx_t_6);
      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
      __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __PYX_ERR(1, 278, __pyx_L1_error)
      break;
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":279
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *                 info.format = f             # <<<<<<<<<<<<<<
 *                 return
 *             else:
 */
    __pyx_v_info->format = __pyx_v_f;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":280
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *                 info.format = f
 *                 return             # <<<<<<<<<<<<<<
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 */
    __pyx_r = 0;
    goto __pyx_L0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":255
 *                 info.obj = self
 * 
 *             if not hasfields:             # <<<<<<<<<<<<<<
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":282
 *                 return
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0
 */
  /*else*/ {
    __pyx_v_info->format = ((char *)malloc(0xFF));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":283
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
 *                 offset = 0
 *                 f = _util_dtypestring(descr, info.format + 1,
 */
    (__pyx_v_info->format[0]) = '^';

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":284
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0             # <<<<<<<<<<<<<<
 *                 f = _util_dtypestring(descr, info.format + 1,
 *                                       info.format + _buffer_format_string_len,
 */
    __pyx_v_offset = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":285
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0
 *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
 *                                       info.format + _buffer_format_string_len,
 *                                       &offset)
 */
    __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(1, 285, __pyx_L1_error)
    __pyx_v_f = __pyx_t_7;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":288
 *                                       info.format + _buffer_format_string_len,
 *                                       &offset)
 *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 */
    (__pyx_v_f[0]) = '\x00';
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":197
 *         # experimental exception made for __getbuffer__ and __releasebuffer__
 *         # -- the details of this may change.
 *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
 *             # This implementation of getbuffer is geared towards Cython
 *             # requirements, and does not yet fullfill the PEP.
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) {
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL;
  }
  goto __pyx_L2;
  __pyx_L0:;
  if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) {
    __Pyx_GOTREF(Py_None);
    __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL;
  }
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":290
 *                 f[0] = c'\0' # Terminate format string
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 */

/* Python wrapper */
static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("__releasebuffer__", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":291
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":292
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)             # <<<<<<<<<<<<<<
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 stdlib.free(info.strides)
 */
    free(__pyx_v_info->format);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":291
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":293
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.strides)
 *                 # info.shape was stored after info.strides in the same block
 */
  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":294
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 stdlib.free(info.strides)             # <<<<<<<<<<<<<<
 *                 # info.shape was stored after info.strides in the same block
 * 
 */
    free(__pyx_v_info->strides);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":293
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.strides)
 *                 # info.shape was stored after info.strides in the same block
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":290
 *                 f[0] = c'\0' # Terminate format string
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 */

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":770
 * ctypedef npy_cdouble     complex_t
 * 
 * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(1, a)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":771
 * 
 * cdef inline object PyArray_MultiIterNew1(a):
 *     return PyArray_MultiIterNew(1, a)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":770
 * ctypedef npy_cdouble     complex_t
 * 
 * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(1, a)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":773
 *     return PyArray_MultiIterNew(1, a)
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":774
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):
 *     return PyArray_MultiIterNew(2, a, b)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 774, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":773
 *     return PyArray_MultiIterNew(1, a)
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":776
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":777
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):
 *     return PyArray_MultiIterNew(3, a, b,  c)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 777, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":776
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":779
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":780
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
 *     return PyArray_MultiIterNew(4, a, b, c,  d)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 780, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":779
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":782
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":783
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)             # <<<<<<<<<<<<<<
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 783, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":782
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":785
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
 *     # Recursive utility function used in __getbuffer__ to get format
 *     # string. The new location in the format string is returned.
 */

static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
  PyArray_Descr *__pyx_v_child = 0;
  int __pyx_v_endian_detector;
  int __pyx_v_little_endian;
  PyObject *__pyx_v_fields = 0;
  PyObject *__pyx_v_childname = NULL;
  PyObject *__pyx_v_new_offset = NULL;
  PyObject *__pyx_v_t = NULL;
  char *__pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  Py_ssize_t __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_t_6;
  int __pyx_t_7;
  long __pyx_t_8;
  char *__pyx_t_9;
  __Pyx_RefNannySetupContext("_util_dtypestring", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":790
 * 
 *     cdef dtype child
 *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
 *     cdef bint little_endian = ((&endian_detector)[0] != 0)
 *     cdef tuple fields
 */
  __pyx_v_endian_detector = 1;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":791
 *     cdef dtype child
 *     cdef int endian_detector = 1
 *     cdef bint little_endian = ((&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
 *     cdef tuple fields
 * 
 */
  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":794
 *     cdef tuple fields
 * 
 *     for childname in descr.names:             # <<<<<<<<<<<<<<
 *         fields = descr.fields[childname]
 *         child, new_offset = fields
 */
  if (unlikely(__pyx_v_descr->names == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(1, 794, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
  for (;;) {
    if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
    #if CYTHON_COMPILING_IN_CPYTHON
    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 794, __pyx_L1_error)
    #else
    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 794, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    #endif
    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":795
 * 
 *     for childname in descr.names:
 *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
 *         child, new_offset = fields
 * 
 */
    if (unlikely(__pyx_v_descr->fields == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(1, 795, __pyx_L1_error)
    }
    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 795, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 795, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
    __pyx_t_3 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":796
 *     for childname in descr.names:
 *         fields = descr.fields[childname]
 *         child, new_offset = fields             # <<<<<<<<<<<<<<
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 */
    if (likely(__pyx_v_fields != Py_None)) {
      PyObject* sequence = __pyx_v_fields;
      #if CYTHON_COMPILING_IN_CPYTHON
      Py_ssize_t size = Py_SIZE(sequence);
      #else
      Py_ssize_t size = PySequence_Size(sequence);
      #endif
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(1, 796, __pyx_L1_error)
      }
      #if CYTHON_COMPILING_IN_CPYTHON
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      #else
      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 796, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 796, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      #endif
    } else {
      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 796, __pyx_L1_error)
    }
    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 796, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
    __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
    __pyx_t_4 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":798
 *         child, new_offset = fields
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 */
    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 798, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":799
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 799, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(1, 799, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":798
 *         child, new_offset = fields
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
    if (!__pyx_t_7) {
      goto __pyx_L8_next_or;
    } else {
    }
    __pyx_t_7 = (__pyx_v_little_endian != 0);
    if (!__pyx_t_7) {
    } else {
      __pyx_t_6 = __pyx_t_7;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_L8_next_or:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":802
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
 *             raise ValueError(u"Non-native byte order not supported")
 *             # One could encode it in the format string and have Cython
 */
    __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
    if (__pyx_t_7) {
    } else {
      __pyx_t_6 = __pyx_t_7;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
    __pyx_t_6 = __pyx_t_7;
    __pyx_L7_bool_binop_done:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":803
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *             # One could encode it in the format string and have Cython
 *             # complain instead, BUT: < and > in format strings also imply
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 803, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(1, 803, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":813
 * 
 *         # Output padding bytes
 *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
 *             f[0] = 120 # "x"; pad byte
 *             f += 1
 */
    while (1) {
      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (!__pyx_t_6) break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":814
 *         # Output padding bytes
 *         while offset[0] < new_offset:
 *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
 *             f += 1
 *             offset[0] += 1
 */
      (__pyx_v_f[0]) = 0x78;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":815
 *         while offset[0] < new_offset:
 *             f[0] = 120 # "x"; pad byte
 *             f += 1             # <<<<<<<<<<<<<<
 *             offset[0] += 1
 * 
 */
      __pyx_v_f = (__pyx_v_f + 1);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":816
 *             f[0] = 120 # "x"; pad byte
 *             f += 1
 *             offset[0] += 1             # <<<<<<<<<<<<<<
 * 
 *         offset[0] += child.itemsize
 */
      __pyx_t_8 = 0;
      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":818
 *             offset[0] += 1
 * 
 *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
 * 
 *         if not PyDataType_HASFIELDS(child):
 */
    __pyx_t_8 = 0;
    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":820
 *         offset[0] += child.itemsize
 * 
 *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
 *             t = child.type_num
 *             if end - f < 5:
 */
    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":821
 * 
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num             # <<<<<<<<<<<<<<
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")
 */
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 821, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
      __pyx_t_4 = 0;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":822
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num
 *             if end - f < 5:             # <<<<<<<<<<<<<<
 *                 raise RuntimeError(u"Format string allocated too short.")
 * 
 */
      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
      if (__pyx_t_6) {

        /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":823
 *             t = child.type_num
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 */
        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 823, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __PYX_ERR(1, 823, __pyx_L1_error)

        /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":822
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num
 *             if end - f < 5:             # <<<<<<<<<<<<<<
 *                 raise RuntimeError(u"Format string allocated too short.")
 * 
 */
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":826
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 826, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 826, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 826, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 98;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":827
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 827, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 827, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 827, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 66;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":828
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 828, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 828, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 828, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x68;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":829
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 829, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 829, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 829, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 72;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":830
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 830, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 830, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 830, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x69;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":831
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 831, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 831, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 831, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 73;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":832
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 832, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 832, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 832, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x6C;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":833
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 833, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 833, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 833, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 76;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":834
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 834, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 834, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x71;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":835
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 835, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 835, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 81;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":836
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 836, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 836, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 836, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x66;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":837
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 837, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 837, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x64;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":838
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 838, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 838, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 838, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x67;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":839
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 839, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 839, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x66;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":840
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 840, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 840, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 840, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x64;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":841
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 *             else:
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 841, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 841, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x67;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":842
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 842, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 842, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 842, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 79;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":844
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
 *             f += 1
 *         else:
 */
      /*else*/ {
        __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_3);
        PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
        __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __PYX_ERR(1, 844, __pyx_L1_error)
      }
      __pyx_L15:;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":845
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *             f += 1             # <<<<<<<<<<<<<<
 *         else:
 *             # Cython ignores struct boundary information ("T{...}"),
 */
      __pyx_v_f = (__pyx_v_f + 1);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":820
 *         offset[0] += child.itemsize
 * 
 *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
 *             t = child.type_num
 *             if end - f < 5:
 */
      goto __pyx_L13;
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":849
 *             # Cython ignores struct boundary information ("T{...}"),
 *             # so don't output it
 *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
 *     return f
 * 
 */
    /*else*/ {
      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(1, 849, __pyx_L1_error)
      __pyx_v_f = __pyx_t_9;
    }
    __pyx_L13:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":794
 *     cdef tuple fields
 * 
 *     for childname in descr.names:             # <<<<<<<<<<<<<<
 *         fields = descr.fields[childname]
 *         child, new_offset = fields
 */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":850
 *             # so don't output it
 *             f = _util_dtypestring(child, f, end, offset)
 *     return f             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __pyx_r = __pyx_v_f;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":785
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
 *     # Recursive utility function used in __getbuffer__ to get format
 *     # string. The new location in the format string is returned.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_child);
  __Pyx_XDECREF(__pyx_v_fields);
  __Pyx_XDECREF(__pyx_v_childname);
  __Pyx_XDECREF(__pyx_v_new_offset);
  __Pyx_XDECREF(__pyx_v_t);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":966
 * 
 * 
 * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
 *      cdef PyObject* baseptr
 *      if base is None:
 */

static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
  PyObject *__pyx_v_baseptr;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  __Pyx_RefNannySetupContext("set_array_base", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":968
 * cdef inline void set_array_base(ndarray arr, object base):
 *      cdef PyObject* baseptr
 *      if base is None:             # <<<<<<<<<<<<<<
 *          baseptr = NULL
 *      else:
 */
  __pyx_t_1 = (__pyx_v_base == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":969
 *      cdef PyObject* baseptr
 *      if base is None:
 *          baseptr = NULL             # <<<<<<<<<<<<<<
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!
 */
    __pyx_v_baseptr = NULL;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":968
 * cdef inline void set_array_base(ndarray arr, object base):
 *      cdef PyObject* baseptr
 *      if base is None:             # <<<<<<<<<<<<<<
 *          baseptr = NULL
 *      else:
 */
    goto __pyx_L3;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":971
 *          baseptr = NULL
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!             # <<<<<<<<<<<<<<
 *          baseptr = base
 *      Py_XDECREF(arr.base)
 */
  /*else*/ {
    Py_INCREF(__pyx_v_base);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":972
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!
 *          baseptr = base             # <<<<<<<<<<<<<<
 *      Py_XDECREF(arr.base)
 *      arr.base = baseptr
 */
    __pyx_v_baseptr = ((PyObject *)__pyx_v_base);
  }
  __pyx_L3:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":973
 *          Py_INCREF(base) # important to do this before decref below!
 *          baseptr = base
 *      Py_XDECREF(arr.base)             # <<<<<<<<<<<<<<
 *      arr.base = baseptr
 * 
 */
  Py_XDECREF(__pyx_v_arr->base);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":974
 *          baseptr = base
 *      Py_XDECREF(arr.base)
 *      arr.base = baseptr             # <<<<<<<<<<<<<<
 * 
 * cdef inline object get_array_base(ndarray arr):
 */
  __pyx_v_arr->base = __pyx_v_baseptr;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":966
 * 
 * 
 * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
 *      cdef PyObject* baseptr
 *      if base is None:
 */

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":976
 *      arr.base = baseptr
 * 
 * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
 *     if arr.base is NULL:
 *         return None
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("get_array_base", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":977
 * 
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:             # <<<<<<<<<<<<<<
 *         return None
 *     else:
 */
  __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":978
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:
 *         return None             # <<<<<<<<<<<<<<
 *     else:
 *         return arr.base
 */
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_None);
    __pyx_r = Py_None;
    goto __pyx_L0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":977
 * 
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:             # <<<<<<<<<<<<<<
 *         return None
 *     else:
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":980
 *         return None
 *     else:
 *         return arr.base             # <<<<<<<<<<<<<<
 */
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(((PyObject *)__pyx_v_arr->base));
    __pyx_r = ((PyObject *)__pyx_v_arr->base);
    goto __pyx_L0;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":976
 *      arr.base = baseptr
 * 
 * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
 *     if arr.base is NULL:
 *         return None
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "_common.pxd":124
 *         tsize Num_Alms (int l, int m)
 * 
 * cdef inline Healpix_Map[double]* ndarray2map(np.ndarray[np.float64_t, ndim=1, mode='c'] array, Healpix_Ordering_Scheme scheme) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as a Healpix Map. """
 *     # To ensure that the output map is a view of the input array, the latter
 */

static CYTHON_INLINE Healpix_Map  *__pyx_f_7_common_ndarray2map(PyArrayObject *__pyx_v_array, enum Healpix_Ordering_Scheme __pyx_v_scheme) {
  arr  *__pyx_v_a;
  Healpix_Map  *__pyx_v_map;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_array;
  __Pyx_Buffer __pyx_pybuffer_array;
  Healpix_Map  *__pyx_r;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  __Pyx_RefNannySetupContext("ndarray2map", 0);
  __pyx_pybuffer_array.pybuffer.buf = NULL;
  __pyx_pybuffer_array.refcount = 0;
  __pyx_pybuffernd_array.data = NULL;
  __pyx_pybuffernd_array.rcbuffer = &__pyx_pybuffer_array;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_array.rcbuffer->pybuffer, (PyObject*)__pyx_v_array, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float64_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) __PYX_ERR(2, 124, __pyx_L1_error)
  }
  __pyx_pybuffernd_array.diminfo[0].strides = __pyx_pybuffernd_array.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_array.diminfo[0].shape = __pyx_pybuffernd_array.rcbuffer->pybuffer.shape[0];

  /* "_common.pxd":129
 *     # is forced to be contiguous, of correct type and dimensions (otherwise, an
 *     # exception is raised).
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)             # <<<<<<<<<<<<<<
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)
 */
  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_pybuffernd_array.diminfo[0].shape;
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_pybuffernd_array.diminfo[0].shape)) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(2, 129, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_array), __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 129, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_a = new arr ((&(*__Pyx_BufPtrCContig1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_array.rcbuffer->pybuffer.buf, __pyx_t_1, __pyx_pybuffernd_array.diminfo[0].strides))), __pyx_t_4);

  /* "_common.pxd":130
 *     # exception is raised).
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()             # <<<<<<<<<<<<<<
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated
 */
  __pyx_v_map = new Healpix_Map ();

  /* "_common.pxd":131
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)             # <<<<<<<<<<<<<<
 *     del a # a does not own its buffer, so it won't be deallocated
 *     return map
 */
  __pyx_v_map->Set((__pyx_v_a[0]), __pyx_v_scheme);

  /* "_common.pxd":132
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated             # <<<<<<<<<<<<<<
 *     return map
 * 
 */
  delete __pyx_v_a;

  /* "_common.pxd":133
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated
 *     return map             # <<<<<<<<<<<<<<
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:
 */
  __pyx_r = __pyx_v_map;
  goto __pyx_L0;

  /* "_common.pxd":124
 *         tsize Num_Alms (int l, int m)
 * 
 * cdef inline Healpix_Map[double]* ndarray2map(np.ndarray[np.float64_t, ndim=1, mode='c'] array, Healpix_Ordering_Scheme scheme) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as a Healpix Map. """
 *     # To ensure that the output map is a view of the input array, the latter
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("_common.ndarray2map", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "_common.pxd":135
 *     return map
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 */

static CYTHON_INLINE Alm >  *__pyx_f_7_common_ndarray2alm(PyArrayObject *__pyx_v_array, int __pyx_v_lmax, int __pyx_v_mmax) {
  arr >  *__pyx_v_a;
  Alm >  *__pyx_v_alm;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_array;
  __Pyx_Buffer __pyx_pybuffer_array;
  Alm >  *__pyx_r;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  __Pyx_RefNannySetupContext("ndarray2alm", 0);
  __pyx_pybuffer_array.pybuffer.buf = NULL;
  __pyx_pybuffer_array.refcount = 0;
  __pyx_pybuffernd_array.data = NULL;
  __pyx_pybuffernd_array.rcbuffer = &__pyx_pybuffer_array;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_array.rcbuffer->pybuffer, (PyObject*)__pyx_v_array, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) __PYX_ERR(2, 135, __pyx_L1_error)
  }
  __pyx_pybuffernd_array.diminfo[0].strides = __pyx_pybuffernd_array.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_array.diminfo[0].shape = __pyx_pybuffernd_array.rcbuffer->pybuffer.shape[0];

  /* "_common.pxd":137
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)             # <<<<<<<<<<<<<<
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)
 */
  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_pybuffernd_array.diminfo[0].shape;
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_pybuffernd_array.diminfo[0].shape)) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(2, 137, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_array), __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 137, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 137, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_a = new arr > (((xcomplex  *)(&(*__Pyx_BufPtrCContig1d(__pyx_t_double_complex *, __pyx_pybuffernd_array.rcbuffer->pybuffer.buf, __pyx_t_1, __pyx_pybuffernd_array.diminfo[0].strides)))), __pyx_t_4);

  /* "_common.pxd":138
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()             # <<<<<<<<<<<<<<
 *     alm.Set(a[0], lmax, mmax)
 *     del a
 */
  __pyx_v_alm = new Alm > ();

  /* "_common.pxd":139
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)             # <<<<<<<<<<<<<<
 *     del a
 *     return alm
 */
  __pyx_v_alm->Set((__pyx_v_a[0]), __pyx_v_lmax, __pyx_v_mmax);

  /* "_common.pxd":140
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)
 *     del a             # <<<<<<<<<<<<<<
 *     return alm
 */
  delete __pyx_v_a;

  /* "_common.pxd":141
 *     alm.Set(a[0], lmax, mmax)
 *     del a
 *     return alm             # <<<<<<<<<<<<<<
 */
  __pyx_r = __pyx_v_alm;
  goto __pyx_L0;

  /* "_common.pxd":135
 *     return map
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("_common.ndarray2alm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyMethodDef __pyx_methods[] = {
  {0, 0, 0, 0}
};

#if PY_MAJOR_VERSION >= 3
static struct PyModuleDef __pyx_moduledef = {
  #if PY_VERSION_HEX < 0x03020000
    { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
  #else
    PyModuleDef_HEAD_INIT,
  #endif
    "_query_disc",
    0, /* m_doc */
    -1, /* m_size */
    __pyx_methods /* m_methods */,
    NULL, /* m_reload */
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};
#endif

static __Pyx_StringTabEntry __pyx_string_tab[] = {
  {&__pyx_kp_s_Array_has_to_be_one_dimensional, __pyx_k_Array_has_to_be_one_dimensional, sizeof(__pyx_k_Array_has_to_be_one_dimensional), 0, 0, 1, 0},
  {&__pyx_kp_s_Array_of_pixels_has_to_be_intege, __pyx_k_Array_of_pixels_has_to_be_intege, sizeof(__pyx_k_Array_of_pixels_has_to_be_intege), 0, 0, 1, 0},
  {&__pyx_kp_s_Buffer_too_small_to_contain_retu, __pyx_k_Buffer_too_small_to_contain_retu, sizeof(__pyx_k_Buffer_too_small_to_contain_retu), 0, 0, 1, 0},
  {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
  {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
  {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
  {&__pyx_kp_s_Pixel_identifier_is_too_large, __pyx_k_Pixel_identifier_is_too_large, sizeof(__pyx_k_Pixel_identifier_is_too_large), 0, 0, 1, 0},
  {&__pyx_kp_u_Returns_an_array_containing_vect, __pyx_k_Returns_an_array_containing_vect, sizeof(__pyx_k_Returns_an_array_containing_vect), 0, 1, 0, 0},
  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
  {&__pyx_kp_s_Wrong_nside_value_must_be_a_powe, __pyx_k_Wrong_nside_value_must_be_a_powe, sizeof(__pyx_k_Wrong_nside_value_must_be_a_powe), 0, 0, 1, 0},
  {&__pyx_n_s_asarray, __pyx_k_asarray, sizeof(__pyx_k_asarray), 0, 0, 1, 1},
  {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1},
  {&__pyx_n_s_boundaries, __pyx_k_boundaries, sizeof(__pyx_k_boundaries), 0, 0, 1, 1},
  {&__pyx_kp_u_boundaries_line_236, __pyx_k_boundaries_line_236, sizeof(__pyx_k_boundaries_line_236), 0, 1, 0, 0},
  {&__pyx_n_s_boundaries_multiple, __pyx_k_boundaries_multiple, sizeof(__pyx_k_boundaries_multiple), 0, 0, 1, 1},
  {&__pyx_n_s_boundaries_single, __pyx_k_boundaries_single, sizeof(__pyx_k_boundaries_single), 0, 0, 1, 1},
  {&__pyx_n_s_bounds, __pyx_k_bounds, sizeof(__pyx_k_bounds), 0, 0, 1, 1},
  {&__pyx_n_s_buff, __pyx_k_buff, sizeof(__pyx_k_buff), 0, 0, 1, 1},
  {&__pyx_n_s_can_cast, __pyx_k_can_cast, sizeof(__pyx_k_can_cast), 0, 0, 1, 1},
  {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1},
  {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1},
  {&__pyx_n_s_fact, __pyx_k_fact, sizeof(__pyx_k_fact), 0, 0, 1, 1},
  {&__pyx_kp_s_fact_must_be_a_power_of_2_less_t, __pyx_k_fact_must_be_a_power_of_2_less_t, sizeof(__pyx_k_fact_must_be_a_power_of_2_less_t), 0, 0, 1, 0},
  {&__pyx_n_s_factor, __pyx_k_factor, sizeof(__pyx_k_factor), 0, 0, 1, 1},
  {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1},
  {&__pyx_n_s_hb, __pyx_k_hb, sizeof(__pyx_k_hb), 0, 0, 1, 1},
  {&__pyx_n_s_healpy__query_disc, __pyx_k_healpy__query_disc, sizeof(__pyx_k_healpy__query_disc), 0, 0, 1, 1},
  {&__pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_k_home_zonca_zonca_p_software_hea, sizeof(__pyx_k_home_zonca_zonca_p_software_hea), 0, 0, 1, 0},
  {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
  {&__pyx_n_s_inclusive, __pyx_k_inclusive, sizeof(__pyx_k_inclusive), 0, 0, 1, 1},
  {&__pyx_n_s_int, __pyx_k_int, sizeof(__pyx_k_int), 0, 0, 1, 1},
  {&__pyx_n_s_int64, __pyx_k_int64, sizeof(__pyx_k_int64), 0, 0, 1, 1},
  {&__pyx_n_s_isscalar, __pyx_k_isscalar, sizeof(__pyx_k_isscalar), 0, 0, 1, 1},
  {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1},
  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
  {&__pyx_n_s_maxnpix, __pyx_k_maxnpix, sizeof(__pyx_k_maxnpix), 0, 0, 1, 1},
  {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1},
  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
  {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1},
  {&__pyx_n_s_nest, __pyx_k_nest, sizeof(__pyx_k_nest), 0, 0, 1, 1},
  {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
  {&__pyx_n_s_npix, __pyx_k_npix, sizeof(__pyx_k_npix), 0, 0, 1, 1},
  {&__pyx_n_s_nside, __pyx_k_nside, sizeof(__pyx_k_nside), 0, 0, 1, 1},
  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
  {&__pyx_n_s_out, __pyx_k_out, sizeof(__pyx_k_out), 0, 0, 1, 1},
  {&__pyx_n_s_pix, __pyx_k_pix, sizeof(__pyx_k_pix), 0, 0, 1, 1},
  {&__pyx_n_s_pixset, __pyx_k_pixset, sizeof(__pyx_k_pixset), 0, 0, 1, 1},
  {&__pyx_n_s_ptg, __pyx_k_ptg, sizeof(__pyx_k_ptg), 0, 0, 1, 1},
  {&__pyx_n_s_query_disc, __pyx_k_query_disc, sizeof(__pyx_k_query_disc), 0, 0, 1, 1},
  {&__pyx_n_s_query_polygon, __pyx_k_query_polygon, sizeof(__pyx_k_query_polygon), 0, 0, 1, 1},
  {&__pyx_n_s_query_strip, __pyx_k_query_strip, sizeof(__pyx_k_query_strip), 0, 0, 1, 1},
  {&__pyx_n_s_radius, __pyx_k_radius, sizeof(__pyx_k_radius), 0, 0, 1, 1},
  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
  {&__pyx_n_s_scheme, __pyx_k_scheme, sizeof(__pyx_k_scheme), 0, 0, 1, 1},
  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
  {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1},
  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
  {&__pyx_n_s_theta1, __pyx_k_theta1, sizeof(__pyx_k_theta1), 0, 0, 1, 1},
  {&__pyx_n_s_theta2, __pyx_k_theta2, sizeof(__pyx_k_theta2), 0, 0, 1, 1},
  {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
  {&__pyx_n_s_v, __pyx_k_v, sizeof(__pyx_k_v), 0, 0, 1, 1},
  {&__pyx_n_s_vec, __pyx_k_vec, sizeof(__pyx_k_vec), 0, 0, 1, 1},
  {&__pyx_n_s_vert, __pyx_k_vert, sizeof(__pyx_k_vert), 0, 0, 1, 1},
  {&__pyx_n_s_vertices, __pyx_k_vertices, sizeof(__pyx_k_vertices), 0, 0, 1, 1},
  {0, 0, 0, 0, 0, 0, 0}
};
static int __Pyx_InitCachedBuiltins(void) {
  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 54, __pyx_L1_error)
  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 206, __pyx_L1_error)
  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 799, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

static int __Pyx_InitCachedConstants(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);

  /* "healpy/src/_query_disc.pyx":54
 *     # Check Nside value
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     cdef vec3 v = vec3(vec[0], vec[1], vec[2])
 *     cdef Healpix_Ordering_Scheme scheme
 */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Wrong_nside_value_must_be_a_powe); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 54, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

  /* "healpy/src/_query_disc.pyx":117
 *     # Check Nside value
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     # Create vector of vertices
 *     cdef vector[pointing] vert
 */
  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Wrong_nside_value_must_be_a_powe); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 117, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__2);
  __Pyx_GIVEREF(__pyx_tuple__2);

  /* "healpy/src/_query_disc.pyx":178
 *     # Check Nside value
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     # Create the Healpix_Base2 structure
 *     cdef Healpix_Ordering_Scheme scheme
 */
  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_Wrong_nside_value_must_be_a_powe); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__3);
  __Pyx_GIVEREF(__pyx_tuple__3);

  /* "healpy/src/_query_disc.pyx":202
 *     cdef vector[vec3] bounds
 *     if pix >= (12*nside*nside):
 *         raise ValueError('Pixel identifier is too large')             # <<<<<<<<<<<<<<
 *     hb.boundaries(pix, step, bounds)
 *     cdef size_t n = bounds.size()
 */
  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_Pixel_identifier_is_too_large); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__4);
  __Pyx_GIVEREF(__pyx_tuple__4);

  /* "healpy/src/_query_disc.pyx":227
 *     for j in range(npix):
 *         if pix[j] >= maxnpix:
 *             raise ValueError('Pixel identifier is too large')             # <<<<<<<<<<<<<<
 * 
 *         hb.boundaries(pix[j], step, bounds)
 */
  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_Pixel_identifier_is_too_large); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 227, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__5);
  __Pyx_GIVEREF(__pyx_tuple__5);

  /* "healpy/src/_query_disc.pyx":279
 * 
 *     if not isnsideok(nside):
 *         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')             # <<<<<<<<<<<<<<
 *     if np.isscalar(pix):
 *         if not np.can_cast(type(pix), np.int):
 */
  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Wrong_nside_value_must_be_a_powe); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 279, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__6);
  __Pyx_GIVEREF(__pyx_tuple__6);

  /* "healpy/src/_query_disc.pyx":282
 *     if np.isscalar(pix):
 *         if not np.can_cast(type(pix), np.int):
 *             raise ValueError('Array of pixels has to be integers')             # <<<<<<<<<<<<<<
 *         return _boundaries_single(nside, pix, step=step, nest=nest)
 *     else:
 */
  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_Array_of_pixels_has_to_be_intege); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 282, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__7);
  __Pyx_GIVEREF(__pyx_tuple__7);

  /* "healpy/src/_query_disc.pyx":288
 *         if np.can_cast(pix.dtype, np.int):
 *             if pix.ndim!=1:
 *                 raise ValueError('Array has to be one dimensional')             # <<<<<<<<<<<<<<
 *             return _boundaries_multiple(nside, pix.astype(np.int), step=step, nest=nest)
 *         else:
 */
  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Array_has_to_be_one_dimensional); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 288, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__8);
  __Pyx_GIVEREF(__pyx_tuple__8);

  /* "healpy/src/_query_disc.pyx":291
 *             return _boundaries_multiple(nside, pix.astype(np.int), step=step, nest=nest)
 *         else:
 *             raise ValueError('Array of pixels has to be integers')             # <<<<<<<<<<<<<<
 * 
 * # Try to implement pix2ang
 */
  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Array_of_pixels_has_to_be_intege); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 291, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__9);
  __Pyx_GIVEREF(__pyx_tuple__9);

  /* "healpy/src/_query_disc.pyx":333
 *     else :
 *        if n>=len(buff) :
 *            raise ValueError("Buffer too small to contain return value")             # <<<<<<<<<<<<<<
 *        ipix = buff[:n]
 * 
 */
  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Buffer_too_small_to_contain_retu); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 333, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__10);
  __Pyx_GIVEREF(__pyx_tuple__10);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":218
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 */
  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":222
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
 * 
 *             info.buf = PyArray_DATA(self)
 */
  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__12);
  __Pyx_GIVEREF(__pyx_tuple__12);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":259
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 */
  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 259, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__13);
  __Pyx_GIVEREF(__pyx_tuple__13);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":799
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 */
  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 799, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__14);
  __Pyx_GIVEREF(__pyx_tuple__14);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":803
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *             # One could encode it in the format string and have Cython
 *             # complain instead, BUT: < and > in format strings also imply
 */
  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 803, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__15);
  __Pyx_GIVEREF(__pyx_tuple__15);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":823
 *             t = child.type_num
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 */
  __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 823, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__16);
  __Pyx_GIVEREF(__pyx_tuple__16);

  /* "healpy/src/_query_disc.pyx":13
 * @cython.boundscheck(False)
 * @cython.wraparound(False)
 * def query_disc(nside, vec, radius, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """Returns pixels whose centers lie within the disk defined by
 *     *vec* and *radius* (in radians) (if *inclusive* is False), or which
 */
  __pyx_tuple__17 = PyTuple_Pack(13, __pyx_n_s_nside, __pyx_n_s_vec, __pyx_n_s_radius, __pyx_n_s_inclusive, __pyx_n_s_fact, __pyx_n_s_nest, __pyx_n_s_buff, __pyx_n_s_v, __pyx_n_s_scheme, __pyx_n_s_hb, __pyx_n_s_pixset, __pyx_n_s_factor, __pyx_n_s_ptg); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__17);
  __Pyx_GIVEREF(__pyx_tuple__17);
  __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(7, 0, 13, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_query_disc, 13, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 13, __pyx_L1_error)

  /* "healpy/src/_query_disc.pyx":78
 * 
 * 
 * def query_polygon(nside, vertices, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """ Returns the pixels whose centers lie within the convex polygon
 *     defined by the *vertices* array (if *inclusive* is False), or which
 */
  __pyx_tuple__19 = PyTuple_Pack(13, __pyx_n_s_nside, __pyx_n_s_vertices, __pyx_n_s_inclusive, __pyx_n_s_fact, __pyx_n_s_nest, __pyx_n_s_buff, __pyx_n_s_vert, __pyx_n_s_ptg, __pyx_n_s_v, __pyx_n_s_scheme, __pyx_n_s_hb, __pyx_n_s_pixset, __pyx_n_s_factor); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 78, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__19);
  __Pyx_GIVEREF(__pyx_tuple__19);
  __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(6, 0, 13, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_query_polygon, 78, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 78, __pyx_L1_error)

  /* "healpy/src/_query_disc.pyx":146
 *     return pixset_to_array(pixset, buff)
 * 
 * def query_strip(nside, theta1, theta2, inclusive = False, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """Returns pixels whose centers lie within the colatitude range
 *     defined by *theta1* and *theta2* (if inclusive is False), or which
 */
  __pyx_tuple__21 = PyTuple_Pack(9, __pyx_n_s_nside, __pyx_n_s_theta1, __pyx_n_s_theta2, __pyx_n_s_inclusive, __pyx_n_s_nest, __pyx_n_s_buff, __pyx_n_s_scheme, __pyx_n_s_hb, __pyx_n_s_pixset); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 146, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__21);
  __Pyx_GIVEREF(__pyx_tuple__21);
  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(6, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_query_strip, 146, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 146, __pyx_L1_error)

  /* "healpy/src/_query_disc.pyx":193
 * 
 * 
 * def _boundaries_single(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */
  __pyx_tuple__23 = PyTuple_Pack(10, __pyx_n_s_nside, __pyx_n_s_pix, __pyx_n_s_step, __pyx_n_s_nest, __pyx_n_s_scheme, __pyx_n_s_hb, __pyx_n_s_bounds, __pyx_n_s_n, __pyx_n_s_out, __pyx_n_s_i); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__23);
  __Pyx_GIVEREF(__pyx_tuple__23);
  __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_boundaries_single, 193, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 193, __pyx_L1_error)

  /* "healpy/src/_query_disc.pyx":212
 *     return out
 * 
 * def _boundaries_multiple(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */
  __pyx_tuple__25 = PyTuple_Pack(13, __pyx_n_s_nside, __pyx_n_s_pix, __pyx_n_s_step, __pyx_n_s_nest, __pyx_n_s_scheme, __pyx_n_s_hb, __pyx_n_s_npix, __pyx_n_s_n, __pyx_n_s_maxnpix, __pyx_n_s_out, __pyx_n_s_bounds, __pyx_n_s_j, __pyx_n_s_i); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__25);
  __Pyx_GIVEREF(__pyx_tuple__25);
  __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_boundaries_multiple, 212, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 212, __pyx_L1_error)

  /* "healpy/src/_query_disc.pyx":236
 *     return out
 * 
 * def boundaries(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     """Returns an array containing vectors to the boundary of
 *     the nominated pixel.
 */
  __pyx_tuple__27 = PyTuple_Pack(4, __pyx_n_s_nside, __pyx_n_s_pix, __pyx_n_s_step, __pyx_n_s_nest); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 236, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__27);
  __Pyx_GIVEREF(__pyx_tuple__27);
  __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_boundaries, 236, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 236, __pyx_L1_error)
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_InitGlobals(void) {
  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_12 = PyInt_FromLong(12); if (unlikely(!__pyx_int_12)) __PYX_ERR(0, 1, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

#if PY_MAJOR_VERSION < 3
PyMODINIT_FUNC init_query_disc(void); /*proto*/
PyMODINIT_FUNC init_query_disc(void)
#else
PyMODINIT_FUNC PyInit__query_disc(void); /*proto*/
PyMODINIT_FUNC PyInit__query_disc(void)
#endif
{
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannyDeclarations
  #if CYTHON_REFNANNY
  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
  if (!__Pyx_RefNanny) {
      PyErr_Clear();
      __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
      if (!__Pyx_RefNanny)
          Py_FatalError("failed to import 'refnanny' module");
  }
  #endif
  __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__query_disc(void)", 0);
  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
  #ifdef __Pyx_CyFunction_USED
  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_FusedFunction_USED
  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Coroutine_USED
  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Generator_USED
  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_StopAsyncIteration_USED
  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  /*--- Library function declarations ---*/
  /*--- Threads initialization code ---*/
  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
  #ifdef WITH_THREAD /* Python build with threading support? */
  PyEval_InitThreads();
  #endif
  #endif
  /*--- Module creation code ---*/
  #if PY_MAJOR_VERSION < 3
  __pyx_m = Py_InitModule4("_query_disc", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
  #else
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  #endif
  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
  Py_INCREF(__pyx_d);
  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
  #if CYTHON_COMPILING_IN_PYPY
  Py_INCREF(__pyx_b);
  #endif
  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  /*--- Initialize various global constants etc. ---*/
  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  if (__pyx_module_is_main_healpy___query_disc) {
    if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  }
  #if PY_MAJOR_VERSION >= 3
  {
    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
    if (!PyDict_GetItemString(modules, "healpy._query_disc")) {
      if (unlikely(PyDict_SetItemString(modules, "healpy._query_disc", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
    }
  }
  #endif
  /*--- Builtin init code ---*/
  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Constants init code ---*/
  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Global init code ---*/
  /*--- Variable export code ---*/
  /*--- Function export code ---*/
  /*--- Type init code ---*/
  /*--- Type import code ---*/
  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", 
  #if CYTHON_COMPILING_IN_PYPY
  sizeof(PyTypeObject),
  #else
  sizeof(PyHeapTypeObject),
  #endif
  0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(3, 9, __pyx_L1_error)
  __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(1, 155, __pyx_L1_error)
  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(1, 168, __pyx_L1_error)
  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(1, 172, __pyx_L1_error)
  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(1, 181, __pyx_L1_error)
  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(1, 861, __pyx_L1_error)
  /*--- Variable import code ---*/
  /*--- Function import code ---*/
  /*--- Execution code ---*/
  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif

  /* "healpy/src/_query_disc.pyx":3
 * # Wrapper around the query_disc method of Healpix_base class
 * 
 * import numpy as np             # <<<<<<<<<<<<<<
 * cimport numpy as np
 * from libcpp cimport bool
 */
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_query_disc.pyx":13
 * @cython.boundscheck(False)
 * @cython.wraparound(False)
 * def query_disc(nside, vec, radius, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """Returns pixels whose centers lie within the disk defined by
 *     *vec* and *radius* (in radians) (if *inclusive* is False), or which
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_11_query_disc_1query_disc, NULL, __pyx_n_s_healpy__query_disc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_query_disc, __pyx_t_1) < 0) __PYX_ERR(0, 13, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_query_disc.pyx":78
 * 
 * 
 * def query_polygon(nside, vertices, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """ Returns the pixels whose centers lie within the convex polygon
 *     defined by the *vertices* array (if *inclusive* is False), or which
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_11_query_disc_3query_polygon, NULL, __pyx_n_s_healpy__query_disc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_query_polygon, __pyx_t_1) < 0) __PYX_ERR(0, 78, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_query_disc.pyx":146
 *     return pixset_to_array(pixset, buff)
 * 
 * def query_strip(nside, theta1, theta2, inclusive = False, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):             # <<<<<<<<<<<<<<
 *     """Returns pixels whose centers lie within the colatitude range
 *     defined by *theta1* and *theta2* (if inclusive is False), or which
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_11_query_disc_5query_strip, NULL, __pyx_n_s_healpy__query_disc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_query_strip, __pyx_t_1) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_query_disc.pyx":193
 * 
 * 
 * def _boundaries_single(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_11_query_disc_7_boundaries_single, NULL, __pyx_n_s_healpy__query_disc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_boundaries_single, __pyx_t_1) < 0) __PYX_ERR(0, 193, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_query_disc.pyx":212
 *     return out
 * 
 * def _boundaries_multiple(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     cdef Healpix_Ordering_Scheme scheme
 *     if nest:
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_11_query_disc_9_boundaries_multiple, NULL, __pyx_n_s_healpy__query_disc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_boundaries_multiple, __pyx_t_1) < 0) __PYX_ERR(0, 212, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_query_disc.pyx":236
 *     return out
 * 
 * def boundaries(nside, pix, step=1, nest=False):             # <<<<<<<<<<<<<<
 *     """Returns an array containing vectors to the boundary of
 *     the nominated pixel.
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_11_query_disc_11boundaries, NULL, __pyx_n_s_healpy__query_disc); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_boundaries, __pyx_t_1) < 0) __PYX_ERR(0, 236, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_query_disc.pyx":1
 * # Wrapper around the query_disc method of Healpix_base class             # <<<<<<<<<<<<<<
 * 
 * import numpy as np
 */
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_kp_u_boundaries_line_236, __pyx_kp_u_Returns_an_array_containing_vect) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "_common.pxd":135
 *     return map
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 */

  /*--- Wrapped vars code ---*/

  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  if (__pyx_m) {
    if (__pyx_d) {
      __Pyx_AddTraceback("init healpy._query_disc", __pyx_clineno, __pyx_lineno, __pyx_filename);
    }
    Py_DECREF(__pyx_m); __pyx_m = 0;
  } else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_ImportError, "init healpy._query_disc");
  }
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #if PY_MAJOR_VERSION < 3
  return;
  #else
  return __pyx_m;
  #endif
}

/* --- Runtime support code --- */
/* Refnanny */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
    PyObject *m = NULL, *p = NULL;
    void *r = NULL;
    m = PyImport_ImportModule((char *)modname);
    if (!m) goto end;
    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
    if (!p) goto end;
    r = PyLong_AsVoidPtr(p);
end:
    Py_XDECREF(p);
    Py_XDECREF(m);
    return (__Pyx_RefNannyAPIStruct *)r;
}
#endif

/* GetBuiltinName */
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
    if (unlikely(!result)) {
        PyErr_Format(PyExc_NameError,
#if PY_MAJOR_VERSION >= 3
            "name '%U' is not defined", name);
#else
            "name '%.200s' is not defined", PyString_AS_STRING(name));
#endif
    }
    return result;
}

/* RaiseArgTupleInvalid */
static void __Pyx_RaiseArgtupleInvalid(
    const char* func_name,
    int exact,
    Py_ssize_t num_min,
    Py_ssize_t num_max,
    Py_ssize_t num_found)
{
    Py_ssize_t num_expected;
    const char *more_or_less;
    if (num_found < num_min) {
        num_expected = num_min;
        more_or_less = "at least";
    } else {
        num_expected = num_max;
        more_or_less = "at most";
    }
    if (exact) {
        more_or_less = "exactly";
    }
    PyErr_Format(PyExc_TypeError,
                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 func_name, more_or_less, num_expected,
                 (num_expected == 1) ? "" : "s", num_found);
}

/* RaiseDoubleKeywords */
static void __Pyx_RaiseDoubleKeywordsError(
    const char* func_name,
    PyObject* kw_name)
{
    PyErr_Format(PyExc_TypeError,
        #if PY_MAJOR_VERSION >= 3
        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
        #else
        "%s() got multiple values for keyword argument '%s'", func_name,
        PyString_AsString(kw_name));
        #endif
}

/* ParseKeywords */
static int __Pyx_ParseOptionalKeywords(
    PyObject *kwds,
    PyObject **argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    const char* function_name)
{
    PyObject *key = 0, *value = 0;
    Py_ssize_t pos = 0;
    PyObject*** name;
    PyObject*** first_kw_arg = argnames + num_pos_args;
    while (PyDict_Next(kwds, &pos, &key, &value)) {
        name = first_kw_arg;
        while (*name && (**name != key)) name++;
        if (*name) {
            values[name-argnames] = value;
            continue;
        }
        name = first_kw_arg;
        #if PY_MAJOR_VERSION < 3
        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
            while (*name) {
                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                        && _PyString_Eq(**name, key)) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    if ((**argname == key) || (
                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
                             && _PyString_Eq(**argname, key))) {
                        goto arg_passed_twice;
                    }
                    argname++;
                }
            }
        } else
        #endif
        if (likely(PyUnicode_Check(key))) {
            while (*name) {
                int cmp = (**name == key) ? 0 :
                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
                #endif
                    PyUnicode_Compare(**name, key);
                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                if (cmp == 0) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    int cmp = (**argname == key) ? 0 :
                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
                    #endif
                        PyUnicode_Compare(**argname, key);
                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                    if (cmp == 0) goto arg_passed_twice;
                    argname++;
                }
            }
        } else
            goto invalid_keyword_type;
        if (kwds2) {
            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
        } else {
            goto invalid_keyword;
        }
    }
    return 0;
arg_passed_twice:
    __Pyx_RaiseDoubleKeywordsError(function_name, key);
    goto bad;
invalid_keyword_type:
    PyErr_Format(PyExc_TypeError,
        "%.200s() keywords must be strings", function_name);
    goto bad;
invalid_keyword:
    PyErr_Format(PyExc_TypeError,
    #if PY_MAJOR_VERSION < 3
        "%.200s() got an unexpected keyword argument '%.200s'",
        function_name, PyString_AsString(key));
    #else
        "%s() got an unexpected keyword argument '%U'",
        function_name, key);
    #endif
bad:
    return -1;
}

/* ArgTypeTest */
static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
    PyErr_Format(PyExc_TypeError,
        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
        name, type->tp_name, Py_TYPE(obj)->tp_name);
}
static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
    const char *name, int exact)
{
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (none_allowed && obj == Py_None) return 1;
    else if (exact) {
        if (likely(Py_TYPE(obj) == type)) return 1;
        #if PY_MAJOR_VERSION == 2
        else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
        #endif
    }
    else {
        if (likely(PyObject_TypeCheck(obj, type))) return 1;
    }
    __Pyx_RaiseArgumentTypeInvalid(name, obj, type);
    return 0;
}

/* BufferFormatCheck */
static CYTHON_INLINE int __Pyx_IsLittleEndian(void) {
  unsigned int n = 1;
  return *(unsigned char*)(&n) != 0;
}
static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
                              __Pyx_BufFmt_StackElem* stack,
                              __Pyx_TypeInfo* type) {
  stack[0].field = &ctx->root;
  stack[0].parent_offset = 0;
  ctx->root.type = type;
  ctx->root.name = "buffer dtype";
  ctx->root.offset = 0;
  ctx->head = stack;
  ctx->head->field = &ctx->root;
  ctx->fmt_offset = 0;
  ctx->head->parent_offset = 0;
  ctx->new_packmode = '@';
  ctx->enc_packmode = '@';
  ctx->new_count = 1;
  ctx->enc_count = 0;
  ctx->enc_type = 0;
  ctx->is_complex = 0;
  ctx->is_valid_array = 0;
  ctx->struct_alignment = 0;
  while (type->typegroup == 'S') {
    ++ctx->head;
    ctx->head->field = type->fields;
    ctx->head->parent_offset = 0;
    type = type->fields->type;
  }
}
static int __Pyx_BufFmt_ParseNumber(const char** ts) {
    int count;
    const char* t = *ts;
    if (*t < '0' || *t > '9') {
      return -1;
    } else {
        count = *t++ - '0';
        while (*t >= '0' && *t < '9') {
            count *= 10;
            count += *t++ - '0';
        }
    }
    *ts = t;
    return count;
}
static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
    int number = __Pyx_BufFmt_ParseNumber(ts);
    if (number == -1)
        PyErr_Format(PyExc_ValueError,\
                     "Does not understand character buffer dtype format string ('%c')", **ts);
    return number;
}
static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
  PyErr_Format(PyExc_ValueError,
               "Unexpected format string character: '%c'", ch);
}
static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
  switch (ch) {
    case 'c': return "'char'";
    case 'b': return "'signed char'";
    case 'B': return "'unsigned char'";
    case 'h': return "'short'";
    case 'H': return "'unsigned short'";
    case 'i': return "'int'";
    case 'I': return "'unsigned int'";
    case 'l': return "'long'";
    case 'L': return "'unsigned long'";
    case 'q': return "'long long'";
    case 'Q': return "'unsigned long long'";
    case 'f': return (is_complex ? "'complex float'" : "'float'");
    case 'd': return (is_complex ? "'complex double'" : "'double'");
    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
    case 'T': return "a struct";
    case 'O': return "Python object";
    case 'P': return "a pointer";
    case 's': case 'p': return "a string";
    case 0: return "end";
    default: return "unparseable format string";
  }
}
static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return 2;
    case 'i': case 'I': case 'l': case 'L': return 4;
    case 'q': case 'Q': return 8;
    case 'f': return (is_complex ? 8 : 4);
    case 'd': return (is_complex ? 16 : 8);
    case 'g': {
      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
      return 0;
    }
    case 'O': case 'P': return sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
  switch (ch) {
    case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(short);
    case 'i': case 'I': return sizeof(int);
    case 'l': case 'L': return sizeof(long);
    #ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
    #endif
    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
    case 'O': case 'P': return sizeof(void*);
    default: {
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
  }
}
typedef struct { char c; short x; } __Pyx_st_short;
typedef struct { char c; int x; } __Pyx_st_int;
typedef struct { char c; long x; } __Pyx_st_long;
typedef struct { char c; float x; } __Pyx_st_float;
typedef struct { char c; double x; } __Pyx_st_double;
typedef struct { char c; long double x; } __Pyx_st_longdouble;
typedef struct { char c; void *x; } __Pyx_st_void_p;
#ifdef HAVE_LONG_LONG
typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
#endif
static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
#ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
#endif
    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
/* These are for computing the padding at the end of the struct to align
   on the first member of the struct. This will probably the same as above,
   but we don't have any guarantees.
 */
typedef struct { short x; char c; } __Pyx_pad_short;
typedef struct { int x; char c; } __Pyx_pad_int;
typedef struct { long x; char c; } __Pyx_pad_long;
typedef struct { float x; char c; } __Pyx_pad_float;
typedef struct { double x; char c; } __Pyx_pad_double;
typedef struct { long double x; char c; } __Pyx_pad_longdouble;
typedef struct { void *x; char c; } __Pyx_pad_void_p;
#ifdef HAVE_LONG_LONG
typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
#endif
static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
#ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
#endif
    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
  switch (ch) {
    case 'c':
        return 'H';
    case 'b': case 'h': case 'i':
    case 'l': case 'q': case 's': case 'p':
        return 'I';
    case 'B': case 'H': case 'I': case 'L': case 'Q':
        return 'U';
    case 'f': case 'd': case 'g':
        return (is_complex ? 'C' : 'R');
    case 'O':
        return 'O';
    case 'P':
        return 'P';
    default: {
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
  }
}
static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
    const char* expected;
    const char* quote;
    if (ctx->head == NULL) {
      expected = "end";
      quote = "";
    } else {
      expected = ctx->head->field->type->name;
      quote = "'";
    }
    PyErr_Format(PyExc_ValueError,
                 "Buffer dtype mismatch, expected %s%s%s but got %s",
                 quote, expected, quote,
                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
  } else {
    __Pyx_StructField* field = ctx->head->field;
    __Pyx_StructField* parent = (ctx->head - 1)->field;
    PyErr_Format(PyExc_ValueError,
                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
                 parent->type->name, field->name);
  }
}
static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
  char group;
  size_t size, offset, arraysize = 1;
  if (ctx->enc_type == 0) return 0;
  if (ctx->head->field->type->arraysize[0]) {
    int i, ndim = 0;
    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
        ndim = 1;
        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
            PyErr_Format(PyExc_ValueError,
                         "Expected a dimension of size %zu, got %zu",
                         ctx->head->field->type->arraysize[0], ctx->enc_count);
            return -1;
        }
    }
    if (!ctx->is_valid_array) {
      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
                   ctx->head->field->type->ndim, ndim);
      return -1;
    }
    for (i = 0; i < ctx->head->field->type->ndim; i++) {
      arraysize *= ctx->head->field->type->arraysize[i];
    }
    ctx->is_valid_array = 0;
    ctx->enc_count = 1;
  }
  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
  do {
    __Pyx_StructField* field = ctx->head->field;
    __Pyx_TypeInfo* type = field->type;
    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
    } else {
      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
    }
    if (ctx->enc_packmode == '@') {
      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
      size_t align_mod_offset;
      if (align_at == 0) return -1;
      align_mod_offset = ctx->fmt_offset % align_at;
      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
      if (ctx->struct_alignment == 0)
          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
                                                                 ctx->is_complex);
    }
    if (type->size != size || type->typegroup != group) {
      if (type->typegroup == 'C' && type->fields != NULL) {
        size_t parent_offset = ctx->head->parent_offset + field->offset;
        ++ctx->head;
        ctx->head->field = type->fields;
        ctx->head->parent_offset = parent_offset;
        continue;
      }
      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
      } else {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return -1;
      }
    }
    offset = ctx->head->parent_offset + field->offset;
    if (ctx->fmt_offset != offset) {
      PyErr_Format(PyExc_ValueError,
                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
      return -1;
    }
    ctx->fmt_offset += size;
    if (arraysize)
      ctx->fmt_offset += (arraysize - 1) * size;
    --ctx->enc_count;
    while (1) {
      if (field == &ctx->root) {
        ctx->head = NULL;
        if (ctx->enc_count != 0) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return -1;
        }
        break;
      }
      ctx->head->field = ++field;
      if (field->type == NULL) {
        --ctx->head;
        field = ctx->head->field;
        continue;
      } else if (field->type->typegroup == 'S') {
        size_t parent_offset = ctx->head->parent_offset + field->offset;
        if (field->type->fields->type == NULL) continue;
        field = field->type->fields;
        ++ctx->head;
        ctx->head->field = field;
        ctx->head->parent_offset = parent_offset;
        break;
      } else {
        break;
      }
    }
  } while (ctx->enc_count);
  ctx->enc_type = 0;
  ctx->is_complex = 0;
  return 0;
}
static CYTHON_INLINE PyObject *
__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
{
    const char *ts = *tsp;
    int i = 0, number;
    int ndim = ctx->head->field->type->ndim;
;
    ++ts;
    if (ctx->new_count != 1) {
        PyErr_SetString(PyExc_ValueError,
                        "Cannot handle repeated arrays in format string");
        return NULL;
    }
    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
    while (*ts && *ts != ')') {
        switch (*ts) {
            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
            default:  break;
        }
        number = __Pyx_BufFmt_ExpectNumber(&ts);
        if (number == -1) return NULL;
        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
            return PyErr_Format(PyExc_ValueError,
                        "Expected a dimension of size %zu, got %d",
                        ctx->head->field->type->arraysize[i], number);
        if (*ts != ',' && *ts != ')')
            return PyErr_Format(PyExc_ValueError,
                                "Expected a comma in format string, got '%c'", *ts);
        if (*ts == ',') ts++;
        i++;
    }
    if (i != ndim)
        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
                            ctx->head->field->type->ndim, i);
    if (!*ts) {
        PyErr_SetString(PyExc_ValueError,
                        "Unexpected end of format string, expected ')'");
        return NULL;
    }
    ctx->is_valid_array = 1;
    ctx->new_count = 1;
    *tsp = ++ts;
    return Py_None;
}
static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
  int got_Z = 0;
  while (1) {
    switch(*ts) {
      case 0:
        if (ctx->enc_type != 0 && ctx->head == NULL) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return NULL;
        }
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        if (ctx->head != NULL) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return NULL;
        }
        return ts;
      case ' ':
      case '\r':
      case '\n':
        ++ts;
        break;
      case '<':
        if (!__Pyx_IsLittleEndian()) {
          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
          return NULL;
        }
        ctx->new_packmode = '=';
        ++ts;
        break;
      case '>':
      case '!':
        if (__Pyx_IsLittleEndian()) {
          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
          return NULL;
        }
        ctx->new_packmode = '=';
        ++ts;
        break;
      case '=':
      case '@':
      case '^':
        ctx->new_packmode = *ts++;
        break;
      case 'T':
        {
          const char* ts_after_sub;
          size_t i, struct_count = ctx->new_count;
          size_t struct_alignment = ctx->struct_alignment;
          ctx->new_count = 1;
          ++ts;
          if (*ts != '{') {
            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
            return NULL;
          }
          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
          ctx->enc_type = 0;
          ctx->enc_count = 0;
          ctx->struct_alignment = 0;
          ++ts;
          ts_after_sub = ts;
          for (i = 0; i != struct_count; ++i) {
            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
            if (!ts_after_sub) return NULL;
          }
          ts = ts_after_sub;
          if (struct_alignment) ctx->struct_alignment = struct_alignment;
        }
        break;
      case '}':
        {
          size_t alignment = ctx->struct_alignment;
          ++ts;
          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
          ctx->enc_type = 0;
          if (alignment && ctx->fmt_offset % alignment) {
            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
          }
        }
        return ts;
      case 'x':
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        ctx->fmt_offset += ctx->new_count;
        ctx->new_count = 1;
        ctx->enc_count = 0;
        ctx->enc_type = 0;
        ctx->enc_packmode = ctx->new_packmode;
        ++ts;
        break;
      case 'Z':
        got_Z = 1;
        ++ts;
        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
          return NULL;
        }
      case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
      case 'l': case 'L': case 'q': case 'Q':
      case 'f': case 'd': case 'g':
      case 'O': case 'p':
        if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&
            ctx->enc_packmode == ctx->new_packmode) {
          ctx->enc_count += ctx->new_count;
          ctx->new_count = 1;
          got_Z = 0;
          ++ts;
          break;
        }
      case 's':
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        ctx->enc_count = ctx->new_count;
        ctx->enc_packmode = ctx->new_packmode;
        ctx->enc_type = *ts;
        ctx->is_complex = got_Z;
        ++ts;
        ctx->new_count = 1;
        got_Z = 0;
        break;
      case ':':
        ++ts;
        while(*ts != ':') ++ts;
        ++ts;
        break;
      case '(':
        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
        break;
      default:
        {
          int number = __Pyx_BufFmt_ExpectNumber(&ts);
          if (number == -1) return NULL;
          ctx->new_count = (size_t)number;
        }
    }
  }
}
static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
  buf->buf = NULL;
  buf->obj = NULL;
  buf->strides = __Pyx_zeros;
  buf->shape = __Pyx_zeros;
  buf->suboffsets = __Pyx_minusones;
}
static CYTHON_INLINE int __Pyx_GetBufferAndValidate(
        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
{
  if (obj == Py_None || obj == NULL) {
    __Pyx_ZeroBuffer(buf);
    return 0;
  }
  buf->buf = NULL;
  if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail;
  if (buf->ndim != nd) {
    PyErr_Format(PyExc_ValueError,
                 "Buffer has wrong number of dimensions (expected %d, got %d)",
                 nd, buf->ndim);
    goto fail;
  }
  if (!cast) {
    __Pyx_BufFmt_Context ctx;
    __Pyx_BufFmt_Init(&ctx, stack, dtype);
    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
  }
  if ((unsigned)buf->itemsize != dtype->size) {
    PyErr_Format(PyExc_ValueError,
      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
    goto fail;
  }
  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
  return 0;
fail:;
  __Pyx_ZeroBuffer(buf);
  return -1;
}
static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
  if (info->buf == NULL) return;
  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
  __Pyx_ReleaseBuffer(info);
}

/* PyObjectCall */
  #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *result;
    ternaryfunc call = func->ob_type->tp_call;
    if (unlikely(!call))
        return PyObject_Call(func, arg, kw);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = (*call)(func, arg, kw);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyErrFetchRestore */
  #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    tmp_type = tstate->curexc_type;
    tmp_value = tstate->curexc_value;
    tmp_tb = tstate->curexc_traceback;
    tstate->curexc_type = type;
    tstate->curexc_value = value;
    tstate->curexc_traceback = tb;
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
}
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
    *type = tstate->curexc_type;
    *value = tstate->curexc_value;
    *tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
}
#endif

/* RaiseException */
  #if PY_MAJOR_VERSION < 3
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
                        CYTHON_UNUSED PyObject *cause) {
    __Pyx_PyThreadState_declare
    Py_XINCREF(type);
    if (!value || value == Py_None)
        value = NULL;
    else
        Py_INCREF(value);
    if (!tb || tb == Py_None)
        tb = NULL;
    else {
        Py_INCREF(tb);
        if (!PyTraceBack_Check(tb)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: arg 3 must be a traceback or None");
            goto raise_error;
        }
    }
    if (PyType_Check(type)) {
#if CYTHON_COMPILING_IN_PYPY
        if (!value) {
            Py_INCREF(Py_None);
            value = Py_None;
        }
#endif
        PyErr_NormalizeException(&type, &value, &tb);
    } else {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto raise_error;
        }
        value = type;
        type = (PyObject*) Py_TYPE(type);
        Py_INCREF(type);
        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: exception class must be a subclass of BaseException");
            goto raise_error;
        }
    }
    __Pyx_PyThreadState_assign
    __Pyx_ErrRestore(type, value, tb);
    return;
raise_error:
    Py_XDECREF(value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
    return;
}
#else
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
    PyObject* owned_instance = NULL;
    if (tb == Py_None) {
        tb = 0;
    } else if (tb && !PyTraceBack_Check(tb)) {
        PyErr_SetString(PyExc_TypeError,
            "raise: arg 3 must be a traceback or None");
        goto bad;
    }
    if (value == Py_None)
        value = 0;
    if (PyExceptionInstance_Check(type)) {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto bad;
        }
        value = type;
        type = (PyObject*) Py_TYPE(value);
    } else if (PyExceptionClass_Check(type)) {
        PyObject *instance_class = NULL;
        if (value && PyExceptionInstance_Check(value)) {
            instance_class = (PyObject*) Py_TYPE(value);
            if (instance_class != type) {
                int is_subclass = PyObject_IsSubclass(instance_class, type);
                if (!is_subclass) {
                    instance_class = NULL;
                } else if (unlikely(is_subclass == -1)) {
                    goto bad;
                } else {
                    type = instance_class;
                }
            }
        }
        if (!instance_class) {
            PyObject *args;
            if (!value)
                args = PyTuple_New(0);
            else if (PyTuple_Check(value)) {
                Py_INCREF(value);
                args = value;
            } else
                args = PyTuple_Pack(1, value);
            if (!args)
                goto bad;
            owned_instance = PyObject_Call(type, args, NULL);
            Py_DECREF(args);
            if (!owned_instance)
                goto bad;
            value = owned_instance;
            if (!PyExceptionInstance_Check(value)) {
                PyErr_Format(PyExc_TypeError,
                             "calling %R should have returned an instance of "
                             "BaseException, not %R",
                             type, Py_TYPE(value));
                goto bad;
            }
        }
    } else {
        PyErr_SetString(PyExc_TypeError,
            "raise: exception class must be a subclass of BaseException");
        goto bad;
    }
#if PY_VERSION_HEX >= 0x03030000
    if (cause) {
#else
    if (cause && cause != Py_None) {
#endif
        PyObject *fixed_cause;
        if (cause == Py_None) {
            fixed_cause = NULL;
        } else if (PyExceptionClass_Check(cause)) {
            fixed_cause = PyObject_CallObject(cause, NULL);
            if (fixed_cause == NULL)
                goto bad;
        } else if (PyExceptionInstance_Check(cause)) {
            fixed_cause = cause;
            Py_INCREF(fixed_cause);
        } else {
            PyErr_SetString(PyExc_TypeError,
                            "exception causes must derive from "
                            "BaseException");
            goto bad;
        }
        PyException_SetCause(value, fixed_cause);
    }
    PyErr_SetObject(type, value);
    if (tb) {
#if CYTHON_COMPILING_IN_PYPY
        PyObject *tmp_type, *tmp_value, *tmp_tb;
        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
        Py_INCREF(tb);
        PyErr_Restore(tmp_type, tmp_value, tb);
        Py_XDECREF(tmp_tb);
#else
        PyThreadState *tstate = PyThreadState_GET();
        PyObject* tmp_tb = tstate->curexc_traceback;
        if (tb != tmp_tb) {
            Py_INCREF(tb);
            tstate->curexc_traceback = tb;
            Py_XDECREF(tmp_tb);
        }
#endif
    }
bad:
    Py_XDECREF(owned_instance);
    return;
}
#endif

/* GetItemInt */
    static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
    PyObject *r;
    if (!j) return NULL;
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_COMPILING_IN_CPYTHON
    if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o);
    if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) {
        PyObject *r = PyList_GET_ITEM(o, i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_COMPILING_IN_CPYTHON
    if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o);
    if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) {
        PyObject *r = PyTuple_GET_ITEM(o, i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
                                                     CYTHON_NCP_UNUSED int wraparound,
                                                     CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_COMPILING_IN_CPYTHON
    if (is_list || PyList_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
        if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) {
            PyObject *r = PyList_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    }
    else if (PyTuple_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
        if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) {
            PyObject *r = PyTuple_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    } else {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_item)) {
            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
                Py_ssize_t l = m->sq_length(o);
                if (likely(l >= 0)) {
                    i += l;
                } else {
                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                        return NULL;
                    PyErr_Clear();
                }
            }
            return m->sq_item(o, i);
        }
    }
#else
    if (is_list || PySequence_Check(o)) {
        return PySequence_GetItem(o, i);
    }
#endif
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
}

/* GetModuleGlobalName */
    static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
    PyObject *result;
#if CYTHON_COMPILING_IN_CPYTHON
    result = PyDict_GetItem(__pyx_d, name);
    if (likely(result)) {
        Py_INCREF(result);
    } else {
#else
    result = PyObject_GetItem(__pyx_d, name);
    if (!result) {
        PyErr_Clear();
#endif
        result = __Pyx_GetBuiltinName(name);
    }
    return result;
}

/* ExtTypeTest */
      static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (likely(PyObject_TypeCheck(obj, type)))
        return 1;
    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
                 Py_TYPE(obj)->tp_name, type->tp_name);
    return 0;
}

/* BufferIndexError */
      static void __Pyx_RaiseBufferIndexError(int axis) {
  PyErr_Format(PyExc_IndexError,
     "Out of bounds on buffer access (axis %d)", axis);
}

/* PyObjectCallMethO */
      #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
    PyObject *self, *result;
    PyCFunction cfunc;
    cfunc = PyCFunction_GET_FUNCTION(func);
    self = PyCFunction_GET_SELF(func);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = cfunc(self, arg);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallOneArg */
      #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_New(1);
    if (unlikely(!args)) return NULL;
    Py_INCREF(arg);
    PyTuple_SET_ITEM(args, 0, arg);
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
#ifdef __Pyx_CyFunction_USED
    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
#else
    if (likely(PyCFunction_Check(func))) {
#endif
        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
            return __Pyx_PyObject_CallMethO(func, arg);
        }
    }
    return __Pyx__PyObject_CallOneArg(func, arg);
}
#else
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_Pack(1, arg);
    if (unlikely(!args)) return NULL;
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
#endif

/* BufferFallbackError */
        static void __Pyx_RaiseBufferFallbackError(void) {
  PyErr_SetString(PyExc_ValueError,
     "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!");
}

/* SliceObject */
        static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
        Py_ssize_t cstart, Py_ssize_t cstop,
        PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
        int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {
#if CYTHON_COMPILING_IN_CPYTHON
    PyMappingMethods* mp;
#if PY_MAJOR_VERSION < 3
    PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;
    if (likely(ms && ms->sq_slice)) {
        if (!has_cstart) {
            if (_py_start && (*_py_start != Py_None)) {
                cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);
                if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
            } else
                cstart = 0;
        }
        if (!has_cstop) {
            if (_py_stop && (*_py_stop != Py_None)) {
                cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);
                if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
            } else
                cstop = PY_SSIZE_T_MAX;
        }
        if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {
            Py_ssize_t l = ms->sq_length(obj);
            if (likely(l >= 0)) {
                if (cstop < 0) {
                    cstop += l;
                    if (cstop < 0) cstop = 0;
                }
                if (cstart < 0) {
                    cstart += l;
                    if (cstart < 0) cstart = 0;
                }
            } else {
                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                    goto bad;
                PyErr_Clear();
            }
        }
        return ms->sq_slice(obj, cstart, cstop);
    }
#endif
    mp = Py_TYPE(obj)->tp_as_mapping;
    if (likely(mp && mp->mp_subscript))
#endif
    {
        PyObject* result;
        PyObject *py_slice, *py_start, *py_stop;
        if (_py_slice) {
            py_slice = *_py_slice;
        } else {
            PyObject* owned_start = NULL;
            PyObject* owned_stop = NULL;
            if (_py_start) {
                py_start = *_py_start;
            } else {
                if (has_cstart) {
                    owned_start = py_start = PyInt_FromSsize_t(cstart);
                    if (unlikely(!py_start)) goto bad;
                } else
                    py_start = Py_None;
            }
            if (_py_stop) {
                py_stop = *_py_stop;
            } else {
                if (has_cstop) {
                    owned_stop = py_stop = PyInt_FromSsize_t(cstop);
                    if (unlikely(!py_stop)) {
                        Py_XDECREF(owned_start);
                        goto bad;
                    }
                } else
                    py_stop = Py_None;
            }
            py_slice = PySlice_New(py_start, py_stop, Py_None);
            Py_XDECREF(owned_start);
            Py_XDECREF(owned_stop);
            if (unlikely(!py_slice)) goto bad;
        }
#if CYTHON_COMPILING_IN_CPYTHON
        result = mp->mp_subscript(obj, py_slice);
#else
        result = PyObject_GetItem(obj, py_slice);
#endif
        if (!_py_slice) {
            Py_DECREF(py_slice);
        }
        return result;
    }
    PyErr_Format(PyExc_TypeError,
        "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name);
bad:
    return NULL;
}

/* RaiseTooManyValuesToUnpack */
        static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
}

/* RaiseNeedMoreValuesToUnpack */
        static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
    PyErr_Format(PyExc_ValueError,
                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
                 index, (index == 1) ? "" : "s");
}

/* RaiseNoneIterError */
        static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}

/* Import */
        static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
    #if PY_VERSION_HEX < 0x03030000
    PyObject *py_import;
    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
    if (!py_import)
        goto bad;
    #endif
    if (from_list)
        list = from_list;
    else {
        empty_list = PyList_New(0);
        if (!empty_list)
            goto bad;
        list = empty_list;
    }
    global_dict = PyModule_GetDict(__pyx_m);
    if (!global_dict)
        goto bad;
    empty_dict = PyDict_New();
    if (!empty_dict)
        goto bad;
    {
        #if PY_MAJOR_VERSION >= 3
        if (level == -1) {
            if (strchr(__Pyx_MODULE_NAME, '.')) {
                #if PY_VERSION_HEX < 0x03030000
                PyObject *py_level = PyInt_FromLong(1);
                if (!py_level)
                    goto bad;
                module = PyObject_CallFunctionObjArgs(py_import,
                    name, global_dict, empty_dict, list, py_level, NULL);
                Py_DECREF(py_level);
                #else
                module = PyImport_ImportModuleLevelObject(
                    name, global_dict, empty_dict, list, 1);
                #endif
                if (!module) {
                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
                        goto bad;
                    PyErr_Clear();
                }
            }
            level = 0;
        }
        #endif
        if (!module) {
            #if PY_VERSION_HEX < 0x03030000
            PyObject *py_level = PyInt_FromLong(level);
            if (!py_level)
                goto bad;
            module = PyObject_CallFunctionObjArgs(py_import,
                name, global_dict, empty_dict, list, py_level, NULL);
            Py_DECREF(py_level);
            #else
            module = PyImport_ImportModuleLevelObject(
                name, global_dict, empty_dict, list, level);
            #endif
        }
    }
bad:
    #if PY_VERSION_HEX < 0x03030000
    Py_XDECREF(py_import);
    #endif
    Py_XDECREF(empty_list);
    Py_XDECREF(empty_dict);
    return module;
}

/* CodeObjectCache */
        static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
    int start = 0, mid = 0, end = count - 1;
    if (end >= 0 && code_line > entries[end].code_line) {
        return count;
    }
    while (start < end) {
        mid = start + (end - start) / 2;
        if (code_line < entries[mid].code_line) {
            end = mid;
        } else if (code_line > entries[mid].code_line) {
             start = mid + 1;
        } else {
            return mid;
        }
    }
    if (code_line <= entries[mid].code_line) {
        return mid;
    } else {
        return mid + 1;
    }
}
static PyCodeObject *__pyx_find_code_object(int code_line) {
    PyCodeObject* code_object;
    int pos;
    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
        return NULL;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
        return NULL;
    }
    code_object = __pyx_code_cache.entries[pos].code_object;
    Py_INCREF(code_object);
    return code_object;
}
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
    int pos, i;
    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
    if (unlikely(!code_line)) {
        return;
    }
    if (unlikely(!entries)) {
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
        if (likely(entries)) {
            __pyx_code_cache.entries = entries;
            __pyx_code_cache.max_count = 64;
            __pyx_code_cache.count = 1;
            entries[0].code_line = code_line;
            entries[0].code_object = code_object;
            Py_INCREF(code_object);
        }
        return;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
        PyCodeObject* tmp = entries[pos].code_object;
        entries[pos].code_object = code_object;
        Py_DECREF(tmp);
        return;
    }
    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
        int new_max = __pyx_code_cache.max_count + 64;
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
            __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
        if (unlikely(!entries)) {
            return;
        }
        __pyx_code_cache.entries = entries;
        __pyx_code_cache.max_count = new_max;
    }
    for (i=__pyx_code_cache.count; i>pos; i--) {
        entries[i] = entries[i-1];
    }
    entries[pos].code_line = code_line;
    entries[pos].code_object = code_object;
    __pyx_code_cache.count++;
    Py_INCREF(code_object);
}

/* AddTraceback */
        #include "compile.h"
#include "frameobject.h"
#include "traceback.h"
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
            const char *funcname, int c_line,
            int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyObject *py_srcfile = 0;
    PyObject *py_funcname = 0;
    #if PY_MAJOR_VERSION < 3
    py_srcfile = PyString_FromString(filename);
    #else
    py_srcfile = PyUnicode_FromString(filename);
    #endif
    if (!py_srcfile) goto bad;
    if (c_line) {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #else
        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #endif
    }
    else {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromString(funcname);
        #else
        py_funcname = PyUnicode_FromString(funcname);
        #endif
    }
    if (!py_funcname) goto bad;
    py_code = __Pyx_PyCode_New(
        0,
        0,
        0,
        0,
        0,
        __pyx_empty_bytes, /*PyObject *code,*/
        __pyx_empty_tuple, /*PyObject *consts,*/
        __pyx_empty_tuple, /*PyObject *names,*/
        __pyx_empty_tuple, /*PyObject *varnames,*/
        __pyx_empty_tuple, /*PyObject *freevars,*/
        __pyx_empty_tuple, /*PyObject *cellvars,*/
        py_srcfile,   /*PyObject *filename,*/
        py_funcname,  /*PyObject *name,*/
        py_line,
        __pyx_empty_bytes  /*PyObject *lnotab*/
    );
    Py_DECREF(py_srcfile);
    Py_DECREF(py_funcname);
    return py_code;
bad:
    Py_XDECREF(py_srcfile);
    Py_XDECREF(py_funcname);
    return NULL;
}
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyFrameObject *py_frame = 0;
    py_code = __pyx_find_code_object(c_line ? c_line : py_line);
    if (!py_code) {
        py_code = __Pyx_CreateCodeObjectForTraceback(
            funcname, c_line, py_line, filename);
        if (!py_code) goto bad;
        __pyx_insert_code_object(c_line ? c_line : py_line, py_code);
    }
    py_frame = PyFrame_New(
        PyThreadState_GET(), /*PyThreadState *tstate,*/
        py_code,             /*PyCodeObject *code,*/
        __pyx_d,      /*PyObject *globals,*/
        0                    /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    py_frame->f_lineno = py_line;
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}

#if PY_MAJOR_VERSION < 3
static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
    return -1;
}
static void __Pyx_ReleaseBuffer(Py_buffer *view) {
    PyObject *obj = view->obj;
    if (!obj) return;
    if (PyObject_CheckBuffer(obj)) {
        PyBuffer_Release(view);
        return;
    }
        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; }
    Py_DECREF(obj);
    view->obj = NULL;
}
#endif


        /* CIntFromPyVerify */
        #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
    {\
        func_type value = func_value;\
        if (sizeof(target_type) < sizeof(func_type)) {\
            if (unlikely(value != (func_type) (target_type) value)) {\
                func_type zero = 0;\
                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
                    return (target_type) -1;\
                if (is_unsigned && unlikely(value < zero))\
                    goto raise_neg_overflow;\
                else\
                    goto raise_overflow;\
            }\
        }\
        return (target_type) value;\
    }

/* CIntToPy */
        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
    const long neg_one = (long) -1, const_zero = (long) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(long) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(long) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(long),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64(int64 value) {
    const int64 neg_one = (int64) -1, const_zero = (int64) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(int64) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int64) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(int64) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(int64) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int64) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(int64),
                                     little, !is_unsigned);
    }
}

/* None */
        #if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      return ::std::complex< float >(x, y);
    }
  #else
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      return x + y*(__pyx_t_float_complex)_Complex_I;
    }
  #endif
#else
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      __pyx_t_float_complex z;
      z.real = x;
      z.imag = y;
      return z;
    }
#endif

/* None */
        #if CYTHON_CCOMPLEX
#else
    static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
       return (a.real == b.real) && (a.imag == b.imag);
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real + b.real;
        z.imag = a.imag + b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real - b.real;
        z.imag = a.imag - b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real * b.real - a.imag * b.imag;
        z.imag = a.real * b.imag + a.imag * b.real;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        float denom = b.real * b.real + b.imag * b.imag;
        z.real = (a.real * b.real + a.imag * b.imag) / denom;
        z.imag = (a.imag * b.real - a.real * b.imag) / denom;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) {
        __pyx_t_float_complex z;
        z.real = -a.real;
        z.imag = -a.imag;
        return z;
    }
    static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) {
       return (a.real == 0) && (a.imag == 0);
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) {
        __pyx_t_float_complex z;
        z.real =  a.real;
        z.imag = -a.imag;
        return z;
    }
    #if 1
        static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) {
          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
            return sqrtf(z.real*z.real + z.imag*z.imag);
          #else
            return hypotf(z.real, z.imag);
          #endif
        }
        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
            __pyx_t_float_complex z;
            float r, lnr, theta, z_r, z_theta;
            if (b.imag == 0 && b.real == (int)b.real) {
                if (b.real < 0) {
                    float denom = a.real * a.real + a.imag * a.imag;
                    a.real = a.real / denom;
                    a.imag = -a.imag / denom;
                    b.real = -b.real;
                }
                switch ((int)b.real) {
                    case 0:
                        z.real = 1;
                        z.imag = 0;
                        return z;
                    case 1:
                        return a;
                    case 2:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(a, a);
                    case 3:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(z, a);
                    case 4:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(z, z);
                }
            }
            if (a.imag == 0) {
                if (a.real == 0) {
                    return a;
                }
                r = a.real;
                theta = 0;
            } else {
                r = __Pyx_c_absf(a);
                theta = atan2f(a.imag, a.real);
            }
            lnr = logf(r);
            z_r = expf(lnr * b.real - theta * b.imag);
            z_theta = theta * b.real + lnr * b.imag;
            z.real = z_r * cosf(z_theta);
            z.imag = z_r * sinf(z_theta);
            return z;
        }
    #endif
#endif

/* None */
        #if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      return ::std::complex< double >(x, y);
    }
  #else
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      return x + y*(__pyx_t_double_complex)_Complex_I;
    }
  #endif
#else
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      __pyx_t_double_complex z;
      z.real = x;
      z.imag = y;
      return z;
    }
#endif

/* None */
        #if CYTHON_CCOMPLEX
#else
    static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) {
       return (a.real == b.real) && (a.imag == b.imag);
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real + b.real;
        z.imag = a.imag + b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real - b.real;
        z.imag = a.imag - b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real * b.real - a.imag * b.imag;
        z.imag = a.real * b.imag + a.imag * b.real;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        double denom = b.real * b.real + b.imag * b.imag;
        z.real = (a.real * b.real + a.imag * b.imag) / denom;
        z.imag = (a.imag * b.real - a.real * b.imag) / denom;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) {
        __pyx_t_double_complex z;
        z.real = -a.real;
        z.imag = -a.imag;
        return z;
    }
    static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) {
       return (a.real == 0) && (a.imag == 0);
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) {
        __pyx_t_double_complex z;
        z.real =  a.real;
        z.imag = -a.imag;
        return z;
    }
    #if 1
        static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) {
          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
            return sqrt(z.real*z.real + z.imag*z.imag);
          #else
            return hypot(z.real, z.imag);
          #endif
        }
        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) {
            __pyx_t_double_complex z;
            double r, lnr, theta, z_r, z_theta;
            if (b.imag == 0 && b.real == (int)b.real) {
                if (b.real < 0) {
                    double denom = a.real * a.real + a.imag * a.imag;
                    a.real = a.real / denom;
                    a.imag = -a.imag / denom;
                    b.real = -b.real;
                }
                switch ((int)b.real) {
                    case 0:
                        z.real = 1;
                        z.imag = 0;
                        return z;
                    case 1:
                        return a;
                    case 2:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(a, a);
                    case 3:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(z, a);
                    case 4:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(z, z);
                }
            }
            if (a.imag == 0) {
                if (a.real == 0) {
                    return a;
                }
                r = a.real;
                theta = 0;
            } else {
                r = __Pyx_c_abs(a);
                theta = atan2(a.imag, a.real);
            }
            lnr = log(r);
            z_r = exp(lnr * b.real - theta * b.imag);
            z_theta = theta * b.real + lnr * b.imag;
            z.real = z_r * cos(z_theta);
            z.imag = z_r * sin(z_theta);
            return z;
        }
    #endif
#endif

/* CIntToPy */
        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
    const int neg_one = (int) -1, const_zero = (int) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(int) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(int) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(int),
                                     little, !is_unsigned);
    }
}

/* CIntToPy */
        static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
    const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NPY_TYPES) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
                                     little, !is_unsigned);
    }
}

/* CIntFromPy */
        static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
    const int neg_one = (int) -1, const_zero = (int) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(int) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (int) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int) 0;
                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
                case 2:
                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (int) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(int) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int) 0;
                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(int) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            int val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (int) -1;
        }
    } else {
        int val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (int) -1;
        val = __Pyx_PyInt_As_int(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to int");
    return (int) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to int");
    return (int) -1;
}

/* CIntFromPy */
        static CYTHON_INLINE int64 __Pyx_PyInt_As_int64(PyObject *x) {
    const int64 neg_one = (int64) -1, const_zero = (int64) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(int64) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(int64, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (int64) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int64) 0;
                case  1: __PYX_VERIFY_RETURN_INT(int64, digit, digits[0])
                case 2:
                    if (8 * sizeof(int64) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) >= 2 * PyLong_SHIFT) {
                            return (int64) (((((int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int64) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) >= 3 * PyLong_SHIFT) {
                            return (int64) (((((((int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int64) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) >= 4 * PyLong_SHIFT) {
                            return (int64) (((((((((int64)digits[3]) << PyLong_SHIFT) | (int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (int64) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(int64) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int64, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(int64) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int64, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int64) 0;
                case -1: __PYX_VERIFY_RETURN_INT(int64, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(int64,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(int64) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 2 * PyLong_SHIFT) {
                            return (int64) (((int64)-1)*(((((int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(int64) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 2 * PyLong_SHIFT) {
                            return (int64) ((((((int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(int64) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 3 * PyLong_SHIFT) {
                            return (int64) (((int64)-1)*(((((((int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int64) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 3 * PyLong_SHIFT) {
                            return (int64) ((((((((int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(int64) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 4 * PyLong_SHIFT) {
                            return (int64) (((int64)-1)*(((((((((int64)digits[3]) << PyLong_SHIFT) | (int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int64) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int64, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int64) - 1 > 4 * PyLong_SHIFT) {
                            return (int64) ((((((((((int64)digits[3]) << PyLong_SHIFT) | (int64)digits[2]) << PyLong_SHIFT) | (int64)digits[1]) << PyLong_SHIFT) | (int64)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(int64) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int64, long, PyLong_AsLong(x))
            } else if (sizeof(int64) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int64, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            int64 val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (int64) -1;
        }
    } else {
        int64 val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (int64) -1;
        val = __Pyx_PyInt_As_int64(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to int64");
    return (int64) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to int64");
    return (int64) -1;
}

/* CIntFromPy */
        static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
    const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(size_t) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (size_t) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (size_t) 0;
                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
                case 2:
                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
                            return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
                            return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
                            return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (size_t) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(size_t) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (size_t) 0;
                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                            return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                            return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
                            return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(size_t) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            size_t val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (size_t) -1;
        }
    } else {
        size_t val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (size_t) -1;
        val = __Pyx_PyInt_As_size_t(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to size_t");
    return (size_t) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to size_t");
    return (size_t) -1;
}

/* CIntFromPy */
        static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
    const long neg_one = (long) -1, const_zero = (long) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(long) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (long) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (long) 0;
                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
                case 2:
                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (long) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(long) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (long) 0;
                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(long) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            long val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (long) -1;
        }
    } else {
        long val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (long) -1;
        val = __Pyx_PyInt_As_long(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to long");
    return (long) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to long");
    return (long) -1;
}

/* CheckBinaryVersion */
        static int __Pyx_check_binary_version(void) {
    char ctversion[4], rtversion[4];
    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
        char message[200];
        PyOS_snprintf(message, sizeof(message),
                      "compiletime version %s of module '%.100s' "
                      "does not match runtime version %s",
                      ctversion, __Pyx_MODULE_NAME, rtversion);
        return PyErr_WarnEx(NULL, message, 1);
    }
    return 0;
}

/* ModuleImport */
        #ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
    PyObject *py_name = 0;
    PyObject *py_module = 0;
    py_name = __Pyx_PyIdentifier_FromString(name);
    if (!py_name)
        goto bad;
    py_module = PyImport_Import(py_name);
    Py_DECREF(py_name);
    return py_module;
bad:
    Py_XDECREF(py_name);
    return 0;
}
#endif

/* TypeImport */
        #ifndef __PYX_HAVE_RT_ImportType
#define __PYX_HAVE_RT_ImportType
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
    size_t size, int strict)
{
    PyObject *py_module = 0;
    PyObject *result = 0;
    PyObject *py_name = 0;
    char warning[200];
    Py_ssize_t basicsize;
#ifdef Py_LIMITED_API
    PyObject *py_basicsize;
#endif
    py_module = __Pyx_ImportModule(module_name);
    if (!py_module)
        goto bad;
    py_name = __Pyx_PyIdentifier_FromString(class_name);
    if (!py_name)
        goto bad;
    result = PyObject_GetAttr(py_module, py_name);
    Py_DECREF(py_name);
    py_name = 0;
    Py_DECREF(py_module);
    py_module = 0;
    if (!result)
        goto bad;
    if (!PyType_Check(result)) {
        PyErr_Format(PyExc_TypeError,
            "%.200s.%.200s is not a type object",
            module_name, class_name);
        goto bad;
    }
#ifndef Py_LIMITED_API
    basicsize = ((PyTypeObject *)result)->tp_basicsize;
#else
    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
    if (!py_basicsize)
        goto bad;
    basicsize = PyLong_AsSsize_t(py_basicsize);
    Py_DECREF(py_basicsize);
    py_basicsize = 0;
    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
        goto bad;
#endif
    if (!strict && (size_t)basicsize > size) {
        PyOS_snprintf(warning, sizeof(warning),
            "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd",
            module_name, class_name, basicsize, size);
        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
    }
    else if ((size_t)basicsize != size) {
        PyErr_Format(PyExc_ValueError,
            "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd",
            module_name, class_name, basicsize, size);
        goto bad;
    }
    return (PyTypeObject *)result;
bad:
    Py_XDECREF(py_module);
    Py_XDECREF(result);
    return NULL;
}
#endif

/* InitStrings */
        static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
    while (t->p) {
        #if PY_MAJOR_VERSION < 3
        if (t->is_unicode) {
            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
        } else if (t->intern) {
            *t->p = PyString_InternFromString(t->s);
        } else {
            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
        }
        #else
        if (t->is_unicode | t->is_str) {
            if (t->intern) {
                *t->p = PyUnicode_InternFromString(t->s);
            } else if (t->encoding) {
                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
            } else {
                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
            }
        } else {
            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
        }
        #endif
        if (!*t->p)
            return -1;
        ++t;
    }
    return 0;
}

static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
}
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {
    Py_ssize_t ignore;
    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
}
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
    if (
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
            __Pyx_sys_getdefaultencoding_not_ascii &&
#endif
            PyUnicode_Check(o)) {
#if PY_VERSION_HEX < 0x03030000
        char* defenc_c;
        PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
        if (!defenc) return NULL;
        defenc_c = PyBytes_AS_STRING(defenc);
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        {
            char* end = defenc_c + PyBytes_GET_SIZE(defenc);
            char* c;
            for (c = defenc_c; c < end; c++) {
                if ((unsigned char) (*c) >= 128) {
                    PyUnicode_AsASCIIString(o);
                    return NULL;
                }
            }
        }
#endif
        *length = PyBytes_GET_SIZE(defenc);
        return defenc_c;
#else
        if (__Pyx_PyUnicode_READY(o) == -1) return NULL;
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        if (PyUnicode_IS_ASCII(o)) {
            *length = PyUnicode_GET_LENGTH(o);
            return PyUnicode_AsUTF8(o);
        } else {
            PyUnicode_AsASCIIString(o);
            return NULL;
        }
#else
        return PyUnicode_AsUTF8AndSize(o, length);
#endif
#endif
    } else
#endif
#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
    if (PyByteArray_Check(o)) {
        *length = PyByteArray_GET_SIZE(o);
        return PyByteArray_AS_STRING(o);
    } else
#endif
    {
        char* result;
        int r = PyBytes_AsStringAndSize(o, &result, length);
        if (unlikely(r < 0)) {
            return NULL;
        } else {
            return result;
        }
    }
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
   int is_true = x == Py_True;
   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
   else return PyObject_IsTrue(x);
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
  PyNumberMethods *m;
  const char *name = NULL;
  PyObject *res = NULL;
#if PY_MAJOR_VERSION < 3
  if (PyInt_Check(x) || PyLong_Check(x))
#else
  if (PyLong_Check(x))
#endif
    return __Pyx_NewRef(x);
  m = Py_TYPE(x)->tp_as_number;
#if PY_MAJOR_VERSION < 3
  if (m && m->nb_int) {
    name = "int";
    res = PyNumber_Int(x);
  }
  else if (m && m->nb_long) {
    name = "long";
    res = PyNumber_Long(x);
  }
#else
  if (m && m->nb_int) {
    name = "int";
    res = PyNumber_Long(x);
  }
#endif
  if (res) {
#if PY_MAJOR_VERSION < 3
    if (!PyInt_Check(res) && !PyLong_Check(res)) {
#else
    if (!PyLong_Check(res)) {
#endif
      PyErr_Format(PyExc_TypeError,
                   "__%.4s__ returned non-%.4s (type %.200s)",
                   name, name, Py_TYPE(res)->tp_name);
      Py_DECREF(res);
      return NULL;
    }
  }
  else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_TypeError,
                    "an integer is required");
  }
  return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
  Py_ssize_t ival;
  PyObject *x;
#if PY_MAJOR_VERSION < 3
  if (likely(PyInt_CheckExact(b))) {
    if (sizeof(Py_ssize_t) >= sizeof(long))
        return PyInt_AS_LONG(b);
    else
        return PyInt_AsSsize_t(x);
  }
#endif
  if (likely(PyLong_CheckExact(b))) {
    #if CYTHON_USE_PYLONG_INTERNALS
    const digit* digits = ((PyLongObject*)b)->ob_digit;
    const Py_ssize_t size = Py_SIZE(b);
    if (likely(__Pyx_sst_abs(size) <= 1)) {
        ival = likely(size) ? digits[0] : 0;
        if (size == -1) ival = -ival;
        return ival;
    } else {
      switch (size) {
         case 2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
      }
    }
    #endif
    return PyLong_AsSsize_t(b);
  }
  x = PyNumber_Index(b);
  if (!x) return -1;
  ival = PyInt_AsSsize_t(x);
  Py_DECREF(x);
  return ival;
}
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
    return PyInt_FromSize_t(ival);
}


#endif /* Py_PYTHON_H */
healpy-1.10.3/healpy/src/_query_disc.pyx0000664000175000017500000003022313010374155020446 0ustar  zoncazonca00000000000000# Wrapper around the query_disc method of Healpix_base class

import numpy as np
cimport numpy as np
from libcpp cimport bool
from libcpp.vector cimport vector
cimport cython

from _common cimport int64, pointing, rangeset, vec3, Healpix_Ordering_Scheme, RING, NEST, SET_NSIDE, T_Healpix_Base

@cython.boundscheck(False)
@cython.wraparound(False)
def query_disc(nside, vec, radius, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):
    """Returns pixels whose centers lie within the disk defined by
    *vec* and *radius* (in radians) (if *inclusive* is False), or which
    overlap with this disk (if *inclusive* is True).

    Parameters
    ----------
    nside : int
      The nside of the Healpix map.
    vec : float, sequence of 3 elements
      The coordinates of unit vector defining the disk center.
    radius : float
      The radius (in radians) of the disk
    inclusive : bool, optional
      If False, return the exact set of pixels whose pixel centers lie 
      within the disk; if True, return all pixels that overlap with the disk,
      and maybe a few more. Default: False
    fact : int, optional
      Only used when inclusive=True. The overlapping test will be done at
      the resolution fact*nside. For NESTED ordering, fact must be a power of 2, less than 2**30,
      else it can be any positive integer. Default: 4.
    nest: bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering
    buff: int array, optional
      if provided, this numpy array is used to contain the return values and must be
      at least long enough to do so

    Returns
    -------
    ipix : int, array
      The pixels which lie within the given disk.

    Note
    ----
    This method is more efficient in the RING scheme.
    For inclusive=True, the algorithm may return some pixels which don't overlap
    with the disk at all. The higher fact is chosen, the fewer false positives
    are returned, at the cost of increased run time.
    """
    # Check Nside value
    if not isnsideok(nside):
        raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
    cdef vec3 v = vec3(vec[0], vec[1], vec[2])
    cdef Healpix_Ordering_Scheme scheme
    if nest:
        scheme = NEST
    else:
        scheme = RING
    cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
    cdef rangeset[int64] pixset
    cdef int factor = fact
    cdef pointing ptg = pointing(v)
    ptg.normalize()
    if inclusive:
        factor = abs(fact)
        if nest and (factor == 0 or (factor & (factor - 1) != 0)):
            raise ValueError('fact must be a power of 2, less than 2**30 when '
                             'nest is True (fact=%d)' % (fact))
        hb.query_disc_inclusive(ptg, radius, pixset, factor)
    else:
        hb.query_disc(ptg, radius, pixset)

    return pixset_to_array(pixset, buff)


def query_polygon(nside, vertices, inclusive = False, fact = 4, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):
    """ Returns the pixels whose centers lie within the convex polygon 
    defined by the *vertices* array (if *inclusive* is False), or which 
    overlap with this polygon (if *inclusive* is True).

    Parameters
    ----------
    nside : int
      The nside of the Healpix map.
    vertices : float, array-like
      Vertex array containing the vertices of the polygon, shape (N, 3).
    inclusive : bool, optional
      If False, return the exact set of pixels whose pixel centers lie
      within the polygon; if True, return all pixels that overlap with the
      polygon, and maybe a few more. Default: False.
    fact : int, optional
      Only used when inclusive=True. The overlapping test will be done at
      the resolution fact*nside. For NESTED ordering, fact must be a power of 2, less than 2**30,
      else it can be any positive integer. Default: 4.
    nest: bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering
    buff: int array, optional
      if provided, this numpy array is used to contain the return values and must be
      at least long enough to do so
      
    Returns
    -------
    ipix : int, array
      The pixels which lie within the given polygon.

    Note
    ----
    This method is more efficient in the RING scheme.
    For inclusive=True, the algorithm may return some pixels which don't overlap
    with the disk at all. The higher fact is chosen, the fewer false positives
    are returned, at the cost of increased run time.
    """
    # Check Nside value
    if not isnsideok(nside):
        raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
    # Create vector of vertices
    cdef vector[pointing] vert
    cdef pointing ptg
    for v in vertices:
        ptg = pointing(vec3(v[0], v[1], v[2]))
        ptg.normalize()
        vert.push_back(ptg)
    # Create the Healpix_Base2 structure
    cdef Healpix_Ordering_Scheme scheme
    if nest:
        scheme = NEST
    else:
        scheme = RING
    cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
    # Call query_polygon
    cdef rangeset[int64] pixset
    cdef int factor
    if inclusive:
        factor = abs(fact)
        if nest and (factor == 0 or (factor & (factor - 1) != 0)):
            raise ValueError('fact must be a power of 2, less than 2**30 when '
                             'nest is True (fact=%d)' % (fact))
        hb.query_polygon_inclusive(vert, pixset, factor)
    else:
        hb.query_polygon(vert, pixset)

    return pixset_to_array(pixset, buff)

def query_strip(nside, theta1, theta2, inclusive = False, nest = False, np.ndarray[np.int64_t, ndim=1] buff=None):
    """Returns pixels whose centers lie within the colatitude range
    defined by *theta1* and *theta2* (if inclusive is False), or which 
    overlap with this region (if *inclusive* is True). If theta1= (12*nside*nside):
        raise ValueError('Pixel identifier is too large')
    hb.boundaries(pix, step, bounds)
    cdef size_t n = bounds.size()
    cdef np.ndarray[double, ndim = 2] out = np.empty((3, n), dtype=np.float)
    for i in range(n):
        out[0,i] = bounds[i].x
        out[1,i] = bounds[i].y
        out[2,i] = bounds[i].z
    return out

def _boundaries_multiple(nside, pix, step=1, nest=False):
    cdef Healpix_Ordering_Scheme scheme
    if nest:
        scheme = NEST
    else:
        scheme = RING
    cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
    cdef size_t npix = len(pix)
    cdef size_t n = step * 4
    cdef size_t maxnpix = 12*nside*nside
    cdef np.ndarray[double, ndim = 3] out = np.empty((npix, 3, n), dtype=np.float)
    cdef vector[vec3] bounds
 
    for j in range(npix):
        if pix[j] >= maxnpix:
            raise ValueError('Pixel identifier is too large')

        hb.boundaries(pix[j], step, bounds)
        for i in range(n):
            out[j, 0, i] = bounds[i].x
            out[j, 1, i] = bounds[i].y
            out[j, 2, i] = bounds[i].z
    return out

def boundaries(nside, pix, step=1, nest=False):
    """Returns an array containing vectors to the boundary of
    the nominated pixel.

    The returned array has shape (3, 4*step), the elements of
    which are the x,y,z positions on the unit sphere of the
    pixel boundary.  In order to get vector positions for just
    the corners, specify step=1.

    Parameters
    ----------
    nside : int
      The nside of the Healpix map.
    pix : int
      Pixel identifier
    step : int, optional
      Number of elements for each side of the pixel.
    nest : bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering

    Returns
    -------
    boundary : float, array
      x,y,z for positions on the boundary of the pixel

    Example
    -------
    # Get corners of HEALPixel 5 in nside=2, RINGS ordering.

    >>> import healpy as hp
    >>> import numpy as np
    >>> nside = 2
    >>> corners = hp.boundaries(nside, 5)

    # Now convert to phi,theta representation:
    >>> phi_theta = hp.vec2ang(np.transpose(corners))

    >>> corners = hp.boundaries(nside, np.array([5,5]))

    # doctest moved to test_query_disc.py
    """

    if not isnsideok(nside):
        raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
    if np.isscalar(pix):
        if not np.can_cast(type(pix), np.int):
            raise ValueError('Array of pixels has to be integers')
        return _boundaries_single(nside, pix, step=step, nest=nest)
    else:
        pix = np.asarray(pix)
        if np.can_cast(pix.dtype, np.int):
            if pix.ndim!=1:
                raise ValueError('Array has to be one dimensional')
            return _boundaries_multiple(nside, pix.astype(np.int), step=step, nest=nest)
        else:
            raise ValueError('Array of pixels has to be integers')

# Try to implement pix2ang
### @cython.boundscheck(False)
### @cython.wraparound(False)
### def pix2ang(nside, ipix, nest = False):
###     # Check Nside value
###     if not isnsideok(nside):
###         raise ValueError('Wrong nside value, must be a power of 2, less than 2**30')
###     # Create the Healpix_Base2 structure
###     cdef Healpix_Ordering_Scheme scheme
###     if nest:
###         scheme = NEST
###     else:
###         scheme = RING
###     cdef T_Healpix_Base[int64] hb = T_Healpix_Base[int64](nside, scheme, SET_NSIDE)
###     cdef pointing p
###     ipix_ = np.asarray(ipix, dtype = np.int64)
###     out_shape = (2,) + ipix_.shape
###     out = np.empty(out_shape, dtype = np.float64)
###     cdef np.ndarray[int64, ndim = 1] ipix_r = ipix_.reshape(-1)
###     cdef np.ndarray[double, ndim = 2] out_r = out.reshape(2, -1)
###     cdef int i, n
###     n = ipix_r.size
###     for i in range(n):
###         p = hb.pix2ang(ipix_r[i])
###         out_r[0, i] = p.theta
###         out_r[1, i] = p.phi
###     del out_r, ipix_r, ipix_
###     return out
    
@cython.boundscheck(False)
@cython.wraparound(False)
cdef pixset_to_array(rangeset[int64] &pixset, buff=None):
    cdef int64 i, n
    n = pixset.nval()
    cdef np.ndarray[np.int64_t, ndim=1] ipix 
   		
    if buff is None :
       ipix = np.empty(n, dtype=np.int64)
    else :
       if n>=len(buff) :
           raise ValueError("Buffer too small to contain return value")
       ipix = buff[:n] 		
    
    cdef int64 a, b, ii, ip
    ii = 0
    n = pixset.size()
    for i in range(n):
        a = pixset.ivbegin(i)
        b = pixset.ivend(i)
        for ip in range(a, b):
            ipix[ii] = ip
            ii += 1
    return ipix

cdef bool isnsideok(int nside):
     return nside > 0 and ((nside & (nside -1))==0)
    


healpy-1.10.3/healpy/src/_sphtools.cpp0000664000175000017500000233065313010376621020130 0ustar  zoncazonca00000000000000/* Generated by Cython 0.24 */

#define PY_SSIZE_T_CLEAN
#include "Python.h"
#ifndef Py_PYTHON_H
    #error Python headers needed to compile C extensions, please install development version of Python.
#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
    #error Cython requires Python 2.6+ or Python 3.2+.
#else
#define CYTHON_ABI "0_24"
#include 
#ifndef offsetof
  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
  #ifndef __stdcall
    #define __stdcall
  #endif
  #ifndef __cdecl
    #define __cdecl
  #endif
  #ifndef __fastcall
    #define __fastcall
  #endif
#endif
#ifndef DL_IMPORT
  #define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
  #define DL_EXPORT(t) t
#endif
#ifndef PY_LONG_LONG
  #define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
  #define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
  #define CYTHON_COMPILING_IN_PYPY 1
  #define CYTHON_COMPILING_IN_CPYTHON 0
#else
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_CPYTHON 1
#endif
#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000
  #define CYTHON_USE_PYLONG_INTERNALS 1
#endif
#if CYTHON_USE_PYLONG_INTERNALS
  #include "longintrepr.h"
  #undef SHIFT
  #undef BASE
  #undef MASK
#endif
#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
  #define Py_OptimizeFlag 0
#endif
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
#if PY_MAJOR_VERSION < 3
  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyClass_Type
#else
  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyType_Type
#endif
#ifndef Py_TPFLAGS_CHECKTYPES
  #define Py_TPFLAGS_CHECKTYPES 0
#endif
#ifndef Py_TPFLAGS_HAVE_INDEX
  #define Py_TPFLAGS_HAVE_INDEX 0
#endif
#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#ifndef Py_TPFLAGS_HAVE_FINALIZE
  #define Py_TPFLAGS_HAVE_FINALIZE 0
#endif
#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
  #define CYTHON_PEP393_ENABLED 1
  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
                                              0 : _PyUnicode_Ready((PyObject *)(op)))
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
#else
  #define CYTHON_PEP393_ENABLED 0
  #define __Pyx_PyUnicode_READY(op)       (0)
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
#endif
#if CYTHON_COMPILING_IN_PYPY
  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
#else
  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
  #define PyObject_Malloc(s)   PyMem_Malloc(s)
  #define PyObject_Free(p)     PyMem_Free(p)
  #define PyObject_Realloc(p)  PyMem_Realloc(p)
#endif
#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
#else
  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
#endif
#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
  #define PyObject_ASCII(o)            PyObject_Repr(o)
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBaseString_Type            PyUnicode_Type
  #define PyStringObject               PyUnicodeObject
  #define PyString_Type                PyUnicode_Type
  #define PyString_Check               PyUnicode_Check
  #define PyString_CheckExact          PyUnicode_CheckExact
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
#else
  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
#endif
#ifndef PySet_CheckExact
  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
#endif
#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
#if PY_MAJOR_VERSION >= 3
  #define PyIntObject                  PyLongObject
  #define PyInt_Type                   PyLong_Type
  #define PyInt_Check(op)              PyLong_Check(op)
  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
  #define PyInt_FromString             PyLong_FromString
  #define PyInt_FromUnicode            PyLong_FromUnicode
  #define PyInt_FromLong               PyLong_FromLong
  #define PyInt_FromSize_t             PyLong_FromSize_t
  #define PyInt_FromSsize_t            PyLong_FromSsize_t
  #define PyInt_AsLong                 PyLong_AsLong
  #define PyInt_AS_LONG                PyLong_AS_LONG
  #define PyInt_AsSsize_t              PyLong_AsSsize_t
  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
  #define PyNumber_Int                 PyNumber_Long
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBoolObject                 PyLongObject
#endif
#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
  #ifndef PyUnicode_InternFromString
    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
  #endif
#endif
#if PY_VERSION_HEX < 0x030200A4
  typedef long Py_hash_t;
  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
#else
  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
#else
  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
#endif
#if PY_VERSION_HEX >= 0x030500B1
#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
typedef struct {
    unaryfunc am_await;
    unaryfunc am_aiter;
    unaryfunc am_anext;
} __Pyx_PyAsyncMethodsStruct;
#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
#else
#define __Pyx_PyType_AsAsync(obj) NULL
#endif
#ifndef CYTHON_RESTRICT
  #if defined(__GNUC__)
    #define CYTHON_RESTRICT __restrict__
  #elif defined(_MSC_VER) && _MSC_VER >= 1400
    #define CYTHON_RESTRICT __restrict
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_RESTRICT restrict
  #else
    #define CYTHON_RESTRICT
  #endif
#endif
#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)

#ifndef __cplusplus
  #error "Cython files generated with the C++ option must be compiled with a C++ compiler."
#endif
#ifndef CYTHON_INLINE
  #define CYTHON_INLINE inline
#endif
template
void __Pyx_call_destructor(T& x) {
    x.~T();
}
template
class __Pyx_FakeReference {
  public:
    __Pyx_FakeReference() : ptr(NULL) { }
    __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { }
    T *operator->() { return ptr; }
    operator T&() { return *ptr; }
  private:
    T *ptr;
};

#if defined(WIN32) || defined(MS_WINDOWS)
  #define _USE_MATH_DEFINES
#endif
#include 
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
  float value;
  memset(&value, 0xFF, sizeof(value));
  return value;
}
#endif


#define __PYX_ERR(f_index, lineno, Ln_error) \
{ \
  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
}

#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
#else
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
#endif

#ifndef __PYX_EXTERN_C
  #ifdef __cplusplus
    #define __PYX_EXTERN_C extern "C"
  #else
    #define __PYX_EXTERN_C extern
  #endif
#endif

#define __PYX_HAVE__healpy___sphtools
#define __PYX_HAVE_API__healpy___sphtools
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "numpy/arrayobject.h"
#include "numpy/ufuncobject.h"
#include 
#include "ios"
#include "new"
#include "stdexcept"
#include "typeinfo"
#include "math.h"
#include 
#include "stddef.h"
#include "datatypes.h"
#include "xcomplex.h"
#include "arr.h"
#include "rangeset.h"
#include "vec3.h"
#include "pointing.h"
#include "healpix_base.h"
#include "healpix_map.h"
#include "alm.h"
#include "alm_healpix_tools.h"
#include "alm_powspec_tools.h"
#include "healpix_data_io.h"
#ifdef _OPENMP
#include 
#endif /* _OPENMP */

#ifdef PYREX_WITHOUT_ASSERTIONS
#define CYTHON_WITHOUT_ASSERTIONS
#endif

#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define CYTHON_UNUSED __attribute__ ((__unused__))
#   else
#     define CYTHON_UNUSED
#   endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
#   define CYTHON_UNUSED __attribute__ ((__unused__))
# else
#   define CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_NCP_UNUSED
# if CYTHON_COMPILING_IN_CPYTHON
#  define CYTHON_NCP_UNUSED
# else
#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;

#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
#define __PYX_DEFAULT_STRING_ENCODING ""
#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#define __Pyx_uchar_cast(c) ((unsigned char)c)
#define __Pyx_long_cast(x) ((long)x)
#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
    (sizeof(type) < sizeof(Py_ssize_t))  ||\
    (sizeof(type) > sizeof(Py_ssize_t) &&\
          likely(v < (type)PY_SSIZE_T_MAX ||\
                 v == (type)PY_SSIZE_T_MAX)  &&\
          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
                                v == (type)PY_SSIZE_T_MIN)))  ||\
    (sizeof(type) == sizeof(Py_ssize_t) &&\
          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
                               v == (type)PY_SSIZE_T_MAX)))  )
#if defined (__cplusplus) && __cplusplus >= 201103L
    #include 
    #define __Pyx_sst_abs(value) std::abs(value)
#elif SIZEOF_INT >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) abs(value)
#elif SIZEOF_LONG >= SIZEOF_SIZE_T
    #define __Pyx_sst_abs(value) labs(value)
#elif defined (_MSC_VER) && defined (_M_X64)
    #define __Pyx_sst_abs(value) _abs64(value)
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define __Pyx_sst_abs(value) llabs(value)
#elif defined (__GNUC__)
    #define __Pyx_sst_abs(value) __builtin_llabs(value)
#else
    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
#endif
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
#define __Pyx_PyBytes_FromString        PyBytes_FromString
#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
#if PY_MAJOR_VERSION < 3
    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#else
    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
#endif
#define __Pyx_PyObject_AsSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
#if PY_MAJOR_VERSION < 3
static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
{
    const Py_UNICODE *u_end = u;
    while (*u_end++) ;
    return (size_t)(u_end - u - 1);
}
#else
#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
#endif
#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
#if CYTHON_COMPILING_IN_CPYTHON
#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
#else
#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#endif
#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
#else
#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
#endif
#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
static int __Pyx_sys_getdefaultencoding_not_ascii;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
    PyObject* sys;
    PyObject* default_encoding = NULL;
    PyObject* ascii_chars_u = NULL;
    PyObject* ascii_chars_b = NULL;
    const char* default_encoding_c;
    sys = PyImport_ImportModule("sys");
    if (!sys) goto bad;
    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
    Py_DECREF(sys);
    if (!default_encoding) goto bad;
    default_encoding_c = PyBytes_AsString(default_encoding);
    if (!default_encoding_c) goto bad;
    if (strcmp(default_encoding_c, "ascii") == 0) {
        __Pyx_sys_getdefaultencoding_not_ascii = 0;
    } else {
        char ascii_chars[128];
        int c;
        for (c = 0; c < 128; c++) {
            ascii_chars[c] = c;
        }
        __Pyx_sys_getdefaultencoding_not_ascii = 1;
        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
        if (!ascii_chars_u) goto bad;
        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
            PyErr_Format(
                PyExc_ValueError,
                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
                default_encoding_c);
            goto bad;
        }
        Py_DECREF(ascii_chars_u);
        Py_DECREF(ascii_chars_b);
    }
    Py_DECREF(default_encoding);
    return 0;
bad:
    Py_XDECREF(default_encoding);
    Py_XDECREF(ascii_chars_u);
    Py_XDECREF(ascii_chars_b);
    return -1;
}
#endif
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
#else
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
static char* __PYX_DEFAULT_STRING_ENCODING;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
    PyObject* sys;
    PyObject* default_encoding = NULL;
    char* default_encoding_c;
    sys = PyImport_ImportModule("sys");
    if (!sys) goto bad;
    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
    Py_DECREF(sys);
    if (!default_encoding) goto bad;
    default_encoding_c = PyBytes_AsString(default_encoding);
    if (!default_encoding_c) goto bad;
    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
    Py_DECREF(default_encoding);
    return 0;
bad:
    Py_XDECREF(default_encoding);
    return -1;
}
#endif
#endif


/* Test for GCC > 2.95 */
#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
  #define likely(x)   __builtin_expect(!!(x), 1)
  #define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
  #define likely(x)   (x)
  #define unlikely(x) (x)
#endif /* __GNUC__ */

static PyObject *__pyx_m;
static PyObject *__pyx_d;
static PyObject *__pyx_b;
static PyObject *__pyx_empty_tuple;
static PyObject *__pyx_empty_bytes;
static PyObject *__pyx_empty_unicode;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
static const char *__pyx_filename;

/* None.proto */
#if !defined(CYTHON_CCOMPLEX)
  #if defined(__cplusplus)
    #define CYTHON_CCOMPLEX 1
  #elif defined(_Complex_I)
    #define CYTHON_CCOMPLEX 1
  #else
    #define CYTHON_CCOMPLEX 0
  #endif
#endif
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    #include 
  #else
    #include 
  #endif
#endif
#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
  #undef _Complex_I
  #define _Complex_I 1.0fj
#endif


static const char *__pyx_f[] = {
  "healpy/src/_sphtools.pyx",
  "healpy/src/_common.pxd",
  "__init__.pxd",
  "type.pxd",
};
/* BufferFormatStructs.proto */
#define IS_UNSIGNED(type) (((type) -1) > 0)
struct __Pyx_StructField_;
#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
typedef struct {
  const char* name;
  struct __Pyx_StructField_* fields;
  size_t size;
  size_t arraysize[8];
  int ndim;
  char typegroup;
  char is_unsigned;
  int flags;
} __Pyx_TypeInfo;
typedef struct __Pyx_StructField_ {
  __Pyx_TypeInfo* type;
  const char* name;
  size_t offset;
} __Pyx_StructField;
typedef struct {
  __Pyx_StructField* field;
  size_t parent_offset;
} __Pyx_BufFmt_StackElem;
typedef struct {
  __Pyx_StructField root;
  __Pyx_BufFmt_StackElem* head;
  size_t fmt_offset;
  size_t new_count, enc_count;
  size_t struct_alignment;
  int is_complex;
  char enc_type;
  char new_packmode;
  char enc_packmode;
  char is_valid_array;
} __Pyx_BufFmt_Context;


/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":725
 * # in Cython to enable them only on the right systems.
 * 
 * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t
 */
typedef npy_int8 __pyx_t_5numpy_int8_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":726
 * 
 * ctypedef npy_int8       int8_t
 * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int32      int32_t
 * ctypedef npy_int64      int64_t
 */
typedef npy_int16 __pyx_t_5numpy_int16_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":727
 * ctypedef npy_int8       int8_t
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_int64      int64_t
 * #ctypedef npy_int96      int96_t
 */
typedef npy_int32 __pyx_t_5numpy_int32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":728
 * ctypedef npy_int16      int16_t
 * ctypedef npy_int32      int32_t
 * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_int96      int96_t
 * #ctypedef npy_int128     int128_t
 */
typedef npy_int64 __pyx_t_5numpy_int64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":732
 * #ctypedef npy_int128     int128_t
 * 
 * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t
 */
typedef npy_uint8 __pyx_t_5numpy_uint8_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":733
 * 
 * ctypedef npy_uint8      uint8_t
 * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint32     uint32_t
 * ctypedef npy_uint64     uint64_t
 */
typedef npy_uint16 __pyx_t_5numpy_uint16_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":734
 * ctypedef npy_uint8      uint8_t
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uint64     uint64_t
 * #ctypedef npy_uint96     uint96_t
 */
typedef npy_uint32 __pyx_t_5numpy_uint32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":735
 * ctypedef npy_uint16     uint16_t
 * ctypedef npy_uint32     uint32_t
 * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_uint96     uint96_t
 * #ctypedef npy_uint128    uint128_t
 */
typedef npy_uint64 __pyx_t_5numpy_uint64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":739
 * #ctypedef npy_uint128    uint128_t
 * 
 * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
 * ctypedef npy_float64    float64_t
 * #ctypedef npy_float80    float80_t
 */
typedef npy_float32 __pyx_t_5numpy_float32_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":740
 * 
 * ctypedef npy_float32    float32_t
 * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
 * #ctypedef npy_float80    float80_t
 * #ctypedef npy_float128   float128_t
 */
typedef npy_float64 __pyx_t_5numpy_float64_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":749
 * # The int types are mapped a bit surprising --
 * # numpy.int corresponds to 'l' and numpy.long to 'q'
 * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longlong   long_t
 * ctypedef npy_longlong   longlong_t
 */
typedef npy_long __pyx_t_5numpy_int_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":750
 * # numpy.int corresponds to 'l' and numpy.long to 'q'
 * ctypedef npy_long       int_t
 * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longlong   longlong_t
 * 
 */
typedef npy_longlong __pyx_t_5numpy_long_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":751
 * ctypedef npy_long       int_t
 * ctypedef npy_longlong   long_t
 * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_ulong      uint_t
 */
typedef npy_longlong __pyx_t_5numpy_longlong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":753
 * ctypedef npy_longlong   longlong_t
 * 
 * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
 * ctypedef npy_ulonglong  ulong_t
 * ctypedef npy_ulonglong  ulonglong_t
 */
typedef npy_ulong __pyx_t_5numpy_uint_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":754
 * 
 * ctypedef npy_ulong      uint_t
 * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
 * ctypedef npy_ulonglong  ulonglong_t
 * 
 */
typedef npy_ulonglong __pyx_t_5numpy_ulong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":755
 * ctypedef npy_ulong      uint_t
 * ctypedef npy_ulonglong  ulong_t
 * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_intp       intp_t
 */
typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":757
 * ctypedef npy_ulonglong  ulonglong_t
 * 
 * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
 * ctypedef npy_uintp      uintp_t
 * 
 */
typedef npy_intp __pyx_t_5numpy_intp_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":758
 * 
 * ctypedef npy_intp       intp_t
 * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_double     float_t
 */
typedef npy_uintp __pyx_t_5numpy_uintp_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":760
 * ctypedef npy_uintp      uintp_t
 * 
 * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
 * ctypedef npy_double     double_t
 * ctypedef npy_longdouble longdouble_t
 */
typedef npy_double __pyx_t_5numpy_float_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":761
 * 
 * ctypedef npy_double     float_t
 * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
 * ctypedef npy_longdouble longdouble_t
 * 
 */
typedef npy_double __pyx_t_5numpy_double_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":762
 * ctypedef npy_double     float_t
 * ctypedef npy_double     double_t
 * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_cfloat      cfloat_t
 */
typedef npy_longdouble __pyx_t_5numpy_longdouble_t;

/* "_common.pxd":6
 * from libcpp.vector cimport vector
 * 
 * ctypedef unsigned size_t             # <<<<<<<<<<<<<<
 * ctypedef size_t tsize
 * 
 */
typedef unsigned int __pyx_t_7_common_size_t;

/* "_common.pxd":7
 * 
 * ctypedef unsigned size_t
 * ctypedef size_t tsize             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "stddef.h":
 */
typedef size_t __pyx_t_7_common_tsize;

/* "_common.pxd":11
 * cdef extern from "stddef.h":
 *     ctypedef long ptrdiff_t
 * ctypedef ptrdiff_t tdiff             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "datatypes.h":
 */
typedef ptrdiff_t __pyx_t_7_common_tdiff;
/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    typedef ::std::complex< double > __pyx_t_double_complex;
  #else
    typedef double _Complex __pyx_t_double_complex;
  #endif
#else
    typedef struct { double real, imag; } __pyx_t_double_complex;
#endif

/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    typedef ::std::complex< float > __pyx_t_float_complex;
  #else
    typedef float _Complex __pyx_t_float_complex;
  #endif
#else
    typedef struct { float real, imag; } __pyx_t_float_complex;
#endif


/*--- Type declarations ---*/

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":764
 * ctypedef npy_longdouble longdouble_t
 * 
 * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
 * ctypedef npy_cdouble     cdouble_t
 * ctypedef npy_clongdouble clongdouble_t
 */
typedef npy_cfloat __pyx_t_5numpy_cfloat_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":765
 * 
 * ctypedef npy_cfloat      cfloat_t
 * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
 * ctypedef npy_clongdouble clongdouble_t
 * 
 */
typedef npy_cdouble __pyx_t_5numpy_cdouble_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":766
 * ctypedef npy_cfloat      cfloat_t
 * ctypedef npy_cdouble     cdouble_t
 * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
 * 
 * ctypedef npy_cdouble     complex_t
 */
typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":768
 * ctypedef npy_clongdouble clongdouble_t
 * 
 * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew1(a):
 */
typedef npy_cdouble __pyx_t_5numpy_complex_t;

/* --- Runtime support code (head) --- */
/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
  #define CYTHON_REFNANNY 0
#endif
#if CYTHON_REFNANNY
  typedef struct {
    void (*INCREF)(void*, PyObject*, int);
    void (*DECREF)(void*, PyObject*, int);
    void (*GOTREF)(void*, PyObject*, int);
    void (*GIVEREF)(void*, PyObject*, int);
    void* (*SetupContext)(const char*, int, const char*);
    void (*FinishContext)(void**);
  } __Pyx_RefNannyAPIStruct;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
#ifdef WITH_THREAD
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          if (acquire_gil) {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
              PyGILState_Release(__pyx_gilstate_save);\
          } else {\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
          }
#else
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
#endif
  #define __Pyx_RefNannyFinishContext()\
          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
#else
  #define __Pyx_RefNannyDeclarations
  #define __Pyx_RefNannySetupContext(name, acquire_gil)
  #define __Pyx_RefNannyFinishContext()
  #define __Pyx_INCREF(r) Py_INCREF(r)
  #define __Pyx_DECREF(r) Py_DECREF(r)
  #define __Pyx_GOTREF(r)
  #define __Pyx_GIVEREF(r)
  #define __Pyx_XINCREF(r) Py_XINCREF(r)
  #define __Pyx_XDECREF(r) Py_XDECREF(r)
  #define __Pyx_XGOTREF(r)
  #define __Pyx_XGIVEREF(r)
#endif
#define __Pyx_XDECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_XDECREF(tmp);\
    } while (0)
#define __Pyx_DECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_DECREF(tmp);\
    } while (0)
#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)

/* PyObjectGetAttrStr.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_getattr))
        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
    return PyObject_GetAttr(obj, attr_name);
}
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif

/* GetBuiltinName.proto */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);

/* GetModuleGlobalName.proto */
static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);

/* PyObjectCall.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif

/* PyObjectCallMethO.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif

/* PyObjectCallOneArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);

/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);

/* RaiseDoubleKeywords.proto */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);

/* ParseKeywords.proto */
static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
    const char* function_name);

/* ListCompAppend.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
    PyListObject* L = (PyListObject*) list;
    Py_ssize_t len = Py_SIZE(list);
    if (likely(L->allocated > len)) {
        Py_INCREF(x);
        PyList_SET_ITEM(list, len, x);
        Py_SIZE(list) = len+1;
        return 0;
    }
    return PyList_Append(list, x);
}
#else
#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
#endif

/* ExtTypeTest.proto */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);

/* GetItemInt.proto */
#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                                                     int is_list, int wraparound, int boundscheck);

/* PyThreadStateGet.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
#define __Pyx_PyThreadState_assign  __pyx_tstate = PyThreadState_GET();
#else
#define __Pyx_PyThreadState_declare
#define __Pyx_PyThreadState_assign
#endif

/* PyErrFetchRestore.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
#endif

/* RaiseException.proto */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);

/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);

/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);

/* IterFinish.proto */
static CYTHON_INLINE int __Pyx_IterFinish(void);

/* UnpackItemEndCheck.proto */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);

/* PyIntBinop.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
#else
#define __Pyx_PyInt_EqObjC(op1, op2, intval, inplace)\
    PyObject_RichCompare(op1, op2, Py_EQ)
    #endif

/* None.proto */
static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);

/* PyObjectCallNoArg.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
#else
#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
#endif

/* PyIntBinop.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
#else
#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\
    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
#endif

/* BufferFormatCheck.proto */
static CYTHON_INLINE int  __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
                              __Pyx_BufFmt_StackElem* stack,
                              __Pyx_TypeInfo* type); // PROTO

/* BufferFallbackError.proto */
static void __Pyx_RaiseBufferFallbackError(void);

/* BufferIndexError.proto */
static void __Pyx_RaiseBufferIndexError(int axis);

#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)
/* ListAppend.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
    PyListObject* L = (PyListObject*) list;
    Py_ssize_t len = Py_SIZE(list);
    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
        Py_INCREF(x);
        PyList_SET_ITEM(list, len, x);
        Py_SIZE(list) = len+1;
        return 0;
    }
    return PyList_Append(list, x);
}
#else
#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
#endif

/* PyObjectCallMethod1.proto */
static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg);

/* append.proto */
static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x);

/* None.proto */
static CYTHON_INLINE long __Pyx_div_long(long, long);

/* WriteUnraisableException.proto */
static void __Pyx_WriteUnraisable(const char *name, int clineno,
                                  int lineno, const char *filename,
                                  int full_traceback, int nogil);

/* PyIntBinop.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_AddCObj(PyObject *op1, PyObject *op2, long intval, int inplace);
#else
#define __Pyx_PyInt_AddCObj(op1, op2, intval, inplace)\
    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
#endif

/* PyObjectSetAttrStr.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL)
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_setattro))
        return tp->tp_setattro(obj, attr_name, value);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_setattr))
        return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
#endif
    return PyObject_SetAttr(obj, attr_name, value);
}
#else
#define __Pyx_PyObject_DelAttrStr(o,n)   PyObject_DelAttr(o,n)
#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
#endif

/* ArgTypeTest.proto */
static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
    const char *name, int exact);

#define __Pyx_BufPtrCContig1d(type, buf, i0, s0) ((type)buf + i0)
/* DictGetItem.proto */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
    PyObject *value;
    value = PyDict_GetItemWithError(d, key);
    if (unlikely(!value)) {
        if (!PyErr_Occurred()) {
            PyObject* args = PyTuple_Pack(1, key);
            if (likely(args))
                PyErr_SetObject(PyExc_KeyError, args);
            Py_XDECREF(args);
        }
        return NULL;
    }
    Py_INCREF(value);
    return value;
}
#else
    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#endif

/* RaiseNoneIterError.proto */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);

/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);

/* ImportFrom.proto */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);

/* CodeObjectCache.proto */
typedef struct {
    PyCodeObject* code_object;
    int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
    int count;
    int max_count;
    __Pyx_CodeObjectCacheEntry* entries;
};
static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
static PyCodeObject *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);

/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename);

/* BufferStructDeclare.proto */
typedef struct {
  Py_ssize_t shape, strides, suboffsets;
} __Pyx_Buf_DimInfo;
typedef struct {
  size_t refcount;
  Py_buffer pybuffer;
} __Pyx_Buffer;
typedef struct {
  __Pyx_Buffer *rcbuffer;
  char *data;
  __Pyx_Buf_DimInfo diminfo[8];
} __Pyx_LocalBuf_ND;

#if PY_MAJOR_VERSION < 3
    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
    static void __Pyx_ReleaseBuffer(Py_buffer *view);
#else
    #define __Pyx_GetBuffer PyObject_GetBuffer
    #define __Pyx_ReleaseBuffer PyBuffer_Release
#endif


/* None.proto */
static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0};
static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1};

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);

/* CppExceptionConversion.proto */
#ifndef __Pyx_CppExn2PyErr
#include 
#include 
#include 
#include 
static void __Pyx_CppExn2PyErr() {
  try {
    if (PyErr_Occurred())
      ; // let the latest Python exn pass through and ignore the current one
    else
      throw;
  } catch (const std::bad_alloc& exn) {
    PyErr_SetString(PyExc_MemoryError, exn.what());
  } catch (const std::bad_cast& exn) {
    PyErr_SetString(PyExc_TypeError, exn.what());
  } catch (const std::domain_error& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
  } catch (const std::invalid_argument& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
  } catch (const std::ios_base::failure& exn) {
    PyErr_SetString(PyExc_IOError, exn.what());
  } catch (const std::out_of_range& exn) {
    PyErr_SetString(PyExc_IndexError, exn.what());
  } catch (const std::overflow_error& exn) {
    PyErr_SetString(PyExc_OverflowError, exn.what());
  } catch (const std::range_error& exn) {
    PyErr_SetString(PyExc_ArithmeticError, exn.what());
  } catch (const std::underflow_error& exn) {
    PyErr_SetString(PyExc_ArithmeticError, exn.what());
  } catch (const std::exception& exn) {
    PyErr_SetString(PyExc_RuntimeError, exn.what());
  }
  catch (...)
  {
    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
  }
}
#endif

/* None.proto */
#if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    #define __Pyx_CREAL(z) ((z).real())
    #define __Pyx_CIMAG(z) ((z).imag())
  #else
    #define __Pyx_CREAL(z) (__real__(z))
    #define __Pyx_CIMAG(z) (__imag__(z))
  #endif
#else
    #define __Pyx_CREAL(z) ((z).real)
    #define __Pyx_CIMAG(z) ((z).imag)
#endif
#if defined(__cplusplus) && CYTHON_CCOMPLEX         && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
    #define __Pyx_SET_CREAL(z,x) ((z).real(x))
    #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
#else
    #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
    #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
#endif

/* None.proto */
static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);

/* None.proto */
#if CYTHON_CCOMPLEX
    #define __Pyx_c_eq(a, b)   ((a)==(b))
    #define __Pyx_c_sum(a, b)  ((a)+(b))
    #define __Pyx_c_diff(a, b) ((a)-(b))
    #define __Pyx_c_prod(a, b) ((a)*(b))
    #define __Pyx_c_quot(a, b) ((a)/(b))
    #define __Pyx_c_neg(a)     (-(a))
  #ifdef __cplusplus
    #define __Pyx_c_is_zero(z) ((z)==(double)0)
    #define __Pyx_c_conj(z)    (::std::conj(z))
    #if 1
        #define __Pyx_c_abs(z)     (::std::abs(z))
        #define __Pyx_c_pow(a, b)  (::std::pow(a, b))
    #endif
  #else
    #define __Pyx_c_is_zero(z) ((z)==0)
    #define __Pyx_c_conj(z)    (conj(z))
    #if 1
        #define __Pyx_c_abs(z)     (cabs(z))
        #define __Pyx_c_pow(a, b)  (cpow(a, b))
    #endif
 #endif
#else
    static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex);
    static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex);
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex);
    #if 1
        static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex);
        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex);
    #endif
#endif

/* None.proto */
static CYTHON_INLINE long __Pyx_pow_long(long, long);

/* None.proto */
static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);

/* None.proto */
#if CYTHON_CCOMPLEX
    #define __Pyx_c_eqf(a, b)   ((a)==(b))
    #define __Pyx_c_sumf(a, b)  ((a)+(b))
    #define __Pyx_c_difff(a, b) ((a)-(b))
    #define __Pyx_c_prodf(a, b) ((a)*(b))
    #define __Pyx_c_quotf(a, b) ((a)/(b))
    #define __Pyx_c_negf(a)     (-(a))
  #ifdef __cplusplus
    #define __Pyx_c_is_zerof(z) ((z)==(float)0)
    #define __Pyx_c_conjf(z)    (::std::conj(z))
    #if 1
        #define __Pyx_c_absf(z)     (::std::abs(z))
        #define __Pyx_c_powf(a, b)  (::std::pow(a, b))
    #endif
  #else
    #define __Pyx_c_is_zerof(z) ((z)==0)
    #define __Pyx_c_conjf(z)    (conjf(z))
    #if 1
        #define __Pyx_c_absf(z)     (cabsf(z))
        #define __Pyx_c_powf(a, b)  (cpowf(a, b))
    #endif
 #endif
#else
    static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex);
    static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex);
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex);
    #if 1
        static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex);
        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex);
    #endif
#endif

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);

/* CIntFromPy.proto */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);

/* CIntFromPy.proto */
static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);

/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(void);

/* PyIdentifierFromString.proto */
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif

/* ModuleImport.proto */
static PyObject *__Pyx_ImportModule(const char *name);

/* TypeImport.proto */
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);

/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);


/* Module declarations from 'cpython.buffer' */

/* Module declarations from 'libc.string' */

/* Module declarations from 'libc.stdio' */

/* Module declarations from '__builtin__' */

/* Module declarations from 'cpython.type' */
static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;

/* Module declarations from 'cpython' */

/* Module declarations from 'cpython.object' */

/* Module declarations from 'cpython.ref' */

/* Module declarations from 'libc.stdlib' */

/* Module declarations from 'numpy' */

/* Module declarations from 'numpy' */
static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/

/* Module declarations from 'libcpp.string' */

/* Module declarations from 'libc.math' */

/* Module declarations from 'libc' */

/* Module declarations from 'cython' */

/* Module declarations from 'libcpp' */

/* Module declarations from 'libcpp.vector' */

/* Module declarations from '_common' */
static CYTHON_INLINE Healpix_Map  *__pyx_f_7_common_ndarray2map(PyArrayObject *, enum Healpix_Ordering_Scheme); /*proto*/
static CYTHON_INLINE Alm >  *__pyx_f_7_common_ndarray2alm(PyArrayObject *, int, int); /*proto*/

/* Module declarations from 'healpy._sphtools' */
static double __pyx_v_6healpy_9_sphtools_UNSEEN;
static double __pyx_v_6healpy_9_sphtools_rtol_UNSEEN;
static int __pyx_f_6healpy_9_sphtools_alm_getn(int, int); /*proto*/
static CYTHON_INLINE int __pyx_f_6healpy_9_sphtools_alm_getlmax(int); /*proto*/
static CYTHON_INLINE int __pyx_f_6healpy_9_sphtools_alm_getlmax2(int, int); /*proto*/
static CYTHON_INLINE int __pyx_f_6healpy_9_sphtools_alm_getidx(int, int, int); /*proto*/
static PyObject *__pyx_f_6healpy_9_sphtools_mkmask(PyArrayObject *, int __pyx_skip_dispatch); /*proto*/
static int __pyx_f_6healpy_9_sphtools_count_bad(PyArrayObject *, int __pyx_skip_dispatch); /*proto*/
static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo___pyx_t_double_complex = { "double complex", NULL, sizeof(__pyx_t_double_complex), { 0 }, 0, 'C', 0, 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t = { "int8_t", NULL, sizeof(__pyx_t_5numpy_int8_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int8_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int8_t), 0 };
static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float64_t = { "float64_t", NULL, sizeof(__pyx_t_5numpy_float64_t), { 0 }, 0, 'R', 0, 0 };
#define __Pyx_MODULE_NAME "healpy._sphtools"
int __pyx_module_is_main_healpy___sphtools = 0;

/* Implementation of 'healpy._sphtools' */
static PyObject *__pyx_builtin_ValueError;
static PyObject *__pyx_builtin_zip;
static PyObject *__pyx_builtin_IOError;
static PyObject *__pyx_builtin_range;
static PyObject *__pyx_builtin_xrange;
static PyObject *__pyx_builtin_RuntimeError;
static const char __pyx_k_a[] = "a";
static const char __pyx_k_f[] = "f";
static const char __pyx_k_i[] = "i";
static const char __pyx_k_j[] = "j";
static const char __pyx_k_l[] = "l";
static const char __pyx_k_m[] = "m";
static const char __pyx_k_n[] = "n";
static const char __pyx_k_A1[] = "A1";
static const char __pyx_k_A2[] = "A2";
static const char __pyx_k_AC[] = "AC";
static const char __pyx_k_AG[] = "AG";
static const char __pyx_k_AI[] = "AI";
static const char __pyx_k_M1[] = "M1";
static const char __pyx_k_M2[] = "M2";
static const char __pyx_k_MI[] = "MI";
static const char __pyx_k_MQ[] = "MQ";
static const char __pyx_k_MU[] = "MU";
static const char __pyx_k_ac[] = "ac";
static const char __pyx_k_ag[] = "ag";
static const char __pyx_k_ai[] = "ai";
static const char __pyx_k_fl[] = "fl";
static const char __pyx_k_mi[] = "mi";
static const char __pyx_k_mq[] = "mq";
static const char __pyx_k_mu[] = "mu";
static const char __pyx_k_np[] = "np";
static const char __pyx_k_os[] = "os";
static const char __pyx_k_alm[] = "alm";
static const char __pyx_k_len[] = "__len__";
static const char __pyx_k_phi[] = "phi";
static const char __pyx_k_psi[] = "psi";
static const char __pyx_k_zip[] = "zip";
static const char __pyx_k_alm1[] = "alm1_";
static const char __pyx_k_alm2[] = "alm2_";
static const char __pyx_k_almC[] = "almC";
static const char __pyx_k_almG[] = "almG";
static const char __pyx_k_almI[] = "almI";
static const char __pyx_k_alms[] = "alms";
static const char __pyx_k_copy[] = "copy";
static const char __pyx_k_data[] = "data";
static const char __pyx_k_file[] = "__file__";
static const char __pyx_k_fl_2[] = "fl_";
static const char __pyx_k_info[] = "info";
static const char __pyx_k_int8[] = "int8";
static const char __pyx_k_join[] = "join";
static const char __pyx_k_lmax[] = "lmax";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_maps[] = "maps";
static const char __pyx_k_mask[] = "mask";
static const char __pyx_k_maxm[] = "maxm";
static const char __pyx_k_mmax[] = "mmax";
static const char __pyx_k_ndim[] = "ndim";
static const char __pyx_k_npix[] = "npix";
static const char __pyx_k_path[] = "path";
static const char __pyx_k_size[] = "size";
static const char __pyx_k_spin[] = "spin";
static const char __pyx_k_sqrt[] = "sqrt";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_Nspec[] = "Nspec";
static const char __pyx_k_alm_2[] = "alm_";
static const char __pyx_k_alms2[] = "alms2";
static const char __pyx_k_array[] = "array";
static const char __pyx_k_dtype[] = "dtype";
static const char __pyx_k_empty[] = "empty";
static const char __pyx_k_limit[] = "limit";
static const char __pyx_k_masks[] = "masks";
static const char __pyx_k_n_alm[] = "n_alm";
static const char __pyx_k_niter[] = "niter";
static const char __pyx_k_nside[] = "nside";
static const char __pyx_k_numpy[] = "numpy";
static const char __pyx_k_range[] = "range";
static const char __pyx_k_theta[] = "theta";
static const char __pyx_k_w_arr[] = "w_arr";
static const char __pyx_k_zeros[] = "zeros";
static const char __pyx_k_Nspec2[] = "Nspec2";
static const char __pyx_k_alm2cl[] = "alm2cl";
static const char __pyx_k_alms_c[] = "alms_c";
static const char __pyx_k_almxfl[] = "almxfl";
static const char __pyx_k_append[] = "append";
static const char __pyx_k_flsize[] = "flsize";
static const char __pyx_k_healpy[] = "healpy";
static const char __pyx_k_import[] = "__import__";
static const char __pyx_k_isfile[] = "isfile";
static const char __pyx_k_lmax_2[] = "lmax_";
static const char __pyx_k_maps_c[] = "maps_c";
static const char __pyx_k_mmax_2[] = "mmax_";
static const char __pyx_k_xrange[] = "xrange";
static const char __pyx_k_IOError[] = "IOError";
static const char __pyx_k_abspath[] = "abspath";
static const char __pyx_k_almsize[] = "almsize";
static const char __pyx_k_dirname[] = "dirname";
static const char __pyx_k_float64[] = "float64";
static const char __pyx_k_inplace[] = "inplace";
static const char __pyx_k_map2alm[] = "map2alm";
static const char __pyx_k_maptype[] = "maptype";
static const char __pyx_k_mask_mi[] = "mask_mi";
static const char __pyx_k_mask_mq[] = "mask_mq";
static const char __pyx_k_mask_mu[] = "mask_mu";
static const char __pyx_k_powspec[] = "powspec_";
static const char __pyx_k_spectra[] = "spectra";
static const char __pyx_k_DATAPATH[] = "DATAPATH";
static const char __pyx_k_datapath[] = "datapath";
static const char __pyx_k_lmax_out[] = "lmax_out";
static const char __pyx_k_ValueError[] = "ValueError";
static const char __pyx_k_c_datapath[] = "c_datapath";
static const char __pyx_k_complex128[] = "complex128";
static const char __pyx_k_lmax_out_2[] = "lmax_out_";
static const char __pyx_k_npix2nside[] = "npix2nside";
static const char __pyx_k_nside2npix[] = "nside2npix";
static const char __pyx_k_rotate_alm[] = "rotate_alm";
static const char __pyx_k_weightfile[] = "weightfile";
static const char __pyx_k_alms_lonely[] = "alms_lonely";
static const char __pyx_k_use_weights[] = "use_weights";
static const char __pyx_k_RuntimeError[] = "RuntimeError";
static const char __pyx_k_alm_getlmmax[] = "alm_getlmmax";
static const char __pyx_k_get_datapath[] = "get_datapath";
static const char __pyx_k_polarization[] = "polarization";
static const char __pyx_k_Invalid_input[] = "Invalid input.";
static const char __pyx_k_healpy__sphtools[] = "healpy._sphtools";
static const char __pyx_k_healpy_pixelfunc[] = "healpy.pixelfunc";
static const char __pyx_k_ascontiguousarray[] = "ascontiguousarray";
static const char __pyx_k_mmax_must_be_lmax[] = "mmax must be <= lmax";
static const char __pyx_k_alm2map_spin_healpy[] = "alm2map_spin_healpy";
static const char __pyx_k_map2alm_spin_healpy[] = "map2alm_spin_healpy";
static const char __pyx_k_weight_ring_n_05d_fits[] = "weight_ring_n%05d.fits";
static const char __pyx_k_Weight_file_not_found_in_s[] = "Weight file not found in %s";
static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
static const char __pyx_k_all_alms_must_have_same_size[] = "all alms must have same size";
static const char __pyx_k_Input_maps_must_have_same_size[] = "Input maps must have same size";
static const char __pyx_k_Wrong_input_map_must_be_a_valid[] = "Wrong input map (must be a valid healpix map or a sequence of 1 or 3 maps)";
static const char __pyx_k_home_zonca_zonca_p_software_hea[] = "/home/zonca/zonca/p/software/healpy/healpy/src/_sphtools.pyx";
static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
static const char __pyx_k_alms2_must_be_an_array_or_a_sequ[] = "alms2 must be an array or a sequence of arrays";
static const char __pyx_k_alms_and_alms2_must_have_same_nu[] = "alms and alms2 must have same number of spectra";
static const char __pyx_k_alms_must_be_an_array_or_a_seque[] = "alms must be an array or a sequence of arrays";
static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
static PyObject *__pyx_n_s_A1;
static PyObject *__pyx_n_s_A2;
static PyObject *__pyx_n_s_AC;
static PyObject *__pyx_n_s_AG;
static PyObject *__pyx_n_s_AI;
static PyObject *__pyx_n_s_DATAPATH;
static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
static PyObject *__pyx_n_s_IOError;
static PyObject *__pyx_kp_s_Input_maps_must_have_same_size;
static PyObject *__pyx_kp_s_Invalid_input;
static PyObject *__pyx_n_s_M1;
static PyObject *__pyx_n_s_M2;
static PyObject *__pyx_n_s_MI;
static PyObject *__pyx_n_s_MQ;
static PyObject *__pyx_n_s_MU;
static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
static PyObject *__pyx_n_s_Nspec;
static PyObject *__pyx_n_s_Nspec2;
static PyObject *__pyx_n_s_RuntimeError;
static PyObject *__pyx_n_s_ValueError;
static PyObject *__pyx_kp_s_Weight_file_not_found_in_s;
static PyObject *__pyx_kp_s_Wrong_input_map_must_be_a_valid;
static PyObject *__pyx_n_s_a;
static PyObject *__pyx_n_s_abspath;
static PyObject *__pyx_n_s_ac;
static PyObject *__pyx_n_s_ag;
static PyObject *__pyx_n_s_ai;
static PyObject *__pyx_kp_s_all_alms_must_have_same_size;
static PyObject *__pyx_n_s_alm;
static PyObject *__pyx_n_s_alm1;
static PyObject *__pyx_n_s_alm2;
static PyObject *__pyx_n_s_alm2cl;
static PyObject *__pyx_n_s_alm2map_spin_healpy;
static PyObject *__pyx_n_s_almC;
static PyObject *__pyx_n_s_almG;
static PyObject *__pyx_n_s_almI;
static PyObject *__pyx_n_s_alm_2;
static PyObject *__pyx_n_s_alm_getlmmax;
static PyObject *__pyx_n_s_alms;
static PyObject *__pyx_n_s_alms2;
static PyObject *__pyx_kp_s_alms2_must_be_an_array_or_a_sequ;
static PyObject *__pyx_kp_s_alms_and_alms2_must_have_same_nu;
static PyObject *__pyx_n_s_alms_c;
static PyObject *__pyx_n_s_alms_lonely;
static PyObject *__pyx_kp_s_alms_must_be_an_array_or_a_seque;
static PyObject *__pyx_n_s_almsize;
static PyObject *__pyx_n_s_almxfl;
static PyObject *__pyx_n_s_append;
static PyObject *__pyx_n_s_array;
static PyObject *__pyx_n_s_ascontiguousarray;
static PyObject *__pyx_n_s_c_datapath;
static PyObject *__pyx_n_s_complex128;
static PyObject *__pyx_n_s_copy;
static PyObject *__pyx_n_s_data;
static PyObject *__pyx_n_s_datapath;
static PyObject *__pyx_n_s_dirname;
static PyObject *__pyx_n_s_dtype;
static PyObject *__pyx_n_s_empty;
static PyObject *__pyx_n_s_f;
static PyObject *__pyx_n_s_file;
static PyObject *__pyx_n_s_fl;
static PyObject *__pyx_n_s_fl_2;
static PyObject *__pyx_n_s_float64;
static PyObject *__pyx_n_s_flsize;
static PyObject *__pyx_n_s_get_datapath;
static PyObject *__pyx_n_s_healpy;
static PyObject *__pyx_n_s_healpy__sphtools;
static PyObject *__pyx_n_s_healpy_pixelfunc;
static PyObject *__pyx_kp_s_home_zonca_zonca_p_software_hea;
static PyObject *__pyx_n_s_i;
static PyObject *__pyx_n_s_import;
static PyObject *__pyx_n_s_info;
static PyObject *__pyx_n_s_inplace;
static PyObject *__pyx_n_s_int8;
static PyObject *__pyx_n_s_isfile;
static PyObject *__pyx_n_s_j;
static PyObject *__pyx_n_s_join;
static PyObject *__pyx_n_s_l;
static PyObject *__pyx_n_s_len;
static PyObject *__pyx_n_s_limit;
static PyObject *__pyx_n_s_lmax;
static PyObject *__pyx_n_s_lmax_2;
static PyObject *__pyx_n_s_lmax_out;
static PyObject *__pyx_n_s_lmax_out_2;
static PyObject *__pyx_n_s_m;
static PyObject *__pyx_n_s_main;
static PyObject *__pyx_n_s_map2alm;
static PyObject *__pyx_n_s_map2alm_spin_healpy;
static PyObject *__pyx_n_s_maps;
static PyObject *__pyx_n_s_maps_c;
static PyObject *__pyx_n_s_maptype;
static PyObject *__pyx_n_s_mask;
static PyObject *__pyx_n_s_mask_mi;
static PyObject *__pyx_n_s_mask_mq;
static PyObject *__pyx_n_s_mask_mu;
static PyObject *__pyx_n_s_masks;
static PyObject *__pyx_n_s_maxm;
static PyObject *__pyx_n_s_mi;
static PyObject *__pyx_n_s_mmax;
static PyObject *__pyx_n_s_mmax_2;
static PyObject *__pyx_kp_s_mmax_must_be_lmax;
static PyObject *__pyx_n_s_mq;
static PyObject *__pyx_n_s_mu;
static PyObject *__pyx_n_s_n;
static PyObject *__pyx_n_s_n_alm;
static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
static PyObject *__pyx_n_s_ndim;
static PyObject *__pyx_n_s_niter;
static PyObject *__pyx_n_s_np;
static PyObject *__pyx_n_s_npix;
static PyObject *__pyx_n_s_npix2nside;
static PyObject *__pyx_n_s_nside;
static PyObject *__pyx_n_s_nside2npix;
static PyObject *__pyx_n_s_numpy;
static PyObject *__pyx_n_s_os;
static PyObject *__pyx_n_s_path;
static PyObject *__pyx_n_s_phi;
static PyObject *__pyx_n_s_polarization;
static PyObject *__pyx_n_s_powspec;
static PyObject *__pyx_n_s_psi;
static PyObject *__pyx_n_s_range;
static PyObject *__pyx_n_s_rotate_alm;
static PyObject *__pyx_n_s_size;
static PyObject *__pyx_n_s_spectra;
static PyObject *__pyx_n_s_spin;
static PyObject *__pyx_n_s_sqrt;
static PyObject *__pyx_n_s_test;
static PyObject *__pyx_n_s_theta;
static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
static PyObject *__pyx_n_s_use_weights;
static PyObject *__pyx_n_s_w_arr;
static PyObject *__pyx_kp_s_weight_ring_n_05d_fits;
static PyObject *__pyx_n_s_weightfile;
static PyObject *__pyx_n_s_xrange;
static PyObject *__pyx_n_s_zeros;
static PyObject *__pyx_n_s_zip;
static PyObject *__pyx_pf_6healpy_9_sphtools_get_datapath(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_2map2alm_spin_healpy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_maps, PyObject *__pyx_v_spin, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_4alm2map_spin_healpy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_alms, PyObject *__pyx_v_nside, PyObject *__pyx_v_spin, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_6map2alm(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_m, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax, PyObject *__pyx_v_niter, PyObject *__pyx_v_use_weights, PyObject *__pyx_v_datapath); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_8alm2cl(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_alms, PyObject *__pyx_v_alms2, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax, PyObject *__pyx_v_lmax_out); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_10almxfl(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_alm, PyObject *__pyx_v_fl, PyObject *__pyx_v_mmax, PyObject *__pyx_v_inplace); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_12rotate_alm(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_alm, double __pyx_v_psi, double __pyx_v_theta, double __pyx_v_phi, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_14alm_getlmmax(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_a, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_16mkmask(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_m); /* proto */
static PyObject *__pyx_pf_6healpy_9_sphtools_18count_bad(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_m); /* proto */
static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
static PyObject *__pyx_float_0_0;
static PyObject *__pyx_int_0;
static PyObject *__pyx_int_1;
static PyObject *__pyx_int_2;
static PyObject *__pyx_int_3;
static PyObject *__pyx_int_neg_3;
static PyObject *__pyx_tuple_;
static PyObject *__pyx_tuple__2;
static PyObject *__pyx_tuple__3;
static PyObject *__pyx_tuple__4;
static PyObject *__pyx_tuple__5;
static PyObject *__pyx_tuple__6;
static PyObject *__pyx_tuple__7;
static PyObject *__pyx_tuple__8;
static PyObject *__pyx_tuple__9;
static PyObject *__pyx_tuple__10;
static PyObject *__pyx_tuple__11;
static PyObject *__pyx_tuple__12;
static PyObject *__pyx_tuple__13;
static PyObject *__pyx_tuple__14;
static PyObject *__pyx_tuple__15;
static PyObject *__pyx_tuple__17;
static PyObject *__pyx_tuple__19;
static PyObject *__pyx_tuple__21;
static PyObject *__pyx_tuple__23;
static PyObject *__pyx_tuple__25;
static PyObject *__pyx_tuple__27;
static PyObject *__pyx_tuple__29;
static PyObject *__pyx_codeobj__16;
static PyObject *__pyx_codeobj__18;
static PyObject *__pyx_codeobj__20;
static PyObject *__pyx_codeobj__22;
static PyObject *__pyx_codeobj__24;
static PyObject *__pyx_codeobj__26;
static PyObject *__pyx_codeobj__28;
static PyObject *__pyx_codeobj__30;

/* "healpy/src/_sphtools.pyx":54
 * DATAPATH = None
 * 
 * def get_datapath():             # <<<<<<<<<<<<<<
 *     global DATAPATH
 *     if DATAPATH is None:
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_1get_datapath(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_get_datapath[] = "get_datapath()";
static PyMethodDef __pyx_mdef_6healpy_9_sphtools_1get_datapath = {"get_datapath", (PyCFunction)__pyx_pw_6healpy_9_sphtools_1get_datapath, METH_NOARGS, __pyx_doc_6healpy_9_sphtools_get_datapath};
static PyObject *__pyx_pw_6healpy_9_sphtools_1get_datapath(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("get_datapath (wrapper)", 0);
  __pyx_r = __pyx_pf_6healpy_9_sphtools_get_datapath(__pyx_self);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_get_datapath(CYTHON_UNUSED PyObject *__pyx_self) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  Py_ssize_t __pyx_t_12;
  __Pyx_RefNannySetupContext("get_datapath", 0);

  /* "healpy/src/_sphtools.pyx":56
 * def get_datapath():
 *     global DATAPATH
 *     if DATAPATH is None:             # <<<<<<<<<<<<<<
 *         DATAPATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')
 *     return DATAPATH
 */
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DATAPATH); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = (__pyx_t_1 == Py_None);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {

    /* "healpy/src/_sphtools.pyx":57
 *     global DATAPATH
 *     if DATAPATH is None:
 *         DATAPATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')             # <<<<<<<<<<<<<<
 *     return DATAPATH
 * 
 */
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_path); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_join); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_path); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_dirname); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_path); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_abspath); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_file); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_10 = NULL;
    if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_8))) {
      __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8);
      if (likely(__pyx_t_10)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
        __Pyx_INCREF(__pyx_t_10);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_8, function);
      }
    }
    if (!__pyx_t_10) {
      __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 57, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_GOTREF(__pyx_t_7);
    } else {
      __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 57, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL;
      __Pyx_GIVEREF(__pyx_t_9);
      PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_9);
      __pyx_t_9 = 0;
      __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 57, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    }
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = NULL;
    if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
      if (likely(__pyx_t_8)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
        __Pyx_INCREF(__pyx_t_8);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_6, function);
      }
    }
    if (!__pyx_t_8) {
      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __Pyx_GOTREF(__pyx_t_5);
    } else {
      __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 57, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL;
      __Pyx_GIVEREF(__pyx_t_7);
      PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_7);
      __pyx_t_7 = 0;
      __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 57, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    }
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = NULL;
    __pyx_t_12 = 0;
    if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_6)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
        __pyx_t_12 = 1;
      }
    }
    __pyx_t_11 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_11);
    if (__pyx_t_6) {
      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_6); __pyx_t_6 = NULL;
    }
    __Pyx_GIVEREF(__pyx_t_5);
    PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_12, __pyx_t_5);
    __Pyx_INCREF(__pyx_n_s_data);
    __Pyx_GIVEREF(__pyx_n_s_data);
    PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_12, __pyx_n_s_data);
    __pyx_t_5 = 0;
    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (PyDict_SetItem(__pyx_d, __pyx_n_s_DATAPATH, __pyx_t_1) < 0) __PYX_ERR(0, 57, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

    /* "healpy/src/_sphtools.pyx":56
 * def get_datapath():
 *     global DATAPATH
 *     if DATAPATH is None:             # <<<<<<<<<<<<<<
 *         DATAPATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')
 *     return DATAPATH
 */
  }

  /* "healpy/src/_sphtools.pyx":58
 *     if DATAPATH is None:
 *         DATAPATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')
 *     return DATAPATH             # <<<<<<<<<<<<<<
 * 
 * def map2alm_spin_healpy(maps, spin, lmax = None, mmax = None):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DATAPATH); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":54
 * DATAPATH = None
 * 
 * def get_datapath():             # <<<<<<<<<<<<<<
 *     global DATAPATH
 *     if DATAPATH is None:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("healpy._sphtools.get_datapath", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":60
 *     return DATAPATH
 * 
 * def map2alm_spin_healpy(maps, spin, lmax = None, mmax = None):             # <<<<<<<<<<<<<<
 *     """Computes the spinned alm of a 2 Healpix maps.
 * 
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_3map2alm_spin_healpy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_2map2alm_spin_healpy[] = "map2alm_spin_healpy(maps, spin, lmax=None, mmax=None)\nComputes the spinned alm of a 2 Healpix maps.\n\n    Parameters\n    ----------\n    m : list of 2 arrays\n        list of 2 input maps as numpy arrays\n    spin : int\n        spin of the alms (either 1, 2 or 3)\n    lmax : int, scalar, optional\n      Maximum l of the power spectrum. Default: 3*nside-1\n    mmax : int, scalar, optional\n      Maximum m of the alm. Default: lmax\n    \n    Returns\n    -------\n    alms : list of 2 arrays\n      list of 2 alms\n    ";
static PyMethodDef __pyx_mdef_6healpy_9_sphtools_3map2alm_spin_healpy = {"map2alm_spin_healpy", (PyCFunction)__pyx_pw_6healpy_9_sphtools_3map2alm_spin_healpy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_9_sphtools_2map2alm_spin_healpy};
static PyObject *__pyx_pw_6healpy_9_sphtools_3map2alm_spin_healpy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_maps = 0;
  PyObject *__pyx_v_spin = 0;
  PyObject *__pyx_v_lmax = 0;
  PyObject *__pyx_v_mmax = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("map2alm_spin_healpy (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_maps,&__pyx_n_s_spin,&__pyx_n_s_lmax,&__pyx_n_s_mmax,0};
    PyObject* values[4] = {0,0,0,0};
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maps)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_spin)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("map2alm_spin_healpy", 0, 2, 4, 1); __PYX_ERR(0, 60, __pyx_L3_error)
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lmax);
          if (value) { values[2] = value; kw_args--; }
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mmax);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "map2alm_spin_healpy") < 0)) __PYX_ERR(0, 60, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_maps = values[0];
    __pyx_v_spin = values[1];
    __pyx_v_lmax = values[2];
    __pyx_v_mmax = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("map2alm_spin_healpy", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 60, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._sphtools.map2alm_spin_healpy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_9_sphtools_2map2alm_spin_healpy(__pyx_self, __pyx_v_maps, __pyx_v_spin, __pyx_v_lmax, __pyx_v_mmax);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_2map2alm_spin_healpy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_maps, PyObject *__pyx_v_spin, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax) {
  PyObject *__pyx_v_maps_c = NULL;
  PyObject *__pyx_v_masks = NULL;
  int __pyx_v_lmax_;
  int __pyx_v_mmax_;
  int __pyx_v_nside;
  int __pyx_v_npix;
  Healpix_Map  *__pyx_v_M1;
  Healpix_Map  *__pyx_v_M2;
  PyObject *__pyx_v_m = NULL;
  PyObject *__pyx_v_mask = NULL;
  int __pyx_v_n_alm;
  PyObject *__pyx_v_alms = NULL;
  Alm >  *__pyx_v_A1;
  Alm >  *__pyx_v_A2;
  arr  *__pyx_v_w_arr;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  Py_ssize_t __pyx_t_3;
  PyObject *(*__pyx_t_4)(PyObject *);
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  int __pyx_t_10;
  int __pyx_t_11;
  int __pyx_t_12;
  Healpix_Map  *__pyx_t_13;
  PyObject *(*__pyx_t_14)(PyObject *);
  Alm >  *__pyx_t_15;
  __Pyx_RefNannySetupContext("map2alm_spin_healpy", 0);

  /* "healpy/src/_sphtools.pyx":79
 *       list of 2 alms
 *     """
 *     maps_c = [np.ascontiguousarray(m, dtype=np.float64) for m in maps]             # <<<<<<<<<<<<<<
 * 
 *     # create UNSEEN mask for map
 */
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (likely(PyList_CheckExact(__pyx_v_maps)) || PyTuple_CheckExact(__pyx_v_maps)) {
    __pyx_t_2 = __pyx_v_maps; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_maps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 79, __pyx_L1_error)
        #else
        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        #endif
      } else {
        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 79, __pyx_L1_error)
        #else
        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        #endif
      }
    } else {
      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
      if (unlikely(!__pyx_t_5)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 79, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_5);
    }
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_5);
    __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_INCREF(__pyx_v_m);
    __Pyx_GIVEREF(__pyx_v_m);
    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_m);
    __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_float64); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 79, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_maps_c = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":82
 * 
 *     # create UNSEEN mask for map
 *     masks = [False if count_bad(m) == 0 else mkmask(m) for m in maps_c]             # <<<<<<<<<<<<<<
 * 
 *     # Adjust lmax and mmax
 */
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_v_maps_c; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
  for (;;) {
    if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
    #if CYTHON_COMPILING_IN_CPYTHON
    __pyx_t_9 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_9); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 82, __pyx_L1_error)
    #else
    __pyx_t_9 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 82, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    #endif
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_9);
    __pyx_t_9 = 0;
    if (!(likely(((__pyx_v_m) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_m, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 82, __pyx_L1_error)
    if (((__pyx_f_6healpy_9_sphtools_count_bad(((PyArrayObject *)__pyx_v_m), 0) == 0) != 0)) {
      __Pyx_INCREF(Py_False);
      __pyx_t_9 = Py_False;
    } else {
      if (!(likely(((__pyx_v_m) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_m, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 82, __pyx_L1_error)
      __pyx_t_7 = __pyx_f_6healpy_9_sphtools_mkmask(((PyArrayObject *)__pyx_v_m), 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 82, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __pyx_t_9 = __pyx_t_7;
      __pyx_t_7 = 0;
    }
    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 82, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_masks = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":86
 *     # Adjust lmax and mmax
 *     cdef int lmax_, mmax_, nside, npix
 *     npix = maps_c[0].size             # <<<<<<<<<<<<<<
 *     nside = npix2nside(npix)
 *     if lmax is None:
 */
  __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_maps_c, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_npix = __pyx_t_10;

  /* "healpy/src/_sphtools.pyx":87
 *     cdef int lmax_, mmax_, nside, npix
 *     npix = maps_c[0].size
 *     nside = npix2nside(npix)             # <<<<<<<<<<<<<<
 *     if lmax is None:
 *         lmax_ = 3 * nside - 1
 */
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_npix2nside); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 87, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_7 = NULL;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_7)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  if (!__pyx_t_7) {
    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_GOTREF(__pyx_t_2);
  } else {
    __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = NULL;
    __Pyx_GIVEREF(__pyx_t_9);
    PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_9);
    __pyx_t_9 = 0;
    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_nside = __pyx_t_10;

  /* "healpy/src/_sphtools.pyx":88
 *     npix = maps_c[0].size
 *     nside = npix2nside(npix)
 *     if lmax is None:             # <<<<<<<<<<<<<<
 *         lmax_ = 3 * nside - 1
 *     else:
 */
  __pyx_t_11 = (__pyx_v_lmax == Py_None);
  __pyx_t_12 = (__pyx_t_11 != 0);
  if (__pyx_t_12) {

    /* "healpy/src/_sphtools.pyx":89
 *     nside = npix2nside(npix)
 *     if lmax is None:
 *         lmax_ = 3 * nside - 1             # <<<<<<<<<<<<<<
 *     else:
 *         lmax_ = lmax
 */
    __pyx_v_lmax_ = ((3 * __pyx_v_nside) - 1);

    /* "healpy/src/_sphtools.pyx":88
 *     npix = maps_c[0].size
 *     nside = npix2nside(npix)
 *     if lmax is None:             # <<<<<<<<<<<<<<
 *         lmax_ = 3 * nside - 1
 *     else:
 */
    goto __pyx_L7;
  }

  /* "healpy/src/_sphtools.pyx":91
 *         lmax_ = 3 * nside - 1
 *     else:
 *         lmax_ = lmax             # <<<<<<<<<<<<<<
 *     if mmax is None:
 *         mmax_ = lmax_
 */
  /*else*/ {
    __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_lmax); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 91, __pyx_L1_error)
    __pyx_v_lmax_ = __pyx_t_10;
  }
  __pyx_L7:;

  /* "healpy/src/_sphtools.pyx":92
 *     else:
 *         lmax_ = lmax
 *     if mmax is None:             # <<<<<<<<<<<<<<
 *         mmax_ = lmax_
 *     else:
 */
  __pyx_t_12 = (__pyx_v_mmax == Py_None);
  __pyx_t_11 = (__pyx_t_12 != 0);
  if (__pyx_t_11) {

    /* "healpy/src/_sphtools.pyx":93
 *         lmax_ = lmax
 *     if mmax is None:
 *         mmax_ = lmax_             # <<<<<<<<<<<<<<
 *     else:
 *         mmax_ = mmax
 */
    __pyx_v_mmax_ = __pyx_v_lmax_;

    /* "healpy/src/_sphtools.pyx":92
 *     else:
 *         lmax_ = lmax
 *     if mmax is None:             # <<<<<<<<<<<<<<
 *         mmax_ = lmax_
 *     else:
 */
    goto __pyx_L8;
  }

  /* "healpy/src/_sphtools.pyx":95
 *         mmax_ = lmax_
 *     else:
 *         mmax_ = mmax             # <<<<<<<<<<<<<<
 * 
 *     # Check all maps have same npix
 */
  /*else*/ {
    __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 95, __pyx_L1_error)
    __pyx_v_mmax_ = __pyx_t_10;
  }
  __pyx_L8:;

  /* "healpy/src/_sphtools.pyx":98
 * 
 *     # Check all maps have same npix
 *     if maps_c[1].size != npix:             # <<<<<<<<<<<<<<
 *         raise ValueError("Input maps must have same size")
 * 
 */
  __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_maps_c, 1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 98, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (__pyx_t_11) {

    /* "healpy/src/_sphtools.pyx":99
 *     # Check all maps have same npix
 *     if maps_c[1].size != npix:
 *         raise ValueError("Input maps must have same size")             # <<<<<<<<<<<<<<
 * 
 *     # View the ndarray as a Healpix_Map
 */
    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 99, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __PYX_ERR(0, 99, __pyx_L1_error)

    /* "healpy/src/_sphtools.pyx":98
 * 
 *     # Check all maps have same npix
 *     if maps_c[1].size != npix:             # <<<<<<<<<<<<<<
 *         raise ValueError("Input maps must have same size")
 * 
 */
  }

  /* "healpy/src/_sphtools.pyx":102
 * 
 *     # View the ndarray as a Healpix_Map
 *     M1 = ndarray2map(maps_c[0], RING)             # <<<<<<<<<<<<<<
 *     M2 = ndarray2map(maps_c[1], RING)
 * 
 */
  __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_maps_c, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 102, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 102, __pyx_L1_error)
  __pyx_t_13 = __pyx_f_7_common_ndarray2map(((PyArrayObject *)__pyx_t_5), RING); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 102, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_M1 = __pyx_t_13;

  /* "healpy/src/_sphtools.pyx":103
 *     # View the ndarray as a Healpix_Map
 *     M1 = ndarray2map(maps_c[0], RING)
 *     M2 = ndarray2map(maps_c[1], RING)             # <<<<<<<<<<<<<<
 * 
 *     # replace UNSEEN pixels with zeros
 */
  __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_maps_c, 1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 103, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 103, __pyx_L1_error)
  __pyx_t_13 = __pyx_f_7_common_ndarray2map(((PyArrayObject *)__pyx_t_5), RING); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 103, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_M2 = __pyx_t_13;

  /* "healpy/src/_sphtools.pyx":106
 * 
 *     # replace UNSEEN pixels with zeros
 *     for m, mask in zip(maps_c, masks):             # <<<<<<<<<<<<<<
 *         if mask:
 *             m[mask] = 0.0
 */
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_v_maps_c);
  __Pyx_GIVEREF(__pyx_v_maps_c);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_maps_c);
  __Pyx_INCREF(__pyx_v_masks);
  __Pyx_GIVEREF(__pyx_v_masks);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_masks);
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
    __pyx_t_5 = __pyx_t_2; __Pyx_INCREF(__pyx_t_5); __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_5))) {
        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_5)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 106, __pyx_L1_error)
        #else
        __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        #endif
      } else {
        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 106, __pyx_L1_error)
        #else
        __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        #endif
      }
    } else {
      __pyx_t_2 = __pyx_t_4(__pyx_t_5);
      if (unlikely(!__pyx_t_2)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 106, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_2);
    }
    if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
      PyObject* sequence = __pyx_t_2;
      #if CYTHON_COMPILING_IN_CPYTHON
      Py_ssize_t size = Py_SIZE(sequence);
      #else
      Py_ssize_t size = PySequence_Size(sequence);
      #endif
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 106, __pyx_L1_error)
      }
      #if CYTHON_COMPILING_IN_CPYTHON
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); 
        __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); 
      } else {
        __pyx_t_1 = PyList_GET_ITEM(sequence, 0); 
        __pyx_t_9 = PyList_GET_ITEM(sequence, 1); 
      }
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_9);
      #else
      __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 106, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      #endif
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_7 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 106, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_14 = Py_TYPE(__pyx_t_7)->tp_iternext;
      index = 0; __pyx_t_1 = __pyx_t_14(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L12_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_1);
      index = 1; __pyx_t_9 = __pyx_t_14(__pyx_t_7); if (unlikely(!__pyx_t_9)) goto __pyx_L12_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_9);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_7), 2) < 0) __PYX_ERR(0, 106, __pyx_L1_error)
      __pyx_t_14 = NULL;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      goto __pyx_L13_unpacking_done;
      __pyx_L12_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_14 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 106, __pyx_L1_error)
      __pyx_L13_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_1);
    __pyx_t_1 = 0;
    __Pyx_XDECREF_SET(__pyx_v_mask, __pyx_t_9);
    __pyx_t_9 = 0;

    /* "healpy/src/_sphtools.pyx":107
 *     # replace UNSEEN pixels with zeros
 *     for m, mask in zip(maps_c, masks):
 *         if mask:             # <<<<<<<<<<<<<<
 *             m[mask] = 0.0
 * 
 */
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_mask); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 107, __pyx_L1_error)
    if (__pyx_t_11) {

      /* "healpy/src/_sphtools.pyx":108
 *     for m, mask in zip(maps_c, masks):
 *         if mask:
 *             m[mask] = 0.0             # <<<<<<<<<<<<<<
 * 
 *     # Create an ndarray object that will contain the alm for output (to be returned)
 */
      if (unlikely(PyObject_SetItem(__pyx_v_m, __pyx_v_mask, __pyx_float_0_0) < 0)) __PYX_ERR(0, 108, __pyx_L1_error)

      /* "healpy/src/_sphtools.pyx":107
 *     # replace UNSEEN pixels with zeros
 *     for m, mask in zip(maps_c, masks):
 *         if mask:             # <<<<<<<<<<<<<<
 *             m[mask] = 0.0
 * 
 */
    }

    /* "healpy/src/_sphtools.pyx":106
 * 
 *     # replace UNSEEN pixels with zeros
 *     for m, mask in zip(maps_c, masks):             # <<<<<<<<<<<<<<
 *         if mask:
 *             m[mask] = 0.0
 */
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "healpy/src/_sphtools.pyx":111
 * 
 *     # Create an ndarray object that will contain the alm for output (to be returned)
 *     n_alm = alm_getn(lmax_, mmax_)             # <<<<<<<<<<<<<<
 *     alms = [np.empty(n_alm, dtype=np.complex128) for m in maps]
 * 
 */
  __pyx_v_n_alm = __pyx_f_6healpy_9_sphtools_alm_getn(__pyx_v_lmax_, __pyx_v_mmax_);

  /* "healpy/src/_sphtools.pyx":112
 *     # Create an ndarray object that will contain the alm for output (to be returned)
 *     n_alm = alm_getn(lmax_, mmax_)
 *     alms = [np.empty(n_alm, dtype=np.complex128) for m in maps]             # <<<<<<<<<<<<<<
 * 
 *     # View the ndarray as an Alm
 */
  __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (likely(PyList_CheckExact(__pyx_v_maps)) || PyTuple_CheckExact(__pyx_v_maps)) {
    __pyx_t_2 = __pyx_v_maps; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_maps); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 112, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_9 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_9); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 112, __pyx_L1_error)
        #else
        __pyx_t_9 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 112, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        #endif
      } else {
        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_9); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 112, __pyx_L1_error)
        #else
        __pyx_t_9 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 112, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_9);
        #endif
      }
    } else {
      __pyx_t_9 = __pyx_t_4(__pyx_t_2);
      if (unlikely(!__pyx_t_9)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 112, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_9);
    }
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_9);
    __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_n_alm); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_GIVEREF(__pyx_t_9);
    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9);
    __pyx_t_9 = 0;
    __pyx_t_9 = PyDict_New(); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_complex128); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 112, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_alms = ((PyObject*)__pyx_t_5);
  __pyx_t_5 = 0;

  /* "healpy/src/_sphtools.pyx":116
 *     # View the ndarray as an Alm
 *     # Alms = [ndarray2alm(alm, lmax_, mmax_) for alm in alms]
 *     A1 = ndarray2alm(alms[0], lmax_, mmax_)             # <<<<<<<<<<<<<<
 *     A2 = ndarray2alm(alms[1], lmax_, mmax_)
 * 
 */
  __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_alms, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 116, __pyx_L1_error)
  __pyx_t_15 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_t_5), __pyx_v_lmax_, __pyx_v_mmax_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 116, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_A1 = __pyx_t_15;

  /* "healpy/src/_sphtools.pyx":117
 *     # Alms = [ndarray2alm(alm, lmax_, mmax_) for alm in alms]
 *     A1 = ndarray2alm(alms[0], lmax_, mmax_)
 *     A2 = ndarray2alm(alms[1], lmax_, mmax_)             # <<<<<<<<<<<<<<
 * 
 *     # ring weights
 */
  __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_alms, 1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 117, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 117, __pyx_L1_error)
  __pyx_t_15 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_t_5), __pyx_v_lmax_, __pyx_v_mmax_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 117, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_A2 = __pyx_t_15;

  /* "healpy/src/_sphtools.pyx":120
 * 
 *     # ring weights
 *     cdef arr[double] * w_arr = new arr[double]()             # <<<<<<<<<<<<<<
 *     cdef int i
 *     cdef char *c_datapath
 */
  __pyx_v_w_arr = new arr ();

  /* "healpy/src/_sphtools.pyx":123
 *     cdef int i
 *     cdef char *c_datapath
 *     w_arr.allocAndFill(2 * nside, 1.)             # <<<<<<<<<<<<<<
 * 
 *     map2alm_spin(M1[0], M2[0], A1[0], A2[0], spin, w_arr[0], False)
 */
  __pyx_v_w_arr->allocAndFill((2 * __pyx_v_nside), 1.);

  /* "healpy/src/_sphtools.pyx":125
 *     w_arr.allocAndFill(2 * nside, 1.)
 * 
 *     map2alm_spin(M1[0], M2[0], A1[0], A2[0], spin, w_arr[0], False)             # <<<<<<<<<<<<<<
 * 
 *     # restore input map with UNSEEN pixels
 */
  __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_spin); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 125, __pyx_L1_error)
  map2alm_spin((__pyx_v_M1[0]), (__pyx_v_M2[0]), (__pyx_v_A1[0]), (__pyx_v_A2[0]), __pyx_t_10, (__pyx_v_w_arr[0]), 0);

  /* "healpy/src/_sphtools.pyx":128
 * 
 *     # restore input map with UNSEEN pixels
 *     for m, mask in zip(maps_c, masks):             # <<<<<<<<<<<<<<
 *         if mask:
 *             m[mask] = UNSEEN
 */
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 128, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_v_maps_c);
  __Pyx_GIVEREF(__pyx_v_maps_c);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_maps_c);
  __Pyx_INCREF(__pyx_v_masks);
  __Pyx_GIVEREF(__pyx_v_masks);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_masks);
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
    __pyx_t_5 = __pyx_t_2; __Pyx_INCREF(__pyx_t_5); __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 128, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_4 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 128, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_5))) {
        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_5)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_2 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 128, __pyx_L1_error)
        #else
        __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        #endif
      } else {
        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 128, __pyx_L1_error)
        #else
        __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_2);
        #endif
      }
    } else {
      __pyx_t_2 = __pyx_t_4(__pyx_t_5);
      if (unlikely(!__pyx_t_2)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 128, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_2);
    }
    if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) {
      PyObject* sequence = __pyx_t_2;
      #if CYTHON_COMPILING_IN_CPYTHON
      Py_ssize_t size = Py_SIZE(sequence);
      #else
      Py_ssize_t size = PySequence_Size(sequence);
      #endif
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(0, 128, __pyx_L1_error)
      }
      #if CYTHON_COMPILING_IN_CPYTHON
      if (likely(PyTuple_CheckExact(sequence))) {
        __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); 
        __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); 
      } else {
        __pyx_t_8 = PyList_GET_ITEM(sequence, 0); 
        __pyx_t_9 = PyList_GET_ITEM(sequence, 1); 
      }
      __Pyx_INCREF(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_9);
      #else
      __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 128, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 128, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      #endif
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    } else {
      Py_ssize_t index = -1;
      __pyx_t_7 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 128, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_7);
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
      __pyx_t_14 = Py_TYPE(__pyx_t_7)->tp_iternext;
      index = 0; __pyx_t_8 = __pyx_t_14(__pyx_t_7); if (unlikely(!__pyx_t_8)) goto __pyx_L19_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_8);
      index = 1; __pyx_t_9 = __pyx_t_14(__pyx_t_7); if (unlikely(!__pyx_t_9)) goto __pyx_L19_unpacking_failed;
      __Pyx_GOTREF(__pyx_t_9);
      if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_7), 2) < 0) __PYX_ERR(0, 128, __pyx_L1_error)
      __pyx_t_14 = NULL;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      goto __pyx_L20_unpacking_done;
      __pyx_L19_unpacking_failed:;
      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
      __pyx_t_14 = NULL;
      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
      __PYX_ERR(0, 128, __pyx_L1_error)
      __pyx_L20_unpacking_done:;
    }
    __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_8);
    __pyx_t_8 = 0;
    __Pyx_XDECREF_SET(__pyx_v_mask, __pyx_t_9);
    __pyx_t_9 = 0;

    /* "healpy/src/_sphtools.pyx":129
 *     # restore input map with UNSEEN pixels
 *     for m, mask in zip(maps_c, masks):
 *         if mask:             # <<<<<<<<<<<<<<
 *             m[mask] = UNSEEN
 * 
 */
    __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_mask); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 129, __pyx_L1_error)
    if (__pyx_t_11) {

      /* "healpy/src/_sphtools.pyx":130
 *     for m, mask in zip(maps_c, masks):
 *         if mask:
 *             m[mask] = UNSEEN             # <<<<<<<<<<<<<<
 * 
 *     del w_arr
 */
      __pyx_t_2 = PyFloat_FromDouble(__pyx_v_6healpy_9_sphtools_UNSEEN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_2);
      if (unlikely(PyObject_SetItem(__pyx_v_m, __pyx_v_mask, __pyx_t_2) < 0)) __PYX_ERR(0, 130, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

      /* "healpy/src/_sphtools.pyx":129
 *     # restore input map with UNSEEN pixels
 *     for m, mask in zip(maps_c, masks):
 *         if mask:             # <<<<<<<<<<<<<<
 *             m[mask] = UNSEEN
 * 
 */
    }

    /* "healpy/src/_sphtools.pyx":128
 * 
 *     # restore input map with UNSEEN pixels
 *     for m, mask in zip(maps_c, masks):             # <<<<<<<<<<<<<<
 *         if mask:
 *             m[mask] = UNSEEN
 */
  }
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

  /* "healpy/src/_sphtools.pyx":132
 *             m[mask] = UNSEEN
 * 
 *     del w_arr             # <<<<<<<<<<<<<<
 *     del M1, M2, A1, A2
 *     return alms
 */
  delete __pyx_v_w_arr;

  /* "healpy/src/_sphtools.pyx":133
 * 
 *     del w_arr
 *     del M1, M2, A1, A2             # <<<<<<<<<<<<<<
 *     return alms
 * 
 */
  delete __pyx_v_M1;
  delete __pyx_v_M2;
  delete __pyx_v_A1;
  delete __pyx_v_A2;

  /* "healpy/src/_sphtools.pyx":134
 *     del w_arr
 *     del M1, M2, A1, A2
 *     return alms             # <<<<<<<<<<<<<<
 * 
 * def alm2map_spin_healpy(alms, nside, spin, lmax, mmax=None):
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_alms);
  __pyx_r = __pyx_v_alms;
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":60
 *     return DATAPATH
 * 
 * def map2alm_spin_healpy(maps, spin, lmax = None, mmax = None):             # <<<<<<<<<<<<<<
 *     """Computes the spinned alm of a 2 Healpix maps.
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("healpy._sphtools.map2alm_spin_healpy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_maps_c);
  __Pyx_XDECREF(__pyx_v_masks);
  __Pyx_XDECREF(__pyx_v_m);
  __Pyx_XDECREF(__pyx_v_mask);
  __Pyx_XDECREF(__pyx_v_alms);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":136
 *     return alms
 * 
 * def alm2map_spin_healpy(alms, nside, spin, lmax, mmax=None):             # <<<<<<<<<<<<<<
 *     """Computes maps from a set of 2 spinned alm
 * 
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_5alm2map_spin_healpy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_4alm2map_spin_healpy[] = "alm2map_spin_healpy(alms, nside, spin, lmax, mmax=None)\nComputes maps from a set of 2 spinned alm\n\n    Parameters\n    ----------\n    alms : list of 2 arrays\n      list of 2 alms\n    nside : int\n        requested nside of the output map \n    spin : int\n        spin of the alms (either 1, 2 or 3)\n    lmax : int, scalar\n      Maximum l of the power spectrum.\n    mmax : int, scalar, optional\n      Maximum m of the alm. Default: lmax\n    \n    Returns\n    -------\n    m : list of 2 arrays\n        list of 2 out maps in RING scheme as numpy arrays\n    ";
static PyMethodDef __pyx_mdef_6healpy_9_sphtools_5alm2map_spin_healpy = {"alm2map_spin_healpy", (PyCFunction)__pyx_pw_6healpy_9_sphtools_5alm2map_spin_healpy, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_9_sphtools_4alm2map_spin_healpy};
static PyObject *__pyx_pw_6healpy_9_sphtools_5alm2map_spin_healpy(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alms = 0;
  PyObject *__pyx_v_nside = 0;
  PyObject *__pyx_v_spin = 0;
  PyObject *__pyx_v_lmax = 0;
  PyObject *__pyx_v_mmax = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("alm2map_spin_healpy (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alms,&__pyx_n_s_nside,&__pyx_n_s_spin,&__pyx_n_s_lmax,&__pyx_n_s_mmax,0};
    PyObject* values[5] = {0,0,0,0,0};
    values[4] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_alms)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nside)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("alm2map_spin_healpy", 0, 4, 5, 1); __PYX_ERR(0, 136, __pyx_L3_error)
        }
        case  2:
        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_spin)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("alm2map_spin_healpy", 0, 4, 5, 2); __PYX_ERR(0, 136, __pyx_L3_error)
        }
        case  3:
        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lmax)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("alm2map_spin_healpy", 0, 4, 5, 3); __PYX_ERR(0, 136, __pyx_L3_error)
        }
        case  4:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mmax);
          if (value) { values[4] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "alm2map_spin_healpy") < 0)) __PYX_ERR(0, 136, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_alms = values[0];
    __pyx_v_nside = values[1];
    __pyx_v_spin = values[2];
    __pyx_v_lmax = values[3];
    __pyx_v_mmax = values[4];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("alm2map_spin_healpy", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 136, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._sphtools.alm2map_spin_healpy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_9_sphtools_4alm2map_spin_healpy(__pyx_self, __pyx_v_alms, __pyx_v_nside, __pyx_v_spin, __pyx_v_lmax, __pyx_v_mmax);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_4alm2map_spin_healpy(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_alms, PyObject *__pyx_v_nside, PyObject *__pyx_v_spin, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax) {
  PyObject *__pyx_v_alms_c = NULL;
  PyObject *__pyx_v_npix = NULL;
  PyObject *__pyx_v_maps = NULL;
  Healpix_Map  *__pyx_v_M1;
  Healpix_Map  *__pyx_v_M2;
  Alm >  *__pyx_v_A1;
  Alm >  *__pyx_v_A2;
  PyObject *__pyx_v_alm = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  Py_ssize_t __pyx_t_3;
  PyObject *(*__pyx_t_4)(PyObject *);
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  Healpix_Map  *__pyx_t_10;
  int __pyx_t_11;
  int __pyx_t_12;
  int __pyx_t_13;
  int __pyx_t_14;
  Alm >  *__pyx_t_15;
  __Pyx_RefNannySetupContext("alm2map_spin_healpy", 0);
  __Pyx_INCREF(__pyx_v_mmax);

  /* "healpy/src/_sphtools.pyx":157
 *         list of 2 out maps in RING scheme as numpy arrays
 *     """
 *     alms_c = [np.ascontiguousarray(alm, dtype=np.complex128) for alm in alms]             # <<<<<<<<<<<<<<
 * 
 *     npix = nside2npix(nside)
 */
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (likely(PyList_CheckExact(__pyx_v_alms)) || PyTuple_CheckExact(__pyx_v_alms)) {
    __pyx_t_2 = __pyx_v_alms; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_alms); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 157, __pyx_L1_error)
        #else
        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        #endif
      } else {
        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 157, __pyx_L1_error)
        #else
        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        #endif
      }
    } else {
      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
      if (unlikely(!__pyx_t_5)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 157, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_5);
    }
    __Pyx_XDECREF_SET(__pyx_v_alm, __pyx_t_5);
    __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_INCREF(__pyx_v_alm);
    __Pyx_GIVEREF(__pyx_v_alm);
    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_alm);
    __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_complex128); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 157, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_alms_c = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":159
 *     alms_c = [np.ascontiguousarray(alm, dtype=np.complex128) for alm in alms]
 * 
 *     npix = nside2npix(nside)             # <<<<<<<<<<<<<<
 *     maps = [np.zeros(npix, dtype=np.float64) for alm in alms]
 * 
 */
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_nside2npix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 159, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_9 = NULL;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_9)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_9);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  if (!__pyx_t_9) {
    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_nside); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 159, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL;
    __Pyx_INCREF(__pyx_v_nside);
    __Pyx_GIVEREF(__pyx_v_nside);
    PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_nside);
    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 159, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_npix = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":160
 * 
 *     npix = nside2npix(nside)
 *     maps = [np.zeros(npix, dtype=np.float64) for alm in alms]             # <<<<<<<<<<<<<<
 * 
 *     # View the ndarray as a Healpix_Map
 */
  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (likely(PyList_CheckExact(__pyx_v_alms)) || PyTuple_CheckExact(__pyx_v_alms)) {
    __pyx_t_2 = __pyx_v_alms; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
    __pyx_t_4 = NULL;
  } else {
    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_alms); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 160, __pyx_L1_error)
  }
  for (;;) {
    if (likely(!__pyx_t_4)) {
      if (likely(PyList_CheckExact(__pyx_t_2))) {
        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_7 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_7); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 160, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 160, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      } else {
        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_7); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 160, __pyx_L1_error)
        #else
        __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 160, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_7);
        #endif
      }
    } else {
      __pyx_t_7 = __pyx_t_4(__pyx_t_2);
      if (unlikely(!__pyx_t_7)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 160, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_7);
    }
    __Pyx_XDECREF_SET(__pyx_v_alm, __pyx_t_7);
    __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_zeros); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_INCREF(__pyx_v_npix);
    __Pyx_GIVEREF(__pyx_v_npix);
    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v_npix);
    __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float64); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 160, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_maps = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":163
 * 
 *     # View the ndarray as a Healpix_Map
 *     M1 = ndarray2map(maps[0], RING)             # <<<<<<<<<<<<<<
 *     M2 = ndarray2map(maps[1], RING)
 * 
 */
  __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_maps, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 163, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 163, __pyx_L1_error)
  __pyx_t_10 = __pyx_f_7_common_ndarray2map(((PyArrayObject *)__pyx_t_1), RING); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 163, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_M1 = __pyx_t_10;

  /* "healpy/src/_sphtools.pyx":164
 *     # View the ndarray as a Healpix_Map
 *     M1 = ndarray2map(maps[0], RING)
 *     M2 = ndarray2map(maps[1], RING)             # <<<<<<<<<<<<<<
 * 
 *     if not mmax:
 */
  __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_maps, 1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 164, __pyx_L1_error)
  __pyx_t_10 = __pyx_f_7_common_ndarray2map(((PyArrayObject *)__pyx_t_1), RING); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 164, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_M2 = __pyx_t_10;

  /* "healpy/src/_sphtools.pyx":166
 *     M2 = ndarray2map(maps[1], RING)
 * 
 *     if not mmax:             # <<<<<<<<<<<<<<
 *         mmax = lmax
 * 
 */
  __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_mmax); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 166, __pyx_L1_error)
  __pyx_t_12 = ((!__pyx_t_11) != 0);
  if (__pyx_t_12) {

    /* "healpy/src/_sphtools.pyx":167
 * 
 *     if not mmax:
 *         mmax = lmax             # <<<<<<<<<<<<<<
 * 
 *     # View the ndarray as an Alm
 */
    __Pyx_INCREF(__pyx_v_lmax);
    __Pyx_DECREF_SET(__pyx_v_mmax, __pyx_v_lmax);

    /* "healpy/src/_sphtools.pyx":166
 *     M2 = ndarray2map(maps[1], RING)
 * 
 *     if not mmax:             # <<<<<<<<<<<<<<
 *         mmax = lmax
 * 
 */
  }

  /* "healpy/src/_sphtools.pyx":170
 * 
 *     # View the ndarray as an Alm
 *     A1 = ndarray2alm(alms_c[0], lmax, mmax)             # <<<<<<<<<<<<<<
 *     A2 = ndarray2alm(alms_c[1], lmax, mmax)
 * 
 */
  __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_alms_c, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 170, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 170, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_lmax); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 170, __pyx_L1_error)
  __pyx_t_14 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_14 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 170, __pyx_L1_error)
  __pyx_t_15 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_t_1), __pyx_t_13, __pyx_t_14); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 170, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_A1 = __pyx_t_15;

  /* "healpy/src/_sphtools.pyx":171
 *     # View the ndarray as an Alm
 *     A1 = ndarray2alm(alms_c[0], lmax, mmax)
 *     A2 = ndarray2alm(alms_c[1], lmax, mmax)             # <<<<<<<<<<<<<<
 * 
 *     alm2map_spin(A1[0], A2[0], M1[0], M2[0], spin)
 */
  __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_alms_c, 1, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 171, __pyx_L1_error)
  __pyx_t_14 = __Pyx_PyInt_As_int(__pyx_v_lmax); if (unlikely((__pyx_t_14 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L1_error)
  __pyx_t_15 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_t_1), __pyx_t_14, __pyx_t_13); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 171, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_A2 = __pyx_t_15;

  /* "healpy/src/_sphtools.pyx":173
 *     A2 = ndarray2alm(alms_c[1], lmax, mmax)
 * 
 *     alm2map_spin(A1[0], A2[0], M1[0], M2[0], spin)             # <<<<<<<<<<<<<<
 * 
 *     del M1, M2, A1, A2
 */
  __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_spin); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 173, __pyx_L1_error)
  alm2map_spin((__pyx_v_A1[0]), (__pyx_v_A2[0]), (__pyx_v_M1[0]), (__pyx_v_M2[0]), __pyx_t_13);

  /* "healpy/src/_sphtools.pyx":175
 *     alm2map_spin(A1[0], A2[0], M1[0], M2[0], spin)
 * 
 *     del M1, M2, A1, A2             # <<<<<<<<<<<<<<
 *     return maps
 * 
 */
  delete __pyx_v_M1;
  delete __pyx_v_M2;
  delete __pyx_v_A1;
  delete __pyx_v_A2;

  /* "healpy/src/_sphtools.pyx":176
 * 
 *     del M1, M2, A1, A2
 *     return maps             # <<<<<<<<<<<<<<
 * 
 * def map2alm(m, lmax = None, mmax = None, niter = 3, use_weights = False,
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_maps);
  __pyx_r = __pyx_v_maps;
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":136
 *     return alms
 * 
 * def alm2map_spin_healpy(alms, nside, spin, lmax, mmax=None):             # <<<<<<<<<<<<<<
 *     """Computes maps from a set of 2 spinned alm
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_AddTraceback("healpy._sphtools.alm2map_spin_healpy", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_alms_c);
  __Pyx_XDECREF(__pyx_v_npix);
  __Pyx_XDECREF(__pyx_v_maps);
  __Pyx_XDECREF(__pyx_v_alm);
  __Pyx_XDECREF(__pyx_v_mmax);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":178
 *     return maps
 * 
 * def map2alm(m, lmax = None, mmax = None, niter = 3, use_weights = False,             # <<<<<<<<<<<<<<
 *             datapath = None):
 *     """Computes the alm of a Healpix map.
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_7map2alm(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_6map2alm[] = "map2alm(m, lmax=None, mmax=None, niter=3, use_weights=False, datapath=None)\nComputes the alm of a Healpix map.\n\n    Parameters\n    ----------\n    m : array-like, shape (Npix,) or (3, Npix)\n      The input map or a list of 3 input maps (polariztion).\n    lmax : int, scalar, optional\n      Maximum l of the power spectrum. Default: 3*nside-1\n    mmax : int, scalar, optional\n      Maximum m of the alm. Default: lmax\n    iter : int, scalar, optional\n      Number of iteration (default: 1)\n    use_weights: bool, scalar, optional\n      If True, use the ring weighting. Default: False.\n    \n    Returns\n    -------\n    alm : array or tuple of arrays\n      alm or a tuple of 3 alm (almT, almE, almB) if polarized input.\n    ";
static PyMethodDef __pyx_mdef_6healpy_9_sphtools_7map2alm = {"map2alm", (PyCFunction)__pyx_pw_6healpy_9_sphtools_7map2alm, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_9_sphtools_6map2alm};
static PyObject *__pyx_pw_6healpy_9_sphtools_7map2alm(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_m = 0;
  PyObject *__pyx_v_lmax = 0;
  PyObject *__pyx_v_mmax = 0;
  PyObject *__pyx_v_niter = 0;
  PyObject *__pyx_v_use_weights = 0;
  PyObject *__pyx_v_datapath = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("map2alm (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_m,&__pyx_n_s_lmax,&__pyx_n_s_mmax,&__pyx_n_s_niter,&__pyx_n_s_use_weights,&__pyx_n_s_datapath,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)__pyx_int_3);
    values[4] = ((PyObject *)Py_False);

    /* "healpy/src/_sphtools.pyx":179
 * 
 * def map2alm(m, lmax = None, mmax = None, niter = 3, use_weights = False,
 *             datapath = None):             # <<<<<<<<<<<<<<
 *     """Computes the alm of a Healpix map.
 * 
 */
    values[5] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_m)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lmax);
          if (value) { values[1] = value; kw_args--; }
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mmax);
          if (value) { values[2] = value; kw_args--; }
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_niter);
          if (value) { values[3] = value; kw_args--; }
        }
        case  4:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_use_weights);
          if (value) { values[4] = value; kw_args--; }
        }
        case  5:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_datapath);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "map2alm") < 0)) __PYX_ERR(0, 178, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_m = values[0];
    __pyx_v_lmax = values[1];
    __pyx_v_mmax = values[2];
    __pyx_v_niter = values[3];
    __pyx_v_use_weights = values[4];
    __pyx_v_datapath = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("map2alm", 0, 1, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 178, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._sphtools.map2alm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_9_sphtools_6map2alm(__pyx_self, __pyx_v_m, __pyx_v_lmax, __pyx_v_mmax, __pyx_v_niter, __pyx_v_use_weights, __pyx_v_datapath);

  /* "healpy/src/_sphtools.pyx":178
 *     return maps
 * 
 * def map2alm(m, lmax = None, mmax = None, niter = 3, use_weights = False,             # <<<<<<<<<<<<<<
 *             datapath = None):
 *     """Computes the alm of a Healpix map.
 */

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_6map2alm(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_m, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax, PyObject *__pyx_v_niter, PyObject *__pyx_v_use_weights, PyObject *__pyx_v_datapath) {
  PyObject *__pyx_v_info = NULL;
  int __pyx_v_polarization;
  PyObject *__pyx_v_mi = NULL;
  PyObject *__pyx_v_mq = NULL;
  PyObject *__pyx_v_mu = NULL;
  PyObject *__pyx_v_mask_mi = NULL;
  PyObject *__pyx_v_mask_mq = NULL;
  PyObject *__pyx_v_mask_mu = NULL;
  int __pyx_v_lmax_;
  int __pyx_v_mmax_;
  int __pyx_v_nside;
  int __pyx_v_npix;
  Healpix_Map  *__pyx_v_MI;
  Healpix_Map  *__pyx_v_MQ;
  Healpix_Map  *__pyx_v_MU;
  int __pyx_v_n_alm;
  PyObject *__pyx_v_almI = NULL;
  PyObject *__pyx_v_almG = NULL;
  PyObject *__pyx_v_almC = NULL;
  Alm >  *__pyx_v_AI;
  Alm >  *__pyx_v_AG;
  Alm >  *__pyx_v_AC;
  arr  *__pyx_v_w_arr;
  int __pyx_v_i;
  char *__pyx_v_c_datapath;
  PyObject *__pyx_v_weightfile = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  int __pyx_t_7;
  int __pyx_t_8;
  Healpix_Map  *__pyx_t_9;
  Alm >  *__pyx_t_10;
  char *__pyx_t_11;
  Py_ssize_t __pyx_t_12;
  PyObject *__pyx_t_13 = NULL;
  std::string __pyx_t_14;
  size_t __pyx_t_15;
  long __pyx_t_16;
  int __pyx_t_17;
  __Pyx_RefNannySetupContext("map2alm", 0);
  __Pyx_INCREF(__pyx_v_datapath);

  /* "healpy/src/_sphtools.pyx":201
 *     """
 *     # Check if the input map is polarized or not
 *     info = maptype(m)             # <<<<<<<<<<<<<<
 *     if info == 0:
 *         polarization = False
 */
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_maptype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = NULL;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  if (!__pyx_t_3) {
    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_m); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 201, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
    __Pyx_INCREF(__pyx_v_m);
    __Pyx_GIVEREF(__pyx_v_m);
    PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_m);
    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  }
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_info = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":202
 *     # Check if the input map is polarized or not
 *     info = maptype(m)
 *     if info == 0:             # <<<<<<<<<<<<<<
 *         polarization = False
 *         mi = np.ascontiguousarray(m, dtype=np.float64)
 */
  __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_v_info, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 202, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 202, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":203
 *     info = maptype(m)
 *     if info == 0:
 *         polarization = False             # <<<<<<<<<<<<<<
 *         mi = np.ascontiguousarray(m, dtype=np.float64)
 *     elif info == 1:
 */
    __pyx_v_polarization = 0;

    /* "healpy/src/_sphtools.pyx":204
 *     if info == 0:
 *         polarization = False
 *         mi = np.ascontiguousarray(m, dtype=np.float64)             # <<<<<<<<<<<<<<
 *     elif info == 1:
 *         polarization = False
 */
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_v_m);
    __Pyx_GIVEREF(__pyx_v_m);
    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_m);
    __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 204, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float64); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 204, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 204, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 204, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_mi = __pyx_t_6;
    __pyx_t_6 = 0;

    /* "healpy/src/_sphtools.pyx":202
 *     # Check if the input map is polarized or not
 *     info = maptype(m)
 *     if info == 0:             # <<<<<<<<<<<<<<
 *         polarization = False
 *         mi = np.ascontiguousarray(m, dtype=np.float64)
 */
    goto __pyx_L3;
  }

  /* "healpy/src/_sphtools.pyx":205
 *         polarization = False
 *         mi = np.ascontiguousarray(m, dtype=np.float64)
 *     elif info == 1:             # <<<<<<<<<<<<<<
 *         polarization = False
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 */
  __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_v_info, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 205, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":206
 *         mi = np.ascontiguousarray(m, dtype=np.float64)
 *     elif info == 1:
 *         polarization = False             # <<<<<<<<<<<<<<
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 *     elif info == 3:
 */
    __pyx_v_polarization = 0;

    /* "healpy/src/_sphtools.pyx":207
 *     elif info == 1:
 *         polarization = False
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)             # <<<<<<<<<<<<<<
 *     elif info == 3:
 *         polarization = True
 */
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_m, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_6);
    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6);
    __pyx_t_6 = 0;
    __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float64); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_v_mi = __pyx_t_3;
    __pyx_t_3 = 0;

    /* "healpy/src/_sphtools.pyx":205
 *         polarization = False
 *         mi = np.ascontiguousarray(m, dtype=np.float64)
 *     elif info == 1:             # <<<<<<<<<<<<<<
 *         polarization = False
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 */
    goto __pyx_L3;
  }

  /* "healpy/src/_sphtools.pyx":208
 *         polarization = False
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 *     elif info == 3:             # <<<<<<<<<<<<<<
 *         polarization = True
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 */
  __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_info, __pyx_int_3, 3, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 208, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":209
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 *     elif info == 3:
 *         polarization = True             # <<<<<<<<<<<<<<
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 *         mq = np.ascontiguousarray(m[1], dtype=np.float64)
 */
    __pyx_v_polarization = 1;

    /* "healpy/src/_sphtools.pyx":210
 *     elif info == 3:
 *         polarization = True
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)             # <<<<<<<<<<<<<<
 *         mq = np.ascontiguousarray(m[1], dtype=np.float64)
 *         mu = np.ascontiguousarray(m[2], dtype=np.float64)
 */
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_m, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_3);
    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
    __pyx_t_3 = 0;
    __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_v_mi = __pyx_t_2;
    __pyx_t_2 = 0;

    /* "healpy/src/_sphtools.pyx":211
 *         polarization = True
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 *         mq = np.ascontiguousarray(m[1], dtype=np.float64)             # <<<<<<<<<<<<<<
 *         mu = np.ascontiguousarray(m[2], dtype=np.float64)
 *     else:
 */
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_m, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_2);
    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
    __pyx_t_2 = 0;
    __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float64); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 211, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_mq = __pyx_t_4;
    __pyx_t_4 = 0;

    /* "healpy/src/_sphtools.pyx":212
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 *         mq = np.ascontiguousarray(m[1], dtype=np.float64)
 *         mu = np.ascontiguousarray(m[2], dtype=np.float64)             # <<<<<<<<<<<<<<
 *     else:
 *         raise ValueError("Wrong input map (must be a valid healpix map "
 */
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_m, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_GIVEREF(__pyx_t_4);
    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
    __pyx_t_4 = 0;
    __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float64); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_mu = __pyx_t_6;
    __pyx_t_6 = 0;

    /* "healpy/src/_sphtools.pyx":208
 *         polarization = False
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 *     elif info == 3:             # <<<<<<<<<<<<<<
 *         polarization = True
 *         mi = np.ascontiguousarray(m[0], dtype=np.float64)
 */
    goto __pyx_L3;
  }

  /* "healpy/src/_sphtools.pyx":214
 *         mu = np.ascontiguousarray(m[2], dtype=np.float64)
 *     else:
 *         raise ValueError("Wrong input map (must be a valid healpix map "             # <<<<<<<<<<<<<<
 *                          "or a sequence of 1 or 3 maps)")
 * 
 */
  /*else*/ {
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 214, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_Raise(__pyx_t_6, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __PYX_ERR(0, 214, __pyx_L1_error)
  }
  __pyx_L3:;

  /* "healpy/src/_sphtools.pyx":218
 * 
 *     # create UNSEEN mask for I map
 *     mask_mi = False if count_bad(mi) == 0 else mkmask(mi)             # <<<<<<<<<<<<<<
 *     # same for polarization maps if needed
 *     if polarization:
 */
  if (!(likely(((__pyx_v_mi) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mi, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 218, __pyx_L1_error)
  if (((__pyx_f_6healpy_9_sphtools_count_bad(((PyArrayObject *)__pyx_v_mi), 0) == 0) != 0)) {
    __Pyx_INCREF(Py_False);
    __pyx_t_6 = Py_False;
  } else {
    if (!(likely(((__pyx_v_mi) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mi, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 218, __pyx_L1_error)
    __pyx_t_4 = __pyx_f_6healpy_9_sphtools_mkmask(((PyArrayObject *)__pyx_v_mi), 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = __pyx_t_4;
    __pyx_t_4 = 0;
  }
  __pyx_v_mask_mi = __pyx_t_6;
  __pyx_t_6 = 0;

  /* "healpy/src/_sphtools.pyx":220
 *     mask_mi = False if count_bad(mi) == 0 else mkmask(mi)
 *     # same for polarization maps if needed
 *     if polarization:             # <<<<<<<<<<<<<<
 *         mask_mq = False if count_bad(mq) == 0 else mkmask(mq)
 *         mask_mu = False if count_bad(mu) == 0 else mkmask(mu)
 */
  __pyx_t_5 = (__pyx_v_polarization != 0);
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":221
 *     # same for polarization maps if needed
 *     if polarization:
 *         mask_mq = False if count_bad(mq) == 0 else mkmask(mq)             # <<<<<<<<<<<<<<
 *         mask_mu = False if count_bad(mu) == 0 else mkmask(mu)
 * 
 */
    if (unlikely(!__pyx_v_mq)) { __Pyx_RaiseUnboundLocalError("mq"); __PYX_ERR(0, 221, __pyx_L1_error) }
    if (!(likely(((__pyx_v_mq) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mq, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 221, __pyx_L1_error)
    if (((__pyx_f_6healpy_9_sphtools_count_bad(((PyArrayObject *)__pyx_v_mq), 0) == 0) != 0)) {
      __Pyx_INCREF(Py_False);
      __pyx_t_6 = Py_False;
    } else {
      if (unlikely(!__pyx_v_mq)) { __Pyx_RaiseUnboundLocalError("mq"); __PYX_ERR(0, 221, __pyx_L1_error) }
      if (!(likely(((__pyx_v_mq) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mq, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 221, __pyx_L1_error)
      __pyx_t_4 = __pyx_f_6healpy_9_sphtools_mkmask(((PyArrayObject *)__pyx_v_mq), 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = __pyx_t_4;
      __pyx_t_4 = 0;
    }
    __pyx_v_mask_mq = __pyx_t_6;
    __pyx_t_6 = 0;

    /* "healpy/src/_sphtools.pyx":222
 *     if polarization:
 *         mask_mq = False if count_bad(mq) == 0 else mkmask(mq)
 *         mask_mu = False if count_bad(mu) == 0 else mkmask(mu)             # <<<<<<<<<<<<<<
 * 
 *     # Adjust lmax and mmax
 */
    if (unlikely(!__pyx_v_mu)) { __Pyx_RaiseUnboundLocalError("mu"); __PYX_ERR(0, 222, __pyx_L1_error) }
    if (!(likely(((__pyx_v_mu) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mu, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 222, __pyx_L1_error)
    if (((__pyx_f_6healpy_9_sphtools_count_bad(((PyArrayObject *)__pyx_v_mu), 0) == 0) != 0)) {
      __Pyx_INCREF(Py_False);
      __pyx_t_6 = Py_False;
    } else {
      if (unlikely(!__pyx_v_mu)) { __Pyx_RaiseUnboundLocalError("mu"); __PYX_ERR(0, 222, __pyx_L1_error) }
      if (!(likely(((__pyx_v_mu) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mu, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 222, __pyx_L1_error)
      __pyx_t_4 = __pyx_f_6healpy_9_sphtools_mkmask(((PyArrayObject *)__pyx_v_mu), 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_6 = __pyx_t_4;
      __pyx_t_4 = 0;
    }
    __pyx_v_mask_mu = __pyx_t_6;
    __pyx_t_6 = 0;

    /* "healpy/src/_sphtools.pyx":220
 *     mask_mi = False if count_bad(mi) == 0 else mkmask(mi)
 *     # same for polarization maps if needed
 *     if polarization:             # <<<<<<<<<<<<<<
 *         mask_mq = False if count_bad(mq) == 0 else mkmask(mq)
 *         mask_mu = False if count_bad(mu) == 0 else mkmask(mu)
 */
  }

  /* "healpy/src/_sphtools.pyx":226
 *     # Adjust lmax and mmax
 *     cdef int lmax_, mmax_, nside, npix
 *     npix = mi.size             # <<<<<<<<<<<<<<
 *     nside = npix2nside(npix)
 *     if lmax is None:
 */
  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_mi, __pyx_n_s_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 226, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 226, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_npix = __pyx_t_7;

  /* "healpy/src/_sphtools.pyx":227
 *     cdef int lmax_, mmax_, nside, npix
 *     npix = mi.size
 *     nside = npix2nside(npix)             # <<<<<<<<<<<<<<
 *     if lmax is None:
 *         lmax_ = 3 * nside - 1
 */
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_npix2nside); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 227, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 227, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = NULL;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_2)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  if (!__pyx_t_2) {
    __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 227, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_GOTREF(__pyx_t_6);
  } else {
    __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 227, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
    __Pyx_GIVEREF(__pyx_t_1);
    PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 227, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  }
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 227, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_nside = __pyx_t_7;

  /* "healpy/src/_sphtools.pyx":228
 *     npix = mi.size
 *     nside = npix2nside(npix)
 *     if lmax is None:             # <<<<<<<<<<<<<<
 *         lmax_ = 3 * nside - 1
 *     else:
 */
  __pyx_t_5 = (__pyx_v_lmax == Py_None);
  __pyx_t_8 = (__pyx_t_5 != 0);
  if (__pyx_t_8) {

    /* "healpy/src/_sphtools.pyx":229
 *     nside = npix2nside(npix)
 *     if lmax is None:
 *         lmax_ = 3 * nside - 1             # <<<<<<<<<<<<<<
 *     else:
 *         lmax_ = lmax
 */
    __pyx_v_lmax_ = ((3 * __pyx_v_nside) - 1);

    /* "healpy/src/_sphtools.pyx":228
 *     npix = mi.size
 *     nside = npix2nside(npix)
 *     if lmax is None:             # <<<<<<<<<<<<<<
 *         lmax_ = 3 * nside - 1
 *     else:
 */
    goto __pyx_L5;
  }

  /* "healpy/src/_sphtools.pyx":231
 *         lmax_ = 3 * nside - 1
 *     else:
 *         lmax_ = lmax             # <<<<<<<<<<<<<<
 *     if mmax is None:
 *         mmax_ = lmax_
 */
  /*else*/ {
    __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_lmax); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 231, __pyx_L1_error)
    __pyx_v_lmax_ = __pyx_t_7;
  }
  __pyx_L5:;

  /* "healpy/src/_sphtools.pyx":232
 *     else:
 *         lmax_ = lmax
 *     if mmax is None:             # <<<<<<<<<<<<<<
 *         mmax_ = lmax_
 *     else:
 */
  __pyx_t_8 = (__pyx_v_mmax == Py_None);
  __pyx_t_5 = (__pyx_t_8 != 0);
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":233
 *         lmax_ = lmax
 *     if mmax is None:
 *         mmax_ = lmax_             # <<<<<<<<<<<<<<
 *     else:
 *         mmax_ = mmax
 */
    __pyx_v_mmax_ = __pyx_v_lmax_;

    /* "healpy/src/_sphtools.pyx":232
 *     else:
 *         lmax_ = lmax
 *     if mmax is None:             # <<<<<<<<<<<<<<
 *         mmax_ = lmax_
 *     else:
 */
    goto __pyx_L6;
  }

  /* "healpy/src/_sphtools.pyx":235
 *         mmax_ = lmax_
 *     else:
 *         mmax_ = mmax             # <<<<<<<<<<<<<<
 * 
 *     # Check all maps have same npix
 */
  /*else*/ {
    __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 235, __pyx_L1_error)
    __pyx_v_mmax_ = __pyx_t_7;
  }
  __pyx_L6:;

  /* "healpy/src/_sphtools.pyx":238
 * 
 *     # Check all maps have same npix
 *     if polarization:             # <<<<<<<<<<<<<<
 *         if mq.size != npix or mu.size != npix:
 *             raise ValueError("Input maps must have same size")
 */
  __pyx_t_5 = (__pyx_v_polarization != 0);
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":239
 *     # Check all maps have same npix
 *     if polarization:
 *         if mq.size != npix or mu.size != npix:             # <<<<<<<<<<<<<<
 *             raise ValueError("Input maps must have same size")
 * 
 */
    if (unlikely(!__pyx_v_mq)) { __Pyx_RaiseUnboundLocalError("mq"); __PYX_ERR(0, 239, __pyx_L1_error) }
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_mq, __pyx_n_s_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 239, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_6, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 239, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (!__pyx_t_8) {
    } else {
      __pyx_t_5 = __pyx_t_8;
      goto __pyx_L9_bool_binop_done;
    }
    if (unlikely(!__pyx_v_mu)) { __Pyx_RaiseUnboundLocalError("mu"); __PYX_ERR(0, 239, __pyx_L1_error) }
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_mu, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_6 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 239, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 239, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_5 = __pyx_t_8;
    __pyx_L9_bool_binop_done:;
    if (__pyx_t_5) {

      /* "healpy/src/_sphtools.pyx":240
 *     if polarization:
 *         if mq.size != npix or mu.size != npix:
 *             raise ValueError("Input maps must have same size")             # <<<<<<<<<<<<<<
 * 
 *     # View the ndarray as a Healpix_Map
 */
      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __PYX_ERR(0, 240, __pyx_L1_error)

      /* "healpy/src/_sphtools.pyx":239
 *     # Check all maps have same npix
 *     if polarization:
 *         if mq.size != npix or mu.size != npix:             # <<<<<<<<<<<<<<
 *             raise ValueError("Input maps must have same size")
 * 
 */
    }

    /* "healpy/src/_sphtools.pyx":238
 * 
 *     # Check all maps have same npix
 *     if polarization:             # <<<<<<<<<<<<<<
 *         if mq.size != npix or mu.size != npix:
 *             raise ValueError("Input maps must have same size")
 */
  }

  /* "healpy/src/_sphtools.pyx":243
 * 
 *     # View the ndarray as a Healpix_Map
 *     MI = ndarray2map(mi, RING)             # <<<<<<<<<<<<<<
 *     if polarization:
 *         MQ = ndarray2map(mq, RING)
 */
  if (!(likely(((__pyx_v_mi) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mi, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 243, __pyx_L1_error)
  __pyx_t_9 = __pyx_f_7_common_ndarray2map(((PyArrayObject *)__pyx_v_mi), RING); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 243, __pyx_L1_error)
  __pyx_v_MI = __pyx_t_9;

  /* "healpy/src/_sphtools.pyx":244
 *     # View the ndarray as a Healpix_Map
 *     MI = ndarray2map(mi, RING)
 *     if polarization:             # <<<<<<<<<<<<<<
 *         MQ = ndarray2map(mq, RING)
 *         MU = ndarray2map(mu, RING)
 */
  __pyx_t_5 = (__pyx_v_polarization != 0);
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":245
 *     MI = ndarray2map(mi, RING)
 *     if polarization:
 *         MQ = ndarray2map(mq, RING)             # <<<<<<<<<<<<<<
 *         MU = ndarray2map(mu, RING)
 * 
 */
    if (unlikely(!__pyx_v_mq)) { __Pyx_RaiseUnboundLocalError("mq"); __PYX_ERR(0, 245, __pyx_L1_error) }
    if (!(likely(((__pyx_v_mq) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mq, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 245, __pyx_L1_error)
    __pyx_t_9 = __pyx_f_7_common_ndarray2map(((PyArrayObject *)__pyx_v_mq), RING); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 245, __pyx_L1_error)
    __pyx_v_MQ = __pyx_t_9;

    /* "healpy/src/_sphtools.pyx":246
 *     if polarization:
 *         MQ = ndarray2map(mq, RING)
 *         MU = ndarray2map(mu, RING)             # <<<<<<<<<<<<<<
 * 
 *     # replace UNSEEN pixels with zeros
 */
    if (unlikely(!__pyx_v_mu)) { __Pyx_RaiseUnboundLocalError("mu"); __PYX_ERR(0, 246, __pyx_L1_error) }
    if (!(likely(((__pyx_v_mu) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_mu, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 246, __pyx_L1_error)
    __pyx_t_9 = __pyx_f_7_common_ndarray2map(((PyArrayObject *)__pyx_v_mu), RING); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 246, __pyx_L1_error)
    __pyx_v_MU = __pyx_t_9;

    /* "healpy/src/_sphtools.pyx":244
 *     # View the ndarray as a Healpix_Map
 *     MI = ndarray2map(mi, RING)
 *     if polarization:             # <<<<<<<<<<<<<<
 *         MQ = ndarray2map(mq, RING)
 *         MU = ndarray2map(mu, RING)
 */
  }

  /* "healpy/src/_sphtools.pyx":249
 * 
 *     # replace UNSEEN pixels with zeros
 *     if mask_mi is not False:             # <<<<<<<<<<<<<<
 *         mi[mask_mi] = 0.0
 *     if polarization:
 */
  __pyx_t_5 = (__pyx_v_mask_mi != Py_False);
  __pyx_t_8 = (__pyx_t_5 != 0);
  if (__pyx_t_8) {

    /* "healpy/src/_sphtools.pyx":250
 *     # replace UNSEEN pixels with zeros
 *     if mask_mi is not False:
 *         mi[mask_mi] = 0.0             # <<<<<<<<<<<<<<
 *     if polarization:
 *         if mask_mq is not False:
 */
    if (unlikely(PyObject_SetItem(__pyx_v_mi, __pyx_v_mask_mi, __pyx_float_0_0) < 0)) __PYX_ERR(0, 250, __pyx_L1_error)

    /* "healpy/src/_sphtools.pyx":249
 * 
 *     # replace UNSEEN pixels with zeros
 *     if mask_mi is not False:             # <<<<<<<<<<<<<<
 *         mi[mask_mi] = 0.0
 *     if polarization:
 */
  }

  /* "healpy/src/_sphtools.pyx":251
 *     if mask_mi is not False:
 *         mi[mask_mi] = 0.0
 *     if polarization:             # <<<<<<<<<<<<<<
 *         if mask_mq is not False:
 *             mq[mask_mq] = 0.0
 */
  __pyx_t_8 = (__pyx_v_polarization != 0);
  if (__pyx_t_8) {

    /* "healpy/src/_sphtools.pyx":252
 *         mi[mask_mi] = 0.0
 *     if polarization:
 *         if mask_mq is not False:             # <<<<<<<<<<<<<<
 *             mq[mask_mq] = 0.0
 *         if mask_mu is not False:
 */
    if (unlikely(!__pyx_v_mask_mq)) { __Pyx_RaiseUnboundLocalError("mask_mq"); __PYX_ERR(0, 252, __pyx_L1_error) }
    __pyx_t_8 = (__pyx_v_mask_mq != Py_False);
    __pyx_t_5 = (__pyx_t_8 != 0);
    if (__pyx_t_5) {

      /* "healpy/src/_sphtools.pyx":253
 *     if polarization:
 *         if mask_mq is not False:
 *             mq[mask_mq] = 0.0             # <<<<<<<<<<<<<<
 *         if mask_mu is not False:
 *             mu[mask_mu] = 0.0
 */
      if (unlikely(!__pyx_v_mq)) { __Pyx_RaiseUnboundLocalError("mq"); __PYX_ERR(0, 253, __pyx_L1_error) }
      if (unlikely(!__pyx_v_mask_mq)) { __Pyx_RaiseUnboundLocalError("mask_mq"); __PYX_ERR(0, 253, __pyx_L1_error) }
      if (unlikely(PyObject_SetItem(__pyx_v_mq, __pyx_v_mask_mq, __pyx_float_0_0) < 0)) __PYX_ERR(0, 253, __pyx_L1_error)

      /* "healpy/src/_sphtools.pyx":252
 *         mi[mask_mi] = 0.0
 *     if polarization:
 *         if mask_mq is not False:             # <<<<<<<<<<<<<<
 *             mq[mask_mq] = 0.0
 *         if mask_mu is not False:
 */
    }

    /* "healpy/src/_sphtools.pyx":254
 *         if mask_mq is not False:
 *             mq[mask_mq] = 0.0
 *         if mask_mu is not False:             # <<<<<<<<<<<<<<
 *             mu[mask_mu] = 0.0
 * 
 */
    if (unlikely(!__pyx_v_mask_mu)) { __Pyx_RaiseUnboundLocalError("mask_mu"); __PYX_ERR(0, 254, __pyx_L1_error) }
    __pyx_t_5 = (__pyx_v_mask_mu != Py_False);
    __pyx_t_8 = (__pyx_t_5 != 0);
    if (__pyx_t_8) {

      /* "healpy/src/_sphtools.pyx":255
 *             mq[mask_mq] = 0.0
 *         if mask_mu is not False:
 *             mu[mask_mu] = 0.0             # <<<<<<<<<<<<<<
 * 
 * 
 */
      if (unlikely(!__pyx_v_mu)) { __Pyx_RaiseUnboundLocalError("mu"); __PYX_ERR(0, 255, __pyx_L1_error) }
      if (unlikely(!__pyx_v_mask_mu)) { __Pyx_RaiseUnboundLocalError("mask_mu"); __PYX_ERR(0, 255, __pyx_L1_error) }
      if (unlikely(PyObject_SetItem(__pyx_v_mu, __pyx_v_mask_mu, __pyx_float_0_0) < 0)) __PYX_ERR(0, 255, __pyx_L1_error)

      /* "healpy/src/_sphtools.pyx":254
 *         if mask_mq is not False:
 *             mq[mask_mq] = 0.0
 *         if mask_mu is not False:             # <<<<<<<<<<<<<<
 *             mu[mask_mu] = 0.0
 * 
 */
    }

    /* "healpy/src/_sphtools.pyx":251
 *     if mask_mi is not False:
 *         mi[mask_mi] = 0.0
 *     if polarization:             # <<<<<<<<<<<<<<
 *         if mask_mq is not False:
 *             mq[mask_mq] = 0.0
 */
  }

  /* "healpy/src/_sphtools.pyx":259
 * 
 *     # Create an ndarray object that will contain the alm for output (to be returned)
 *     n_alm = alm_getn(lmax_, mmax_)             # <<<<<<<<<<<<<<
 *     almI = np.empty(n_alm, dtype=np.complex128)
 *     if polarization:
 */
  __pyx_v_n_alm = __pyx_f_6healpy_9_sphtools_alm_getn(__pyx_v_lmax_, __pyx_v_mmax_);

  /* "healpy/src/_sphtools.pyx":260
 *     # Create an ndarray object that will contain the alm for output (to be returned)
 *     n_alm = alm_getn(lmax_, mmax_)
 *     almI = np.empty(n_alm, dtype=np.complex128)             # <<<<<<<<<<<<<<
 *     if polarization:
 *         almG = np.empty(n_alm, dtype=np.complex128)
 */
  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_alm); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
  __pyx_t_6 = 0;
  __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_complex128); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_v_almI = __pyx_t_2;
  __pyx_t_2 = 0;

  /* "healpy/src/_sphtools.pyx":261
 *     n_alm = alm_getn(lmax_, mmax_)
 *     almI = np.empty(n_alm, dtype=np.complex128)
 *     if polarization:             # <<<<<<<<<<<<<<
 *         almG = np.empty(n_alm, dtype=np.complex128)
 *         almC = np.empty(n_alm, dtype=np.complex128)
 */
  __pyx_t_8 = (__pyx_v_polarization != 0);
  if (__pyx_t_8) {

    /* "healpy/src/_sphtools.pyx":262
 *     almI = np.empty(n_alm, dtype=np.complex128)
 *     if polarization:
 *         almG = np.empty(n_alm, dtype=np.complex128)             # <<<<<<<<<<<<<<
 *         almC = np.empty(n_alm, dtype=np.complex128)
 * 
 */
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_alm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_2);
    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
    __pyx_t_2 = 0;
    __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 262, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_v_almG = __pyx_t_1;
    __pyx_t_1 = 0;

    /* "healpy/src/_sphtools.pyx":263
 *     if polarization:
 *         almG = np.empty(n_alm, dtype=np.complex128)
 *         almC = np.empty(n_alm, dtype=np.complex128)             # <<<<<<<<<<<<<<
 * 
 *     # View the ndarray as an Alm
 */
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_alm); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_GIVEREF(__pyx_t_1);
    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_complex128); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 263, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_v_almC = __pyx_t_4;
    __pyx_t_4 = 0;

    /* "healpy/src/_sphtools.pyx":261
 *     n_alm = alm_getn(lmax_, mmax_)
 *     almI = np.empty(n_alm, dtype=np.complex128)
 *     if polarization:             # <<<<<<<<<<<<<<
 *         almG = np.empty(n_alm, dtype=np.complex128)
 *         almC = np.empty(n_alm, dtype=np.complex128)
 */
  }

  /* "healpy/src/_sphtools.pyx":266
 * 
 *     # View the ndarray as an Alm
 *     AI = ndarray2alm(almI, lmax_, mmax_)             # <<<<<<<<<<<<<<
 *     if polarization:
 *         AG = ndarray2alm(almG, lmax_, mmax_)
 */
  if (!(likely(((__pyx_v_almI) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_almI, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 266, __pyx_L1_error)
  __pyx_t_10 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_v_almI), __pyx_v_lmax_, __pyx_v_mmax_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 266, __pyx_L1_error)
  __pyx_v_AI = __pyx_t_10;

  /* "healpy/src/_sphtools.pyx":267
 *     # View the ndarray as an Alm
 *     AI = ndarray2alm(almI, lmax_, mmax_)
 *     if polarization:             # <<<<<<<<<<<<<<
 *         AG = ndarray2alm(almG, lmax_, mmax_)
 *         AC = ndarray2alm(almC, lmax_, mmax_)
 */
  __pyx_t_8 = (__pyx_v_polarization != 0);
  if (__pyx_t_8) {

    /* "healpy/src/_sphtools.pyx":268
 *     AI = ndarray2alm(almI, lmax_, mmax_)
 *     if polarization:
 *         AG = ndarray2alm(almG, lmax_, mmax_)             # <<<<<<<<<<<<<<
 *         AC = ndarray2alm(almC, lmax_, mmax_)
 * 
 */
    if (unlikely(!__pyx_v_almG)) { __Pyx_RaiseUnboundLocalError("almG"); __PYX_ERR(0, 268, __pyx_L1_error) }
    if (!(likely(((__pyx_v_almG) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_almG, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 268, __pyx_L1_error)
    __pyx_t_10 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_v_almG), __pyx_v_lmax_, __pyx_v_mmax_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 268, __pyx_L1_error)
    __pyx_v_AG = __pyx_t_10;

    /* "healpy/src/_sphtools.pyx":269
 *     if polarization:
 *         AG = ndarray2alm(almG, lmax_, mmax_)
 *         AC = ndarray2alm(almC, lmax_, mmax_)             # <<<<<<<<<<<<<<
 * 
 *     # ring weights
 */
    if (unlikely(!__pyx_v_almC)) { __Pyx_RaiseUnboundLocalError("almC"); __PYX_ERR(0, 269, __pyx_L1_error) }
    if (!(likely(((__pyx_v_almC) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_almC, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 269, __pyx_L1_error)
    __pyx_t_10 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_v_almC), __pyx_v_lmax_, __pyx_v_mmax_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 269, __pyx_L1_error)
    __pyx_v_AC = __pyx_t_10;

    /* "healpy/src/_sphtools.pyx":267
 *     # View the ndarray as an Alm
 *     AI = ndarray2alm(almI, lmax_, mmax_)
 *     if polarization:             # <<<<<<<<<<<<<<
 *         AG = ndarray2alm(almG, lmax_, mmax_)
 *         AC = ndarray2alm(almC, lmax_, mmax_)
 */
  }

  /* "healpy/src/_sphtools.pyx":272
 * 
 *     # ring weights
 *     cdef arr[double] * w_arr = new arr[double]()             # <<<<<<<<<<<<<<
 *     cdef int i
 *     cdef char *c_datapath
 */
  __pyx_v_w_arr = new arr ();

  /* "healpy/src/_sphtools.pyx":275
 *     cdef int i
 *     cdef char *c_datapath
 *     if use_weights:             # <<<<<<<<<<<<<<
 *         if datapath is None:
 *             datapath = get_datapath()
 */
  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_use_weights); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 275, __pyx_L1_error)
  if (__pyx_t_8) {

    /* "healpy/src/_sphtools.pyx":276
 *     cdef char *c_datapath
 *     if use_weights:
 *         if datapath is None:             # <<<<<<<<<<<<<<
 *             datapath = get_datapath()
 *         c_datapath = datapath
 */
    __pyx_t_8 = (__pyx_v_datapath == Py_None);
    __pyx_t_5 = (__pyx_t_8 != 0);
    if (__pyx_t_5) {

      /* "healpy/src/_sphtools.pyx":277
 *     if use_weights:
 *         if datapath is None:
 *             datapath = get_datapath()             # <<<<<<<<<<<<<<
 *         c_datapath = datapath
 *         weightfile = 'weight_ring_n%05d.fits' % (nside)
 */
      __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_datapath); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 277, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_3 = NULL;
      if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
        __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
        if (likely(__pyx_t_3)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
          __Pyx_INCREF(__pyx_t_3);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_1, function);
        }
      }
      if (__pyx_t_3) {
        __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 277, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      } else {
        __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 277, __pyx_L1_error)
      }
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __Pyx_DECREF_SET(__pyx_v_datapath, __pyx_t_4);
      __pyx_t_4 = 0;

      /* "healpy/src/_sphtools.pyx":276
 *     cdef char *c_datapath
 *     if use_weights:
 *         if datapath is None:             # <<<<<<<<<<<<<<
 *             datapath = get_datapath()
 *         c_datapath = datapath
 */
    }

    /* "healpy/src/_sphtools.pyx":278
 *         if datapath is None:
 *             datapath = get_datapath()
 *         c_datapath = datapath             # <<<<<<<<<<<<<<
 *         weightfile = 'weight_ring_n%05d.fits' % (nside)
 *         if not os.path.isfile(os.path.join(datapath, weightfile)):
 */
    __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_v_datapath); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) __PYX_ERR(0, 278, __pyx_L1_error)
    __pyx_v_c_datapath = __pyx_t_11;

    /* "healpy/src/_sphtools.pyx":279
 *             datapath = get_datapath()
 *         c_datapath = datapath
 *         weightfile = 'weight_ring_n%05d.fits' % (nside)             # <<<<<<<<<<<<<<
 *         if not os.path.isfile(os.path.join(datapath, weightfile)):
 *             raise IOError('Weight file not found in %s' % (datapath))
 */
    __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_nside); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 279, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_weight_ring_n_05d_fits, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 279, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_v_weightfile = __pyx_t_1;
    __pyx_t_1 = 0;

    /* "healpy/src/_sphtools.pyx":280
 *         c_datapath = datapath
 *         weightfile = 'weight_ring_n%05d.fits' % (nside)
 *         if not os.path.isfile(os.path.join(datapath, weightfile)):             # <<<<<<<<<<<<<<
 *             raise IOError('Weight file not found in %s' % (datapath))
 *         read_weight_ring(string(c_datapath), nside, w_arr[0])
 */
    __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_isfile); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_path); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_join); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = NULL;
    __pyx_t_12 = 0;
    if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_6)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_6);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
        __pyx_t_12 = 1;
      }
    }
    __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_13);
    if (__pyx_t_6) {
      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_6); __pyx_t_6 = NULL;
    }
    __Pyx_INCREF(__pyx_v_datapath);
    __Pyx_GIVEREF(__pyx_v_datapath);
    PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_v_datapath);
    __Pyx_INCREF(__pyx_v_weightfile);
    __Pyx_GIVEREF(__pyx_v_weightfile);
    PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_weightfile);
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = NULL;
    if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_2)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_2);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    if (!__pyx_t_2) {
      __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 280, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_1);
    } else {
      __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 280, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_13);
      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_2); __pyx_t_2 = NULL;
      __Pyx_GIVEREF(__pyx_t_3);
      PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_3);
      __pyx_t_3 = 0;
      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 280, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
    }
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 280, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_8 = ((!__pyx_t_5) != 0);
    if (__pyx_t_8) {

      /* "healpy/src/_sphtools.pyx":281
 *         weightfile = 'weight_ring_n%05d.fits' % (nside)
 *         if not os.path.isfile(os.path.join(datapath, weightfile)):
 *             raise IOError('Weight file not found in %s' % (datapath))             # <<<<<<<<<<<<<<
 *         read_weight_ring(string(c_datapath), nside, w_arr[0])
 *         for i in range(w_arr.size()):
 */
      __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Weight_file_not_found_in_s, __pyx_v_datapath); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 281, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 281, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_GIVEREF(__pyx_t_1);
      PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
      __pyx_t_1 = 0;
      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 281, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __Pyx_Raise(__pyx_t_1, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
      __PYX_ERR(0, 281, __pyx_L1_error)

      /* "healpy/src/_sphtools.pyx":280
 *         c_datapath = datapath
 *         weightfile = 'weight_ring_n%05d.fits' % (nside)
 *         if not os.path.isfile(os.path.join(datapath, weightfile)):             # <<<<<<<<<<<<<<
 *             raise IOError('Weight file not found in %s' % (datapath))
 *         read_weight_ring(string(c_datapath), nside, w_arr[0])
 */
    }

    /* "healpy/src/_sphtools.pyx":282
 *         if not os.path.isfile(os.path.join(datapath, weightfile)):
 *             raise IOError('Weight file not found in %s' % (datapath))
 *         read_weight_ring(string(c_datapath), nside, w_arr[0])             # <<<<<<<<<<<<<<
 *         for i in range(w_arr.size()):
 *             w_arr[0][i] += 1
 */
    try {
      __pyx_t_14 = std::string(__pyx_v_c_datapath);
    } catch(...) {
      __Pyx_CppExn2PyErr();
      __PYX_ERR(0, 282, __pyx_L1_error)
    }
    read_weight_ring(__pyx_t_14, __pyx_v_nside, (__pyx_v_w_arr[0]));

    /* "healpy/src/_sphtools.pyx":283
 *             raise IOError('Weight file not found in %s' % (datapath))
 *         read_weight_ring(string(c_datapath), nside, w_arr[0])
 *         for i in range(w_arr.size()):             # <<<<<<<<<<<<<<
 *             w_arr[0][i] += 1
 *     else:
 */
    __pyx_t_15 = __pyx_v_w_arr->size();
    for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_15; __pyx_t_7+=1) {
      __pyx_v_i = __pyx_t_7;

      /* "healpy/src/_sphtools.pyx":284
 *         read_weight_ring(string(c_datapath), nside, w_arr[0])
 *         for i in range(w_arr.size()):
 *             w_arr[0][i] += 1             # <<<<<<<<<<<<<<
 *     else:
 *         w_arr.allocAndFill(2 * nside, 1.)
 */
      __pyx_t_16 = 0;
      __pyx_t_17 = __pyx_v_i;
      ((__pyx_v_w_arr[__pyx_t_16])[__pyx_t_17]) = (((__pyx_v_w_arr[__pyx_t_16])[__pyx_t_17]) + 1.0);
    }

    /* "healpy/src/_sphtools.pyx":275
 *     cdef int i
 *     cdef char *c_datapath
 *     if use_weights:             # <<<<<<<<<<<<<<
 *         if datapath is None:
 *             datapath = get_datapath()
 */
    goto __pyx_L18;
  }

  /* "healpy/src/_sphtools.pyx":286
 *             w_arr[0][i] += 1
 *     else:
 *         w_arr.allocAndFill(2 * nside, 1.)             # <<<<<<<<<<<<<<
 * 
 *     if polarization:
 */
  /*else*/ {
    __pyx_v_w_arr->allocAndFill((2 * __pyx_v_nside), 1.);
  }
  __pyx_L18:;

  /* "healpy/src/_sphtools.pyx":288
 *         w_arr.allocAndFill(2 * nside, 1.)
 * 
 *     if polarization:             # <<<<<<<<<<<<<<
 *         map2alm_pol_iter(MI[0], MQ[0], MU[0], AI[0], AG[0], AC[0], niter, w_arr[0])
 *     else:
 */
  __pyx_t_8 = (__pyx_v_polarization != 0);
  if (__pyx_t_8) {

    /* "healpy/src/_sphtools.pyx":289
 * 
 *     if polarization:
 *         map2alm_pol_iter(MI[0], MQ[0], MU[0], AI[0], AG[0], AC[0], niter, w_arr[0])             # <<<<<<<<<<<<<<
 *     else:
 *         map2alm_iter(MI[0], AI[0], niter, w_arr[0])
 */
    __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_niter); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 289, __pyx_L1_error)
    map2alm_pol_iter((__pyx_v_MI[0]), (__pyx_v_MQ[0]), (__pyx_v_MU[0]), (__pyx_v_AI[0]), (__pyx_v_AG[0]), (__pyx_v_AC[0]), __pyx_t_7, (__pyx_v_w_arr[0]));

    /* "healpy/src/_sphtools.pyx":288
 *         w_arr.allocAndFill(2 * nside, 1.)
 * 
 *     if polarization:             # <<<<<<<<<<<<<<
 *         map2alm_pol_iter(MI[0], MQ[0], MU[0], AI[0], AG[0], AC[0], niter, w_arr[0])
 *     else:
 */
    goto __pyx_L23;
  }

  /* "healpy/src/_sphtools.pyx":291
 *         map2alm_pol_iter(MI[0], MQ[0], MU[0], AI[0], AG[0], AC[0], niter, w_arr[0])
 *     else:
 *         map2alm_iter(MI[0], AI[0], niter, w_arr[0])             # <<<<<<<<<<<<<<
 * 
 *     # restore input map with UNSEEN pixels
 */
  /*else*/ {
    __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_niter); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 291, __pyx_L1_error)
    map2alm_iter((__pyx_v_MI[0]), (__pyx_v_AI[0]), __pyx_t_7, (__pyx_v_w_arr[0]));
  }
  __pyx_L23:;

  /* "healpy/src/_sphtools.pyx":294
 * 
 *     # restore input map with UNSEEN pixels
 *     if mask_mi is not False:             # <<<<<<<<<<<<<<
 *         mi[mask_mi] = UNSEEN
 *     if polarization:
 */
  __pyx_t_8 = (__pyx_v_mask_mi != Py_False);
  __pyx_t_5 = (__pyx_t_8 != 0);
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":295
 *     # restore input map with UNSEEN pixels
 *     if mask_mi is not False:
 *         mi[mask_mi] = UNSEEN             # <<<<<<<<<<<<<<
 *     if polarization:
 *         if mask_mq is not False:
 */
    __pyx_t_1 = PyFloat_FromDouble(__pyx_v_6healpy_9_sphtools_UNSEEN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    if (unlikely(PyObject_SetItem(__pyx_v_mi, __pyx_v_mask_mi, __pyx_t_1) < 0)) __PYX_ERR(0, 295, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

    /* "healpy/src/_sphtools.pyx":294
 * 
 *     # restore input map with UNSEEN pixels
 *     if mask_mi is not False:             # <<<<<<<<<<<<<<
 *         mi[mask_mi] = UNSEEN
 *     if polarization:
 */
  }

  /* "healpy/src/_sphtools.pyx":296
 *     if mask_mi is not False:
 *         mi[mask_mi] = UNSEEN
 *     if polarization:             # <<<<<<<<<<<<<<
 *         if mask_mq is not False:
 *             mq[mask_mq] = UNSEEN
 */
  __pyx_t_5 = (__pyx_v_polarization != 0);
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":297
 *         mi[mask_mi] = UNSEEN
 *     if polarization:
 *         if mask_mq is not False:             # <<<<<<<<<<<<<<
 *             mq[mask_mq] = UNSEEN
 *         if mask_mu is not False:
 */
    if (unlikely(!__pyx_v_mask_mq)) { __Pyx_RaiseUnboundLocalError("mask_mq"); __PYX_ERR(0, 297, __pyx_L1_error) }
    __pyx_t_5 = (__pyx_v_mask_mq != Py_False);
    __pyx_t_8 = (__pyx_t_5 != 0);
    if (__pyx_t_8) {

      /* "healpy/src/_sphtools.pyx":298
 *     if polarization:
 *         if mask_mq is not False:
 *             mq[mask_mq] = UNSEEN             # <<<<<<<<<<<<<<
 *         if mask_mu is not False:
 *             mu[mask_mu] = UNSEEN
 */
      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_6healpy_9_sphtools_UNSEEN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (unlikely(!__pyx_v_mq)) { __Pyx_RaiseUnboundLocalError("mq"); __PYX_ERR(0, 298, __pyx_L1_error) }
      if (unlikely(!__pyx_v_mask_mq)) { __Pyx_RaiseUnboundLocalError("mask_mq"); __PYX_ERR(0, 298, __pyx_L1_error) }
      if (unlikely(PyObject_SetItem(__pyx_v_mq, __pyx_v_mask_mq, __pyx_t_1) < 0)) __PYX_ERR(0, 298, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

      /* "healpy/src/_sphtools.pyx":297
 *         mi[mask_mi] = UNSEEN
 *     if polarization:
 *         if mask_mq is not False:             # <<<<<<<<<<<<<<
 *             mq[mask_mq] = UNSEEN
 *         if mask_mu is not False:
 */
    }

    /* "healpy/src/_sphtools.pyx":299
 *         if mask_mq is not False:
 *             mq[mask_mq] = UNSEEN
 *         if mask_mu is not False:             # <<<<<<<<<<<<<<
 *             mu[mask_mu] = UNSEEN
 * 
 */
    if (unlikely(!__pyx_v_mask_mu)) { __Pyx_RaiseUnboundLocalError("mask_mu"); __PYX_ERR(0, 299, __pyx_L1_error) }
    __pyx_t_8 = (__pyx_v_mask_mu != Py_False);
    __pyx_t_5 = (__pyx_t_8 != 0);
    if (__pyx_t_5) {

      /* "healpy/src/_sphtools.pyx":300
 *             mq[mask_mq] = UNSEEN
 *         if mask_mu is not False:
 *             mu[mask_mu] = UNSEEN             # <<<<<<<<<<<<<<
 * 
 *     del w_arr
 */
      __pyx_t_1 = PyFloat_FromDouble(__pyx_v_6healpy_9_sphtools_UNSEEN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 300, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_1);
      if (unlikely(!__pyx_v_mu)) { __Pyx_RaiseUnboundLocalError("mu"); __PYX_ERR(0, 300, __pyx_L1_error) }
      if (unlikely(!__pyx_v_mask_mu)) { __Pyx_RaiseUnboundLocalError("mask_mu"); __PYX_ERR(0, 300, __pyx_L1_error) }
      if (unlikely(PyObject_SetItem(__pyx_v_mu, __pyx_v_mask_mu, __pyx_t_1) < 0)) __PYX_ERR(0, 300, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

      /* "healpy/src/_sphtools.pyx":299
 *         if mask_mq is not False:
 *             mq[mask_mq] = UNSEEN
 *         if mask_mu is not False:             # <<<<<<<<<<<<<<
 *             mu[mask_mu] = UNSEEN
 * 
 */
    }

    /* "healpy/src/_sphtools.pyx":296
 *     if mask_mi is not False:
 *         mi[mask_mi] = UNSEEN
 *     if polarization:             # <<<<<<<<<<<<<<
 *         if mask_mq is not False:
 *             mq[mask_mq] = UNSEEN
 */
  }

  /* "healpy/src/_sphtools.pyx":302
 *             mu[mask_mu] = UNSEEN
 * 
 *     del w_arr             # <<<<<<<<<<<<<<
 *     if polarization:
 *         del MI, MQ, MU, AI, AG, AC
 */
  delete __pyx_v_w_arr;

  /* "healpy/src/_sphtools.pyx":303
 * 
 *     del w_arr
 *     if polarization:             # <<<<<<<<<<<<<<
 *         del MI, MQ, MU, AI, AG, AC
 *         return almI, almG, almC
 */
  __pyx_t_5 = (__pyx_v_polarization != 0);
  if (__pyx_t_5) {

    /* "healpy/src/_sphtools.pyx":304
 *     del w_arr
 *     if polarization:
 *         del MI, MQ, MU, AI, AG, AC             # <<<<<<<<<<<<<<
 *         return almI, almG, almC
 *     else:
 */
    delete __pyx_v_MI;
    delete __pyx_v_MQ;
    delete __pyx_v_MU;
    delete __pyx_v_AI;
    delete __pyx_v_AG;
    delete __pyx_v_AC;

    /* "healpy/src/_sphtools.pyx":305
 *     if polarization:
 *         del MI, MQ, MU, AI, AG, AC
 *         return almI, almG, almC             # <<<<<<<<<<<<<<
 *     else:
 *         del MI, AI
 */
    __Pyx_XDECREF(__pyx_r);
    if (unlikely(!__pyx_v_almG)) { __Pyx_RaiseUnboundLocalError("almG"); __PYX_ERR(0, 305, __pyx_L1_error) }
    if (unlikely(!__pyx_v_almC)) { __Pyx_RaiseUnboundLocalError("almC"); __PYX_ERR(0, 305, __pyx_L1_error) }
    __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_INCREF(__pyx_v_almI);
    __Pyx_GIVEREF(__pyx_v_almI);
    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_almI);
    __Pyx_INCREF(__pyx_v_almG);
    __Pyx_GIVEREF(__pyx_v_almG);
    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_almG);
    __Pyx_INCREF(__pyx_v_almC);
    __Pyx_GIVEREF(__pyx_v_almC);
    PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_almC);
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;

    /* "healpy/src/_sphtools.pyx":303
 * 
 *     del w_arr
 *     if polarization:             # <<<<<<<<<<<<<<
 *         del MI, MQ, MU, AI, AG, AC
 *         return almI, almG, almC
 */
  }

  /* "healpy/src/_sphtools.pyx":307
 *         return almI, almG, almC
 *     else:
 *         del MI, AI             # <<<<<<<<<<<<<<
 *         return almI
 * 
 */
  /*else*/ {
    delete __pyx_v_MI;
    delete __pyx_v_AI;

    /* "healpy/src/_sphtools.pyx":308
 *     else:
 *         del MI, AI
 *         return almI             # <<<<<<<<<<<<<<
 * 
 * 
 */
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_almI);
    __pyx_r = __pyx_v_almI;
    goto __pyx_L0;
  }

  /* "healpy/src/_sphtools.pyx":178
 *     return maps
 * 
 * def map2alm(m, lmax = None, mmax = None, niter = 3, use_weights = False,             # <<<<<<<<<<<<<<
 *             datapath = None):
 *     """Computes the alm of a Healpix map.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_AddTraceback("healpy._sphtools.map2alm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_info);
  __Pyx_XDECREF(__pyx_v_mi);
  __Pyx_XDECREF(__pyx_v_mq);
  __Pyx_XDECREF(__pyx_v_mu);
  __Pyx_XDECREF(__pyx_v_mask_mi);
  __Pyx_XDECREF(__pyx_v_mask_mq);
  __Pyx_XDECREF(__pyx_v_mask_mu);
  __Pyx_XDECREF(__pyx_v_almI);
  __Pyx_XDECREF(__pyx_v_almG);
  __Pyx_XDECREF(__pyx_v_almC);
  __Pyx_XDECREF(__pyx_v_weightfile);
  __Pyx_XDECREF(__pyx_v_datapath);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":311
 * 
 * 
 * def alm2cl(alms, alms2 = None, lmax = None, mmax = None, lmax_out = None):             # <<<<<<<<<<<<<<
 *     """Computes (cross-)spectra from alm(s). If alm2 is given, cross-spectra between
 *     alm and alm2 are computed. If alm (and alm2 if provided) contains n alm,
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_9alm2cl(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_8alm2cl[] = "alm2cl(alms, alms2=None, lmax=None, mmax=None, lmax_out=None)\nComputes (cross-)spectra from alm(s). If alm2 is given, cross-spectra between\n    alm and alm2 are computed. If alm (and alm2 if provided) contains n alm,\n    then n(n+1)/2 auto and cross-spectra are returned.\n\n    Parameters\n    ----------\n    alms : complex, array or sequence of arrays\n      The alm from which to compute the power spectrum. If n>=2 arrays are given,\n      computes both auto- and cross-spectra.\n    alms2 : complex, array or sequence of 3 arrays, optional\n      If provided, computes cross-spectra between alm and alm2.\n      Default: alm2=alm, so auto-spectra are computed.\n    lmax : None or int, optional\n      The maximum l of the input alm. Default: computed from size of alm\n      and mmax_in\n    mmax : None or int, optional\n      The maximum m of the input alm. Default: assume mmax_in = lmax_in\n    lmax_out : None or int, optional\n      The maximum l of the returned spectra. By default: the lmax of the given\n      alm(s).\n\n    Returns\n    -------\n    cl : array or tuple of n(n+1)/2 arrays\n      the spectrum <*alm* x *alm2*> if *alm* (and *alm2*) is one alm, or \n      the auto- and cross-spectra <*alm*[i] x *alm2*[j]> if alm (and alm2)\n      contains more than one spectra.\n      If more than one spectrum is returned, they are ordered by diagonal.\n      For example, if *alm* is almT, almE, almB, then the returned spectra are:\n      TT, EE, BB, TE, EB, TB.\n    ";
static PyMethodDef __pyx_mdef_6healpy_9_sphtools_9alm2cl = {"alm2cl", (PyCFunction)__pyx_pw_6healpy_9_sphtools_9alm2cl, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_9_sphtools_8alm2cl};
static PyObject *__pyx_pw_6healpy_9_sphtools_9alm2cl(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alms = 0;
  PyObject *__pyx_v_alms2 = 0;
  PyObject *__pyx_v_lmax = 0;
  PyObject *__pyx_v_mmax = 0;
  PyObject *__pyx_v_lmax_out = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("alm2cl (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alms,&__pyx_n_s_alms2,&__pyx_n_s_lmax,&__pyx_n_s_mmax,&__pyx_n_s_lmax_out,0};
    PyObject* values[5] = {0,0,0,0,0};
    values[1] = ((PyObject *)Py_None);
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_None);
    values[4] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_alms)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_alms2);
          if (value) { values[1] = value; kw_args--; }
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lmax);
          if (value) { values[2] = value; kw_args--; }
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mmax);
          if (value) { values[3] = value; kw_args--; }
        }
        case  4:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lmax_out);
          if (value) { values[4] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "alm2cl") < 0)) __PYX_ERR(0, 311, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_alms = values[0];
    __pyx_v_alms2 = values[1];
    __pyx_v_lmax = values[2];
    __pyx_v_mmax = values[3];
    __pyx_v_lmax_out = values[4];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("alm2cl", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 311, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._sphtools.alm2cl", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_9_sphtools_8alm2cl(__pyx_self, __pyx_v_alms, __pyx_v_alms2, __pyx_v_lmax, __pyx_v_mmax, __pyx_v_lmax_out);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_8alm2cl(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_alms, PyObject *__pyx_v_alms2, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax, PyObject *__pyx_v_lmax_out) {
  int __pyx_v_Nspec;
  int __pyx_v_Nspec2;
  int __pyx_v_alms_lonely;
  int __pyx_v_almsize;
  int __pyx_v_i;
  int __pyx_v_j;
  int __pyx_v_l;
  int __pyx_v_m;
  int __pyx_v_limit;
  int __pyx_v_lmax_;
  CYTHON_UNUSED int __pyx_v_mmax_;
  CYTHON_UNUSED int __pyx_v_lmax_out_;
  PyArrayObject *__pyx_v_powspec_ = 0;
  PyArrayObject *__pyx_v_alm1_ = 0;
  PyArrayObject *__pyx_v_alm2_ = 0;
  PyObject *__pyx_v_spectra = NULL;
  PyObject *__pyx_v_n = NULL;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_alm1_;
  __Pyx_Buffer __pyx_pybuffer_alm1_;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_alm2_;
  __Pyx_Buffer __pyx_pybuffer_alm2_;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_powspec_;
  __Pyx_Buffer __pyx_pybuffer_powspec_;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  Py_ssize_t __pyx_t_4;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_t_6;
  int __pyx_t_7;
  PyObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  PyObject *(*__pyx_t_11)(PyObject *);
  PyObject *(*__pyx_t_12)(PyObject *);
  long __pyx_t_13;
  PyObject *__pyx_t_14 = NULL;
  PyArrayObject *__pyx_t_15 = NULL;
  PyObject *__pyx_t_16 = NULL;
  PyObject *__pyx_t_17 = NULL;
  PyObject *__pyx_t_18 = NULL;
  PyArrayObject *__pyx_t_19 = NULL;
  PyArrayObject *__pyx_t_20 = NULL;
  long __pyx_t_21;
  Py_ssize_t __pyx_t_22;
  int __pyx_t_23;
  Py_ssize_t __pyx_t_24;
  Py_ssize_t __pyx_t_25;
  int __pyx_t_26;
  long __pyx_t_27;
  Py_ssize_t __pyx_t_28;
  Py_ssize_t __pyx_t_29;
  Py_ssize_t __pyx_t_30;
  Py_ssize_t __pyx_t_31;
  Py_ssize_t __pyx_t_32;
  Py_ssize_t __pyx_t_33;
  int __pyx_t_34;
  __Pyx_RefNannySetupContext("alm2cl", 0);
  __Pyx_INCREF(__pyx_v_alms);
  __Pyx_INCREF(__pyx_v_alms2);
  __Pyx_INCREF(__pyx_v_lmax);
  __Pyx_INCREF(__pyx_v_mmax);
  __Pyx_INCREF(__pyx_v_lmax_out);
  __pyx_pybuffer_powspec_.pybuffer.buf = NULL;
  __pyx_pybuffer_powspec_.refcount = 0;
  __pyx_pybuffernd_powspec_.data = NULL;
  __pyx_pybuffernd_powspec_.rcbuffer = &__pyx_pybuffer_powspec_;
  __pyx_pybuffer_alm1_.pybuffer.buf = NULL;
  __pyx_pybuffer_alm1_.refcount = 0;
  __pyx_pybuffernd_alm1_.data = NULL;
  __pyx_pybuffernd_alm1_.rcbuffer = &__pyx_pybuffer_alm1_;
  __pyx_pybuffer_alm2_.pybuffer.buf = NULL;
  __pyx_pybuffer_alm2_.refcount = 0;
  __pyx_pybuffernd_alm2_.data = NULL;
  __pyx_pybuffernd_alm2_.rcbuffer = &__pyx_pybuffer_alm2_;

  /* "healpy/src/_sphtools.pyx":347
 *     #
 *     cdef int Nspec, Nspec2
 *     if not hasattr(alms, '__len__'):             # <<<<<<<<<<<<<<
 *         raise ValueError('alms must be an array or a sequence of arrays')
 *     if not hasattr(alms[0], '__len__'):
 */
  __pyx_t_1 = PyObject_HasAttr(__pyx_v_alms, __pyx_n_s_len); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 347, __pyx_L1_error)
  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_sphtools.pyx":348
 *     cdef int Nspec, Nspec2
 *     if not hasattr(alms, '__len__'):
 *         raise ValueError('alms must be an array or a sequence of arrays')             # <<<<<<<<<<<<<<
 *     if not hasattr(alms[0], '__len__'):
 *         alms_lonely = True
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 348, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 348, __pyx_L1_error)

    /* "healpy/src/_sphtools.pyx":347
 *     #
 *     cdef int Nspec, Nspec2
 *     if not hasattr(alms, '__len__'):             # <<<<<<<<<<<<<<
 *         raise ValueError('alms must be an array or a sequence of arrays')
 *     if not hasattr(alms[0], '__len__'):
 */
  }

  /* "healpy/src/_sphtools.pyx":349
 *     if not hasattr(alms, '__len__'):
 *         raise ValueError('alms must be an array or a sequence of arrays')
 *     if not hasattr(alms[0], '__len__'):             # <<<<<<<<<<<<<<
 *         alms_lonely = True
 *         alms = [alms]
 */
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_alms, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = PyObject_HasAttr(__pyx_t_3, __pyx_n_s_len); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 349, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":350
 *         raise ValueError('alms must be an array or a sequence of arrays')
 *     if not hasattr(alms[0], '__len__'):
 *         alms_lonely = True             # <<<<<<<<<<<<<<
 *         alms = [alms]
 *     else:
 */
    __pyx_v_alms_lonely = 1;

    /* "healpy/src/_sphtools.pyx":351
 *     if not hasattr(alms[0], '__len__'):
 *         alms_lonely = True
 *         alms = [alms]             # <<<<<<<<<<<<<<
 *     else:
 *         alms_lonely = False
 */
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_alms);
    __Pyx_GIVEREF(__pyx_v_alms);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_alms);
    __Pyx_DECREF_SET(__pyx_v_alms, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "healpy/src/_sphtools.pyx":349
 *     if not hasattr(alms, '__len__'):
 *         raise ValueError('alms must be an array or a sequence of arrays')
 *     if not hasattr(alms[0], '__len__'):             # <<<<<<<<<<<<<<
 *         alms_lonely = True
 *         alms = [alms]
 */
    goto __pyx_L4;
  }

  /* "healpy/src/_sphtools.pyx":353
 *         alms = [alms]
 *     else:
 *         alms_lonely = False             # <<<<<<<<<<<<<<
 * 
 *     Nspec = len(alms)
 */
  /*else*/ {
    __pyx_v_alms_lonely = 0;
  }
  __pyx_L4:;

  /* "healpy/src/_sphtools.pyx":355
 *         alms_lonely = False
 * 
 *     Nspec = len(alms)             # <<<<<<<<<<<<<<
 * 
 *     if alms2 is None:
 */
  __pyx_t_4 = PyObject_Length(__pyx_v_alms); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 355, __pyx_L1_error)
  __pyx_v_Nspec = __pyx_t_4;

  /* "healpy/src/_sphtools.pyx":357
 *     Nspec = len(alms)
 * 
 *     if alms2 is None:             # <<<<<<<<<<<<<<
 *         alms2 = alms
 * 
 */
  __pyx_t_1 = (__pyx_v_alms2 == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_sphtools.pyx":358
 * 
 *     if alms2 is None:
 *         alms2 = alms             # <<<<<<<<<<<<<<
 * 
 *     if not hasattr(alms2, '__len__'):
 */
    __Pyx_INCREF(__pyx_v_alms);
    __Pyx_DECREF_SET(__pyx_v_alms2, __pyx_v_alms);

    /* "healpy/src/_sphtools.pyx":357
 *     Nspec = len(alms)
 * 
 *     if alms2 is None:             # <<<<<<<<<<<<<<
 *         alms2 = alms
 * 
 */
  }

  /* "healpy/src/_sphtools.pyx":360
 *         alms2 = alms
 * 
 *     if not hasattr(alms2, '__len__'):             # <<<<<<<<<<<<<<
 *         raise ValueError('alms2 must be an array or a sequence of arrays')
 *     if not hasattr(alms2[0], '__len__'):
 */
  __pyx_t_2 = PyObject_HasAttr(__pyx_v_alms2, __pyx_n_s_len); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 360, __pyx_L1_error)
  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":361
 * 
 *     if not hasattr(alms2, '__len__'):
 *         raise ValueError('alms2 must be an array or a sequence of arrays')             # <<<<<<<<<<<<<<
 *     if not hasattr(alms2[0], '__len__'):
 *         alms2 = [alms2]
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 361, __pyx_L1_error)

    /* "healpy/src/_sphtools.pyx":360
 *         alms2 = alms
 * 
 *     if not hasattr(alms2, '__len__'):             # <<<<<<<<<<<<<<
 *         raise ValueError('alms2 must be an array or a sequence of arrays')
 *     if not hasattr(alms2[0], '__len__'):
 */
  }

  /* "healpy/src/_sphtools.pyx":362
 *     if not hasattr(alms2, '__len__'):
 *         raise ValueError('alms2 must be an array or a sequence of arrays')
 *     if not hasattr(alms2[0], '__len__'):             # <<<<<<<<<<<<<<
 *         alms2 = [alms2]
 *     Nspec2 = len(alms2)
 */
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_alms2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_1 = PyObject_HasAttr(__pyx_t_3, __pyx_n_s_len); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 362, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_sphtools.pyx":363
 *         raise ValueError('alms2 must be an array or a sequence of arrays')
 *     if not hasattr(alms2[0], '__len__'):
 *         alms2 = [alms2]             # <<<<<<<<<<<<<<
 *     Nspec2 = len(alms2)
 * 
 */
    __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_INCREF(__pyx_v_alms2);
    __Pyx_GIVEREF(__pyx_v_alms2);
    PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_alms2);
    __Pyx_DECREF_SET(__pyx_v_alms2, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "healpy/src/_sphtools.pyx":362
 *     if not hasattr(alms2, '__len__'):
 *         raise ValueError('alms2 must be an array or a sequence of arrays')
 *     if not hasattr(alms2[0], '__len__'):             # <<<<<<<<<<<<<<
 *         alms2 = [alms2]
 *     Nspec2 = len(alms2)
 */
  }

  /* "healpy/src/_sphtools.pyx":364
 *     if not hasattr(alms2[0], '__len__'):
 *         alms2 = [alms2]
 *     Nspec2 = len(alms2)             # <<<<<<<<<<<<<<
 * 
 *     if Nspec != Nspec2:
 */
  __pyx_t_4 = PyObject_Length(__pyx_v_alms2); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_v_Nspec2 = __pyx_t_4;

  /* "healpy/src/_sphtools.pyx":366
 *     Nspec2 = len(alms2)
 * 
 *     if Nspec != Nspec2:             # <<<<<<<<<<<<<<
 *         raise ValueError('alms and alms2 must have same number of spectra')
 * 
 */
  __pyx_t_2 = ((__pyx_v_Nspec != __pyx_v_Nspec2) != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_sphtools.pyx":367
 * 
 *     if Nspec != Nspec2:
 *         raise ValueError('alms and alms2 must have same number of spectra')             # <<<<<<<<<<<<<<
 * 
 *     ##############################################
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(0, 367, __pyx_L1_error)

    /* "healpy/src/_sphtools.pyx":366
 *     Nspec2 = len(alms2)
 * 
 *     if Nspec != Nspec2:             # <<<<<<<<<<<<<<
 *         raise ValueError('alms and alms2 must have same number of spectra')
 * 
 */
  }

  /* "healpy/src/_sphtools.pyx":373
 *     #
 *     cdef int almsize
 *     almsize = alms[0].size             # <<<<<<<<<<<<<<
 *     for i in xrange(Nspec):
 *         if alms[i].size != almsize or alms2[i].size != almsize:
 */
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_alms, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 373, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 373, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 373, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_almsize = __pyx_t_6;

  /* "healpy/src/_sphtools.pyx":374
 *     cdef int almsize
 *     almsize = alms[0].size
 *     for i in xrange(Nspec):             # <<<<<<<<<<<<<<
 *         if alms[i].size != almsize or alms2[i].size != almsize:
 *             raise ValueError('all alms must have same size')
 */
  __pyx_t_6 = __pyx_v_Nspec;
  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
    __pyx_v_i = __pyx_t_7;

    /* "healpy/src/_sphtools.pyx":375
 *     almsize = alms[0].size
 *     for i in xrange(Nspec):
 *         if alms[i].size != almsize or alms2[i].size != almsize:             # <<<<<<<<<<<<<<
 *             raise ValueError('all alms must have same size')
 * 
 */
    __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_alms, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_almsize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    if (!__pyx_t_1) {
    } else {
      __pyx_t_2 = __pyx_t_1;
      goto __pyx_L12_bool_binop_done;
    }
    __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_alms2, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_almsize); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 375, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_2 = __pyx_t_1;
    __pyx_L12_bool_binop_done:;
    if (__pyx_t_2) {

      /* "healpy/src/_sphtools.pyx":376
 *     for i in xrange(Nspec):
 *         if alms[i].size != almsize or alms2[i].size != almsize:
 *             raise ValueError('all alms must have same size')             # <<<<<<<<<<<<<<
 * 
 *     lmax, mmax = alm_getlmmax(alms[0], lmax, mmax)
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 376, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(0, 376, __pyx_L1_error)

      /* "healpy/src/_sphtools.pyx":375
 *     almsize = alms[0].size
 *     for i in xrange(Nspec):
 *         if alms[i].size != almsize or alms2[i].size != almsize:             # <<<<<<<<<<<<<<
 *             raise ValueError('all alms must have same size')
 * 
 */
    }
  }

  /* "healpy/src/_sphtools.pyx":378
 *             raise ValueError('all alms must have same size')
 * 
 *     lmax, mmax = alm_getlmmax(alms[0], lmax, mmax)             # <<<<<<<<<<<<<<
 * 
 *     if lmax_out is None:
 */
  __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_alm_getlmmax); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_alms, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = NULL;
  __pyx_t_4 = 0;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) {
    __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
    if (likely(__pyx_t_9)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
      __Pyx_INCREF(__pyx_t_9);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_8, function);
      __pyx_t_4 = 1;
    }
  }
  __pyx_t_10 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  if (__pyx_t_9) {
    __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL;
  }
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_4, __pyx_t_5);
  __Pyx_INCREF(__pyx_v_lmax);
  __Pyx_GIVEREF(__pyx_v_lmax);
  PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_4, __pyx_v_lmax);
  __Pyx_INCREF(__pyx_v_mmax);
  __Pyx_GIVEREF(__pyx_v_mmax);
  PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_4, __pyx_v_mmax);
  __pyx_t_5 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 378, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
    PyObject* sequence = __pyx_t_3;
    #if CYTHON_COMPILING_IN_CPYTHON
    Py_ssize_t size = Py_SIZE(sequence);
    #else
    Py_ssize_t size = PySequence_Size(sequence);
    #endif
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 378, __pyx_L1_error)
    }
    #if CYTHON_COMPILING_IN_CPYTHON
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_10 = PyTuple_GET_ITEM(sequence, 1); 
    } else {
      __pyx_t_8 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_10 = PyList_GET_ITEM(sequence, 1); 
    }
    __Pyx_INCREF(__pyx_t_8);
    __Pyx_INCREF(__pyx_t_10);
    #else
    __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 378, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __pyx_t_10 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 378, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    #endif
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 378, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_11 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_8 = __pyx_t_11(__pyx_t_5); if (unlikely(!__pyx_t_8)) goto __pyx_L14_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_8);
    index = 1; __pyx_t_10 = __pyx_t_11(__pyx_t_5); if (unlikely(!__pyx_t_10)) goto __pyx_L14_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_10);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_5), 2) < 0) __PYX_ERR(0, 378, __pyx_L1_error)
    __pyx_t_11 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L15_unpacking_done;
    __pyx_L14_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_11 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 378, __pyx_L1_error)
    __pyx_L15_unpacking_done:;
  }
  __Pyx_DECREF_SET(__pyx_v_lmax, __pyx_t_8);
  __pyx_t_8 = 0;
  __Pyx_DECREF_SET(__pyx_v_mmax, __pyx_t_10);
  __pyx_t_10 = 0;

  /* "healpy/src/_sphtools.pyx":380
 *     lmax, mmax = alm_getlmmax(alms[0], lmax, mmax)
 * 
 *     if lmax_out is None:             # <<<<<<<<<<<<<<
 *         lmax_out = lmax
 * 
 */
  __pyx_t_2 = (__pyx_v_lmax_out == Py_None);
  __pyx_t_1 = (__pyx_t_2 != 0);
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":381
 * 
 *     if lmax_out is None:
 *         lmax_out = lmax             # <<<<<<<<<<<<<<
 * 
 * 
 */
    __Pyx_INCREF(__pyx_v_lmax);
    __Pyx_DECREF_SET(__pyx_v_lmax_out, __pyx_v_lmax);

    /* "healpy/src/_sphtools.pyx":380
 *     lmax, mmax = alm_getlmmax(alms[0], lmax, mmax)
 * 
 *     if lmax_out is None:             # <<<<<<<<<<<<<<
 *         lmax_out = lmax
 * 
 */
  }

  /* "healpy/src/_sphtools.pyx":388
 *     #
 *     cdef int j, l, m, limit
 *     cdef int lmax_ = lmax, mmax_ = mmax             # <<<<<<<<<<<<<<
 *     cdef int lmax_out_ = lmax_out
 * 
 */
  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_lmax); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 388, __pyx_L1_error)
  __pyx_v_lmax_ = __pyx_t_6;
  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 388, __pyx_L1_error)
  __pyx_v_mmax_ = __pyx_t_6;

  /* "healpy/src/_sphtools.pyx":389
 *     cdef int j, l, m, limit
 *     cdef int lmax_ = lmax, mmax_ = mmax
 *     cdef int lmax_out_ = lmax_out             # <<<<<<<<<<<<<<
 * 
 *     cdef np.ndarray[double, ndim=1] powspec_
 */
  __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_lmax_out); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 389, __pyx_L1_error)
  __pyx_v_lmax_out_ = __pyx_t_6;

  /* "healpy/src/_sphtools.pyx":395
 *     cdef np.ndarray[np.complex128_t, ndim=1] alm2_
 * 
 *     spectra = []             # <<<<<<<<<<<<<<
 *     for n in xrange(Nspec): # diagonal rank
 *         for m in xrange(0, Nspec - n): # position in the diagonal
 */
  __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_v_spectra = __pyx_t_3;
  __pyx_t_3 = 0;

  /* "healpy/src/_sphtools.pyx":396
 * 
 *     spectra = []
 *     for n in xrange(Nspec): # diagonal rank             # <<<<<<<<<<<<<<
 *         for m in xrange(0, Nspec - n): # position in the diagonal
 *             powspec_ = np.zeros(lmax + 1)
 */
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_Nspec); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_10);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_3);
  __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_xrange, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
    __pyx_t_10 = __pyx_t_3; __Pyx_INCREF(__pyx_t_10); __pyx_t_4 = 0;
    __pyx_t_12 = NULL;
  } else {
    __pyx_t_4 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 396, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __pyx_t_12 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 396, __pyx_L1_error)
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  for (;;) {
    if (likely(!__pyx_t_12)) {
      if (likely(PyList_CheckExact(__pyx_t_10))) {
        if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_10)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 396, __pyx_L1_error)
        #else
        __pyx_t_3 = PySequence_ITEM(__pyx_t_10, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 396, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        #endif
      } else {
        if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_10)) break;
        #if CYTHON_COMPILING_IN_CPYTHON
        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 396, __pyx_L1_error)
        #else
        __pyx_t_3 = PySequence_ITEM(__pyx_t_10, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 396, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        #endif
      }
    } else {
      __pyx_t_3 = __pyx_t_12(__pyx_t_10);
      if (unlikely(!__pyx_t_3)) {
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
          else __PYX_ERR(0, 396, __pyx_L1_error)
        }
        break;
      }
      __Pyx_GOTREF(__pyx_t_3);
    }
    __Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "healpy/src/_sphtools.pyx":397
 *     spectra = []
 *     for n in xrange(Nspec): # diagonal rank
 *         for m in xrange(0, Nspec - n): # position in the diagonal             # <<<<<<<<<<<<<<
 *             powspec_ = np.zeros(lmax + 1)
 *             alm1_ = alms[m]
 */
    __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_Nspec); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_8 = PyNumber_Subtract(__pyx_t_3, __pyx_v_n); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 397, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_8);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_13 = __Pyx_PyInt_As_long(__pyx_t_8); if (unlikely((__pyx_t_13 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_13; __pyx_t_6+=1) {
      __pyx_v_m = __pyx_t_6;

      /* "healpy/src/_sphtools.pyx":398
 *     for n in xrange(Nspec): # diagonal rank
 *         for m in xrange(0, Nspec - n): # position in the diagonal
 *             powspec_ = np.zeros(lmax + 1)             # <<<<<<<<<<<<<<
 *             alm1_ = alms[m]
 *             alm2_ = alms2[m + n]
 */
      __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 398, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 398, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_lmax, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 398, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_9 = NULL;
      if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
        __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
        if (likely(__pyx_t_9)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
          __Pyx_INCREF(__pyx_t_9);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_5, function);
        }
      }
      if (!__pyx_t_9) {
        __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 398, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __Pyx_GOTREF(__pyx_t_8);
      } else {
        __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 398, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_14);
        __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_9); __pyx_t_9 = NULL;
        __Pyx_GIVEREF(__pyx_t_3);
        PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_t_3);
        __pyx_t_3 = 0;
        __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_14, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 398, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
      }
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 398, __pyx_L1_error)
      __pyx_t_15 = ((PyArrayObject *)__pyx_t_8);
      {
        __Pyx_BufFmt_StackElem __pyx_stack[1];
        __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_powspec_.rcbuffer->pybuffer);
        __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_powspec_.rcbuffer->pybuffer, (PyObject*)__pyx_t_15, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack);
        if (unlikely(__pyx_t_7 < 0)) {
          PyErr_Fetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
          if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_powspec_.rcbuffer->pybuffer, (PyObject*)__pyx_v_powspec_, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
            Py_XDECREF(__pyx_t_16); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_18);
            __Pyx_RaiseBufferFallbackError();
          } else {
            PyErr_Restore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
          }
        }
        __pyx_pybuffernd_powspec_.diminfo[0].strides = __pyx_pybuffernd_powspec_.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_powspec_.diminfo[0].shape = __pyx_pybuffernd_powspec_.rcbuffer->pybuffer.shape[0];
        if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 398, __pyx_L1_error)
      }
      __pyx_t_15 = 0;
      __Pyx_XDECREF_SET(__pyx_v_powspec_, ((PyArrayObject *)__pyx_t_8));
      __pyx_t_8 = 0;

      /* "healpy/src/_sphtools.pyx":399
 *         for m in xrange(0, Nspec - n): # position in the diagonal
 *             powspec_ = np.zeros(lmax + 1)
 *             alm1_ = alms[m]             # <<<<<<<<<<<<<<
 *             alm2_ = alms2[m + n]
 *             # compute cross-spectrum alm1[n] x alm2[n+m]
 */
      __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_alms, __pyx_v_m, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 399, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 399, __pyx_L1_error)
      __pyx_t_19 = ((PyArrayObject *)__pyx_t_8);
      {
        __Pyx_BufFmt_StackElem __pyx_stack[1];
        __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm1_.rcbuffer->pybuffer);
        __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alm1_.rcbuffer->pybuffer, (PyObject*)__pyx_t_19, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);
        if (unlikely(__pyx_t_7 < 0)) {
          PyErr_Fetch(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
          if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alm1_.rcbuffer->pybuffer, (PyObject*)__pyx_v_alm1_, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
            Py_XDECREF(__pyx_t_18); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_16);
            __Pyx_RaiseBufferFallbackError();
          } else {
            PyErr_Restore(__pyx_t_18, __pyx_t_17, __pyx_t_16);
          }
        }
        __pyx_pybuffernd_alm1_.diminfo[0].strides = __pyx_pybuffernd_alm1_.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_alm1_.diminfo[0].shape = __pyx_pybuffernd_alm1_.rcbuffer->pybuffer.shape[0];
        if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 399, __pyx_L1_error)
      }
      __pyx_t_19 = 0;
      __Pyx_XDECREF_SET(__pyx_v_alm1_, ((PyArrayObject *)__pyx_t_8));
      __pyx_t_8 = 0;

      /* "healpy/src/_sphtools.pyx":400
 *             powspec_ = np.zeros(lmax + 1)
 *             alm1_ = alms[m]
 *             alm2_ = alms2[m + n]             # <<<<<<<<<<<<<<
 *             # compute cross-spectrum alm1[n] x alm2[n+m]
 *             # and place result in result list
 */
      __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_m); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 400, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __pyx_t_5 = PyNumber_Add(__pyx_t_8, __pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 400, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
      __pyx_t_8 = PyObject_GetItem(__pyx_v_alms2, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 400, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_8);
      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
      if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 400, __pyx_L1_error)
      __pyx_t_20 = ((PyArrayObject *)__pyx_t_8);
      {
        __Pyx_BufFmt_StackElem __pyx_stack[1];
        __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm2_.rcbuffer->pybuffer);
        __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alm2_.rcbuffer->pybuffer, (PyObject*)__pyx_t_20, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);
        if (unlikely(__pyx_t_7 < 0)) {
          PyErr_Fetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
          if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alm2_.rcbuffer->pybuffer, (PyObject*)__pyx_v_alm2_, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
            Py_XDECREF(__pyx_t_16); Py_XDECREF(__pyx_t_17); Py_XDECREF(__pyx_t_18);
            __Pyx_RaiseBufferFallbackError();
          } else {
            PyErr_Restore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
          }
        }
        __pyx_pybuffernd_alm2_.diminfo[0].strides = __pyx_pybuffernd_alm2_.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_alm2_.diminfo[0].shape = __pyx_pybuffernd_alm2_.rcbuffer->pybuffer.shape[0];
        if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 400, __pyx_L1_error)
      }
      __pyx_t_20 = 0;
      __Pyx_XDECREF_SET(__pyx_v_alm2_, ((PyArrayObject *)__pyx_t_8));
      __pyx_t_8 = 0;

      /* "healpy/src/_sphtools.pyx":403
 *             # compute cross-spectrum alm1[n] x alm2[n+m]
 *             # and place result in result list
 *             for l in range(lmax_ + 1):             # <<<<<<<<<<<<<<
 *                 j = alm_getidx(lmax_, l, 0)
 *                 powspec_[l] = alm1_[j].real * alm2_[j].real
 */
      __pyx_t_21 = (__pyx_v_lmax_ + 1);
      for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_21; __pyx_t_7+=1) {
        __pyx_v_l = __pyx_t_7;

        /* "healpy/src/_sphtools.pyx":404
 *             # and place result in result list
 *             for l in range(lmax_ + 1):
 *                 j = alm_getidx(lmax_, l, 0)             # <<<<<<<<<<<<<<
 *                 powspec_[l] = alm1_[j].real * alm2_[j].real
 *                 limit = l if l <= mmax else mmax
 */
        __pyx_v_j = __pyx_f_6healpy_9_sphtools_alm_getidx(__pyx_v_lmax_, __pyx_v_l, 0);

        /* "healpy/src/_sphtools.pyx":405
 *             for l in range(lmax_ + 1):
 *                 j = alm_getidx(lmax_, l, 0)
 *                 powspec_[l] = alm1_[j].real * alm2_[j].real             # <<<<<<<<<<<<<<
 *                 limit = l if l <= mmax else mmax
 *                 for m in range(1, limit + 1):
 */
        __pyx_t_22 = __pyx_v_j;
        __pyx_t_23 = -1;
        if (__pyx_t_22 < 0) {
          __pyx_t_22 += __pyx_pybuffernd_alm1_.diminfo[0].shape;
          if (unlikely(__pyx_t_22 < 0)) __pyx_t_23 = 0;
        } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_alm1_.diminfo[0].shape)) __pyx_t_23 = 0;
        if (unlikely(__pyx_t_23 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_23);
          __PYX_ERR(0, 405, __pyx_L1_error)
        }
        __pyx_t_24 = __pyx_v_j;
        __pyx_t_23 = -1;
        if (__pyx_t_24 < 0) {
          __pyx_t_24 += __pyx_pybuffernd_alm2_.diminfo[0].shape;
          if (unlikely(__pyx_t_24 < 0)) __pyx_t_23 = 0;
        } else if (unlikely(__pyx_t_24 >= __pyx_pybuffernd_alm2_.diminfo[0].shape)) __pyx_t_23 = 0;
        if (unlikely(__pyx_t_23 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_23);
          __PYX_ERR(0, 405, __pyx_L1_error)
        }
        __pyx_t_25 = __pyx_v_l;
        __pyx_t_23 = -1;
        if (__pyx_t_25 < 0) {
          __pyx_t_25 += __pyx_pybuffernd_powspec_.diminfo[0].shape;
          if (unlikely(__pyx_t_25 < 0)) __pyx_t_23 = 0;
        } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_powspec_.diminfo[0].shape)) __pyx_t_23 = 0;
        if (unlikely(__pyx_t_23 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_23);
          __PYX_ERR(0, 405, __pyx_L1_error)
        }
        *__Pyx_BufPtrStrided1d(double *, __pyx_pybuffernd_powspec_.rcbuffer->pybuffer.buf, __pyx_t_25, __pyx_pybuffernd_powspec_.diminfo[0].strides) = (__Pyx_CREAL((*__Pyx_BufPtrStrided1d(__pyx_t_double_complex *, __pyx_pybuffernd_alm1_.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_alm1_.diminfo[0].strides))) * __Pyx_CREAL((*__Pyx_BufPtrStrided1d(__pyx_t_double_complex *, __pyx_pybuffernd_alm2_.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_alm2_.diminfo[0].strides))));

        /* "healpy/src/_sphtools.pyx":406
 *                 j = alm_getidx(lmax_, l, 0)
 *                 powspec_[l] = alm1_[j].real * alm2_[j].real
 *                 limit = l if l <= mmax else mmax             # <<<<<<<<<<<<<<
 *                 for m in range(1, limit + 1):
 *                     j = alm_getidx(lmax_, l, m)
 */
        __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_l); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 406, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_8);
        __pyx_t_5 = PyObject_RichCompare(__pyx_t_8, __pyx_v_mmax, Py_LE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 406, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
        __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 406, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        if (__pyx_t_1) {
          __pyx_t_23 = __pyx_v_l;
        } else {
          __pyx_t_26 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_26 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 406, __pyx_L1_error)
          __pyx_t_23 = __pyx_t_26;
        }
        __pyx_v_limit = __pyx_t_23;

        /* "healpy/src/_sphtools.pyx":407
 *                 powspec_[l] = alm1_[j].real * alm2_[j].real
 *                 limit = l if l <= mmax else mmax
 *                 for m in range(1, limit + 1):             # <<<<<<<<<<<<<<
 *                     j = alm_getidx(lmax_, l, m)
 *                     powspec_[l] += 2 * (alm1_[j].real * alm2_[j].real +
 */
        __pyx_t_27 = (__pyx_v_limit + 1);
        for (__pyx_t_23 = 1; __pyx_t_23 < __pyx_t_27; __pyx_t_23+=1) {
          __pyx_v_m = __pyx_t_23;

          /* "healpy/src/_sphtools.pyx":408
 *                 limit = l if l <= mmax else mmax
 *                 for m in range(1, limit + 1):
 *                     j = alm_getidx(lmax_, l, m)             # <<<<<<<<<<<<<<
 *                     powspec_[l] += 2 * (alm1_[j].real * alm2_[j].real +
 *                                         alm1_[j].imag * alm2_[j].imag)
 */
          __pyx_v_j = __pyx_f_6healpy_9_sphtools_alm_getidx(__pyx_v_lmax_, __pyx_v_l, __pyx_v_m);

          /* "healpy/src/_sphtools.pyx":409
 *                 for m in range(1, limit + 1):
 *                     j = alm_getidx(lmax_, l, m)
 *                     powspec_[l] += 2 * (alm1_[j].real * alm2_[j].real +             # <<<<<<<<<<<<<<
 *                                         alm1_[j].imag * alm2_[j].imag)
 *                 powspec_[l] /= (2 * l + 1)
 */
          __pyx_t_28 = __pyx_v_j;
          __pyx_t_26 = -1;
          if (__pyx_t_28 < 0) {
            __pyx_t_28 += __pyx_pybuffernd_alm1_.diminfo[0].shape;
            if (unlikely(__pyx_t_28 < 0)) __pyx_t_26 = 0;
          } else if (unlikely(__pyx_t_28 >= __pyx_pybuffernd_alm1_.diminfo[0].shape)) __pyx_t_26 = 0;
          if (unlikely(__pyx_t_26 != -1)) {
            __Pyx_RaiseBufferIndexError(__pyx_t_26);
            __PYX_ERR(0, 409, __pyx_L1_error)
          }
          __pyx_t_29 = __pyx_v_j;
          __pyx_t_26 = -1;
          if (__pyx_t_29 < 0) {
            __pyx_t_29 += __pyx_pybuffernd_alm2_.diminfo[0].shape;
            if (unlikely(__pyx_t_29 < 0)) __pyx_t_26 = 0;
          } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_alm2_.diminfo[0].shape)) __pyx_t_26 = 0;
          if (unlikely(__pyx_t_26 != -1)) {
            __Pyx_RaiseBufferIndexError(__pyx_t_26);
            __PYX_ERR(0, 409, __pyx_L1_error)
          }

          /* "healpy/src/_sphtools.pyx":410
 *                     j = alm_getidx(lmax_, l, m)
 *                     powspec_[l] += 2 * (alm1_[j].real * alm2_[j].real +
 *                                         alm1_[j].imag * alm2_[j].imag)             # <<<<<<<<<<<<<<
 *                 powspec_[l] /= (2 * l + 1)
 *             spectra.append(powspec_)
 */
          __pyx_t_30 = __pyx_v_j;
          __pyx_t_26 = -1;
          if (__pyx_t_30 < 0) {
            __pyx_t_30 += __pyx_pybuffernd_alm1_.diminfo[0].shape;
            if (unlikely(__pyx_t_30 < 0)) __pyx_t_26 = 0;
          } else if (unlikely(__pyx_t_30 >= __pyx_pybuffernd_alm1_.diminfo[0].shape)) __pyx_t_26 = 0;
          if (unlikely(__pyx_t_26 != -1)) {
            __Pyx_RaiseBufferIndexError(__pyx_t_26);
            __PYX_ERR(0, 410, __pyx_L1_error)
          }
          __pyx_t_31 = __pyx_v_j;
          __pyx_t_26 = -1;
          if (__pyx_t_31 < 0) {
            __pyx_t_31 += __pyx_pybuffernd_alm2_.diminfo[0].shape;
            if (unlikely(__pyx_t_31 < 0)) __pyx_t_26 = 0;
          } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_alm2_.diminfo[0].shape)) __pyx_t_26 = 0;
          if (unlikely(__pyx_t_26 != -1)) {
            __Pyx_RaiseBufferIndexError(__pyx_t_26);
            __PYX_ERR(0, 410, __pyx_L1_error)
          }

          /* "healpy/src/_sphtools.pyx":409
 *                 for m in range(1, limit + 1):
 *                     j = alm_getidx(lmax_, l, m)
 *                     powspec_[l] += 2 * (alm1_[j].real * alm2_[j].real +             # <<<<<<<<<<<<<<
 *                                         alm1_[j].imag * alm2_[j].imag)
 *                 powspec_[l] /= (2 * l + 1)
 */
          __pyx_t_32 = __pyx_v_l;
          __pyx_t_26 = -1;
          if (__pyx_t_32 < 0) {
            __pyx_t_32 += __pyx_pybuffernd_powspec_.diminfo[0].shape;
            if (unlikely(__pyx_t_32 < 0)) __pyx_t_26 = 0;
          } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_powspec_.diminfo[0].shape)) __pyx_t_26 = 0;
          if (unlikely(__pyx_t_26 != -1)) {
            __Pyx_RaiseBufferIndexError(__pyx_t_26);
            __PYX_ERR(0, 409, __pyx_L1_error)
          }
          *__Pyx_BufPtrStrided1d(double *, __pyx_pybuffernd_powspec_.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_powspec_.diminfo[0].strides) += (2.0 * ((__Pyx_CREAL((*__Pyx_BufPtrStrided1d(__pyx_t_double_complex *, __pyx_pybuffernd_alm1_.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_alm1_.diminfo[0].strides))) * __Pyx_CREAL((*__Pyx_BufPtrStrided1d(__pyx_t_double_complex *, __pyx_pybuffernd_alm2_.rcbuffer->pybuffer.buf, __pyx_t_29, __pyx_pybuffernd_alm2_.diminfo[0].strides)))) + (__Pyx_CIMAG((*__Pyx_BufPtrStrided1d(__pyx_t_double_complex *, __pyx_pybuffernd_alm1_.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_alm1_.diminfo[0].strides))) * __Pyx_CIMAG((*__Pyx_BufPtrStrided1d(__pyx_t_double_complex *, __pyx_pybuffernd_alm2_.rcbuffer->pybuffer.buf, __pyx_t_31, __pyx_pybuffernd_alm2_.diminfo[0].strides))))));
        }

        /* "healpy/src/_sphtools.pyx":411
 *                     powspec_[l] += 2 * (alm1_[j].real * alm2_[j].real +
 *                                         alm1_[j].imag * alm2_[j].imag)
 *                 powspec_[l] /= (2 * l + 1)             # <<<<<<<<<<<<<<
 *             spectra.append(powspec_)
 * 
 */
        __pyx_t_33 = __pyx_v_l;
        __pyx_t_23 = -1;
        if (__pyx_t_33 < 0) {
          __pyx_t_33 += __pyx_pybuffernd_powspec_.diminfo[0].shape;
          if (unlikely(__pyx_t_33 < 0)) __pyx_t_23 = 0;
        } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_powspec_.diminfo[0].shape)) __pyx_t_23 = 0;
        if (unlikely(__pyx_t_23 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_23);
          __PYX_ERR(0, 411, __pyx_L1_error)
        }
        *__Pyx_BufPtrStrided1d(double *, __pyx_pybuffernd_powspec_.rcbuffer->pybuffer.buf, __pyx_t_33, __pyx_pybuffernd_powspec_.diminfo[0].strides) /= ((2 * __pyx_v_l) + 1);
      }

      /* "healpy/src/_sphtools.pyx":412
 *                                         alm1_[j].imag * alm2_[j].imag)
 *                 powspec_[l] /= (2 * l + 1)
 *             spectra.append(powspec_)             # <<<<<<<<<<<<<<
 * 
 *     # if only one alm was given, returns only cl and not a list with one cl
 */
      __pyx_t_34 = __Pyx_PyObject_Append(__pyx_v_spectra, ((PyObject *)__pyx_v_powspec_)); if (unlikely(__pyx_t_34 == -1)) __PYX_ERR(0, 412, __pyx_L1_error)
    }

    /* "healpy/src/_sphtools.pyx":396
 * 
 *     spectra = []
 *     for n in xrange(Nspec): # diagonal rank             # <<<<<<<<<<<<<<
 *         for m in xrange(0, Nspec - n): # position in the diagonal
 *             powspec_ = np.zeros(lmax + 1)
 */
  }
  __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;

  /* "healpy/src/_sphtools.pyx":415
 * 
 *     # if only one alm was given, returns only cl and not a list with one cl
 *     if alms_lonely:             # <<<<<<<<<<<<<<
 *         spectra = spectra[0]
 * 
 */
  __pyx_t_1 = (__pyx_v_alms_lonely != 0);
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":416
 *     # if only one alm was given, returns only cl and not a list with one cl
 *     if alms_lonely:
 *         spectra = spectra[0]             # <<<<<<<<<<<<<<
 * 
 *     return spectra
 */
    __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_spectra, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 416, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF_SET(__pyx_v_spectra, __pyx_t_10);
    __pyx_t_10 = 0;

    /* "healpy/src/_sphtools.pyx":415
 * 
 *     # if only one alm was given, returns only cl and not a list with one cl
 *     if alms_lonely:             # <<<<<<<<<<<<<<
 *         spectra = spectra[0]
 * 
 */
  }

  /* "healpy/src/_sphtools.pyx":418
 *         spectra = spectra[0]
 * 
 *     return spectra             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_spectra);
  __pyx_r = __pyx_v_spectra;
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":311
 * 
 * 
 * def alm2cl(alms, alms2 = None, lmax = None, mmax = None, lmax_out = None):             # <<<<<<<<<<<<<<
 *     """Computes (cross-)spectra from alm(s). If alm2 is given, cross-spectra between
 *     alm and alm2 are computed. If alm (and alm2 if provided) contains n alm,
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_8);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_14);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm1_.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm2_.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_powspec_.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._sphtools.alm2cl", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm1_.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm2_.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_powspec_.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_powspec_);
  __Pyx_XDECREF((PyObject *)__pyx_v_alm1_);
  __Pyx_XDECREF((PyObject *)__pyx_v_alm2_);
  __Pyx_XDECREF(__pyx_v_spectra);
  __Pyx_XDECREF(__pyx_v_n);
  __Pyx_XDECREF(__pyx_v_alms);
  __Pyx_XDECREF(__pyx_v_alms2);
  __Pyx_XDECREF(__pyx_v_lmax);
  __Pyx_XDECREF(__pyx_v_mmax);
  __Pyx_XDECREF(__pyx_v_lmax_out);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":423
 * @cython.wraparound(False)
 * @cython.boundscheck(False)
 * def almxfl(alm, fl, mmax = None, inplace = False):             # <<<<<<<<<<<<<<
 *     """Multiply an a_lm by a vector b_l.
 * 
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_11almxfl(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_10almxfl[] = "almxfl(alm, fl, mmax=None, inplace=False)\nMultiply an a_lm by a vector b_l.\n\n    Parameters\n    ----------\n    alm : array, double\n      The array representing the spherical harmonics coefficients\n    fl : array, double\n      The array giving the factor f_l by which to multiply a_lm\n    mmax : None or int, optional\n      The maximum m of the input alm\n    inplace : bool, optional\n      If True, performs the computation in-place if possible (input alm\n      is modified if it is a 1d-array of type float64). Otherwise,\n      a copy of alm is done.\n\n    Returns\n    -------\n    alm : array, double\n      The result of a_lm * f_l. If *inplace* is True, returns the input\n      alm modified\n    ";
static PyMethodDef __pyx_mdef_6healpy_9_sphtools_11almxfl = {"almxfl", (PyCFunction)__pyx_pw_6healpy_9_sphtools_11almxfl, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_9_sphtools_10almxfl};
static PyObject *__pyx_pw_6healpy_9_sphtools_11almxfl(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alm = 0;
  PyObject *__pyx_v_fl = 0;
  PyObject *__pyx_v_mmax = 0;
  PyObject *__pyx_v_inplace = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("almxfl (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alm,&__pyx_n_s_fl,&__pyx_n_s_mmax,&__pyx_n_s_inplace,0};
    PyObject* values[4] = {0,0,0,0};
    values[2] = ((PyObject *)Py_None);
    values[3] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_alm)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fl)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("almxfl", 0, 2, 4, 1); __PYX_ERR(0, 423, __pyx_L3_error)
        }
        case  2:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mmax);
          if (value) { values[2] = value; kw_args--; }
        }
        case  3:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inplace);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "almxfl") < 0)) __PYX_ERR(0, 423, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_alm = values[0];
    __pyx_v_fl = values[1];
    __pyx_v_mmax = values[2];
    __pyx_v_inplace = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("almxfl", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 423, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._sphtools.almxfl", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_9_sphtools_10almxfl(__pyx_self, __pyx_v_alm, __pyx_v_fl, __pyx_v_mmax, __pyx_v_inplace);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_10almxfl(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_alm, PyObject *__pyx_v_fl, PyObject *__pyx_v_mmax, PyObject *__pyx_v_inplace) {
  PyArrayObject *__pyx_v_alm_ = 0;
  PyArrayObject *__pyx_v_fl_ = 0;
  int __pyx_v_lmax_;
  int __pyx_v_mmax_;
  int __pyx_v_l;
  int __pyx_v_m;
  __pyx_t_double_complex __pyx_v_f;
  int __pyx_v_maxm;
  int __pyx_v_i;
  int __pyx_v_flsize;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_alm_;
  __Pyx_Buffer __pyx_pybuffer_alm_;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_fl_;
  __Pyx_Buffer __pyx_pybuffer_fl_;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyArrayObject *__pyx_t_7 = NULL;
  int __pyx_t_8;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  PyArrayObject *__pyx_t_12 = NULL;
  Py_ssize_t __pyx_t_13;
  PyObject *(*__pyx_t_14)(PyObject *);
  int __pyx_t_15;
  long __pyx_t_16;
  __pyx_t_double_complex __pyx_t_17;
  Py_ssize_t __pyx_t_18;
  long __pyx_t_19;
  Py_ssize_t __pyx_t_20;
  __Pyx_RefNannySetupContext("almxfl", 0);
  __pyx_pybuffer_alm_.pybuffer.buf = NULL;
  __pyx_pybuffer_alm_.refcount = 0;
  __pyx_pybuffernd_alm_.data = NULL;
  __pyx_pybuffernd_alm_.rcbuffer = &__pyx_pybuffer_alm_;
  __pyx_pybuffer_fl_.pybuffer.buf = NULL;
  __pyx_pybuffer_fl_.refcount = 0;
  __pyx_pybuffernd_fl_.data = NULL;
  __pyx_pybuffernd_fl_.rcbuffer = &__pyx_pybuffer_fl_;

  /* "healpy/src/_sphtools.pyx":448
 *     cdef np.ndarray[np.complex128_t, ndim=1] fl_
 * 
 *     if inplace:             # <<<<<<<<<<<<<<
 *         alm_ = np.ascontiguousarray(alm, dtype = np.complex128)
 *     else:
 */
  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_inplace); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 448, __pyx_L1_error)
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":449
 * 
 *     if inplace:
 *         alm_ = np.ascontiguousarray(alm, dtype = np.complex128)             # <<<<<<<<<<<<<<
 *     else:
 *         alm_ = np.array(alm, dtype = np.complex128, copy = True)
 */
    __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_INCREF(__pyx_v_alm);
    __Pyx_GIVEREF(__pyx_v_alm);
    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_alm);
    __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_complex128); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 449, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 449, __pyx_L1_error)
    __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
    {
      __Pyx_BufFmt_StackElem __pyx_stack[1];
      __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm_.rcbuffer->pybuffer);
      __pyx_t_8 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alm_.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack);
      if (unlikely(__pyx_t_8 < 0)) {
        PyErr_Fetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
        if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alm_.rcbuffer->pybuffer, (PyObject*)__pyx_v_alm_, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
          Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11);
          __Pyx_RaiseBufferFallbackError();
        } else {
          PyErr_Restore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
        }
      }
      __pyx_pybuffernd_alm_.diminfo[0].strides = __pyx_pybuffernd_alm_.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_alm_.diminfo[0].shape = __pyx_pybuffernd_alm_.rcbuffer->pybuffer.shape[0];
      if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 449, __pyx_L1_error)
    }
    __pyx_t_7 = 0;
    __pyx_v_alm_ = ((PyArrayObject *)__pyx_t_6);
    __pyx_t_6 = 0;

    /* "healpy/src/_sphtools.pyx":448
 *     cdef np.ndarray[np.complex128_t, ndim=1] fl_
 * 
 *     if inplace:             # <<<<<<<<<<<<<<
 *         alm_ = np.ascontiguousarray(alm, dtype = np.complex128)
 *     else:
 */
    goto __pyx_L3;
  }

  /* "healpy/src/_sphtools.pyx":451
 *         alm_ = np.ascontiguousarray(alm, dtype = np.complex128)
 *     else:
 *         alm_ = np.array(alm, dtype = np.complex128, copy = True)             # <<<<<<<<<<<<<<
 * 
 *     fl_ = np.ascontiguousarray(fl, dtype = np.complex128)
 */
  /*else*/ {
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 451, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 451, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 451, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_v_alm);
    __Pyx_GIVEREF(__pyx_v_alm);
    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_alm);
    __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 451, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 451, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_complex128); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 451, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 451, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_copy, Py_True) < 0) __PYX_ERR(0, 451, __pyx_L1_error)
    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 451, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 451, __pyx_L1_error)
    __pyx_t_7 = ((PyArrayObject *)__pyx_t_5);
    {
      __Pyx_BufFmt_StackElem __pyx_stack[1];
      __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm_.rcbuffer->pybuffer);
      __pyx_t_8 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alm_.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack);
      if (unlikely(__pyx_t_8 < 0)) {
        PyErr_Fetch(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9);
        if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alm_.rcbuffer->pybuffer, (PyObject*)__pyx_v_alm_, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
          Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_9);
          __Pyx_RaiseBufferFallbackError();
        } else {
          PyErr_Restore(__pyx_t_11, __pyx_t_10, __pyx_t_9);
        }
      }
      __pyx_pybuffernd_alm_.diminfo[0].strides = __pyx_pybuffernd_alm_.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_alm_.diminfo[0].shape = __pyx_pybuffernd_alm_.rcbuffer->pybuffer.shape[0];
      if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 451, __pyx_L1_error)
    }
    __pyx_t_7 = 0;
    __pyx_v_alm_ = ((PyArrayObject *)__pyx_t_5);
    __pyx_t_5 = 0;
  }
  __pyx_L3:;

  /* "healpy/src/_sphtools.pyx":453
 *         alm_ = np.array(alm, dtype = np.complex128, copy = True)
 * 
 *     fl_ = np.ascontiguousarray(fl, dtype = np.complex128)             # <<<<<<<<<<<<<<
 * 
 *     cdef int lmax_, mmax_
 */
  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 453, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 453, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 453, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_INCREF(__pyx_v_fl);
  __Pyx_GIVEREF(__pyx_v_fl);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_fl);
  __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 453, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 453, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 453, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 453, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 453, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 453, __pyx_L1_error)
  __pyx_t_12 = ((PyArrayObject *)__pyx_t_3);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_fl_.rcbuffer->pybuffer);
    __pyx_t_8 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_fl_.rcbuffer->pybuffer, (PyObject*)__pyx_t_12, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack);
    if (unlikely(__pyx_t_8 < 0)) {
      PyErr_Fetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_fl_.rcbuffer->pybuffer, (PyObject*)__pyx_v_fl_, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
        Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11);
        __Pyx_RaiseBufferFallbackError();
      } else {
        PyErr_Restore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
      }
    }
    __pyx_pybuffernd_fl_.diminfo[0].strides = __pyx_pybuffernd_fl_.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_fl_.diminfo[0].shape = __pyx_pybuffernd_fl_.rcbuffer->pybuffer.shape[0];
    if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 453, __pyx_L1_error)
  }
  __pyx_t_12 = 0;
  __pyx_v_fl_ = ((PyArrayObject *)__pyx_t_3);
  __pyx_t_3 = 0;

  /* "healpy/src/_sphtools.pyx":457
 *     cdef int lmax_, mmax_
 *     cdef int l, m
 *     lmax_, mmax_ = alm_getlmmax(alm_, None, mmax)             # <<<<<<<<<<<<<<
 * 
 *     cdef np.complex128_t f
 */
  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_alm_getlmmax); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 457, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_5 = NULL;
  __pyx_t_13 = 0;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
    if (likely(__pyx_t_5)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_6, function);
      __pyx_t_13 = 1;
    }
  }
  __pyx_t_2 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 457, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (__pyx_t_5) {
    __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5); __pyx_t_5 = NULL;
  }
  __Pyx_INCREF(((PyObject *)__pyx_v_alm_));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_alm_));
  PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_13, ((PyObject *)__pyx_v_alm_));
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_13, Py_None);
  __Pyx_INCREF(__pyx_v_mmax);
  __Pyx_GIVEREF(__pyx_v_mmax);
  PyTuple_SET_ITEM(__pyx_t_2, 2+__pyx_t_13, __pyx_v_mmax);
  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 457, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
    PyObject* sequence = __pyx_t_3;
    #if CYTHON_COMPILING_IN_CPYTHON
    Py_ssize_t size = Py_SIZE(sequence);
    #else
    Py_ssize_t size = PySequence_Size(sequence);
    #endif
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 457, __pyx_L1_error)
    }
    #if CYTHON_COMPILING_IN_CPYTHON
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); 
    } else {
      __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_2 = PyList_GET_ITEM(sequence, 1); 
    }
    __Pyx_INCREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_t_2);
    #else
    __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 457, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 457, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    #endif
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 457, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_14 = Py_TYPE(__pyx_t_5)->tp_iternext;
    index = 0; __pyx_t_6 = __pyx_t_14(__pyx_t_5); if (unlikely(!__pyx_t_6)) goto __pyx_L4_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_6);
    index = 1; __pyx_t_2 = __pyx_t_14(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L4_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_2);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_5), 2) < 0) __PYX_ERR(0, 457, __pyx_L1_error)
    __pyx_t_14 = NULL;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    goto __pyx_L5_unpacking_done;
    __pyx_L4_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_14 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 457, __pyx_L1_error)
    __pyx_L5_unpacking_done:;
  }
  __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 457, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_15 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_15 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 457, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_lmax_ = __pyx_t_8;
  __pyx_v_mmax_ = __pyx_t_15;

  /* "healpy/src/_sphtools.pyx":461
 *     cdef np.complex128_t f
 *     cdef int maxm, i
 *     cdef int flsize = fl_.size             # <<<<<<<<<<<<<<
 *     for l in xrange(lmax_ + 1):
 *         f = fl_[l] if l < flsize else 0.
 */
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_fl_), __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 461, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_15 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_15 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 461, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_flsize = __pyx_t_15;

  /* "healpy/src/_sphtools.pyx":462
 *     cdef int maxm, i
 *     cdef int flsize = fl_.size
 *     for l in xrange(lmax_ + 1):             # <<<<<<<<<<<<<<
 *         f = fl_[l] if l < flsize else 0.
 *         maxm = l if l <= mmax_ else mmax_
 */
  __pyx_t_16 = (__pyx_v_lmax_ + 1);
  for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_16; __pyx_t_15+=1) {
    __pyx_v_l = __pyx_t_15;

    /* "healpy/src/_sphtools.pyx":463
 *     cdef int flsize = fl_.size
 *     for l in xrange(lmax_ + 1):
 *         f = fl_[l] if l < flsize else 0.             # <<<<<<<<<<<<<<
 *         maxm = l if l <= mmax_ else mmax_
 *         for m in xrange(maxm + 1):
 */
    if (((__pyx_v_l < __pyx_v_flsize) != 0)) {
      __pyx_t_18 = __pyx_v_l;
      __pyx_t_17 = (*__Pyx_BufPtrStrided1d(__pyx_t_double_complex *, __pyx_pybuffernd_fl_.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_fl_.diminfo[0].strides));
    } else {
      __pyx_t_17 = __pyx_t_double_complex_from_parts(0., 0);
    }
    __pyx_v_f = __pyx_t_17;

    /* "healpy/src/_sphtools.pyx":464
 *     for l in xrange(lmax_ + 1):
 *         f = fl_[l] if l < flsize else 0.
 *         maxm = l if l <= mmax_ else mmax_             # <<<<<<<<<<<<<<
 *         for m in xrange(maxm + 1):
 *             i = alm_getidx(lmax_, l, m)
 */
    if (((__pyx_v_l <= __pyx_v_mmax_) != 0)) {
      __pyx_t_8 = __pyx_v_l;
    } else {
      __pyx_t_8 = __pyx_v_mmax_;
    }
    __pyx_v_maxm = __pyx_t_8;

    /* "healpy/src/_sphtools.pyx":465
 *         f = fl_[l] if l < flsize else 0.
 *         maxm = l if l <= mmax_ else mmax_
 *         for m in xrange(maxm + 1):             # <<<<<<<<<<<<<<
 *             i = alm_getidx(lmax_, l, m)
 *             alm_[i] *= f
 */
    __pyx_t_19 = (__pyx_v_maxm + 1);
    for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_19; __pyx_t_8+=1) {
      __pyx_v_m = __pyx_t_8;

      /* "healpy/src/_sphtools.pyx":466
 *         maxm = l if l <= mmax_ else mmax_
 *         for m in xrange(maxm + 1):
 *             i = alm_getidx(lmax_, l, m)             # <<<<<<<<<<<<<<
 *             alm_[i] *= f
 * 
 */
      __pyx_v_i = __pyx_f_6healpy_9_sphtools_alm_getidx(__pyx_v_lmax_, __pyx_v_l, __pyx_v_m);

      /* "healpy/src/_sphtools.pyx":467
 *         for m in xrange(maxm + 1):
 *             i = alm_getidx(lmax_, l, m)
 *             alm_[i] *= f             # <<<<<<<<<<<<<<
 * 
 *     return alm_
 */
      __pyx_t_20 = __pyx_v_i;
      *__Pyx_BufPtrStrided1d(__pyx_t_double_complex *, __pyx_pybuffernd_alm_.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_alm_.diminfo[0].strides) *= __pyx_v_f;
    }
  }

  /* "healpy/src/_sphtools.pyx":469
 *             alm_[i] *= f
 * 
 *     return alm_             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_alm_));
  __pyx_r = ((PyObject *)__pyx_v_alm_);
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":423
 * @cython.wraparound(False)
 * @cython.boundscheck(False)
 * def almxfl(alm, fl, mmax = None, inplace = False):             # <<<<<<<<<<<<<<
 *     """Multiply an a_lm by a vector b_l.
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm_.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_fl_.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._sphtools.almxfl", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alm_.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_fl_.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_alm_);
  __Pyx_XDECREF((PyObject *)__pyx_v_fl_);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":472
 * 
 * 
 * def rotate_alm(alm not None, double psi, double theta, double phi, lmax=None,             # <<<<<<<<<<<<<<
 *                mmax=None):
 *     """
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_13rotate_alm(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_12rotate_alm[] = "rotate_alm(alm, double psi, double theta, double phi, lmax=None, mmax=None)\n\n    This routine transforms the scalar (and tensor) a_lm coefficients\n    to emulate the effect of an arbitrary rotation of the underlying\n    map. The rotation is done directly on the a_lm using the Wigner\n    rotation matrices, computed by recursion. To rotate the a_lm for\n    l \342\211\244 l_max the number of operations scales like l_max^3.\n\n    Parameters\n    ----------\n    alm : array-like of shape (n,) or (k,n), or list of arrays\n        Complex a_lm values before and after rotation of the coordinate system.\n    psi : float\n        First rotation: angle \317\210 about the z-axis. All angles are in radians\n        and should lie in [-2pi,2pi], the rotations are active and the\n        referential system is assumed to be right handed. The routine\n        coordsys2euler zyz can be used to generate the Euler angles \317\210, \316\270, \317\206\n        for rotation between standard astronomical coordinate systems.\n    theta : float\n        Second rotation: angle \316\270 about the original (unrotated) y-axis\n    phi : float.\n        Third rotation: angle \317\206 about the original (unrotated) z-axis.\n    lmax : int\n        Maximum multipole order l of the data set.\n    mmax : int\n        Maximum degree m of data set.\n\n    ";
static PyMethodDef __pyx_mdef_6healpy_9_sphtools_13rotate_alm = {"rotate_alm", (PyCFunction)__pyx_pw_6healpy_9_sphtools_13rotate_alm, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_9_sphtools_12rotate_alm};
static PyObject *__pyx_pw_6healpy_9_sphtools_13rotate_alm(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_alm = 0;
  double __pyx_v_psi;
  double __pyx_v_theta;
  double __pyx_v_phi;
  PyObject *__pyx_v_lmax = 0;
  PyObject *__pyx_v_mmax = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("rotate_alm (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alm,&__pyx_n_s_psi,&__pyx_n_s_theta,&__pyx_n_s_phi,&__pyx_n_s_lmax,&__pyx_n_s_mmax,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[4] = ((PyObject *)Py_None);

    /* "healpy/src/_sphtools.pyx":473
 * 
 * def rotate_alm(alm not None, double psi, double theta, double phi, lmax=None,
 *                mmax=None):             # <<<<<<<<<<<<<<
 *     """
 *     This routine transforms the scalar (and tensor) a_lm coefficients
 */
    values[5] = ((PyObject *)Py_None);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_alm)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_psi)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("rotate_alm", 0, 4, 6, 1); __PYX_ERR(0, 472, __pyx_L3_error)
        }
        case  2:
        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_theta)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("rotate_alm", 0, 4, 6, 2); __PYX_ERR(0, 472, __pyx_L3_error)
        }
        case  3:
        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_phi)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("rotate_alm", 0, 4, 6, 3); __PYX_ERR(0, 472, __pyx_L3_error)
        }
        case  4:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lmax);
          if (value) { values[4] = value; kw_args--; }
        }
        case  5:
        if (kw_args > 0) {
          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mmax);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "rotate_alm") < 0)) __PYX_ERR(0, 472, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_alm = values[0];
    __pyx_v_psi = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_psi == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 472, __pyx_L3_error)
    __pyx_v_theta = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_theta == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 472, __pyx_L3_error)
    __pyx_v_phi = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_phi == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 472, __pyx_L3_error)
    __pyx_v_lmax = values[4];
    __pyx_v_mmax = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("rotate_alm", 0, 4, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 472, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._sphtools.rotate_alm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  if (unlikely(((PyObject *)__pyx_v_alm) == Py_None)) {
    PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "alm"); __PYX_ERR(0, 472, __pyx_L1_error)
  }
  __pyx_r = __pyx_pf_6healpy_9_sphtools_12rotate_alm(__pyx_self, __pyx_v_alm, __pyx_v_psi, __pyx_v_theta, __pyx_v_phi, __pyx_v_lmax, __pyx_v_mmax);

  /* "healpy/src/_sphtools.pyx":472
 * 
 * 
 * def rotate_alm(alm not None, double psi, double theta, double phi, lmax=None,             # <<<<<<<<<<<<<<
 *                mmax=None):
 *     """
 */

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_12rotate_alm(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_alm, double __pyx_v_psi, double __pyx_v_theta, double __pyx_v_phi, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax) {
  PyObject *__pyx_v_a = NULL;
  PyObject *__pyx_v_ai = NULL;
  Alm >  *__pyx_v_AI;
  PyObject *__pyx_v_ag = NULL;
  PyObject *__pyx_v_ac = NULL;
  Alm >  *__pyx_v_AG;
  Alm >  *__pyx_v_AC;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  int __pyx_t_6;
  Py_ssize_t __pyx_t_7;
  PyObject *(*__pyx_t_8)(PyObject *);
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  PyObject *__pyx_t_12 = NULL;
  PyObject *__pyx_t_13 = NULL;
  Py_ssize_t __pyx_t_14;
  PyObject *__pyx_t_15 = NULL;
  PyObject *(*__pyx_t_16)(PyObject *);
  int __pyx_t_17;
  int __pyx_t_18;
  Alm >  *__pyx_t_19;
  __Pyx_RefNannySetupContext("rotate_alm", 0);
  __Pyx_INCREF(__pyx_v_alm);
  __Pyx_INCREF(__pyx_v_lmax);
  __Pyx_INCREF(__pyx_v_mmax);

  /* "healpy/src/_sphtools.pyx":501
 * 
 *     """
 *     if isinstance(alm, np.ndarray) and alm.ndim == 1:             # <<<<<<<<<<<<<<
 *         alm = [alm]
 * 
 */
  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_alm, __pyx_ptype_5numpy_ndarray); 
  __pyx_t_3 = (__pyx_t_2 != 0);
  if (__pyx_t_3) {
  } else {
    __pyx_t_1 = __pyx_t_3;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_alm, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 501, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_t_4, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 501, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 501, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_1 = __pyx_t_3;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":502
 *     """
 *     if isinstance(alm, np.ndarray) and alm.ndim == 1:
 *         alm = [alm]             # <<<<<<<<<<<<<<
 * 
 *     if not isinstance(alm, (list, tuple, np.ndarray)) or len(alm) == 0:
 */
    __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 502, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_INCREF(__pyx_v_alm);
    __Pyx_GIVEREF(__pyx_v_alm);
    PyList_SET_ITEM(__pyx_t_5, 0, __pyx_v_alm);
    __Pyx_DECREF_SET(__pyx_v_alm, __pyx_t_5);
    __pyx_t_5 = 0;

    /* "healpy/src/_sphtools.pyx":501
 * 
 *     """
 *     if isinstance(alm, np.ndarray) and alm.ndim == 1:             # <<<<<<<<<<<<<<
 *         alm = [alm]
 * 
 */
  }

  /* "healpy/src/_sphtools.pyx":504
 *         alm = [alm]
 * 
 *     if not isinstance(alm, (list, tuple, np.ndarray)) or len(alm) == 0:             # <<<<<<<<<<<<<<
 *         raise ValueError('Invalid input.')
 * 
 */
  __pyx_t_2 = PyList_Check(__pyx_v_alm); 
  __pyx_t_6 = (__pyx_t_2 != 0);
  if (!__pyx_t_6) {
  } else {
    __pyx_t_3 = __pyx_t_6;
    goto __pyx_L9_bool_binop_done;
  }
  __pyx_t_6 = PyTuple_Check(__pyx_v_alm); 
  __pyx_t_2 = (__pyx_t_6 != 0);
  if (!__pyx_t_2) {
  } else {
    __pyx_t_3 = __pyx_t_2;
    goto __pyx_L9_bool_binop_done;
  }
  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_alm, __pyx_ptype_5numpy_ndarray); 
  __pyx_t_6 = (__pyx_t_2 != 0);
  __pyx_t_3 = __pyx_t_6;
  __pyx_L9_bool_binop_done:;
  __pyx_t_6 = ((!(__pyx_t_3 != 0)) != 0);
  if (!__pyx_t_6) {
  } else {
    __pyx_t_1 = __pyx_t_6;
    goto __pyx_L7_bool_binop_done;
  }
  __pyx_t_7 = PyObject_Length(__pyx_v_alm); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 504, __pyx_L1_error)
  __pyx_t_6 = ((__pyx_t_7 == 0) != 0);
  __pyx_t_1 = __pyx_t_6;
  __pyx_L7_bool_binop_done:;
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":505
 * 
 *     if not isinstance(alm, (list, tuple, np.ndarray)) or len(alm) == 0:
 *         raise ValueError('Invalid input.')             # <<<<<<<<<<<<<<
 * 
 *     # C++ rotate_alm only handles 1 or 3 maps. The function handling 3 maps
 */
    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 505, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __PYX_ERR(0, 505, __pyx_L1_error)

    /* "healpy/src/_sphtools.pyx":504
 *         alm = [alm]
 * 
 *     if not isinstance(alm, (list, tuple, np.ndarray)) or len(alm) == 0:             # <<<<<<<<<<<<<<
 *         raise ValueError('Invalid input.')
 * 
 */
  }

  /* "healpy/src/_sphtools.pyx":510
 *     # is faster than running 3 times the 1-map function, but gives identical
 *     # results.
 *     if len(alm) not in (1, 3):             # <<<<<<<<<<<<<<
 *         for a in alm:
 *             rotate_alm(a, psi, theta, phi)
 */
  __pyx_t_7 = PyObject_Length(__pyx_v_alm); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 510, __pyx_L1_error)
  __pyx_t_6 = ((__pyx_t_7 != 1) != 0);
  if (__pyx_t_6) {
  } else {
    __pyx_t_1 = __pyx_t_6;
    goto __pyx_L13_bool_binop_done;
  }
  __pyx_t_6 = ((__pyx_t_7 != 3) != 0);
  __pyx_t_1 = __pyx_t_6;
  __pyx_L13_bool_binop_done:;
  __pyx_t_6 = (__pyx_t_1 != 0);
  if (__pyx_t_6) {

    /* "healpy/src/_sphtools.pyx":511
 *     # results.
 *     if len(alm) not in (1, 3):
 *         for a in alm:             # <<<<<<<<<<<<<<
 *             rotate_alm(a, psi, theta, phi)
 *         return
 */
    if (likely(PyList_CheckExact(__pyx_v_alm)) || PyTuple_CheckExact(__pyx_v_alm)) {
      __pyx_t_5 = __pyx_v_alm; __Pyx_INCREF(__pyx_t_5); __pyx_t_7 = 0;
      __pyx_t_8 = NULL;
    } else {
      __pyx_t_7 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_v_alm); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 511, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_5);
      __pyx_t_8 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 511, __pyx_L1_error)
    }
    for (;;) {
      if (likely(!__pyx_t_8)) {
        if (likely(PyList_CheckExact(__pyx_t_5))) {
          if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_5)) break;
          #if CYTHON_COMPILING_IN_CPYTHON
          __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 511, __pyx_L1_error)
          #else
          __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 511, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          #endif
        } else {
          if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
          #if CYTHON_COMPILING_IN_CPYTHON
          __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 511, __pyx_L1_error)
          #else
          __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 511, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          #endif
        }
      } else {
        __pyx_t_4 = __pyx_t_8(__pyx_t_5);
        if (unlikely(!__pyx_t_4)) {
          PyObject* exc_type = PyErr_Occurred();
          if (exc_type) {
            if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
            else __PYX_ERR(0, 511, __pyx_L1_error)
          }
          break;
        }
        __Pyx_GOTREF(__pyx_t_4);
      }
      __Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_4);
      __pyx_t_4 = 0;

      /* "healpy/src/_sphtools.pyx":512
 *     if len(alm) not in (1, 3):
 *         for a in alm:
 *             rotate_alm(a, psi, theta, phi)             # <<<<<<<<<<<<<<
 *         return
 * 
 */
      __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_rotate_alm); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 512, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_9);
      __pyx_t_10 = PyFloat_FromDouble(__pyx_v_psi); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 512, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __pyx_t_11 = PyFloat_FromDouble(__pyx_v_theta); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 512, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      __pyx_t_12 = PyFloat_FromDouble(__pyx_v_phi); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 512, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_12);
      __pyx_t_13 = NULL;
      __pyx_t_14 = 0;
      if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_9))) {
        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_9);
        if (likely(__pyx_t_13)) {
          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
          __Pyx_INCREF(__pyx_t_13);
          __Pyx_INCREF(function);
          __Pyx_DECREF_SET(__pyx_t_9, function);
          __pyx_t_14 = 1;
        }
      }
      __pyx_t_15 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 512, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_15);
      if (__pyx_t_13) {
        __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __pyx_t_13 = NULL;
      }
      __Pyx_INCREF(__pyx_v_a);
      __Pyx_GIVEREF(__pyx_v_a);
      PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_v_a);
      __Pyx_GIVEREF(__pyx_t_10);
      PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_10);
      __Pyx_GIVEREF(__pyx_t_11);
      PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_11);
      __Pyx_GIVEREF(__pyx_t_12);
      PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_t_12);
      __pyx_t_10 = 0;
      __pyx_t_11 = 0;
      __pyx_t_12 = 0;
      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 512, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;

      /* "healpy/src/_sphtools.pyx":511
 *     # results.
 *     if len(alm) not in (1, 3):
 *         for a in alm:             # <<<<<<<<<<<<<<
 *             rotate_alm(a, psi, theta, phi)
 *         return
 */
    }
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;

    /* "healpy/src/_sphtools.pyx":513
 *         for a in alm:
 *             rotate_alm(a, psi, theta, phi)
 *         return             # <<<<<<<<<<<<<<
 * 
 *     lmax, mmax = alm_getlmmax(alm[0], lmax, mmax)
 */
    __Pyx_XDECREF(__pyx_r);
    __pyx_r = Py_None; __Pyx_INCREF(Py_None);
    goto __pyx_L0;

    /* "healpy/src/_sphtools.pyx":510
 *     # is faster than running 3 times the 1-map function, but gives identical
 *     # results.
 *     if len(alm) not in (1, 3):             # <<<<<<<<<<<<<<
 *         for a in alm:
 *             rotate_alm(a, psi, theta, phi)
 */
  }

  /* "healpy/src/_sphtools.pyx":515
 *         return
 * 
 *     lmax, mmax = alm_getlmmax(alm[0], lmax, mmax)             # <<<<<<<<<<<<<<
 *     ai = np.ascontiguousarray(alm[0], dtype=np.complex128)
 *     AI = ndarray2alm(ai, lmax, mmax)
 */
  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_alm_getlmmax); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_alm, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_15 = NULL;
  __pyx_t_7 = 0;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_15)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_15);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
      __pyx_t_7 = 1;
    }
  }
  __pyx_t_12 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  if (__pyx_t_15) {
    __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_15); __pyx_t_15 = NULL;
  }
  __Pyx_GIVEREF(__pyx_t_9);
  PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_7, __pyx_t_9);
  __Pyx_INCREF(__pyx_v_lmax);
  __Pyx_GIVEREF(__pyx_v_lmax);
  PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_7, __pyx_v_lmax);
  __Pyx_INCREF(__pyx_v_mmax);
  __Pyx_GIVEREF(__pyx_v_mmax);
  PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_7, __pyx_v_mmax);
  __pyx_t_9 = 0;
  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_12, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 515, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
    PyObject* sequence = __pyx_t_5;
    #if CYTHON_COMPILING_IN_CPYTHON
    Py_ssize_t size = Py_SIZE(sequence);
    #else
    Py_ssize_t size = PySequence_Size(sequence);
    #endif
    if (unlikely(size != 2)) {
      if (size > 2) __Pyx_RaiseTooManyValuesError(2);
      else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
      __PYX_ERR(0, 515, __pyx_L1_error)
    }
    #if CYTHON_COMPILING_IN_CPYTHON
    if (likely(PyTuple_CheckExact(sequence))) {
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_12 = PyTuple_GET_ITEM(sequence, 1); 
    } else {
      __pyx_t_4 = PyList_GET_ITEM(sequence, 0); 
      __pyx_t_12 = PyList_GET_ITEM(sequence, 1); 
    }
    __Pyx_INCREF(__pyx_t_4);
    __Pyx_INCREF(__pyx_t_12);
    #else
    __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 515, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_12 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 515, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    #endif
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  } else {
    Py_ssize_t index = -1;
    __pyx_t_9 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 515, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __pyx_t_16 = Py_TYPE(__pyx_t_9)->tp_iternext;
    index = 0; __pyx_t_4 = __pyx_t_16(__pyx_t_9); if (unlikely(!__pyx_t_4)) goto __pyx_L17_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_4);
    index = 1; __pyx_t_12 = __pyx_t_16(__pyx_t_9); if (unlikely(!__pyx_t_12)) goto __pyx_L17_unpacking_failed;
    __Pyx_GOTREF(__pyx_t_12);
    if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_9), 2) < 0) __PYX_ERR(0, 515, __pyx_L1_error)
    __pyx_t_16 = NULL;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    goto __pyx_L18_unpacking_done;
    __pyx_L17_unpacking_failed:;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_16 = NULL;
    if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
    __PYX_ERR(0, 515, __pyx_L1_error)
    __pyx_L18_unpacking_done:;
  }
  __Pyx_DECREF_SET(__pyx_v_lmax, __pyx_t_4);
  __pyx_t_4 = 0;
  __Pyx_DECREF_SET(__pyx_v_mmax, __pyx_t_12);
  __pyx_t_12 = 0;

  /* "healpy/src/_sphtools.pyx":516
 * 
 *     lmax, mmax = alm_getlmmax(alm[0], lmax, mmax)
 *     ai = np.ascontiguousarray(alm[0], dtype=np.complex128)             # <<<<<<<<<<<<<<
 *     AI = ndarray2alm(ai, lmax, mmax)
 *     if len(alm) == 1:
 */
  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_alm, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
  __pyx_t_5 = 0;
  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_9);
  __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_complex128); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_15) < 0) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
  __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 516, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_15);
  __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  __pyx_v_ai = __pyx_t_15;
  __pyx_t_15 = 0;

  /* "healpy/src/_sphtools.pyx":517
 *     lmax, mmax = alm_getlmmax(alm[0], lmax, mmax)
 *     ai = np.ascontiguousarray(alm[0], dtype=np.complex128)
 *     AI = ndarray2alm(ai, lmax, mmax)             # <<<<<<<<<<<<<<
 *     if len(alm) == 1:
 *         c_rotate_alm(AI[0], psi, theta, phi)
 */
  if (!(likely(((__pyx_v_ai) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_ai, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 517, __pyx_L1_error)
  __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_v_lmax); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error)
  __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error)
  __pyx_t_19 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_v_ai), __pyx_t_17, __pyx_t_18); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error)
  __pyx_v_AI = __pyx_t_19;

  /* "healpy/src/_sphtools.pyx":518
 *     ai = np.ascontiguousarray(alm[0], dtype=np.complex128)
 *     AI = ndarray2alm(ai, lmax, mmax)
 *     if len(alm) == 1:             # <<<<<<<<<<<<<<
 *         c_rotate_alm(AI[0], psi, theta, phi)
 *         del AI
 */
  __pyx_t_7 = PyObject_Length(__pyx_v_alm); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 518, __pyx_L1_error)
  __pyx_t_6 = ((__pyx_t_7 == 1) != 0);
  if (__pyx_t_6) {

    /* "healpy/src/_sphtools.pyx":519
 *     AI = ndarray2alm(ai, lmax, mmax)
 *     if len(alm) == 1:
 *         c_rotate_alm(AI[0], psi, theta, phi)             # <<<<<<<<<<<<<<
 *         del AI
 *     else:
 */
    rotate_alm((__pyx_v_AI[0]), __pyx_v_psi, __pyx_v_theta, __pyx_v_phi);

    /* "healpy/src/_sphtools.pyx":520
 *     if len(alm) == 1:
 *         c_rotate_alm(AI[0], psi, theta, phi)
 *         del AI             # <<<<<<<<<<<<<<
 *     else:
 *         ag = np.ascontiguousarray(alm[1], dtype=np.complex128)
 */
    delete __pyx_v_AI;

    /* "healpy/src/_sphtools.pyx":518
 *     ai = np.ascontiguousarray(alm[0], dtype=np.complex128)
 *     AI = ndarray2alm(ai, lmax, mmax)
 *     if len(alm) == 1:             # <<<<<<<<<<<<<<
 *         c_rotate_alm(AI[0], psi, theta, phi)
 *         del AI
 */
    goto __pyx_L19;
  }

  /* "healpy/src/_sphtools.pyx":522
 *         del AI
 *     else:
 *         ag = np.ascontiguousarray(alm[1], dtype=np.complex128)             # <<<<<<<<<<<<<<
 *         ac = np.ascontiguousarray(alm[2], dtype=np.complex128)
 *         AG = ndarray2alm(ag, lmax, mmax)
 */
  /*else*/ {
    __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __pyx_t_15 = __Pyx_GetItemInt(__pyx_v_alm, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_15);
    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_15);
    __pyx_t_15 = 0;
    __pyx_t_15 = PyDict_New(); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_complex128); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_dtype, __pyx_t_9) < 0) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 522, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __pyx_v_ag = __pyx_t_9;
    __pyx_t_9 = 0;

    /* "healpy/src/_sphtools.pyx":523
 *     else:
 *         ag = np.ascontiguousarray(alm[1], dtype=np.complex128)
 *         ac = np.ascontiguousarray(alm[2], dtype=np.complex128)             # <<<<<<<<<<<<<<
 *         AG = ndarray2alm(ag, lmax, mmax)
 *         AC = ndarray2alm(ac, lmax, mmax)
 */
    __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_ascontiguousarray); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_15);
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_alm, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_GIVEREF(__pyx_t_9);
    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_9);
    __pyx_t_9 = 0;
    __pyx_t_9 = PyDict_New(); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_9);
    __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_complex128); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_dtype, __pyx_t_12) < 0) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
    __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 523, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_12);
    __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
    __pyx_v_ac = __pyx_t_12;
    __pyx_t_12 = 0;

    /* "healpy/src/_sphtools.pyx":524
 *         ag = np.ascontiguousarray(alm[1], dtype=np.complex128)
 *         ac = np.ascontiguousarray(alm[2], dtype=np.complex128)
 *         AG = ndarray2alm(ag, lmax, mmax)             # <<<<<<<<<<<<<<
 *         AC = ndarray2alm(ac, lmax, mmax)
 *         c_rotate_alm(AI[0], AG[0], AC[0], psi, theta, phi)
 */
    if (!(likely(((__pyx_v_ag) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_ag, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 524, __pyx_L1_error)
    __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_v_lmax); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 524, __pyx_L1_error)
    __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 524, __pyx_L1_error)
    __pyx_t_19 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_v_ag), __pyx_t_18, __pyx_t_17); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 524, __pyx_L1_error)
    __pyx_v_AG = __pyx_t_19;

    /* "healpy/src/_sphtools.pyx":525
 *         ac = np.ascontiguousarray(alm[2], dtype=np.complex128)
 *         AG = ndarray2alm(ag, lmax, mmax)
 *         AC = ndarray2alm(ac, lmax, mmax)             # <<<<<<<<<<<<<<
 *         c_rotate_alm(AI[0], AG[0], AC[0], psi, theta, phi)
 *         del AI, AG, AC
 */
    if (!(likely(((__pyx_v_ac) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_ac, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 525, __pyx_L1_error)
    __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_v_lmax); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 525, __pyx_L1_error)
    __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 525, __pyx_L1_error)
    __pyx_t_19 = __pyx_f_7_common_ndarray2alm(((PyArrayObject *)__pyx_v_ac), __pyx_t_17, __pyx_t_18); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 525, __pyx_L1_error)
    __pyx_v_AC = __pyx_t_19;

    /* "healpy/src/_sphtools.pyx":526
 *         AG = ndarray2alm(ag, lmax, mmax)
 *         AC = ndarray2alm(ac, lmax, mmax)
 *         c_rotate_alm(AI[0], AG[0], AC[0], psi, theta, phi)             # <<<<<<<<<<<<<<
 *         del AI, AG, AC
 * 
 */
    rotate_alm((__pyx_v_AI[0]), (__pyx_v_AG[0]), (__pyx_v_AC[0]), __pyx_v_psi, __pyx_v_theta, __pyx_v_phi);

    /* "healpy/src/_sphtools.pyx":527
 *         AC = ndarray2alm(ac, lmax, mmax)
 *         c_rotate_alm(AI[0], AG[0], AC[0], psi, theta, phi)
 *         del AI, AG, AC             # <<<<<<<<<<<<<<
 * 
 * 
 */
    delete __pyx_v_AI;
    delete __pyx_v_AG;
    delete __pyx_v_AC;
  }
  __pyx_L19:;

  /* "healpy/src/_sphtools.pyx":472
 * 
 * 
 * def rotate_alm(alm not None, double psi, double theta, double phi, lmax=None,             # <<<<<<<<<<<<<<
 *                mmax=None):
 *     """
 */

  /* function exit code */
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_9);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_XDECREF(__pyx_t_13);
  __Pyx_XDECREF(__pyx_t_15);
  __Pyx_AddTraceback("healpy._sphtools.rotate_alm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_a);
  __Pyx_XDECREF(__pyx_v_ai);
  __Pyx_XDECREF(__pyx_v_ag);
  __Pyx_XDECREF(__pyx_v_ac);
  __Pyx_XDECREF(__pyx_v_alm);
  __Pyx_XDECREF(__pyx_v_lmax);
  __Pyx_XDECREF(__pyx_v_mmax);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":530
 * 
 * 
 * cdef int alm_getn(int l, int m):             # <<<<<<<<<<<<<<
 *     if not m <= l:
 *         raise ValueError("mmax must be <= lmax")
 */

static int __pyx_f_6healpy_9_sphtools_alm_getn(int __pyx_v_l, int __pyx_v_m) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  PyObject *__pyx_t_2 = NULL;
  __Pyx_RefNannySetupContext("alm_getn", 0);

  /* "healpy/src/_sphtools.pyx":531
 * 
 * cdef int alm_getn(int l, int m):
 *     if not m <= l:             # <<<<<<<<<<<<<<
 *         raise ValueError("mmax must be <= lmax")
 *     return ((m+1)*(m+2))/2 + (m+1)*(l-m)
 */
  __pyx_t_1 = ((!((__pyx_v_m <= __pyx_v_l) != 0)) != 0);
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":532
 * cdef int alm_getn(int l, int m):
 *     if not m <= l:
 *         raise ValueError("mmax must be <= lmax")             # <<<<<<<<<<<<<<
 *     return ((m+1)*(m+2))/2 + (m+1)*(l-m)
 * 
 */
    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 532, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __PYX_ERR(0, 532, __pyx_L1_error)

    /* "healpy/src/_sphtools.pyx":531
 * 
 * cdef int alm_getn(int l, int m):
 *     if not m <= l:             # <<<<<<<<<<<<<<
 *         raise ValueError("mmax must be <= lmax")
 *     return ((m+1)*(m+2))/2 + (m+1)*(l-m)
 */
  }

  /* "healpy/src/_sphtools.pyx":533
 *     if not m <= l:
 *         raise ValueError("mmax must be <= lmax")
 *     return ((m+1)*(m+2))/2 + (m+1)*(l-m)             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __pyx_r = (__Pyx_div_long(((__pyx_v_m + 1) * (__pyx_v_m + 2)), 2) + ((__pyx_v_m + 1) * (__pyx_v_l - __pyx_v_m)));
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":530
 * 
 * 
 * cdef int alm_getn(int l, int m):             # <<<<<<<<<<<<<<
 *     if not m <= l:
 *         raise ValueError("mmax must be <= lmax")
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_WriteUnraisable("healpy._sphtools.alm_getn", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":536
 * 
 * 
 * def alm_getlmmax(a, lmax, mmax):             # <<<<<<<<<<<<<<
 *     if lmax is None:
 *         if mmax is None:
 */

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_15alm_getlmmax(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_14alm_getlmmax[] = "alm_getlmmax(a, lmax, mmax)";
static PyMethodDef __pyx_mdef_6healpy_9_sphtools_15alm_getlmmax = {"alm_getlmmax", (PyCFunction)__pyx_pw_6healpy_9_sphtools_15alm_getlmmax, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6healpy_9_sphtools_14alm_getlmmax};
static PyObject *__pyx_pw_6healpy_9_sphtools_15alm_getlmmax(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_a = 0;
  PyObject *__pyx_v_lmax = 0;
  PyObject *__pyx_v_mmax = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("alm_getlmmax (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_a,&__pyx_n_s_lmax,&__pyx_n_s_mmax,0};
    PyObject* values[3] = {0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_a)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        case  1:
        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lmax)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("alm_getlmmax", 1, 3, 3, 1); __PYX_ERR(0, 536, __pyx_L3_error)
        }
        case  2:
        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mmax)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("alm_getlmmax", 1, 3, 3, 2); __PYX_ERR(0, 536, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "alm_getlmmax") < 0)) __PYX_ERR(0, 536, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
    }
    __pyx_v_a = values[0];
    __pyx_v_lmax = values[1];
    __pyx_v_mmax = values[2];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("alm_getlmmax", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 536, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("healpy._sphtools.alm_getlmmax", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_6healpy_9_sphtools_14alm_getlmmax(__pyx_self, __pyx_v_a, __pyx_v_lmax, __pyx_v_mmax);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_14alm_getlmmax(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_a, PyObject *__pyx_v_lmax, PyObject *__pyx_v_mmax) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  __Pyx_RefNannySetupContext("alm_getlmmax", 0);
  __Pyx_INCREF(__pyx_v_lmax);
  __Pyx_INCREF(__pyx_v_mmax);

  /* "healpy/src/_sphtools.pyx":537
 * 
 * def alm_getlmmax(a, lmax, mmax):
 *     if lmax is None:             # <<<<<<<<<<<<<<
 *         if mmax is None:
 *             lmax = alm_getlmax(a.size)
 */
  __pyx_t_1 = (__pyx_v_lmax == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_sphtools.pyx":538
 * def alm_getlmmax(a, lmax, mmax):
 *     if lmax is None:
 *         if mmax is None:             # <<<<<<<<<<<<<<
 *             lmax = alm_getlmax(a.size)
 *             mmax = lmax
 */
    __pyx_t_2 = (__pyx_v_mmax == Py_None);
    __pyx_t_1 = (__pyx_t_2 != 0);
    if (__pyx_t_1) {

      /* "healpy/src/_sphtools.pyx":539
 *     if lmax is None:
 *         if mmax is None:
 *             lmax = alm_getlmax(a.size)             # <<<<<<<<<<<<<<
 *             mmax = lmax
 *         else:
 */
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 539, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 539, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_f_6healpy_9_sphtools_alm_getlmax(__pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 539, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_lmax, __pyx_t_3);
      __pyx_t_3 = 0;

      /* "healpy/src/_sphtools.pyx":540
 *         if mmax is None:
 *             lmax = alm_getlmax(a.size)
 *             mmax = lmax             # <<<<<<<<<<<<<<
 *         else:
 *             lmax = alm_getlmax2(a.size, mmax)
 */
      __Pyx_INCREF(__pyx_v_lmax);
      __Pyx_DECREF_SET(__pyx_v_mmax, __pyx_v_lmax);

      /* "healpy/src/_sphtools.pyx":538
 * def alm_getlmmax(a, lmax, mmax):
 *     if lmax is None:
 *         if mmax is None:             # <<<<<<<<<<<<<<
 *             lmax = alm_getlmax(a.size)
 *             mmax = lmax
 */
      goto __pyx_L4;
    }

    /* "healpy/src/_sphtools.pyx":542
 *             mmax = lmax
 *         else:
 *             lmax = alm_getlmax2(a.size, mmax)             # <<<<<<<<<<<<<<
 *     elif mmax is None:
 *         mmax = lmax
 */
    /*else*/ {
      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 542, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_mmax); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 542, __pyx_L1_error)
      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_f_6healpy_9_sphtools_alm_getlmax2(__pyx_t_4, __pyx_t_5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 542, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_DECREF_SET(__pyx_v_lmax, __pyx_t_3);
      __pyx_t_3 = 0;
    }
    __pyx_L4:;

    /* "healpy/src/_sphtools.pyx":537
 * 
 * def alm_getlmmax(a, lmax, mmax):
 *     if lmax is None:             # <<<<<<<<<<<<<<
 *         if mmax is None:
 *             lmax = alm_getlmax(a.size)
 */
    goto __pyx_L3;
  }

  /* "healpy/src/_sphtools.pyx":543
 *         else:
 *             lmax = alm_getlmax2(a.size, mmax)
 *     elif mmax is None:             # <<<<<<<<<<<<<<
 *         mmax = lmax
 *     return lmax, mmax
 */
  __pyx_t_1 = (__pyx_v_mmax == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "healpy/src/_sphtools.pyx":544
 *             lmax = alm_getlmax2(a.size, mmax)
 *     elif mmax is None:
 *         mmax = lmax             # <<<<<<<<<<<<<<
 *     return lmax, mmax
 * 
 */
    __Pyx_INCREF(__pyx_v_lmax);
    __Pyx_DECREF_SET(__pyx_v_mmax, __pyx_v_lmax);

    /* "healpy/src/_sphtools.pyx":543
 *         else:
 *             lmax = alm_getlmax2(a.size, mmax)
 *     elif mmax is None:             # <<<<<<<<<<<<<<
 *         mmax = lmax
 *     return lmax, mmax
 */
  }
  __pyx_L3:;

  /* "healpy/src/_sphtools.pyx":545
 *     elif mmax is None:
 *         mmax = lmax
 *     return lmax, mmax             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 545, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_lmax);
  __Pyx_GIVEREF(__pyx_v_lmax);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_lmax);
  __Pyx_INCREF(__pyx_v_mmax);
  __Pyx_GIVEREF(__pyx_v_mmax);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_mmax);
  __pyx_r = __pyx_t_3;
  __pyx_t_3 = 0;
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":536
 * 
 * 
 * def alm_getlmmax(a, lmax, mmax):             # <<<<<<<<<<<<<<
 *     if lmax is None:
 *         if mmax is None:
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_AddTraceback("healpy._sphtools.alm_getlmmax", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_lmax);
  __Pyx_XDECREF(__pyx_v_mmax);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":549
 * 
 * @cython.cdivision(True)
 * cdef inline int alm_getlmax(int s):             # <<<<<<<<<<<<<<
 *     cdef double x
 *     x=(-3+np.sqrt(1+8*s))/2
 */

static CYTHON_INLINE int __pyx_f_6healpy_9_sphtools_alm_getlmax(int __pyx_v_s) {
  double __pyx_v_x;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  double __pyx_t_6;
  int __pyx_t_7;
  __Pyx_RefNannySetupContext("alm_getlmax", 0);

  /* "healpy/src/_sphtools.pyx":551
 * cdef inline int alm_getlmax(int s):
 *     cdef double x
 *     x=(-3+np.sqrt(1+8*s))/2             # <<<<<<<<<<<<<<
 *     if x != floor(x):
 *         return -1
 */
  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 551, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 551, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_long((1 + (8 * __pyx_v_s))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 551, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  if (!__pyx_t_4) {
    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 551, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_GOTREF(__pyx_t_1);
  } else {
    __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 551, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
    __Pyx_GIVEREF(__pyx_t_2);
    PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
    __pyx_t_2 = 0;
    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 551, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  }
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_AddCObj(__pyx_int_neg_3, __pyx_t_1, -3L, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 551, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_int_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 551, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_6 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 551, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_x = __pyx_t_6;

  /* "healpy/src/_sphtools.pyx":552
 *     cdef double x
 *     x=(-3+np.sqrt(1+8*s))/2
 *     if x != floor(x):             # <<<<<<<<<<<<<<
 *         return -1
 *     else:
 */
  __pyx_t_7 = ((__pyx_v_x != floor(__pyx_v_x)) != 0);
  if (__pyx_t_7) {

    /* "healpy/src/_sphtools.pyx":553
 *     x=(-3+np.sqrt(1+8*s))/2
 *     if x != floor(x):
 *         return -1             # <<<<<<<<<<<<<<
 *     else:
 *         return floor(x)
 */
    __pyx_r = -1;
    goto __pyx_L0;

    /* "healpy/src/_sphtools.pyx":552
 *     cdef double x
 *     x=(-3+np.sqrt(1+8*s))/2
 *     if x != floor(x):             # <<<<<<<<<<<<<<
 *         return -1
 *     else:
 */
  }

  /* "healpy/src/_sphtools.pyx":555
 *         return -1
 *     else:
 *         return floor(x)             # <<<<<<<<<<<<<<
 * 
 * 
 */
  /*else*/ {
    __pyx_r = ((int)floor(__pyx_v_x));
    goto __pyx_L0;
  }

  /* "healpy/src/_sphtools.pyx":549
 * 
 * @cython.cdivision(True)
 * cdef inline int alm_getlmax(int s):             # <<<<<<<<<<<<<<
 *     cdef double x
 *     x=(-3+np.sqrt(1+8*s))/2
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_WriteUnraisable("healpy._sphtools.alm_getlmax", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":559
 * 
 * @cython.cdivision(True)
 * cdef inline int alm_getlmax2(int s, int mmax):             # <<<<<<<<<<<<<<
 *     cdef double x
 *     x = (2 * s + mmax ** 2 - mmax - 2.) / (2 * mmax + 2.)
 */

static CYTHON_INLINE int __pyx_f_6healpy_9_sphtools_alm_getlmax2(int __pyx_v_s, int __pyx_v_mmax) {
  double __pyx_v_x;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("alm_getlmax2", 0);

  /* "healpy/src/_sphtools.pyx":561
 * cdef inline int alm_getlmax2(int s, int mmax):
 *     cdef double x
 *     x = (2 * s + mmax ** 2 - mmax - 2.) / (2 * mmax + 2.)             # <<<<<<<<<<<<<<
 *     if x != floor(x):
 *         return -1
 */
  __pyx_v_x = (((((2 * __pyx_v_s) + __Pyx_pow_long(((long)__pyx_v_mmax), 2)) - __pyx_v_mmax) - 2.) / ((2 * __pyx_v_mmax) + 2.));

  /* "healpy/src/_sphtools.pyx":562
 *     cdef double x
 *     x = (2 * s + mmax ** 2 - mmax - 2.) / (2 * mmax + 2.)
 *     if x != floor(x):             # <<<<<<<<<<<<<<
 *         return -1
 *     else:
 */
  __pyx_t_1 = ((__pyx_v_x != floor(__pyx_v_x)) != 0);
  if (__pyx_t_1) {

    /* "healpy/src/_sphtools.pyx":563
 *     x = (2 * s + mmax ** 2 - mmax - 2.) / (2 * mmax + 2.)
 *     if x != floor(x):
 *         return -1             # <<<<<<<<<<<<<<
 *     else:
 *         return floor(x)
 */
    __pyx_r = -1;
    goto __pyx_L0;

    /* "healpy/src/_sphtools.pyx":562
 *     cdef double x
 *     x = (2 * s + mmax ** 2 - mmax - 2.) / (2 * mmax + 2.)
 *     if x != floor(x):             # <<<<<<<<<<<<<<
 *         return -1
 *     else:
 */
  }

  /* "healpy/src/_sphtools.pyx":565
 *         return -1
 *     else:
 *         return floor(x)             # <<<<<<<<<<<<<<
 * 
 * 
 */
  /*else*/ {
    __pyx_r = ((int)floor(__pyx_v_x));
    goto __pyx_L0;
  }

  /* "healpy/src/_sphtools.pyx":559
 * 
 * @cython.cdivision(True)
 * cdef inline int alm_getlmax2(int s, int mmax):             # <<<<<<<<<<<<<<
 *     cdef double x
 *     x = (2 * s + mmax ** 2 - mmax - 2.) / (2 * mmax + 2.)
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":569
 * 
 * @cython.cdivision(True)
 * cdef inline int alm_getidx(int lmax, int l, int m):             # <<<<<<<<<<<<<<
 *     return m*(2*lmax+1-m)/2+l
 * 
 */

static CYTHON_INLINE int __pyx_f_6healpy_9_sphtools_alm_getidx(int __pyx_v_lmax, int __pyx_v_l, int __pyx_v_m) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("alm_getidx", 0);

  /* "healpy/src/_sphtools.pyx":570
 * @cython.cdivision(True)
 * cdef inline int alm_getidx(int lmax, int l, int m):
 *     return m*(2*lmax+1-m)/2+l             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __pyx_r = (((__pyx_v_m * (((2 * __pyx_v_lmax) + 1) - __pyx_v_m)) / 2) + __pyx_v_l);
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":569
 * 
 * @cython.cdivision(True)
 * cdef inline int alm_getidx(int lmax, int l, int m):             # <<<<<<<<<<<<<<
 *     return m*(2*lmax+1-m)/2+l
 * 
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":575
 * @cython.wraparound(False)
 * @cython.boundscheck(False)
 * cpdef mkmask(np.ndarray[double, ndim=1] m):             # <<<<<<<<<<<<<<
 *     cdef int nbad
 *     cdef int size = m.size
 */

static PyObject *__pyx_pw_6healpy_9_sphtools_17mkmask(PyObject *__pyx_self, PyObject *__pyx_v_m); /*proto*/
static PyObject *__pyx_f_6healpy_9_sphtools_mkmask(PyArrayObject *__pyx_v_m, CYTHON_UNUSED int __pyx_skip_dispatch) {
  int __pyx_v_nbad;
  int __pyx_v_size;
  int __pyx_v_i;
  PyArrayObject *__pyx_v_mask = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_m;
  __Pyx_Buffer __pyx_pybuffer_m;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_mask;
  __Pyx_Buffer __pyx_pybuffer_mask;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  PyObject *__pyx_t_5 = NULL;
  PyObject *__pyx_t_6 = NULL;
  PyObject *__pyx_t_7 = NULL;
  PyArrayObject *__pyx_t_8 = NULL;
  PyObject *__pyx_t_9 = NULL;
  PyObject *__pyx_t_10 = NULL;
  PyObject *__pyx_t_11 = NULL;
  int __pyx_t_12;
  Py_ssize_t __pyx_t_13;
  Py_ssize_t __pyx_t_14;
  __Pyx_RefNannySetupContext("mkmask", 0);
  __pyx_pybuffer_mask.pybuffer.buf = NULL;
  __pyx_pybuffer_mask.refcount = 0;
  __pyx_pybuffernd_mask.data = NULL;
  __pyx_pybuffernd_mask.rcbuffer = &__pyx_pybuffer_mask;
  __pyx_pybuffer_m.pybuffer.buf = NULL;
  __pyx_pybuffer_m.refcount = 0;
  __pyx_pybuffernd_m.data = NULL;
  __pyx_pybuffernd_m.rcbuffer = &__pyx_pybuffer_m;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_m.rcbuffer->pybuffer, (PyObject*)__pyx_v_m, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 575, __pyx_L1_error)
  }
  __pyx_pybuffernd_m.diminfo[0].strides = __pyx_pybuffernd_m.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_m.diminfo[0].shape = __pyx_pybuffernd_m.rcbuffer->pybuffer.shape[0];

  /* "healpy/src/_sphtools.pyx":577
 * cpdef mkmask(np.ndarray[double, ndim=1] m):
 *     cdef int nbad
 *     cdef int size = m.size             # <<<<<<<<<<<<<<
 *     cdef int i
 *     # first, count number of bad pixels, to see if allocating a mask is needed
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_m), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 577, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 577, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_size = __pyx_t_2;

  /* "healpy/src/_sphtools.pyx":580
 *     cdef int i
 *     # first, count number of bad pixels, to see if allocating a mask is needed
 *     nbad = count_bad(m)             # <<<<<<<<<<<<<<
 *     cdef np.ndarray[np.int8_t, ndim=1] mask
 *     #cdef np.ndarray[double, ndim=1] m_
 */
  __pyx_v_nbad = __pyx_f_6healpy_9_sphtools_count_bad(((PyArrayObject *)__pyx_v_m), 0);

  /* "healpy/src/_sphtools.pyx":583
 *     cdef np.ndarray[np.int8_t, ndim=1] mask
 *     #cdef np.ndarray[double, ndim=1] m_
 *     if nbad == 0:             # <<<<<<<<<<<<<<
 *         return False
 *     else:
 */
  __pyx_t_3 = ((__pyx_v_nbad == 0) != 0);
  if (__pyx_t_3) {

    /* "healpy/src/_sphtools.pyx":584
 *     #cdef np.ndarray[double, ndim=1] m_
 *     if nbad == 0:
 *         return False             # <<<<<<<<<<<<<<
 *     else:
 *         mask = np.zeros(size, dtype = np.int8)
 */
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_False);
    __pyx_r = Py_False;
    goto __pyx_L0;

    /* "healpy/src/_sphtools.pyx":583
 *     cdef np.ndarray[np.int8_t, ndim=1] mask
 *     #cdef np.ndarray[double, ndim=1] m_
 *     if nbad == 0:             # <<<<<<<<<<<<<<
 *         return False
 *     else:
 */
  }

  /* "healpy/src/_sphtools.pyx":586
 *         return False
 *     else:
 *         mask = np.zeros(size, dtype = np.int8)             # <<<<<<<<<<<<<<
 *         #m_ = m
 *         for i in range(size):
 */
  /*else*/ {
    __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_5);
    __Pyx_GIVEREF(__pyx_t_1);
    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
    __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 586, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_7);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 586, __pyx_L1_error)
    __pyx_t_8 = ((PyArrayObject *)__pyx_t_7);
    {
      __Pyx_BufFmt_StackElem __pyx_stack[1];
      __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer);
      __pyx_t_2 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mask.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack);
      if (unlikely(__pyx_t_2 < 0)) {
        PyErr_Fetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
        if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mask.rcbuffer->pybuffer, (PyObject*)__pyx_v_mask, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
          Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11);
          __Pyx_RaiseBufferFallbackError();
        } else {
          PyErr_Restore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
        }
      }
      __pyx_pybuffernd_mask.diminfo[0].strides = __pyx_pybuffernd_mask.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mask.diminfo[0].shape = __pyx_pybuffernd_mask.rcbuffer->pybuffer.shape[0];
      if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 586, __pyx_L1_error)
    }
    __pyx_t_8 = 0;
    __pyx_v_mask = ((PyArrayObject *)__pyx_t_7);
    __pyx_t_7 = 0;

    /* "healpy/src/_sphtools.pyx":588
 *         mask = np.zeros(size, dtype = np.int8)
 *         #m_ = m
 *         for i in range(size):             # <<<<<<<<<<<<<<
 *             if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
 *                 mask[i] = 1
 */
    __pyx_t_2 = __pyx_v_size;
    for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_2; __pyx_t_12+=1) {
      __pyx_v_i = __pyx_t_12;

      /* "healpy/src/_sphtools.pyx":589
 *         #m_ = m
 *         for i in range(size):
 *             if fabs(m[i] - UNSEEN) < rtol_UNSEEN:             # <<<<<<<<<<<<<<
 *                 mask[i] = 1
 *     mask.dtype = bool
 */
      __pyx_t_13 = __pyx_v_i;
      __pyx_t_3 = ((fabs(((*__Pyx_BufPtrStrided1d(double *, __pyx_pybuffernd_m.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_m.diminfo[0].strides)) - __pyx_v_6healpy_9_sphtools_UNSEEN)) < __pyx_v_6healpy_9_sphtools_rtol_UNSEEN) != 0);
      if (__pyx_t_3) {

        /* "healpy/src/_sphtools.pyx":590
 *         for i in range(size):
 *             if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
 *                 mask[i] = 1             # <<<<<<<<<<<<<<
 *     mask.dtype = bool
 *     return mask
 */
        __pyx_t_14 = __pyx_v_i;
        *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int8_t *, __pyx_pybuffernd_mask.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_mask.diminfo[0].strides) = 1;

        /* "healpy/src/_sphtools.pyx":589
 *         #m_ = m
 *         for i in range(size):
 *             if fabs(m[i] - UNSEEN) < rtol_UNSEEN:             # <<<<<<<<<<<<<<
 *                 mask[i] = 1
 *     mask.dtype = bool
 */
      }
    }
  }

  /* "healpy/src/_sphtools.pyx":591
 *             if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
 *                 mask[i] = 1
 *     mask.dtype = bool             # <<<<<<<<<<<<<<
 *     return mask
 * 
 */
  if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_mask), __pyx_n_s_dtype, ((PyObject*)&PyBool_Type)) < 0) __PYX_ERR(0, 591, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":592
 *                 mask[i] = 1
 *     mask.dtype = bool
 *     return mask             # <<<<<<<<<<<<<<
 * 
 * @cython.wraparound(False)
 */
  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_mask));
  __pyx_r = ((PyObject *)__pyx_v_mask);
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":575
 * @cython.wraparound(False)
 * @cython.boundscheck(False)
 * cpdef mkmask(np.ndarray[double, ndim=1] m):             # <<<<<<<<<<<<<<
 *     cdef int nbad
 *     cdef int size = m.size
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._sphtools.mkmask", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mask.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_mask);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_17mkmask(PyObject *__pyx_self, PyObject *__pyx_v_m); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_16mkmask[] = "mkmask(ndarray m)";
static PyObject *__pyx_pw_6healpy_9_sphtools_17mkmask(PyObject *__pyx_self, PyObject *__pyx_v_m) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("mkmask (wrapper)", 0);
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_m), __pyx_ptype_5numpy_ndarray, 1, "m", 0))) __PYX_ERR(0, 575, __pyx_L1_error)
  __pyx_r = __pyx_pf_6healpy_9_sphtools_16mkmask(__pyx_self, ((PyArrayObject *)__pyx_v_m));

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_16mkmask(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_m) {
  __Pyx_LocalBuf_ND __pyx_pybuffernd_m;
  __Pyx_Buffer __pyx_pybuffer_m;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("mkmask", 0);
  __pyx_pybuffer_m.pybuffer.buf = NULL;
  __pyx_pybuffer_m.refcount = 0;
  __pyx_pybuffernd_m.data = NULL;
  __pyx_pybuffernd_m.rcbuffer = &__pyx_pybuffer_m;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_m.rcbuffer->pybuffer, (PyObject*)__pyx_v_m, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 575, __pyx_L1_error)
  }
  __pyx_pybuffernd_m.diminfo[0].strides = __pyx_pybuffernd_m.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_m.diminfo[0].shape = __pyx_pybuffernd_m.rcbuffer->pybuffer.shape[0];
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_f_6healpy_9_sphtools_mkmask(__pyx_v_m, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 575, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._sphtools.mkmask", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "healpy/src/_sphtools.pyx":596
 * @cython.wraparound(False)
 * @cython.boundscheck(False)
 * cpdef int count_bad(np.ndarray[double, ndim=1] m):             # <<<<<<<<<<<<<<
 *     cdef int i
 *     cdef int nbad = 0
 */

static PyObject *__pyx_pw_6healpy_9_sphtools_19count_bad(PyObject *__pyx_self, PyObject *__pyx_v_m); /*proto*/
static int __pyx_f_6healpy_9_sphtools_count_bad(PyArrayObject *__pyx_v_m, CYTHON_UNUSED int __pyx_skip_dispatch) {
  int __pyx_v_i;
  int __pyx_v_nbad;
  CYTHON_UNUSED PyObject *__pyx_v_size = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_m;
  __Pyx_Buffer __pyx_pybuffer_m;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  long __pyx_t_2;
  int __pyx_t_3;
  Py_ssize_t __pyx_t_4;
  int __pyx_t_5;
  __Pyx_RefNannySetupContext("count_bad", 0);
  __pyx_pybuffer_m.pybuffer.buf = NULL;
  __pyx_pybuffer_m.refcount = 0;
  __pyx_pybuffernd_m.data = NULL;
  __pyx_pybuffernd_m.rcbuffer = &__pyx_pybuffer_m;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_m.rcbuffer->pybuffer, (PyObject*)__pyx_v_m, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 596, __pyx_L1_error)
  }
  __pyx_pybuffernd_m.diminfo[0].strides = __pyx_pybuffernd_m.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_m.diminfo[0].shape = __pyx_pybuffernd_m.rcbuffer->pybuffer.shape[0];

  /* "healpy/src/_sphtools.pyx":598
 * cpdef int count_bad(np.ndarray[double, ndim=1] m):
 *     cdef int i
 *     cdef int nbad = 0             # <<<<<<<<<<<<<<
 *     cdef size = m.size
 *     for i in xrange(m.size):
 */
  __pyx_v_nbad = 0;

  /* "healpy/src/_sphtools.pyx":599
 *     cdef int i
 *     cdef int nbad = 0
 *     cdef size = m.size             # <<<<<<<<<<<<<<
 *     for i in xrange(m.size):
 *         if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_m), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 599, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_size = __pyx_t_1;
  __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":600
 *     cdef int nbad = 0
 *     cdef size = m.size
 *     for i in xrange(m.size):             # <<<<<<<<<<<<<<
 *         if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
 *             nbad += 1
 */
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_m), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_2 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 600, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_i = __pyx_t_3;

    /* "healpy/src/_sphtools.pyx":601
 *     cdef size = m.size
 *     for i in xrange(m.size):
 *         if fabs(m[i] - UNSEEN) < rtol_UNSEEN:             # <<<<<<<<<<<<<<
 *             nbad += 1
 *     return nbad
 */
    __pyx_t_4 = __pyx_v_i;
    __pyx_t_5 = ((fabs(((*__Pyx_BufPtrStrided1d(double *, __pyx_pybuffernd_m.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_m.diminfo[0].strides)) - __pyx_v_6healpy_9_sphtools_UNSEEN)) < __pyx_v_6healpy_9_sphtools_rtol_UNSEEN) != 0);
    if (__pyx_t_5) {

      /* "healpy/src/_sphtools.pyx":602
 *     for i in xrange(m.size):
 *         if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
 *             nbad += 1             # <<<<<<<<<<<<<<
 *     return nbad
 */
      __pyx_v_nbad = (__pyx_v_nbad + 1);

      /* "healpy/src/_sphtools.pyx":601
 *     cdef size = m.size
 *     for i in xrange(m.size):
 *         if fabs(m[i] - UNSEEN) < rtol_UNSEEN:             # <<<<<<<<<<<<<<
 *             nbad += 1
 *     return nbad
 */
    }
  }

  /* "healpy/src/_sphtools.pyx":603
 *         if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
 *             nbad += 1
 *     return nbad             # <<<<<<<<<<<<<<
 */
  __pyx_r = __pyx_v_nbad;
  goto __pyx_L0;

  /* "healpy/src/_sphtools.pyx":596
 * @cython.wraparound(False)
 * @cython.boundscheck(False)
 * cpdef int count_bad(np.ndarray[double, ndim=1] m):             # <<<<<<<<<<<<<<
 *     cdef int i
 *     cdef int nbad = 0
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_WriteUnraisable("healpy._sphtools.count_bad", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF(__pyx_v_size);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_6healpy_9_sphtools_19count_bad(PyObject *__pyx_self, PyObject *__pyx_v_m); /*proto*/
static char __pyx_doc_6healpy_9_sphtools_18count_bad[] = "count_bad(ndarray m) -> int";
static PyObject *__pyx_pw_6healpy_9_sphtools_19count_bad(PyObject *__pyx_self, PyObject *__pyx_v_m) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("count_bad (wrapper)", 0);
  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_m), __pyx_ptype_5numpy_ndarray, 1, "m", 0))) __PYX_ERR(0, 596, __pyx_L1_error)
  __pyx_r = __pyx_pf_6healpy_9_sphtools_18count_bad(__pyx_self, ((PyArrayObject *)__pyx_v_m));

  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_6healpy_9_sphtools_18count_bad(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_m) {
  __Pyx_LocalBuf_ND __pyx_pybuffernd_m;
  __Pyx_Buffer __pyx_pybuffer_m;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("count_bad", 0);
  __pyx_pybuffer_m.pybuffer.buf = NULL;
  __pyx_pybuffer_m.refcount = 0;
  __pyx_pybuffernd_m.data = NULL;
  __pyx_pybuffernd_m.rcbuffer = &__pyx_pybuffer_m;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_m.rcbuffer->pybuffer, (PyObject*)__pyx_v_m, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 596, __pyx_L1_error)
  }
  __pyx_pybuffernd_m.diminfo[0].strides = __pyx_pybuffernd_m.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_m.diminfo[0].shape = __pyx_pybuffernd_m.rcbuffer->pybuffer.shape[0];
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_f_6healpy_9_sphtools_count_bad(__pyx_v_m, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("healpy._sphtools.count_bad", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_m.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "_common.pxd":124
 *         tsize Num_Alms (int l, int m)
 * 
 * cdef inline Healpix_Map[double]* ndarray2map(np.ndarray[np.float64_t, ndim=1, mode='c'] array, Healpix_Ordering_Scheme scheme) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as a Healpix Map. """
 *     # To ensure that the output map is a view of the input array, the latter
 */

static CYTHON_INLINE Healpix_Map  *__pyx_f_7_common_ndarray2map(PyArrayObject *__pyx_v_array, enum Healpix_Ordering_Scheme __pyx_v_scheme) {
  arr  *__pyx_v_a;
  Healpix_Map  *__pyx_v_map;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_array;
  __Pyx_Buffer __pyx_pybuffer_array;
  Healpix_Map  *__pyx_r;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  __Pyx_RefNannySetupContext("ndarray2map", 0);
  __pyx_pybuffer_array.pybuffer.buf = NULL;
  __pyx_pybuffer_array.refcount = 0;
  __pyx_pybuffernd_array.data = NULL;
  __pyx_pybuffernd_array.rcbuffer = &__pyx_pybuffer_array;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_array.rcbuffer->pybuffer, (PyObject*)__pyx_v_array, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float64_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) __PYX_ERR(1, 124, __pyx_L1_error)
  }
  __pyx_pybuffernd_array.diminfo[0].strides = __pyx_pybuffernd_array.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_array.diminfo[0].shape = __pyx_pybuffernd_array.rcbuffer->pybuffer.shape[0];

  /* "_common.pxd":129
 *     # is forced to be contiguous, of correct type and dimensions (otherwise, an
 *     # exception is raised).
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)             # <<<<<<<<<<<<<<
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)
 */
  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_pybuffernd_array.diminfo[0].shape;
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_pybuffernd_array.diminfo[0].shape)) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(1, 129, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_array), __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 129, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 129, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_a = new arr ((&(*__Pyx_BufPtrCContig1d(__pyx_t_5numpy_float64_t *, __pyx_pybuffernd_array.rcbuffer->pybuffer.buf, __pyx_t_1, __pyx_pybuffernd_array.diminfo[0].strides))), __pyx_t_4);

  /* "_common.pxd":130
 *     # exception is raised).
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()             # <<<<<<<<<<<<<<
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated
 */
  __pyx_v_map = new Healpix_Map ();

  /* "_common.pxd":131
 *     cdef arr[double] *a = new arr[double](&array[0], array.size)
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)             # <<<<<<<<<<<<<<
 *     del a # a does not own its buffer, so it won't be deallocated
 *     return map
 */
  __pyx_v_map->Set((__pyx_v_a[0]), __pyx_v_scheme);

  /* "_common.pxd":132
 *     cdef Healpix_Map[double] *map = new Healpix_Map[double]()
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated             # <<<<<<<<<<<<<<
 *     return map
 * 
 */
  delete __pyx_v_a;

  /* "_common.pxd":133
 *     map.Set(a[0], scheme)
 *     del a # a does not own its buffer, so it won't be deallocated
 *     return map             # <<<<<<<<<<<<<<
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:
 */
  __pyx_r = __pyx_v_map;
  goto __pyx_L0;

  /* "_common.pxd":124
 *         tsize Num_Alms (int l, int m)
 * 
 * cdef inline Healpix_Map[double]* ndarray2map(np.ndarray[np.float64_t, ndim=1, mode='c'] array, Healpix_Ordering_Scheme scheme) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as a Healpix Map. """
 *     # To ensure that the output map is a view of the input array, the latter
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("_common.ndarray2map", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "_common.pxd":135
 *     return map
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 */

static CYTHON_INLINE Alm >  *__pyx_f_7_common_ndarray2alm(PyArrayObject *__pyx_v_array, int __pyx_v_lmax, int __pyx_v_mmax) {
  arr >  *__pyx_v_a;
  Alm >  *__pyx_v_alm;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_array;
  __Pyx_Buffer __pyx_pybuffer_array;
  Alm >  *__pyx_r;
  __Pyx_RefNannyDeclarations
  Py_ssize_t __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  size_t __pyx_t_4;
  __Pyx_RefNannySetupContext("ndarray2alm", 0);
  __pyx_pybuffer_array.pybuffer.buf = NULL;
  __pyx_pybuffer_array.refcount = 0;
  __pyx_pybuffernd_array.data = NULL;
  __pyx_pybuffernd_array.rcbuffer = &__pyx_pybuffer_array;
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_array.rcbuffer->pybuffer, (PyObject*)__pyx_v_array, &__Pyx_TypeInfo___pyx_t_double_complex, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) __PYX_ERR(1, 135, __pyx_L1_error)
  }
  __pyx_pybuffernd_array.diminfo[0].strides = __pyx_pybuffernd_array.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_array.diminfo[0].shape = __pyx_pybuffernd_array.rcbuffer->pybuffer.shape[0];

  /* "_common.pxd":137
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)             # <<<<<<<<<<<<<<
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)
 */
  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_pybuffernd_array.diminfo[0].shape;
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_pybuffernd_array.diminfo[0].shape)) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(1, 137, __pyx_L1_error)
  }
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_array), __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 137, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 137, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_a = new arr > (((xcomplex  *)(&(*__Pyx_BufPtrCContig1d(__pyx_t_double_complex *, __pyx_pybuffernd_array.rcbuffer->pybuffer.buf, __pyx_t_1, __pyx_pybuffernd_array.diminfo[0].strides)))), __pyx_t_4);

  /* "_common.pxd":138
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()             # <<<<<<<<<<<<<<
 *     alm.Set(a[0], lmax, mmax)
 *     del a
 */
  __pyx_v_alm = new Alm > ();

  /* "_common.pxd":139
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)             # <<<<<<<<<<<<<<
 *     del a
 *     return alm
 */
  __pyx_v_alm->Set((__pyx_v_a[0]), __pyx_v_lmax, __pyx_v_mmax);

  /* "_common.pxd":140
 *     cdef Alm[xcomplex[double]] *alm = new Alm[xcomplex[double]]()
 *     alm.Set(a[0], lmax, mmax)
 *     del a             # <<<<<<<<<<<<<<
 *     return alm
 */
  delete __pyx_v_a;

  /* "_common.pxd":141
 *     alm.Set(a[0], lmax, mmax)
 *     del a
 *     return alm             # <<<<<<<<<<<<<<
 */
  __pyx_r = __pyx_v_alm;
  goto __pyx_L0;

  /* "_common.pxd":135
 *     return map
 * 
 * cdef inline Alm[xcomplex[double]]* ndarray2alm(np.ndarray[np.complex128_t, ndim=1, mode='c'] array, int lmax, int mmax) except *:             # <<<<<<<<<<<<<<
 *     """ View a contiguous ndarray as an Alm. """
 *     cdef arr[xcomplex[double]] *a = new arr[xcomplex[double]](&array[0], array.size)
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("_common.ndarray2alm", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_array.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":197
 *         # experimental exception made for __getbuffer__ and __releasebuffer__
 *         # -- the details of this may change.
 *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
 *             # This implementation of getbuffer is geared towards Cython
 *             # requirements, and does not yet fullfill the PEP.
 */

/* Python wrapper */
static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
  int __pyx_v_copy_shape;
  int __pyx_v_i;
  int __pyx_v_ndim;
  int __pyx_v_endian_detector;
  int __pyx_v_little_endian;
  int __pyx_v_t;
  char *__pyx_v_f;
  PyArray_Descr *__pyx_v_descr = 0;
  int __pyx_v_offset;
  int __pyx_v_hasfields;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  int __pyx_t_4;
  int __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  char *__pyx_t_7;
  __Pyx_RefNannySetupContext("__getbuffer__", 0);
  if (__pyx_v_info != NULL) {
    __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(__pyx_v_info->obj);
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":203
 *             # of flags
 * 
 *             if info == NULL: return             # <<<<<<<<<<<<<<
 * 
 *             cdef int copy_shape, i, ndim
 */
  __pyx_t_1 = ((__pyx_v_info == NULL) != 0);
  if (__pyx_t_1) {
    __pyx_r = 0;
    goto __pyx_L0;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":206
 * 
 *             cdef int copy_shape, i, ndim
 *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)
 * 
 */
  __pyx_v_endian_detector = 1;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":207
 *             cdef int copy_shape, i, ndim
 *             cdef int endian_detector = 1
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
 * 
 *             ndim = PyArray_NDIM(self)
 */
  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":209
 *             cdef bint little_endian = ((&endian_detector)[0] != 0)
 * 
 *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":211
 *             ndim = PyArray_NDIM(self)
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 copy_shape = 1
 *             else:
 */
  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":212
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 copy_shape = 1             # <<<<<<<<<<<<<<
 *             else:
 *                 copy_shape = 0
 */
    __pyx_v_copy_shape = 1;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":211
 *             ndim = PyArray_NDIM(self)
 * 
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 copy_shape = 1
 *             else:
 */
    goto __pyx_L4;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":214
 *                 copy_shape = 1
 *             else:
 *                 copy_shape = 0             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 */
  /*else*/ {
    __pyx_v_copy_shape = 0;
  }
  __pyx_L4:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L6_bool_binop_done;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":217
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 */
  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L6_bool_binop_done:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":218
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 218, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(2, 218, __pyx_L1_error)

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":216
 *                 copy_shape = 0
 * 
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L9_bool_binop_done;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":221
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 * 
 */
  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L9_bool_binop_done:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":222
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
 * 
 *             info.buf = PyArray_DATA(self)
 */
    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 222, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __PYX_ERR(2, 222, __pyx_L1_error)

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":220
 *                 raise ValueError(u"ndarray is not C contiguous")
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":224
 *                 raise ValueError(u"ndarray is not Fortran contiguous")
 * 
 *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
 *             info.ndim = ndim
 *             if copy_shape:
 */
  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":225
 * 
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim             # <<<<<<<<<<<<<<
 *             if copy_shape:
 *                 # Allocate new buffer for strides and shape info.
 */
  __pyx_v_info->ndim = __pyx_v_ndim;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":226
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim
 *             if copy_shape:             # <<<<<<<<<<<<<<
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 */
  __pyx_t_1 = (__pyx_v_copy_shape != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":229
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)             # <<<<<<<<<<<<<<
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):
 */
    __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2)));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":230
 *                 # This is allocated as one block, strides first.
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)
 *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 */
    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":231
 *                 info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2)
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):             # <<<<<<<<<<<<<<
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 */
    __pyx_t_4 = __pyx_v_ndim;
    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
      __pyx_v_i = __pyx_t_5;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":232
 *                 info.shape = info.strides + ndim
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 *             else:
 */
      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":233
 *                 for i in range(ndim):
 *                     info.strides[i] = PyArray_STRIDES(self)[i]
 *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
 *             else:
 *                 info.strides = PyArray_STRIDES(self)
 */
      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":226
 *             info.buf = PyArray_DATA(self)
 *             info.ndim = ndim
 *             if copy_shape:             # <<<<<<<<<<<<<<
 *                 # Allocate new buffer for strides and shape info.
 *                 # This is allocated as one block, strides first.
 */
    goto __pyx_L11;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":235
 *                     info.shape[i] = PyArray_DIMS(self)[i]
 *             else:
 *                 info.strides = PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL
 */
  /*else*/ {
    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":236
 *             else:
 *                 info.strides = PyArray_STRIDES(self)
 *                 info.shape = PyArray_DIMS(self)             # <<<<<<<<<<<<<<
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)
 */
    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
  }
  __pyx_L11:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":237
 *                 info.strides = PyArray_STRIDES(self)
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
 *             info.itemsize = PyArray_ITEMSIZE(self)
 *             info.readonly = not PyArray_ISWRITEABLE(self)
 */
  __pyx_v_info->suboffsets = NULL;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":238
 *                 info.shape = PyArray_DIMS(self)
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
 *             info.readonly = not PyArray_ISWRITEABLE(self)
 * 
 */
  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":239
 *             info.suboffsets = NULL
 *             info.itemsize = PyArray_ITEMSIZE(self)
 *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
 * 
 *             cdef int t
 */
  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":242
 * 
 *             cdef int t
 *             cdef char* f = NULL             # <<<<<<<<<<<<<<
 *             cdef dtype descr = self.descr
 *             cdef int offset
 */
  __pyx_v_f = NULL;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":243
 *             cdef int t
 *             cdef char* f = NULL
 *             cdef dtype descr = self.descr             # <<<<<<<<<<<<<<
 *             cdef int offset
 * 
 */
  __pyx_t_3 = ((PyObject *)__pyx_v_self->descr);
  __Pyx_INCREF(__pyx_t_3);
  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
  __pyx_t_3 = 0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":246
 *             cdef int offset
 * 
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)             # <<<<<<<<<<<<<<
 * 
 *             if not hasfields and not copy_shape:
 */
  __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":248
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
 * 
 *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
 *                 # do not call releasebuffer
 *                 info.obj = None
 */
  __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0);
  if (__pyx_t_2) {
  } else {
    __pyx_t_1 = __pyx_t_2;
    goto __pyx_L15_bool_binop_done;
  }
  __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0);
  __pyx_t_1 = __pyx_t_2;
  __pyx_L15_bool_binop_done:;
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":250
 *             if not hasfields and not copy_shape:
 *                 # do not call releasebuffer
 *                 info.obj = None             # <<<<<<<<<<<<<<
 *             else:
 *                 # need to call releasebuffer
 */
    __Pyx_INCREF(Py_None);
    __Pyx_GIVEREF(Py_None);
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj);
    __pyx_v_info->obj = Py_None;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":248
 *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
 * 
 *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
 *                 # do not call releasebuffer
 *                 info.obj = None
 */
    goto __pyx_L14;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":253
 *             else:
 *                 # need to call releasebuffer
 *                 info.obj = self             # <<<<<<<<<<<<<<
 * 
 *             if not hasfields:
 */
  /*else*/ {
    __Pyx_INCREF(((PyObject *)__pyx_v_self));
    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj);
    __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
  }
  __pyx_L14:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":255
 *                 info.obj = self
 * 
 *             if not hasfields:             # <<<<<<<<<<<<<<
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 */
  __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":256
 * 
 *             if not hasfields:
 *                 t = descr.type_num             # <<<<<<<<<<<<<<
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 */
    __pyx_t_4 = __pyx_v_descr->type_num;
    __pyx_v_t = __pyx_t_4;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
    if (!__pyx_t_2) {
      goto __pyx_L20_next_or;
    } else {
    }
    __pyx_t_2 = (__pyx_v_little_endian != 0);
    if (!__pyx_t_2) {
    } else {
      __pyx_t_1 = __pyx_t_2;
      goto __pyx_L19_bool_binop_done;
    }
    __pyx_L20_next_or:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":258
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"
 */
    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
    if (__pyx_t_2) {
    } else {
      __pyx_t_1 = __pyx_t_2;
      goto __pyx_L19_bool_binop_done;
    }
    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
    __pyx_t_1 = __pyx_t_2;
    __pyx_L19_bool_binop_done:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    if (__pyx_t_1) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":259
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 259, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(2, 259, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":257
 *             if not hasfields:
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":260
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"
 */
    switch (__pyx_v_t) {
      case NPY_BYTE:
      __pyx_v_f = ((char *)"b");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":261
 *                     raise ValueError(u"Non-native byte order not supported")
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"
 */
      case NPY_UBYTE:
      __pyx_v_f = ((char *)"B");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":262
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"
 */
      case NPY_SHORT:
      __pyx_v_f = ((char *)"h");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":263
 *                 elif t == NPY_UBYTE:       f = "B"
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"
 */
      case NPY_USHORT:
      __pyx_v_f = ((char *)"H");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":264
 *                 elif t == NPY_SHORT:       f = "h"
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"
 */
      case NPY_INT:
      __pyx_v_f = ((char *)"i");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":265
 *                 elif t == NPY_USHORT:      f = "H"
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"
 */
      case NPY_UINT:
      __pyx_v_f = ((char *)"I");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":266
 *                 elif t == NPY_INT:         f = "i"
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"
 */
      case NPY_LONG:
      __pyx_v_f = ((char *)"l");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":267
 *                 elif t == NPY_UINT:        f = "I"
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 */
      case NPY_ULONG:
      __pyx_v_f = ((char *)"L");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":268
 *                 elif t == NPY_LONG:        f = "l"
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"
 */
      case NPY_LONGLONG:
      __pyx_v_f = ((char *)"q");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":269
 *                 elif t == NPY_ULONG:       f = "L"
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"
 */
      case NPY_ULONGLONG:
      __pyx_v_f = ((char *)"Q");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":270
 *                 elif t == NPY_LONGLONG:    f = "q"
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 */
      case NPY_FLOAT:
      __pyx_v_f = ((char *)"f");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":271
 *                 elif t == NPY_ULONGLONG:   f = "Q"
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 */
      case NPY_DOUBLE:
      __pyx_v_f = ((char *)"d");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":272
 *                 elif t == NPY_FLOAT:       f = "f"
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 */
      case NPY_LONGDOUBLE:
      __pyx_v_f = ((char *)"g");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":273
 *                 elif t == NPY_DOUBLE:      f = "d"
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 */
      case NPY_CFLOAT:
      __pyx_v_f = ((char *)"Zf");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":274
 *                 elif t == NPY_LONGDOUBLE:  f = "g"
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 *                 elif t == NPY_OBJECT:      f = "O"
 */
      case NPY_CDOUBLE:
      __pyx_v_f = ((char *)"Zd");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":275
 *                 elif t == NPY_CFLOAT:      f = "Zf"
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
 *                 elif t == NPY_OBJECT:      f = "O"
 *                 else:
 */
      case NPY_CLONGDOUBLE:
      __pyx_v_f = ((char *)"Zg");
      break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":276
 *                 elif t == NPY_CDOUBLE:     f = "Zd"
 *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
 *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 */
      case NPY_OBJECT:
      __pyx_v_f = ((char *)"O");
      break;
      default:

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":278
 *                 elif t == NPY_OBJECT:      f = "O"
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
 *                 info.format = f
 *                 return
 */
      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_GIVEREF(__pyx_t_6);
      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
      __pyx_t_6 = 0;
      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 278, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_6);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
      __PYX_ERR(2, 278, __pyx_L1_error)
      break;
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":279
 *                 else:
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *                 info.format = f             # <<<<<<<<<<<<<<
 *                 return
 *             else:
 */
    __pyx_v_info->format = __pyx_v_f;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":280
 *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *                 info.format = f
 *                 return             # <<<<<<<<<<<<<<
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 */
    __pyx_r = 0;
    goto __pyx_L0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":255
 *                 info.obj = self
 * 
 *             if not hasfields:             # <<<<<<<<<<<<<<
 *                 t = descr.type_num
 *                 if ((descr.byteorder == c'>' and little_endian) or
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":282
 *                 return
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0
 */
  /*else*/ {
    __pyx_v_info->format = ((char *)malloc(0xFF));

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":283
 *             else:
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
 *                 offset = 0
 *                 f = _util_dtypestring(descr, info.format + 1,
 */
    (__pyx_v_info->format[0]) = '^';

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":284
 *                 info.format = stdlib.malloc(_buffer_format_string_len)
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0             # <<<<<<<<<<<<<<
 *                 f = _util_dtypestring(descr, info.format + 1,
 *                                       info.format + _buffer_format_string_len,
 */
    __pyx_v_offset = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":285
 *                 info.format[0] = c'^' # Native data types, manual alignment
 *                 offset = 0
 *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
 *                                       info.format + _buffer_format_string_len,
 *                                       &offset)
 */
    __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(2, 285, __pyx_L1_error)
    __pyx_v_f = __pyx_t_7;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":288
 *                                       info.format + _buffer_format_string_len,
 *                                       &offset)
 *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 */
    (__pyx_v_f[0]) = '\x00';
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":197
 *         # experimental exception made for __getbuffer__ and __releasebuffer__
 *         # -- the details of this may change.
 *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
 *             # This implementation of getbuffer is geared towards Cython
 *             # requirements, and does not yet fullfill the PEP.
 */

  /* function exit code */
  __pyx_r = 0;
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = -1;
  if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) {
    __Pyx_GOTREF(__pyx_v_info->obj);
    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL;
  }
  goto __pyx_L2;
  __pyx_L0:;
  if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) {
    __Pyx_GOTREF(Py_None);
    __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL;
  }
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":290
 *                 f[0] = c'\0' # Terminate format string
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 */

/* Python wrapper */
static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("__releasebuffer__", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":291
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":292
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)             # <<<<<<<<<<<<<<
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 stdlib.free(info.strides)
 */
    free(__pyx_v_info->format);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":291
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):
 *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":293
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.strides)
 *                 # info.shape was stored after info.strides in the same block
 */
  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":294
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
 *                 stdlib.free(info.strides)             # <<<<<<<<<<<<<<
 *                 # info.shape was stored after info.strides in the same block
 * 
 */
    free(__pyx_v_info->strides);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":293
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
 *                 stdlib.free(info.strides)
 *                 # info.shape was stored after info.strides in the same block
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":290
 *                 f[0] = c'\0' # Terminate format string
 * 
 *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
 *             if PyArray_HASFIELDS(self):
 *                 stdlib.free(info.format)
 */

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":770
 * ctypedef npy_cdouble     complex_t
 * 
 * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(1, a)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":771
 * 
 * cdef inline object PyArray_MultiIterNew1(a):
 *     return PyArray_MultiIterNew(1, a)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 771, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":770
 * ctypedef npy_cdouble     complex_t
 * 
 * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(1, a)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":773
 *     return PyArray_MultiIterNew(1, a)
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":774
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):
 *     return PyArray_MultiIterNew(2, a, b)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 774, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":773
 *     return PyArray_MultiIterNew(1, a)
 * 
 * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":776
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":777
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):
 *     return PyArray_MultiIterNew(3, a, b,  c)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 777, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":776
 *     return PyArray_MultiIterNew(2, a, b)
 * 
 * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":779
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":780
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
 *     return PyArray_MultiIterNew(4, a, b, c,  d)             # <<<<<<<<<<<<<<
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 780, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":779
 *     return PyArray_MultiIterNew(3, a, b,  c)
 * 
 * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":782
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":783
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)             # <<<<<<<<<<<<<<
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 783, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":782
 *     return PyArray_MultiIterNew(4, a, b, c,  d)
 * 
 * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":785
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
 *     # Recursive utility function used in __getbuffer__ to get format
 *     # string. The new location in the format string is returned.
 */

static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
  PyArray_Descr *__pyx_v_child = 0;
  int __pyx_v_endian_detector;
  int __pyx_v_little_endian;
  PyObject *__pyx_v_fields = 0;
  PyObject *__pyx_v_childname = NULL;
  PyObject *__pyx_v_new_offset = NULL;
  PyObject *__pyx_v_t = NULL;
  char *__pyx_r;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  Py_ssize_t __pyx_t_2;
  PyObject *__pyx_t_3 = NULL;
  PyObject *__pyx_t_4 = NULL;
  int __pyx_t_5;
  int __pyx_t_6;
  int __pyx_t_7;
  long __pyx_t_8;
  char *__pyx_t_9;
  __Pyx_RefNannySetupContext("_util_dtypestring", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":790
 * 
 *     cdef dtype child
 *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
 *     cdef bint little_endian = ((&endian_detector)[0] != 0)
 *     cdef tuple fields
 */
  __pyx_v_endian_detector = 1;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":791
 *     cdef dtype child
 *     cdef int endian_detector = 1
 *     cdef bint little_endian = ((&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
 *     cdef tuple fields
 * 
 */
  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":794
 *     cdef tuple fields
 * 
 *     for childname in descr.names:             # <<<<<<<<<<<<<<
 *         fields = descr.fields[childname]
 *         child, new_offset = fields
 */
  if (unlikely(__pyx_v_descr->names == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(2, 794, __pyx_L1_error)
  }
  __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
  for (;;) {
    if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
    #if CYTHON_COMPILING_IN_CPYTHON
    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 794, __pyx_L1_error)
    #else
    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 794, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    #endif
    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
    __pyx_t_3 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":795
 * 
 *     for childname in descr.names:
 *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
 *         child, new_offset = fields
 * 
 */
    if (unlikely(__pyx_v_descr->fields == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(2, 795, __pyx_L1_error)
    }
    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 795, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(2, 795, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
    __pyx_t_3 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":796
 *     for childname in descr.names:
 *         fields = descr.fields[childname]
 *         child, new_offset = fields             # <<<<<<<<<<<<<<
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 */
    if (likely(__pyx_v_fields != Py_None)) {
      PyObject* sequence = __pyx_v_fields;
      #if CYTHON_COMPILING_IN_CPYTHON
      Py_ssize_t size = Py_SIZE(sequence);
      #else
      Py_ssize_t size = PySequence_Size(sequence);
      #endif
      if (unlikely(size != 2)) {
        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
        __PYX_ERR(2, 796, __pyx_L1_error)
      }
      #if CYTHON_COMPILING_IN_CPYTHON
      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      #else
      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 796, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 796, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      #endif
    } else {
      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 796, __pyx_L1_error)
    }
    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(2, 796, __pyx_L1_error)
    __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
    __pyx_t_3 = 0;
    __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
    __pyx_t_4 = 0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":798
 *         child, new_offset = fields
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 */
    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 798, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 798, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":799
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 799, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(2, 799, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":798
 *         child, new_offset = fields
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
    if (!__pyx_t_7) {
      goto __pyx_L8_next_or;
    } else {
    }
    __pyx_t_7 = (__pyx_v_little_endian != 0);
    if (!__pyx_t_7) {
    } else {
      __pyx_t_6 = __pyx_t_7;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_L8_next_or:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":802
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
 *             raise ValueError(u"Non-native byte order not supported")
 *             # One could encode it in the format string and have Cython
 */
    __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
    if (__pyx_t_7) {
    } else {
      __pyx_t_6 = __pyx_t_7;
      goto __pyx_L7_bool_binop_done;
    }
    __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
    __pyx_t_6 = __pyx_t_7;
    __pyx_L7_bool_binop_done:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":803
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *             # One could encode it in the format string and have Cython
 *             # complain instead, BUT: < and > in format strings also imply
 */
      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 803, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __PYX_ERR(2, 803, __pyx_L1_error)

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":801
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
 * 
 *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")
 */
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":813
 * 
 *         # Output padding bytes
 *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
 *             f[0] = 120 # "x"; pad byte
 *             f += 1
 */
    while (1) {
      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 813, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 813, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 813, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (!__pyx_t_6) break;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":814
 *         # Output padding bytes
 *         while offset[0] < new_offset:
 *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
 *             f += 1
 *             offset[0] += 1
 */
      (__pyx_v_f[0]) = 0x78;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":815
 *         while offset[0] < new_offset:
 *             f[0] = 120 # "x"; pad byte
 *             f += 1             # <<<<<<<<<<<<<<
 *             offset[0] += 1
 * 
 */
      __pyx_v_f = (__pyx_v_f + 1);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":816
 *             f[0] = 120 # "x"; pad byte
 *             f += 1
 *             offset[0] += 1             # <<<<<<<<<<<<<<
 * 
 *         offset[0] += child.itemsize
 */
      __pyx_t_8 = 0;
      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":818
 *             offset[0] += 1
 * 
 *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
 * 
 *         if not PyDataType_HASFIELDS(child):
 */
    __pyx_t_8 = 0;
    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":820
 *         offset[0] += child.itemsize
 * 
 *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
 *             t = child.type_num
 *             if end - f < 5:
 */
    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
    if (__pyx_t_6) {

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":821
 * 
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num             # <<<<<<<<<<<<<<
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")
 */
      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 821, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
      __pyx_t_4 = 0;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":822
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num
 *             if end - f < 5:             # <<<<<<<<<<<<<<
 *                 raise RuntimeError(u"Format string allocated too short.")
 * 
 */
      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
      if (__pyx_t_6) {

        /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":823
 *             t = child.type_num
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 */
        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 823, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __PYX_ERR(2, 823, __pyx_L1_error)

        /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":822
 *         if not PyDataType_HASFIELDS(child):
 *             t = child.type_num
 *             if end - f < 5:             # <<<<<<<<<<<<<<
 *                 raise RuntimeError(u"Format string allocated too short.")
 * 
 */
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":826
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 826, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 826, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 826, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 98;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":827
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 827, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 827, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 827, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 66;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":828
 *             if   t == NPY_BYTE:        f[0] =  98 #"b"
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 828, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 828, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 828, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x68;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":829
 *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 829, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 829, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 829, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 72;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":830
 *             elif t == NPY_SHORT:       f[0] = 104 #"h"
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 830, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 830, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 830, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x69;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":831
 *             elif t == NPY_USHORT:      f[0] =  72 #"H"
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 831, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 831, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 831, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 73;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":832
 *             elif t == NPY_INT:         f[0] = 105 #"i"
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 832, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 832, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 832, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x6C;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":833
 *             elif t == NPY_UINT:        f[0] =  73 #"I"
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 833, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 833, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 833, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 76;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":834
 *             elif t == NPY_LONG:        f[0] = 108 #"l"
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 834, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 834, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 834, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x71;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":835
 *             elif t == NPY_ULONG:       f[0] = 76  #"L"
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 835, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 835, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 835, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 81;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":836
 *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 836, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 836, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 836, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x66;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":837
 *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 837, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 837, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 837, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x64;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":838
 *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 838, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 838, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 838, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 0x67;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":839
 *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 839, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 839, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 839, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x66;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":840
 *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 840, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 840, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 840, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x64;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":841
 *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 *             else:
 */
      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 841, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_3);
      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 841, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 841, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 90;
        (__pyx_v_f[1]) = 0x67;
        __pyx_v_f = (__pyx_v_f + 1);
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":842
 *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
 *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 */
      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 842, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 842, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(2, 842, __pyx_L1_error)
      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
      if (__pyx_t_6) {
        (__pyx_v_f[0]) = 79;
        goto __pyx_L15;
      }

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":844
 *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
 *             f += 1
 *         else:
 */
      /*else*/ {
        __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_GIVEREF(__pyx_t_3);
        PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
        __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 844, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __PYX_ERR(2, 844, __pyx_L1_error)
      }
      __pyx_L15:;

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":845
 *             else:
 *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
 *             f += 1             # <<<<<<<<<<<<<<
 *         else:
 *             # Cython ignores struct boundary information ("T{...}"),
 */
      __pyx_v_f = (__pyx_v_f + 1);

      /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":820
 *         offset[0] += child.itemsize
 * 
 *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
 *             t = child.type_num
 *             if end - f < 5:
 */
      goto __pyx_L13;
    }

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":849
 *             # Cython ignores struct boundary information ("T{...}"),
 *             # so don't output it
 *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
 *     return f
 * 
 */
    /*else*/ {
      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(2, 849, __pyx_L1_error)
      __pyx_v_f = __pyx_t_9;
    }
    __pyx_L13:;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":794
 *     cdef tuple fields
 * 
 *     for childname in descr.names:             # <<<<<<<<<<<<<<
 *         fields = descr.fields[childname]
 *         child, new_offset = fields
 */
  }
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":850
 *             # so don't output it
 *             f = _util_dtypestring(child, f, end, offset)
 *     return f             # <<<<<<<<<<<<<<
 * 
 * 
 */
  __pyx_r = __pyx_v_f;
  goto __pyx_L0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":785
 *     return PyArray_MultiIterNew(5, a, b, c,  d,  e)
 * 
 * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
 *     # Recursive utility function used in __getbuffer__ to get format
 *     # string. The new location in the format string is returned.
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF((PyObject *)__pyx_v_child);
  __Pyx_XDECREF(__pyx_v_fields);
  __Pyx_XDECREF(__pyx_v_childname);
  __Pyx_XDECREF(__pyx_v_new_offset);
  __Pyx_XDECREF(__pyx_v_t);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":966
 * 
 * 
 * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
 *      cdef PyObject* baseptr
 *      if base is None:
 */

static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
  PyObject *__pyx_v_baseptr;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  int __pyx_t_2;
  __Pyx_RefNannySetupContext("set_array_base", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":968
 * cdef inline void set_array_base(ndarray arr, object base):
 *      cdef PyObject* baseptr
 *      if base is None:             # <<<<<<<<<<<<<<
 *          baseptr = NULL
 *      else:
 */
  __pyx_t_1 = (__pyx_v_base == Py_None);
  __pyx_t_2 = (__pyx_t_1 != 0);
  if (__pyx_t_2) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":969
 *      cdef PyObject* baseptr
 *      if base is None:
 *          baseptr = NULL             # <<<<<<<<<<<<<<
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!
 */
    __pyx_v_baseptr = NULL;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":968
 * cdef inline void set_array_base(ndarray arr, object base):
 *      cdef PyObject* baseptr
 *      if base is None:             # <<<<<<<<<<<<<<
 *          baseptr = NULL
 *      else:
 */
    goto __pyx_L3;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":971
 *          baseptr = NULL
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!             # <<<<<<<<<<<<<<
 *          baseptr = base
 *      Py_XDECREF(arr.base)
 */
  /*else*/ {
    Py_INCREF(__pyx_v_base);

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":972
 *      else:
 *          Py_INCREF(base) # important to do this before decref below!
 *          baseptr = base             # <<<<<<<<<<<<<<
 *      Py_XDECREF(arr.base)
 *      arr.base = baseptr
 */
    __pyx_v_baseptr = ((PyObject *)__pyx_v_base);
  }
  __pyx_L3:;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":973
 *          Py_INCREF(base) # important to do this before decref below!
 *          baseptr = base
 *      Py_XDECREF(arr.base)             # <<<<<<<<<<<<<<
 *      arr.base = baseptr
 * 
 */
  Py_XDECREF(__pyx_v_arr->base);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":974
 *          baseptr = base
 *      Py_XDECREF(arr.base)
 *      arr.base = baseptr             # <<<<<<<<<<<<<<
 * 
 * cdef inline object get_array_base(ndarray arr):
 */
  __pyx_v_arr->base = __pyx_v_baseptr;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":966
 * 
 * 
 * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
 *      cdef PyObject* baseptr
 *      if base is None:
 */

  /* function exit code */
  __Pyx_RefNannyFinishContext();
}

/* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":976
 *      arr.base = baseptr
 * 
 * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
 *     if arr.base is NULL:
 *         return None
 */

static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  int __pyx_t_1;
  __Pyx_RefNannySetupContext("get_array_base", 0);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":977
 * 
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:             # <<<<<<<<<<<<<<
 *         return None
 *     else:
 */
  __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0);
  if (__pyx_t_1) {

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":978
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:
 *         return None             # <<<<<<<<<<<<<<
 *     else:
 *         return arr.base
 */
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(Py_None);
    __pyx_r = Py_None;
    goto __pyx_L0;

    /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":977
 * 
 * cdef inline object get_array_base(ndarray arr):
 *     if arr.base is NULL:             # <<<<<<<<<<<<<<
 *         return None
 *     else:
 */
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":980
 *         return None
 *     else:
 *         return arr.base             # <<<<<<<<<<<<<<
 */
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(((PyObject *)__pyx_v_arr->base));
    __pyx_r = ((PyObject *)__pyx_v_arr->base);
    goto __pyx_L0;
  }

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":976
 *      arr.base = baseptr
 * 
 * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
 *     if arr.base is NULL:
 *         return None
 */

  /* function exit code */
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyMethodDef __pyx_methods[] = {
  {"mkmask", (PyCFunction)__pyx_pw_6healpy_9_sphtools_17mkmask, METH_O, __pyx_doc_6healpy_9_sphtools_16mkmask},
  {"count_bad", (PyCFunction)__pyx_pw_6healpy_9_sphtools_19count_bad, METH_O, __pyx_doc_6healpy_9_sphtools_18count_bad},
  {0, 0, 0, 0}
};

#if PY_MAJOR_VERSION >= 3
static struct PyModuleDef __pyx_moduledef = {
  #if PY_VERSION_HEX < 0x03020000
    { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
  #else
    PyModuleDef_HEAD_INIT,
  #endif
    "_sphtools",
    0, /* m_doc */
    -1, /* m_size */
    __pyx_methods /* m_methods */,
    NULL, /* m_reload */
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};
#endif

static __Pyx_StringTabEntry __pyx_string_tab[] = {
  {&__pyx_n_s_A1, __pyx_k_A1, sizeof(__pyx_k_A1), 0, 0, 1, 1},
  {&__pyx_n_s_A2, __pyx_k_A2, sizeof(__pyx_k_A2), 0, 0, 1, 1},
  {&__pyx_n_s_AC, __pyx_k_AC, sizeof(__pyx_k_AC), 0, 0, 1, 1},
  {&__pyx_n_s_AG, __pyx_k_AG, sizeof(__pyx_k_AG), 0, 0, 1, 1},
  {&__pyx_n_s_AI, __pyx_k_AI, sizeof(__pyx_k_AI), 0, 0, 1, 1},
  {&__pyx_n_s_DATAPATH, __pyx_k_DATAPATH, sizeof(__pyx_k_DATAPATH), 0, 0, 1, 1},
  {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
  {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
  {&__pyx_n_s_IOError, __pyx_k_IOError, sizeof(__pyx_k_IOError), 0, 0, 1, 1},
  {&__pyx_kp_s_Input_maps_must_have_same_size, __pyx_k_Input_maps_must_have_same_size, sizeof(__pyx_k_Input_maps_must_have_same_size), 0, 0, 1, 0},
  {&__pyx_kp_s_Invalid_input, __pyx_k_Invalid_input, sizeof(__pyx_k_Invalid_input), 0, 0, 1, 0},
  {&__pyx_n_s_M1, __pyx_k_M1, sizeof(__pyx_k_M1), 0, 0, 1, 1},
  {&__pyx_n_s_M2, __pyx_k_M2, sizeof(__pyx_k_M2), 0, 0, 1, 1},
  {&__pyx_n_s_MI, __pyx_k_MI, sizeof(__pyx_k_MI), 0, 0, 1, 1},
  {&__pyx_n_s_MQ, __pyx_k_MQ, sizeof(__pyx_k_MQ), 0, 0, 1, 1},
  {&__pyx_n_s_MU, __pyx_k_MU, sizeof(__pyx_k_MU), 0, 0, 1, 1},
  {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
  {&__pyx_n_s_Nspec, __pyx_k_Nspec, sizeof(__pyx_k_Nspec), 0, 0, 1, 1},
  {&__pyx_n_s_Nspec2, __pyx_k_Nspec2, sizeof(__pyx_k_Nspec2), 0, 0, 1, 1},
  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
  {&__pyx_kp_s_Weight_file_not_found_in_s, __pyx_k_Weight_file_not_found_in_s, sizeof(__pyx_k_Weight_file_not_found_in_s), 0, 0, 1, 0},
  {&__pyx_kp_s_Wrong_input_map_must_be_a_valid, __pyx_k_Wrong_input_map_must_be_a_valid, sizeof(__pyx_k_Wrong_input_map_must_be_a_valid), 0, 0, 1, 0},
  {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1},
  {&__pyx_n_s_abspath, __pyx_k_abspath, sizeof(__pyx_k_abspath), 0, 0, 1, 1},
  {&__pyx_n_s_ac, __pyx_k_ac, sizeof(__pyx_k_ac), 0, 0, 1, 1},
  {&__pyx_n_s_ag, __pyx_k_ag, sizeof(__pyx_k_ag), 0, 0, 1, 1},
  {&__pyx_n_s_ai, __pyx_k_ai, sizeof(__pyx_k_ai), 0, 0, 1, 1},
  {&__pyx_kp_s_all_alms_must_have_same_size, __pyx_k_all_alms_must_have_same_size, sizeof(__pyx_k_all_alms_must_have_same_size), 0, 0, 1, 0},
  {&__pyx_n_s_alm, __pyx_k_alm, sizeof(__pyx_k_alm), 0, 0, 1, 1},
  {&__pyx_n_s_alm1, __pyx_k_alm1, sizeof(__pyx_k_alm1), 0, 0, 1, 1},
  {&__pyx_n_s_alm2, __pyx_k_alm2, sizeof(__pyx_k_alm2), 0, 0, 1, 1},
  {&__pyx_n_s_alm2cl, __pyx_k_alm2cl, sizeof(__pyx_k_alm2cl), 0, 0, 1, 1},
  {&__pyx_n_s_alm2map_spin_healpy, __pyx_k_alm2map_spin_healpy, sizeof(__pyx_k_alm2map_spin_healpy), 0, 0, 1, 1},
  {&__pyx_n_s_almC, __pyx_k_almC, sizeof(__pyx_k_almC), 0, 0, 1, 1},
  {&__pyx_n_s_almG, __pyx_k_almG, sizeof(__pyx_k_almG), 0, 0, 1, 1},
  {&__pyx_n_s_almI, __pyx_k_almI, sizeof(__pyx_k_almI), 0, 0, 1, 1},
  {&__pyx_n_s_alm_2, __pyx_k_alm_2, sizeof(__pyx_k_alm_2), 0, 0, 1, 1},
  {&__pyx_n_s_alm_getlmmax, __pyx_k_alm_getlmmax, sizeof(__pyx_k_alm_getlmmax), 0, 0, 1, 1},
  {&__pyx_n_s_alms, __pyx_k_alms, sizeof(__pyx_k_alms), 0, 0, 1, 1},
  {&__pyx_n_s_alms2, __pyx_k_alms2, sizeof(__pyx_k_alms2), 0, 0, 1, 1},
  {&__pyx_kp_s_alms2_must_be_an_array_or_a_sequ, __pyx_k_alms2_must_be_an_array_or_a_sequ, sizeof(__pyx_k_alms2_must_be_an_array_or_a_sequ), 0, 0, 1, 0},
  {&__pyx_kp_s_alms_and_alms2_must_have_same_nu, __pyx_k_alms_and_alms2_must_have_same_nu, sizeof(__pyx_k_alms_and_alms2_must_have_same_nu), 0, 0, 1, 0},
  {&__pyx_n_s_alms_c, __pyx_k_alms_c, sizeof(__pyx_k_alms_c), 0, 0, 1, 1},
  {&__pyx_n_s_alms_lonely, __pyx_k_alms_lonely, sizeof(__pyx_k_alms_lonely), 0, 0, 1, 1},
  {&__pyx_kp_s_alms_must_be_an_array_or_a_seque, __pyx_k_alms_must_be_an_array_or_a_seque, sizeof(__pyx_k_alms_must_be_an_array_or_a_seque), 0, 0, 1, 0},
  {&__pyx_n_s_almsize, __pyx_k_almsize, sizeof(__pyx_k_almsize), 0, 0, 1, 1},
  {&__pyx_n_s_almxfl, __pyx_k_almxfl, sizeof(__pyx_k_almxfl), 0, 0, 1, 1},
  {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1},
  {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1},
  {&__pyx_n_s_ascontiguousarray, __pyx_k_ascontiguousarray, sizeof(__pyx_k_ascontiguousarray), 0, 0, 1, 1},
  {&__pyx_n_s_c_datapath, __pyx_k_c_datapath, sizeof(__pyx_k_c_datapath), 0, 0, 1, 1},
  {&__pyx_n_s_complex128, __pyx_k_complex128, sizeof(__pyx_k_complex128), 0, 0, 1, 1},
  {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1},
  {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1},
  {&__pyx_n_s_datapath, __pyx_k_datapath, sizeof(__pyx_k_datapath), 0, 0, 1, 1},
  {&__pyx_n_s_dirname, __pyx_k_dirname, sizeof(__pyx_k_dirname), 0, 0, 1, 1},
  {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1},
  {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1},
  {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1},
  {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1},
  {&__pyx_n_s_fl, __pyx_k_fl, sizeof(__pyx_k_fl), 0, 0, 1, 1},
  {&__pyx_n_s_fl_2, __pyx_k_fl_2, sizeof(__pyx_k_fl_2), 0, 0, 1, 1},
  {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1},
  {&__pyx_n_s_flsize, __pyx_k_flsize, sizeof(__pyx_k_flsize), 0, 0, 1, 1},
  {&__pyx_n_s_get_datapath, __pyx_k_get_datapath, sizeof(__pyx_k_get_datapath), 0, 0, 1, 1},
  {&__pyx_n_s_healpy, __pyx_k_healpy, sizeof(__pyx_k_healpy), 0, 0, 1, 1},
  {&__pyx_n_s_healpy__sphtools, __pyx_k_healpy__sphtools, sizeof(__pyx_k_healpy__sphtools), 0, 0, 1, 1},
  {&__pyx_n_s_healpy_pixelfunc, __pyx_k_healpy_pixelfunc, sizeof(__pyx_k_healpy_pixelfunc), 0, 0, 1, 1},
  {&__pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_k_home_zonca_zonca_p_software_hea, sizeof(__pyx_k_home_zonca_zonca_p_software_hea), 0, 0, 1, 0},
  {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1},
  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
  {&__pyx_n_s_info, __pyx_k_info, sizeof(__pyx_k_info), 0, 0, 1, 1},
  {&__pyx_n_s_inplace, __pyx_k_inplace, sizeof(__pyx_k_inplace), 0, 0, 1, 1},
  {&__pyx_n_s_int8, __pyx_k_int8, sizeof(__pyx_k_int8), 0, 0, 1, 1},
  {&__pyx_n_s_isfile, __pyx_k_isfile, sizeof(__pyx_k_isfile), 0, 0, 1, 1},
  {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1},
  {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1},
  {&__pyx_n_s_l, __pyx_k_l, sizeof(__pyx_k_l), 0, 0, 1, 1},
  {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1},
  {&__pyx_n_s_limit, __pyx_k_limit, sizeof(__pyx_k_limit), 0, 0, 1, 1},
  {&__pyx_n_s_lmax, __pyx_k_lmax, sizeof(__pyx_k_lmax), 0, 0, 1, 1},
  {&__pyx_n_s_lmax_2, __pyx_k_lmax_2, sizeof(__pyx_k_lmax_2), 0, 0, 1, 1},
  {&__pyx_n_s_lmax_out, __pyx_k_lmax_out, sizeof(__pyx_k_lmax_out), 0, 0, 1, 1},
  {&__pyx_n_s_lmax_out_2, __pyx_k_lmax_out_2, sizeof(__pyx_k_lmax_out_2), 0, 0, 1, 1},
  {&__pyx_n_s_m, __pyx_k_m, sizeof(__pyx_k_m), 0, 0, 1, 1},
  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
  {&__pyx_n_s_map2alm, __pyx_k_map2alm, sizeof(__pyx_k_map2alm), 0, 0, 1, 1},
  {&__pyx_n_s_map2alm_spin_healpy, __pyx_k_map2alm_spin_healpy, sizeof(__pyx_k_map2alm_spin_healpy), 0, 0, 1, 1},
  {&__pyx_n_s_maps, __pyx_k_maps, sizeof(__pyx_k_maps), 0, 0, 1, 1},
  {&__pyx_n_s_maps_c, __pyx_k_maps_c, sizeof(__pyx_k_maps_c), 0, 0, 1, 1},
  {&__pyx_n_s_maptype, __pyx_k_maptype, sizeof(__pyx_k_maptype), 0, 0, 1, 1},
  {&__pyx_n_s_mask, __pyx_k_mask, sizeof(__pyx_k_mask), 0, 0, 1, 1},
  {&__pyx_n_s_mask_mi, __pyx_k_mask_mi, sizeof(__pyx_k_mask_mi), 0, 0, 1, 1},
  {&__pyx_n_s_mask_mq, __pyx_k_mask_mq, sizeof(__pyx_k_mask_mq), 0, 0, 1, 1},
  {&__pyx_n_s_mask_mu, __pyx_k_mask_mu, sizeof(__pyx_k_mask_mu), 0, 0, 1, 1},
  {&__pyx_n_s_masks, __pyx_k_masks, sizeof(__pyx_k_masks), 0, 0, 1, 1},
  {&__pyx_n_s_maxm, __pyx_k_maxm, sizeof(__pyx_k_maxm), 0, 0, 1, 1},
  {&__pyx_n_s_mi, __pyx_k_mi, sizeof(__pyx_k_mi), 0, 0, 1, 1},
  {&__pyx_n_s_mmax, __pyx_k_mmax, sizeof(__pyx_k_mmax), 0, 0, 1, 1},
  {&__pyx_n_s_mmax_2, __pyx_k_mmax_2, sizeof(__pyx_k_mmax_2), 0, 0, 1, 1},
  {&__pyx_kp_s_mmax_must_be_lmax, __pyx_k_mmax_must_be_lmax, sizeof(__pyx_k_mmax_must_be_lmax), 0, 0, 1, 0},
  {&__pyx_n_s_mq, __pyx_k_mq, sizeof(__pyx_k_mq), 0, 0, 1, 1},
  {&__pyx_n_s_mu, __pyx_k_mu, sizeof(__pyx_k_mu), 0, 0, 1, 1},
  {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1},
  {&__pyx_n_s_n_alm, __pyx_k_n_alm, sizeof(__pyx_k_n_alm), 0, 0, 1, 1},
  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
  {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1},
  {&__pyx_n_s_niter, __pyx_k_niter, sizeof(__pyx_k_niter), 0, 0, 1, 1},
  {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
  {&__pyx_n_s_npix, __pyx_k_npix, sizeof(__pyx_k_npix), 0, 0, 1, 1},
  {&__pyx_n_s_npix2nside, __pyx_k_npix2nside, sizeof(__pyx_k_npix2nside), 0, 0, 1, 1},
  {&__pyx_n_s_nside, __pyx_k_nside, sizeof(__pyx_k_nside), 0, 0, 1, 1},
  {&__pyx_n_s_nside2npix, __pyx_k_nside2npix, sizeof(__pyx_k_nside2npix), 0, 0, 1, 1},
  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
  {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1},
  {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1},
  {&__pyx_n_s_phi, __pyx_k_phi, sizeof(__pyx_k_phi), 0, 0, 1, 1},
  {&__pyx_n_s_polarization, __pyx_k_polarization, sizeof(__pyx_k_polarization), 0, 0, 1, 1},
  {&__pyx_n_s_powspec, __pyx_k_powspec, sizeof(__pyx_k_powspec), 0, 0, 1, 1},
  {&__pyx_n_s_psi, __pyx_k_psi, sizeof(__pyx_k_psi), 0, 0, 1, 1},
  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
  {&__pyx_n_s_rotate_alm, __pyx_k_rotate_alm, sizeof(__pyx_k_rotate_alm), 0, 0, 1, 1},
  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
  {&__pyx_n_s_spectra, __pyx_k_spectra, sizeof(__pyx_k_spectra), 0, 0, 1, 1},
  {&__pyx_n_s_spin, __pyx_k_spin, sizeof(__pyx_k_spin), 0, 0, 1, 1},
  {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1},
  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
  {&__pyx_n_s_theta, __pyx_k_theta, sizeof(__pyx_k_theta), 0, 0, 1, 1},
  {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
  {&__pyx_n_s_use_weights, __pyx_k_use_weights, sizeof(__pyx_k_use_weights), 0, 0, 1, 1},
  {&__pyx_n_s_w_arr, __pyx_k_w_arr, sizeof(__pyx_k_w_arr), 0, 0, 1, 1},
  {&__pyx_kp_s_weight_ring_n_05d_fits, __pyx_k_weight_ring_n_05d_fits, sizeof(__pyx_k_weight_ring_n_05d_fits), 0, 0, 1, 0},
  {&__pyx_n_s_weightfile, __pyx_k_weightfile, sizeof(__pyx_k_weightfile), 0, 0, 1, 1},
  {&__pyx_n_s_xrange, __pyx_k_xrange, sizeof(__pyx_k_xrange), 0, 0, 1, 1},
  {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1},
  {&__pyx_n_s_zip, __pyx_k_zip, sizeof(__pyx_k_zip), 0, 0, 1, 1},
  {0, 0, 0, 0, 0, 0, 0}
};
static int __Pyx_InitCachedBuiltins(void) {
  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 99, __pyx_L1_error)
  __pyx_builtin_zip = __Pyx_GetBuiltinName(__pyx_n_s_zip); if (!__pyx_builtin_zip) __PYX_ERR(0, 106, __pyx_L1_error)
  __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) __PYX_ERR(0, 281, __pyx_L1_error)
  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 283, __pyx_L1_error)
  #if PY_MAJOR_VERSION >= 3
  __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_xrange) __PYX_ERR(0, 374, __pyx_L1_error)
  #else
  __pyx_builtin_xrange = __Pyx_GetBuiltinName(__pyx_n_s_xrange); if (!__pyx_builtin_xrange) __PYX_ERR(0, 374, __pyx_L1_error)
  #endif
  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(2, 799, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

static int __Pyx_InitCachedConstants(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);

  /* "healpy/src/_sphtools.pyx":99
 *     # Check all maps have same npix
 *     if maps_c[1].size != npix:
 *         raise ValueError("Input maps must have same size")             # <<<<<<<<<<<<<<
 * 
 *     # View the ndarray as a Healpix_Map
 */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Input_maps_must_have_same_size); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 99, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

  /* "healpy/src/_sphtools.pyx":214
 *         mu = np.ascontiguousarray(m[2], dtype=np.float64)
 *     else:
 *         raise ValueError("Wrong input map (must be a valid healpix map "             # <<<<<<<<<<<<<<
 *                          "or a sequence of 1 or 3 maps)")
 * 
 */
  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Wrong_input_map_must_be_a_valid); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 214, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__2);
  __Pyx_GIVEREF(__pyx_tuple__2);

  /* "healpy/src/_sphtools.pyx":240
 *     if polarization:
 *         if mq.size != npix or mu.size != npix:
 *             raise ValueError("Input maps must have same size")             # <<<<<<<<<<<<<<
 * 
 *     # View the ndarray as a Healpix_Map
 */
  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_Input_maps_must_have_same_size); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 240, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__3);
  __Pyx_GIVEREF(__pyx_tuple__3);

  /* "healpy/src/_sphtools.pyx":348
 *     cdef int Nspec, Nspec2
 *     if not hasattr(alms, '__len__'):
 *         raise ValueError('alms must be an array or a sequence of arrays')             # <<<<<<<<<<<<<<
 *     if not hasattr(alms[0], '__len__'):
 *         alms_lonely = True
 */
  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_alms_must_be_an_array_or_a_seque); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 348, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__4);
  __Pyx_GIVEREF(__pyx_tuple__4);

  /* "healpy/src/_sphtools.pyx":361
 * 
 *     if not hasattr(alms2, '__len__'):
 *         raise ValueError('alms2 must be an array or a sequence of arrays')             # <<<<<<<<<<<<<<
 *     if not hasattr(alms2[0], '__len__'):
 *         alms2 = [alms2]
 */
  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_alms2_must_be_an_array_or_a_sequ); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__5);
  __Pyx_GIVEREF(__pyx_tuple__5);

  /* "healpy/src/_sphtools.pyx":367
 * 
 *     if Nspec != Nspec2:
 *         raise ValueError('alms and alms2 must have same number of spectra')             # <<<<<<<<<<<<<<
 * 
 *     ##############################################
 */
  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_alms_and_alms2_must_have_same_nu); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 367, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__6);
  __Pyx_GIVEREF(__pyx_tuple__6);

  /* "healpy/src/_sphtools.pyx":376
 *     for i in xrange(Nspec):
 *         if alms[i].size != almsize or alms2[i].size != almsize:
 *             raise ValueError('all alms must have same size')             # <<<<<<<<<<<<<<
 * 
 *     lmax, mmax = alm_getlmmax(alms[0], lmax, mmax)
 */
  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_all_alms_must_have_same_size); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 376, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__7);
  __Pyx_GIVEREF(__pyx_tuple__7);

  /* "healpy/src/_sphtools.pyx":505
 * 
 *     if not isinstance(alm, (list, tuple, np.ndarray)) or len(alm) == 0:
 *         raise ValueError('Invalid input.')             # <<<<<<<<<<<<<<
 * 
 *     # C++ rotate_alm only handles 1 or 3 maps. The function handling 3 maps
 */
  __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Invalid_input); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 505, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__8);
  __Pyx_GIVEREF(__pyx_tuple__8);

  /* "healpy/src/_sphtools.pyx":532
 * cdef int alm_getn(int l, int m):
 *     if not m <= l:
 *         raise ValueError("mmax must be <= lmax")             # <<<<<<<<<<<<<<
 *     return ((m+1)*(m+2))/2 + (m+1)*(l-m)
 * 
 */
  __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_mmax_must_be_lmax); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 532, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__9);
  __Pyx_GIVEREF(__pyx_tuple__9);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":218
 *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
 * 
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 */
  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 218, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__10);
  __Pyx_GIVEREF(__pyx_tuple__10);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":222
 *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
 *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
 *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
 * 
 *             info.buf = PyArray_DATA(self)
 */
  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(2, 222, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__11);
  __Pyx_GIVEREF(__pyx_tuple__11);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":259
 *                 if ((descr.byteorder == c'>' and little_endian) or
 *                     (descr.byteorder == c'<' and not little_endian)):
 *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *                 if   t == NPY_BYTE:        f = "b"
 *                 elif t == NPY_UBYTE:       f = "B"
 */
  __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(2, 259, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__12);
  __Pyx_GIVEREF(__pyx_tuple__12);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":799
 * 
 *         if (end - f) - (new_offset - offset[0]) < 15:
 *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
 * 
 *         if ((child.byteorder == c'>' and little_endian) or
 */
  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(2, 799, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__13);
  __Pyx_GIVEREF(__pyx_tuple__13);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":803
 *         if ((child.byteorder == c'>' and little_endian) or
 *             (child.byteorder == c'<' and not little_endian)):
 *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
 *             # One could encode it in the format string and have Cython
 *             # complain instead, BUT: < and > in format strings also imply
 */
  __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(2, 803, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__14);
  __Pyx_GIVEREF(__pyx_tuple__14);

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":823
 *             t = child.type_num
 *             if end - f < 5:
 *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
 * 
 *             # Until ticket #99 is fixed, use integers to avoid warnings
 */
  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(2, 823, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__15);
  __Pyx_GIVEREF(__pyx_tuple__15);

  /* "healpy/src/_sphtools.pyx":54
 * DATAPATH = None
 * 
 * def get_datapath():             # <<<<<<<<<<<<<<
 *     global DATAPATH
 *     if DATAPATH is None:
 */
  __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_get_datapath, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 54, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":60
 *     return DATAPATH
 * 
 * def map2alm_spin_healpy(maps, spin, lmax = None, mmax = None):             # <<<<<<<<<<<<<<
 *     """Computes the spinned alm of a 2 Healpix maps.
 * 
 */
  __pyx_tuple__17 = PyTuple_Pack(21, __pyx_n_s_maps, __pyx_n_s_spin, __pyx_n_s_lmax, __pyx_n_s_mmax, __pyx_n_s_maps_c, __pyx_n_s_masks, __pyx_n_s_lmax_2, __pyx_n_s_mmax_2, __pyx_n_s_nside, __pyx_n_s_npix, __pyx_n_s_M1, __pyx_n_s_M2, __pyx_n_s_m, __pyx_n_s_mask, __pyx_n_s_n_alm, __pyx_n_s_alms, __pyx_n_s_A1, __pyx_n_s_A2, __pyx_n_s_w_arr, __pyx_n_s_i, __pyx_n_s_c_datapath); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 60, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__17);
  __Pyx_GIVEREF(__pyx_tuple__17);
  __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(4, 0, 21, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_map2alm_spin_healpy, 60, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 60, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":136
 *     return alms
 * 
 * def alm2map_spin_healpy(alms, nside, spin, lmax, mmax=None):             # <<<<<<<<<<<<<<
 *     """Computes maps from a set of 2 spinned alm
 * 
 */
  __pyx_tuple__19 = PyTuple_Pack(13, __pyx_n_s_alms, __pyx_n_s_nside, __pyx_n_s_spin, __pyx_n_s_lmax, __pyx_n_s_mmax, __pyx_n_s_alms_c, __pyx_n_s_npix, __pyx_n_s_maps, __pyx_n_s_M1, __pyx_n_s_M2, __pyx_n_s_A1, __pyx_n_s_A2, __pyx_n_s_alm); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__19);
  __Pyx_GIVEREF(__pyx_tuple__19);
  __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(5, 0, 13, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_alm2map_spin_healpy, 136, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 136, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":178
 *     return maps
 * 
 * def map2alm(m, lmax = None, mmax = None, niter = 3, use_weights = False,             # <<<<<<<<<<<<<<
 *             datapath = None):
 *     """Computes the alm of a Healpix map.
 */
  __pyx_tuple__21 = PyTuple_Pack(32, __pyx_n_s_m, __pyx_n_s_lmax, __pyx_n_s_mmax, __pyx_n_s_niter, __pyx_n_s_use_weights, __pyx_n_s_datapath, __pyx_n_s_info, __pyx_n_s_polarization, __pyx_n_s_mi, __pyx_n_s_mq, __pyx_n_s_mu, __pyx_n_s_mask_mi, __pyx_n_s_mask_mq, __pyx_n_s_mask_mu, __pyx_n_s_lmax_2, __pyx_n_s_mmax_2, __pyx_n_s_nside, __pyx_n_s_npix, __pyx_n_s_MI, __pyx_n_s_MQ, __pyx_n_s_MU, __pyx_n_s_n_alm, __pyx_n_s_almI, __pyx_n_s_almG, __pyx_n_s_almC, __pyx_n_s_AI, __pyx_n_s_AG, __pyx_n_s_AC, __pyx_n_s_w_arr, __pyx_n_s_i, __pyx_n_s_c_datapath, __pyx_n_s_weightfile); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__21);
  __Pyx_GIVEREF(__pyx_tuple__21);
  __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(6, 0, 32, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_map2alm, 178, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 178, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":311
 * 
 * 
 * def alm2cl(alms, alms2 = None, lmax = None, mmax = None, lmax_out = None):             # <<<<<<<<<<<<<<
 *     """Computes (cross-)spectra from alm(s). If alm2 is given, cross-spectra between
 *     alm and alm2 are computed. If alm (and alm2 if provided) contains n alm,
 */
  __pyx_tuple__23 = PyTuple_Pack(22, __pyx_n_s_alms, __pyx_n_s_alms2, __pyx_n_s_lmax, __pyx_n_s_mmax, __pyx_n_s_lmax_out, __pyx_n_s_Nspec, __pyx_n_s_Nspec2, __pyx_n_s_alms_lonely, __pyx_n_s_almsize, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_l, __pyx_n_s_m, __pyx_n_s_limit, __pyx_n_s_lmax_2, __pyx_n_s_mmax_2, __pyx_n_s_lmax_out_2, __pyx_n_s_powspec, __pyx_n_s_alm1, __pyx_n_s_alm2, __pyx_n_s_spectra, __pyx_n_s_n); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__23);
  __Pyx_GIVEREF(__pyx_tuple__23);
  __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(5, 0, 22, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_alm2cl, 311, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 311, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":423
 * @cython.wraparound(False)
 * @cython.boundscheck(False)
 * def almxfl(alm, fl, mmax = None, inplace = False):             # <<<<<<<<<<<<<<
 *     """Multiply an a_lm by a vector b_l.
 * 
 */
  __pyx_tuple__25 = PyTuple_Pack(14, __pyx_n_s_alm, __pyx_n_s_fl, __pyx_n_s_mmax, __pyx_n_s_inplace, __pyx_n_s_alm_2, __pyx_n_s_fl_2, __pyx_n_s_lmax_2, __pyx_n_s_mmax_2, __pyx_n_s_l, __pyx_n_s_m, __pyx_n_s_f, __pyx_n_s_maxm, __pyx_n_s_i, __pyx_n_s_flsize); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__25);
  __Pyx_GIVEREF(__pyx_tuple__25);
  __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(4, 0, 14, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_almxfl, 423, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 423, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":472
 * 
 * 
 * def rotate_alm(alm not None, double psi, double theta, double phi, lmax=None,             # <<<<<<<<<<<<<<
 *                mmax=None):
 *     """
 */
  __pyx_tuple__27 = PyTuple_Pack(13, __pyx_n_s_alm, __pyx_n_s_psi, __pyx_n_s_theta, __pyx_n_s_phi, __pyx_n_s_lmax, __pyx_n_s_mmax, __pyx_n_s_a, __pyx_n_s_ai, __pyx_n_s_AI, __pyx_n_s_ag, __pyx_n_s_ac, __pyx_n_s_AG, __pyx_n_s_AC); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 472, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__27);
  __Pyx_GIVEREF(__pyx_tuple__27);
  __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(6, 0, 13, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_rotate_alm, 472, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 472, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":536
 * 
 * 
 * def alm_getlmmax(a, lmax, mmax):             # <<<<<<<<<<<<<<
 *     if lmax is None:
 *         if mmax is None:
 */
  __pyx_tuple__29 = PyTuple_Pack(3, __pyx_n_s_a, __pyx_n_s_lmax, __pyx_n_s_mmax); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__29);
  __Pyx_GIVEREF(__pyx_tuple__29);
  __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_zonca_zonca_p_software_hea, __pyx_n_s_alm_getlmmax, 536, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 536, __pyx_L1_error)
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_InitGlobals(void) {
  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  __pyx_float_0_0 = PyFloat_FromDouble(0.0); if (unlikely(!__pyx_float_0_0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_int_neg_3 = PyInt_FromLong(-3); if (unlikely(!__pyx_int_neg_3)) __PYX_ERR(0, 1, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

#if PY_MAJOR_VERSION < 3
PyMODINIT_FUNC init_sphtools(void); /*proto*/
PyMODINIT_FUNC init_sphtools(void)
#else
PyMODINIT_FUNC PyInit__sphtools(void); /*proto*/
PyMODINIT_FUNC PyInit__sphtools(void)
#endif
{
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  __Pyx_RefNannyDeclarations
  #if CYTHON_REFNANNY
  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
  if (!__Pyx_RefNanny) {
      PyErr_Clear();
      __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
      if (!__Pyx_RefNanny)
          Py_FatalError("failed to import 'refnanny' module");
  }
  #endif
  __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__sphtools(void)", 0);
  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
  #ifdef __Pyx_CyFunction_USED
  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_FusedFunction_USED
  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Coroutine_USED
  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Generator_USED
  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_StopAsyncIteration_USED
  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  /*--- Library function declarations ---*/
  /*--- Threads initialization code ---*/
  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
  #ifdef WITH_THREAD /* Python build with threading support? */
  PyEval_InitThreads();
  #endif
  #endif
  /*--- Module creation code ---*/
  #if PY_MAJOR_VERSION < 3
  __pyx_m = Py_InitModule4("_sphtools", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
  #else
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  #endif
  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
  Py_INCREF(__pyx_d);
  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
  #if CYTHON_COMPILING_IN_PYPY
  Py_INCREF(__pyx_b);
  #endif
  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  /*--- Initialize various global constants etc. ---*/
  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  if (__pyx_module_is_main_healpy___sphtools) {
    if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  }
  #if PY_MAJOR_VERSION >= 3
  {
    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
    if (!PyDict_GetItemString(modules, "healpy._sphtools")) {
      if (unlikely(PyDict_SetItemString(modules, "healpy._sphtools", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
    }
  }
  #endif
  /*--- Builtin init code ---*/
  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Constants init code ---*/
  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Global init code ---*/
  /*--- Variable export code ---*/
  /*--- Function export code ---*/
  /*--- Type init code ---*/
  /*--- Type import code ---*/
  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", 
  #if CYTHON_COMPILING_IN_PYPY
  sizeof(PyTypeObject),
  #else
  sizeof(PyHeapTypeObject),
  #endif
  0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(3, 9, __pyx_L1_error)
  __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(2, 155, __pyx_L1_error)
  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(2, 168, __pyx_L1_error)
  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(2, 172, __pyx_L1_error)
  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(2, 181, __pyx_L1_error)
  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(2, 861, __pyx_L1_error)
  /*--- Variable import code ---*/
  /*--- Function import code ---*/
  /*--- Execution code ---*/
  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif

  /* "healpy/src/_sphtools.pyx":4
 * # Wrapper around the query_disc method of Healpix_base class
 * 
 * import numpy as np             # <<<<<<<<<<<<<<
 * cimport numpy as np
 * from libcpp.string cimport string
 */
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":9
 * from libc.math cimport sqrt, floor, fabs
 * cimport libc
 * from healpy import npix2nside, nside2npix             # <<<<<<<<<<<<<<
 * from healpy.pixelfunc import maptype
 * import os
 */
  __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_n_s_npix2nside);
  __Pyx_GIVEREF(__pyx_n_s_npix2nside);
  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_npix2nside);
  __Pyx_INCREF(__pyx_n_s_nside2npix);
  __Pyx_GIVEREF(__pyx_n_s_nside2npix);
  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_nside2npix);
  __pyx_t_2 = __Pyx_Import(__pyx_n_s_healpy, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_npix2nside); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_npix2nside, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_nside2npix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_nside2npix, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "healpy/src/_sphtools.pyx":10
 * cimport libc
 * from healpy import npix2nside, nside2npix
 * from healpy.pixelfunc import maptype             # <<<<<<<<<<<<<<
 * import os
 * import cython
 */
  __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_n_s_maptype);
  __Pyx_GIVEREF(__pyx_n_s_maptype);
  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_maptype);
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_healpy_pixelfunc, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_maptype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 10, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_maptype, __pyx_t_2) < 0) __PYX_ERR(0, 10, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":11
 * from healpy import npix2nside, nside2npix
 * from healpy.pixelfunc import maptype
 * import os             # <<<<<<<<<<<<<<
 * import cython
 * from libcpp cimport bool as cbool
 */
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":17
 * from _common cimport tsize, arr, xcomplex, Healpix_Ordering_Scheme, RING, NEST, Healpix_Map, Alm, ndarray2map, ndarray2alm
 * 
 * cdef double UNSEEN = -1.6375e30             # <<<<<<<<<<<<<<
 * cdef double rtol_UNSEEN = 1.e-7 * 1.6375e30
 * 
 */
  __pyx_v_6healpy_9_sphtools_UNSEEN = -1.6375e30;

  /* "healpy/src/_sphtools.pyx":18
 * 
 * cdef double UNSEEN = -1.6375e30
 * cdef double rtol_UNSEEN = 1.e-7 * 1.6375e30             # <<<<<<<<<<<<<<
 * 
 * cdef extern from "alm_healpix_tools.h":
 */
  __pyx_v_6healpy_9_sphtools_rtol_UNSEEN = (1.e-7 * 1.6375e30);

  /* "healpy/src/_sphtools.pyx":52
 *     cdef void read_weight_ring (string &dir, int nside, arr[double] &weight)
 * 
 * DATAPATH = None             # <<<<<<<<<<<<<<
 * 
 * def get_datapath():
 */
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DATAPATH, Py_None) < 0) __PYX_ERR(0, 52, __pyx_L1_error)

  /* "healpy/src/_sphtools.pyx":54
 * DATAPATH = None
 * 
 * def get_datapath():             # <<<<<<<<<<<<<<
 *     global DATAPATH
 *     if DATAPATH is None:
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_9_sphtools_1get_datapath, NULL, __pyx_n_s_healpy__sphtools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_datapath, __pyx_t_1) < 0) __PYX_ERR(0, 54, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":60
 *     return DATAPATH
 * 
 * def map2alm_spin_healpy(maps, spin, lmax = None, mmax = None):             # <<<<<<<<<<<<<<
 *     """Computes the spinned alm of a 2 Healpix maps.
 * 
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_9_sphtools_3map2alm_spin_healpy, NULL, __pyx_n_s_healpy__sphtools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 60, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_map2alm_spin_healpy, __pyx_t_1) < 0) __PYX_ERR(0, 60, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":136
 *     return alms
 * 
 * def alm2map_spin_healpy(alms, nside, spin, lmax, mmax=None):             # <<<<<<<<<<<<<<
 *     """Computes maps from a set of 2 spinned alm
 * 
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_9_sphtools_5alm2map_spin_healpy, NULL, __pyx_n_s_healpy__sphtools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_alm2map_spin_healpy, __pyx_t_1) < 0) __PYX_ERR(0, 136, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":178
 *     return maps
 * 
 * def map2alm(m, lmax = None, mmax = None, niter = 3, use_weights = False,             # <<<<<<<<<<<<<<
 *             datapath = None):
 *     """Computes the alm of a Healpix map.
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_9_sphtools_7map2alm, NULL, __pyx_n_s_healpy__sphtools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_map2alm, __pyx_t_1) < 0) __PYX_ERR(0, 178, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":311
 * 
 * 
 * def alm2cl(alms, alms2 = None, lmax = None, mmax = None, lmax_out = None):             # <<<<<<<<<<<<<<
 *     """Computes (cross-)spectra from alm(s). If alm2 is given, cross-spectra between
 *     alm and alm2 are computed. If alm (and alm2 if provided) contains n alm,
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_9_sphtools_9alm2cl, NULL, __pyx_n_s_healpy__sphtools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 311, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_alm2cl, __pyx_t_1) < 0) __PYX_ERR(0, 311, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":423
 * @cython.wraparound(False)
 * @cython.boundscheck(False)
 * def almxfl(alm, fl, mmax = None, inplace = False):             # <<<<<<<<<<<<<<
 *     """Multiply an a_lm by a vector b_l.
 * 
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_9_sphtools_11almxfl, NULL, __pyx_n_s_healpy__sphtools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 423, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_almxfl, __pyx_t_1) < 0) __PYX_ERR(0, 423, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":472
 * 
 * 
 * def rotate_alm(alm not None, double psi, double theta, double phi, lmax=None,             # <<<<<<<<<<<<<<
 *                mmax=None):
 *     """
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_9_sphtools_13rotate_alm, NULL, __pyx_n_s_healpy__sphtools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 472, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_rotate_alm, __pyx_t_1) < 0) __PYX_ERR(0, 472, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":536
 * 
 * 
 * def alm_getlmmax(a, lmax, mmax):             # <<<<<<<<<<<<<<
 *     if lmax is None:
 *         if mmax is None:
 */
  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6healpy_9_sphtools_15alm_getlmmax, NULL, __pyx_n_s_healpy__sphtools); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 536, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_alm_getlmmax, __pyx_t_1) < 0) __PYX_ERR(0, 536, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "healpy/src/_sphtools.pyx":1
 * # coding: utf-8             # <<<<<<<<<<<<<<
 * # Wrapper around the query_disc method of Healpix_base class
 * 
 */
  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

  /* "../../../../anaconda/lib/python3.5/site-packages/Cython/Includes/numpy/__init__.pxd":976
 *      arr.base = baseptr
 * 
 * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
 *     if arr.base is NULL:
 *         return None
 */

  /*--- Wrapped vars code ---*/

  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  if (__pyx_m) {
    if (__pyx_d) {
      __Pyx_AddTraceback("init healpy._sphtools", __pyx_clineno, __pyx_lineno, __pyx_filename);
    }
    Py_DECREF(__pyx_m); __pyx_m = 0;
  } else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_ImportError, "init healpy._sphtools");
  }
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #if PY_MAJOR_VERSION < 3
  return;
  #else
  return __pyx_m;
  #endif
}

/* --- Runtime support code --- */
/* Refnanny */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
    PyObject *m = NULL, *p = NULL;
    void *r = NULL;
    m = PyImport_ImportModule((char *)modname);
    if (!m) goto end;
    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
    if (!p) goto end;
    r = PyLong_AsVoidPtr(p);
end:
    Py_XDECREF(p);
    Py_XDECREF(m);
    return (__Pyx_RefNannyAPIStruct *)r;
}
#endif

/* GetBuiltinName */
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
    if (unlikely(!result)) {
        PyErr_Format(PyExc_NameError,
#if PY_MAJOR_VERSION >= 3
            "name '%U' is not defined", name);
#else
            "name '%.200s' is not defined", PyString_AS_STRING(name));
#endif
    }
    return result;
}

/* GetModuleGlobalName */
static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
    PyObject *result;
#if CYTHON_COMPILING_IN_CPYTHON
    result = PyDict_GetItem(__pyx_d, name);
    if (likely(result)) {
        Py_INCREF(result);
    } else {
#else
    result = PyObject_GetItem(__pyx_d, name);
    if (!result) {
        PyErr_Clear();
#endif
        result = __Pyx_GetBuiltinName(name);
    }
    return result;
}

/* PyObjectCall */
  #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *result;
    ternaryfunc call = func->ob_type->tp_call;
    if (unlikely(!call))
        return PyObject_Call(func, arg, kw);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = (*call)(func, arg, kw);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallMethO */
  #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
    PyObject *self, *result;
    PyCFunction cfunc;
    cfunc = PyCFunction_GET_FUNCTION(func);
    self = PyCFunction_GET_SELF(func);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = cfunc(self, arg);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallOneArg */
  #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_New(1);
    if (unlikely(!args)) return NULL;
    Py_INCREF(arg);
    PyTuple_SET_ITEM(args, 0, arg);
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
#ifdef __Pyx_CyFunction_USED
    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
#else
    if (likely(PyCFunction_Check(func))) {
#endif
        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
            return __Pyx_PyObject_CallMethO(func, arg);
        }
    }
    return __Pyx__PyObject_CallOneArg(func, arg);
}
#else
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_Pack(1, arg);
    if (unlikely(!args)) return NULL;
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
#endif

/* RaiseArgTupleInvalid */
    static void __Pyx_RaiseArgtupleInvalid(
    const char* func_name,
    int exact,
    Py_ssize_t num_min,
    Py_ssize_t num_max,
    Py_ssize_t num_found)
{
    Py_ssize_t num_expected;
    const char *more_or_less;
    if (num_found < num_min) {
        num_expected = num_min;
        more_or_less = "at least";
    } else {
        num_expected = num_max;
        more_or_less = "at most";
    }
    if (exact) {
        more_or_less = "exactly";
    }
    PyErr_Format(PyExc_TypeError,
                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 func_name, more_or_less, num_expected,
                 (num_expected == 1) ? "" : "s", num_found);
}

/* RaiseDoubleKeywords */
    static void __Pyx_RaiseDoubleKeywordsError(
    const char* func_name,
    PyObject* kw_name)
{
    PyErr_Format(PyExc_TypeError,
        #if PY_MAJOR_VERSION >= 3
        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
        #else
        "%s() got multiple values for keyword argument '%s'", func_name,
        PyString_AsString(kw_name));
        #endif
}

/* ParseKeywords */
    static int __Pyx_ParseOptionalKeywords(
    PyObject *kwds,
    PyObject **argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    const char* function_name)
{
    PyObject *key = 0, *value = 0;
    Py_ssize_t pos = 0;
    PyObject*** name;
    PyObject*** first_kw_arg = argnames + num_pos_args;
    while (PyDict_Next(kwds, &pos, &key, &value)) {
        name = first_kw_arg;
        while (*name && (**name != key)) name++;
        if (*name) {
            values[name-argnames] = value;
            continue;
        }
        name = first_kw_arg;
        #if PY_MAJOR_VERSION < 3
        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
            while (*name) {
                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                        && _PyString_Eq(**name, key)) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    if ((**argname == key) || (
                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
                             && _PyString_Eq(**argname, key))) {
                        goto arg_passed_twice;
                    }
                    argname++;
                }
            }
        } else
        #endif
        if (likely(PyUnicode_Check(key))) {
            while (*name) {
                int cmp = (**name == key) ? 0 :
                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
                #endif
                    PyUnicode_Compare(**name, key);
                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                if (cmp == 0) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    int cmp = (**argname == key) ? 0 :
                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
                    #endif
                        PyUnicode_Compare(**argname, key);
                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                    if (cmp == 0) goto arg_passed_twice;
                    argname++;
                }
            }
        } else
            goto invalid_keyword_type;
        if (kwds2) {
            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
        } else {
            goto invalid_keyword;
        }
    }
    return 0;
arg_passed_twice:
    __Pyx_RaiseDoubleKeywordsError(function_name, key);
    goto bad;
invalid_keyword_type:
    PyErr_Format(PyExc_TypeError,
        "%.200s() keywords must be strings", function_name);
    goto bad;
invalid_keyword:
    PyErr_Format(PyExc_TypeError,
    #if PY_MAJOR_VERSION < 3
        "%.200s() got an unexpected keyword argument '%.200s'",
        function_name, PyString_AsString(key));
    #else
        "%s() got an unexpected keyword argument '%U'",
        function_name, key);
    #endif
bad:
    return -1;
}

/* ExtTypeTest */
    static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (likely(PyObject_TypeCheck(obj, type)))
        return 1;
    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
                 Py_TYPE(obj)->tp_name, type->tp_name);
    return 0;
}

/* GetItemInt */
    static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
    PyObject *r;
    if (!j) return NULL;
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_COMPILING_IN_CPYTHON
    if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o);
    if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) {
        PyObject *r = PyList_GET_ITEM(o, i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_COMPILING_IN_CPYTHON
    if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o);
    if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) {
        PyObject *r = PyTuple_GET_ITEM(o, i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
                                                     CYTHON_NCP_UNUSED int wraparound,
                                                     CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_COMPILING_IN_CPYTHON
    if (is_list || PyList_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
        if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) {
            PyObject *r = PyList_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    }
    else if (PyTuple_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
        if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) {
            PyObject *r = PyTuple_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    } else {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_item)) {
            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
                Py_ssize_t l = m->sq_length(o);
                if (likely(l >= 0)) {
                    i += l;
                } else {
                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                        return NULL;
                    PyErr_Clear();
                }
            }
            return m->sq_item(o, i);
        }
    }
#else
    if (is_list || PySequence_Check(o)) {
        return PySequence_GetItem(o, i);
    }
#endif
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
}

/* PyErrFetchRestore */
    #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
    PyObject *tmp_type, *tmp_value, *tmp_tb;
    tmp_type = tstate->curexc_type;
    tmp_value = tstate->curexc_value;
    tmp_tb = tstate->curexc_traceback;
    tstate->curexc_type = type;
    tstate->curexc_value = value;
    tstate->curexc_traceback = tb;
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
}
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
    *type = tstate->curexc_type;
    *value = tstate->curexc_value;
    *tb = tstate->curexc_traceback;
    tstate->curexc_type = 0;
    tstate->curexc_value = 0;
    tstate->curexc_traceback = 0;
}
#endif

/* RaiseException */
    #if PY_MAJOR_VERSION < 3
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
                        CYTHON_UNUSED PyObject *cause) {
    __Pyx_PyThreadState_declare
    Py_XINCREF(type);
    if (!value || value == Py_None)
        value = NULL;
    else
        Py_INCREF(value);
    if (!tb || tb == Py_None)
        tb = NULL;
    else {
        Py_INCREF(tb);
        if (!PyTraceBack_Check(tb)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: arg 3 must be a traceback or None");
            goto raise_error;
        }
    }
    if (PyType_Check(type)) {
#if CYTHON_COMPILING_IN_PYPY
        if (!value) {
            Py_INCREF(Py_None);
            value = Py_None;
        }
#endif
        PyErr_NormalizeException(&type, &value, &tb);
    } else {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto raise_error;
        }
        value = type;
        type = (PyObject*) Py_TYPE(type);
        Py_INCREF(type);
        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
            PyErr_SetString(PyExc_TypeError,
                "raise: exception class must be a subclass of BaseException");
            goto raise_error;
        }
    }
    __Pyx_PyThreadState_assign
    __Pyx_ErrRestore(type, value, tb);
    return;
raise_error:
    Py_XDECREF(value);
    Py_XDECREF(type);
    Py_XDECREF(tb);
    return;
}
#else
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
    PyObject* owned_instance = NULL;
    if (tb == Py_None) {
        tb = 0;
    } else if (tb && !PyTraceBack_Check(tb)) {
        PyErr_SetString(PyExc_TypeError,
            "raise: arg 3 must be a traceback or None");
        goto bad;
    }
    if (value == Py_None)
        value = 0;
    if (PyExceptionInstance_Check(type)) {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto bad;
        }
        value = type;
        type = (PyObject*) Py_TYPE(value);
    } else if (PyExceptionClass_Check(type)) {
        PyObject *instance_class = NULL;
        if (value && PyExceptionInstance_Check(value)) {
            instance_class = (PyObject*) Py_TYPE(value);
            if (instance_class != type) {
                int is_subclass = PyObject_IsSubclass(instance_class, type);
                if (!is_subclass) {
                    instance_class = NULL;
                } else if (unlikely(is_subclass == -1)) {
                    goto bad;
                } else {
                    type = instance_class;
                }
            }
        }
        if (!instance_class) {
            PyObject *args;
            if (!value)
                args = PyTuple_New(0);
            else if (PyTuple_Check(value)) {
                Py_INCREF(value);
                args = value;
            } else
                args = PyTuple_Pack(1, value);
            if (!args)
                goto bad;
            owned_instance = PyObject_Call(type, args, NULL);
            Py_DECREF(args);
            if (!owned_instance)
                goto bad;
            value = owned_instance;
            if (!PyExceptionInstance_Check(value)) {
                PyErr_Format(PyExc_TypeError,
                             "calling %R should have returned an instance of "
                             "BaseException, not %R",
                             type, Py_TYPE(value));
                goto bad;
            }
        }
    } else {
        PyErr_SetString(PyExc_TypeError,
            "raise: exception class must be a subclass of BaseException");
        goto bad;
    }
#if PY_VERSION_HEX >= 0x03030000
    if (cause) {
#else
    if (cause && cause != Py_None) {
#endif
        PyObject *fixed_cause;
        if (cause == Py_None) {
            fixed_cause = NULL;
        } else if (PyExceptionClass_Check(cause)) {
            fixed_cause = PyObject_CallObject(cause, NULL);
            if (fixed_cause == NULL)
                goto bad;
        } else if (PyExceptionInstance_Check(cause)) {
            fixed_cause = cause;
            Py_INCREF(fixed_cause);
        } else {
            PyErr_SetString(PyExc_TypeError,
                            "exception causes must derive from "
                            "BaseException");
            goto bad;
        }
        PyException_SetCause(value, fixed_cause);
    }
    PyErr_SetObject(type, value);
    if (tb) {
#if CYTHON_COMPILING_IN_PYPY
        PyObject *tmp_type, *tmp_value, *tmp_tb;
        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
        Py_INCREF(tb);
        PyErr_Restore(tmp_type, tmp_value, tb);
        Py_XDECREF(tmp_tb);
#else
        PyThreadState *tstate = PyThreadState_GET();
        PyObject* tmp_tb = tstate->curexc_traceback;
        if (tb != tmp_tb) {
            Py_INCREF(tb);
            tstate->curexc_traceback = tb;
            Py_XDECREF(tmp_tb);
        }
#endif
    }
bad:
    Py_XDECREF(owned_instance);
    return;
}
#endif

/* RaiseTooManyValuesToUnpack */
      static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
}

/* RaiseNeedMoreValuesToUnpack */
      static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
    PyErr_Format(PyExc_ValueError,
                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
                 index, (index == 1) ? "" : "s");
}

/* IterFinish */
      static CYTHON_INLINE int __Pyx_IterFinish(void) {
#if CYTHON_COMPILING_IN_CPYTHON
    PyThreadState *tstate = PyThreadState_GET();
    PyObject* exc_type = tstate->curexc_type;
    if (unlikely(exc_type)) {
        if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) {
            PyObject *exc_value, *exc_tb;
            exc_value = tstate->curexc_value;
            exc_tb = tstate->curexc_traceback;
            tstate->curexc_type = 0;
            tstate->curexc_value = 0;
            tstate->curexc_traceback = 0;
            Py_DECREF(exc_type);
            Py_XDECREF(exc_value);
            Py_XDECREF(exc_tb);
            return 0;
        } else {
            return -1;
        }
    }
    return 0;
#else
    if (unlikely(PyErr_Occurred())) {
        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
            PyErr_Clear();
            return 0;
        } else {
            return -1;
        }
    }
    return 0;
#endif
}

/* UnpackItemEndCheck */
      static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
    if (unlikely(retval)) {
        Py_DECREF(retval);
        __Pyx_RaiseTooManyValuesError(expected);
        return -1;
    } else {
        return __Pyx_IterFinish();
    }
    return 0;
}

/* PyIntBinop */
      #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
    if (op1 == op2) {
        Py_RETURN_TRUE;
    }
    #if PY_MAJOR_VERSION < 3
    if (likely(PyInt_CheckExact(op1))) {
        const long b = intval;
        long a = PyInt_AS_LONG(op1);
        if (a == b) {
            Py_RETURN_TRUE;
        } else {
            Py_RETURN_FALSE;
        }
    }
    #endif
    #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3
    if (likely(PyLong_CheckExact(op1))) {
        const long b = intval;
        long a;
        const digit* digits = ((PyLongObject*)op1)->ob_digit;
        const Py_ssize_t size = Py_SIZE(op1);
        if (likely(__Pyx_sst_abs(size) <= 1)) {
            a = likely(size) ? digits[0] : 0;
            if (size == -1) a = -a;
        } else {
            switch (size) {
                case -2:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    }
                case 2:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    }
                case -3:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    }
                case 3:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    }
                case -4:
                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    }
                case 4:
                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    }
                #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15
                default: return PyLong_Type.tp_richcompare(op1, op2, Py_EQ);
                #else
                default: Py_RETURN_FALSE;
                #endif
            }
        }
            if (a == b) {
                Py_RETURN_TRUE;
            } else {
                Py_RETURN_FALSE;
            }
    }
    #endif
    if (PyFloat_CheckExact(op1)) {
        const long b = intval;
        double a = PyFloat_AS_DOUBLE(op1);
            if ((double)a == (double)b) {
                Py_RETURN_TRUE;
            } else {
                Py_RETURN_FALSE;
            }
    }
    return PyObject_RichCompare(op1, op2, Py_EQ);
}
#endif

/* None */
      static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
    PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
}

/* PyObjectCallNoArg */
      #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
#ifdef __Pyx_CyFunction_USED
    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
#else
    if (likely(PyCFunction_Check(func))) {
#endif
        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
            return __Pyx_PyObject_CallMethO(func, NULL);
        }
    }
    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
}
#endif

/* PyIntBinop */
        #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
    #if PY_MAJOR_VERSION < 3
    if (likely(PyInt_CheckExact(op1))) {
        const long b = intval;
        long x;
        long a = PyInt_AS_LONG(op1);
            x = (long)((unsigned long)a + b);
            if (likely((x^a) >= 0 || (x^b) >= 0))
                return PyInt_FromLong(x);
            return PyLong_Type.tp_as_number->nb_add(op1, op2);
    }
    #endif
    #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3
    if (likely(PyLong_CheckExact(op1))) {
        const long b = intval;
        long a, x;
        const PY_LONG_LONG llb = intval;
        PY_LONG_LONG lla, llx;
        const digit* digits = ((PyLongObject*)op1)->ob_digit;
        const Py_ssize_t size = Py_SIZE(op1);
        if (likely(__Pyx_sst_abs(size) <= 1)) {
            a = likely(size) ? digits[0] : 0;
            if (size == -1) a = -a;
        } else {
            switch (size) {
                case -2:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case 2:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case -3:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case 3:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case -4:
                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case 4:
                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
            }
        }
                x = a + b;
            return PyLong_FromLong(x);
        long_long:
                llx = lla + llb;
            return PyLong_FromLongLong(llx);
    }
    #endif
    if (PyFloat_CheckExact(op1)) {
        const long b = intval;
        double a = PyFloat_AS_DOUBLE(op1);
            double result;
            PyFPE_START_PROTECT("add", return NULL)
            result = ((double)a) + (double)b;
            PyFPE_END_PROTECT(result)
            return PyFloat_FromDouble(result);
    }
    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
}
#endif

/* BufferFormatCheck */
        static CYTHON_INLINE int __Pyx_IsLittleEndian(void) {
  unsigned int n = 1;
  return *(unsigned char*)(&n) != 0;
}
static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
                              __Pyx_BufFmt_StackElem* stack,
                              __Pyx_TypeInfo* type) {
  stack[0].field = &ctx->root;
  stack[0].parent_offset = 0;
  ctx->root.type = type;
  ctx->root.name = "buffer dtype";
  ctx->root.offset = 0;
  ctx->head = stack;
  ctx->head->field = &ctx->root;
  ctx->fmt_offset = 0;
  ctx->head->parent_offset = 0;
  ctx->new_packmode = '@';
  ctx->enc_packmode = '@';
  ctx->new_count = 1;
  ctx->enc_count = 0;
  ctx->enc_type = 0;
  ctx->is_complex = 0;
  ctx->is_valid_array = 0;
  ctx->struct_alignment = 0;
  while (type->typegroup == 'S') {
    ++ctx->head;
    ctx->head->field = type->fields;
    ctx->head->parent_offset = 0;
    type = type->fields->type;
  }
}
static int __Pyx_BufFmt_ParseNumber(const char** ts) {
    int count;
    const char* t = *ts;
    if (*t < '0' || *t > '9') {
      return -1;
    } else {
        count = *t++ - '0';
        while (*t >= '0' && *t < '9') {
            count *= 10;
            count += *t++ - '0';
        }
    }
    *ts = t;
    return count;
}
static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
    int number = __Pyx_BufFmt_ParseNumber(ts);
    if (number == -1)
        PyErr_Format(PyExc_ValueError,\
                     "Does not understand character buffer dtype format string ('%c')", **ts);
    return number;
}
static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
  PyErr_Format(PyExc_ValueError,
               "Unexpected format string character: '%c'", ch);
}
static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
  switch (ch) {
    case 'c': return "'char'";
    case 'b': return "'signed char'";
    case 'B': return "'unsigned char'";
    case 'h': return "'short'";
    case 'H': return "'unsigned short'";
    case 'i': return "'int'";
    case 'I': return "'unsigned int'";
    case 'l': return "'long'";
    case 'L': return "'unsigned long'";
    case 'q': return "'long long'";
    case 'Q': return "'unsigned long long'";
    case 'f': return (is_complex ? "'complex float'" : "'float'");
    case 'd': return (is_complex ? "'complex double'" : "'double'");
    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
    case 'T': return "a struct";
    case 'O': return "Python object";
    case 'P': return "a pointer";
    case 's': case 'p': return "a string";
    case 0: return "end";
    default: return "unparseable format string";
  }
}
static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return 2;
    case 'i': case 'I': case 'l': case 'L': return 4;
    case 'q': case 'Q': return 8;
    case 'f': return (is_complex ? 8 : 4);
    case 'd': return (is_complex ? 16 : 8);
    case 'g': {
      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
      return 0;
    }
    case 'O': case 'P': return sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
  switch (ch) {
    case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(short);
    case 'i': case 'I': return sizeof(int);
    case 'l': case 'L': return sizeof(long);
    #ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
    #endif
    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
    case 'O': case 'P': return sizeof(void*);
    default: {
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
  }
}
typedef struct { char c; short x; } __Pyx_st_short;
typedef struct { char c; int x; } __Pyx_st_int;
typedef struct { char c; long x; } __Pyx_st_long;
typedef struct { char c; float x; } __Pyx_st_float;
typedef struct { char c; double x; } __Pyx_st_double;
typedef struct { char c; long double x; } __Pyx_st_longdouble;
typedef struct { char c; void *x; } __Pyx_st_void_p;
#ifdef HAVE_LONG_LONG
typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
#endif
static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
#ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
#endif
    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
/* These are for computing the padding at the end of the struct to align
   on the first member of the struct. This will probably the same as above,
   but we don't have any guarantees.
 */
typedef struct { short x; char c; } __Pyx_pad_short;
typedef struct { int x; char c; } __Pyx_pad_int;
typedef struct { long x; char c; } __Pyx_pad_long;
typedef struct { float x; char c; } __Pyx_pad_float;
typedef struct { double x; char c; } __Pyx_pad_double;
typedef struct { long double x; char c; } __Pyx_pad_longdouble;
typedef struct { void *x; char c; } __Pyx_pad_void_p;
#ifdef HAVE_LONG_LONG
typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
#endif
static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
  switch (ch) {
    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
#ifdef HAVE_LONG_LONG
    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
#endif
    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
    default:
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
}
static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
  switch (ch) {
    case 'c':
        return 'H';
    case 'b': case 'h': case 'i':
    case 'l': case 'q': case 's': case 'p':
        return 'I';
    case 'B': case 'H': case 'I': case 'L': case 'Q':
        return 'U';
    case 'f': case 'd': case 'g':
        return (is_complex ? 'C' : 'R');
    case 'O':
        return 'O';
    case 'P':
        return 'P';
    default: {
      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
      return 0;
    }
  }
}
static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
    const char* expected;
    const char* quote;
    if (ctx->head == NULL) {
      expected = "end";
      quote = "";
    } else {
      expected = ctx->head->field->type->name;
      quote = "'";
    }
    PyErr_Format(PyExc_ValueError,
                 "Buffer dtype mismatch, expected %s%s%s but got %s",
                 quote, expected, quote,
                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
  } else {
    __Pyx_StructField* field = ctx->head->field;
    __Pyx_StructField* parent = (ctx->head - 1)->field;
    PyErr_Format(PyExc_ValueError,
                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
                 parent->type->name, field->name);
  }
}
static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
  char group;
  size_t size, offset, arraysize = 1;
  if (ctx->enc_type == 0) return 0;
  if (ctx->head->field->type->arraysize[0]) {
    int i, ndim = 0;
    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
        ndim = 1;
        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
            PyErr_Format(PyExc_ValueError,
                         "Expected a dimension of size %zu, got %zu",
                         ctx->head->field->type->arraysize[0], ctx->enc_count);
            return -1;
        }
    }
    if (!ctx->is_valid_array) {
      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
                   ctx->head->field->type->ndim, ndim);
      return -1;
    }
    for (i = 0; i < ctx->head->field->type->ndim; i++) {
      arraysize *= ctx->head->field->type->arraysize[i];
    }
    ctx->is_valid_array = 0;
    ctx->enc_count = 1;
  }
  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
  do {
    __Pyx_StructField* field = ctx->head->field;
    __Pyx_TypeInfo* type = field->type;
    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
    } else {
      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
    }
    if (ctx->enc_packmode == '@') {
      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
      size_t align_mod_offset;
      if (align_at == 0) return -1;
      align_mod_offset = ctx->fmt_offset % align_at;
      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
      if (ctx->struct_alignment == 0)
          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
                                                                 ctx->is_complex);
    }
    if (type->size != size || type->typegroup != group) {
      if (type->typegroup == 'C' && type->fields != NULL) {
        size_t parent_offset = ctx->head->parent_offset + field->offset;
        ++ctx->head;
        ctx->head->field = type->fields;
        ctx->head->parent_offset = parent_offset;
        continue;
      }
      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
      } else {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return -1;
      }
    }
    offset = ctx->head->parent_offset + field->offset;
    if (ctx->fmt_offset != offset) {
      PyErr_Format(PyExc_ValueError,
                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
      return -1;
    }
    ctx->fmt_offset += size;
    if (arraysize)
      ctx->fmt_offset += (arraysize - 1) * size;
    --ctx->enc_count;
    while (1) {
      if (field == &ctx->root) {
        ctx->head = NULL;
        if (ctx->enc_count != 0) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return -1;
        }
        break;
      }
      ctx->head->field = ++field;
      if (field->type == NULL) {
        --ctx->head;
        field = ctx->head->field;
        continue;
      } else if (field->type->typegroup == 'S') {
        size_t parent_offset = ctx->head->parent_offset + field->offset;
        if (field->type->fields->type == NULL) continue;
        field = field->type->fields;
        ++ctx->head;
        ctx->head->field = field;
        ctx->head->parent_offset = parent_offset;
        break;
      } else {
        break;
      }
    }
  } while (ctx->enc_count);
  ctx->enc_type = 0;
  ctx->is_complex = 0;
  return 0;
}
static CYTHON_INLINE PyObject *
__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
{
    const char *ts = *tsp;
    int i = 0, number;
    int ndim = ctx->head->field->type->ndim;
;
    ++ts;
    if (ctx->new_count != 1) {
        PyErr_SetString(PyExc_ValueError,
                        "Cannot handle repeated arrays in format string");
        return NULL;
    }
    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
    while (*ts && *ts != ')') {
        switch (*ts) {
            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
            default:  break;
        }
        number = __Pyx_BufFmt_ExpectNumber(&ts);
        if (number == -1) return NULL;
        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
            return PyErr_Format(PyExc_ValueError,
                        "Expected a dimension of size %zu, got %d",
                        ctx->head->field->type->arraysize[i], number);
        if (*ts != ',' && *ts != ')')
            return PyErr_Format(PyExc_ValueError,
                                "Expected a comma in format string, got '%c'", *ts);
        if (*ts == ',') ts++;
        i++;
    }
    if (i != ndim)
        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
                            ctx->head->field->type->ndim, i);
    if (!*ts) {
        PyErr_SetString(PyExc_ValueError,
                        "Unexpected end of format string, expected ')'");
        return NULL;
    }
    ctx->is_valid_array = 1;
    ctx->new_count = 1;
    *tsp = ++ts;
    return Py_None;
}
static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
  int got_Z = 0;
  while (1) {
    switch(*ts) {
      case 0:
        if (ctx->enc_type != 0 && ctx->head == NULL) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return NULL;
        }
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        if (ctx->head != NULL) {
          __Pyx_BufFmt_RaiseExpected(ctx);
          return NULL;
        }
        return ts;
      case ' ':
      case '\r':
      case '\n':
        ++ts;
        break;
      case '<':
        if (!__Pyx_IsLittleEndian()) {
          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
          return NULL;
        }
        ctx->new_packmode = '=';
        ++ts;
        break;
      case '>':
      case '!':
        if (__Pyx_IsLittleEndian()) {
          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
          return NULL;
        }
        ctx->new_packmode = '=';
        ++ts;
        break;
      case '=':
      case '@':
      case '^':
        ctx->new_packmode = *ts++;
        break;
      case 'T':
        {
          const char* ts_after_sub;
          size_t i, struct_count = ctx->new_count;
          size_t struct_alignment = ctx->struct_alignment;
          ctx->new_count = 1;
          ++ts;
          if (*ts != '{') {
            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
            return NULL;
          }
          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
          ctx->enc_type = 0;
          ctx->enc_count = 0;
          ctx->struct_alignment = 0;
          ++ts;
          ts_after_sub = ts;
          for (i = 0; i != struct_count; ++i) {
            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
            if (!ts_after_sub) return NULL;
          }
          ts = ts_after_sub;
          if (struct_alignment) ctx->struct_alignment = struct_alignment;
        }
        break;
      case '}':
        {
          size_t alignment = ctx->struct_alignment;
          ++ts;
          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
          ctx->enc_type = 0;
          if (alignment && ctx->fmt_offset % alignment) {
            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
          }
        }
        return ts;
      case 'x':
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        ctx->fmt_offset += ctx->new_count;
        ctx->new_count = 1;
        ctx->enc_count = 0;
        ctx->enc_type = 0;
        ctx->enc_packmode = ctx->new_packmode;
        ++ts;
        break;
      case 'Z':
        got_Z = 1;
        ++ts;
        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
          return NULL;
        }
      case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
      case 'l': case 'L': case 'q': case 'Q':
      case 'f': case 'd': case 'g':
      case 'O': case 'p':
        if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&
            ctx->enc_packmode == ctx->new_packmode) {
          ctx->enc_count += ctx->new_count;
          ctx->new_count = 1;
          got_Z = 0;
          ++ts;
          break;
        }
      case 's':
        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
        ctx->enc_count = ctx->new_count;
        ctx->enc_packmode = ctx->new_packmode;
        ctx->enc_type = *ts;
        ctx->is_complex = got_Z;
        ++ts;
        ctx->new_count = 1;
        got_Z = 0;
        break;
      case ':':
        ++ts;
        while(*ts != ':') ++ts;
        ++ts;
        break;
      case '(':
        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
        break;
      default:
        {
          int number = __Pyx_BufFmt_ExpectNumber(&ts);
          if (number == -1) return NULL;
          ctx->new_count = (size_t)number;
        }
    }
  }
}
static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
  buf->buf = NULL;
  buf->obj = NULL;
  buf->strides = __Pyx_zeros;
  buf->shape = __Pyx_zeros;
  buf->suboffsets = __Pyx_minusones;
}
static CYTHON_INLINE int __Pyx_GetBufferAndValidate(
        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
{
  if (obj == Py_None || obj == NULL) {
    __Pyx_ZeroBuffer(buf);
    return 0;
  }
  buf->buf = NULL;
  if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail;
  if (buf->ndim != nd) {
    PyErr_Format(PyExc_ValueError,
                 "Buffer has wrong number of dimensions (expected %d, got %d)",
                 nd, buf->ndim);
    goto fail;
  }
  if (!cast) {
    __Pyx_BufFmt_Context ctx;
    __Pyx_BufFmt_Init(&ctx, stack, dtype);
    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
  }
  if ((unsigned)buf->itemsize != dtype->size) {
    PyErr_Format(PyExc_ValueError,
      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
    goto fail;
  }
  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
  return 0;
fail:;
  __Pyx_ZeroBuffer(buf);
  return -1;
}
static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
  if (info->buf == NULL) return;
  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
  __Pyx_ReleaseBuffer(info);
}

/* BufferFallbackError */
          static void __Pyx_RaiseBufferFallbackError(void) {
  PyErr_SetString(PyExc_ValueError,
     "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!");
}

/* BufferIndexError */
          static void __Pyx_RaiseBufferIndexError(int axis) {
  PyErr_Format(PyExc_IndexError,
     "Out of bounds on buffer access (axis %d)", axis);
}

/* PyObjectCallMethod1 */
          static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
    PyObject *method, *result = NULL;
    method = __Pyx_PyObject_GetAttrStr(obj, method_name);
    if (unlikely(!method)) goto bad;
#if CYTHON_COMPILING_IN_CPYTHON
    if (likely(PyMethod_Check(method))) {
        PyObject *self = PyMethod_GET_SELF(method);
        if (likely(self)) {
            PyObject *args;
            PyObject *function = PyMethod_GET_FUNCTION(method);
            args = PyTuple_New(2);
            if (unlikely(!args)) goto bad;
            Py_INCREF(self);
            PyTuple_SET_ITEM(args, 0, self);
            Py_INCREF(arg);
            PyTuple_SET_ITEM(args, 1, arg);
            Py_INCREF(function);
            Py_DECREF(method); method = NULL;
            result = __Pyx_PyObject_Call(function, args, NULL);
            Py_DECREF(args);
            Py_DECREF(function);
            return result;
        }
    }
#endif
    result = __Pyx_PyObject_CallOneArg(method, arg);
bad:
    Py_XDECREF(method);
    return result;
}

/* append */
          static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
    if (likely(PyList_CheckExact(L))) {
        if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1;
    } else {
        PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x);
        if (unlikely(!retval))
            return -1;
        Py_DECREF(retval);
    }
    return 0;
}

/* None */
          static CYTHON_INLINE long __Pyx_div_long(long a, long b) {
    long q = a / b;
    long r = a - q*b;
    q -= ((r != 0) & ((r ^ b) < 0));
    return q;
}

/* WriteUnraisableException */
          static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
                                  CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
                                  int full_traceback, CYTHON_UNUSED int nogil) {
    PyObject *old_exc, *old_val, *old_tb;
    PyObject *ctx;
    __Pyx_PyThreadState_declare
#ifdef WITH_THREAD
    PyGILState_STATE state;
    if (nogil)
        state = PyGILState_Ensure();
#ifdef _MSC_VER
    else state = (PyGILState_STATE)-1;
#endif
#endif
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
    if (full_traceback) {
        Py_XINCREF(old_exc);
        Py_XINCREF(old_val);
        Py_XINCREF(old_tb);
        __Pyx_ErrRestore(old_exc, old_val, old_tb);
        PyErr_PrintEx(1);
    }
    #if PY_MAJOR_VERSION < 3
    ctx = PyString_FromString(name);
    #else
    ctx = PyUnicode_FromString(name);
    #endif
    __Pyx_ErrRestore(old_exc, old_val, old_tb);
    if (!ctx) {
        PyErr_WriteUnraisable(Py_None);
    } else {
        PyErr_WriteUnraisable(ctx);
        Py_DECREF(ctx);
    }
#ifdef WITH_THREAD
    if (nogil)
        PyGILState_Release(state);
#endif
}

/* PyIntBinop */
          #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_AddCObj(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
    #if PY_MAJOR_VERSION < 3
    if (likely(PyInt_CheckExact(op2))) {
        const long a = intval;
        long x;
        long b = PyInt_AS_LONG(op2);
            x = (long)((unsigned long)a + b);
            if (likely((x^a) >= 0 || (x^b) >= 0))
                return PyInt_FromLong(x);
            return PyLong_Type.tp_as_number->nb_add(op1, op2);
    }
    #endif
    #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3
    if (likely(PyLong_CheckExact(op2))) {
        const long a = intval;
        long b, x;
        const PY_LONG_LONG lla = intval;
        PY_LONG_LONG llb, llx;
        const digit* digits = ((PyLongObject*)op2)->ob_digit;
        const Py_ssize_t size = Py_SIZE(op2);
        if (likely(__Pyx_sst_abs(size) <= 1)) {
            b = likely(size) ? digits[0] : 0;
            if (size == -1) b = -b;
        } else {
            switch (size) {
                case -2:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        b = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
                        llb = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case 2:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        b = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
                        llb = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case -3:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        b = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
                        llb = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case 3:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        b = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
                        llb = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case -4:
                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                        b = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
                        llb = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                case 4:
                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                        b = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
                        break;
                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
                        llb = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
                        goto long_long;
                    }
                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
            }
        }
                x = a + b;
            return PyLong_FromLong(x);
        long_long:
                llx = lla + llb;
            return PyLong_FromLongLong(llx);
    }
    #endif
    if (PyFloat_CheckExact(op2)) {
        const long a = intval;
        double b = PyFloat_AS_DOUBLE(op2);
            double result;
            PyFPE_START_PROTECT("add", return NULL)
            result = ((double)a) + (double)b;
            PyFPE_END_PROTECT(result)
            return PyFloat_FromDouble(result);
    }
    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
}
#endif

/* ArgTypeTest */
          static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
    PyErr_Format(PyExc_TypeError,
        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
        name, type->tp_name, Py_TYPE(obj)->tp_name);
}
static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
    const char *name, int exact)
{
    if (unlikely(!type)) {
        PyErr_SetString(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (none_allowed && obj == Py_None) return 1;
    else if (exact) {
        if (likely(Py_TYPE(obj) == type)) return 1;
        #if PY_MAJOR_VERSION == 2
        else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
        #endif
    }
    else {
        if (likely(PyObject_TypeCheck(obj, type))) return 1;
    }
    __Pyx_RaiseArgumentTypeInvalid(name, obj, type);
    return 0;
}

/* RaiseNoneIterError */
          static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}

/* Import */
          static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
    #if PY_VERSION_HEX < 0x03030000
    PyObject *py_import;
    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
    if (!py_import)
        goto bad;
    #endif
    if (from_list)
        list = from_list;
    else {
        empty_list = PyList_New(0);
        if (!empty_list)
            goto bad;
        list = empty_list;
    }
    global_dict = PyModule_GetDict(__pyx_m);
    if (!global_dict)
        goto bad;
    empty_dict = PyDict_New();
    if (!empty_dict)
        goto bad;
    {
        #if PY_MAJOR_VERSION >= 3
        if (level == -1) {
            if (strchr(__Pyx_MODULE_NAME, '.')) {
                #if PY_VERSION_HEX < 0x03030000
                PyObject *py_level = PyInt_FromLong(1);
                if (!py_level)
                    goto bad;
                module = PyObject_CallFunctionObjArgs(py_import,
                    name, global_dict, empty_dict, list, py_level, NULL);
                Py_DECREF(py_level);
                #else
                module = PyImport_ImportModuleLevelObject(
                    name, global_dict, empty_dict, list, 1);
                #endif
                if (!module) {
                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
                        goto bad;
                    PyErr_Clear();
                }
            }
            level = 0;
        }
        #endif
        if (!module) {
            #if PY_VERSION_HEX < 0x03030000
            PyObject *py_level = PyInt_FromLong(level);
            if (!py_level)
                goto bad;
            module = PyObject_CallFunctionObjArgs(py_import,
                name, global_dict, empty_dict, list, py_level, NULL);
            Py_DECREF(py_level);
            #else
            module = PyImport_ImportModuleLevelObject(
                name, global_dict, empty_dict, list, level);
            #endif
        }
    }
bad:
    #if PY_VERSION_HEX < 0x03030000
    Py_XDECREF(py_import);
    #endif
    Py_XDECREF(empty_list);
    Py_XDECREF(empty_dict);
    return module;
}

/* ImportFrom */
          static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
        PyErr_Format(PyExc_ImportError,
        #if PY_MAJOR_VERSION < 3
            "cannot import name %.230s", PyString_AS_STRING(name));
        #else
            "cannot import name %S", name);
        #endif
    }
    return value;
}

/* CodeObjectCache */
          static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
    int start = 0, mid = 0, end = count - 1;
    if (end >= 0 && code_line > entries[end].code_line) {
        return count;
    }
    while (start < end) {
        mid = start + (end - start) / 2;
        if (code_line < entries[mid].code_line) {
            end = mid;
        } else if (code_line > entries[mid].code_line) {
             start = mid + 1;
        } else {
            return mid;
        }
    }
    if (code_line <= entries[mid].code_line) {
        return mid;
    } else {
        return mid + 1;
    }
}
static PyCodeObject *__pyx_find_code_object(int code_line) {
    PyCodeObject* code_object;
    int pos;
    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
        return NULL;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
        return NULL;
    }
    code_object = __pyx_code_cache.entries[pos].code_object;
    Py_INCREF(code_object);
    return code_object;
}
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
    int pos, i;
    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
    if (unlikely(!code_line)) {
        return;
    }
    if (unlikely(!entries)) {
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
        if (likely(entries)) {
            __pyx_code_cache.entries = entries;
            __pyx_code_cache.max_count = 64;
            __pyx_code_cache.count = 1;
            entries[0].code_line = code_line;
            entries[0].code_object = code_object;
            Py_INCREF(code_object);
        }
        return;
    }
    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
        PyCodeObject* tmp = entries[pos].code_object;
        entries[pos].code_object = code_object;
        Py_DECREF(tmp);
        return;
    }
    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
        int new_max = __pyx_code_cache.max_count + 64;
        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
            __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
        if (unlikely(!entries)) {
            return;
        }
        __pyx_code_cache.entries = entries;
        __pyx_code_cache.max_count = new_max;
    }
    for (i=__pyx_code_cache.count; i>pos; i--) {
        entries[i] = entries[i-1];
    }
    entries[pos].code_line = code_line;
    entries[pos].code_object = code_object;
    __pyx_code_cache.count++;
    Py_INCREF(code_object);
}

/* AddTraceback */
          #include "compile.h"
#include "frameobject.h"
#include "traceback.h"
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
            const char *funcname, int c_line,
            int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyObject *py_srcfile = 0;
    PyObject *py_funcname = 0;
    #if PY_MAJOR_VERSION < 3
    py_srcfile = PyString_FromString(filename);
    #else
    py_srcfile = PyUnicode_FromString(filename);
    #endif
    if (!py_srcfile) goto bad;
    if (c_line) {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #else
        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
        #endif
    }
    else {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromString(funcname);
        #else
        py_funcname = PyUnicode_FromString(funcname);
        #endif
    }
    if (!py_funcname) goto bad;
    py_code = __Pyx_PyCode_New(
        0,
        0,
        0,
        0,
        0,
        __pyx_empty_bytes, /*PyObject *code,*/
        __pyx_empty_tuple, /*PyObject *consts,*/
        __pyx_empty_tuple, /*PyObject *names,*/
        __pyx_empty_tuple, /*PyObject *varnames,*/
        __pyx_empty_tuple, /*PyObject *freevars,*/
        __pyx_empty_tuple, /*PyObject *cellvars,*/
        py_srcfile,   /*PyObject *filename,*/
        py_funcname,  /*PyObject *name,*/
        py_line,
        __pyx_empty_bytes  /*PyObject *lnotab*/
    );
    Py_DECREF(py_srcfile);
    Py_DECREF(py_funcname);
    return py_code;
bad:
    Py_XDECREF(py_srcfile);
    Py_XDECREF(py_funcname);
    return NULL;
}
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename) {
    PyCodeObject *py_code = 0;
    PyFrameObject *py_frame = 0;
    py_code = __pyx_find_code_object(c_line ? c_line : py_line);
    if (!py_code) {
        py_code = __Pyx_CreateCodeObjectForTraceback(
            funcname, c_line, py_line, filename);
        if (!py_code) goto bad;
        __pyx_insert_code_object(c_line ? c_line : py_line, py_code);
    }
    py_frame = PyFrame_New(
        PyThreadState_GET(), /*PyThreadState *tstate,*/
        py_code,             /*PyCodeObject *code,*/
        __pyx_d,      /*PyObject *globals,*/
        0                    /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    py_frame->f_lineno = py_line;
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}

#if PY_MAJOR_VERSION < 3
static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
    return -1;
}
static void __Pyx_ReleaseBuffer(Py_buffer *view) {
    PyObject *obj = view->obj;
    if (!obj) return;
    if (PyObject_CheckBuffer(obj)) {
        PyBuffer_Release(view);
        return;
    }
        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; }
    Py_DECREF(obj);
    view->obj = NULL;
}
#endif


          /* CIntToPy */
          static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
    const long neg_one = (long) -1, const_zero = (long) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(long) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(long) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(long),
                                     little, !is_unsigned);
    }
}

/* CIntFromPyVerify */
          #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
    {\
        func_type value = func_value;\
        if (sizeof(target_type) < sizeof(func_type)) {\
            if (unlikely(value != (func_type) (target_type) value)) {\
                func_type zero = 0;\
                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
                    return (target_type) -1;\
                if (is_unsigned && unlikely(value < zero))\
                    goto raise_neg_overflow;\
                else\
                    goto raise_overflow;\
            }\
        }\
        return (target_type) value;\
    }

/* CIntToPy */
          static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
    const int neg_one = (int) -1, const_zero = (int) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(int) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(int) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(int),
                                     little, !is_unsigned);
    }
}

/* None */
          #if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      return ::std::complex< double >(x, y);
    }
  #else
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      return x + y*(__pyx_t_double_complex)_Complex_I;
    }
  #endif
#else
    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
      __pyx_t_double_complex z;
      z.real = x;
      z.imag = y;
      return z;
    }
#endif

/* None */
          #if CYTHON_CCOMPLEX
#else
    static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) {
       return (a.real == b.real) && (a.imag == b.imag);
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real + b.real;
        z.imag = a.imag + b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real - b.real;
        z.imag = a.imag - b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        z.real = a.real * b.real - a.imag * b.imag;
        z.imag = a.real * b.imag + a.imag * b.real;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) {
        __pyx_t_double_complex z;
        double denom = b.real * b.real + b.imag * b.imag;
        z.real = (a.real * b.real + a.imag * b.imag) / denom;
        z.imag = (a.imag * b.real - a.real * b.imag) / denom;
        return z;
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) {
        __pyx_t_double_complex z;
        z.real = -a.real;
        z.imag = -a.imag;
        return z;
    }
    static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) {
       return (a.real == 0) && (a.imag == 0);
    }
    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) {
        __pyx_t_double_complex z;
        z.real =  a.real;
        z.imag = -a.imag;
        return z;
    }
    #if 1
        static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) {
          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
            return sqrt(z.real*z.real + z.imag*z.imag);
          #else
            return hypot(z.real, z.imag);
          #endif
        }
        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) {
            __pyx_t_double_complex z;
            double r, lnr, theta, z_r, z_theta;
            if (b.imag == 0 && b.real == (int)b.real) {
                if (b.real < 0) {
                    double denom = a.real * a.real + a.imag * a.imag;
                    a.real = a.real / denom;
                    a.imag = -a.imag / denom;
                    b.real = -b.real;
                }
                switch ((int)b.real) {
                    case 0:
                        z.real = 1;
                        z.imag = 0;
                        return z;
                    case 1:
                        return a;
                    case 2:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(a, a);
                    case 3:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(z, a);
                    case 4:
                        z = __Pyx_c_prod(a, a);
                        return __Pyx_c_prod(z, z);
                }
            }
            if (a.imag == 0) {
                if (a.real == 0) {
                    return a;
                }
                r = a.real;
                theta = 0;
            } else {
                r = __Pyx_c_abs(a);
                theta = atan2(a.imag, a.real);
            }
            lnr = log(r);
            z_r = exp(lnr * b.real - theta * b.imag);
            z_theta = theta * b.real + lnr * b.imag;
            z.real = z_r * cos(z_theta);
            z.imag = z_r * sin(z_theta);
            return z;
        }
    #endif
#endif

/* None */
          static CYTHON_INLINE long __Pyx_pow_long(long b, long e) {
    long t = b;
    switch (e) {
        case 3:
            t *= b;
        case 2:
            t *= b;
        case 1:
            return t;
        case 0:
            return 1;
    }
    #if 1
    if (unlikely(e<0)) return 0;
    #endif
    t = 1;
    while (likely(e)) {
        t *= (b * (e&1)) | ((~e)&1);
        b *= b;
        e >>= 1;
    }
    return t;
}

/* None */
          #if CYTHON_CCOMPLEX
  #ifdef __cplusplus
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      return ::std::complex< float >(x, y);
    }
  #else
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      return x + y*(__pyx_t_float_complex)_Complex_I;
    }
  #endif
#else
    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
      __pyx_t_float_complex z;
      z.real = x;
      z.imag = y;
      return z;
    }
#endif

/* None */
          #if CYTHON_CCOMPLEX
#else
    static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
       return (a.real == b.real) && (a.imag == b.imag);
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real + b.real;
        z.imag = a.imag + b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real - b.real;
        z.imag = a.imag - b.imag;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        z.real = a.real * b.real - a.imag * b.imag;
        z.imag = a.real * b.imag + a.imag * b.real;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
        __pyx_t_float_complex z;
        float denom = b.real * b.real + b.imag * b.imag;
        z.real = (a.real * b.real + a.imag * b.imag) / denom;
        z.imag = (a.imag * b.real - a.real * b.imag) / denom;
        return z;
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) {
        __pyx_t_float_complex z;
        z.real = -a.real;
        z.imag = -a.imag;
        return z;
    }
    static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) {
       return (a.real == 0) && (a.imag == 0);
    }
    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) {
        __pyx_t_float_complex z;
        z.real =  a.real;
        z.imag = -a.imag;
        return z;
    }
    #if 1
        static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) {
          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
            return sqrtf(z.real*z.real + z.imag*z.imag);
          #else
            return hypotf(z.real, z.imag);
          #endif
        }
        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) {
            __pyx_t_float_complex z;
            float r, lnr, theta, z_r, z_theta;
            if (b.imag == 0 && b.real == (int)b.real) {
                if (b.real < 0) {
                    float denom = a.real * a.real + a.imag * a.imag;
                    a.real = a.real / denom;
                    a.imag = -a.imag / denom;
                    b.real = -b.real;
                }
                switch ((int)b.real) {
                    case 0:
                        z.real = 1;
                        z.imag = 0;
                        return z;
                    case 1:
                        return a;
                    case 2:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(a, a);
                    case 3:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(z, a);
                    case 4:
                        z = __Pyx_c_prodf(a, a);
                        return __Pyx_c_prodf(z, z);
                }
            }
            if (a.imag == 0) {
                if (a.real == 0) {
                    return a;
                }
                r = a.real;
                theta = 0;
            } else {
                r = __Pyx_c_absf(a);
                theta = atan2f(a.imag, a.real);
            }
            lnr = logf(r);
            z_r = expf(lnr * b.real - theta * b.imag);
            z_theta = theta * b.real + lnr * b.imag;
            z.real = z_r * cosf(z_theta);
            z.imag = z_r * sinf(z_theta);
            return z;
        }
    #endif
#endif

/* CIntToPy */
          static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
    const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0;
    const int is_unsigned = neg_one > const_zero;
    if (is_unsigned) {
        if (sizeof(enum NPY_TYPES) < sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
            return PyLong_FromUnsignedLong((unsigned long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
        }
    } else {
        if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
            return PyInt_FromLong((long) value);
        } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
            return PyLong_FromLongLong((PY_LONG_LONG) value);
        }
    }
    {
        int one = 1; int little = (int)*(unsigned char *)&one;
        unsigned char *bytes = (unsigned char *)&value;
        return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
                                     little, !is_unsigned);
    }
}

/* CIntFromPy */
          static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
    const int neg_one = (int) -1, const_zero = (int) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(int) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (int) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int) 0;
                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
                case 2:
                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (int) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(int) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (int) 0;
                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(int) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            int val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (int) -1;
        }
    } else {
        int val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (int) -1;
        val = __Pyx_PyInt_As_int(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to int");
    return (int) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to int");
    return (int) -1;
}

/* CIntFromPy */
          static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
    const long neg_one = (long) -1, const_zero = (long) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(long) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (long) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (long) 0;
                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
                case 2:
                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (long) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(long) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (long) 0;
                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(long) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            long val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (long) -1;
        }
    } else {
        long val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (long) -1;
        val = __Pyx_PyInt_As_long(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to long");
    return (long) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to long");
    return (long) -1;
}

/* CIntFromPy */
          static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
    const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
    const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
    if (likely(PyInt_Check(x))) {
        if (sizeof(size_t) < sizeof(long)) {
            __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
        } else {
            long val = PyInt_AS_LONG(x);
            if (is_unsigned && unlikely(val < 0)) {
                goto raise_neg_overflow;
            }
            return (size_t) val;
        }
    } else
#endif
    if (likely(PyLong_Check(x))) {
        if (is_unsigned) {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (size_t) 0;
                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
                case 2:
                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
                            return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
                            return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
                            return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
                        }
                    }
                    break;
            }
#endif
#if CYTHON_COMPILING_IN_CPYTHON
            if (unlikely(Py_SIZE(x) < 0)) {
                goto raise_neg_overflow;
            }
#else
            {
                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
                if (unlikely(result < 0))
                    return (size_t) -1;
                if (unlikely(result == 1))
                    goto raise_neg_overflow;
            }
#endif
            if (sizeof(size_t) <= sizeof(unsigned long)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
            }
        } else {
#if CYTHON_USE_PYLONG_INTERNALS
            const digit* digits = ((PyLongObject*)x)->ob_digit;
            switch (Py_SIZE(x)) {
                case  0: return (size_t) 0;
                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
                case -2:
                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 2:
                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                            return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case -3:
                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 3:
                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                            return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case -4:
                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
                            return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
                case 4:
                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
                            return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
                        }
                    }
                    break;
            }
#endif
            if (sizeof(size_t) <= sizeof(long)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
            }
        }
        {
#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
            PyErr_SetString(PyExc_RuntimeError,
                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
            size_t val;
            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
 #if PY_MAJOR_VERSION < 3
            if (likely(v) && !PyLong_Check(v)) {
                PyObject *tmp = v;
                v = PyNumber_Long(tmp);
                Py_DECREF(tmp);
            }
 #endif
            if (likely(v)) {
                int one = 1; int is_little = (int)*(unsigned char *)&one;
                unsigned char *bytes = (unsigned char *)&val;
                int ret = _PyLong_AsByteArray((PyLongObject *)v,
                                              bytes, sizeof(val),
                                              is_little, !is_unsigned);
                Py_DECREF(v);
                if (likely(!ret))
                    return val;
            }
#endif
            return (size_t) -1;
        }
    } else {
        size_t val;
        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
        if (!tmp) return (size_t) -1;
        val = __Pyx_PyInt_As_size_t(tmp);
        Py_DECREF(tmp);
        return val;
    }
raise_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "value too large to convert to size_t");
    return (size_t) -1;
raise_neg_overflow:
    PyErr_SetString(PyExc_OverflowError,
        "can't convert negative value to size_t");
    return (size_t) -1;
}

/* CheckBinaryVersion */
          static int __Pyx_check_binary_version(void) {
    char ctversion[4], rtversion[4];
    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
        char message[200];
        PyOS_snprintf(message, sizeof(message),
                      "compiletime version %s of module '%.100s' "
                      "does not match runtime version %s",
                      ctversion, __Pyx_MODULE_NAME, rtversion);
        return PyErr_WarnEx(NULL, message, 1);
    }
    return 0;
}

/* ModuleImport */
          #ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
    PyObject *py_name = 0;
    PyObject *py_module = 0;
    py_name = __Pyx_PyIdentifier_FromString(name);
    if (!py_name)
        goto bad;
    py_module = PyImport_Import(py_name);
    Py_DECREF(py_name);
    return py_module;
bad:
    Py_XDECREF(py_name);
    return 0;
}
#endif

/* TypeImport */
          #ifndef __PYX_HAVE_RT_ImportType
#define __PYX_HAVE_RT_ImportType
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
    size_t size, int strict)
{
    PyObject *py_module = 0;
    PyObject *result = 0;
    PyObject *py_name = 0;
    char warning[200];
    Py_ssize_t basicsize;
#ifdef Py_LIMITED_API
    PyObject *py_basicsize;
#endif
    py_module = __Pyx_ImportModule(module_name);
    if (!py_module)
        goto bad;
    py_name = __Pyx_PyIdentifier_FromString(class_name);
    if (!py_name)
        goto bad;
    result = PyObject_GetAttr(py_module, py_name);
    Py_DECREF(py_name);
    py_name = 0;
    Py_DECREF(py_module);
    py_module = 0;
    if (!result)
        goto bad;
    if (!PyType_Check(result)) {
        PyErr_Format(PyExc_TypeError,
            "%.200s.%.200s is not a type object",
            module_name, class_name);
        goto bad;
    }
#ifndef Py_LIMITED_API
    basicsize = ((PyTypeObject *)result)->tp_basicsize;
#else
    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
    if (!py_basicsize)
        goto bad;
    basicsize = PyLong_AsSsize_t(py_basicsize);
    Py_DECREF(py_basicsize);
    py_basicsize = 0;
    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
        goto bad;
#endif
    if (!strict && (size_t)basicsize > size) {
        PyOS_snprintf(warning, sizeof(warning),
            "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd",
            module_name, class_name, basicsize, size);
        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
    }
    else if ((size_t)basicsize != size) {
        PyErr_Format(PyExc_ValueError,
            "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd",
            module_name, class_name, basicsize, size);
        goto bad;
    }
    return (PyTypeObject *)result;
bad:
    Py_XDECREF(py_module);
    Py_XDECREF(result);
    return NULL;
}
#endif

/* InitStrings */
          static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
    while (t->p) {
        #if PY_MAJOR_VERSION < 3
        if (t->is_unicode) {
            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
        } else if (t->intern) {
            *t->p = PyString_InternFromString(t->s);
        } else {
            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
        }
        #else
        if (t->is_unicode | t->is_str) {
            if (t->intern) {
                *t->p = PyUnicode_InternFromString(t->s);
            } else if (t->encoding) {
                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
            } else {
                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
            }
        } else {
            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
        }
        #endif
        if (!*t->p)
            return -1;
        ++t;
    }
    return 0;
}

static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
}
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {
    Py_ssize_t ignore;
    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
}
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
    if (
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
            __Pyx_sys_getdefaultencoding_not_ascii &&
#endif
            PyUnicode_Check(o)) {
#if PY_VERSION_HEX < 0x03030000
        char* defenc_c;
        PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
        if (!defenc) return NULL;
        defenc_c = PyBytes_AS_STRING(defenc);
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        {
            char* end = defenc_c + PyBytes_GET_SIZE(defenc);
            char* c;
            for (c = defenc_c; c < end; c++) {
                if ((unsigned char) (*c) >= 128) {
                    PyUnicode_AsASCIIString(o);
                    return NULL;
                }
            }
        }
#endif
        *length = PyBytes_GET_SIZE(defenc);
        return defenc_c;
#else
        if (__Pyx_PyUnicode_READY(o) == -1) return NULL;
#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
        if (PyUnicode_IS_ASCII(o)) {
            *length = PyUnicode_GET_LENGTH(o);
            return PyUnicode_AsUTF8(o);
        } else {
            PyUnicode_AsASCIIString(o);
            return NULL;
        }
#else
        return PyUnicode_AsUTF8AndSize(o, length);
#endif
#endif
    } else
#endif
#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
    if (PyByteArray_Check(o)) {
        *length = PyByteArray_GET_SIZE(o);
        return PyByteArray_AS_STRING(o);
    } else
#endif
    {
        char* result;
        int r = PyBytes_AsStringAndSize(o, &result, length);
        if (unlikely(r < 0)) {
            return NULL;
        } else {
            return result;
        }
    }
}
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
   int is_true = x == Py_True;
   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
   else return PyObject_IsTrue(x);
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
  PyNumberMethods *m;
  const char *name = NULL;
  PyObject *res = NULL;
#if PY_MAJOR_VERSION < 3
  if (PyInt_Check(x) || PyLong_Check(x))
#else
  if (PyLong_Check(x))
#endif
    return __Pyx_NewRef(x);
  m = Py_TYPE(x)->tp_as_number;
#if PY_MAJOR_VERSION < 3
  if (m && m->nb_int) {
    name = "int";
    res = PyNumber_Int(x);
  }
  else if (m && m->nb_long) {
    name = "long";
    res = PyNumber_Long(x);
  }
#else
  if (m && m->nb_int) {
    name = "int";
    res = PyNumber_Long(x);
  }
#endif
  if (res) {
#if PY_MAJOR_VERSION < 3
    if (!PyInt_Check(res) && !PyLong_Check(res)) {
#else
    if (!PyLong_Check(res)) {
#endif
      PyErr_Format(PyExc_TypeError,
                   "__%.4s__ returned non-%.4s (type %.200s)",
                   name, name, Py_TYPE(res)->tp_name);
      Py_DECREF(res);
      return NULL;
    }
  }
  else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_TypeError,
                    "an integer is required");
  }
  return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
  Py_ssize_t ival;
  PyObject *x;
#if PY_MAJOR_VERSION < 3
  if (likely(PyInt_CheckExact(b))) {
    if (sizeof(Py_ssize_t) >= sizeof(long))
        return PyInt_AS_LONG(b);
    else
        return PyInt_AsSsize_t(x);
  }
#endif
  if (likely(PyLong_CheckExact(b))) {
    #if CYTHON_USE_PYLONG_INTERNALS
    const digit* digits = ((PyLongObject*)b)->ob_digit;
    const Py_ssize_t size = Py_SIZE(b);
    if (likely(__Pyx_sst_abs(size) <= 1)) {
        ival = likely(size) ? digits[0] : 0;
        if (size == -1) ival = -ival;
        return ival;
    } else {
      switch (size) {
         case 2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -2:
           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -3:
           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case 4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
         case -4:
           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
           }
           break;
      }
    }
    #endif
    return PyLong_AsSsize_t(b);
  }
  x = PyNumber_Index(b);
  if (!x) return -1;
  ival = PyInt_AsSsize_t(x);
  Py_DECREF(x);
  return ival;
}
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
    return PyInt_FromSize_t(ival);
}


#endif /* Py_PYTHON_H */
healpy-1.10.3/healpy/src/_sphtools.pyx0000664000175000017500000004606213010374155020162 0ustar  zoncazonca00000000000000# coding: utf-8
# Wrapper around the query_disc method of Healpix_base class

import numpy as np
cimport numpy as np
from libcpp.string cimport string
from libc.math cimport sqrt, floor, fabs
cimport libc
from healpy import npix2nside, nside2npix
from healpy.pixelfunc import maptype
import os
import cython
from libcpp cimport bool as cbool

from _common cimport tsize, arr, xcomplex, Healpix_Ordering_Scheme, RING, NEST, Healpix_Map, Alm, ndarray2map, ndarray2alm

cdef double UNSEEN = -1.6375e30
cdef double rtol_UNSEEN = 1.e-7 * 1.6375e30

cdef extern from "alm_healpix_tools.h":
    cdef void map2alm_iter(Healpix_Map[double] &m,
                           Alm[xcomplex[double]] &alm,
                           int num_iter, arr[double] &weight)
    cdef void map2alm_pol_iter(Healpix_Map[double] &mapT,
                               Healpix_Map[double] &mapQ,
                               Healpix_Map[double] &mapU,
                               Alm[xcomplex[double]] &almT,
                               Alm[xcomplex[double]] &almG,
                               Alm[xcomplex[double]] &almC,
                               int num_iter,
                               arr[double] &weight)
    cdef void map2alm_spin(    Healpix_Map[double] &map1, 
                               Healpix_Map[double] &map2,
                               Alm[xcomplex[double]] &alm1, 
                               Alm[xcomplex[double]] &alm2, 
                               int spin, 
                               arr[double] &weight, 
                               cbool add_alm)
    cdef void alm2map_spin(    Alm[xcomplex[double]] &alm1, 
                               Alm[xcomplex[double]] &alm2, 
                               Healpix_Map[double] &map1, 
                               Healpix_Map[double] &map2,
                               int spin) 

cdef extern from "alm_powspec_tools.h":
    cdef void c_rotate_alm "rotate_alm" (Alm[xcomplex[double]] &alm, double psi, double theta, double phi)
    cdef void c_rotate_alm "rotate_alm" (Alm[xcomplex[double]] &ai, Alm[xcomplex[double]] &ag, Alm[xcomplex[double]] &ac, double psi, double theta, double phi)

cdef extern from "healpix_data_io.h":
    cdef void read_weight_ring (string &dir, int nside, arr[double] &weight)

DATAPATH = None

def get_datapath():
    global DATAPATH
    if DATAPATH is None:
        DATAPATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')
    return DATAPATH

def map2alm_spin_healpy(maps, spin, lmax = None, mmax = None):
    """Computes the spinned alm of a 2 Healpix maps.

    Parameters
    ----------
    m : list of 2 arrays
        list of 2 input maps as numpy arrays
    spin : int
        spin of the alms (either 1, 2 or 3)
    lmax : int, scalar, optional
      Maximum l of the power spectrum. Default: 3*nside-1
    mmax : int, scalar, optional
      Maximum m of the alm. Default: lmax
    
    Returns
    -------
    alms : list of 2 arrays
      list of 2 alms
    """
    maps_c = [np.ascontiguousarray(m, dtype=np.float64) for m in maps]

    # create UNSEEN mask for map
    masks = [False if count_bad(m) == 0 else mkmask(m) for m in maps_c]

    # Adjust lmax and mmax
    cdef int lmax_, mmax_, nside, npix
    npix = maps_c[0].size
    nside = npix2nside(npix)
    if lmax is None:
        lmax_ = 3 * nside - 1
    else:
        lmax_ = lmax
    if mmax is None:
        mmax_ = lmax_
    else:
        mmax_ = mmax

    # Check all maps have same npix
    if maps_c[1].size != npix:
        raise ValueError("Input maps must have same size")
    
    # View the ndarray as a Healpix_Map
    M1 = ndarray2map(maps_c[0], RING)
    M2 = ndarray2map(maps_c[1], RING)

    # replace UNSEEN pixels with zeros
    for m, mask in zip(maps_c, masks):
        if mask:
            m[mask] = 0.0

    # Create an ndarray object that will contain the alm for output (to be returned)
    n_alm = alm_getn(lmax_, mmax_)
    alms = [np.empty(n_alm, dtype=np.complex128) for m in maps]

    # View the ndarray as an Alm
    # Alms = [ndarray2alm(alm, lmax_, mmax_) for alm in alms]
    A1 = ndarray2alm(alms[0], lmax_, mmax_) 
    A2 = ndarray2alm(alms[1], lmax_, mmax_) 
    
    # ring weights
    cdef arr[double] * w_arr = new arr[double]()
    cdef int i
    cdef char *c_datapath
    w_arr.allocAndFill(2 * nside, 1.)
    
    map2alm_spin(M1[0], M2[0], A1[0], A2[0], spin, w_arr[0], False)
    
    # restore input map with UNSEEN pixels
    for m, mask in zip(maps_c, masks):
        if mask:
            m[mask] = UNSEEN

    del w_arr
    del M1, M2, A1, A2
    return alms

def alm2map_spin_healpy(alms, nside, spin, lmax, mmax=None):
    """Computes maps from a set of 2 spinned alm

    Parameters
    ----------
    alms : list of 2 arrays
      list of 2 alms
    nside : int
        requested nside of the output map 
    spin : int
        spin of the alms (either 1, 2 or 3)
    lmax : int, scalar
      Maximum l of the power spectrum.
    mmax : int, scalar, optional
      Maximum m of the alm. Default: lmax
    
    Returns
    -------
    m : list of 2 arrays
        list of 2 out maps in RING scheme as numpy arrays
    """
    alms_c = [np.ascontiguousarray(alm, dtype=np.complex128) for alm in alms]

    npix = nside2npix(nside)
    maps = [np.zeros(npix, dtype=np.float64) for alm in alms]

    # View the ndarray as a Healpix_Map
    M1 = ndarray2map(maps[0], RING)
    M2 = ndarray2map(maps[1], RING)

    if not mmax:
        mmax = lmax

    # View the ndarray as an Alm
    A1 = ndarray2alm(alms_c[0], lmax, mmax) 
    A2 = ndarray2alm(alms_c[1], lmax, mmax) 
    
    alm2map_spin(A1[0], A2[0], M1[0], M2[0], spin)
    
    del M1, M2, A1, A2
    return maps

def map2alm(m, lmax = None, mmax = None, niter = 3, use_weights = False, 
            datapath = None):
    """Computes the alm of a Healpix map.

    Parameters
    ----------
    m : array-like, shape (Npix,) or (3, Npix)
      The input map or a list of 3 input maps (polariztion).
    lmax : int, scalar, optional
      Maximum l of the power spectrum. Default: 3*nside-1
    mmax : int, scalar, optional
      Maximum m of the alm. Default: lmax
    iter : int, scalar, optional
      Number of iteration (default: 1)
    use_weights: bool, scalar, optional
      If True, use the ring weighting. Default: False.
    
    Returns
    -------
    alm : array or tuple of arrays
      alm or a tuple of 3 alm (almT, almE, almB) if polarized input.
    """
    # Check if the input map is polarized or not
    info = maptype(m)
    if info == 0:
        polarization = False
        mi = np.ascontiguousarray(m, dtype=np.float64)
    elif info == 1:
        polarization = False
        mi = np.ascontiguousarray(m[0], dtype=np.float64)
    elif info == 3:
        polarization = True
        mi = np.ascontiguousarray(m[0], dtype=np.float64)
        mq = np.ascontiguousarray(m[1], dtype=np.float64)
        mu = np.ascontiguousarray(m[2], dtype=np.float64)
    else:
        raise ValueError("Wrong input map (must be a valid healpix map "
                         "or a sequence of 1 or 3 maps)")

    # create UNSEEN mask for I map
    mask_mi = False if count_bad(mi) == 0 else mkmask(mi)
    # same for polarization maps if needed
    if polarization:
        mask_mq = False if count_bad(mq) == 0 else mkmask(mq)
        mask_mu = False if count_bad(mu) == 0 else mkmask(mu)

    # Adjust lmax and mmax
    cdef int lmax_, mmax_, nside, npix
    npix = mi.size
    nside = npix2nside(npix)
    if lmax is None:
        lmax_ = 3 * nside - 1
    else:
        lmax_ = lmax
    if mmax is None:
        mmax_ = lmax_
    else:
        mmax_ = mmax

    # Check all maps have same npix
    if polarization:
        if mq.size != npix or mu.size != npix:
            raise ValueError("Input maps must have same size")
    
    # View the ndarray as a Healpix_Map
    MI = ndarray2map(mi, RING)
    if polarization:
        MQ = ndarray2map(mq, RING)
        MU = ndarray2map(mu, RING)

    # replace UNSEEN pixels with zeros
    if mask_mi is not False:
        mi[mask_mi] = 0.0
    if polarization:
        if mask_mq is not False:
            mq[mask_mq] = 0.0
        if mask_mu is not False:
            mu[mask_mu] = 0.0


    # Create an ndarray object that will contain the alm for output (to be returned)
    n_alm = alm_getn(lmax_, mmax_)
    almI = np.empty(n_alm, dtype=np.complex128)
    if polarization:
        almG = np.empty(n_alm, dtype=np.complex128)
        almC = np.empty(n_alm, dtype=np.complex128)

    # View the ndarray as an Alm
    AI = ndarray2alm(almI, lmax_, mmax_)
    if polarization:
        AG = ndarray2alm(almG, lmax_, mmax_)
        AC = ndarray2alm(almC, lmax_, mmax_)
    
    # ring weights
    cdef arr[double] * w_arr = new arr[double]()
    cdef int i
    cdef char *c_datapath
    if use_weights:
        if datapath is None:
            datapath = get_datapath()
        c_datapath = datapath
        weightfile = 'weight_ring_n%05d.fits' % (nside)
        if not os.path.isfile(os.path.join(datapath, weightfile)):
            raise IOError('Weight file not found in %s' % (datapath))
        read_weight_ring(string(c_datapath), nside, w_arr[0])
        for i in range(w_arr.size()):
            w_arr[0][i] += 1
    else:
        w_arr.allocAndFill(2 * nside, 1.)
    
    if polarization:
        map2alm_pol_iter(MI[0], MQ[0], MU[0], AI[0], AG[0], AC[0], niter, w_arr[0])
    else:
        map2alm_iter(MI[0], AI[0], niter, w_arr[0])
    
    # restore input map with UNSEEN pixels
    if mask_mi is not False:
        mi[mask_mi] = UNSEEN
    if polarization:
        if mask_mq is not False:
            mq[mask_mq] = UNSEEN
        if mask_mu is not False:
            mu[mask_mu] = UNSEEN
    
    del w_arr
    if polarization:
        del MI, MQ, MU, AI, AG, AC
        return almI, almG, almC
    else:
        del MI, AI
        return almI


def alm2cl(alms, alms2 = None, lmax = None, mmax = None, lmax_out = None):
    """Computes (cross-)spectra from alm(s). If alm2 is given, cross-spectra between
    alm and alm2 are computed. If alm (and alm2 if provided) contains n alm,
    then n(n+1)/2 auto and cross-spectra are returned.

    Parameters
    ----------
    alms : complex, array or sequence of arrays
      The alm from which to compute the power spectrum. If n>=2 arrays are given,
      computes both auto- and cross-spectra.
    alms2 : complex, array or sequence of 3 arrays, optional
      If provided, computes cross-spectra between alm and alm2.
      Default: alm2=alm, so auto-spectra are computed.
    lmax : None or int, optional
      The maximum l of the input alm. Default: computed from size of alm
      and mmax_in
    mmax : None or int, optional
      The maximum m of the input alm. Default: assume mmax_in = lmax_in
    lmax_out : None or int, optional
      The maximum l of the returned spectra. By default: the lmax of the given
      alm(s).

    Returns
    -------
    cl : array or tuple of n(n+1)/2 arrays
      the spectrum <*alm* x *alm2*> if *alm* (and *alm2*) is one alm, or 
      the auto- and cross-spectra <*alm*[i] x *alm2*[j]> if alm (and alm2)
      contains more than one spectra.
      If more than one spectrum is returned, they are ordered by diagonal.
      For example, if *alm* is almT, almE, almB, then the returned spectra are:
      TT, EE, BB, TE, EB, TB.
    """
    #############################
    # Check alm and number of spectra
    #
    cdef int Nspec, Nspec2
    if not hasattr(alms, '__len__'):
        raise ValueError('alms must be an array or a sequence of arrays')
    if not hasattr(alms[0], '__len__'):
        alms_lonely = True
        alms = [alms]
    else:
        alms_lonely = False

    Nspec = len(alms)

    if alms2 is None:
        alms2 = alms
    
    if not hasattr(alms2, '__len__'):
        raise ValueError('alms2 must be an array or a sequence of arrays')
    if not hasattr(alms2[0], '__len__'):
        alms2 = [alms2]
    Nspec2 = len(alms2)
    
    if Nspec != Nspec2:
        raise ValueError('alms and alms2 must have same number of spectra')
    
    ##############################################
    # Check sizes of alm's and lmax/mmax/lmax_out
    #
    cdef int almsize
    almsize = alms[0].size
    for i in xrange(Nspec):
        if alms[i].size != almsize or alms2[i].size != almsize:
            raise ValueError('all alms must have same size')

    lmax, mmax = alm_getlmmax(alms[0], lmax, mmax)

    if lmax_out is None:
        lmax_out = lmax


    #######################
    # Computing the spectra
    #
    cdef int j, l, m, limit
    cdef int lmax_ = lmax, mmax_ = mmax
    cdef int lmax_out_ = lmax_out

    cdef np.ndarray[double, ndim=1] powspec_
    cdef np.ndarray[np.complex128_t, ndim=1] alm1_
    cdef np.ndarray[np.complex128_t, ndim=1] alm2_

    spectra = []
    for n in xrange(Nspec): # diagonal rank
        for m in xrange(0, Nspec - n): # position in the diagonal
            powspec_ = np.zeros(lmax + 1)
            alm1_ = alms[m]
            alm2_ = alms2[m + n]
            # compute cross-spectrum alm1[n] x alm2[n+m]
            # and place result in result list
            for l in range(lmax_ + 1):
                j = alm_getidx(lmax_, l, 0)
                powspec_[l] = alm1_[j].real * alm2_[j].real
                limit = l if l <= mmax else mmax
                for m in range(1, limit + 1):
                    j = alm_getidx(lmax_, l, m)
                    powspec_[l] += 2 * (alm1_[j].real * alm2_[j].real +
                                        alm1_[j].imag * alm2_[j].imag)
                powspec_[l] /= (2 * l + 1)
            spectra.append(powspec_)
    
    # if only one alm was given, returns only cl and not a list with one cl
    if alms_lonely:
        spectra = spectra[0]

    return spectra


@cython.wraparound(False)
@cython.boundscheck(False)
def almxfl(alm, fl, mmax = None, inplace = False):
    """Multiply an a_lm by a vector b_l.

    Parameters
    ----------
    alm : array, double
      The array representing the spherical harmonics coefficients
    fl : array, double
      The array giving the factor f_l by which to multiply a_lm
    mmax : None or int, optional
      The maximum m of the input alm
    inplace : bool, optional
      If True, performs the computation in-place if possible (input alm
      is modified if it is a 1d-array of type float64). Otherwise,
      a copy of alm is done.

    Returns
    -------
    alm : array, double
      The result of a_lm * f_l. If *inplace* is True, returns the input
      alm modified
    """
    cdef np.ndarray[np.complex128_t, ndim=1] alm_
    cdef np.ndarray[np.complex128_t, ndim=1] fl_

    if inplace:
        alm_ = np.ascontiguousarray(alm, dtype = np.complex128)
    else:
        alm_ = np.array(alm, dtype = np.complex128, copy = True)
    
    fl_ = np.ascontiguousarray(fl, dtype = np.complex128)

    cdef int lmax_, mmax_
    cdef int l, m
    lmax_, mmax_ = alm_getlmmax(alm_, None, mmax)
    
    cdef np.complex128_t f
    cdef int maxm, i
    cdef int flsize = fl_.size
    for l in xrange(lmax_ + 1):
        f = fl_[l] if l < flsize else 0.
        maxm = l if l <= mmax_ else mmax_
        for m in xrange(maxm + 1):
            i = alm_getidx(lmax_, l, m)
            alm_[i] *= f

    return alm_


def rotate_alm(alm not None, double psi, double theta, double phi, lmax=None,
               mmax=None):
    """
    This routine transforms the scalar (and tensor) a_lm coefficients
    to emulate the effect of an arbitrary rotation of the underlying
    map. The rotation is done directly on the a_lm using the Wigner
    rotation matrices, computed by recursion. To rotate the a_lm for
    l ≤ l_max the number of operations scales like l_max^3.

    Parameters
    ----------
    alm : array-like of shape (n,) or (k,n), or list of arrays
        Complex a_lm values before and after rotation of the coordinate system.
    psi : float
        First rotation: angle ψ about the z-axis. All angles are in radians
        and should lie in [-2pi,2pi], the rotations are active and the
        referential system is assumed to be right handed. The routine
        coordsys2euler zyz can be used to generate the Euler angles ψ, θ, φ
        for rotation between standard astronomical coordinate systems.
    theta : float
        Second rotation: angle θ about the original (unrotated) y-axis
    phi : float.
        Third rotation: angle φ about the original (unrotated) z-axis.
    lmax : int
        Maximum multipole order l of the data set.
    mmax : int
        Maximum degree m of data set.

    """
    if isinstance(alm, np.ndarray) and alm.ndim == 1:
        alm = [alm]

    if not isinstance(alm, (list, tuple, np.ndarray)) or len(alm) == 0:
        raise ValueError('Invalid input.')

    # C++ rotate_alm only handles 1 or 3 maps. The function handling 3 maps
    # is faster than running 3 times the 1-map function, but gives identical
    # results.
    if len(alm) not in (1, 3):
        for a in alm:
            rotate_alm(a, psi, theta, phi)
        return

    lmax, mmax = alm_getlmmax(alm[0], lmax, mmax)
    ai = np.ascontiguousarray(alm[0], dtype=np.complex128)
    AI = ndarray2alm(ai, lmax, mmax)
    if len(alm) == 1:
        c_rotate_alm(AI[0], psi, theta, phi)
        del AI
    else:
        ag = np.ascontiguousarray(alm[1], dtype=np.complex128)
        ac = np.ascontiguousarray(alm[2], dtype=np.complex128)
        AG = ndarray2alm(ag, lmax, mmax)
        AC = ndarray2alm(ac, lmax, mmax)
        c_rotate_alm(AI[0], AG[0], AC[0], psi, theta, phi)
        del AI, AG, AC


cdef int alm_getn(int l, int m):
    if not m <= l:
        raise ValueError("mmax must be <= lmax")
    return ((m+1)*(m+2))/2 + (m+1)*(l-m)


def alm_getlmmax(a, lmax, mmax):
    if lmax is None:
        if mmax is None:
            lmax = alm_getlmax(a.size)
            mmax = lmax
        else:
            lmax = alm_getlmax2(a.size, mmax)
    elif mmax is None:
        mmax = lmax
    return lmax, mmax


@cython.cdivision(True)
cdef inline int alm_getlmax(int s):
    cdef double x
    x=(-3+np.sqrt(1+8*s))/2
    if x != floor(x):
        return -1
    else:
        return floor(x)


@cython.cdivision(True)
cdef inline int alm_getlmax2(int s, int mmax):
    cdef double x
    x = (2 * s + mmax ** 2 - mmax - 2.) / (2 * mmax + 2.)
    if x != floor(x):
        return -1
    else:
        return floor(x)


@cython.cdivision(True)
cdef inline int alm_getidx(int lmax, int l, int m):
    return m*(2*lmax+1-m)/2+l


@cython.wraparound(False)
@cython.boundscheck(False)
cpdef mkmask(np.ndarray[double, ndim=1] m):
    cdef int nbad
    cdef int size = m.size
    cdef int i
    # first, count number of bad pixels, to see if allocating a mask is needed
    nbad = count_bad(m)
    cdef np.ndarray[np.int8_t, ndim=1] mask
    #cdef np.ndarray[double, ndim=1] m_
    if nbad == 0:
        return False
    else:
        mask = np.zeros(size, dtype = np.int8)
        #m_ = m
        for i in range(size):
            if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
                mask[i] = 1
    mask.dtype = bool
    return mask
            
@cython.wraparound(False)
@cython.boundscheck(False)
cpdef int count_bad(np.ndarray[double, ndim=1] m):
    cdef int i
    cdef int nbad = 0
    cdef size = m.size
    for i in xrange(m.size):
        if fabs(m[i] - UNSEEN) < rtol_UNSEEN:
            nbad += 1
    return nbad
healpy-1.10.3/healpy/test/0000775000175000017500000000000013031130324015555 5ustar  zoncazonca00000000000000healpy-1.10.3/healpy/test/data/0000775000175000017500000000000013031130324016466 5ustar  zoncazonca00000000000000healpy-1.10.3/healpy/test/data/anafast_3_11_config_test_anafast.par0000664000175000017500000000041413010374155025423 0ustar  zoncazonca00000000000000infile = wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked.fits
outfile = !cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter.fits
simul_type = 1
nlmax = 64
#maskfile = wmap_temperature_analysis_mask_r9_7yr_v4_udgraded32.fits
iter_order = 3
regression = 1
healpy-1.10.3/healpy/test/data/anafast_3_11_config_test_anafast_nomask.par0000664000175000017500000000030713010374155026774 0ustar  zoncazonca00000000000000infile = wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits
outfile = !cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter_nomask.fits
simul_type = 1
nlmax = 64
iter_order = 3
regression = 1
healpy-1.10.3/healpy/test/data/anafast_3_11_config_test_anafast_xspectra.par0000664000175000017500000000052013010374155027332 0ustar  zoncazonca00000000000000infile = wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked.fits
infile2 = wmap_band_iqumap_r9_7yr_V_v4_udgraded32_masked.fits
outfile = !cl_wmap_band_iqumap_r9_7yr_WVxspec_v4_udgraded32_II_lmax64_rmmono_3iter.fits
simul_type = 1
nlmax = 64
#maskfile = wmap_temperature_analysis_mask_r9_7yr_v4_udgraded32.fits
iter_order = 3
regression = 1
././@LongLink0000000000000000000000000000015400000000000011215 Lustar  00000000000000healpy-1.10.3/healpy/test/data/cl_wmap_band_iqumap_r9_7yr_WVxspec_v4_udgraded32_II_lmax64_rmmono_3iter.fitshealpy-1.10.3/healpy/test/data/cl_wmap_band_iqumap_r9_7yr_WVxspec_v4_udgraded32_II_lmax64_rmmono_3it0000664000175000017500000002640013010374155033637 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2014-01-14T19:01:01' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'TABLE   '           / ASCII table extension                          BITPIX  =                    8 / 8-bit ASCII characters                         NAXIS   =                    2 / 2-dimensional ASCII table                      NAXIS1  =                   15 / width of table in characters                   NAXIS2  =                   65 / number of rows in table                        PCOUNT  =                    0 / no group parameters (required keyword)         GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    1 / number of fields in each row                   COMMENT  -----------------------------------------------                        COMMENT  Map Analysis Specific Keywords                                         COMMENT  -----------------------------------------------                        EXTNAME = 'ANALYSED CROSS POWER SPECTRUM'                                       COMMENT                                                                         CREATOR = 'ANAFAST '           / Software creating the FITS file                VERSION = '3.11    '           / Version of the simulation software             COMMENT                                                                         MAX-LPOL=                   64 / Maximum Legendre order L                       COMMENT                                                                         POLAR   =                    F / Polarisation included (True/False)             BCROSS  =                    F / Magnetic cross terms included (True/False)     COMMENT                                                                         NSIDE   =                   32 / Resolution Parameter of Input Map              COORDSYS= 'unknown '           / Input Map Coordinate system                    COMMENT  G = Galactic, E = ecliptic, C = celestial = equatorial                 COMMENT                                                                         TBCOL1  =                    1 / beginning column of field   1                  TFORM1  = 'E15.7   '                                                            TTYPE1  = 'TEMPERATURE'        / Temperature C(l)                               TUNIT1  = '^2      '           / square of map units                            COMMENT                                                                         CUT-SKY =   0.000000000000E+00 / [deg] Symmetric Cut Sky                        NITERALM=                    3 / Number of iterations for a_lms extraction      LREGRESS=                    1 / Regression of low multipoles (0/1/2)           NMAPS_IN=                    2 / Number of maps (co-)analysed (1/2)             COMMENT                                                                         HISTORY  Input Map1 = wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked.fits       HISTORY  Input Map2 = wmap_band_iqumap_r9_7yr_V_v4_udgraded32_masked.fits       END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               3.8113821E-11  3.9654506E-06  4.5803368E-05  9.6292591E-05  1.1860339E-04  1.1168914E-04  4.4884171E-05  4.6054989E-05  3.0653522E-05  2.9247529E-05  1.6336451E-05  2.8232542E-05  1.5068387E-05  1.7006696E-05  1.7160228E-05  1.2958244E-05  1.2032266E-05  1.1709052E-05  6.1748001E-06  9.3632098E-06  5.5478167E-06  4.8620650E-06  3.9769957E-06  4.6241457E-06  5.6935928E-06  4.4905291E-06  4.9183400E-06  4.9639752E-06  4.5160127E-06  4.5209140E-06  3.6474119E-06  4.2834340E-06  5.3268277E-06  3.3172198E-06  3.6983699E-06  2.3960129E-06  3.4645136E-06  2.5494594E-06  3.4671673E-06  3.5282451E-06  3.3109943E-06  3.5375799E-06  3.5123887E-06  3.3512979E-06  2.2368963E-06  2.2496997E-06  2.3724469E-06  2.5460008E-06  1.7534456E-06  2.3832351E-06  2.0410664E-06  2.1037938E-06  2.1080539E-06  1.6286394E-06  1.9294610E-06  2.0597274E-06  1.6830304E-06  1.6431676E-06  1.6247285E-06  1.6202574E-06  1.7479871E-06  1.5648384E-06  1.5660847E-06  1.2259272E-06  1.1410553E-06                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ././@LongLink0000000000000000000000000000014600000000000011216 Lustar  00000000000000healpy-1.10.3/healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter.fitshealpy-1.10.3/healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter.fit0000664000175000017500000002640013010374155033556 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2014-01-14T18:57:57' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'TABLE   '           / ASCII table extension                          BITPIX  =                    8 / 8-bit ASCII characters                         NAXIS   =                    2 / 2-dimensional ASCII table                      NAXIS1  =                   15 / width of table in characters                   NAXIS2  =                   65 / number of rows in table                        PCOUNT  =                    0 / no group parameters (required keyword)         GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    1 / number of fields in each row                   COMMENT  -----------------------------------------------                        COMMENT  Map Analysis Specific Keywords                                         COMMENT  -----------------------------------------------                        EXTNAME = 'ANALYSED AUTO POWER SPECTRUM'                                        COMMENT                                                                         CREATOR = 'ANAFAST '           / Software creating the FITS file                VERSION = '3.11    '           / Version of the simulation software             COMMENT                                                                         MAX-LPOL=                   64 / Maximum Legendre order L                       COMMENT                                                                         POLAR   =                    F / Polarisation included (True/False)             BCROSS  =                    F / Magnetic cross terms included (True/False)     COMMENT                                                                         NSIDE   =                   32 / Resolution Parameter of Input Map              COORDSYS= 'unknown '           / Input Map Coordinate system                    COMMENT  G = Galactic, E = ecliptic, C = celestial = equatorial                 COMMENT                                                                         TBCOL1  =                    1 / beginning column of field   1                  TFORM1  = 'E15.7   '                                                            TTYPE1  = 'TEMPERATURE'        / Temperature C(l)                               TUNIT1  = '^2      '           / square of map units                            COMMENT                                                                         CUT-SKY =   0.000000000000E+00 / [deg] Symmetric Cut Sky                        NITERALM=                    3 / Number of iterations for a_lms extraction      LREGRESS=                    1 / Regression of low multipoles (0/1/2)           NMAPS_IN=                    1 / Number of maps (co-)analysed (1/2)             COMMENT                                                                         HISTORY  Input Map = wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked.fits        END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               3.3414573E-11  3.3517558E-06  4.8989430E-05  1.0169477E-04  1.2062433E-04  1.1325596E-04  4.7197471E-05  4.6721838E-05  3.1373249E-05  2.9179017E-05  1.6283797E-05  2.8455279E-05  1.5565542E-05  1.7469347E-05  1.7716973E-05  1.2910575E-05  1.2409597E-05  1.1831381E-05  6.3309044E-06  9.5228725E-06  5.5759465E-06  5.0533667E-06  4.0194614E-06  4.6285672E-06  5.7274942E-06  4.6215828E-06  5.1510547E-06  5.0876070E-06  4.6781470E-06  4.5110633E-06  3.7194425E-06  4.3340710E-06  5.3396429E-06  3.4312413E-06  3.6795705E-06  2.3858963E-06  3.5362266E-06  2.5809411E-06  3.5526471E-06  3.5767098E-06  3.3679785E-06  3.5763799E-06  3.6576841E-06  3.3139222E-06  2.2850354E-06  2.2602651E-06  2.4078142E-06  2.5892639E-06  1.8113082E-06  2.4214503E-06  2.0994112E-06  2.1263249E-06  2.1714288E-06  1.6605873E-06  1.9703330E-06  2.1057131E-06  1.7174100E-06  1.6981736E-06  1.6703773E-06  1.6212538E-06  1.8049700E-06  1.6118177E-06  1.5781592E-06  1.2372816E-06  1.1714108E-06                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ././@LongLink0000000000000000000000000000015500000000000011216 Lustar  00000000000000healpy-1.10.3/healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter_nomask.fitshealpy-1.10.3/healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter_nom0000664000175000017500000002640013010374155033646 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2014-01-10T20:25:48' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'TABLE   '           / ASCII table extension                          BITPIX  =                    8 / 8-bit ASCII characters                         NAXIS   =                    2 / 2-dimensional ASCII table                      NAXIS1  =                   15 / width of table in characters                   NAXIS2  =                   65 / number of rows in table                        PCOUNT  =                    0 / no group parameters (required keyword)         GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    1 / number of fields in each row                   COMMENT  -----------------------------------------------                        COMMENT  Map Analysis Specific Keywords                                         COMMENT  -----------------------------------------------                        EXTNAME = 'ANALYSED AUTO POWER SPECTRUM'                                        COMMENT                                                                         CREATOR = 'ANAFAST '           / Software creating the FITS file                VERSION = '3.11    '           / Version of the simulation software             COMMENT                                                                         MAX-LPOL=                   64 / Maximum Legendre order L                       COMMENT                                                                         POLAR   =                    F / Polarisation included (True/False)             BCROSS  =                    F / Magnetic cross terms included (True/False)     COMMENT                                                                         NSIDE   =                   32 / Resolution Parameter of Input Map              COORDSYS= 'unknown '           / Input Map Coordinate system                    COMMENT  G = Galactic, E = ecliptic, C = celestial = equatorial                 COMMENT                                                                         TBCOL1  =                    1 / beginning column of field   1                  TFORM1  = 'E15.7   '                                                            TTYPE1  = 'TEMPERATURE'        / Temperature C(l)                               TUNIT1  = '^2      '           / square of map units                            COMMENT                                                                         CUT-SKY =   0.000000000000E+00 / [deg] Symmetric Cut Sky                        NITERALM=                    3 / Number of iterations for a_lms extraction      LREGRESS=                    1 / Regression of low multipoles (0/1/2)           NMAPS_IN=                    1 / Number of maps (co-)analysed (1/2)             COMMENT                                                                         HISTORY  Input Map = wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits               END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               7.7518313E-12  3.2126587E-03  9.6208649E-03  1.5124589E-03  5.4148668E-03  6.8912120E-04  2.4400102E-03  5.4524658E-04  1.7056183E-03  5.2598078E-04  1.2343171E-03  6.1758002E-04  8.7302341E-04  4.2051595E-04  7.4940576E-04  3.2323800E-04  5.3276756E-04  3.2391399E-04  4.7395029E-04  2.4499805E-04  4.0832191E-04  1.9236472E-04  3.1067690E-04  1.9935732E-04  2.7305013E-04  1.5129332E-04  2.2570419E-04  1.3587187E-04  1.8686480E-04  1.1943751E-04  1.6475016E-04  9.7270407E-05  1.3401134E-04  8.9293688E-05  1.2487322E-04  8.6192558E-05  1.0508329E-04  8.0331818E-05  9.9586650E-05  6.2721563E-05  8.2966559E-05  6.6724424E-05  7.5245429E-05  5.8052537E-05  6.0123086E-05  6.4155691E-05  6.5243075E-05  5.4126042E-05  4.8645215E-05  4.5126373E-05  5.0803061E-05  4.1083866E-05  4.1331583E-05  3.6028840E-05  3.9471146E-05  3.1664225E-05  3.6514211E-05  2.9357230E-05  3.1004543E-05  2.6760192E-05  2.8267792E-05  2.6567754E-05  2.3616500E-05  2.4474188E-05  2.4070412E-05                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ././@LongLink0000000000000000000000000000014700000000000011217 Lustar  00000000000000healpy-1.10.3/healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_IQU_lmax64_rmmono_3iter.fitshealpy-1.10.3/healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_IQU_lmax64_rmmono_3iter.fi0000664000175000017500000004160013010374155033526 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2014-01-14T18:50:12' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'TABLE   '           / ASCII table extension                          BITPIX  =                    8 / 8-bit ASCII characters                         NAXIS   =                    2 / 2-dimensional ASCII table                      NAXIS1  =                   95 / width of table in characters                   NAXIS2  =                   65 / number of rows in table                        PCOUNT  =                    0 / no group parameters (required keyword)         GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    6 / number of fields in each row                   COMMENT  -----------------------------------------------                        COMMENT  Map Analysis Specific Keywords                                         COMMENT  -----------------------------------------------                        EXTNAME = 'ANALYSED AUTO POWER SPECTRUM'                                        COMMENT                                                                         CREATOR = 'ANAFAST '           / Software creating the FITS file                VERSION = '3.11    '           / Version of the simulation software             COMMENT                                                                         MAX-LPOL=                   64 / Maximum Legendre order L                       COMMENT                                                                         POLAR   =                    T / Polarisation included (True/False)             BCROSS  =                    T / Magnetic cross terms included (True/False)     COMMENT                                                                         NSIDE   =                   32 / Resolution Parameter of Input Map              COORDSYS= 'unknown '           / Input Map Coordinate system                    COMMENT  G = Galactic, E = ecliptic, C = celestial = equatorial                 COMMENT                                                                         TBCOL1  =                    1 / beginning column of field   1                  TFORM1  = 'E15.7   '                                                            TTYPE1  = 'TEMPERATURE'        / Temperature C(l)                               TUNIT1  = '^2      '           / square of map units                            COMMENT                                                                         TBCOL2  =                   17 / beginning column of field   2                  TFORM2  = 'E15.7   '                                                            TTYPE2  = 'GRADIENT'           / Gradient (=ELECTRIC) polarisation C(l)         TUNIT2  = '^2      '           / power spectrum units                           COMMENT                                                                         TBCOL3  =                   33 / beginning column of field   3                  TFORM3  = 'E15.7   '                                                            TTYPE3  = 'CURL    '           / Curl (=MAGNETIC) polarisation C(l)             TUNIT3  = '^2      '           / power spectrum units                           COMMENT                                                                         TBCOL4  =                   49 / beginning column of field   4                  TFORM4  = 'E15.7   '                                                            TTYPE4  = 'G-T     '           / Gradient-Temperature (=CROSS) terms            TUNIT4  = '^2      '           / power spectrum units                           COMMENT                                                                         TBCOL5  =                   65 / beginning column of field   5                  TFORM5  = 'E15.7   '                                                            TTYPE5  = 'C-T     '           / Curl-Temperature terms                         TUNIT5  = '^2      '           / power spectrum units                           COMMENT                                                                         TBCOL6  =                   81 / beginning column of field   6                  TFORM6  = 'E15.7   '                                                            TTYPE6  = 'C-G     '           / Curl-Gradient terms                            TUNIT6  = '^2      '           / power spectrum units                           COMMENT                                                                         COMMENT  The polarisation power spectra have the same definition as in CMBFAST  COMMENT                                                                         CUT-SKY =   0.000000000000E+00 / [deg] Symmetric Cut Sky                        NITERALM=                    3 / Number of iterations for a_lms extraction      LREGRESS=                    1 / Regression of low multipoles (0/1/2)           NMAPS_IN=                    1 / Number of maps (co-)analysed (1/2)             COMMENT                                                                         HISTORY  Input Map = wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked.fits        END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               3.3414573E-11   0.0000000E+00   0.0000000E+00   0.0000000E+00   0.0000000E+00   0.0000000E+00  3.3517558E-06   0.0000000E+00   0.0000000E+00   0.0000000E+00   0.0000000E+00   0.0000000E+00  4.8989430E-05   1.1326727E-05   1.5167591E-06   1.8729554E-05  -5.0660765E-07  -1.2990840E-06  1.0169477E-04   5.5491796E-07   3.8988201E-05  -8.2934815E-07  -1.1219169E-05   1.8067552E-06  1.2062433E-04   2.7363657E-07   3.1835313E-07   2.8755430E-06   2.4569422E-06   1.0931864E-07  1.1325596E-04   1.7977787E-07   1.5543286E-06   2.8972218E-07  -3.5698260E-06   3.8918211E-07  4.7197471E-05   3.5122463E-07   8.0548624E-08   1.6187582E-06  -2.5457095E-07  -7.8117601E-09  4.6721838E-05   2.9025040E-07   5.4732448E-07   1.8679569E-07   8.0861071E-07   1.6300866E-07  3.1373249E-05   1.6711914E-07   1.3002980E-07  -1.5752390E-07   6.0998417E-07  -5.9480239E-08  2.9179017E-05   7.4773467E-08   2.1617154E-07  -6.2634064E-07  -3.4087824E-07   2.3513314E-08  1.6283797E-05   1.1672569E-07   7.1538452E-08   4.2229684E-07   4.8906196E-07  -1.4694910E-09  2.8455279E-05   6.2293317E-08   1.5802097E-07   3.8576127E-07  -2.6001143E-07   3.6031366E-08  1.5565542E-05   9.0137057E-08   8.4176719E-08  -3.6806281E-07  -5.4398683E-08   1.1470060E-08  1.7469347E-05   5.2516327E-08   1.1767365E-07   1.7213877E-07  -1.0687624E-07   2.2248097E-08  1.7716973E-05   1.1285540E-07   1.2472890E-07  -1.1188859E-07   9.8666881E-08  -1.6694468E-08  1.2910575E-05   8.4291230E-08   6.3593774E-08  -1.9726707E-09   9.3617935E-08  -2.4510989E-08  1.2409597E-05   7.7402902E-08   5.3499942E-08   1.3308906E-07  -6.6400737E-08   2.6162448E-09  1.1831381E-05   6.5099499E-08   9.1751886E-08   7.6643175E-08  -1.6233711E-08  -1.6971301E-08  6.3309044E-06   6.6205367E-08   8.1543647E-08  -1.0657038E-07   5.5560379E-09   2.7702651E-08  9.5228725E-06   5.1687952E-08   1.3422897E-07  -5.0333743E-08   9.4987918E-08   7.1446986E-09  5.5759465E-06   4.8521827E-08   6.9847218E-08   1.2662450E-07   1.1206572E-07   9.5209955E-09  5.0533667E-06   3.7051095E-08   5.9060927E-08   3.3978118E-08   9.5742443E-08   6.9442746E-10  4.0194614E-06   4.5561773E-08   8.2329564E-08  -4.4227448E-08  -1.3380291E-07  -1.0451082E-08  4.6285672E-06   7.0213218E-08   5.5583765E-08  -1.5426014E-08   4.0318479E-08  -5.4374962E-09  5.7274942E-06   4.4926225E-08   1.0069360E-07   7.6489544E-09   4.5717421E-08   1.2411229E-08  4.6215828E-06   7.4644234E-08   6.2953333E-08   1.2454113E-08  -8.2562039E-08  -1.4207249E-08  5.1510547E-06   4.9761585E-08   3.5465646E-08   5.5413921E-08   3.4581070E-08   2.3994184E-09  5.0876070E-06   4.8609841E-08   7.1690437E-08  -1.4455247E-07   1.4442573E-07  -3.7034631E-10  4.6781470E-06   4.2000664E-08   4.0190177E-08  -1.8539815E-08  -5.2430789E-08   6.9588251E-09  4.5110633E-06   3.7648888E-08   8.0887602E-08  -3.1838638E-08   8.2901671E-08   8.8493275E-09  3.7194425E-06   4.4569632E-08   4.9354561E-08  -5.1000637E-08   2.3846111E-08  -4.2243560E-09  4.3340710E-06   2.4894126E-08   5.0191655E-08   8.1070919E-09   1.0444322E-07  -9.8000241E-10  5.3396429E-06   3.8473491E-08   5.6868114E-08  -7.3734519E-08  -4.9318459E-08  -6.9752404E-09  3.4312413E-06   4.1023235E-08   4.1241520E-08   1.3148380E-07  -8.1654548E-08  -3.6472485E-09  3.6795705E-06   2.9387111E-08   5.8280023E-08  -1.0297464E-08   5.6925320E-08  -1.7731748E-09  2.3858963E-06   4.4388191E-08   4.7877904E-08   6.1468919E-09  -3.5399477E-08  -7.0660344E-09  3.5362266E-06   3.1711508E-08   3.6997882E-08  -1.9408519E-08   2.1578805E-08  -2.3280804E-09  2.5809411E-06   4.3973770E-08   5.6319994E-08   2.6172218E-09  -3.7576058E-08   7.0989445E-09  3.5526471E-06   3.2260786E-08   3.5412384E-08   2.6822459E-08  -2.9876123E-08   2.8594191E-09  3.5767098E-06   3.6238013E-08   4.2996703E-08   3.3229757E-08   1.9209260E-08  -4.2390638E-09  3.3679785E-06   3.3644760E-08   3.3077626E-08  -5.4325586E-08   5.0498823E-08  -1.1307041E-08  3.5763799E-06   3.6355459E-08   3.6421220E-08  -3.9380279E-08  -6.5472513E-08  -2.4136253E-09  3.6576841E-06   3.7718280E-08   4.0498847E-08   2.3284095E-08  -3.8424332E-08  -6.0553257E-10  3.3139222E-06   3.7356493E-08   3.5905590E-08  -6.7429170E-08  -3.6308005E-08   1.7868270E-09  2.2850354E-06   3.4967957E-08   4.7278032E-08  -3.9159801E-08   2.1897767E-08  -6.0651590E-09  2.2602651E-06   3.5784261E-08   5.5064127E-08   1.3484804E-08   2.1172231E-09  -1.4507182E-09  2.4078142E-06   4.0586173E-08   3.5370299E-08   3.9109043E-08  -1.5488581E-08  -2.8332496E-09  2.5892639E-06   3.2592350E-08   4.2571667E-08  -1.4736191E-08  -4.9003592E-09  -1.0316374E-09  1.8113082E-06   4.7515925E-08   4.1403972E-08  -1.9459398E-08   1.0315002E-08   4.5571702E-09  2.4214503E-06   3.3786378E-08   4.0579021E-08   9.0302112E-09  -8.0383266E-08  -2.3375817E-09  2.0994112E-06   5.1217686E-08   4.9477457E-08  -3.0651046E-09   4.8709912E-09  -3.0967717E-10  2.1263249E-06   3.0008440E-08   3.2908694E-08  -6.8305024E-09  -8.1724325E-09  -1.9307356E-09  2.1714288E-06   2.6085985E-08   3.3008497E-08   1.1039996E-08  -5.2998816E-10  -2.9880032E-09  1.6605873E-06   2.7855240E-08   2.9612035E-08   1.7350445E-08  -1.9177701E-08  -6.0001644E-09  1.9703330E-06   3.2100829E-08   4.5367933E-08   1.3381025E-08   1.6832031E-09   4.2481360E-10  2.1057131E-06   4.5092165E-08   3.4587522E-08  -3.6454928E-08  -2.1820563E-08  -4.0278456E-09  1.7174100E-06   2.9217579E-08   3.9498520E-08   2.1351259E-08   4.1037776E-08  -3.8102206E-09  1.6981736E-06   3.4158209E-08   4.1009987E-08  -2.4353895E-08   1.0280260E-08  -4.7005932E-09  1.6703773E-06   4.0781380E-08   3.6596671E-08   4.1422975E-08  -5.5711361E-08  -2.3359064E-09  1.6212538E-06   3.2762653E-08   3.0405566E-08  -1.8850663E-09   1.5046229E-08  -1.0119409E-09  1.8049700E-06   3.2124838E-08   3.7500346E-08  -1.6460463E-08  -2.1222910E-08   2.1940931E-09  1.6118177E-06   3.1331698E-08   3.5415919E-08   3.8942797E-08  -1.6711065E-08   2.3549926E-09  1.5781592E-06   3.5286966E-08   3.4420523E-08  -2.0983954E-08   5.3279359E-09  -2.5278641E-09  1.2372816E-06   3.0536871E-08   3.7504719E-08   9.7266977E-09  -7.6671878E-09   7.0666482E-09  1.1714108E-06   3.4840955E-08   3.5955313E-08  -1.9077234E-08  -1.1136090E-09  -8.6695498E-11                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 healpy-1.10.3/healpy/test/data/gaussbeam_10arcmin_lmax512_pol.fits0000664000175000017500000004730013010374155025156 0ustar  zoncazonca00000000000000SIMPLE  =                    T / Written by IDL:  Wed Dec 12 09:04:08 2012      BITPIX  =                  -64 / Number of bits per data pixel                  NAXIS   =                    2 / Number of data axes                            NAXIS1  =                  513 /                                                NAXIS2  =                    4 /                                                EXTEND  =                    T / FITS data may contain extensions               DATE    = '2012-12-12'         / Creation UTC (CCCC-MM-DD) date of FITS header  COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy  COMMENT and Astrophysics', volume 376, page 359; bibcode 2001A&A...376..359H    END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ???fO?̢$?N?i?i?f?y ?o?P(5?,q6?gw?}?
?7?L?p5:?ٯu(??`:?2?ֆm
?
D?@.?7?|?FO?'?hy?0xv=?Vd?g9?$?u? $??7?
?Ac6?B$?>ѩ?G_^	?.?E}?|;?;?]?P%3???-?pE!?Ӯ?!1r?u2;?ŘY?Ue?\ܿ?ꣻ+N?lg?'?eJ$H?v?wf?
K:3?:X?hs<?d?֊???jt?6w?NAah$?box?ss^?ہO?ڌ?ٓC?ؗC?י0?֗F+l?Ւ4?6?ԉ,|?~3I?pR?^qۗN?I g?1r+?'R?ZU?	S?ʲu⿥?ɊuQ?`S*?2,?@0?E?Õl?[?|>?XA?ﾘi|?Q+?.?ﺺ*>H?jeW?|_?i^T?fU?	Z?ﲪ?G?X?w#?o[?﫜$*?)|<	?勉&4?;$;2?勵Rg?@h|?g?9N
?ft?%׸C?{VNd?	m	?qt?}g??74?s?fD?\=,I?	$?i]?^?^#1?}pN?DУ'N?r|??G?MyF?~l=D?|ʘ۹?zKb?y$bwG?wRH{?u}Z?s)?q?o'9D8?n3?l(8>?jA5
?hW,VZ?fj?dz	X?bv?`?J7?H‚?E[?C߻?AS??b
?=mf?;A#o?9ڨ?60Q?4?2sV>?08 ?-RY?+VR?)v?F?'/:-?$Vq?"Ɛݻ??6b?H?B^?%8~?C.zB??8Q?Rr?vc?h?	V ?S?T?<|?Ӂ?[?~X?	<^?~.ǧ?{9?x?u?q-	?n@?k=%?h}L?e
?b4?_?\r9_?YS/i?V2[?Sɝ?O|cC?LI?Ib`?FdW?C3sB??U5??,j?)HQ?%_[?"\?dݏ?e#Y?qK?hrl??IA?UCyR?%:9?g/?*+{?PN?U~4?Mfc?v+?70?"?_r?ey>?@D?ޛRw?k?ג'Y?
*?ЀM_W?#K??cj=?%W?3Q4?:e	Ώ?61?25j?.x?+G?'eX?#qcJ?4	?#[??fO??
Bp?䭊?i?ā\Z?Y?
?̚?hC2?Kjv?,C
?
Ϙ8?^|?>z0?՘&?n?A0F)?'Y?v?	m?v
kx?>u?DO?ǎww?쫈?Gj?+'?잾Y4?vz3?,c\?S?썑?@Td?}@=?쀘ү:?|Av?w?s\}5?o.)?j@<	?flOO?bX?]uI?Y8͜c?Ts?Pa%?KZH?Gڱ6?C
dZ"?>M;?: S??5da?1*?,sZ?(,Y1?#?&?R?ןV?֝ZK?՘?ԐZ?ӄóG?vx?d)?PG?8&k??ﾟK?XV̅?B4?Ɵ?p;t?N?/X?mzC?N+?ﲰjHu?Mjtx?NL?~L ?:?﫢X~?/:U?墨2'?Ax?ŧ	v?Fm{?ĺF??
?qPg?,*5??[
?wh?8	?E%G?ߒ?\?cwF?店?"?d?Y?n&&?K?Y?S?F?SOfP\?~g?+ػ?)|M?'6/T?$?"? PF?
e?!F?PX#~???5?Ĵ6?
jh??&?$sN?֔H?MN+?ﴂr?'#?F!c?*'?p?Vhs?=H ?ݟ[?3?Zj?մk?T?^?ͯəB\?]?I!A?őO2??܎?Y?ۻ??!?E`?=.?ng?Yt?-o ?Cp?%-*?=?^넧?}>i?!O#?'aL?ux?(J?Y?zE&??
?т??~H
G?{M/?x!
?u	'j?rE?nV?kRX?h֒(?ev?b?_.?\xK+?YY?V8רE?Sv?On!?LX|?IqU?Fj{(?C9D?@>?<?9?6Y-?3:i?/|8e?,si?)NN?&fΕ?"cU,?j[?jН?vN?n^?9^?Ē+?[ET?&?hƛG?0w9??[}"%?L_F?|C?	'W?g?e?`A?!U"?ޡL?d?m?ט?o!?ІC8?%y?i`L?Ć?BG6?r?~?taIF?՗"?47?c?ˎ?@uCT?.Sq?uL?69?햃$*?͑?V?{?Z9l?퇝Ut?d?e?fsr?|WȞ?x?tǠ
\?pcz?m-z?i\ڲ?e#s?a2?]9?ZS3j?V$d?>:?:=6D?6	̫?2rA|?.x#?+	#?'
`w?#E?EC??i?	72?P9/?
M8?{C?ۏg8'?MA?d?Ѓ]?4_?n?Q2?2?|G7V?wLH?s
B4S?o43-?j.E;?fqݎ?b
SX?]"E?Y>y?TӪ?Pf\?K3!?Ge?Cle?>@~?:%?5B{?10pW?,W2?(2|?#]w9?,'0?g5?z/9?j;?
Y?w_n?A _?T5?fH?(g?!d?>8?XSO?ac?j"?un&$?oM?)nf?̀le2??km?(l`*?yp1?y!Q?yq?`z?뫩y?p?6?yQ:?똺~?A?7bg?r݆Մ?녬k?
z?|Ā܁?wM3A?rwB?muC~b?hݍ?d	 ?_4?Z\?U?P
l?Kʑ"?F놔?B
F>?='?8CG	b?3\ֺ
?.t_y?)uHW?$ŋ?'?4?޲?ܤM?K??P2_?8?Ӗܼ?bg"?>Ij?͟;?l?I?󉖺?t?S`!,?iC"?B?g?껧RXs?궔3?걀,?iNL?Qi?8Xh?U??|P?/?ꈟ9*5?{A?~VR?y/e?tӻL(?nܞNa?i@?dONP?_T8Q?Z#ŗr?T0)?OC?J?EPh?@OT?:ݙ?5{+?0dDh?3;???3{?f0?fe?2ӥ?g*?2V?vf3Fm?Vf|0?33&??5Xn?iȽ?kb?S:2!?J}??3?vL?fz
?#LA?C?Y{&?FQ?k0I?tQ4H?MLN?vd?R?6'?Ӽ?mi?	?/p})?'I	?1!?=a?q!6?G	?;?D"??5B.
?~?xz?U?V\?Vk+L?+?2?wPlX?@j?(u?{G?H?3LN?c??Oz?δ?.S}oR?ןV?֝ZK?՘?ԐZ?ӄóG?vx?d)?PG?8&k??ﾟK?XV̅?B4?Ɵ?p;t?N?/X?mzC?N+?ﲰjHu?Mjtx?NL?~L ?:?﫢X~?/:U?墨2'?Ax?ŧ	v?Fm{?ĺF??
?qPg?,*5??[
?wh?8	?E%G?ߒ?\?cwF?店?"?d?Y?n&&?K?Y?S?F?SOfP\?~g?+ػ?)|M?'6/T?$?"? PF?
e?!F?PX#~???5?Ĵ6?
jh??&?$sN?֔H?MN+?ﴂr?'#?F!c?*'?p?Vhs?=H ?ݟ[?3?Zj?մk?T?^?ͯəB\?]?I!A?őO2??܎?Y?ۻ??!?E`?=.?ng?Yt?-o ?Cp?%-*?=?^넧?}>i?!O#?'aL?ux?(J?Y?zE&??
?т??~H
G?{M/?x!
?u	'j?rE?nV?kRX?h֒(?ev?b?_.?\xK+?YY?V8רE?Sv?On!?LX|?IqU?Fj{(?C9D?@>?<?9?6Y-?3:i?/|8e?,si?)NN?&fΕ?"cU,?j[?jН?vN?n^?9^?Ē+?[ET?&?hƛG?0w9??[}"%?L_F?|C?	'W?g?e?`A?!U"?ޡL?d?m?ט?o!?ІC8?%y?i`L?Ć?BG6?r?~?taIF?՗"?47?c?ˎ?@uCT?.Sq?uL?69?햃$*?͑?V?{?Z9l?퇝Ut?d?e?fsr?|WȞ?x?tǠ
\?pcz?m-z?i\ڲ?e#s?a2?]9?ZS3j?V$d?>:?:=6D?6	̫?2rA|?.x#?+	#?'
`w?#E?EC??i?	72?P9/?
M8?{C?ۏg8'?MA?d?Ѓ]?4_?n?Q2?2?|G7V?wLH?s
B4S?o43-?j.E;?fqݎ?b
SX?]"E?Y>y?TӪ?Pf\?K3!?Ge?Cle?>@~?:%?5B{?10pW?,W2?(2|?#]w9?,'0?g5?z/9?j;?
Y?w_n?A _?T5?fH?(g?!d?>8?XSO?ac?j"?un&$?oM?)nf?̀le2??km?(l`*?yp1?y!Q?yq?`z?뫩y?p?6?yQ:?똺~?A?7bg?r݆Մ?녬k?
z?|Ā܁?wM3A?rwB?muC~b?hݍ?d	 ?_4?Z\?U?P
l?Kʑ"?F놔?B
F>?='?8CG	b?3\ֺ
?.t_y?)uHW?$ŋ?'?4?޲?ܤM?K??P2_?8?Ӗܼ?bg"?>Ij?͟;?l?I?󉖺?t?S`!,?iC"?B?g?껧RXs?궔3?걀,?iNL?Qi?8Xh?U??|P?/?ꈟ9*5?{A?~VR?y/e?tӻL(?nܞNa?i@?dONP?_T8Q?Z#ŗr?T0)?OC?J?EPh?@OT?:ݙ?5{+?0dDh????ۧV?2w?2q? ?4`??s3(?S3R

?0?	?9?6`?8L7?P"$??T?+}?CX?cGw? Ϸ?ٹX??&,C?CaC?jk?A?I}?Y?9?3?Љ3?j66p?N?w?$?[i_?:c}4?>wr?D“?ļwr?A>?yzc?2 w?wU'?#?򂶝?쏃JI?S9g?w]?ͅ?t؅??$(*?xc:?c??`
?6
?ꝮM?+"?h{ܽ?碧T?٧?
|lj?>%q?k&?1?$M????:?Qq>:T?eEb?vq?ۄ?ڏ3Q?ٖ?؛#%W?ל_?֚uB?ՕctO?ԍ,W?ӁU?sI?am7?Lі\?4̶?dk?YS?(
g?ʵɒ
?ɍ?;?c1Ƴ/?5D5q?5p?H?ØFj?^=(? /?*@?ﾜ?U*a?_?ﺽxFL?m?"Aq?ÕG?iQ[?
#6?ﲭ?4h?J?$~?#K"C?z8?J]?﫟-J?, ^?嘆?>N?|F?CЈ{?r??)*R?ȭ?	2g?tmO??B_?`?Ż}?_h)_?w?Ӯ~[?aD?%?F\?G˾3?FX?vQ?;5
?jrj?$d?.؎??mo???:1_?ݜEy?|P?W.l?ձV.?2?[<.8?ͬ!?G*?F
+S?Ŏw?C?QX%?V	?
?#?}#Tj?:e]?k??m?,&?h?:Ux?[ۦ?zظ?wKF??g?vb?J?ϦD?o?'?ēs?~;jP?{
?x?u?q?nKڅ?kG~?hӈ-^?e
AJ?bjt?_防y?\uBo?YV&?V5}?Sx?Oi3?LP6?Ij#l?Fgi]E?C6C?@^w?<Ҙ?9
-0?6V?3z?/wg?,oLR?)Kz`?&b?"`x?g/HG?g;?s?k۞>?c)
?d=?XD,?&
m?hI?-Qf?W?X}0?L H?:QY\?6c?2N?.i?+1I?'
vPr?#[l?e?*?A ?NݙC?ho?
*o'?用f?ب~&?g?ҺF?dx?򅱯d?k'R?NN<{?/'c*?
?L?2?՛W;\?po/?DL?Y?x^?"R?yкM?AH?"?lߙ?쫋xe?JHa?L^?5?q?썔lL?C7?ɜ`?쀛_p?|D^^?wI?s4Y?o1[ʇ?jV—?fo&rX?b
ͱ
?]Lɺ?Y;\?T­?Pc}?KƎ?G=)?C7?>)?:#%3G?5pI?1-?,/?(/?#J?)Wl??Kh?7<\?
*?ub?tdy?QX?V?&.F?V|5?s?U(.?㶗?+	?r@?ͦj?&ȫ?}
?Ҥ7I?%{?v??ųS8A?#?],?뫦1?·?3PI;?vޒ?똷̬?5?4x?ptU?녩s?M]OS?|+?wJ
?r|l?m?h?d.?_1V?ZYŧ?UT?PJy?K?FC{G?BqB?=%&?8@/?3Z]v?.q؀M
?)?$/M?€?~?vk?쿮??-8??B[
?!)$?9t2??nW?L???D?xt?ޤ+?һZ_???껤m4?궑h?}\n?g)pĄ?OD=K?5+?h_?tYP?49?ꍾ?ꈜ?xB?~Sa%.?y,9=?t._?nd?i#)g?d}3?_QƳ?Z !Z?T?O&?JK?EM?@FFs?:-َ?5nP?0aȣhealpy-1.10.3/healpy/test/data/map_synfast_seed12345.fits0000664000175000017500000045760013010374155023325 0ustar  zoncazonca00000000000000SIMPLE  =                    T / conforms to FITS standard                      BITPIX  =                    8 / array data type                                NAXIS   =                    0 / number of array dimensions                     EXTEND  =                    T                                                  END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / array data type                                NAXIS   =                    2 / number of array dimensions                     NAXIS1  =                12288 / length of dimension 1                          NAXIS2  =                   12 / length of dimension 2                          PCOUNT  =                    0 / number of group parameters                     GCOUNT  =                    1 / number of groups                               TFIELDS =                    3 / number of table fields                         TTYPE1  = 'I_STOKES'                                                            TFORM1  = '1024E   '                                                            TTYPE2  = 'Q_STOKES'                                                            TFORM2  = '1024E   '                                                            TTYPE3  = 'U_STOKES'                                                            TFORM3  = '1024E   '                                                            PIXTYPE = 'HEALPIX '           / HEALPIX pixelisation                           ORDERING= 'RING    '           / Pixel ordering scheme, either RING or NESTED   EXTNAME = 'xtension'           / name of this binary table extension            NSIDE   =                   32 / Resolution parameter of HEALPIX                FIRSTPIX=                    0 / First pixel # (0 based)                        LASTPIX =                12287 / Last pixel # (0 based)                         INDXSCHM= 'IMPLICIT'           / Indexing: IMPLICIT or EXPLICIT                 END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             =09=={=ߥ==7z=R=^Z=K=!F=E===l=\A<Ժggڽ
S(SH;y<=L=<=ă=$.=%U=ۓ<~Z;R;纏׼	aƼs?3Wu!gݽi>׽*"02e7z=s0yPJzI+%@<8<:A<|o7dźL4L޼qe~;&Gnˌh|@_rL=9xTepϽnׂPmd]tC*vý>ml(j<4˓
C
0()c-J3	!ֺuK[<
;Yq;!;܋B;:iG:8+r7:8IA9h5G%mع;&Cc;1;+;_;P:r׺UR\W:):@[L2vݺT`M[C];6;g;V1;Y;9;;$;2%	\Ǻٱ:;:9ʸ~CVUѪjR
#[^Ի$M[@w"Ѷ;;y8;b;<u;8;";f:ⅺR/hi:`;;:#.:N;:;;8t;<l<LQ<|N<ݔ;T;wF;;M;!;M:|:E(>9%9z:"M:Ya:p:?Ю<fǺ@V_b7^P\F#=83]dkyGH1(I"U&>غ.99):.;#;;E<_<<'<O<;;ӽ;^1;C;Dq;x;Em;k:
::E:9+9ն9dV99Qe8ʺp3
篻P0 [5nY\,q1ٻ {QEOdݻU|FC_mn}?+-F9Y:u::t::Y;f;H;<<n<a<rm<;V;t;=;9;:W:A;;:i:K9B9m9Z9981r}F	8({2dc`,w׻n^/XV\Q	FS`?WLp7X5C:h;#;:$:ƣ;D;S;<1z<>N<5<\<2!;;؁;\;;4;m:̚::F;ܹ;d:)@: XE9,9:	q:0^h:9t9WJ~W$
/λ+ lj5һtϻ;1g+fRMH9d K㦻}.T;H2Csft1;2;Nm`;A;)#;G;=;;ّ<g<=<)
<s<d<	;>;Ѣ;;;3::
h:V:Ho:k;;[E:9t9f*:65:s:D:9Yv&?"k_û7,dԻ\sb7AػaY423]Wл4gXseO7;;N];N;Db;>lo;Kq;)
;_<G<2Q<Ŀ<P<<<;;-;];;.::4:k:g9/:]H:(z:Z:xS:E29"	9r:N:T:S":98|%[M%ʶOG'}@Ż
ONB-pVj(~u G.GwDDu軔M\fzZϣB;K;$;3z;@,;P;`B;\;O5;X<<(<<X<:Y<Zf<];(0;+;=J;v0;!c::xln9G8k9:l:X:q:h92D<9D':A_:n:,49+9-9Qi*uAh	t"蓻'D=ҫŻLbT?<ĻeU껐mb˻HEd?\N&Obt#:Id:[:;"[;L;n;;V;<0<<bX<4<t<<Qh;V;w&;;s;[ͻ;
!Y:6:O9¥8X9S{:
:C:I(A:$9,$8::p9'99A8]dPҎЅrF`^޻TYYʍK;`=azEbAX;wUwuBɻd睻iv6n^WcNFr:)9A:Q:M;7A;p\;,;G;?;<<.0<S<\<G<
<;I';);;y;>E:Kq:Jy:GԒ9}(9;ME9S:t :TI:wr]917v/S
	oA9K93I[8'9+𑸞 s3jιz8E7AbZ廂74	߻uH('㊠[R
bJwf廑@rď,Ia\v839:z;,;;c\Y;;N;G;<0<Y<

<E<^T<N<
W|<r;#;b;;(;a/;,}::0:q:KV9:-y:E:6g:ٚ@:tg8պCO˺Iq蹧Q{.,.Qh_9Ϲ.ͺUa,9N:I*C0t6}V" ;y
(ȻzܻlǻGػ"|j.Vk܆Z=3:H-:ta;J;;L;Up0wһY/a
;)U9(:;,;+;;;;ʻ;<V<<<<'d;(-;"Q;;a;;;c+;E<;&sO;	?`;;:::;5S;E;"#:Ƞ9ߢ!y_4n+gpۨ/躗4TL-:9q5E6@DNrp~ֻEMsﻭӶֳWR썳dz
ժh⿢W"~%O{׻ֻ*cfgϻ}Ȼ??țU7XR`ֻZi^PZ3o F(9
:;n;sJ;`;Z;;n;<;{u;KFˮ;\L;C_FڻCS:p:0u`/t7;7;:dAP}PjɾSɃ:ɸ:1$Y=:6;65;;W:Uku_&
$
̶7ʂ6:y>
qByq;)w;O;b;ϾT;y
|gSz?ûֺ$9E=9J=sΦu	yeA;cN;w;;@;^;'A;J;;.;Ԑb;ȼ;n;;x::1ݺE[+#g'G50Ȼ{*+G_
N:̩
EAf3
Qϻ-'	8NK`da79:ڧ:x:;4G;yr;:;;;;;T;1;;EU:vR(»U,+d#s7ѻ+lYC,*뻞໳fw^/FU0?2f$j$Cgx`ٺ;޺99c4:::p;7;;;Ԧ;M3;]_;K;̊;5;J;zv;rJ0;
19f_y$7N#XY|iV껇+@ûCzFG^|E>Ȼ`ەbǻr,Yp
H.98Y_|9j::';;@X;MS;E;o;;A;
;;U-;;;(;:;.:]uZ5%vSajX [9nF黴sh(p	`ʻxSvzsi黅4c͎9`:i:&:)::;
p;*;S;6#;;;ϝ;[;Ď>;k;;˼;ҿ;s;L;ٯ;G:]:AyO-Ka&bv3߻i	`gjpuNp黹j{d/k]һ 點
~r8~-CpHr::e/;;:e;H7;";1;?;e#H;;1;t;^;J 2Kv|SĻ@xt㻀绗5MOԻ[/HE͑ػ%v>kǻv&%:\;Qi;;;`;w;_q;A;`;-;;;:H;
<=<;1;ਇ;;_u;s;=;3<<m;[;Mu;Wl;&:YhgHػ>Sɻc>q~tQN!;6Yr#\:]`x"tb}ǻH9B
ûk-"RD>4.WRǺn[9;;v(;q;$;;91;5;t;m*;NL;0;
1;r;w;3'<	<	<u;;Ѝ";;t;˱;E<ã<%
;#;;'.;d;:ᲺS殏W7`OA`iT-޻
ϺJ✫һ0B8]XFul|>Qﻝ仙{$q ,h83$!໫G;䲻X3Sm:Z;!;H`;-;0;o;-D;׺;1Y;;j;;k;u3;@f;;ޕ<@;<@<<;;y;EP;>;;y<<.;;p;o;^1D:ֺĻ0w?sӻFڻ6Z
e˿
{ֻR G*30ZI'qR+ۻI>Oﻎ΂p=J栻`лa˻9V&t\덻H;W D	je}:;"|;;,c;;;&;;	;S=;;C_;
;qf;k;;;<>i<A<XL<	n;n;Ғ;k9;j;O;;<<v;b;;2];̇;0A:>)Pc`ںe.X#:;gR*ۻpR{κK9-vUW"E *t$zJAdnDλuﻃ4HX`96?aol侻[-?%ʻlW &ֺ>
:k;y%;
{;2;;r;;ޛm;\;b;\;;
%;SW;<(;N@q;
;w;<r<
<
,<;i);];#;;;;ʨh;@H;;O;;;n":oT~j*Й+Wͻ.<<
0
悺*z#8g2kYpG#d*j|e|7cw|Zzru$B{ަs}Vջ45iF5w˻/+NqҠE»{ Avt9:=;jN;(;?6;a;};
6;1;A;+;
;e;E;G;~1;>;;;<l<\V<	<;I;΁;0P;0;y;;
;ܻ;ݚ;Z;Lj;;;C9ҩiZѺր&Y6=8n2LPnкeI::T8Kʎf솺-MT&	VL+`]׻\jTIUȢZ2UjػF68`ϻzsyza~8\n=䐺[ۺQ޹{й\?g:4;5T9;;%;;v;;;;;K;<~^=2ڲ=g<.;kmfc`Lq޼
%+
^E&#
N6ܼSg;MN=9\=.=A<=;I7me'ʇ;X伬0xB;nkبH׻1޻]) 
;ξ<CUɼq뼣qAͷ(
F:v;G1H:0:I;T<)<R<ݏO=B1oa9+RdW{
XyZ^MWዽ0jރ;2ڽOνYeQӅ9z p
gϥ"qrd;~?<0KsF7gؽVWkٽ<x@꼇;=xx=PSJ=3=)=$=;j;p;6;x;r+F;u,;qA;i?X;P5;:#:˾;':
;Z;Q;&Y:N:||Tۺf}	K<Ӻa溠
f9:}/::?-#3{P#`EPBŻѢ
NٻM5X`Pr$&-mgü	#CǻV 21vX$pĻ;eŻ|bé@)]%ſld4ǻ
i(KqH:;;c.;V;X;<;{;F<<_<"~81Z|TM(v	Ơg>kSs2Q)in[˻%Ӵ9eTN뻺!K=&:;)7;gJa;S;a;C;;<N<<'V;:;|;;Z;Ƿ;;d;;3y;;;A5:nf:":a;G;f];K; n::{9W?~G:wۯ麞::+:;Z;:8袺i`Ż2g|4v{!F\ϻ%ӊQPV㻴C+yq&m"ǻ3yUݻݞ,v$4᰺2˥FC8kỶX'߻y켄Z4Ik+ʕDX\θX:ڃ;8(;i;zи;v~;u#;;><<@<+<1x<5<6<,3<K<;6;0;;R;4;;d;;iw;@;g;DT;;k܁;.:&Q:;3x;^~;RE;-g;
H:e:uf9S879K9$7+ȺHM.>
u2:q:A:Љ:N;;,;%6:*غ.g+u滁ۻ]0n;f@lPҶ~򉻿&>Ȼyr8"λӻKwͻ*G&߽(%$_*,λ铻@-zļm.^HHA҂N$HBE:%;4b;_;j;cw;eN;:;;s<P<*<2[<6t<7t<3<(<˕<	0;u;߻;(;	;~?;I;1;S;;D;];W;v;>;;Q;:p;);U9;PU;0B_;|I: &::K:>:b:w:r94߹ᆺF/7#!9P:Y:;;;;
;7W;B;9.σR{7bhEJ){lͻֻ˻6ͻ{ӻ˔$Yᶻໟ-$ŻԻM8bj|(Tc
D3=Mk[)
˅z
^w
ˆpSsa|8ݻS8Ǻ5:	;.;C;T-;UA;\P;{C;j;(<<#76<7ŷ<2<*<u<L;;Ӻ{;/;wO;;e;;;,;'r;¹;Ċf;Q;[;;EC{;];5-;Yr;W|;2>;
9:2o:G:jA:B:Ũ,;Jf;B:Jz:18/긟۞9::;	;s;gx;H;3J;A ;#g:p4hԻ ~,/лa*y+;^s滵a%9xON,λM/^eyɻgʻ9Aϱ[F	ٻĻ)Fi\VTo7ܪ%@޺.տƪz>PdP9X:;;;3Ze;Dx2;V=;vF;B;h;<p<&<0<6<7<5<2!<-<%5<S9<R;2:;;1;;ٕ;t;6; ;ī0;`t;:;;F;;;;Nu;M;fA;h;@;9a:ǤS:V:`^: $:ѡ"; ;;;$Xq::mā9ɺ9ٸg:g:&:_;
;e5;	<;;'o;/y;r6:K̺[ջ_=5û4黥uٻ5j?#\5TquOڻtios|gtܻ8a )kېW1&q=W|eKp>mxK"uY2t`34[!@p:c%Yt9':J;D;';G;nN;L@;X;P<<!<&r<.]H<2&<2h)h)AbS뺡|D:	o R8@KXhӻfƻܔ׻+nPѻ/$Nɮ+ms\pMМIRU:m0:q;%Z;VA;?;;{;U<<u< <&<(<%<$w	<&ѳ<)N<&<.<j;F;[;Z;Oa;6;T8;r;;J;Ǝ{;0@;ͮr;&;n;2K;[;fF;dN;gdH;S;1':d:e8:@:}:Þ;2;=;_w;Z;1K:ި:YR9M9ى/:N>:c:w];n;`;ed:~C8Gb>Aͺ褗iO X ﮻;
ç[R:0::8[>㺜ʺFaӉ~9ٻ'q0)K#81(ڻ0e0n#.	--9'y`}8\l?HxRӺ㕅H\9
W76cu*uN9f:;;;f<;u;9;o;;mTQ;{;-;se4;.(:ڄ:1;i;M2;;;֡;;/;r;S;W;өj;;b;;8j;\^;;Ƣ*;p/;#;گ;W;4@;!X5:
1ަjd=q5⺷DƜ:[.LJ޺û% ׻T\}~kc֧=
6<Ӯ=.8r999c@!iO=,:vm;?y;z=;h;3;u;4;;V;R{;i>;$y;;j;1p;:;f;Sk;P3;;F`;˫T;ʇ;[;5;j&;;z;I;[;!;;;4;ȤC;1;@;;\;o0p;C|:Q2,-i=躄#19>B99?8e7Li9:+0;;:):9CLǺzȃ-KVں1ߞ8y93ܹ^0Q`ֺB5㻈Pe`{ػֻT4fҹ}r"8k9p9ݷ)i'=;;S;;;`;5;y~;s;j;];;]~;(h4:޹˺Zۻ
["뺸+պF.nZ:Dx:G:l:+::::;/J;;4:K:E8묁Ge⸺KvźN/9$j::q'Sfѻ9jl+uzثɇvI`݂Q5me?OPЀV99t,9VRe99830Mkt:;=u;|7;;;;D;BF;c;T<;\;pH;}H;P';;`ze;-;:l:i;";c{;Z;.;=;;ˀ;x;';Ũ;@o;u;^;ĝ;;m;֩;L;;[;;p^;Ix;":Տ!9zH.a?kS4"^	#V9:;8Q;l;';/;(;;
;i; ;{:i:9H01Ļ[4kOz|m69t:X:_ǹ\Ȼ+B0+K\UϻȰ^~L297KX+-+?ы8kZ:pbU::;D9;@S;+;(D;;(;-Q;';"^U;v:O:xCлQwKûgFֻ{
!c2!9s:c;-;I;sܘ;;q;$;/H;;@;ix;H;$O_;с::TڹUJ	h[EKٙ!9T:`M:d:#*׺ػlDeaU}$O5wY5$IWY@`\_hIvdڱ:P;W;,;V:D:[:s9tCGy)XL﹚:λ;(U;y+;v;;;ݎ;G;5;;(;;;e;zO;];=|e;#::a:RX::9:;6>;});e;;;tw;K9;L<.;<7C;"_;:":;;(;:=[::ʎ:Փ8::K;;n4:e87.ǣKOﻮ8wɻwX]t\I9
:~;&;;f;$;(;|;_;:;;X;b;p;RF;6G;o:N:4q+gjJs!9$:7l:::=8wkcjj>ihk7C75S;x)к-}rmQ; C_]];H9@]:2s;5;C\G;!r:E:lZ9h۹*cUg+
t.Q:00;
@;Xj;c;g;?;
;2;;< ;g;`;5;ʞ;yN(;T<;8;;f:ΐ[::v:lK::ө;7H;{d;;Tx;g&;Lo^;;):Me:gt:1:B:I:S;~;0::tl:$:5xO:Zew::u:|:SK:F{'d$=EnkRJλ'䳺P>_xW9Qz:u;%+;w0x;; ;z;y;ɱ;;;P; ;yx;gL;Q;,4::+ui[nߺ¬i?wǕֺvƹAj9:tH:p::X٧9\/{ov/Q5N7"*yТ89;m=Uw=70=}=e=ċ=,
<;Ta;#c(*ѽ?½[轂޽a5{Kv
rlLZq|*?myH;D<b¼_g.A~hD de^;e<@ѽtӽľ4'7e{ʽn@iɽ4Zh;,<A<°<<<<9b@O9;;i<;֦:ݗ:<m<4<T<)nZ#F:;#<;r<$O<+w;z!kZ^J\;:g< <K;A.tl9,;>p<4<`6e<;;N<\MJ_j&|l9h[+iqj;f<<;<Ɯ<<3\Ž5uD2bRG밽8͹6O!}tr6RPӺ(c@]A) [i|MgyQۻӻء)Gt~'
ջ㿻oH
X8:q/;;B};jR;z;x;e;b-<S<Ó<Ǩ<K<g<,<<_<
N;-;b;1;&;g;a;};y@;o;;;;B;;m;e;hx;@o;3;4;*;::::;O;	;;)R;1;ln:94>+)A)CG:W:5M:6;:O6:::h9
ZiẨ( pT˻[G^Gѻfs6M쀺e2{`bMӻvٺ7:Y[:::a:b1:
"	9446(Jn5F<ͻG3Λ2|E~ru0෻ʼn̻ʔ^ÚD^qϺ9:x8;S;H<;yI;$;M;;S<(<<L<-<<FP<
I;;";…f;;>;w;Vo;;B#;C;F;N;/;D~;n;vH;nqY;;";;";+U;#p;%:8:|:U;b
;:A:l#;	-;U:9Me'tkR9dw9*9UD69a9%9Ua{5)4NUԻbok_)GŖ=qZxr鄻Wٻ<қNW&wks
h9t:;J;:RZ:+:[C9j9]#7:1*}ɺ%G们>Ą\V7m|۰C䊻`G՞ظ8zvUԻ-옺Oj+6:\:oF;!/;[;e;jE;ܟ;<
<4w<y<iX<
j<
J<e;7;i;;ɇ;G;^;=;;6;;ۢ;;i;Vq;A;o$;;;';;,;;?;6Y;(~:D:a;.;:ؽ::!:װ::9J``AoM꺱qj
I% UIoBDlJF9xcr9r<໅b%»4[nkF\[~eAXy%:Ϻ⍺؆BJ()	й^9,9qO&&,9F$:C;%;K=;9;J::$|E99U15ΨΑº\y'_ -׻rWXxdž=Ѡ%l>MfЯӄ ǻ^\Hk둬ͻkЎ滥UՍ\XҍѺ>9}:2:4;9;(i;G;"d;y<
<<
=<B-<+)<;H;;;X;;޼`;tg;E;SE;wv;sq;=;;ɩ;z;tC;f~;;;|D;F;&;GC;XU#;IQH;::!;:̼7::v}::z9uM0P51&iƺQ%mƆIe
Y?j:TU5pD&z绁nT#֓FlU=_l,BF/%.I|K"J.IM:y:`9&89߉:9U;*;n;vH;E:q:i9 99B2el>!p8c|B#ltYJ/սoF͵#@pH0̉ۻ7ñpڃcWV98:a;|;\|;6;*<<r<<*x;;P
;;<HJ<;H;2;};;a,;;Sp;Z;eAu;a;Rf;N";Qz;:	;	O:;i;<|;]1s;`y;8Y:u::{:::L:f:h#9P7
ƻQ;epF$wȻOuseLTWYpxTǻ׻T׻Y"\	Hл띻@
ʻQ/
v|ƻiӻ);m*@Xٗg?ɺ&q9М:-:M9\9S:^j;;r;~;}:;.:%:9m9(W8	-gRlc= 1D&we)ίBetɻ՟)JIǼOZG򻡞vNw㵠\ú꛺%_DO:4c;;_;r;q:<<
A;B;[;';A6;y"<<E<,;s;͗;R;c;E9v;D;IC;?;&.;t;,M;1;?:&;:Β;7;?;P;::&:2::I:L*:z<:q%:O]9h9}W+TU㻇b'n^{[~dbZlǻy_=ϻ\e|W=ϻe3)>˻;?;;7{:Ҡ:H:SE:K::?::9T%Ŝ~@	Voӻź3OhoRB'..л4^9C9ӹCv!~SͲp:Ub;/;;;<2;:|:YIةSںzBA_}|m9:y;"ڛ;Gs;`ۇ;C;M;>?;q@;;5
;;;});s7;Es;$(;A;&:=]:S:$e:.ˁ:+\:y:;@&6;{;>;k;R;-$;	u:
::%:8ޤ^28r|:Z=:DZH::28pPJ8N9|:9p::Ϳ:91(&,~{nuZػULÝ'$Qj_9d:;Iզ;T;;s;0;XT;θ;;N;;;%;y;a0;.n:::n\!?}}8q;:04:1:;::'O8ePMfl(VJQҺn.$@-鄻)U}7vx:r:s896i	)QA6E9::;wS;+y;b:w:wW8
պ9/кxS=_]:1v:H::M;Q;!;e;D;);~;t3;c;t;;gd;4(;`:u:e*:啲:̢Q::6
96W:F8L:˻y;&r;aQ;/;}x;[a;-D::! :8Ǔ9![yPݺ"(9a:19vWF;B9!q:M:}T::p9
8ߺ>(#2?tu
'wHX;PٹU29r:;l[};e;6;;L/;-;yW;x;H;ia;_;~>;s];S;B:Ŝ:CLD7V_*,7⺅}AT9k:`:::P9,@L-ŻV去U+ME	sXù[T:V:©:A:Rw:?:iН:U::Mi:\;;g:1:ۨ:1F>x]ɢ"kӹnL9:1w:_Ȥ:H:e:ߝ;M;;{;g;?İ;I5;`r;W!t;(:xI:C::ŷ:P::!b::,k:i;;P;m<;nh_;Zt;5a;@u:y:: 19ḤzUf"ƹW町),_:rP%9::F:W:9k󊺄= .UOy@v/(aۂ9n
S:'v;;Q;;4+;;;M;1;o;!;F;lp;`;M;)x1::@!:cK-5ƺ5R~/Һ9:z:n:^F9"*5=E)(uf`QV湢:hs::6}:2:;2U;
::~:>:г;	:C:C:Cm:/羸~D7wj&q899Ԟ:X9L~9EO:;=^q;oK;V;%M;HX;<;F:;#fA:#i:@::(:E:q:E:=:h:;S;F8H;Z;TE;Ew;/;
:1(:Xd9\h
f9'l= $ҹF$bo8:C|:qF:/8ER.CމǺFźZ@?+G7]:?
:}:SC;K3;I;i;F;g;=;A :);0;*6;0˼;n;:qM::/l}9?	7)9=I`9:L:W9 *9$,:gv:::4:ξ;;:*:AE:P:E:q/::x;f;O:(2;T;2;*;C:~:_::9HK;8ϙ
05⤺NqRy~mhp
M;&FU9x::9:1:h58ǻ`m=O)8nʻ\0K>:VZ;8l;gj;Ts;n;p;IA;JS;M;-;C:k:Y\99!8LAuRѺh&y9Q b4}::J:|:3R8
]Mźf8)$ͷ|9ɺ..6p9e\:cs;X;;(;Up;;; ;;;6h;cw;9;V;A^;/;:k:]:/9Pj89$29e:ib::s!8l^$)dz9k/9#9ϝ:?::ŊX::Fd:&:J:e:p0J:K=^:];%;%; -9;;V;:$:8/:1`y:I:9B^=}X0wmOaWu+v,|oo2K];)|9p)T:[:Y2:D޸!^|Z3wh'默)lȻ
DF4Ḙ:;8;RH;;=;=;w;z;";jG;
_:@0.
ں5j	9N:2H9sx9_\::3<:C:e09EBd:H	::Vݞi9t:%i;-;E;;L>;dkJ;4;~;;l;3;;<];Ah;j;i(;>;9;_:Ն:`#:F_9֯M9}9_F:}$y:::[]O7YV8>-%¹W!\9(lc:o4:>I:=p:b:|@:::D?::(ˁ:W;;:cX;,o;g4; ::'9U7|8J8tϹ0hv"+YL|커Jzm$nyJa4-@U7H909%Dba8^λ72"Ͳfg+.PI;]м-0enuZ*D0_=;{S(c߻c:9߹;Gk;<s;.<k<<<#Jo;|g;Y<W2ӽpjl1'Pϼ߼:;\獽9%f)iM1ۜнyuפKvo_Ϊ;xH#X"¼ʷJ-DSޯ?F2ܽo봽dio?мhD⃯<)_=5)=VO[Hq;0ỦҺMBz86Ⱥ麨WI6Prj46V`dcf(ij9::w:39:k};
;Q#;);-P;ur;*4:J:9v8ߺ?=`4x:	: 왻rӻړ'
iҵ?ޮ?)
?${
K䣀0t'Ă溕υx˸jqRxş::|;V!};A;2;0;L;-Q;f;;n;v;ި;酣;j;n;;1;u;U;HQh;32;):::);
ϫ:K:G|Q:M:jb:\::{u9:7:Dh:;;q:	㡃(ҢgJ%p/Q,޻8Pκ.պURc8,߻ƺiy4:::,9%:(:(C;DD;};t;zJ;Cu:tU:bA9~8RVܺ'ipV
T/yEãx"ܶ
klzf4[<.
fڻ܎껵3(j7YZ+J8bZX5:;s!;6';cM;;;sI;:;;͔;;c;{;n;̏;/;	;;_X;B);f::`Bv::N::m:82ϸ49L99/^D8r?:U; ;=;\:m9Ss5"}wUGޖt1'	n仸b껻NK컨/|1>$|^†J@'.t^Ż4偻5,? +(Foo9$9,9%,:;.N;m:;;y;O(;>:wF:	8@빍jU{
ϻ@]N@
-Ӽ"ɀƼ
DR9مβ4n4Dŕ/}pf& >㻅,3
CκǮR5ќC2:U;(_=;|@{;;T;;R;;;H;);;t;wk;;;#};p;2;w;VW[;1f;V::^:j:v{:>18.5pGrDde4:V;;`	
;\;:Iͥ<2[)*鰻SԻO֐ٻEn-'
դuK̿.0Ż˻\U T9
@j#֮!FUæƺ0aY6bɓ9;
;U;}};}&;Yƕ;)E :s:q%9iQ0º~(IX󼜼:!IdhuF~sJ=}]&ߠI㻄x3}&N?\F}л[8a:};=K;ty;d;+;p;;;k;tt;Z;b!;|z;;;͙;;x;q;@V;&N}:+:8:lY:|G:z9lԺ8J|
aKkF9h:QP;Yv;|;M:"*9ʽR8ɹҺNԻJڻ?،2_#%#|aT/͔٘Irաjf`3_7F2
HLg}r<@ߏ׺gjϺh{-6\T))c:,9;,;l;~z;gKe;89;:\":*9bvV@Lq9/c	I>˼̓LS»NJ
Td[;P׻…HkB$Ļ'ۻឺ{ẶǺEB:3^:t;@E;p;9;);w;8;b;yֿ;E|;7;Zbo;;
;~;D7;;e;;G;/;%k::3:8,:9}ºfz6H-9:A;4e;nk;f;=:d9z95 k\̑]@ź&3%.h!g̼l2Kл?ԅHc}tM{2-}kxt֘Ѻvߺqu5*

pºAźuJ8ېZ:J;R=;x;rq;Gu;6:¦:R89=O9T)P	\2dֈaNT_ۼaFn»+UK
QfƼprr˽ـ?9̻XG9JǻGV$%h2MS:zOF;1;C;v;X;g;;+;;^B;̻u
f".9X>׼6&t3#tࠕ:P𽻯^j'5KtZHSNzRɺ$}@A%~afWl}wṃ:A;2O~;l\c;tr;SI;::w:!: )9kWJ3ؕ[ȅܼvCBxXȼ	X  T߻ᠻ+DWO戻Qv׻pphQ@/\k6-:b;
;N;xU;u;u#;r;;;k;bAU;{;;C;};K;9;e2;{;V;'`f;:98 7.930NNt'<;8Y:lAB:Ұ;;^;;:~:99c'ƻS{'=ቼ6iG
JFd:h*r#fm`~,j7ۡݻ.ػ0o6Ӻz人Q";6N+)FNԐ_ʻHQPS":;&;\B;p;X;':81::A6:f:[9mwPT죻[<	#ggW߻l
1`!<\g	ʻ^-zJ1"NtSK];k	:;N';T ;c;TM;hǰ;j;;u;;~3;ą;;;;6;~;:Ï:ޘ;#J;	48:m+*ZAZ8G9toFNESwϜ:g1 :;;G:G:::(!9}?9N8Ljʺ>һ8gB9tg:0;kb::?йEB9p:ۇk;Kpn;{B;;C;r;;Ƭ1;+;F;;~v;R;i;y;Y;0P;);5:UU:$:\:=:7
::\;{:Z:"288qqIY
:Kg:Ɨ:W:j%:Iϓ::ε:u:;H92:RL:Ջ;-;Ce;3I;!V;^:c9'Ѓ[M3-P\Qjd!Ps2$л»ykYRE4\BEB:+Gʹ
~ ݻh[d᜻Z49ݽ:> :k;;Qk;;3;z;8;r;q7#;ZT9`lΟdaWz]eQT*}:\;y:):::::O:z:k@:4Z:jn;
;0[;Vd:F9ٳ:˂;UI\;Q!;Q;g};<;Ǥ;lV;3; ;&;Ը;|A;d;r\;d;;;&P;$;:a8::rH:u)5::K;n;͡:>9%v88uBny:1@:^l::l::@:::L8g}9:߇;4;I;A;8;V=:F9qfǹU5ߛi7@$>Ⱥа@	>ZG#XW`5*ȻBieJ湹|'?f 0zтVL{5
o|IǫvgѻzfoxU p`A9U:`:U:$;
<;vC;{T;?;O;|;Ѡ;Q:0RŜH|a۹J:c;!V;(;v7:./::)::9:^XR:>:0;t;8;>;:O:e~;N;T;;ǕG;ũK;;ȅ;;t;0=;w;׷;u;e;`V;@';'/;$^[;e::P: :S:K;
;%H;(;}\:K5q:D7`:/S:!;'V:C:%^69:@&;:X:q8~O9s":;0|Ƒ$Ѻ%bLP'tQgr.*ִ	;Ѻ]RdP"TYš?ŇλNL&hͻZjh]suKٺZ28:l::G:v;,;\;y;N;E;;mZ;9Ҧ!s`f
OI:::;A!;Aɜ;';;j:ڊ:#g"969$:Z:;+ֈ;ND;>G;L:;CQ;s;y;0I;%;@;;;?<;;ˢ;';ip;\3;HfG;)kP; w;.;o
:A:0<:m:ǝ;;,;-q;^:95鹮
9qv:O:;/ؓ;:d!{R:(:;|9ig:w9]):2;G.;l
;+;c;":t9y9iӕ9x#ٺ㺵^J"$+n&uM㎻qeǻ:y
~Wæ9K3[ɹDSb)[*TkuWqj̻V\l`#l]
!4: ^:Y::!:;f[
;;b;;B;;^:?෺aRl9]9}i 9Q:ŧ&;>C;d3;YѮ;L?;*?:F9IJz˥9:;;g;F	;Vx;?/;%D;ED;%O;;؁x;;;;h;<I<}!;;;;ew~;XT;9=;"H;;~:0::u:J:;!;)K;W:a:9ѹz9kj::;,;*:w;H:ު:'x9<9D`R/̺\%82ֻ!9{^hܻa;;7;
;];;~;/3:9x:&:::8!96:;a;g;;;?i;I:Z:W8Ə09ju:;!-;E;Zq;p;b;n;;;Η;FX;S;۪;;%;gG;A;vE;G;m;6;5;H~;V;'(`:0:`:U:Կ::V::d:r:6::G9E:4;;F(;-:9ȹ++="6@o~|Ȼ$%Vq5!9::O:I:aV8幃6yD9	df-9;x;t;Њ;";*;;\\;O:I:3::u:9n:TN;'X2;=;;;ٝ;߭;@V5:X:.:jI:b)3Lݽ̝p:Jk;9;bV;M:_;W<2<5ĻAB9M647}9_9GA4<|<$d97!]֘8ռ4 JpsR7j;<;x=Ok=AK=1<<
<7p<<;m
;&J;a58י;˒;»M=	I<=*׵=]=Z4=R='-=#J=-T@<ռB;g)1(H;N=V=4=2ܫ=8< n;y:':ۄZOvj೉;N;;#;Xm9vĈVFܼ^q<#==2)=I3=<<< m=^=yu=b2j=D<|<<_?hh=#=H=+G; ;p<0<<5<,?ļ0QFӼPJJF=+UbkXշ㱻ʻ{㞻#˺,{fvXޯ䨈72U!9w8ὺ5,ߓ
U(9nS:;+;R;lZ;\;0}::V:d::B:!Icǽjļ4l*Gza|5cn
Í_yԼ "br̼Miw^J4ѻ|o:лA˻{8_:
;);@,;9r;9<;j+;;;.;;&;;P;
;;;@^:U:1;i;l
:C9mD99柹A	9{:;&L;:D:Y:?B:9`kf9{9Tָ2Dֻxn2&w㲼&0-yAR	UOLl< +(4	ө#cu%a鷻Nz\ɻc{ZW9Mno:Q[\:1-z#K9߄:C;5J;[?5;m;e)";@L;:Ĺ:::΂h:-:hBѻ+ƻ^r靻}ݻۨv!讼
r$kEʷr۴T8j
Xb\{Ҡa4> Zfo96:Ʀl;l;);R;1;x;|
;;ŝ;=;;|7#;~;Q;iH;i&;::b;6;3:oWø8yc:2:
Tƺ
꯺f]ѝ+ղ:vq;7;+:8B:'9}996
R=8I|Hb滑m* =/::6MYl
VlIv6"
oûrP;ӻǻ*I	%@kSB9:':i:?غ	v9:Ԓ;L68;r0;x;q;Y;0::L:}@:eT:X.:Q`[ݻ\&D냐q;YxVgБ@6+=	=düB#ɼt4ߝ-݄ٻJdл{ghmT,Aǻ&ۺ0:A::b::;9
;;i;;;;;C;5;=o;Wl;th;^{;
{::;:֔988:$::
5RcC2?:Ə;;΋:SO9-9+Y9DҜʳoMI从uhƻM#1G6DTmY\R#B].̼&ܼsHǼb賚ˁ"׻wrD.̺xE&;:;<:4+9
ntA8
:̵;D;~S;;{ҳ;qa;[;/x:b:R:::'9ɻ#tjԻT$ިըKҬ^C.̻@D̬Cϻƙz~~˼]%l8*Iѻӵ'˻ʻaQSM|E~"X·迦:9L*:;ҍ:M4::W;A
;Ŀ;ԉ;^;;$-e:l:/;?;Qt;~;[;x:;j;5w:::2Lv:ş:9pa9HȺR"a98$:ʣ)::>9]"9:-2{QGӅL+IxG?30ռ!9$13)23UM6Plc軵dԻ¬ԻaAƿlû](-w	D!Vb
$
	9_v*G^2߻EٻR/9lݥdD;V9w::`h;=;; ;I:I0LW8YP:Q;=;n=;vX;*
;;B4;O; ::;m;:#V:(epҟd\/M9U7Y:;:3̺ewK	뿻s߻'ɜ+Q޼78<.ȼ@TAپ?_8Y+
 C%¼/h+BNӻoQWDޘHû5):j;/~;-U:k:1:":<:;0;!;GR;^F;_p;x;1;;c;.;s2:+:؆:-yFBKr7	G_ma{Wcx
y>ջő]kvk2h1iuܼ	:
+k?67jQQxd-BºUb>F:)::T;-;r[;Y:v0r/:8;1	;`;H;w;6Zh;kk;`;<9;,;/;0i;#3J:":P#5zI!Y9w:tM]㊺dYDHJ-Ș5w/#6#66E79kU9/3ڼ'+%R0,a3w%Ҽ
ػ޻g:7w5<(&:B;;2r;:::P:1;;!Fv; S;1y;J4;R;^L;;%;&;xJ;8;;;:8)5o7-2!#O)id3^wڻǻ׋.#ŻAuVMQcfs+b^?s)l|iϕG[B]T,=iJwSYQz,[,F:8ٱ:	:E::;_;:l:f9/gUn(	:";iu;8D3;U;Ğ;`[;;s~;`>v;S;L;L`;>V;	8:;YmKغb6Ѻ")Z9r)`IcqgJI@^
;
;A;\O;y_;M(;";F;@;;;\*;w.;k;e;ن;);h;`;m;C;;k;;LA;;:š::{N:y:Q:@]:~wS:oM:ʮ:d:S:6:$`;C;Z4w;I:9HX!˻2afOO>)%Eaλ< IdXϻݾqxP9~lK:p9ɺ$!(趷dui=T˷&^:O<:-:\8Ib<t?U7	kk{;)0xWn"9vl9M~98깯5|p?	_:廸7?cl@Zע0٧I*B@68/Ln$i:~v;G(;;u;;;iJ;J|;#e:K;Y{;*;:9ڃ:;Z=;;!;";;w;L{p;^:5:(;;>;at8;Ӛ;XC;;g;e;9v;;3;f;`;;a;L;Ѓ;?;r;U!;d`;y;X;A;y4;>g4;::n::Th::~:a[::ڲ9::_:;
0,;Z!;c;!:2?)oyzFSE7g3yh<[gZi}ܻ'6ԳW-g]纊V
	q78	,lո^W::[S:b#{9MR/*a$9d9_89W8zֆ8$!D90T%Dv&2\2d+[C,zt4+ʹy;8j+:p;V@;;h;yw;Z;\QK;MRv;*;2;WzJ;Ngz;W:;::4;w8D;;c;Q;a;{n=;[e";0 k;;s;/.;`;;X;@	;i;;4;O;aS_;J;x;%;;eTj;+;q;k;K8;OѤ;7;;;lʹ;.a:6:ǟ:!=:1:>::G^::ؤM;m:7:Y;p;N6;h;5:ьλY_/!L{-SJ?&U{Zٿ{S7~Ȋ998T~ewvb:Ox:::l:Fq0UPUn]ڤjEJ2(MRһH7yyq׮*y4jI޺YڹD:#:;";^;v#;Mב;6K;^;;V;W<;CF;;6	:9߹:;:;v%t;ks;Y/@;i&;z;d;9;r:v;;s*;R;ѡ7;f;
w;s;b;P;*;9;	!;Up;6c;;!;6_;/E;,W;T;e;p;;Z;Cؑ;:!:|:;
w;V;:L;F;ۀ;#:N;;At;ha;J":Ѻ:$׹P`$G4HJg\s/yU>cYǻ^&0ڻnͭ@g˶/3GYȹQ7?: :K:Ԙ:Ҥ:A:7xKM	E溩qce<U*1+Ϫs!9E:sG
X9|I9&qj2:zL;)(;^M;Y?;7T;J;;~:;-;^;j;w";
$2:, 59,:D;O;cJ1;Mm;J;c;aZ;?;X:o:&;8j;;0\;Mw;;r;t;y:z:Eb;A;t;<ű:J:A;c;;.4;XN;;;u;A@;ca;":?:!::;
H;$;8;;~;)h;vm;;5;o8;];:Y7c*\\T»sg˻p\MQܵt<ȻܻS6b~jl@&n 9
0hS1'
nxn89G:
'_:,:˨::2f:
:>99r㹺_+9K)G\&dػFN]˷!Vz93::;9ST::&9
A"Tb8:;0z&;St;Ew;Ea;{;;ȁ;;IK;
;H%
:9O:Hl&;;YJ;Tc;?;;F/;R;>
;p:Z;:gI:d;bD;X;C;;&;(;h;6:&\:š;EV;?B:i:HR::߲; ;`޿;6;;F;;x(a;9!:::k;J;";$w:J:;;#ne;f; 0;;e;s$;':
U8G
]	wͻQ,Xa_Lf%ڕh[=31,Ȼyͧ:ƺv,úBtRv,㸙9:&7::cE::ʔO:*f:uJ:B:095Ǻa|vûл.@pFkٻ{zb::WA: :+:qUI:%B:	tߣ#:?,:;1;C;I:9;n;;S;b,;;;m;70;:=:RyL:~(E;2/;;q;;';g;6;*98ڇ%:#;(,:oZ:uT:OL::	;R;;N;C;YV;;Mq;e:x}:;Y;;}:1l::ݽ;8;i;	Q;@,;q
};B:=84{+0ZE
AM}Ļ{l(owjUлv^軽v|W׻nʻ?]7=*NힺU)9F:DF#:J:uh:::H:2:s:x}:r
%4 Ļ>Id=.<л#Ѻ:TF4:!:{:A[:;D:g:C\o,5^9:K;Tr;#+;;;_c;;f;;U;;I!;(:-8Y:BY;(
;^;`;ED;6
a;0-;(8;V::W5;ߊ0h;o;[(0<(=1Sk==:=/=={?h=D%"=Y<'S==(=J=p)=t=;=?2=NF==l<,<%u;>;[s<{==&<0:98;bH&<=i==?.=v=o#=OH=Y='b=2==\<@<ێU<[:ἡ<3<<9=,d=/Ѿ=1֫=m<AL=F=3=@==6O=k=
~=&D===)th=,:=)e<"U3<<<("}=6+=C'<o=+x=3*=1=m
[:%TҺ9584*<6<	=!=o<<-5zq;i_Ԩ;ѻRϼfµۻ3T;q;
*9ۼѦOػ뇮;ҩ<
l;<.<ô|< <;ᵏ;@_üF<3l<.=-= =&[04mǼ1μ0R2x5U6/6&I-<6/ ݻ;v@2ey8f:K;'z;
r:;3:w:J;!R;@,;:C;9;M:p;YK;W%;y]/;;Qi;ګ;{KF;Tua;/:A!:B9(9'8?sGi# B2CvDb/K2dO0uRL*
og,M;FC
Zbe6S)[ebۻ`ys8ߺc)ǜ8-T(9T
e95:nl:];S:|RXv%NF	98:I;&;N;:L;z&;M;p;u_;e0;i;uNv;Xp;D9׻ZBԺUJ8H̻IV_^须7W-c6!00$-.h014)3*t0)#3?4('Ȼ󦻂ǻ4źTA庻J:^;
O;
:ɳ:y+:;;M;Yi;W,;i;{;sɏ;p,S;K|;ē;];q
;h\;y.;3T:K:=X:lA::_Nt5Pqjg#{%p|i*Ĵꮼ.{pIEH׻v`!㗼	#J)LeyfLg˻z|mCº3'X(8	Ȫ:H:::29̺3Ɍ9E:
:빌;;R;;{;J;u1%;w;o;;`d:&S⳺/bvEһ'4ƻ
q&/z,,/K1&35-](ϼ/ 4R-홼yo̂=Hڞ{
+n:q8;;r::h'::;?;h7I;u@;7;^;c;r";;;0;);;;2;}; S:-:;Sl;O:"e9e9ٔ"+]\BY
ϻ1bZ6$Z\ûC,
yڼļ
WH2񸻄$rW{$ǻ45`H5]kyI$ع9M
:Oh:9(~M{Z!~:::F; ;cD(;U;;x;t9;;x;';Q#:`>bϥ2Co&1$RdE2?jA;6'$妮up˼)*+*)>-}0g0|.'(l+2y0N%reV:C޻\̧4+9RG:;X;X`:y:z:v:U;";]+7;{;;ә;m;,;L;;;;J;Z;|;;
:=9;0h;8m;F:':#PΑȆM-6x&
໶ ڻ˱p08\	
Ҽʼ|ZEIϝKS`໇nt#ջ
>ޏaRk꺵b[jc:(:]T:RRBܻk4):g.:-:;0m;o;8;s0;d_T;;;R;;,t:I~~غ"bqK;EY%9v޺)
9%2OzNλʥ@N_(5&ʼ)TK.Z/(޼,Q#''U/1!1b)>
ٖI!>3$
3uz:x;@:/:::V;
q~;C;v;;"r;3;ϳ|;˩";6z;;Q;j;;w;i;Q;f;0;0C;W6;R;(Z::Dܺ޻ԏ>t}K;ٻмq5	μd
gn	H[ay!2N䚻m.Nq76u=7Tġ4{/^3_gt:`:x:j9̺Րyr9{:%:/w;];A;or_;id;S);pm;-;̺Q;u;1:9r,<Ǻ\qPûQ㻆rwvm%h1ԻQ»0Ծ._ӓMY&""!
(H-`*3%׼$:+0t}+Ѽu5D}v]Vf	*!UֻBֻ֛ջ"vᔼϒ)#$Ǽ!E#bz))(Hto
ؘ9!ճ9vfj::dH::;;<(1;ZW;v;R;Y;xt;;;ğ;ÚA;;$;߲;;@;!;ֱ;;;;;M<;s};Vs:1Jv	x%z-⻳7
$ͳӻf7*?	i"'@ֻKE,XM̻44(cft#>nWĺ9\
a>k9B:8(ݺڳbj:4e:D:K:³;``;!e;*P;];Hh;?;&;T;E:4:tF:F/ۻxY-R`:v:z:V:=;d/:(;
;I;Ga:	9^AF>rL%5;;B"cgXCǮIz&Rлܻ!ĻaOڻfojP߻VͳOLKUһ0Q%`t
8(:8p :T:%:K:L:::):Ni:H6i$
  #068RͻrsU»wW&<::-:Vs:M/5:VJ:yO92i]=9
:a:Ƭ:9;;>;t0;>A;v;;D;;?xB:868 :;H8;ht;;U;:;/;-*;)];d:K:.;
:;G;|3;";;;S:m69<:_9OQ(::X;W@;;
;E;;a;!3W:~:p:G:;(:
:9CU:[:C:ӱ:y;P;(~:貼9WC賺
4*E'@J˻Y^
^䔻#i(Vûs6~)bӻb=d7wպcI{ºb
Q%ػ8+<һWOwBT:F
9*::-`&:L:n:::
p909+:gQ:::@e;<;@H;|;;;;;";VlA:'9c@: ;;Y;YȮ;?*;2;3*;=;0k!;:G;;!*;L;;;;;sKպ}v2a㾺oQĹt:[ ;;s;yN;E;;gx;,Q:K99{:$:2:р:9*9d::&:R:	:ԺU:9LBv%ݻN6\˻a`f黄.N:Cݻ\NI5(лɻԻ8q8Zc\m`Rq0
vR9ه:?Z:8:ѱ:=:,:҂::,:8^/"@ǻ膻̻&s{7Xtw绉 @X溞Q:v:Ib:Jn:p:: :y:[:*:n::::.?:W:);>_;u;,;;;pB;:_:A;2l;IU;5{;(#;2;F;P;0n;
O;;;2w;]5;;iP;;XwG:iϺ:7Uh-g*$:;';q;;|;dj;4:p䍝9:}:::c9vH::	:k9:>:r?9DOg$.\\um{4.>QL×s4Rл/T(;%{?5`kfp=b`=
Url^b::e
:d::|::ep:dN:g	9&U%ú,h{$;3{l
{2Z[GssvX
#J:!::b	 :՛::g:y=:Ɠ:R::9:E:Q1:2:,;9V;`;u>;;~;Dc:Vzj92ٸ:d;%O;E;;A;@(
;\;TP;-;";-;9i;S;|a;;n;T;͢4"lm"6"p座08.:.;.M;V	;T;MO{;6a+:͖[5t޼F9F:5|:p!::<9}:9-:W,\9>19
T9K3ȺȑJU8?w$rv`Ն(&8>^	
a^3_/Xb=xFmbA cbe.9*:~:FM:{W:Ly:'9899𐹀j#"BF&u>vN
Ի8߻c-r(tP6LѰ8	:8L:w::1
::/:Mo:g:Ż:ћ::m:KS::2;0`;D;U?;m;eiK;	9>HTO:l:R:&:Ǝ:;f$;M.;_;FYI;/-q;:JL;L;cA;-;;9;;M:Ⱥ>#qлGVSrFqC9@:;(;,+;&_{;%
:8ۖ4L=9f9x:bC:#:-9 v:):9ܹYĹl4#̻a@u-\ا'|SLčį?<盻gm׻ﻎ< ebY|y<ɻ]ػMp=Ǻ8ι`9:fa:[:X:29P96K#rKr.-hC	n V.&ԻM[o"o[(,œ:R::r;;W=;	^;:::˰:I:l:N:j:fS;;'C;,#;BG;a;M:OHV"9:mB:O:S4:9;q;J;M;8;;;Xm;x5[;';;{; ;l;et{M_~staLTR6m:".;
y;;I;&$:,9ȯú=7?ǹ\*9:~`:4:}:e:Z7N$w	*:[J	O_YÊِ&Mg|h8yܩ~ػn#Ry)^YuB߻th*|.oC8::;L:^t:q::!9Bպ@-й;9I:G:p:Q:7*:7M:G"׺yکs?6Wm
Kg>ջQ廲mѝŹ剻=#R.^bhgs黏XReJEKs::]>::M95,~ٺ4RmeKsJA;^{32
UoM|}K
mh>@{ 乁^):l:P;J;/d;59;,Q
;"ݩ;";*p;2!;(;n/;ۀ;	{;;h$;(c;;;=;4O;I_@:n,d >Q/hhVl^v+9N:W|;s;+>;:R;R!Ƽ;!	;gֺ;;;i<9^;5kټ>+ռXՑϼI>:Dk`ooQ<'~;q<:g,$⎼l@%
:;조<]R<;]{2>렪;_<{=FS<~;eU[{j?l;%9;<^<<x;C潞;8b܅;o̼pfY
9LovOZT3X p#[8Ȳ9;zR̼AHN1;5$z<*0?<=
}Wɼᓼ5;_;ƞ;;-x;O;';);z;7t+:p`m9亲iAsȻmk̾qlѼ5
	$5ڼ'[%f;q;-?;Ú;;h;S;"u;ʈR;@;~h;(h;߻	;#S;;r;/c;iP;`;:;;~;Lv;d:A/*Ŋӆu&q3.2fzȕӹ;I
,jv&ȼ%O#{ܼ	惻l unp6dZ'л4pLJřy+\M
]CԸF驸aU'lͻZy{KغW)db~>5JJ|o9d:;:;y;
a9'"7y]C2ủӻ{˻8'׻F;UEqN
+a|$˼!쵼\g9敼9Rq3˻ϻwn*979Yq:a:a:G;3;o|y;;!;‡;φ;+;0;zT;>c;;C;]%;@;;M;Ќy;i;;;;_L;;W;9:.uƺ>P<|T;j,<ֻNjŻʵ˱Tեe*x(^QBϼO8gvûFǻj$3]'Cҽpyﺹٺrƺx	w\ԢxS+0ວY:7:*;̳;e;{4;a!b;XY;X.%;2R;	kS;;1,:RZ	f?TqkDү;tƑj|ڻPOڼJCw %(j$O0

s,$E:IH50!1:d:r:@; ;X;"4;8;,;
;(;-+;6;J#;i;޽;;G$;ˮ;;=;֋;Y;hi;گ;a;;B;kR;L5:_mO~Λݻ-
y]BĻ~iȡӻcϻs)vлaϼ	
5
ܼ~$>#$㠻лϐλK~ypg׻Rcb:>/81`ߺ>^ϥIŸ}ATt(CeD>{9tC:Ť;;A;l;b;W;cp;^4;97;-r;E
0;!:>s,q#`Vr2-"ڻ.W3n,dҐ:جu0#:/x^+ݡ:L
ڼe~z»2q1罺>X\%9:::;!x;M;uL#;Q;j;:;s;͍;&;5;R;,);;@;λ;Ÿ;;%;ܸy;F;zt;j;
;l;W;F&:f<8źԙo6s黯om!Bʻcͮʯwɞ{ C<	&P+"tֻ/0Cf鼻_'4gNS7	8_a/\9ܺ=z}0f_ĺbY޺]W9.	:t;:;-cj;Xz:;c^;_;n2;z;f]r;IE;Oi;G:QCdл[UY
P$	O<7ϼM	9y-ϲvӼ&l6k6~$ټɆ
	
NF|3T޻*>ߘ6:W:;2#~;U&;wIw;;3;v;;Y{;};K;V;Ž;%;;);;y
;R;q;;ġ9;^;j;;;a;O:
h3S;PԻ2\λ eʲ(걻iiF@%]D/ݼ+ZpdOһ?)4bp+D^Ssƻ>[<_j>9z躂'&޺#1|κjœ(ƺz@2j"1
:Y;,;+ݖ;L;at:;iz;~;m;[;gH;Xk;Y@;':6)v;듼q8Ҽ
x
1 F	Ƃ;|;.;;/:;i{;E;6:ِ]3ͻ.蕻v:pֺul:;U:):we:j	:'{̺sfϺ/t7"z
-m:{:Q:&:< :ĩ:58e
QPb'+P}%Yv߻»פz哻s,(>"p&@򻒖vB|x)ٻFػ83KSjg ")
U9ȟX::::>:z}MYJ´ԺT0EƹuV8Pйb860ny"yɯi)J|MU:]:;*:x;;5;H̺;H;Z;<*;g)8P:ł;:Nz<~7/q0j^dk8(:)7;J;\,;E-;":9`lie'%ybX~˻)qj
ܺn?=ѻ	jKQVap3Uܻ-oü1[ƺip!9o:;F;*|;$%\:9D@dpຢ.s˺bH8v9!9祺G/C8[jqW03E:>k:#;'F;CD;e;x	;wfB;};;};w?;v.
;;;6i;z&;T;)B:kk:x:S:F9lv$%7<~P%;j:-:;N/;;+;j;;mh;8x::h:9ځB[^[0T,QRJX}9::|1HغPKxN7W<9:58>Z(|z~s:=O;[V;;#;k;&S*:غNϺFn{xp=emrsUWKu9@t<Ƅ';ջڻ\`o-!Jngֽu1zs9:q;
;8;H;':fG?w;;hD;9%W0'((6nIG8]io7nbtvm$miwk{"A+ƻM_?ݻvK黄׻Z}y"WɺET9:ŭ;w;9;[R;Y
;
:tRֹx|lȲ+!s7$90j:-H+92%	pc]̭:!GǐQd9:
*;;9;f;;;nD;[;ݖ;5;;8;^;J;\;J;
:r9ʞ8W9}7|Gī8޻'9n쫺V9L:i;d;\;,;ّ;;];:::X9ĸDasi61c9 n-ﺺuB:(.ze/9>:S2:d?9!S6uJ7B;M;#;H;ɢ;;C:MU)bV STf6eMb"V򻊋sP/D.ȴʻ)1w';;;DT;9|d,j
a)bҺ}dZ3{9M-ۻ=fm&ݞ@
(;aͻ9NxW\W8λ3E㽙ݻ! 꺬09::4;s;6;h
@;~;PЭ:d:1{h{v7*M:Х:Vu::^Ef,/պȻir9|:m";&1;DR;eKJ;M4;;;;;>;ߋ;;';;z@;6f:ڜ:37޹N	ZqlSO@
WL	:A	h9Hu:;T;;l;&;;"k;\˧;Bm;:q:t:7+Ry٬ {aZ&c
7dӸqM99+ǺlSrVg8d
;;pX;&;ܵ;;Z_:չX:5ֺ/Ժ4b1SW7[c໲*-lɻg٦68*k!ǚ AGɹ?:llK:;;;:%;w2;~;Aa::vTPm:/Z:Mh::6:Z5ﺝҹ9&k-D۹.9t:;!;VF;hj;|;K;;;;;;i;'T;b;%x;T;
T:l9O0o:w9$ɷh'*mGdϺul7:e;;`&;~<՝Q<+;Ʀ EL]f6L=oY'/-ݍu:LkcC\R<=_=D'=w=x==N>=|=P=}=>=:`@=M<@<}!;;<3\<!;%C%;s<)'n<\g|!J.ռKzr;ݹ=ڻ
w 9촷yMb:Fxu;mfoѻ3ĕKzk:꛺Cؼ޽!0&좼ѼP~H߼'#d1BHOxYu-ؠ⼼`/w;1v<^'\,)0z`ż4%XPۼc!6<燽8e >׽*ӽoWڽ=-5u;;G<E-^̵ͼS
OI@qoŽgH$3iqnHH;O?1-:;.$&t;;Կ<ZO<[w<:7!;9VIѻAo;;-	,0M¿gԽڽrs 3'w|]AR߆Ϧ/XVбN<ͼ<מ<;R;;iѻD
MG=軰9n<Y<&
(B~ǼG<"^=1w==G8==n=#*=|	W=^=<;;;;;;A;#;;ה;M;0;nJ;:;B;;;;;_;oh;3::l9@ͺ,[X79ޞrx}U껈\7»޻\-
wDϼ#!Ѽ1/*#QPTһr&X»geix_Ż=lA99d_T=@R*ĹpC:M:;*d;L};c;q;3;;y;H;cZ;_{;F}:)9۔7_F2	!z(J,SʁLx$84D9g h<
7!;͗R"==3ºj:;U$W;h;;Ĩ;.;;;qq;ī;_;Cq;7;";ߡ;;զl;;R;Y;;-;7b;;t;;y;8W:m(:-OP^q3/taL軌:Vrǻ+yƘZoy183^(;Ap(׻U5ŻY{m޻bK%z`6!9Iù]ڲ/`8!7!)Q<9	5:τ;E;KL;i;z;;;;=;t;_@;U; @:\qvyxg
`użۼͼ-ݻ5xm'ۑ*5?2<'VrK	x]BH?/ZH»-e#Nϸ:5;VY;~;
;p;;`;;u;~;];;2;4;;Mx;#;]e;;5;};;*;v;};f;;@:+:tJęNoZhỐѻDUt乻|&tv{QMYe/5+i 8	̑iR`aV6^+8\9(W8e8WNOZݺb|88
ɸ067`::*P:;9fq;i;$;;ڋ;1;;t;eq
;Y[;9o::KH	\KpbЀaL XG	?*E򻙛*jDE/%7`d)ʗl6l	Vջ琻ם
Fu/HVBڹ::;JR;;";:;ˀ;6T;N;;;Mq;I;P;Zn;;;+;0;ۿ;9;];;;d;a;;R;U;ܳ:ZYl6;
^q鉻u滂̻̻}߻]qN2TwƩ&W).,5#ʼ.$T
BpQPdw[-h\g%@akt9\#9 99$ѹA~`:{$9v}
3H|
>ݰ6Q:Tm£˧%押(`d$̼ݟ
p⦼}cĻ 1T=HhúԽe:u;8N;<;r;*Q;Qm;;{;.8;µ;5;(;ƹ;@Q;a;:;u;.;(.;0;?;cm;߰;[>;G\;gb;:A;n*;M:[Cຼ6)|edλi껋Ni7Ytj_kI(ܻ=
n/zSK*O48ȼ0x&s ,}7^!ˆ^hl:sY0@8vNۺ08%:5:~
:';(m:ʋ:`A-?{甂Q
%#c|i*ƻvh)(	apR:߻󅨻頫ӎ,`<Ǻ8|~:4);7;|^;;52;;C;+;<;ϛ;9L;͙;!M;e;i;;@;D;,;';{;]B;`;N;'];'4;Ny;c;msw$2MWhP.*-G.G[::;E;Q#;ݷ;m;;%9:"H^ņܻA.,-u
H7pIq:L7.:ؾ:m:=:͝9WX.غ2p9CI9r}dOṠa9:ZY;	;e_;;;F;;;_;;;;>];;;o;3N::ҹ#ǖI˸:R,a ,j庖%ͻ$/+!:;¡:;.;U;f;x;OC;;\T;;B*::F:"9jo?U1܁uG=LR:źOM_+g[x$G(}캖2:8;m;ŭ;;*;@:9Ҹ0fKqE!RQ0/V^=8S<2K6hE@c3QvAwڸz͸w):i;;a:ښ;;[8;av;ju;!:oϸ0Ѻ\7HA:u:XY:Y::i:y
w8):3h9Kqp/9k:::;Nxe;Z;a-;;`;6;;Zf;;%;ĝ;?;M;B;Zc;4	:2w‡SCY	jVaY?O1Uz9w:;1;,;H;c ;q;z;36;N;}L-;,:;-:#:P6)Á`޺&qOo剆
 0ouwϺú麲徺sE9H;{r;;c;;;]"::*9/G
4%k
&غԣ9l_}лU4p)2˺
_ϺJ۹29EI 9r9Os2Rº!9;N;;-;:P	;'ܣ;{;W;X;[:%9SU?::<:X:]
Z:[:x:ܺr8i:;::)8
:@:S
:oE;[^;;;;D;N;Z;ݍ;2;v8;t=;;t;d;~I;Po:9nܹ\ۦ?M]ڻ:lLiFj8Wf:;;a;*7;MuU;p(;bQ; Z;Y;d;fp;#;:YQtd+޺4ֺUкDT@SZ}f'ꄻ$Ģ[$nXtl.^:;^B;/Z;;;Z;Ex:i":cs9a(iw>ZV趺/TsP2Jֻ	ϻ>&λ
sɺf9չd7p9:Z-:*>H}F1RW:';^%\;l
;52\;#	;a;;lS;9:9j9B:t.:::9:9L9G9H1:5:^":9H::r$:BG:;8RU;;m;;%;ƽ;;;y<
;SY=;dq;;$;?;;G$:딋-?"s÷V 	Vɻ;Ui&::&;l;W;8;a';~n;*;ô;|X;_;Y;%R:9{ĺwo3_Xb޺lJ۸)ɂ'v>ر5M:c-n-{ƺ:5i;d;I;';2;En;;@H
::aŨ.SӺw|+6W⼺iX^
ǰ:=vʘ㻐gN&)պ2N9Gn8N9:YR9JG޺.۱h:;jm;>;;oCQ;o\;C;;d;':9:l:st:E	:I:ܹ<{w8b9Ʀ:.L:::uH: ̇:s;:]9C:;R_;<;Z;kZ;2;lC;:b;U;I;:";];~T;;;;(i9OﺞUBU
)2'Q@tLpMf:Q+;;6s;=Ѯ3<9:hsN9>PhKCUҲIEt3ړ&sQ.?~߽ŽDhz˒p9xƟT':	$;w3,uy&XN^Ϛ<7l,B켠;<(<Ԇ(.,0r0ؙ%s!ѦWkgş:-e;:p/pXpF<CѼ	Ik	
a*dɻͻ综ӻ9{̔dqnH/Xw9:'U:n:;Rڞ;;DK;	$;c;4;C;L<;\;пs;V;V!;;;+;->;N;::M:::2#9.:9M:Sd9;湺r~UpXP[Qu6ljŹijsE+û#/As>\"B $\&a%"T_!W#]( '8n|KݻSv~	::|m:;P;B;;jty;7::hk8X(:;;z:U;;9;[H;uE;{;{;Q;?;Y;;we;tR;3:+>FHAHs9&hWbҼfゼmѻxk{fB~ZL_Rîn`ŻSʻGػE9ֺ+^_:[-:C:Q:;&;J;-;ɇ~;(<<+<<	X<;;;:;(;;,;;;]_l:::f9MFŀq<庴>Tp43\@%Clzj˷w})[eqh=a)׼2 ˼!&&%j'$-ꮼ0/$?Za|j/7䖥:U.j:;)J;~7;О;;#;;%t:9	9U:]:…:ߐ;6; 
;?;aD";|z^;;V3;v7;zs;_+;g;;r;NA:c#xNƮ8ӣc;es;k;;y;\+;6B;0Ko;KJB;G˲;9LIԻ_rnMSyc{hػ&0/4
a5{xCCqλ슻Tmd#SttcTɻ7l|j$ܐk:[:7W;	ȏ:f;	;OJB;;̶;)<k<<v<<hj<G<h;;M;;;E;;vA;:<79I+\`[ZҺ5?ĻXz>9vɺcݸ(\kkq
'
ຣĺܳ69fȸ6PY"5d*ֹieĻ
jc胻fDټx8K'X-9ּ2
:꿼C;@/-FﻑFwW̰G7e69>:>;];_E;-;lj;;qpj;$:uR:p9@!:?o:::C;;f;>T~;m&F;;k*q;>8\;:;@;"I::!7
jڻWqBU>ܮ_FɶKgo-1:4;T;
;<;B(;L;K;p<%<.]<^B<<<g#<fO;;;І;o;;1;Wl;:m
ԑR$]Txr
FBh;
Gqzĺr7S/90::9I7au878溩6p ƻ̜P$-I4Z>rItKӼ<ٗoݻeAa5:{:%;!U;cT;'>;y;	;E:#:%:,:K:T:::a:F;R;G;p;h8;1:܊:z:Q::k98RuX)/#@nû^R؍QNջF=R;8n޻6WHW=ANFHYFZ,5&mp:;;=;;5V;;;Td<6k< <<#5sK={R߼HԼ.AX֚K\cڌ2:c!O:S;%;Yx;A;;];G:::0:9W:|8:::B?;(;$u;R-;`a;4k:лt:r#9)#:U:8rP7N※V;䴻*ܻ*3|sW(JWn;19;#;?;j;Q;;;|o;
996Nɛ7:|
)3y5:6JYrYw
Vz:W+(;wj;<]0;b-R;j';S;E;e;S;o!;4u:[%Ad|mBC[Ɇ+\WlF&^[53:R:@:ͥ
::C<:\\Z:j;;;?<WŻs1'9л:!=oPz:K8:T:+:<:h:Ex:Y;ib;Υ<'.<m<"<;e";bo;}#;):ݕm:`]9r9P9T/@Y^
I8ߙ::l%9N7ݹչI:9 :&3; .;$;;/;;({a;7:6w:U:n:מ;G;";.:>oCҌȺ1&:+{:#:x{x8.CD*Moٝ9C::ɗ::N:i<:;;H7;|;+P;[@:tݹs=$V,ac̝
Ȼ#[d0oF|crr8#hrOnZR:**;!;)H;&;a:x0:?L;#;I;;D5;:=`9`Cv˺0I|޻c!&$a1&6Bǻ1oW
fߴ::;q;q4:?:6;l;.B;;W<<<V<[;ӹ;&;PX;:(9x99P8&P,C'R*('`G~g9Բ:Z@9R%
7,w:o:#L::::'T":B<:ɢ;;::::S:"::VPQ\eh~9_T::Q:-dsCκX캞OjS]9!:0:2k9^8M-9Y: :η;3f;h;X/:K]G^
	m
Ż<9//M`Cd:icn2JD:w`:m:p::S:'y:~;N;;o;,i;
:9sCFvK̻+"W{\	}׭aӻti4 LK):U^:d;r;{;;:(;R&;;)a<<
<;|;\;x;/[:Ο:k9x@:˦:79S(xT,$׻4Y̻9Tܻ6P69ݾ92¹ٹ'+	:?r::::|9nD˺HE`8Gk":	:/::%:icZ:m:fB:Z2
9oĖhؤ8o~:,=:N:_9
ֺ;VަhI`
!5L$MЉ>9ѩ:z1:k;)T;=9:9=; 8>X]Q7{Ru*;52Vd;dHZ3vIh:l:&:u9$7*9A:e;	;38; 6;+:8
.1꺄̺
߹4O'xLRmлhmJ!# 4S9@:f:L:;A;;@R;9;;;p:;^;;z;ΰ;+7;4;!;dE;e:Qu9v:	H:b0:#r亰S(n3A;}-?419L8{AQ
Ǹ99K:cɥ:
9ZBr6Äs5:rQ:˯:l:F:Qk:FD:8ӹhFIGٸ:3R:lt:y9
ܹN\7d6/"BcZFDf=ʺrԺ~R9:=w:`;S:89Cź9c56л4&3Pa'6ݘArdӻF*be9tYz?
S2C:"]:%s9O(xչ?9U1:g;$/;+;::k
qsا)=sfZkƻ-]ٺ$
#NԺ:h}:v:{:2I;
;:e;,;;;;|;;;E;;Z4;s:c-:04:uq`:@9ۺ@P./AN@BvO&~@ݺ89z9B9V:29vm"+Ô9AR:	:6:J:6"P}`5,]Jl\](<Í*p79bK8¹O8,M59N:&U;r;,::r9LCg)(bn׻V*KJr9/#
ӻ$Q\~19:.:; :0::;::':88J7A*yF̻(9#为#GJ9I59Nj&EOJ4r/ûX@Z.8+~?糧J?	0}_l8Э:6\::4[Ӻ(Y3XXnWlpkIWM9T̻!fmVٻP1qzcg[?g
Q{wl?1λdMS_h9|P:	s::9::&C9@w>ŤܺZ3
,'栻PM
_.ip1}cֈ:*x:9!:m:ߛ:]; |y;b;;`;;J,;;;;;X;7:o:[:"8|7	dYo
ػZ!woWk\0eOH9^K:6^9%)KK[;a8*CtW9t4:MW:Y:D	:7:ߌ9yC܎1!3'{F*<ػihDm&OnͻJֻO'>6Mi?65qiurpF(1./p,K[мv汌b,{A;f<Z
켍^#晼./-K)\ۼZH[tϪ2HŦt%Ժ<Ꞽ3"`л;;M::<<&j
|G!U&üPB9e`GSw;V;V9`2ǧ6%T介|$ڜ7;YQ<==;y<<(=m=@=E!^=s7R#YC8?dr# :7N2T9B	DXIsNJ7E2ϵGL9D:M:F#;J;A;[;ő<KM<b< <*R<0<)߇<V;;I~;;X;Ul;+|:9V%+Żq7[m9y
κ)~ɻ@;ғXKǻR-?tIt˖l38Di:&W^ |O[	[dRkz.E.Xw5!7.޻;>3$/9:eK:$;.V;gM;;<U<U<#<.`<.|<'<;;';um;8;i4:e:]v䶺֧W9]Ȼ]DS׻:4Qv:kGzW,̕Fk%cW::A::G
55SS[g9:T:Lu:WPd__ֻ'Ԅ^`C޼"P+1Ħ5+-vڻ/PϺlL8r:=C:}6:FtP966:;:t; ;&;	l::v:_:<;7b;U;::#j::g:v8Dq޻s@4tcuѓo̖xr8ͻU?:y3:^ʸX:ߺnj>N*&$"ӻ#W@g){q
=&!ҏ9Ɲ:;?;NN;O;;1<<H<%<, <",<	u;@#;2;Z;4:-y::l
9q)*$I^|jF;Q-Yss(ػBC׺nUS9m:::9A~"7\:`::eݺ]+@⻛Nʄ'<ûػ آL3B"'&dL$3Vjls
[a9Ø:U:>944#kc9c::B;;O:b:P1:(O:;
;C';H>;D::R:k90%W`VrݻІ4#Յh|
'Q=fϻӻf
::Q:wﺓ[nu2~;43twi!ݹ^
89:x;4f;tO;(g;;B<<4E<"C@<P><;	;;K];M*:-:k:79rӒߤuC&HXyͻx%V6ûKRc}wHh_8$躜ǺG:lO:p:Ͱ}:C:)ŸVq:cV:V:SeT7SƢED+t&
ܼټtѼi}cϗ<)ɻ%Jφ185:0:G9#˹Ӹ
:::,:t:::.:<:or;;5u;::9r98t.fwM͝\
޳-|:	d0T~g~1:I:$:Wx4kbpn|elӕ99bk+,j{j:F;
q;Zo;2;;(;E<<<<
7;;;U;sj ;:T9[b^=ٻԻ5Sd0ZqMQ4X3@C3_l)o4f!En/a!ڹ::CK:Ͱ:L:[Vg9D{8$kj9gH:L:(ğTW"N"黷/$d1һ@uLP˟'qs
Ho04λPL;HK9:9v)?(BxǸ@:#b:M:=:3:U.:6:q:~]:%;!;sb:9ΰ\1qQDܞLMsxй)TLd{6xػY\Pg@3?:H:'::M{mh-q"P{9ƿa:D9e{bߺ_a-\:];4z;;j;T;Ԓq;m<<	<EE;;1;;v;/':~74VX&
	3DV$}f1OR( :MWknRJ]:::A:999[:(:rukP`廱5YrHb
R1j;PI{pܻNg,=:㺹88eɺa.̺uź.|7:O-:$;\@;::ƛ^:zd:Z::|:qW9T,~71ĔQߣmEH{ʾڻ	껠bڻ'3ȺԺa*T9:F>b7,չ4:ƕ:(͹>A.Wy^;pXPI:w4 wDoqKTǀ@PJںcϹt̹?WC&ߔ{y9t::|:+$W9NٺM愺oU֡{Z}aez66;5N'ߡv9j:"#Ҍ]9k:v:n:;M;EV9;{a;i
;A;C;^\;?;;a;s;U;o:̣9ۧS0 ҺH
o)8toB'%|]:
n9^fऺq3^z)kH3홻. 2y9:e:sD:@s::!9kC8Ĺ}aD4
~)7DR[MYϻӴc6Mm5B
)Y	r!9ac:J2G^+N?ymRk}TZ;H<5s"ba"5 V|xi9&ҺpǺ{@o=z%ٙӺ
:nf:x:{:9-::ZpC)gn c{/&\7tg
4⻇me
Kh߻6
dnK-̽J躗u)W4mYAлarlv廀[}cyawջ},u6T&y|&)܊zD@oQIĺ__r^;t([NhywEk4W'7dEؙ:U57.gs1khI::GG7'A:,U::gH;#;[k[;;L;z;ɢ;;;;7;;#;":HOLUVp-H˻
\4g'kaѺ^fs1ղջEƿt:D@:jX:G9#X99`7d'[cV
CS92ԃcdKb,:^pL`2q6Pٺ>rf1xYn	.#~H,ȋổ#7MRDTB Lb7λ 3u/$@ߺZ_ͷ$úlYgZe݂wRǦ~V\k}xZdMکG9T::K8]4J^9k:ɕ:h;HB;|8;C;;F;;	';•;;;l?;g4:7F庲Bx$ԝ{s=	ˮWrTLf6л+U0ݍ5`cݘך5D|k&yD:F׿:J9y%wS_G<
vt_x0'
*~;Ÿн`4d#iNa0k9Ϩ8#jVd5{emF8Y껓[+qy@4w6ٻhd'e
ߺb!OCû^ᙻV
CӠ*í֭98n)%"U̻ѼaQB]ɻGua)ʜћ#i׏疻ѻac=aѺoP99Ռ)红KHrzUƹ^F}#RQ'𻝚A,Z$x)8d `g7 \>jDF	c7YYȄ޺$n!κ(I-?^ऺ݊#qVR8kw2<Ժ;9:(:^F9)B9"s>: I:;L;;;[";p
;q(;;|G;U;ā;e;gx;0V;~6P:N1(Uy#vdp{sc=u7<\SX~EV/.:89O/]Mtoc~R~GLBs01$mQػvՉr_c'!x,}59d@>ǺzxbzPU,ꐻۻ
#U_ﻊE^AZa»,SC7-Cy:a$ZuZe3ϺzĻ
5xG^]#A6Oܻ)걪\Ė솺=\|4~SƻC+49>98g9L>O:|:;!;*2;B;];-;A8;C;6	;X;K;%;ĺ;K;N9:{_o:aK}JoB$lyղRûW7%ܐκժΚդ
(T˷\9Ӻn/]s]*̺gϺPػ7F^y\C$YSy4px8aRyjy仢˻vJqD\&ѹ؈ẙTn8i&ᶻW|6MI+뻓SV4zAi"ƺT$sTͺYbi&S,#]#?9 ,9'꺯Ӻh}m+v+@-χt
xVȺ-
9ѡ:;
;F;^**;u;},;;Э;o;/;<;;d;l;"I&:Sgvvֻ*]N٣~[>Ļ&
¢hn1>n@#]EP<4lͺϳ59ttx@*
)
Vv)ԻjϫeaQˉl:ރ}a"뽠 ӽiҽ"&zʍ&H9(8<"G<@;;&r̫ʽ(Ri\SA&X5^o;m	<\Awln˽B+3̒:
;Px;*7݇:sǼ~ٽUO^轊J㽛3$ggX N޼<	< <v<&<ㅥ3<_<̐H;%1Q
$ʻ!0p6h$6j?ǽ4x
 мcHŻd)RU$aɼ-skp,b)5K[n<<ݹ<&AE4*QWս;
CEZS;<<<<@B<w<<7@<;i<51i;=>I=-l="<3=x=6#<̺)92zE<<'VջF,+;.څ"EEy7Ѽմ<<<<<4<<֯<̹y:)Sz.x\W.g5XODq~֗Dd׼t]׼;>
;xݺiqrOYo)@Ef:Ky:;m;;G:m:D:_
:e:z~: X`.]7\-l+λv(黧I;w
P滣FL4b*9%:K:8:W:
n0Ňغ纚s̹h:@:m/[:fb:o:::<:p:6x:':9:#;Mz;;z;Ђ;غK;ߨ;); ;й;;;m{;q9|bm}1v3Sn|iKo]ֻ=lϻ(%$ +?ػY#P:\7D:;:;"[=:w99=9ЉE9gֹ ,ͻB\|ջҤD3cYPYyCf?Ƅ{:ON::1t:4::̐:j:2:):;::];N:;;;;C;P9;+;X@;%;>;S;2;v;M:	\CMjd߻!ջAhc)})sP|. hiS#5'aZ:BY;M;MX;0:V'99ߐ8ȯ^ кGb&u4reOI-z߻Իi̻$Ի̡A+K[RnW)B0߇dۻ
(ʻ
}i:h:ݛ;(N;;N:b:VH9
99Ϲ--ah>Zf:λ*f\׻޻*i&Ld})AD:{:ԕ::::w:9I3m"0	e85":b::a:a:x;m;
;x;#|;?%;J;D;Hv;n;;`;;;Ə;rB;F;/7;j;@~:(f
E$E"_hJɻv[7.]\diRj;ǺWԺQ:t;J;h^;-:c:9=7gȺ1ºگ@鳻Zg@l
nʻfԻUCR=Ố9V@O-bPuG,bY45[$k8ѺV&2:n:R;;y:::M0e:99J2캇a_nZ	GJܭmiHW1꘻=;9":yN:|:YU:9k}T8O:e: <:|s:;FY;(9;>R;Bur;Ke;k;}Q;G;x';tF;S;Ot;3;(d;k;);&;;,;B~:P1WF2Ժ%!ӻUc4qaS$I(井ߺAѹu:>+;5];m;Kc::V9ځd8؊εj0>;B?e=Xd:M6;a߻7j5ۃU*]{ܽĻa1ֻoqa+M:n:sW:	:۾:g::~0_:[5:19IrĻsYq!.fuQMwX)W4ݺt}/8h::ܓ::h8κ
n:ف::qe:sa;
;7XH;g;{#_;y1;ݣ;;;l;!;;<;!;";;;;yq;E;E:)ĺ2ܻ#3a+ 5rF("o:W~;;^¡;Y
;8:9:8̍9̹G||Vl#5ХoH+\>׻3fOc'o+T+һTV8J:`;M:::V:6:v:~::nH:(\9En'nR#k~|k!Ye59P{<ֹ-9Rn:ic:t:M+VLo:rJ;mx;R;A;BM;;ȡ;cD;y;O;ש;#;5;;;M;^;KY;C;;5;;7F1n:e:s;=؈;S;'d:::%F	l&2V>˺|߻/ut""ɻfиV Y؏&.)p iW6ZAD:2:h4:u:a:::úl:<:ۖ:;8#"`fScXǻGS &^yE(9DF@"69/9sL*# u9]:;4L;R;k|;g;;;+;ʏ;6;6;;ņ;;I7;;;;;];$;+:9,;`S԰(}lJɡTI=ը.0l9Ca:;	;5N;&::;j:^8nsI̺KVڑǻ|#ٻjŻaJ!I»؝ӻsck{'tEC[_:	9ANԙ໒3vY;c,_R0|绣t׏Bǻ{m主}2aS蹻W,V$=e> hho88P8'*}w."	麵eZM{/qOL%3
6DX;ٻ#$q}h?8ܟZ~&9ED4ι*cXYB7&.9h:a;;K;{Q;}';n;;)a;ɍr;ռ;;;O;R;;\;&G:$:7/X׋O~/
&-f׻."
q	Ĩ6FG8̹ܸ@v{U~I~oc׺L{ɃjTfڻUl豻Իؼp!ؼlwF("~fB軞bNzfP)AaI![f黴 T;,k$xD)1S+`*Ê8`fcecb&
o89X97sP[s,vcBVxPcm?@@L+11djgCfV9k,9OĹgvźwgdžl9R9b\0鸱]o:u8;;I%.;c;;B?;^;Q;Hk;*;*;R<BT;Z;ƽ;;;GY::]3rx$ɻ/+ g
GƫM
kQDκ$Ea'ǰ
=Gs鹃Tӹ[.9:-9л:)bֻZ
H
@?NP~:+ցmpV:H4,\7bhiV^]ӻ5P#t"pAK8?̺ww^5Bź$:[fXι8l9?RҸf,QTyl=vZLnȻ%N&`I!Go=>9@"7;yYпs9:^j:	9Z:L/:;@;;F;/;;;;ӛ^;S};Ѯ;v<7<7;.;u ;A;n*;b:#b\`ݖORCŻ;?!#8ZyN̺ۺyzѹf@9)16:z::9u)3]hAC)NRf8Ȓ҉>HKZj\4ӻLR=S<ѻR軀]Vl/_@`7!؋dVxʺr|WXR;TsSV$Sj΃۟#ͻMi`'}Mh]x!B20:r:O:cm9窻#HfmoP̣͌l*B1&}>ѻAi:޻v$SD2b:ֻ<Nt,s]X-=+&~fz
r4/xR]!:Ta
L{Ѻ$iҺǺ!!w/ƻ5^Tޔ^m	ٻoݠVsi	!Oc`?9R֑:o:M:Z-;2;N3;x;	;;;ғ0;;W";6;n<F<p<<;捧;';;8:s6:29nf/˺}ɺCnفAٹ[T99՚:(:B::_9!(R;>+лS"y>».O0񻅶`CA3v.?!JezQzb8D孻^s[varbNh9B9QH.V]i)YKT
t'ºTͺg4O	aJwߛ<,@d#J8^9<:O:%;	T;'H;^;hX;;;9;;;7x;Hc;<
(<Z<'<m;;-;'z;::m:Ͻ:r(9m93:F:=::a9Uf$|#&
s^S?ߺ%Ǻ\7=?=B=9=5}=<=F7-=N=K)=*<<4ۻ	r(8PE2j:ִ<($;tפ;;qr;;%!A/`)N_6+.a!iJvIDѺ;滇-;n<<ɠ7<%Lҽ-}<^%0=zX=>O=J9+=(١<2;@μv}E)>	̼|99<
=N.БؼK2°<k<$=<_<=<<<$+<<=*= <ק:ҼżF߼2t+s8R;6;p<=<\<!9*E{V<<Ǩ޼I#W?De:
;L;>pcѼX)仌Lû,ۻ7բ<*<;o_W;y;iiм= Wc;
N-ӻqGaūɹlg?}kw9mo:c:D:;	9N9$wvֺL:`Dj
Ⱥ$,f&uw㺝i*ºh#5m):O;;;s;<#<a<E;o;;	W;:;];;;;+N;&;;\;?Q::t8h8d7.ۢ,!ݺ\/N](i`9K:J7:Yi9޶$zBQB^8`=:2A9W}Nӻ#+xW>
b/p#Ϸ乤qo~Voٺs/996?ºꩺ|޹":̺S08u:D;l;;T<O<ϱ<.<2<(<<g;S;;OTb;B/K;j;;;f;$:::|P8{FJva.קl9:
:8`l:9Y-ȮJq7uikg	Фd.sлRGʮͻ^sSjQk"FlDOw& Ǻ>йs.A.-ˣ9jc)2r)v,J:;$Y;4Q;;<e<J<.]0p_Ѻw[ce K/wܻF0(ºKy2{7hV,JsZ
':I;aS;o;֜5;1<<
<rq;;wX;ss;;u;t;D;:O;?B;?:#3g񧹆X:w&:f,9}ͺ0b9ӻ+h34N)[黒*bsӻ&,ʠ6di⺓.Ժ"*	ni{$p4
:e;fK;;;P<<>q;1;v;;;u;R;,;;*;07I;.v:!<Ɉ[,9Wn8C[aq5%#b<{!f_ڻH
iһWw27T9ֺqо`ҭs컋pû
OʻectV;#7;'<<
̟;…;G:
:29TT4Da)7&6ϝ
:;;B;9Kܺ$
׻ogG,M%;8P;<;r7;Y:K.:9L%֟"kǻp`Ļ83:B;g;:D:qA](DûCI;f< <	;N:d:/9I%P+㻘,:\@;NQ;m
mz׻ջG~dZh;<;;5q:Rfo8ʺIy{Vһ:;>l;:wt~(N3e;3,;8Z;]z:hi`5huһ1j:;h|9ӻ);^;*:Ʀ֬g;FK:΃Y4;<;3,DM;Ua;CL;`:ol:oR:|:մ;Hw;Ab;r;*u;;$;;;d;;<o<f;{;';.;;i0;IV:8}4M/7kǺrS)WxB;hGu8)8ֻ8+Ҡ7`Ż"R_V㥻5yx7cTs]f`
⻕-w}vSgqUSֻY5ld:aK:;Q:::#:J:g:7;/::%8&_q38k`xAh~ʺVPںЬ4TI9s::-::;";R(L;v;Z;5;;;;³;q;;6;;ĶI;d;(;Bї:!N9'꺋[񩻑»=J@qּ7SCMJrVH]Ew:_b;j;AoG;KӾ;*:';:+Q;($;w:
:9h9SX9B:z:W)>H_κ٠hy3=7S:V<:#8;%k;9<^;N;L;];j;;ο;;;;SA;V;WM;#:9&e Pg/=.鍒ͺqQ)m80`Wz/iqbນlT𡻔໤S뻶gcZԅpWf|Lqĺx>j:;$=;Kl;=J;:;K;:U:#::&':>Q:₃:57Ư"|K (!Q999:|:;';/W;7ځ;+c;7);@;`?;s;2:;R;Td;uW;JR;ҟ::|,"9`j,⮺|/WJ߹ֹ׃?oEغ)uްݻ8|2tI⇻! ûѼN>twș仕JW9m3I9J:;7;@ab;";;
^;
q:::::*I;Wf;U:B:1;0-
8L:F:Pg;};!; ?;{Y;A;I>;'';1;n;T;;j	;0b;:::A'b9v?S|
}غ{_hZ9
Gxll-jBd$`9Q9MeӺ?pʻ$Fȡ#GPbX[ѻ`NpG:-;
z;:;:;-;/#J;%[:%
:e:p=3;7;D;3:l8X)9:;Z;;;,;
P:d::U:P:z: M;z;@/; Ƭ:[:`:#<9ۭ{8znw:WD@YGൺ'&:q:$.}<#QC1ټn7:;@;N};@Ⱦ;8O;$9j:b:UD:9A;
;A!;#ʱ:o9ȓ9:;;;Q:۫:9_~35-:$:	;Y::c9;/9zdќG("g VH2!n95:D>:}N~(ԻF@@pzVє8RBʺ%:
;JY;m;]#;B9;:@9:LJ:;	;0m; ::i>:]::;HJ:HN:;:5Qֆ8:m5Ү:d#t::Y]:[x9չ43"'v6eEY:$$:9:YP`L&:ؼ;#z㻿Bvw:Ր;S;;;\};%]
:y:i:Y;"P;#V;Y::):x;s::i\9>e4~78:,Z!:5w9h&17׺dϘD#:#>9 ɺɋhhHxtۻ"$:;Nȯ;T;7;,;@:҉:':(};~;(;ۀ;p:tH:e:Q9hrw%gkU:9t1:xe9}8b677x7'dW.
KP5⻖~ܹ;#O<;
;;;o;b:[;ʖ;-;>h;4;I:ݹ:btv~h)J P59:IR:US9clѿwx̏NF2u	]+q:C;;\;;!;J;,U;<;R;WX;;:J:?xǺ[.ȻDFĹ{#::Ѡ:^¹@i×<ɝEdB!#	5J;-GV;;);;hV;MW;b;oW;[B;9!Zt7pJIMYP@<"<:oa^;H:96tẾZ)vD4*am#Ⱥ;,;P;;r;Z;tL ;pU~;,:L	ms6ʻWU0&9J;';0H:Ŕ%>dxr|vA	:On;=;;pL;Z2K;o;EwY:zгB8YA/;#!;Z;91$[.,P;U;Y;n;W ;R:\heCzS=„7;};zS;*1
-/-:95i;;w;Tl;1!AA:&
;7;8zsRp;"m;;HQ9˻>ûΜ;!;m༻ ;;x6":I:0wyFhealpy-1.10.3/healpy/test/data/smoothing_3_11_config_test_smoothing_masked.par0000664000175000017500000000031513010374155027733 0ustar  zoncazonca00000000000000infile = wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked.fits
outfile = !wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked_smoothed10deg_fortran.fits
simul_type = 2
fwhm_arcmin = 600
nlmax = 64
iter_order = 3
healpy-1.10.3/healpy/test/data/smoothing_3_11_config_test_smoothing_notmasked.par0000664000175000017500000000027713010374155030463 0ustar  zoncazonca00000000000000infile = wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits
outfile = !wmap_band_iqumap_r9_7yr_W_v4_udgraded32_smoothed10deg_fortran.fits
simul_type = 2
fwhm_arcmin = 600
nlmax = 64
iter_order = 3
healpy-1.10.3/healpy/test/data/synfast_3_11_config_test_synfast.par0000664000175000017500000000033113010374155025545 0ustar  zoncazonca00000000000000infile = cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_IQU_lmax64_rmmono_3iter.fits
outfile = !map_synfast_fortran_seed12345.fits
simul_type = 1
nsmax = 32
nlmax = 64
iseed = 12345
fwhm_arcmin = 420
applywindows = false
healpy-1.10.3/healpy/test/data/wmap_band_iqumap_r9_7yr_V_v4_udgraded32.fits0000664000175000017500000045760013010374155027023 0ustar  zoncazonca00000000000000SIMPLE  =                    T / conforms to FITS standard                      BITPIX  =                    8 / array data type                                NAXIS   =                    0 / number of array dimensions                     EXTEND  =                    T                                                  END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / array data type                                NAXIS   =                    2 / number of array dimensions                     NAXIS1  =                12288 / length of dimension 1                          NAXIS2  =                   12 / length of dimension 2                          PCOUNT  =                    0 / number of group parameters                     GCOUNT  =                    1 / number of groups                               TFIELDS =                    3 / number of table fields                         TTYPE1  = 'I_STOKES'                                                            TFORM1  = '1024E   '                                                            TTYPE2  = 'Q_STOKES'                                                            TFORM2  = '1024E   '                                                            TTYPE3  = 'U_STOKES'                                                            TFORM3  = '1024E   '                                                            PIXTYPE = 'HEALPIX '           / HEALPIX pixelisation                           ORDERING= 'RING    '           / Pixel ordering scheme, either RING or NESTED   EXTNAME = 'xtension'           / name of this binary table extension            NSIDE   =                   32 / Resolution parameter of HEALPIX                FIRSTPIX=                    0 / First pixel # (0 based)                        LASTPIX =                12287 / Last pixel # (0 based)                         INDXSCHM= 'IMPLICIT'           / Indexing: IMPLICIT or EXPLICIT                 END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             an'ڽ[eHֺ5<)<7< Y;;=}="6<P=2f=d><TA$===h<5=V=*>V=wk=^3ۻTՈ=T=-5<)<=9=F],=G<=
y<%=-=(>>GQ><===|P=Ć0=,=dۛ=^5=;<%+{x|z'E>>%'=b=>===Y==S)=}e=bk=a=\`<>!=<=:==C;=q='N>|w>,o=C==VN<`=R=Q\/=O=Dv=\л]<۴=;)"=;=W=)U=K-KpR==:=rRŞ====;=4?;=Ɯ>==|@=$0==6=3*0=g=];=&==Yu =M=<=<Ѥg=*=Þ8=0	=DA=)64
1d=>=DT=>=	л;F<wU<=nu=|=Bo>ߧ=M<a<]4:}L=<"w<5@7=>1l=Ch=\;<ǽ-Cf+=)R0=[S=x===*=X<3<;2R=	=V=<һf=!D<2ٽ#jgrF=@{<]ٻ=BG]=< }}= KoQ<=P`=FB=Ķ=})?3<=!Z>4==Bf==Ϩ=zN=j<:=c=q	<'X"=7Ӽ{@=R=*:λ{H<?;λT<;Df;=#=i^_+=7<=F=;PY,JNy<ԝ^ˀ]RG^<N<Ш41X%֮88/&*
}fTڼ~8=F{bW<.= R<;=7<^l"<<%<1[У=J=˛===
ͽa:<
;#<ӥNiw6%=&;<6n=\;$C޼g޼ǼBf9=l8=1Hʝ=Bs=_
*<:=m=a=g=I=m=U;==?=r=E<1=/=
=.==ۀ=43),=Q</<&绨w%"Hl¹=U=Y=*=Xie=ED	;<_M=l^/<$+<l齓d=O=̼<%b]=)<1=B=b]d==+J=!ż/ C=`i6=a;N=9>8=(=_$==v=:?=+=Խ=*N.롼PU<
5;Ԅ=1۟=,:=<[RU=ۯ=iǼ2VڹE<%V,{Ev=FI^=`}=<@===%=Z;v,=qE=(X=E<^N;s=&=s=}[=N=D=Ю;l;xȺN<;OZ;k9?:~9$S;};:;zEg;Y6d;/f:%bW_;:$6H"_-H;HH;9i;=O/D;=;	;j{kNJ;sȹiY7;6ԕoŹFɚ@󅛻VH;;a9,R.%K<C;,	6;`:ѣd{ꋢ;e;<#La:4X;\Mb:cK::/~;p; ;2n>ƻ{%Ѐqk8xD@o:':N;*:߻:.:>::S:ȶ;n
i;d*1#Yi::";U;;u
<T;T:0;B G;iB3ȋ<́<(k<8;T[;#y:r&;,W:1f;`iQ;}t$8ܺ;ܪ |#;H93蹜<;THϼ);1T
;;?˺;dP;ް雺,z$_|*(Z8{Yɻim<ZTUﷶj;9qɼ<,aZ$;]f;ĩ<dž:>;N	59;;*9;2Zor!:"% ;!H:ыpZѻ2,:Eס
o:v;3;5>(;>!-W:м3`9x;f!0;S㻙Ȧ8hc˺r7`:;>x9;.
;ٻf;;P6y:㐺Wռ
oмx<9L绦:F.<mb;E;;h;:IE;̺'M;-㻹KEgt;S`Ы:7y; c|anY:ԹJ
&;kg<;h49:H{xHu:Nϼnj;оZ:pF:;s
At;:ݻ4,F
y*8;D4:s8o;N;I	K̺d:7<4<+i);D%$;=:;;0@9W:
Y.Ӱc;e嶘;;4:fUC>;>5:BӅ،::DǠợW	;MI;U:)d|qK;~uB:׺ܐU:I;;P(*:RKɺޖ=x;L2;G":TpU;x&⻁e;u,`.;zjջ19 ͗><;<+؟;:Ṟ2
<_ˬ;ջCQM;A6`:G3"0F:g/
?X;)s<;;;;Gh<5Dž;SL<8N<Q;.4m.㕺7ޏӓ$UBYệz<ջ<2;vԺsB;FE.;l:sq|^:
S;,4;\92"o;9ZDX:P::.;Ym:BFy;{;˱M*wB:;^K;V;?
;3qV;L;[:=O;u1K";99;&;)o2Y}>9#b:\J;ԺI;A;T8߸P&u=;!;>D8;;@A;;T'9/+i#,-:Es}}5Xb;Wx0'9;).:ˡ;p\+;$,Ŵ<
uպ;oN<أ;rQջO#LN-޿`;]w:m;}.;:kT3;	;Pt;|<A
bS(6*},;D!4c#i;2Bd;,Da:{oy:9;>u<:;|O?;ɻ+/;4U4'r+\4V;k	:)~/;@<;SBKMp;G|<9:;S/;ȹ;H<4;agj_Q9/lrK;m:#a;˼aǺ%P:i99AQۏ<x::|]C
;t:A;_""W0)t<
z};~,ϻC9:'<3sY;Ktj<<%1;M$<;FJֻ⻂:n-Mu
e4g;zI;9:;;䭺z; BH;l;伨W:ກ9M;F%EWA:
(;;.9͆;4:["asG;/<c;;S<S;<[Tʜ9q;;<'8,E894 l:+໚: 9ע^#:^9B;b#;	o_;K;р
v:
s;ࣻO4:g:$c;Y?-;:7:Y.ͼBu9>߼bo;
q:}h;;Ǻ^;xJK6<7ʺ ;TO;::u:컎=9;Fb<0p;Gj:
;m;y;S<޳==WS	n=<H===b=ZL_#=o;,)D+=Au+Z9<{q=W>>E===ݣ=f=G=>==i=;.M<<~=pX<ż>8
0QO-B=`<@⮺\ë:=4fhI½N<~=ʇ<JG=O="=<=	,Zr4h'=g;;=x?QF/c=E"ƼӲ<==M=Q-s=&<m<]=3R=
ν9o<\j< JDyýӽ6[e=~<Ȅsw76(=$=K==);7VwyRl<ϼ=c=9>Zbsɽh==AP7W>Mr=Y=0
<=Z6=|9|;hϫƽ,;|1<{^=CR>?zN;{r	3={F=,=;t=t=;$B;eѼ<=.=ύ=d"H$Y<=L$=c>)*/R/<犳=͉=;@GL<}.=6ȼŃ3=7ќ0nC=!V==ک>*u+=<=I>
rr=$=u@9BY;]:NG;rp;nĺw;;@3ͼ)9E;4;zZBK<4':N4#:S%ӻ.;;UJaXT?Z&w&;5;Gں^M/ɹH;-3Q;Gz9T8JS;=9nm;fߋ:Gɻ];v9ZWdX默-
B,ƬCG)[g|f:ٓ!⻚;3I:$TX8wo;uźx;ӏD;[yRl$;ݯ;;O*ymO!,:_-[]_:c<eCg:wbWXĺCEA&Ѻ
4T<8;.]In?9T;E;q8Q|u+:y9:>n;8P<}_%;И;-:@p:K;Mֻ:r5: :zA;q6;e;_U:59ǻ?o;h;<;e<6;B&;qk;\Fƺ/2SSpvqĻ~:.:(
"	4<:Eo$MYU]
z<:Σ;#S<;'ke><	;ֻfrUK;,{<:&z{|;L;.;[:C:b;r2;~G@,>x+%QH9ż:;!»P*ڼriкT$h i1Ov;ܑ;翎;DD-;Z#*G=;]C5;R⳻ʻE5;Ãڹ:#;2fԻI/&a:ư!;ټ!ٺ<<=8c;6;TnR;9%8:R;ĵU<6PO;Υ<::q<	]<
Oo;RU+r:Ƿ4<Uֻ_F4<Cof9E;j~96{ԩ;!m`ï90;@˴Y
/ryM;-9K;R׽xf2¼"	;:غ`;׽:۷;)6Ę:q~I; );Wr7D;b2<<@);jʔû;=;I;c};!>xlKWܺNg;U;|!<s<Q;'
8XFɼR4<⳻ǹ:b^;*;~’J;D!u Z:4Fz9O彼r99IջAi2z>;zF;B9p;l}ݺ*̻\]A;	;U$:̂<	K[;1'9g:
5j;	w:!'9]UpBa9(9<$QVly:Ļ\;$s;\&l:دG;);՗EӰ;h@l;Jۿû]*;Y:@Щ;;t(L;566&;6;;;mq;v;i=(<V;te<&<]"oYݻ2[5;L<$*D:@1<G;,<&>qiy:)<"X;<=٥;?ɩh(K;vJ
m:Ǎ<S9M;<;P:s4k
vG:.};q]/;;bF.8w9bs:q:));dʺyA/c #9;ĺ;?%y;̃Md";̬:58T~o;"9+d:a;RA ; :D1/B(L;6q:lo4M$7<>e;5:.;wM,};L<f+<
ԝu-D9,]:>}<0 :ݗ9Pi|;@Y;C?ݻoºKʻj%:l9[x\*!ֻ;]:9r	;?;纆N;6A#:ɄdY߯$̑"'Nև,i;9'b:W˟+λ}0;0N;	~,L<|<};U}Y\&7D;:=AG;E;:t9+ƶ<<+;9SYr;W<
ừ8	Cλc+<74:I;(;^9.Ի(;)[~;;o8:{F L:'
;dNue];:l+,ɻ<+::ǂBԻ,1绫;;	<1d;5&;4;LZJ9)';;B
<,|.ʻܟ;/C;};\&;]:<2tq;;Gdhy
`;s;G1E<܁;;;ʲ:;S;7Tמ$;X:b;0r;ћH]V	Kt>;;Dh_<[;L3V<7;R1:Q;;+#r;KƸ<;*<;;4K#[WG:b7`X:>@ʻƺ<::=wx:۲ڻҺ|Z;>`c;r:󻒰CIO]%;-xo<&-<m;Ż;mCF9rSf<*:O;zZ;xWŒ;ۥGw;&ﱻ⻽;WP;;v]o;i:;;B2叺D~;Dk:g;ϖ:V;{LW<4:<0c껪e<6=	p:y;ơ=scH="fZ0Z=AP4X<dk=<-brD%<[*m&轷8=a_<=彔½0=l=>=Q=l=<=i=6AFȽ\)0;?_@K=-ߠ=Y=VMGt>=n <=@}*.p(4<$<PdiDŽ==]_[~` =B;l;qA̰;v=/?X=ze;=;)y=g?^;p+<Έ=t-=I;==d .Axs=&S<=	OnWK5P=von=20=[==
<:=q#>>l=w	G<0V=0=Ӷ<%Qh=Qۜ9&S;sW~\c=\p^>b==z8D.%;3*==
=;*E56<(;|===!P<@&==9y<5< _=<=9E%=L=Lq=H=I
U:iA\n;Ihf=\<ŎNM=`RG=P=(E=AVQ=bL`=
XIChݪef==
&PK<="o===/z=΃~+2=J:葽C︼=A<={=ƿ<%S=laX=yd{Ҽb =1=i`=e6<{=ڋ5=ů4=r=^Oq=Ӯk3<<&=N|U=X>\=q=L6>޻<#w=
h8Vj:}齆ǚ;qV=X份nK#џu˾c7=diz<
<ލ=n==G===T	]7=M>=L=x<М<~mq=s4:t=M*j =e
=H>A>[=`=L==چ[=\=ZF*d'ULm܉Y(>;ڻ:5gwϺ`;*ʻkָwC8;W껡':!fu;u@(<,k;:i;;;)HP9^0-Ƚ:U(-,b:ٹT:	 LɧL:9w߈;<:2f7`&:Wl;,::J:A;b;|;tzJ;Nϥ:J:Zol
<;||;a#:F(<:yV9|w;Y9:lgg9l:L:v:4H:l9#\;u;tM;
;;/; J<9r;.);ӻH;IK:#ٔ;b;j,h:xmG1-]V;!;S	S
t;
[L>;uj;Թ:5;KU:Z;:DFgC:fpW;>$$/;8);Q;v<#B6;;
:ۼ껐<(
)*H;󍻀-Fa:ا;;RG::7G
:&E;/;˺˻为q;r -Sq:F;<::K684;7!l%n<,zcbf^<*~<~;_;5޻D;ﲨ;Yl;?Ϻ&^;w9;x?:y;ϣD<Y<#û;0h;1p;ئ;vF;願;F:Zºt]!Iv:'<$ͼ>);[Dfx;X:`K;20t("&
;آ}0GwY;;̲:V8F	8W;-;VD;;A,;n=@?Jd0Bo:FW&^ILRO^ݼC*Uz;;_
u8HW{\aHF;{g9941:G"Du%͟:d4:EYz;9ʻ@xlz8;!,Z6"/P<";H<0v4Pj<N޻乬Q黛;8ĺy;C9x<:s`~;ZͻO];I<Z;
rXy;0]JBl;=;kԗ;b<4;;I<̼fx;01/:`I:l;bW;*D5w;:3<>ϼW:Y_Axl:ء];.;%<ݻ;`;;\_\[<<H;Z;;DsLLڻջ;/F黧Ƽ/;o__<#G߹_Ǯ"zl0>3B
:TL;
^:*<;;:ɨ;r
ww;
;.5;ºtѻփ;[΁9%x;ydg;|;:B;z:im:C;s;0;e;-I;r&;v;i:\ź92;/(mF5hs:g;R;:
˹g5{;-`b<O;t;<$`: ^B;(YŃ0`g;ERT;pP9Ze+֞EW\qt8:ؤ;7 <#w'S:$ŻGκ:/;<+_N;rwB;3;j;;z:n;O§;{@bi;I<&;׻Ļ6b9;HZ;Nô;V:Kpajsǻ)r;LNfgc<[}/74';nݺ	j;< :9n-!ѧt/:kq::;=:b;j:;_L\:Q;T;.o:s܄;@:P;2<;:;]H:-P:ȕj2&r;Er9ԗ;:5ֺ;@};L92xV;:;2;䔻;~@<"(tǻb~XU;';F:8	<$N<;@E<>ZҪ$<
$;:;ƻCZ;π;*;O-O@;TOd_;V#n;Df;!OA:oP64x<:5;,u6~3.)F;I3/<%<
-ջ#<"~w::$C>+f9!컙;쒙y;2X:ѱSjW}<(8;mǘ2~G9Y+9J	i9'ݻadoIm2@~;=9l\pH:i$:;N)-89:.9*@o
J``ɹNvm
[;4Mc]V=,/:')캿`C.rt]"h;"W[:;U5<q;3r^j`wUi,E=O=lܟ=0wt^1b<=OH>	
=$==8_D<Ž)<=f˼aK<ۖ^=(==,<1L==Uz=>
>=K=7>=z=
<@<9=9>
=<=A|=67=*g(Ijp=#sVfD~< <z<===}n=<@=@=D=F5=.1/==gU=f]|c=*=|z==@=<==Z_>K>7M5>6H>h=3=GA>U=lV=<,>1=N{=g=
=!==L\oUZF=	@SA=嵻fZ<==O޼O=#1={=@Ԝ=d="h= =%=A=ս=r7=Ϲ>v'4>m=c=;i=*>==z^>==S>"1\$=+===Q]of"`g(=4=H>r=K<UE==iK	)ԙBכx$=P	\=P6;x=өS-*;kͼ(=\=+q=ɰ>{==)=>>l>I>=====X==?k>W
=P=I<!<<^
3XϢ<*uy=]p.===rw?=T'o=3CLټl	s<=7;X=Ď;k0=<3ʽt
XO3˞]H;}L=w=z=z<8/{=`=v>=5~=iOϽ1v$=Dc==>F=y=(=dꙻ<ځ==0,2=b<"y&}f=D$j\4k<|:׻z<>`=&=J=R:_<2< D=ѡm=>s>=ꖅ>:~=Y+>-}>>]>2>.=_=."<ܗ=t=g=t==3=CgP<-=+=j=E9<=n<
8=#=k&M=M=3S;
튽1re&=m6<^=7=ǭ=ĶμKq=A==L
=',3=T[=q=N=s;=0\<6==9>Qq$=Ĥ=lә==n>=Ȯ=	f>[+B=r>#~>>:>I>|>=x%=N==n	=u<=M==3==g
H*:O=<|[
=N?=b!=T]=ۼ4:=n
z=~D=g۩=/;=E7<u<2;:v.tμ.=;H-R=w%> ==>s=2_
Y=mW=|<7==P;MҼa2z=T%<=Er=UC̦>1y`>J>>P;>I>us.>>3:
O=z====>^=P^=Se<;缩􄽁6Oe
~=>	<6nzm)Eq)z5U]*y>
5Y=+A<~s[ń=q=h=-=y>/>M.=E>0:5>8?>5d>3==ھ9==۪==i>W=]<Ӥ;GD>WV\kN:KVǘ;-Ia:A";`|;(;2;#:ʡ;::X<ݸ<;X:໗;ºN;C;5;(I;NO;ݼChS;і:e<WW8otl;ܴR$m))`;Zn:;F.;"LYL4+:벻
-iD;R$Iv}::e;3`*;C6;=湞#ui8@'D_):<;);|<_d;-h};3<;ϓQ;SF'op_c[;$;0:K;hN;Z<$ɾ<p.i;@Oc{y=:eZB;ߺ;aP;-cVͻ.<5	;Ɨ` !
:3:
e=*:*1)1uF7:ˠۻ;&;i<?<;l:pJ; ;;뺰r;%:;9${t:ֺ;j_ԻL;#:$#2g̺}8(;,;	/;hZ::W8mp;^8;ͻ7;f$x8&s;:Gռ=-cQ%:4]F6<T;zjz 8;iZHIf);@pڢ;1EA@o?,vлջ㖻s9I旪];h;R	;/]j*Lj˻Z(;<Ρ;8仠pbC+ĺG˦;޹GE99<;a;ph;9K;U\;'>Xӻ+:d~;Zw<d:<;g]IIJ;:+K:ٺyC3t;:;<5]8
W;uOU#;_J:#|j:?ֹ8Nm;uӺMx)U:]@gm:V;a }ӱTp3:ԋB$o3^:cs׼L);%8-[ηG<<
ڧ;ˊ;;y;ػ);rl:̉<Џ;r;];t<Ȏ5:-:-9m:I\!;?;pa;Nٻ69;:<
ܭ;o.;%WR
M;Q;@G<<
4a;
9.R;$;fc;;Rw<:p;c]%Y2<p;aMA;Ӝg;hP:;V:dr#ȟgDH0`L;gؼ)@/--a;yFvA;gvݫ<)|8;'s;˻	".c:H:b
p;6;/:DAۺ_:Fl8:,];\%G;/˻v&dЉaՇ˻t;1h;A<;]b<	;9\;	__f^v;n;<
Y.=; ʮ;;6u9j;HKEN9}g;=$9SL
.ge; ϻ
:nT&lQ:лt	;%<)U<H;Nϼ8:Gb";QoBǼ:4fe)K/*0TvEM:<*'a:Z:Ix';X6:;N:a;V;j:_кڪ;R;OS;;r:(=;]-hg)8;k:;Z;:-4e:kh;58;19TUi9`\;ij:];պ;&:;J_;])X;<#;h_V;/;{Wv	b<<H;eM}gC51qp;
;;^:ʮ;I:E;.Ż9;kkk;4;;<7;@h.q;7;{<PICs\<5;-輻`lV;qF;1R:O;,L;&U;WS;oMi;>nɻ,G8;K!EHI;w;2ZVЎ=R>=Rv<=A=x74d==B$=FxP>==L=|~=L=Q=&><>=6N=3=e==1=
> #=uإ==x=G=(=u=DÌ=Mu=c$[3^:CH=Qy<?<ԩJ"o=A[<=;!=8C;={!,=/>=]ك>D=N3=ʆ=
==%^=H=,=hA=>>	w>*m=9=:=c=@^==
U=p=\?=B{/<根=q;=Z<$ACvlT=2ͺ;e
=UUT<襝qf=/==Ь=F=3w=N<_T=$X>=>ʙ=j=g]=n8=Y|=y:e=@rH<\g?=w=;>=)gP=6(N J=
ȼv.Q>R>G=5=E==C=yQ=>(=45=g>
<.<=J,>#.=
<#=f=>)R;=Zk=p#==Z7=T='F=ح>"ݎ>
=<&<=L=~=;}=+=8';1=>==m=<=3=Co=?p==X<=~W=8={[ɣ=#=n|A&"d<=C<<=&a5E=^X>
^96`=O<}ױ;齈*>1>=>,#)===9=>4>=>=x=<8>=>5>/=`=+=;Z=鼷;d=.F&=ƣ3=Nj\:
D<6="=FuL==b=ٚ=/= =6/{=o<==Y0RWDo>=ı=iO=0=(=k<7ڽ	ʼ=>{5=	>U>1X==i컻=s=G{=X{=,==>a;~)`Je1\9J<=M=Kb=!=h>m=m<*;0;c=<*<I==>μ>16=h=r=^I=O=U=7=">]>*>=@=	K=w>{=
$=<<@<-=g=t	<={;{:Ud=߅===p=!o=E	<@
==u==˜=܂=S*>8==Y>=-=tU>?=[~=0ϕh=J==1};)=y<<*=7B>_==.=n1>?|>8>=V=o=< ="=E=R===
J=L=,=+>pJ-F=*=/=Wf3>r>D>'U>~=ʁ=r~>%=_=D=#>CQ;;U;=<_I=[	=QSW=2uI"Ju*=CB2=WJ=?<̝컽aK=A=0_=h^;t=\d==p==R=oKc<===z=w.{=y<ԕ9=>">ɗ:_=>A=ɏ===;oX<^<=>'M=S=^8>Z=Km<d=}<'=V=e4K=x4=Q:=>==;NE>/H^=%d=AK=)=·w>-vU=<>F=n==5<@== UT=R>
w>$<==1k_,=Z>;V(>W>'F>p߼>,7>-$=2,
>/=H=cŧ:)=	<<`W< S^.b;8p*=
==u=h=&<\=_=c=(>Y=B=g=Y==>">$0=-3=]7#F>a>\='=>;,=,=!>=\<%D<խr=ܝ=a: <x;8:V;3 :&%K<lt7;)TK<";"'hK];P9֚:O;{p<D'w;akû4=:bҼ):H^;I-;<:ƒm;3W4vQ;{;x\^XVL;ڞ;r_GS><%;";a4;*;asyN;؎;:;RϷ;d;<; <-2HQ;9o:(Q:CO;Zvso:TԻl.$;p7<>:͏ڼ03ͻ[![<cK,;!ºD>;-u5;fa:s;
j?;U;Jq<;.[;n;U;܂CNT–;;'M)z;O.::v";ɹ<9j;kx;:mv<:+<o<ZT]Y;*96;A<'&zs޻;wz::;MT;[Q;x:Af<:sSM-~O)RsuLFaW⃺;!;:hx;;Pk-5&ʺw9^dM8uQ!
M
;f{59~;rX;l)ݻ^K3a; ;;Һ9E9k;0;~ۥ$i#;a=:uȻÒ=;;׼O<;H; :"<
.R<;<;;,; $:<
C;(<
='*,`;[˻y9jӻ-$Rrk(G;dYn;h|ữ;x\;`Hp:2ڻ;a	î;wcZ<:nW;ﹹ<VF<q<+;?;#+<I;MZwv<&73rd;hbA<);BNLF	;"-91:_OCs;06n;y໴:8`ƻi+B޻a76f5F;ki;h28;Äk$6;PY: :@};t:\9Zb;QW;&<l;ĿJ;a0:P:򟻥۰:n2;x;!i3Z;W;hWu]:;.d(:j;֝!sj:J <; ;YM;j9;ݻ;*
;p;;ۄ;R.;nLaϛ;/h:Am<$[9Ѵ;c;d&z<7B0:;G<W:ܞ1RsC;<
<	k=;Pp$ךj;_Y)+;O=j/e
"Me63Pp<e]<.;¹E::Psû3#'t5:O8a;j%;Mq:f:&ۺ>U;f":!v;ɇ
;>/;RMf;<N5<1n<J
?<:Y;;J\g;јG<
4;ٳ3^;Tה;±J[`;]qۇ:܇<<G;R[:Ȼ"v/<2~;`+.I:q;Q_<
(9;37;s,<85>B:qV;ܻHP<U;c;!-cT11;F;3L;	9d;@:)?;6:돷;
<	a<Mǂ<&;{;Ke M;;Ig::[:u~iJe=O:;:
㎺A:.҆:?<X;9:*YL9#zz;1U;;));@ZBR1
.:БcP`;p;	;q';m:Zw;ayRko0nۻHֺY(:¢:%v:;m`ĻYz;U8:;:9;x;j;><S;:ހ;=M6~=׺ZS;w4$Aźjؘ9~-κJ;gtcks:$;<
;~:q͹C;9Pu9ǻ/8'/;*WjӼ;Gs<3:;O;;*d;Q:g:i;+;^<<";_<;<;~9X!\B8#(YdCM5t;L\52hI>P`!;5 E{쑲Vnj(pItq|M܎3vc88E֚<Q8:Ǻi2;%c;/;G2~J^f׻[K<Q?<
=W;[Y;]A{L$a;]9@:ׯz$;,Q:/<;&$κo;;ӄ9;Ǖ6;Bϛ%ۀ&;ظg	X8:b6;;w;D;j:";O;B5i]5վ;msl_h9rlB;:h;L<;;;rZ<8z2-9;[LBqU<4ŻûmK9
/9	b'RǺhb9Cn
׼)ƴ;PjE1d{;i@5λJZTaa;Y;~||;Ə9{HC;YS;:`-B;b%;[XyG;w?;̺U0a:d;g;ܻb<H㻵&<@
g||2;L9lGb'^;M^℺n>ȉ<Y;,e4P;<Jܛ7k:Dw,T񻴙pi}Qn:8r;H:fAd׆KϻF);cŻn85;:ԝ
s;R;D7zH"<.&1<V;dTq.4k7V:F=Щ;=s<1ǼE;J5N;S<ʼ2ƻȓtuS2;~;Y/̻{B9Cz::,9p[Ǹh;U=v:S؈1:B]%c;W^k;9⤻hm{D*\:oNeÖ:<G:jT;{ԻSһ;X;;Ůk;A;);Xa;_rysZ1;d\:һ]<&3;ӼQ»;;M4=;1;1:-aKX;;;9D;+yfгKJY;Rl;<=1J;&;5R=H=ĕ<=%E=3>0)o<=$<>>_D=Q?;9=->	=|>F=mt=K<
<=E=*|==(=U*=$=$H=
0۽q=;}>C>*8=a=<#+=>=`&
=,=\=3>.>*>>0H>jal>r;L>>>&k>9=H=Ʈ=>;>y<Q4=W=Ͼ>=<<vE=G\a=*^[=H>+=T==T귞=Ϫ=->kCJ>_T=\>>F*><+==J==W=7>
x<@>R>c=j>Qk>,=>+p>6җ==r=A<=Pl=G^;Ҽ4===(0=C<==i=;YI=O9=]I<<޸[%=	=H<`>;=Fgm=C>9>sl<""=gx=Mi>Xr>`=)==<=|8=[>
=>;)M=<;|<#6==fϣ=?>A>	ʐ>5uf==ºn>>p=µ)$0==#=+>>9>l'>Ee>8>]
>W8\>y>v>.a=TM>2>@=u
nQ==*=;y@=BAI=~=c>>'٥=>=&
=q>=ڣ>	Wm=f>->}c|>C==s5>Kk =>:=Ck=VD>I^=>_=ɀ>D=G.>
`=PF>c~=n=
<P=/=N-==x>ӱGKl>(=s=6[>]==9=6I=>%vz>d>!A^=?,>#er==w[===4Y>'~>O>$=?=?;=Bd=rK=ra>1<=Wƫ=	q=r=-.==?K>BQ>^>a=9B==<+=@f==Q>=|>1^=>6">H>s>)L>E7>_>>U{f>R>L>m`;C=g$/=
=70<< ɼ
=o=?=>>Շ?"K>>	>ȶ=`=>.
a>($>>w>>d>!Z?zg>N?=>D=.=L>e=c\>A>>$==>D>4> =p=뺼f=h==c=X=\=ZE=="P=F=^<=>>2>>>
~=h=l>=>	=e>?>>n>9>=W=4===s=_>I>
nHKݽK<	i=u+<)a2=ݼ><>1>>/>7=>+%{>Lu>&|K=C=͋=#>>*y=5>^>KB>,;==M6=W~>O>iM>V>>b>>>P>R>^	y>)O>>>Ok>=0>=gl=46O=5A;YZ={=ò=?<$:o=V>O">R? ?z>3>c>5>(>
>N?1>j>l?
$>>???M>]=>-U>)=<>>2h>>=ȯ>5Y>h>h>LC=C>8=l$>ft>E==>0/*=>5=aC=S~;<4K=&=T=;=!F=*>Zj=ƌ0=Z=Yo>=)>M*=>	&>=NJ=ƨ>
=~==8=>?>D>V}=˽=ڲY=ac=&<#=>/#>">q>9>_>m1>bsx>3>32=։S=j<=W><>E>Yݑ>rx>!>>>j>> n>:->>C>]wx>{>;>>@>+>Y>Y	?F".>>c>>f>C&=gx
=/>#=/>"(={|=:k==>5>yũ?6+<@;?ΚE?>>Ȱ0?B>?>̣>>zC>	>V>/?2P>[>>==>7=2>;H2>d2>>(>>>7>0>=`>7
=56>	=TJ>!U>"='=w=+=ݭ?Y=!==3;ui><> >>)'v=X=1=Q>I\=ۀ>/>A >!o>]xq=x>="=>O===Z=G=ە>,>k0>1^> >
ɼ=C==>	=]=O>'->?>>^>\4>p>iޞ>#>W>>A>ə>^d>>,>j?>μ>U>w>
~>ͅ>!?>8>؍>>U?=@2H>>KK?>?ش>:??V>
>Wad>U*>bK>>_i>G>}>X>T?>?6@"'@N,?յ?>߃?@?,ǭ>?>?	X?	վ?;>>>ۏ>>>|K> d>N??>|I>߬D> >J>[>*q>}>g~>(>)=>>>>{=d=Y4=x>X=|>|=0='<	>>ԉ4>x_>/>|>>>p0>z>>R!~>ck>_(>5>kT>R<>=䝥=6=B>c>>`>&>>0k>C=>>Y>>>*I>&>]
>"?
>L>:>>\>>r>7hs>o?ݩ?*>8>
'?}1??P??Վ?AQ_?
@?e?T?Q?c?=z@Z???c???P?<?h?L?*-??3$5?/B>K>>C4>gE>?t?I?@	@?!>>u? >N>>?>?V?AQ>>>O~>
>>'$>g??br>Up>>>7>R>G|>\>Jw]>	> =>h >@>k=ح=qJ>k=m>]A>4=;>#>G>>N/>`>0>CM}>RgM>\J>z>f>">th>>1>4Y=J>>0wc=x~>#>H?l?t}>0?>o>&>!>
?(/?&4?=>͐L>M?s?p]?r!??^S?4+?:k?X[H?}W?#?N@
?s?%	?h?>?@#W?b@@)?{@O@+h@s@ir@~@Y@{b@;@@qIN@R@UlZ@P@P6;?@a?=@?N?E?:?[
|?>[>?O?
@(5@\@%m?y3>ou>_`>׊>>?M>f?b?J>w:>܁>XB>o>u>+y>m?q6?~>?>B>k%>9?>C{>d >T_"=>Q'=o>kح>?=̼b=a濺ҝ($9Kj;߼;P7߹;O;;,y
;h5;su=M;)*;S<'-];
B4;<:#4y;(Σ<;o1;;ػs;<C:f;>;
q;y;#sn;zR;qɼ$Au;S;9!;&:;^һ;g;X;y:;Ӱ;whk;4:I`D]U;h%<C:ú6G+Mg;x9<#'Wgܩ;;R<"<=G;¹ݚs:5(;z|ݼ;R<e9k:L<<%;;@ә;zu<;"|;.<pe F;θA<_%[<<<@;<4><;;ǹ;˂<I;Y<8\<1=6Y>< [<x;B;U<1
;E;:&;m9;_	;lAD۪)C/e;;u?!8&;*:9ɻ͟n)*J@;g/<3%+ʙ:;奰g]-:P;
hü9ػ';4AiZW9zL:!@ILK"^;$*ʺ꺕H(;_:Xi&Ey_:[ռ.%:!;r;~;;S:A*;\M%@tJxNYIW;Lѻ;]<'L?Qػ߼9{q;:7;0œ}3r;WC;?
$BGͺ2CB:(:-ݔ;Ȼֺ@;zֻaJ;=:;N<d;
(SP;ۼ;ge;;;L:1|j;>Kf|1:J~6ܻ#?7;ɀ3H;򁾻5':9;-6;CO9xL&7ɗ6l,\ɺ£=<_{;?̯;*;1
ӻ+<*G<1q<<:υӺ9*
J?&Q.*:QZ@;˼tQ+wpub;<5h,U<
SD;҂;Hȸkdi;@;Qc:A\;u7μ;;;;?;кj[H;
J仗S[?T;BWԔ :
]gO黎Tq>->j==̤?>I=z=*7=d>K>>P>d>$>Z>Wi><>Y>Y>">q>Q->`	>[>E>0r>$>ŸC>M??nc?Z?ob?,]>ҩG>>}?K@"p@@u$?~?uہ@&?T@!^?;@v K@$n@2@4?Ǽ?=@0@Ae@\@<@@jO@[@C{@R~@@X$@d@V?b@a?b@/@\W?u?ހ??S?@z'?4$?3??]O?_?;?2x?*>>Ի>=>X>hu?	?.?:D@%]?J@
    I>>[>[i>bx> <>fϦ>>X?q?m>>J>>=8>ND)>\>V+>{>D>>>ڹ??>>>E>aV>=ầ>˼>l>*t=-	>
G>X6>>HE>P>>=>__>->G=>&,>H>->GG|>tks?K>odm>>}r>c>vV>K>L>>
1>k>i!>>A??K`@+uv??8<>~>ڐ?<9@ƨ@@՘@W@>י?d>?`?/?\???*>sV>Z>o%?"F>>`>j>cw>9:s>v>[>]H>V,>=>V|>bS>>??h?@v?
y>J*6>>)>2=/o>&>>{?u>x>>K>p>t\9=Bz=l>>;au>>>S>_>.>9H>3mq>A=hZ>8&=>GC>ރd==n>m=q&>P=Қ>2]=}E>
Gb>3?ć>`o>=>;7>0>2>b>>p>	>B(&>>g>>>u>V>>‹?	?8?.?g?>q0>>?Q3^>}?U?&a?u>R>m>З>>>R>'>>Y>n+0>n>;e>:-I>'G>?h?1?bEe?D?Ab>w?G>V>?"a>Y>z>3	>M>O>?'>>>>d>r8>>=:>B>%#)=KF=e<,V>u>H=v=U=">>Q>S>7}L>ؤ>~>V>3>>V>"Wu=>>mb>g#>^2>>z.>lw>8R>=T>/Sq=5=>7z>%>;> >d[b=N> f>J.>	A"==L>=;=X=p*P>@=E=/=6CT>5(>L=,>8=I>xF>s>E>­>(>u>Z>Sr
>$>`f>z<>>&??C@>M>;>q>
(>V>|N=ǥ>tw>vͰ>>>3>I>>B>*)=?=G>P@>=:t
<=>'M>e>6?U>>ן>1v>aY>>%>e>>?>->,G>;P>;>	>>A=>>A=>*O=i=<>>C>LG>=,=r=W>kk=u>=>}f==>I>>y>FT>U>I=s>G=[=p=v=>>n>V>>>W2=D=x"=צ >Ux=#L=>QKVry?Z)R=N3c	j{^>6/=E>=0=~>.>&>->d7>3~>}~>>>z>"M>N$>>G%>>>i>L?>ԿP>ݑ>O\=l>
=}==[~>c >A>x>'z:=߄>$7>dj>H>`L;aӼ "=⥻={;=4o=Bp>
L>i>>>DU={>-=n|>շ>x>DQH=p>->=K>O">!>G>m>.>>
=t=_=9.;\`&=v==6=ƾ=ļoc=`(=wd=wv=9}=<8m>(<^=>=;B=>%>e>=k=v>D>=?ll>CD==.=&=Y8>1kR=>>E^>=Il>>=u-=hS|?in9ｳs!6+ټ8<=m>8=>nQ= _>QT=.>'>in>_9>f2>V>(>m>ri>3]f>q]=jJ>|j8>
|>>c>Z_==xS=`=}.>(
*>>U=>W`=x$>0>YֽGEF"bJD q><b=r=[=J=e{>>#>>>(m==g>C=Z> bt=xU=1==\=L,=+=W=7y=I=>+]=\>N=7>%<=׭=^C===h=<=L$=Y=!=I<==>&n{>dn>&>p=Ű;T旽=I=c9=m>>a2>>Jj=">=y>1>Y9$>	]	>_q>`>-$J>=w>}">Dn>>9=Ɠ=I=
ǻY=7Q=XY_>Ԍ=pe==z=hg=ɖ]===N>5>4><ܣ=35>$( =0Y2>H=R>={> ]>s=yZ=1=Vы=|=aL===ľ~='Q;gnE==p`=L|nk=C==
='u=-+;z|=V1==g=
\=э==ʷ
i#=	=
T>M
{>F=
=<~<|t pg=?=#=;=x>La>%?K>?G>YN>'>xT==>>F>=>>>u>{>>b>'=oI<޽<+_L=A,=4=h==G>	>>>=Sa>?>p>
>3K=^=ǣ;n=&=O<2=m==?=	<"cYT;.߽;ڽh-μ;Fl=Qx;=R,R=~1;=2`>~=P=;=]=.r=F曼$:Q;OF}=<
;`;(6;<< b;skq;ze;쪻1;<:c<'*:S;P<`:$;F!;oz:;;?D;Co;/;;2;]u;^A^;b:<0G;C8;lk;+q;:.";J߹<H7H[-;9;Ѕ9KֆQ;»-:;G;S;#p;Ï< 9;;04;†:<;dl;;<:L];;
;$E9yt|;<	";gYJ^;:x|:H;;+Y;uR:8P;b8;Ba;kI;; /;;K;;V=E:M;n;L3o<6(f:0
<:G;ά;-9R;λ:;h];=˖ۜ; y<-[: (<(<\m<,v;}OH;3?(;T
<Ի؞RןʻE;;T$<
B"<	Wӻi9$B;8:L;;~9V:I/:<[:;%j<?;9:u&໫>(:Q(o;^;;<@D0D8<J;y;sC;PT<;|<.A(7;,:X;6;;xDTwZ;STf;4~w;:e';B1;kϬs:j9S:v-;;b˲.;u};aλBNƤm;Ԑˇ;.޼#a/<ʹ;结tDjށƠ;5j;~&;Żʺ*9;;0:"'E;0J;_B;J;U;6B	hҴ»X];lz;C;¾;V8[;;:<;~\_ӻV.i2oy<̹;-wY;V:ό*;7atFK<<.&JQn;0EP;Wo:	%:$2ɹC};_<;/ ;\{:e5>;oh_;b8:<1B;f_n˻9j:{|;O:أ(c;:d;ה;;{;xӻJ(;hz;id:B;q;W(;1i:9Rl:h;▷즻do:G*;黼)1Gm;k9;\|;@:;VN;1>;ecp:7;3];';Ǯ;A;׻\L<0<:0<:d;D50:?;+q:יݱ;T"?JPp|;Ѱ8`Zػ<';"\=<.<2
<;@9k<]q;A~;c;t;G}bB;((#:Y;];u<e׻' f

;,8(;8_Bٻ׼#?<:;;@O:;9Nݻ;~:%:ܓ;RO):`
F;H;9:,=:A;爺;CQ:c;*T99T^?P-;FE:
:b9P;zyػf]K;a;;;\:
D:P;uS;x0?|F2;D;	ں299r׵;A^;Ƨ9	]::1;8 )};9(P>44=H>6;>%M=>Nas=>)>>w>I
)>(>>>">R:=H>=N`=u}Y.InΗG$l+
8uxkc=xgͽ><:eZq=*.=GH-<,//>A=__=г={=Vw>><Ż/75=k=|=0=S==7=at=T<`!̻2<~=K
>h>P==[={~>6>/J="<===v>>Nm>h>#!>>?>|>Y>sF>ny>	>R3=M=;_<鷽NUA4ͼq^{"ƽ4<=
Q>&={<*aھu佣)xȞC*<o=ό<=D0
==5%=TQ=Ɋ>=౬=Z=u=S==މ=ty<&Ğ<}?=[=L=V3R>6{>d	=角=~=\й=JJ$\=Tm\r>6=:=>>=ӣV#]=k=>h=}57> q>QlGa=K>R>Q*=3>
=c=Ȯ%=߅q===Q=y=p>k>|>'>pC>c>
>>;>ݘ=c=i=2<Ȇ]=;
="	B>d;lN==H=L:ޗwa!n4'9E6ٽ̽H@==Fz;2<<<9~=9=_>>/.>S>#1=>.<*H=ͺ=O>B]ܽg}zi;i==&@ٕ;`>=fu?=_>!U_>	=r=`x==x=)<+pi>EU=Z;޲Q=^>U>P=
>'=\=;0>[==r2<=fz=W=FJ=>Y><>h{K>@>a>N>r>GA]>%,=[<&:ڻ G91'9ue.OX=Yex<~&]snAWfṭ0Wbm8oTo++üpjj==
3='=F>B>*=d|=૕=̀==C1=.=>==ڳ=}=+[=t0q=f=Htn+! =>Qȼl=Y
==rhgJs=mѶ)a==>]>}$=ޣ=#=i>
==tw;Dd=#PG=a<=E=}">m-k>au>qP>_>>J>d>$Cx=k>Q>,N>+=0ƕ==Y!==`P'==?=@w==Q$>?<==Jm=_=%>>-=F=NO=E==k=uy >Pܼ<;=]}{=Ŗr=
=dz<<==Tr<g>d>b$>Pmq>H}>`>U>u>pC=Ե==!==BU<zE====>R<<$>)C=7=tg==6ּ=͏j=?=M=Fn<jWlFJQ(;vT=t<,3==s/=K>.ٰ>=߇>*"^=#=>-= #V=R
r>4X=*y=> <E=V0=۩{=ӭ="==;
<"<:;݁srPC=RE;=F=%>>G>b>S2;j>"+=In=>>af>=q>
D>	k==@=O=-͓==J=
==78(=-=1W=J=6XZ=aD>=MyG<<&]=*GMN=[=@c^=ɱt=q<.A=V\9:(:;@Bv<<G4;z:ݷo:M4<-<3;;`5;X~_t9G=;y55;O9<3Rg;Z:<.;6/;Uq}vO̺ʳ;[;8ݷL<
zo9e9$99*;"һr;D<;;.D;;3!:h;:<9:;
;*;\Acݺ<⻨ M;RlS;s򺁲;yZ;<0lW?;3{=(:@mܻL-95\;y;$?*Y;l8O
f 3 ;;r4;Ȥ2z""vI;C/;qA39;w̾;;;;՝;6;W9;h*HzK;˷<<;{ju;%;쫻SU.]:hO8< p;8;y	92Y;Y.:%;+Fj;gX<*f;hi.r;k	HW;Ўl;J;;Ά&Rv;ȞP;;@;}\";n
9b:ې<+	(;}qE;4ӏkj;SU;eC;;;s;btBU;oGi;<V<5#<@/y8L:6(8;)˻K;wd:z2;:`8;;3;M;v跻+{<;O2+;_}n%O;q:p8>:̧7P-rub:h;;<^:̺u;G;d$k:Hhպ5L̍9g2D?<h: <\;H;σ ;ĥo8g;|~;G;9Z6<%绾55;0;|z;f4y;:\X;c[q:<$hne\;%;"k;	|ȻB;bq.7ؼܻQf[FX
<:d=9<\n;[_;,;!';AQ;1ռ::g;u2;׼M9&;:B;		;;u<
˺+8 ;
C3B8㱋;:~̻/L:bG=;;9r9q.:	oc:u;BNW:d-;i6;H<	P;X;];c<;"9y,O9Yy;x<6;ߕX:zݻ +;s/:Vӡ:WԻ8;Q;+r~;|Y3rń;Fp.5A@SNpP;;ZtNcbD6W$IY{9oSdC9JʼC;oP;<;{^:O9ʦXʈ;[:|:q<o;};+Yu+"<f;|<
Eۣ:a4U@B9"˻`<m;;;`;i
@;t<<Do<y;1<"[<=;;);M:;,8L|60:V\gߺv9+;$:cɟ	";1;E%ٹmz;;D,Zd;E4;;5<+Eןc;ܻ8e:MU8;ls:o<9m?ܺܖ#˺5i;C;<կ+6(R<<C;:&
v@OкܒJML;;&{T]Bm:b7ˢ.;&dR:L;A zϹ6;7;h{;-|}=	? -9oĤ^;><j$&<<źh4#o<'D9O;q9D:ӿ:};@_)>H<>;z6=O*n=W=f=
<.3<)O<<2>c>f>D=3==<;=L=Ȋ<D;!=)=	R=A;=7;:f%E;fĽZKL=/(=>;"C=ę=u=-5+=dƼ8@߽F<}ɺ(O=$,>H<#;Lh=5׽Vo=0+-<,=h*w==<=:c=g;b=@>W1d=kC=G>Q>o><"=N=bg=ğ=|>Ef=h=z:><=<=PX=q0<ۼnl^bC˽8#9ʼ[i?{-wͽ½\==`C==?>)ƪ==>=^{7==!<<=AڽTR+$=:2===м;l=@\kx=t@*Fea.Ƞ==JŽ2`?̽)9Vl<קae<=x<jal=}#=NV=<ؼ?<<=Š=5c<нݑ	o[M:9Z;<=gLc>p
>==p=l*!=u==a=S=]be=~<[;ʄ=1==mt=LR;2=z<.:6<=H4à$ҽ&wJR=%VŽ0Gս&2=s/,Y*=Y<2D=ҋ=gg=9=E>һ=y=I5#<%s"<@`h6e=*}Xʙ;;̅^bB7C%ܽpٽ	E:CG<(J=====9=#1=9{Z3r=+%m==m<#
';>CH;޽50wTW=1r=}=cG0>F>߉<ú=]=TiF=FQ=ь;ƛm=z=4V==6a.3/=A@=_=Z=="=8=(=U=K{=
4=8O==F4=W:k=X=S=
wG;=O"S
DYOIwkǓש=M<p⬼E=L¢k=0p@&mxXHrv<7v*6.>	pfr|=W=!n=|>=K{<ݟ=[<	=DW]=׵|Q ;
\=lb:w΢n bQ(-qX;^?]aFsDB=V==}\>==_=W;=<ܭIJY='OU=p@=\<===%=Di>=:=TU=c=hn;m𺶙e===P=h=7<]gѠkc<0=';4<"(lSv<+
GüHZ;=+=!N=R(\!㥽lMٺ."̽䔽Nh7.<׌=
V=;_-=Y=l%<,;|v=A99:m==X)<}M==_=v}=n=j=8E=M>>{<ν=e>Cp=^<=K=DcH=V&<_%V=N`=k9'bXZz,e^99]O|ᘽ=@=="=\^=<
=h-="=MB^>/====W'=*=֖yJ:߼Ձ49x;i:8¹&M;<i";r&D6;Qr^w:h;'w{Sk;x;x)ݡga;|̏;;T;Gu;{:M7`Nػ-:Sx;"Ufi:{v;d<<;|󽻢;:גY;x.<##I;9m;$;:9:)ȻdQ;i#?G᩹eCys(I8Ȼ_8:_6;mI{)-:;wHϩ3;+^;<rC:~cR;G3C);5h;kL;f;)`;:qi3;I<rf:P;B!
;վ;~;':p$";]r~P:7&+;q::Uv;4;w;yN;脸:L<%t;rp|"T;P;na:5;kOg+9&:;,Wֹ]B;8;)Yy;nm:y];;j3;d;;bpO<:3VK>Rf.k<c^o:01%;`̼Mںݲل;x3Ȼv4k:i;փ;;;:k:e:0%:;g7MyZ;L#,:[;dI};A&;pچ9#Jl;I+vzػo;6;Y!;L[;\;M9ml:;A;"3݁;lhL:_f:s.:#/#cr<<<2;V:jҸS)\<ɬ;-B<:ٶ6_:܀:&;>S::H;9cںX:ƻ续o4ii
dI໳PǼA;R;<̻6[9ԩV:볻9;R:]:s<<_!;;$; h<:E<%;;]oED;"/;{U;n;0	~);M}ֺ[TkB֫t;O}л
ڹC:c3ϺºJ;e9hC:^;;;[:y%컇;m<;-XX<1:d   ;8A5ez;VN8ք<@;{U
Å;*]GR}H;c7a;뻉A[;T:l;(Q:) ;M	;˘;Z^G;˫b{rs<4$<=:;3F/;v;;[;86:=t<Ҙ;:t eǾ3޻?r;N;p5<;z9!;r~9{;+:F<'L:19j<;O9`8;
,<,H;ɤ8<p`m8H:	;";@;S;E0;<=7+9	Ż!Q;d;*;Q~{NwMy͟s8njJ<27
:Ϝ?;?Dy|;A4;7:ͥ;;:<_:J6';R;X{
;$[;U<T*"G5w%;
g<=y:TՍ;ߦ:|<"4<;,|8HYt:bf;]%
G<Be;œ}UM;6<~<@	]<347;0;ǧ:P:C;<
h;Lu<,a:.B:D:_:<	4<$溜4:y\j[:1C;K;EqY^%$]^t:;ly@*59;;j<;::B"\;`<H;li5!;u
0.y*6;{2;{:s;SO:8Kk0d:`<j|k;؝[--9ѼD-û:ޫ;H:@::`s:r;\:sc.;ӽ;2;껉:5 ;I2s&̰L;M躣t,	u:~<o:i⻯N/,t;B;3;W/e:=:B<;;0x9A
<+;ջ
c<*-O;P;.:l58s&2VE;<^:;;{
:N=<&u;JFd!;Դ8:nmFW;7a;ءW:XO8֒;<v/k:XZɳmt;t#;L;(q	;'A<8x;1[B;T};׺N:pκk;Һ;!dsu9;;;gY;r;[;2F;ĻxܻR:5`:"x_b:9;|k<;);m;;!4~CW9X:ۼ$< Q;;7}߻`;:I8d=i=<Β/7T:ɨ½jb*<	e콙$f@<>L:"=@2=$b:u@=ҫi=1=	=v;=˩(>91=9=Z==.=^>*eW=u㼙i=#&,
4I='uE<=<?e=Xs<=NP=/=%*=lhx=m=ɽxrѼBGc5=6|=[F=Z=reN=>=+=XP5=	="=Cy<	/X=U=.A-
P*=E<+b2\<]="G1='V}z轭޽)Mܞ9)/F=fAu;J====R콃2:;F01Nƽ~|f.t~ ZuAd
]e<;$6>X:=531;h==D=<<=0N=4>%=q<~)={0>z>[u>1{=+=<߭FdQP=v]<{==J=2
:==*4=U=`=7A==EFM
_
27ݽ1<Ǽ<(=Jk;(|0v=l0Y>>>.D=P=1==>q=Ϗk=;=֍ּ3<ه_⼕ʊ[Rý-;+aY=ok!f==-w׽ľ)=L`3
O==m=a=s=5dh8Y==g==c;5|;KoApH3Թ=K=N>Vs>=6=u;!H=6==P==>;gX=Od>	_1>/q.=Q=?.
<=k;;i=N0=9^=Mސ=h=J'-?qq"=<؟ս뽩6$/n=_YD
X<2<*:Ҹ=
`{=zw:==3=~Ծ:<8_*!Q9
p=K;]<<`4<(;+̻b:=n==ǻq=	%=V-=g=ԛ=+N>d.==`=m*=Tz=bh?2"==:$-J=t=G=ܓ=>1j="d=MNν*_ҼYQ="'=d>=<<3A8=s=A<=G=؊K=k=>->
<=pH;sbu#_$?[bDBSҚc㽖,<'=M*=L=Xڇ
mѼe<,aUǼ-ΨfAru;",(ྲྀE=
<0Q{6:mn:S@=}<=2<=im< =~=+=ST'{;oQ{=s~y`=7K<P<=>	Q8=r%-"2l=.W=B=O0|=BCbZ;e`=(==3N=Ѫ<=];MὅsG͚=1K;k;<@ٯ={<8\zj=(r]Vmm@.uq@UnZjB۽#ʻc=s'=jOJr٩<ԾzS<8m=\}>t=X x<#J	==)=v==+=,)=SPظ,ҼdB|=Z3=;iv!b<$[9`;pAЮÙ;p;C<qR;I#k}
3<;g/;KQ
R!Kތ<u$;*9
A;<m;Nj1;5.;m2e:#n;κ5:AZ:V;̮t;;;	K"8E<8p;;1c"ػR;[݉zw:7;B9c-
>Uɻgֺ";{9;B[Jk#;}N:r彻,97̻rּ:݁CtJHл<%7<8}9!;'!ˢ|;1:;;/;ڻdM\Y:{<8lH:ϧ:@;c@DŽ:P3'o':Yż:Q;v:'`<
7V:{:;J;pM;6|;wo;~:ػ;R"F<{aq<"2;Ā;L=]N9E8$<@-:7a=McU;#<	^@;e:[Y𻢘1:-	$;QC:x^BK:i;A7Dc;
2Q;?9:f;(;~*	r<߻V`+;Mt7@;I$C;#2:<n;M<fp<
JEv;:ݏ;b9`u;)R~;X"Ļf; ;YWQJ[cx<e:etu*;;&w<gW<[N[;p;9:4dCz=il?;8a;?;䒼>W;;n&;N9yL<j9܎;Wnw<GC)M;XH
2ۺӰ.߻ݘ:Mr:?󹻋z
kVV;n;KI;snQ;a ݗ";CS-}<;Kn<
y8T:;읣9x;`f;<5ܼA Ǽ%5!9;(:9;Mb3;+V:̼DZB:%;;u3{;X@;.p;7,:(<8V;޻19NUݻV;;cj;[;C~A:ọ;,;5C;Z::~%ݻ}q׼Cx::q?	hl;-/ph;]HB:
;\;ػɻ7q;QU9W%C';|D޻㺑Wkk;mV@MU:ds/"P99񩺶ouD:@UV_:{;;~c:62?
:1s:yVv^;>F:;VZ::>;۶k(;O:Ӻ-:Ӭ:8
E><;.:3qy/3e:ւ4o+Ln;<++;d2ɻk8;	Se;ɂǼ$5<*NPEp<'0uu;##gZ=j<<Gyh}XI;жI;]n<
b<;/&%;G*};$c;;u";Ț;X& fv<;!׺}<*g8w;-|;0"Z;;^||<i;<$X[;J\Q<m;Ox~9GA;M;t;u:#sܺl];{0):YSs7Y;s;H&:"E˼Ų;dE;{П*;d3]D:-h:"`:$;*ȹb';9;D;,9:F;k=?9=:`O8;iz!&8`;;#;򹖢:?9::; ;M޻)4;Nb*::^*>:/~p: ߺ;M:q0ݍ;h:ɓ:}̺"2"\U;>;sh꺰G;-;MB;:(R+;p<Л; <$d;n|#Ui;p;C;l;~;/ <3Q<5Apgی<;d:
<*=;<;;blϢ"L;7;Kk:]	89;
;W;;F~:;XԺB":YR#ň	;QʻZ:<;W$}695+S5	u<;mWD;;:;هǻsH-;BTey7;;K|l3'`;Yl:P;%;"=:':H7:J/HU;;_;Eu;":c:7
M;#(=
A&^:u|g]; @:n9;o;ٹ; _:WT:"R0:/;;;ȣ;Ҳ;i'S<+q;۹;S@:ߍ%;
C}*:S;Z=;iH<#b<<(;oBٷ9;Y۪]C;׺TȻU9ˑ;Dw^ʻĵ
]
;;r;#noFww<D;9)(u<"\;.<6@m<Ҽ;i<;K[;:G;ֻ<8J;E<2&:'T+;;	^;9S:gw:-:zc;w;{U;hH+5;;׌i`	-L{9j;;j4<;V;3Nڻ<$(1:Zs;:Y:^;ʻq.;ZY0;n9;I
;p:ۭ$<<0;;k߻&):;;a;p:2Z;4껻@;n;Z;|0-໻ޝ廡8;i;j#:`Un:@[pl滴y)+;;Ɔ~RY;;&;uϻ;ݪ;$B:::"9EĤPл0;k;>`ڻk<*;S;;;p
Y:GI&;6t<
2ʻAl0<)<%;*ٺڍ;(5;(l/2:<;D<"(/z&M=>*=D=!;=I=QJ<=
=<}s㷼=~!ۼOj=I;ɑ>=/r]=ֽ115;6^b2;R.<Ҽ =ː
B`IJ9h==U=>Y>(t>>?==<	==6ʮ<==6+ܼG*'=< R<_"gӽO;0e:>;>@W=<=h=q;oc=Ӭ ϠVuS}œzf==u"(=nP=iZ~h=7c<`/'"Km>̼ν彯E6=3F̻B==|\<*2.Z=i>  =!===$p<^7jy_=|]=</A=?* =`>[r=,d=l;ե>	HOTD|<ꨪ<~ =<]=BWlҪ]ڠW/%ns==~P>=x>)=bq=ӎwI{=Su<zq-=m=$-=(=F=>&=@D=C(efmzl=~̽4ü=#'d,=>*===.=<4է<*;̓]^;N
*==d_Ļ=Mi/9ҽ=b`w)r=bmϻ;f?宽k;"	Йw*:Q׻'3==Yx>#R=Q俽b;E<4:SJY=@t<ѡ=q|-0=`=~=n~;ŇS<|=}=-G==N=cԙUv(q|;*>Q>	5>=}M/=>Q==>>=^=A=u==2j

k;g= =
Q=j=I-=+=NÆS vi)(;Q/
1
xQ|&R{?<-ul-<OW(m=-:5Q=M<<=n=D,>
$<]R(\0=UW=<ӌ<<ټX!:(o>>B=Z1=6ʽSٽg)܆:=$ټR=ن=k=h*6A«;BX&ֽeHW=R:@Mtiz.:<	lE;k;U<ۀO/W;i:;u;]W&:h毻m@Ī6;nͺ;i~;ä;@A;)nz-se<N:Ț8:=t6<GO
:iӺ *;K;4h_;t:3;Sn;P[;`D::><1<&1aq8Q<%((:N幈6v<,I;;;G;_N;sD	80IoۢQ|:Phŧ8ɺE;o{!DH޺;;;CcRz?;kC8	𹻈;5mD:c::rһx:;*8)^;W8s: ƻaIWk3;ᭉz!;,<1&9H
^5;M:JުNXjw;n@;p
ͻ@;ñ;΃;5k7}	;iչ3绣:;B݄;_.Ѵn9cDyJZ5;-RW(F;o;;Í<<5=:ҳV;e:;:cnqúԝC;j0,;'
c:׹3;c!!F
:-L,;̻Iz&k;Dq;dK;g9_:&:E;	c9;@:v;dVv;Qr$>@:e?(;E`hH;BLc2v9 8@&:;:
l:%yJ;eɺ-9k
4:;֬:t_:y;;g廯[h];;D;MB;κycw:;L:b'+;ݢ;PR;_Ѽ>;7;F`;KR1!C;%=I":s;z7;:pt:$
);,K:<|;c(;iN[:,qym:v0;{vh
;&9;f3;J ;;Kk;;⹦&K!?'50:`z?IL;z;?Q6ú}&9<#λ;B;&B~;.+<-1%;ܟ
;_BK;;,$<F{uF!:Կ
;\W::ۻt:-"m9g;<=薺:Nh+؎_M;/q
3:,8`R<@*ϻ%˻s9ӀC(Fm;;;tq:lV<yK';:ŕgÕ<`0S:":;xb:̕.::?;KLR;6;),q;i:
)@;J
;%s<<; :ZI:#;
X6:Y;VGs;x;W:9G;PqC?<Ü;	L;r+\
°:sĺo;&;	f;;2׎;kmNy;n껬:z|9˦:<9ۣ<
"f<ߺ:	><@;1r9;
+:s;1VuG92:~,ػQl;?~;-ƺ:.6?O;Edo9;):k.:?2ԼUһhnM;;:r1:M;mWYdƺƎ:;z-;R҅ j;98:*4U;W!wxr;fL<6M<>I_/:m;Tvں;1p@xw4Ȕ:#pcTv4a;ϼ,oؼr#FfW;
;<$ar;̶]:;ao;+Y;9Y?;޺]v;i'=9e9:MҺҢ:e;_:;j4ڇ]*;xJI<,$~҂:򹡕CPD<;^_8]{az;h!Y;jNVʻe'i:鞋;:(;Cj:P;v>c<^;;l:<	;6:2Zb~<̯<(v};fٮmhX;.:`-;^[;	);:,;ږ;	'r:l;
:_;|;<:	;';CQ::ɯ;Mm.3;)ǎ:{;ɡ;V;#@즺YR绑;Q_cU;
m9m2a";Ӎ:鶊Ks䛅0;6{%F5󻇿T<}i2<Im;j08p>d]'9ü.;=;*°;;EX9ϻj;:Ou.;	61#\<U:7;@<<":o;3:,P;'
;$<&׋;Bo;=:Ty;X{;Đ;de9ؾn;-;:^v;?
<;(L[H;dNSRAݻ(7𕛻9Z9,<`xyy/~;룤Lw<;|0;ؼ<:;:ۺz`;Nvּ"k9P(~_p<'aA:뻜x<; '*J	<<5BX<};:<;d-*j;2כ ;;vrY:1
;i;R;u;"35:#<o<;;ڻbw:;Ҵl;;0QF<ju&u<谽4zD$?<༮==->W> j=چ=նD=7=OO1\.K NT_'<=:=pЀ=މ=?ro;U=oD,~=,<<;	_=Ag=kJU
= <|=_Y==`W=Z=R==n <҂*;K=iVl-}<;*&=N=Vԏ=f6W=O?=a=?=
=: m5M1<7=%%(;=8M.̼BҾ`S2P8QI=>}<<<<)'=x=6=<)==7=2<^MD>x,=z=);0
==U==;<	<_=@jT=n=s=O4=\TjA===Xs1=\=%;g=-1׽sGν)=0&{=P=SDI;or=.=<=5	r(k=
=I===!f)X=<~u;='< fO¼=s;5c:Okw4cGL/ō#?<6= Q=Y=}=<><>x<8n=0=ͼhмo=R(=w=캡>x;E=+=Tz= a==Z9`ǻX7vb;:7=/M=rF<`/=ph)Z;=,U=9<<[N@=;KqClt;[̼1=R=Xʫý%=%=L
==%h^==*_<~<*=l==kU=i<#;.<=-
==sͻ;=ŏ;{J=D<ELX؏vY=a5==w~;=Gv=;;w<:X!m=V<[9=J==d=;뭽I(
֠==y1Z'E­=W=];I<:B,:7t):9;
9~:뽻n`5<)-:-@;TF:;	ۂ:@TKS;!"l8K!º;%eyۻ+*;~,ռO;.;G:W;N;!w9GB;/@9D2]zt;o%ػ;Ƶ;;:I3<5};綻;d'hQ3̻;̗<λ;cn<C7;'<i97ẵ^_"&;B:ʀZ;]
C;<:]<::ʓ:pgZ:6W;,T(i<Һ;\	; 뻣X;d:9;:<=;b:ՙ:Qw><Z6:1?;;1B:w;8#2w8<7;]`;l;S:!I:(j;;rTkA:";*:t;2;x:RCX/xTl;i;ܺx;qtf:kya9a4;M^;Es
:q~ۻb5<W;?:tlH;;~m<%mv;'@;L)Dinx;Rc5Z9tk@a<9$SO:+";w;\\q;#ϼ<
C%P;$f;*,\\:cKyڅ;];: Jz};iD/M};f:`9;v(ܻ̺l6SB{e;˄Ի۱j;@~9;лD:4<;>x;>;=H;^:>9;.k,;y>;¹j<zl;iYf
DK};y4;Ƨcػ:K:99:{a/#;al2U%JbϺIa:T;
ȻZvEf:˥KET4,;V8;:76@F;Ph6I;w,;%Ļ;sX8;-;<J<Q»A"e;.b;?H:{Dr:y:;y^fGW@#ѼX`m
κ?ǻG09멻}<
YG;5Ƃqt@;ц;	kL;ZUf9,;v4]:v;cx:@:fQ[3.b^"*컢gM0	7h~DPf[:z^$:F
;I:mf!㑻[=:L';rVC89ϻ&(;;: 
:;3e<:+,ʻ:s^;w,9vﻕєD.;~oe;R]y'q;ü ;c{;$;u$o+:ux;Y:2G;LwD;/;齹Z6;9;";"nŻI_(hR;!黥e:C~i5;7kF9l8C;x;cκ^;-Od:M;*`I
	&9_;#;K;YE;~=\:F z j;`;L<V:<:Ⱦw;J;Z<	i
:J揻h;;e:P9;A{;lgթS #;j;߻wû#;;7f<Y;Ҹ\xY8;OHi!I8?9I&;o~:"f;,:%2:;;=;;_;n<̝;_?v:D:cf;!h<`JI1;.9٬l:;D;܀dź9U9:nT+;J9;Cu;;B((x798Y4:g;IGG;\;$&2!F;ۺGb<<(;᯻k;</%:
)Fj;w:st;{;`:
+x8`{:hX;W. S<q)ɖ
t;5:8,:;s߼:a1<$Td;] Z:73޿pV;:;c._p;3/\;ByXyN;9Owc<zhealpy-1.10.3/healpy/test/data/wmap_band_iqumap_r9_7yr_V_v4_udgraded32_masked.fits0000664000175000017500000045760013010374155030347 0ustar  zoncazonca00000000000000SIMPLE  =                    T / conforms to FITS standard                      BITPIX  =                    8 / array data type                                NAXIS   =                    0 / number of array dimensions                     EXTEND  =                    T                                                  END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / array data type                                NAXIS   =                    2 / number of array dimensions                     NAXIS1  =                12288 / length of dimension 1                          NAXIS2  =                   12 / length of dimension 2                          PCOUNT  =                    0 / number of group parameters                     GCOUNT  =                    1 / number of groups                               TFIELDS =                    3 / number of table fields                         TTYPE1  = 'I_STOKES'                                                            TFORM1  = '1024E   '                                                            TTYPE2  = 'Q_STOKES'                                                            TFORM2  = '1024E   '                                                            TTYPE3  = 'U_STOKES'                                                            TFORM3  = '1024E   '                                                            PIXTYPE = 'HEALPIX '           / HEALPIX pixelisation                           ORDERING= 'RING    '           / Pixel ordering scheme, either RING or NESTED   EXTNAME = 'xtension'           / name of this binary table extension            NSIDE   =                   32 / Resolution parameter of HEALPIX                FIRSTPIX=                    0 / First pixel # (0 based)                        LASTPIX =                12287 / Last pixel # (0 based)                         INDXSCHM= 'IMPLICIT'           / Indexing: IMPLICIT or EXPLICIT                 END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XbXb'ڽ[eHֺ5<)<7< Y;;=}="6Xb=2f=d><TA$===h<5=V=*>VXbXb===[P=އ<=:Ufr=b=-=Xb=QZXb<XbXb=
=J;i==q(>>GQ>'E>>%'=b=>==Xb==S)=}e=XbXb=\`<>!=<=:==C;=q='N>|w>,o=C==VN<`Xb=Q\/=O=Dv=\л]XbXbXbXbhXb="=;=W=)U=K-KpR==:=rRŞ=Xb=Xb;XbXbXbXb.XbXbXb=@<<d;I=>?;Xb>==|@Xb==6=3*0=g=];=&==Yu =M=Xb<Ѥg=*=Þ8Xb=DAXb4
XbXbXb9*<;HEDXb(q0k1d=>Xb=>Xb;F<wU<=nu=|=BoXb=M<a<]4:}L=XbwXb1lXbXb;<ǽ-Cf+=)R0=[S=x=Xb=*=XXb;2R=	=V=<=P`=FB=ĶXb)?3<=!Xb4==Bf==Ϩ=zN=j<:=c=q	<'X"=7Ӽ{@=R=*:λ{H<?;λT<;Df;=#=XbXb=7<=F=;PY,XbXb<ԝ^Xb]RG^<N<Ш41X%֮88XbXbb7<=u	k9<j
=YXb Ϳ=: =$<=iXbXb=:<џXbXb=AX=L=g=i <86==">
}fTڼ~8=F{bWXbXbXb;=7Xbl"<<%<1[У=J=˛===
ͽa:<
;#<ӥNiw6%XbXbXb;$C޼g޼ǼBf9=l8=1Hʝ=Bs=_m=a=g=I=mXbXb=?Xb=E<1Xb=.==ۀ=43),=QXb<&绨w%"HlXb=UXb=*=XieXbD	Xb<_M=l^/<$+N=9Xb=(=_$==v=:Xb=$=?=+XbԽ=*N.롼PU<
5;Ԅ=1۟=,:=<[RU=ۯXbXbXb=W=!=x<;.ͬ:P=_<|=D=*=>Ǽ2VڹE<%V,{;l;xȺNXb;OZXbk9XbXb$S;};:XbXbgXb;/f:%bW_;:$6H"_-HXb;9i;=O/D;=;	XbkXb;sȹiY7;6XboŹFɚ@󅛻VH;;a9,R.%KXb;,	6;`:ѣd{ꋢ;e;Xba:4X;\MbXb::/~Xb; ;XbXb{%Ѐqk8xD@oXb:N;*Xb:.:>::SXbXb
i;d*1#Yi::";U;;u
<T;TXb;B G;iB3ȋ<́<(kXbT[;#y:r&;,W:1f;`iQ;}Xb8XbXb |#;H93蹜<;THϼ);1T
;;?˺;dP;ްXb,z$_|*(Z8{Yɻim<ZTXbXb;9qɼ<,aZ$;]f;ĩ<dž:Xb;N	59Xb;*9;2Zor!:"% ;!H:ыpZѻ2,:Eס
o:v;3;5>(;>!-W:м3`9x;fXbXbȦ8hc˺r7XbXb;>x9Xb;.
;ٻf;;PXbXbWռ
oмx<9L绦Xb<mb;E;;hXbXbE;XbXbKEgt;S`Ы:7y; c|anY:ԹJ
&XbXbXb49XbxHu:Nϼnj;оZ:pF:;s
At;:ݻ4,F
yXbXbXbs8o;N;I	K̺d:7<4<+iXb;D%$;=:;Xb@9W:
Y.Xb;eXb;Xb;4:fUXb>Xb5:BӅ،:XbDǠợW	;MIXbXbXb|qKXbXb:׺ܐU:I;;P(*:RKɺޖ=x;L2;G":TpU;x&⻁e;u,XbXbXbXb9 ͗><;<+؟;:Ṟ2
<_ˬ;ջCQXbXb6`:G3"0F:g/
?X;)s<8N<QUBYXbz<ջ<2;XbXbXbXbXb:sq|^:
S;,4;\92"o;9ZDX:PXbXb;Ym:BFy;{;˱M*Xb;^Xb;VXbXb;3qV;L;[:=O;u1KXbXb;Xb&;)o2YXb#b:\J;ԺI;A;T8߸P&u=;!;>D8;;@A;;T'9/+i#,-Xbs}}XbbXb0'9;).:ˡ;p\+;$,Ŵ<
uպ;oN<أ;rQջO#LN-Xb;]w:m;}.;:kT3;	;Pt;|<A
bS(6*},Xb;D!4c#iXbXb;,Da:{oy:9;>u<:;|O?;ɻ+/;4U4'r+\4V;k	:)~/;@M$߼bo;
q:}h;;Ǻ^;xJK6XbXb;Y==WSXbXbn=<H===b=ZL_#=o;,)D+=Au+Z9Xbq=W>>E=XbXbݣXb=G=>==i=XbBXbXbkihuC7w@⮺\ëXb=4fhIXbNXb=ʇ<JGXbXb=<=	,Zr4h'=gXbXbx?QFXb=Xb=Q-s=&<m<]=3R=
ν9oXb< JDyýӽ6[eXb<ȄswXb6(=$=K=XbXb;7VwyRl<ϼ=cXb9>ZbsɽhXbW>Mr=Y=0
<=Z6XbXb:?Xb<)O#Ž=1Xb<<<,|<ʚ:ǀ	;<$Xb<+~P4H׈>;hXbXb,Xb<{^=CRXbXbvF;=0.
Ľ
-XbXbXb<.=J=z;I;h=?#y=ل=kټTKy=|j}Xb<7NXb=c;wVDҽDƽa>zN;{r	3={FXbXbXbXb=;$BXbXbXb=ύ=d"H)*/XbXb<犳=͉XbXbXbXbXb=6ȼŃ3Xb0nCXb==ک>*u+=<=I>
rr=$=u@9BY;]:NG;rpXb;nĺw;XbXb9EXb;zZBK<4'Xb#Xbӻ.;Xb{qRa#~[ʋ^;UXbXbXT?Z&w&XbXb^M/ɹH;-3Q;Gz9T8JS;=9nm;fߋ:Gɻ];v9ZWdX默-
XbƬCG)[g|XbXb!⻚;3I:$TXXbXbźx;ӏDXbXbXbXb;;O*ymO!Xb_-[Xb_:c<eCg:wbWXĺCEA&Ѻ
4T<8;.]In?9T;E;q8Q|u+:y9:>n;8P<}_%;И;-:@p:K;MֻXbXb:zA;q6Xb;XbXb:59ǻ?oXb;h;Xb;e<6Xb;qkXb/2SSpvqXb~:.:(
"XbXbXbXb$MYU]
z<:Σ;#S<Xbe><	;ֻfrUXbXb<:&XbXbXbXb;[:C:bXb;r2;~G@,>x+%QXb9ż:;!XbP*XbriкT$h iXbv;ܑXb;DDXbXb#*G=;]C5XbXb⳻ʻE5;Ãڹ:#;2fԻI/&a:ư!;ټ!ٺ<<=8Xb;6;XbXbXbXb9%8Xb:RXb<6PO;Υ<::q<	]<
Oo;RXbr:Ƿ4<Uֻ_Xb<CofXbE;j~96{XbXb`ï90;@˴Y
/rXbM;-9K;R׽xf2Xb	;:غ`;׽:۷;)6Xb:q~IXb);WrXb;b2<<@);jʔûXbXb;c};!>xlKWܺNg;UXb|!Xb<Q;'
XbXFɼR4<⳻ǹ:b^;*;~’J;D!u Z:4Fz9O彼r99IջAi2zXb9z;:'Xb:.qXbXbXb8
<;VS:S<];v)?i:[4<	N>;zFXb;B9p;l}XbXb\]Xb;	;U$:̂<	K[;1'9g:
5j;	w:!'XbXbaXb<$QVly:Ļ\;$s;\&l:دG;)XbXbXb;h@l;JۿXbXb:@ЩXb;t(L;566&;6;;XbXbv;i=(<V;te<&<]"oXbXbXbXb<$*D:@1<GXb;,<&>qXbXb<"X;<=٥;?ɩh(KXbm:Ǎ<S9M;<;P:seXbXbXb;wM,Xb;L<f+<
ԝXbuXbXb9,]:>}<0 :ݗ9Pi|;@YXbXboºKʻj%:l9[x\*!ֻ;]:9r	;?;纆N;6A#XbdY߯$̑XbXbNևXb;9'b:W˟+λ}Xb;0NXb,L<|Xb};U}Y\&7D;:=AG;EXbXb9+ƶ<<Xb;Xb9SYr;W<
Xb	Cλc+<74:I;(;^Xb(;)[~;XbXb L:'
XbXbNue];:l+,ɻ<+::ǂBԻ,1绫;;	<1d;5&;4;LZJ9)';;B
Xb<,|.ʻܟXbXb;\&;]:<2tXbXb;;GdhyXbXbXbXb4#)|K[;ZXb;2!wXb:唻ۺhrO;tu;Xb6Yb2llXb9rNXb<$;X:b;0r;ћH]V	Kt>;;Dh_<[;L3VXb7XbXbXbXb<5Xb;CXbb!U;-.N/T`ٻg1`Օ#XbL2;U9x+Xb?¼ XbqzIUo;;;~+]XbXb<ѻY;
< /<
+Xbϯ%ί;c;J;>:QXb;+#r;KƸ<;*<;;4KXbWG:b7`Xb:>@ʻƺ;v]o;i:;;B2XbD~;DkXb;ϖ:VXbXb;*Ô0Xb=>=Q=l=XbXbXbAFXb;?_@K=-ߠXb=VXbXbXbǴXb;ȻQXb=.<q2μ2ԃ(HXb=Xb\Xbva=<iuz:M{bBu1<[>t>=n <=@}*.p(4<$<PdiDŽ==]_[~` =B;l;qA̰;v=/?X=ze;=;)y=g?^;p+<Έ=t-=I;Xb=dXb.Axs=&S>l=w	G<0VXbXb<%QXbXb9&S;sXb<ݙlXbXb=2<"<D4Xb;ɷW~\c=\p^Xb==z8D.%Xb*=XbXb56<(;|===!P<@&=Xb9yXb< _=<=9E%=L=Lq=H=IXbXbA\nXbIhf=\<ŎNM=`RGXbXbEXbQ=bL`=
XbXbhݪXb==
&PXb<="o===/z=΃~+2=J:葽C︼XbXXb+c<ӳ[Xb>\=qXb>XbXbXbXbXbw=$==/==΃="rG=Ex<[<=b#vA>[=`XbZF*d'ULm܉Y(>;ڻ:5gwϺ`;*ʻkָwC8;WXb:!fu;u@XbXb;:iXb;;)HP9^0XbXb-,b:ٹT:	 LɧL:9wXbXb:2f7`&:Wl;XbXb'XbXbU;x;KXb6XbXbD򻋽	;*rpXb:>,::J:A;b;|;tzJ;Nϥ:J:Zol
<;||;a#Xb<:yV9|w;Y9:lgg9l:LXbXbXb:lXbXb:6Y9#\;u;tM;
;;/; Xb<9rXb);ӻH;IK:#ٔ;b;j,h:xmG1Xb;!;S	S
t;
[XbXbjXbXbXbXbXb:Z;:DFXbC:fpW;>$$/;8);Q;v<#B6;;
:ۼ껐XbXb*H;󍻀-FXbXbXb;XbXbXb8{;ע;
XbXbGXbXb
:&E;/XbXb为q;r -Xb:F;<::K6Xb;7!l%n<,zcbf^<*~<~;_;5޻DXb;Yl;?Ϻ&^;w9;x?Xb;ϣD<Y<#û;0h;1p;ئ;vF;願XbXbXbXbXb;|:*sM9:XbXb;4:#rO4;EXb;Xb;XbXb;6<X(UXbXb: JXb:~/7ykc2XbXbei:A#;XblmgXbܻ';L:IʫvXb|d9xж;TPXb;L2JI}XbXb;(XbT;D;ށ;H;;(g`;eºt]!Iv:'<$ͼ>);[DfxXb:`K;20t("&
XbXbXb;;̲:V8F	8W;-;VD;;A,;n=XbXbd0Bo:FW&XbXbRO^ݼC*Uz;;_
u8XbXb\aHF;{g9XbXb:G"XbXb:d4:EXb;9XbXbʻ@xlz8XbZ6"/P<";H<0v4Pj<N޻乬Q黛;8ĺy;C9x<Xb`~;ZͻO];I<Z;
rXy;0]JBl;=;kԗ;b<4;;I<̼fx;01/:`I:lXb;*D5w;Xb<>ϼW:Y_XbXb:ء];.;%<ݻ;`;;\_\Xb<HXb;;DsLLXb;/F黧Ƽ/;o__XbXbXb_Ǯ"zl0>3B
:TLXb:*<;;:ɨ;r
ww;
;.5;ºXbփ;[XbXbXbXbdg;|XbB;z:im:C;s;0;e;-IXbr&;v;i:\ź92;/(mFXbXbXb;XbXb5{;-`b<O;t;<$`: ^B;(YŃ0`g;ERT;pP9Ze+֞EW\Xb:ؤXb<#w'SXbGκ:/;<+_N;rwB;3;jXb;z:n;O§;{@bi;I<&;XbXb9;HZ;Nô;VXbKpajsXb;LNXbgcXbXbXbҪ$<
$;XbXbCZ;π;*;O-Xb;TOd_;V#nXb;Df;!OA:oP64x<:5;,u6~Xb3.)F;I3/<%Xb#<"~w::$C>+f9!XbXbXbXbXb:ѱSjW}<(8;mǘXbXb9Y+9J	i9'XbdoIm2@~Xb;=XbXbH:iXbXb)-Xb9:.9*@XbXb``ɹNvXb[Xbc]V=,/:'Xb)캿`C.rXb]"h;"W[XbXb5Xb;3r^j`wUi,E=O=lܟXbt^1b<Xb>	
=$==8_DXb<Ž)<=f˼aK<ۖ=z=
Xb<9=9>
=<=A|=67=*g(Ijp=#sVfD~< <z<===}n=<@=@=D=F5=.1/Xb=gU=f]|c=*=|z1=N{=g=
Xb==L\oUZF=	@SAXbsXb=.P@:OXbXb7<XbXb=嵻fZ<==S>"1\$=+===Q]of"`g(=4=H>r=K<UE=XbiK	)ԙBכx$=P	\=P6;x=өXb=F/Xb=8=ksRS-*;kͼ(XbXbXbXb=XbXbXbXbXbXbXbXbXbXb==?k>W
=PXb<!<<^
3XXb<*XbXb==Xbrw?Xbo=3CXbXb	s<Xb;X=Ď;k0=<3XbXb
XO3˞]H;Xb}L=w=z=z<8/{=`=v>=5~=iOϽ1vFXbXb=dꙻ<ځ==0,2=b<"y&}f=D$j\4k<|:׻zP<-Xb=jXbXb=n<$=Ĥ=lә=XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=u<=M==3XbXbg
H*:O=<|[
=N?=b!XbXb=[==-nd]=ۼ4:=n
s=2_
Y=mW=|Xb==P;MҼa2Xb=TXb	XbXbzm)Eq)z5U]*y>
5Y=+A<~sW=]<ӤXb>WV\kN:KVǘ;-Ia:A"Xb;(;2;Xb; ثM;)ZXbje
ߺ2=EB6׳fi}
M],]7;]ỜZ<9ԂS{;WE.e;pr4vۿ&;!K<[;ҕXbXb;I>#:ʡ;::X<ݸ<;X:໗;ºN;C;5;(IXb;ݼChSXbXbXbXbXbXb;ܴR$m))`XbXbXbXbLYLXb:벻
-iD;R$Iv}::Xb;3`*;CXb;=湞#XbXbXb_):3:
e=*:*1)1uF7:ˠۻ;&;i<?<XbXb; ;;XbXbXbXb9$XbXbXbXbXbXbXbXbXbXbo7뻚fXb<0fλ:"	Xb;;ź::: "XbXb6'Xb:;uXb@u:4XbXb;=:>Xb;j_ԻL;#:$#2gXbXb;,;	/;hZXb:W8mp;^8;ͻ7;f$x8&s;:Gռ=-cQ%:4]FXӻ+:d~;Zw<d:Xb;g]IIJ;XbK:XbXb`;B;ӻlg;Xb<"jXb83;,~:\;֊Xb;4U<XbXbֺ;R络KXb;XbXbXbXbXbP
y:;Q<C;Xb9k;@e<T;:8XbkBXbXb;t;&;z%ٺyC3t;:Xb<5]8
W;uXb#;_J:#|jXbXbXb;uӺMXbU:]@gm:V;aXbXbXbXbXb$o3^:cs׼L);%Xb-[ηG<Xb;ˊ;;y;Xb;rl:̉<Џ;r;];t<Ȏ5:-:-9m:I\!;?Xba;Nٻ69;:XbXb;%WR
MXb;Q;@G<<
4a;
9.R;$;fc;;Rw<:p;c]%Y2<p;aMAXb;hP:;V:dr#XbXbXb`L;gؼ)@/--aXbFvA;gvݫ<)|XbXbXb	"XbXb:b
p;6;/:DAXb_:FXbXbXb];\%G;/˻v&XbaՇ˻t;1h;A<;]b<	Xb9\Xb;	__Xb^XbXbXbXbXb=; ʮ;;6u9jXbEN9}gXb9SLXbXb; ϻ
:nT&lQ:лt	Xb<)UXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb:<*XbXb:Z:IXb;X6:;N:a;V;j:_кڪ;RXbXb;r:(=;]-hgXb8;k:XbXbXbXb;58Xb9TUi9`\;ij:]Xb;&:;J_;])X;<#;hXbV;/XbXb;{Wv	b<<H;eM}gC51qp;
;;^:ʮ;I:E;.Ż9Xb;4;;<7Xb.qXbXb;{XbCs\XbXbXbXb;qFXbXb;,L;&UXb;WS;oMi;>nXb8;K!EHI;w;2ZVЎ=R>=Rv<=A=Xb!<",gXbXbXbXbXbd=o=A[Xb=;>	wXb=9=:=c=@^==
U=p=\?=B{=Xb=j=g]=n8=Y|=y:e=@rH<\gXb=w=;>=)gP=6(N J=
ȼvg>
<.<=JXb=؂=4ײ=5[=bXbXb)R;=Zk=p#Xb=Z7=T='F=ح>"ݎ>
=<&<=L=~=;}=+=8'Xb=>==m=<=3=CXb=?pXb=X<=~WXbXbXbXbXbXbXbXbXb<=&a5EXbXbXb=O<}ױ;齈Xb=<<9Z/=`=+=;ZXb;d=.F&XbXb:
DXb="=FuDo>=ı=iO=0=(=k<7ڽ	Xb=>{5=	>U>1aXbXb`Xbe1\9JXbXb=Kb=!=h>m=m<*;0XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=Xb=Z==PXb=sƽ!N=_7=taXb>
$Xb<<@Xb<-=g=t	Xb=Xb=g=v=rXbXbXbXbXbXbXbXbXbXb=XbXbXbXbXbXbXbXbXb=܂=S*>8Xb=Y>=-=tU>?=[~=0ϕh=J=XbXb=ypXb=*Xb=WfCQ;;U;XbXb=[	=QSW=2uI"Ju*=CB2=WJXb<̝XbaKXb=0_XbXbXbXbXbXbXbXbXbXb==zXbXbXbXbXbXbXbXbXbXb=XbXb;oX<^Xb=>'M=S=^8>Z=Km<d=}<'=V=e4K=x4XbXb>==Xb>/H^=%d=AKXbXbXbXbXbXbXb<%XbXbXbXbXbNXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbÚ:&XbXb9ՅXbU;VLC;Yc:}XbYٻ5b7č0:A;nyA;+Xb{Xb
}]XbtXbXbXbXbXb;Xb;ffN3vso:TԻl.$;p7<>XbXb03ͻ[![<cK,;!ºD>;-u5;fXb;
XbXbXbXb;.[XbXb;܂CNT–Xb;'M)z;O.::v";ɹ<9j;kx;:mv<:+<oXbXbY;*96XbA<'&zXb;wzXb:;MT;[Q;x:Af<:sSXbXbXbXbXbXbXbXb:hx;Xbk-5&ʺw9^Xb='*Xb;[˻y9jXbXbrk(G;dYn;h|ữ;x\XbXbXbXbXbî;wcZ<XbXbXb<VF<q<+XbXb<I;MZwv<&73Xb򟻥۰Xb;x;!i3Z;W;hXbXbXbXb;.dXbXbXbXbXbXbXbXbXbXb9;Xb;*
XbXb;ۄXb;nLaϛXbXb<$[9Ѵ;c;d&z<7B0XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbe
Xb63PpXb<e]<.;Xb:XbsXb#'tXb:OXb;j%;MqXbXbXbXbXbXbXbXbXbXbMfXbXbXbXbXbXbXbXbXb;i;.;6HXb9vѸt>
?<:Y;;J\g;јG<
4;ٳ3^;Tה;±J[`;]qXbXb<<XbXbXb"v/XbXbXbXbXbXbXbXbXbXbXbXbXb;s,<85>BXbVXbHP<UXb;!-cT11;FXb;3L;	9dXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb:
XbA:.҆:?<XXbXbL9#zz;1U;;))Xb@ZXbXb1XbXbXbXbXbXbXbXbXbXbyRkXbXbXbXbXbXbXbXbXbXb;qXbXbo0XbXbXbXb:%vXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;gtckXbXb<
XbXbXbq͹C;9Pu9XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;+XbXbXbXbXbXbXbXbXbXbXb;6l]XbXbXbXbXbXbXb(YXbPXbXbXbXbXbXbXbXbXbXbXbXbXb܎3vc88E֚<Q8Xbi2Xb;/;G2~J^f׻[K<Q?<
=W;[Xb;]AXbXbXbXb:ׯz$Xb:/<;&$κo;;ӄ9;Ǖ6;Bϛ%ۀ&;ظXbX8:b6;;w;D;j:"XbO;B5i]5վ;msl_h9rlB;:hXbXbXbXbXbXbXbXbXb;[XbXbXbûmK9
/Xb	bȉ<Y;,e4P;Xb}MxA<;;+;ao<$;r9B/;TPXb&D:R;yi;;B;	XbXbXbXb`XbXbXbXbXbXbXbXbXbXb:abXbtXbXbB.kXb<;ŇXbXb9h#Y໙o̞qXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbVpXb9qֽXb_8;@GXb\XbXbOu};
;pXb>Xb7k:Dw,TXbXbXbXbXbXbXbXbXbXbF)XbXbXbXbXbXbXbXbXb<.&1<V;dXb.4k7V:F=Щ;=s<1ǼE;J5N;S<ʼ2ƻȓtuS2;~;YXbXb{B9CzXbXbXbh;UXbXbXbXbXbXbXbXbXbXbXbXbXb:C̻ԩ;Z;Xb;Xb:=Xbu&];R¹ڭXbe2ĻXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;'Xb;_LXbXb;Öc::	\)b͔ͳXb;XbXb9TXbXbXbXbXbXbXbXbXbXbB^XbXbXbXbXbXbXbXbXbXb;pXbXbXb<+]G;;{.hS4:B;s;'ٺq;gXbXbu;A;\Xbt69
XbXbXbXbXbXbXb6XbXbXbXbXbXb$V|;yy
nXbXbGvXbXb5}XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbD*XbXbNeXbXbXb:jT;{ԻSһ;X;XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;XbXbXbXbXbXbXbXbXbXbXbfгXbXb;RlXbXb;&;5R=H=ĕ<=%E=3>0)o<=$<>>_D=Q?;9XbXbXbXb=mt=K<
;=Fgm=C>9>sl<""=gxXbXb>`=)==<Xb=[XbXbXbXb<;|Xb=Xbϣ=?XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=nXb<P=/Xb==x>ӱGKl>(=s=6[>]=Xb=6IXbXb>d>!=^<=>>2>>>
~=h=l>=XbXb>?XbXb>9>=WXbXbXbXbXbXbXbnHKݽKXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=S~;XbXb=T=;=!F=*>Zj=ƌ0=Z=Yo>=)XbXb>	&XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=X=1XbXbXbXbXbXbXb=x>XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=xXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>Q'XbXbXbXbXb;
q;y;#sn;zR;qɼ$AuXbXb;&XbXb;gXbXbXbXbXbXbXb;4:I`DXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<)ݠ;5XbXb;vN9;!Igufv;6r"?XbXb;0XbXbXbXb$BGͺ2CB:(:-ݔ;Ȼֺ@XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>8&XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=vXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=vXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=>=;BXbXbXbXbXbXbXbXbXbXb=F=e/XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb9Xb!6+XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;0O2XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>=7y=I=>+]XbXbXbXbXbXbXb===h|=V1XbXbXbXb==ʷ
iFlXbXbXb=ޅ=e&>;=R,R=~1;Xb;XbXbXbXbXbXbXbXbXbXb;Ǯ;AXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb(i<Xb8̲7BXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;%ɭC#XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<(XbXb2XbXbXbXbXbXbXb:1;8 Xb};9(XbXbXb[n;ot2<!_:ݎ:_Xb ʇ;jiXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>=XbXbXbL<魼XbXb=u}XbXbXbXbG$l+
XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>//XbXb=г={=Vw>Xb/756>/JXbXbXb=v>XbXbXbXbXbXbXbXbXbXbXbXb=;_<鷽NUXbq^{"ƽ4&={<*aھuXbXbXbXbXbXbXbXbXbXb==5%Xb=Ɋ>=౬=Z=u=S==މ=ty<&XbXb}?=[=L=V3RXb>d	=角Xb=\й=JJ$\=Tm\r
=c=Ȯ%XbXbXbXb=yXbXbXbXbXbXbXbXbXbXbXbXb=2<Ȇ]=;
="	B>XbXb==H=L:ޗwa!n4XbXb'9XbXbXbXb@Xb=FzXbXb2<<<9~=9=_>Xb>S>#1=>.<*H=ͺ=O>B]ܽXbg}zi;i==&@ٕXbXbXbXbXbXb=_XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=;0>[=XbXbXbXb=W=FJXbXbXbXbXbXbXbXbXbXbXb<&:ڻ G91'9ue.OXb=Yex<~&]snAWXbtXbXbXbXbXbbm8oTXbo++üpjj==
3='=F>B>*=d|=૕=̀==C1==Xb=}=+[=t0q=f=Htn+Xb Xb
=XbXbXb=aXb=EXbXbXbXbXbXbXbXbXbXb=ո==NQ#Kx=k>QXb>+=0ƕ==Y!==`P'==?=@w==Q$Xb<Xb=J>-XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb}{Xb=
=dz<Xb==TrXbXbXbXbXbXbXbXbXbXbXb==BU<zEXb==Xb<$>)C=7=tg==6ּ=͏j=?Xb=Fn<jWlFJQXb;vT=t<,3==s/XbXbXb=߇XbXb=ɣ
=zRf=}~ B=6G$=cXbXb|,[AXb#SXbXbXb=>-= #V=XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<}='Xb=v@==LXb<XbXbXbXbXbXbXbXbXb=l>
X@>fz=#/<3<'u=r;<6Xb=
9מ<*,x<93V+ɾ
xXbX=*yXb> <EXbXb=ӭ="Xb=;
<"<:;݁srPC=RE;=F=2;	k==@=O=-͓Xb=
XbXbXZ=aD>=MyG<<&]=*GMXb=[=@cXbie9:.#=SXb=mXbU.v;ȞP;XbXbXbXbXbXb<+	(XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbnwR:u/XbXbXbXb:վ	xXbXbXbXbXbXbXbXbXbXbXb;{f;>j;S@/y8L:6(XbXb;)˻K;wd:z2;:`8;;3;M;vXbXbXb;Xbn%Xb;q:p8>:̧7P-ruXb<0;gXbXbXbXbXbXb^XcMXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXboFXb;^4h;zXb:چ!,eXbXbXbXbXbXbXbXbXbXbXb<;RH\
;;ԉ;,3<(;:;y;x:о:;F:s;@;,w:XbXbXbVYXb>b:h;;<^:̺u;G;d$k:HhպXb̍Xb:}(:s;tqtHm:pW39XbF¼S;SmXb<
e;<;M;p1PXbXbXb;)XbXb;
<#;X/Q::WŻA<4.7ؼܻQf[FXXb<:dXb9<\n;Xb;,Xb;AQ;1ռ::g;u2;׼M9&;:B;		;;u<
XbXb;
CXbXbXbXb/L:bG=;XbXbr9q.XbXbXbXb;BNW:d-;i6;HXb;XXb];c<;"9y,O9Yy;xXb;ߕXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;ZtNcXbXbXbXb9XbXbXbXbXbXbXbXbXbXbXbXb:|:q<o;};+Yu+"XbXb;|<
Eۣ:a4U@B9"˻`XbXb;XbXbXbXb;tXb<DoXbXb<"[<=;;);M:;,Xb60:V\gߺv9+;$:cXbɟXbXbXbXb;;D,Zd;E4XbXbןcXbXbXbXb8;ls:o<9m?ܺܖ#<Xb:SXbXb;:W_<<
j<	5);L9y!9-T<; Xb*/.?;;u;"CXb=u=-5+=dƼ8@߽F<}ɺ(O=$,XbXb;Lh=5׽V=<XbXb;b=@XbXbXbXbXbXbXbXb=ğXb>Ef=h=z:Xb=<=PXXbXbnl^bXb˽8#9XbXbXbXb-wͽ½\=Xb==?>)ƪ==>XbXb=!<<=AXb+$=:2===м;l=@\kx=t@*Fea.Ƞ==JŽ2`?̽)9Vl<קaeXb=x<jXbXbXbXbXbXb?<<=Š=5cp
>XbXb=l*!=u==aXbXb=]be=~<[Xb2=s/,Y*=YXb=ҋ=gg=9=E>һXb=I5#<%s"<@`h6eXbXbʙ;Xb;̅^bB7C%ܽpٽ	E:CG<(J=====9=#1=9{ZXbXb=XbXbw9\B=;USVx=<„<zgtq8<=Xb=4ɅXbXb
';>CH;XbXbTW=1r=}=cG0>FXb<ú=]=TiF=FQ=ь;ƛm=zXb==6a.3/=A@=_=ZXb=8=(=U=K{Xb[w==,~Xb=Y]=;.=`;J
=tb=
<:i<"AGx1Xb=x~=
4Xb==F4=W:k=XXbXbXbmLۼ֢Xbw=P=B=8)=`$<1(O_=X"&XbXb<
;zXblXb=
wGXb=O"S
DYOIwkǓשXb=M<pXbXbkXb@&mxXXbXb7vXbXbXbXb=t==yJXb=Xb=	(H6.XbXb=W=!n=|>=K{<ݟ=[<	=DW]Xb|Q ;
\=lb:w΢n bQ(-qX;^?]XbDB=VXbXb>Xb=_=W;=<ܭIJY='OU=p@=\<===%=Di>=:=TUXb<`XbXbc潘r6	=L$==Ȭ>=c=hn;m𺶙e==XbXb=7XbXbXbXb='Xb4Xb(lSvXb<+
GüHZ;=+Xb=R(XbXblMٺ."̽䔽NXbXbXb.Xb=
Xb=;_-=YXbXb;|v=A99:m==X)Xb==_Xb=n=jXb=M>>{<ν=e>Cp=^<=KXb=V&<_%V=N`Xb'bXbXbe^9Xb|ᘽ=@=Xb=\^=<
=h-="=MB^>/====W'Xb=֖yJXbՁ4XbXb:8¹&M;Xbi";rXbXb:?;*;4:E
XbXbGXbXb9]y~Xb;;PR<:*V.o3Xb;>&D6;QrXb:h;'w{Sk;Xbx;x)ݡga;|̏;;T;Gu;{:M7`Nػ-:Sx;"Ufi:{vXbXb<<;|󽻢Xb:גYXb;x.<##I;9m;XbXb;w;yN;脸:L<%t;rp|"T;PXb:5Xb+9&Xb;,Wֹ]B;8Xb;nmXb;;j3;d;;bpO<:3VXb>Rf.k<c^o:XbXb;`̼MXbل;x3Ȼv4k:i;փ;;;:k:e:0%:;g7MyZ;L#,Xb;dI};A&XbXbl;I+XbzXbo;6;Y!;L[Xb;M9ml:;AXbXb݁;lhLXbXb:s.:#/#cr<<<2;V:jҸS)Xb<ɬ;-B<:ٶXb:܀:&;>SXb:H;9cںX:ƻ续o4ii
dIXbǼA;RXbXb6[9ԩVXb9XbXb:s<<_!;;$; h<:E<%;;]oXb;"/XbXb;0	~);M}ֺ[TkB֫t;O}л
ڹCXb3ϺXb;e9hXb:^;;;[XbXb컇XbXb;-XXXb:d   ;8A5Xb;VN8ք<@;{UXb<<;
;Q<:)\fA/9,S'd<H
Å;*]GR}Xb;c7a;뻉A[;T:l;(Q:) XbXb;˘Xb^G;˫b{rs<4$<=:;3XbXb;v;Xb;8Xb6Xb<Ҙ;:t eǾ3$[;U<T*"Xbw%XbXbXbXbXbXb:|<"4<;,|8HYtXb;]%
G<BXb:EXbJW;~9oFe;œ}UM;6XbXb<@	]<347Xb0;ǧ:PXbXb<
h;LuXb:.B:D:_:<	4<$溜4:y\j[:1C;K;EXb^%$]^t:Xb@*59;;j<;::B"\;`XbH;li5!;uXbXby*6;{2;{:s;SO:8KkXbXbXbXbd:`<j|kXb[--9ѼDXbXbޫ;H:@::`sXb;\:sc.;ӽ;2Xb:5 ;I2sXb̰L;M躣t,	u:~<o:i⻯N/Xb,t;B;3;W/e:=:BXbXb;0Xb
<+;ջ
c<*-O;P;.XbXbXbeJ	Xb;w4V<2
:5⻬:4ܻݻk;.XbXbDhJXb;?^Xb\Xbs&2VE;<^:Xb;{
:N=<&u;JFXbXb;Դ8XbW;7a;Xb:Xb8֒;<v/k:XZɳmtXb;LXb	XbXb<8x;1[B;T}XbN:pκk;Һ;!dsu9;;;gYXb;[;2XbXbxXb:5`:"x_b:9;|k<XbXbmXb;!4~CWXb:ۼ$< Q;;7}߻`;:I8d=i=XbΒXbT:ɨ½jb*<	e콙$f@XbXbXbL:"=@2Xb:u@=ҫiXbXb91=9=Z==.=^>*eWXbXbiXbXb,
Xb='uE<=<?e=Xs<=NP=/=%*=lhx=m=ɽxrѼBGc5=6|=[F=Z=reN=>=+=XP5=	="Xb<	Xb=UнXb	ᕼ=);{=UHļXbXbXb>/X=U=.A-
P*=EXbXbXb<]="G1='V}z轭޽)Mܞ9)/F=fAuXb=XbXbXbXbF01Nƽ~|f.t~ ZuXbXb
]e<;$%Xb<~)Xb>z>[u>1{Xb=XbdQP=Xb]<{==J=2
:==*4=U=`=7A==EFM
_Xb27ݽ1XbXbXb=JkXbXbXb=l>.DXbXbXb>q=Ϗk=;=֍ּ3<ه_⼕ʊ[Rý-XbY=ok!f==-wXbXb)=LXb
O==m=aXb=5dh8Y==g==c;5|;KoApH	_1>/q.=QXb
<=k;;i=N0=9^Xb=h=J'-?qqXb=<؟ս뽩6$/n=_YXbXb<XbXb:Ҹ=
`{XbXbXbXb3Xb~Ծ:1j="d=MNXbYQ="'=d>Xb<3A8=s=A<=G=؊K=k=>-Xb<=pH:mn:S@	Q8=r%-"2lXb=B=O0|=BCbZ;e`Xb==3NXbXb=];MὅsGXbXb=1K;k;<@ٯ={<8\zj=(r]Vmm@.uq@UnZjB۽#Xbc=s'XbJr٩XbXbXb=\}>t=X x<#J	==)=v=XbXbXb=SP!bXb;cNXb	<<ڼr}TO;<5<;
"XbXbXbMLXbL:UXbXb<|<
^;<|Xbz;)XbXbXbXbXbHXb:7;8<v:);?;&;7ۺo6<&t]{XbXb)XbXbXb9Pb;4ȼ8ixvƻ;d!`R':vtκՆ;OG&3I_&;[+M;#iĹߩ:"Ǻ:D;QXbXbkK:Xb;% N2:mVt9<7:P;KwZXbXbXbM;JX;?LJ;ΫXbXbXb<b|ٺ|y;⪦;]=;/x$p,	;&><$[9`;pAЮÙ;pXb<XbXbXbXb
3<;g/;KQ
R!KތXbXb;*9
A;<mXbXb1;5.XbXbXbXbXbXbXbXbXb;;XbXb"8E<8pXb;1cXbR;[Xbw:7;B9c-
>Uɻgֺ";{9;B[Jk#;}N:r彻,97̻rּ:XbCtXbXb%7Xb9!;'!ˢXb;1:;XbXbdM\Y:{<8lH:ϧXb;c@DŽ:P3'o'Xb:Q;v:'`<
Xb:XbXb:;JXbXb6|;wo;~Xb;R"F<{aqXb;Ā;L=]N9E8$<@-:7a=McUWXbXbF:;VZ::>;۶k(;O:Ӻ-:Ӭ:8
E><;.Xby/3eXbւ4o+LnXb<+XbXbXbk8;	Se;ɂXbXbXb*NPEp<'0uu;##gZ=j<<GyXbXbXb;]n<
b<;/&%;G*}Xb;;u"Xb;X&XbXbXbXb}<*g8wXb;0"ZXb;^||<i;<$X[;J\Q<mXbxXb9GA;M;t;u:#sܺl];{0):YXbXbXb;s;H&Xb˼Ų;XbXbП*;d3Xb:-hXbXbXbXbXb;D;,9Xb;k=?9=:`O8;iz!&8`;XbXbXbXb:Xb;M޻)4;;shXb;-;Xb;:(Xb;p<Л; <$d;n|#Ui;p;C;l;~;/ <3Q<5Apgی<;dXb<*=;u<;mWD;Xb:;XbXb:ߍ%;
C}*:SXb;iH<#;;a;p:2Z;4껻@Xb;Z;|0-໻ޝ廡XbXb;j#:`Un:@[pl滴y)+XbXbXb;;&;uϻXb;ݪ;$B:::"9EĤPXb;k;>`ڻk<*;S;;;p
YXbXb<
2XbAl0<)<%;*ٺڍXb(5;(l/2XbXbXbD<"(XbXb+=I#=E<؜MXb>*=D=!;=IXbXbXb=Xbs㷼=~!ۼOj=I;ɑ>=/rXb]YXb>>?==<	=Xbʮ<==6+ܼG*Xb<6'XbXb<_XbXb=RizaXbXb;^B۽N"cGwܼ2US󙞽½h;kn콻w	Ū޼.|"m
껗=}<=~p==ӽO;0eVuXbœzf==uXb=nP=iZ~h=7Xb<)l=U=
&XbXbXb=vXbXb<`/'"XbXbXbXbE6=3F̻B==|\<*2.Z=i>  =!Xb==$p<^7jy_=|]Xb*k>=Xb=?* =`>[r=,d=l;ե>	HOTD|<ꨪ<~ =Xb=BWlҪXbW/%ns==~P>Xb>)=bq=ӎwI{=Su<zq-=m=$-XbXbXb&=@D=C(efXbXbXbXbXb=#'Xb=Xb===.=<4Xb<*;̓]Xb;N
Xb=-7Xb=OXbXb=<,=S/A=eGX=.=~x<I=v=GXb9TW==-0=|<4saA;	<~]ik1~}нlMXbXbXb轥5
<<@=kD=whXbXb=@?=y,E=լ=pXbXb<S:
=YXbXbXb=d_Ļ=Mi/9XbXbwXbXbmϻXb宽k;"	Xb*XbXb3==Yx>#R=Q>Q>	5>=}M/>=^=A=u==2j

k;g= =
Q=j=I-=+=NÆS vi)(;Q/
1
xQ|&R{?Xb-ul-<OW(m=-:5Q=M<<=n=D,XbXb(\0=UW=<ӌ<<ټX!:(o>>B=Z1=6ʽSٽg)܆:XbXb_չ=P=2G=MXbR=ن=k=h*6A«;BX&XbW=R:@Mz.:<	lE;k;U<ۀOXb;iXbXb;]W&:h毻m@Ī6;nͺ;i~;äXbXbnz-se<N:Ț8:=t6<GO
:iXb*;K;4h_;t:3;Sn;P[;`D::><1<&1aq8Q<%((:N幈6v<,I;;;G;_N;sD	80IoXbQ|Xbŧ8ɺE;o{!DXbXb;;;CcRz?;kC8	𹻈;5mD:c::rһx:;*8)Xb;W8s: ƻaXbWk3;ᭉz!;,<1&9H
^5;M:JުNXjw;n@;p
ͻ@;ñ;΃;5kXb;iXb:XbXbXbѴn9cDXbXb;-RW(FXbXbXbXb<5=:ҳV;e:Xb:cXbXbXbXbXb;j0,;'
c:׹3;c!!F
:-L,XbXb&k;Dq;dK;g9_:&:E;	cXb;@:v;dVv;Qr$>@XbXbXb;E`hc2v9 8@&:XbXbXb;eɺ-9k
4:;֬:t_:y;XbXb[h];;DXbXb;κycXbXbXb;L:b'+;ݢXbXb>XbXb;[Xb;#:cXb;:|uXbXb<$<;݆d|::1G;2^BSXb<6:G
N;^_9$;b|$7;r.l;w;Y5=XbXb:XbXb9DjXb;TFֻe;G; ;Zm:y`:KͼF-b&M;>;7;F`;KR1!C;%=I":s;z7;Xb:$
);,KXb<|;c(;iN[:,qymXb;{vh
XbXb;J XbXbR:5>;Xb;;⹦&K!?'50:`z?Xb;z;?Q6Xb}&9XbXb;B;&BXb;.+<-1%;ܟ
;_BKXb;,$<XbXb!:Կ
;\W::ۻt:-"m9g;XbXb:NhXb؎_MXbXbXb8`R<@*ϻ%˻s9ӀC(Fm;;;tq:lV<yK';:ŕgÕ<`0SXb:;xb:̕.::?;KLR;6;),q;iXbXb;J
;%s<<; :ZI:#;
X6:Y;VGs;x;W:9G;PqC?<ÜXbXb\
°:sĺo;&;	f;;2׎;kmNyXb:z|9˦:<9ۣ<
"f<ߺ:	><@;1rXb;
+:s;1VXbXb:~XbXbl;?~;-Xb:.6?O;Edo9;):XbXbXb2ԼUһhnMXbXb:r1XbXbYdƺƎ:;z-;R҅ j;98Xb*4UXbXbxr;fL<6MXb_/:m;Tvں;1pXb4Ȕ:#pcTv4a;ϼ,oؼr#FfW;
Xb<$ar;̶]:;aoXbXb9Y?;޺Xbv;i'=9e9:MҺҢ:e;_:;j4ڇ]*;xJI<,$~҂:򹡕CXb<;^_8]{azXbR;ĸg_XbXbXb;`Xb;#Xb9;h!Y;jNVʻe'iXb;:(;Cj:PXb<^;Xb:XbXb:2Zb~<̯<(v};fٮmhX;.:`-;^[;	);:,;ږ;	'rXb;
:_;|;䛅XbXbXbF5󻇿XbXbi2<Im;j0XbXbXbXbd]'9ü.;=;*°;Xb9ϻj;Xbu.;	6Xb<UXb;@<Xb:o;3:,P;'
;$Xb;BXbo;=:TyXb{;ĐXbXbXbXbXb:^v;?
<;(LAݻ(7Xb𕛻9Z9,<`xXb/~XbXb<;|0;Xb;:ۺz`;Nvּ"kXb!H-XbXbb;iwBk;|J<,;J;,|M]XbXb;nXb<"-λD"XbXbXb;8+]#j:7;:ސ;oΓ;Y:;u m$;<b1;4Ż]OP'	9ԑ9Ʀ;*
:UtXbSu<^;;;)IӺX;E;5bc;;D<.XbXb;컽ɔ9;.;B[_Z$;IA;t;V:k=->W> jXb=նD=7=OO1\.K NT_'<=:=pЀXbXb="	=r2=r=0==5h=?;=c=HBg=Lyhg׼/;Y>=?rXb;LμJXb7
ӞXbˎ
Xb<|=_1XbXb(Xb=8XbXb<%XbXb<\XbXb=I;I;-=%=0;Q+=R3;=$PW=mM.XbXb2Xb8QIXbXb<<)'=x=6=<)==7=2<^MXb;"oL=^j=ku=;=F:I=SY=]6Xb<,(0YyXbXb=Z^=?d:=rXXbXbXbXbXbD>x,=z=);0
==U==;<	<_=@jT=nXb=O4=\TjA==Xb=XbXb=%;g=-1׽sGXb=0XbXbm\e8C}XbXb=SDXb;or=.=Xb=5	r(k=
=IXb=XbXbXb<~u;='XbOXb=s;5c:OkwXb4cGLXb/ō#?<6Xb= Q=Y=}=<><>x<8n=0Xbhмo=R(=w=캡>x;E=+=TzXbXb=Z9`ǻX7vbXbXb7=/M=rFXb=ph)Z;W=];I<:B,:7t):9;
9~:뽻n`5<)-:-@;TF:;	ۂ:@TKS;XbXbXbXb;%eyXb;~,Xb;.;G:W;NXb9GB;/@Xb]zXb;oXbXbXbXbXb'^nǻu;ͽ+:I3XbXb}XbXbXb'hQ3̻;̗<λ;cn<C7Xb<i97ẵ^_"&;B:ʀZXb
C;<:]<Z6Xb;;1B:wXb2w8XbXb;l;SXbXb;;rTXbXbXb:t;2;xXbX/xXbXbl;i;XbXbf:kXb9a4;M^Xb:q~ۻb5<W;?XblXbXbXb;~m<%mvXbXbDinxXbcXb9tk@a<9$SXb:+";w;\\q;#ϼ<
C%P;$f;XbXb:cKXbXb;: Jz}XbXbXb;f:`9;v(ܻ̺l6SB{e;˄Ի۱jXbXb;лD:4<;>x;>;Xb;^XbXb9;.k,Xb;XbXb;iYf
DXb;y4;Ƨcػ:K:99XbXb;alXbXb%JbXbXbXbȻZvEf:˥KET4,Xb;:76@FXb6I;w,;%Ļ;sX8;-;<JXbA"eXb;?H:{Dr:XbXb;y^fGXb@#ѼX`m
κ?ǻG0Xb}<
YG;5Ƃqt@;ц;	kXb;Zĺ#ݻ6ܲ;9!;NR;DO;9+qʌ>Xb;ZUf9,;v4]:v;cx:@:fQ[3.b^XbgM0	7h~DPf[:z^$:F
;I:mf!㑻[=XbXb;rVC89ϻ&(;;XbXb:Xb<:+,ʻXbXb^;w,9vﻕXbXb;~oeXbXbXb;Xb;XbXb;$;Xb$o+:ux;Y:2G;LwD;/;齹Z6Xb;"XbnXb_XbXb;!XbXb~i5;7kF9l8C;x;cκ^;-Od:M;*`I
	&9_;#;K;YE;~=\:F z jXbXbXb:A{;lXbթS #;jXbwû#;;7f<Yź9U9:XbXb;Cu;;B((x798Y4XbXbXb;$&XbXbF;ۺGb<<(XbkXb/%:
)Fj;wXb;{;`XbXbXb8`{:hX;W. S<q)ɖXb;5:8,:;s߼:a1XbXb;] Z:73޿pV;:;cXbXb;3/\;ByXyN;9OXb<zhealpy-1.10.3/healpy/test/data/wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits0000664000175000017500000045760013010374155027024 0ustar  zoncazonca00000000000000SIMPLE  =                    T / conforms to FITS standard                      BITPIX  =                    8 / array data type                                NAXIS   =                    0 / number of array dimensions                     EXTEND  =                    T                                                  END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / array data type                                NAXIS   =                    2 / number of array dimensions                     NAXIS1  =                12288 / length of dimension 1                          NAXIS2  =                   12 / length of dimension 2                          PCOUNT  =                    0 / number of group parameters                     GCOUNT  =                    1 / number of groups                               TFIELDS =                    3 / number of table fields                         TTYPE1  = 'I_STOKES'                                                            TFORM1  = '1024E   '                                                            TTYPE2  = 'Q_STOKES'                                                            TFORM2  = '1024E   '                                                            TTYPE3  = 'U_STOKES'                                                            TFORM3  = '1024E   '                                                            PIXTYPE = 'HEALPIX '           / HEALPIX pixelisation                           ORDERING= 'RING    '           / Pixel ordering scheme, either RING or NESTED   EXTNAME = 'xtension'           / name of this binary table extension            NSIDE   =                   32 / Resolution parameter of HEALPIX                FIRSTPIX=                    0 / First pixel # (0 based)                        LASTPIX =                12287 / Last pixel # (0 based)                         INDXSCHM= 'IMPLICIT'           / Indexing: IMPLICIT or EXPLICIT                 END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             l$n;jfS<3=6<==7	><N?=VVr*b_=ag=<Ow:9=[==
'n>?>MV>:=1=te==;FC=$j=od=	=05r<}ýELkڄ<!(;i<yGq<-=?';sP;;B*ZO>Kf>:=˗=8=yc=<ѻ=*=YN"="='_P=`=Uc=s="O=ny=}/>>x>-=@==<&=H=`n=N'=='L(=g1="+=)=<ջtP==ss=Ҳ~<[=:= =ߺ"O=-7=3=w8=?cn===>Z=^o2=m-=I=ɻR=[o=!=0<"= o	==xݢ wj==fS7w=r2>/=#'=j>	2=.n:7=Ƽ<"v=p=Xv=NOB>=D<<7<=N0<<[Y2&>=\=t=
P=K=<@.DUPqKb$=A<<[=t?~=uG=A=#=FFk=4J==$B=_=]>r,=>>*̗=4N=(;WJaT\<==qs$=\<='Ib=Em=<=<4Q=c=$c==-Ѽ}¼^;âu<<ޫ;k=
v8;=ּUֽi_@=V==L༮QU=
ɠU3=齝B('_uC<';iԽl$N
]*=m
	5,=*=N!N==j===<3=S͍<%<Ԣ弯ZE<=.i=N==u<a0=&=r>
JrUl=Ae#ռ.>=<;Z=:f;,=s	-'x`y#=	*=3/<ܻ=
==Ja7
P<=@=!Zh5m=^JR&=r<=
w0=üזŘ=/gX<3DLRro7;af=޽Kt>υ"g;==lC=í=>j=@>
=Ɩ="_=3O=W=+);=%W3܋#/<
v=874=/a!V<;8#;V<\a;.p/~.=;qj#;w
<',h](/ك;(O2	<!:K;EӗM;aT;(:3;?;,·2;>:ߒ;_;<,;
;<%&<@v,+M	%;Ǘ;$:pVJP|an9V)nUŝͼU滳RƼ2̻Ce_ ü6Ӈ<7'; 6/<-;
<T<;L;Ǩ;k:
L;BSr;EOѻ95&1t+_I(/&,9s;nŹڵ@<2>NϻM3:'(:~
O t_EYGbS	\KP_'|9ύ]м+'<@<;t:;Ĝw:5:)<)ZdX>:ϼ<4}<CN:;yb;];<
<;:Hb;&;8iм4!ռܼ%l^[*\=8;6f:;<;T%;yh<'≻L:Y9&7Z%MTT¥!+^9׺2_;QhI;n/;?X;|O?	c~D4'S1,Mӈ;+<-a<%R;E;%C:;ܞQ;;<;˩<;v<6cta;;;OzHUc`һ?5;;V:fu_!)[y{:);_7+fvξhA#ʤ&;ʳ<<8<uLI<a
4n@9ǻ;?r;XϓHdp"dq~:-O;}LG఼<_nMQi;9:16L5EHm4ؤ9N鄠9`ͼB»|;__x~rLnˑ3O[:0;s:I<޺7G ϻEMD@;\flGQUFV޻#Yq*
%W̻z8Gӳ<ckB96桻R7μbœ'pRE)һK7[9!R\^:>LL<.;ο&v@%fcF;Ƙc;/~;p37<Ϩ<a̺bu;	;j<l":^8+߻s9<;:.秼H;f;N_heqI;\);3诼jZmAPfԻ~Too
S%9ba7hGG$ ;y7S=b=e
[89M	Iiby<=x=Ul=_=dlPs==x=Ȫ^_=$O=qc=q==
^~<xw>
=8Y,aH$$^F<6ٿ=%=:)=<<Q7/eg=+4O6:D6	&=aK=E=ђ<>=/=[k<~=m<;w<{^Jz:=SJ`):NH0|<=Ѣ<I3=*T<<\ƽ2^Zb=d';h='N%KoD^
n3=<t>L=nĤʼ>v<?=8Q=S=GE==ۘyZԛ+??K=	<;/=>E:[< &c=>=j=y=<';JC=
_<5r8=H=K<^I;`a!=t.u	=;=(˽2-<R!=	+=#[==D
{^<%¶=K=Fټ~.w_R`G?uSQP)x=\ʻtG˻{ռv|ԼB97R$:;	λj9OI5»(ɼQ!W9!"^WƟB<:fI󻾾zuhT)wN%ڼ%_%ͩ9yeيlɶAK!a_4@Qټv(Cɐ}^?՗4rD?(nZ⼩%^~޺kyh[
;-Ύ<}>;
<.;|.<;7:ȹ;n;[^:; 7;j:ܹ$;P;޻#o:KI(.7<:ijH܄/9a~;JV˻<;A_;;<:3:7kEyGd¼LZek-X)q_p0@q:z-.1:u؜I<\9μ7P-߼[d,-5)$&(iP<:*z;кQߒ;޼;96%P;'<<<߸;;MBۼ3nQ
&ȹ JRK1+Y+rG|o|:ϼD7R>ڻe;НFp9!@0y;};#;
K<>p;;튶ӹ;yH}9$Qj^n:.zƻL
6yJdS.;ACq:H;NVļ
:>mK;N38:j:+;SƼ+=>:}:W|vskrz
.ڼ
ntaM^mo8mn\UNZͼ"A}:`;"@Ѽ
V@DBG:{3kdRWEhs9zm:VE;=pj"vH9Sbຫ1u	oD##"5ڼ
L+SQ6:Br';Xɾ<1^v;QcY<-Uц/q:Ӿ;!;<<`G&T:-ȵ,;\.&lu/vIb7Gq׻R8S:;<v`&UQP#vrV:.R ;JxlSDu;xlm{:y̮?ͻNz6~"ͼFHE;x[CM}7<{;2s;;qּMϻH򱻂Iݼ-<;&m	@oV~P:r]Ba߻;~n 3;w@yuƻ@{cɉ	X<&v:J:ֻ39:oA:;OF/_]⽼ƻlc鏿Q`
Iȼ2vԼ_ib7Z1*IU@>c{TW"> ;a.?:kD[
,䫼GO(2LsA7	Ft!i;Ot/Hv:ē%:E;k׻j絻a"	ֲduvbx/Sy9ϑUzu;}L;T<~:P-<o<M:18<m);%t%';=a;acn;H8ǃ.RU2ܒ9C׊gBQÉBVX9ŭ
ZCNu5)̻0Or4vBJiS=8񼗒K34z}#>,T:Gt`;v-T$<|;L;N<'
Q<
%:!:9;ޕ;^a<
~3i-O!	;BAxQ~;D$6\I	6;:;
UlټF+;Lat:%}X;H
;d\^q^+p\Akcn:ȏ翻:|;YϼC;KOF.;ȻD
!Ak	~n6m: ܼL(Q-s;	.:_CpXq{^0i:ZHz3dc`:S.`o;̼5%=m=V1-]=;T'<=ӽH̽4};Jr~ٽ$=<QX~<*7v
ӽIL;ӽW=70=3
==$=m<Ӫ(=v=&RE1zR;(ѽX\C=En=
o=f>=tq<=>هei<|$ov1-=
m=hE4UM <ꓫ"<.=dN<.A=d=[= <5
<=3k!H
=_`;^<@&6:50Khl=).>H=,h=Z=h=t$m>D=dZ;)==5<
b`=Bu;2UEf<6==
=L<*='f{0=}<߼-<pgmE_5ndܽ; ro㽁'n_k=<5aI=ay)Cy;ּc>H;Ž<=6=I,ra=./Ͻ|WݽJ=n.=qQd=-n=rƻE=.=g<2<
	=fK:XF-< ͼu,Ƚ\6=c<ڼH=N=B%< =_v=JĪ>=E7=b&^=6HZ9=!_.W;c;=f=SƻTL/H$(=>y*;⡼sٶfm;q<;G<[=jcp;
;<"<]:B=t=,^=o==K=28= <=!i=1V=䃤=:㩻5>#={=]<===-¼=L.FS=fƣ=NH=(=;=sC[=o=d< =L="ļlAL"<^r}l2=(V!:=4$W=*=*<֬Mѽ
1Y<༪%Ƭl5|	=^	=qdS;/==Zs=;h:Y=3"I-=e<[==s꼅%><؆U$<:2Y=,JGV=;-/`+=n=ؽT2ݜ*QӽE=E>ۼX=O;=1S=eT	IPc>L>%=e=fZ
>	g;=r8z=P)y<3Ϲ<
R=Kgƌͽqg7=aC:SɁ<݆'ً?񼙲=Y2|=	f0=u=ϽY<)=Z⚻_5;Qk=$=S+?=p=#>K\=2D=11=T=Y=U=9[=2=m{dP(@ּ)Wl{mHhQ|PBsU299a5CF;	OK:lۻ>ƈi;*:^L:7b;	^@<x;;Qg+úsݙ#廛b~%z]/A&;ϻcܼBKpS>I{CЄ,V`ldXhk\Z#<-_:Y9؜;k<ût<9
    _^L>-wQ	2ZO輚0m<ӼGd"=:C6MdS0i8Ⱥn<˼a/<}9:Nϗr<9[<+<><;`a6<{7 V:đ;;;V;0mX;h6~<{r)n<'G4;=껸qfa;D1:E4nǚ;7S*;$9><7㤻9]8RRY;tM:UwpR;6ͤ:<:ku:z<b19Le5$fߺVwE>H_nԼdH6i:a%e~[֫^ڼn$jLz]UT7M1Xg?\k^e<|<	Ne<~㸱_#;֜w;N)i;h##t`J:\;ǒ:<^ἧ$;3Żw渹W[R*|{x7]l5Q~s&8U7"I&
:Bú޻z߻I[E;Ϥg\9^ۻc%C»eL
;֕:K:
;Z6;<~:<\Ȼ.SκsSzLl;Lx:^Ƽ:˻Њo1.ּqټ;;"MJļrNLnSPOwEzv;;ki|6'Z˼p&߼a0>"2<[{X)6زI6`#2tM\
;9v<<;Л;4tݺK;;;;^|;P8	92;<ݏ;3&aͼI:~+(XƼC;Yɻ`cx{ս;n/qn_;e1%B9h;tt6uMnc'|y4b:@W0WȻ9o
.y`=QB:'	:,n=}>m`::\:Qu_"L4ᐻĻz`+C_:;P#&
h;:GػЕY@:U=e^jD#,~L3<
T̼[Ҽ4Ph㼴.2
:˂|</Z:;U9Ð;E}8| M|;?:ph;|;4;z>T<㦺@
;v(;ӿ:4	DA~@C;+jlPF0;&2
#:C_;ƘR}9۪f8>G
}ź4b:Sɻ򻟐rۘX{B&:͆л_Ch:Ӿ*;a,ٻ[$uC:?9463=:zv!ӹ*;*(jKM޶88"Ir&fI	ZjX/ѼJ3A7%%[X~}(<μ);*g-lﳻc주gJ{kޮ0@a&<^?}u^~eSݻ8ΜR퍻߹D;&̖':`z*\..;q<`#M9bW:Uc;/ZBr;o:n;oCk<&;j/3:. 	;EA!:᯻ט%;0ʹϙ`:9Ӫ;E/hHRAAS;̆:FTea;b=8=J=Q@<CB@<><俽Ž\Y><.lƼ~w!=>=3[<8C<rbm:G;Zۻ=׺F=W„=/kɡP菽/P:X= !;;+<=S=ߗ<1=1Ͻ=h=%$K݉=;yaK༲=<%<2==QT=;=')===2=7=^>:|==Ź>W==r4>=lH=,û=^X=`==9=K[=+\s~g=\FE񼶲;6ܺ0=):>^M¼:<<k=='н9{=G=Nݹ=g=+=u=k==o"=Ϭ==?`=2>
=ቼ=U38=~>*=4=l> \=
/=>q=DwM==m=C,AT<DCeo=@=z;0ؑWi<=<5:q<	=A=n1=)'=!S'=\>s6=q=4>
q=c<ѯ<`sFN;W<Lߟj|Ed'=j=qd>F?9=OT= |Il̖<Ą

%=N=I=ªP>?w=ﮓ>e=f=Q>)x>>=oL=1=!H==L\=k>=X=Y=cm:0<Ҽ/no=0s=>=J=nea<8i#п~OH_N;5=G=vwG>H=,h=lE#3`=y=(=|b	5
;>c<[+ʼ=&>!#==W>=\>==?껧5<==5=Z-=7=+=Q<<&=Ɇ=,_>{m>9=w>*;=4ƺ>&f=D==P>.%=5=$>A=5=c;y=LK=zZ=4U|佰Hx(t=/Z<>X==ͅ;=4b=7G=M=Tr1<}p=Pƒ%o=C}=a===9H$
V/Q 5==̻=U=i>==>K|=D>#2'=>Q>IF>:(>RC>[ށ=C=*=;=GM=
==ƚ=

=LH=	]<8ț@ƺ'z=<!=B<7=<=j'<=R;l=i7=#U:-Y=w'=m==P<=y=˭}P=dhֻ*;yk=k=@@D===ͼfq=g=v<=6=<P׼NL
=ɼI$<[=K=G[=F==(D5>E>{>@>;.>,ݱ>'>4l>><
:=AV=t==G=>A=5==R>|;̼LV3VV HDm]Tw=+=$̻GW";44=Vv=U6=U=4g>>j~=94>}=
>>?==C=^===G>Jh`=2<ڰ86ja<n=@RI؆=A=$2=Ia=S(X=;3]}XOH̼=F2gKɼ8\Nc:V~ߩu=}CFQ6\H?IԼ1廏?UɼaM_ʡ};ӗzId;Ca+
n{:4pl^e$s,iw׼I1!+޻Z;I컄);4:4?NϺcH;Aa;V;캻s<F:
;Ekv9I:.S*/9,F;۞,?(!Q{0x&ܟ꼙,~DUjT+e91<	IYTM94<i(_h;v;:v;;&;;muH<]9:<W<";bŻxFW(9A<޻؁;)X;Np;^;
;Sa5<;;:;՚q@;D̓,N
;F7Y;l(Do:nDྻGgYU1/=L;Y*;ռ}t,.B8*/hޥ:Ǻ[j$qTp<h
7;T;_92n:=};e< ֹӸ:;?U;qKݻ@8(t8,ǠQ$gEwG2Q*}-$F_72'p;ogYE޻<7<<ںJ1;yH<1;$v<#G:;|bn！-κ^v;#i;ش:){iD:)0A9<:pZ2F[;M;
z_>;s;'֯;0fIm±<9:l%(>p;:P%];'.:Q^.9`>9FrHBa4;-D9Tһ4<_:Fʸ730b+VϼN7X[fü-eQ;|Zyo2iJX,#QƼzʼi;?ڪ;<^_;蝒[C;ƚlkC}Һg0<qﻥLp;`H:2ȹZ!yT
zfu:6;<ޜc"<'0;ŗǹT_;mu;s0J;꡻X*;;ֵýH&:CC|s	k8ѠJC ?L<,6	9V^;9cw;"k:B:.b;| ;~'L;f88%u	pӦTBżj/eMm/UڼE
j#P<(9=FE;#;;:_AҔVԥ=:l;46=TM#@紼	aB%h-yyU,HFڥN;`R=ooҼз65;蒺vH7&:Aʻ`q5Q|:;yVL;]*֩&x('jt;/;;>:b躪7	ONݻK;8
;
:r;4i<#zĻW;gQ;l9C(tamR:v}ߚ8<
:7nD:hFr:G޻bu9x:s+Ddj0'F{c;J#_ռ麋2mhtbbԼ_P;;NȺJ;989<k޼\oߑ9;8A"廾ADѵ<
๥䣷w[1Mqx5&LDbx{'J.$ Iȼ~{
MUHܻ7
<-yS<(CȻ;Ka1M<"NICFeu"}>;k;g!~;)׭m̞;hz(һJݺq:;d;m>*iP19&.0t޼eXɺq8:ho;?;_;A{;´;"@<na<# ;V>;a;\؝]GZC	b;}:!DN\9:E?;[_w*:j`k漤"yn0޼#f);\~K`+yϼ7güfͻ
:TG:URڻ/QȻoݹ5;<5e,k	*1(6޻xX/mm;ojGix8XǹpٺO`T;GLdѼ	E^V%!:	[g<?e58l\Y<)4<,:;l;<\3o:ס;{0,+ܻ:S<^z:d<^;|<0p`H۸: :G;{Ϭp|;k;w绝>$9ּtO\4ټ,:C92ɼgx˼r}L|$mxacĀoڎ9|>߻'K!<ɺ|';;~0tڻ%O:;5:C;<μ<]EȺL?R7Qf;@{3FdLmoU-9<j|99țƻͼ7;޺ea;e;4l7
L:jJ";K;d96e9ȼLz̼\ȠǼ(=Ώj=8k;=ͼ#&1ɻ:0=d>
-=75==f=ԩ<$<73R1L=ADe,?=<=b=#=?>=o=B}=P^;W=/+=
$>/+>T==	Y=c=o==W>*=6=m	=}={f=6===aYX=t
wK;=S2ԁ<W<*(@>=a<|<5on4δ=J=]ּP1/=>=?=G>>J==<=l<ʼ9;&+Q=8>9:ԇ=jT=Pv=>'"=컇Ѝ=r@=D=
D=1Zׂ=7=}=mS>$=;
=ܷ(=	=ܰ>
"=d=A$==z>>>mX==URX}>Y	:;
=bD=9U<4=
=:>0Ef=v=#<љҼxػ<½s.h=dw=6k$=’ڽơ=>)U;=x=b>j>="=7>==B>=Vp>
=4=
==L> |=ܦ=Q=f=,=}]==M^a=&=<=]"=";=\>e=k>*L=Ta=tx=`r='m=4<&PO=7B=Jh=@=7Ɔ6<=c|=sɓ=D=阼d<$v%h<`
=L={=,:=p>JH<==A&=T>|1=E=^=(=*=x=ĸ>=
=e===pw>
>=)MV>A==%ۇ<=M=&i=;<;j z=]	Vr9;ӗ<==zl3>=F;}=k<^d<弽h9t>3=6=8=UO=>">>.[=P==3=f>A>o=prF==nX>X>zT= $5=:===Q=[=MJ(H=Ag=^=p5==a=^1=5=98=O9==2>"=@.=>RG1>q=>L=/=͗=Į=v,<㫺\==_>2	><˩=[=B<:'e=yi==a===G==n`8I=%u}=-f,8x=dU=D\='=\9cһɏB;{ 2ϫ<;D=wo=\(=E=X>=X
=>a>>3$>T=\==}M>Y=т<=sO==>=>==>=A)	>#<<4>n=̀=>*=G===z=ںy=F=>Zv=̆>
Y=F=u>j=Bk=(E>U=W=fk7=u=\==Z7~C=NJk=w>=A=,=qa;hF=oV<:%=x=ȼ>J=Ŏ=0=0>(ԟ=7=6)={<<[;l<=qHy=`=#=V=Y=$4=񽛲ý(=}=d=}^<ʞ|O\=C<9lx=vfv=0U=q{p=6RoՕ=a)=m=t=eV=׼|=<Ԧ=2W={"C=ɹ=y=q>>"6O>bw>.>6=M#=C>$=^h
=B=;D>DLL$;M=J==>*=H=X=H==_R=h==d=zdV=>*>2;<>	>Qp>N==Nx=>28@=q=bP<9><>I=5K
ָ=o=œgY>5v,=t2=K=ۜ=U>=L!>6P=Bp5<.=?μ=2c<=	>~#9h=h=H	p^=t,<=;>
`>USN>fU>?>>Ku>=P>:%==E\=P=Yp>=Ƿf=#]<|><.粼Bh;V===N=nI=o=2=y#=>7>*^>L=@i=3|=>>&t>B=gS>
=n>:ce<>M>>=Z>
%>Y	=X=vz>=Y=tw=Mh%>
=jCDڒ,:ֵnW238P\#/3>]fD@ً9
Ky;7Gۻ/6f;E<;8ɞujg9xv9~B3#IR<\;ʞj<]rL<+R:n3<<&4ӻ;2һ~4_;|;}a;hN)9Wy5<1w;|g,V%Q@ǐż\/D:ɿ l1ccֳͼM»9;/;\	3:ō;bq:#;y;<X<:=:dw;Z-:.;n؀aY6Ynb:Ώ»u;;1_LeaHU4) 0+ڻ9g<-0A;;8ݼZL;u_:
6;;Aܻ,V;`%;1C<
X:/;0;+P;21<8<}<⚹*c<W<dP<5;;|=;֧H<2U:<Cf;<&_;W<`;.L<*zS<$;3f;dWIx=:b;;ZEJ;E<	c; :2E;՗;m;<0E<;|}<$;2<.L;6;V~*K?:+`,/g<<&<3<;8\:l<:.E9Jn;⻻8=<=ĺ|oϼ;O;/;<"cJ<z-:L;1Y9"g;1 &l;FmI9?;1AdE:_Q;ky;J8Ux;ːU
'<+9;Mr\G|aPUDn»>5ӥn:YZ޻T
Dz?:Z;!}%Et;鬺W<z»);t;gIm:FjnU놼{bżBpr	@1"$f:09]>M	yd<Yüdf2$쏺s-=hL
l;ut;}<\:0b:_rdD;pGg$<\:ݨ}Ncݻ|sT;:4U;i_z;<&YH;72mHʻaj;L"HnhFu;Oڼ];lhd)tw}v<;q绪XLAI&.;Q_J\Zl}_U׏
㢻PM$#E>`cO>JApf0迯DvC
!;&H;co(ĺ2@;9~
9:*׼ռ$;p[}C3;"̹ڻdZl
H:ͻ;:0;Dk&:?;莺;<;\
:': Kh:%:mpм.:HKGkun6o=aS':#A*1]#50cCRFkÐ;r;pWBVa/;8*-],)rAļ?<y	"Tg¯ۼ˼HؼTi!Cڻ> +$;$p.Ie#eYǼe>7oӼL@VPD#iM_Xycyyǻ*+\Ui@)(;/?
|C;kKP:\KzBʉ1vfS M;a);<1;;ǒ<i;y.;J4K;=q5;<#?9Ǽ;er;ۖVzY{S<9;;:(:e;NI><C:k;{M2:~;# ;1;Jho;J<<;
;
~;r	Bqj[KrQټ8aL쀺҉J?!4.Ek^.vag[\9aƻ$Nt<}I11dd:JYͼ	^,B)S;躙mEXJF:W	@M	;XAR

ƻĜXN+eG&'O1>$[gRػ?;Ns苼R >:3["5ӻ3"3;WGݻ2<̫Sa<&F;:jpYzF;};d;!,;Ҧ;Wz;<;^И<i:GT;<;C;;XmGv:14;eh;E\;3&(fp<"س=f+G<^2h;{P&v»lD;t䧼*gJ	.K19%;;:Wj;¼};lx,W'h
3O~;vp:u;H3H弉ڼ/ ;@N9#;};);)[-H!"јf!0@)+Լ!s\ࠞC`?
fOF;;H>B_@6a(=WP&' a[%Awf.#:QG-
{]RqY;;)T;gBbUu:?4q_o,޶;H4<+;);Ϻ<)<#;9h;C;p;Y<@4<;Ӻ夿<{ɼ];n;;!:(;:4!!y|;1r:pżOVɳ߼^[YPN(`$ۑ뻾eʼ?ؼ[.y\*A\z<D!˱9J%ㆼV#QCIQ'q^fN)[;K0#;<e;^8<\<E;3<今`n&=>?[H==S`>H>=ֺ/G=h=(5<<=J==f=R3=<9=&O=>y=%g
L=lc>%>%PS=KV>I<'= c>/=vq<:q<ϲ=vq==d=a=ć=<8ER=庌=j=d>==c>*Ć>0Z>Fa>O=K>Z>>`;>4H>=e=
)==%=L=I=齧=<¯<DZ5J=@=;@~=@->+q==*=Z1>Ϻ>[y0>fE=ܲ>F>D?=u=ѯ=>8=J>"=>>Cl>>n%>L6=_>E&>\A>H=	>j={=w>B>
>=ߥN=E=sH=;"l=)>@tB>3*G5^>Y=&=<,=<=W=C>
t=>/X=><2\>}>E%>?=ы=m>
˟>==_=Ye=(b;*=ݔ<Մ=y==R|>;A=B=Y<T>$>3:>>_s>k>|ϼ>Jo>]>;g\>U>>U=6ax^.=#>$=<\=Y~½=<<=
>1>kS>.&=Z==V>*=;u>x=s>]x>qd>Yt>")> >lp=>;l=\=:>xX=U>0M>Oq>1YZ>>M>	>,=>=+k=
#=>?}>96==>	
F=ʁd>+ἆ@x<Ҷ=;wx===k=(>1>0=^3=nj><=.=o=I=>>Zկ><
=9f=>[=V<̶4c=:=Fv=)ǼFG>.	$>	>.==={W>^=粝>Hk!==&=$=8=2=='z>KV>;>թ==ZJ=Asp>%g=GY>D>Z@>>L>zIe>	N>>>ojm>)>S<>=
"=,4<˺
===9~<(
=WPI==>+,>>>a3>c>\Z>>>2/>,=~>>$>{>r5?(1~>{J>	>p>m=>>>j>5ڣ>Jm>	b>\8>c&>F>
><@==X>v>,>>$==}Q=<2Cs(o=Z<>>J>>g>=t9=>%m!=->=t΋=>>&C>zF=㊥>9=R==͍=>)><{2=10=}O3> e>#>">1=>+>Q>/==r^==Ÿ(>>+-5=>aO>>",T=:5=6!K=B=o>wF>%>=/>A>R>v>u]>\>>>A`>c%>Wu>%]=6==ƌ=Fl=ִ>=;<+O;=q$=xr>O|!>V?8/C>>>>>}>ToG>F>>-%&>~>L>+>޻>x?>_>/C>`^O>.?U>κ>A#>d>u>]>pV>C>+>9=>3c==}>>5ҡ>5Qt>	>+\>p=>%W=Zr=&e>^H>1==:=W>%p=ߌ>Z;=>>|=ʒ^=>>W==se=M}>$>Q>$+>h@=#>;Ƴp==J<ҧs=*>+>)2>
>+w=
>_\U>S>C>D>
it>xD>^B>_:>YZ>a>@=+=o[=b5=$>78>>>Ï>F&>J>4>>>?>>?F#)>>>z>>8>T{=˗>>b7>B:V>ms>>>
F=>,W>3Ӿ??|??C0W>>p?@y>;->e>>\>A>D>DT?F?t>?>>m>>\V>a/>j]>\>mI\>>O>(>>o 2>Cg=8>83>n>U9>F/=>K>>	>υ==Q><•c>"(>>
ԩ>K>J>{=4>]K>&>>Y@>63>s=>=|A>>(=x=t=z>J>=(>>S$p>;'>"===S>v2=W=|>;Y>->>gBF>i>i>P@m>s>eZ>)a>%@>>cA>($>>>F4>>>E>P>>>h>2>>!">˺?]/?w>>D???=?
?q?0>~>T=>ը>&>Ɖ>>>>K4>?H?S*?K@?Ӷ?N>x?J%?9i>b?>T???->څ>I_>4>۱G>*>R|>>>g>y]\>u->">>&>a>%>Ub>Y0> =>2 >4>μ>=̪]>>-1=ҿ>s>E=T=(Mo>s>8>rK>_-n>1>.> @R>1u>n>F`5>w6>2>e>>*l>֭=%Z>"(>X=ܓ=Ȭ>ò>*>3M>T7>>LGE>(=:>1@>shg>uK>vw>#>_>>n>>>1>>y">>`>[>%,?
?>+>=?8?'vn?W>?SW? J>/?:?s?fN?u+?>?Y@
???d?u??
q???_?2?*
?Sk?>?E?(?@R@?C?ȱ>Z>ѱ?$>>(>ըh?٠?_?k?*0">&>S>0>_>G>mf>'?ț?'bP>	>.m>>>>~$>w>tX>;s>JY>?>gm>$=G>==\>Ԣ>}=;=i>=J>$>>Z>U>Z>fh>>`>Ő>"M>7>`L>>`}8>C>=@>.M>D!==z>=T>/? j'?T>?>L>é>y>???c>^\>4?a?`3W?t??~]??@y?9ӭ?gr?3
??S??k??T:?g??A@9R?I?d@>N@#L_@7l@5@U@,@AG@@@2`@y8@$@.R@1???€@1p?	G?8??fb?TN7?o>荳?r?7?W\]?P@0l??>>ϓ?>0>Y?i>?3e?l">>ܲ>Vi> >=>y5t>
?A/>s>?
M>ʵ??>n>> >6>t>@> >>)l>E%8;f6+3;e	SŻ8cd#ûi;Q<o~<;w;'.'9S;ɜP:;<t
׏);jYQb\r;.t3;O;1{iu;<9h2;KP<NE;<ecq9VU<[s9&33;<80<< Ȼ&vJ;R$z`;}i;FG<*o<Z;&:T<BG;ٸ;pV<:;=<4;X<}<;_n<u(:Ԃ;@<<]<;<6b<I1_%Ҽ޻\]4Z>z#mP[zdkż
`d/VeԼj;vL[!%<㩼-R:[;諻w4C<%O#;,-<;Y-i;>gdm/:"SռE’OA'[u!cKxݜ7KjRN^$kW˥%TV7Q!KF+M
j?;r4j	VS?b<MR`;9̹uK
d<jG2}ӣKE.;݇+'D4@]9+y@O瀼[ROR2;ؼ<w:N[(>5仆,+#!Ol"pʼ,":):<L*;#U;8J;$ج.<;ƺS<3<;<:Gp<݇<_dS<:g
,+;mʼF_d
:
UǠ&%>GsCV}DG">Hsy7~
Ni켔D>u,g$fH:T}U>VؼQeip;śHKr<p;qA;5-8`UJ5;<+ݼC6ĝ<
ZUk/sȾ>J|q;Py;/GZ;F
~Mk*xϼ:]?6	ݼV滅6ϻԻ,~p!ǼG޼:TK<{:o);P㻤Tλ{:M:F:;;hn<X;`;<4b<>;<<<1;#<T;~;;M⻙:<$(<Q1ڻ,`4$'Y	ϻ8ȻdѻP](<N;7Q|<'ӇpFH~8yMY;F8}9;"<<< <[!; ;Ec;̌;ը<wT<-ۂ|$;<;<RZ
0º<;;<<1ߺX}X2>EF*>$]?
>(>M>?>'>#>k>>uz>>>F>U>ź>Q>>ښ>>|>Y>qj>V>L>9>Ft>Ñ9?)/U?P=?!yv?Sg7?1x>(>d>?Fj?PY@V@?uc?`3?d?@36?*4@?P@c@=??O?ѥ@k5@Q
@#Z@zFi@f\@:g,@*T@@ ur@ў@09@}'@R?a@P?S?
@B??ǘ
?C?;??{:??(?˕?j?l\?H?Ll?4>ݦb>?
>p>?}y??Z?g??>>A>>>Kk>e
>~
>?	1?>>>>k>.}>
>k>>e>s>ʑn>>?>.>>G5>QO>$d>G
>>~ڙ>>F5>tc>O>>w>Y>Ga>->,>>T>,>
>>A>k?4>>>`>>>:>>YE>2>@#>??G?"g?G?^?(U>>˛?@4@D9.?а??R)? ?U?b?br?5?e?B?=?7?P?"?p?t?Y@?g??1?ç?3?A3?>>E^?0??R?*?> }>͵>>W!>3Q?k>i>o>H0>>5">n><>P>>8>>I>
>?6?//?v>K>O>k>m>M6=>D~>$>|i?_+>>>x>j>=>%I>F>l>)>L>*>>0>>m.^>A>*T>gs>a>yz=>S>=4>v>s>AJ>1%v>z>!|>E==^>iH?D>}>E>">´>zÂ>ܓ5>p%>>,>}Y>>>G:>ch>й>>>c??U?	!?;!j?>q>g>.>Q?Ga>p?	??Y?V>R>>?>q>`>#>Pr>h>@>P
>C>{
>|$?T?4o??>&/>:P>>i>q>~[>a>>Z5>>`>>_>&>kO>_>|f>9=J>P:t>FW5=W=Pm= >+zY>C=>m>@]>XH>hO>Yt>J>>\>ax>[X>>>5>>
mJ>(>>ww>k*>>>L>O>>SY>KK=Ë=>Pc>P>{z>d>>>/o>Jߒ>q>4V=r>D>?=9=s#=(K=|>H<0>S==B4=r>$m>P>d(>8>>f>Lb>>,1>s>>;r>*>#z>i@>>8>>>W;>.>_>X>ä>W>>F>>I=;>fW>xe>H>>/Q>>+>>M>!=H=d>7=#=@3<,=֎=>KJ>)O>>Y>$>>B>%7>'	d>*g=>{>CR>e!>oS>>~>=1j>{!>$=n}>=	>#N=~t==.=>_=>#Z=˜>>>(b>cw>=f=[=q>	>#=>>~==>)>!>1d>]\@>u>]|E>
(>	=ܣ=tP=)=>a>{3>gu>**x>=>	>ve=?>>=wXN==Q=ک=^>R-=ֈ
ݽ<7ٽG	>N>">=>Q
>[`4>k_e>>V>>R>>q>+;a>p>%>l>>>0>^>>r>f>{>7(>[=X==zq>">_>oq>>f=t#>$>ij>E>	x/:UU=]˼<\<>=q=*>JW!>t2>I,C=.=/>==>8#5>2>$o>%">#>".==`=*Q;J>w= ~>
d>![=>->7>8>>=#>>}>:N=~_=H>=C
>+e>l$9=YN=*p=ۣQD>f>JB	=>>yw>2=]=Lj=N5t?@ftg
;29W@hѯ<`=Q=c>9X>3>>_>y8>W>Mt>>S>^>>>{>?>>xF>6>g>ݲ>g>P>x=9=<=/&|=8>'R>ޢ>bUk=NL>6=>9|='<4Q^o'J)T3佄>m>>
=pXA=`
>,=P>$==Hu==|=/=:<="-1=2@+<"cHC>=[=<ΏT=Х=kt	dz=]Ą@==!=CH=>u=N`=cN=>8D=>,d=^>8ަ=#f>m==a==((>d>T=ݾ=4=Ӣx=g>8"> M>PgT>>b>&>eN=h'sλqC==+TǻVu$ֽH==0=>>+>$=>+]S>>/>jp$=Z>y=>*K>Y={>h>{+>7w>J>(>[&>wZ>/==s`=XqzR=CE=}>"w=Ȼ>~=!=܆=<{=Iq
Yr	%(1zǽء2,m=	ߩ==&=8n=>
v5>-<=>(iv=5-==>=x>'c>
xn=Њ==_G<7 ==Ak=!g===\<#'o;\=$)E=
@=&=S==,=Od=w㼟"<=rq>/p>=>t='5=>
>u>̆>>+\>z==<mt=uU<8")=K`eE<h=zH=j=O->" >"T>+>x>V>9o/>>Y>E>{(=ι=G>/>xT>=m>7s>.>o>ay==<Ja!<'; ;$=&i=>etH=#F=#;Â&%hJBC$jpy>̡;z:=i=:=c=5&>D>):==X<p>/>> >=%UG=f=;=p==}>=55',1<^j~=C=mϦ8>	=	K>ћ>*6=L=4<*<#;@<ă<6e:k<&;&<OV;Ұc<V<>=|;;v0-:s;qc`;+Ը;<*iD;NBO!<&Q<)T;m?1;K'VݼOwl:~Eb;XѻiQh;`;P&_>~ջ0";Ϫ:U ::͡<{;>OYs;x.:K<8<,Xc@<:;<0I<1;K;r9V<70::<5Z;;uw
0<<<s3<[;<9<4lQ:{F]Ve8A.AF~qΔe/;b5];hk;;v<h:鄫<;vIc;6;q<*	;D_;f8:;	v<_xt;<_:1e<
+<Ȼ:cB<1g;LE<`<3<<0<	<'A<+cy?<ջY0:pqӻR):g廁A}Ĭ)x'Ӽiu<6<;Õ$<F;;\t<U/;޻.G8y93
,޼64d<I5B}[Xd.Ữ+36:l9<	/饻'rc;A57%;à׻4~c?{s%#;v|AU;\$Bz
*	>ɩx8cٻW4şx}<6L;DH|;3NQ:|@vSN5$2;Y3JGTb:qNC˻>;Xe	}¢zE:yJǼE;#KCTlt9TSV;
aM9ڼ1:Ƨ<7<
A<<H;G<6k:×;s~nMw?==w=GeS:>K>5#>>^>O=j.><>-=>K1*=3I>IKr>H8>;>*S=3v>^>>u^#>.>=>5g=;=?2;=wR"(|ڽǿ1'O/"Ҿ*-8JK0* 9=1B>
^(>==>=>>O+	
h==Ч\==Zi=0-<a=c=\<+d:z<=><_L>Ac=X=sx>VW>e=~>
y`_<=Z=\Jow>->Yp=Cg>C>-Z=OQ=P=ے=`%a>>&>"Z>H >Y{>>Gr>>J>lo'>=O=t=
7ș9ݼvZ!`ı=Mi>3=̉=t&j=Ϥ=fG=
=l>=l=+9=2=w=mUv>3p>=V=*=\=d!fy=1l׼p=+ů=G=6=ŝ̼2=Q=l=>l >R|=Om=>7J>]>E;W=V=钌=?Ͳ='=pл!#=>=> ׊><=>;=[=!>DV=`==߼=Ї=G>ZD;>g}>Ry>Ef>CL>2>[=\=G=(=;,<ռd=Doc=,<M>m>m8>="_=\=ȟ=WaK=WWQz===66=<<g;=P=E(>}`==b>L=Z=rJ>~=.=^-=t=_=<=s=uL>U=0>'c>"؅>;>f0>>Y===j<<@1K%v3;;;%ļ7#=;{s~>E.=^t=}=(==	=h=!9y=u=
=	ݼ=k^lWϻ!5_9|3̅^=	5C;:<=rƍ=X"==|x=]>=:=9y=-=R===/	vRH;:Aܴ;d"<	=4@=%?>_/=G.λ==`=Dž.(=l=v*>n>P==N=RAq=V=e`;=@˾=[;=B=".>eH->lw>)0>r>Q>a=&j=)<+l=
=^8=l:i<
=8ow==j;fV5=Z=>':7=[B<{p=@7#4-ujLxiŽY:罌ɟ^Q\\JoAg޼=i=X=>U>|>y=GKT==U==	>IK =s
=>4>zR>3w>#hؽji=K=\=ݔ=;t֌<@%N=S>=6=?>f>*<=:y=:`=Z=f<%*<7>C5\>*>
>#<>6y6=Ғ>S==w= ==@I<퇜<@5V=?=VL=>>=mv=AG2v=@=^FF|=3==y(==i=$-a>ݡ=ݍZ>,Γ<fB="<=;ӽp
=;f=q=|x<;9==tK5>B='>=R(6===Vr=JzQ=<2G=7s>eo={O=&=ɿ>s>. >(=>j>>6=7G<T=9e.!r>*i!=pF=
0<7F==YXj=l=*t==F=4	ں`C=Cc=b+h+96TuZ=>=JVؼYU=x;<}=L^=5:===j!=G}*]>QE)=S~>	4<="<=\W=eڻB*>f; Ə=<$ =	=>y=[=>_>KC>5	>>LE=+U=¼#= =w=Iq*>;HΝ=d0>7<ֱnk; sW9_IbIB:LZa	ν@H&=0K>O=j=m5===(==C=ʠ=4>=<j8=I~\=c=n=|L=kq:Pb;X/;$<|Y':;r<+t<<-;`@9@;;;k(f:=Kۺ_#;B~<3;ӺW9'߻T'Ổjغ1;j;[<`;.;\u<ݵ;ٻr1|-z:{Z;B<6G;a:l;_:úA</; (9v:zG;ܻI;.F
n<};<03(;A~:-氺;W@Zʹȉ>;!6.3[V仑4NCZ۩;f:~;t;WH ;;1Pm;x<`:?<>2;;;~z<^H<1َ:<<ݵ;2<mh<-A<><(?'<^7<;o9Q6ϻ_;HJMt;tE;_;*'<+|9\Y=O;m+;ɼE|*GE;~	;:򹽓"WP;'T;2;{;Rܻ̽;B
qҰ:&_;k';\:;{~
;4G;<;I:~h;XHgH;<;o"|X};8XPx;.'μ7Z%sH]

`溹ɺ/}ؗ=X_
CH:gܻ;{9<~;M<:!P[;8;g<>ݻ;e;/EH<^n;MƻV0O]E<c;G:~<&#v<"<ҖD;C;+.Y;A-;6;%EB<=ɰ;|o3<;:빳Z<(4~;|C;\i<.];L<*׆;j;~;vw<<(:Ne:vܼ>BO-9˭#κI};׻IIʍ%Z~_A;r<[^<ry<J;l;Z<
;Υ;j"s;*;廳<I;<;</<=OcW**;Kqd:QB;y;m;Ei:<(<D<f;/4<'q9:$=M$dk=C=n=5$>{j>a>BN=m0==V=oy=O= h<׿==T$I<=h<]<-$ͼO;ޞL/7[MJ;lLźսhR;[ʽ	X=(=Dx)=Z=-`==՛`>1=(o==c@=P[=EG=O=_/==|0=}<9=!b߽):[q$0W>1r=]:Y7=1=>
P>p>8ם=[z=?gk==>(=ݦ1=Ȍ>"9=SbX=ʐ|=ls> =r]|=1hS=E$=c=SRvz==*>@===k2>/usȹ<սmL$U{޽A:^9%>^&>==
*=U<==c=x='8=$>	=bO=u=3_z3a:9$ý߂*>K2Q玻JᬽԆN|MϾ'<<@/=sO=L=V=>G!=z==ռ9=Y=!=w<;w<˚<;-!M8i
=?ܐ9=~=a
hݽb=-=3=f=Gcp!W>D=J<:sn<=ţ;R̾!L
@Ѻ􀬽A|{;VHKܽ"{ýQ7=A=Ĥ=G<=W0=;=QK=kX>8=ei͗=%g>
=i9c<\^=v'h=,W;"a;K<0az,\s`

Ce҆-]ڼt;o=#=0=Y=~===!=<\'\=+=r=m/<Όs.o=^<9ڠ@=|<<.н	⻀1;й3A`ؽYx?Q%=I=2={l*<`=jj`=%s=x=]79Ø5=Q?i=ޚh\CC޽lڽb־|TP~n{K)Ix$ǽ]Qg04=<4=<^=NN==sQ8=4=<ܡ='=]<J=9==X^>)L>VL>";=d=u:`=L'=p='Kҽ:;37fk<~.<ū=b=|=G
9>(6	=k=<<=)==o=9=O=	۽O==S=*R==<7=$U<"7$==K= Xܽ$==Vm=⺫]#=;>$=^Q=(=i=%="=+$=$=m[==E>l=3p:g~
=P`=
C>1v==g>L\=ڃ=l>=z=._<(i=-7R==j#H=c='=ߙ="?p=Ud=|HY<5A(!fD`=z=-==$=?=˹bs=D<j==	=Z)<ڃE<yO@ǘ=t=Ԍ<5'ܽv&s½oݽX;H1KZ,Ɩ==Kl;t;7<:F:;;ڬ<8ŻQg3;Eh;'[Iy<	;E;A9wz;.:6aPk#ĻȂ-
;E.jθ;t#1h(<$!<."U;	K ;qd9Y~x6@l;=]:]1f`f8	;0Z9(:X<[ܼ	:3WMmY<_me8;:;ׅ#9;ӻ2~䪂;2;SG;cƻra~*fIW:NSg^"M;M麐db<R;S:fc8k=:s;U?^ok;qh:ʸH<0[wTz;q{yo(;V1/;C:H:g:rԼL,л.>!3y9;9z"_'MNhg|:<<.c;|
<+<@}m<8<9;';;亱Kɼ|3;`<D̬9VqcR~	5:ѓP:`:PúsPS;;
F,;<$B»R[;&-W!P':,V1:R4cI;5nG!1I;=:!ѻJ"0;n;wyn绨L;s5/:<»:=<_;eQǏ;e|;/(;I;\:dջ%T;ٰػh$;pλ)<.31eR;dFo.:? 9;z;C;;5yJ?F<7ȏ< 4[6:xɥz;Ỗ劺t`/o&Mƺyd;Ha;Dz$J:C`DtC:g;w;8ۻ;B<<{;;ӛ,<
;L"X4;X3xH=2<=>>y=W/=	=ϨG>a=R>)r=]9PL^=!:Nżd=
?@Q:Q=%;y=/c==m==&=[h=qJ=oXfɚ]=F+,]=B=h=o=>
9==[;=]=(=Ι<΃-9=M$=5Jh:1==<BVh<ج<=C QFĽ̽ʇXz&r==9(<:Zً=.*=T=m{(+4Y'B9WxMy8Hvx?Sgj<F0<\I齛\\=3;|JN<=<)=@==P>.>.S=:<+=7$=\=d_T=V7=9ɳ=J >=_=I=9>
>>0=,=?(ȻRI==LŨ=h=^^=A=$='<(o=zs====8=;%<-u!;XB3/@h؜0=u9{=UC>%>q=[=+=Q:=9˼P@=D&=T>f>7=5w=:>	c>
"(==*=%kn=z=!`=aρN<='=hZ=y=y<=H%nb;=]q=6v<_<
QQ>t=62|*
Z=C*==5B=x<==/);=X@===%<`8<-᪽č'6<`.,V2f/o_=1$=>Gs=l=nt=	P;=Ul0]=c=B|`= =M
>g+;I=iE>.>0L?=B%=,<0<9i<;j滽`{*")tPO={=l=9L>t<;
!=g=#<>=^=G=[z=_zm'=s%w={=2:Lkb==`=c=H>7=s(6=9GTW7<"eNZ;*b;-to><5==d*w;&2<=z=>=0=W=$=79y=œ=R=b>w)=**AY0+#J2aCdLׁsS;Izc,Rݽ–[1<ȵ<ܫZ$gA;`мqbY=R?=m=rVϻŗi<0===$=]l=>=}m=:VdX
=k=k_>=m)Vo=[eŗ8]e¼ռ?<;5=[=*YW=3`Ԋ=W=ʺ4=p=%=|/:ӽ\Z4ҽuLt.K<,ߴbVQ_9<'׀e9qx>؟<#=&	=Xt׽G+s=>e==:
W=f	=J=-<<=U$=I4LA1
-==5='=gB=C=湼!_=kn"<	BD<
8N.=5?=ι==c;Z<[<9;i<|Z<'a9;e3)򈉻:v1)	踻5W$\}:;&k;4!ϻ\ ;L!Xz꼄]źauڈ3:L;^<=PV;4;TK:X;!;n=;aj<	K;<Thźm<!;S<黄;r;:c;~;h;k;V';;B;?bXdtr+: p;$;[;[q;V:j5=m_;:7Ȼ軻'3nZz:}zb;g "<t;j <:;Qf;pLλ-?oC<X[Z0,:3<;+t4;jKX-;S[;);1Qu}R`\2J}p{=`7\W˸ռG|Aλһޓ;J9k=B@UU*<R;*<[S<8k;~ݻR}f<I׹	b Rң;:7/k;»g;λ#Dٿ1:;Œ;7<+W;*<-(&4D<f!;;<ץ<7;Vv;פ;;/
;뎟<~`1DQϻC6~~I;H;.;*XƖo5;</!:\;=lܻ~yL:
N.
;pX<j;g.a;U:Wɺu>;=P/;s<
=U<1,K<9^<_P8r9Z;4m<3`;CU;G+<o};u;;+zriJ9&<2i;uG
oFﻫ燺_<&;;o+,:L!;;g@!<2:Hg]nV;y;_<%Rw<0<Pû4Qs;g)<(,:3RȜ|K<-u;=<:C<&<)>;w<(}<=(<(y; ;7;_-CvݼRJ:#;.<[<;l<;rG:#x;〖uK<_0<Ώ;<ݼ[b<:BӤ<
:PJLԻBD໬0<;;ٴ;ګ9WwʲZ8O绕`S:u=3C=1:=Y=L<#N<5=e<#1[An<C=;d=*C*΁Q<<<	P~(X3
ҽ4ײb}~OLAK(<=c=J==5e=<!f=i򖼩_=)Ou6wJ4=TY=O<<\;b[8;Tb=`T>Ԯ>s%@<e_~=fmڑ>>,ߗ>>Q=5<^=$/=<ē=
~=3<=<첇={;=4*=|f=>~s=!ڝ׾=;Z0Л<ӽ@򕽖½m=m¼s=;/	,`;foӽypx<.u󋼱|;P:9:Bo<==9=k=1=d>8*>G|>D<=u=MoƼvS<Հ=;0R=-=C=q==%={E=|=::==>-<<u;O=7=\ZWcҽ|q=	[ Jвa=7=:	T=4s=੽r:=I<@G7>$=|=[= <ݕp
x=g>Cl=e=c)(;YtX>>x?=aE=xT= =9<νQzCB{L:-Z>=z>z=p=߼X	B<='¼x;%2 _j:>=kU;`	n}t<>̼*;9<<(Zh<*e)/4	7%oc?=nC=2z+== {k=ܽ1޼)M===b݅=h@=$=3={C=><{H;L&=J<>+=ҷ=m;i
=W^R9%=4:A;¯<9#3klD=Ͻ=Qi<{t=|<;=y:>b=YZ=H%=sOO`<=e=+Bm=)lV=!r=o@ż/X%<s=<޽0U==;=a ;SD+8^.Y>@>2>۩=W% ?==<===;=f>#k=v/=N=W,==
<<˼H(xL>>D=6=!tD%Ưýܾ8=vqsm=I.=J====Q]="^=G=(>=O=C=RoߠB\߁kÔV>t2<<󩊽T½e^d==½3KZ`+=̀;cyi=Ơ='xb=Ɇ3=<<_ٺ=?wN;ʜ=\=KT<>=P+;6<`<hz;tN=KJK<`==d=ڜ=v9y{9.^A໒p:;;`:h:&;AX@@gA:ռD;9E<>PcͼM;ʃKż)YsL:;Xd;';oy<<݇<
94;pl8-,:s(<&#)R<1P?='́Yػpv957dC<\zs.;	-%qo5:C:2R-3\;@.ݼ
;XH뻤5@Z?2[xe-ż޻u`[)¼EnF>o~k;K-^,9bZy;''u;;˟;oS;/9#ʺ5:6h6ԺLD;p*I<Ϫ9S59MμU;%[;ZA;΀:G7;t;걖;ʘ;Z<(f$;J:);c";;;ޯ<:cf<.X;l69׸-Q[>;<0<<c<-#:g<\ƺP;;!_;;聺;T9uC5;tv/}(Ļn&;Ҵ>oσ;m<10"<	;p.ɲz;<6Xp;M;|gӻ;
m<\_9Wk;E:9;h;U;zGΕsX$!9~;JB<yB;F
ʻ!<ټ;,9绫GgE;;6;k9$;̈:z<l0<Һ<c|
γQyl=TAq==w$9<&<I-o ===>=6>=x=W==ľ5?->n N哽4Er="=I==ҽ༚<:=R@6v<-:k;A$%"};ܽ;<pTau%~̼Jy91=
%=b=Yw=
v=.==h="<;=$HtdT{=?	n
#'{-׳=Mmټ3:S#D[kY:	:&CS=v=׊>~;&μ=d=X's&tUi8|=<=$U=.Ի=.=jŻ.[	=WF-e*9QX?=@=i%<#;=	c;1=>=+7<ۼt{aql6=,==mG{)g=ꓽ"D3=,k=a=
=ni=T<\x<_=ja//tM>|=֙=V9{=~i=O==\:%<=;<=G椽_=@b>
t=@<ۥ=E=58(=!:$`=	<<[_h=:4==O>mI=m׼^Bxk賽ЅĠ=q<ʅ9X=u>>(μw{===%g=13=E19ϼa|;;;ϻ=%W<
6=xS:޴==64=C<._;_=F1Ѽ\AG(<2cZa(=Uy=GuSὉ@=	=jq=4= Z=p=O6[ZH:/j=Uv>-#G<
=Bc?i	v)x;=<=a)=`.1=?;{cvAT9<2#\==_=c>e=g<%+=2)O6=mXs=<=T=}=V[<۠=21kay=Qx===d=SU=`r=#=H=bL<<ѝ=n=R+2;M<*===
9K7<K=o===go<<	=a<ҽco;h=#n;;Q;;;[<A<4<->1lqj~w];a]A0nk5<k,Hkuќ;;?<.\<	
:
~ֻܼ#	һ\
X\d Z:v<廲,mfA+vD`:bƀE;q湡J2:$dL>ػ;Y!;<;sp;ʤ:
Ľrż1:4{J;b;i:%~cY)xJ<me>(:jaBĺE8,;n;;7;;#;qo|p;l:vU	j,<;4C;.<
2;=`#;팼;ұ;j;6
<̼*n;=pU;f><%:g,D;i%K:Xs;<;,\̝s<fZ?T+ǻڼU:7EVw+v;[E;><V<d0<ʞ:)<&غSC:Ί;ټh:i~FPvΒ_a];fs;?F:;ô5;{qh<.Uy/3;;`ג:pH:[܏
;1^<(Q<|@o"<]3;^;/D<P;K;;nV-!;/:
4<%;iX9V;,9k;ğ<{,;;<?TP껹
ɻZ_;-{;v;J<(<;.]!~h;"a>zkڼNԺw;;d6;	;<;(;Jv:<;?7Z[٥[oZ:hzü9}+8G<<;Ϸ)@;ۢ;]9a>̼3zm츻|;.;m|;"x4HNÌ߸oS
;$<•wɜέ:>8,˼(;|:a㹚+;B;П<]ּ Pʊ5LY769v88ǧ;:<6x[;:n7f;n;jfS<3=6<==7	>XbXb=C<}e=L1==W;ֆT=䮍=nN?=VVr*b_=agXbXbXbXbXb=5'n>?>MV>:Xb=te=XbFCXb=od=	=05r<}ýELkڄ<!(;i<yGq<-=?';sP;;B*ZO>Kf>:=˗=8=yc=Xb=*=YN"="='_XbXb=Uc=s="O=ny=}/>>x>-=@==<&Xb=`n=N'=='L(XbXbXbXbXb==g1="+=)=<ջtP==ss=Ҳ~<[Xb= Xb"OXbXbXbXb*:XbXbXb=N;{<}:,;_u<=.]?Xb>=3=w8Xb===>Z=^o2=m-=I=ɻR=[o=!=0Xb"= o	Xb=5Xbb6XbXbXb;w3Xbݢ wj==fS7w=r2>/Xb=j>	2Xbn:7=Ƽ<"v=p=Xv=NOBXb=D<<7<=NXbXb<[Y2&>Xb=t=
P=K=<@.DUPqKb$Xb<<[=t?~=uG=AXb=FFk=4J=Xb=_=]Xb=>>*̗XbXb;WJaT\<==qs$=\<='IXb=Em=<=XbXb
=a===yXbXb=c=$Xb==j<8b;U=Ԥ=m=<è=\"x亄@&c==-Ѽ}¼^;âu<<ޫ;k=
v8;=XbXb=V==L༮QU=XbXb=齝BXb_uC<';iXbXb]*=m
	5,=*XbN==j===XbXb<%<ԢXbXb=.i=N==u<a0=&=r>
JrUl=Ae#ռ.XbXbXb;B=lXb䊻%<w<3<o6`=M]=k=;==G޽㺽;:
-'x`y#=	*=3/<ܻ=
=Xb
P<=@=!Zh5m=^JR&=r<Xb0=üזŘ=/gX<3DLRrXb;af=޽KtXbXb"gXb==lC=í=>j=@Xb=Ɩ="_=3/a!Vh](/ك;(O2	Xb:K;XbӗXbM;aT;(:3;?;,XbXbXbXb;Xb;
;<%&<XbXbXbXbXbXb<XbXbXb9;`:!;btPXbGݏ fA:Xb;a<8;^2;*s;$?żZ;eߢ8+:;rQ:ċLXb=ZZ;Q?e=ݖMXb*Xb"XbXbXb<5e;<,<%MXb;f&<0;M]Q:pVJXb;<
wP|XbXb9V)nUŝͼU滳RƼ2̻Ce_Xb6Ӈ<7'; 6/<-;
XbXb;Ǩ;k:
L;BXbXb95&1t+_I(/XbXb9s;nXbڵ@<2>NϻM3:'(:~
O t_EYGbSXbXbXbP_'|9ύ]м+'<@<;t:;Ĝw:5:)XbZXb>Xb<4}<CN:;yb;];<
<;:Hb;&;8iм4!ռܼ%l^[*\=Xb;6f:;<XbXb<'≻L:Y9&7Z%MTT¥!+^XbXb2_;QhI;n/;?X;|O?	c~D4'S1Xbӈ;+<-a<%RXbXbXbXb;ԗXb[LYtXbXbe;.!AXb什NS0лA/eK:-;;UAL::"9H;
\9R%VZ(>:;ܞQXb;Xb;˩XbXbXbXb;;XbXbXbһ?5;;VXbfuXb[y{:);_XbXbhA#ʤ&Xb<<8<uLI<a
4n@9ǻ;?r;XϓHdXbp"dq~:-O;}LG఼<_nMQi;9:16L5EHmXbؤ9N鄠9`Xb|;__x~rLnˑXbXb:0;s:I<޺7G ϻEMD@;\flGQUFV޻#Yq*
%W̻z8Gӳ<ckB96桻R7μbœ'pRE)XbXb[9!R\^:>LLXbXb\)XbjZmAPfXbXbXbXb9ba7hGGXb ;y7S=b=e
XbXb	Iiby<=x=Ul=_=dlPs=XbXb_Xb=qc=q==
^~Xbw>
XbXbxLp
ɑk,aH$$^F<6ٿ=%=:)=<<QXbeg=+4O6:D6XbXb=aK=E=ђ<>=/=[kXbXb<;w<{^Jz:XbXbXbXb0|<Xb=Ѣ<I3=*TXbXbXb2^ZXbXb;h='N%KoD^XbXb=XbXb>L=nĤ<?=8Q=S=GE==ۘyZԛ+??K=	<;/=>Xb:[XbXbXbXb=KXb> &cXb=j=y=<Xb;JXb=
_<5r8=H=K<^I;Xb!=Xb.u	Xb=(˽2-<R!=	+=#[T>=1
=*5;<=\XbXb>Xb;n2)˽0=6XbY=<ʭ=}>P=x=3XbwN%ڼ%_%ͩ9yeيlXbXbXba_4@QXbXbCɐ}^?՗4rD?XbXbZXbXbkyh[
;-ΎXb;
<.;|.<;7:ȹ;n;[^:; 7;j:ܹ$;P;޻#o:KI(.7<:ijH܄/9a~XbXb<Xb;A_XbXb:7kEyGdXbZekXb)q_pXb:z-.Xbu؜I<\9Xb7P-߼[d,XbXbXbXb&(iP<:*z;XbXbXb3nQ
&ȹ JRXb1+Xb+rG|Xb:ϼD7R>ڻe;НFp9!@0y;}Xb;
K<>pXb<%r<	[Xb;튶ӹ;yH}9$Qj^n:.zƻL
XbdS.Xbq:HXbVļ
:>mK;N38:j:XbXb+=>Xb:W|vskrz
.ڼ
ntaMXbmo8mn\UNZͼ"A}:`;"@Ѽ
V@s;XbMϻH򱻂Iݼ-<;&m	@oV~P:r]Ba߻;~nXb;w@yuƻ@XbXb	X<&vXb:J:ֻ39Xb:XbXbXb_]⽼ƻlXbc鏿Q`
Xb2vXbb7Z1*IXb@>Xb{TWXbXb?:kD[
,XbO(2LsA7	Ft!iXbt/Hv:ēXb:E;k׻Xb絻a"	ֲdXbXbx/Sy9ϑUzu;XbLXb;TXb:P-<o<MC׊gBQÉBVX9ŭ
ZCNXb5XbXbOr4vBJiS=8񼗒K34z}#XbXbT:Gt`XbXb;M&`;C;{;g:T$<|;L;N<'
Q<
%:!XbXbXb<
~3iXbXb;BAxQXb;D$6\I	6;:;
XbXbF+;Lat:%}X;H
;d\^q^+p\Akcn:ȏXbXbXb|XbXbC;KOF.XbD
!Ak	~Xbm: XbXb-s;	.XbpXbXb^0iXbXbXbXb`:S.`o;Xb5%Xb=m=V1-]=;T'<=ӽH̽4};Jr~ٽ$=<QXXb<*7v
ӽIXbӽW=70=3
==$=mXbXbXbE1zXb;(ѽX\C=EnXb=/XbeXbR:mXbzXb;nXbח9=3=$WBd޵XbYXbTXbp<<:tV#G[IyS>=
o=f>=tq<=>هei<|$ov1-=
m=hE4UM <ꓫ"<.=dN<.A=d=[= <5
Xb=3kXbH
=_`;^XbXb:50Khl=).>H=,h=Z=h=tXbXb>$m>D=dZ;)XbXb<
XbXb;2UEfXb=XbXb*='f{0=}<߼-<pgmE_5ndܽ; ro㽁'n_k=<5aI=ay)Cy;ּc>H;Ž<=6=I,ra=./Ͻ|WݽJ=n.=qQd=-n=rƻE=.=g<2<
	XbK:XF-_v=JĪ>XbE7=b&^=6HZXbXbWXb=f=SƻTLXbHXb[<,@
F4$W=*=*<֬Mѽ
1Y<༪%Ƭl5|XbXb=qdS;/XbXbXb;hXbXbXb=e<[==sXbXb%>XbU$<:2Y=,JGV=;-/XbXb=ؽT2ݜXbQӽE=E>ۼX=OXbXb=eT	IPc>L>%=eXb>	XbXbXbXbXb= o=O==Ձy==\=:<[=<:XbɁ<݆'ً?񼙲=Y2|Xb=u=ϽY<)=Z⚻_5;Qk=$Xb=p=#>K\=2D=1XbXbXbXbXb=`=,F=
==;XbXb=Y=U=9[=2Xbm{dP(@ּ)Wl{mHhQ|PBsUXb99a5CF;	XbOK:lۻ>ƈi;*:^L:7b;	^@<x;Xbg+úsݙ#廛b~%z]/A&;ϻcܼBKpS>I{CЄ,V`ldXhk\Z#<-_:Y9؜;k_^L>-wQ	2ZO輚0m<ӼGd"=:C6MdS0i8Ⱥn<˼a/<}9:Nϗr<9[<+<><;`a6<{7 V:đ;Xb<`*$Xb;Xb;0mX;h6~<{rXbXb4Xb<<,;VXb%Ż;=껸qfa;D1:E4nXb;7S*;$9><7㤻9]8RXbXb;tM:UwpRXbͤ:<Xb:z<b1Xb5$XbXbE>Xb_nXb6i:aXb~[֫^ڼn$jLz]Xb7M1Xg?\k^e<|<	N;֜w;N)i;h##t`J:\;ǒ:<^ἧ$XbXbW[R*|{x7]l5Q~s&XbXb"I&
XbXbzXbXbE;Ϥg\XbcXbXbeL
Xb:K:
;Z6;<~:<\Ȼ.SκsSzLl;Lx:^XbЊo1.ּqټ;;"MJļrNLnSPOwEzv;;ki|6'ZXbXbXbXbXb"2<[{X)6زI6`#2tM\
;9v<<;Л;4tݺK;;;;^|;P8	92;<ݏ;3&aXb:~+Xb(XƼCXb̴ּL[D;׈at9<@j:仰?z$)-/Yɻ`cx{ս;n/qn_Xb%B9hXbtXbuMnc'|y4b:@W0WȻ9o
.y`=QB:'	:,XbXb}>Xb::\:Qu_"L4ᐻĻz`XbXb:Xb&
h;:GػЕY@:U=eXbXbjDXb#,~L3Xb<
T̼[Ҽ4Ph㼴.2
Xb:˂|</Z:;U9Ð;E}8| M|Xb:pXbXb;4;z>T<㦺@
;v(;ӿ:4	DA~Xb@C;+jlPF0;&2
#:C_;ƘXbXbf8XbXbXbXbXbb:Sɻ򻟐rۘXb{B&:͆л_Ch:Ӿ*;a,ٻ[$uC:?9463=:zv!XbXbjKM޶XbXbXbr&fXbXbXbX/ѼJ3AXbXb[Xb~}(<μ)XbXb;Yɼs(k;LXb);dqvj;]7<,XXbXb*</垻+ 8rnܻ>g-lﳻc주gJ{kޮ0@a&XbXb^~eSݻ8ΜRXbXbXbXbXbXb*\..;q<`#M9bW:Uc;/ZBr;o:n;oCk<&;j/3:. 	;EXb:XbXb%XbXbXb`XbӪ;E/hHRAASXb:FTea;bXbZS!:'6;仗p:4磻
..0KN#kXbUXbXbF6i!D㼸WXb{3,ҼfXb=8=J=Q@<CBXb<><俽Ž\Y><.lƼ~!=>=3Xb<8C<rbm:G;Zۻ=׺FXb=/kɡPXb/P:XXbXbXb=S=ߗ<1=1Ͻ=h=%$K݉=;yaK༲=<%<2==QT=;=',û=^X=`=Xb=K[=+\s~g=\FE񼶲XbܺXb=):>^XbXb:<< \=
/=>q=DwM==m=C,AT<DXbeoXb=@=z;0XbXb<A=n1=)'=!S'=\>s6=q=4>
q=c<ѯ<`sFN;WXb<Lߟj|Ed'=j=qd>F?9=OTXb|Il̖<Ą

%XbXbXbXb=ﮓXbXbXbXbXbXbXbXbXbXb=L\=k>=XXbY=cm:0<Ҽ/no=0s=>=J=nea<8i#п~OHXbN;5=G=vwGXbXbXb#3`=y=(=|b	Xb;>c<[+ʼ=&XbXbXb>XbXb=?껧5<==5=Z-X=XbXb=4bXb=M=Tr1<}p=Pƒ 5==̻=UXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=
==ƚ=

=LHXbXbț@ƺ'z=<!=B<7XbXb=j'<=R;l=i7=#U:-YXbXbXbXb<=y=˭}P=dhֻ*;yk
=Xb<[XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=GXbXb=5=|XbXbV3VV HDm]Tw=+=$̻GWXbXbXb<(::#=V<=Xb
XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=XbXb>Jh`=2<Xb86ja<n=@Xb;3]}XOH̼=F2gKXbNc:V~ߩXb}CFQ6\H?IXb1廏?UɼaM_ʡ};ӗzId;Ca+
n{:4pl^e$Xb,iw׼I1!+޻Z;I컄);4:4?NϺcF:
;Ekv9I:.S*/9,F;۞,?(!QXb0x&ܟ꼙,~DUjXb+e91<	IYTM94<i(_hXb;:v;;&;Xb<]9XbXb<";bŻXbFW(XbXbXb؁;)X;Np;^Xb;Sa5<;;:;՚q@;D̓,N
Xb7YXbXbXb:nDXbGgXbUXbXbL;Y*;ռ}XbXb8*/Xb:Ǻ[j$qTp<h
7XbXbXbXbXb:=ݻ@8(t8,ǠQ$gEwG2Q*XbXb$F_72'p;ogYE޻<7<<Xb1;yHXbXbXbXbXbXbn！-XbXbXbXb;ش:){Xb:)0A9<:pZ2F[;M;
z_>Xb;'֯;0fImXb<9:lXbXbXb];'.Xb.9`>9FrHBaXbXb;-D9TXbXbXb_:Fʸ730b+VXbX[fü-eXb|Zyo2iJX,#Xbzʼi;?ڪ;<^_;蝒[C;ƚlkC}46=TM#@紼	aXb%h-Xb,HFڥNXbXbXbXbXbXbXbXbXbXbXbXbXb:AXbXb5Q|:;yVL;]*֩&x('jt;/;;>XbXb	ONXbXb8
;
XbXb;4iXbXbW;gQ;l9C(taXbR:v}Xb8<
:7nD:hFr:G޻bu9x:s+Ddj0'F{c;JXbռ麋2mhtbbԼ_PXb;NȺJ;98Xb<k޼\oߑ9;8A"廾ADXb<Xb䣷w[1XbMqx5&LDbx{'J.$ IXbXb{
MUHXbXbXbXb<(CXbXbXbXbXbXbXbXbXbXb;g!~;)׭m̞Xbhz(һJݺq:Xb;d;m>*iPXbXb.0XbeXɺqXb8:hoXbXb;A{Xb;"@<na<# ;V>;a;\XbXbZC	b;}XbDN\9:E?;[_w*:j`k漤"yn0޼#f);\XbK`+yϼ7gXbXbXb:URڻ/QXboݹ5;XbXbXb*XbXb(6޻xX/mm;ojGix8XǹpٺO`T;GLXb	E^V%!:	[XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb+ܻ:SXbXb<^Xb<0p`H۸:Xb:++-Uv%"ѻbXb@XbXb|;;p<= :GXbp|;k;w<μ<]EȺXbR7Qf;@{XbFXbXbUXbXbXbXbXbXbXb7;Xb;e;4l7
LXb";K;d96e9ȼLz̼\ȠǼ(XbXb;=ͼ#&1ɻ:0=d>
-=75==f=ԩXb<73XbXbXbXbXb?==a<|<5on4δ=J=]XbP1Xb/Xb=?XbXbXbXbXb=lXb9;&+Q=8>XbXb=jT=Pv=>'"=Xb=r@>Xb==URX}>Y	:;
=bD=9UXb=
=:Xb=v=#<љҼxػ<½sXb=9[Ľ1Xb=ĹC=/nXb=p=j86Q=f8&&I<;r=h\XbXbXbXbXbXbXbXb=$:=d-=
Xb= |=ܦ=Q=f=,=}]==M^a=&=<=]"=";=\>e=kXb=Ta=tx=`r='m=4<&PO=7B=Jh=@=7Ɔ6<=c|=sɓXbXbXbXbXbXbXbXbXb=p>JHXbXbXb
>=)M3>=o=prF==n"=@.=>RG1>q=>L=/=͗=Į=v,<㫺Xb==_>2	><˩=[=B<:'XbXbXbXb=XbXbXbXbXbXbXbXbXbXb8x=dUXb='=\XbXb;Xb 2ϫ<XbXb=\(=E=X>=>=Xb>XbZv=̆>
YXb=u>j=Bk=(E>U=W=fk7=u=\==Z7~C=NJk=w>=A=,XbXb=oV<:%XbXbXb=Ŏ=0XbXbXbXbXbXbXbXbXbXbXbXbXb=Y=$4=񽛲Xb=}Xb=}^<ʞXbO\=C<9lxXb=0U=q{p=6XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=BXb>DLL$;>28@=q=bP<9><>I=5K
ָ=o=œgXb>5v,=t2=KXbXbXbXbXbXbXb<.XbXbXbXbXb<.粼Bh;V=XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=gSXbXbXbXbXbXbXbXbXbXbXb=vzXbXb=tXbXb>
=jXbXbڒ,:ֵnW238P\#XbXbXbD@ً9Xby;7Gۻ/6f;E<;8ɞujg9xv9~B3XbXbXbXbXbXbL<+R:n3<<&4ӻXb~4_XbXbXbXbXb9W<:=:dw;Z-:.;n؀aY6Xbnb:Ώ»u;;1_LeaHU4Xb0+ڻ9g<-0A;;8ݼZL;u_:
6;;AXbXbXbXbXbXbXbXbXb;XbXbXbXbXbXbXbXb<`;.L<*zS<$;3fXbIx=:b;;ZEJ;E<	c\:lXb9Jn;⻻8=<=Xb;O;/XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<QXb<۽;<[IXbXb; <2;M<"R;$:?Xb\\Xb9Xb;'*XbXbXbXbXbXbXbXbXbXb<;/*;uXbXbXbXbXbXbXbXbXbXb<8XbXb;:A\;Xb&>U
'<+9;Mr\G|aPUDn»>5ӥn:YXbXb
DzXb:Z;!}%EtXbXbXbXbXbXbXb;gXbXbXbXbXbIm:FjnXbXbXbXbXbXb	@1"$f:09]>MXb<YXbXbXbXbXbs-=hLXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;qVXbXb;;]1XbaC4;;1~P:Xb;j=/XbcXbXbXbXbXb;XbYH;7XbXb;X!,~;1WXbo
6;9YvXb)>Hʻaj;L"HnhFu;XbXbXblhdXbXbw}v<;q绪XLAXb.;QXbXbXbXbXb
XbPM$#E>`cO>JAXbpfXbXbXbvC
Xb&H;cXb(XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb:ͻ;:0Xbk&:?;莺;<XbXb;DGK:_X;G;O߻]:?;;E O<;wXb%wXbXbXbXb:'XbXbh:%:mXb.:HKGkun6o=aS':#A*1Xb#50XbRFkÐ;r;pWBVa/Xb],)Xb?<y	XbTg¯ۼ˼HؼTi!Cڻ>XbXbXbXbXbXbXbXbYǼe>XbL@VPD#XbMXbXbXb*+\UiXbXbXb
XbXbXbPXbXbXbXbXbXbXbXbXbXbXbXbXbຣi;a);<1;;ǒ<i;y.;JXb;=q5Xb<#?9Ǽ;er;ۖVzY{S<9;;:(:eXbI>XbXbXbXb:~;#Xb;Jho;J<<;
;
~;r	Bqj[KrQټ8aL쀺҉Xb?!4.Ek^.vag[\9aXbNt<}I11dd:JYͼ	^,B)SXbXbXbXbXbXbXbXbXbR

XbXbXb+eG&'Xb>$Xbػ?;NsXbR XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;};d;!,;Ҧ;Wz;Xb;^И<i:GT;<XbXb;XmGv:14Xb;EXbXbXbXb;e;OE?Ps<XbXbXb;J:η;BXbXbBW/c1~T3|
FXb:.Uϫoȼ&XL)Bg'
ZcDkXb<ržnƣpѼK6Xb:VXbķUXbXbXbXbXbXbXbXbXbR:꼅mXbXbXb:X?+OJd@]//Xbp<"س=f+G<^2Xb;{PXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb,WXbh
3O~Xb:uXbXbXbXbXbӻnf;v0XbXbXbXbXbXbXbXbK :6qX4Xb:`#}ɼ
lx:krc5y0'R汼Xbٙep;dÞ^nl!XbXbXbXb>3XbXbXbXbXbXbXbXbXbXb!"јXb0@)+XbXbXb?
fOF;XbXb_@6a(=WP&' a[%XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;Xb<+;)Xb<)<#;XbXb;pXb<@4<;Xb<{Xb];n;XbXbXbXbXbXbXbXbXbXb<XbXbXbXbXbXbXbXbXbc5EO:F,Xb<6.Ҽ7VXbXbXbXbXbXbXb$XbXbXbXbXb[.yXb*A\zXbXbXbXb9J%XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<@YXbXb;54XbXbXb;}=;z,i;zXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbjXbXbXbXbXbXbXbXbXbXbXbpXbXb<XbXb<;/=͏=+A&=>?[H==S`>H>=ֺw>B>
>=ߥN=E=sH=;"l=)>@tB>3*Y=&=<,=96=Xb>	
F=ʁd>+ἆ@x<Ҷ=;wx=Xb=kXb>1>0=^3=nj><=.Xb=IXbXb>Zկ><
=XbXbXbXbXb=V<̶4c=:XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>
Xb<@=XbXb>,XbXbXbXb=<2Cs(o=Z<>>J>>g>=t9=>%m!=-XbXb=XbXb>zF=㊥XbXbXbXbXbXbXb<{2XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=&e>^H>1==:=W>%p=ߌXbXb>XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>J>{XbXbXbXbXbXbXb=>XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>tXbXbXbXbXb8;f6+3;e	SŻ8cd#XbXb;Q<o~<;w;'.'9S;ɜP:XbXb׏);jYQb\Xb;.tXbXbXbXb:.XbVXb:\<WXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbJ;R$zXb;XbXb;;4Ի;,XwXbXbXbXbXb;;4<4ēXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<[!XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<XbXbXb<7uXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbqXbXb	OXbY:E仃hTFz
XGrK7纔.,wjHXbXb-i;>gdm/:"SXbXb’OA'[uXbcXbXbXbXbN^$XbW˥XbTXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbfXb:F:hXbXb`29`Xb6=Kx\MV"peL
Xb<&"Xb>MR`;9̹uK
Xb<jXbXbKE.;݇+XbXbXbXbXb@O瀼[RORXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbVDXbCVXbXbWXbXbXbXbt:6ٻק%.;?N,{.?}(;>_dSHsyXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbMk*XbXb]?6	ݼV滅6ϻXbXb!XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb8XbXbXbXbXbXbXb;~;;XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbo?XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>QOXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>gsXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=)XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb=
d>![=XbXbXbXbXbXbXbXbXbXb>=C
XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbg
;29Xb@hѯXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<"cHCXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>u=N`=cN=>8DXbXbXbXbXbXbXb=a==((XbXbXbXb=Ӣx=gXbXbXbXbXbXbXbXbXbXbXb=XbXbXbֽH==0=>XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb==Ak=!g=XbXbXbXb;\=XbXbXbXbXbXbXbXbXb=<$)E=
@XbXbXbXb=Od=w㼟"<=rqXbXbXb='5=XbXbXbXbXbXbXbXbXbXbXb=uUXbXbXbXbXbXb=zH=jXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbUGXbXbXb==}>=55',1<^j~=CXbk;;v<h:鄫Xb:g:pe;|XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbCXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<ͫXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<)]XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<|XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<
<\Bg<]XbXbXbXbXbXbXbXbXbXb<]:C~XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbH=;6RXb#8XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbLp5g=XbXbXb7$(XbXb=>=>XbC>-ZXbXbXb=`%aXbXbXbXbXbXbXbXbXbXbXbXb=t=
7Xb9ݼvZ!`ıXb>3=̉=t&j=Ϥ=fG=
=l>=l=+9=2=w=mUvXb>=VXb=\=d!fy=1l׼p=+ů=G=6=ŝXb=QXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb>;=[=!XbXbXbXb=߼XbXbXbXbXbXbXbXbXbXbXbXb=;,<ռd=Doc=,XbXb==J7=$<])N95影RۆXbXb,{XbXbXbXbI2Xb= XbXb8<+;1=*=>Xb>m8>="_=\=ȟ=WaK=WWQXb===6XbXbXbXb6=<<g;=P=E(>}q=VXbXbXb=[Xb=BXbXbXbXbXbXbXbXbXbXb=
=^8=l:i<
=8ow==j;fV5=Z=>':7=[B<{p=@7#4-ujLXbY:XbXb\\JoAg޼=i=X=>UXb>y=GKT==U==XbXb=Xͽe+38vp:;ị^=H=Հ==yLXbXbXb>	Xb4>zRXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb:yXb=Z=f<%*Xb>=mv=AG2v=@=^FF|=3==y(=Xb=B='>XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb<2G=Xb=R!=l:)%Xb<3XbXbXbXbXbXbXbXbXb>j>>6=7G<T=9e.Xb>*i!=pF=
0<7F==YXj=l=*t==FXb`C=Cc=b+h+96XbXb=>=JVXbXb;<}XbXb==Xb=G}f; Ə=<$ =	XbXbXbXbXbXbXbXb>LE=+U=¼#= =wXb>;HΝXbXb<ֱnk; sWXb_IbIB:LXbXb=jXbXb==(==C=ʠ=4>=<;!6.3[V仑4NCZ۩;f:~;t;WH ;XbXbXb;NYʊ9X;;mXb<%v;Q>mXb<`:?XbXb;;~zXb<1َ:<<ݵ;2<mXb<-AXb<(?'<^7<;oXbQ6XbXbXbXbXb;*'<+XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;Z<+G'XbXbXb<w>Xb;XbXbXbXbXbXbXbXbXbXbҰ:&_;k';\:;{~
;4G;:~hXbgH;<Xb;o"|X};8XPxXb;Xbμ7Z%sXb

`溹ɺ/}ؗ=X_
CH:gܻXb{9<~;M<:!P[XbXb<>XbXbXb;e;/EH<^n;MXbXbXbXbXbXbXbXb;";]
;7;R\Xb;D;*[XbXb<4;:<.]Xb<*׆XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb;h;2}E}1XbXbXbXbXbXbXbXbXbXbXbXbXbXbXbXb
XO^I,,J (XbXb)oF;u!ӄ:x,XbXb:XbXbXbXb;1Xb;+XbXb;:Xbܼ>BO-9˭#XbI}XbXbʍXbXbXbk<sXb<޾<^9<<2<;P<D\_AXb<[^<ry<J;l;Z<
;Υ;j"s;*XbXbXb;Xb;Xb</<=OcW**;XbXbXb:QBXb;y;m;Ei:<(<D<f;/4<'q91Xb==c@=P(=ݦ1=ȌXb=SbX=ʐ|=ls> XbXb=E^&>XbXb=U<==c=x='8=$>	=bO=uXb=3XbXba:9$ý߂*>K2XbJXbԆN|MϾ'<<@/Xb=L=V=>G!=z==XbXb=!=w<˚<;-!M8i
=?ܐ9=~=aXb
hݽb=-=3=f=Gcp8=ei͗=Xb=M=K=Q=j>%gXb=i9c<\^=v'hXbXba;KXb<0az,\s`

Ce҆-]ڼt;o=#=0=Y=~===!=<\'XbXb=rXbXbs.o=^<9ڠ@=|<<.н	⻀1;йXbXbYx?Q%=I=2={l*<`=jj`XbXbXbXb=Q?i=ޚh\CC޽XbXbXbXbXbXbK)Ix$ǽ]Qg04Xb<4=Xb=NN=XbXb=<ܡ='Xb<J=9==X^>)L>VLXb;=d=u:`=L'=pXbKXbXb%=Xb==JMYp='4<:XbXb;XbXbb#Xb<	@<Ӝ=P7fk<~.Xb=b=|XbXb9>(6	=k=<Xb=Xb=⺫]#XbXb>$=^Q=(=i=%="Xb=$=m[==E>l=3p:g~
=P`=
C>1v==g>L\=ڃ=l>Xb=._<(i=-7RXbXbXbd׽	fXbQ=IX>=Xb#H=c='=ߙ="?pXb=|HY<5A(XbXbD`Xb=z=-==$=?=Xbs=D<j==	=Z)Xb<XbXbXbXb=Ԍ<5'ܽv&s½oݽX;H1KZ,Ɩ==KlXbXbXb:F:Xb;ڬXbXbXbXbXbXbXbXbEXbXb;.:6aPk#Xb-
;EXbXbXbXbXbXbXbXbXbXb9Y~xXbXbl;=Xb:]1XbXb*IچvXbXb)XbXb;aϒ?Xbр;svm{;`q;
;ּBP)Xb]cüXb<7MYa;1#PXb&F& &,-ԼCK:;i:B\qӖNpf`fXb	;0Z9(:XXbXb	:3WMmY<_mXbXbXbXb;ӻ2~䪂Xb;SGXb;cXbraXbfIXbXbg^"M;M麐db<RXb:fcXbXb:s;UXbk;qh:ʸHXbwTz;q{yo(;V1/;C:H:g:rԼL,л.>!3y9;9Xb"_'MNhXbXb5Xb
I<;G<&;#Xb:<<.c;|
<+<@}m<8<9;';;亱Kɼ|3XbXbXb;ilfXb6:xɥXbXb:CXb;o< ^o;DŽ1Xb;p)<
<;S lXb9M<w<`;a`DtXbXbXbXb;B<<{Xb;ӛXb:7<o
;LXb4XbXb8`)c1lXbx>y=W/=	=ϨG>a=R>)rXbXbL^XbXbdXb=
?@Q:Q=%;y=/c==m==&=[h=qJ=oXfɚ]=F+,]=B=h=o=>
9==[;=]=(Xb<΃Xb=oⰼϬgXb!=]-9=M$=5Jh:1==XbXbXb<ج<=C QFĽ̽ʇXz&r==9(<Xb=.*XbXbXbXbY'B9WxMy8Hvx?XbXbgj<F0<\I齛\\XbXbJNXbXbXbXbXbXbXbXbXb<+=7$XbXb=V7=9ɳ=J >Xb=IXb>
>>0Xb=?(ȻRI==LŨ=h=^^=A=$='<(o=zs===Xb;%XbXb!;Xb3/@h؜Xb=u9{=Uf>7XbXbXb>
"(==*=%t=62XbXb
Z=CXb==5B=x<Xb=/);=X@===%<`8<-᪽č'6<`.,V2f.>0L?=B%Xb<0<9i<Xbj滽`{*")tPO={=lXbXb=t=>t<;
!XbXbXbXbXb=[zXbm'=s%Xb={=2:Lkb=XbXb=H>7=s(6=9Xb7<"eNZ;*b;-to><5=Xb;&2<=z=>=0=W=$=79y=œ=R=bXb$gA;`мqbY=R?=m=rVXbi<0===$=]l=Xb=}XbmXbXbXb=k_>=m)VoXbeXb8XbXbռ?<;5Xb=[=*YW=3`XbXb=ʺ4=؟Xb=&	=Xt׽G+sXbXb=1j<IXbXb=DH:<5f;	N<={;)]=(:@]=.ݮkzT/ռsdCXbh?=RPXb>e==:
W=f	=J=-<<=U$=I4LA1XbY<~=F.ʝC/FyXb<
+o۽JLXbXb
-==5='=gBXbXbXb=kn"<	BDXb8N.hźm<Xb;SXbXb;r;:c;~;h;k;V'Xb;B;?bXdXbXb+Xb;$;[XbXbXb:j5=mXb;XbXbXbXbXbXbzb;g "Xb;j <:;Qf;pLXbXbXb<X[Z0,:3<;+t4;jKX-Xb;);1QXbu}R`\2Xb{=`7\W˸Xb|Aλһޓ;JXbBXbXbU*XbXbº;}<Xb;s;<<2>Xb1DQϻC6~~I;H;.Xb*XbXbXbXbXb</!Xb;=lܻ~yL:
N.
;pX<j;g.a;UXbXbu>XbXb<
=Xb<1,KXbXbr9ZXbXbXbXbXbXbXbXbXbrXbXb9&<2i;uGXbXb_<&;;oXb:L!Xb;g@!<2Xb]nV;y;_<%Rw<XbXb;g)<(,:3RȜ|K<-uXbXbXbXbXbXb;:TXbXbXbXb:2:=;:RXb9<:C<&<)>l<;rG:Xb;〖uK<_0<Ώ;<ݼ[b<:BӤ<
:PJXbBD໬0<;;ٴXb9WwʲZ8O绕`S:XbXb@%\um;l;K;[߻o;z;<"zXbXbXb(<5ET&Xb;S#M!J^<z;8XbKH8gc;:S<%;; <T
XbXb;T=H={骼sXbXbu=3C=1:=YXbXbXb=eXb#1[An<C=;d=*C*XbQ<<<	P~(X3
ҽ4XbbXbXbLAK(<=c=J==5e=<!f=iXbXbOu6wJ4=TY=O<<\;b[8;Tb=`T>Ԯ>Xb%@<e_~=fmڑ>Xb>>Q=5<^=$/Xb<ē=
~XbXb=<첇={XbXb=|f=>~s=!Xb׾=;Z0ЛƼvS<Հ=;0R=-=C=q==%={E=|Xb:==>-<<u;OXbXbWXbҽ|q=	[ Jвa=7=:Xb=4s=੽r:=IXbG7>$=|Xb= <ݕp
x=g>Cl=e=c)(;YtX>>x?=aE=xTZ>Xb>z=p=߼X	BXb;`	n}tXbXbXbXbXb=Ah=<̼*;9<<(Zh<*Xb)/4	7%oc?=nCMXbXb=b݅=h@=$=3XbXb<{H;L&=JXbXbXb=m;i
=W^XbXbXbXb:A;¯Xb9#3klD=Ͻ=Qi<{tXb<;=y:XbXb=YZXbXbO`<Xb=+Bm=)lV=!r=o@żXb%<s=<޽0UXb=;=XbXbSD+8^.Xb!=S$G=CY*=%	Xb=&g~Y>@>2>۩=W% ?Xb=<XbXbXb=f>#k=v/=(xL>>D=6=!tD%Ưýܾ8XbXbm=I.=J=Xb==Q]="^Xb=(>=O=C=RoߠB\߁kÔV>Xb<<󩊽T½e^dXb3KZ`+=̀;cyi=Ơ='xb=Ɇ3Xb<Xb=?wN;ʜ=\Xb<>=P+;6<`<hz;tNXbKJK<`==dXbXbv9y{Xb.^XbXbu9; ߻4m7,X~K	MFXbXb_"TػI]e*NGC:滳κjf/|:^<XbkU<&7q;/<A໒p:;;`:h:&;AX@@gA:ռD;9EXb>XbcͼM;ʃKXbXbYsLXb;Xd;';oy<<݇XbXb;plXb?='́Yػpv957dXb<\zs.;	-%qXbXbXb-3\;@.ݼ
;XHXbXb@Z?2[xe-ż޻uXbXbXbEnF>o~k;XbXbXbXb;(Xb,XbXb;''u;;XbXbXb9#Xb:6XbXbXbXbXb9S59MXbXb;ZA;΀:G7;t;걖;ʘXb;l69׸-Xb:B;1;u#;k%1Xb;<0<<c<-#XbXbXbXbXb;;聺;T9uC5;tXb}oXbXbXb0"<	;p.ɲXbp;MXbXb;;Ī-SW4:gXb;Xb<\_Xb;E:9;h;U;zGXbXbX$!9~;JB<yB;F
ʻ!<Xb;,9绫GgE;;6Xb9$;̈:z<l0XbXb<c|XbQyl=TAq==w$9<&<IXbXb =XbXb<ڽhuҽ9zXbXbXb
<皼=<=H\Xb
O=|=<8=>=6>Xb=W==ľ5?->n N哽4Er="=IXbXb=F=Z8==0=E= ]=X==8>=ҽ༚<:=R@6vXb:kXb$%"}Xb;<pXbXbu%~̼Jy91Xb=<=$U=.Ի=.=jŻ.[	=WF-e*9QX?=@=i%Xb;=	Xb;1Xb=+7XbXbXbXbXbql6=,=XbmG{)g=ꓽ"D3XbXb<k=a=
=ni=T<\x<_=ja/XbtXbM>|=֙=V9{=~i=O==\:%<=;<=G
t=@<ۥXb=5XbXb=!:$`=	<<[_hXb==O>>(μw{==XbXb=E19ϼa|XbXb=%W<
6=xS:޴=j=Uv>-#G<
=BXbXbv)x;=<=a)=`.1=?XbXbXb9<2Xb\Xb==_=c>e=g<%Xb=2)OXb=mXs=<=T=}=V[Xb=21kXbXbXb===d=SU=`r=#Xb=bL<<ѝ=n=R+2;MXbXb==
9K7<K=o===go<<	XbXbco;h=#n;;Q;;;[<A<4<->1Xb<;);';;s6lqj~w];a]A0nk5<k,Hkuќ;;?<.\<	
:
Xbֻ#	XbXb
X\d Z:v<廲,XbXbXbXbXbXbXb`:bXbE;q湡J2:$dL>ػ;Y!;<;sp;ʤ:
Ľrż1:4{J;b(:jaBĺE8,;n;;7XbXbXb|p;l:vU	j,Xb;XbXbXb#XbXbXb<%:g,D;i%KXb;<Xb̝sXb?T+ǻڼU:7EXbw+Xb;[Xb><V<d0<ʞ:)<&غSC:ΊXbh:i~FPvΒXb;fsXb:;ô5;{qh<.Uy/3;;`גXb:[܏Xb;1^Xb<(QXb"<]3;^;/DXbXbXbXbXbXbXbk;ğXbXbXb<?TXbXbXbZ_;-{Xb;v;J<(<;.]!~h;"a>zkڼNԺwXb;d6;	;<;(;JvXb<;?7Z[Xb[oZ:hzü9}+8̼XbXbXb;.Xb;"Xb4HNÌ߸oS
;$XbwɜXb:>8,˼(;|:aXb;B;ПXbXbXbLY769v88ǧ;Xb<6x[;:n7f; 1 pixel data                     (EXPLICIT) COMMENT  GRAIN>1 : 1 pixel index -> data of GRAIN consecutive pixels (EXPLICIT) COMMENT                                                                         POLAR   =                    T / Polarisation included (True/False)             DERIV   =                    0 / Derivative included (0, 1 or 2)                COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / Temperature map                                TFORM1  = '1024E   '           / data format of field: 4-byte REAL              TUNIT1  = 'unknown '           / map unit                                       COMMENT                                                                         TTYPE2  = 'Q-POLARISATION'     / Q Polarisation map                             TFORM2  = '1024E   '           / data format of field: 4-byte REAL              TUNIT2  = 'unknown '           / map unit                                       COMMENT                                                                         TTYPE3  = 'U-POLARISATION'     / U Polarisation map                             TFORM3  = '1024E   '           / data format of field: 4-byte REAL              TUNIT3  = 'unknown '           / map unit                                       COMMENT                                                                         COMMENT                                                                         COMMENT  ************************* Input data *************************         COMMENT  Input Map in wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked.fits       COMMENT  ***************************************************************        COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <ħ<2|<<<-<ʔ<~=CG`=+=4=<Җ><<~<ǽ<*=A=M=wK====r=*=t4=Y8=CJ=1=s=Ѫ<_l=?=sA=(n=*=,=.y=-=$u_=<.6;m_;'<$`E<j≮==	=y=X=1=a&==&=2C=1q=!
=
<<<ҡ=ܷ=-=3B=+]=$fC== o=.l=@J1=F=7=Z<8%=*Ų=&=J3=<===0>=2Ea=<\2;[<"_zX<M;F;3:ȋ:S;OY<^;Ͳ;ner#W$%.[!+:7S{VD6n;;%;::,9a|9ɣ*]:5f:9q[g/Ӻ9:;;;::Cͺ̻	;l
pXդwD/Ga޺5O:X@;4;;Ҥ;;T;j;_:N
:`9f\9#G:ɖ;d/;-9;-<::G\慻-f?998q:g:v*9蓫
x>󻄍Ի9rdڧx\7չr:;+A;;Y;ڼZ;k;%;`Q;"T]:
::Vo:U:|\:S;*;;E;4:l"9e
n
硬`--X
g@:N:=:W%\8~
1̻`Z뻕jEӻ$
j&X4қ9":v;0K;a;ë;;Ԑl; W;?;oj;D;:X:>#:5i:uAR:M;!f;FI;Os;1:e9e:e33^~*;,90H:>5:rg:V	º N37_ȦM!eRm廲bYGZ:(:u;?;;;?;ɍ;;;$O;g;;jj;7an;cQ::Q:uJ:ҽp;}4;Ao;R;M	;(:ŀm9vvJNԻ)ʣӹ9d-:/ F:TM9/RPz+ ߻a}q6E&=rJH;*;R>;;I;r;j;`6;d;;u;f;%6;O;Vu:.:g,:v
Y:dW;	;B;R;S~;Dlj;:B8Њf&
>|mújڸ8<::>y!93r|.>Ȼi#TZf	.Hڼ/$ӻӻ~EO>
ʺҸy:DZ;;3[;fOn;+;vh;Q<d<;hQ;;'
;:*;;x;ZE;78:Z:~:x:˓;;KQ;\?;Y;OX;;U;Fl:,8lĺvXzs1>II8/:!K:4	7o}(3')Y{?z»/*9pg	cv7廞rz6ں8U:6Z;C#;vM;ԉ;8;r<~<	;y;J;";b;.;,;Hs;Y{;*:j:r:a:;r;U];mz;iK;Z;Int;1u;j7:9Z:^κٴ%18Ȍ:1:&+E+3cvyE	?>hMAM~PĻѻ}3躿K8(~	:ٴ;HTQ;;Pm;;;<@<;Mk;|;;&;ϲ;7;2;Q1};q:G:::;;Y=;|zZ;0;ma;Wo{;A;%:Ȫ:+v9+7ֺ+亯qׄUǺ#9PQ:3>:sƹg#);-[kǻ:HGY!f#)	\ԼBˈ^P;3̾Ș#:!Y;B;];D;
;"*;h<
]<
F;);;΅; ;;џ;m<;j;F;;n;
o5:錄:ʌ::;;Vq;;;#;i&;Q];80s;c:׈V:g9 }Z#䭺$~6\Ds	JMA.9[U:S9:A5kK랤?޻*;vƼ3#RnCGʼgt\^һ2{':;67;];;;;s;l<<;B;=;;~;Ꮾ;	;;zg;>U;$;^;;;-;$;S;|;|;I;x;bd;J;.;H:dQ:3Q8p},xE$k%	S%X[IҺ)p78,*8D!ໃ';G]8!K E*tnP*ӼLROطzP1,1:d;&l;(;̽;;;;ک;D;Cq;1;Y;J>;[;4;ݙ;žB;q;n9M;:;*N;/;1;*;';72;X`/;v;!M;Z;{F;n;^6;G=#;%::X9kS+cmg%T$
UfO! &b'AN4`|#ٲa{iK
ڻx5
|\f|	['(`f5ƻnL)n:7F;e;|@;;;A;S;eW;k;:B;N;"L;׶;I;M;aq;DY;;X;h˓;9l;.B;9$;Gw;KO;K?;U\;hG;yZ;~,;x;p;k;hʬ;_#;F+;O:ۆ:j9~LK̺Bh׺%-o%.O..һ"
//83ºѺջλ5|PW;~Tg	w>d**n<	
=fW߻‰»
ۻHL
@ɺoki:.k;;w;n;?;n;;+f;;];{;βg;c>;
;o?;H;Z%;T;;z;j;;r;/;;;Q;a];k%;upk;;Y;P&;o2;a,;];c;jp+;c;F;|:x
:8P84빘X^ ֺyϺc(
&ͻz .;u;|;;;;;sD;@;3f;9;Op{;h;};me;@T;0;U;qe;ZD6;O2t8`{8ͬ|6<؞N:?:-$;Y=;h͢;^h/8׷): H:^iVm7?\9;v;81
e$x6ϊ&M9/9ֺ1)C;;S;\c;!
q6ȺC,=P29vv(39<=Dz'#kGM9;9:;;;~墸5]pqICX8YbںLF9C4:/Rûx:ۙ;T;#;ы;:O.Si,27'T깢ĺcǺ8j\Tu,f5
:,9x;
/;e;F;	;(;85"7L}ܻ*]!序su*KfAw7('$cj78٠O== qD}WV]ǹ<:;3o;vVX;M;^V;b;hc :h|[Eielλw8No
Q\F@N86R\[Vɻ04z8棹n!obuﻆl?q^$i:T';L;Yd$;v;(;͕;=;:
*ͻ%NZnFZ@)%q򺩼<B߻(ǎn%bQ!|%<ȸLKFZDFA?m+ϻƻAM>9vH;E;J;;W;;mL;1;$;(S9"ζ'J;Wm<~7H8&##]G`{wغXQaỢHiEUw[JFwܺ
?}"^jdV󻞠dZ`9:;L=m;W7;;;;;̝;e;H7:{v`$-o%.3G;^Ⱥ{ܺ䰻GKoV,廳ڱ0X9D-:dDKIxźI;|g+uJ=%eqһd]e:y;\;c$;2;
;>;I;;G;k;_:SVgGT6t SfM(Q/򽴺H+ۻ@AyN3|\UKȻjJںrY`&$tŻŜ㕻7
N絹J:-;oӐ;x>;6;p;$c;*_;0z;c;;ފ;lUh;/82vg&6;d޻@=0[E W3}C
k	,ֻ=hբ=ЎF5;ٻL?ɼeH)Pb릻	ӗl9ٺ<:;q;;;{;_;x;?;;;o;f
;a;pO;:g\
?}G=]e)DRB[WG4ͻmYǻFEjeﻄAJȻgyZԻp5Z˻Bi.N0
RTčśgT߻V]:;X;|;^;J;L;p;G;a;;l;;6;lu;!ʈ:cb IqPҹxҺ'
Ў#yUIT߻N_->"ٺӻ;i%qESIRԠݯՋ.yW%zH+`$\$LWKbωջ&B>	T.SqT`L9;)M;(;f;;3;/;;c;ף;zl;s;^;[;g;#Y:Q	5c9B-N0I1J2!?{!M zaպ. zj[yۋ#휻~M&g2E!N满)ԻcqIA;Γ2򑜻
"=!˻&琻ǻ!2e'DH:;b;];;f;į;˙>;:;ނ ;7;R;֦;;;f0;$\g:Ǟ캺IaDR~9U@<6ʻH\@p18GܓJs!T6?.)ih_x˻̻2MřӛiӣGx
4,8\5/û(_bHXhu̎;ͣp軿"&U:fo;#";v;l;;; ;Ν;	;
;];;c;	;;k>;'H:ǃ9 ݺ{ȺܺFm
ܸ)_v9<K	PAEHͩ=_'ؗ5)ecPɻ Qgn'}G˻@sŕ2I&Ȼdmw;I.g!(K	N°XCKb~
ɻ7[8黴ۻ,*Sﻋ,tz::L;5s;{Ҏ;	;/;^;Ȥ;]!;;ղ;٧;Q+;];4;;u;/:˵:#|ټٺDž8J!o3COHNC&
Ƙttsغ
qb;V)O_mjVλn"ٻǭm`Ř&̱#Żcͻh2:ӷC	ǻ+VU3ǻHPh7ﻳO7f8nY%Yg8[`x8B:
:;>;A:;;>;;Il;jk;аy;Ҹ);l;U;<;+n;;;:|t::\r뿺]M\+QF	2*~J$MN
d5]&Q2C-B<4K˺>Ӻ:xZ^1/KֻVO^uaʻ8֓qM7k%
.<ԗ]1PR83VZmٻ֮7	ûWFRD+ȳIr3tn9:N;	9;Rs;;
;
;2;3M;4;Z;M;ҙA;В;d;;R;;D:3:9+غWfxoE+ڇGB獺|	(l=)hcʻ|Rr
cř8ޒK,?Uu3KnjV[&ջl IҀԠѻH໚S`|{T=+zT5C}20SztgN
>?o˻"KGScs庞y99Xe:<;;t;n;;>;1;=;͚;U/;ڿ;К;/K;L;XE;;;HT3;}:F#9%Wh9Zdݺ;e-8nL	ĺ+}Z>̻{+廄ԻumD1dz朊T8fiP&\e+Z}_
#[k;.S<@<&|Q;s:Qƻ2.9^;5r:1{ŻSϻ'	;;/%:,Y˻0*m|;K;1@;8:ҟa!A#
˽	мq_Ѽ;s><w<=="i=0nu=4T=/=%=)U=2=]=5@	IM󒻭oa/;r&₼\Rtz u';;<p<<ޯ==1Q<ń<<<1 << <*j<
s;0jcϬ~׻(߻I
2M;<]:<4&<<¹<P<\Ӡ;+̜AmXr3Z*㻜B:-;<Y<"<)<@0F<{l:x9εyݡ:"}-;;T<<'GP\ڻ筮D&9);p+j*oJ_)_)rEɼtP+;'gZ2UANF5w ;7);d=<=؏<	 <>r<	anE\*}K`K@{Ȼ.w2m~xºAB#Լz<뼗6{(M"+樼D#σ(X㺭;iwLF:[M>%<&<+bRd5T
S9;,Y%=M;<}<
r{<%BS<<"}<=<@8<;P KqM;u<W(ŝûs!CHkapUudٻxQWOϼͼ>;Kɻ(야λ滸b|J	fr
o:ls;f;;љ;ø ;(;;;I;;;
;#;by;k;;Ȃ;T;S^;;);;>;K,;<;6;F;bj;d;%n;:;;;|l;^>;J;FA;RA;c;jf;[g;8;s::7zr$6sTq8Sq)!׻@"V)ceaJWN˻F»0?JV=cz컋G!20ܻ{һ~-S
GϼԻ;Ȼh})#k
*#Ⱥk~:p;-!;B;;ˆ;ҋ;3;5;dk;;;;;[;;;;;;U;hc;;<;;^:;K;8	K;Z<|'F$޻T:eKջ.N/Vͻ8ɺw|׻U/d	kSF_ƻ3a5!*:;SM;+;~";y;;1;
;H;߬;;A;G;x;x";sԢ;~;}_;;;;;5;;ɷ;;Շ;d;;;(O;..;H@;h;C;\;Xb;#;;p;^;P!;I;D;?[;6;)%;;e:ƪ!:~%_:9G]::9Yx_x{U5G\Lûq5~~?}T]r/dZһPBu/C~%9Fw@t<񹻠v߄ƺ6&_6:
ܻTؼnCjFâvǻ6Qǻ-.TR޸	:C;];=O;@;ǎD;bV;;&;e;;x,;;;;~8;i.;c;u5;mA;=;;_><c<t;B;\;;*;;^;3S;.-;d;3
~;PR:;j;|C;9;XQ;i;};pP;b;VC|;Kt;>;.;;:::G:~:k?:vj9:=:;:ķC`˺殮#
Y@
߻P5ֻ_s|q~_&}OoO
]P\PH.o?K1l"1-;VB;h ;tB;;{;);H;s;f;Yh;J#;5l;[;T:%:::.:a :>::$
:9g:PXkN,JU>\˻i஻wRy&koUCs93w+U_Hh4i[ot	d{57B޻Ļ߽X̿$:*Y'(
1Hٞ},կsF>|]iS@й_1:R:=;WD;8;7;;s;Ph;;4;;G;;J;o;";H;";r[;s; ;T;h< <<<g;;;S;;#;:!T;
;;6!/;M;\~;i_m;w5;;;;B;t{g;g;[K;H7;,ӛ;
:|9:ɹ::::i
:&:":(: 	9=32%ƪl7'RWU\.oiѻpYg0߻Q׻:"+4;#'9m/ϻGjd^7r^q,n
&@NWRVwt})qy#jA&H/̼0m*ۼ!L6ѼB'mS/jA6*պ\H̹9:N;b;P;~;;;GK;>;|;b;zd;;";;׫;K;;;;;d|;E};̩v;7<<pS<<;h;;;[;:ן:ע:};ˁ;4n;LM;[`9;g;t;,;D;;G;t;s; ;i#I;]g;H`;);K:O:kR:A:P:i:4X:CS:K:
9]9\I$lF
r>K2WlW{ZMXLYXDodyb}Ow6c!ka
q>Ξ4Xzֻr$EE)jb5Ӊ$33.2i1
+m$]}4
u	¼eLeYŮYy^Mau9B:R::;($;Oz;i;sW;qB0;o;|;;b;f;;ǂ;J;Ϩ;rf;;;;-;i;;n@;<*<E<<
R;H;X;q";~;14:^:ӎ:g|:폱;u;6:;O;_;k~;xD;J;v;Z;;5;~ Y;s@;m;do;P;/o;
:7:::Ä:q::n$:*:49A81
=V8SERػ>)FлV4\͚Q&8o$׺ٶϛjlI*I%HgŻdznTZ'd_ijmջnAj7i<q`X88nĻ!_4{OKz%*oq
]A'>7Eѩk@onOD	((xD}Qĺ[ۚ9q:ɬ;Bc;8;;];" ;C5;0;B;u;Ї_;;$;;;];y};Dc;:9h}SAϺ/ŹRvRDZtݧ iIs'9ػK+Fiޅԧߚ0h5O~`df7k*t{軕QV׭ûYSζVz_0*vS(껮A׻2jٻm̼@*~qF6ܻaKջf7軪,rE볻.kL4_@Z#1RA59;8n;iK;;;o;ԣ;-;,;O;v;ϧ;
;5;;{;g;e_;8;j: 9Hlź2VXպN	g	U8 ̻M:<ٻaWc'=\ݻ~՛H»]l_纭}M0z߻$+C[[h?lwȻL@̕˯ִaj.9G޻}PQ'컃ZE.x{κծܰ2w*!]W;#W]{)iĻNỿ{黺ͻ8zs?9VzIV:E;";L;E);q;3;#8;O;f;z;4;̉;ʦF;;>x;O;p;KHp;&::t8@̺*0Iڹ"Fκh&%,OHts<\}Ժ}꺡-J#wf^x컌]9*f(ʢs d"xK/4лU1i1:+;<P;S;C;;6b;X;;ӄ;;È;y;ƞr;3;|!;>Q;U4;/\);J:M:^N`ZcSg%
!̺\}?
5]BgfipZ^ė'M~?g 59,l1⹺꠻r3*NG@^/Dg̻t6	RNO*:80˻\˻W.ٻJﻜ< ໍbHj[Dښv5xw_`yW;"VJaDtϜ
̻ۘșJxA)
O׻D:)X{y:L;D;y;;;,;&;U;h;q;;;;
;;p;9;?:I:0:Eo3
}vo0Z/#mκBz }
=#c6бVݻN컉0F
!+к>2=($B($ջ;5Pl;^j|YûϻMG!񻪖'Ի{ϻໟdB85Ma뻃As[<n;
P'tI#f;U;;SK;R;;T{;:쫷::.:#عQJ=愻_sm9dGy'ûj3:=܋`23y뻕kY}/pA ~Auʺ
bBvXNŻ.E	?UkduEfmT/PLһ%a:50<\Px>Sɻⱻo߻[C|H(+yϺ'9ٗ%kٻ!Tk
}YXSHuJYBӻ-Ml!'%;OXrxAi/_!!,B#t0v'OϺɞ##*W?šP,ػ`Ksû)RD߻x
/zϻH5qtCjwcPQF⻛sn⠻XA'Ѻ߹BExq)WwܢU/-{d+Bq ՗Vy໠LNʎ}2bD̼!o*nF,3&p-Ǽ45w#DX𔘺^q8:;4;V6;;E;;Y;;Z;*a;u;;;r;>ћ;U:T:Qߨ:9ҋ86-">43Ve"ngmλl𻥹*Exq^8M(lDq#
H:ęO<`*t.'*}DRXs!Nߓ;I47|ú첺t[P0>A
O#Ի]_pໃYNj놻'rcZ`,Kd)ٻ{
nwlfgwTv2Ft[쳻EPܻ,q6Gq1n,߹ឹ*Һ	glA29ӻLcz߻-v̻̄һ=43
\޼+ʼ5Y84t*6ż'ռX9
E]dιV|:w:;O;Χ;;;B;;;X;#;};oc;>
;L:]:1O9*cGIe0>8
Lx71z<j=6{@今mb7&1+@ꍻHɓOl(^Utn=l?PQλ.5=\3ۺlcPUG-Iٻm%9(0P:߄FP&\k+ڻzL8_LSmfo仉Q:lѻZYCeMv󯻂ۻ6*z4eEO|9և r\޺rQ<<:=5==
;.0<2U=6=+:==ԉ<Ζ<,<|;;H;A;dI!:pi6[K~ox\JưPY+d;;::r;A=<)=5=!==p<4< <<<~#y;4D:Q: ;T!;;;
;>y_9t%mk59;<{)*õ
)bߞɻs(b:l):Ug;;b;[;_;Ze;Z7;]e;]\<;X
u;T@;a;-;6;صg;u;p;o;l5;G&;;s;;+;;8;;;$;-<&;;t;];;8;cV;L:Gn:24:;z;&fI;E;^;nB;{B;L7;;I;;;1;k;b;
;{;Om;fi;7;	>:Dž:*:l::::e\/:9Xĸxl'
xa&$9X6ֻ*7i&h38GQ`G!/F㷻(OٺӞxϺʺ'.ϻB
f
?JN]`élz!M]#%E(ݹ+
,~*[ݼ$ys`ȼ,CTf
?_:ROD9a:-;_b;Rj;Ҟ;C;j@;bz;a;\;Wj;]WV;;?;;굱;j;];g;&;B;;Y;;n;0;o5;2A;I	;Z;Yj;;;Q;;|;k62;.
y;a&::媘:|;P	;#Ac;>;Wa;id<;vc;K;n;M;eI;&;D;;J?;.;;);;h[;0Lu: O:Δ:8:U;Ť:幦::D9ƀ8T4E\v ;ݻT4SH|$J#$8%אE5nĀl'pC2'd+nB~컧sѧLx޼y\*  tV Iʼ!v$F(_+j*d%r'=ȼI8ϻ)<:+R:X;^;P;ĕ;;r;kH;fj;es;a;b;z;kJ;u;\;};̞~;;v5r;f;}s;v4;;;i;;Em;;ס;L;;	@;N;;jz;eU;6;::ҋ;;;#;8u;N);`;m@;wE;`;h;Ƣ;~;x$;*i; ;;G;;;;[;?::P:^:;3:(~::'v\9z7kiЋQyf'[)5|5WD,N<%{
fт	(GֺۧٺSs6$$2	Zbn?лEx(jR 6"r!}\ݼU5%iH*W	+%/ozr
E~x:	b[NU(9+;/X;{F;; ;4=;z;m;n;n;o>;~(;.;;;X;.8;";J;c;e4;|;;;s;;f;4;;;;;7;OK;Y;y;R5;.F";X;z%::p;
D; ;2;Cɼ;SZ,;_k;h;oJ;yb;N;;;;;o;;R;,;b?;;DӇ;v::E:;:8U:g:~:y9=<ѺsrѺNᴺ{2$O~28ݻ(iɻUäKl\,	ֺrj7T6^gOXג-aE[Pz
@$d#%Aм!A-Qn"y)*k"P

[X
Kټ=ߝٻ\v:;{\B;+;Z;n;u+;x5;x~>;|l;~;F;o;;ݘm;[;;;9;;k
;q;{ޛ;y'd;m);m!b;;;;?;^;q;_;;[q;6@;';>:Y:D:;q5;&;5;B;N\#;W#U;\f;b;pS;X7;;o;;ֱ;9;;c;DX;;mkU;+1:I0:ٖ:%:暥:g:3:1:gN:x>9w	@SZ|o';ٚ1b(%Ϥ0S~2D׻#Vຫr5~v"
z)>Zaٻ{''k!Xm!z'a&ˢ# (d'~ѼqҼY
}zqdn1d;b;׼;7;#f;f;u;;u;{;Z;˟;R;p;]<;F1;b3;;;(};|;q;_];U;e;N;;;;z;8;t5;B;un::٩::X:_::&;;!HR;,;7,>;A;IA;Np;W;i;~;4;';;J;>;;;;|;VC;F:Љ$::ʷ::F::":M9$94+dεǺ
n!(/@-ߺΨֻ
<j
WlĻ
Ip
ޟPúJ=wfU|㻎;φԻa
tKü&ռ*.%'
5Ѽvi%tb _ORvK`U
~1?:
;O;;;;; J;l/;G;V<;T;;Z?;5;ķ;q;ֻ;ķ;;;q;z[G;];;GY;Gs;f|@;g.;;;K ;;g;/;H:P::h::5:De:!;f;hf;;&4;2;<;EL;PX;a;t1d;

;N;3v;^;d;.;U;;;D;
:":ş:Ԧ&:/:݈:<:Z:!f98LgٹY'bV[(V%t&Ի{1|Yʛb堒s]Pw.=ǹU$YFۻ!esӼg!j׼2N?ļD=Aeo9a0)$ƶ8hӯp^hq^ޓv]5:î;Hgn;;6;;;Jn;Dd;NN;;&;mn;>2;::Np\Hr(/?1Hln^˻2ۻ?Ɔɻ6p续Ws~]KH.AAλJ"NjHC߻L\|aBPNk3к=㺲h0[#-2;\@J@CH}PriYȻfp%ybKBi?jF;-J[hP][bn8TmG$Jn=VYcm.лp k)_/P_>''X𺽐#Y8IӇѹcQ/yYKd̻S
ŻG:ԉX[

	/(@μKNIüAC8+RʻTX/պ\Ⱥԁ
P:;Hc;İ;;,U;6;X>;}J;v);\/;-1:T:s;9Mz!N)E/M^2M$}һӄͻտn$aNJ\ݻgBfUg5YλE;c=aG!VZR%:Dp|ܻ ͻ9X,H0M[K‘GmEvIR}^EmxZ㻏ջrBHg-ê,¾B@B_޻p.id(P92ͻ8^ڻB˻KXQJU?U[RJ8'Y:e۶ 8})l
[p
Ӻ̡»	+=Bz`m@0~M'A[ϼ&;ZLUGSL;|U;~;r;`;^o;_;N:A;$Q:-m::n:Nd@")U=mt2a;}_aC7ܻɕлû2bi/+v_-a6»(<(:9>'#Z)(W9+Yֻ;HⶻLt+A6(%ۿ	񪒸nźY1-ӻ:y5%黻5İ:0	˼@D"μ8
L2UQZFv?<ͼ6oM$&˻a~'ErC}aAV:;a:;	#:C:׻;;;
::aG|a`]̻ԓstexL_3A.׻ٕͻ`|˻f{L15\@^1e/8GݻEֻ25y6\+(BNn2IAgE<7̻)~Hq	g~.BPAOUYUTS<E#;$+p}X$dN|}%@0互)޺#T뗻IpN
+m7VE˼P'$I)>MLd@(411{3M0ռiD/޻wܻ;̻G0{WtS]D
9^:~8:l,:P&:::ΰ:9eʺg`5.nfdvL}+7r1ӻdO>LDf`j0tػϓλ"|3aǻC3/!%A'&b)$F/i0'&p׻6Uͺ~/l.
R#v3U:F6O(ӼѺ,}u39Kw`+eź蹣cb""vS^	ה)ajLKSj`Co)
(@eKlŽΞfhһ	;hc60~@μE<:#)rM ќ$Y;,ͼ,H6T%tfvj;R5ƺ%帘Z0?9:H^:"1ҺQA{%QZSLv9Uûzs
쮼$|UqWT#Aɩƻ0WDߖۘhӻZ
9:&'2
/r0غ;N1λR!}ƺ Рoc	嫻{sʻ2yc
>fo+ﺚ!q՗ͳ`kۺ@ҺԖñ*}A*PDw?պȩ|Wպ^o]w;)Bd3/B`.ɻ(cČ$	hʼi(&:4EN;33 μr),co-2vλ>Ls~Uۺv_?ӺٹE	(3o#M,J^bDzv=6#ܼewܾ;
ʫIVQk)v@t͏v̜D0{̺i׻3dӺiH;<1Cjl(1;;;ޖ<`+;9g-ϻF)_<[IU;-<V<3X:;<8=>(=T<<<";;R;bE8;':8u<
;z<"%<<{=;=z<<<
	; ;;m;r;C;Gͦ:e:x:;'y~;;o&;}';ҷ;P;;fF;z;6;v;;;
R:h:ѲK:Z/:}h:::A99)7D4̸f#?(YGbf g._ƺf薺Q@ۺduʗκSv庣Ϻd&}9
&λaP8^Ƈ%J>+ z&ZAɼ~#qХKG
4	-qe^&Իwk^G]D;;n;;M';;|;);q;\;Z;ͩ;ѥ;;;Y;4;Ȍ;n;q;:;Q;T;4)};+{;;C;\;}l";;x*;Om;x:Q:~:70::^v:b9:48:V::E:1:;;+N;;\1;A;Dŵ;IG*;T|;dٔ;y;;;;m;;;pB;<`
;:[::֎:h:o:UA9W[9YUฝiez/@*ԹXc9:yn+e;i[Tp ;O׺}jEĺr кd(ݼ5J7[r\
ڻBM{f"j^(:CMغx:$;I;V+;c;jw;;a;;]M;;;;P;w;R;;2;;N;;-;h;>f;%q;!A;/V#;Gu;Y,;VY;<{;:/:|:9T9VR9`91997::Qm:|::d:;/;5;@;?;<:;>ޓ;M?;dA;;;;m;#;/;J;q;C;
::̍: ::bb99fLB>VC=&!K񵆸\oRTAAlSO]I9م[F/EspYq!XǗճ8fh[m7'u9,96Z99ڜyiȺtCLCpC5(畊!ļIॼ޼"`HmH,K3*a΍Wİhػ)~D d.ʼؼ$+9*޼I6Yû^%ͼ n00a!_c-s滖r໕R}u2/Aw1߻Jz#5lR
d3x#!H81iiW://ziG9N=}>rcoS]l; h#$9Ժ+8D97x:,:49].NLqຣpT-㲺:LA X"CaOSLs!G񣻭~λvͼPo%o'C`G:Q(hx5),g_;,Vo(BɻXxػV9efjDd!ڗ:@GɻPcN:6|齼9
!Լ=n\ɻyλg[胑duؘ]<>+J#VNV κކjsZoڠǺ#?~GT>W/Euݹ߸RƹҺ*:YW
XC5ӵ)b999&(ֺTK'udҺ⺎
;h%/;%-wzfŹūW::X:М:O̸7kH^B^
ۺPCкφEOtmH'Zٻ蕻N|n6)aȼ#OXֻ
a!ü/5#jVA'$PV׻rݻsUE)<޾k~6n?I$M/ QD۫T)`eTd>	,$aތӻy*'
 藻k߶+OcWohK(GO2|>`ТԹfB	A0
cEaϺk-ɺ3΋A90乞8e99Aʹs*к^@9::1 :8LHW5tܺ?f["͎Qq5}$c9:x:WS:H:6zD\5ԣ	q1e꣺htzI1?y4IֲOm@+DѰ/߼hm;r 
JBw
掆
ټ#μ3}/4		x lolh
LƻKOj5-nk Xi(Vno/J?c⻀ûW黧@!.K|ݼaټ#f _t9ĻkT?'hKuĭmTXO[ߕ64ֶu`4G˺pa\$8,9,:9R{8M+8#9\z::o>:
:kU:8⹷-d}ra^Q̊m։67M8-888]89I9:h:>:n1:ga9vZYغ-ѓF)gݺӂڻ86za *\ۻ@/g<
		]xNWm{gOcیj_)01$-!黤!ʻt仅pN~ʻr/shmqֻꎻ;dw0}ɛp1ۻWdx}#Ȼ!al0D\	4CR|⭈1·X/xͻ߻׶er|8'亱)Bĸ8518@7Z/kùsK96 <8q:S:g͡:c}:9T9+9>9A:i::%E:p::%9{߸ξ̱Ѻ&{:y37b9(-99k39?~98E9(29
>E9:;	:l:U:H:kd񺤠Ǻ]0T7]w|mBPA᣻w޻"Q<ٻzڼ.YnS夼zܻ뾢a+9`*:\s <?mf{4z'2 ;so3vVTFF93	!Ѽ
z].ػ8	ȼ߼piSʻɈ=
ںX˹'j6
^8876;["DڹEtr8:%V:	::F:>9$9P:+(:u:?:4W:::l:a{:89Kr`ӹtFC=9|999y,9ahJ99t9@9)si9:}g:B::M9*%Rr&Ⱥ 8'&96D;ߠ̻O#黤Ի3{컸]*Ѽؼ叼
Bм4$Tѻ%3Wܼf(!}׼
Oe
LTT/w̻Q@_?cb3A`~MRx@v߻Gлʻ	y}UuGr@PgIxM6Xp׻T Jqw[$mٹ=78f85,ʶ EhF5Mɹa3Է#f9H:w::A:б:Q[[:G:I,:O+:;;:j:q7:Oz:m:P:$9z5,^89#:-:+9_990j5889G&:$::::>]﹏Ѻ'Yb87K99(Ժ}W>"fhƻ-Ed@!
ep=2<#:$DFƻ0{/;~;N< <<<4={%=l==O=,=<<D<V<<O>=0(="=="%=H=\@='=@=-=u=P=1=<19J:v:;zj5<Xo=,=%4==<<<0ݺ;D;;7r<?;;g;6x;;<_'<
<==#[=#$=Ǖ=R=,j=_O='="=P=e-==m"=C:=V<<<=Y=/8=X==u=Zg=N=s=)F=m=e%=cF=V=8m=[J<^1;,1:#7:%:is:/:w:>g:x99	9PH91q8&8M7067^7=7|8b[99՝::J;(7;J
;^};ku=;w

;A;&;;;;;|#;ͽ;p;v;[;";9::0|:Z:v:zN:-9 M\v@|9i:]G::;;(;(;	:À:X:h;*;O;^4b;T;-:ǫ8UʺW􀖻7"Pջbƻw-wK维aλő=Cܻһ(웘>߻՜f3H{e;6G剺;!#&*4^To*]9~9nU:kX\:6x;3;fd;;ʛ;ޠ;wm;;D;c;P{v;+3j;ad;b;$;,q;+;z;:iS:lu:G::[:E:9B9p9u9i88227u6WDS6]7478|;9X::I;];4;R;i&m;z.;Z;;N;4;;W;G;v;r;tG;x;q;\j;:b::gU:x:e:Nz9?K
E)8:/Q:};;B;1;9z;%Sw:%:#O:Z;;=p;];kXF;b/;5":#6S꒻w*%E}_T_4rppc׻y»j"8:Eܝ@Δ!fJ12G
n%o躊ysdAvO:]ع!R&"9xO:!:;	;D;j;r;e;;`;;9;b;2.;;;Q;%$;+;$;::x:::z::^A:9 9t>99;G9?8(<76Ć6
T5,+6_067u8|9:V:ʶ#;I;:;XQ;r<;*;;
;;.;
;C9;fؗ;T	;e|;on;;sۂ;2::5::?:uD:4k9iY'9:e:%;J;2u;? ;5$;Cu:u:q:#@;nY;B̭;a9;r};jx@;4:ɹ$>*1ƲFO$Y8r#лo廲pbzNݽQb)Q˒ﻮ໋"X0󎗺!Ob$@b(
8c9ʓQ:S:ȧy;;La;h;z;aW;;b;T;~϶;E;K\;V;E;l;&;(3;:k::::֧:ym:1+9#19ɥ9ܑ9ɝ29Ŷ8mN8ܱ7L5?5t|6D789!e9ˢ::8;W#;;;;Z;uA;;uP;oC;};t;;Y ;=;@h?;`z;~9;x\:;H;::1:#o::O9=8Z1inoӞS9<:Ir:ī|;;)4;:>g;:>;:c:f+::ރ2;$;=;_r;u;j;(:2膻,(<1DUt뻊!vĻ"	[q
/ŰTݻ
FLUPը}\#㹌bNйjҚFNU7(9ލ:To:H:k;);L*;h;\;;;7;;^;. y;ж;;;CS;$;MF;R:Rq::C]:::N:f97%999U9$8a7aΔ60K5DJ4A56[}7YD89vvC:!::r;;7*;V4;o;jP;4;+;7;s.;K;+&;";75;Y;h;Pr;]:U::d:]:Q9M9'幡輹T5	I9t:
:	;;*;4a;$W:[::iI:
:i;
;4
);[Rd;s;_Sp;:E>ʼnz»G׻+N:T\ԻtӇcể69~Lv`d/
Q򾻸qC\#VvU>8ƻ8B8E#H0~m;b9I9:N.:;z;+;K{;i?;"1;1;;$;ul`;@I;eX;:;
3d;,;;ܕ:Ы:.:[:]:r]:[:49|9993v96E87664C4@V5x67H+8`i9(:=<:D;:;
W;,;I;^;lt;t;pC;\4;;);X
;	;]K;0_;I;E;#+_:_:+F:yS:_mb:99T9N^?9-jOUpѤ9(::ǜ;5;+;G/;W;c{;qea;p
#;S;&::4+:E):q:']:p:&:<:;?:z:~:+w$:$9a/9f9039x9n88 766>6pc3VG2;4]5ܵ7E88b9639z:6K:{::ݢ;w;nY;$;&#;ϯ;=:j:ş:::;
B;	:b:Ӧ:Ps:N99B9596D8DŪڹ9%HGF,(889oS:@em:":K.::t:):Xs%999y:8):}:qD;ɪ;5Xl;:/;::p9HVFٺߺ@X	μsb3/'}+Bݼ Lۼ
{cNռӼߜh#)@L/xU/5S.a30'eպ𸺀Ժ)kؒZ)p-ӻ3jDN=ငаɼ˼̎=F؉ɻ½~Լ
uUֻ9߻oݻOgJ
.9x/Թ̹帳78 =#76߶yǷQU[j︹9a9T:A:
::ٯ:':a:b:7;;'I;-;V;8;[:N:SG:Ԇ:,:ywI:I9R:T:U+4:a_:1P9җ09IZC8ٳ8 8Wk9w:%47:::v9Ruyν"yC8:,v:zs{;S8W*mܚXbpL<
		˼:$32D2/#,ؼvEB6YZMqpV-zHû
h%Ż/,LRlWQӺG޻E;
AbldֳgIJLf=/3#ӻѻQ#S:1GZ>\b"57$7^4Ω9G;
\>9Y~89:E9:];@::N::2;?;2C;D\;3;	;;%);:+:ֻ::b͛:Q#:z
::f:9Ƃ8(7c!/8X9:):t:o;:~^.aJ8ʕ:9a[:i>9Ȅ2K]Nz>ɻ>(bjz0􏻺ϻ'B,	|81':9l8G򹦊S8 t:&}::ON+9v1\F0k໥5^̻

;+~=C7"d8(FIVCt	(Nq}_x˻<{pI%>dU󱺇4.z9:¸<ݻ
@Ԩge3
=+GOX߻_@Pm
B˼
qQ3r5	M4(LE}xP;8R9Ϳ:}:ꆄ;I;:+:V:G;(vo;Ul;Z;:#;Yi;	ܼ;;;];O:޼::@:V::u :w9|z8|7E3#899{s:99vNX8:0:r^:|d9LŻPѻyn$ﻣ黻t9.O"Ѽ7E]Dk4`:
gdlz9
|ɼ
Ż»LQUs(EQ)ºnzl~z˻sG׻II.ɵ|ި❲ۯX{|҇#F|ﻹ);g'2sK*aw~׹¹PJηЛų$\>u
]] L[9:8::;P:M:`:g;;I-;`.);H;;j;7;T;_;;>:R:[e:+F::::"9998Zt6^P7͞999959ފ9H909r*:B:q0::Ŀ8`hjػN}Fܪi"uBYp6
d+>G7^@.ۼ˼
Ҷλ~P30m	_@ۄֻ|s»eHTBûLDߕƘ6ʻx^-ȓй ջ;W7^Gfקe=̻ݺW{Tgt-ukeʩV0c븚[Mgj۴t	߄XloX$yխ9n:C:8N:;˙::+;"7;2;V;O;%A::Ӗ;w;;
(;;:L:N:::^9%&9U88A7!b8L9*F9b:X999N909U::D:>9ʘ!4PBt>f׻n`@wủ`eܯ$rT/b?aC4A8ɼ',䊼?_V˻X{k˻Pλwz#ʺ칺{8+#wSD g㻻5ܻ4i{M滽4\t/Ż?Єiػ@[+eN`'	򹣧*h˾Y*>ˁEꄵn$^ 0$K:$'ܼK< P8!Z;9:^8::C:::;;=e;I;*::::&:::N::7d:l:j^:w$:B9-8!828+7?7u	^8kM8W9(<9p~9@99hm93:
*R:98fZO")A/(W1g-Vm<|=h[H`IW	ϼ/@@;ü:u@.ڤ/Eɨݒ'Թizջ\3jûdu-[PQ]!m
hȺkS~Ǻ;Dv3$BXMֻ$5֝'"]	xͻ&޻˻XLxrTEn쩭':oK<5-R	xpo 69|\oDDY >ݶyhxE*f89ү:f:u:Ҷ:+:hH:\;};3;':D:>:(:H::H^:J:˞:?::܏:|:,99%}8[8w28yC7T78M!R8O9
V9n$9,o9Yr9Z9F99n9m]]#
x헻}#8$;$YSd;`w\mf=r=b=rՔ=T"==w=>s=nM=ܙ=S=y"=w{Y=p=U=,=<ނ=U=[*=I={p=hI3=C=_w<<=҄=~;0;!it;At;tX;<%;v;;SX;I;x{%;;W;:o:<9.:.::
r;@;+;;};_)$;/:y::}4M:R;;(;YI<,<Ҧ=.=@>=j>==:=_=}=m=g=_MJ=K=-,r=.<*<<<<';/;[uS;;;ǵ;a;];7;p[;];6P;1;:9織Z8OX:q':1;6;;,;;@:j:Y9+H8\B8*8)79M74M6Jb5
4D*d5I6Gs7"m8pt9ޕ9δ:s:[;,;o;;ƭ;(;߾;6;L$:!:(;Z;C:;Kw;-::w;~H;z;;}8\;:;;S;*_;(j;	:Q :jyS:-j::e77-9646eg6Mh5wٵIGf5}6x67i8EI8,85989y:a:Nf::
;.;.#;4Sl;_X:T:o:I:t4::@:g9k:)D^:Z;:A:O:Cn:D:4$:2:;
U;';&;
ܪ:|::=:{j:ev:V:;
[;I;	;
:{q:qN:4:҆;=;<LP(gfT7U8S8T9 9`599۝9Ő:	H:5:ju:X&:X:B;*T:::۟:dE:Y5:S:+9޹9:::
:a:991:&&:	;$bD;x&;ݹ;l;g7v;BR;!Y:X)::~:k2;;64;l&;x{;J|;c::p4:H;:2;<0;#G;<;9u_9Gf9L91y8,U4@u۸^769-9&,:,E\:|Q::M::e999+9ְ9::hP:܏;N; ;#;
::G:
9﹫
]*N
ӻJ6ɺ]佻%f5@aݻ9/ݻ\
t]7
D:'!9G9g88b8uKHM:Rp;.$8vH969::TIE::{2:`N99t&9'*9Ea9(9_:F,::{;;;
,:m:n9ɐ8p6̺lϺdҺ>a"0
Ѣ㯺g:b=7ź1,7JLbx^ܯ/%):<[:5d:- :7R:`::A
9qkn)<9%99mB9S:+/:ղ:6::":lg2:w
:}:Wt:
939+9o9999Q
988T8h8Ơ887b776H6T69}j5]r3'DP8BCgj
Dʳa6mD7)888@9*z9}}c989M<9,99¯O99ҷ9U9-K9N99Vw9r99+87lxȶ4Sl67R81808AO8fJ8c895#99XG9989E9|69_>9'387X99:B:n:L;;;a:{:8J9
*5hب˹rۣrz"ez(
F
R9dA:k21:
::*::t9Y8)yG6i/68W
9 S9S9}96:&:nZ::\:(
t:I:$8:F9C9~97a[9
=9	9.Z9*R98^8\-K88A[U8e^8F

7W7X-66u6A|5bo4\/  TȶN2+dI5~޶B3ˠ6˵7%8683c80P9'9W9qs9q9n89k9?9U9;V9J9x9^99w7k9Fz9~Z8ט7!6;z5[|7w7O8Jʷ8q]8wb8988:88h9o9\9ٕ99TK99М9"9X9Jc9[9M:j:w
:b;;:ݑ:nH9*H84a
R'{(0'ܹ)'p=๋ZWEٺ(˫
b&7::n::Y::X:9H %
i885I99Q9r:+:5CJbh2i҆fYmNVeE@V(L*!:Vl@/-7@"8"Il888979M9]m9
98
)9	999IM9`9/-9:98H8r99F919Ƴ:
:1H:'	i99=99+Y:9*:::5;s;:_X:[9Tc8T^Sae78w7qMIW~Ԕ/~yغ@i6!nR9q: :TM:{J::sh:-98(juQ37~888а99T99:#9D9g9c~9kw9i?9:&88n8^w8(888az8 %777z7z7q7{665a5P4':q򒶙ͷJXʷǀmSq1Iu7#8^88P8!8[888T88Q92S9,9(
9.8ג8Դ8'ZU7?7U78e8tm9@j9i9(9?91G9g9PM9#9l9'8z9O9:A:):r:qa:LJ98a8MY8x7#7U7@m7ߎ89)9)/9$9U9
98Κp8ʸ^oT:8ܺAРB5Ѻ贺$#ٴStMMf`⻕컯ͦEՏ#L)|ƻ_!'^GkJbA)ƺغqкeKۗ썺OBPj?ﺖLmɻ;nXQs:%λ̻Eсi
;`QJM·u
ºk	:ȺсN	IXI^Bgypr445	-5Q5-{3ٶ 6U8se93Yu99t::o:1ҡ:j:p:L:7:999N999Ɋ9W{9[9N99XB8p8I888_8s8087988U8E8Ӡ898㭑888"7i⡹0v1ֺxmt{J3S/%Ի!1i޺4=JӺژL;UC6"ͺyH*/p$⮺
s9+:E&&L5t~yϺU]"aݸGm
	dN/c)Ե5D3'4D5	5566?`6LV5/еH7Er7899%99_9:k9:=V:I:!s9ژ99S 9	9]=9@^9^49U9X929a9+88,8u8S99?i9c]8v88\w88(6*8{_8@88K88p9'9t?;99ob99}978a8u8T8>8ţ_99]9e9u9%87RBfCFQ[5$p;DS;S̈́F)ŻPUsu㻂\sxϻUu.[<ۙb;&6*	Xᐺa_h͹65v|R*$[	Vi>κ'IRκ{L[F($x6_V\׹tQ`G+jٸuÚ¸D/#R]h7ND5^"6v67g6N6No7Z7)77]7̻7ï7a7978p8YT88Q999_9|[9::99p9Dݵ9(9!9	!88m8j888e8_8v89Uk99<9ﰃ9>9z9\ue9%8x8x8`9B9:9ڼ99:"9a88*8`YxP84k7к%Źx(=,Flc	͞%޻>H"AM01ʻD=^߻!6t亟'J;bˍw0,K0 F$LL򐹾Ru3_YҺϺ@Ǻ
da*>Gw
,3ɹ#d]m!DJq#<]N56V]667	{l7
7u77P8=g8Ns8g8uk88i888ή89C9_u9n;:Na:+U:#79_9?9%9 :u9169/98 8l88xV8c88b89mɡ9,:8:S&5:A50:_9E9O9W99!9#9:#:DG:4E:V9l959,[8&7KW~$T||b=B'd<%k<?>;T; ;M:S9[xA:7A;v}<m<.9+<b<<	<;5e;7qO:u9Ȭ9(89):|:t;ӑ<6g<<{9b$9We9+u8[88n8Gm8)b8L8^9i9f:@l:
 $:4999l9T9E9R:^:k::߸:Q]:u:	:6999U:	m:p":̄;:/8:w6959.H88,99>9ʲn994:999!
8_Ź?YRl8999:
:	Z,9˺h9H8t
6M7+&7b88Xj99k99m9'8L8Mf8)-9{9Ķ9	,9E9%1g988H8D*88y8?Q87nj7z7v?6Oo64A¶+|iq2ZjttWBB4(	F(Y&&6^[8Vp8~?8XF7ce8 W8֔888<99a29^99/9q96#9=8\8s8M8y9Al9g\:6:S:R7w:D#:.:
R9799F:-:B.:I
;/;!8B;
,:f:OV:[95:
j:9:::hh:E:19}r#8O8l99 r:6:v959j9k$a99I9:18c8,e}l8ٰx9^!99999pz8,<6L6ʷŶFT6ْ7G7m889N9_h9zج9[9%"e9N99)Z9GpO9[e9s9y9q9_9!l9a88b8=88T8c877ma7F-6T]
D+V|?}bWո
 ҹ1йHF湃i8l%88%9]9e8q78u868م8e9&99w:S:
X9?9}e99a<%9<<9 N 9&.^9}:	H:b>:l@:]P:\:Q:q1:<:77:u:6x::>W;3@;YXG;TL);#To::nHt:5:7:@:e:-:J::a9N8N8s8#9Ml:
/:l9a!9%9f9R99܊(9š99`K9P9Sc9:9
8	j8d8Z8+7ɠ7,Tڸf|lIaDӹMعP䈹bs8c幐1޴> ú -l7@k9JO9&91=8r7V808ޙ 8֏9Q9::EI:\:B:
$9|9Ζ9?9D99::l::N
::տ^:b:>:W:rd:FM:dS:-I;{;L;;h;|;1:ך:u(:|:xWI:h9:}
:|:w:{99/8o}u8!9JC39Y:IV:`*:,Od9|9=9-9+9A9[H9A9D:9$t¸d%89b9l9%99vk8%86>	4x56(e67iu8{U9`r99ȣ>9m$999=@9
9<::y:':R:g9bo9s99~k99B"98o8v8H:87GyҸΧh^l'G͹EU\Yd[ʺ
U~3f/nfxS99=]999>8a7W8GD8J9ޤ9j:Q:uIG::M:|n:J+:-::
\9/9::T:.];;B;
;^::Ü:v::;=;`g;WS;'!;;ea;5:偔:f~:::w:w}::w#:988BP89w:3:u9:`:999$:e::"f:#9\8Qи~8cX3839;|;99D;99y87,8651 4p5%05¼6:O8
8.99F:E::Qs99B: :?:Yl:m~:mp:M:Ī9-g9909ԫ999U
9K8?588"Ǡ䷑8Bxa!"D+w/BlN^"7vغ4+7g9d*:N9]9X,	f;7 88=9x:::w@::o:Π:Q':vE:gm:MA:3:=:j:ف;ߖ;*y^;0?;+w; ';I7:-:׿<:;(|h;qQ;;Oj;{;;;4::6i:':z:i:]:^:.9s9c8_8:9W:4:`:z:>9/9ĕ9tk::ff:(|S:0:	Dv9x7cv65Ju9N9
9nZ:1P99|87j65N2!4R7W`Z8
9V}9r:0:Rw:I:,-:%#:F-:r:6:_:0:i:nu:4Ѳ:!`:&*:9>99h?9919@Yn88h86.Lxe@1IIKyWznFź,C.~89T:;:1y9Rܹ$g9nV9::?;\;:߇:~:k:::V:<::V;K;@R;Pe;Rq@;KqF;?;,=x;;
;=);;!;);;`	;`;(;2;:H:::P:H>:=Ex:39f8٭8[8z9qy:,²:k:W\C:Jw9̭9$9U:/R:k:/]:$OD9Z9f1V	8x<9w:l:9Y:19=9nuh876&95FǏ`ԙ7Ě
8U9:.:y::z1:[}!:i::@::#:/_:s:,:R26:O:O`:3p:ع9ڄ9f9M9]l9
8DHHYr_>8f*	D
m6je *ݻ5C򴲛:5]:h[:/8ǹuKɹ[V=9:l: ;b;#;!:2j:$:[:4:ߘ:ľ:NJ:	;:;J;h;rP;q;j|f;`u;QY;It;\/;;ɼ;e<	R<;K;p;y;0;:-W::tƈ:F>>:L:899k!8X8g"d:C3q97
0h ޺
N(j]K1:㓹YC^TWٽۧ,	nMl/:3GsB_۹؈Jֹu
Aٴ(	cRq۷܏Dⶒ~lI5f6HB6ڰV7=Hw797!77H8B86x28L888m8(9e9
9*3939,9ji9*J9u"G9l:!Ne:].:p]]:C]9҇9y9A$	9m99c9J!9J8gR8(8o8:V8E9kz:
:vl:0::62:ej:-h9P9f9|T9a::cM:~{::}:'*9969at9T8	9?-w
Wn¹!s\w>GL$TJ{79nZ&{.Q屢y/,캀"Xo(v/	U"U!ؑD}ODߍD(qewl+T(ٸ-]KHM0#2HY﹁vVY@kk>F?:-(Ϲ
ӹL LWΕ5t65$6G67:7>C88/|P8IO;8N88aZ89+w9XD9o9>9899=89*9999:G
E:^:2):M9:_9ۅ9l9`99귊99~k9"xZ8g08ڥ8M849_S:
|~:K:	::s:ʔ:c:og:'Y9]::C5:f:å:{e:y:}:S+:h99?9:V9":8*eƹvbtBI?sQ
ɺWٺ废QyC4\nsѽB3ݹWʹHsN"*븦?θ!RVϦlVjY,(SLLx?QX.ȶ&	tg~wǹadgfYw7	6܂7L7,7X7h8
z8lj88~8ߐ8ڭ9R9C9U M99a9ԫc9K9#:ST:j:{:
y9Q9U:`+:s%G:::~G:%l:jӭ:V9>o:|:4jS:04:919]9>~99B\9A9o	9NG:L;f\;,+O;5;#;G:0::m:Wh::c; ;&w.;);
1:Z)::P:F5:@:
98o*&)`q+K1A1ݯ$ຄ7#eʺo~?]Ú꺸"7UVXMIB4&۸WQd7O=|ﴸ|O3ؔ/۴1pp`b8
й7hҲ3zQmغY)!ƍj8t\77^C7S7֋8S8~9S^9=9Zu9`9?9g9Y:(:.:=e:I':]7:rh:
:yy2:^|%:F>:V;:
:ٽ;;&9;N:Ξ:in::9!:w@:X:mߡ:&9>99D9t9Q9Ǜ:;;KwZ;r;n;P(;,;	:@:g:}:b;'M;U;l;Xڨ;(:h:=:z:{:: Ch9/ͅ!!QlaY~ȸJ&>͹#Z?ZT\'ֻ	ɻ8.쵺b้͹=$$ѴFgbK9Fɦ׸J '?׸,;=M8#)Fߺ^/\dPMONN&69+5V7$8[M8ak+
>|ϲ%غVv]guE޻Ñ-7L))#2:!&XDfCR-cc/j&FE޷
%%pø>[p5bgкz*T!c[V\㺘~p?wqsoQKd]VvܷWB8798p8\8ͱ969>9::1:7wd:w:oX:I-:I:(b:v:0;S; ;;;P;:S:{;t*;D;u+;
Q;a;!_:::q:Vw;:O:3:p::GN:P`:S:@n:\:h;B͆;W;Ħ;Yr;č;;;[z;H`;P;uh7;[;;;|;;T;&9;

;|:٥::
9S|96~98׿8tVwk`\mEjWa<EYɉtCU0HW&Qʹ6D&nPsr∹PȯeͶw7ٶ5]GH(哹)sn:a%fVc?oj~f{}'tWVD^Arm*+f8\8	8r:99k9Z:e:Y::g::ձh:c}:,:;;#;);5;C;R;JC;Iv;>;.Uz;&rK;4;[;;q;;Z;
W:˜:,;; ];C;:_r::S::,::n;#;d;~;&;Գ$;”;LN;D; ;;t;;̉;a=;K;;;h;?!;&;:ګ:G`9%99S9cl8#K79LB@i𒺂杺h<	
-&,=1{}G5H(DJZm=cM*bh%6{5yeo7'65!Q~yƆdPhƢ~[
5='MQB;<݂ͻB:qºJ-naܸ'h8Nl9%~9O9t9u:Bj::E<;;):l:
9::%}:v;o<6Kp=VN=V=P5=P=W=W}=C="=j===p\<l_=f=mY=eѕ=aȵ=XR7=9!=I<<<<˯<{<լ<#<$:ȼ`8E5q)/Ca6뛽tʼZ}?Ƽ,}rm֪=2:O<5<8=(B=G=o7=yޚ=qS=imv=k=od=dͷ=Df= =h1=ΐ==.;0P;W;ͮ=(n=Ff<-<<Ә<!|;;<$=}=>=wn+=Ø==VR==zk=z
=mP=K='?==#
=.y="=<:o<;CM<Fǯ ׻
Uɦ;C;ކ<2p:<:<8:ߋ:l:r:uoX:c~:6%:
:
9x9L>9fr81,Jzm75ºi>:Ժҍ_UG>	բ&ڻCY9"9P:r:T/+9P::J:::lJ:{;;;H:h:::C:6:X":+}:[::29[9=f蛹@"[UNRfظ.-p*Pc#w;\fE9(3:8I:a69ӹ[Y+źd(Oz9:;9;8A;GO;8v;*;2;F;Q/;G^;2;;$y:;)k;G,;p;5;w;;Wa;R;%R;pJ;=;{\;P<o<{<%<
;ʳ;o;TU4;(,;	9:l:&:tQ::8:O9ܺ98"8>89V9@:990GD8189G9m9F!99=9_Z7E&!u@ڷ	9:D@:v	:`:П:'99
38Nٰ7)ʶZivb=>Ÿ8(9:{ :y;:Ȱ":W:D9:Ƙ:lu;;];@;	:c:>::k.:gS:6:E:$n:"G998RĞ.`C|nx9
%q(=SNnm;
_غt!9an:.v9|Fߺ/|#T0t:?w:g;(^;I$;H;:;@G;\;y/;}ݢ;l;U~;Gw;L;iL;g;0;1;e>;;;J;h;;<	(<@y<p<H;A;;;EW6m)WEmsO9xi969)D#T9O:P;i;:;I;AS;C6/;aO;;&;1
;%;t;dH;j;9;3;;NC;*;О;ѤK;s*;%6;<
Qw<<x<<\;ÿ;*;i;7;:)O:1G:5:$::i5::u9!$9|08¹9+m99J9A(8fʁ889#949~87ܸqPć9W0:l::.~:i:us:6&99`Y98<YB}6q1+u}X}71zкݻ0,7J/0qZw8˸:d:1C;!)K;.h;1_;C;rPk;0;b;;[;;Ú;\]; ;F;Q;n;ƶ;<;;z<-E<
l<ͯ<< <TN<P);҆L;C;n;NE;:˾::^:;:نN:929B8~99x99=r8{{7BcJ8v{8L8888'Ž8l9-9M:4:U::
:A5:Xu$:`99*9":9YB8+=
S+=	:h;e;;,2;QX;
;;}V;ʆ;;;9;ݚ;{;;Ǹ;S;B;;)<<S<<L<<ú<\;;;;};;B{;0R:5::֫;;
k;::[$9
9K9v9r9G99K9=9799593)9	$8`8Oc8'6o89s9
:P:5::6:E:R\):E:::h9D9o0ǹ K縮+DPf꩸99Bm9Oe9:
:9ݧ::b:M;t(:s:g:S9o7pP.\8Gs9!l9އ8OI,'anҺ
=՘<
9(u'ȻYo#ovJ*VҺCྻ^TTnֻXN\㪻AiQ8Ǝ:a	S::;;U;/;euF;X;U;	;B;5;ȉ;;<;;Ե;ߐ;iM;b;;N-<8<X<j<;
;H;x;2:[::\;Y;P;q:T:9_Q)Uppfb_7ͭZ)Q!VٺmߺS=|U\ӹ+i-rZºGdd-!_C87-"6]c5,q=|Ӹ
Ee%fʻ%ͻ!Gh&׻5Hջ?y-:bB0Z02*w2;LE]8dZ9R9j9:\:f::\;N;;D;L;C{;M8;mL;e;w;
T;n;;e;I;B";q;ww;Y;Ҫ;;;4;{;/41;L>;)_;K;d1u;dG;G1;d::W|;
;Hv:[:;?~;;;Mv;G;:;";c;<;I;쏼;F<+<\<;㾊;ZT;M;:;Yn;3Q ;::$)U:Kb̺p5Qx(-0f鄰Po6}'ݺ x+j7kF;DyD'PS_faaV,	OTcS.=G!B0fD[9
7pƭz,Ŵ9X;z99:,E:E:pS;T;-;K;T;|d;} x;;;;\;z;;;Q;lf;o;w|;;+;Ŏ;C;ĵx;;[R;0;;:^L;\~;yH1;zW;vZ;MM;"cn;;$;)z;;;!;xC;T;<$<<SR<<8<<	e<S@<O<<1<;j;6;$;};T4;%F:"0:Z:F:=RW:"99l7%z;*`F&nJ0ٺWvɺJk3H޺Bg蔹5/jkh}D998-"7sC7*QOր?7Wӻ_d_e)-tpTVAx㪻llr-n>ee)a2@6л`x?b!969xZ:p:G:D:;D;A[];lO/;k;;Q;c;$;v|;;͆;́;C;4;;*;Á;J;;};җX;;ۉ;;.;L;I$;i;B;$;-;z;K;,;3;Ey;>r;$;;Jײ;[;t;4s<<F<<<<O/<t<
N<P<A<<y;d;h;;;tQ;F.;d:]Q::p5:d>p:&~98l6Vy@ع>Iù/(2*Gn^ѺW>ؕ.Ǻ*, 	K0L7V 
k9CSZ9~X9 08=77-t8q`8`i$U3j?o:q}@sŻ%~滂p_蜻BYiػ.ᠺĹ+6I9:#:`p:ym:;s;L;~u;;k;%;;;…;g;;O;);;0;܌A;ђR;j;k;/;ޯ;R$;j;
;K;l;UH;q;p;;C;;qG;E5;;;Q@3;[;I8;1;82U;na;i;;<<	<y<<<%@<%<#l<"~C<a<<M;";;v;;h;9/;:Q::Œ::9Ɖ8eSJ9h<`S8ƨ80`MN^B$F1> O5Eĺ,Q2x1s)jdY9v9`}9$9 8 8P6F|w#	,BG?\%bp@ty{a黋绅ݻû⻋Kǻ\Wi
'ֺ}"V$9:^:l@:?:?c;&;UI;;;;yX;k;\;K;ᔟ;t~;,;;;;l";;ӂ ;Fd;ݫA;eu;И;T;~;T;{;bW;qZ;s;d;D;;;]e;B;Ng;f~;e;N<9;?2;P-;I;e;;k<<I<<$<)<(<&<<$<<^A<
T;>;-;;Fx;&9;c[;5;}S::Ǟ:6F:/:A&9h[/8{6fٹG=IӸiɴ9>t99dܷHSZu|Iqں3.izߺZҺhZIL f }|ώ-w91:5:9(k98x~8RA^dȼ1dA
aILbfvl=ap{	ʻ()軉]W*\әo-x|Zw8Ԯ{:^:d4:z::;-jm;_H>;9);&;+5;;ʛ%;ֆc;rI;<<O;9;;;|;J;f;;;M;;;K;;;wc;l) ;;;0%;|;&`;Yf;pM;H;E ;^;o;e;;RjN;L{;c;[;;y;q;S<7a<<#<&&<&9<%< *=<æ;;W8;|;^;/;y;l_;@;V;5e;O:C):L5:i:9l8]7qVV:븃<9&9^998>VQ``~(^iu+mx9>v:4:C=':
9q9"88wOzѹ'<á<<V=+,>;'q<?};;Cq9:V;)o;;:%y,õW+l}HuFt7;Zm6jʄ,;<?VNL^Yx<>W;`:Uo'J&Z_:m;;M3; 0X߼4ĘB&U
̅evĽ	/	5M:$eWXǾ<<=P=x5==l=e
I=*9޻Ӽp1_5
>2cXId;0>/df%Ʌ9چ;C<
<;tlv;|U{Ž$(|q</:;GQ;#'!:~>*;,*^JnOL?Y'uI|uWZ9?;Q<#<6<ɹ/O@,ځ鵽3$Ž.ڈ+L(ݽBSc(L2559<;3<^=M=9=$V=s=	t=[=@=bJ=
"=y<<"=b===Y_=f=c6=F%l=3/؈Z:ō;F$<(91W9el99Ɛ9h99&99'9q9B8C[88=69g:	xM:i::j:A:w:XsU::1::9V:?:9RD$9*cOʺ
|:йl]7
%9>:z݁:):б:_:՚:/V9o%ꮹ7>5r8*(7 ĸu*~ :yIgG42Vȵi?k@vfVg2׻&	ѻ)TcỎ=绘15K7v⺵:m:I:1R:::뤞;L;;a;{k;1H;ǰ;;;#;8;+;(!;4;6;g;ZJ;g;8;P;@<G<cz<p;:P;p;]8:|r::p;;ir:◮:y`V9@99C99fq99::;:B:9ԟK9B9G9<9:2u:u::➹:R:Q:w:9:A:]:":}
:95޸
6o>_A628	D-l9^1/:_~):t:::JΛ9MԹ|y7W8]P$,/̺hvغ'1}*+u𻚡6%ywZ|FD/o$6
dȻӻ}bҤ9F:=:n/:q:[:܍f;;LQ];'?;`h;3;;;;ɜ;;;;l<i;w;A;\;;V;<m<wl<O<<;;;;z;bxI;	:U:;y;;:*: 9(͞9u9j:
':
::6::/:Z":O:
>9;s9[9::q~Z:y::[:؁::!U[9̹g::fZ::B:UY:~8u$ɸ87ff!::tb,6Rek9'A\:` ::l:bӻ9;7`
4ʸδ8K<9]8|e>1,_ŷ9>@ZϺzXEe^4 WƻMETA_PSIW9A:r1:$:s:8҄ϸ8F9sy9Xoݫn_!CSS#Iɺ3ںl zUAh2ZHj>l?Z^Żdzjdzw|0Mqlv99S9o9o:/:v:;6b;~;&;y+;֙;ZH;;;ߔ;{<
a<,F<Y<d;ZX;_;);֏+;;<{<ó<IA<g;;m;;;N-;;l;$1;2V;
:98^9gD:8X:?:L:CQ:R6::y;		?;f::A:w:F:05:UT::֥r:%:b::{=:y39ג:2:=:X;N::9898ƺ@1׺i4p
$l
:K::{:$)i9q9#
8Th9^9
9%w4i	%Hݐȅؔѹgv`<(LF-eF.GS⻓Fj@`oRM#XuϻwɕQ7ܥ9\8򃸅8?2:u:;q;R;;);Lh;齻;;;h;y@<L%<N<Y<<<;V;+;6;;;ڬ;_<u<W<q<A<;v;ɆO;o;X`;-(;4J2;CIS;3	U:٩:g
9|9[%::^:ql:m:q:;W;(;0:N:C::D:h::S:B::ʐn:Y:=9p:::]:(;@;:}~:UGD9d896DJ$iӺwU
6ֺ	x>93:Jv\:wے:D98Ѷ79h9'L9U(9h869U깰Ì8'uG
عIѺCyO>:%ͻkN{%S㻍CC;ɻP%XD(Ǫ8I湵NjzN³: 3:;&;t;Լ;ɀ;4;;R;;l;<%<i<<<
;a;+;΅;Ǥ5;;ST<
H<L<C <<ڭ;h;Y;;v;\5;]tQ;Ri;$D:ͨ:9:C:{:::5:;#;C};B\o;+P_;:e:N:4L::Zf:>:l#:ݹ:^:w; :*^::e4:]+;;(7;B%:x:(58&8ʋ7QPK'R纀3ոͻ="U溎᤹::cy:VN:9h8%99I9‚9;9 Q˹T.b KAt*Jǧ:ݹ8i*;j"DCUWu)»8n!+u5=~񦻯ZF̻u=4n ʋR)2GA
u27:ah:;H;n3;7;;*<D<;۝;<D(<w<٥<*<H@<;;J;ʫ<;;;u<<<t<Z^<;C;ӏ;;=;VS;w)6;O`;
:Yd:\:=ho:s:j:6:y:um;";Q4;caB;W;@;){I;{::[!::1:Ґa::g::gm::}:O::;!#;":1:^9&Jcg{|R.5ѰA߈蟺vOYߺĹ@F9:=H:MM:%9Ӓ9{K9[x979R9	93^7X޹WfExi㺌4麖q0Ի a,yQf𼻗!ȹ6tºsUŖ6yߺJFtX9z{:af:B:|:#4-99\99dQ8!sFZ"*l7o;e~0;zW;;;;u;Y;3r;)Y;Ы:	1::,:s:R?9_9H9цB999L8/NfLCA]hq%+}"\JjZbY˧Qe753 s]].cy=o9I::}Z:/;II;';;;};;;ܨ;<1<<r=<7<;;;a;Ȧ;s;[;;
;<
Ft1qBFDS<#$zጺ$Rv,7M96*:9V:';';;;{;v;@,;;Z;>;M<P<<
M<.<
<o#;E;;6!;Of;;W;_;{c;;[;);H;٧M;w;˪
;C;՟[;뫅<*<<<)/;u;Þ;(;;W;^}>;+WI::T:::P::	:`:U9::FQ:998չ>ꋺU9yR:`:iH:C:::-^:&A:0P:>:1::}y:o:Su9<>]Òwԩ@Xx"1yǻ_bg?n7L6
589:^G:ٿ;G6;[?;F;۳;ԭ;Ǹ:;ò;͐;a;d<Q=<<<z<7<<;[;T;D;?;M;
;;;!];R;v?;S\o;I0;N|;Q.;C-;&֥;	:ێ:T:;l; ;+o;?7;\;rİ;t;es;Q;@;5;6j%;L;y;;;;h`;ɹ;c;;;L;x
;D<g\<<#:<@<Y;\;2;k;;b;hc;0;ss:Wb:w:T:F::Ѳ:_:8:UI:0<:!a:9nֹ#(g޺u?g9pI:I:n;t";;I::b:FL$:f<:?[:*
:u:o:]:g90G
7o{*o]|?uL2W@Oe9k<909S9a9f9si:H"J:;(	;;;;0";Ӫ];ʴ;H;^<<؝<]<<<ޞ<i<!{;P;s:;w;;7&;z;k;;;|;[R;<;1d;2h;/{;{f;b:Z!:մ	:t;;;!6;;XK;X;;f;_U;HR;.`;|;;%k;S;U*;d;Q;G;;;h;;\<4<e<)<,<<';X.;z;_';x;;`T;%H:G:
::Hm:Ԓ%:3:;:^:@:n=:^!:jR:Z9Ѥ8ج:)`:;;%<;":
:x:tJ:@::J:䕿:UA:::R9蹆L*S)z0 s$݃ёe2}I9D:/H:U:?v::	i:Q=:|;i;k];;;);;ϗ;ϊ;G0;;q<}E<#<< e!ʐ=+V=)_!=-v;= <찐<^c<޻P
~_!/#4sgϮ<<x=0˒===Mt=`^(=^L=KZw=9<=9k8=GR=IKa=*b<<<*fɽWOwX:{=>=,2'=
)$ |!ƻjSɻ5䠻qQ;<B1<<;<=iY=<ξqrI[]Xq;<%<)O<<=r=<<ܣ9<ֲ<<1<<6+A\ؼnb||[K}0>;x4|=CA=GSH=>|=)=<#<"<]zI;-OżlEnˎySa?<@<:<Ю<|;ou8ХIiy!ؠ;3)<<ݚ<v<x9;n<<===8=Oqt=_=eW=^ܐ=I:C:ڂ:MT:Ӱs:M;;V;r;Z5T;3M;(:):h:R:::M:/:z:F:C:۾4;:D:JT9r1"䢹8r	0nغϭ^MP9H9*G9599^9&r9g9F8._kE'aZ^*kߺ3n
?HC`6W3WN0$q.n.J֔^黫*rq黋pH%X)hA'pKh38ǚ:Jx;;X+;);dT;Ta;Y<;>;P;r~;櫘;<
<<K<X<|<;‘;؃;؜h;v<
|;-O;Qkb;z;f;;ԗ;;;imV;:};e:	::%:3:::.:(: ::Շ::9EM V9.5+TD3,׺W[9&wZ927G6t909w99JI#h+U`1(shSܻgĻ-ACS|H:rAeOV fSϥ8F3<ֻZDһoP9*%<*6J<%_j<-<;~;; ;_;;N;!];;j;%;
k;(u;4;J~;a;|o;D;	;n;>;;n;:;
4:u:S}:Vu:~G:2:*:~d4:qJ:F:::R92TI[ߺ~rӺl@iOKк˦ҳ$ڸ:(2[۹v7B9k9LW/9R\̹Gh7/3ZBlҸ]#¹(qw8)LڝSDL?ͻRSAx<4ۻi/[_aѻ̣G47n[ݻdmr~Fby}:fp:';*;c|;6J;6g;s;x;@;v;׹x;f;ߞ&;L<	<<<<<</;a2;$p;
<><;|;;;n;4};;-;;@;fZ;5;
g::Ǵ :>7:(:]:Dq:o9G9F8⹆_,F]KήM&!.UTNmCgɒwW9z2F纉6(z/+깄ֹ}/ˣX`7ʳ9h`q;JB2l>DjʻM>T횻ADS>DDWVEcq0UH
J:Z0ΪArbBHtߵ?ǻ$vK;:(	#a	8U8ךr:j=:,;";g;dc;|(;+;P;;!;y;#;_;<
?<ʺ-c	'+>:лDLtF"3GcF;.Q1Hc׻仛a3N̔	g13ڻٺ˸غ[D:Vd:;2;;;Τ;h;W;.;ه;Ӈ;Վ;eg;><a<<$<#P<<;z;_;
;G;;[~;;;W;Խ;&t;r;R;j?X;X;Z~;\;V);R>X;`u;	.;;L;-;L;?;;f;	U;;|޺;[;=F;';/;:ج::A%9%)6_W}bq	[6%ػ*Ӟ*0iĥmWֹep[κݗI0ֹʜbQ&寺h*(ǃU!S8ƻ@Ļ=:7!|1EC+0bKajS$»GXջNcùȹV?0ܻKغ|=S@3+]1:r.LT:;;T;;(;Ғ;7;h;;׬;ռ;>;<Љ<gT<#
;<&< ><ڔ;d; f;;x;֘;ਹ;;k;4;ՙ;lj;3;@;u(;b;fV;tCy:::z:I::|:F:a:::J:ʟ::<::҇9:1::5;$;G9;E=; ::d::S;.,;;4:B:.:yN9ߖ?8<)1\cj0zLݺrLei~T,:@::<:G:::\+;[;Q;r;w;.;S;o";ԚM;ח;;;s<`!<6L<{<D< 8<@<*<h;;;u!;;7;8;;;V\;;K;-:u:m::Im::Z:%g:&}:F:en:,:E:;";1;
:iE::T
:Ph;1;}p;^;L;ZW;*P;;;*;;4<<*:;";Lg;\ij;G;:H:ޠ:;s;;צ;p:Oj:lb:D89}8"@"9WܺcZQgg//9H_:x}::::賒:;u;Ta;;s;x;ё;ǂ(;ά;ո_;~;qn<w<Y<K<a<_<<<+;f;ŕ;!;;@;;w;;#i;[G;.: K:P:::!9|L9j9C9V{96S9!9::[j::փ::<:`q9f:T:An;Gn;;(;D;S;y;soF;;%-;Ѽ<%<A<(v<"<[Z;;;t;Xe;;b2;Vv;:G:I:3:PVe::|:::kt:G:G:Dr;;';*b;
CC:сH:C$::{|;\;L;jeX;e";A-;h:&:;;Z;;;,K::/:#69p87zá'G802g4W4y5XF:i:x;|;7;
;7);$B;U̼;;;d;y;;q;;+$;!;4;f<<ƨ<
=<< <<;;f`;;8;;
;3P;";Y;n}c;)Ɩ::)B8u^ڀж̘?`i?o|bz8u9p۷:R:':$G:9e9
?:/;XN;py5;h;|_;;|;c;c;F;@;<<<<;i;ŷ!;;;-;fb;#t ::G^9:[:#,:V:%:=::ǭ:::;$	*;>;5X;˟:x:H:T;(A;M;r2;y;b;8;D:k::_H;f;;$H;!;*\:a:$:9918#zh-ԣ&h9^:z:C%;;;z;%(;O4;N};;;nE;;};Q;j;;;͍<<<<	<;N;;v;P;;u;n;n;#;;;Aol:꾁:9t&~!cR--LȐk]
kVͺK끺UK!XK&,:}V:K:t'9ଋ|8/:;'t;;y;7|;;^;M?X;S9;};;<<qm<,;;ڭ;J;;;;MN_;&G:yt:999)l:_:%&:VO:t:Ŵ::)":;|;7;F;5;U;;*;!;M[;u;;y];Wb;.;/W:M;uT;;$x;2uy;.?;4Y:G:y:0g9<9D9#珹Fݹխ01Yrr	.v:S:Gq:t;j0;.;;? ;v;;;;;u;[;*;gL;x_;ۊ ;ꮱ;;;AJ;;;';;T;F|;;F;;b;;;;[;,x:yS{x&I်pcy^2麫{>'9:+R9Y5aTj9:6;9N;zq;;y:>;[U;B;6d;Bp;tD;;;'<K;.<;З^;;;r;;ƾ;N?!;:P:r:3K92W9z94O:z:::W@:rI:(:r7;׈;>;C;0;;;$F{;JkV;s;^;;;n'";I;%];;
Z:j;*;z;8p;I};C
0;%:Z:p:J{9v9D9_H7XB€K\" K99:IN::;;A\;(m;Ws;	;R1;%7; ;;W;;;D;ӣ;ҩ;;;a;;ڠ@;
;;==;B;;>;h;d;;;s?E;+:-8źT9$Ѻ+ܺǺ{`JmW4"ߥMͮE9V-9eq|:G:q;5;^`;c;S;=;)$a;a;.;d_I;;Sh;;U;;l;A;Q;";f;;X;d3;,?:|:OE:.(9f999E/::C8:}:;_;(7a;?{;@K;1w;%;+`;Fza;lE;$;;};`A;??; ;
;q
;֕;5N];W#;h;];:0;
7::c;::998;adߔ9ұ9:rC::f:;;3;iI;b;$;A7;-&;~;9;;o`;;;;ЖG;C;KQ;s;ɧb;;;;c;(;Y;E;>;;q;;CqD:܇]9	=3ټpCۤxR	û&Crջw Ə$czc: :%1;$
;AT;Ek;:c;%w;
;.;w;L3E;,B;;;S;;Q;1!;J;B;;v;|/;B;::?4N9 9MN9rV:$
:C:~B::;;4#;EG;Es;<;9ű;GF;d;#;O;;r6);X_;=V;$;o;_;1;ZS;~;;x};K6;J: :ysL:9:ߛ99c8θgXj7k.+9[?:k/:4:ϛ:έ:u^;o;=wz;nލ;;n;5;};6;8;x~;.;;	;);;;N;ڕ;;;N;;;Q;6;x;H;;P3+:_:!ɪ tԦ@
>d 0,86:b:9
F.ʭJu(4d`;-J:~/:ƌf:x;-?;e7;D;^;@9;
;;;7&;;A;;=*By=<]<<"=J[=5=?e=;e=,j=iA<.< <*X`<HbYfhY-ĻO:Lɨ<=	=-=>#=<
=-=<[D<=eGIC
01޼)q
<-C<˛=/=7ہ=Df=>cX='0=<©CU==5:=d#=-^<۠G<4s{yᆼuĽv!w|p;=v4<͝3$da
CIe_93
+
`	z,Ji<-<6<(=`=%<&A<ڎ.qyﺐV:l;X";D;]2:R˺qUĻ\
	[G;^<
;{;%;e;؆;;@;:/;Q;oӺ;h;v;;$;;k;8;$;t&;O;;&;q;4;;^;u*;c{;S+;G;;:;%;:r:8-GY?$=݌(t:pV\ػ[#PrENۻBFBHQC7л80M.p+ܭg8?EĶs9Ժ‘.T4ԫ>Du7&$g&(NT%sڻIuj̻tuûLýJ8Zd隻ХDևj:n>9sFݷƺ=|ӭ!U<8"_elRiZehnKogB[>Q[Jq;ӻ,Z;Orѹ֒\we:k$<חf	䮻%ƻ;]ѻFػA}-yhdE]hλ\yMһȎ)UVBȻVܡ|L͠-Հٻл穓9^xA\j߃ZtqB;úַֹK&:1;&;lJ;z;;;';F~;3X;-<
<
i<@<6<k<
a<j ;";[;U;;ij;;Go;5;f;rd&;k;nL;|9;s;.\;X;0;;;Գ;?;u;;e;;;y;fQ;T;H	;?
;2;':	:\:=9ǹ#ǺiAg(ú*Q
:9`	tn){6ѻ^ػ+Y.{vMmb]I`=!	@7i縏MHK8<+WOE3лVۨX%Ih794/tKqYˤ@+ը6"yf&e#̻5E#E|Ff<_
:,;iz;C;ug;}h;O;{;:;D;*a<<<5,<*<s;G;1;)/;k;;SQ;m;;;z-;h;i};u;;S;aJ;S;մ};;۩;;Ĺ;nA;:N;;t;J;qB;[f;I_;=;0D2;;n:Ǖ:R:1L9\☺K>ź;fw;%;#;Ax;l;
;b;0;
;;;;4;';;L;5;j;;z;}l;;!;;~gJ;N%A;4:+S
}T
T%q;i;A:
:#ùHᄽ!%8}AvVc&$dkZ.B_pBIj).ݺɨF9ҡ:z;3;.:=:y:M:z:hY:w_;;+;Pv;}A;;;z;};U;C;;\T;,;	`::=:;	ڻ;/;*;?ĉ;W];o(;w;#;;;{E;{ A;X;;?;c;;V;};v;oX;q;;"; ;;v=;3g;
:::^:f::O1:u:?H:9Cw9׊:)ki:bi::Ht;;;5b`;RJ&;i;t;w;~ʥ;r;߁;&K;s
;7;ݛ;`";s7;;~J;b;LR;A؀;B;Hw;Ec;)s::s̺u	f&CY[]j:oc߻J9q'ͺڭT"T4ĺ29H::::?:#x9b9:Q:ԁ;;1J;Z;S^;];;e0;j;; ;Z! ;5{;D;w;G;(s;6);E];X`;n;b;ݎ;d;;Of;;;p;!;@;n:;;;5;&z;;-;H;5;+;;~v;AN;:`:W;::g:::Ѐ:
6;Mf;\;l&;p~;m(;;0;MG;n;;w;;U;;T;B;+;;~;M;;;X;;9;;Q:;(D;::f:(::y:lI:w99oW3::|p::7`;e!;S;1_A;R;l܀;~&;9;5;Pr;d;r;;;s;i;i-;G;"
;
:Ӿz::Ե:XR8=庺u.xE02VGe]x$𻂴t=]eH>8q/ƻ/&.Cúf։[9:	H98st9<4:,J:J;u;+;B;Q9>;]+;i;uW;y;r>;c8-;Qd;C;;?-;H;[;n8;~;;;};R;5;;2;Uz;b;4;;DZ;<;{`;;(;;";;=;1;;;cQ;@4; ":e:A:<:M:v|:;q9r9uY~9c:XK}::;l;r;:*;\?;z};B;_;;[;};.;;c;;ol;O;'l:ۮ:C	:EP99g캊o6D˻7lQOd>mtRv(;ƻ$Tz!j]T&I[׻0ͻNܜ˸|8Vr:k:;_;.d;D;I};;G';HBj;O[N;V;X;;Tg;N;J;OS;_r;wW;;`{;*g;;);;t;);7;;cI;W;^&;;;ݖ;;[;;;;;/;J|;:;tlq;S-;*l~:M::]:P:H:)c9Ȓ9
{:J::X;D;/;MX;n|;;jp;;0;;;%
;/;;<;_|;6;e:;9}@/<a|%+v7?컥0󻝰˻F\=y#d~ApúW㿹9/::;#;?^;Ec;={y;6r;8;>QY;D;IJ;N3;U;bAg;yh3;;;;?;;W;a;ƀ;f5;Qx;>i;y;43;;;R;;j;KZ;;n;y;;;<;\;&:::^:::-$\:7t:7:3:Sbe:u:A;!\;A/;aM;;'N;<;;u;;@;t_;";);};SV;-:j99_k;2߻g':/.4NZz\ݻzEn/˻݊~SZzإKYl9N:6>:A;Y;,I;;T;8;2;0z;3;:;D6;Rxg;c#;y+;;7;;;;`;;F;0;;S;'	;';;&;qE;;:;74;+;e;;;;;~n;W;*:H:L9+:/+:J:I:m:{R:;%O;J;lDK;;w;m;!;;;I7;;;;}n;Ha<;f:MQ[L9޻cܻ^㻩们tKj=͛Ǝ
m黝_7%꺆k^
9:QI:;	;%;0p;2u;4wk;6;;y;GD;ZN;tU;΀;U;U;t;;;R;#;[;p;;k;;;;;;;;ac;};o;;&;|;6;{;F:f:^9Ȯ:mG:S:y@÷Yˢϼ.Ov8u3Zt;J;]D:J9ॺ+D!@ߊ_ʼ
4bs*o:;2C;P;,;Գ;Ĥ;s;;vg:4Y:`X;o>Z<2<-=D=/=O=k=gC=R===d="o<>;l9𻛴!&Gh愼lxY{ϻH/M";;7;j:`pO$Iӻ~vл׍F::Q:[V0,_.6$00e{=䓼B=ؼ8f8	6⾼'j72
8;n(<(<&<"<0%T<5<<+;J<'CM3»M~}ĻF;:;;M;;;^;3D;䏉;;~+;׸;k;;ގf;N;h;;u;;@=;,;;qT;2%;Q;p;_;i;;&;l;*;;A;qi:ə:j::v9R8@xPh0k2fEYҍiPgsƻ2?h'ǺQfUȧ(A3N]lppq^WFgi⻢<'@*gpni
drCǼ\XPnݺ^-:;;Rו;'Q;D;ª ;Yh;;!;`;ɡ;	;Z;˹;
C;З;s;;;,;>;#;{;j;b;R
;J8;bC;n;;;;O;G::_d:0:9CӹH`pȥD}>eF5_Fmw>g
kzP?+@޺sJ8޻}(uB
NwQʞQKigлQüp?
/nafg*ElXi:A;ԭ;Z6;;m@;˧;5S;ߥ;7;Ǝ;;;s;ԔY;_;;M;Z;y;e;cv;a;Q^;?0.;Ak;d;/.;;u;TW;*::UN: 99`Kck90-DLp-EwwSS"f*vdUǺZ۟ûa(6ۻ<>?MxH]߻#Zټ9u5ϻhO
^n{:U;;a);E_;3;;.;;~;D;<;;ɲ;ϳf;[;;;m;T;R;R;Gm;;`;E+;h;U,;d
;R*;:5U:CAQ:9N94t}Aú&2xVRx)`IlAVL΂/i4ԺwǺeˇXd$/?9-WV<7Hļ)c{{CĮK
ٻѻeRZZ:Y;G;dq;*;;4;Y;1;;=;;y;ǜ";4;;E;l5;Q	;O;RB;J};;CM;N[;e;j;I}2;r::(I9ʧF9%!6R):<+:[zû}ybB3@o{_ oG]buz(AI:`
}GǼ)	8;mD7 >lË/9:0;d5;;~;ߏ;V;IJ;w;ƛ;;;Z;ĥ;ac;qə;Vx;U;Y.;T;M=;P-;R;;;m~:H^:	f9ue_8bù8'-8*Y:w\Vvb)U
#cɺII]x&H'
uh$=edd5Ҽ_ȼDCO:28rw4:&;_~;8;;;,;ө;;;;;);9;K;x;^x-;];`$;YO;Mj;A;,
;2T:=<98$չ`N	G7#6PZn]Qj]CtEDa)x}>F"P߻@JTfԻ֩Q`Lϼ)G!?Kh:82;X&;4;}~;l;Ͳ;p!;;;MS;j;3;|hq;bi;^vd;]):;P];:I;a:$:)h9	۸*[s;)g\C)6\CI`WR(v_ѕT\GnOw@SbỏT]ؼꪼ	ܘ	v>h's4#*㙺A:1;RE;V;;٭;E;Y;^;p;q;;y;] ;S;Il;3;:Ա:Lq9R=jv'׺vE44%N;Ƴb~/\c8ǹ!4H
=*,_=/YKj[gJMQ:w4g;L;;м;>;&);,;B?;);8;p;Nh;:Y;%,\;J:ƪ:h90eQ23
rf$#j6y5=T9Lj90xaF
Ȼ6^&-b\dP~Dػw8:=y;H;P;n;;I;;p;R;c&;8,;h:4::7 9vK0ںG*Y9㛎Xԛ#Y:ҭ:V987N,_~EՑXhSJ?ٛ[ػ':@;Hb;2; ;i;h
;
;ve;UV;4::g9n8mO߹PpQ		Faප3g::e:tq񓺯лbֻñ)*so
-"U$9;N:W;e;Е;};_p;K;J^;c:9dwxȺKCغغv"\c]9::b:P$
VCd}ٻ%
ͻ
=f9P;[;';ʈ;;
;H4?:[9'%؄3P"_ƺFYsIM@Ϲ^Z:y::J!חaE=𽌼;xŻeMY9;ru;-;y;;Q8:c6fOԺ|W_eE4a? :,B::疖9ɺY	W%ٶ⻻SL:GH;OR;;>;;g:įkM.ƺպ홟o}am:^;
g:v}N ȻRǡ:;l;p;m:OѺJ+4%ia:q";i?:蹮uHS>4:?;Lo;>;ۺ`xn:T}0!;	WI;.9޶FQlC[`;(
;2;(9:i:)L;Sj:_{9;n';kر*>h;a;3w;;R:9.:Iu:#;L;EJ);hX;P;;%;|;;B;;*;;ǘ;{L3;7:8=к41Q!;vm4/?
aVaA䝻7"ldP~4`kvSEVb9{:A):;#; !A;1g;<;A;E0z;OZ;f#;3};;H;1;;;h;;y;|;8;-;y;;;;Fj;;Y;;;A;	;J;k@;,]:;:t
9~:.::T:T:;;"r;2A;U7;q;qq;;Y_;#@;;;A.;C;;p[;0X:P-QX 
/T7⻻KMPĶ1b9i׻Yo;ztBP	d!Je8e\:,<:Rj;;(;@;M;Q=m;Y;py';%H;-;;;%;ő;v;p#;};);&;;D;+5;;m;;;D;L;5;;!;U@;-:9	J9y:Y_:ѹ:[::!o; U;7|;T	\;i;tB;u;s;y;z#a;8;;A;XYI:->D*0vf񔻻u!ƶ<ƻؔ<
81N6mH3J+d?iw_hx:3R:+;y;:B/;P:;W;^;t;?,;oH;;;ۅ;";?;;;í;;M;V;;;
5;;>;Z;y; g;y!;;:I:>Y9P3:U:nO::Q#::;a;19-;J);Y;^r;^c;eu;j;q;1;U;2:xx<%Spk𐻌oƻ/nͫϻ"(onjGBhѻ5|仼M%ab\ֺ._1T%ost1:eP:c;&;F;Qv;XE;l;+;.;H;z;;;);;C`;ďK;_E;oK;6+;D;;@w;;D;;D;euM;{:9-9J:	 :eVc:+::s:\t;q;*p;?;H;K";S~;\5;x;n;^d;:8b2	Iz+򡻙ِu滹CG)qߨ̻CLo,̻,6q9+!)ԺRn?κ
e9P:x;;/8;?Z;Gm;Z-;{;";;R\;H;Q;8j;o;ð;;_;;9;E;c;d;;O;;O1;:u
.99=̮9M:Ie:Of:tM:
f:;B;(`;5b;:;Di;M;f>;g;6:˺4ϻT|rٰNU8)û58!rF|t?
crezE&RSgH{K[:0V:;& ;$;.c;AE;a;^;/;;O@;\;>;;b;;;Š;?;_";;;;;tk;7:<:&V8=8d9:1:::\5:by;d;';.o;8q-;?V;Q{;I;:ݻXS!xJK^4c~Ļ-,W/%,ڗ~&Od=ԋX`Y9::;
M;=);*;K#;l
;F;o;;P&;m;S;b;u;;%;;@.;D;s;_
;!].:m9EA9:2'<:::,;;b;&));.*;2d;=sI;.d:]9T[	&ӻ;5;Is;G_W;':w۹_Xa*ƋE1"лTUw=V:yO:߂a;<;";ANP;^;u;;k;;';z;VF;=;&;;::9:I)DR:/;!;D4";R{;L?;dq;[[f;*:F.`a٧9¼߲"$8:Y;;49;Z;}i;c#;;;	;o;Mh;.
;: :m:Sf:.p𹉇.`ĺ2:QT:;Fv;e;f;}f;ha; ;:4zf
A9g*|>r9:;7Kz;hء;;;;;b%;B^;%;Q:&:r:i͸c[H:;=*;rSs;7;;gɇ;#Lƿ2x\߻X?λ"71$rdG:;iE;8G;;@9Y.pֻ:l~[;I;,;Ii;>;PX:ЉO:tՖOj*Ph:=;Q(;ؖ;w;mT/v=dػl>-s;#Y;^d;q%;p:¥F::5;@8P3;*M;#
;@:ܻ7)@}:;},;g::һ@:ڡ;;kXq	;qT;c2:4T4eDV;y;W";G;Mn"4;J%%!̹9Chealpy-1.10.3/healpy/test/data/wmap_band_iqumap_r9_7yr_W_v4_udgraded32_smoothed10deg_fortran.fits0000664000175000017500000046530013010374155033276 0ustar  zoncazonca00000000000000SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   32 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H DATE    = '2014-01-14T19:10:04' / file creation date (YYYY-MM-DDThh:mm:ss UT)   END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                12288 / width of table in bytes                        NAXIS2  =                   12 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    3 / number of fields in each row                   COMMENT                                                                         COMMENT  -----------------------------------------------                        COMMENT  Sky Map Pixelisation Specific Keywords                                 COMMENT  -----------------------------------------------                        PIXTYPE = 'HEALPIX '           / HEALPIX Pixelisation                           ORDERING= 'RING    '           / Pixel ordering scheme, either RING or NESTED   NSIDE   =                   32 / Resolution parameter for HEALPIX               FIRSTPIX=                    0 / First pixel # (0 based)                        LASTPIX =                12287 / Last pixel # (0 based)                         COORDSYS= 'unknown '           / Pixelisation coordinate system                 COMMENT  G = Galactic, E = ecliptic, C = celestial = equatorial                 BAD_DATA=  -1.637500000000E+30 / Sentinel value given to bad pixels             COMMENT                                                                         COMMENT  -----------------------------------------------                        COMMENT  Planck Simulation Specific Keywords                                    COMMENT  -----------------------------------------------                        EXTNAME = 'SMOOTHED DATA'                                                       CREATOR = 'SMOOTHING'          / Software creating the FITS file                VERSION = '3.11    '           / Version of the simulation software             COMMENT                                                                         MAX-LPOL=                   64 / Maximum Legendre order L                       POLCCONV= 'COSMO   '           / Coord. convention for polarisation (COSMO/IAU) FWHM    =   1.000000000000E+01 / [deg] FWHM of gaussian symmetric beam          COMMENT  -----------------------------------------------                        COMMENT  Data Description Specific Keywords                                     COMMENT  -----------------------------------------------                        COMMENT                                                                         COMMENT  Full sky data                                                          OBJECT  = 'FULLSKY '                                                            INDXSCHM= 'IMPLICIT'           / Indexing : IMPLICIT or EXPLICIT                GRAIN   =                    0 / Grain of pixel indexing                        COMMENT  GRAIN=0 : no indexing of pixel data                         (IMPLICIT) COMMENT  GRAIN=1 : 1 pixel index -> 1 pixel data                     (EXPLICIT) COMMENT  GRAIN>1 : 1 pixel index -> data of GRAIN consecutive pixels (EXPLICIT) COMMENT                                                                         POLAR   =                    T / Polarisation included (True/False)             DERIV   =                    0 / Derivative included (0, 1 or 2)                COMMENT                                                                         TTYPE1  = 'TEMPERATURE'        / Temperature map                                TFORM1  = '1024E   '           / data format of field: 4-byte REAL              TUNIT1  = 'unknown '           / map unit                                       COMMENT                                                                         TTYPE2  = 'Q-POLARISATION'     / Q Polarisation map                             TFORM2  = '1024E   '           / data format of field: 4-byte REAL              TUNIT2  = 'unknown '           / map unit                                       COMMENT                                                                         TTYPE3  = 'U-POLARISATION'     / U Polarisation map                             TFORM3  = '1024E   '           / data format of field: 4-byte REAL              TUNIT3  = 'unknown '           / map unit                                       COMMENT                                                                         COMMENT                                                                         COMMENT  ************************* Input data *************************         COMMENT  Input Map in wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits              COMMENT  ***************************************************************        COMMENT                                                                         END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             :;z;<:H<;<8<=d="W=&=$=3
=Լ=e<<<<	#<2H<Î==M=vP=Zq=DM===
=Ge=k:=]G=UF=Kr=9="v=<=>=?,=<=7=)H=<Ӌ<<t<<=l&=,_=@ҿ=Y=Yc=X";=Z]=b=f=Z=9"=E<6<^<9x-sbμrhy*wW򻻌ڹ/;
w;<X<5d<28=
f=3m=N;=\<=\=P=C=Ae=N;=c=nԿ=c6=@=<+kǺ	:y;	=d<<YZ=(f=p=
o==!6=5{,====/=%<*<6;.$#?T6Xޣ
(3qGH(/SU	J?;N8#;MC<;O;K5N̵1'H =#1<|;;);=;j;ߺW+'.)MPEn'ESK)z,Z/Gd2D9fZ::|ڻJz?e;F(A;A:􆓺ë::>9!:D:(:l:J'1ٻճ ^;y;	;j:۱cLT:f:B9@wHo3:]:gh9jD	U;{;x;䅵;A9jPe7:QD:i:-c8dy3]d8lz:/:#8AwO0$ٳ:uj;u;+;;Y9',YU:\;	qu;$:rFl"*:	::suM3v$󾻷sԻ˻tɢ:hs;*;<;j@;)F8,4tG9:k;Bt;3:?ٺS#:L7Z:{q::Z\4$Ps5-T׻Y\Ӻ:;6;5<|;J;j;Ƥ9˶V82V&9:4;>;cщ;4:-g<.ݺ1:!:{:w ky=CiZαg<[/1\;m
;w;<<#;(;;T:s
:Iʁ9yr9{:{;+8;l;q;*o:c׻5紺G"7eo9_::9T`1ϻpҪޞt(	
eϻ1pUw;);;<`<<?;D4;o;3N:սT:]v:':$:;ޏ;^S;V;n;y:"e9<k":P::`#Q껑}{Ψۻֻ񜸻X6@	EomE:HQ;<>;;<D< `<bR;;Z;&;^5);:,+:s::;$;LӦ;}u(;a;`A;XB9_m`	šϕ1JH8T:-T:j9fFe!I׻D(WTG p屮He_M:;X81;B;m<>19\9Y_H񻄬5Cߧ&=ټ$}&oo뎚—\dYe8;?:;pӏ;;9v;<Y<Ťӻ6Ȼ
º≺@Gc9w98HۻqcŇf$(-0o,g.<
DŽ"Ó3%X׾y8^:_;e ;P;);q<*<*< v<i;E;);ޙ;E;j;;;@\;r); :Ԧ::k:;&_;t;\;*;;vX;X2;3O
;7: C9 +F&ڟ0ڻ$׻҄xWv9ޟ9,Yg[NŻo<.(26y5-ܻLϻiPϺ|:f;Uѷ;);;טq;E
<F<p<Y<%X;1$;ġ;;j;-;pi;;l;+;:C:
:Q;'Ѷ;s
;	;xq;m;;i0;H;":D:x+9	/Eʺ»Ns]	#"2f3p~R6R9vs!E_zO}@D)rA5;h:Y:6 -3 ޼ǯݛI=ŹШ:|;Gj;i;;֑Q;<	T<(<<
K;;U6;w;V<5;P;oj;\;iy];<g;#;U;;;3s;r;.;N;D;;*;}D;^
;<;~	:k:JB28F/;-ƺ+&$ 7!C:#OڦdJq>nC:]p'=mz:發A&}4xi;Q=?U;*7Y/"92‘,3@F>:X;=/s;&;+Y;;=<<G<
<	'<YP;;;<_<";g;̭;_;l
;NM:;D;@;6s#;4;J;x&u;};/;;;};t,;X;3?T;j::cCZɊLxMv$#;7uzKPN>$||7H:UQݻλ5g-gջ]<
3 ¼0˼9.>>઼=<80S!~m컷4ֈ=%,:s;8; ;%;5?;8<<<<
0<K;;;ӏ<H<~<=;{;/j;C;rKT;_w;bn;j(x;g;b;lkI;v;0;;;;K;%6;q;V\;,:Wk:&9yͺZM{߻! Sɻ$F6Pbf`uHO#:GْjغC*BKlN׻
nz+ּ6@H=@@AOr?l9|."Eֻɻr&3:
mb:~X_;;V;;;]<Y-<P<l;
;W;;;Q|;|<A<x<c;W0;V;;t;z
;m};y;_;(;;l&;;;=.;d;l;4p;c;}S%;qT;TcJ;%S:ڪ:XK9-Dƺ^кQ9N %jԻ$M%%	6hT^#pһ}rct.]Xl37ۺzmz{
7Uk~8@I:t?E&"I%+0:/@oCHDIs@6'?ۻQ)aཻj[(I:S;E	;;؀8;—<<;g;7;dk;0;F;R;[;;qU;;;;o;o;q;(;{;I;;^;l;J`;޲;=;M;;K;}9X\]9ap5=j::Vm9(;~";DRԺa959:2rl0(]9;;q7,|9_g)zԏ9{b;hۻd?؝;};VD;,;1D6P59H?9˺KeW8R nҺٻIU:;i;ׄ;E;:.Ồz9,F@@WF[7k.M52+}ŻO_:,,:!9<;G%;;dJ;;;^j's4他gs\ƻޤm7l98:&m2@W#¹ɺ:`~-sBCs+:;Lsn;a;Қq;<;;;mRzY7ٻ[~zRv0ɻ
*>d.ºwe|лʻػ{s0㺷c_{+pL7sڄoJ[˺x9;$k;;;l<Z<;;DŽL;cȏ9lam}[G{E%1>n슻NX[y?=ޯld-ٻY NAvͻH
滻89K9n"9w3;;}{/;i;
;<	<
Yt<4;:;:NӻqIlLĵ>䤻7%X&M/l1;*P;|};t*;(;S<B<BV<<;+;f3;*ɻl»Oڻ?K.pK&sy>rO"k8#N,л/ȅzgY-0:@
K=躵]eSxҿ8فjU%չe;w;;> ;K;։;m<
J<<6<;\G;8;@98Ƙӻ
ۺ#q;V{,#`XQGF鶻Vdt:P;s9P;7;;Ϳ;U;G;<M<
*s<;h;$;";{!T:e6r.̺}{-B2G!.z4f
ݻ-V*r#eY㻍1Q 2ػ߻m	#?ʒE_%o9B;>`VG
}	ϻ}̻O黃(
9;B;N;œ;J;Ѳ;4P;;;<ý<<^7;6;X;;$Q:ٹ]\κ0kð⹍c޺XR
[k^/AY +Պ޺m<"2n`Ƃ7XNKٻ2ĻŪ໷-#-e6T"xJ1DdME#>xл83wt(ۦp;yW;;j;;ҕ;Ӏ;{0;4
;;d;=;<;;>|;];#;`9fúi9+Y(o۟!1w̻MB}-}>  0WRGﻐ#$绹A\C>C&4ܼ\qF6终aW)1o,JkiT{Ի~`ӻICx:';J&H;˗;;έ;;oK;ۮc;;v;;3;;8;ٻX;!];M;&:>gdVr[渶@9^(g/ׂDuF*J`qƎ*~cC/λ0Hj#0ӻEvhD-k	8b{ڻĻڧŻػJT|ȻFM.8acGڍ(MGԹuM|b|r8`c;-;t;;Ǟ;=;;ɔ;r;j;߱;,!;ݖ;;c;Ա;;;*u:ι	-377`
7`]9zRhga5R)u}Rz$yaŇgHPsu:zA];*;i;K;&;0J;Ѿr;";ٵ;;h;y;S;j;;ao;!;`;&u:){N1܉ֺϳ庁1uH5sӁ5Ȼ}@]񶻇e;V,>9ϻFuѻiwһ7QA=4
g£;kUMQpgq# 㻦N4./
M(}H蘻ۻ廯!)P8̢黳W~>DȸBsm:!;Ds;i;;
c;);4;g;;-;C;;;;ԫ;4d;ŭR;";;:'b }vt[d0\<vJ|d/[VFp#ѻvͻ{
Sɻ+!޻
=!!IjHzT&tʻB)51mWĻIfኛy;q컷l᝻o='1ѻR"9Tһ3».[
"j<Z&
KR׼C/'1<󺅚ASƯ	Ҽ#L8;}/jZ꼜в,d9fa<qi;	%/:g;;<Yȼ3gʼZ-~oZռNs~;B<.𔼽\̼801t
1d'1n[;:Y;N;0a/8n1y"qYXvYs:8z;T;^;&<<	@<;E;허;f-;~;;<V;"; ;;;.;-;;ů;);Q;;K;z;
;;;;;;=";;vd;fp;e>;nt;p;a3;?N;
A&:9xjh~,Đy(ҝ1ϻ3߻@*]"»4fULOqEN750?ϻB~f6Z T򻫨pWƼ 'ˌ/8AGIDD?8e$̼7oT.yvP?λX#qKP ޅ:;g;{;D<6<
o<T<{;0;.5;|;n;k;Դ;);;j;];楧;ē;Չ;n;f; z;;j;0+;t;{;BY;m;;;D;;X;z;c;Z5;\u ;bjb;`
;NL;,:6:
9$L˹?[5'<	BMIeSKZQ=߻9oP7?<{>iŻXڻ8 ;NEO&fI
N#',3M;Y1COuII@+v.C[dwurX ƻ[!Fͺ%M^:r;z;G^;꾚<<"<_<
;@;<;Ӛ;0W;_;j;_;k;N
;Ҹ;+z;˻;X;;+;;jX;;;%;_;X;g;d ;ү;*;;;);tv;;n;](;Uk;TX;S#7;Jq;7;::j9>8M^9gGï$Y@FXTm]oRjkg(GueJ>=
DF1fis(4g%7ۻXռμμ(U+K-RU/౼5ּ<DԼIѼF#8m"XcC,@<nuuYfQ$QWB:<; ;x;;r<<</;;;{<A{<k<S;X9;'#;;_;Z;dT;;(<_;!;۶;;;`;;S5;j;R`;5;t;;y\;L;;<;;nk';_c;Ua;L;C ;6B;#$;x::E͞9_T8d9p9Ѡ9[!EP(%e[n0xE?G@X.0RB.z'ͦzrK̯81
;[;X;^);y-;y;;I;2<<Y<<<2<;;q;s;ĵ;i4;ݯJ;t<<@<YN;i;;;;!;ZK;w;G;c;B;c;_;o;!u;;;5;y;u^;en;V*;G;8r;(gP;:::.9i:9ړ9:9995!qWYjt˻{&»iۻ3&,"p=XA<2?5*L$uWGDJ$SX4'j#=-g57ts4|1
v1ͼ7@м?XԼE
Cx"8
$!֭A/<.m[7PQi_\_p+źo6:Q;Z;yǩ;;J;<;(;G;<0<
<%<d
<8<<);;k;Y#;;5;ْ;*<7<ND<W<<.e;q;;%8;ys;q;|g;;;Oh;];;;;;;k;&;;j;O;s;];G ;2@;;h:HV:A:HF9k9E9U9sC928ƺ^׻2$n8},ydSuĜL@л&OxDBd/iO/8z"#
E&7Hɻvợ=3L̻(AvOF%2#9;P73!1v38/B;N:Ji34%wV~:lfFG+7

[`R'r9\:3;'a;k;D;;;;_;՚;
<{<I<8<^<d<c;?;ݐ;<8;;;ĉv;`<أ<ː<<5<܊<;;*;&;S;T;lP;^m;;G;&;f;;G;;;*h;;_;DR;3;c;y;;d';M;6R;Cc;	>:
:[:Et:I9N9P9舸_Z?@xۻ솻ۻre;`lGFr9tN̻^;IV25(LٻDqỌV֎莻;^dVϷ/`e:+ļ4i8E8U¼5js32#3e5X52*	Xb~0@{c5Gk8}:RpA:TV;;9b;a#;|i.;9;U2;.;!;!8;5<<rN<$<5<p;3;};ݥ;̃;~;;̎;š;[<<x<"<tw<<+G;Ց;;yG;:>`;C3n;fE0;;_;6;9;e;`;;=;;;;;";Y;|;{;	;n/;UG;:^;"(;$::::Sd9o9n"r  Qv5ȻIi|]ͻl6VһWyjwDqpݣY6CF.Nl|lݐ3ĻFAͻkWͻLy
Mn4(yI廪5Ž0{?󽦻:t {/.ϼIfYX/!+0ͻV/
%"$	熻 ǻuϻFJ첻h8qweb9]=;k;pd;[l;;;";Ŷ;y;(;;;;;Z{;e;O;";]A;:*w8쥺cM:7VSӶm
.mWt?FٻlT»h8
=z
Ȼ(Jn⻈raby믚$시`5ۂG3|ىiW2y0GP`Ȼ_Yg5ZܡGknڻBgWe̺Ű-Y̺λC߻jûofƻEؚ͞{Eɐ0y6oɻԦW$gƽ;)껴Lջܣ/a+kۺnnKrmLg3ځvU+_ļּ
iϼ?ػp:=:Y;NA;;:;;!u;w;;;ú;7;i;I;>;>;;f;:9;J:989AXH6ӻpɻ41iA937C[Tl_`'Jwn"CT(]i?'#ۻPsNgŻjǻ)3=¼v!D»HӻuzYݐ `vM:^?*?Z!K3'{SBDxA7|]S?
xn#\%:޼"Xy36λ2޻ع4R-:#;h;;w;
o;;#;7;w;;ɇ|;̩;;y;;;D]];8:k:98L?4t>rX%jW["*Ƽ0ٽ2/'Tϼ?I߻T%LK#?򹓦:;u+;;;;;6;<;.
;i;;C;؅;o;6;_Ϲ;$X:E5:F:_}8%%;j{Y_>GJNҷ8јỾfx^qHB}Oh;黓FeJ_
'޺b>쿹&xQNr,Q	rx8EE?wϻn
)Ż놻k˻IY͸׻QQ给fr=T1	
߉we*'nt5LH}лM#*_@"z-r5;Õ=:82i'=h!@^d\Eu9r;
H;rhN;ǥ;;};;s;;1;;;S;XT;(;xt6;=\;::h9Ym,QǻՎ/^~Kƻz`a@7dF^|yϻ1r廕/S2n.^a
؁!g|rۺ?\lR#g-LFmLj}T(pU<YwuKT6Y4gɻÀϻs|LY37SRGv8N", 03hлƻ6л
w)74Zq=H~CWE'C-L<1AX$*ڻҲ8zr!9;+;];W;;8vAmʼGJJ,EFJ<ҵ<;gS<(;%nؒz<4<<)<<ʠ<<}<"<@=
==̊=!Z<q,|$N;ww<w<9%IMx=!d=?Y=9v=>&=HU=Q=^%k=qZ=)3=4=x=ڥ=f=MSr=:=,a==<3=Vx=̓=x$=W&=:= =<5?λi%i;ؼ%-z!2^53Y5t4%3I2y1y0#.1}+$%_xܼV~vW&Z[+9w:J;;%;:Q;M7;^;l"e;v{;;h;;T;0<<<Ֆ<;@;;ު@;,";׮;;%;oH;;Mh;<
<V<<u<
;:;£;k;YU;;;9p;X;9;U;;;~;5;;;;;
;Ƹ;;;;);;w;v;VS;6%;;d;
u:ڢ:&:G9*,KúF4'i/lPER%jO|6}nƻVƻ>)ֻ#7%ynI;LoR0<3__!.&,/1M2_3
2Ǽ1)U.t+{_(N&Gi!K*	E滶]u»#;[A9$:2;>i;a);fh;`;_a;cL;l:;z;;;a;u<a<?<<;\%;Ң ;,;;;;@;b;˖;U;<f<<
<
ޅ<Tk;`;ȞN;;gP;E=;Zm;;<;t;;T;;i;.;;;=;I;q;H;';eY;;;t;;x2;OA;.;;h;P::,:rX7۶5ϙ}eS
肻Ktnv+g.fLyC:>]BT2k73sDjUE<[ͻ'`~,<Òʺ-&ONra!⻖P:ٻK
~	!A%$))+˪,¼-m/B14O1/I,^(2%o#E0K;;(^һb݅8s
:;b;>;;;lA;dk.;i;wc;E;;>;U<<
<<G;G;;/;w;);;o;@^;};;Ά!;	<<Z;i,;O;;9;*;{{;O;[~;jId;`;M;;0;%;;5];&;X;;w;ư\;0;SV;;;G(;X~Wh!f*U=(7һy/+TxB9^S]]1!#rż%+h(},hF-έ+)6(+/0쫼/+˼&# PFμFջ}7p>\:;`p;
;;
;+;jy;i;v;
;^;;;<_<u<P<</;ܦ;ss;f;\;f;;I;;2;E$;¬;7;;a;Ⲍ;Թ;ƶ;;~;Kl;d;|֕;i;;f;;;1;9;+;o;e;>8;;*%;};N;{a;;(;5;(;I;],;1A;vD;#6;(w;T:RG:@8 Á'Tfź<Ǭ"@L4y6,_y"&|AFY&^SL@,k &\.ûxq괉=v{Ǻmiي,HMWȻJI8YIdk .{&{&
'<+}142h*$U
#(ּ-h10+%%9
?-5m໑p[n8;.;;;u;;yy;m\;wY;T;?;;#<	E<b<l<;i4;;;;};;N];1;;L;;6K;;~j;4;*H;&;^;o;tR;f;k{M;;V;;&;3;S;_;;g;eh;A>;9;Ň;';b;x;PX;85;B;c;w;/;cN;G;#;;'Q;$;n:b:~@JviesCq6
-!j
Ȼ!
aػ#AuQN-S?/I%QL$*(gk0>yNZzo@*_sԻH-Y3",(6)R(E+಼4<=+G3C&c>3%W.e3Q2*!="$Գy{ɠ[:v;};;›;h;_;ww;|JS;&;̊;lW;<n<~<om<X<;΍<;>;;*;,;;;)0;O;;ē;f;/;;>;];V;c;M9;M.#;c;;A;E;Ik;;˝;(;d;S;+!;5g;8;;m;
;&;Fq;a;R>;Ơ;:;;h';4Ca;; H
;(';:$:94͸9cZl`Ѻ|gcЛպĻ^9@8X-&L޻&/o[6V,R_ܿ!(+S"s%⻫Fc˼!p~*Oܼ*(.+)3üA*HcA0?bY$|/q4-0&(JDj6a)>]2SB!G;f;;;;	;oV;u;";%;7;';퇓<
lv<<<
q*;2+;VJ;R;H;*;;|,;z;;_<;;t;ʡT;u;;.;`9;7>;z;5;>;l;t>;;rj;D;BR;_;;;΢;;n;;;,;0;;-;(;H;r;J;\;]t;QS;(;W;%;%`;
y::XiV9"ظ2l-̠C>'%J;t>' (>!X+ )o57~#}6ݺܺO
Nwç4:E˝O4()Y7+(='H.Y?U6N*P3Ad)(ټ%0߁3ت,	ʼc
RthL-ֻ@]9-t;U/;;;W;n;w;1;,[;;;3O<&<F<'<;;ڏ;Ȍ;;z;;z;hJ;q5;U;+;J;a;P;K;;KX;-:,:Θ;;<;o,;;=;>;P;x;|s;;؍;;};;;N;S;ha;;V;=;;;O6;y;DA;'c;$u;)0;X:::+39D}w"=g)zdyFj@c;;u*;PE;;ƈ;ۧ;;6;ٴ;0;m;A;;:Y:]98ek馻6/ػxɻNQ=}b#࿻MV؈Ǒ3@TZM{Xpٻ`޻a6f3wໄ>"jL^U/'g8F1
@k40DJpO;Zi,~ㅻ:.{㻜,h<wJԻCnZNP4I"̻i윻Et`;IzхʺLḳ/-@\zo޺UV>Vd!"_>XtZ䨼f)$5\S?.kFMټSFWVQc"Jr|BQ'5N&ﻨr2FQA8砺jq"e8(:7;fr;dn;{;ST;;w;$$;uؚ;Z;,:Yu:ҵ9ں84`|8`Bֻt}һb&hػܯ箻M@]ƻxqpӖv1LyPno귻|piʻ{ U.,кՀ?
.1DOT}X=M`ap
绎tWλuqC㼻vwPBzrL(s뻑A<
W$W8e
vxb;E9 ں{º9>(8L՟kɺŮW
C/#6
i=h	z~Ǽ$.1E;9CֆK
SMԼ[jȼ_ܼ^PGYiT+LL\ʼ;rλ?.뺰Rں
OԻ%}:m;Od;\;.;|;g;`g;]i;I);S:ײ:Fg80V1Q|nHhl 廡bZN ظڝû!Ȼ*rӻV^仟ϻﻐyĽLz̻y8[}|.n]*H %2Lhh˻9PXOiU|jP.cOXkIxϻD38yeaKn4Ȼﻋf߻7sGrͻ~|л7|fqMjڻf^&^]L̻/7}
9ZY
nN]ȤùVbMG/sp}oZlϲ%m
Ѽ"b^.h:$BeGHڌP{UZ:bټea^]pPY}ͼQRB<1lx?M+KF_,p:;,l;VC;PJ;<;6;<9;5>};:.:V[n7b,/iQJJj߻ѥA
tokFGs|ƻ@F알eКu$˻OI|ujDл3e'H:pS=ZvSE:轻:G]JuE컂ȻR8{Ag9лSq.JiQc/vܻSw-e[;_jĮm_,cXVO&N	M?Dꃻ1N0RKl) S"~۽u\Q
!L޻ɻyT?)gƼ"&-B9XBgHNV_eP6c
^DZZXBPz9əvFػ _WSWQڻŽFk:5:V;
;W:;
F;L>::	98ú*#Ļ6*w 컗'%R`Uһ OP4rӑ1)ͶU뻯 Lxe[9Dǻ`tϫ`OVE-m&kAk
\X޻2ZKJUN޻:&!r2J_^j$ϻlgȻ]qM"޻;薻36-D)Ta
aoSV
TI=fw׺ZӺu̺S0pN*=8dٺz|j~(>G»ObƼռT!T+<7}BgJCMӺOSXz7YJQGmC^INI2L_*bĻH˻*G1Ϻ3%˸~79:9enN)ϻ1vi02ۻ+>MKUGT!tƼ>c*Ȼdٻ=Hƻ1k*Xkg=1j:)t ^&%w8tA3ƻ;*ٻ%Sisú:niO<  T=
adM)xWл>0(I-~-R( "ݻ %!S^ 쁻D
j㹺$º՛ﺓۺck)j4s?Q\"׺ eM:i_0c7VX8i6  ̼d'
̼8|gB2D=RiA컊້Qֻ|XLa@庮ɺB'QA5:ͻ>7;uK|Dm/xV̵䉺S(f!j ߻_Žj퀻Rл/ھP_ϺTBn:@ѺoƺYqkwݺ{b6
*1S{7:^dZf  ",9nؼCsIU<<
M:G|8W!Y
[`DH;.6q~U
ZP(cdr=rs<6t<^==(=F0=^?=f=U=)2<٧-<J=U(i=]=W=E=/g==i2===	V<\n;f<<2<
=5=nLT=}=pc=gg=nk=C=v=D===ݱ=st=TZ=Z== =) =C=d6=q===S~=˰&=G==&=;]?<7<< ; ;{u;];Y;;;q;P;Mx;^;y6;U;;w;~(;F,J;:]1:FA:*::$~;$;GD;_,;bs;S`;E;O;qV;>;1w;2;;;|;~;a;;mP;;;;;.;l;L;>;6t;#:j:,:8ᨹ;ObV3P0)ĹOcʴ(i0*%T㺭.h21&4yKк|&5Oټ vh!: `%\6hM{\צX*Aٸ'f
2)'&-Ҽxټp=REໝuc,Й:?;;q;m;C;;;;yx;zL;k<_<	<ָ;c;;5;̼;U;P;1;W;?E;?>;L);_}#;qL;zx[;ow/;G9k;rx:q:C09T:}:n::ܶv;Ы;:G;Os;K;7;0;;J4L;vX,;mT;!;X;z;lE;kpH;w;C;;;;\;Êh;;;;;w%;\);JO;58;::Zǯ9Tetm;hvz1Dq@:8m88|4Zej_!_,#ɐIvUȺ^lrxtI53ZggkлNo"{й;:£j:D78YNqx>I޺TM8:@:)
:9~:PZ:sb:e:*0:i:N:-u:I`:se:}:Y9)Ye4gںVK.(D>@hjB;	Լӿ.kۼBļMvH9v(dgie0]!ϫ`9ûֻaV*{4:;5;x_;;;
e;;;@=;;H;;_;ۦ;;j;f;rn;;z;%;b;/r;S;;;;:y;#;#;:”:_:z:Mb:D:|2;[U;0N;V#I;];=>7;;9;*:;[};vF;yw;uF;oC<;mU;wX;:;~;c;{8;˒;!;Uk;;I;b;Z;Z
;($)::[%9vgߺF>}Տg;K^9I:r::h:K::A:L;;$:X:6c:[W:߻:0:>4:}:>8_ğ4Z{]VHe-ʘ\XT->ÌDļ>ט2D%%׼S=e)ˑtwȻph;ܻd:P繻%޺%K9:;V+;;[;;J;;l;a;3;);J;';;r';Z;;	;`w;s;zZR;;5;-:
9t Qk!û%ǻYC;3%o甓iü;*&n8ͼ;57%Ҽ.^i#4dXһNjxֻEbc4)R7f5U!춛-a :p=;&/;tn;;;fp;;';;ٰ.;\;h;N;]c;a;;/;ق;;;;O;;VS:h::z;;
;x;;p:::":p7:W;Pٽ;wX;;Y;S1m;:I;;K;i;yy;;ʑ;/r;;;e;;݆;ˠ;^;6;õR;r;Lz;@;Y};$;:::Q8ª'VZ|D0ۺt}ʸk:O:M;;%;*;E;_ٿ;f7;Stj;=;?+;Y;t;z));e~;7:ᚙ9}wx&Xm;d.B1KzK׼L,K3Dq̼6'pȼ$4/?+@YJiE8.U!=nԻo=t,LRǭV&HѺ5Qow-RLr[[jY[yjػ&7~$W) R&" /Fn^w	GջCξ3lO;9b6'`>`\PҺ/ϻ	-+->:"a>1TI'GDUv	Ѻ:Ժ~OS7Q_כ&uѻ9(	*l'Cs6k6нd"X|9::8+!.}ܺ_rxSC\  BLp޻`?˼*J#H1	(зcie"ߢ,Լ.
*&ݵ#)jƼ~0)
d-uYMhP룻o?ʻ墺Un:=1̺6Kڻ@L$,ທ皺UDR["t%κKo]8iE!8G.
ћg<f2F^gʺPF9:.8:Y::s8Qaxeĺһֻ<lệAN׻[.l&53<[@aAJB3?C#s@?ϼ5Gl#¼Uͼ!6PG,ɼK]->!;!y{󥻬V:|㻟:@mN+oFLZyxWỻvg꫻yػv/Kuӻ#yEZ~*z0503-J(#|fDBkURvC;v9+3滦x|㻊'ĻoQ2]xyѡ*=ì9*_
9H9N8CRYªa}999臸0?󹺵xoT^y㺇K[9C3/*-b/B9f*:3:::t:w:ehwL(AKU2đ@ݻ_6LusSü	R(=4r:r;2;ȼ=>j8ļ)rYQ*搼?!K]IJ6$ښF黩&pͻLHYcfA7BֻuỞ$໭[Ļ|!}#uS-2+1.ā)\ټ#m Sf~0_SԼ):,ͬ5N8kUv3]o6dI6~tٺ-ڻB1){ӹ9
:M:4O9w9Rބ868ڲ9^:2S:s5}:l%:uaMݺaD>E&&4W2rKP27H%%9רf:uԅ::";q;gX:]:6q&qݝ
1I:z%ڦA⻂뻕A[maUܻ^Eh+ڼ465g6:7:޼12 ]"|6FTL߼Cq+S/
k|^_6鲻̻y$EpcZ$ +״CgMY껻׻XӵN	bμ&.2N3a0T+:v'&{$!=B	
UĻ])lpmCT&@}ںuTn3%`1~qAUJ?
VE9v:_:Yu:~Af:2:0J9f:2C:^:`:::7_VC!${ܺ0$p289P
97:9:;S];5;)h;J:vH9kbVڻcSxX㸻gDl`s)!jsf W.-31iT0497~+ּ2J/+@K+J^;#ˆ뻯Aew߁bdA^kjO:#i[IVk(/xnμ&.4d5͵3X0//H+d/$sd5*(ɻ:y`XEE3
W[-Z@a39MS$1UBV8Ǔ:R:C::f:g:X:Y:2:::I:]:e:e
|9(:PU4ĺ*&5X9t}o99p::o:<;	;$;1n;,y;!$:r5#ݧxG}{Si?m/\ݻ)NEǼM%lB//[%,\I-495(cv(DŽ9#"EJ込D.1YkwFrˆʻ׻30GBJ㻞uU댻件~c`,uܻg
 wݫh
xڼ~'/69V9:7:F6]ܼ-i/!OۼRɻ1_î@zPfhKC4'
hI/B*ں).a׻YJer:::l!:ˢ
:g:I:}:Ѣ;(;;];;e:M:l9ٺ/u8xG9::\::Q8:&;2;"h;3#6;2k;4:ʢ9d庉
Jl| L8伞7oKoʻWʎoshi(-9*(L-6ゼ;O5n1)8!ZB%	Ƽ1Ga>FbjG5={(_,r}O\|d\&
@vKrmsYﻼO%λʻrT
Ȼk3@̼s%Q9 Y||(b3%ͼ;_@CbEgaB7)=s	ͻڱ򹻾~)!ßWLZC)>ù뺳$2h}ԻLRĖr9Ⱦ:߾*;;:RP:i:;:7~;Ȃ;5;;;1C;!T;::OO)US|Ź9)7::GA:AvV:/]:D::c;	&;1ڼ;4wF;$:v:y=<>j`:ʧ9v0E97yð~/+¼+:()>=f=$<<79Ų
 FcO۴K=z=qD=pl=|r====qS=s=ꖱ====X=ﹿ=*==$=%=ԁ=ұY==ٮ=+===Zj=)=[w===3==[=׽=ѐ=GV==5>i>	N>
>	A>P>>	= =â=M==FT=P=1=	N=FC=
qe<5<3>r>>d>(>,>%>==C=2=
=L='i=%=3
C=4=;>`>c>.oG>6>7>5
>0>%ͻ>a=f
=}=.u=8=b5Z=N~=YC=c=T=.'@<<˕=J=d&=ذ=߲y=J=U===s=B==Ѷ=>>y>
!==$=)=F=0====Ҙ==Ű^=|======_9=?="=%@===#==ʹ===hT=F =L>>D>*>,\>D`>U>\N>[MF>WN>NF><>%W>"=tM=ƉL=Ȇ=Y="==F=wTu=A=^d=E[=ly=ä>>&>$>4=4=?===~S>>\>">$n%>a>z3>>=o====-=0M==o=E>U>&>q==T=1=[==rB=w=l=:=]=h==?=AC=82?=E=f==r>1=]>2V>6>E>`\>|->	>.>j>>ui>]in>B>(>=O==@=
=U=2==b=J|=h=ӰL>$u>Zn>n6>[6>6>>
>4>0D>>'>6>@>@
_>:B>3>*>>>=>>
|><>>P>U>ܢ>D>	=='=du==[=$2=~|=e뻵λʋ׻$00n341*o=3!0[	aG]8Y:C;NO;Z;;;xa;s[;;L;濉;Pb;;ɐ;LJ\;΅;;ǩ;L;ťx;;,^;wo;8;T+:j:8:(QYɺ
zZ_K/:;S;34;BxU;M;a;[;;{;y>;k;{B;ź;x;;H;[[;/9к~x	.4Lmm.ƻJ-S뚻^߰C"
+ּ
).-,Ƽ$ÃŻ߻؁*»`XʻԫT-}ڳxo-9:[pe;K;qa_;;0;;;k;,;;N,;MZ;&;Yl;.;M;J;:;N;>&;??;f;@1;:fV:ߩ:;;;;6t;C;9&;";W;e~;{;@;J;;;;k;2v;"a;=;b;|;jQ;;};?;$;;;1;w;ɫ;;;u;ÁE;K;ӳ;Q;;+:Ⴁ:9`E-*ۄ~0}M׸2:b;\;T;n;w{;ؓ;;;;9;;W;'_;l;{;;;~];9{w]->/»Y4ػuɻbQ"A9#΢PZ]dl"'쀼%Q	Ю0v7ѻsRf
/) sx5Ow`D$9C:R8;FJ;;b;+;o;;;L;|;𧻓;E;;4;;^;+;;Ε;t;`H;H0:Y::;
;R4;'b;A)
;YJ;YG;=T;#;d;;FA;t
;;S;k;um';]D;.Z;
#;;:D;p;;C;&;Ð;;c;c;|~j;);";;;;E;;܁;o;EE;;;X;;q;dx;;;QE:;&;
;o:Ը:0W8ߺiù뙸C:yh;%;;;R;%,;;K;;ي;5;b;
;-;+s;%;;-;2;,;.:J!%|n%Fv_a|=뻍MrRFûCI
޼\@.Xsmu.,ƺ#	9\+::V:҆98u'!9:j+;>(;;K;;;k;,;C;ā;a;d;|!;;SO;Cg;U;;̗;;[;W:s_:#;;A;\;q@;r;b;}X;K;*;=;";[6; ;`;;j;8;;;$;Hg;;&;?G;q;;D;
;;d;%;U;2;;R;|%;Ȫ;";;u/K;B';+;`:V:P:L9_9Z9
:;1_g;;;g;V0;;˖g;2;}:;m<v<\;և<]<<	)R<v<%q;;];W9;=o:w޺ X;u;;6;;];;;;b?;>;;4;T;;[;;;b;?;;c;ؓ;`;љ;͎;±;9;;gd;;Jբ;>;)w:4::I:7_:u:;DAW;;t;;컎;3;;%a<<<,<<=<#o<a<]n<N<<R;W:;a;S:ֲ	r)MGeQy˘xUgf*o!"4I^ttӅh:i:R:뛵:ޯ:M:':gz9:::;<;a;
R;ذ;$;v;6;Ѝ+;X;N;Ng;¡;
Q;Y;;#-;o;F;;];5g;,;K2;|;P;Ӽ;;E;o;c;PrA;.;
?;);;[n;,;;_;1;;;|;;0T;AW;;vY;];;]B;;;;);};ԉq;;'Z;i;;~;k/;;;t2O;j;`Z';?#;
:F:(:K;:;cʪ;=;#$<<В<U<!<	<5< O<-D<2<1|<1`<2k;N@{;s;;^l;r;E;;U;;e;:;K^;Tj;R;;;;3;;;S;ۑ;;k;q;;Ž;W;i;;e;;I;dS;5:; :;-;TP;;;K<R<e<C<<ٺ<"qd7+t&]+>j5
Ӽ>Cj9BG7c!.߻|] 5 á[Gq]TDt?໻$	
|%{p

 ,7怼A|IݼONݼC䦼2 wrgٻB6?»
廥)kepRQPfn7ccWl12eD&U*"':;;;UD:֭:ܣr;;-;LT;W;P҃;ET;8a; :(:192s9u:C[:v7:q:U:PY::;;/';7;);
:9Vc<8p:O:l	8eġ,^]ęjdb:?bo=1츼,d~˻bRћo-sL(R	7껵x
ٻJu	k$̺Fżɼ$J0w=J='TTX	Q?@)%Z|1(a.KB.vqoޕTPZEGD7AX]ϺutSu3/㻅4wBlg:;f;7;(;;,;T;~;v;;{u;l;fm;[Z;C;;!:::24:;(:}+::R:3::"5;;,;DՏ;@A;%G;::^9jg79^:S
:%:s:k20FgTzUUָ+Ү^!)ܘ85YGwNYH$i:/Ip(Q'#*f21f9c6c&SػMƻؐ1D<ӑH9nỸtǻtGLxi6׼cgEԼ.=nZh*$
-;LM]el\qF1-(	lƻK'm=eWB*1-UA$F9!źCmS	\#"ﻝ{yQǻN9'9;i;Ak;Ks;AM;H;l@;_;;fo;ۅ;ڿ;sq;mc;`u;Jр;0;^:@t::⒚:ز:=:::`;;3;On;S[;:;::`y:`:w:@:_:=c;:I:,AɸS'*X
0#͈ g|n#/@sNyQG95,¼$q )$.6^0q:۠:iW%22BҏĈӻ`廦mɸ40L(;◼<" 0G뙼!μ',0ף@T
e~[gw¼W_>`м%! kҐYET+V-
F
l.E3h0Ⱥkuxλ0wo=,:P;6;d];i;m޺;M;I;;J;<;;;t;;k;^@;O;?K;);ޕ;;:&:Ϊ]:ܥ:(;;?;^T;i~j;W4;17;c::(:w:::;-;Cf:Q9q
KErs廭c˒zֻƻ(ֻwsj+'ME'q6$H:yR̼PٵEƼ60(5+P4߼+M"0%*Gǻ`#߬L=>٘f kzGһje@ż $5#! T!|#(3)FgM\_iNePo7b!/HN>豻E
Sjֺa1uP򫷰-/B+Vwλ@o຤
:-;;l;;%R;|;&;
;ƽ;;J;;Z;o;c);Zi;V~;M!;>k;0E;$
;;:;;(;Q;rm;;w;T;(n,;gA:E:e::vk;;;)S;:th઻h_=ǼM	󻱎h}cQٺ,_ݼ=yMmSN~A23ż"3epʼ&&"lԻ׵ݻLI֥v̻~c6	>9!dG!@`%DҼ&6%{b#I#$ۼ"#P(޼6"üLati_6J)221
3Ħ/Q-t}	/~ʼHq4Hf
Hܻ^bPܻݯϻĩ3r{ܻ.>	G\F"I%i'(LH'a%#!!'8P~4c;̼f[YmDP/sUvէ>)8ObD'&f::B:p9Zm}/B{w:=N;	R$;h;x;;1;';ݴ;4k;;ۼ;æ;/;&;s*R;]
1;Y;g\;rs;ob;eY;UP;Ba;12;2p';OB};";;y;*;vG;|j;IB;;:I:d;V;/;?;H;>;
:'h^߻P>ƻʻw)q,޻-ǻ8=墁=_>==}={"=+=|p=A=G/=}:=9@=^^==Ȑ=={="
=`	=N=ڰT=Ӑ=|B=~F=ڞ=݅=ϩ=`===I=/=u=ʋ#=/y=v=1=8:==+=%=t=K>>l>>2>e>[=s=h=\=>>>>#\>*Z>+R>$>>[>@>!J>*>ok>o+~>k>p>>x8>>-h>:>l>a>>>k>L)S>+>o>=h=====$=P=P>6>4(>>,>`z>@@#>3>1Lc>42>>T>M>\>cZ>bq>^m>V))>Eڑ>/X>H>v>> $>)H>.]>/u/>/>/>->#/>==J=N=`=_==&=x=b=ѷ=DZ=X=oӟ=0=/#=\=hC===UR=/=$=.=?\=Y=i=
=]=9	=5
==|=
=ܱ=>D=ċ=Ѵ?={>%>>='P==={=f=آ=!=ܷ>q>&Q>1>f>5R>7>7>5>+$>(>0>i>*i>A>U<>a>i>lL>g;I>\>Uj>U>\>g>v>ɰ>\>>>3H>Ԩ>>!>5=>>B>+>b8>x>R>8.>-Qe>)Xt>!>>"h=9=O=̆>>Csa>>>VD>˸U>r>>g۬>[/>W&>Z@W>e0>wG>\k>k>b>$r>u9`>[>?-)>.Y>-c>7>B'>I>K>I>GƷ>F;>=>,>r>L =Kq=;==y>>Y>V==8==}=p0=S!=xGS=<==S=h= =k/>>>&>d>
>ǯ>h==>Z>ߘ==(=q>>ܨ>"S>'>{>	==y>[>
>#Y>+>:d>OF>bi>nO>u>y>xۦ>o?U>^/>N/>KL>]]>Z~>>
>>>>6>5>L>>>b>9>ۀ>4F>?w>>??3?_?3O>,>gb>`>ŵ>Pm>>
>n">cD>Xv>Ew>->
>>>Nwt>>?	ɱ?
W>밨>R>r>p>>z>p>">z>>>>z>r>hQ>Le@>B>KG>Z}>d>hk>e>bZ#>_0>Y]>I]>2>>z={=n>Eo>>>>	D>}=J1=֔=T=W-===3==}>(k>#>SG>H>s>>">$n> >"e>3>
G4>
J>
">K>>7>2>H>T>Nc>8>=>(>,>MNY>dU!>l>s
>M>>C>o>>#>FV>í>>g>>4>F>>(>ۗL>L>]>]>̐>bY>=>??@F?
[f??xT???$?!v?2
??		?
??>u>>*><>>&>>f>IC >39>3Q>[6>>?sw?-0?l>r>o>R>hd>>$>x>@>]>p>P>T>x>3>n1>Y
>\%h>mR>}>>ڳ>~?>z$>tDD>fi>O%>3lt>#>
>	}>+>y>>̚>>b>>/h==2G===k>	>ʓ>f>
>>&>*[>->3=g>:%>9{f>->>͜>>>A> >3C>PH>o>lb> @>q{j>R3s>@>QMp>~%z>8Y>>;>>6>$>>>[>Ϛ>ƙ>>s>>a>H??
??
P?
.?V??Z?b?@?
?7?1?%?!2?*0?9La?B?AP?;U?6]?3?,? I??>~>>.>>`>>>da>V`>k>K>&x?g?B?D?$b>X>N>>>4/>>3m>x>>y>o>̈>>~>r9>iG>x}>>nx>{>q>R>>n>kig>N>2>>>[>':/>'>>>`>i>J>D=
=X=.=0>>&m>)`J>)8q>,U>4><>B4>GN>NK>R=>J>9>+>%/[>%>(Т>0H,>DB>gW>v
>:'>y>>>o1V>t8>v>>0>Ζ>ɡ>[>.> >>o>>U>>N*>Ҝh>8?}??'ٰ?/?0V?,i7?&?#[?$?*Ϳ?0q?6a[?Tګ?H?>??M?Ma?[HD?^c?W8?O?K?F=?<?.?7J?Dy>,>˳>i>>>\>|f>~>>>m0???E?[t?G?9}>>:V>>ab>xl>5>L>,>>?>t>>]>=>uJ8>|+<>F]>>m>5u>>>_>>h{U>J4>1>$>'`>0>2>)fj>>>"f>$4>(>s=а=)=>J>7/>>_>;>:*>?m
>J
_>T 1>[ O>a>>gdh>d[>U>B>6>3y>6B>=>P3>uj>x(>?>I'>xx>1>k>>Ί>Ɨ1>>{>L>>>?7G?T?=??		>$>j>?
\?#?:P?I)?N?Ke?E9?>u?=%?C>9?Jw?R?Wj?m?e?Vn?P?Y.?h?p?k_?bc?[?W}?O?CN?2? ?~?D>&>>o>>K>">>gt>??6?]PA?]?8'?
3>q@>)>>V'>!>>>̟>>;>^>J!>Q>#>yVY>>7>r> >$<>FO>X>>|>_ŝ>D>3>/>6>;>3>%I>>!s>(]>&wq>==|=ƫ>><>N&>M>HY>HE>R>_e/>j>q>wP>y=>oTT>\Y>J>B_'>B
>IZ>Yi>{:>>U>e>>9>>
>f>>?
g?U????
6%?=?\H?z?7?????#U@??J?U1?aJ?b-[?\"?S?N?Q0?Yn5?a+?i[?rI?f?Zq#?[}?hW?tHd?tE?j?a(?\Cg?V4?LQn?=?,Wj?6?	>1>q>܎7>>>H
>L>s>b>ߩh?d,?I*_?])?I&?.r>&T>Z>ݓ>>g>>>:`>Y>>d>܀>(&>>s>|N>b>>H>T>V>Lc>1B>C>nB>Td>@$>7	X>:4r>?,>:>*><\"b)Ļ.-;;ň;o;;辐;ۃz;;M;;ʹ;;s;>;)k;;;^;ۧ;;;G;f;Q;ϟ;y;;;|;;(g;hb";@;>;X1	;y5;b;Au;);X;x;B;U@;e;x;D;8;r;̽;\;;1;V;/;';F;);ػ;Qf;`;m;@0;Px;0;;@;%;Qa;;z;}$;;$;<<Y\<(*K<1S<5 <5R<7<4<,d<|<d;ؽ;;&2:9VS2;f_k/	 5aλ6}⪻&lB:Q:;=m;o;}f;jj;Qm;>\; (a::4Z:	;*;i;Q8;=;;~&;T;8;
;";N;i;;A;/;ݥ;;[;;;<3;L;pD;y<o<<
<M<,;/;;>;t;jp;|>;ZJ;;IQ;C;ϸ;;;*w;IJX;9f;;u;y;ۅ;f;Un;k; ;;<U<	$<
|<0<;&;ɲ;q;I+;;ݐH;/D;:;0;a;\;::;<C<&<6q+<5,m<$R<
;~9;>;De.:g:x:&l]9ȥ'10'&}h杶'eUûoe!B:z;a;];\;pn;;?;h;O;&LJ::x;	U;pG;,;e;kB;c;L;;Ϙs;h6;
;;;A;;Ț;7;;;D;a;10;<`< <(4V<*<".=<
;;;S;;CY;p;i;;;S;6;K;P;g;>;AK;⇻;=;O;ܕ;J;8;N;7;lg;M<
0M<~^<<J<<)y</;K;K;!<3<#:<;;;)<S<$<&rU<6"<@n<7l<3<3g<5^<5Ǫ<6|H<9G<
-y<@u~<@.4<_};3cRy+wјvLLdJE5:һ~13bWڻC$(1'ۼ(K**Ƽ("9Ҽ"'=ɼS'_[sMK:#nֻÖq^ʺ֎mq9K9
"9608J:E;Xud;cG;E;Qb:Ȧ:3:8;::X;@;;;9;q;׮;Lq;"Q<T<;;;;`T;7;;qƌ;oBP;;qr;;;;r+;n;;;G1;{r;Z;H;w;-;t`;>;;;S;0;Qf;e_;j;Wi;"ǒ:y\}:#f㻕;IM,?ڻ9Z4!¦-*9;]G>MLB
x,L뀶8Aǫ9*׻ۻǏkP.qxܝmǻ}k3(M*")$A:42(Y?-S1ZTLD`0Wϼ#8G
1d92:90%9h94R:a:>;;1;;{%;x;Dg;:L;!&;i;;C;CY;V;|;;u<#<^<>;2;=;;u;;&k;ҍ;;^;C;;;;!/;`;{;ܖ<;s;b;X;;;q;@=;!Ʃ;F;/;T;sl;d;u;L;M:[ml8nx@;Zݻꁯ
Ɩ$.Ӽ<ѶH}LH:Ƽgۄ`3ܩ̻/"#eoA+95Õ5a+ǃ}Km=-}.U׼)'`ͼ(Ѽ)&!qM
(
*@ePȱSJ9;"\SLv8^9nY:3T9
9¿:f%;P;_2;;y;;yQP;X;`X;2C;g;3V;V;[;;䋚;
<%<J<ĉ<r;1;\(;Ȭ=;;;;ɞ;?;0;;;;fK;S;U;q;;>;1;a;f;s";wչ;O>;9";;;X;x;/x;af;rh;7C:67K6Nrjһ elȻ$4\`۝ϼ[<$䔼0{l?! I3JRB.ʻՊ.d/!m^˻ƻ{ƻ"p00%,':^VAS$#,1T}-2'%&T%p Ӽ1:
bz,03@߼K-jH?*=D[޻ܻ䤻»y++CnGWໝ\ɻz)/,J.m(w!CPY׼ۼHl:=
#&Q*rǼ31#)2r	xFz
)vMO99T::x;$;_ ;գX<M<
Z<|;;6;t;
;^;NR;&;_#;}8;W;;u;ot;h;"<<<
 <y;֚;ن7;;ܗ;3j;4O;eP;~;ة;j;أQ;'w<
<<h<
ˀ<3Q;n;a;X;;;";;;$u;;T;u;Bz:	<8<K*vs)9M$5qАQl6	&.ټr"*1[?Dw<,r&b廢<ŻԻ2V"Y{ѻ(tnzŻmKbûvI]$6)EG$ 9'μ}
	.?!9	#&#!.nm盻ax[~0U:p;Q;>F_;;Й<<<vT;
5;;@;풣;";;;S;tf;݇W;ň;0;&;<$R<	d~<
`<
Z<}i;~;sg;B;m<2L;;*;|;;;_<
<<	<<
k<\?<,!;;M;;Z[;z;D;Q;р{;0;Ӱ;|};1Nr:~2^t)4l߻%& di+˟>5L>$ݡ>(>q>
H`=M=>
>1l>PH>Z7>T:>PMs>Ur>c>q>{Z>1i>1>X>r>^E>QZ>NL>S>`!>{>7>>>b>>n<>g>r>Š>o?-??aP?
?	
?}J??o?C?Z?,??_j?o??3?O5F?a+?iG?fb?^6+?U?THs?Z?b?kc?sO?k?f?Y?T:?[r?h$}?m5x?f?\R?TT?O?Hjj?>&>B>h>ţ>?>>>>;>p-?&?F?Fq?%A>o>>М>>2>'>`>d>=>>>c>Y>T>lr>g>y>VY>o>>ј>k>
>>s~r>]2/>I>=_><"L>@K>>>/h>]>2>>">4>Q==ׅ=박>*>@>Y4>[\X>U->UA>_E>p(>}>>>Q>t>n>^F>WG>Zo>d0>y/>$>>q>>M'>ӻ>#|>>&>܍'?Ѥ?s?~??
Wp?;?'??[??>??,>L?i?۝>܀1>>_>K>>~>>P>=>>;?!F?/b?K>_>&S>l>>U>>>>(>:>>>>>d^^>T>Y@>n>?>o>[O>>>A>n.>\>M>B>f>=>>>=>1
>TY>ԏ>:>>>
@r==ɻq=ݤ=S> >F#P>V$>TV>Q>X
	>fг>v>>>~>>wt>fL>\t>]V>e>u3>)>8>\>ԏ>@>قz>>_>2>>@?	9`?	?3?.?>?y?	y?
?>>"~>vE>W>??-???I^?IU<>ӟ>la>{>>^>
>	>i*>_>m>>o>8???>
W>>F>qf>c>_>g>fq>|BP>#>>>l>i>tm>X>C>=*R>GZ>[D>or>}$>>y>m>^>Q!>H>B>=>=5><+>2A`>>	SJ>7<>#?>Z>'=\=y===[>">Aq>K5>Jz>M+>XI>hW>v
>}>j>>wo>hӄ>\>Z4>a>n7>>>w>>>C>u>m_>I>e>&>_>-?k>>U>3>U>Q<>>E> >fa>b>F>>ۆ2??c?$D?)k?'G? ???V?%?./?O?
N?	d??f?O???u?>m>x>,>>>1>>m>i>uN>_>K4>;]>:z>P>ء>4A>(>ٍ>>~>x^>Qa>C)>>Ji>@i>Mo`>f>qV>>m>>{5>aގ>I>4M7>&HP>%>0Z>A>S>^8>]>T>S>H>>>;>;">:g>:5>9˧>2>k>M>==ʝ=S=4#=xA==z=}X=A=>,>6>=o>@>Gy>T>cK>m@>q=\>q>m>c2>>WMK>RS{>W>dl>uI>n>$>eu>"o>Ŗ>>J>>+>->[>ƞO>!n>>L>Jd>+>>7>b>y>>N`>>>>>P>\?:?a?>:E>>>?^?J>E>)>ՕB>Gb>?>.>΢>4$>>e>ʳ>>>g>i>>k3>\>QZ>F>9f>)>|>\>1>-Z>W>|>>G>>R>19>#j>> q>'$>7?o>Od>e@^>l>a‰>Mu>8P>$[>)>
>
>s~>'"g>6X>=>71>-O>%N>%n>,>39>65<>6|>1Qu>!ʏ>	0=!=i=-=a=ëB==m=;q=L= =X>L>*4>0>6D5>@>M2>X`>]A>^8>\>U$>L>Fc$>I>U>e>wƫ>2,>;>>>
>b	>>`>[g>vr>>'>d>>e3>l,>>>%Z>F>o>Jޞ>/£>$^>.RN>P;o>Lh>>q>'>`>&>[>n>3U>>>v>B8>\>>@8>>$>	>#>>x>H>>a\>F>2>%J>>5>>=4=4=͇=>ì>$>A>M+>?D>$>|/>>~>4'>
w>a7>#->7>FD>E>8qP>&o>>===N=[>
>>T>&>
>>>%,>.p&>1F^>/>#(>
=j=0=ҧ====W{=o==9O=^P={>>F>%{>,r{>6Z
>A>GT>H>FP>B>7>8@H>Bܣ>Slx>d>v>$>	C>=f>x3>>x:>K0&>1R>1C>Eg>^>oL*>s=>p(>m >n>nb+>f>Q$>0>:=״=]==PE>5#>)>P>oϊ>>[.>>}ȅ>$B>X>`>>L>V>]>h>yh>>>
>yOe>p!y>h>]E>I>/>S>pF=o=
5="=4=K=E=b==X==x=O/=i= ===Y=K==-=>lq>>!t>(X\>#4&>&>O=~M=ћF=_==>4=Б=[$=%=Ý==Ē=>=>"M>)|>*>#K>d==="==^==M=:
Z>7>>f>!}>)>1`>2>/>+t>(o>$2>%7>.'>>%>Q>b#>p>>>>Y>k>>}->(>5>r>> >)%>,>/@D>3>6>1E\>s;>)==pN=Qz<>[> -U>#(>%>'>.4>	>s> >07>B>M
I>Kz>B>:`>5v>/~>">
{=YQ===<=S=@===|-==Ƣ=	=[=1=]8=f=Q=x=O=a=KT==ȯ=J^=#=>V>c>
>h=A=Ҥ==,:==mY=l==
=օ=LO=h=s'=<>?>E>"RZ> Nl>m6>m=ʴm=;c;ֳ;E;.h;0L;T;
C;g;@V;͟;Po;C;;;d;ZG;A;a;<b<;;Ls;ʳ;K;/);9;Ɋ;d;Ҹ;#;<	9<Jz<%<<_C;کA;X;X;#;h<<Ex<<<Q<-|<5u9	< <
S<;ᯱ;AD;{w;e;qh;;;;;A;(b;;g<A<8<*<:;%;c;`;Ʉn;ռ;Ѿ;O;ᇔ;آ;ҙ`;;yY;{Y;H;Q;B;ίL;";ԉ;;;Z;̙;;J<<<<;;;;;a;	<l<<<<.<-Gx^<;<k<(A5<&<T<<h<@<(1<'x<<F<е<)	S<7eq)<@<9=D<14<(;$;r;蝧;;u;*;;8;~;]8;'t;;:%;;ƃf;H[;m;O;i;4 ;v;;k;*;q;n;<;5;i ;J;;ގ;H;L;Am<<.n<1<	<"<<{<;;<8<<Ǚ;;{;ߵ;L;}m:8I&ι]G	O*^FML::`Jd:P;w;v5S	@r
2G>ٻdN֙d"ʼio
1	r;FI}л
h1S%?λ)Ȳ:Z8c":sO;^&;;u<M<<<"b+<<J<<<	<<;;;:;;);Xq;Z;B;;<&<<
:<<
<u<W<q<<;;C;x;R;ܔ<<<
<[<"9<$=<&O<'|<&<( F<*<#0< <`<mR<q;I;0};٥;;h;O:~8ny	[q<HI<;<_<ɡ<
<<<<;};.<!<<V<<z<<<c<k"<$<tF<
*a;V;;ˣ>;<j;<5U<H<<h<a<
J<E<?<{<<f<$<%<<<+&<><N<b<k<;z;+Z;};H<<
V<<%;<'<0<9J<>y<@eWE#9>һlN绛%Do
U\OI>θ6 3[/oSͻ PwRg=(#		:;?c;G;௼<<,<6\< <<6V<(<U<	<Yv<h<O<<<<i<l<<B<K<<<ڱ<
J<<<~<<`<;<&f;꿋;w;΂;Z";<<3I<< U1<*<5rO<<<@!<5<-<"w<><;m;;;;;;N_5;	:K72=O=MtҺ
8Ժ==
T={j=I=U<2<<\~=y0=ƅ=>	]>
a>y>>>}>D>G2>>b>>:>'>O\>f^>r:>|I>x@>^>7'>?=k==ճ=/=ܕ==&->>	>	l=
/=L==A;xOpޞ^廚d<"=?=l=}=l=a==ɀ{= ===^=;="=->>f>#G\>>J>GC>tC>p=*=K:==v==v=iO=j=f5=F=
<<"K<7<B>s>K>Ы>a0=B7=Z=
=m=h{=IǗ=,>ݗ>>L=><>	>E> =e=?=>S(>M>%HS>;>KH>T1>[b>c4>c>S8=>2>
2=R=J/===D=]==K9=b=׌\=ˌ=h=RD
<Ǽp[?GR6J9Pi:<^u>$=a==K=iP==9=0=t=bo=R=@Չ=7=4{==!<8>
'm>+)>6W>e=T===g=]p=K=M`<|=#=:==O\=ݚ==7==φ==~>>$>8&>D,>J?n>O(>R[A>I">/ݹ>Z=8=;=w=RU=D=P=d=R-=e=F=M;=L=>Z<%;5zk^#$Fd2uJ缿UǼ|Y;A>>JZ>9=B=̖==vR==\b=Nc=)<ܒ/S==ۥv=͗"=͝=Q=í]==z=6
=i==C>1>#8>3">;>@(>C>@>.Bp>}=*K=b=R=O=*u=$A=0t=D/=a==Rp====R
=;H=<=9u]=(w1=
=
<۫<:&~дw?`X"ͼ;1H
>0=ٷ==j
='=}=v=!=%S==w=J='>
0><'>*>1@>6|3>7>,?>=?T=¶==l=8=!="=.E=@=[ư=xb=t=@ܼ߅t:EZ;><{="=V=_=S==S="=Y=(=oͧ=P=%:>
L=[==.=X==_=o=`=eH=xFj=6=P=,q>	g>-> >(>->*R:>>A==e=<^=[=](=8O=.E|=4===J"=]=dv=Dr<<}C$kM-Ar)2e=T[hycbнH91#rSO:1a<ߖ=/[=wR=P=Ht==g=ې=@=NA==sTh=FHS=%6=$i=8Z=CP=6H=<`<#;}żP;ۼc|5:#<1"<Ư=#=fST==-=?6=J=~=`7`=N{=9^=<*<<<-<1<&<2<|(+<R9ٻ7<[S=,r=g=Ŭ5=R=	===='=i=r=Z=.<ѣk;0giuL<=!=>f==:=~4=]=`P=\=HD=6=5=CI=]̕=
4=Fe=;>)>_w>rq> >$x|>>=o===i=]=Iu=Ia=O=Q=U=Z4=G=<J%ڽ \꽀K:}n_JZRknk	{sUX^:E<$;<|==^==^3==:==&=/=w=cC5=>=9w==(T=BL=GH =3X=A<܌<{!:|Z[Ѽ'(Ѽ"z00o%;LN~<=X#= =3*=,
=C==ߨ=?=s==jv=C\=<@Q*JSB)]'====>=ʑ=h="==!'q==WT==e=-=N̩=h=f=>=>>>#>)>l==8N=I=x==jO=d=i=h[=`\%=Y^=JSh=!c=T=^===`=u)=_=Pz=4t=>==Q=4=KŴ=Fk=+=b==(=g=>=!w=B
=<<<&{;;;_;o-;dN;hl;~;;d3;;ӳ;9t*;4;;J;7;!;PV;R;p;;;;a7G;*m_;+;7?V;qyd;;Z;^;)t:I:TQ;	oj;5;kt;; ;;,;;L;;:;[;O;h;[-;l8;O;R;;WI;]<8;+i;0d:E9MiܻTL3kG߻z⻃㻨OC3ܻ;^:J;@:N:u:Z7}T8Q:;:b;
;5;;UEP;rw;j;;[;;];D;^;_4<a<
5<;V;@(;S;l<<.<	<h<x<<%?<3+<<!;Q:x:w*:
;S;4EJ;h'q;;ֹ;о;;b;;
;j;P;37;C;*|;O&\;mUx;p;Y;/1:uh:1:<%n纜-MCr0	p0t}zٻv釻3Kи: ::<-1^X½9):"Y;k;/v;T/;viJ;2o;w;8O;ɮ;Z;Q;Eh;Y<|<=;;O;;R;w<<i<PP<<O<<*~<4<:8[<:x<2Q< <
c;r;Y0;;;;1;dEa:d3Ijź-": )s:;)Th;[F;t_;x;w=;o{u;_ٱ;L[};=;?u;F3;/:w:|Q::;|;J;p;y);i";P;AA;DO;E_;':ߚ::U;:;,;;^r:Z :7':Γ:ߵQ;k;0;d~;Vk;;;-;x_;Y;=g;$:;	:欂:;;=;JUq;6x;
:Gg:9$HU>ftHBb@NcP:$8<9$o:^9W
}~"E&9a:;Ӛ;5;[;zGG;{;;;;S;,;<f<<;;q;;e <<	<0</<(<<%C68;`;xR;;o;;P;~;<<A<L;D);z;= <<R<!5<ݞ<q<!<<"d<+@!<1&<4?<0
<"<<Q;;9;׽;.;`?;X;aw;I:DNb=޻!:ҁ::ꦙ;(J;[N;};;:;j.Z;4^:ۊ:2
:::u:La:jm:,; ;;;<\;+F;3::H;Y:s
:H]:/:A>::Ɠ::o:v:::^:C:@;#Z;N.;f;i;Z;;	;:2:E:[(::P/:};X;f:Ƈ':?vumR^̺Ẫ}P*8	Un|>=Dl&߻`=}
!ɓi#Ѻٻ%PBʟ -i:<:^;;AO;];r;,M;J;.;1; <;u<{p< <`3;;<3<	<
g<<+<<[<"5<(*<.<2F<1M<'<p';;ӯ;q;!;d;Fď;L9I;Rc;'Ã:pE_qλV9&+:v:`;;:;m˲;t;;J;M|;:::Ĭf:ϓ::::;4; _;%;M;Y1:::!:%::
T9m:J::z:Z9:-;:R:C:?Cg:zi:Ս;$d;7;Ik;J4;7z;:5::
9z9}:5:::\~:"ٹiKCr#L=7QUBuav`!⍻]0溺-YoHIߣP%,:ɡ:;;?l;Xȱ;q1;;U;q;;L< 7<Ѻ<U<<*<7<<C<?<~"<\<"<#F<%x<+<0<2
{<-j<C<	;x;I;;{Q;G;8I(;E_;C;	9؟?̺
0:S::+;;R];RS;K9;n;f6};!mh::b::#]:o:H:V:;;#;:UV:ɿ::LD:::'R9f.9=:J):ME>9ē8=f99r9s9or9݄:KZ:*;;Z;08;/^;o:CS:oS9V6Jak8:.:::#\vþ˾bqwf6J]m%	.$\qRBn12O׷l޻:wlbSM˻cnvv|f9W::Ќ;n;;8u;X*;x=b;;;@;(L<G<v<<{<F<N<ǭ<<_<8ur~M{aB&ݻ%)Oݻ#݇.\\{ɻVY3X7W:2rP:!:Q;S;=Z;b";!;8;q;;;;
<<<h<X<&"<&E<#<#<&W<&-<#P&<"~<&m<-w<3<3*[<(hT<Ϝ<;׹;;y;?V1;"N;.;@;.:9H~80FKڻ4	9#t1JQx\PZvntby뻒𻎪5{l]䜻SqNΖHXnW~$̒v㻖kл:eԝbݻaͻa8)kA:@;,߼;d-;<F<i<2N<0x<$<<\<"<<ɢ<E%<<<<n<P<Gz<<<<
W<<#b<1<
}<	,i<C<,<b<6<KX;M;P;;ԩ;;Bt<<M<$v2;;(;|;;";R;8:d	{9c~8g:9]$Xkl6uKNZsaxǸnS8̟ws[YbvһKƲn̻RQKJQ0EN Mpk4R߼wHN<Y;mA;;۝;F8;ۧ&;\;;۠X;;D<<p<<"}<0E<8r<<<1<8{<
;;GI;Ud;r;;;I;K;Dc4:ָ:`̸J&:L:mW:	:#?U%.D⻌*]@
z̉*k
^3쓻RWŻ-ү+>7LJ8|2jK
%R&%@Ar큻h汻	w廕1+f&C2lѮJ}'|:w 7tF
Źs:&G:';N];?;4;Ud<<5<`<F<<<&|<*B<&<"	< <fe<<9<w<%4<+<J<
ڇ<<%<-;;zq;L;;ۈ;j;;ٴ;gA;U;;Ӥ;ާ;;E;m<<<%<.O<3<<!$<.R<<1;k;;R;};;[;.;j;n;1v::,s:0:wY:::G:RҺtkYv߻ỖuE?Hꬻ5}AS	k.G#
Z>^[%Uv x񂕻*{R,bjRwzg»AǙܻIH¾c]򻦾_{ʻWl	庞<3!-8Iz:;u0;gZ;s;;u^;'-<<Qx<	9<\	<"<-<._<)h<$< ݰ<<
<C;I<R<5<<<{<
;*;̸;;n;;;;W;oq;;j;G;t1;Δ;$r;;;hZ<:<j<n#<"I<**<64^KSu޻a@c7aۻk|Kr]#뻠~/K5߻.,a!Ⱥ5b@e9Ц:;K;{cP;;s;b;al;^;J<
[<8<'<.E<,~<(<"Z<`P<<;95;;3<H<Vq<bN<Ô;
;};;;k;;;,6;~;l;;V;;u;a;,;b;i;դ;p<<:<<\<t<k<(@	>q;>t=d===\=Cx=z=7=QI=.=y=e=QM=/H<=i=K=<&=)=
[<=<>)e=|=A===NT=0=L=)S==Rs=~|=`c=?}=H`5b"E&t8;Vg)"ZV:$ｌVaq~9g:wsq=!=lN=Y=yc==y="=b_P=:˔=(=[=3<<=
Y=1=M=N=9zG=<<};!_V2s%]eҁ;);o<$= N=L=[qH=Ow=2==o<<<E>6-na3<(BM=
V=I2=OR=4p=.=v=.s=Qh=kE=i=EB=< sYn
b&ϼm;=:=Vh="7<@jy:,b2:?R\;!<=z=`L==j=.===s1==#== =s==xK=Sf=,˥<@q<;_ļ6U䢽.86>hEkuŽ[^w
?w`<8==W=2=D==t==_n=.ew===Z=M3=3=?==m==	=	<=x==h`S=*8C<<ҥ<
<D=-.=҇<<:xy9.OYݻHi1E5<=9=cU=w=zy=nSD=K۪=	<<<b<;
<6\s; :3::83::4|:=:~:~89/{99[\)2ںf,_S9
Dԝ93$:V::;
::9.Oo[32(;9c99l8JKq{ZjJiOضһR;b;1_;Bc;(p:98!:
d:)q;T;!D;
;)F
;Yf;;(;j5;/t::}:s:$:߃:̧;Qz;;%u;9:::h8:T)::4::el9o8)Q9b9V82:D gG̺)Ⱥ>׸:+::::q:+"8Vቹ}?59s799!!pDsrfp(ĺ
ú-ֆnoe?ghi!2ERs\޻o:Z^w`UjEy9:}U:h:l;-$;d;t;;+;C;ٰ~; ;K<B<^<ɿ<,8<7%<8*<2i<,<)`<$<<< <+<7B<=H0<7<)n<R;8;g;خ;I;;~;;/;ED;"p:z:6x:3m:N;;;Vv;1;7x;jy;o;8;Pb;Ƒ::<
:9:ʊ:*;*;!;.;*.;:":a:A:::z::4=9HW8zº962͸`L((O]7[]OU+Js'
:/46:):g:+:^9"l빥X/g38Y90P8RI
ҹ3gVA,'(m# ˻G׻t₻bAـZdTYAɻUs}2ƈ|"::a(:b;-;J;H;\;O;;Ĩ;V3;b;<F<r[<*<7D<= <;_
<3x<-&<'< k<?j<u<$<2>{<>S;?:5:dq:);v);%e;#}9/0:4X:];;"&{;kr;;;N;2M;S;݊;L<<m<$<2*1<<'K'<y;U;{G;yҞ;2;));C*;R;9h#::":hq:; ;2M;#ŝ;;1C;ez	;5W;T;fw;+:vP::::д;;-t@;4Q;)
;.@:3:͟i:Y:;՝;'::927|X؅⺈{CUl:eX!,RI9Kr9*::f:q8:9]-9h8Ot 89%9j7|.o͹gY7	N
 f-ͺ{|:֪:=km⻟sݻȻ]LhyȻD;G<9<3<.`<'>;Ec;Tk;|>%;U;E;o;YD;)$;/C:0::;;)/;*T;^;˿:*:Ό:ϩ:#C;	;g;:9+L&Leݭ(57m"z,)zU5ѺXӹ`9
:qM:rF:w:5	9969h99[8$8ϹɅUDغ*
ȇFǹکHϺRId#Rv3bdQ@x3Zgjﻫ3uϵRڀIvࣻ1߻jmHЛM$3fK:HN;:;sx;b
;O;2r;;婟<N<
k`<E<*[< <&(<-˙<5Y<:3<<3Y<Y<5ש<-<*<-y<4H<:<=?H<8<-7<=<
h;`;;;7n;%Q;t`/;+E
::;B;]:e:>^9+I`^i0Js7Cu=q yllP\yB@׺
 P7E9_:Q:g9Vr7>8c//Kb*V	3)?ɰL	LŻK8ZV}㭻׻7yyջ}=[k4OX ̟
-9:e:;Rd;g;7|;׸;;?;4`;md<'<L<#<+<,)><(m
<#<	p<a<	Z;N;`I;^o;BG;҇;;G`;h;˝;#;'%;e;;p7;*;;;w;{A;;*;);;;;ˮ;@;.;&;;h?;[<	=<4<u<'<&X<<;7-;c;ܚ;,;<R<<i<
;;];4N;wuO;8x;~;L;E);#;:V?:`L9GѺ+._+-yv;6;);:=:`9A$8)&7xz尻3L>\:"Yd9:dL^:=:::5:I#:$Q
:=+:D9WN!E@n)`>#[»!X%BB8glNY9YRjl?uԻ%ꩻYۺP+/lK89t:YX;?;d9;;QE;;c;ٰ;{<<<*<%A<(<'^<%<"t<)u<N<
T<;p;^;;z;F;;͘;RE;;c;c;x<;
;yCk;j+;Yn;K;QP;m;@;;&X;I
;›;;;u;N;H;<[;{z;;zA<f<h<Z<;T;i';	;Vk<
<(w< l<#<<;ಞ;	;j;%;g;W;Q;F;,;::e:49yu8859!ꏹVl~Ժ&$IĻ3*5ZRd:W:.:ο:w8:,:-::
::::E#9r9J4ufM	@l
;&5:Ի7{'(wu3
o6h29:a9:٥;=;;͸;W;ָ<	:<v<w<-<"f<&/<&f<%hS<$w;3;5
Q;L1;lT;;p;-;y;d;;;;;;J;;ߗx;8<
Ls<c<h?;/;;_;e<־<18<$<,TA<%*V<ٗ;;bq;;;0;F;rB(;d;P;3;:菡:9:s
=:%::!>92aZ)oWV[9co:
:;;7;p:a%:4F:B:':
$:m::(:9m9DT亐}(Kfolwj~ӻٻ^~/%#3մ<9c\:8:ְ;#;2;(I;a<0<JY<L!<9<I<< t<$6<&<%O<%<%-[< ܌<jN<
W<;;;Io;¸F;Qu;;;C;z>;K4;5*;/;-;'$; ;/;h;)d;H%;b];q<;|;;z;;1L;(;_F;m;;;!;f<7<s<9;７;h;m;<C<<&p<2c<0*< v;<
";;ն;;r;=;;h5;lJ;V;?lA;%r;c:¦:8:Q:ݮ:rC4:!$8)"gԺS㉁o9E:;w;);;7+;7y;(>;D;!;.%;
;:?:::˦:9Mh͒~UOA;g?籺/׺W߹J,i9,MT9999r:	:E;);i;	;;V<<<<9<"\<"<$]<%=<&i<'z<%<W[<<J;Z;ݖ,;*;Y<;;;;Ue;;Vt;(.;J;:{:/A:a:;l; b;.;1F;Fk;N;ę;n<~h;;ط;;ѭ;߂;S7<
~<"<2<;]<55<"\<
s;;;י;z;*;F;t";_\I;U;T;P;@2;$;t:J:/:|:v::C8G/]d<:? :&;0;`;|d;E;{pL;l;[/8;Nb;H;Ex;E;G;;4L;h:{:29$t>p	f(,BomgZ6
ܺQp-9Z:8l:x:m:k':t;UK;[;T;X;܆;YX<>A<[<~<<=< j<$0<&A<)'K<)<'k< m0<oB<հ;wt;Q;e;;B;;d$;;;>::: :Z:A4:W/:f:E:ߖ:];<;;P;3
;e;8F;m;Z;R{;f;
;M{;V;ݾb;x@<]\;b;;a;ϖ;;N[<Z<<,<9<8vc<)	<]<15;;;+;r;
;dE=$=֛mc/mɽGW:Dǽ$e.Z<6
F<2,d=&q=UB=$=<~;wrӼ~"KMV9hF<:˽ƈAiL
CRF;c=[%
=o_={0====}=H=x=8)<ʭ7;E}wr42:2DA<~<ϗ-<=N=>i=-=- h=5G=8_=3j='=GF<ѣ<:]ûڼ j]7uĽTBޮ.P'
?f͙LM;8&ꪻC28»+1[4;<=IC=5
= =T=!=$ms==
<ʆ<1u;9(pZn>dyܰ8x\eL2:#<|<ᥕ=R=1+=@`=Hr=Ls=Oض=N=A="AZ<<^u<ٯ|y\#jm*ƽ.)Ry(DAd5ᗼ(LlJU}i;<<<9=#=Lx=o?
=ݿ=3=<=l=-?=n=2= %<<u==[M=$=<<`9<@!N;޽<=fJ=d=<{;[6];3ާ;w;&;_;;;H:x:Z:Ȋ:::9:y:r{9^CaоC"q#;"W"5U#OR_.U9c999t9՘9̭9oe9YVH8Z<<$"rx
FtjA~طb%:G߻:*:ӻ_Bl߻ƨûծһvxE/̚Юӻči2rK˻|nF}6$:;_1;%;;g;׬< 3<
K,<<<0f< <D<<"5o<32'<6<.<+ƻ=޻`۹EUлڔMXǼp\ջGylX'|黴⻵g)9jVu@<>:;.ȣ;{I);?;;Զ;<<;:<
_<;K;<<u<'P<7-72J0O)e`&6twOcغ6'"%B`Zͤ
N'40ں\[0꟠,KTx6Wܻ_hodtYeBɻ9EM[}#ٻL:Md\3&7l(Dq)Yz仐ûR=:ơ;4;|;;F;A;<'<[<;;δ;<	6'<]<+<8-V<@L2;.=*A3s}]fg{t0&Sm%V麨.!?PZ;Khmq"uNzn'C7^BeлYݻp"n7.һUz䆭o%q޶qǻM}r-a8=:;1u;~b;ץ;¨c;m;J<|<S@;S;
;b<<w4ٵܻ&qHt]ꊻb Z#S5O
I[7ݻR)`*CPL([NQta)mۻ(OIi wkz߻pHZ3;1;ػX#YGb-Th⠻E[A6(M}ެ˻̇`*뺧	߸#E:;2;i;h;z;;<G;Y;;<<
_<*<'<2<;"
]=a9,sXslufxcŻ[G)7C"KSҺ7g<o¹#HJuH=ֻ]xpu/izӻRyI'3$R,}[ѻեh̯x8(EF㸻@{Θ,յrһػ[̻$#{Y:x;A;&;8;;,;;K;7;<4j<<<#R<-^<6<>;	:UT::F::/;c;Zc;z;7;Ψ;ヂ;ƈ<<
*<<<t<<"j<&<)s<*hp<(<"I<I<	U;;';jV;į;A(;;M;.;-L;Z[;:f8QiIy9%99n7:%:p::B2:d;r;Y;Z;n;W;r
:;;l&X;F;Z;;;u;S;T*;єt;Ѡ<C4;;\;;݉;;;;;֘;;|gQ;d;ih;2;;;;d;@=;$;.::R9
!S/@VUE79P:t:r;
;;!,|;=4;}];W;ņ;Ҹ;h;t;+;S;Rm<g<8<W<$ފ<(H<'u<"C<[<;;5u;ӿ;k;;w;;;;;r;
cT9w}8vۻ*Nk6 x캺49:;:g:9	9:E;N);H;;ex;r^;';;;;H;;ӧ;n<E<<<]<W<<<S;9;;i;]:k9z9U:j":ҥ;;1:S:g:E:M;x;AM;D~8;';;;3;U;r;;0 ;(;E;;	-;1;`;Va;nPt;C;Φ;y;;qԂ;R;4;T:6:jd(9H6f"@
9Q:ns:ѡ;
J;T;^V;-W;\~;!;y~;d
;l;;I;;>;<<	89<7<;<"T<"<:<w5<P2;;ٽb;B;i;4;|;x;;Y;m;4;3v:>4
{*32L* `pU	źW縺3ϯɺuA89q:u::L8^?9:߬;XA;;ZA;;;8c;;2;;\>;ͽ;+<<<*h<<
T<R<
<[;;;Y7:&:@9DJ9um:>jj:U1::o::q	:|;;,;G;Cʜ;,;;j;'/F;N;;;;j;;p;B;h;eƑ;Ix;S4;};2;;;V_;n6;~;\M>;9;~O:ӫ!:}9Kbk{琵Xq:::o:D;	8;y;;9r;vV;;;;ͭy;t;;؏;V;>;<T<<Y<s<
<<';_;^;m;0;>;r;ǩ;;;D;;RC:R:]/OMOA_1A!^9Q-\׹39ѝ9x`ֹ::6&;N?;=;IT;,;n;5;;2;o;å;x<~P<<|j<٬<<c|<<,;v;;ZB::M9]9Ǵ:"-):r3::B:x:.:;;5?~;I;EC;9;8͔;Op;ya;;b;6;;);u;u;v;K;A+;a);W;B`;+;3;;;X;3/;:z:D:8fCzі@9Y:V#:MN:5:;;;E{B;;;;J;;';A<;W;;H;j<<	b<<V<<-;8;;s;;8;;s;;;;c;g:M'8ARr`ƻcnZPNtKB::/λ8<=ˆ.guf#i-)ۺຉjbj:%n:};;;hg;1;;E;v;;r;8;x;i;<)B<
Lt<z<B<55<<Z;	x;|;_y;I:{9B9:,S:[%:v:*:::j:; ;A	?;R;U;S;];x];;D;|M;f;0;;;;a;D~~;OY;R;;;2;#;IJ;s;I|);&J;:5:2:9>^\<ˑ90:gw:u :ӊ:Ȣ:9:;M;N;4;;;;d;!;$;;&2;};;^0;;;O;;?;;;{;;];;;:;;r:L׷ڈ)VEjCobg=^wZtջXY]Fƻ^FT79>f^%޺eP12f:1:2;.k;YY;|2;32;E; ;s';rK;`;;',;
;~,<<C<$3<<
<;F;~=wl=L/=&[=1<<@c:뱼zj9cEniެo/:d;&;)<
ۯ;;m']}s;NP<	m<鶨==A=Y=j=t=z=u=_=8~=
^<=<;==h=,<ل^
>:2ƨXNqUwmX;l#'ۻ=%yL=OkV=bp=]`=F	2=#<1<<<_<<>E<b==r=;;m`~ּ-:
T0mMepl{0]/Ez#h#*i-<`đ;
	d!X_Q(9<*F;sk*p^l/9!*.-/N3?=sI"iR1UCEP:k?|ҽ \]fϼh,<_=3=5=DK=M=T=^U=j%=q=pL=cK=Q{=@Y=1b=O=<<<-o;޲jMtˎC]
,_!k)-7/O2x8,>@A?L2սX_
T<[%sWTR}Ͻ#Ǽñzr;ڦ<
1;(:幇#=[S{mz|;,(ݼ?V[M";;7;	c;ޗ;m;㈧;ރ;Է;
;;;s;ġG;;CP;T;ݴ;;dt~;?Ls;:g:`Z9!dE)^z+Tƺ¢k註$SRuL[|yp]fԻC#-#q!	]ܺo
;-kU¹*Pbo\u.ȻNbci]ԻEGN.#2x==g7Frl텼ce:ͻ6T_	
&
A^@ĻqWûRbѻ(º$9I;;L;";;;c;xa;&;w<O<<	<'<0e<8<>8;;ְ;Q;;R;;;O;<;11;8;~;u;;;G;;M=;j:;5::W9?:˺!uߺ]/>GwL'Gv5lRh߻Q	sŻm߻^?M!1d	@[ZAiGĺ=M1FtĻ3=eлVd$`2K0o$jOxs*ʻ>uF
gɼ¼'%3
e[2u.[':,Vn;>;;Ț;ߕ;;y5;
;<<f<$=<.i<4v<6<60<1<(5<<L]<(;Z;;3;^k;?v;ϖ\;;ۭ;`;f7;;;;x
;];K;;z;;#;<;™;;)F;!3;;;;x;Af;;B::	(7t:y٫UL܆`nTú^4	s>o&ݻ;No껝ވ)㑻J}mP6%U2{+\\.'8KDg?v+sM`5I@?~m*čɻα˻?A
м|Eݼ!,#഼%7$|澼V8|B:ͻϻ(;;h;;P;;̞;2;-;<<G<%<.h<21<1+<-f<('< -)<u <G<";;;TJ;Ԡ;W;n;˄;;i7;ȖW;Ցc;;;;Ff;0;\;8;+;Ա;1I;;ƹJ;;;,;;V;L~;:ֺ:3!9`4
ɬlm6|,K$ٻ&d˻wAQix_'C1'`6>>i~?;[5,7 2)L-յ!(fb8v;M;x;;;;Y;;<<<$db<(<&_<";<\<<!N<0<4<	;,s;k;|D;h:;q;;ht;Խ;ڮ;G;;*w;_;;S\;ѕv;`g;;h;8S;k;;;;oo;&::u-:1"98:3rڅJ'HlHj7Vt+$xW;ޣ̹9۶3:39_ĺWCW3SJ/ٻeǻI̊"a	Tͻ*9˰P&5>E˚L
IRּAϼ7+8pѼ
Ļy*_3YI_\:u/;I;{;;AK;;C<+<?ƺM3ںɺ\ѻL!=`򻇼P+黻ǻRT满㑻U3oy9H:F:G軉; ~á4DGr,߮
)CRSL @3м$Jբlю!:aV;%;Z;{+E;w3;/;<"<<3<<M<<<,;<n<<
=<3f;;`;U;ۋ;ֳ/;u;Ѥ;ө;oA;ȫp;;;;;N;Q;;l;`;5;Tf;::Yh:GX:k8IJf沺ϼVAj7}Zջ˻=ӹoJiH)S߹T92:)n\28'w=`ªȿUCdY Zмk7=N\Wn=RF8Ɖ*EѼgkt;޻oh9;P;C9;ep;&;;<D<<#<~<<<Q<<@<P<hu;u;∮;;u;;ɘ;Ǐ4;;g;0;F;f;~z;^;;;WO;};r;n;ǂ:"f:ksy:Rm:9Ph9@h+}%d0
/Z8\]򩻡263炙th:N;_*;
|:0:e:^:w:Pl:j:Ɋ:;L[; ;?;[;m1;t;zI;XW;[;с;=;;';|;~;;O(;^\;RwE;nI;Y;;4;0;W;;]<;5~;t;:ЬH::Cxc99k9b9߶:/:q?::d:ê;(;"#;N;|;!d;l%;r;%;6;;l;x;A; ;0;ߖp;ಾ;;C];l;0;P;&;;{;_;;;;q:&.ƻTqwQvajʯd,go»p8zFghs"nBMTw"ٺmĺjK-dԺ8
::ՠi;#v;K;c;i?;ZA;AS;7@H;H;o;t;;";g<Ԍ<A<s<|<;;d;G;0v:n::m:ͽB:r;,;;'T;82;NY;k;py;;A;W;+;@;a;F;bC;;=;l;;K;|k;h;{4;h;;;o;s;;Tl;.=;;b];:OJ:::
:6y::w:B:,xe:Vշ::::C;
#;,&;O;r;1.;NE;;0;q;^;M*;Ĺ;>;B;;Ϛ;^;m;;,;{P;;;;_;R;j9:컃{wann7fo\TPȻmȽf<\
;xG(6E.ewҫeq9M%:g;ѩ;1Z;6#;([;;;
];+n;R
%;}
;w;.;z;n<#u<<֚;;BN;;L;;	;
f;;,x;A?;Sq;b#;r;{;;F;}
;;;;I;;֘;;΅;;x;;S;;;$;;;;;t;OΞ;*j;t;?:J:
R:<:m:@::f
::A::p:^;;1r|;M;i`;L;c;l;;wm;;;aV;1;<;};ȍ;;9;;{;;Qi;;c;*;Tw:D{Ի
o$h㻈SyڑmSuDͻ+([S߻i^jFP@ETSiU\:HI%9W::/;R::od:(::kf;=;?J;h;R;;);R;F;=k;d#;;;;_nx;8sw;,;5i;J6;b$;y;;];{;';};U;Çj;Ǫ;c;ςE;ӷ;;h;F;͛;Ń;b;\;];;v;f;
;$;#!;Qa;,;e: h::*::{
:Ci:	S9јj9[:TE:t:;4;%)4;;x;T\;k8;}c;;;;(D;/s;;;;ū;]C;`;N^;U;v;bl6;[;N;)8:j]]\lg@A
|S~75ֻ10N|k4u
tġ~ȞXwb
h kO9!9:{8::q:4:a@G:H:g%:[;;<;b8;;@u;t;Bv;`;ӱ ;L;g;jH;K;Hs;Y;u;;;;m;{;ъ;?;֊;݂;;;;G;8;C;t;/;g;DG;0;m;;M;;;;Y;369;::U::d':2:eKH:%9Ӡ9Ñ:"-:'g:;;*G;?
3;U;j;|b;;-;);=6;;;;O;J;M;5z;!Z;z[;C;;:ϊI:\[<`aλ$"rnU~W󻒗ٻ»M-Ż`ѻI滕dwp,"<
u,'9%x:r99:$Z:O:S;d););BN;]|;O;B;\;Ǯx;;7;J;p8};Z'x;^|;w;);e; ;;;R;3;;K;R";ٖ;;j;
;u;,;m;GR;;8d;Y;f$;$4;;@;;eE-;92;
::H:s5q:dt:Dn#:9O:+:w:F;>k;;P;S ;i4;|v;;W;K;\i&e_RdlH1ܻϻc4{л߻.5:t:͓;|;4Q;B.;Va;}-;;r;^;	;V;tSx;gY;sK^;;F;s;R;;;b;;f;l;X_;b;;l;G;;Ӄ&;MM;.;li;;;;~;;Bp;n~;:z;;)p:#:EM:6H#:D:6]::)n:@:&,;!;N>3;o[n;;k;.;A;;;7;;s;;";-;;Ci;g;:sܻ(˷pPsrֻ"ۻӻO囻jz秠סۻMaƒJW绰YG:y̺7s"09ė:n5:O;
z;)f;4;M;\:99%A::cO:ޏ:o:;M;W;;;;;;1;0;6;;f;;;;;[:̺fOmfo;,;>;;~;uq;̲;;;;O;ۘ;~;s;;kU;;|;';;rZ;_;;Z;V;h:P9OX9x:@ݧ:O–w;6#S0<͆rf;"<<=W=iH<<;<,@vm	*::!
`sc:U;;7<,oSʻȳ
襼[+*7|󼋻<p:r<-'@=ca_=N=$X<;d漖ڬ'H|.!;3<=4=S@=ZW=U\=L+=@»=0	=	<;,B;F'ռ\¼żK;f;-;$;;L;yۺ!:q0]BTnwꪼwI̼bܼ`e`MLg:?8n2źɿ׺ɿ]%CBǼ#JS0~ļB~}Xռ<{Daڻ<
<<=
=)=3=;`z=?=?Y=:=/=R=}<{<^<05;3:AW˼EVXjG8+мKnB1}|ϭa{<:͹<
=R=J=q5=@=z)=d=B=f7=Y=[s=I=%ފ<<<:<3;	;r<=+c=<=&${=<<]v-;:;}1<<0R@<<=ϼF	>/"ʅkhU%ZV@_:v:҉; =;SG;;lI;<my< ۠;~;R;;;{D;u|;_:;;W;;;;RA;
:m:n:Z:<9a>vv6̻aǻd$#,X(!AȺ>%h=TDȺܺI%[46fo-@x=?3f+>)9*)R-NpA컾Sug+Y:1;H;\;;p<$<G<$2Y< <B<<
<
<ٯ;@;;;d;=P;<;c;I~;~zV;r;tP;M4;m;L;~;R;u:/:kY:M:7K9¿6&[A
EBt[Awoz9f)?l4պa=BkCƻI;~Q;|F;;g;
;H;}9;k;@.3;:D:/9%938P3#.^߻N*H&ʾ(ln[wcC4b滠
&۬*(LIPɼD AӼH
ӻcStL;j;g;oI<< [<%<<
g;[;;CT;>;;<;;L;M;ݘ;K;q;v;__;5:]:*:|9	9-D9Xc)`8@o1?:8޺_toM)F^f#ЧZmp!@n-gë(:l;5;օ<h$kV?q1JN<5:z;;۹;<<<<8;Ǫ;;а@;s;Q;;;/;;vPk;Z;/z:-:+9zT4PWC)AKNvꚻwH9̺>VA%hVhq;Ěw9=]޺ZPֺ2|olc/ռ#Sy#*ؼлd:||;y_;ŭ<^<
]<=;G;;;w9;F;$;e:~2:,Y:dś)phCygG#O1ȻcN+ 9:OлB}8/atǠѻ
(c2:a;p;<<;*;;m@;:t9_и?MԹˤO㭺8R
':,:b::A:qK`JE	:Լ/owϚLY9T;{h;o<;;13;i;{c:+98-R ?:mtܺz48EB:C:Y:ϝ9_L4fӼK`T:;;{d;ܥ;;D:%ĺHcჺUaZ~)1:;
:H<b

7䲻o\:] ;;)1;z;zZ;dҪ庾hg:Ay
޻:b&;T;
49#k\2of}TM:;&#;;.;%_Һuʻt`qi8;`;6:o%4Ϊ|Q~:7;9;5v;7b2%_:Sm;Yr:PNunI
g;5ۉ;ԑ;gv[Ng1–7!&;b~d;.C*(;BL;ޏd}0:_;~O	;𠻘Ղ;$::;~9;G;~7{;";K;J;;;^;Cz;E;;-;u;|;;9g8QpRS,P»ܻP_;:;x;a5;ڇ6;O;;׆;Q);*z;ǿ;t;;Ī;Ǵ5;O;t;r;S;a;@#::!491j9|:s:p:s;;-;_;rC;;\;;;;Ţ;;;Kj;;.;YQ:T&仼=.j1F9)Q;g%Z&httV^"=?M-20$/^9թ:
:Z;#;D;\2;i;t8;ώ;;F;;r;;Q;[[;ɔ;[k;-;ܛ;;;$;d;E&;;|;;5{;;ƴ;%;K;xӝ;'#:vR9*9Do:	:74::;;8)e;e;;_M;k;;i;f;;E;;;;GiC#oٻۓY6\zx1	\6FBm	!*6ٻ`#퇺d%#H7Akk:%PD:m;X;=n;Z$X;h';r`;5[;j;;;*;Ă';
q;ȅ;ζ;Y;;;S';"_;7;;hv;B%;s;gi;";;\;e8;:x˪99)s::,::w':;{;6;`;?;6;	;I;O{;;o;;;R>:&b_dܹ1^zû"( p%F//-A߼
Kn,)&H@6@{Y(8c::0;.R;P;ai;l;/;S;;nS;;F@;);;Jt;/;Xf;%;;I;;;k);ȍY;d;Ԁ;ɦ;;;O{::;%9\A9$:?::?:|;$;38-;`H;;̟;;;B;;;{\;Hw$+YA8QGT̼"jN,]ûjBU:˹R+
Zf6MI::;
;>	;R;_;ts;;;;s;R;<;7;i%;Ќl;.;uY;;;;;-;(;K;R;(;4:[:9%b9:8Y:zS:*:ܕ;A;:6;h
;d;;x;v.;/;w;;4:h4	QlY軐޻ԡJNB ($Yx識:&=0UD9+8ù
9V:
;U;);>;L;A;a;&;;;p_;T;;9;τp;Ơ;;9؛p:-:&;{;,;:;QU;u;"j;;CJ;Г0;8p;ϭ;Ęt;9;;;~;ºB;l;Do;d;;N:4:2M	8I89ٻZ:iRs:V:;;6y;Yn;pb;}|;lVg;\;(:6KʻU9D
;f;~;`V;:TCmLQ9d34:ym:O;J;08;I0;Xg;^l;UG;9t$:;s;3#;LT;Y;\DE;^;F;
:`Ur9,>\CުB!1-V9+4ǼϻB-v^m:$^;6;X;h;p6;p;ta;9;k;;M;JT;;;
;):;C;t;uY;XzN;:}ṽ	`D):>(:;/ux;P;a;d
;s;\Մ;!:*[h׻.-8!)e&?Qj^v[bY;
!;b;;k;;R;9;b;;+;s";;s?;2;nm ;X,;G;-:L9VE;ۺ	/:C;;NN;i;tvn;y;v>;1:oκT3!»}%H!Ɨ@5ˊ9;7);;;!b;=k;;I[;;ȯ;;;v;O$;,;:L:i'3ѪXA8[*:S;>;o#;;	;x;1:-^udԼ 7?P:;c;C;n;#;Ԯ;$;;;c;e;9t;)::^69b3:,gv;s;kY;1;,;c;!U7ǻ8WLCw#S$j;;̄;D;;C;9;;d`;NG;)M:{4:9$_Sm79:;[A;@;
;:5ƻp@;ŻJ5;O;!;c;};;;U;3r;:ȓ:&鹬*fޒ:#;>w;
x;o;i:6nUf06a+%:…x;ݴ;;R;t9;&};:K69gRջ
O(;G;6;<;latg	A̼
矻kKG;\e;;;J:':H!R]:W7;;S;* F&PsX:ߧ;C3;s4;!s:__U jq:;;ʘ9vUy/Fq;;n:GLȺ;;hrFJ';Z
;\sLd;A:?Vzq:wpQhealpy-1.10.3/healpy/test/data/wmap_temperature_analysis_mask_r9_7yr_v4_udgraded32.fits0000664000175000017500000045760013010374155031531 0ustar  zoncazonca00000000000000SIMPLE  =                    T / conforms to FITS standard                      BITPIX  =                    8 / array data type                                NAXIS   =                    0 / number of array dimensions                     EXTEND  =                    T                                                  END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / array data type                                NAXIS   =                    2 / number of array dimensions                     NAXIS1  =                12288 / length of dimension 1                          NAXIS2  =                   12 / length of dimension 2                          PCOUNT  =                    0 / number of group parameters                     GCOUNT  =                    1 / number of groups                               TFIELDS =                    3 / number of table fields                         TTYPE1  = 'I_STOKES'                                                            TFORM1  = '1024E   '                                                            TTYPE2  = 'Q_STOKES'                                                            TFORM2  = '1024E   '                                                            TTYPE3  = 'U_STOKES'                                                            TFORM3  = '1024E   '                                                            PIXTYPE = 'HEALPIX '           / HEALPIX pixelisation                           ORDERING= 'RING    '           / Pixel ordering scheme, either RING or NESTED   EXTNAME = 'xtension'           / name of this binary table extension            NSIDE   =                   32 / Resolution parameter of HEALPIX                FIRSTPIX=                    0 / First pixel # (0 based)                        LASTPIX =                12287 / Last pixel # (0 based)                         INDXSCHM= 'IMPLICIT'           / Indexing: IMPLICIT or EXPLICIT                 END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ??????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????healpy-1.10.3/healpy/test/__init__.py0000664000175000017500000000000013010374155017665 0ustar  zoncazonca00000000000000healpy-1.10.3/healpy/test/test_doctest_cython.py0000664000175000017500000000100013010374155022217 0ustar  zoncazonca00000000000000import unittest
import doctest
from .. import _query_disc
from .. import _pixelfunc

# FIXME: I can't get py.test to recognize test suites returned with
# doctest.DocTestSuite.

class TestDoctestCython(unittest.TestCase):

    def test_query_disc(self):
        failed, passed = doctest.testmod(_query_disc)
        self.assertEqual(failed, 0)

    def test_pixelfunc(self):
        failed, passed = doctest.testmod(_pixelfunc)
        self.assertEqual(failed, 0)

if __name__ == '__main__':
    unittest.main()
healpy-1.10.3/healpy/test/test_fitsfunc.py0000664000175000017500000001735713010374155021035 0ustar  zoncazonca00000000000000import os
import astropy.io.fits as pf
import unittest
import numpy as np
import gzip

import healpy
from ..fitsfunc import *
from ..sphtfunc import *

class TestFitsFunc(unittest.TestCase):

    def setUp(self):
        self.nside = 512
        self.m = np.arange(healpy.nside2npix(self.nside))
        self.filename = 'testmap.fits'

    def test_write_map_IDL(self):
        write_map(self.filename, self.m, fits_IDL=True)
        read_m = pf.open(self.filename)[1].data.field(0)
        self.assertEqual(read_m.ndim, 2)
        self.assertEqual(read_m.shape[1], 1024)
        self.assertTrue(np.all(self.m == read_m.flatten()))

    def test_write_map_units_string(self):
        write_map(self.filename, self.m, column_units='K')
        read_m = pf.open(self.filename)[1].data.field(0)

    def test_write_map_units_list(self):
        write_map(self.filename, [self.m, self.m], column_units=['K', 'K'])
        read_m = pf.open(self.filename)[1].data.field(0)

    def test_write_map_C(self):
        write_map(self.filename, self.m, fits_IDL=False)
        read_m = pf.open(self.filename)[1].data.field(0)
        self.assertEqual(read_m.ndim, 1)
        self.assertTrue(np.all(self.m == read_m))

    def test_write_map_C_3comp(self):
        write_map(self.filename, [self.m, self.m, self.m], fits_IDL=False)
        read_m = pf.open(self.filename)[1].data
        for comp in range(3):
            self.assertTrue(np.all(self.m == read_m.field(comp)))

    def test_read_map_filename(self):
        write_map(self.filename, self.m)
        read_map(self.filename)

    def test_read_map_hdulist(self):
        write_map(self.filename, self.m)
        hdulist = pf.open(self.filename)
        read_map(hdulist)

    def test_read_map_hdu(self):
        write_map(self.filename, self.m)
        hdu = pf.open(self.filename)[1]
        read_map(hdu)

    def test_read_map_all(self):
        write_map(self.filename, [self.m, self.m, self.m])
        read_m = read_map(self.filename, None)
        for rm in read_m:
            np.testing.assert_array_almost_equal(self.m, rm)

    def test_read_write_partial(self):
        m = self.m.astype(float)
        m[:11 * self.nside * self.nside] = UNSEEN
        write_map(self.filename, m, partial=True)
        read_m = read_map(self.filename)
        np.testing.assert_array_almost_equal(m, read_m)

    def test_read_write_partial_3comp(self):
        m = self.m.astype(float)
        m[:11 * self.nside * self.nside] = UNSEEN
        write_map(self.filename, [m, m, m], partial=True)
        read_m = read_map(self.filename,(0,1,2))
        for rm in read_m:
            np.testing.assert_array_almost_equal(m, rm)

    def test_read_write_dtype(self):
        write_map(self.filename, self.m, dtype=np.float64)
        read_m = read_map(self.filename, dtype=np.float32)
        np.testing.assert_almost_equal(np.float32(self.m), read_m)

    def test_read_write_dtype_multiarr(self):
        write_map(self.filename, [self.m, self.m, self.m], dtype=np.float64)
        read_m = read_map(self.filename, field=(0, 1, 2), dtype=np.float32)
        for rm in read_m:
            np.testing.assert_array_almost_equal(np.float32(self.m), rm)

    def test_read_write_iterable_dtype(self):
        write_map(self.filename, [self.m, self.m, self.m], dtype=[np.float64,
                                                                  np.float32,
                                                                  np.int32])
        read_m = read_map(self.filename, field=(0, 1, 2), 
                          dtype=[np.float32, np.int32, np.float64])
        for rm, dtype in zip(read_m, [np.float32, np.int32, np.float64]):
            np.testing.assert_almost_equal(dtype(self.m), rm)

    def tearDown(self):
        os.remove(self.filename)


class TestFitsFuncGzip(unittest.TestCase):

    def setUp(self):
        self.nside = 4
        self.m = np.arange(healpy.nside2npix(self.nside))
        self.filename = 'testmap.fits.gz'

    def test_write_map(self):
        write_map(self.filename, self.m)
        # Make sure file is gzip-compressed
        gzfile = gzip.open(self.filename, 'rb')
        gzfile.read()
        gzfile.close()
        read_m = pf.open(self.filename)[1].data.field(0)

    def tearDown(self):
        os.remove(self.filename)

class TestReadWriteAlm(unittest.TestCase):

    def setUp(self):

        s=Alm.getsize(256)
        self.alms = [np.arange(s, dtype=np.complex128),
                     np.arange(s, dtype=np.complex128),
                     np.arange(s, dtype=np.complex128)]

    def tearDown(self):
        if os.path.exists('testalm_128.fits'):
            os.remove('testalm_128.fits')
        if os.path.exists('testalm_256_128.fits'):
            os.remove('testalm_256_128.fits')

    def test_write_alm(self):

        write_alm('testalm_128.fits',self.alms,lmax=128,mmax=128)
        a0 = read_alm('testalm_128.fits')
        # Sanity check of the file
        self.assertEqual(Alm.getlmax(len(a0)),128)

        # Check the written data
        a0 = read_alm('testalm_128.fits')
        l0,m0 = Alm.getlm(128)
        # We extract 0 <= l <= 128 and 0 <= m <= 128 from self.alms
        idx = Alm.getidx(256,l0,m0)
        np.testing.assert_array_almost_equal(self.alms[0][idx],a0)


    def test_write_alm_256_128(self):
        write_alm('testalm_256_128.fits',self.alms,lmax=256,mmax=128)
        a0,mmax = read_alm('testalm_256_128.fits',return_mmax=True)
        self.assertEqual(mmax, 128)
        self.assertEqual(Alm.getlmax(len(a0),mmax=mmax),256)

        # Check the written data
        a0 = read_alm('testalm_256_128.fits')

        l0,m0 = Alm.getlm(256)
        idx = Alm.getidx(256, l0, m0)
            # Extract 0 <= l <= 256 and 0 <= m <= 128
        idx_mmax = np.where(m0 <= mmax)
        idx = idx[idx_mmax]
        np.testing.assert_array_almost_equal(self.alms[0][idx], a0)

    def test_read_alm_filename(self):
        write_alm('testalm_128.fits',self.alms,lmax=128,mmax=128)
        read_alm('testalm_128.fits')

    def test_read_alm_hdulist(self):
        write_alm('testalm_128.fits',self.alms,lmax=128,mmax=128)
        hdulist = pf.open('testalm_128.fits')
        read_alm(hdulist)

    def test_read_alm_hdu(self):
        write_alm('testalm_128.fits',self.alms,lmax=128,mmax=128)
        hdu = pf.open('testalm_128.fits')[1]
        read_alm(hdu)


class TestReadWriteCl(unittest.TestCase):

    def tearDown(self):
        os.remove("test_cl.fits")

    def test_write_read_cl_II(self):
        cl = np.arange(1025, dtype=np.double)
        write_cl("test_cl.fits", cl)
        cl_read = read_cl("test_cl.fits")
        np.testing.assert_array_almost_equal(cl, cl_read)

    def test_write_read_cl_4comp(self):
        cl = [np.arange(1025, dtype=np.double) for n in range(4)]
        write_cl("test_cl.fits", cl)
        cl_read = read_cl("test_cl.fits")
        for cl_column, cl_read_column in zip(cl, cl_read):
            np.testing.assert_array_almost_equal(cl_column, cl_read_column)

    def test_write_read_cl_6comp(self):
        cl = [np.arange(1025, dtype=np.double) for n in range(6)]
        write_cl("test_cl.fits", cl)
        cl_read = read_cl("test_cl.fits")
        for cl_column, cl_read_column in zip(cl, cl_read):
            np.testing.assert_array_almost_equal(cl_column, cl_read_column)

    def test_read_cl_filename(self):
        cl = np.arange(1025, dtype=np.double)
        write_cl("test_cl.fits", cl)
        read_cl('test_cl.fits')

    def test_read_cl_hdulist(self):
        cl = np.arange(1025, dtype=np.double)
        write_cl("test_cl.fits", cl)
        hdulist = pf.open('test_cl.fits')
        read_cl(hdulist)

    def test_read_cl_hdu(self):
        cl = np.arange(1025, dtype=np.double)
        write_cl("test_cl.fits", cl)
        hdu = pf.open('test_cl.fits')[1]
        read_cl(hdu)

if __name__ == '__main__':
    unittest.main()
healpy-1.10.3/healpy/test/test_pixelfunc.py0000664000175000017500000001651713026275744021221 0ustar  zoncazonca00000000000000from ..pixelfunc import *
from .._query_disc import boundaries
from .._pixelfunc import ringinfo, pix2ring
import numpy as np
import unittest

class TestPixelFunc(unittest.TestCase):

    def setUp(self):
        # data fixture
        self.theta0 = [ 1.52911759,  0.78550497,  1.57079633,  0.05103658,  3.09055608] 
        self.phi0   = [ 0.        ,  0.78539816,  1.61988371,  0.78539816,  0.78539816]
        self.lon0   = np.degrees(self.phi0)
        self.lat0   = 90. - np.degrees(self.theta0)
    
    def test_nside2npix(self):
        self.assertEqual(nside2npix(512), 3145728) 
        self.assertEqual(nside2npix(1024), 12582912) 

    def test_nside2resol(self):
        self.assertAlmostEqual(nside2resol(512,arcmin=True), 6.87097282363) 
        self.assertAlmostEqual(nside2resol(1024,arcmin=True), 3.43548641181) 

    def test_nside2pixarea(self):
        self.assertAlmostEqual(nside2pixarea(512), 3.9947416351188569e-06)

    def test_ang2pix_ring(self):
        # ensure nside = 1 << 23 is correctly calculated
        # by comparing the original theta phi are restored.
        # NOTE: nside needs to be sufficiently large!
        id = ang2pix(1048576 * 8, self.theta0, self.phi0, nest=False)
        theta1, phi1 = pix2ang(1048576 * 8, id, nest=False)
        np.testing.assert_array_almost_equal(theta1, self.theta0)
        np.testing.assert_array_almost_equal(phi1, self.phi0)

    def test_ang2pix_ring_outofrange(self):
        # Healpy_Base2 works up to nside = 2**29.
        # Check that a ValueError is raised for nside = 2**30.
        self.assertRaises(
            ValueError, ang2pix, 1<<30, self.theta0, self.phi0, nest=False)

    def test_ang2pix_nest(self):
        # ensure nside = 1 << 23 is correctly calculated
        # by comparing the original theta phi are restored.
        # NOTE: nside needs to be sufficiently large!
        # NOTE: with Healpy_Base this will fail because nside
        #       is limited to 1 << 13 with Healpy_Base.
        id = ang2pix(1048576 * 8, self.theta0, self.phi0, nest=True)
        theta1, phi1 = pix2ang(1048576 * 8, id, nest=True)
        np.testing.assert_array_almost_equal(theta1, self.theta0)
        np.testing.assert_array_almost_equal(phi1, self.phi0)

        self.assertTrue(np.allclose(theta1, self.theta0))
        self.assertTrue(np.allclose(phi1, self.phi0))

    def test_ang2pix_nest_outofrange_doesntcrash(self):
        # Healpy_Base2 works up to nside = 2**29.
        # Check that a ValueError is raised for nside = 2**30.
        self.assertRaises(
            ValueError, ang2pix, 1<<30, self.theta0, self.phi0, nest=False)

    def test_ang2pix_negative_theta(self):
        self.assertRaises(ValueError, ang2pix, 32, -1, 0)

    def test_ang2pix_lonlat(self):
        # Need to decrease the precision of the check because deg not radians
        id = ang2pix(1048576 * 8, self.lon0, self.lat0, nest=False, lonlat=True)
        lon1, lat1 = pix2ang(1048576 * 8, id, nest=False, lonlat=True)
        np.testing.assert_array_almost_equal(lon1, self.lon0,decimal=5)
        np.testing.assert_array_almost_equal(lat1, self.lat0,decimal=5)

        # Now test nested
        id = ang2pix(1048576 * 8, self.theta0, self.phi0, nest=True)
        theta1, phi1 = pix2ang(1048576 * 8, id, nest=True)
        np.testing.assert_array_almost_equal(theta1, self.theta0)
        np.testing.assert_array_almost_equal(phi1, self.phi0)

    def test_vec2pix_lonlat(self):
        # Need to decrease the precision of the check because deg not radians
        vec = ang2vec(self.lon0, self.lat0, lonlat=True)
        lon1, lat1 = vec2ang(vec, lonlat=True)
        np.testing.assert_array_almost_equal(lon1, self.lon0,decimal=5)
        np.testing.assert_array_almost_equal(lat1, self.lat0,decimal=5)

    def test_get_interp_val_lonlat(self):
        m = np.arange(12.)
        val0 = get_interp_val(m, self.theta0, self.phi0)
        val1 = get_interp_val(m, self.lon0, self.lat0, lonlat=True)
        np.testing.assert_array_almost_equal(val0, val1)

    def test_get_interp_weights(self):
        p0,w0 = (np.array([0,1,4,5]), np.array([1.,0.,0.,0.]))

        # phi not specified, theta assumed to be pixel
        p1,w1 = get_interp_weights(1, 0)
        np.testing.assert_array_almost_equal(p0,p1)
        np.testing.assert_array_almost_equal(w0,w1)

        # If phi is not specified, lonlat should do nothing
        p1,w1 = get_interp_weights(1, 0, lonlat=True)
        np.testing.assert_array_almost_equal(p0,p1)
        np.testing.assert_array_almost_equal(w0,w1)

        p0,w0 = (np.array([1,2,3,0]), np.array([ 0.25,0.25,0.25,0.25]))

        p1,w1 = get_interp_weights(1, 0, 0)
        np.testing.assert_array_almost_equal(p0,p1)
        np.testing.assert_array_almost_equal(w0,w1)

        p1,w1 = get_interp_weights(1, 0, 90, lonlat=True)
        np.testing.assert_array_almost_equal(p0,p1)
        np.testing.assert_array_almost_equal(w0,w1)

    def test_get_all_neighbours(self):
        ipix0 = np.array([8, 4, 0, -1, 1, 6, 9, -1])
        ipix1 = get_all_neighbours(1, np.pi/2, np.pi/2)
        ipix2 = get_all_neighbours(1, 90, 0, lonlat=True)
        np.testing.assert_array_almost_equal(ipix0,ipix1)
        np.testing.assert_array_almost_equal(ipix0,ipix2)

    def test_fit_dipole(self):
        nside = 32
        npix = nside2npix(nside)
        d = [0.3, 0.5, 0.2]
        vec = np.transpose(pix2vec(nside, np.arange(npix)))
        signal = np.dot(vec, d)
        mono, dipole = fit_dipole(signal)
        self.assertAlmostEqual(mono, 0.)
        self.assertAlmostEqual(d[0], dipole[0])
        self.assertAlmostEqual(d[1], dipole[1])
        self.assertAlmostEqual(d[2], dipole[2])

    def test_boundaries(self):
        """Test whether the boundary shapes look sane"""
        for lgNside in range(1, 5):
            nside = 1< query_disc, 8, [ 0.17101007,  0.03015369,  0.98480775],6,listpix,/DEG,NESTED=0           
        #HIDL> print,listpix
        #           4
        np.testing.assert_array_equal(
                query_disc(self.NSIDE, self.vec, self.radius, inclusive=False),
                np.array([4])
            )

    def test_inclusive(self):
        #HIDL> query_disc, 8, [ 0.17101007,  0.03015369,  0.98480775],6,listpix,/DEG,NESTED=0,/inclusive
        #HIDL> print,listpix
        #           0           3           4           5          11          12          13          23
        np.testing.assert_array_equal(
                query_disc(self.NSIDE, self.vec, self.radius, inclusive=True),
                np.array([ 0, 3, 4, 5, 11, 12, 13, 23 ])
            )

    def test_boundaries(self):
        nside = 2
        corners = boundaries(nside, 5)
        corners_precomp = np.array(
            [[  2.44708573e-17,  5.27046277e-01,  3.60797400e-01,  4.56383842e-17],
             [  3.99652627e-01,  5.27046277e-01,  8.71041977e-01,  7.45355992e-01],
             [  9.16666667e-01,  6.66666667e-01,  3.33333333e-01,  6.66666667e-01]])
        np.testing.assert_array_almost_equal(corners, corners_precomp, decimal=8)

    def test_boundaries_list(self):
        nside = 2
        corners = boundaries(nside, [5,5])
        np.testing.assert_array_almost_equal(corners, self.nside2_55_corners_precomp, decimal=8)

    def test_boundaries_phi_theta(self):
        nside = 2
        corners = boundaries(nside, np.array([5,5]))
        np.testing.assert_array_almost_equal(corners, self.nside2_55_corners_precomp, decimal=8)

    def test_boundaries_floatpix_array(self):
        self.assertRaises(ValueError, boundaries, 2, np.array([5.,5]))

    def test_boundaries_floatpix_scalar(self):
        self.assertRaises(ValueError, boundaries, 2, 1/2.)

    def test_buffer_mode(self) :
    
        
        # allocate something manifestly too short, should raise a value error
        buff = np.empty(0, dtype=np.int64)
        self.assertRaises(ValueError,
                          query_disc,
                          self.NSIDE, self.vec, self.radius, inclusive=True, buff=buff)
        

        # allocate something of wrong type, should raise a value error
        buff = np.empty(nside2npix(self.NSIDE), dtype=np.float64)
        self.assertRaises(ValueError,
                          query_disc,
                          self.NSIDE, self.vec, self.radius, inclusive=True, buff=buff)
       
        # allocate something acceptable, should succeed and return a subview
        buff = np.empty(nside2npix(self.NSIDE), dtype=np.int64)
        result = query_disc(self.NSIDE, self.vec, self.radius, inclusive=True, buff=buff)
        
        assert result.base is buff
        
        np.testing.assert_array_equal(
            result,
            np.array([ 0, 3, 4, 5, 11, 12, 13, 23 ])
            )
healpy-1.10.3/healpy/test/test_sphtfunc.py0000664000175000017500000001522713010374155021040 0ustar  zoncazonca00000000000000import astropy.io.fits as pf
import os
import numpy as np
from copy import deepcopy
from itertools import chain

import unittest

import healpy as hp

import warnings
# disable new order warnings in tests
warnings.filterwarnings('ignore')

class TestSphtFunc(unittest.TestCase):

    def setUp(self):
        self.lmax = 64
        self.path = os.path.dirname( os.path.realpath( __file__ ) )
        self.map1 = [hp.ma(m) for m in hp.read_map(os.path.join(self.path, 'data', 'wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits'), (0,1,2))]
        self.map2 = [hp.ma(m) for m in hp.read_map(os.path.join(self.path, 'data', 'wmap_band_iqumap_r9_7yr_V_v4_udgraded32.fits'), (0,1,2))]
        self.mask = hp.read_map(os.path.join(self.path, 'data', 'wmap_temperature_analysis_mask_r9_7yr_v4_udgraded32.fits')).astype(np.bool)
        for m in chain(self.map1, self.map2):
            m.mask = np.logical_not(self.mask)
        self.cla = hp.read_cl(os.path.join(self.path, 'data', 'cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter.fits'))
        self.cl_fortran_nomask = hp.read_cl(os.path.join(self.path, 'data', 'cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter_nomask.fits'))
        cls_file = pf.open(os.path.join(self.path, 'data',
                                       'cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_IQU_lmax64_rmmono_3iter.fits'))
        # fix for pyfits to read the file with duplicate column names
        for i in range(2, 6):
            cls_file[1].header['TTYPE%d' % i] += '-%d' % i
        cls = cls_file[1].data
        # order of HEALPIX is TB, EB while in healpy is EB, TB
        self.cliqu = [np.array(cls.field(i)) for i in (0,1,2,3,5,4)]
        nside = 32
        lmax = 64
        fwhm_deg = 7.
        seed = 12345
        np.random.seed(seed)
        self.mapiqu = hp.synfast(self.cliqu, nside, lmax=lmax, pixwin=False,
                                 fwhm=np.radians(fwhm_deg), new=False)

    def test_anafast(self):
        cl = hp.anafast(hp.remove_monopole(self.map1[0].filled()), lmax = self.lmax)
        self.assertEqual(len(cl), 65)
        np.testing.assert_array_almost_equal(cl, self.cla, decimal=8)

    def test_anafast_nomask(self):
        cl = hp.anafast(hp.remove_monopole(self.map1[0].data), lmax = self.lmax)
        self.assertEqual(len(cl), 65)
        np.testing.assert_array_almost_equal(cl, self.cl_fortran_nomask, decimal=8)

    def test_anafast_iqu(self):
        self.map1[0] = hp.remove_monopole(self.map1[0])
        cl = hp.anafast(self.map1, lmax = self.lmax)
        self.assertEqual(len(cl[0]), 65)
        self.assertEqual(len(cl), 6)
        for i in range(6):
            np.testing.assert_array_almost_equal(cl[i], self.cliqu[i], decimal=8)

    def test_anafast_xspectra(self):
        cl = hp.anafast(hp.remove_monopole(self.map1[0]), hp.remove_monopole(self.map2[0]), lmax = self.lmax)
        self.assertEqual(len(cl), self.lmax+1)
        clx = hp.read_cl(os.path.join(self.path, 'data', 'cl_wmap_band_iqumap_r9_7yr_WVxspec_v4_udgraded32_II_lmax64_rmmono_3iter.fits'))
        np.testing.assert_array_almost_equal(cl, clx, decimal=8)

    def test_synfast(self):
        nside = 32
        lmax = 64
        fwhm_deg = 7.
        seed = 12345
        np.random.seed(seed)
        map_pregen = hp.read_map(os.path.join(self.path, 'data',
                                              'map_synfast_seed%d.fits' % seed),
                                              (0,1,2))
        sim_map = hp.synfast(self.cliqu, nside, lmax = lmax, pixwin=False,
                             fwhm=np.radians(fwhm_deg), new=False, pol=True)
        np.testing.assert_array_almost_equal(sim_map, map_pregen,
                                             decimal=8)

    def test_smoothing_notmasked(self):
        smoothed = hp.smoothing([m.data for m in self.map1], fwhm=np.radians(10), lmax=self.lmax)
        smoothed_f90 = hp.read_map(os.path.join(self.path, 'data',
                  'wmap_band_iqumap_r9_7yr_W_v4_udgraded32_smoothed10deg_fortran.fits'), (0,1,2))
        np.testing.assert_array_almost_equal(smoothed, smoothed_f90, decimal=6)

    def test_smoothing_masked(self):
        smoothed = hp.smoothing(self.map1, fwhm=np.radians(10), lmax=self.lmax)
        smoothed_f90 = hp.ma(hp.read_map(os.path.join(self.path, 'data',
                  'wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked_smoothed10deg_fortran.fits'), (0,1,2)))
        # fortran does not restore the mask
        for mm in smoothed_f90:
            mm.mask = smoothed[0].mask
        for i in range(3):
            np.testing.assert_array_almost_equal(smoothed[i].filled(), smoothed_f90[i].filled(), decimal=6)
        
    def test_gauss_beam(self):
        idl_gauss_beam = np.array(pf.open(os.path.join(self.path, 'data', 'gaussbeam_10arcmin_lmax512_pol.fits'))[0].data).T
        gauss_beam = hp.gauss_beam(np.radians(10./60.), lmax=512, pol=True)
        np.testing.assert_allclose(idl_gauss_beam, gauss_beam)

    def test_map2alm(self):
        nside = 32
        lmax = 64
        fwhm_deg = 7.
        seed = 12345
        np.random.seed(seed)
        orig = hp.synfast(self.cla, nside, lmax=lmax, pixwin=False,
                          fwhm=np.radians(fwhm_deg), new=False)
        tmp = np.empty(orig.size * 2)
        tmp[::2] = orig
        maps = [orig, orig.astype(np.float32), tmp[::2]]
        for input in maps:
            alm = hp.map2alm(input, iter=10)
            output = hp.alm2map(alm, nside)
            np.testing.assert_allclose(input, output, atol=1e-4)

    def test_map2alm_pol(self):
        tmp = [np.empty(o.size*2) for o in self.mapiqu]
        for t, o in zip(tmp, self.mapiqu):
            t[::2] = o
        maps = [self.mapiqu, [o.astype(np.float32) for o in self.mapiqu],
                [t[::2] for t in tmp]]
        for input in maps:
            alm = hp.map2alm(input, iter=10)
            output = hp.alm2map(alm, 32)
            for i, o in zip(input, output):
                np.testing.assert_allclose(i, o, atol=1e-4)

    def test_rotate_alm(self):
        almigc = hp.map2alm(self.mapiqu)
        alms = [almigc[0], almigc[0:2], almigc, np.vstack(almigc)]
        for i in alms:
            o = deepcopy(i)
            hp.rotate_alm(o, 0.1, 0.2, 0.3)
            hp.rotate_alm(o, -0.3, -0.2, -0.1)
            # FIXME: rtol=1e-6 works here, except on Debian with Python 3.4.
            np.testing.assert_allclose(i, o, rtol=1e-5)

    def test_accept_ma_allows_only_keywords(self):
        """ Test whether 'smoothing' wrapped with accept_ma works with only
            keyword arguments. """

        ma = np.ones(12*16**2)
        try:
            hp.smoothing(map_in=ma)
        except IndexError:
            self.fail()

if __name__ == '__main__':
    unittest.main()
healpy-1.10.3/healpy/test/test_spinfunc.py0000664000175000017500000011732013010374155021030 0ustar  zoncazonca00000000000000# Implemented by Duncan Hanson
import six
import os
import numpy as np
from copy import deepcopy
from itertools import chain

import unittest

import healpy as hp

import warnings
# disable new order warnings in tests
warnings.filterwarnings('ignore')

nside_precomputed = 4
lmax_precomputed  = 8

galm = np.array([-0.60749536999999998+0j, 0.83559932999999997+0j, -1.0174608599999999+0j, 1.0993299999999999+0j, -1.0415247299999999+0j, 0.98637741999999995+0j, -1.2327712799999999+0j, -0.65081703999999996+0j, -1.1239971900000001+0j, 0.96501168000000004-2.3554313900000001j, -0.40474513000000001-0.65564383000000004j, 0.15638859999999999-0.23621884000000001j, 0.28043983-0.39658116999999998j, -0.26163387999999999-0.077809699999999996j, 0.20287720000000001-0.06082216j, 0.052013629999999998+0.073047849999999998j, 0.68909047999999995+0.65423257999999995j, 0.48747127000000001+0.30760153000000001j, -0.35432469999999999-1.0799235300000001j, 0.43819587999999998-0.22769086999999999j, -0.57252002000000002-0.13502544j, 0.63900029000000003-0.59585710000000003j, -1.16030893-0.25760955000000002j, 0.37504869000000002+0.058102309999999997j, -0.98924601000000001-0.46924109000000003j, 0.71031016000000002-0.90896836000000003j, -0.43448922000000001-0.12677451000000001j, -0.77544904000000003-0.25176252999999998j, -0.01721661-0.94948701000000002j, 0.85474141000000003-0.051103330000000002j, -0.60520565999999998+0.87760647999999997j, -0.77864944000000003-0.79208626999999998j, -1.08657508-0.59487055j, 0.21367211-1.5110769900000001j, -0.16784056999999999+0.80020639000000005j, -1.1339041000000001-0.32197503999999999j, 0.19618954+1.08100252j, 0.43866369-0.47475267999999998j, 0.11857266-0.049022839999999998j, -0.40366523999999998+0.85542658000000005j, 0.56154870999999995-0.77527478999999999j, 0.48146275999999999+0.16245443000000001j, -0.68355484-0.22983015000000001j, -0.061040659999999997-0.13420304999999999j, 0.27255975999999998-0.75328077999999998j])

calm = np.array([1.0718601933803977+0j, -1.5182685950801673+0j, -0.39119975933464429+0j, -0.6620552667513403+0j, 0.42674481653281382+0j, 1.3799470126677567+0j, -1.4604721504544589+0j, -1.1136471151307403+0j, -1.647392955477013+0j, 0.71919252212426499-0.39773236587790972j, 1.1884542365155342-0.02640806030381616j, -0.040937417189905477+0.41096619318378996j, 0.19575829981467366-0.9285256561788201j, -0.81538492817093389-0.35929021939020905j, 0.46870617235542178-0.16617809319149193j, 0.23640105395174835+0.20199283448907013j, -0.4326244206185022-0.59306323217984414j, 0.70410703555897491+1.1105121855564981j, -0.25795284664102419-1.2596368643912992j, -0.32298608901330822+0.28961247423501457j, 0.86075337105780647+0.11654277740017273j, 0.61549312276703594-0.10703912813862339j, 0.18586512296424443-0.19025963131317278j, -1.0133508690870945+0.37723661046981605j, 0.81779407406185822+0.079623471577802724j, -0.36878503033040533-0.2898255702618146j, -0.13864500443953851+0.99443154731355876j, -0.18473645501235322-0.27320195658100321j, -0.59576170002379292+0.82900875927708351j, -0.42589567337148737-0.4359073358803493j, -1.0071527860797036+0.94936616398900131j, 0.52681818118587864-0.14360294581437408j, 0.92619570387111039+0.051664002362596051j, 0.75431992804310644-0.25779974392362176j, -0.89919787406938079+0.4989749264182417j, 0.50889483979981087+0.80485052548180069j, 1.0832061738848424-0.70024088919678606j, -0.81326057995656997+1.0871815291974078j, 0.66115253781072936-1.1579428341478799j, -0.25669790905903495+0.031910894413264487j, -0.055840352620168392-0.27126620265309953j, 0.77754873311978667+0.1677199540737199j, -0.2428367232543345+0.058222152917874435j, -0.35655343174399751+0.28585938716743436j, 0.44494756551095588+0.17931771534010477j])

maps = { 1 : np.array([1.1743580943750218+1.0162508812596662j, -1.7545991014514022+3.9632546003544267j, 3.4755301242047865+3.6205268666848651j, 3.463772051893852-0.16092758895196169j, 1.6137200258556599+0.73266613851658846j, -0.78408695644456827-0.017688408927465843j, -3.2331912918298711+1.0423682626399753j, -2.4967573102249689+5.4249205744223872j, 1.9618186881421982+4.9309708160236383j, 3.0923993499620077-0.4894899405424642j, 3.8802145016214444-1.7023962410322717j, 1.6609384663419748-1.907262230594307j, 0.48237984905359593-1.7832620041462326j, -0.91903915540372738-1.4797023464820716j, -3.3079615434500242-0.87195141293021572j, -3.2711896733834713+0.12177676469629328j, -1.4919533733781134-1.6435471612444656j, -2.6523233433871019+4.2474564187420576j, 0.91780925153179838+4.9570523962893001j, 0.42584487195441895-1.8426545772598648j, 0.23225332448920533-3.4181823103655073j, 1.4984860851219615-0.98863554278420129j, -0.35246834799111726-3.3771616282380563j, -1.5062845496910013-3.4935340751923691j, 0.13099914430749093-2.0149335831137503j, -0.99476127813711768-1.9875208527665134j, -1.1508757672399341-1.1170925992609697j, -2.2800860488149857+2.5337276570280665j, -2.0227144551955485+4.4062547882406582j, 0.85159759341389984-0.25969432494507549j, 0.10617879436802691-1.4704556654073533j, -0.74056700667340003+3.9958069996884769j, 1.8376229758120008+4.8939057972543516j, 0.56097592637522953+1.1962336897882726j, -1.3522314207704584-2.3788885700721187j, -0.3910200060975908-2.0276298492296441j, 1.1696744495267888+2.4194144879695001j, 0.61111633566009804+1.9810226991014681j, -1.2570081724109712-2.4256572995991448j, -2.0379607424382673-2.3401230961329462j, -0.11895117415507916-0.20168228572033531j, -1.1721585258230467-0.40434726332170645j, -0.87007913988881902+1.0470079216653014j, 1.0632956396927513+0.86183414835909822j, -0.38580133850999232+4.9648768523408924j, -1.1378511659644674+3.5600642062343684j, 0.059277285920489975+2.2071682852740224j, 0.32981878804494424+2.0708756974471436j, 1.5954797850952303+3.9506597955061187j, 1.113967802900363+3.8105501539801976j, -0.34187488675854677+3.0267213287624557j, 0.18662232048160876-1.2571845658067642j, 2.7139610044225382+0.69222466212540557j, 1.4373026138501541+3.902110493851922j, 2.3082293966444007+2.2987716217551775j, 1.3462006391244148-0.10182718246119304j, -1.0329879104957191-1.0590332100623074j, -3.0810859363267094+3.1945037345098988j, 0.77362743359084163+0.84013578687826662j, 1.0464890345883808-0.72771732260634059j, -0.51744859070890492-0.81451970371406568j, -2.9428700854575434+2.762899585992368j, -0.40115243174986093+3.8372871200581486j, 0.96128270685925343+0.93840717545663799j, 0.41639434446527768+2.5331280325752732j, -0.519386987039123+4.2723375559049348j, 0.52495944959322849+0.8116227621810026j, 2.5244086242304857-1.89004339281529j, 2.0195410343451292+0.21295550110166039j, -1.8684314756711684+2.3019863570099734j, 4.0113534030248825+2.4322957453578007j, 2.5067778456719454+1.3635087014727825j, 1.8581737323759087-1.1755871365622586j, -3.278606394868425-0.74168306105753778j, -1.6581650987018286+3.4206773381711715j, -0.20328962742120149-2.6517323129301227j, 0.11939427685928439-3.914762222637826j, -1.1719762486786653-3.6258016903482262j, -1.9695972814337694+4.7844819781500254j, 0.70410051090004111-0.63082142973243238j, 0.58203862242748194+0.17092305557744025j, -1.0446335319978968+2.2194447533251744j, 0.15655310887242035+0.86561734274560376j, 0.31563746550827387-2.9298241668860747j, 2.7860378031530235-1.0136028592766184j, -4.3782229028819648-0.33971568537612828j, -3.0909568032763324+2.5513031796814909j, 4.6737413708938655+2.7302786045020038j, 0.13272621959023939-4.1711765732663011j, -2.2749762169482466+0.25421841905327258j, -0.50489760751634882-0.91377903881434097j, -2.287069616277897-1.0631181589973533j, 0.7972895323203042-3.4207848305117969j, -0.23326908605637886+1.089382332171946j, 0.0098601007056405704+1.4586475390991032j, 1.0365833871785477-2.4620420564717742j, 0.36572720828156252+1.6541853704371952j, -0.51430469009147317-0.049252228418473765j, -0.62145289699741391-3.375619986564951j, 0.35466808756859192-1.3690595024956109j, -0.25322914773962185+0.32316646758647627j, -7.4892488525844554+1.1525104561324868j, -0.12392585470999483+2.4297661937947765j, 4.2905861596881323+0.67018882572843463j, 2.3390789232929543-2.3191321695784399j, -0.44619718489570181-3.8333096552555777j, 0.51352876521471524-1.6804333968219132j, -1.7025201697344337-0.1008347592396226j, -1.477972480809314+4.2322266421353856j, 1.399058406997034+0.63203496833525186j, -0.039998736140595348+3.1534667411092578j, 0.001699954715300489-1.6894128318777268j, 1.8608282629517956+0.54462233467286736j, 0.022347730866276339+0.94097808664808924j, -0.97565390581191991-2.0043597662134327j, -0.85205216583024623-2.2679689843892588j, 0.53947735206622338+0.92108210028888182j, -2.5670596443819931+0.38871863049383093j, -2.934869851153608+1.2511147622702086j, 2.0825683383127727+0.45929928305134715j, 0.37898448820629005-2.6841486733486013j, 1.0120152854590612-1.6425972444002646j, 0.7776935701538118-1.952106003854329j, -1.2780368759454575+4.6651596443819408j, -0.039206971051687134+5.265018964377389j, -0.54489461163081254+2.8671152905341284j, -1.636083304638287+1.8615197052158607j, 1.4325345827348386-0.58443769148648628j, 1.8893019352323406+0.93513602825308595j, -2.139093319814994+0.49456047669865844j, 0.033273312452318238-0.67524051231226145j, 0.0018165800924796471+0.24539790830842012j, -1.830677860003034-0.88907276825821402j, 0.23881421516801424-0.71660110558242596j, 1.4607757935805321-0.20332350008812516j, 0.31479988117869262-1.4797543881405799j, -1.4700646395419654-2.3412000314939014j, 1.3630043099840954+1.0459288308034624j, 1.0366509002025306+1.4017065365354837j, 0.5324643362883491-0.19564285336892207j, 0.86203010112261591+3.8589883704164376j, -1.4871335108899939+3.2965305219683243j, -3.506476212648844+3.1925528967103802j, 0.15264175448604056+0.431490908418659j, 4.2777064175487407-1.2512757866202306j, -1.1870189698038707+0.75501344481612265j, -1.839602146399741+1.4963403982128953j, 2.3099273465758903+1.2697775493766699j, -4.3475497187867314-0.32036886085994221j, -3.3064040751562334-2.9625087732893531j, 3.6141886575697248-0.0099341031074851038j, 0.0048861040277541345-0.6295182389123023j, 1.5000073794953357-0.88609288760098115j, 2.2323719937100908+5.4902541505729845j, -0.2585807286071018+2.5584952206368938j, 1.7769833707262548-0.3408851516775957j, 0.37978034270511074+2.9026249163611726j, -4.6921406543266571+4.3678134780358526j, -2.4462636775404958+1.4523419567722944j, 5.2941943690732423-2.6008774047519228j, 3.4595406699843201-0.99129783569826058j, -3.4841770617209473+1.2717869796731138j, 0.13850539692866526+0.94282786052434553j, -2.1789230651774014+1.6415064719591206j, -8.811149558407779-0.86858984219214674j, -0.98048863671795994+0.035234022992954195j, 2.3501190627193562+2.7317457688466678j, -1.5421024919985193-1.7186736892960668j, 2.139635096504529-1.8367715460959313j, 0.41669207038592981+3.3753865855933527j, 0.42812877807536154+0.88267208286037602j, -1.6620756081654045+5.368686741364268j, -5.4496694415397027+3.4393514966821126j, 3.2274980963579551-2.6154731433818244j, 1.2325162367548854+0.25900311819665534j, -4.9927575224429273-0.77655205094166613j, -3.9137002256716968-0.87208435187132305j, -5.8396208197376538-0.033400550471304857j, 0.88165596824067283+3.3402495465420188j, -0.77813555128307499-0.49824566884112964j, -1.2569589183195746-3.992299237539171j, -0.55073556348169195-0.99367233232065755j, -3.1361715966867241+3.8990411125610152j, -1.2479889140797951-0.86728888508048596j, -3.438346192247995+0.75427470765301274j, -5.8362598289444767-3.7106623335656881j, -1.6220739622888261-0.85412380326550341j, -2.3618246988425389+0.10262957279861007j, -2.0128151752491599-5.2483459258638678j, -0.28798741542347162+0.082139772535972211j, -4.4336542047160892-0.12984758528642848j, -3.0452434904226706-0.34940617145697844j]), 
         2 : np.array([-1.1165046042602529+0.74756586618731813j, 2.9563864696268687+1.016510598068517j, -1.7273931284275377+1.684970250530498j, 2.1374510755011236+1.3953489111135389j, 1.264058043394483+1.0656402139582337j, 0.59206130659344847+2.8140992156732278j, 0.062093775185857902+2.0904994744842891j, 2.9429778836437221+1.7128991560692999j, -2.6110141508418021+1.1140285432863466j, 2.326165567157239+3.2728054144888676j, 2.6626908823784907+0.52728366204875832j, 3.5908021600075641+0.96903781804179978j, 0.90571149765085535+0.24081124592692693j, 0.72871814828353709+1.332418563783788j, 0.60164374752130945+0.15445148430884423j, -2.5529506354313782-2.3304064585375239j, -1.8879418959660019+2.682343033625215j, 2.1668168490952775+1.4157064593061692j, -3.1636708644108649+0.64742953025658889j, -1.4210029334653473+2.6334896788286049j, 3.6902066347461573+0.13892873924238483j, 2.9575090399303945-2.6325502244852719j, 0.17878513667675777-1.1585078531329858j, 2.1237001808101663-1.323323837586023j, -0.16120044138369383-1.2121424743269673j, 0.8624452370473753-1.0686957121793859j, -0.51467053641764826-1.1945130365136154j, -0.18418165278174148-0.59116856193750777j, -2.6169185838042068-2.4146314558175046j, -2.7622714373457917-2.3797351683439834j, 0.073910048482292545+0.16496145279596552j, 0.80910813851825103+0.56242050573198998j, -1.9584133243280075+1.0892351163388432j, -2.1814162287477559+0.61054532617299695j, -1.5169577705416253-1.0235623545618981j, 1.9895718538585976-1.8211523939205545j, 2.4118671091811361-1.9453281674321252j, -1.3835825480021706-2.94255319882138j, -3.3831677322689044-2.4580709837790149j, -1.0643850899431524-2.7522668625312905j, -1.9640650365404291-0.35711187195874783j, 2.0439239983559903-0.31240155157933036j, -0.22521863704724376-3.4584160218021305j, -0.51534527570261424+1.0301056642659554j, -0.81562474322987222+3.7503264056978267j, -0.060726807609905009+1.8031960877879551j, 0.86667213746967398-2.9028917378472125j, -0.15387539712023934+0.13908261984620263j, 0.45953137238099684+2.2626118142274105j, 0.62744200989512788+1.9272207054022881j, -2.3255110017526608-0.53695630414710283j, -1.5190658716876777-0.9208472578106438j, 2.137223495429847+0.68320323689351148j, 3.1584401529074442+1.7321545691722557j, -1.1125695286320998-3.2076280088399511j, -3.7060965836044932-1.9780143459066473j, -0.0012842332451774574+3.2452953615132838j, 2.2855371052053712-1.1752563745986131j, -1.7649471509112493-0.88061905568140997j, 0.75495292840738937+3.6278072525475187j, -0.49646600004863894+5.9486839669421894j, 2.9426274856719101+1.0146400853383064j, -1.5434946162364205-1.1288427968038663j, 0.1004948003661843+2.7446408233087585j, 1.6891184209589296+3.1297213004998374j, -0.05236089581184955+1.9379909861717084j, -2.5137867334898658+1.4249473105986246j, 1.649739972413804-0.1284157001992281j, 3.8737660306719093+4.4058712012072778j, 5.5734334582390925-0.01859570677500616j, 0.034418186067761702-3.7863468040480583j, -3.6185785482837716+0.87492996512854082j, -3.523709866409459+3.8351231556344709j, 1.9035220821258987+3.5762696257910473j, -1.3355317211315365-0.12437729138156417j, 0.27233720824024044+0.62568960888382408j, -0.087131156071871274-0.010324624464344678j, 1.4827889367880731+2.2703868481775364j, -0.27368753287508718-0.23035237674465425j, -2.3786689738351767+1.4567486754553038j, 1.4386131990647175+2.4034598349374283j, 0.066680160631143237+2.7232295144266274j, -1.666407419777012+2.9083944127863561j, 1.3023780882542342+0.52194039596842601j, 3.3146056296510493+0.66745607226026649j, 4.2456604060579677+3.8969561221755749j, 4.1998262021248625-4.0793461167911262j, -0.76421358406766027-1.2315027885578802j, -1.5357398471693586+3.7748327293868642j, 0.095984948174640872+2.2104973139657291j, -1.4588631998320354+1.134201407450617j, 1.6387745345036606-3.8466513697644413j, -0.73057877816794492-4.655134203127945j, 1.6085189126683648-0.21988000108022218j, -3.1142178896816564+0.091923489293964877j, 0.62820278401392149+0.1889975872022136j, -0.16120633228908154+1.9707163592075072j, -1.235116936758984+2.1482450245585314j, -0.021985008426573249+1.1038279261596868j, 3.6413478144793245-1.5615567405467394j, 1.836327464800555+2.8541227399557041j, 0.93919940461177709+0.14620058990910742j, 0.95456236801488359-3.2026192357315972j, -1.7481075885435755+1.6730186360367643j, -0.84626775726936276+1.6575377579793631j, -0.26164286832258099+0.76088427278556803j, -1.2966015229936554+0.97676041471092478j, 1.6124370820759013-0.58585228456899752j, -0.21994376085816314-6.2532282013448075j, 0.8353593803854652-3.6420691105508212j, -0.03824087822866562-0.054729642257138833j, -1.3319497354973748-2.0327095379389153j, 0.75662881948485083+0.30541845281794644j, -0.76757214187579981+2.2787455111432591j, -0.455100077730823-0.55830706795474327j, 1.3313718654711193-1.5460827721627417j, 2.9912065916181261+0.77182516673656876j, -0.52278090407902422+2.7877639036769803j, -2.3528997632544266-1.2308866273244197j, 0.27817666198979296+0.059213451422733376j, 0.45875812556331846-1.2692467729246268j, -0.45874375601474504-2.3686526493885238j, 0.479232709947924-0.3060902759460391j, 1.4895902195529662-0.41735115244048793j, -0.85025677044974457-2.3693856367193904j, 2.0718452260590321-0.54927604975188671j, -1.176356516666446-1.9392922793319025j, -0.79423474673281291-2.1390403821586896j, 0.25372445079390721+3.1629513441654384j, 0.54044572189189222+0.18770434833000893j, -0.32776474396893496-2.9986158756129355j, 1.8555964580559503+0.64523330354515551j, 2.6163923211891467+2.0073816231373094j, -0.96827837897054836-0.20669532105285635j, -1.6161700297890988+0.058760459668895204j, 1.0388341083117685+1.0343083372958142j, 0.8171690777526357-1.0241901711901955j, 1.161178491272123-3.3193021589202116j, -0.65705952284124769-2.909740964518341j, 1.0464027137937968-0.28516514967891382j, 0.31407614249026861+2.0789914726795806j, 0.89249898217038592+0.74504430864132187j, 0.46653627607511738-1.2535459455441251j, -2.8759949933021893-3.4253168189020871j, -0.55004579155281808+1.4416964251162601j, 1.3842770119914176+3.7499085234789105j, 0.73300538480603206-2.3651197461061306j, 1.2610841999098341-0.04478569409858002j, 2.2663256193995895+2.6893001805232006j, 3.2282105473513854-3.089294872359758j, 1.0246687806608903-2.1329916398440454j, -0.79719171443068326+1.1114942772440388j, 2.3820851781718693-1.9138147704390083j, 1.478151603469551+0.15364879065364989j, -1.5233345516736922-1.3099212472909443j, 1.5072515797375459-0.57475142166442117j, 2.1228188430644579+2.0096979974944369j, 0.16349467160657194-0.13019412026157573j, -2.8501863703427208-4.0570052570082602j, -1.0157135917807159-2.6825682466889411j, 2.3253206740804364+4.1263405715172157j, 1.5487387410680176+2.2318083306172714j, 3.3480777012584348-0.30034799964836079j, 2.7011245606581289+4.7335734563336729j, 0.57254668180230106-1.6139253460404996j, 3.903853955673366-6.6991967093618143j, 0.64492682991521111-0.31017629667123225j, -2.1607929176337426-0.16857297635682733j, 4.8098868433499913+0.41785061609925878j, 1.1564314939094591+4.3710892388226963j, 1.8224691599081939-0.63910766786442408j, 2.6435565518448572+2.9094520705913056j, -3.7780259549880189-2.1074067076770948j, 1.5393672791948894-5.2619312349734786j, 4.5356550511622213+4.2698512297085127j, 2.3969803974124391+1.9571123112588573j, 3.6061144615068086+4.3736176949628423j, -0.39324476338149617-1.9082883633012435j, 3.026448300108715-1.7428825416966158j, -1.9045802882682787+0.4426906193634812j, 5.0241978704119958+1.9445871037916549j, 2.6831636546598459+3.0839149450548007j, -1.4019967581265769+5.0027949271902887j, -0.0031667657498008206-5.3402188332400726j, 2.9517714615379806+4.0246422636276797j, 1.4785600380549067+0.51660087996842741j, 2.7856553478477579-0.88532969501753778j, 0.2673738444085586+2.2859423305476705j, 2.7550882281445315+0.58476661154179221j, -3.2828096156515181+0.45102580026710948j, -1.8220345108884464-0.00054247733982548674j, 3.2007680062608741+2.4615774393552337j]), 
         3 : np.array([-0.66999593287202142+0.46243708757420809j, 0.82115988275196528-1.6643038327885704j, 0.67399713542071471-2.3955600817810208j, 2.215439913637927+0.72446638537859487j, 0.93108120226407332+0.064033670430578393j, -0.92739574739897401+2.2493044552029375j, 4.0678984753394341+3.2507085430096483j, -1.3168389222564625-0.80923697224245794j, 2.4067925151982705+0.92813675598570766j, -2.0493109031701429-0.49108376461287684j, 1.6349441369388815+4.1340925667887625j, 2.5312429669372829+0.44393295017157475j, 2.2198800992090253-0.20688768772829413j, -0.053776255855561117+2.1684193251401833j, -0.74507569207418511+2.0534600226420934j, 1.0590676473818048+3.4665027379637494j, 2.5831500212178433+0.10767106535418591j, -0.81172453742230211+1.5135115252098388j, 0.51675313192529826+1.7364523664094207j, 0.017777040747489425+0.33054862825595765j, -0.031923375391498365-0.03647474837162834j, 0.75627328628012946+2.5870613579433228j, 4.0854570875479279+2.1694354582233544j, 3.5281541314540927+0.20192676958354183j, 1.2898229939329962-2.8439309558484345j, -1.4676716747053+1.2550839973056764j, 1.4660283077695149+1.250015105410669j, -0.24960947184476789-1.274656996015006j, -2.105841001070178-2.0766118645037839j, -2.4893754811904127-0.40574540171916373j, 1.1819182474823142+1.2543311034554072j, 0.66112124774937775+0.73421234301293936j, -1.5435321344721677+0.2405604201908027j, -2.5174124636556181+1.1618925572216374j, 0.69011465007947015-0.52483143713649749j, 1.5464610264677234-2.6451243970838227j, -0.097592832333731394-2.1470448648923481j, -1.7790027249170768+1.4929022997757122j, 2.1060693685955689+0.72313993979877744j, 3.1638994698726481-2.1269139943415407j, 2.2107279234732862-5.0404555730899059j, -2.5209363703464924-3.302312046473193j, 0.12059012761921761+1.3587818158227796j, 1.8826126043065536-1.5865310833153738j, -0.57070268838796012-1.585154256627491j, -4.7784601734110614-3.8493106222543396j, -1.4421251579517258+0.98946495072189533j, 3.1612898053286718-0.44422399561859394j, -0.27830641044372373-0.94412748500393695j, -2.6942690780226708+0.22023121586779437j, -1.2938276668529529-0.06583465169229219j, -0.18392187376248736-3.6374010616991139j, 1.3907294398416794-3.5152092057270137j, -4.2456806268120735-2.3371824677843467j, -4.5174367628342278+3.0159027596758059j, 1.4569480295154498-0.40481687203522998j, 0.24452064515296237-5.5529329980953808j, -2.1273220239180053-0.73593942867713091j, 1.595151423023013-1.1401776866728879j, 0.15780690321442792+2.2661324101587246j, -0.74933288055404634+1.3749431486856962j, -3.0816809779382717+0.23742643682485964j, 2.8994367119049036+0.7396921744800089j, 1.4994335029613002-1.2798108792722671j, -0.16539584890629019+0.48010791918853934j, -0.89194363806978616+0.7170467910739301j, -2.1293682627235322-2.5845385071231268j, -0.63427315935121464-2.1595594356167398j, 0.99308347169563682-1.8514493405763055j, -5.4450584092937877+0.97902894760670878j, -1.0604698602513214+3.2312043227524949j, 2.3124452902496664-1.3950895449462946j, 1.3201823408003734-1.6028209931750983j, -0.87616516312961035-2.1465631953543003j, -0.34056443490530253-0.35013249591511048j, -1.2364508408450898+0.13781313196431211j, 0.038609534515580135+6.8698762949471899j, 0.12380533905802339+2.7921341862952316j, 0.54660167417157157+2.7346629269827281j, 1.6952037866074647-0.33387389764274045j, 0.94628165540958409+1.2037205024287594j, 0.68176721298456666+1.3320274860427599j, -1.497001928100073+0.16859140871709216j, -2.9208164653643847-2.013262526262011j, 2.23493624166204+0.38888195090814426j, 0.083266882937527834+0.042519190431531406j, -0.81622472526299195+1.602983850729655j, 1.9107865697855551+1.8860940491210119j, -0.5161686146069725+0.1067286365498733j, -0.56830015109909349+1.5080358150275226j, -1.9977061163459469-1.2634518707513132j, -2.7762791817204802+2.8410553962536476j, 1.5348104323655993+3.8209466359027746j, 1.0447821110316866+2.8953941140696262j, -0.16156969418429323+2.1568137355441648j, 1.1423882118876016+0.80959057152946856j, 1.2184203681166248+1.6431143641185439j, -1.3333936354073923+1.3051448172275528j, -2.2003497621202652+0.034485634672569598j, 0.48305931966908489-1.0059947680083925j, 2.4240719735430218+1.520434513132964j, 0.14152780483805999+0.38291838819136248j, 2.6247680254133194-0.34273750279620985j, 0.5170632044924367+1.5591723010537319j, -1.964084322524609+2.2043273581641452j, -1.1123693520916111+2.9076285022885537j, -1.0205304639064758+1.726462948906172j, -3.0513199493069254-1.3262259566094576j, -1.1782640915309317-0.13290415044827952j, 2.2282976599379309-0.72321887567511034j, -0.60179533239909233+3.307433985055094j, 0.16788252783154045+1.0362178538533637j, 2.6706953553371453+0.77074105928608427j, -1.8533672105796244+0.35596405935487074j, -2.6147380869392443+1.6093046768585832j, 0.37759170296150524-1.5083149569782319j, 1.8716643004532001-0.35801239552465747j, -1.1450981234973723+3.042261086804297j, 0.44452106639608746-0.69350503725695845j, 1.4879090143200902-0.64776217405327741j, -2.8205775502795389+2.641687352135917j, -0.93692044263706187+3.0048923877610507j, -0.426546964943878+0.013344667316707221j, -1.4443525828613666-1.7131214807111499j, -0.14354399201917334-4.0206831461274337j, 0.83443104253838163+0.29432217858366894j, -0.93252862665525393+2.9364673343460126j, 3.4431983705905731-0.3251990454994399j, 0.43806792303059483-0.70784096193188306j, -4.4119004072708137+0.24052114921567447j, -0.98891595175430935-0.46079086925838275j, 1.7417334974194558-2.9208658301095776j, -1.5454462711687187+2.5296917145427482j, -3.3282492610480996+4.156447539050224j, 0.40902409375307852-0.76847358054292236j, -0.56330685439900319+0.69661436668049836j, -1.8762485869816681+0.64778551016479047j, -2.4393425483279865+0.85171074321319784j, -0.209819964163376+0.099157970328755729j, 1.2392961839922023-0.64639270138790006j, -1.1641752459378989-1.4971678104463564j, -0.56703471832581931-2.1716088946899359j, -0.16437097090423169+3.1220884585750146j, 1.3539163377460306+1.1869107505913261j, 2.9491476787185125-1.2808347797003192j, -3.2908684053012207-0.88608324309025921j, -4.1007674458331485-1.4527729940313197j, 0.44035311401335531-3.1365712871936395j, -1.0141686129277752-0.63568191152634734j, -3.4102891864012639+4.2247127971259122j, -1.1836594760112424+3.781939963215049j, 0.51422023588565446+0.57579154063617177j, -2.0246664119505891-2.237040145119146j, -2.2053210495403732-1.3846005574579319j, -1.1160865960532751-2.5475738207830227j, 0.50275220925239728-1.2519481985598606j, -1.2100185502945444-0.16812837098982908j, -0.59983421887255994+1.6027230741262604j, -0.52478938635633754+2.458183305060198j, 1.5028757257080834-0.72420113128118369j, -0.31146843994891138-0.27135667939274499j, -5.1133106827158112-1.8113241566448617j, -1.5548284863229618-4.0468311536026844j, -0.73513228831134692-0.50030377688003924j, -4.1474633033600306+0.067247755883021731j, 0.21758777097351378+1.278485302383952j, 1.2889426032473679+3.3676304645801252j, -1.6413393543174832-0.091092522462874137j, -0.40598559211980501-3.5363616320930467j, -4.4770433756596688-1.0937535548777739j, -1.2734316477554803-5.4194063797821297j, 0.97449379705901817+0.49671560815912308j, -2.4145658013036444+1.063978254382109j, 0.99809956584583803-2.5020372804114697j, -0.12266974796697871+1.5896940246064126j, -2.8686854657724843-3.1801933594238334j, -0.082981417033829663+1.7518152509849325j, -5.3524188522498743-2.1053297170691661j, 2.5900259839505644-0.061488539624564797j, -3.4408514291718109-0.25659858369140398j, 1.1709160532948188-1.3230248129652447j, -2.9408323582582936-4.5277551603690283j, -0.28478178944932209+2.5139667584019603j, 0.28384136446055264-6.2274346660954141j, 1.0139856934187432+3.7690735174469179j, -0.0078974510283624788+1.2194467618092526j, -2.7712491346368346-2.8279715184334919j, -2.992529715098045+0.56058068732562871j, 0.84316411435805716-0.86466988408221113j, -5.5804660954223984-2.9335962670233511j, -2.5482718063619298+3.9524532393702518j, 1.0516464424971148+1.578274341181523j]) }

glms = { 1 : np.array([0., 0.84319998566330767+0j, -1.0248100911568008+0j, 1.110961761523819+0j, -1.0626942039579403+0j, 0.99145170493860635+0j, -1.2628244164642952+0j, -0.63157305188622881+0j, -1.1573098411259166+0j, 0.98774392762746244-2.3324463135047853j, -0.42041547702109927-0.6638941892709691j, 0.17949892445575544-0.18716973000962853j, 0.26430768591955539-0.40505260468553134j, -0.24063674747596783-0.01667629102507856j, 0.20243814807193189-0.061501040558063963j, 0.074181600901263869+0.13110650173965177j, 0.70925473188372479+0.65335194343646219j, 0.4879926917946677+0.31352391256853401j, -0.35809352192298388-1.0728322735956963j, 0.4533725297757551-0.22559691758977207j, -0.60038286724379097-0.11246033971793468j, 0.66825095356633812-0.60076635444258042j, -1.1946567473464309-0.22635664737160516j, 0.40228588081801298+0.068430477904664722j, -0.9882729303598855-0.46953404636080764j, 0.71188035470148237-0.92234375063488339j, -0.42665812492162319-0.12577894001454354j, -0.76472165401579706-0.26752959905101342j, -0.0060656639141563051-0.93138763769826982j, 0.89415079943278952-0.066507100471720232j, -0.61447982075563323+0.87348984596560353j, -0.78070473872335344-0.78753205263021409j, -1.1191256017366982-0.60047283637051052j, 0.2133088567364409-1.464647765466137j, -0.23425203712922088+0.80569933612650535j, -1.1366303557443924-0.32263741303024324j, 0.2041593807964231+1.0927143488558069j, 0.43611791501355668-0.46222719965613662j, 0.13160849960684828-0.025453022150853984j, -0.39955107839159809+0.85522030725234566j, 0.55636294499207284-0.77063085552936683j, 0.50643037413406744+0.15921955235797908j, -0.67794895826681578-0.2302258170581491j, -0.057766506371200475-0.13606392096680481j, 0.2681214210068823-0.75888465889983925j]), 
         2 : np.array([0., 0., -1.0146369650118083+0j, 1.11121557988063+0j, -1.0268187317357511+0j, 0.98244234543551479+0j, -1.2007880041682084+0j, -0.69447547017176625+0j, -1.0726374658022424+0j, 0., -0.40253474561900393-0.65784721719896422j, 0.15199112969379647-0.24330956005348325j, 0.28523253658954206-0.3981266584575725j, -0.26845152711149062-0.083593980089662734j, 0.19959571779331189-0.057385723112071435j, 0.048274474287257146+0.05571849108314867j, 0.66612416673860797+0.66489298075894143j, 0.47445092525264315+0.33233327925496392j, -0.33978651546110278-1.0700406529115529j, 0.42170150945972673-0.20638423667056441j, -0.5630841470957999-0.12922848005411802j, 0.61971326220555945-0.56144750223866158j, -1.1423916258591016-0.25581299034320437j, 0.34730218633923393+0.10618832232762943j, -0.99822733104115735-0.4682367163596412j, 0.70620977727778933-0.90938188008554444j, -0.44219516027124856-0.13493822626962626j, -0.78951918570902713-0.23576709704052287j, -0.014428235772776353-0.97751697894267986j, 0.81909761987552843-0.032145061525208574j, -0.59959900791799092+0.87660510575181094j, -0.77968569605966409-0.81916479783758211j, -1.0543271356804378-0.59294085416609699j, 0.21451468853321071-1.575924063487286j, -0.097584235980056111+0.79606153258991741j, -1.1425268084073952-0.33343881952558124j, 0.20815667516194364+1.0864812143836942j, 0.42124636529500581-0.49483794628510092j, 0.12538155362131775-0.054095442648732069j, -0.40820405930119319+0.85936840188813757j, 0.57774999828224061-0.79228000632060525j, 0.45984172555887304+0.1760761108040782j, -0.69197600035251772-0.22762901382604028j, -0.068152714393202821-0.13031971412287957j, 0.28004810987754036-0.74648931403104868j]), 
         3 : np.array([0., 0., 0., 1.1040780794436231+0j, -1.0554780343915136+0j, 1.003760955073254+0j, -1.2565856441338645+0j, -0.62932602562674234+0j, -1.160067204424214+0j, 0., 0., 0.15865387620507715-0.23612586328728333j, 0.27391824074536975-0.40229821680653666j, -0.24904217061890843-0.066454748333335312j, 0.19465514972961681-0.071603817219522803j, 0.07585111789946225+0.10671255623789123j, 0.67521859645108184+0.63791014584128802j, 0., -0.34816350138864738-1.084783542403446j, 0.43615290425078285-0.22284828128529358j, -0.57324320239356563-0.14126286640853886j, 0.65304426498325374-0.6000904287578529j, -1.165079833528107-0.26540336287320754j, 0.38879888788337164+0.049892403597867507j, -0.95196155755809375-0.46240128463150965j, 0.66010872131183373-0.89379242001828385j, -0.38155334031368932-0.11319555736108271j, -0.83737598920187895-0.23689666124954797j, 0.036024621196599382-0.93058744213774647j, 0.79480395548872762-0.042441974598074916j, -0.61480456309191522+0.88772972943182071j, -0.77889262539414239-0.76334259507894808j, -1.1118023694151189-0.59375535579172312j, 0.21015147536095025-1.4894366921848528j, -0.20540486553192566+0.80716874886526713j, -1.1317123907310076-0.32257306660406088j, 0.18948788955123907+1.0757829951402618j, 0.45816121337749072-0.46825028118838685j, 0.094048425004741185-0.062988484577269799j, -0.40021838153849576+0.85629510171370782j, 0.54773135746681112-0.76849935301866623j, 0.49872929242448694+0.14779843610587595j, -0.67415810187311553-0.22910004410769433j, -0.05652956808223264-0.13895923733616072j, 0.26192691834998399-0.75985770223080795j]) }

clms = { 1 : np.array([0., -1.5258173689739127+0j, -0.38321729790014736+0j, -0.67468807400536313+0j, 0.42460653551185651+0j, 1.3828469966900694+0j, -1.4606906476867365+0j, -1.1024802895292889+0j, -1.6258480748456989+0j, 0.72184388572247027-0.40980679076163978j, 1.155123366597125-0.00025652164718847903j, -0.046798126366738545+0.38718565377077507j, 0.14209457945669973-0.89695521394655509j, -0.81580217823771384-0.40181448848956358j, 0.41047881458968138-0.1152355464248823j, 0.25214366009371275+0.13596558218505578j, -0.48642804026342107-0.51921699092205253j, 0.70318282623713557+1.1149229917786518j, -0.2620711198443052-1.2608592875108899j, -0.32886228833465481+0.28343506891478615j, 0.87116700915729073+0.12201153895105338j, 0.61061947387230175-0.13255341818790078j, 0.20682058643208909-0.18157727548793343j, -1.012535222212142+0.35770276797463263j, 0.82344404513932368+0.081123452026155174j, -0.36925633394180285-0.28239296801331859j, -0.13701971130554524+1.0015322075605051j, -0.17636539799409506-0.23987373576395629j, -0.61110525471621113+0.8387900954265588j, -0.38131027712597904-0.36432117739386211j, -1.0079042770692939+0.9484888310663222j, 0.53963333913487466-0.15889892563621916j, 0.90252874051924248+0.047882748600954872j, 0.77742302026156063-0.28243856974519727j, -0.9721760087917013+0.49058350689687308j, 0.50365618535953161+0.8080725210109363j, 1.0815686965383575-0.70497162383482825j, -0.83122125861324603+1.0900112211266584j, 0.63134176691035382-1.1506771025986287j, -0.25413053864796836+0.029385890444217244j, -0.056623996602004172-0.26225905883112283j, 0.79047827545371763+0.14640251150139555j, -0.24482352824373257+0.055856847996116454j, -0.34090568518036446+0.31363733143816142j, 0.4367718299537125+0.17676151335880672j]), 
         2 : np.array([0., 0., -0.38326814027750383+0j, -0.65418849087307329+0j, 0.4365892671577063+0j, 1.3803202920785584+0j, -1.4916247379419461+0j, -1.1324277132571721+0j, -1.718185868626174+0j, 0., 1.1956968215533583-0.030205892584907437j, -0.046100534504420865+0.41807122036767436j, 0.20782483037951727-0.94246433056743517j, -0.83529709861832213-0.33903347515975163j, 0.48223350794745773-0.1926218400020257j, 0.21761499886653402+0.23961747977479567j, -0.41751923193484447-0.6353671827291465j, 0.69260449292859827+1.130305228894001j, -0.27954119293120033-1.2766279639264633j, -0.33817969510878398+0.30951969744288232j, 0.83742868793014358+0.091212369129396176j, 0.58571691217352817-0.070712873379824182j, 0.14679306846624376-0.21513933832793367j, -1.0638029100403115+0.41792437931719256j, 0.8237611915825912+0.077755997607020733j, -0.37108969890984272-0.30238750878485998j, -0.14723325508395391+0.9932281688841047j, -0.19383569442563495-0.29295381202435722j, -0.60670529686130736+0.83380243303561374j, -0.45917079393130283-0.47912168797908361j, -0.99345730695253176+0.94820175796661454j, 0.52649034820916507-0.12783909225900825j, 0.95924022156146393+0.055538327979596458j, 0.75064860942575096-0.21370815773918539j, -0.84586566942124497+0.51342826175108991j, 0.50395723769037315+0.813189467153421j, 1.1022997429292671-0.71579859067105911j, -0.81673852639172906+1.1007947378391343j, 0.68458074409331271-1.1856051362879017j, -0.25008109729217404+0.039905637802000099j, -0.062189175604629054-0.28221196312220687j, 0.78892563532515847+0.20103962113750989j, -0.2427808848517484+0.05747362398942496j, -0.36648874880005772+0.26046556342439908j, 0.46087686583398435+0.18234525262036616j]), 
         3 : np.array([0., 0., 0., -0.65872355978145192+0j, 0.43111157992422688+0j, 1.3933719902449626+0j, -1.4337104872664086+0j, -1.0953871385562564+0j, -1.592919216965424+0j, 0., 0., -0.037750501706858508+0.4056437707216613j, 0.19266431434449349-0.92413738054154204j, -0.80624682077443821-0.3750231326847116j, 0.44820402588981811-0.14801697141861184j, 0.25229035881318124+0.17607723506064732j, -0.47384685147145073-0.54847200740427982j, 0., -0.26403005654710615-1.2664841194732137j, -0.31764611275074489+0.29566346120804393j, 0.85876964582432236+0.11833464087123241j, 0.62548078652733941-0.10502140662441077j, 0.18551399493477491-0.18721874018509277j, -0.9828066043226521+0.38082405462307395j, 0.80637975865752387+0.038495909743214873j, -0.37901190842236099-0.24290178119622488j, -0.15681111690711577+0.93523746819782994j, -0.19823080090222214-0.21435654151321781j, -0.61995793538329469+0.75489242177728544j, -0.4291786442205881-0.3647575706316637j, -1.036373422481776+0.9498490485674238j, 0.52091939787694486-0.16079466106792323j, 0.90447971944064343+0.049384983566628349j, 0.76161216915691299-0.28843184314201131j, -0.921447188295894+0.49222438394413293j, 0.50972830882201325+0.80496870972031798j, 1.0799130050305059-0.69042579996889542j, -0.80230481303668388+1.0710316308031511j, 0.65228711481346291-1.1285250709486818j, -0.25636616152524505+0.027205860798986677j, -0.052885291187932219-0.26226354597662616j, 0.76408397668509698+0.13719891764968475j, -0.24129807401981906+0.059572855113709577j, -0.35702076334353117+0.30851416270921495j, 0.42377772250897539+0.17587202874134827j]) }
    
class TestSpinFunc(unittest.TestCase):

    def setUp(self):
        self.nside = 64
        self.lmax  = self.nside
        
        seed = 12345
        np.random.seed(seed)
        self.mapr = hp.synfast( np.ones(self.lmax+1), self.nside, pixwin=False, fwhm=0.0, sigma=None )
        self.mapi = hp.synfast( np.ones(self.lmax+1), self.nside, pixwin=False, fwhm=0.0, sigma=None )

        self.almg = hp.synalm( np.ones(self.lmax+1), self.lmax )
        self.almc = hp.synalm( np.ones(self.lmax+1), self.lmax )

    def test_der1(self):
        """ compare output of alm2map_der1 with the equivalent spin-1 transform using alm2map_spin """
        
        m, dt_der1, dp_der1 = hp.alm2map_der1( self.almg, self.nside )

        alm_spin            = hp.almxfl( self.almg, np.array( [np.sqrt(l*(l+1.)) for l in six.moves.xrange(0,self.lmax+1)] ), inplace=False )
        dt_spin, dp_spin    = hp.alm2map_spin( [alm_spin, alm_spin*0.], self.nside, 1, self.lmax )

        np.testing.assert_array_almost_equal( dt_der1, dt_spin, decimal=8)
        np.testing.assert_array_almost_equal( dp_der1, dp_spin, decimal=8)

    def test_spin0(self):
        m1 = hp.alm2map( self.almg, self.nside, self.lmax )
        m2_r, m2_i = hp.alm2map_spin( [self.almg, 0.*self.almg], self.nside, 0, self.lmax )

        np.testing.assert_array_almost_equal( m1, m2_r, decimal=8)
        np.testing.assert_array_almost_equal( m1*0., m2_i, decimal=8)

    def test_alm2map_spin_precomputed(self):
        """ compare alm2map_spin outputs to some precomputed results for spin=1,2,3 """
        
        for spin in [1,2,3]:
            rmap, imap = hp.alm2map_spin( [galm, calm], nside_precomputed, spin, lmax_precomputed )
            np.testing.assert_array_almost_equal( rmap, maps[spin].real, decimal=7)
            np.testing.assert_array_almost_equal( imap, maps[spin].imag, decimal=7)

    def test_map2alm_spin_spin_precomputed(self):
        """ compare map2alm_spin outputs to some precomputed results for spin=1,2,3 """
        
        for spin in [1,2,3]:
            tglm, tclm = hp.map2alm_spin( [maps[spin].real, maps[spin].imag], spin, lmax_precomputed )
            np.testing.assert_array_almost_equal( glms[spin], tglm, decimal=7)
            np.testing.assert_array_almost_equal( clms[spin], tclm, decimal=7)

    def test_forward_backward_spin(self):
        """ compare map2alm_spin outputs to alm2map_spin inputs. tolerances are very loose. """
        for spin in [1,2,3]:
            tcl = np.ones(self.lmax+1); tcl[0:spin] = 0.
            almg = hp.almxfl(self.almg, tcl, inplace=False)
            almc = hp.almxfl(self.almc, tcl, inplace=False)
            
            rmap, imap = hp.alm2map_spin( [almg, almc], self.nside, spin, self.lmax )
            tglm, tclm = hp.map2alm_spin( [rmap, imap], spin, self.lmax )
            np.testing.assert_allclose( almg, tglm, rtol=1.e-2, atol=1.e-2)
            np.testing.assert_allclose( almc, tclm, rtol=1.e-2, atol=1.e-2)

            
if __name__ == '__main__':
    unittest.main()
healpy-1.10.3/healpy/test/test_visufunc.py0000664000175000017500000000224413010375075021045 0ustar  zoncazonca00000000000000import matplotlib
matplotlib.use("agg")
import unittest
import numpy as np

import healpy as hp
from ..visufunc import *
from ..zoomtool import mollzoom

class TestNoCrash(unittest.TestCase):
    
    def setUp(self):
        self.nside = 1
        self.m = np.arange(hp.nside2npix(self.nside), dtype=np.double)
        self.ma = self.m.copy()
        self.ma[3] = hp.UNSEEN
        self.ma = hp.ma(self.ma)

    def test_cartview_nocrash(self):
        cartview(self.m)

    def test_mollview_nocrash(self):
        mollview(self.m)

    def test_gnomview_nocrash(self):
        gnomview(self.m)

    def test_orthview_nocrash(self):
        orthview(self.m)

    def test_azeqview_nocrash(self):
        azeqview(self.m)

    def test_mollzoom_nocrash(self):
        mollzoom(self.m)

    def test_cartview_ma_nocrash(self):
        cartview(self.ma)

    def test_mollview_ma_nocrash(self):
        mollview(self.ma)

    def test_gnomview_ma_nocrash(self):
        gnomview(self.ma)

    def test_orthview_ma_nocrash(self):
        orthview(self.ma)

    def test_mollzoom_ma_nocrash(self):
        mollzoom(self.ma)

    def test_azeqview_ma_nocrash(self):
        azeqview(self.ma)
healpy-1.10.3/healpy/__init__.py0000664000175000017500000000503313010375075016723 0ustar  zoncazonca00000000000000# 
#  This file is part of Healpy.
# 
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# 
#  For more information about Healpy, see http://code.google.com/p/healpy
# 
"""HealPy is a package to manipulate Healpix maps (ang2pix, pix2ang) and
compute spherical harmonics tranforms on them.
"""

from .version import __version__

from .pixelfunc import (ma, mask_good, mask_bad,
                       ang2pix, pix2ang,
                       xyf2pix, pix2xyf,
                       pix2vec, vec2pix,
                       vec2ang, ang2vec,
                       nside2npix, npix2nside,
                       nside2order, order2nside,
                       isnsideok, isnpixok,
                       ring2nest, nest2ring, reorder,
                       get_neighbours, get_all_neighbours, max_pixrad, get_interp_val,
                       get_interp_weights,
                       fit_dipole, fit_monopole,
                       remove_dipole, remove_monopole,
                       get_nside, maptype, ud_grade, nside2resol, nside2pixarea,
                       get_map_size)

from .sphtfunc import (anafast, map2alm,
                      alm2map, Alm, synalm, synfast,
                      smoothing, smoothalm, almxfl, alm2cl,
                      pixwin, alm2map_der1, gauss_beam)

from ._query_disc import query_disc, query_strip, query_polygon, boundaries
from ._pixelfunc import ringinfo, pix2ring

from ._sphtools import rotate_alm
from ._sphtools import alm2map_spin_healpy as alm2map_spin
from ._sphtools import map2alm_spin_healpy as map2alm_spin
from .rotator import Rotator, vec2dir, dir2vec
from ._healpy_pixel_lib import UNSEEN
from .visufunc import (mollview,graticule,delgraticules,gnomview,
                      projplot,projscatter, projtext, cartview, orthview, azeqview)
from .zoomtool import mollzoom,set_g_clim
from .fitsfunc import write_map,read_map,mrdfits,mwrfits,read_alm,write_alm,write_cl,read_cl

healpy-1.10.3/healpy/cookbook.py0000664000175000017500000000314113010374155016766 0ustar  zoncazonca00000000000000"""Various generic useful functions 
"""

def is_seq(o):
    """Check if the object is a sequence.

    Parameters
    ----------
    o : any object
      The object to check
    
    Returns
    -------
    is_seq : bool, scalar
      True if *o* is a sequence, False otherwise
    """
    return hasattr(o, '__len__')

def is_seq_of_seq(o):
    """Check if the object is a sequence of sequences. No check is done on
    the sizes of the sequences.

    Parameters
    ----------
    o : any object
      The object to check
    
    Returns
    -------
    is_seq_of_seq : bool
      True if *o* is a sequence of sequences, False otherwise.
    """
    if not is_seq(o):
        return False
    for s in o:
        if not is_seq(s):
            return False
    return True

def is_like2d(o):
    """Check if *o* is conformable to a 2d array.

    Parameters
    ----------
    o : any object
      The object to check
   
    Returns
    -------
    is_like2d : bool, scalar
      True if *o* is conformable to a 2d array, False otherwise.
    """
    if not is_seq(o):
        return False
    size = None
    for s in o:
        if not is_seq(s):
            return False
        if size is None:
            size = len(s)
        if len(s) != size:
            return False
    return True


def len_array_or_arrays(o):
    """Returns the length of a single array or list of arrays
    
    Parameters
    ----------
    o : either array or sequence of arrays

    Returns
    -------
    length : length of array
    """
    if is_seq_of_seq(o):
        length = len(o[0])
    else:
        length = len(o)
    return length
healpy-1.10.3/healpy/fitsfunc.py0000664000175000017500000005556613026275744017036 0ustar  zoncazonca00000000000000#
#  This file is part of Healpy.
#
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#
#  For more information about Healpy, see http://code.google.com/p/healpy
#
"""Provides input and output functions for Healpix maps, alm, and cl.
"""
from __future__ import with_statement
from __future__ import division

import six
import gzip
import tempfile
import shutil
import os
import warnings
import astropy.io.fits as pf
import numpy as np

from . import pixelfunc
from .sphtfunc import Alm
from .pixelfunc import UNSEEN
from . import cookbook as cb

standard_column_names = {
    1 : "I_STOKES",
    3 : ["%s_STOKES" % comp for comp in "IQU"],
    6 : ["II", "IQ", "IU", "QQ", "QU", "UU"]
}

class HealpixFitsWarning(Warning):
    pass

def writeto(tbhdu, filename):
    # FIXME: Pyfits versions earlier than 3.1.2 had no support or flaky support
    # for writing to .gz files or GzipFile objects. Drop this code when
    # we decide to drop support for older versions of Pyfits or if we decide
    # to support only Astropy.
    if isinstance(filename, six.string_types) and filename.endswith('.gz'):
        basefilename, ext = os.path.splitext(filename)
        with tempfile.NamedTemporaryFile(suffix='.fits') as tmpfile:
            tbhdu.writeto(tmpfile.name, clobber=True)
            gzfile = gzip.open(filename, 'wb')
            try:
                try:
                    shutil.copyfileobj(tmpfile, gzfile)
                finally:
                    gzfile.close()
            except:
                os.unlink(gzfile.name)
                raise
    else:
        tbhdu.writeto(filename, clobber=True)

def read_cl(filename, dtype=np.float64, h=False):
    """Reads Cl from an healpix file, as IDL fits2cl.

    Parameters
    ----------
    filename : str or HDUList or HDU
      the fits file name
    dtype : data type, optional
      the data type of the returned array

    Returns
    -------
    cl : array
      the cl array
    """
    fits_hdu = _get_hdu(filename, hdu=1)
    cl = [fits_hdu.data.field(n) for n in range(len(fits_hdu.columns))]
    if len(cl) == 1:
        return cl[0]
    else:
        return cl

def write_cl(filename, cl, dtype=np.float64):
    """Writes Cl into an healpix file, as IDL cl2fits.

    Parameters
    ----------
    filename : str
      the fits file name
    cl : array
      the cl array to write to file, currently TT only
    """
    # check the dtype and convert it
    fitsformat = getformat(dtype)
    column_names = ['TEMPERATURE','GRADIENT','CURL','G-T','C-T','C-G']
    if isinstance(cl, list):
        cols = [pf.Column(name=column_name,
                               format='%s'%fitsformat,
                               array=column_cl) for column_name, column_cl in zip(column_names[:len(cl)], cl)]
    else: # we write only one TT
        cols = [pf.Column(name='TEMPERATURE',
                               format='%s'%fitsformat,
                               array=cl)]

    tbhdu = pf.BinTableHDU.from_columns(cols)
    # add needed keywords
    tbhdu.header['CREATOR'] = 'healpy'
    writeto(tbhdu, filename)

def write_map(filename,m,nest=False,dtype=np.float32,fits_IDL=True,coord=None,partial=False,column_names=None,column_units=None,extra_header=()):
    """Writes an healpix map into an healpix file.

    Parameters
    ----------
    filename : str
      the fits file name
    m : array or sequence of 3 arrays
      the map to write. Possibly a sequence of 3 maps of same size.
      They will be considered as I, Q, U maps.
      Supports masked maps, see the `ma` function.
    nest : bool, optional
      If True, ordering scheme is assumed to be NESTED, otherwise, RING. Default: RING.
      The map ordering is not modified by this function, the input map array
      should already be in the desired ordering (run `ud_grade` beforehand).
    fits_IDL : bool, optional
      If True, reshapes columns in rows of 1024, otherwise all the data will
      go in one column. Default: True
    coord : str
      The coordinate system, typically 'E' for Ecliptic, 'G' for Galactic or 'C' for
      Celestial (equatorial)
    partial : bool, optional
      If True, fits file is written as a partial-sky file with explicit indexing.
      Otherwise, implicit indexing is used.  Default: False.
    column_names : str or list
      Column name or list of column names, if None we use:
      I_STOKES for 1 component,
      I/Q/U_STOKES for 3 components,
      II, IQ, IU, QQ, QU, UU for 6 components,
      COLUMN_0, COLUMN_1... otherwise
    column_units : str or list
      Units for each column, or same units for all columns.
    extra_header : list
      Extra records to add to FITS header.
    dtype: np.dtype or list of np.dtypes, optional
      The datatype in which the columns will be stored. Will be converted
      internally from the numpy datatype to the fits convention. If a list,
      the length must correspond to the number of map arrays. 
      Default: np.float32.
    """
    if not hasattr(m, '__len__'):
        raise TypeError('The map must be a sequence')

    m = pixelfunc.ma_to_array(m)
    if pixelfunc.maptype(m) == 0: # a single map is converted to a list
        m = [m]

    # check the dtype and convert it
    try:
        fitsformat = []
        for curr_dtype in dtype:
            fitsformat.append(getformat(curr_dtype))
    except TypeError:
        #dtype is not iterable
        fitsformat = [getformat(dtype)] * len(m)

    if column_names is None:
        column_names = standard_column_names.get(len(m), ["COLUMN_%d" % n for n in range(len(m))])
    else:
        assert len(column_names) == len(m), "Length column_names != number of maps"

    if column_units is None or isinstance(column_units, six.string_types):
        column_units = [column_units] * len(m)

    # maps must have same length
    assert len(set(map(len, m))) == 1, "Maps must have same length"
    nside = pixelfunc.npix2nside(len(m[0]))

    if nside < 0:
        raise ValueError('Invalid healpix map : wrong number of pixel')

    cols=[]
    if partial:
        fits_IDL = False
        mask = pixelfunc.mask_good(m[0])
        pix = np.where(mask)[0]
        if len(pix) == 0:
            raise ValueError('Invalid healpix map : empty partial map')
        m = [mm[mask] for mm in m]
        ff = getformat(np.min_scalar_type(-pix.max()))
        if ff is None:
            ff = 'I'
        cols.append(pf.Column(name='PIXEL',
                              format=ff,
                              array=pix,
                              unit=None))

    for cn, cu, mm, curr_fitsformat in zip(column_names, column_units, m, 
                                           fitsformat):
        if len(mm) > 1024 and fits_IDL:
            # I need an ndarray, for reshape:
            mm2 = np.asarray(mm)
            cols.append(pf.Column(name=cn,
                                   format='1024%s' % curr_fitsformat,
                                   array=mm2.reshape(mm2.size//1024,1024),
                                   unit=cu))
        else:
            cols.append(pf.Column(name=cn,
                                   format='%s' % curr_fitsformat,
                                   array=mm,
                                   unit=cu))

    tbhdu = pf.BinTableHDU.from_columns(cols)
    # add needed keywords
    tbhdu.header['PIXTYPE'] = ('HEALPIX', 'HEALPIX pixelisation')
    if nest: ordering = 'NESTED'
    else:    ordering = 'RING'
    tbhdu.header['ORDERING'] = (ordering,
                                'Pixel ordering scheme, either RING or NESTED')
    if coord:
        tbhdu.header['COORDSYS'] = (coord,
                                    'Ecliptic, Galactic or Celestial (equatorial)')
    tbhdu.header['EXTNAME'] = ('xtension',
                               'name of this binary table extension')
    tbhdu.header['NSIDE'] = (nside,'Resolution parameter of HEALPIX')
    if not partial:
        tbhdu.header['FIRSTPIX'] = (0, 'First pixel # (0 based)')
        tbhdu.header['LASTPIX'] = (pixelfunc.nside2npix(nside)-1,
                                   'Last pixel # (0 based)')
    tbhdu.header['INDXSCHM'] = ('EXPLICIT' if partial else 'IMPLICIT',
                                'Indexing: IMPLICIT or EXPLICIT')
    tbhdu.header['OBJECT'] = ('PARTIAL' if partial else 'FULLSKY',
                              'Sky coverage, either FULLSKY or PARTIAL')

    # FIXME: In modern versions of Pyfits, header.update() understands a
    # header as an argument, and headers can be concatenated with the `+'
    # operator.
    for args in extra_header:
        tbhdu.header[args[0]] = args[1:]

    writeto(tbhdu, filename)


def read_map(filename,field=0,dtype=np.float64,nest=False,partial=False,hdu=1,h=False,
             verbose=True,memmap=False):
    """Read an healpix map from a fits file.  Partial-sky files,
    if properly identified, are expanded to full size and filled with UNSEEN.

    Parameters
    ----------
    filename : str or HDU or HDUList
      the fits file name
    field : int or tuple of int, or None, optional
      The column to read. Default: 0.
      By convention 0 is temperature, 1 is Q, 2 is U.
      Field can be a tuple to read multiple columns (0,1,2)
      If the fits file is a partial-sky file, field=0 corresponds to the
      first column after the pixel index column.
      If None, all columns are read in.
    dtype : data type or list of data types, optional
      Force the conversion to some type. Passing a list allows different 
      types for each field. In that case, the length of the list must
      correspond to the length of the field parameter. Default: np.float64
    nest : bool, optional
      If True return the map in NEST ordering, otherwise in RING ordering;
      use fits keyword ORDERING to decide whether conversion is needed or not
      If None, no conversion is performed.
    partial : bool, optional
      If True, fits file is assumed to be a partial-sky file with explicit indexing,
      if the indexing scheme cannot be determined from the header.
      If False, implicit indexing is assumed.  Default: False.
      A partial sky file is one in which OBJECT=PARTIAL and INDXSCHM=EXPLICIT,
      and the first column is then assumed to contain pixel indices.
      A full sky file is one in which OBJECT=FULLSKY and INDXSCHM=IMPLICIT.
      At least one of these keywords must be set for the indexing
      scheme to be properly identified.
    hdu : int, optional
      the header number to look at (start at 0)
    h : bool, optional
      If True, return also the header. Default: False.
    verbose : bool, optional
      If True, print a number of diagnostic messages
    memmap : bool, optional
      Argument passed to astropy.io.fits.open, if True, the map is not read into memory,
      but only the required pixels are read when needed. Default: False.

    Returns
    -------
    m | (m0, m1, ...) [, header] : array or a tuple of arrays, optionally with header appended
      The map(s) read from the file, and the header if *h* is True.
    """

    fits_hdu = _get_hdu(filename, hdu=hdu, memmap=memmap)

    nside = fits_hdu.header.get('NSIDE')
    if nside is None:
        warnings.warn("No NSIDE in the header file : will use length of array", HealpixFitsWarning)
    else:
        nside = int(nside)
    if verbose: print('NSIDE = {0:d}'.format(nside))

    if not pixelfunc.isnsideok(nside):
        raise ValueError('Wrong nside parameter.')
    ordering = fits_hdu.header.get('ORDERING','UNDEF').strip()
    if ordering == 'UNDEF':
        ordering = (nest and 'NESTED' or 'RING')
        warnings.warn("No ORDERING keyword in header file : "
                      "assume %s"%ordering)
    if verbose: print('ORDERING = {0:s} in fits file'.format(ordering))

    sz=pixelfunc.nside2npix(nside)
    ret = []

    # partial sky: check OBJECT, then INDXSCHM
    obj = fits_hdu.header.get('OBJECT', 'UNDEF').strip()
    if obj != 'UNDEF':
        if obj == 'PARTIAL':
            partial = True
        elif obj == 'FULLSKY':
            partial = False

    schm = fits_hdu.header.get('INDXSCHM', 'UNDEF').strip()
    if schm != 'UNDEF':
        if schm == 'EXPLICIT':
            if obj == 'FULLSKY':
                raise ValueError('Incompatible INDXSCHM keyword')
            partial = True
        elif schm == 'IMPLICIT':
            if obj == 'PARTIAL':
                raise ValueError('Incompatible INDXSCHM keyword')
            partial = False

    if schm == 'UNDEF':
        schm = (partial and 'EXPLICIT' or 'IMPLICIT')
        warnings.warn("No INDXSCHM keyword in header file : "
                       "assume {}".format(schm))
    if verbose:
        print('INDXSCHM = {0:s}'.format(schm))

    if field is None:
        field = range(len(fits_hdu.data.columns) - 1*partial)
    if not (hasattr(field, '__len__') or isinstance(field, str)):
        field = (field,)

    if partial:
        # increment field counters
        field = tuple(f if isinstance(f, str) else f+1 for f in field)
        try:
            pix = fits_hdu.data.field(0).astype(int).ravel()
        except pf.VerifyError as e:
            print(e)
            print("Trying to fix a badly formatted header")
            fits_hdu.verify("fix")
            pix = fits_hdu.data.field(0).astype(int).ravel()

    try:
        assert len(dtype) == len(field), "The number of dtypes are not equal to the number of fields"
    except TypeError:
        dtype = [dtype] * len(field)

    for ff, curr_dtype in zip(field, dtype):
        try:
            m=fits_hdu.data.field(ff).astype(curr_dtype).ravel()
        except pf.VerifyError as e:
            print(e)
            print("Trying to fix a badly formatted header")
            m=fits_hdu.verify("fix")
            m=fits_hdu.data.field(ff).astype(curr_dtype).ravel()

        if partial:
            mnew = UNSEEN * np.ones(sz, dtype=curr_dtype)
            mnew[pix] = m
            m = mnew

        if (not pixelfunc.isnpixok(m.size) or (sz>0 and sz != m.size)) and verbose:
            print('nside={0:d}, sz={1:d}, m.size={2:d}'.format(nside,sz,m.size))
            raise ValueError('Wrong nside parameter.')
        if not nest is None: # no conversion with None
            if nest and ordering == 'RING':
                idx = pixelfunc.nest2ring(nside,np.arange(m.size,dtype=np.int32))
                m = m[idx]
                if verbose: print('Ordering converted to NEST')
            elif (not nest) and ordering == 'NESTED':
                idx = pixelfunc.ring2nest(nside,np.arange(m.size,dtype=np.int32))
                m = m[idx]
                if verbose: print('Ordering converted to RING')
        try:
            m[pixelfunc.mask_bad(m)] = UNSEEN
        except OverflowError:
            pass
        ret.append(m)

    if len(ret) == 1:
        if h:
            return ret[0],fits_hdu.header.items()
        else:
            return ret[0]
    else:
        if h:
            ret.append(fits_hdu.header.items())
            return tuple(ret)
        else:
            return tuple(ret)


def write_alm(filename,alms,out_dtype=None,lmax=-1,mmax=-1,mmax_in=-1):
    """Write alms to a fits file.

    In the fits file the alms are written
    with explicit index scheme, index = l*l + l + m +1, possibly out of order.
    By default write_alm makes a table with the same precision as the alms.
    If specified, the lmax and mmax parameters truncate the input data to
    include only alms for which l <= lmax and m <= mmax.

    Parameters
    ----------
    filename : str
      The filename of the output fits file
    alms : array, complex or list of arrays
      A complex ndarray holding the alms, index = m*(2*lmax+1-m)/2+l, see Alm.getidx
    lmax : int, optional
      The maximum l in the output file
    mmax : int, optional
      The maximum m in the output file
    out_dtype : data type, optional
      data type in the output file (must be a numpy dtype). Default: *alms*.real.dtype
    mmax_in : int, optional
      maximum m in the input array
    """

    if not cb.is_seq_of_seq(alms):
        alms = [alms]

    l2max = Alm.getlmax(len(alms[0]),mmax=mmax_in)
    if (lmax != -1 and lmax > l2max):
        raise ValueError("Too big lmax in parameter")
    elif lmax == -1:
        lmax = l2max

    if mmax_in == -1:
        mmax_in = l2max

    if mmax == -1:
        mmax = lmax
    if mmax > mmax_in:
        mmax = mmax_in

    if (out_dtype == None):
        out_dtype = alms[0].real.dtype

    l,m = Alm.getlm(lmax)
    idx = np.where((l <= lmax)*(m <= mmax))
    l = l[idx]
    m = m[idx]

    idx_in_original = Alm.getidx(l2max, l=l, m=m)

    index = l**2 + l + m + 1

    hdulist = pf.HDUList()
    for alm in alms:
        out_data = np.empty(len(index),
                   dtype=[('index','i'),
                          ('real',out_dtype),
                          ('imag',out_dtype)])
        out_data['index'] = index
        out_data['real'] = alm.real[idx_in_original]
        out_data['imag'] = alm.imag[idx_in_original]

        cindex = pf.Column(name="index", format=getformat(np.int32), unit="l*l+l+m+1", array=out_data['index'])
        creal = pf.Column(name="real", format=getformat(out_dtype), unit="unknown", array=out_data['real'])
        cimag = pf.Column(name="imag", format=getformat(out_dtype), unit="unknown", array=out_data['imag'])

        tbhdu = pf.BinTableHDU.from_columns([cindex,creal,cimag])
        hdulist.append(tbhdu)
    writeto(hdulist, filename)

def read_alm(filename,hdu=1,return_mmax=False):
    """Read alm from a fits file.

    In the fits file, the alm are written
    with explicit index scheme, index = l**2+l+m+1, while healpix cxx
    uses index = m*(2*lmax+1-m)/2+l. The conversion is done in this
    function.

    Parameters
    ----------
    filename : str or HDUList or HDU
      The name of the fits file to read
    hdu : int, optional
      The header to read. Start at 0. Default: hdu=1
    return_mmax : bool, optional
      If true, both the alms and mmax is returned in a tuple. Default: return_mmax=False

    Returns
    -------
    alms[, mmax] : complex array or tuple of a complex array and an int
      The alms read from the file and optionally mmax read from the file
    """
    idx, almr, almi = mrdfits(filename,hdu=hdu)
    l = np.floor(np.sqrt(idx-1)).astype(np.long)
    m = idx - l**2 - l - 1
    if (m<0).any():
        raise ValueError('Negative m value encountered !')
    lmax = l.max()
    mmax = m.max()
    alm = almr*(0+0j)
    i = Alm.getidx(lmax,l,m)
    alm.real[i] = almr
    alm.imag[i] = almi
    if return_mmax:
        return alm, mmax
    else:
        return alm

## Generic functions to read and write column of data in fits file

def _get_hdu(input_data, hdu=None, memmap=None):
    """
    Return an HDU from a FITS file

    Parameters
    ----------
    input_data : str or HDUList or HDU instance
        The input FITS file, either as a filename, HDU list, or HDU instance.

    Returns
    -------
    fits_hdu : HDU
        The extracted HDU
    """

    if isinstance(input_data, six.string_types):
        hdulist = pf.open(input_data, memmap=memmap)
        return _get_hdu(hdulist, hdu=hdu)

    if isinstance(input_data, pf.HDUList):
        if isinstance(hdu, int) and hdu >= len(input_data):
            raise ValueError('Available hdu in [0-%d]' % len(input_data))
        else:
            fits_hdu = input_data[hdu]
    elif isinstance(input_data, (pf.PrimaryHDU, pf.ImageHDU, pf.BinTableHDU, pf.TableHDU, pf.GroupsHDU)):
        fits_hdu = input_data
    else:
        raise TypeError("First argument should be a input_data, HDUList instance, or HDU instance")

    return fits_hdu


def mrdfits(filename, hdu=1):
    """
    Read a table in a fits file.

    Parameters
    ----------
    filename : str or HDUList or HDU
      The name of the fits file to read, or an HDUList or HDU instance.
    hdu : int, optional
      The header to read. Start at 0. Default: hdu=1

    Returns
    -------
    cols : a list of arrays
      A list of column data in the given header
    """
    fits_hdu = _get_hdu(filename, hdu=hdu)
    val=[]
    for i in range(len(fits_hdu.columns)):
        val.append(fits_hdu.data.field(i))
    return val


def mwrfits(filename,data,hdu=1,colnames=None,keys=None):
    """Write columns to a fits file in a table extension.

    Parameters
    ----------
    filename : str
      The fits file name
    data : list of 1D arrays
      A list of 1D arrays to write in the table
    hdu : int, optional
      The header where to write the data. Default: 1
    colnames : list of str
      The column names
    keys : dict-like
      A dictionary with keywords to write in the header
    """
    # Check the inputs
    if colnames is not None:
        if len(colnames) != len(data):
            raise ValueError("colnames and data must the same length")
    else:
        colnames = ['']*len(data)
    cols=[]
    for line in six.moves.xrange(len(data)):
        cols.append(pf.Column(name=colnames[line],
                               format=getformat(data[line]),
                               array=data[line]))
    tbhdu = pf.BinTableHDU.from_columns(cols)
    if type(keys) is dict:
        for k,v in keys.items():
            tbhdu.header[k] = v
    # write the file
    writeto(tbhdu, filename)

def getformat(t):
    """Get the FITS convention format string of data type t.

    Parameters
    ----------
    t : data type
      The data type for which the FITS type is requested

    Returns
    -------
    fits_type : str or None
      The FITS string code describing the data type, or None if unknown type.
    """
    conv = {
        np.dtype(np.bool): 'L',
        np.dtype(np.uint8): 'B',
        np.dtype(np.int16): 'I',
        np.dtype(np.int32): 'J',
        np.dtype(np.int64): 'K',
        np.dtype(np.float32): 'E',
        np.dtype(np.float64): 'D',
        np.dtype(np.complex64): 'C',
        np.dtype(np.complex128): 'M'
        }
    try:
        if t in conv:
            return conv[t]
    except:
        pass
    try:
        if np.dtype(t) in conv:
            return conv[np.dtype(t)]
    except:
        pass
    try:
        if np.dtype(type(t)) in conv:
            return conv[np.dtype(type(t))]
    except:
        pass
    try:
        if np.dtype(type(t[0])) in conv:
            return conv[np.dtype(type(t[0]))]
    except:
        pass
    try:
        if t is str:
            return 'A'
    except:
        pass
    try:
        if type(t) is str:
            return 'A%d'%(len(t))
    except:
        pass
    try:
        if type(t[0]) is str:
            l=max(len(s) for s in t)
            return 'A%d'%(l)
    except:
        pass
healpy-1.10.3/healpy/newvisufunc.py0000664000175000017500000001557513010374155017552 0ustar  zoncazonca00000000000000__all__ = ['mollview', 'projplot']

import numpy as np
from .pixelfunc import ang2pix, npix2nside
from .rotator import Rotator
from matplotlib.projections.geo import GeoAxes

###### WARNING #################
# this module is work in progress, the aim is to reimplement the healpy
# plot functions using the new features of matplotlib and remove most
# of the custom projection code

class ThetaFormatterShiftPi(GeoAxes.ThetaFormatter):
    """Shifts labelling by pi

    Shifts labelling from -180,180 to 0-360"""
    def __call__(self, x, pos=None):
        if x != 0:
            x *= -1
        if x < 0:
            x += 2*np.pi
        return super(ThetaFormatterShiftPi, self).__call__(x, pos)

def lonlat(theta, phi):
    """Converts theta and phi to longitude and latitude

    From colatitude to latitude and from astro longitude to geo longitude"""

    longitude = -1*np.asarray(phi)
    latitude = np.pi/2 - np.asarray(theta)
    return longitude, latitude 

def mollview(m=None, rot=None, coord=None, unit='',
             xsize=1000, nest=False,
             min=None, max=None, flip='astro',
             format='%g',
             cbar=True, cmap=None,
             norm=None, 
             graticule=False, graticule_labels=False,
             **kwargs):
    """Plot an healpix map (given as an array) in Mollweide projection.
    
    Parameters
    ----------
    map : float, array-like or None
      An array containing the map, supports masked maps, see the `ma` function.
      If None, will display a blank map, useful for overplotting.
    rot : scalar or sequence, optional
      Describe the rotation to apply.
      In the form (lon, lat, psi) (unit: degrees) : the point at
      longitude *lon* and latitude *lat* will be at the center. An additional rotation
      of angle *psi* around this direction is applied.
    coord : sequence of character, optional
      Either one of 'G', 'E' or 'C' to describe the coordinate
      system of the map, or a sequence of 2 of these to rotate
      the map from the first to the second coordinate system.
    unit : str, optional
      A text describing the unit of the data. Default: ''
    xsize : int, optional
      The size of the image. Default: 800
    nest : bool, optional
      If True, ordering scheme is NESTED. Default: False (RING)
    min : float, optional
      The minimum range value
    max : float, optional
      The maximum range value
    flip : {'astro', 'geo'}, optional
      Defines the convention of projection : 'astro' (default, east towards left, west towards right)
      or 'geo' (east towards roght, west towards left)
    format : str, optional
      The format of the scale label. Default: '%g'
    cbar : bool, optional
      Display the colorbar. Default: True
    norm : {'hist', 'log', None}
      Color normalization, hist= histogram equalized color mapping,
      log= logarithmic color mapping, default: None (linear color mapping)
    kwargs : keywords
      any additional keyword is passed to pcolormesh
    graticule : bool
      add graticule
    graticule_labels : bool
      longitude and latitude labels
    """

    # not implemented features
    if not (norm is None):
        raise NotImplementedError()

    # Create the figure
    import matplotlib.pyplot as plt

    width = 8.5
    fig = plt.figure(figsize=(width,width*.63))
    ax = fig.add_subplot(111, projection="mollweide")
    # FIXME: make a more general axes creation that works also with subplots
    #ax = plt.gcf().add_axes((.125, .1, .9, .9), projection="mollweide")

    # remove white space around the image
    plt.subplots_adjust(left=0.02, right=0.98, top=0.95, bottom=0.05)
    if graticule and graticule_labels:
        plt.subplots_adjust(left=0.04, right=0.98, top=0.95, bottom=0.05)

    if not m is None:
        # auto min and max
        if min is None:
            min = m.min()
        if max is None:
            max = m.max()

    # allow callers to override the hold state by passing hold=True|False
    washold = ax.ishold()
    hold = kwargs.pop('hold', None)
    if hold is not None:
        ax.hold(hold)

    try:
        ysize = xsize/2
        theta = np.linspace(np.pi, 0, ysize)
        phi   = np.linspace(-np.pi, np.pi, xsize)

        longitude = np.radians(np.linspace(-180, 180, xsize))
        if flip == "astro":
            longitude = longitude[::-1]
        latitude = np.radians(np.linspace(-90, 90, ysize))
        # project the map to a rectangular matrix xsize x ysize
        PHI, THETA = np.meshgrid(phi, theta)
        # coord or rotation
        if coord or rot:
            r = Rotator(coord=coord, rot=rot, inv=True)
            THETA, PHI = r(THETA.flatten(), PHI.flatten())
            THETA = THETA.reshape(ysize, xsize)
            PHI = PHI.reshape(ysize, xsize)
        nside = npix2nside(len(m))
        if not m is None:
            grid_pix = ang2pix(nside, THETA, PHI, nest=nest)
            grid_map = m[grid_pix]

            # plot
            ret = plt.pcolormesh(longitude, latitude, grid_map, vmin=min, vmax=max, rasterized=True, **kwargs)

        # graticule
        plt.grid(graticule)
        if graticule:
            longitude_grid_spacing = 60 # deg
            ax.set_longitude_grid(longitude_grid_spacing)
            if width < 10:
                ax.set_latitude_grid(45)
                ax.set_longitude_grid_ends(90)

        if graticule_labels:
            ax.xaxis.set_major_formatter(ThetaFormatterShiftPi(longitude_grid_spacing))
        else:
            # remove longitude and latitude labels
            ax.xaxis.set_ticklabels([])
            ax.yaxis.set_ticklabels([])

        # colorbar
        if cbar and not m is None:
            cb = fig.colorbar(ret, orientation='horizontal', shrink=.4, pad=0.05, ticks=[min, max])
            cb.ax.xaxis.set_label_text(unit)
            cb.ax.xaxis.labelpad = -8
            # workaround for issue with viewers, see colorbar docstring
            cb.solids.set_edgecolor("face")

        plt.draw()
    finally:
        ax.hold(washold)

    return ret
    
def projplot(theta, phi, fmt=None, **kwargs):
    """projplot is a wrapper around :func:`matplotlib.Axes.plot` to take into account the
    spherical projection.

    You can call this function as::
    
       projplot(theta, phi)        # plot a line going through points at coord (theta, phi)
       projplot(theta, phi, 'bo')  # plot 'o' in blue at coord (theta, phi)
    
    Parameters
    ----------
    theta, phi : float, array-like
      Coordinates of point to plot in radians.
    fmt : str
      A format string (see :func:`matplotlib.Axes.plot` for details)

    Notes
    -----
    Other keywords are passed to :func:`matplotlib.Axes.plot`.

    See Also
    --------
    projscatter, projtext
    """
    import matplotlib.pyplot as plt
    longitude, latitude = lonlat(theta, phi)
    if fmt is None:
        ret = plt.plot(longitude, latitude, **kwargs)
    else:
        ret = plt.plot(longitude, latitude, fmt, **kwargs)
    return ret
healpy-1.10.3/healpy/pixelfunc.py0000664000175000017500000015200713031130162017152 0ustar  zoncazonca00000000000000# 
#  This file is part of Healpy.
# 
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# 
#  For more information about Healpy, see http://code.google.com/p/healpy
#
"""
=====================================================
pixelfunc.py : Healpix pixelization related functions
=====================================================

This module provides functions related to Healpix pixelization scheme.

conversion from/to sky coordinates
----------------------------------

- :func:`pix2ang` converts pixel number to angular coordinates
- :func:`pix2vec` converts pixel number to unit 3-vector direction
- :func:`ang2pix` converts angular coordinates to pixel number
- :func:`vec2pix` converts 3-vector to pixel number 
- :func:`vec2ang` converts 3-vector to angular coordinates
- :func:`ang2vec` converts angular coordinates to unit 3-vector
- :func:`pix2xyf` converts pixel number to coordinates within face
- :func:`xyf2pix` converts coordinates within face to pixel number
- :func:`get_interp_weights` returns the 4 nearest pixels for given
  angular coordinates and the relative weights for interpolation
- :func:`get_all_neighbours` return the 8 nearest pixels for given
  angular coordinates

conversion between NESTED and RING schemes
------------------------------------------

- :func:`nest2ring` converts NESTED scheme pixel numbers to RING
  scheme pixel number
- :func:`ring2nest` converts RING scheme pixel number to NESTED
  scheme pixel number
- :func:`reorder` reorders a healpix map pixels from one scheme to another

nside/npix/resolution
---------------------

- :func:`nside2npix` converts healpix nside parameter to number of pixel
- :func:`npix2nside` converts number of pixel to healpix nside parameter
- :func:`nside2order` converts nside to order
- :func:`order2nside` converts order to nside
- :func:`nside2resol` converts nside to mean angular resolution
- :func:`nside2pixarea` converts nside to pixel area
- :func:`isnsideok` checks the validity of nside
- :func:`isnpixok` checks the validity of npix
- :func:`get_map_size` gives the number of pixel of a map
- :func:`get_min_valid_nside` gives the minimum nside possible for a given
  number of pixel
- :func:`get_nside` returns the nside of a map
- :func:`maptype` checks the type of a map (one map or sequence of maps)
- :func:`ud_grade` upgrades or degrades the resolution (nside) of a map

Masking pixels
--------------

- :const:`UNSEEN` is a constant value interpreted as a masked pixel
- :func:`mask_bad` returns a map with ``True`` where map is :const:`UNSEEN`
- :func:`mask_good` returns a map with ``False`` where map is :const:`UNSEEN`
- :func:`ma` returns a masked array as map, with mask given by :func:`mask_bad`

Map data manipulation
---------------------

- :func:`fit_dipole` fits a monopole+dipole on the map
- :func:`fit_monopole` fits a monopole on the map
- :func:`remove_dipole` fits and removes a monopole+dipole from the map
- :func:`remove_monopole` fits and remove a monopole from the map
- :func:`get_interp_val` computes a bilinear interpolation of the map
  at given angular coordinates, using 4 nearest neighbours
"""

try:
    from exceptions import NameError
except:
    pass

import numpy as np
from functools import wraps

UNSEEN = None

try:
    from . import _healpy_pixel_lib as pixlib
    #: Special value used for masked pixels
    UNSEEN = pixlib.UNSEEN
except:
    import warnings
    warnings.warn('Warning: cannot import _healpy_pixel_lib module')

# We are using 64-bit integer types.
# nside > 2**29 requires extended integer types.
max_nside = 1 << 29

__all__ = ['pix2ang', 'pix2vec', 'ang2pix', 'vec2pix',
           'ang2vec', 'vec2ang',
           'get_interp_weights', 'get_neighbours', 'get_interp_val', 'get_all_neighbours',
           'max_pixrad',
           'nest2ring', 'ring2nest', 'reorder', 'ud_grade',
           'UNSEEN', 'mask_good', 'mask_bad', 'ma',
           'fit_dipole', 'remove_dipole', 'fit_monopole', 'remove_monopole',
           'nside2npix', 'npix2nside', 'nside2order', 'order2nside',
           'nside2resol', 'nside2pixarea',
           'isnsideok', 'isnpixok',
           'get_map_size', 'get_min_valid_nside',
           'get_nside', 'maptype', 'ma_to_array']

def check_theta_valid(theta):
    """Raises exception if theta is not within 0 and pi"""
    theta = np.asarray(theta)
    if not((theta >= 0).all() and (theta <= np.pi + 1e-5).all()):
        raise ValueError('THETA is out of range [0,pi]')

def lonlat2thetaphi(lon,lat):
    """ Transform longitude and latitude (deg) into co-latitude and longitude (rad)

    Parameters
    ----------
    lon : int or array-like
      Longitude in degrees
    lat : int or array-like
      Latitude in degrees

    Returns
    -------
    theta, phi : float, scalar or array-like
      The co-latitude and longitude in radians
    """
    return np.pi/2. - np.radians(lat),np.radians(lon)

def thetaphi2lonlat(theta,phi):
    """ Transform co-latitude and longitude (rad) into longitude and latitude (deg)

    Parameters
    ----------
    theta : int or array-like
      Co-latitude in radians
    phi : int or array-like
      Longitude in radians

    Returns
    -------
    lon, lat : float, scalar or array-like
      The longitude and latitude in degrees
    """
    return np.degrees(phi), 90. - np.degrees(theta)

def maptype(m):
    """Describe the type of the map (valid, single, sequence of maps).
    Checks : the number of maps, that all maps have same length and that this
    length is a valid map size (using :func:`isnpixok`).

    Parameters
    ----------
    m : sequence
      the map to get info from

    Returns
    -------
    info : int
      -1 if the given object is not a valid map, 0 if it is a single map,
      *info* > 0 if it is a sequence of maps (*info* is then the number of
      maps)

    Examples
    --------
    >>> import healpy as hp
    >>> hp.pixelfunc.maptype(np.arange(12))
    0
    >>> hp.pixelfunc.maptype([np.arange(12), np.arange(12)])
    2
    """
    if not hasattr(m, '__len__'):
        raise TypeError('input map is a scalar')
    if len(m) == 0:
        raise TypeError('input map has length zero')
    if hasattr(m[0], '__len__'):
        npix=len(m[0])
        for mm in m[1:]:
            if len(mm) != npix:
                raise TypeError('input maps have different npix')
        if isnpixok(len(m[0])):
            return len(m)
        else:
            raise TypeError('bad number of pixels')
    else:
        if isnpixok(len(m)):
            return 0
        else:
            raise TypeError('bad number of pixels')

def ma_to_array(m):
    """Converts a masked array or a list of masked arrays to filled numpy arrays

    Parameters
    ----------
    m : a map (may be a sequence of maps)

    Returns
    -------
    m : filled map or tuple of filled maps

    Examples
    --------
    >>> import healpy as hp
    >>> m = hp.ma(np.array([2., 2., 3, 4, 5, 0, 0, 0, 0, 0, 0, 0]))
    >>> m.mask = np.array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=np.bool)
    >>> print(m.data[1]) # data is not affected by mask
    2.0
    >>> print(m[1]) # shows that the value is masked
    --
    >>> print(ma_to_array(m)[1]) # filled array, masked values replace by UNSEEN
    -1.6375e+30
    """

    try:
        return m.filled()
    except AttributeError:
        try:
            return tuple([mm.filled() for mm in m])
        except AttributeError:
            pass
    return m

def is_ma(m):
    """Converts a masked array or a list of masked arrays to filled numpy arrays

    Parameters
    ----------
    m : a map (may be a sequence of maps)

    Returns
    -------
    is_ma : bool
        whether the input map was a ma or not
    """
    return hasattr(m, 'filled') or hasattr(m[0], 'filled')

def accept_ma(f):
    """Wraps a function in order to convert the input map from
    a masked to a regular numpy array, and convert back the
    output from a regular array to a masked array"""
    @wraps(f)
    def wrapper(map_in, *args, **kwds):
        return_ma = is_ma(map_in)
        m = ma_to_array(map_in)
        out = f(m, *args, **kwds)
        return ma(out) if return_ma else out

    return wrapper

def mask_bad(m, badval = UNSEEN, rtol = 1.e-5, atol = 1.e-8):
    """Returns a bool array with ``True`` where m is close to badval.

    Parameters
    ----------
    m : a map (may be a sequence of maps)
    badval : float, optional
        The value of the pixel considered as bad (:const:`UNSEEN` by default)
    rtol : float, optional
        The relative tolerance
    atol : float, optional
        The absolute tolerance

    Returns
    -------
    mask
      a bool array with the same shape as the input map, ``True`` where input map is
      close to badval, and ``False`` elsewhere.

    See Also
    --------
    mask_good, ma

    Examples
    --------
    >>> import healpy as hp
    >>> import numpy as np
    >>> m = np.arange(12.)
    >>> m[3] = hp.UNSEEN
    >>> hp.mask_bad(m)
    array([False, False, False,  True, False, False, False, False, False,
           False, False, False], dtype=bool)
    """
    m = np.asarray(m)
    atol = np.absolute(atol)
    rtol = np.absolute(rtol)
    return np.absolute(m - badval) <= atol + rtol * np.absolute(badval)

def mask_good(m, badval = UNSEEN, rtol = 1.e-5, atol = 1.e-8):
    """Returns a bool array with ``False`` where m is close to badval.

    Parameters
    ----------
    m : a map (may be a sequence of maps)
    badval : float, optional
        The value of the pixel considered as bad (:const:`UNSEEN` by default)
    rtol : float, optional
        The relative tolerance
    atol : float, optional
        The absolute tolerance

    Returns
    -------
    a bool array with the same shape as the input map, ``False`` where input map is
    close to badval, and ``True`` elsewhere.

    See Also
    --------
    mask_bad, ma

    Examples
    --------
    >>> import healpy as hp
    >>> m = np.arange(12.)
    >>> m[3] = hp.UNSEEN
    >>> hp.mask_good(m)
    array([ True,  True,  True, False,  True,  True,  True,  True,  True,
            True,  True,  True], dtype=bool)
    """
    m = np.asarray(m)
    atol = np.absolute(atol)
    rtol = np.absolute(rtol)
    return np.absolute(m - badval) > atol + rtol * np.absolute(badval)

def ma(m, badval = UNSEEN, rtol = 1e-5, atol = 1e-8, copy = True):
    """Return map as a masked array, with ``badval`` pixels masked.

    Parameters
    ----------
    m : a map (may be a sequence of maps)
    badval : float, optional
        The value of the pixel considered as bad (:const:`UNSEEN` by default)
    rtol : float, optional
        The relative tolerance
    atol : float, optional
        The absolute tolerance
    copy : bool, optional
        If ``True``, a copy of the input map is made.

    Returns
    -------
    a masked array with the same shape as the input map, 
    masked where input map is close to badval.

    See Also
    --------
    mask_good, mask_bad, numpy.ma.masked_values

    Examples
    --------
    >>> import healpy as hp
    >>> m = np.arange(12.)
    >>> m[3] = hp.UNSEEN
    >>> hp.ma(m)
    masked_array(data = [0.0 1.0 2.0 -- 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0],
                 mask = [False False False  True False False False False False False False False],
           fill_value = -1.6375e+30)
    
    """
    if maptype(m) == 0:
        return np.ma.masked_values(m, badval, rtol = rtol, atol = atol, copy = copy)
    else:
        return tuple([ma(mm) for mm in m])

def ang2pix(nside,theta,phi,nest=False,lonlat=False):
    """ang2pix : nside,theta[rad],phi[rad],nest=False,lonlat=False -> ipix (default:RING)

    Parameters
    ----------
    nside : int, scalar or array-like
      The healpix nside parameter, must be a power of 2, less than 2**30
    theta, phi : float, scalars or array-like
      Angular coordinates of a point on the sphere
    nest : bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering
    lonlat : bool
      If True, input angles are assumed to be longitude and latitude in degree,
      otherwise, they are co-latitude and longitude in radians.

    Returns
    -------
    pix : int or array of int
      The healpix pixel numbers. Scalar if all input are scalar, array otherwise.
      Usual numpy broadcasting rules apply.

    See Also
    --------
    pix2ang, pix2vec, vec2pix

    Examples
    --------
    >>> import healpy as hp
    >>> hp.ang2pix(16, np.pi/2, 0)
    1440

    >>> hp.ang2pix(16, [np.pi/2, np.pi/4, np.pi/2, 0, np.pi], [0., np.pi/4, np.pi/2, 0, 0])
    array([1440,  427, 1520,    0, 3068])

    >>> hp.ang2pix(16, np.pi/2, [0, np.pi/2])
    array([1440, 1520])

    >>> hp.ang2pix([1, 2, 4, 8, 16], np.pi/2, 0)
    array([   4,   12,   72,  336, 1440])

    >>> hp.ang2pix([1, 2, 4, 8, 16], 0, 0, lonlat=True)
    array([   4,   12,   72,  336, 1440])
    """
    if lonlat:
        theta,phi = lonlat2thetaphi(theta,phi)
    check_theta_valid(theta)
    check_nside(nside)
    if nest:
        return pixlib._ang2pix_nest(nside,theta,phi)
    else:
        return pixlib._ang2pix_ring(nside,theta,phi)

def pix2ang(nside,ipix,nest=False,lonlat=False):
    """pix2ang : nside,ipix,nest=False,lonlat=False -> theta[rad],phi[rad] (default RING)

    Parameters
    ----------
    nside : int or array-like
      The healpix nside parameter, must be a power of 2, less than 2**30
    ipix : int or array-like
      Pixel indices
    nest : bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering
    lonlat : bool, optional
      If True, return angles will be longitude and latitude in degree,
      otherwise, angles will be longitude and co-latitude in radians (default)

    Returns
    -------
    theta, phi : float, scalar or array-like
      The angular coordinates corresponding to ipix. Scalar if all input
      are scalar, array otherwise. Usual numpy broadcasting rules apply.

    See Also
    --------
    ang2pix, vec2pix, pix2vec

    Examples
    --------
    >>> import healpy as hp
    >>> hp.pix2ang(16, 1440)
    (1.5291175943723188, 0.0)

    >>> hp.pix2ang(16, [1440,  427, 1520,    0, 3068])
    (array([ 1.52911759,  0.78550497,  1.57079633,  0.05103658,  3.09055608]), array([ 0.        ,  0.78539816,  1.61988371,  0.78539816,  0.78539816]))

    >>> hp.pix2ang([1, 2, 4, 8], 11)
    (array([ 2.30052398,  0.84106867,  0.41113786,  0.2044802 ]), array([ 5.49778714,  5.89048623,  5.89048623,  5.89048623]))

    >>> hp.pix2ang([1, 2, 4, 8], 11, lonlat=True)
    (array([ 315. ,  337.5,  337.5,  337.5]), array([-41.8103149 ,  41.8103149 ,  66.44353569,  78.28414761]))
    """
    check_nside(nside)
    if nest:
        theta,phi = pixlib._pix2ang_nest(nside, ipix)
    else:
        theta,phi = pixlib._pix2ang_ring(nside,ipix)

    if lonlat:
        return thetaphi2lonlat(theta,phi)
    else:
        return theta, phi

def xyf2pix(nside,x,y,face,nest=False):
    """xyf2pix : nside,x,y,face,nest=False -> ipix (default:RING)

    Parameters
    ----------
    nside : int, scalar or array-like
      The healpix nside parameter, must be a power of 2
    x, y : int, scalars or array-like
      Pixel indices within face
    face : int, scalars or array-like
      Face number
    nest : bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering

    Returns
    -------
    pix : int or array of int
      The healpix pixel numbers. Scalar if all input are scalar, array otherwise.
      Usual numpy broadcasting rules apply.

    See Also
    --------
    pix2xyf

    Examples
    --------
    >>> import healpy as hp
    >>> hp.xyf2pix(16, 8, 8, 4)
    1440

    >>> hp.xyf2pix(16, [8, 8, 8, 15, 0], [8, 8, 7, 15, 0], [4, 0, 5, 0, 8])
    array([1440,  427, 1520,    0, 3068])
    """
    check_nside(nside)
    if nest:
        return pixlib._xyf2pix_nest(nside,x,y,face)
    else:
        return pixlib._xyf2pix_ring(nside,x,y,face)

def pix2xyf(nside,ipix,nest=False):
    """pix2xyf : nside,ipix,nest=False -> x,y,face (default RING)

    Parameters
    ----------
    nside : int or array-like
      The healpix nside parameter, must be a power of 2
    ipix : int or array-like
      Pixel indices
    nest : bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering

    Returns
    -------
    x, y : int, scalars or array-like
      Pixel indices within face
    face : int, scalars or array-like
      Face number

    See Also
    --------
    xyf2pix

    Examples
    --------
    >>> import healpy as hp
    >>> hp.pix2xyf(16, 1440)
    (8, 8, 4)

    >>> hp.pix2xyf(16, [1440,  427, 1520,    0, 3068])
    (array([ 8,  8,  8, 15,  0]), array([ 8,  8,  7, 15,  0]), array([4, 0, 5, 0, 8]))

    >>> hp.pix2xyf([1, 2, 4, 8], 11)
    (array([0, 1, 3, 7]), array([0, 0, 2, 6]), array([11,  3,  3,  3]))
    """
    check_nside(nside)
    if nest:
        return pixlib._pix2xyf_nest(nside, ipix)
    else:
        return pixlib._pix2xyf_ring(nside,ipix)

def vec2pix(nside,x,y,z,nest=False):
    """vec2pix : nside,x,y,z,nest=False -> ipix (default:RING)

    Parameters
    ----------
    nside : int or array-like
      The healpix nside parameter, must be a power of 2, less than 2**30
    x,y,z : floats or array-like
      vector coordinates defining point on the sphere
    nest : bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering

    Returns
    -------
    ipix : int, scalar or array-like
      The healpix pixel number corresponding to input vector. Scalar if all input
      are scalar, array otherwise. Usual numpy broadcasting rules apply.

    See Also
    --------
    ang2pix, pix2ang, pix2vec

    Examples
    --------
    >>> import healpy as hp
    >>> hp.vec2pix(16, 1, 0, 0)
    1504

    >>> hp.vec2pix(16, [1, 0], [0, 1], [0, 0])
    array([1504, 1520])

    >>> hp.vec2pix([1, 2, 4, 8], 1, 0, 0)
    array([  4,  20,  88, 368])
    """
    if nest:
        return pixlib._vec2pix_nest(nside,x,y,z)
    else:
        return pixlib._vec2pix_ring(nside,x,y,z)

def pix2vec(nside,ipix,nest=False):
    """pix2vec : nside,ipix,nest=False -> x,y,z (default RING)

    Parameters
    ----------
    nside : int, scalar or array-like
      The healpix nside parameter, must be a power of 2, less than 2**30
    ipix : int, scalar or array-like
      Healpix pixel number
    nest : bool, optional
      if True, assume NESTED pixel ordering, otherwise, RING pixel ordering

    Returns
    -------
    x, y, z : floats, scalar or array-like
      The coordinates of vector corresponding to input pixels. Scalar if all input
      are scalar, array otherwise. Usual numpy broadcasting rules apply.

    See Also
    --------
    ang2pix, pix2ang, vec2pix

    Examples
    --------
    >>> import healpy as hp
    >>> hp.pix2vec(16, 1504)
    (0.99879545620517241, 0.049067674327418015, 0.0)

    >>> hp.pix2vec(16, [1440,  427])
    (array([ 0.99913157,  0.5000534 ]), array([ 0.       ,  0.5000534]), array([ 0.04166667,  0.70703125]))

    >>> hp.pix2vec([1, 2], 11)
    (array([ 0.52704628,  0.68861915]), array([-0.52704628, -0.28523539]), array([-0.66666667,  0.66666667]))
    """
    check_nside(nside)
    if nest:
        return pixlib._pix2vec_nest(nside,ipix)
    else:
        return pixlib._pix2vec_ring(nside,ipix)

def ang2vec(theta, phi, lonlat=False):
    """ang2vec : convert angles to 3D position vector

    Parameters
    ----------
    theta : float, scalar or arry-like
      colatitude in radians measured southward from north pole (in [0,pi]). 
    phi : float, scalar or array-like
      longitude in radians measured eastward (in [0, 2*pi]). 
    lonlat : bool
      If True, input angles are assumed to be longitude and latitude in degree,
      otherwise, they are co-latitude and longitude in radians.

    Returns
    -------
    vec : float, array
      if theta and phi are vectors, the result is a 2D array with a vector per row
      otherwise, it is a 1D array of shape (3,)

    See Also
    --------
    vec2ang, rotator.dir2vec, rotator.vec2dir
    """
    if lonlat:
        theta,phi = lonlat2thetaphi(theta,phi)
    check_theta_valid(theta)
    sintheta = np.sin(theta)
    return np.array([sintheta*np.cos(phi),
                      sintheta*np.sin(phi),
                      np.cos(theta)]).T

def vec2ang(vectors, lonlat=False):
    """vec2ang: vectors [x, y, z] -> theta[rad], phi[rad]

    Parameters
    ----------
    vectors : float, array-like
      the vector(s) to convert, shape is (3,) or (N, 3)
    lonlat : bool, optional
      If True, return angles will be longitude and latitude in degree,
      otherwise, angles will be longitude and co-latitude in radians (default)

    Returns
    -------
    theta, phi : float, tuple of two arrays
      the colatitude and longitude in radians

    See Also
    --------
    ang2vec, rotator.vec2dir, rotator.dir2vec
    """
    vectors = vectors.reshape(-1,3)
    dnorm = np.sqrt(np.sum(np.square(vectors),axis=1))
    theta = np.arccos(vectors[:,2]/dnorm)
    phi = np.arctan2(vectors[:,1],vectors[:,0])
    phi[phi < 0] += 2*np.pi
    if lonlat:
        return thetaphi2lonlat(theta,phi)
    else:
        return theta, phi

def ring2nest(nside, ipix):
    """Convert pixel number from RING ordering to NESTED ordering.

    Parameters
    ----------
    nside : int, scalar or array-like
      the healpix nside parameter
    ipix : int, scalar or array-like
      the pixel number in RING scheme

    Returns
    -------
    ipix : int, scalar or array-like
      the pixel number in NESTED scheme

    See Also
    --------
    nest2ring, reorder
    
    Examples
    --------
    >>> import healpy as hp
    >>> hp.ring2nest(16, 1504)
    1130

    >>> hp.ring2nest(2, np.arange(10))
    array([ 3,  7, 11, 15,  2,  1,  6,  5, 10,  9])
    
    >>> hp.ring2nest([1, 2, 4, 8], 11)
    array([ 11,  13,  61, 253])
    """
    check_nside(nside)
    return pixlib._ring2nest(nside, ipix)

def nest2ring(nside, ipix):
    """Convert pixel number from NESTED ordering to RING ordering.

    Parameters
    ----------
    nside : int, scalar or array-like
      the healpix nside parameter
    ipix : int, scalar or array-like
      the pixel number in NESTED scheme

    Returns
    -------
    ipix : int, scalar or array-like
      the pixel number in RING scheme

    See Also
    --------
    ring2nest, reorder
    
    Examples
    --------
    >>> import healpy as hp
    >>> hp.nest2ring(16, 1130)
    1504

    >>> hp.nest2ring(2, np.arange(10))
    array([13,  5,  4,  0, 15,  7,  6,  1, 17,  9])
    
    >>> hp.nest2ring([1, 2, 4, 8], 11)
    array([ 11,   2,  12, 211])
    """
    check_nside(nside)
    return pixlib._nest2ring(nside, ipix)

@accept_ma
def reorder(map_in, inp=None, out=None, r2n=None, n2r=None):
    """Reorder an healpix map from RING/NESTED ordering to NESTED/RING

    Parameters
    ----------
    map_in : array-like
      the input map to reorder, accepts masked arrays
    inp, out : ``'RING'`` or ``'NESTED'``
      define the input and output ordering
    r2n : bool
      if True, reorder from RING to NESTED
    n2r : bool
      if True, reorder from NESTED to RING

    Returns
    -------
    map_out : array-like
      the reordered map, as masked array if the input was a 
      masked array

    Notes
    -----
    if ``r2n`` or ``n2r`` is defined, override ``inp`` and ``out``.

    See Also
    --------
    nest2ring, ring2nest

    Examples
    --------
    >>> import healpy as hp
    >>> hp.reorder(np.arange(48), r2n = True)
    array([13,  5,  4,  0, 15,  7,  6,  1, 17,  9,  8,  2, 19, 11, 10,  3, 28,
           20, 27, 12, 30, 22, 21, 14, 32, 24, 23, 16, 34, 26, 25, 18, 44, 37,
           36, 29, 45, 39, 38, 31, 46, 41, 40, 33, 47, 43, 42, 35])
    >>> hp.reorder(np.arange(12), n2r = True)
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
    >>> hp.reorder(hp.ma(np.arange(12.)), n2r = True)
    masked_array(data = [  0.   1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  11.],
                 mask = False,
           fill_value = -1.6375e+30)
    
    >>> m = [np.arange(12.), np.arange(12.), np.arange(12.)]
    >>> m[0][2] = hp.UNSEEN
    >>> m[1][2] = hp.UNSEEN
    >>> m[2][2] = hp.UNSEEN
    >>> m = hp.ma(m)
    >>> hp.reorder(m, n2r = True)
    (masked_array(data = [0.0 1.0 -- 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0],
                 mask = [False False  True False False False False False False False False False],
           fill_value = -1.6375e+30)
    , masked_array(data = [0.0 1.0 -- 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0],
                 mask = [False False  True False False False False False False False False False],
           fill_value = -1.6375e+30)
    , masked_array(data = [0.0 1.0 -- 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0],
                 mask = [False False  True False False False False False False False False False],
           fill_value = -1.6375e+30)
    )
    """
    typ = maptype(map_in)
    if typ == 0:
        npix = len(map_in)
    else:
        npix = len(map_in[0])
    nside = npix2nside(npix)
    if nside>128:
        bunchsize = npix//24
    else:
        bunchsize = npix
    if r2n:
        inp='RING'
        out='NEST'
    if n2r:
        inp='NEST'
        out='RING'
    inp = str(inp).upper()[0:4]
    out = str(out).upper()[0:4]
    if inp not in ['RING','NEST'] or out not in ['RING','NEST']:
        raise ValueError('inp and out must be either RING or NEST')
    if typ == 0:
        mapin = [map_in]
    else:
        mapin = map_in
    mapout = []
    for m_in in mapin:
        if inp == out:
            mapout.append(m_in)
        elif inp == 'RING':
            m_out = np.zeros(npix,dtype=type(m_in[0]))
            for ibunch in range(npix//bunchsize):
                ipix_n = np.arange(ibunch*bunchsize,
                                    (ibunch+1)*bunchsize)
                ipix_r = nest2ring(nside, ipix_n)
                m_out[ipix_n] = np.asarray(m_in)[ipix_r]
            mapout.append(m_out)
        elif inp == 'NEST':
            m_out = np.zeros(npix,dtype=type(m_in[0]))
            for ibunch in range(npix//bunchsize):
                ipix_r = np.arange(ibunch*bunchsize,
                                    (ibunch+1)*bunchsize)
                ipix_n = ring2nest(nside, ipix_r)
                m_out[ipix_r] = np.asarray(m_in)[ipix_n]
            mapout.append(m_out)
    if typ == 0:
        return mapout[0]
    else:
        return mapout

def nside2npix(nside):
    """Give the number of pixels for the given nside.

    Parameters
    ----------
    nside : int
      healpix nside parameter; an exception is raised if nside is not valid
      (nside must be a power of 2, less than 2**30)

    Returns
    -------
    npix : int
      corresponding number of pixels
    
    Notes
    -----
    Raise a ValueError exception if nside is not valid.

    Examples
    --------
    >>> import healpy as hp
    >>> import numpy as np
    >>> hp.nside2npix(8)
    768

    >>> np.all([hp.nside2npix(nside) == 12 * nside**2 for nside in [2**n for n in range(12)]])
    True

    >>> hp.nside2npix(7)
    Traceback (most recent call last):
        ...
    ValueError: 7 is not a valid nside parameter (must be a power of 2, less than 2**30)
    """
    check_nside(nside)
    return 12*nside**2

def nside2order(nside):
    """Give the resolution order for a given nside.

    Parameters
    ----------
    nside : int
      healpix nside parameter; an exception is raised if nside is not valid
      (nside must be a power of 2, less than 2**30)

    Returns
    -------
    order : int
      corresponding order where nside = 2**(order)

    Notes
    -----
    Raise a ValueError exception if nside is not valid.

    Examples
    --------
    >>> import healpy as hp
    >>> import numpy as np
    >>> hp.nside2order(128)
    7

    >>> np.all([hp.nside2order(2**o) == o for o in range(30)])
    True

    >>> hp.nside2order(7)
    Traceback (most recent call last):
        ...
    ValueError: 7 is not a valid nside parameter (must be a power of 2, less than 2**30)
    """
    check_nside(nside)
    return len('{0:b}'.format(nside)) - 1

def nside2resol(nside, arcmin=False):
    """Give approximate resolution (pixel size in radian or arcmin) for nside.

    Resolution is just the square root of the pixel area, which is a gross
    approximation given the different pixel shapes

    Parameters
    ----------
    nside : int
      healpix nside parameter, must be a power of 2, less than 2**30
    arcmin : bool
      if True, return resolution in arcmin, otherwise in radian

    Returns
    -------
    resol : float
      approximate pixel size in radians or arcmin

    Notes
    -----
    Raise a ValueError exception if nside is not valid.

    Examples
    --------
    >>> import healpy as hp
    >>> hp.nside2resol(128, arcmin = True)
    27.483891294539248

    >>> hp.nside2resol(256)
    0.0039973699529159707

    >>> hp.nside2resol(7)
    Traceback (most recent call last):
       ...
    ValueError: 7 is not a valid nside parameter (must be a power of 2, less than 2**30)
    """
    check_nside(nside)
    
    resol = np.sqrt(nside2pixarea(nside))

    if arcmin:
        resol = np.rad2deg(resol) * 60
        
    return resol


def nside2pixarea(nside, degrees=False):
    """Give pixel area given nside in square radians or square degrees.

    Parameters
    ----------
    nside : int
      healpix nside parameter, must be a power of 2, less than 2**30
    degrees : bool
      if True, returns pixel area in square degrees, in square radians otherwise

    Returns
    -------
    pixarea : float
      pixel area in square radian or square degree

    Notes
    -----
    Raise a ValueError exception if nside is not valid.

    Examples
    --------
    >>> import healpy as hp
    >>> hp.nside2pixarea(128, degrees = True)
    0.2098234113027917

    >>> hp.nside2pixarea(256)
    1.5978966540475428e-05

    >>> hp.nside2pixarea(7)
    Traceback (most recent call last):
       ...
    ValueError: 7 is not a valid nside parameter (must be a power of 2, less than 2**30)
    """
    check_nside(nside)
    
    pixarea = 4*np.pi/nside2npix(nside)

    if degrees:
        pixarea = np.rad2deg(np.rad2deg(pixarea))
        
    return pixarea

def npix2nside(npix):
    """Give the nside parameter for the given number of pixels.

    Parameters
    ----------
    npix : int
      the number of pixels
    
    Returns
    -------
    nside : int
      the nside parameter corresponding to npix

    Notes
    -----
    Raise a ValueError exception if number of pixel does not correspond to
    the number of pixel of an healpix map.

    Examples
    --------
    >>> import healpy as hp
    >>> hp.npix2nside(768)
    8

    >>> np.all([hp.npix2nside(12 * nside**2) == nside for nside in [2**n for n in range(12)]])
    True

    >>> hp.npix2nside(1000)
    Traceback (most recent call last):
        ...
    ValueError: Wrong pixel number (it is not 12*nside**2)
    """
    nside = np.sqrt(npix/12.)
    if nside != np.floor(nside):
        raise ValueError("Wrong pixel number (it is not 12*nside**2)")
    nside=int(np.floor(nside))
    check_nside(nside)
    return nside

def order2nside(order):
    """Give the nside parameter for the given resolution order.

    Parameters
    ----------
    order : int
      the resolution order

    Returns
    -------
    nside : int
      the nside parameter corresponding to order

    Notes
    -----
    Raise a ValueError exception if order produces an nside out of range.

    Examples
    --------
    >>> import healpy as hp
    >>> hp.order2nside(7)
    128

    >>> hp.order2nside(np.arange(8))
    array([  1,   2,   4,   8,  16,  32,  64, 128])

    >>> hp.order2nside(31)
    Traceback (most recent call last):
        ...
    ValueError: 2147483648 is not a valid nside parameter (must be a power of 2, less than 2**30)
    """
    nside = 1<>> import healpy as hp
    >>> hp.isnsideok(13)
    False
    
    >>> hp.isnsideok(32)
    True

    >>> hp.isnsideok([1, 2, 3, 4, 8, 16])
    array([ True,  True, False,  True,  True,  True], dtype=bool)
    """
    # we use standard bithacks from http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
    if hasattr(nside, '__len__'):
        if not isinstance(nside, np.ndarray):
            nside = np.asarray(nside)
        return ((nside == nside.astype(np.int)) & (0 < nside) &
                (nside <= max_nside) &
                ((nside.astype(np.int) & (nside.astype(np.int) - 1)) == 0))
    else:
        return (nside == int(nside) and 0 < nside <= max_nside and
               (int(nside) & (int(nside) - 1)) == 0)

def check_nside(nside):
    """Raises exception is nside is not valid"""
    if not np.all(isnsideok(nside)):
        raise ValueError("%s is not a valid nside parameter (must be a power of 2, less than 2**30)" % str(nside))

def isnpixok(npix):
    """Return :const:`True` if npix is a valid value for healpix map size, :const:`False` otherwise.

    Parameters
    ----------
    npix : int, scalar or array-like
      integer value to be tested

    Returns
    -------
    ok : bool, scalar or array-like
      :const:`True` if given value is a valid number of pixel, :const:`False` otherwise

    Examples
    --------
    >>> import healpy as hp
    >>> hp.isnpixok(12)
    True
    
    >>> hp.isnpixok(768)
    True

    >>> hp.isnpixok([12, 768, 1002])
    array([ True,  True, False], dtype=bool)
    """
    if hasattr(npix,'__len__'):
        nside = np.sqrt(np.asarray(npix)/12.)
        return isnsideok(nside)
    else:
        nside = np.sqrt(npix/12.)
        return isnsideok(nside)

def get_interp_val(m,theta,phi,nest=False,lonlat=False):
    """Return the bi-linear interpolation value of a map using 4 nearest neighbours.

    Parameters
    ----------
    m : array-like
      an healpix map, accepts masked arrays
    theta, phi : float, scalar or array-like
      angular coordinates of point at which to interpolate the map
    nest : bool
      if True, the is assumed to be in NESTED ordering.
    lonlat : bool
      If True, input angles are assumed to be longitude and latitude in degree,
      otherwise, they are co-latitude and longitude in radians.

    Returns
    -------
      val : float, scalar or arry-like
        the interpolated value(s), usual numpy broadcasting rules apply.

    See Also
    --------
    get_interp_weights, get_all_neighbours

    Examples
    --------
    >>> import healpy as hp
    >>> hp.get_interp_val(np.arange(12.), np.pi/2, 0)
    4.0
    >>> hp.get_interp_val(np.arange(12.), np.pi/2, np.pi/2)
    5.0
    >>> hp.get_interp_val(np.arange(12.), np.pi/2, np.pi/2 + 2*np.pi)
    5.0
    >>> hp.get_interp_val(np.arange(12.), np.linspace(0, np.pi, 10), 0)
    array([ 1.5       ,  1.5       ,  1.5       ,  2.20618428,  3.40206143,
            5.31546486,  7.94639458,  9.5       ,  9.5       ,  9.5       ])
    >>> hp.get_interp_val(np.arange(12.), 0, np.linspace(90, -90, 10), lonlat=True)
    array([ 1.5       ,  1.5       ,  1.5       ,  2.20618428,  3.40206143,
            5.31546486,  7.94639458,  9.5       ,  9.5       ,  9.5       ])
    """
    m2=m.ravel()
    nside=npix2nside(m2.size)
    if lonlat:
        theta,phi = lonlat2thetaphi(theta,phi)
    if nest:
        r=pixlib._get_interpol_nest(nside,theta,phi)
    else:
        r=pixlib._get_interpol_ring(nside,theta,phi)
    p=np.array(r[0:4])
    w=np.array(r[4:8])
    del r
    return np.sum(m2[p]*w,0)

def get_neighbours(nside, theta, phi=None, nest=False):
    raise NameError("get_neighbours has been renamed to get_interp_weights")

def get_interp_weights(nside,theta,phi=None,nest=False,lonlat=False):
    """Return the 4 closest pixels on the two rings above and below the
    location and corresponding weights.
    Weights are provided for bilinear interpolation along latitude and longitude

    Parameters
    ----------
    nside : int
      the healpix nside
    theta, phi : float, scalar or array-like
      if phi is not given, theta is interpreted as pixel number,
      otherwise theta[rad],phi[rad] are angular coordinates
    nest : bool
      if ``True``, NESTED ordering, otherwise RING ordering.
    lonlat : bool
      If True, input angles are assumed to be longitude and latitude in degree,
      otherwise, they are co-latitude and longitude in radians.

    Returns
    -------
    res : tuple of length 2
      contains pixel numbers in res[0] and weights in res[1].
      Usual numpy broadcasting rules apply.

    See Also
    --------
    get_interp_val, get_all_neighbours

    Examples
    --------
    >>> import healpy as hp
    >>> hp.get_interp_weights(1, 0)
    (array([0, 1, 4, 5]), array([ 1.,  0.,  0.,  0.]))

    >>> hp.get_interp_weights(1, 0, 0)
    (array([1, 2, 3, 0]), array([ 0.25,  0.25,  0.25,  0.25]))

    >>> hp.get_interp_weights(1, 0, 90, lonlat=True)
    (array([1, 2, 3, 0]), array([ 0.25,  0.25,  0.25,  0.25]))

    >>> hp.get_interp_weights(1, [0, np.pi/2], 0)
    (array([[ 1,  4],
           [ 2,  5],
           [ 3, 11],
           [ 0,  8]]), array([[ 0.25,  1.  ],
           [ 0.25,  0.  ],
           [ 0.25,  0.  ],
           [ 0.25,  0.  ]]))
    """
    check_nside(nside)
    if phi == None:
        theta,phi = pix2ang(nside,theta,nest=nest)
    elif lonlat:
        theta,phi = lonlat2thetaphi(theta,phi)
    if nest:
        r=pixlib._get_interpol_nest(nside,theta,phi)
    else:
        r=pixlib._get_interpol_ring(nside,theta,phi)
    p=np.array(r[0:4])
    w=np.array(r[4:8])
    return (p,w)

def get_all_neighbours(nside, theta, phi=None, nest=False, lonlat=False):
    """Return the 8 nearest pixels.

    Parameters
    ----------
    nside : int
      the nside to work with
    theta, phi : scalar or array-like
      if phi is not given or None, theta is interpreted as pixel number,
      otherwise, theta[rad],phi[rad] are angular coordinates
    nest : bool
      if ``True``, pixel number will be NESTED ordering, otherwise RING ordering.
    lonlat : bool
      If True, input angles are assumed to be longitude and latitude in degree,
      otherwise, they are co-latitude and longitude in radians.

    Returns
    -------
    ipix : int, array
      pixel number of the SW, W, NW, N, NE, E, SE and S neighbours,
      shape is (8,) if input is scalar, otherwise shape is (8, N) if input is
      of length N. If a neighbor does not exist (it can be the case for W, N, E and S)
      the corresponding pixel number will be -1.

    See Also
    --------
    get_interp_weights, get_interp_val

    Examples
    --------
    >>> import healpy as hp
    >>> hp.get_all_neighbours(1, 4)
    array([11,  7,  3, -1,  0,  5,  8, -1])

    >>> hp.get_all_neighbours(1, np.pi/2, np.pi/2)
    array([ 8,  4,  0, -1,  1,  6,  9, -1])

    >>> hp.get_all_neighbours(1, 90, 0, lonlat=True)
    array([ 8,  4,  0, -1,  1,  6,  9, -1])
    """
    check_nside(nside)
    if phi is not None:
        theta = ang2pix(nside, theta, phi, nest=nest, lonlat=lonlat)
    if nest:
        r=pixlib._get_neighbors_nest(nside,theta)
    else:
        r=pixlib._get_neighbors_ring(nside,theta)
    res=np.array(r[0:8])
    return res

def max_pixrad(nside):
    """Maximum angular distance between any pixel center and its corners

    Parameters
    ----------
    nside : int
      the nside to work with

    Returns
    -------
    rads: double
       angular distance (in radians)

    Examples
    --------
    >>> '%.15f' % max_pixrad(1)
    '0.841068670567930'
    >>> '%.15f' % max_pixrad(16)
    '0.066014761432513'
    """
    check_nside(nside)
    return pixlib._max_pixrad(nside)

def fit_dipole(m, nest=False, bad=UNSEEN, gal_cut=0):
    """Fit a dipole and a monopole to the map, excluding bad pixels.

    Parameters
    ----------
    m : float, array-like
      the map to which a dipole is fitted and subtracted, accepts masked maps
    nest : bool
      if ``False`` m is assumed in RING scheme, otherwise map is NESTED
    bad : float
      bad values of pixel, default to :const:`UNSEEN`.
    gal_cut : float
      pixels at latitude in [-gal_cut;+gal_cut] degrees are not taken into account

    Returns
    -------
    res : tuple of length 2
      the monopole value in res[0] and the dipole vector (as array) in res[1]

    See Also
    --------
    remove_dipole, fit_monopole, remove_monopole
    """
    m=ma_to_array(m)
    m=np.asarray(m)
    npix = m.size
    nside = npix2nside(npix)
    if nside>128:
        bunchsize = npix//24
    else:
        bunchsize = npix
    aa = np.zeros((4,4),dtype=np.float64)
    v = np.zeros(4,dtype=np.float64)
    for ibunch in range(npix//bunchsize):
        ipix = np.arange(ibunch*bunchsize,
                          (ibunch+1)*bunchsize)
        ipix = ipix[(m.flat[ipix]!=bad) & (np.isfinite(m.flat[ipix]))]
        x,y,z = pix2vec(nside, ipix, nest)
        if gal_cut>0:
            w = (np.abs(z)>=np.sin(gal_cut*np.pi/180))
            ipix=ipix[w]
            x=x[w]
            y=y[w]
            z=z[w]
            del w
        aa[0,0] += ipix.size
        aa[1,0] += x.sum()
        aa[2,0] += y.sum()
        aa[3,0] += z.sum()
        aa[1,1] += (x**2).sum()
        aa[2,1] += (x*y).sum()
        aa[3,1] += (x*z).sum()
        aa[2,2] += (y**2).sum()
        aa[3,2] += (y*z).sum()
        aa[3,3] += (z**2).sum()
        v[0] += m.flat[ipix].sum()
        v[1] += (m.flat[ipix]*x).sum()
        v[2] += (m.flat[ipix]*y).sum()
        v[3] += (m.flat[ipix]*z).sum()
    aa[0,1] = aa[1,0]
    aa[0,2] = aa[2,0]
    aa[0,3] = aa[3,0]
    aa[1,2] = aa[2,1]
    aa[1,3] = aa[3,1]
    aa[2,3] = aa[3,2]
    res = np.dot(np.linalg.inv(aa),v)
    mono = res[0]
    dipole = res[1:4]
    return mono,dipole

def remove_dipole(m,nest=False,bad=UNSEEN,gal_cut=0,fitval=False,
                  copy=True,verbose=True):
    """Fit and subtract the dipole and the monopole from the given map m.

    Parameters
    ----------
    m : float, array-like
      the map to which a dipole is fitted and subtracted, accepts masked arrays
    nest : bool
      if ``False`` m is assumed in RING scheme, otherwise map is NESTED
    bad : float
      bad values of pixel, default to :const:`UNSEEN`.
    gal_cut : float
      pixels at latitude in [-gal_cut;+gal_cut] are not taken into account
    fitval : bool
      whether to return or not the fitted values of monopole and dipole
    copy : bool
      whether to modify input map or not (by default, make a copy)
    verbose : bool
      print values of monopole and dipole

    Returns
    -------
    res : array or tuple of length 3
      if fitval is False, returns map with monopole and dipole subtracted,
      otherwise, returns map (array, in res[0]), monopole (float, in res[1]), 
      dipole_vector (array, in res[2])

    See Also
    --------
    fit_dipole, fit_monopole, remove_monopole
    """
    input_ma = is_ma(m)
    m=ma_to_array(m)
    m=np.array(m,copy=copy)
    npix = m.size
    nside = npix2nside(npix)
    if nside>128:
        bunchsize = npix//24
    else:
        bunchsize = npix
    mono,dipole = fit_dipole(m,nest=nest,bad=bad,gal_cut=gal_cut)
    for ibunch in range(npix//bunchsize):
        ipix = np.arange(ibunch*bunchsize,
                          (ibunch+1)*bunchsize)
        ipix = ipix[(m.flat[ipix]!=bad) & (np.isfinite(m.flat[ipix]))]
        x,y,z = pix2vec(nside, ipix, nest)
        m.flat[ipix] -= (dipole[0]*x)
        m.flat[ipix] -= dipole[1]*y
        m.flat[ipix] -= dipole[2]*z
        m.flat[ipix] -= mono
    if verbose:
        from . import rotator as R
        lon,lat = R.vec2dir(dipole,lonlat=True)
        amp = np.sqrt((dipole**2).sum())
        print(
            'monopole: {0:g}  dipole: lon: {1:g}, lat: {2:g}, amp: {3:g}'
            .format(mono, lon, lat, amp))
    if is_ma:
        m = ma(m)
    if fitval:
        return m,mono,dipole
    else:
        return m

def fit_monopole(m,nest=False,bad=UNSEEN,gal_cut=0):
    """Fit a monopole to the map, excluding unseen pixels.

    Parameters
    ----------
    m : float, array-like
      the map to which a dipole is fitted and subtracted, accepts masked arrays
    nest : bool
      if ``False`` m is assumed in RING scheme, otherwise map is NESTED
    bad : float
      bad values of pixel, default to :const:`UNSEEN`.
    gal_cut : float
      pixels at latitude in [-gal_cut;+gal_cut] degrees are not taken into account

    Returns
    -------
    res: float
      fitted monopole value

    See Also
    --------
    fit_dipole, remove_monopole, remove_monopole
    """
    m=ma_to_array(m)
    m=np.asarray(m)
    npix=m.size
    nside = npix2nside(npix)
    if nside>128:
        bunchsize=npix//24
    else:
        bunchsize=npix
    aa = v = 0.0
    for ibunch in range(npix//bunchsize):
        ipix = np.arange(ibunch*bunchsize,
                          (ibunch+1)*bunchsize)
        ipix = ipix[(m.flat[ipix]!=bad) & (np.isfinite(m.flat[ipix]))]
        x,y,z = pix2vec(nside, ipix, nest)
        if gal_cut>0:
            w = (np.abs(z)>=np.sin(gal_cut*np.pi/180))
            ipix=ipix[w]
            x=x[w]
            y=y[w]
            z=z[w]
            del w
        aa += ipix.size
        v += m.flat[ipix].sum()
    mono = v/aa
    return mono

def remove_monopole(m,nest=False,bad=UNSEEN,gal_cut=0,fitval=False,
                    copy=True,verbose=True):
    """Fit and subtract the monopole from the given map m.

    Parameters
    ----------
    m : float, array-like
      the map to which a monopole is fitted and subtracted
    nest : bool
      if ``False`` m is assumed in RING scheme, otherwise map is NESTED
    bad : float
      bad values of pixel, default to :const:`UNSEEN`.
    gal_cut : float
      pixels at latitude in [-gal_cut;+gal_cut] are not taken into account
    fitval : bool
      whether to return or not the fitted value of monopole
    copy : bool
      whether to modify input map or not (by default, make a copy)
    verbose: bool
      whether to print values of monopole

    Returns
    -------
    res : array or tuple of length 3
      if fitval is False, returns map with monopole subtracted,
      otherwise, returns map (array, in res[0]) and monopole (float, in res[1])

    See Also
    --------
    fit_dipole, fit_monopole, remove_dipole
    """
    input_ma = is_ma(m)
    m= ma_to_array(m)
    m=np.array(m,copy=copy)
    npix = m.size
    nside = npix2nside(npix)
    if nside>128:
        bunchsize = npix//24
    else:
        bunchsize = npix
    mono = fit_monopole(m,nest=nest,bad=bad,gal_cut=gal_cut)
    for ibunch in range(npix//bunchsize):
        ipix = np.arange(ibunch*bunchsize,
                          (ibunch+1)*bunchsize)
        ipix = ipix[(m.flat[ipix]!=bad) & (np.isfinite(m.flat[ipix]))]
        x,y,z = pix2vec(nside, ipix, nest)
        m.flat[ipix] -= mono
    if verbose:
        print('monopole: {0:g}'.format(mono))
    if input_ma:
        m = ma(m)
    if fitval:
        return m,mono
    else:
        return m

def get_map_size(m):
    """Returns the npix of a given map (implicit or explicit pixelization).

     If map is a dict type, assumes explicit pixelization: use nside key if present, or use 
     nside attribute if present, otherwise use the smallest valid npix given the maximum key value.
     otherwise assumes implicit pixelization and returns len(m).

     Parameters
     ----------
     m : array-like or dict-like
       a map with implicit (array-like) or explicit (dict-like) pixellization

     Returns
     -------
     npix : int
       a valid number of pixel

     Notes
     -----
     In implicit pixellization, raise a ValueError exception if the size of the input
     is not a valid pixel number.

     Examples
     --------
    >>> import healpy as hp
     >>> m = {0: 1, 1: 1, 2: 1, 'nside': 1}
     >>> print(hp.get_map_size(m))
     12

     >>> m = {0: 1, 767: 1}
     >>> print(hp.get_map_size(m))
     768

     >>> print(hp.get_map_size(np.zeros(12 * 8 ** 2)))
     768
    """
    if isinstance(m, dict):
        if 'nside' in m:
            return nside2npix(m['nside'])
        elif hasattr(ma, 'nside'):
            return nside2npix(m.nside)
        else:
            nside = get_min_valid_nside(max(m.keys())+1)
            return nside2npix(nside)
    else:
        if isnpixok(len(m)):
            return len(m)
        else:
            raise ValueError("Wrong pixel number (it is not 12*nside**2)")

def get_min_valid_nside(npix):
    """Returns the minimum acceptable nside so that npix <= nside2npix(nside).

    Parameters
    ----------
    npix : int
      a minimal number of pixel

    Returns
    -------
    nside : int
      a valid healpix nside so that 12 * nside ** 2 >= npix

    Examples
    --------
    >>> import healpy as hp
    >>> hp.pixelfunc.get_min_valid_nside(355)
    8
    >>> hp.pixelfunc.get_min_valid_nside(768)
    8
    """
    order = 0.5 * np.log2(npix / 12.)
    return 2**int(np.ceil(order))


def get_nside(m):
    """Return the nside of the given map.

    Parameters
    ----------
    m : sequence
      the map to get the nside from.

    Returns
    -------
    nside : int
      the healpix nside parameter of the map (or sequence of maps)

    Notes
    -----
    If the input is a sequence of maps, all of them must have same size.
    If the input is not a valid map (not a sequence, unvalid number of pixels),
    a TypeError exception is raised.
    """
    typ = maptype(m)
    if typ == 0:
        return npix2nside(len(m))
    else:
        return npix2nside(len(m[0]))

@accept_ma
def ud_grade(map_in,nside_out,pess=False,order_in='RING',order_out=None,
             power=None, dtype=None):
    """Upgrade or degrade resolution of a map (or list of maps).

    in degrading the resolution, ud_grade sets the value of the superpixel
    as the mean of the children pixels.

    Parameters
    ----------
    map_in : array-like or sequence of array-like
      the input map(s) (if a sequence of maps, all must have same size)
    nside_out : int
      the desired nside of the output map(s)
    pess : bool
      if ``True``, in degrading, reject pixels which contains
      a bad sub_pixel. Otherwise, estimate average with good pixels
    order_in, order_out : str
      pixel ordering of input and output ('RING' or 'NESTED')
    power : float
      if non-zero, divide the result by (nside_in/nside_out)**power
      Examples:
      power=-2 keeps the sum of the map invariant (useful for hitmaps),
      power=2 divides the mean by another factor of (nside_in/nside_out)**2
      (useful for variance maps)
    dtype : type
      the type of the output map

    Returns
    -------
    map_out : array-like or sequence of array-like
      the upgraded or degraded map(s)

    Examples
    --------
    >>> import healpy as hp
    >>> hp.ud_grade(np.arange(48.), 1)
    array([  5.5 ,   7.25,   9.  ,  10.75,  21.75,  21.75,  23.75,  25.75,
            36.5 ,  38.25,  40.  ,  41.75])
    """
    check_nside(nside_out)
    typ = maptype(map_in)
    if typ<0:
        raise TypeError('Invalid map')
    if typ == 0:
        m_in = [map_in]
    else:
        m_in = map_in
    mapout = []
    if order_out is None: order_out = order_in
    for m in m_in:
        if str(order_in).upper()[0:4] == 'RING':
            m = reorder(m,r2n=True)
        mout = _ud_grade_core(m,nside_out,pess=pess, power=power, dtype=dtype)
        if str(order_out).upper()[0:4] == 'RING':
            mout = reorder(mout,n2r=True)
        mapout.append(mout)
    if typ == 0:
        return mapout[0]
    else:
        return mapout

def _ud_grade_core(m,nside_out,pess=False,power=None, dtype=None):
    """Internal routine used by ud_grade. It assumes that the map is NESTED
    and single (not a list of maps)
    """
    nside_in = get_nside(m)
    if dtype:
        type_out = dtype
    else:
        type_out = type(m[0])
    check_nside(nside_out)
    npix_in = nside2npix(nside_in)
    npix_out = nside2npix(nside_out)

    if power:
        power = float(power)
        ratio = (float(nside_out)/float(nside_in))**power
    else:
        ratio = 1
    
    if nside_out > nside_in:
        rat2 = npix_out//npix_in
        fact = np.ones(rat2, dtype=type_out)*ratio
        map_out = np.outer(m,fact).reshape(npix_out)
    elif nside_out < nside_in:
        rat2 = npix_in//npix_out
        mr = m.reshape(npix_out,rat2)
        goods = ~(mask_bad(mr) | (~np.isfinite(mr)))
        map_out = np.sum(mr*goods, axis=1).astype(type_out)
        nhit = goods.sum(axis=1)
        if pess:
            badout = np.where(nhit != rat2)
        else:
            badout = np.where(nhit == 0)
        if power:
            nhit = nhit / ratio
        map_out[nhit!=0] = map_out[nhit!=0] / nhit[nhit!=0]
        try:
            map_out[badout] = UNSEEN
        except OverflowError:
            pass
    else:
        map_out = m
    return map_out.astype(type_out)
healpy-1.10.3/healpy/projaxes.py0000664000175000017500000012121613010375075017021 0ustar  zoncazonca00000000000000# 
#  This file is part of Healpy.
# 
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# 
#  For more information about Healpy, see http://code.google.com/p/healpy
# 
from . import projector as P
from . import rotator as R
from . import pixelfunc
import matplotlib
import matplotlib.axes
import numpy as np
import six

from ._healpy_pixel_lib import UNSEEN

pi = np.pi
dtor = pi/180.

class SphericalProjAxes(matplotlib.axes.Axes):
    """Define a special Axes to take care of spherical projection.

    Parameters
    ----------
    projection : a SphericalProj class or a class derived from it.
        type of projection
    rot : list or string
        define rotation. See rotator.
    coord : list or string
        define coordinate system. See rotator.
    coordprec : number of digit after floating point for coordinates display.
    format : format string for value display.
      
    Notes
    -----
    Other keywords from Axes (see Axes).
    """
    def __init__(self, ProjClass, *args, **kwds):
        if not issubclass(ProjClass, P.SphericalProj):
            raise TypeError("First argument must be a SphericalProj class "
                            "(or derived from)")
        self.proj = ProjClass(rot   = kwds.pop('rot',None),
                              coord = kwds.pop('coord',None),
                              flipconv = kwds.pop('flipconv',None),
                              **kwds.pop('arrayinfo', {}))
        kwds.setdefault('format','%g')
        kwds.setdefault('coordprec',2)
        kwds['aspect'] = 'equal'
        super(SphericalProjAxes,self).__init__(*args, **kwds)
        self.axis('off')
        self.set_autoscale_on(False)
        xmin,xmax,ymin,ymax = self.proj.get_extent()
        self.set_xlim(xmin,xmax)
        self.set_ylim(ymin,ymax)
        dx,dy = self.proj.ang2xy(pi/2.,1.*dtor,direct=True)
        self._segment_threshold = 16.*np.sqrt(dx**2+dy**2)
        self._segment_step_rad = 0.1*pi/180
        self._do_border = True
        self._gratdef = {}
        self._gratdef['local'] = False
        self._gratdef['dpar'] = 30.
        
    def set_format(self,f):
        """Set the format string for value display
        """
        self._format=f
        return f
    
    def set_coordprec(self,n):
        """Set the number of digits after floating point for coord display.
        """
        self._coordprec = n

    def format_coord(self,x,y):
        """Format the coordinate for display in status bar. Take projection
        into account.
        """
        format=self._format+' at '
        pos=self.get_lonlat(x,y)
        if pos is None or np.isnan(pos).any(): return ''
        lon,lat = np.around(pos,decimals=self._coordprec)
        val = self.get_value(x,y)
        if val is None:
            format = '%s'
            val = ''
        elif type(val) is str: format='%s @ '
        coordsys = self.proj.coordsysstr
        if coordsys != '':
            res=(format+'(%g, %g) in %s')%(val,lon,lat,
                                           coordsys[0:3])
        else:
            res=(format+'lon=%g, lat=%g')%(val,lon,lat)
        return res

    def get_lonlat(self,x,y):
        """Get the coordinate in the coord system of the image, in lon/lat in deg.
        """
        lon,lat = self.proj.xy2ang(x,y,lonlat=True)
        return lon,lat

    def get_value(self,x,y):
        """Get the value of the map at position x,y
        """
        if len(self.get_images()) < 1:
            return None
        im = self.get_images()[-1]
        arr=im.get_array()
        i,j = self.proj.xy2ij(x,y)
        if i is None or j is None:
            return None
        elif arr.mask is not np.ma.nomask and arr.mask[i,j]:
            return 'UNSEEN'
        else:
            return arr[i,j]

    def projmap(self,map,vec2pix_func,vmin=None,vmax=None,badval=UNSEEN,
                cmap=None,norm=None,rot=None,coord=None,**kwds):
        """Project a map on the SphericalProjAxes.

        Parameters
        ----------
        map : array-like
          The map to project.
        vec2pix_func : function
          The function describing the pixelisation.
        vmin, vmax : float, scalars
          min and max value to use instead of min max of the map
        badval : float
          The value of the bad pixels
        cmap : a color map
          The colormap to use (see matplotlib.cm)
        rot : sequence
          In the form (lon, lat, psi) (unit: degree):the center of the map is
          at (lon, lat) and rotated by angle psi around that direction.
        coord : {'G', 'E', 'C', None}
          The coordinate system of the map ('G','E' or 'C'), rotate
          the map if different from the axes coord syst.
        
        Notes
        -----
        Other keywords are transmitted to :func:`matplotlib.Axes.imshow`
        """
        img = self.proj.projmap(map,vec2pix_func,rot=rot,coord=coord)
        w = ~( np.isnan(img) | 
               np.isinf(img) | 
               pixelfunc.mask_bad(img, badval = badval) )
        try:
            if vmin is None: vmin = img[w].min()
        except ValueError:
            vmin = 0.
        try:
            if vmax is None: vmax = img[w].max()
        except ValueError:
            vmax = 0.
        if vmin > vmax:
            vmin = vmax
        if vmin == vmax:
            vmin -= 1.
            vmax += 1.
        cm,nn = get_color_table(vmin,vmax,img[w],cmap=cmap,norm=norm)
        ext = self.proj.get_extent()
        img = np.ma.masked_values(img, badval)
        aximg = self.imshow(img,extent = ext,cmap=cm,norm=nn,
                            interpolation='nearest',origin='lower',
                            vmin=vmin,vmax=vmax,**kwds)
        xmin,xmax,ymin,ymax = self.proj.get_extent()
        self.set_xlim(xmin,xmax)
        self.set_ylim(ymin,ymax)
        return img

    def projplot(self,*args,**kwds):
        """projplot is a wrapper around :func:`matplotlib.Axes.plot` to take into account the
        spherical projection.

        You can call this function as::
        
           projplot(theta, phi)        # plot a line going through points at coord (theta, phi)
           projplot(theta, phi, 'bo')  # plot 'o' in blue at coord (theta, phi)
           projplot(thetaphi)          # plot a line going through points at coord (thetaphi[0], thetaphi[1])
           projplot(thetaphi, 'bx')    # idem but with blue 'x'
        
        Parameters
        ----------
        theta, phi : float, array-like
          Coordinates of point to plot. Can be put into one 2-d array, first line is
          then *theta* and second line is *phi*. See *lonlat* parameter for unit.
        fmt : str
          A format string (see :func:`matplotlib.Axes.plot` for details)
        lonlat : bool, optional
          If True, theta and phi are interpreted as longitude and latitude
          in degree, otherwise, as colatitude and longitude in radian
        coord : {'E', 'G', 'C', None}
          The coordinate system of the points, only used if the coordinate
          coordinate system of the Axes has been defined and in this
          case, a rotation is performed
        rot : None or sequence
          rotation to be applied =(lon, lat, psi) : lon, lat will be position of the
          new Z axis, and psi is rotation around this axis, all in degree.
          if None, no rotation is performed
        direct : bool
          if True, the rotation to center the projection is not
          taken into account

        Notes
        -----
        Other keywords are passed to :func:`matplotlib.Axes.plot`.

        See Also
        --------
        projscatter, projtext
        """
        fmt = None
        if len(args) < 1:
            raise ValueError("No argument given")
        if len(args) == 1:
            theta,phi = np.asarray(args[0])
        elif len(args) == 2:
            if type(args[1]) is str:
                fmt=args[1]
                theta,phi = np.asarray(args[0])
            else:
                theta,phi = np.asarray(args[0]),np.asarray(args[1])
        elif len(args) == 3:
            if type(args[2]) is not str:
                raise TypeError("Third argument must be a string")
            else:
                theta,phi = np.asarray(args[0]),np.asarray(args[1])
                fmt = args[2]
        else:
            raise TypeError("Three args maximum")
        rot=kwds.pop('rot',None)
        if rot is not None:
            rot = np.array(np.atleast_1d(rot),copy=1)
            rot.resize(3)
            rot[1] = rot[1]-90.
        coord=self.proj.mkcoord(kwds.pop('coord',None))[::-1]
        lonlat=kwds.pop('lonlat',False)
        vec = R.dir2vec(theta,phi,lonlat=lonlat)
        vec = (R.Rotator(rot=rot,coord=coord,eulertype='Y')).I(vec)
        x,y = self.proj.vec2xy(vec,direct=kwds.pop('direct',False))
        x,y = self._make_segment(x,y,threshold=kwds.pop('threshold',
                                                        self._segment_threshold))
        thelines = []
        for xx,yy in zip(x,y):
            if fmt is not None:
                try: # works in matplotlib 1.3 and earlier
                    linestyle, marker, color = matplotlib.axes._process_plot_format(fmt)
                except: # matplotlib 1.4 and later
                    linestyle, marker, color = matplotlib.axes._axes._process_plot_format(fmt)
                kwds.setdefault('linestyle',linestyle)
                kwds.setdefault('marker',marker)
                if color is not None: kwds.setdefault('color',color)
            l = matplotlib.lines.Line2D(xx,yy,**kwds)
            self.add_line(l)
            thelines.append(l)
        return thelines

    def projscatter(self,theta, phi=None,*args,**kwds):
        """Projscatter is a wrapper around :func:`matplotlib.Axes.scatter` to take into account the
        spherical projection.
        
        You can call this function as::
        
           projscatter(theta, phi)     # plot points at coord (theta, phi)
           projplot(thetaphi)          # plot points at coord (thetaphi[0], thetaphi[1])

        Parameters
        ----------
        theta, phi : float, array-like
          Coordinates of point to plot. Can be put into one 2-d array, first line is
          then *theta* and second line is *phi*. See *lonlat* parameter for unit.
        lonlat : bool, optional
          If True, theta and phi are interpreted as longitude and latitude
          in degree, otherwise, as colatitude and longitude in radian
        coord : {'E', 'G', 'C', None}, optional
          The coordinate system of the points, only used if the coordinate
          coordinate system of the axes has been defined and in this
          case, a rotation is performed
        rot : None or sequence, optional
          rotation to be applied =(lon, lat, psi) : lon, lat will be position of the
          new Z axis, and psi is rotation around this axis, all in degree.
          if None, no rotation is performed
        direct : bool, optional
          if True, the rotation to center the projection is not
          taken into account

        Notes
        -----
        Other keywords are passed to :func:`matplotlib.Axes.plot`.

        See Also
        --------
        projplot, projtext
        """
        save_input_data = hasattr(self.figure, 'zoomtool')
        if save_input_data:
            input_data = (theta, phi, args, kwds.copy())
        if phi is None:
            theta,phi = np.asarray(theta)
        else:
            theta, phi = np.asarray(theta), np.asarray(phi)
        rot=kwds.pop('rot',None)
        if rot is not None:
            rot = np.array(np.atleast_1d(rot),copy=1)
            rot.resize(3)
            rot[1] = rot[1]-90.
        coord=self.proj.mkcoord(kwds.pop('coord',None))[::-1]
        lonlat=kwds.pop('lonlat',False)
        vec = R.dir2vec(theta,phi,lonlat=lonlat)
        vec = (R.Rotator(rot=rot,coord=coord,eulertype='Y')).I(vec)
        x,y = self.proj.vec2xy(vec,direct=kwds.pop('direct',False))
        s = self.scatter(x, y, *args, **kwds)
        if save_input_data:
            if not hasattr(self, '_scatter_data'):
                self._scatter_data = []
            self._scatter_data.append((s, input_data))
        return s

    def projtext(self, theta, phi, s, **kwds):
        """Projtext is a wrapper around :func:`matplotlib.Axes.text` to take into account the
        spherical projection.

        Parameters
        ----------
        theta, phi : float, array-like
          Coordinates of point to plot. Can be put into one 2-d array, first line is
          then *theta* and second line is *phi*. See *lonlat* parameter for unit.
        text : str
          The text to be displayed.
        lonlat : bool, optional
          If True, theta and phi are interpreted as longitude and latitude
          in degree, otherwise, as colatitude and longitude in radian
        coord : {'E', 'G', 'C', None}, optional
          The coordinate system of the points, only used if the coordinate
          coordinate system of the axes has been defined and in this
          case, a rotation is performed
        rot : None or sequence, optional
          rotation to be applied =(lon, lat, psi) : lon, lat will be position of the
          new Z axis, and psi is rotation around this axis, all in degree.
          if None, no rotation is performed
        direct : bool, optional
          if True, the rotation to center the projection is not
          taken into account

        Notes
        -----
        Other keywords are passed to :func:`matplotlib.Axes.text`.

        See Also
        --------
        projplot, projscatter
        """
        if phi is None:
            theta,phi = np.asarray(theta)
        else:
            theta, phi = np.asarray(theta), np.asarray(phi)
        rot=kwds.pop('rot',None)
        if rot is not None:
            rot = np.array(np.atleast_1d(rot),copy=1)
            rot.resize(3)
            rot[1] = rot[1]-90.
        coord=self.proj.mkcoord(kwds.pop('coord',None))[::-1]
        lonlat=kwds.pop('lonlat',False)
        vec = R.dir2vec(theta,phi,lonlat=lonlat)
        vec = (R.Rotator(rot=rot,coord=coord,eulertype='Y')).I(vec)
        x,y = self.proj.vec2xy(vec,direct=kwds.pop('direct',False))
        return self.text(x,y,s,**kwds)

    def _make_segment(self,x,y,threshold=None):
        if threshold is None:
            threshold = self._segment_threshold
        x,y=np.atleast_1d(x),np.atleast_1d(y)
        d2 = np.sqrt((np.roll(x,1)-x)**2+(np.roll(y,1)-y)**2)
        w=np.where(d2 > threshold)[0]
        #w=w[w!=0]
        xx=[]
        yy=[]
        if len(w) == 1:
            x=np.roll(x,-w[0])
            y=np.roll(y,-w[0])
            xx.append(x)
            yy.append(y)
        elif len(w) >= 2:
            xx.append(x[0:w[0]])
            yy.append(y[0:w[0]])
            for i in six.moves.xrange(len(w)-1):
                xx.append(x[w[i]:w[i+1]])
                yy.append(y[w[i]:w[i+1]])
            xx.append(x[w[-1]:])
            yy.append(y[w[-1]:])
        else:
            xx.append(x)
            yy.append(y)
        return xx,yy

    def get_parallel_interval(self,vx,vy=None,vz=None):
        """Get the min and max value of theta of the parallel to cover the
        field of view.

        Input:
          - the normalized vector of the direction of the center of the
            projection, in the reference frame of the graticule.
        Return:
          - vmin,vmax : between 0 and pi, vmin max_n_par:
            dpar = set_prec((pmax-pmin)/dtor,max_n_par/2)*dtor
        if n_mer > max_n_mer:
            dmer = set_prec((mmax-mmin)/dtor,max_n_mer/2,nn=1)*dtor
        if dmer/dpar < 0.2 or dmer/dpar > 5.:
            dmer = dpar = max(dmer,dpar)
        vdeg = int(np.floor(np.around(dpar/dtor,10)))
        varcmin = (dpar/dtor-vdeg)*60.
        if verbose: print("The interval between parallels is {0:d} deg {1:.2f}'.".format(vdeg,varcmin))
        vdeg = int(np.floor(np.around(dmer/dtor,10)))
        varcmin = (dmer/dtor-vdeg)*60.
        if verbose: print("The interval between meridians is {0:d} deg {1:.2f}'.".format(vdeg,varcmin))
        return dpar,dmer
        
class GnomonicAxes(SphericalProjAxes):
    """Define a gnomonic Axes to handle gnomonic projection.

    Input:
      - rot=, coord= : define rotation and coordinate system. See rotator.
      - coordprec= : number of digit after floating point for coordinates display.
      - format= : format string for value display.
      
      Other keywords from Axes (see Axes).
    """
    def __init__(self,*args,**kwds):
        kwds.setdefault('coordprec',3)
        super(GnomonicAxes,self).__init__(P.GnomonicProj, *args,**kwds)
        self._do_border = False
        self._gratdef['local'] = True
        self._gratdef['dpar'] = 1.

    def projmap(self,map,vec2pix_func,xsize=200,ysize=None,reso=1.5,**kwds):
        self.proj.set_proj_plane_info(xsize=xsize,ysize=ysize,reso=reso)
        return super(GnomonicAxes,self).projmap(map,vec2pix_func,**kwds)
        
class HpxGnomonicAxes(GnomonicAxes):
    def projmap(self,map,nest=False,**kwds):
        nside = pixelfunc.npix2nside(pixelfunc.get_map_size(map))
        f = lambda x,y,z: pixelfunc.vec2pix(nside,x,y,z,nest=nest)
        xsize = kwds.pop('xsize',200)
        ysize = kwds.pop('ysize',None)
        reso = kwds.pop('reso',1.5)
        return super(HpxGnomonicAxes,self).projmap(map,f,xsize=xsize,
                                            ysize=ysize,reso=reso,**kwds)


class MollweideAxes(SphericalProjAxes):
    """Define a mollweide Axes to handle mollweide projection.

    Input:
      - rot=, coord= : define rotation and coordinate system. See rotator.
      - coordprec= : number of digit after floating point for coordinates display.
      - format= : format string for value display.
      
      Other keywords from Axes (see Axes).
    """
    def __init__(self,*args,**kwds):
        kwds.setdefault('coordprec',2)
        super(MollweideAxes,self).__init__(P.MollweideProj, *args,**kwds)
        self.set_xlim(-2.01,2.01)
        self.set_ylim(-1.01,1.01)

    def projmap(self,map,vec2pix_func,xsize=800,**kwds):
        self.proj.set_proj_plane_info(xsize=xsize)
        img = super(MollweideAxes,self).projmap(map,vec2pix_func,**kwds)
        self.set_xlim(-2.01,2.01)
        self.set_ylim(-1.01,1.01)
        return img
        
class HpxMollweideAxes(MollweideAxes):
    def projmap(self,map,nest=False,**kwds):
        nside = pixelfunc.npix2nside(pixelfunc.get_map_size(map))
        f = lambda x,y,z: pixelfunc.vec2pix(nside,x,y,z,nest=nest)
        return super(HpxMollweideAxes,self).projmap(map,f,**kwds)

class CartesianAxes(SphericalProjAxes):
    """Define a cylindrical Axes to handle cylindrical projection.
    """
    def __init__(self,*args,**kwds):
        kwds.setdefault('coordprec',2)
        super(CartesianAxes,self).__init__(P.CartesianProj, *args, **kwds)
        self._segment_threshold = 180
        self._segment_step_rad = 0.1*pi/180
        self._do_border = True
        
    def projmap(self,map,vec2pix_func,xsize=800,ysize=None,lonra=None,latra=None,**kwds):
        self.proj.set_proj_plane_info(xsize=xsize,ysize=ysize,lonra=lonra,latra=latra)
        return super(CartesianAxes,self).projmap(map,vec2pix_func,**kwds)
        
class HpxCartesianAxes(CartesianAxes):
    def projmap(self,map,nest=False,**kwds):
        nside = pixelfunc.npix2nside(pixelfunc.get_map_size(map))
        f = lambda x,y,z: pixelfunc.vec2pix(nside,x,y,z,nest=nest)
        return super(HpxCartesianAxes,self).projmap(map,f,**kwds)

        
class OrthographicAxes(SphericalProjAxes):
    """Define an orthographic Axes to handle orthographic projection.
    
    Input:
    - rot=, coord= : define rotation and coordinate system. See rotator.
    - coordprec= : num of digits after floating point for coordinates display.
    - format= : format string for value display.
    
    Other keywords from Axes (see Axes).
    """
    def __init__(self,*args,**kwds):
        kwds.setdefault('coordprec',2)
        super(OrthographicAxes,self).__init__(P.OrthographicProj, *args,**kwds)
        self._segment_threshold = 0.01
        self._do_border = False
        
    def projmap(self,map,vec2pix_func,xsize=800,half_sky=False,**kwds):
        self.proj.set_proj_plane_info(xsize=xsize,half_sky=half_sky)
        img = super(OrthographicAxes,self).projmap(map,vec2pix_func,**kwds)
        if half_sky: ratio = 1.01
        else: ratio = 2.01
        self.set_xlim(-ratio,ratio)
        self.set_ylim(-1.01,1.01)
        return img
        
class HpxOrthographicAxes(OrthographicAxes):
    def projmap(self,map,nest=False,**kwds):
        nside = pixelfunc.npix2nside(len(map))
        f = lambda x,y,z: pixelfunc.vec2pix(nside,x,y,z,nest=nest)
        return super(HpxOrthographicAxes,self).projmap(map,f,**kwds)

class AzimuthalAxes(SphericalProjAxes):
    """Define an Azimuthal Axes to handle azimuthal equidistant or
       Lambert azimuthal equal-area projections.

    Input:
      - rot=, coord= : define rotation and coordinate system. See rotator.
      - coordprec= : number of digit after floating point for coordinates display.
      - format= : format string for value display.

      Other keywords from Axes (see Axes).
    """
    def __init__(self,*args,**kwds):
        kwds.setdefault('coordprec',3)
        super(AzimuthalAxes,self).__init__(P.AzimuthalProj, *args,**kwds)
        self._do_border = False

    def projmap(self,map,vec2pix_func,xsize=200,ysize=None,reso=1.5,lamb=True,half_sky=False,**kwds):
        self.proj.set_proj_plane_info(xsize=xsize,ysize=ysize,reso=reso,lamb=lamb,half_sky=half_sky)
        return super(AzimuthalAxes,self).projmap(map,vec2pix_func,**kwds)

class HpxAzimuthalAxes(AzimuthalAxes):
    def projmap(self,map,nest=False,**kwds):
        nside = pixelfunc.npix2nside(pixelfunc.get_map_size(map))
        f = lambda x,y,z: pixelfunc.vec2pix(nside,x,y,z,nest=nest)
        xsize = kwds.pop('xsize',800)
        ysize = kwds.pop('ysize',None)
        reso = kwds.pop('reso',1.5)
        lamb = kwds.pop('lamb',True)
        return super(HpxAzimuthalAxes,self).projmap(map,f,xsize=xsize,
                                            ysize=ysize,reso=reso,lamb=lamb,**kwds)

###################################################################
#
#   Table color for mollview, gnomview, and orthview.
#   Currently defined for so that the default colormap, found in 
#   matplotlib.rcParams['image.cmap'], the data is displayed with
#   values greater than vmax as the final element of the colormap,
#   masked indices gray, and the background set to white.
#
#   With matplotlib.rcParams['image.cmap'] assigned to a string
#   corresponding to a standard matplotlib colormap, one can call
#   hp.mollview(m) and have the map projected in the standard way,
#   whereas using just, e.g., hp.mollview(m, cmap='jet') will display
#   the data with a non-white background.
#
#   One can set the default colormap in the matplotlibrc file, or set
#   it in situ:
#   >>> matplotlib.rcParam['image.cmap'] = 'coolwarm'
#   >>> hp.mollview(m)
#   Note that custom colormaps can also be used, but they need to be 
#   registered ahead fo time, as shown in
#   http://matplotlib.org/examples/pylab_examples/custom_cmap.html

def get_color_table(vmin,vmax,val,cmap=None,norm=None):
    # Create color table
    newcmap = create_colormap(cmap)
    if type(norm) is str:
        if norm.lower().startswith('log'):
            norm = LogNorm2(clip=False)
        elif norm.lower().startswith('hist'):
            norm = HistEqNorm(clip=False)
        else:
            norm = None
    if norm is None:
        norm = LinNorm2(clip=False)

    norm.vmin = vmin
    norm.vmax = vmax
    norm.autoscale_None(val)
    
    return newcmap,norm

def create_colormap(cmap):
    if cmap is not None:
        return cmap 
    cmap0 = matplotlib.cm.get_cmap(matplotlib.rcParams['image.cmap'])
    if hasattr(cmap0, '_segmentdata'):
        newcm = matplotlib.colors.LinearSegmentedColormap('newcm',cmap0._segmentdata,
                                                    cmap0.N)
    else:
        newcm = cmap0
    newcm.set_over(newcm(1.0))
    newcm.set_under('w')
    newcm.set_bad('gray')
    return newcm

##################################################################
#
#   A Locator that gives the bounds of the interval
#
class BoundaryLocator(matplotlib.ticker.Locator):
    def __init__(self,N=2):
        if N < 2:
            raise ValueError("Number of locs must be greater than 1")
        self.Nlocs=N

    def __call__(self):
        if matplotlib.__version__ < '0.98':
            vmin,vmax = self.viewInterval.get_bounds()
        else:
            vmin, vmax = self.axis.get_view_interval()
        locs = vmin + np.arange(self.Nlocs)*(vmax-vmin)/(self.Nlocs-1.)
        return locs

    def autoscale(self):
        self.verify_intervals()
        vmin,vmax = self.dataInterval.get_bounds()
        if vmax vmax:
            raise ValueError("minvalue must be less than or equal to maxvalue")
        elif vmin==vmax:
            return 0.0 * val
        else:
            if clip:
                mask = np.ma.getmask(val)
                val = np.ma.array(np.clip(val.filled(vmax), vmin, vmax),
                                   mask=mask)
            result = np.ma.array(np.interp(val, self.xval, self.yval),
                                  mask=np.ma.getmask(val))
            result[np.isinf(val.data)] = -np.inf
        if vtype == 'scalar':
            result = result[0]
        return result

    def inverse(self, value):
        if not self.scaled():
            raise ValueError("Not invertible until scaled")

        if matplotlib.cbook.iterable(value):
            vtype='array'
            val = np.ma.array(value)
        else:
            vtype='scalar'
            val = np.ma.array([value])
        result = np.ma.array(self._lininterp(val, self.yval, self.xval),
                              mask=np.ma.getmask(val))
        result[np.isinf(val.data)] = -np.inf
        if vtype == 'scalar':
            result = result[0]
        return result
        
    def autoscale_None(self, val):
        changed = False
        if self.vmin is None:
            self.vmin = val.min()
            changed = True
        if self.vmax is None:
            self.vmax = val.max()
            changed = True
        if changed or self.xval is None or self.yval is None:
            self._set_xyvals(val)
            
    def autoscale(self, val):
        self.vmin = val.min()
        self.vmax = val.max()
        self._set_xyvals(val)

    def _set_xyvals(self,val):
        data = np.ma.asarray(val).ravel()
        w=np.isinf(data.data)
        if data.mask is not np.ma.nomask:
            w = w|data.mask
        data2 = data.data[~w]
        bins = min(data2.size//20, 5000)
        if bins < 3: bins=data2.size
        try:
            # for numpy 1.1, use new bins format (left and right edges)
            hist, bins = np.histogram(data2,bins=bins,
                                       range=(self.vmin,self.vmax),
                                       new=True)
        except TypeError:
            # for numpy <= 1.0 or numpy >= 1.2, no new keyword
            hist, bins = np.histogram(data2,bins=bins,
                                       range=(self.vmin,self.vmax))
        if bins.size == hist.size+1:
            # new bins format, remove last point
            bins = bins[:-1]
        hist = hist.astype(np.float)/np.float(hist.sum())
        self.yval = np.concatenate([[0.], hist.cumsum(), [1.]])
        self.xval = np.concatenate([[self.vmin], bins + 0.5*(bins[1]-bins[0]),
                                    [self.vmax]])

    def _lininterp(self,x,X,Y):
        if hasattr(x,'__len__'):
            xtype = 'array'
            xx=np.asarray(x).astype(np.float)
        else:
            xtype = 'scalar'
            xx=np.asarray([x]).astype(np.float)
        idx = X.searchsorted(xx)
        yy = xx*0
        yy[idx>len(X)-1] = Y[-1]  # over
        yy[idx<=0] = Y[0]          # under
        wok = np.where((idx>0) & (idx vmax:
            raise ValueError("minvalue must be less than or equal to maxvalue")
        elif vmin<=0:
            raise ValueError("values must all be positive")
        elif vmin==vmax:
            return type(value)(0.0 * np.asarray(value))
        else:
            if clip:
                mask = np.ma.getmask(val)
                val = np.ma.array(np.clip(val.filled(vmax), vmin, vmax),
                                   mask=mask)
            result = (np.ma.log(val)-np.log(vmin))/(np.log(vmax)-np.log(vmin))
            result.data[result.data<0]=0.0
            result.data[result.data>1]=1.0
            result[np.isinf(val.data)] = -np.inf
            if result.mask is not np.ma.nomask:
                result.mask[np.isinf(val.data)] = False
        if vtype == 'scalar':
            result = result[0]
        return result

    def autoscale_None(self, A):
        ' autoscale only None-valued vmin or vmax'
        if self.vmin is None or self.vmax is None:
            val = np.ma.masked_where(np.isinf(A.data),A)
            matplotlib.colors.Normalize.autoscale_None(self,val)

    def inverse(self, value):
        if not self.scaled():
            raise ValueError("Not invertible until scaled")
        vmin, vmax = float(self.vmin), float(self.vmax)

        if matplotlib.cbook.iterable(value):
            val = np.ma.asarray(value)
            return vmin * np.ma.power((vmax/vmin), val)
        else:
            return vmin * np.pow((vmax/vmin), value)



        
##################################################################
#
#   A normalization class to get linear color table
#

class LinNorm2(matplotlib.colors.Normalize):
    """
    Normalize a given value to the 0-1 range on a lin scale
    """
    def __call__(self, value, clip=None):
        if clip is None:
            clip = self.clip

        if matplotlib.cbook.iterable(value):
            vtype = 'array'
            val = np.ma.asarray(value).astype(np.float)
        else:
            vtype = 'scalar'
            val = np.ma.array([value]).astype(np.float)

        winf = np.isinf(val.data)
        val = np.ma.masked_where(winf,val)

        self.autoscale_None(val)
        vmin, vmax = float(self.vmin), float(self.vmax)
        if vmin > vmax:
            raise ValueError("minvalue must be less than or equal to maxvalue")
        elif vmin==vmax:
            return type(value)(0.0 * np.asarray(value))
        else:
            if clip:
                mask = np.ma.getmask(val)
                val = np.ma.array(np.clip(val.filled(vmax), vmin, vmax),
                                   mask=mask)
            result = (val-vmin) * (1./(vmax-vmin))
            result.data[result.data<0]=0.0
            result.data[result.data>1]=1.0
            result[winf] = -np.inf
            if result.mask is not np.ma.nomask:
                result.mask[winf] = False
        if vtype == 'scalar':
            result = result[0]
        return result

    def autoscale_None(self, A):
        ' autoscale only None-valued vmin or vmax'
        if self.vmin is None or self.vmax is None:
            val = np.ma.masked_where(np.isinf(A.data),A)
            matplotlib.colors.Normalize.autoscale_None(self,val)

    def inverse(self, value):
        if not self.scaled():
            raise ValueError("Not invertible until scaled")
        vmin, vmax = float(self.vmin), float(self.vmax)

        if matplotlib.cbook.iterable(value):
            val = np.ma.asarray(value)
            return vmin + (vmax-vmin) * val
        else:
            return vmin + (vmax-vmin) * value
healpy-1.10.3/healpy/projector.py0000664000175000017500000012204013026275744017202 0ustar  zoncazonca00000000000000# 
#  This file is part of Healpy.
# 
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# 
#  For more information about Healpy, see http://code.google.com/p/healpy
# 
"""This module provides classes for some spherical projection.
To be used when calling SphereProjAxes class.

SphericalProj : a virtual class (do nothing). Just a template for derived 
                (useful) classes

GnomonicProj : Gnomonic projection

AzimuthalProj : Azimuthal equidistant or Lambert azimuthal equal-area projection
"""

from . import rotator as R
import numpy as np
from . import pixelfunc
from .pixelfunc import UNSEEN

pi = np.pi
dtor = np.pi/180.

class SphericalProj(object):
    """
    This class defines functions for spherical projection.
    
    This class contains class method for spherical projection computation. It 
    should not be instantiated. It should be inherited from and methods should
    be overloaded for desired projection.
    """

    name = "None"
    
    def __init__(self, rot=None, coord=None, flipconv=None, **kwds):
        self.rotator  = R.Rotator(rot=rot,  coord=None, eulertype='ZYX')
        self.coordsys = R.Rotator(coord=coord).coordout
        self.coordsysstr = R.Rotator(coord=coord).coordoutstr
        self.set_flip(flipconv)
        self.set_proj_plane_info(**kwds)

    def set_proj_plane_info(self, **kwds):
        allNone = True
        for v in kwds.values():
            if v is not None: allNone = False
        if not allNone:
            self._arrayinfo = dict(kwds)
        else:
            self._arrayinfo = None

    def get_proj_plane_info(self):
        return self._arrayinfo
    arrayinfo = property(get_proj_plane_info,
                         doc="Dictionary with information on the projection array")

    def __eq__(self, a):
        if type(a) is not type(self): return False
        return ( (self.rotator == a.rotator) and
                 (self.coordsys == a.coordsys ) )
    
    def ang2xy(self, theta, phi=None, lonlat=False, direct=False):
        """From angular direction to position in the projection plane (%s).

        Input:
          - theta: if phi is None, theta[0] contains theta, theta[1] contains phi
          - phi  : if phi is not None, theta,phi are direction
          - lonlat: if True, angle are assumed in degree, and longitude, latitude
          - flipconv is either 'astro' or 'geo'. None will be default.
        Return:
          - x, y: position in %s plane.
        """
        pass
    
    def vec2xy(self, vx, vy=None, vz=None, direct=False):
        """From unit vector direction to position in the projection plane (%s).

        Input:
          - vx: if vy and vz are None, vx[0],vx[1],vx[2] defines the unit vector.
          - vy,vz: if defined, vx,vy,vz define the unit vector
          - lonlat: if True, angle are assumed in degree, and longitude, latitude
          - flipconv is either 'astro' or 'geo'. None will be default.

        Return:
          - x, y: position in %s plane.
        """
        pass
    
    def xy2ang(self, x, y=None, lonlat=False, direct=False):
        """From position in the projection plane to angular direction (%s).

        Input:
          - x : if y is None, x[0], x[1] define the position in %s plane.
          - y : if defined, x,y define the position in projection plane.
          - lonlat: if True, angle are assumed in degree, and longitude, latitude
          - flipconv is either 'astro' or 'geo'. None will be default.

        Return:
          - theta, phi : angular direction.
        """
        pass

    def xy2vec(self, x, y=None, direct=False):
        """From position in the projection plane to unit vector direction (%s).

        Input:
          - x : if y is None, x[0], x[1] define the position in %s plane.
          - y : if defined, x,y define the position in projection plane.
          - lonlat: if True, angle are assumed in degree, and longitude, latitude
          - flipconv is either 'astro' or 'geo'. None will be default.

        Return:
          - theta, phi : angular direction.
        """
        pass
    
    def xy2ij(self, x, y=None):
        """From position in the projection plane to image array index (%s).

        Input:
          - x : if y is None, x[0], x[1] define the position in %s plane.
          - y : if defined, x,y define the position in projection plane.
          - projinfo : additional projection information.

        Return:
          - i,j : image array indices.
        """
        pass
    
    def ij2xy(self, i=None, j=None):
        """From image array indices to position in projection plane (%s).

        Input:
          - if i and j are None, generate arrays of i and j as input
          - i : if j is None, i[0], j[1] define array indices in %s image.
          - j : if defined, i,j define array indices in image.
          - projinfo : additional projection information.

        Return:
          - x,y : position in projection plane.
        """
        pass

    def projmap(self, map, vec2pix_func,rot=None,coord=None):
        """Create an array containing the projection of the map.

        Input:
          - vec2pix_func: a function taking theta,phi and returning pixel number
          - map: an array containing the spherical map to project,
                 the pixelisation is described by vec2pix_func
        Return:
          - a 2D array with the projection of the map.

        Note: the Projector must contain information on the array.
        """
        x,y = self.ij2xy()
        if np.__version__ >= '1.1':
            matype = np.ma.core.MaskedArray
        else:
            matype = np.ma.array
        if type(x) is matype and x.mask is not np.ma.nomask:
            w = (x.mask == False)
        else:
            w = slice(None)
        img=np.zeros(x.shape,np.float64)-np.inf
        vec = self.xy2vec(np.asarray(x[w]),np.asarray(y[w]))
        vec = (R.Rotator(rot=rot,coord=self.mkcoord(coord))).I(vec)
        pix=vec2pix_func(vec[0],vec[1],vec[2])
        # support masked array for map, or a dictionnary (for explicit pixelisation)
        if isinstance(map, matype) and map.mask is not np.ma.nomask:
            mpix = map[pix]
            mpix[map.mask[pix]] = UNSEEN
        elif isinstance(map, dict):
            is_pix_seen = np.in1d(pix, map.keys()).reshape(pix.shape)
            is_pix_unseen = ~is_pix_seen
            mpix = np.zeros_like(img[w])
            mpix[is_pix_unseen] = UNSEEN
            pix_seen = pix[is_pix_seen]
            iterable = (map[p] for p in pix_seen)
            mpix[is_pix_seen] = np.fromiter(iterable, mpix.dtype,
                                             count = pix_seen.size)
        else:
            mpix = map[pix]
        img[w] = mpix
        return img
        
    def set_flip(self, flipconv):
        """flipconv is either 'astro' or 'geo'. None will be default.
        
        With 'astro', east is toward left and west toward right. 
        It is the opposite for 'geo'
        """
        if flipconv is None:
            flipconv = 'astro'  # default
        if    flipconv == 'astro': self._flip = -1
        elif  flipconv == 'geo':   self._flip = 1
        else: raise ValueError("flipconv must be 'astro', 'geo' or None for default.")
        
    def get_extent(self):
        """Get the extension of the projection plane.

        Return:
          extent = (left,right,bottom,top)
        """
        pass

    def get_fov(self):
        """Get the field of view in degree of the plane of projection

        Return:
          fov: the diameter in radian of the field of view
        """
        return 2.*pi

    def get_center(self,lonlat=False):
        """Get the center of the projection.

        Input:
          - lonlat : if True, will return longitude and latitude in degree,
                     otherwise, theta and phi in radian
        Return:
          - theta,phi or lonlat depending on lonlat keyword
        """
        lon, lat = np.asarray(self.rotator.rots[0][0:2])*180/pi
        if lonlat: return lon,lat
        else: return pi/2.-lat*dtor, lon*dtor

    def mkcoord(self,coord):
        if self.coordsys is None:
            return (coord,coord)
        elif coord is None:
            return (self.coordsys,self.coordsys)
        elif type(coord) is str:
            return (coord,self.coordsys)
        else:
            return (tuple(coord)[0],self.coordsys)
        
            
class GnomonicProj(SphericalProj):
    """This class provides class methods for Gnomonic projection.
    """
    
    name = "Gnomonic"

    def __init__(self, rot=None, coord=None, xsize=None, ysize=None, reso=None,
                 **kwds):
        super(GnomonicProj,self).__init__(rot=rot, coord=coord,
                                          xsize=xsize, ysize=ysize,reso=reso,
                                          **kwds)

    def set_proj_plane_info(self, xsize=200,ysize=None,reso=1.5):
        if xsize is None: xsize=200
        if ysize is None: ysize=xsize
        if reso is None: reso=1.5
        super(GnomonicProj,self).set_proj_plane_info(xsize=xsize,
                                                     ysize=ysize,reso=reso)
    
    def vec2xy(self, vx, vy=None, vz=None, direct=False):
        if not direct: vec = self.rotator(vx,vy,vz)
        elif vy is None and vz is None: vec=vx
        elif vy is not None and vz is not None: vec=vx,vy,vz
        else: raise ValueError("vy and vz must be both defined or both not defined")
        flip = self._flip
        mask = (np.asarray(vec[0])<=0.)
        w = np.where(mask == False)
        if not mask.any(): mask=np.ma.nomask
        if not hasattr(vec[0],'__len__'):
            if mask is not np.ma.nomask:
                x = np.nan
                y = np.nan
            else:
                x = flip*vec[1]/vec[0]
                y = vec[2]/vec[0]
        else:
            x = np.zeros(vec[0].shape)+np.nan
            y = np.zeros(vec[0].shape)+np.nan
            x[w] = flip*vec[1][w]/vec[0][w]
            y[w] = vec[2][w]/vec[0][w]
        return x,y
    vec2xy.__doc__ = SphericalProj.ang2xy.__doc__ % (name,name)

    def xy2vec(self, x, y=None, direct=False):
        flip = self._flip
        if y is None:
            x,y = x
        x,y=np.asarray(x),np.asarray(y)
        rm1=1./np.sqrt(1.+x**2+y**2)
        vec = (rm1,flip*rm1*x,rm1*y)
        if not direct:
            return self.rotator.I(vec)
        else:
            return vec
    xy2vec.__doc__ = SphericalProj.xy2vec.__doc__ % (name,name)

    def ang2xy(self, theta, phi=None, lonlat=False, direct=False):
        vec=R.dir2vec(theta,phi,lonlat=lonlat)
        return self.vec2xy(vec,direct=direct)
    ang2xy.__doc__ = SphericalProj.ang2xy.__doc__ % (name,name)
    
    def xy2ang(self, x, y=None, lonlat=False, direct=False):
        return R.vec2dir(self.xy2vec(x,y,direct=direct),lonlat=lonlat)
    xy2ang.__doc__ = SphericalProj.xy2ang.__doc__ % (name,name)


    def xy2ij(self, x, y=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for "
                            "this projector")
        xsize = int(self.arrayinfo['xsize'])
        ysize = int(self.arrayinfo['ysize'])
        reso = self.arrayinfo['reso']
        if y is None: x,y = x
        dx = reso/60. * dtor
        xc,yc = 0.5*(xsize-1), 0.5*(ysize-1)
        j = np.around(xc+x/dx).astype(np.long)
        i = np.around(yc+y/dx).astype(np.long)
        return i,j
    xy2ij.__doc__ = SphericalProj.xy2ij.__doc__ % (name,name)

    def ij2xy(self, i=None, j=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for "
                            "this projector")
        xsize = int(self.arrayinfo['xsize'])
        ysize = int(self.arrayinfo['ysize'])
        reso = self.arrayinfo['reso']
        dx = reso/60. * dtor
        xc,yc = 0.5*(xsize-1), 0.5*(ysize-1)
        if i is None and j is None:
            idx=np.outer(np.ones(ysize),np.arange(xsize))
            x=(idx-xc) * dx   # astro= '-' sign, geo '+' sign
            idx=np.outer(np.arange(ysize),np.ones(xsize))
            y=(idx-yc)*dx #(idx-yc) * dx
        elif i is not None and j is not None:
            x=(np.asarray(j)-xc) * dx
            y=(np.asarray(i)-yc) * dx #(asarray(i)-yc) * dx
        elif i is not None and j is None:
            i, j = i
            x=(np.asarray(j)-xc) * dx
            y=(np.asarray(i)-yc) * dx #(i-yc) * dx
        else:
            raise TypeError("Wrong parameters")
        return x,y
    ij2xy.__doc__ = SphericalProj.ij2xy.__doc__ % (name,name)

    def get_extent(self):
        xsize,ysize = self.arrayinfo['xsize'],self.arrayinfo['ysize']
        left,bottom = self.ij2xy(0,0)
        right,top = self.ij2xy(ysize-1,xsize-1)
        return (left,right,bottom,top)

    def get_fov(self):
        vx,vy,vz = self.xy2vec(self.ij2xy(0,0), direct=True)
        a = np.arccos(vx)
        return 2.*a

class MollweideProj(SphericalProj):
    """This class provides class methods for Mollweide projection.
    """
    
    name = "Mollweide"
    __molldata = []

    def __init__(self, rot=None, coord=None, xsize=800, **kwds):
        self.__initialise_data()
        super(MollweideProj,self).__init__(rot=rot, coord=coord,
                                           xsize=xsize, **kwds)
        
    def set_proj_plane_info(self,xsize):
        super(MollweideProj,self).set_proj_plane_info(xsize=xsize)

    def vec2xy(self, vx, vy=None, vz=None, direct=False):
        if not direct:
            theta,phi=R.vec2dir(self.rotator(vx,vy,vz))
        else:
            theta,phi=R.vec2dir(vx,vy,vz)
        flip = self._flip
        X,Y = MollweideProj.__molldata
        # set phi in [-pi,pi]
        phi = (phi+pi)%(2*pi)-pi
        lat = pi/2. - theta
        A = MollweideProj.__lininterp(X,Y,lat)
        x = flip*2./pi * phi * np.cos(A)
        y = np.sin(A)
        return x,y
    vec2xy.__doc__ = SphericalProj.vec2xy.__doc__ % (name,name)

    def xy2vec(self, x, y=None, direct=False):
        flip = self._flip
        if y is None: x,y = x
        mask = (np.asarray(x)**2/4.+np.asarray(y)**2 > 1.)
        w=np.where(mask == False)
        if not mask.any(): mask = np.ma.nomask
        if not hasattr(x,'__len__'):
            if mask is not np.ma.nomask:
                return np.nan,np.nan,np.nan
            else:
                s = np.sqrt((1-y)*(1+y))
                a = np.arcsin(y)
                z = 2./pi * (a + y*s)
                phi = flip * pi/2. * x/np.maximum(s,1.e-6)
                sz = np.sqrt((1-z)*(1+z))
                vec = sz*np.cos(phi),sz*np.sin(phi),z
                if not direct:
                    return self.rotator.I(vec)
                else:
                    return vec
        else:
            vec = (np.zeros(x.shape)+np.nan,
                   np.zeros(x.shape)+np.nan,
                   np.zeros(x.shape)+np.nan)
            s = np.sqrt((1-y[w])*(1+y[w]))
            a = np.arcsin(y[w])
            vec[2][w] = 2./pi * (a + y[w]*s)
            phi = flip * pi/2. * x[w]/np.maximum(s,1.e-6)
            sz = np.sqrt((1-vec[2][w])*(1+vec[2][w]))
            vec[0][w] = sz*np.cos(phi)
            vec[1][w] = sz*np.sin(phi)
            if not direct:
                return self.rotator.I(vec)
            else:
                return vec
    xy2vec.__doc__ = SphericalProj.xy2vec.__doc__ % (name,name)

    def ang2xy(self, theta, phi=None, lonlat=False, direct=False):
        return self.vec2xy(R.dir2vec(theta,phi,lonlat=lonlat),direct=direct)
    ang2xy.__doc__ = SphericalProj.ang2xy.__doc__ % (name,name)
    
    def xy2ang(self, x, y=None, lonlat=False, direct=False):
        vec = self.xy2vec(x,y,direct=direct)
        return R.vec2dir(vec,lonlat=lonlat)
    xy2ang.__doc__ = SphericalProj.xy2ang.__doc__ % (name,name)


    def xy2ij(self, x, y=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for "
                            "this projector")
        xsize = int(self.arrayinfo['xsize'])
        ysize = xsize // 2
        if y is None: x,y = x
        xc,yc = (xsize-1.)/2., (ysize-1.)/2.
        if hasattr(x,'__len__'):
            j = np.around(x*xc/2.+xc).astype(np.long)
            i = np.around(yc+y*yc).astype(np.long)
            mask = (x**2/4.+y**2>1.)
            if not mask.any(): mask=np.ma.nomask
            j=np.ma.array(j,mask=mask)
            i=np.ma.array(i,mask=mask)
        else:
            if x**2/4.+y**2 > 1.:
                i,j=np.nan,np.nan
            else:
                j = np.around(x*xc/2.+xc).astype(np.long)
                i = np.around(yc+y*yc).astype(np.long)
        return i,j
    xy2ij.__doc__ = SphericalProj.xy2ij.__doc__ % (name,name)

    def ij2xy(self, i=None, j=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for "
                            "this projector")
        xsize = int(self.arrayinfo['xsize'])
        ysize = xsize // 2
        xc,yc=(xsize-1.)/2.,(ysize-1.)/2.
        if i is None and j is None:
            idx = np.outer(np.arange(ysize),np.ones(xsize))
            y = (idx-yc)/yc
            idx = np.outer(np.ones(ysize),np.arange(xsize))
            x = 2.*(idx-xc)/xc
            mask = x**2/4.+y**2 > 1.
            if not mask.any(): mask=np.ma.nomask
            x = np.ma.array(x,mask=mask)
            y = np.ma.array(y,mask=mask)
        elif i is not None and j is not None:
            y = (np.asarray(i)-yc)/yc
            x=2.*(np.asarray(j)-xc)/xc
            if x**2/4.+y**2 > 1.: x,y=np.nan,np.nan
        elif i is not None and j is None:
            i,j = i
            y=(np.asarray(i)-yc)/yc
            x=2.*(np.asarray(j)-xc)/xc
            if x**2/4.+y**2 > 1.: x,y=np.nan,np.nan
        else:
            raise TypeError("i and j must be both given or both not given")
        return x,y
    ij2xy.__doc__ = SphericalProj.ij2xy.__doc__ % (name,name)

    def get_extent(self):
        return (-2.0,2.0,-1.0,1.0)

    @staticmethod
    def __initialise_data():
        if len(MollweideProj.__molldata) == 0:
            X = (np.arange(1.,180.,1.)-90.)*dtor
            Y = MollweideProj.__findRoot(MollweideProj.__fmoll,
                                         MollweideProj.__dfmoll,
                                         X.copy(),X,niter=10)
            X = np.concatenate([[-pi/2],X,[pi/2]])
            Y = np.concatenate([[-pi/2],Y,[pi/2]])
            MollweideProj.__molldata.append( X )
            MollweideProj.__molldata.append( Y )
        return

    @staticmethod
    def __findRoot(f, df, x0, argsf=None, argsdf=None, niter=100):
        x = x0
        niter = min(abs(niter),1000)
        i = 0
        while i < niter:
            dx = -f(x,argsf)/df(x,argsdf)
            x += dx
            i += 1
        return x

    @staticmethod
    def __fmoll(x,args):
        return 2.*x+np.sin(2.*x)-pi*np.sin(args)

    @staticmethod
    def __dfmoll(x,args):
        return 2.*(1.+np.cos(2.*x))

    @staticmethod
    def __lininterp(X,Y,x):
        idx = X.searchsorted(x)
        y = Y[idx-1] + (Y[idx]-Y[idx-1])/(X[idx]-X[idx-1]) * (x-X[idx-1])
        return y


class CartesianProj(SphericalProj):
    """This class provides class methods for Cartesian projection.
    """
    
    name = "Cartesian"

    def __init__(self, rot=None, coord=None, xsize=800, ysize=None, lonra=None, 
                 latra=None, **kwds):
        super(CartesianProj,self).__init__(rot=rot, coord=coord,
                                           xsize=xsize, ysize=ysize, lonra=lonra, latra=latra, **kwds)
        
    def set_proj_plane_info(self,xsize,ysize,lonra,latra):
        if lonra is None: lonra = [-180.,180.]
        if latra is None: latra = [-90.,90.]
        if (len(lonra)!=2 or len(latra)!=2 or lonra[0]<-180. or lonra[1]>180.
            or latra[0]<-90 or latra[1]>90 or lonra[0]>=lonra[1] or latra[0]>=latra[1]):
            raise TypeError("Wrong argument lonra or latra. Must be lonra=[a,b],latra=[c,d] "
                            "with a=-180, b<=180, c>=-90, d<=+90")
        lonra = self._flip*np.float64(lonra)[::self._flip]
        latra = np.float64(latra)
        xsize = np.long(xsize)
        if ysize is None:
            ratio = (latra[1]-latra[0])/(lonra[1]-lonra[0])
            ysize = np.long(round(ratio*xsize))
        else:
            ysize = np.long(ysize)
            ratio = float(ysize)/float(xsize)
        super(CartesianProj,self).set_proj_plane_info(xsize=xsize, lonra=lonra, latra=latra, 
                                                        ysize=ysize, ratio=ratio)

    def vec2xy(self, vx, vy=None, vz=None, direct=False):
        if not direct:
            theta,phi=R.vec2dir(self.rotator(vx,vy,vz))
        else:
            theta,phi=R.vec2dir(vx,vy,vz)
        flip = self._flip
        # set phi in [-pi,pi]
        x = flip*((phi+pi)%(2*pi)-pi)
        x /= dtor # convert in degree
        y = pi/2. - theta
        y /= dtor # convert in degree
        return x,y
    vec2xy.__doc__ = SphericalProj.vec2xy.__doc__ % (name,name)

    def xy2vec(self, x, y=None, direct=False):
        if y is None:
            x,y = np.asarray(x)
        else:
            x,y = np.asarray(x),np.asarray(y)
        flip = self._flip
        theta = pi/2.-y*dtor # convert in radian
        phi = flip*x*dtor # convert in radian
        # dir2vec does not support 2d arrays, so first use flatten and then
        # reshape back to previous shape
        if not direct: 
            vec = self.rotator.I(R.dir2vec(theta.flatten(),phi.flatten()))
        else:
            vec = R.dir2vec(theta.flatten(),phi.flatten())
        vec = [v.reshape(theta.shape) for v in vec]
        return vec
    xy2vec.__doc__ = SphericalProj.xy2vec.__doc__ % (name,name)

    def ang2xy(self, theta, phi=None, lonlat=False, direct=False):
        return self.vec2xy(R.dir2vec(theta,phi,lonlat=lonlat),direct=direct)
    ang2xy.__doc__ = SphericalProj.ang2xy.__doc__ % (name,name)
    
    def xy2ang(self, x, y=None, lonlat=False, direct=False):
        vec = self.xy2vec(x,y,direct=direct)
        return R.vec2dir(vec,lonlat=lonlat)
    xy2ang.__doc__ = SphericalProj.xy2ang.__doc__ % (name,name)


    def xy2ij(self, x, y=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for "
                            "this projector")
        xsize = int(self.arrayinfo['xsize'])
        ysize = int(self.arrayinfo['ysize'])
        lonra = self.arrayinfo['lonra']
        latra = self.arrayinfo['latra']
        if y is None: x,y = np.asarray(x)
        else: x,y = np.asarray(x), np.asarray(y)
        j = np.around((x-lonra[0])/(lonra[1]-lonra[0])*(xsize-1)).astype(np.int64)
        i = np.around((y-latra[0])/(latra[1]-latra[0])*(ysize-1)).astype(np.int64)
        if len(x.shape) > 0:
            mask = ((i<0)|(i>=ysize)|(j<0)|(j>=xsize))
            if not mask.any(): mask=np.ma.nomask
            j=np.ma.array(j,mask=mask)
            i=np.ma.array(i,mask=mask)
        else:
            if j<0 or j>=xsize or i<0 or i>=ysize: i=j=None
        return i,j
    xy2ij.__doc__ = SphericalProj.xy2ij.__doc__ % (name,name)

    def ij2xy(self, i=None, j=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for "
                            "this projector")
        xsize = int(self.arrayinfo['xsize'])
        ysize = int(self.arrayinfo['ysize'])
        lonra = self.arrayinfo['lonra']
        latra = self.arrayinfo['latra']
        if i is not None and j is None: i,j = np.asarray(i)
        elif i is not None and j is not None: i,j = np.asarray(i),np.asarray(j)
        if i is None and j is None:
            idx = np.outer(np.arange(ysize),np.ones(xsize))
            y = (float(latra[1]-latra[0])/(ysize-1.)) * idx
            y += latra[0]
            idx = np.outer(np.ones(ysize),np.arange(xsize))
            x = (float(lonra[1]-lonra[0])/(xsize-1.) * idx)
            x +=  lonra[0]
            x = np.ma.array(x)
            y = np.ma.array(y)
        elif i is not None and j is not None:
            y = (float(latra[1]-latra[0])/(ysize-1) ) * i 
            y += latra[0]
            x = (float(lonra[1]-lonra[0])/(xsize-1)) * j 
            x += lonra[0]
            if len(i.shape) > 0:
                mask = ((x<-180)|(x>180)|(y<-90)|(y>90))
                if not mask.any():
                    mask = np.ma.nomask
                x = np.ma.array(x,mask=mask)
                y = np.ma.array(y,mask=mask)
            else:
                if x<-180 or x>180 or y<-90 or y>90:
                    x = y = np.nan
        else:
            raise TypeError("i and j must be both given or both not given")
        return x,y
    ij2xy.__doc__ = SphericalProj.ij2xy.__doc__ % (name,name)

    def get_extent(self):
        lonra = self.arrayinfo['lonra']
        latra = self.arrayinfo['latra']
        return (lonra[0],lonra[1],latra[0],latra[1])
    get_extent.__doc__ = SphericalProj.get_extent.__doc__

    def get_fov(self):
        xsize = int(self.arrayinfo['xsize'])
        ysize = int(self.arrayinfo['ysize'])
        v1 = np.asarray(self.xy2vec(self.ij2xy(0,0), direct=True))
        v2 = np.asarray(self.xy2vec(self.ij2xy(ysize-1,xsize-1), direct=True))
        a = np.arccos((v1*v2).sum())
        return 2*a

#    def get_fov(self):
#        lonra = self.arrayinfo['lonra']
#        latra = self.arrayinfo['latra']
#        return np.sqrt((lonra[1]-lonra[0])**2+(latra[1]-latra[0])**2)
        
    def get_center(self,lonlat=False):
        lonra = self.arrayinfo['lonra']
        latra = self.arrayinfo['latra']
        xc = 0.5*(lonra[1]+lonra[0])
        yc = 0.5*(latra[1]+latra[0])
        return self.xy2ang(xc,yc,lonlat=lonlat)
    get_center.__doc__ = SphericalProj.get_center.__doc__


class OrthographicProj(SphericalProj):
    """This class provides methods for orthographic projection
    """
    
    name = "Orthographic"
    
    def __init__(self, rot=None, coord=None, xsize=800, half_sky=False,**kwds):
        super(OrthographicProj,self).__init__(rot=rot, coord=coord,xsize=xsize,
                                              half_sky=half_sky,**kwds)
    
    def set_proj_plane_info(self,xsize,half_sky):
        super(OrthographicProj,self).set_proj_plane_info(xsize=xsize,
                                                         half_sky=half_sky)
    
    def vec2xy(self, vx, vy=None, vz=None, direct=False):
        if not direct:
            theta,phi=R.vec2dir(self.rotator(vx,vy,vz))
        else:
            theta,phi=R.vec2dir(vx,vy,vz)
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for"
                            " this projector")
        half_sky = self.arrayinfo['half_sky']
        flip = self._flip
        # set phi in [-pi,pi]
        phi = flip*(phi+pi)%(2*pi)-pi
        lat = pi/2. - theta
        x = np.cos(lat)*np.sin(phi)
        if not half_sky: x -= 1.0
        y = np.sin(lat)
        # unfold back of sphere
        cosc = np.cos(lat)*np.cos(phi)
        if np.any(cosc<0):
            hmask = (cosc<0)
            if hasattr(x,'__len__'):
                if half_sky:
                    x[hmask] = np.nan
                else:
                    x[hmask] *= -1
            elif hmask:
                if half_sky:
                    x = np.nan
                else:
                    x *= -1
        if half_sky:
            mask = (np.asarray(x)**2+np.asarray(y)**2>1.0)
        else:
            mask = ((np.mod(np.asarray(x)+2.0,2.0)-1.0)**2 + \
                    np.asarray(y)**2>1.0)
        if mask.any():
            if not hasattr(x,'__len__'):
                x = np.nan
                y = np.nan
            else:
                x[mask] = np.nan
                y[mask] = np.nan
        return x,y
    vec2xy.__doc__ = SphericalProj.vec2xy.__doc__ % (name,name)
    
    def xy2vec(self, x, y=None, direct=False):
        if y is None:
            x,y = x
        if hasattr(x,'__len__'):
            x,y = np.asarray(x),np.asarray(y)
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for"
                            " this projector")
        half_sky = self.arrayinfo['half_sky']
        flip = self._flip
        # re-fold back of sphere
        mask = None
        if not half_sky:
            if hasattr(x,'__len__'):
                if np.any(x>0.0):
                    mask = (x>0.0)
                    x[mask] *= -1
            elif x>0:
                mask = 0
                x = -x
            x+=1.0
        r = np.sqrt(x**2+y**2)
        if hasattr(r,'__len__'):
            r[r>1] = np.nan
        elif r>1: r = np.nan
        c = np.arcsin(r)
        if hasattr(y,'__len__'):
            y[np.abs(y)>1] = np.nan
        elif np.abs(y)>1: y = np.nan
        lat = np.arcsin(y)
        phi = np.arctan2(x,np.cos(c))
        phi *= flip
        if not mask is None:
            if hasattr(phi,'__len__'):
                phi[mask] = pi-phi[mask]
            else: phi = pi-phi
        theta = pi/2. - lat
        vec = R.dir2vec(theta,phi)
        if not direct:
            return self.rotator.I(vec)
        else:
            return vec
    xy2vec.__doc__ = SphericalProj.xy2vec.__doc__ % (name,name)
    
    def ang2xy(self, theta, phi=None, lonlat=False, direct=False):
        return self.vec2xy(R.dir2vec(theta,phi,lonlat=lonlat),direct=direct)
    ang2xy.__doc__ = SphericalProj.ang2xy.__doc__ % (name,name)
    
    def xy2ang(self, x, y=None, lonlat=False, direct=False):
        return R.vec2dir(self.xy2vec(x,y,direct=direct),lonlat=lonlat)
    xy2ang.__doc__ = SphericalProj.xy2ang.__doc__ % (name,name)

    def xy2ij(self, x, y=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for"
                            " this projector")
        xsize = int(self.arrayinfo['xsize'])
        half_sky = self.arrayinfo['half_sky']
        if half_sky: ratio = 1
        else: ratio = 2
        ysize = xsize // ratio
        if y is None: x,y = np.asarray(x)
        else: x,y = np.asarray(x), np.asarray(y)
        xc,yc = (xsize-1.)/2., (ysize-1.)/2.
        if hasattr(x,'__len__'):
            if half_sky:
                mask = (x**2+y**2>1.0)
            else:
                mask = ((np.mod(x+2.0,2.0)-1.0)**2+y**2>1.0)
            if not mask.any(): mask = np.ma.nomask
            j=np.ma.array(np.around(x*xc/ratio+xc).astype(np.long),mask=mask)
            i=np.ma.array(np.around(yc+y*yc).astype(np.long),mask=mask)
        else:
            if ( half_sky and x**2+y**2>1.0 ) or \
                   ( not half_sky and (np.mod(x+2.0,2.0)-1.0)**2+y**2>1.0 ):
                i,j,=np.nan,np.nan
            else:
                j = np.around(x*xc/ratio+xc).astype(np.long)
                i = np.around(yc+y*yc).astype(np.long)
        return i,j
    xy2ij.__doc__ = SphericalProj.xy2ij.__doc__ % (name,name)
    
    def ij2xy(self, i=None, j=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for"
                            " this projector")
        xsize = int(self.arrayinfo['xsize'])
        half_sky = self.arrayinfo['half_sky']
        if half_sky: ratio = 1
        else: ratio = 2
        ysize = xsize // ratio
        xc,yc=(xsize-1.)/2.,(ysize-1.)/2.
        if i is None and j is None:
            idx = np.outer(np.arange(ysize),np.ones(xsize))
            y = (idx-yc)/yc
            idx = np.outer(np.ones(ysize),np.arange(xsize))
            x = ratio*(idx-xc)/xc
        elif i is not None and j is not None:
            y = (np.asarray(i)-yc)/yc
            x = ratio*(np.asarray(j)-xc)/xc
            # if np.mod(x,1.0)**2+y**2 > 1.0: x,y=np.nan,np.nan
        elif i is not None and j is None:
            i,j = i
            y=(np.asarray(i)-yc)/yc
            x=ratio*(np.asarray(j)-xc)/xc
            # if np.mod(x,1.0)**2.+y**2 > 1.: x,y=np.nan,np.nan
        else:
            raise TypeError("i and j must be both given or both not given")
        if half_sky:
            mask = (x**2+y**2>1.)
        else:
            mask = ((np.mod(x+2.0,2.0)-1.0)**2+y**2 > 1.)
        if not mask.any(): mask=np.ma.nomask
        x = np.ma.array(x,mask=mask)
        y = np.ma.array(y,mask=mask)
        if len(x)==0: x = x[0]
        if len(y)==0: y = y[0]
        return x,y
    ij2xy.__doc__ = SphericalProj.ij2xy.__doc__ % (name,name)
    
    def get_extent(self):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for"
                            " this projector")
        half_sky = self.arrayinfo['half_sky']
        if half_sky: ratio = 1.0
        else: ratio = 2.0
        return (-ratio,ratio,-1.0,1.0)
    get_extent.__doc__ = SphericalProj.get_extent.__doc__

class AzimuthalProj(SphericalProj):
    """This class provides methods for Lambert azimuthal equal-area projection and
    azimuthal equidistant projection
    """

    name = "Azimuthal"

    def __init__(self, rot=None, coord=None, xsize=None, ysize=None, reso=None, lamb=None, half_sky=None, **kwds):
        super(AzimuthalProj,self).__init__(rot=rot, coord=coord,xsize=xsize,ysize=ysize,reso=reso,lamb=lamb,half_sky=half_sky,**kwds)

    def set_proj_plane_info(self, xsize=800,ysize=None,reso=1.5,lamb=True,half_sky=False):
        if xsize is None: xsize=800
        if ysize is None: ysize=xsize
        if reso is None: reso=1.5
        if lamb is None: lamb=True
        if half_sky is None: half_sky=False
        super(AzimuthalProj,self).set_proj_plane_info(xsize=xsize,ysize=ysize,
                                                      reso=reso,lamb=lamb,half_sky=half_sky)

    def vec2xy(self, vx, vy=None, vz=None, direct=False):
        if not direct:
            theta,phi=R.vec2dir(self.rotator(vx,vy,vz))
        else:
            theta,phi=R.vec2dir(vx,vy,vz)
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for"
                            " this projector")
        flip = self._flip
        lamb = self.arrayinfo['lamb']
        half_sky = self.arrayinfo['half_sky']
        # set phi in [-pi,pi]
        phi = flip*((phi+pi)%(2*pi)-pi)
        lat = pi/2. - theta
        if lamb:
            kprime = np.sqrt (2. / (1. + np.cos(lat) * np.cos(phi)))
        else:
            c = np.arccos(np.cos(lat) * np.cos(phi))
            kprime = c / np.sin(c)
        x = kprime * np.cos(lat) * np.sin(phi)
        y = kprime * np.sin(lat)
        if lamb: r2max = 4.
        else: r2max = pi**2
        if half_sky:
            if lamb: r2max /= 2.
            else: r2max /= 4.
        mask = (np.asarray(x)**2+np.asarray(y)**2 > r2max)
        if not hasattr(x,'__len__'):
            if mask is not np.ma.nomask:
                return np.nan,np.nan
        else:
            w = np.where(mask)
            x[w] = np.nan
            y[w] = np.nan 
        return x,y
    vec2xy.__doc__ = SphericalProj.vec2xy.__doc__ % (name,name)

    def xy2vec(self, x, y=None, direct=False):
        if y is None:
            x,y = x
        if hasattr(x,'__len__'):
            x,y = np.asarray(x),np.asarray(y)
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for"
                            " this projector")
        flip = self._flip
        lamb = self.arrayinfo['lamb']
        half_sky = self.arrayinfo['half_sky']
        if lamb: r2max = 4.
        else: r2max = pi**2
        if half_sky:
            if lamb: r2max /= 2.
            else: r2max /= 4.
        mask = (np.asarray(x)**2+np.asarray(y)**2 > r2max)
        w=np.where(mask == False)
        if not mask.any(): mask = np.ma.nomask
        if not hasattr(x,'__len__'):
            if mask is not np.ma.nomask:
                return np.nan,np.nan,np.nan
            else:
                rho = np.sqrt(x**2 + y**2)
                if lamb:
                  c = 2. * np.arcsin(rho/2.)
                else:
                  c = rho
                lat = np.arcsin(y * np.sin(c)/rho)
                phi = np.arctan2(x * np.sin(c), (rho * np.cos(c)))
                phi *= flip
                vec = R.dir2vec(pi/2.-lat,phi)
                if not direct:
                    return self.rotator.I(vec)
                else:
                    return vec
        else:
            vec = (np.zeros(x.shape)+np.nan,
                   np.zeros(x.shape)+np.nan,
                   np.zeros(x.shape)+np.nan)
            rho = np.sqrt(x[w]**2 + y[w]**2)
            if lamb:
              c = 2. * np.arcsin(rho/2.)
            else:
              c = rho
            lat = np.arcsin(y[w] * np.sin(c)/rho)
            phi = np.arctan2(x[w] * np.sin(c), (rho * np.cos(c)))
            phi *= flip
            vec[0][w] = np.cos(phi)*np.cos(lat)
            vec[1][w] = np.sin(phi)*np.cos(lat)
            vec[2][w] = np.sin(lat)
            if not direct:
                return self.rotator.I(vec)
            else:
                return vec
    xy2vec.__doc__ = SphericalProj.xy2vec.__doc__ % (name,name)

    def ang2xy(self, theta, phi=None, lonlat=False, direct=False):
        return self.vec2xy(R.dir2vec(theta,phi,lonlat=lonlat),direct=direct)
    ang2xy.__doc__ = SphericalProj.ang2xy.__doc__ % (name,name)

    def xy2ang(self, x, y=None, lonlat=False, direct=False):
        return R.vec2dir(self.xy2vec(x,y,direct=direct),lonlat=lonlat)
    xy2ang.__doc__ = SphericalProj.xy2ang.__doc__ % (name,name)

    def xy2ij(self, x, y=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for "
                            "this projector")
        xsize = int(self.arrayinfo['xsize'])
        ysize = int(self.arrayinfo['ysize'])
        reso = self.arrayinfo['reso']
        lamb = self.arrayinfo['lamb']
        half_sky = self.arrayinfo['half_sky']
        if lamb: r2max = 4.
        else: r2max = pi**2
        if half_sky:
            if lamb: r2max /= 2.
            else: r2max /= 4.
        if y is None: x,y = x
        dx = reso/60. * dtor
        xc,yc = 0.5*(xsize-1), 0.5*(ysize-1)
        if hasattr(x,'__len__'):
            mask = (x**2+y**2>r2max)
            if not mask.any(): mask = np.ma.nomask
            j=np.ma.array(np.around(xc+x/dx).astype(np.long),mask=mask)
            i=np.ma.array(np.around(yc+y/dx).astype(np.long),mask=mask)
        else:
            if (x**2+y**2>r2max):
                i,j,=np.nan,np.nan
            else:
                j = np.around(xc+x/dx).astype(np.long)
                i = np.around(yc+y/dx).astype(np.long)
        return i,j
    xy2ij.__doc__ = SphericalProj.xy2ij.__doc__ % (name,name)

    def ij2xy(self, i=None, j=None):
        if self.arrayinfo is None:
            raise TypeError("No projection plane array information defined for "
                            "this projector")
        xsize = int(self.arrayinfo['xsize'])
        ysize = int(self.arrayinfo['ysize'])
        reso = self.arrayinfo['reso']
        lamb = self.arrayinfo['lamb']
        half_sky = self.arrayinfo['half_sky']
        dx = reso/60. * dtor
        xc,yc = 0.5*(xsize-1), 0.5*(ysize-1)
        if lamb: r2max = 4.
        else: r2max = pi**2
        if half_sky:
            if lamb: r2max /= 2.
            else: r2max /= 4.
        if i is None and j is None:
            idx = np.outer(np.arange(ysize),np.ones(xsize))
            y = (idx-yc) * dx
            idx = np.outer(np.ones(ysize),np.arange(xsize))
            x = (idx-xc) * dx
        elif i is not None and j is not None:
            y = (np.asarray(i)-yc) * dx
            x = (np.asarray(j)-xc) * dx
        elif i is not None and j is None:
            i,j = i
            y=(np.asarray(i)-yc) * dx
            x=(np.asarray(j)-xc) * dx
        else:
            raise TypeError("i and j must be both given or both not given")
        if hasattr(x,'__len__'):
            mask = (x**2+y**2 > r2max)
            if not mask.any(): mask=np.ma.nomask
            x = np.ma.array(x,mask=mask)
            y = np.ma.array(y,mask=mask)
        else:
            if (x**2+y**2>r2max): x,y=np.nan,np.nan
        return x,y
    ij2xy.__doc__ = SphericalProj.ij2xy.__doc__ % (name,name)

    def get_extent(self):
        xsize = int(self.arrayinfo['xsize'])
        ysize = int(self.arrayinfo['ysize'])
        reso = self.arrayinfo['reso']
        dx = reso/60.0 * dtor
        xc,yc = 0.5*(xsize-1), 0.5*(ysize-1)
        left = -xc * dx
        bottom = -yc * dx
        right = (xsize-1-xc) * dx
        top = (ysize-1-yc) * dx
        return (left,right,bottom,top)
    get_extent.__doc__ = SphericalProj.get_extent.__doc__

    def get_fov(self):
        half_sky = self.arrayinfo['half_sky']
        vx,vy,vz = self.xy2vec(self.ij2xy(0,0), direct=True)
        a = np.arccos(vx)
        if np.isfinite(a):
          return 2.*a
        else:
          if half_sky: return pi
          else: return 2.*pi
healpy-1.10.3/healpy/rotator.py0000664000175000017500000010432313010374155016656 0ustar  zoncazonca00000000000000# 
#  This file is part of Healpy.
# 
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# 
#  For more information about Healpy, see http://code.google.com/p/healpy
# 
import numpy as np
import six
import warnings

coordname = {'G': 'Galactic', 'E': 'Ecliptic', 'C': 'Equatorial'}

class ConsistencyWarning(Warning):
    """Warns for a problem in the consistency of data
    """
    pass

if __name__ != '__main__':
    warnings.filterwarnings("always", category=ConsistencyWarning, module=__name__)

class Rotator(object):
    """Rotation operator, including astronomical coordinate systems.

    This class provides tools for spherical rotations. It is meant to be used 
    in the healpy library for plotting, and for this reason reflects the
    convention used in the Healpix IDL library.

    Parameters
    ----------
    rot : None or sequence
      Describe the rotation by its euler angle. See :func:`euler_matrix_new`.
    coord : None or sequence of str
      Describe the coordinate system transform. If *rot* is also given, the
      coordinate transform is applied first, and then the rotation.
    inv : bool
      If True, the inverse rotation is defined. (Default: False)
    deg : bool
      If True, angles are assumed to be in degree. (Default: True)
    eulertype : str
      The Euler angle convention used. See :func:`euler_matrix_new`.

    Attributes
    ----------
    mat
    coordin
    coordout
    coordinstr
    coordoutstr
    rots
    coords
      
    Examples
    --------
    >>> r = Rotator(coord=['G','E'])  # Transforms galactic to ecliptic coordinates
    >>> theta_gal, phi_gal = np.pi/2., 0.
    >>> theta_ecl, phi_ecl = r(theta_gal, phi_gal)  # Apply the conversion
    >>> print(theta_ecl)
    1.66742286715
    >>> print(phi_ecl)
    -1.62596400306
    >>> theta_ecl, phi_ecl = Rotator(coord='ge')(theta_gal, phi_gal) # In one line
    >>> print(theta_ecl)
    1.66742286715
    >>> print(phi_ecl)
    -1.62596400306
    >>> vec_gal = np.array([1, 0, 0]) #Using vectors
    >>> vec_ecl = r(vec_gal)
    >>> print(vec_ecl)
    [-0.05488249 -0.99382103 -0.09647625]
    """
    ErrMessWrongPar = ("rot and coord must be single elements or "
                       "sequence of same size.")

    def __init__(self,rot=None,coord=None,inv=None,deg=True,
                 eulertype='ZYX'):
        """Create a rotator with given parameters.
        - rot: a float, a tuple of 1,2 or 3 floats or a sequence of tuples.
               If it is a sequence of tuple, it must have the same length as coord.
        - coord: a string or a tuple of 1 or 2 strings or a sequence of tuple
                 If it is a sequence of tuple, it must have same length as rot.
        - inv: whether to use inverse rotation or not
        - deg: if True, angles in rot are assumed in degree (default: True)
        - eulertype: the convention for Euler angles in rot.
        Note: the coord system conversion is applied first, then the rotation.
        """
        rot_is_seq = (hasattr(rot,'__len__') 
                      and hasattr(rot[0], '__len__'))
        coord_is_seq = (hasattr(coord,'__len__') 
                        and hasattr(coord[0],'__len__')
                        and type(coord[0]) is not str)
        if rot_is_seq and coord_is_seq:
            if len(rot) != len(coord):
                raise ValueError(Rotator.ErrMessWrongPar)
            else:
                rots = rot
                coords = coord
        elif (rot_is_seq or coord_is_seq) and (rot   is not None and
                                               coord is not None):
            raise ValueError(Rotator.ErrMessWrongPar)
        else:
            rots = [rot]
            coords = [coord]
        inv_is_seq = hasattr(inv,'__len__')
        if inv_is_seq:
            if len(inv) != len(rots):
                raise ValueError("inv must have same length as rot and/or coord")
            invs = inv
        else:
            invs = [inv]*len(rots)
        # check the argument and normalize them
        if eulertype in ['ZYX','X','Y']:
            self._eultype = eulertype
        else:
            self._eultype = 'ZYX'
        self._rots = []
        self._coords = []
        self._invs = []
        for r,c,i in zip(rots,coords,invs):
            rn = normalise_rot(r,deg=deg)
#            if self._eultype in ['X','Y']:
#                rn[1] = -rn[1]
            cn = normalise_coord(c)
            self._rots.append(rn)   # append(rn) or insert(0, rn) ?
            self._coords.append(cn) # append(cn) or insert(0, cn) ? 
            self._invs.append(bool(i))
        if not self.consistent:
            warnings.warn("The chain of coord system rotations is not consistent",
                          category=ConsistencyWarning)
        self._update_matrix()

    def _update_matrix(self):
        self._matrix = np.identity(3)
        self._do_rotation = False
        for r,c,i in zip(self._rots, self._coords,self._invs):
            rotmat,do_rot,rotnorm = get_rotation_matrix(r,
                                                        eulertype=self._eultype)
            convmat,do_conv,coordnorm = get_coordconv_matrix(c)
            r = np.dot(rotmat,convmat)
            if i: r = r.T
            self._matrix = np.dot(self._matrix, r)
            self._do_rotation = self._do_rotation or (do_rot or do_conv)

    def _is_coords_consistent(self):
        for c,i in zip(self._coords,self._invs):
            break
        for cnext,inext in zip(self._coords[1:],self._invs[1:]):
            if c[i] != cnext[not inext]:
                return False
            c,i = cnext,inext
        return True
    consistent = property(_is_coords_consistent,
                          doc="consistency of the coords transform chain")

    def __eq__(self,a):
        if type(a) is not type(self): return False
        # compare the _rots
        v = [np.allclose(x,y,rtol=0,atol=1e-15) for x,y in zip(self._rots,a._rots)]
        return ( np.array(v).all() and
                 (self._coords == a._coords) and
                 (self._invs == a._invs) )
    
    def __call__(self,*args,**kwds):
        """Use the rotator to rotate either spherical coordinates (theta, phi)
        or a vector (x,y,z). You can use lonla keyword to use longitude, latitude
        (in degree) instead of theta, phi (in radian). In this case, returns 
        longitude, latitude in degree.

        Accepted forms:

        r(x,y,z)  # x,y,z either scalars or arrays
        r(theta,phi) # theta, phi scalars or arrays 
        r(lon,lat,lonlat=True)  # lon, lat scalars or arrays
        r(vec) # vec 1-D array with 3 elements, or 2-D array 3xN
        r(direction) # direction 1-D array with 2 elements, or 2xN array

        Parameters
        ----------
        vec_or_dir : array or multiple arrays
          The direction to rotate. See above for accepted formats.
        lonlat : bool, optional
          If True, assumes the input direction is longitude/latitude in degrees.
          Otherwise, assumes co-latitude/longitude in radians. Default: False
        inv : bool, optional
          If True, applies the inverse rotation. Default: False.
        """
        if kwds.pop('inv',False): m=self._matrix.T
        else:                     m=self._matrix
        lonlat = kwds.pop('lonlat',False)
        if len(args) == 1:
            arg=args[0]
            if not hasattr(arg,'__len__') or len(arg) < 2 or len(arg) > 3:
                raise TypeError('Argument must be a sequence of 2 or 3 '
                                'elements')
            if len(arg) == 2:
                return rotateDirection(m,arg[0],arg[1],
                                       self._do_rotation,lonlat=lonlat)
            else:
                return rotateVector(m,arg[0],arg[1],arg[2],
                                    self._do_rotation)
        elif len(args) == 2:
            return rotateDirection(m,args[0],args[1],
                                   self._do_rotation,lonlat=lonlat)
        elif len(args) == 3:
            return rotateVector(m,args[0],args[1],args[2],
                                self._do_rotation)
        else:
            raise TypeError('Either 1, 2 or 3 arguments accepted')

    def __mul__(self,a):
        """Composition of rotation.
        """
        if not isinstance(a,Rotator):
            raise TypeError("A Rotator can only multiply another Rotator "
                            "(composition of rotations)")
        rots = self._rots + a._rots
        coords = self._coords + a._coords
        invs = self._invs + a._invs
        return Rotator(rot=rots,coord=coords,inv=invs,deg=False)
    
    def __rmul__(self,b):
        if not isinstance(b,Rotator):
            raise TypeError("A Rotator can only be multiplied by another Rotator "
                            "(composition of rotations)")
        rots = b._rots + self._rots
        coords = b._coords + self._coords
        invs = self._invs + a._invs
        return Rotator(rot=rots,coord=coords,inv=invs,deg=False)

    def __nonzero__(self):
        return self._do_rotation

    def get_inverse(self):
        rots = self._rots[::-1]
        coords = self._coords[::-1]
        invs = [ not i for i in self._invs[::-1]]
        return Rotator(rot=rots,coord=coords,inv=invs,deg=False)
    #I = property(get_inverse,doc='Return a new rotator representing the '
    #             'inverse rotation')

    def I(self,*args,**kwds):
        """Rotate the given vector or direction using the inverse matrix.
        rot.I(vec) <==> rot(vec,inv=True)
        """
        kwds['inv'] = True
        return self.__call__(*args,**kwds)
    
    @property
    def mat(self):
        """The matrix representing the rotation.
        """
        return np.matrix(self._matrix)

    @property
    def coordin(self):
        """The input coordinate system.
        """
        if not self.consistent: return None
        for c,i in zip(self._coords,self._invs):
            pass
        return c[i]

    @property
    def coordout(self):
        """The output coordinate system.
        """
        if not self.consistent: return None
        for c,i in zip(self._coords,self._invs):
            pass
        return c[not i]

    @property
    def coordinstr(self):
        """The input coordinate system in str.
        """
        return coordname.get(self.coordin,'')

    @property
    def coordoutstr(self):
        """The output coordinate system in str.
        """
        return coordname.get(self.coordout,'')

    @property
    def rots(self):
        """The sequence of rots defining the rotation.
        """
        return self._rots
    
    @property
    def coords(self):
        """The sequence of coords defining the rotation.
        """
        return self._coords
    
    def do_rot(self,i):
        """Returns True if rotation is not (close to) identity.
        """
        return not np.allclose(self.rots[i],np.zeros(3),rtol=0.,atol=1.e-15)

    def angle_ref(self,*args,**kwds):
        """Compute the angle between transverse reference direction of initial and final frames

        For example, if angle of polarisation is psi in initial frame, it will be psi+angle_ref in final
        frame.

        Parameters
        ----------
        dir_or_vec : array
          Direction or vector (see Rotator.__call__)
        lonlat: bool, optional
          If True, assume input is longitude,latitude in degrees. Otherwise,
          theta,phi in radian. Default: False
        inv : bool, optional
          If True, use the inverse transforms. Default: False

        Returns
        -------
        angle : float, scalar or array
          Angle in radian (a scalar or an array if input is a sequence of direction/vector)
        """
        R = self
        lonlat = kwds.get('lonlat',False)
        inv = kwds.get('inv',False)
        if len(args) == 1:
            arg=args[0]
            if not hasattr(arg,'__len__') or len(arg) < 2 or len(arg) > 3:
                raise TypeError('Argument must be a sequence of 2 or 3 '
                                'elements')
            if len(arg) == 2:
                v = dir2vec(arg[0],arg[1],lonlat=lonlat)
            else:
                v = arg
        elif len(args) == 2:
            v = dir2vec(args[0],args[1],lonlat=lonlat)
        elif len(args) == 3:
            v = args
        else:
            raise TypeError('Either 1, 2 or 3 arguments accepted')
        vp = R(v,inv=inv)
        north_pole = R([0.,0.,1.],inv=inv)
        sinalpha = north_pole[0]*vp[1]-north_pole[1]*vp[0]
        cosalpha = north_pole[2] - vp[2]*np.dot(north_pole,vp)
        return np.arctan2(sinalpha,cosalpha)

    def __repr__(self):
        return '[ '+', '.join([str(self._coords),
                               str(self._rots),
                               str(self._invs)]) +' ]'
    __str__ = __repr__



################################################################
#
#     Helpers function for rotation
#     used in the Rotator class.

def rotateVector(rotmat,vec,vy=None,vz=None, do_rot=True):
    """Rotate a vector (or a list of vectors) using the rotation matrix
    given as first argument.
    
    Parameters
    ----------
    rotmat : float, array-like shape (3,3)
      The rotation matrix
    vec : float, scalar or array-like
      The vector to transform (shape (3,) or (3,N)),
      or x component (scalar or shape (N,)) if vy and vz are given
    vy : float, scalar or array-like, optional
      The y component of the vector (scalar or shape (N,))
    vz : float, scalar or array-like, optional
      The z component of the vector (scalar or shape (N,))
    do_rot : bool, optional
      if True, really perform the operation, if False do nothing.

    Returns
    -------
    vec : float, array
      The component of the rotated vector(s).

    See Also
    --------
    Rotator
    """
    if vy is None and vz is None:
       if do_rot: return np.tensordot(rotmat,vec,axes=(1,0))
       else: return vec
    elif vy is not None and vz is not None:
       if do_rot: return np.tensordot(rotmat,np.array([vec,vy,vz]),axes=(1,0))
       else: return vec,vy,vz
    else:
       raise TypeError("You must give either vec only or vec, vy "
                       "and vz parameters")

def rotateDirection(rotmat,theta,phi=None,do_rot=True,lonlat=False):
    """Rotate the vector described by angles theta,phi using the rotation matrix
    given as first argument.
   
    Parameters
    ----------
    rotmat : float, array-like shape (3,3)
      The rotation matrix
    theta : float, scalar or array-like
      The angle theta (scalar or shape (N,)) 
      or both angles (scalar or shape (2, N)) if phi is not given.
    phi : float, scalar or array-like, optionnal
      The angle phi (scalar or shape (N,)).
    do_rot : bool, optional
      if True, really perform the operation, if False do nothing.
    lonlat : bool
      If True, input angles are assumed to be longitude and latitude in degree,
      otherwise, they are co-latitude and longitude in radians.
  
    Returns
    -------
    angles : float, array
      The angles of describing the rotated vector(s).

    See Also
    --------
    Rotator
    """
    vx,vy,vz=rotateVector(rotmat,dir2vec(theta,phi,lonlat=lonlat),do_rot=do_rot)
    return vec2dir(vx,vy,vz,lonlat=lonlat)

def vec2dir(vec,vy=None,vz=None,lonlat=False):
    """Transform a vector to angle given by theta,phi.
    
    Parameters
    ----------
    vec : float, scalar or array-like
      The vector to transform (shape (3,) or (3,N)),
      or x component (scalar or shape (N,)) if vy and vz are given
    vy : float, scalar or array-like, optional
      The y component of the vector (scalar or shape (N,))
    vz : float, scalar or array-like, optional
      The z component of the vector (scalar or shape (N,))
    lonlat : bool, optional
      If True, return angles will be longitude and latitude in degree,
      otherwise, angles will be longitude and co-latitude in radians (default)

    Returns
    -------
    angles : float, array
      The angles (unit depending on *lonlat*) in an array of 
      shape (2,) (if scalar input) or (2, N)

    See Also
    --------
    :func:`dir2vec`, :func:`pixelfunc.ang2vec`, :func:`pixelfunc.vec2ang`
    """
    if np.any(np.isnan(vec)):
        return np.nan, np.nan
    if vy is None and vz is None:
        vx,vy,vz = vec
    elif vy is not None and vz is not None:
        vx=vec
    else:
        raise TypeError("You must either give both vy and vz or none of them")
    r = np.sqrt(vx**2+vy**2+vz**2)
    ang = np.empty((2, r.size))
    ang[0, :] = np.arccos(vz / r)
    ang[1, :] = np.arctan2(vy, vx)
    if lonlat:
        ang = np.degrees(ang)
        np.negative(ang[0, :], ang[0, :])
        ang[0, :] += 90.
        return ang[::-1,:].squeeze()
    else:
        return ang.squeeze()

def dir2vec(theta,phi=None,lonlat=False):
    """Transform a direction theta,phi to a unit vector.
    
    Parameters
    ----------
    theta : float, scalar or array-like
      The angle theta (scalar or shape (N,)) 
      or both angles (scalar or shape (2, N)) if phi is not given.
    phi : float, scalar or array-like, optionnal
      The angle phi (scalar or shape (N,)).
    lonlat : bool
      If True, input angles are assumed to be longitude and latitude in degree,
      otherwise, they are co-latitude and longitude in radians.
    
    Returns
    -------
    vec : array
      The vector(s) corresponding to given angles, shape is (3,) or (3, N).
 
    See Also
    --------
    :func:`vec2dir`, :func:`pixelfunc.ang2vec`, :func:`pixelfunc.vec2ang`
    """
    if phi is None:
        theta,phi=theta
    if lonlat:
        lon,lat=theta,phi
        theta,phi = np.pi/2.-np.radians(lat),np.radians(lon)
    ct,st,cp,sp = np.cos(theta),np.sin(theta),np.cos(phi),np.sin(phi)
    vec = np.empty((3, ct.size), np.float64)
    vec[0, :] = st * cp
    vec[1, :] = st * sp
    vec[2, :] = ct
    return vec.squeeze()

def angdist(dir1,dir2,lonlat=False):
    """Returns the angular distance between dir1 and dir2.

    Parameters
    ----------
    dir1, dir2 : float, array-like
      The directions between which computing the angular distance.
      Angular if len(dir) == 2 or vector if len(dir) == 3.
      See *lonlat* for unit
    lonlat : bool, scalar or sequence
      If True, angles are assumed to be longitude and latitude in degree,
      otherwise they are interpreted as colatitude and longitude in radian.
      If a sequence, lonlat[0] applies to dir1 and lonlat[1] applies to dir2.

    Returns
    -------
    angles : float, scalar or array-like
      The angle(s) between dir1 and dir2 in radian.

    Examples
    --------
    >>> import healpy as hp
    >>> hp.rotator.angdist([.2,0], [.2, 1e-6])
    array([  1.98669331e-07])
    """
    if hasattr(lonlat,'__len__') and len(lonlat) == 2:
        lonlat1,lonlat2 = lonlat
    else:
        lonlat1=lonlat2=lonlat
    dir1 = np.asarray(dir1)
    dir2 = np.asarray(dir2)
    if dir1.ndim == 2:
        if dir1.shape[0] == 2: # theta, phi -> vec
            vec1 = dir2vec(dir1, lonlat = lonlat1)
        else:
            vec1 = np.reshape(dir1, (3, -1))
            vec1 = normalize_vec(vec1)
    elif dir1.ndim == 1:
        if dir1.shape[0] == 2: # theta, phi -> vec
            vec1 = np.reshape(dir2vec(dir1, lonlat = lonlat1), (3, 1))
        else:
            vec1 = np.reshape(dir1, (3, 1))
            vec1 = normalize_vec(vec1)
    if dir2.ndim == 2:
        if dir2.shape[0] == 2: # theta, phi -> vec
            vec2 = dir2vec(dir2, lonlat = lonlat2)
        else:
            vec2 = np.reshape(dir2, (3, -1))
            vec2 = normalize_vec(vec2)
    elif dir2.ndim == 1:
        if dir2.shape[0] == 2: # theta, phi -> vec
            vec2 = np.reshape(dir2vec(dir2, lonlat = lonlat2), (3, 1))
        else:
            vec2 = np.reshape(dir2, (3, 1))
            vec2 = normalize_vec(vec2)
    # compute vec product
    vec_prod = np.sqrt((np.cross(vec1.T, vec2.T)**2).sum(axis=1))
    # compute scalar product
    scal_prod = (vec1*vec2).sum(axis=0)

    return np.arctan2(vec_prod, scal_prod)

def normalize_vec(vec):
    """Normalize the vector(s) *vec* (in-place if it is a ndarray).

    Parameters
    ----------
    vec : float, array-like of shape (D,) or (D, N)
      The D-vector(s) to normalize.

    Returns
    -------
    vec_normed : float, array
      Normalized vec, shape (D,) or (D, N)
    """
    vec = np.array(vec, np.float64)
    r = np.sqrt(np.sum(vec ** 2, axis = 0))
    vec /= r
    return vec

#######################################################
#
#   Manage the coord system conventions
#

def check_coord(c):
    """Check if parameter is a valid coord system.
    Raise a TypeError exception if it is not, otherwise returns the normalized
    coordinate system name.
    """
    if c is None:
        return c
    if not isinstance(c, six.string_types):
        raise TypeError('Coordinate must be a string (G[alactic],'
                        ' E[cliptic], C[elestial]'
                        ' or Equatorial=Celestial)')
    if c[0].upper() == 'G':
        x='G'
    elif c[0].upper() == 'E' and c != 'Equatorial':
        x='E'
    elif c[0].upper() == 'C' or c == 'Equatorial':
        x='C'
    else:
        raise ValueError('Wrong coordinate (either G[alactic],'
                         ' E[cliptic], C[elestial]'
                         ' or Equatorial=Celestial)')
    return x

def normalise_coord(coord):
    """Normalise the coord argument.
    Coord sys are either 'E','G', 'C' or 'X' if undefined.

    Input: either a string or a sequence of string.
           
    Output: a tuple of two strings, each being one of the norm coord sys name
            above.

    eg, 'E' -> ['E','E'], ['Ecliptic','G'] -> ['E','G']
    None -> ['X','X'] etc.
    """
    coord_norm = []
    if coord is None:
        coord = (None,None)
    coord=tuple(coord)
    if len(coord) > 2:
        raise TypeError('Coordinate must be a string (G[alactic],'
                        ' E[cliptic] or C[elestial])'
                        ' or a sequence of 2 strings')
    for x in coord:
        coord_norm.append(check_coord(x))
    if len(coord_norm) < 2:
        coord_norm.append(coord_norm[0])
    return tuple(coord_norm)

def normalise_rot(rot,deg=False):
   """Return rot possibly completed with zeroes to reach size 3.
   If rot is None, return a vector of 0.
   If deg is True, convert from degree to radian, otherwise assume input
   is in radian.
   """
   if deg: convert=np.pi/180.
   else: convert=1.
   if rot is None:
      rot=np.zeros(3)
   else:
      rot=np.array(rot,np.float64).flatten()*convert
      rot.resize(3)
   return rot

def get_rotation_matrix(rot, deg=False, eulertype='ZYX'):
   """Return the rotation matrix corresponding to angles given in rot.
   
   Usage: matrot,do_rot,normrot = get_rotation_matrix(rot)
   
   Input:
      - rot: either None, an angle or a tuple of 1,2 or 3 angles
             corresponding to Euler angles.
   Output:
      - matrot: 3x3 rotation matrix
      - do_rot: True if rotation is not identity, False otherwise
      - normrot: the normalized version of the input rot.
   """
   rot = normalise_rot(rot, deg=deg)
   if not np.allclose(rot,np.zeros(3),rtol=0.,atol=1.e-15):
      do_rot = True
   else:
      do_rot = False
   if eulertype == 'X':
       matrot=euler_matrix_new(rot[0],-rot[1],rot[2],X=True)
   elif eulertype == 'Y':
       matrot=euler_matrix_new(rot[0],-rot[1],rot[2],Y=True)
   else:
       matrot=euler_matrix_new(rot[0],-rot[1],rot[2],ZYX=True)
       
   return matrot,do_rot,rot
    
def get_coordconv_matrix(coord):
   """Return the rotation matrix corresponding to coord systems given
   in coord.

   Usage: matconv,do_conv,normcoord = get_coordconv_matrix(coord)

   Input:
      - coord: a tuple with initial and final coord systems.
               See normalise_coord.
   Output:
      - matconv: the euler matrix for coord sys conversion
      - do_conv: True if matconv is not identity, False otherwise
      - normcoord: the tuple of initial and final coord sys.

   History: adapted from CGIS IDL library.
   """
   
   coord_norm = normalise_coord(coord)
   
   if coord_norm[0] == coord_norm[1]:
      matconv = np.identity(3)
      do_conv = False        
   else:
      eps = 23.452294 - 0.0130125 - 1.63889E-6 + 5.02778E-7
      eps = eps * np.pi / 180.
      
      # ecliptic to galactic
      e2g = np.array([[-0.054882486, -0.993821033, -0.096476249],
                   [ 0.494116468, -0.110993846,  0.862281440],
                   [-0.867661702, -0.000346354,  0.497154957]])
      
      # ecliptic to equatorial
      e2q = np.array([[1.,     0.    ,      0.         ],
                   [0., np.cos( eps ), -1. * np.sin( eps )],
                   [0., np.sin( eps ),    np.cos( eps )   ]])
      
      # galactic to ecliptic
      g2e = np.linalg.inv(e2g)
      
      # galactic to equatorial                   
      g2q = np.dot(e2q , g2e)
      
      # equatorial to ecliptic
      q2e = np.linalg.inv(e2q)
      
      # equatorial to galactic
      q2g = np.dot(e2g , q2e)
   
      if coord_norm == ('E','G'):
         matconv = e2g
      elif coord_norm == ('G','E'):
         matconv = g2e
      elif coord_norm == ('E','C'):
         matconv = e2q
      elif coord_norm == ('C','E'):
         matconv = q2e
      elif coord_norm == ('C','G'):
         matconv = q2g
      elif coord_norm == ('G','C'):
         matconv = g2q
      else:
         raise ValueError('Wrong coord transform :',coord_norm)
      do_conv = True
      
   return matconv,do_conv,coord_norm


###################################################
##                                               ##
##                euler functions                ## 
##                                               ##
######                                      #######

def euler(ai, bi, select, FK4 = 0):
   """
   NAME:
       euler
   PURPOSE:
       Transform between Galactic, celestial, and ecliptic coordinates.
   EXPLANATION:
       Use the procedure ASTRO to use this routine interactively
   
   CALLING SEQUENCE:
        EULER, AI, BI, AO, BO, [ SELECT, /FK4, SELECT = ] 
   
   INPUTS:
         AI - Input Longitude in DEGREES, scalar or vector.  If only two 
                 parameters are supplied, then  AI and BI will be modified
                 to contain the output longitude and latitude.
         BI - Input Latitude in DEGREES
   
   OPTIONAL INPUT:
         SELECT - Integer (1-6) specifying type of coordinate
                  transformation.
   
        SELECT   From          To        |   SELECT      From         To
         1     RA-Dec (2000)  Galactic   |     4       Ecliptic     RA-Dec
         2     Galactic       RA-DEC     |     5       Ecliptic    Galactic
         3     RA-Dec         Ecliptic   |     6       Galactic    Ecliptic
   
        If not supplied as a parameter or keyword, then EULER will prompt
        for the value of SELECT
        Celestial coordinates (RA, Dec) should be given in equinox J2000 
        unless the /FK4 keyword is set.
   OUTPUTS:
         AO - Output Longitude in DEGREES
         BO - Output Latitude in DEGREES
   
   INPUT KEYWORD:
         /FK4 - If this keyword is set and non-zero, then input and output 
               celestial and ecliptic coordinates should be given in
               equinox B1950.
         /SELECT  - The coordinate conversion integer (1-6) may
                    alternatively be specified as a keyword
   NOTES:
         EULER was changed in December 1998 to use J2000 coordinates as the
         default, ** and may be incompatible with earlier versions***.
   REVISION HISTORY:
         Written W. Landsman,  February 1987
         Adapted from Fortran by Daryl Yentis NRL
         Converted to IDL V5.0   W. Landsman   September 1997
         Made J2000 the default, added /FK4 keyword
          W. Landsman December 1998
         Add option to specify SELECT as a keyword W. Landsman March 2003
         Converted to python by K. Ganga December 2007
   """

   # npar = N_params()
   #  if npar LT 2 then begin
   #     print,'Syntax - EULER, AI, BI, A0, B0, [ SELECT, /FK4, SELECT= ]'
   #     print,'    AI,BI - Input longitude,latitude in degrees'
   #     print,'    AO,BO - Output longitude, latitude in degrees'
   #     print,'    SELECT - Scalar (1-6) specifying transformation type'
   #     return
   #  endif

   PI = np.pi
   twopi   =   2.0*PI
   fourpi  =   4.0*PI
   deg_to_rad = 180.0/PI
   # 
   # ;   J2000 coordinate conversions are based on the following constants
   # ;   (see the Hipparcos explanatory supplement).
   # ;  eps = 23.4392911111 # Obliquity of the ecliptic
   # ;  alphaG = 192.85948d           Right Ascension of Galactic North Pole
   # ;  deltaG = 27.12825d            Declination of Galactic North Pole
   # ;  lomega = 32.93192d            Galactic longitude of celestial equator  
   # ;  alphaE = 180.02322d           Ecliptic longitude of Galactic North Pole
   # ;  deltaE = 29.811438523d        Ecliptic latitude of Galactic North Pole
   # ;  Eomega  = 6.3839743d          Galactic longitude of ecliptic equator
   # 
   if FK4 == 1:
      
      equinox = '(B1950)' 
      psi   = [ 0.57595865315, 4.9261918136,
                0.00000000000, 0.0000000000,
                0.11129056012, 4.7005372834]     
      stheta =[ 0.88781538514,-0.88781538514,
                0.39788119938,-0.39788119938,
                0.86766174755,-0.86766174755]    
      ctheta =[ 0.46019978478, 0.46019978478,
                0.91743694670, 0.91743694670,
                0.49715499774, 0.49715499774]    
      phi  = [ 4.9261918136,  0.57595865315,
               0.0000000000, 0.00000000000,
               4.7005372834, 0.11129056012]
   else:
      
      equinox = '(J2000)'
      psi   = [ 0.57477043300, 4.9368292465,  
                0.00000000000, 0.0000000000,  
                0.11142137093, 4.71279419371]     
      stheta =[ 0.88998808748,-0.88998808748, 
                0.39777715593,-0.39777715593, 
                0.86766622025,-0.86766622025]    
      ctheta =[ 0.45598377618, 0.45598377618, 
                0.91748206207, 0.91748206207, 
                0.49714719172, 0.49714719172]    
      phi  = [ 4.9368292465,  0.57477043300, 
               0.0000000000, 0.00000000000, 
               4.71279419371, 0.11142137093]
   # 
   i  = select - 1                         # IDL offset
   a  = ai/deg_to_rad - phi[i]
   b = bi/deg_to_rad
   sb = np.sin(b)
   cb = np.cos(b)
   cbsa = cb * np.sin(a)
   b  = -stheta[i] * cbsa + ctheta[i] * sb
   #bo    = math.asin(where(b<1.0, b, 1.0)*deg_to_rad)
   bo    = np.arcsin(b)*deg_to_rad
   #
   a = np.arctan2( ctheta[i] * cbsa + stheta[i] * sb, cb * np.cos(a) )
   ao = np.fmod( (a+psi[i]+fourpi), twopi) * deg_to_rad
   return ao, bo


def euler_matrix_new(a1,a2,a3,X=True,Y=False,ZYX=False,deg=False):
   """
   NAME:
     euler_matrix_new

   PURPOSE:
     computes the Euler matrix of an arbitrary rotation described
     by 3 Euler angles
     correct bugs present in Euler_Matrix
       
   CALLING SEQUENCE:
     result = euler_matrix_new (a1, a2, a3 [,X, Y, ZYX, DEG ])

   INPUTS:
     a1, a2, a3 = Euler angles, scalar
                  (in radian by default, in degree if DEG is set)
                  all the angles are measured counterclockwise
                  correspond to x, y, zyx-conventions (see Goldstein)
                  the default is x

   KEYWORD PARAMETERS:
      DEG : if set the angle are measured in degree

      X : 	rotation a1 around original Z 
    		rotation a2 around interm   X 
    		rotation a3 around final    Z
                DEFAULT,  classical mechanics convention

      Y : 	rotation a1 around original Z
    		rotation a2 around interm   Y
    		rotation a3 around final    Z
                quantum mechanics convention (override X)

      ZYX : 	rotation a1 around original Z
    		rotation a2 around interm   Y
    		rotation a3 around final    X
                aeronautics convention (override X)
                
      * these last three keywords are obviously mutually exclusive *

   OUTPUTS:
      result is a 3x3 matrix

   USAGE:
     if vec is an Nx3 array containing N 3D vectors,
     vec # euler_matrix_new(a1,a2,a3,/Y) will be the rotated vectors


   MODIFICATION HISTORY:
      March 2002, EH, Caltech, rewritting of euler_matrix

      convention   euler_matrix_new           euler_matrix
     X:       M_new(a,b,c,/X)  =  M_old(-a,-b,-c,/X) = Transpose( M_old(c, b, a,/X))
     Y:       M_new(a,b,c,/Y)  =  M_old(-a, b,-c,/Y) = Transpose( M_old(c,-b, a,/Y))
   ZYX:       M_new(a,b,c,/Z)  =  M_old(-a, b,-c,/Z)
   """
   
   t_k = 0
   if ZYX: t_k = t_k + 1
   #if X:   t_k = t_k + 1
   if Y:   t_k = t_k + 1
   if t_k > 1:
      raise ValueError('Choose either X, Y or ZYX convention')
   
   convert = 1.0
   if deg:
      convert = np.pi/180.
      
   c1 = np.cos(a1*convert)
   s1 = np.sin(a1*convert)
   c2 = np.cos(a2*convert)
   s2 = np.sin(a2*convert)
   c3 = np.cos(a3*convert)
   s3 = np.sin(a3*convert)
        
   if ZYX:
      m1 = np.array([[ c1,-s1,  0],
                  [ s1, c1,  0],
                  [  0,  0,  1]]) # around   z

      m2 = np.array([[ c2,  0, s2],
                  [  0,  1,  0],
                  [-s2,  0, c2]]) # around   y

      m3 = np.array([[  1,  0,  0],
                  [  0, c3,-s3],
                  [  0, s3, c3]]) # around   x

   elif Y:
      m1 = np.array([[ c1,-s1,  0],
                  [ s1, c1,  0],
                  [  0,  0,  1]]) # around   z

      m2 = np.array([[ c2,  0, s2],
                  [  0,  1,  0],
                  [-s2,  0, c2]]) # around   y

      m3 = np.array([[ c3,-s3,  0],
                  [ s3, c3,  0],
                  [  0,  0,  1]]) # around   z

   else:
      m1 = np.array([[ c1,-s1,  0],
                  [ s1, c1,  0],
                  [  0,  0,  1]]) # around   z

      m2 = np.array([[  1,  0,  0],
                  [  0, c2,-s2],
                  [  0, s2, c2]]) # around   x

      m3 = np.array([[ c3,-s3,  0],
                  [ s3, c3,  0],
                  [  0,  0,  1]]) # around   z

   M = np.dot(m3.T,np.dot(m2.T,m1.T)) 

   return M

healpy-1.10.3/healpy/sphtfunc.py0000664000175000017500000007670713010374155017034 0ustar  zoncazonca00000000000000# 
#  This file is part of Healpy.
# 
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# 
#  For more information about Healpy, see http://code.google.com/p/healpy
# 
import warnings
import numpy as np
import six
pi = np.pi
import warnings
import astropy.io.fits as pf

from . import _healpy_sph_transform_lib as sphtlib
from . import _healpy_fitsio_lib as hfitslib
from . import _sphtools as _sphtools
from . import cookbook as cb

import os.path
from . import pixelfunc

from .pixelfunc import maptype, UNSEEN, ma_to_array, accept_ma

class FutureChangeWarning(UserWarning):
    pass

DATAPATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')

# Spherical harmonics transformation
def anafast(map1, map2 = None, nspec = None, lmax = None, mmax = None, 
            iter = 3, alm = False, pol = True, use_weights = False,
            datapath = None):
    """Computes the power spectrum of an Healpix map, or the cross-spectrum
    between two maps if *map2* is given.
    No removal of monopole or dipole is performed.

    Parameters
    ----------
    map1 : float, array-like shape (Npix,) or (3, Npix)
      Either an array representing a map, or a sequence of 3 arrays
      representing I, Q, U maps
    map2 : float, array-like shape (Npix,) or (3, Npix)
      Either an array representing a map, or a sequence of 3 arrays
      representing I, Q, U maps
    nspec : None or int, optional
      The number of spectra to return. If None, returns all, otherwise
      returns cls[:nspec]
    lmax : int, scalar, optional
      Maximum l of the power spectrum (default: 3*nside-1)
    mmax : int, scalar, optional
      Maximum m of the alm (default: lmax)
    iter : int, scalar, optional
      Number of iteration (default: 3)
    alm : bool, scalar, optional
      If True, returns both cl and alm, otherwise only cl is returned
    pol : bool, optional
      If True, assumes input maps are TQU. Output will be TEB cl's and
      correlations (input must be 1 or 3 maps).
      If False, maps are assumed to be described by spin 0 spherical harmonics.
      (input can be any number of maps)
      If there is only one input map, it has no effect. Default: True.
    datapath : None or str, optional
      If given, the directory where to find the weights data.

    Returns
    -------
    res : array or sequence of arrays
      If *alm* is False, returns cl or a list of cl's (TT, EE, BB, TE, EB, TB for
      polarized input map)
      Otherwise, returns a tuple (cl, alm), where cl is as above and
      alm is the spherical harmonic transform or a list of almT, almE, almB
      for polarized input
    """

    map1 = ma_to_array(map1)
    alms1 = map2alm(map1, lmax = lmax, mmax = mmax, pol = pol, iter = iter, 
                    use_weights = use_weights,
                    datapath = datapath)
    if map2 is not None:
        map2 = ma_to_array(map2)
        alms2 = map2alm(map2, lmax = lmax, mmax = mmax, pol = pol,
                        iter = iter, use_weights = use_weights, 
                        datapath = datapath)
    else:
        alms2 = None
    
    cls = alm2cl(alms1, alms2 = alms2, lmax = lmax, mmax = mmax,
                 lmax_out = lmax, nspec = nspec)

    if alm:
        if map2 is not None:
            return (cls, alms1, alms2)
        else:
            return (cls, alms1)
    else:
        return cls

def map2alm(maps, lmax = None, mmax = None, iter = 3, pol = True, 
            use_weights = False, datapath = None):
    """Computes the alm of an Healpix map.
    
    Parameters
    ----------
    maps : array-like, shape (Npix,) or (n, Npix)
      The input map or a list of n input maps.
    lmax : int, scalar, optional
      Maximum l of the power spectrum. Default: 3*nside-1
    mmax : int, scalar, optional
      Maximum m of the alm. Default: lmax
    iter : int, scalar, optional
      Number of iteration (default: 3)
    pol : bool, optional
      If True, assumes input maps are TQU. Output will be TEB alm's.
      (input must be 1 or 3 maps)
      If False, apply spin 0 harmonic transform to each map.
      (input can be any number of maps)
      If there is only one input map, it has no effect. Default: True.
    use_weights: bool, scalar, optional
      If True, use the ring weighting. Default: False.
    datapath : None or str, optional
      If given, the directory where to find the weights data.
    
    Returns
    -------
    alms : array or tuple of array
      alm or a tuple of 3 alm (almT, almE, almB) if polarized input.
    
    Notes
    -----
    The pixels which have the special `UNSEEN` value are replaced by zeros
    before spherical harmonic transform. They are converted back to `UNSEEN`
    value, so that the input maps are not modified. Each map have its own, 
    independent mask.
    """
    maps = ma_to_array(maps)
    info = maptype(maps)
    if pol or info in (0, 1):
        alms = _sphtools.map2alm(maps, niter = iter, 
                                 datapath = datapath, use_weights = use_weights,
                                 lmax = lmax, mmax = mmax)
    else:
        # info >= 2 and pol is False : spin 0 spht for each map
        alms = [_sphtools.map2alm(mm, niter = iter,
                                  datapath = datapath, use_weights = use_weights,
                                  lmax = lmax, mmax = mmax)
               for mm in maps]
    return alms

def alm2map(alms, nside, lmax = None, mmax = None, pixwin = False,
            fwhm = 0.0, sigma = None,  pol = True,
            inplace = False, verbose=True):
    """Computes an Healpix map given the alm.

    The alm are given as a complex array. You can specify lmax
    and mmax, or they will be computed from array size (assuming
    lmax==mmax).

    Parameters
    ----------
    alms : complex, array or sequence of arrays
      A complex array or a sequence of complex arrays.
      Each array must have a size of the form: mmax * (2 * lmax + 1 - mmax) / 2 + lmax + 1
    nside : int, scalar
      The nside of the output map.
    lmax : None or int, scalar, optional
      Explicitly define lmax (needed if mmax!=lmax)
    mmax : None or int, scalar, optional
      Explicitly define mmax (needed if mmax!=lmax)
    pixwin : bool, optional
      Smooth the alm using the pixel window functions. Default: False.
    fwhm : float, scalar, optional
      The fwhm of the Gaussian used to smooth the map (applied on alm)
      [in radians]
    sigma : float, scalar, optional
      The sigma of the Gaussian used to smooth the map (applied on alm)
      [in radians]
    pol : bool, optional
      If True, assumes input alms are TEB. Output will be TQU maps.
      (input must be 1 or 3 alms)
      If False, apply spin 0 harmonic transform to each alm.
      (input can be any number of alms)
      If there is only one input alm, it has no effect. Default: True.
    inplace : bool, optional
      If True, input alms may be modified by pixel window function and beam
      smoothing (if alm(s) are complex128 contiguous arrays).
      Otherwise, input alms are not modified. A copy is made if needed to
      apply beam smoothing or pixel window.
      
    Returns
    -------
    maps : array or list of arrays
      An Healpix map in RING scheme at nside or a list of T,Q,U maps (if
      polarized input)
    """
    if not cb.is_seq(alms):
        raise TypeError("alms must be a sequence")

    alms = smoothalm(alms, fwhm = fwhm, sigma = sigma,  
                     pol = pol, inplace = inplace, verbose=verbose)

    if not cb.is_seq_of_seq(alms):
        alms = [alms]
        lonely = True
    else:
        lonely = False
    
    if pixwin:
        pw = globals()['pixwin'](nside,True)
        alms_new = []
        for ialm, alm in enumerate(alms):
            pixelwindow = pw[1] if ialm >= 1 and pol else pw[0]
            alms_new.append(almxfl(alm, pixelwindow, inplace = inplace))
    else:
        alms_new = alms

    if lmax is None:
        lmax = -1
    if mmax is None:
        mmax = -1
    if pol:
        output = sphtlib._alm2map(alms_new[0] if lonely else alms_new,
                                  nside, lmax = lmax, mmax = mmax)
        if lonely:
            output = [output]
    else:
        output = [sphtlib._alm2map(alm, nside, lmax = lmax, mmax = mmax)
                  for alm in alms_new]
    if lonely:
        return output[0]
    else:
        return output

def synalm(cls, lmax = None, mmax = None, new = False, verbose=True):
    """Generate a set of alm given cl.
    The cl are given as a float array. Corresponding alm are generated.
    If lmax is None, it is assumed lmax=cl.size-1
    If mmax is None, it is assumed mmax=lmax.

    Parameters
    ----------
    cls : float, array or tuple of arrays
      Either one cl (1D array) or a tuple of either 4 cl
      or of n*(n+1)/2 cl.
      Some of the cl may be None, implying no
      cross-correlation. See *new* parameter.
    lmax : int, scalar, optional
      The lmax (if None or <0, the largest size-1 of cls)
    mmax : int, scalar, optional
      The mmax (if None or <0, =lmax)
    new : bool, optional
      If True, use the new ordering of cl's, ie by diagonal
      (e.g. TT, EE, BB, TE, EB, TB or TT, EE, BB, TE if 4 cl as input).
      If False, use the old ordering, ie by row
      (e.g. TT, TE, TB, EE, EB, BB or TT, TE, EE, BB if 4 cl as input).      

    Returns
    -------
    alms : array or list of arrays
      the generated alm if one spectrum is given, or a list of n alms 
      (with n(n+1)/2 the number of input cl, or n=3 if there are 4 input cl).

    Notes
    -----
    The order of the spectra will change in a future release. The new= parameter
    help to make the transition smoother. You can start using the new order
    by setting new=True.
    In the next version of healpy, the default will be new=True.
    This change is done for consistency between the different tools
    (alm2cl, synfast, anafast).
    In the new order, the spectra are ordered by diagonal of the correlation
    matrix. Eg, if fields are T, E, B, the spectra are TT, EE, BB, TE, EB, TB
    with new=True, and TT, TE, TB, EE, EB, BB if new=False.
    """
    if (not new) and verbose:
        warnings.warn("The order of the input cl's will change in a future "
                      "release.\n"
                      "Use new=True keyword to start using the new order.\n"
                      "See documentation of healpy.synalm.",
                      category=FutureChangeWarning)
    if not cb.is_seq(cls):
        raise TypeError('cls must be an array or a sequence of arrays')

    if not cb.is_seq_of_seq(cls):
        # Only one spectrum
        if lmax is None or lmax < 0:
            lmax = cls.size-1
        if mmax is None or mmax < 0:
            mmax = lmax
        cls_list = [np.asarray(cls, dtype = np.float64)]
        szalm = Alm.getsize(lmax,mmax)
        alm = np.zeros(szalm,'D')
        alm.real = np.random.standard_normal(szalm)
        alm.imag = np.random.standard_normal(szalm)
        alms_list=[alm]
        sphtlib._synalm(cls_list,alms_list,lmax,mmax)
        return alm

    # From here, we interpret cls as a list of spectra
    cls_list = list(cls)
    maxsize = max([len(c) for c in cls])
    
    if lmax is None or lmax < 0:
        lmax = maxsize-1
    if mmax is None or mmax < 0:
        mmax = lmax
    
    Nspec = sphtlib._getn(len(cls_list))
    
    if Nspec <= 0:
        if len(cls_list) == 4:
            if new: ## new input order: TT EE BB TE -> TT EE BB TE 0 0
                cls_list = [cls[0], cls[1], cls[2], cls[3], None, None]
            else: ## old input order: TT TE EE BB -> TT TE 0 EE 0 BB
                cls_list = [cls[0], cls[1], None, cls[2], None, cls[3]]
            Nspec = 3
        else:
            raise TypeError("The sequence of arrays must have either 4 elements "
                            "or n(n+1)/2 elements (some may be None)")
    
    szalm = Alm.getsize(lmax,mmax)
    alms_list = []
    for i in six.moves.xrange(Nspec):
        alm = np.zeros(szalm,'D')
        alm.real = np.random.standard_normal(szalm)
        alm.imag = np.random.standard_normal(szalm)
        alms_list.append(alm)
    if new: # new input order: input given by diagonal, should be given by row
        cls_list = new_to_old_spectra_order(cls_list)
    # ensure cls are float64
    cls_list = [(np.asarray(cl, dtype = np.float64) if cl is not None else None)
                for cl in cls_list]
    sphtlib._synalm(cls_list, alms_list, lmax, mmax)
    return alms_list

def synfast(cls, nside, lmax = None, mmax = None, alm = False,
            pol = True, pixwin = False, fwhm = 0.0, sigma = None,
            new = False, verbose=True):
    """Create a map(s) from cl(s).

    Parameters
    ----------
    cls : array or tuple of array
      A cl or a list of cl (either 4 or 6, see :func:`synalm`)
    nside : int, scalar
      The nside of the output map(s)
    lmax : int, scalar, optional
      Maximum l for alm. Default: min of 3*nside-1 or length of the cls - 1
    mmax : int, scalar, optional
      Maximum m for alm.
    alm : bool, scalar, optional
      If True, return also alm(s). Default: False.
    pol : bool, optional
      If True, assumes input cls are TEB and correlation. Output will be TQU maps.
      (input must be 1, 4 or 6 cl's)
      If False, fields are assumed to be described by spin 0 spherical harmonics.
      (input can be any number of cl's)
      If there is only one input cl, it has no effect. Default: True.
    pixwin : bool, scalar, optional
      If True, convolve the alm by the pixel window function. Default: False.
    fwhm : float, scalar, optional
      The fwhm of the Gaussian used to smooth the map (applied on alm)
      [in radians]
    sigma : float, scalar, optional
      The sigma of the Gaussian used to smooth the map (applied on alm)
      [in radians]

    Returns
    -------
    maps : array or tuple of arrays
      The output map (possibly list of maps if polarized input).
      or, if alm is True, a tuple of (map,alm)
      (alm possibly a list of alm if polarized input)

    Notes
    -----
    The order of the spectra will change in a future release. The new= parameter
    help to make the transition smoother. You can start using the new order
    by setting new=True.
    In the next version of healpy, the default will be new=True.
    This change is done for consistency between the different tools
    (alm2cl, synfast, anafast).
    In the new order, the spectra are ordered by diagonal of the correlation
    matrix. Eg, if fields are T, E, B, the spectra are TT, EE, BB, TE, EB, TB
    with new=True, and TT, TE, TB, EE, EB, BB if new=False.
    """
    if not pixelfunc.isnsideok(nside):
        raise ValueError("Wrong nside value (must be a power of two).")
    cls_lmax = cb.len_array_or_arrays(cls) -1
    if lmax is None or lmax < 0:
        lmax = min(cls_lmax, 3 * nside - 1)
    alms = synalm(cls, lmax = lmax, mmax = mmax, new = new, verbose=verbose)
    maps = alm2map(alms, nside, lmax = lmax, mmax = mmax, pixwin = pixwin,
                   pol = pol, fwhm = fwhm, sigma = sigma, inplace = True, verbose=verbose)
    if alm:
        return maps, alms
    else:
        return maps
    
class Alm(object):
    """This class provides some static methods for alm index computation.

    Methods
    -------
    getlm
    getidx
    getsize
    getlmax
    """
    def __init__(self):
        pass

    @staticmethod
    def getlm(lmax,i=None):
        """Get the l and m from index and lmax.
        
        Parameters
        ----------
        lmax : int
          The maximum l defining the alm layout
        i : int or None
          The index for which to compute the l and m.
          If None, the function return l and m for i=0..Alm.getsize(lmax)
        """
        if i is None:
            i=np.arange(Alm.getsize(lmax))
        m=(np.ceil(((2*lmax+1)-np.sqrt((2*lmax+1)**2-8*(i-lmax)))/2)).astype(int)
        l = i-m*(2*lmax+1-m)//2
        return (l,m)

    @staticmethod
    def getidx(lmax,l,m):
        """Returns index corresponding to (l,m) in an array describing alm up to lmax.
        
        Parameters
        ----------
        lmax : int
          The maximum l, defines the alm layout
        l : int
          The l for which to get the index
        m : int
          The m for which to get the index

        Returns
        -------
        idx : int
          The index corresponding to (l,m)
        """
        return m*(2*lmax+1-m)//2+l

    @staticmethod
    def getsize(lmax,mmax = None):
        """Returns the size of the array needed to store alm up to *lmax* and *mmax*

        Parameters
        ----------
        lmax : int
          The maximum l, defines the alm layout
        mmax : int, optional
          The maximum m, defines the alm layout. Default: lmax.

        Returns
        -------
        size : int
          The size of the array needed to store alm up to lmax, mmax.
        """
        if mmax is None or mmax < 0 or mmax > lmax:
            mmax = lmax
        return mmax * (2 * lmax + 1 - mmax) // 2 + lmax + 1

    @staticmethod
    def getlmax(s, mmax = None):
        """Returns the lmax corresponding to a given array size.
        
        Parameters
        ----------
        s : int
          Size of the array
        mmax : None or int, optional
          The maximum m, defines the alm layout. Default: lmax.

        Returns
        -------
        lmax : int
          The maximum l of the array, or -1 if it is not a valid size.
        """
        if mmax is not None and mmax >= 0:
            x = (2 * s + mmax ** 2 - mmax - 2) / (2 * mmax + 2)
        else:
            x = (-3 + np.sqrt(1 + 8 * s)) / 2
        if x != np.floor(x):
            return -1
        else:
            return int(x)


def alm2cl(alms1, alms2 = None, lmax = None, mmax = None,
           lmax_out = None, nspec = None):
    """Computes (cross-)spectra from alm(s). If alm2 is given, cross-spectra between
    alm and alm2 are computed. If alm (and alm2 if provided) contains n alm,
    then n(n+1)/2 auto and cross-spectra are returned.

    Parameters
    ----------
    alm : complex, array or sequence of arrays
      The alm from which to compute the power spectrum. If n>=2 arrays are given,
      computes both auto- and cross-spectra.
    alms2 : complex, array or sequence of 3 arrays, optional
      If provided, computes cross-spectra between alm and alm2.
      Default: alm2=alm, so auto-spectra are computed.
    lmax : None or int, optional
      The maximum l of the input alm. Default: computed from size of alm
      and mmax_in
    mmax : None or int, optional
      The maximum m of the input alm. Default: assume mmax_in = lmax_in
    lmax_out : None or int, optional
      The maximum l of the returned spectra. By default: the lmax of the given
      alm(s).
    nspec : None or int, optional
      The number of spectra to return. None means all, otherwise returns cl[:nspec]

    Returns
    -------
    cl : array or tuple of n(n+1)/2 arrays
      the spectrum <*alm* x *alm2*> if *alm* (and *alm2*) is one alm, or 
      the auto- and cross-spectra <*alm*[i] x *alm2*[j]> if alm (and alm2)
      contains more than one spectra.
      If more than one spectrum is returned, they are ordered by diagonal.
      For example, if *alm* is almT, almE, almB, then the returned spectra are:
      TT, EE, BB, TE, EB, TB.
    """
    cls = _sphtools.alm2cl(alms1, alms2 = alms2, lmax = lmax,
                           mmax = mmax, lmax_out = lmax_out)
    if nspec is None:
        return cls
    else:
        return cls[:nspec]

    
def almxfl(alm, fl, mmax = None, inplace = False):
    """Multiply alm by a function of l. The function is assumed
    to be zero where not defined.

    Parameters
    ----------
    alm : array
      The alm to multiply
    fl : array
      The function (at l=0..fl.size-1) by which alm must be multiplied.
    mmax : None or int, optional
      The maximum m defining the alm layout. Default: lmax.
    inplace : bool, optional
      If True, modify the given alm, otherwise make a copy before multiplying.

    Returns
    -------
    alm : array
      The modified alm, either a new array or a reference to input alm, 
      if inplace is True.
    """
    almout = _sphtools.almxfl(alm, fl, mmax = mmax, inplace = inplace)
    return almout

def smoothalm(alms, fwhm = 0.0, sigma = None,  pol = True,
              mmax = None, verbose = True, inplace = True):
    """Smooth alm with a Gaussian symmetric beam function.

    Parameters
    ----------
    alms : array or sequence of 3 arrays
      Either an array representing one alm, or a sequence of arrays.
      See *pol* parameter.
    fwhm : float, optional
      The full width half max parameter of the Gaussian. Default:0.0
      [in radians]
    sigma : float, optional
      The sigma of the Gaussian. Override fwhm.
      [in radians]
    pol : bool, optional
      If True, assumes input alms are TEB. Output will be TQU maps.
      (input must be 1 or 3 alms)
      If False, apply spin 0 harmonic transform to each alm.
      (input can be any number of alms)
      If there is only one input alm, it has no effect. Default: True.
    mmax : None or int, optional
      The maximum m for alm. Default: mmax=lmax
    inplace : bool, optional
      If True, the alm's are modified inplace if they are contiguous arrays
      of type complex128. Otherwise, a copy of alm is made. Default: True.
    verbose : bool, optional
      If True prints diagnostic information. Default: True

    Returns
    -------
    alms : array or sequence of 3 arrays
      The smoothed alm. If alm[i] is a contiguous array of type complex128,
      and *inplace* is True the smoothing is applied inplace.
      Otherwise, a copy is made.
    """
    if sigma is None:
        sigma = fwhm / (2.*np.sqrt(2.*np.log(2.)))

    if verbose:
        print("Sigma is {0:f} arcmin ({1:f} rad) ".format(sigma*60*180/pi,sigma))
        print("-> fwhm is {0:f} arcmin".format(sigma*60*180/pi*(2.*np.sqrt(2.*np.log(2.)))))

    # Check alms
    if not cb.is_seq(alms):
        raise ValueError("alm must be a sequence")

    if sigma == 0:
        # nothing to be done
        return alms

    lonely = False
    if not cb.is_seq_of_seq(alms):
        alms = [alms]
        lonely = True
    
    # we have 3 alms -> apply smoothing to each map.
    # polarization has different B_l from temperature
    # exp{-[ell(ell+1) - s**2] * sigma**2/2}
    # with s the spin of spherical harmonics
    # s = 2 for pol, s=0 for temperature
    retalm = []
    for ialm, alm in enumerate(alms):
        lmax = Alm.getlmax(len(alm), mmax)
        if lmax < 0:
            raise TypeError('Wrong alm size for the given '
                            'mmax (len(alms[%d]) = %d).'%(ialm, len(alm)))
        ell = np.arange(lmax + 1.)
        s = 2 if ialm >= 1 and pol else 0
        fact = np.exp(-0.5 * (ell * (ell + 1) - s ** 2) * sigma ** 2)
        res = almxfl(alm, fact, mmax = mmax, inplace = inplace)
        retalm.append(res)
    # Test what to return (inplace/not inplace...)
    # Case 1: 1d input, return 1d output
    if lonely:
        return retalm[0]
    # case 2: 2d input, check if in-place smoothing for all alm's
    for i in six.moves.xrange(len(alms)):
        samearray = alms[i] is retalm[i]
        if not samearray:
            # Case 2a:
            # at least one of the alm could not be smoothed in place:
            # return the list of alm
            return retalm
    # Case 2b:
    # all smoothing have been performed in place:
    # return the input alms
    return alms

@accept_ma
def smoothing(map_in, fwhm = 0.0, sigma = None,  pol = True,
              iter = 3, lmax = None, mmax = None, use_weights = False,
              datapath = None, verbose = True):
    """Smooth a map with a Gaussian symmetric beam.

    No removal of monopole or dipole is performed.

    Parameters
    ----------
    map_in : array or sequence of 3 arrays
      Either an array representing one map, or a sequence of
      3 arrays representing 3 maps, accepts masked arrays
    fwhm : float, optional
      The full width half max parameter of the Gaussian [in 
      radians]. Default:0.0
    sigma : float, optional
      The sigma of the Gaussian [in radians]. Override fwhm.
    pol : bool, optional
      If True, assumes input maps are TQU. Output will be TQU maps.
      (input must be 1 or 3 alms)
      If False, each map is assumed to be a spin 0 map and is 
      treated independently (input can be any number of alms).
      If there is only one input map, it has no effect. Default: True.
    iter : int, scalar, optional
      Number of iteration (default: 3)
    lmax : int, scalar, optional
      Maximum l of the power spectrum. Default: 3*nside-1
    mmax : int, scalar, optional
      Maximum m of the alm. Default: lmax
    use_weights: bool, scalar, optional
      If True, use the ring weighting. Default: False.
    datapath : None or str, optional
      If given, the directory where to find the weights data.
    verbose : bool, optional
      If True prints diagnostic information. Default: True

    Returns
    -------
    maps : array or list of 3 arrays
      The smoothed map(s)
    """

    if not cb.is_seq(map_in):
        raise TypeError("map_in must be a sequence")

    # save the masks of inputs
    masks = pixelfunc.mask_bad(map_in) 

    if cb.is_seq_of_seq(map_in):
        nside = pixelfunc.npix2nside(len(map_in[0]))
        n_maps = len(map_in)
    else:
        nside = pixelfunc.npix2nside(len(map_in))
        n_maps = 0

    if pol or n_maps in (0, 1):
        # Treat the maps together (1 or 3 maps)
        alms = map2alm(map_in, lmax = lmax, mmax = mmax, iter = iter,
                       pol = pol, use_weights = use_weights,
                       datapath = datapath)
        smoothalm(alms, fwhm = fwhm, sigma = sigma, 
                  inplace = True, verbose = verbose)
        output_map = alm2map(alms, nside, pixwin = False, verbose=verbose)
    else:
        # Treat each map independently (any number)
        output_map = []
        for m in map_in:
            alm = map2alm(m, lmax = lmax, mmax = mmax, iter = iter, pol = pol,
                          use_weights = use_weights, datapath = datapath)
            smoothalm(alm, fwhm = fwhm, sigma = sigma, 
                      inplace = True, verbose = verbose)
            output_map.append(alm2map(alm, nside, pixwin = False, verbose=verbose))
    if pixelfunc.maptype(output_map) == 0:
        output_map[masks.flatten()] = UNSEEN
    else:
        for m, mask in zip(output_map, masks):
            m[mask] = UNSEEN
        
    return output_map

def pixwin(nside, pol = False):
    """Return the pixel window function for the given nside.

    Parameters
    ----------
    nside : int
      The nside for which to return the pixel window function
    pol : bool, optional
      If True, return also the polar pixel window. Default: False

    Returns
    -------
    pw or pwT,pwP : array or tuple of 2 arrays
      The temperature pixel window function, or a tuple with both
      temperature and polarisation pixel window functions.
    """
    datapath = DATAPATH
    if not pixelfunc.isnsideok(nside):
        raise ValueError("Wrong nside value (must be a power of two).")
    fname = os.path.join(datapath, 'pixel_window_n%04d.fits'%nside)
    if not os.path.isfile(fname):
        raise ValueError("No pixel window for this nside "
                         "or data files missing")
    # return hfitslib._pixwin(nside,datapath,pol)  ## BROKEN -> seg fault...
    pw = pf.getdata(fname)
    pw_temp, pw_pol = pw.field(0), pw.field(1)
    if pol:
        return pw_temp, pw_pol
    else:
        return pw_temp

def alm2map_der1(alm, nside, lmax = None, mmax = None):
   """Computes an Healpix map and its first derivatives given the alm.

   The alm are given as a complex array. You can specify lmax
   and mmax, or they will be computed from array size (assuming
   lmax==mmax).

   Parameters
   ----------
   alm : array, complex
     A complex array of alm. Size must be of the form mmax(lmax-mmax+1)/2+lmax
   nside : int
     The nside of the output map.
   lmax : None or int, optional
     Explicitly define lmax (needed if mmax!=lmax)
   mmax : None or int, optional
     Explicitly define mmax (needed if mmax!=lmax)

   Returns
   -------
   m, d_theta, d_phi : tuple of arrays
     The maps correponding to alm, and its derivatives with respect to
     theta and phi. d_phi is already divided by sin(theta)
   """
   if lmax is None:
       lmax = -1
   if mmax is None:
       mmax = -1
   return sphtlib._alm2map_der1(alm,nside,lmax=lmax,mmax=mmax)

def new_to_old_spectra_order(cls_new_order):
    """Reorder the cls from new order (by diagonal) to old order (by row).
    For example : TT, EE, BB, TE, EB, BB => TT, TE, TB, EE, EB, BB
    """
    Nspec = sphtlib._getn(len(cls_new_order))
    if Nspec < 0:
        raise ValueError("Input must be a list of n(n+1)/2 arrays")
    cls_old_order = []
    for i in six.moves.xrange(Nspec):
        for j in six.moves.xrange(i, Nspec):
            p = j - i
            q = i
            idx_new = p * (2 * Nspec + 1 - p) // 2 + q
            cls_old_order.append(cls_new_order[idx_new])
    return cls_old_order

def load_sample_spectra():
    """Read a sample power spectra for testing and demo purpose.
    Based on LambdaCDM. Gives TT, EE, BB, TE.

    Returns
    -------
    ell, f, cls : arrays
      ell is the array of ell values (from 0 to lmax)
      f is the factor ell*(ell+1)/2pi (in general, plots show f * cl)
      cls is a sequence of the power spectra TT, EE, BB and TE
    """
    cls = np.loadtxt(os.path.join(DATAPATH, 'totcls.dat'), unpack = True)
    ell = cls[0]
    f = ell * (ell + 1) / 2 / np.pi
    cls[1:, 1:] /= f[1:]
    return ell, f, cls[1:]

def gauss_beam(fwhm, lmax=512, pol=False):
    """Gaussian beam window function

    Computes the spherical transform of an axisimmetric gaussian beam

    For a sky of underlying power spectrum C(l) observed with beam of  
    given FWHM, the measured power spectrum will be 
    C(l)_meas = C(l) B(l)^2
    where B(l) is given by gaussbeam(Fwhm,Lmax). 
    The polarization beam is also provided (when pol = True ) assuming 
    a perfectly co-polarized beam 
    (e.g., Challinor et al 2000, astro-ph/0008228)

    Parameters
    ----------
    fwhm : float
        full width half max in radians
    lmax : integer
        ell max
    pol : bool
        if False, output has size (lmax+1) and is temperature beam
        if True output has size (lmax+1, 4) with components:
        * temperature beam
        * grad/electric polarization beam
        * curl/magnetic polarization beam
        * temperature * grad beam

    Returns
    -------
    beam : array
        beam window function [0, lmax] if dim not specified
        otherwise (lmax+1, 4) contains polarized beam
    """

    sigma = fwhm / np.sqrt(8. * np.log(2.))
    ell = np.arange(lmax + 1)
    sigma2 = sigma ** 2
    g = np.exp(-.5 * ell * (ell + 1) * sigma2)

    if not pol: # temperature-only beam
        return g
    else: # polarization beam
        # polarization factors [1, 2 sigma^2, 2 sigma^2, sigma^2]
        pol_factor = np.exp([0., 2*sigma2, 2*sigma2, sigma2])
        return g[:, np.newaxis] * pol_factor 
healpy-1.10.3/healpy/version.py0000664000175000017500000000002513031130235016633 0ustar  zoncazonca00000000000000__version__='1.10.3'
healpy-1.10.3/healpy/visufunc.py0000664000175000017500000012254013010375075017031 0ustar  zoncazonca00000000000000# 
#  This file is part of Healpy.
# 
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# 
#  For more information about Healpy, see http://code.google.com/p/healpy
# 

"""
=====================================================
visufunc.py : Healpix visualization functions
=====================================================

This module provides functions to display Healpix map.

Map projections
---------------

- :func:`mollview` displays a map using Mollweide projection (full sky)
- :func:`gnomview` displays a map using Gnomonic projection (local map)
- :func:`cartview` displays a map using Cartesian projection
- :func:`orthview` displays a map using Orthographic projection (full or half sky)
- :func:`azeqview` displays a map using Azimuthal equidistant projection

Graticules
----------

- :func:`graticule` adds a graticule to the current map
- :func:`delgraticules` deletes all graticules of a map

Tracing lines or points
-----------------------

- :func:`projplot` plots data points on the current map
- :func:`projscatter` displays scatter points
- :func:`projtext` display a text on the current map
"""

__all__ = ['mollview', 'gnomview', 'cartview', 'orthview', 'azeqview',
           'graticule', 'delgraticules',
           'projplot', 'projscatter', 'projtext']

from . import projaxes as PA
import numpy as np
import matplotlib
from . import pixelfunc

pi = np.pi
dtor = pi/180.

def mollview(map=None,fig=None,rot=None,coord=None,unit='',
             xsize=800,title='Mollweide view',nest=False,
             min=None,max=None,flip='astro',
             remove_dip=False,remove_mono=False,
             gal_cut=0,
             format='%g',format2='%g',
             cbar=True,cmap=None, notext=False,
             norm=None,hold=False,margins=None,sub=None,
             return_projected_map=False):
    """Plot an healpix map (given as an array) in Mollweide projection.
    
    Parameters
    ----------
    map : float, array-like or None
      An array containing the map, supports masked maps, see the `ma` function.
      If None, will display a blank map, useful for overplotting.
    fig : int or None, optional
      The figure number to use. Default: create a new figure
    rot : scalar or sequence, optional
      Describe the rotation to apply.
      In the form (lon, lat, psi) (unit: degrees) : the point at
      longitude *lon* and latitude *lat* will be at the center. An additional rotation
      of angle *psi* around this direction is applied.
    coord : sequence of character, optional
      Either one of 'G', 'E' or 'C' to describe the coordinate
      system of the map, or a sequence of 2 of these to rotate
      the map from the first to the second coordinate system.
    unit : str, optional
      A text describing the unit of the data. Default: ''
    xsize : int, optional
      The size of the image. Default: 800
    title : str, optional
      The title of the plot. Default: 'Mollweide view'
    nest : bool, optional
      If True, ordering scheme is NESTED. Default: False (RING)
    min : float, optional
      The minimum range value
    max : float, optional
      The maximum range value
    flip : {'astro', 'geo'}, optional
      Defines the convention of projection : 'astro' (default, east towards left, west towards right)
      or 'geo' (east towards roght, west towards left)
    remove_dip : bool, optional
      If :const:`True`, remove the dipole+monopole
    remove_mono : bool, optional
      If :const:`True`, remove the monopole
    gal_cut : float, scalar, optional
      Symmetric galactic cut for the dipole/monopole fit.
      Removes points in latitude range [-gal_cut, +gal_cut]
    format : str, optional
      The format of the scale label. Default: '%g'
    format2 : str, optional
      Format of the pixel value under mouse. Default: '%g'
    cbar : bool, optional
      Display the colorbar. Default: True
    notext : bool, optional
      If True, no text is printed around the map
    norm : {'hist', 'log', None}
      Color normalization, hist= histogram equalized color mapping,
      log= logarithmic color mapping, default: None (linear color mapping)
    hold : bool, optional
      If True, replace the current Axes by a MollweideAxes.
      use this if you want to have multiple maps on the same
      figure. Default: False
    sub : int, scalar or sequence, optional
      Use only a zone of the current figure (same syntax as subplot).
      Default: None
    margins : None or sequence, optional
      Either None, or a sequence (left,bottom,right,top)
      giving the margins on left,bottom,right and top
      of the axes. Values are relative to figure (0-1).
      Default: None
    return_projected_map : bool
      if True returns the projected map in a 2d numpy array

    See Also
    --------
    gnomview, cartview, orthview, azeqview
    """
    # Create the figure
    import pylab
    if not (hold or sub):
        f=pylab.figure(fig,figsize=(8.5,5.4))
        extent = (0.02,0.05,0.96,0.9)
    elif hold:
        f=pylab.gcf()
        left,bottom,right,top = np.array(f.gca().get_position()).ravel()
        extent = (left,bottom,right-left,top-bottom)
        f.delaxes(f.gca())
    else: # using subplot syntax
        f=pylab.gcf()
        if hasattr(sub,'__len__'):
            nrows, ncols, idx = sub
        else:
            nrows, ncols, idx = sub//100, (sub%100)//10, (sub%10)
        if idx < 1 or idx > ncols*nrows:
            raise ValueError('Wrong values for sub: %d, %d, %d'%(nrows,
                                                                 ncols,
                                                                 idx))
        c,r = (idx-1)%ncols,(idx-1)//ncols
        if not margins:
            margins = (0.01,0.0,0.0,0.02)
        extent = (c*1./ncols+margins[0], 
                  1.-(r+1)*1./nrows+margins[1],
                  1./ncols-margins[2]-margins[0],
                  1./nrows-margins[3]-margins[1])
        extent = (extent[0]+margins[0],
                  extent[1]+margins[1],
                  extent[2]-margins[2]-margins[0],
                  extent[3]-margins[3]-margins[1])
        #extent = (c*1./ncols, 1.-(r+1)*1./nrows,1./ncols,1./nrows)
    #f=pylab.figure(fig,figsize=(8.5,5.4))

    # Starting to draw : turn interactive off
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if map is None:
            map = np.zeros(12)+np.inf
            cbar=False
        map = pixelfunc.ma_to_array(map)
        ax=PA.HpxMollweideAxes(f,extent,coord=coord,rot=rot,
                               format=format2,flipconv=flip)
        f.add_axes(ax)
        if remove_dip:
            map=pixelfunc.remove_dipole(map,gal_cut=gal_cut,
                                        nest=nest,copy=True,
                                        verbose=True)
        elif remove_mono:
            map=pixelfunc.remove_monopole(map,gal_cut=gal_cut,nest=nest,
                                          copy=True,verbose=True)
        img = ax.projmap(map,nest=nest,xsize=xsize,coord=coord,vmin=min,vmax=max,
                   cmap=cmap,norm=norm)
        if cbar:
            im = ax.get_images()[0]
            b = im.norm.inverse(np.linspace(0,1,im.cmap.N+1))
            v = np.linspace(im.norm.vmin,im.norm.vmax,im.cmap.N)
            if matplotlib.__version__ >= '0.91.0':
                cb=f.colorbar(im,ax=ax,
                              orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.05,fraction=0.1,boundaries=b,values=v,
                              format=format)
            else:
                # for older matplotlib versions, no ax kwarg
                cb=f.colorbar(im,orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.05,fraction=0.1,boundaries=b,values=v,
                              format=format)
            cb.solids.set_rasterized(True)
        ax.set_title(title)
        if not notext:
            ax.text(0.86,0.05,ax.proj.coordsysstr,fontsize=14,
                    fontweight='bold',transform=ax.transAxes)
        if cbar:
            cb.ax.text(0.5,-1.0,unit,fontsize=14,
                       transform=cb.ax.transAxes,ha='center',va='center')
        f.sca(ax)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    if return_projected_map:
        return img

def gnomview(map=None,fig=None,rot=None,coord=None,unit='',
             xsize=200,ysize=None,reso=1.5,
             title='Gnomonic view',nest=False,remove_dip=False,
             remove_mono=False,gal_cut=0,
             min=None,max=None,flip='astro',
             format='%.3g',cbar=True,
             cmap=None, norm=None,
             hold=False,sub=None,margins=None,notext=False,
             return_projected_map=False):
    """Plot an healpix map (given as an array) in Gnomonic projection.

    Parameters
    ----------
    map : array-like
      The map to project, supports masked maps, see the `ma` function.
      If None, use a blank map, useful for
      overplotting.
    fig : None or int, optional
      A figure number. Default: None= create a new figure
    rot : scalar or sequence, optional
      Describe the rotation to apply.
      In the form (lon, lat, psi) (unit: degrees) : the point at
      longitude *lon* and latitude *lat* will be at the center. An additional rotation
      of angle *psi* around this direction is applied.
    coord : sequence of character, optional
      Either one of 'G', 'E' or 'C' to describe the coordinate
      system of the map, or a sequence of 2 of these to rotate
      the map from the first to the second coordinate system.
    unit : str, optional
      A text describing the unit of the data. Default: ''
    xsize : int, optional
      The size of the image. Default: 200
    ysize : None or int, optional
      The size of the image. Default: None= xsize
    reso : float, optional
      Resolution (in arcmin). Default: 1.5 arcmin
    title : str, optional
      The title of the plot. Default: 'Gnomonic view'
    nest : bool, optional
      If True, ordering scheme is NESTED. Default: False (RING)
    min : float, scalar, optional
      The minimum range value
    max : float, scalar, optional
      The maximum range value
    flip : {'astro', 'geo'}, optional
      Defines the convention of projection : 'astro' (default, east towards left, west towards right)
      or 'geo' (east towards roght, west towards left)
    remove_dip : bool, optional
      If :const:`True`, remove the dipole+monopole
    remove_mono : bool, optional
      If :const:`True`, remove the monopole
    gal_cut : float, scalar, optional
      Symmetric galactic cut for the dipole/monopole fit.
      Removes points in latitude range [-gal_cut, +gal_cut]
    format : str, optional
      The format of the scale label. Default: '%g'
    hold : bool, optional
      If True, replace the current Axes by a MollweideAxes.
      use this if you want to have multiple maps on the same
      figure. Default: False
    sub : int or sequence, optional
      Use only a zone of the current figure (same syntax as subplot).
      Default: None
    margins : None or sequence, optional
      Either None, or a sequence (left,bottom,right,top)
      giving the margins on left,bottom,right and top
      of the axes. Values are relative to figure (0-1).
      Default: None
    notext: bool, optional
      If True: do not add resolution info text. Default=False
    return_projected_map : bool
      if True returns the projected map in a 2d numpy array

    See Also
    --------
    mollview, cartview, orthview, azeqview
    """
    import pylab
    if not (hold or sub):
        f=pylab.figure(fig,figsize=(5.8,6.4))
        if not margins:
                margins = (0.075,0.05,0.075,0.05)
        extent = (0.0,0.0,1.0,1.0)
    elif hold:
        f=pylab.gcf()
        left,bottom,right,top = np.array(pylab.gca().get_position()).ravel()
        if not margins:
            margins = (0.0,0.0,0.0,0.0)
        extent = (left,bottom,right-left,top-bottom)
        f.delaxes(pylab.gca())
    else: # using subplot syntax
        f=pylab.gcf()
        if hasattr(sub,'__len__'):
            nrows, ncols, idx = sub
        else:
            nrows, ncols, idx = sub//100, (sub%100)//10, (sub%10)
        if idx < 1 or idx > ncols*nrows:
            raise ValueError('Wrong values for sub: %d, %d, %d'%(nrows,
                                                                 ncols,
                                                                 idx))
        c,r = (idx-1)%ncols,(idx-1)//ncols
        if not margins:
            margins = (0.01,0.0,0.0,0.02)
        extent = (c*1./ncols+margins[0], 
                  1.-(r+1)*1./nrows+margins[1],
                  1./ncols-margins[2]-margins[0],
                  1./nrows-margins[3]-margins[1])
    extent = (extent[0]+margins[0],
              extent[1]+margins[1],
              extent[2]-margins[2]-margins[0],
              extent[3]-margins[3]-margins[1])
    #f=pylab.figure(fig,figsize=(5.5,6))

    # Starting to draw : turn interactive off
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if map is None:
            map = np.zeros(12)+np.inf
            cbar=False
        map = pixelfunc.ma_to_array(map)
        ax=PA.HpxGnomonicAxes(f,extent,coord=coord,rot=rot,
                              format=format,flipconv=flip)
        f.add_axes(ax)
        if remove_dip:
            map=pixelfunc.remove_dipole(map,gal_cut=gal_cut,nest=nest,copy=True)
        elif remove_mono:
            map=pixelfunc.remove_monopole(map,gal_cut=gal_cut,nest=nest,copy=True)
        img = ax.projmap(map,nest=nest,coord=coord,vmin=min,vmax=max,
                   xsize=xsize,ysize=ysize,reso=reso,cmap=cmap,norm=norm)
        if cbar:
            im = ax.get_images()[0]
            b = im.norm.inverse(np.linspace(0,1,im.cmap.N+1))
            v = np.linspace(im.norm.vmin,im.norm.vmax,im.cmap.N)
            if matplotlib.__version__ >= '0.91.0':
                cb=f.colorbar(im,ax=ax,
                              orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.08,fraction=0.1,boundaries=b,values=v,
                              format=format)
            else:
                cb=f.colorbar(im,orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.08,fraction=0.1,boundaries=b,values=v,
                              format=format)
            cb.solids.set_rasterized(True)                  
        ax.set_title(title)
        if not notext:
            ax.text(-0.07,0.02,
                     "%g '/pix,   %dx%d pix"%(ax.proj.arrayinfo['reso'],
                                              ax.proj.arrayinfo['xsize'],
                                              ax.proj.arrayinfo['ysize']),
                     fontsize=12,verticalalignment='bottom',
                     transform=ax.transAxes,rotation=90)
            ax.text(-0.07,0.6,ax.proj.coordsysstr,fontsize=14,
                     fontweight='bold',rotation=90,transform=ax.transAxes)
            lon,lat = np.around(ax.proj.get_center(lonlat=True),ax._coordprec)
            ax.text(0.5,-0.03,'(%g,%g)'%(lon,lat),
                    verticalalignment='center', horizontalalignment='center',
                    transform=ax.transAxes)
        if cbar:
            cb.ax.text(1.05,0.30,unit,fontsize=14,fontweight='bold',
                       transform=cb.ax.transAxes,ha='left',va='center')
        f.sca(ax)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    if return_projected_map:
        return img

def cartview(map=None,fig=None,rot=None,zat=None,coord=None,unit='',
             xsize=800,ysize=None,lonra=None,latra=None,
             title='Cartesian view',nest=False,remove_dip=False,
             remove_mono=False,gal_cut=0,
             min=None,max=None,flip='astro',
             format='%.3g',cbar=True,
             cmap=None, norm=None,aspect=None,
             hold=False,sub=None,margins=None,notext=False,
             return_projected_map=False):
    """Plot an healpix map (given as an array) in Cartesian projection.

    Parameters
    ----------
    map : float, array-like or None
      An array containing the map, 
      supports masked maps, see the `ma` function.
      If None, will display a blank map, useful for overplotting.
    fig : int or None, optional
      The figure number to use. Default: create a new figure
    rot : scalar or sequence, optional
      Describe the rotation to apply.
      In the form (lon, lat, psi) (unit: degrees) : the point at
      longitude *lon* and latitude *lat* will be at the center. An additional rotation
      of angle *psi* around this direction is applied.
    coord : sequence of character, optional
      Either one of 'G', 'E' or 'C' to describe the coordinate
      system of the map, or a sequence of 2 of these to rotate
      the map from the first to the second coordinate system.
    unit : str, optional
      A text describing the unit of the data. Default: ''
    xsize : int, optional
      The size of the image. Default: 800
    lonra : sequence, optional
      Range in longitude. Default: [-180,180]
    latra : sequence, optional
      Range in latitude. Default: [-90,90]
    title : str, optional
      The title of the plot. Default: 'Mollweide view'
    nest : bool, optional
      If True, ordering scheme is NESTED. Default: False (RING)
    min : float, optional
      The minimum range value
    max : float, optional
      The maximum range value
    flip : {'astro', 'geo'}, optional
      Defines the convention of projection : 'astro' (default, east towards left, west towards right)
      or 'geo' (east towards roght, west towards left)
    remove_dip : bool, optional
      If :const:`True`, remove the dipole+monopole
    remove_mono : bool, optional
      If :const:`True`, remove the monopole
    gal_cut : float, scalar, optional
      Symmetric galactic cut for the dipole/monopole fit.
      Removes points in latitude range [-gal_cut, +gal_cut]
    format : str, optional
      The format of the scale label. Default: '%g'
    cbar : bool, optional
      Display the colorbar. Default: True
    notext : bool, optional
      If True, no text is printed around the map
    norm : {'hist', 'log', None}, optional
      Color normalization, hist= histogram equalized color mapping,
      log= logarithmic color mapping, default: None (linear color mapping)
    hold : bool, optional
      If True, replace the current Axes by a CartesianAxes.
      use this if you want to have multiple maps on the same
      figure. Default: False
    sub : int, scalar or sequence, optional
      Use only a zone of the current figure (same syntax as subplot).
      Default: None
    margins : None or sequence, optional
      Either None, or a sequence (left,bottom,right,top)
      giving the margins on left,bottom,right and top
      of the axes. Values are relative to figure (0-1).
      Default: None
    return_projected_map : bool
      if True returns the projected map in a 2d numpy array

    See Also
    --------
    mollview, gnomview, orthview, azeqview
    """
    import pylab
    if not (hold or sub):
        f=pylab.figure(fig,figsize=(8.5,5.4))
        if not margins:
                margins = (0.075,0.05,0.075,0.05)
        extent = (0.0,0.0,1.0,1.0)
    elif hold:
        f=pylab.gcf()
        left,bottom,right,top = np.array(pylab.gca().get_position()).ravel()
        if not margins:
            margins = (0.0,0.0,0.0,0.0)
        extent = (left,bottom,right-left,top-bottom)
        f.delaxes(pylab.gca())
    else: # using subplot syntax
        f=pylab.gcf()
        if hasattr(sub,'__len__'):
            nrows, ncols, idx = sub
        else:
            nrows, ncols, idx = sub//100, (sub%100)//10, (sub%10)
        if idx < 1 or idx > ncols*nrows:
            raise ValueError('Wrong values for sub: %d, %d, %d'%(nrows,
                                                                 ncols,
                                                                 idx))
        c,r = (idx-1)%ncols,(idx-1)//ncols
        if not margins:
            margins = (0.01,0.0,0.0,0.02)
        extent = (c*1./ncols+margins[0], 
                  1.-(r+1)*1./nrows+margins[1],
                  1./ncols-margins[2]-margins[0],
                  1./nrows-margins[3]-margins[1])
    extent = (extent[0]+margins[0],
              extent[1]+margins[1],
              extent[2]-margins[2]-margins[0],
              extent[3]-margins[3]-margins[1])

    #f=pylab.figure(fig,figsize=(5.5,6))
    # Starting to draw : turn interactive off
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if map is None:
            map = np.zeros(12)+np.inf
            cbar=False
        map = pixelfunc.ma_to_array(map)
        if zat and rot:
            raise ValueError('Only give rot or zat, not both')
        if zat:
            rot = np.array(zat,dtype=np.float64)
            rot.resize(3)
            rot[1] -= 90
        ax=PA.HpxCartesianAxes(f,extent,coord=coord,rot=rot,
                               format=format,flipconv=flip)
        f.add_axes(ax)
        if remove_dip:
            map=pixelfunc.remove_dipole(map,gal_cut=gal_cut,nest=nest,copy=True)
        elif remove_mono:
            map=pixelfunc.remove_monopole(map,gal_cut=gal_cut,nest=nest,copy=True)
        img = ax.projmap(map,nest=nest,coord=coord,vmin=min,vmax=max,
                   xsize=xsize,ysize=ysize,lonra=lonra,latra=latra,
                   cmap=cmap,norm=norm,aspect=aspect)
        if cbar:
            im = ax.get_images()[0]
            b = im.norm.inverse(np.linspace(0,1,im.cmap.N+1))
            v = np.linspace(im.norm.vmin,im.norm.vmax,im.cmap.N)
            if matplotlib.__version__ >= '0.91.0':
                cb=f.colorbar(im,ax=ax,
                              orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.08,fraction=0.1,boundaries=b,values=v,
                              format=format)
            else:
                cb=f.colorbar(im,orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.08,fraction=0.1,boundaries=b,values=v,
                              format=format)
            cb.solids.set_rasterized(True)                 
        ax.set_title(title)
        if not notext:
            ax.text(-0.07,0.6,ax.proj.coordsysstr,fontsize=14,
                     fontweight='bold',rotation=90,transform=ax.transAxes)
        if cbar:
            cb.ax.text(1.05,0.30,unit,fontsize=14,fontweight='bold',
                       transform=cb.ax.transAxes,ha='left',va='center')
        f.sca(ax)
    finally:
        if wasinteractive:
            pylab.ion()
            pylab.draw()
            #pylab.show()
    if return_projected_map:
        return img

def orthview(map=None,fig=None,rot=None,coord=None,unit='',
             xsize=800,half_sky=False,
             title='Orthographic view',nest=False,
             min=None,max=None,flip='astro',
             remove_dip=False,remove_mono=False,
             gal_cut=0,
             format='%g',format2='%g',
             cbar=True,cmap=None, notext=False,
             norm=None,hold=False,margins=None,sub=None,
             return_projected_map=False):
    """Plot an healpix map (given as an array) in Orthographic projection.
    
    Parameters
    ----------
    map : float, array-like or None
      An array containing the map.
      If None, will display a blank map, useful for overplotting.
    fig : int or None, optional
      The figure number to use. Default: create a new figure
    rot : scalar or sequence, optional
      Describe the rotation to apply.
      In the form (lon, lat, psi) (unit: degrees) : the point at
      longitude *lon* and latitude *lat* will be at the center. An additional rotation
      of angle *psi* around this direction is applied.
    coord : sequence of character, optional
      Either one of 'G', 'E' or 'C' to describe the coordinate
      system of the map, or a sequence of 2 of these to rotate
      the map from the first to the second coordinate system.
    half_sky : bool, optional
      Plot only one side of the sphere. Default: False
    unit : str, optional
      A text describing the unit of the data. Default: ''
    xsize : int, optional
      The size of the image. Default: 800
    title : str, optional
      The title of the plot. Default: 'Orthographic view'
    nest : bool, optional
      If True, ordering scheme is NESTED. Default: False (RING)
    min : float, optional
      The minimum range value
    max : float, optional
      The maximum range value
    flip : {'astro', 'geo'}, optional
      Defines the convention of projection : 'astro' (default, east towards left, west towards right)
      or 'geo' (east towards roght, west towards left)
    remove_dip : bool, optional
      If :const:`True`, remove the dipole+monopole
    remove_mono : bool, optional
      If :const:`True`, remove the monopole
    gal_cut : float, scalar, optional
      Symmetric galactic cut for the dipole/monopole fit.
      Removes points in latitude range [-gal_cut, +gal_cut]
    format : str, optional
      The format of the scale label. Default: '%g'
    format2 : str, optional
      Format of the pixel value under mouse. Default: '%g'
    cbar : bool, optional
      Display the colorbar. Default: True
    notext : bool, optional
      If True, no text is printed around the map
    norm : {'hist', 'log', None}
      Color normalization, hist= histogram equalized color mapping,
      log= logarithmic color mapping, default: None (linear color mapping)
    hold : bool, optional
      If True, replace the current Axes by an OrthographicAxes.
      use this if you want to have multiple maps on the same
      figure. Default: False
    sub : int, scalar or sequence, optional
      Use only a zone of the current figure (same syntax as subplot).
      Default: None
    margins : None or sequence, optional
      Either None, or a sequence (left,bottom,right,top)
      giving the margins on left,bottom,right and top
      of the axes. Values are relative to figure (0-1).
      Default: None
    return_projected_map : bool
      if True returns the projected map in a 2d numpy array
    
    See Also
    --------
    mollview, gnomview, cartview, azeqview
    """
    # Create the figure
    import pylab
    if not (hold or sub):
        f=pylab.figure(fig,figsize=(8.5,5.4))
        extent = (0.02,0.05,0.96,0.9)
    elif hold:
        f=pylab.gcf()
        left,bottom,right,top = np.array(f.gca().get_position()).ravel()
        extent = (left,bottom,right-left,top-bottom)
        f.delaxes(f.gca())
    else: # using subplot syntax
        f=pylab.gcf()
        if hasattr(sub,'__len__'):
            nrows, ncols, idx = sub
        else:
            nrows, ncols, idx = sub//100, (sub%100)//10, (sub%10)
        if idx < 1 or idx > ncols*nrows:
            raise ValueError('Wrong values for sub: %d, %d, %d'%(nrows,
                                                                 ncols,
                                                                 idx))
        c,r = (idx-1)%ncols,(idx-1)//ncols
        if not margins:
            margins = (0.01,0.0,0.0,0.02)
        extent = (c*1./ncols+margins[0],
                  1.-(r+1)*1./nrows+margins[1],
                  1./ncols-margins[2]-margins[0],
                  1./nrows-margins[3]-margins[1])
        extent = (extent[0]+margins[0],
                  extent[1]+margins[1],
                  extent[2]-margins[2]-margins[0],
                  extent[3]-margins[3]-margins[1])
        #extent = (c*1./ncols, 1.-(r+1)*1./nrows,1./ncols,1./nrows)
    #f=pylab.figure(fig,figsize=(8.5,5.4))
    
    # Starting to draw : turn interactive off
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if map is None:
            map = np.zeros(12)+np.inf
            cbar=False
        ax=PA.HpxOrthographicAxes(f,extent,coord=coord,rot=rot,
                                  format=format2,flipconv=flip)
        f.add_axes(ax)
        if remove_dip:
            map=pixelfunc.remove_dipole(map,gal_cut=gal_cut,
                                        nest=nest,copy=True,
                                        verbose=True)
        elif remove_mono:
            map=pixelfunc.remove_monopole(map,gal_cut=gal_cut,nest=nest,
                                          copy=True,verbose=True)
        img = ax.projmap(map,nest=nest,xsize=xsize,half_sky=half_sky,
                         coord=coord,vmin=min,vmax=max,
                         cmap=cmap,norm=norm)
        if cbar:
            im = ax.get_images()[0]
            b = im.norm.inverse(np.linspace(0,1,im.cmap.N+1))
            v = np.linspace(im.norm.vmin,im.norm.vmax,im.cmap.N)
            if matplotlib.__version__ >= '0.91.0':
                cb=f.colorbar(im,ax=ax,
                              orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.05,fraction=0.1,boundaries=b,values=v,
                              format=format)
            else:
                # for older matplotlib versions, no ax kwarg
                cb=f.colorbar(im,orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.05,fraction=0.1,boundaries=b,values=v,
                              format=format)
            cb.solids.set_rasterized(True)                  
        ax.set_title(title)
        if not notext:
            ax.text(0.86,0.05,ax.proj.coordsysstr,fontsize=14,
                    fontweight='bold',transform=ax.transAxes)
        if cbar:
            cb.ax.text(0.5,-1.0,unit,fontsize=14,
                       transform=cb.ax.transAxes,ha='center',va='center')
        f.sca(ax)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    if return_projected_map:
        return img

def azeqview(map=None,fig=None,rot=None,zat=None,coord=None,unit='',
             xsize=800,ysize=None,reso=1.5,lamb=False,half_sky=False,
             title=None,nest=False,remove_dip=False,
             remove_mono=False,gal_cut=0,
             min=None,max=None,flip='astro',
             format='%.3g',cbar=True,
             cmap=None, norm=None,aspect=None,
             hold=False,sub=None,margins=None,notext=False,
             return_projected_map=False):
    """Plot a healpix map (given as an array) in Azimuthal equidistant projection
    or Lambert azimuthal equal-area projection.

    Parameters
    ----------
    map : float, array-like or None
      An array containing the map,
      supports masked maps, see the `ma` function.
      If None, will display a blank map, useful for overplotting.
    fig : int or None, optional
      The figure number to use. Default: create a new figure
    rot : scalar or sequence, optional
      Describe the rotation to apply.
      In the form (lon, lat, psi) (unit: degrees) : the point at
      longitude *lon* and latitude *lat* will be at the center. An additional rotation
      of angle *psi* around this direction is applied.
    coord : sequence of character, optional
      Either one of 'G', 'E' or 'C' to describe the coordinate
      system of the map, or a sequence of 2 of these to rotate
      the map from the first to the second coordinate system.
    unit : str, optional
      A text describing the unit of the data. Default: ''
    xsize : int, optional
      The size of the image. Default: 800
    ysize : None or int, optional
      The size of the image. Default: None= xsize
    reso : float, optional
      Resolution (in arcmin). Default: 1.5 arcmin
    lamb : bool, optional
      If True, plot Lambert azimuthal equal area instead of azimuthal
      equidistant. Default: False (az equidistant)
    half_sky : bool, optional
      Plot only one side of the sphere. Default: False
    title : str, optional
      The title of the plot. Default: 'Azimuthal equidistant view'
      or 'Lambert azimuthal equal-area view' (if lamb is True)
    nest : bool, optional
      If True, ordering scheme is NESTED. Default: False (RING)
    min : float, optional
      The minimum range value
    max : float, optional
      The maximum range value
    flip : {'astro', 'geo'}, optional
      Defines the convention of projection : 'astro' (default, east towards left, west towards right)
      or 'geo' (east towards roght, west towards left)
    remove_dip : bool, optional
      If :const:`True`, remove the dipole+monopole
    remove_mono : bool, optional
      If :const:`True`, remove the monopole
    gal_cut : float, scalar, optional
      Symmetric galactic cut for the dipole/monopole fit.
      Removes points in latitude range [-gal_cut, +gal_cut]
    format : str, optional
      The format of the scale label. Default: '%g'
    cbar : bool, optional
      Display the colorbar. Default: True
    notext : bool, optional
      If True, no text is printed around the map
    norm : {'hist', 'log', None}
      Color normalization, hist= histogram equalized color mapping,
      log= logarithmic color mapping, default: None (linear color mapping)
    hold : bool, optional
      If True, replace the current Axes by an Equidistant AzimuthalAxes.
      use this if you want to have multiple maps on the same
      figure. Default: False
    sub : int, scalar or sequence, optional
      Use only a zone of the current figure (same syntax as subplot).
      Default: None
    margins : None or sequence, optional
      Either None, or a sequence (left,bottom,right,top)
      giving the margins on left,bottom,right and top
      of the axes. Values are relative to figure (0-1).
      Default: None
    return_projected_map : bool
      if True returns the projected map in a 2d numpy array

    See Also
    --------
    mollview, gnomview, cartview, orthview
    """
    # Create the figure
    import pylab
    if not (hold or sub):
        f=pylab.figure(fig,figsize=(8.5,5.4))
        extent = (0.02,0.05,0.96,0.9)
    elif hold:
        f=pylab.gcf()
        left,bottom,right,top = np.array(f.gca().get_position()).ravel()
        extent = (left,bottom,right-left,top-bottom)
        f.delaxes(f.gca())
    else: # using subplot syntax
        f=pylab.gcf()
        if hasattr(sub,'__len__'):
            nrows, ncols, idx = sub
        else:
            nrows, ncols, idx = sub//100, (sub%100)//10, (sub%10)
        if idx < 1 or idx > ncols*nrows:
            raise ValueError('Wrong values for sub: %d, %d, %d'%(nrows,
                                                                 ncols,
                                                                 idx))
        c,r = (idx-1)%ncols,(idx-1)//ncols
        if not margins:
            margins = (0.01,0.0,0.0,0.02)
        extent = (c*1./ncols+margins[0],
                  1.-(r+1)*1./nrows+margins[1],
                  1./ncols-margins[2]-margins[0],
                  1./nrows-margins[3]-margins[1])
        extent = (extent[0]+margins[0],
                  extent[1]+margins[1],
                  extent[2]-margins[2]-margins[0],
                  extent[3]-margins[3]-margins[1])
        #extent = (c*1./ncols, 1.-(r+1)*1./nrows,1./ncols,1./nrows)
    #f=pylab.figure(fig,figsize=(8.5,5.4))

    # Starting to draw : turn interactive off
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if map is None:
            map = np.zeros(12)+np.inf
            cbar=False
        ax=PA.HpxAzimuthalAxes(f,extent,coord=coord,rot=rot,
                               format=format,flipconv=flip)
        f.add_axes(ax)
        if remove_dip:
            map=pixelfunc.remove_dipole(map,gal_cut=gal_cut,
                                        nest=nest,copy=True,
                                        verbose=True)
        elif remove_mono:
            map=pixelfunc.remove_monopole(map,gal_cut=gal_cut,nest=nest,
                                          copy=True,verbose=True)
        img = ax.projmap(map,nest=nest,xsize=xsize,ysize=ysize,reso=reso,lamb=lamb,
                         half_sky=half_sky,coord=coord,vmin=min,vmax=max,
                         cmap=cmap,norm=norm)
        if cbar:
            im = ax.get_images()[0]
            b = im.norm.inverse(np.linspace(0,1,im.cmap.N+1))
            v = np.linspace(im.norm.vmin,im.norm.vmax,im.cmap.N)
            if matplotlib.__version__ >= '0.91.0':
                cb=f.colorbar(im,ax=ax,
                              orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.05,fraction=0.1,boundaries=b,values=v,
                              format=format)
            else:
                # for older matplotlib versions, no ax kwarg
                cb=f.colorbar(im,orientation='horizontal',
                              shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                              pad=0.05,fraction=0.1,boundaries=b,values=v,
                              format=format)
            cb.solids.set_rasterized(True)
        if title is None:
            if lamb:
                title = 'Lambert azimuthal equal-area view'
            else:
                title = 'Azimuthal equidistant view'
        ax.set_title(title)
        if not notext:
            ax.text(0.86,0.05,ax.proj.coordsysstr,fontsize=14,
                    fontweight='bold',transform=ax.transAxes)
        if cbar:
            cb.ax.text(0.5,-1.0,unit,fontsize=14,
                       transform=cb.ax.transAxes,ha='center',va='center')
        f.sca(ax)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    if return_projected_map:
        return img
        

def graticule(dpar=None,dmer=None,coord=None,local=None,**kwds):
    """Draw a graticule on the current Axes.

    Parameters
    ----------
    dpar, dmer : float, scalars
      Interval in degrees between meridians and between parallels
    coord : {'E', 'G', 'C'}
      The coordinate system of the graticule (make rotation if needed,
      using coordinate system of the map if it is defined).
    local : bool
      If True, draw a local graticule (no rotation is performed, useful for
      a gnomonic view, for example)

    Notes
    -----
    Other keyword parameters will be transmitted to the projplot function.

    See Also
    --------
    delgraticules
    """
    import pylab
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if len(f.get_axes()) == 0:
            ax=PA.HpxMollweideAxes(f,(0.02,0.05,0.96,0.9),coord=coord)
            f.add_axes(ax)
            ax.text(0.86,0.05,ax.proj.coordsysstr,fontsize=14,
                    fontweight='bold',transform=ax.transAxes)
        for ax in f.get_axes():
            if isinstance(ax,PA.SphericalProjAxes):
                ax.graticule(dpar=dpar,dmer=dmer,coord=coord,
                             local=local,**kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
    
def delgraticules():
    """Delete all graticules previously created on the Axes.

    See Also
    --------
    graticule
    """
    import pylab
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        for ax in f.get_axes():
            if isinstance(ax,PA.SphericalProjAxes):
                ax.delgraticules()
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()

def projplot(*args,**kwds):
    import pylab
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    ret = None
    try:
        for ax in f.get_axes():
            if isinstance(ax,PA.SphericalProjAxes):
                ret = ax.projplot(*args,**kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    return ret
projplot.__doc__ = PA.SphericalProjAxes.projplot.__doc__
    
def projscatter(*args,**kwds):
    import pylab
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    ret=None
    try:
        for ax in f.get_axes():
            if isinstance(ax,PA.SphericalProjAxes):
                ret = ax.projscatter(*args,**kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    return ret
projscatter.__doc__ = PA.SphericalProjAxes.projscatter.__doc__

def projtext(*args,**kwds):
    import pylab
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    ret = None
    try:
        for ax in f.get_axes():
            if isinstance(ax,PA.SphericalProjAxes):
                ret = ax.projtext(*args,**kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    return ret
projtext.__doc__ = PA.SphericalProjAxes.projtext.__doc__
healpy-1.10.3/healpy/zoomtool.py0000664000175000017500000004613413010374155017053 0ustar  zoncazonca00000000000000# 
#  This file is part of Healpy.
# 
#  Healpy is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
# 
#  Healpy is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with Healpy; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# 
#  For more information about Healpy, see http://code.google.com/p/healpy
# 

from . import projaxes as PA
from . import rotator as R
import numpy as np
import matplotlib
from ._healpy_pixel_lib import UNSEEN
from . import pixelfunc

pi = np.pi
dtor = pi/180.

def mollzoom(map=None,fig=None,rot=None,coord=None,unit='',
             xsize=800,title='Mollweide view',nest=False,
             min=None,max=None,flip='astro',
             remove_dip=False,remove_mono=False,
             gal_cut=0,
             format='%g',cmap=None,
             norm=None,hold=False,margins=None,sub=None):
    """Interactive mollweide plot with zoomed gnomview.
    
    Parameters:
    -----------
    map : float, array-like shape (Npix,)
      An array containing the map, 
      supports masked maps, see the `ma` function.
      if None, use map with inf value (white map), useful for
      overplotting
    fig : a figure number. 
      Default: create a new figure
    rot : scalar or sequence, optional
      Describe the rotation to apply.
      In the form (lon, lat, psi) (unit: degrees) : the point at
      longitude *lon* and latitude *lat* will be at the center. An additional rotation
      of angle *psi* around this direction is applied.
    coord : sequence of character, optional
      Either one of 'G', 'E' or 'C' to describe the coordinate
      system of the map, or a sequence of 2 of these to rotate
      the map from the first to the second coordinate system.
    unit : str, optional
      A text describing the unit of the data. Default: ''
    xsize : int, optional
      The size of the image. Default: 800
    title : str, optional
      The title of the plot. Default: 'Mollweide view'
    nest : bool, optional
      If True, ordering scheme is NESTED. Default: False (RING)
    min : float, optional
      The minimum range value
    max : float, optional
      The maximum range value
    flip : {'astro', 'geo'}, optional
      Defines the convention of projection : 'astro' (default, east towards left, west towards right)
      or 'geo' (east towards roght, west towards left)
    remove_dip : bool, optional
      If :const:`True`, remove the dipole+monopole
    remove_mono : bool, optional
      If :const:`True`, remove the monopole
    gal_cut : float, scalar, optional
      Symmetric galactic cut for the dipole/monopole fit.
      Removes points in latitude range [-gal_cut, +gal_cut]
    format : str, optional
      The format of the scale label. Default: '%g'
    """
    import pylab
    # create the figure (if interactive, it will open the window now)
    f=pylab.figure(fig,figsize=(10.5,5.4))
    extent = (0.02,0.25,0.56,0.72)
    # Starting to draw : turn interactive off
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if map is None:
            map = np.zeros(12)+np.inf
        map = pixelfunc.ma_to_array(map)
        ax=PA.HpxMollweideAxes(f,extent,coord=coord,rot=rot,
                               format=format,flipconv=flip)
        f.add_axes(ax)
        if remove_dip:
            map=pixelfunc.remove_dipole(map,gal_cut=gal_cut,
                                        nest=nest,copy=True,
                                        verbose=True)
        elif remove_mono:
            map=pixelfunc.remove_monopole(map,gal_cut=gal_cut,nest=nest,
                                          copy=True,verbose=True)
        ax.projmap(map,nest=nest,xsize=xsize,coord=coord,vmin=min,vmax=max,
                   cmap=cmap,norm=norm)
        im = ax.get_images()[0]
        b = im.norm.inverse(np.linspace(0,1,im.cmap.N+1))
        v = np.linspace(im.norm.vmin,im.norm.vmax,im.cmap.N)
        if matplotlib.__version__ >= '0.91.0':
            cb=f.colorbar(ax.get_images()[0],ax=ax,
                          orientation='horizontal',
                          shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                          pad=0.05,fraction=0.1,boundaries=b,values=v)
        else:
            # for older matplotlib versions, no ax kwarg
            cb=f.colorbar(ax.get_images()[0],orientation='horizontal',
                          shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                          pad=0.05,fraction=0.1,boundaries=b,values=v)
        ax.set_title(title)
        ax.text(0.86,0.05,ax.proj.coordsysstr,fontsize=14,
                fontweight='bold',transform=ax.transAxes)
        cb.ax.text(1.05,0.30,unit,fontsize=14,fontweight='bold',
                   transform=cb.ax.transAxes,ha='left',va='center')
        f.sca(ax)

        ## Gnomonic axes
        #extent = (0.02,0.25,0.56,0.72)
        g_xsize=600
        g_reso = 1.
        extent = (0.60,0.04,0.38,0.94)
        g_ax=PA.HpxGnomonicAxes(f,extent,coord=coord,rot=rot,
                                format=format,flipconv=flip)
        f.add_axes(g_ax)
        if remove_dip:
            map=pixelfunc.remove_dipole(map,gal_cut=gal_cut,nest=nest,copy=True)
        elif remove_mono:
            map=pixelfunc.remove_monopole(map,gal_cut=gal_cut,nest=nest,copy=True)
        g_ax.projmap(map,nest=nest,coord=coord,vmin=min,vmax=max,
                   xsize=g_xsize,ysize=g_xsize,reso=g_reso,cmap=cmap,norm=norm)
        im = g_ax.get_images()[0]
        b = im.norm.inverse(np.linspace(0,1,im.cmap.N+1))
        v = np.linspace(im.norm.vmin,im.norm.vmax,im.cmap.N)
        if matplotlib.__version__ >= '0.91.0':
            cb=f.colorbar(g_ax.get_images()[0],ax=g_ax,
                          orientation='horizontal',
                          shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                          pad=0.08,fraction=0.1,boundaries=b,values=v)
        else:
            cb=f.colorbar(g_ax.get_images()[0],orientation='horizontal',
                          shrink=0.5,aspect=25,ticks=PA.BoundaryLocator(),
                          pad=0.08,fraction=0.1,boundaries=b,values=v)
        g_ax.set_title(title)
        g_ax.text(-0.07,0.02,
                   "%g '/pix,   %dx%d pix"%(g_ax.proj.arrayinfo['reso'],
                                            g_ax.proj.arrayinfo['xsize'],
                                            g_ax.proj.arrayinfo['ysize']),
                   fontsize=12,verticalalignment='bottom',
                   transform=g_ax.transAxes,rotation=90)
        g_ax.text(-0.07,0.8,g_ax.proj.coordsysstr,fontsize=14,
                   fontweight='bold',rotation=90,transform=g_ax.transAxes)
        lon,lat = np.around(g_ax.proj.get_center(lonlat=True),g_ax._coordprec)
        g_ax.text(0.5,-0.03,'on (%g,%g)'%(lon,lat),
                  verticalalignment='center', horizontalalignment='center',
                  transform=g_ax.transAxes)
        cb.ax.text(1.05,0.30,unit,fontsize=14,fontweight='bold',
                   transform=cb.ax.transAxes,ha='left',va='center')
        # Add graticule info axes
        grat_ax = pylab.axes([0.25, 0.02, 0.22,0.25])
        grat_ax.axis('off')
        # Add help text
        help_ax = pylab.axes([0.02,0.02,0.22,0.25])
        help_ax.axis('off')
        t = help_ax.transAxes
        help_ax.text(0.1, 0.8, 'r/t .... zoom out/in',transform=t,va='baseline')
        help_ax.text(0.1, 0.65,'p/v .... print coord/val',transform=t,va='baseline')
        help_ax.text(0.1, 0.5, 'c ...... go to center',transform=t,va='baseline')
        help_ax.text(0.1, 0.35,'f ...... next color scale',transform=t,va='baseline')
        help_ax.text(0.1, 0.2, 'k ...... save current scale',transform=t,
                     va='baseline')
        help_ax.text(0.1, 0.05,'g ...... toggle graticule',transform=t,va='baseline')
        f.sca(g_ax)
        # Set up the zoom capability
        zt=ZoomTool(map,fig=f.number,nest=nest,cmap=cmap,norm=norm,coord=coord)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()

def set_g_clim(vmin,vmax):
    """Set min/max value of the gnomview part of a mollzoom.
    """
    import pylab
    f=pylab.gcf()
    if not hasattr(f,'zoomtool'):
        raise TypeError('The current figure has no zoomtool')
    f.zoomtool.save_min = vmin
    f.zoomtool.save_max = vmax
    f.zoomtool._range_status = 2
    f.zoomtool.draw_gnom()

class ZoomTool(object):
    """A class providing zoom capability to a figure containing a Mollweide
    and a Gnomonic axis.
    """
    def __init__(self,m,fig=None,nest=False,cmap=None,norm=None,
                 coord=None):
        """m: the map to be zoomed (already plotted in Mollweide view)
        fig: the figure to instrument (None->gcf())
        """
        import pylab
        self.reso_list = [0.05,0.1,0.2,0.3,0.5,0.75,1.,1.5,3.,5.,10.,15.,
                          30.,45.,60.]
        self._map = m
        self._nest = nest
        self._cmap = cmap
        self._norm = norm
        self._coord = coord
        self._range_status = 0 #0:normal, 1:global map min,max, 2: saved
        self.save_min = self.save_max = None
        self._graton = False
        # find min, max of map
        if isinstance(m, dict):
            if len(m) == 0:
                self._mapmin, self._mapmax = -1., 1.
            else:
                self._mapmin,self._mapmax = min(m.values()), max(m.values())
        else:
            mgood = m[m!=UNSEEN]
            if mgood.size == 0:
                self._mapmin, self._mapmax = -1., 1.
            else:
                self._mapmin,self._mapmax = mgood.min(),mgood.max()
            del mgood
        if fig is None: f=pylab.gcf()
        else: f=pylab.figure(fig)
        self.f = f
        f.zoomtool = self
        (self._moll_ax, self._moll_cb_ax,
         self._gnom_ax, self._gnom_cb_ax) = f.get_axes()[:4]
        self._grat_ax = f.get_axes()[4]
        self._text_reso, self._text_coord, self._text_loc = self._gnom_ax.texts
        self._xsize = self._gnom_ax.proj.arrayinfo['xsize']
        self._ysize = self._gnom_ax.proj.arrayinfo['ysize']
        try:
            self._reso_idx = self.reso_list.index(self._gnom_ax.proj._arrayinfo['reso'])
        except ValueError as e:
            raise ValueError('Resolution not in %s'%self.reso_list)
        self.zoomcenter, = self._moll_ax.plot([0],[0],'ok',
                                              mew=1,ms=15,alpha=0.1)
        self.zoomcenter2, = self._moll_ax.plot([0], [0], 'xr',
                                               ms=15, alpha=0.5, mew=3)
        self._text_range = self._gnom_ax.text(-0.4, -0.2, 'scale mode: loc',
                                               transform=
                                               self._gnom_ax.transAxes,
                                               va='baseline',
                                               ha='left')
        self.draw_gnom(0,0)
        self._connected = False
        self.connect_callbacks()
        
    def _zoom_on_click(self, ev):
        import pylab
        try:
            ax = ev.inaxes
            lon,lat = ax.get_lonlat(ev.xdata,ev.ydata)
            if np.isnan(lon) or np.isnan(lat):
                raise ValueError('invalid position')
            val = ax.get_value(ev.xdata,ev.ydata)
            self.lastval = val
            self._move_zoom_center(lon,lat)
            self.draw_gnom(lon,lat)            
        except Exception as s:
            self._move_zoom_center(0,0,False)
            pylab.draw_if_interactive()
            #print s
        return

    def _reso_on_key(self, ev):
        if ev.key == 'r':
            self._decrease_reso()
        elif ev.key == 't':
            self._increase_reso()
        elif ev.key == 'p':
            print('lon,lat = %.17g,%.17g'%(self.lon,self.lat))
        elif ev.key == 'c':
            self._move_zoom_center(0,0)
            self.draw_gnom(0,0)
        elif ev.key == 'v':
            print('val = %.17g'%(self.lastval))
        elif ev.key == 'f':
            self._range_status += 1
            self._range_status %= 3
            self.draw_gnom()
        elif ev.key == 'k':
            self.save_min = self._gnom_ax.images[0].norm.vmin
            self.save_max = self._gnom_ax.images[0].norm.vmax
        elif ev.key == 'g':
            if hasattr(self,'_graton') and self._graton == True:
                self._gnom_ax.delgraticules()
                self._moll_ax.delgraticules()
                self._graton = False
            else:
                (self._g_dpar, 
                 self._g_dmer) = self._gnom_ax.graticule(local=False,
                                                         verbose=False)
                (self._m_dpar, 
                 self._m_dmer) = self._moll_ax.graticule(verbose=False)
                self._graton = True
            self.draw_gnom()

    def _update_grat_info(self):
        self._grat_ax.cla()
        self._grat_ax.axis('off')
        if self._graton:
            a = self._grat_ax
            t = a.transAxes
            a.text(0.1, 0.8,  'moll. grat.:',transform=t,weight='bold')
            vdeg = np.floor(np.around(self._m_dpar/dtor,10))
            varcmin = (self._m_dpar/dtor-vdeg)*60.
            a.text(0.1, 0.65, "   -par: %d d %.2f '"%(vdeg,varcmin),
                   transform=t)
            vdeg = np.floor(np.around(self._m_dmer/dtor,10))
            varcmin = (self._m_dmer/dtor-vdeg)*60.
            a.text(0.1, 0.5,  "   -mer: %d d %.2f '"%(vdeg,varcmin),
                   transform=t)
            a.text(0.1, 0.35,  'gnom. grat.:',transform=t,weight='bold')
            vdeg = np.floor(np.around(self._g_dpar/dtor,10))
            varcmin = (self._g_dpar/dtor-vdeg)*60.
            a.text(0.1, 0.2,  "   -par: %d d %.2f '"%(vdeg,varcmin),
                   transform=t)
            vdeg = np.floor(np.around(self._g_dmer/dtor,10))
            varcmin = (self._g_dmer/dtor-vdeg)*60.
            a.text(0.1, 0.05, "   -mer: %d d %.2f '"%(vdeg,varcmin),
                   transform=t)
        
        
    def _increase_reso(self):
        if self._reso_idx > 0:
            self._reso_idx -= 1
            self.draw_gnom(self.lon,self.lat)

    def _decrease_reso(self):
        if self._reso_idx < len(self.reso_list)-1:
            self._reso_idx += 1
            self.draw_gnom(self.lon,self.lat)

    def get_reso(self):
        return self.reso_list[self._reso_idx]

    def connect_callbacks(self):
        if not self._connected:
            self._callbacks_id = []
            cid = self.f.canvas.mpl_connect('button_press_event',
                                            self._zoom_on_click)
            self._callbacks_id.append(cid)
            cid = self.f.canvas.mpl_connect('key_press_event',
                                            self._reso_on_key)
            self._callbacks_id.append(cid)
            self._connected = True

    def disconnect_callbacks(self):
        if self._connected:
            for cid in self._callbacks_id:
                self.figure.canvas.mpl_disconnect(cid)
        
    def _move_zoom_center(self, lon, lat, visible=True):
        # Move the zoom center marker.
        if self.zoomcenter:
            x,y = self._moll_ax.proj.ang2xy(lon,lat,lonlat=True)
            self.zoomcenter.set_xdata([x])
            self.zoomcenter.set_ydata([y])
            self.zoomcenter.set_visible(visible)
        if self.zoomcenter2:
            x,y = self._moll_ax.proj.ang2xy(lon,lat,lonlat=True)
            self.zoomcenter2.set_xdata([x])
            self.zoomcenter2.set_ydata([y])
            self.zoomcenter2.set_visible(visible)

    def draw_gnom(self,lon=None,lat=None):
        import pylab
        wasinteractive = pylab.isinteractive()
        pylab.ioff()
        try:
            # modify rot of the gnom_ax
            if lon is None:
                lon = self._lon
            else:
                self._lon = lon
            if lat is None:
                lat = self._lat
            else:
                self._lat = lat
            self._gnom_ax.proj.rotator._rots.pop()
            self._gnom_ax.proj.rotator._rots.append(R.normalise_rot((lon,lat),deg=True))
            self._gnom_ax.proj.rotator._update_matrix()
            if   self._range_status == 0:
                vmin=vmax = None
            elif self._range_status == 1:
                vmin,vmax = self._mapmin,self._mapmax
            elif self._range_status == 2:
                vmin,vmax = self.save_min, self.save_max
            self._gnom_ax.images.pop()
            self._gnom_ax.projmap(self._map,nest=self._nest,coord=self._coord,
                                  vmin=vmin,vmax=vmax,
                                  xsize=self._xsize,ysize=self._ysize,
                                  reso=self.get_reso(),
                                  cmap=self._cmap,
                                  norm=self._norm)
            if hasattr(self._gnom_ax, '_scatter_data'):
                l = [x for x in self._gnom_ax._scatter_data]
                #print l
                for sd in l:
                    s, input_data = sd
                    #print input_data
                    self._gnom_ax.collections.remove(s)
                    self._gnom_ax._scatter_data.remove(sd)
                    theta, phi, args, kwds = input_data
                    self._gnom_ax.projscatter(theta, phi = phi, *args, **kwds)
                del l
            if self._graton:
                self._gnom_ax.delgraticules()
                (self._g_dpar, 
                 self._g_dmer) = self._gnom_ax.graticule(local=False,
                                                         verbose=False)
            self._gnom_cb_ax.cla()
            im = self._gnom_ax.images[0]
            if matplotlib.__version__ >= '0.91.0':
                cb=self.f.colorbar(im,ax=self._gnom_ax,
                                   cax=self._gnom_cb_ax,orientation='horizontal',
                                   ticks=PA.BoundaryLocator())
            else:
                cb=self.f.colorbar(im,cax=self._gnom_cb_ax,
                                   orientation='horizontal',ticks=PA.BoundaryLocator())
            lon,lat = np.around(self._gnom_ax.proj.get_center(lonlat=True),
                                 self._gnom_ax._coordprec)
            self._text_loc.set_text('on (%g,%g)'%(lon,lat))
            reso = self._gnom_ax.proj.arrayinfo['reso']
            xsize = self._gnom_ax.proj.arrayinfo['xsize']
            ysize  = self._gnom_ax.proj.arrayinfo['ysize']
            self._text_reso.set_text("%g '/pix,   %dx%d pix"%
                                     (reso, xsize, ysize))
            mode = ['loc','map','sav'][self._range_status]
            self._text_range.set_text('scale mode: %s'%mode)
            self.lon,self.lat = lon,lat
            self._update_grat_info()
        except Exception as e:
            pass #print e
        finally:
            if wasinteractive:
                pylab.ion()
                pylab.draw()
                pylab.show()


healpy-1.10.3/healpy.egg-info/0000775000175000017500000000000013031130324016270 5ustar  zoncazonca00000000000000healpy-1.10.3/healpy.egg-info/PKG-INFO0000664000175000017500000000165413031130323017372 0ustar  zoncazonca00000000000000Metadata-Version: 1.1
Name: healpy
Version: 1.10.3
Summary: Healpix tools package for Python
Home-page: http://github.com/healpy
Author: C. Rosset, A. Zonca
Author-email: cyrille.rosset@apc.univ-paris-diderot.fr
License: GPLv2
Description: UNKNOWN
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
Classifier: Operating System :: POSIX
Classifier: Programming Language :: C++
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Topic :: Scientific/Engineering :: Astronomy
Classifier: Topic :: Scientific/Engineering :: Visualization
healpy-1.10.3/healpy.egg-info/SOURCES.txt0000664000175000017500000003714013031130324020161 0ustar  zoncazonca00000000000000CHANGELOG.rst
CITATION
COPYING
INSTALL.rst
MANIFEST.in
README.rst
ez_setup.py
run_pykg_config.py
setup.py
cfitsio/CMakeLists.txt
cfitsio/FindPthreads.cmake
cfitsio/License.txt
cfitsio/Makefile.in
cfitsio/README
cfitsio/README.MacOS
cfitsio/README.win
cfitsio/README_OLD.win
cfitsio/buffers.c
cfitsio/cfileio.c
cfitsio/cfitsio.pc.in
cfitsio/cfitsio_mac.sit.hqx
cfitsio/cfortran.h
cfitsio/checksum.c
cfitsio/config.guess
cfitsio/config.sub
cfitsio/configure
cfitsio/configure.in
cfitsio/cookbook.c
cfitsio/cookbook.f
cfitsio/drvrfile.c
cfitsio/drvrgsiftp.c
cfitsio/drvrgsiftp.h
cfitsio/drvrmem.c
cfitsio/drvrnet.c
cfitsio/drvrsmem.c
cfitsio/drvrsmem.h
cfitsio/editcol.c
cfitsio/edithdu.c
cfitsio/eval.l
cfitsio/eval.y
cfitsio/eval_defs.h
cfitsio/eval_f.c
cfitsio/eval_l.c
cfitsio/eval_tab.h
cfitsio/eval_y.c
cfitsio/f77.inc
cfitsio/f77_wrap.h
cfitsio/f77_wrap1.c
cfitsio/f77_wrap2.c
cfitsio/f77_wrap3.c
cfitsio/f77_wrap4.c
cfitsio/fits_hcompress.c
cfitsio/fits_hdecompress.c
cfitsio/fitscopy.c
cfitsio/fitscore.c
cfitsio/fitsio.h
cfitsio/fitsio2.h
cfitsio/fpack.c
cfitsio/fpack.h
cfitsio/fpackutil.c
cfitsio/funpack.c
cfitsio/getcol.c
cfitsio/getcolb.c
cfitsio/getcold.c
cfitsio/getcole.c
cfitsio/getcoli.c
cfitsio/getcolj.c
cfitsio/getcolk.c
cfitsio/getcoll.c
cfitsio/getcols.c
cfitsio/getcolsb.c
cfitsio/getcolui.c
cfitsio/getcoluj.c
cfitsio/getcoluk.c
cfitsio/getkey.c
cfitsio/group.c
cfitsio/group.h
cfitsio/grparser.c
cfitsio/grparser.h
cfitsio/histo.c
cfitsio/imcompress.c
cfitsio/imcopy.c
cfitsio/install-sh
cfitsio/iraffits.c
cfitsio/iter_a.c
cfitsio/iter_a.f
cfitsio/iter_a.fit
cfitsio/iter_b.c
cfitsio/iter_b.f
cfitsio/iter_b.fit
cfitsio/iter_c.c
cfitsio/iter_c.f
cfitsio/iter_c.fit
cfitsio/iter_image.c
cfitsio/iter_var.c
cfitsio/longnam.h
cfitsio/makefile.bc
cfitsio/makefile.vcc
cfitsio/makepc.bat
cfitsio/modkey.c
cfitsio/pliocomp.c
cfitsio/putcol.c
cfitsio/putcolb.c
cfitsio/putcold.c
cfitsio/putcole.c
cfitsio/putcoli.c
cfitsio/putcolj.c
cfitsio/putcolk.c
cfitsio/putcoll.c
cfitsio/putcols.c
cfitsio/putcolsb.c
cfitsio/putcolu.c
cfitsio/putcolui.c
cfitsio/putcoluj.c
cfitsio/putcoluk.c
cfitsio/putkey.c
cfitsio/quantize.c
cfitsio/region.c
cfitsio/region.h
cfitsio/ricecomp.c
cfitsio/sample.tpl
cfitsio/scalnull.c
cfitsio/smem.c
cfitsio/speed.c
cfitsio/swapproc.c
cfitsio/testf77.f
cfitsio/testf77.out
cfitsio/testf77.std
cfitsio/testprog.c
cfitsio/testprog.out
cfitsio/testprog.std
cfitsio/testprog.tpt
cfitsio/vmsieee.c
cfitsio/wcssub.c
cfitsio/wcsutil.c
cfitsio/winDumpExts.mak
cfitsio/windumpexts.c
cfitsio/zlib/adler32.c
cfitsio/zlib/crc32.c
cfitsio/zlib/crc32.h
cfitsio/zlib/deflate.c
cfitsio/zlib/deflate.h
cfitsio/zlib/infback.c
cfitsio/zlib/inffast.c
cfitsio/zlib/inffast.h
cfitsio/zlib/inffixed.h
cfitsio/zlib/inflate.c
cfitsio/zlib/inflate.h
cfitsio/zlib/inftrees.c
cfitsio/zlib/inftrees.h
cfitsio/zlib/trees.c
cfitsio/zlib/trees.h
cfitsio/zlib/uncompr.c
cfitsio/zlib/zcompress.c
cfitsio/zlib/zconf.h
cfitsio/zlib/zlib.h
cfitsio/zlib/zuncompress.c
cfitsio/zlib/zutil.c
cfitsio/zlib/zutil.h
healpixsubmodule/src/cxx/autotools/Makefile.am
healpixsubmodule/src/cxx/autotools/Makefile.in
healpixsubmodule/src/cxx/autotools/aclocal.m4
healpixsubmodule/src/cxx/autotools/ar-lib
healpixsubmodule/src/cxx/autotools/config.guess
healpixsubmodule/src/cxx/autotools/config.sub
healpixsubmodule/src/cxx/autotools/configure
healpixsubmodule/src/cxx/autotools/configure.ac
healpixsubmodule/src/cxx/autotools/depcomp
healpixsubmodule/src/cxx/autotools/install-sh
healpixsubmodule/src/cxx/autotools/ltmain.sh
healpixsubmodule/src/cxx/autotools/make_release
healpixsubmodule/src/cxx/autotools/missing
healpixsubmodule/src/cxx/autotools/test-driver
healpixsubmodule/src/cxx/autotools/Healpix_cxx/Healpix_cxx.dox
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm2map_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm2map_cxx.par.txt
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm2map_cxx_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_fitsio.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_fitsio.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_healpix_tools.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_healpix_tools.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_powspec_tools.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/alm_powspec_tools.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/anafast_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/anafast_cxx.par.txt
healpixsubmodule/src/cxx/autotools/Healpix_cxx/anafast_cxx_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/calc_powspec.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/calc_powspec_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_base.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_base.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_data_io.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_data_io.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_map.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_map.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_map_fitsio.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_map_fitsio.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_tables.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/healpix_tables.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/hotspots_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/hotspots_cxx_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/hpxtest.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/map2tga.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/map2tga.par.txt
healpixsubmodule/src/cxx/autotools/Healpix_cxx/map2tga_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/median_filter_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/median_filter_cxx_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc_fitsio.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc_fitsio.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc_query.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/moc_query.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/mult_alm.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/mult_alm.par.txt
healpixsubmodule/src/cxx/autotools/Healpix_cxx/mult_alm_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/planck.make
healpixsubmodule/src/cxx/autotools/Healpix_cxx/powspec.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/powspec.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/powspec_fitsio.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/powspec_fitsio.h
healpixsubmodule/src/cxx/autotools/Healpix_cxx/rotalm_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/smoothing_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/smoothing_cxx.par.txt
healpixsubmodule/src/cxx/autotools/Healpix_cxx/smoothing_cxx_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/syn_alm_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/syn_alm_cxx.par.txt
healpixsubmodule/src/cxx/autotools/Healpix_cxx/syn_alm_cxx_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/udgrade_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/udgrade_cxx_module.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/udgrade_harmonic_cxx.cc
healpixsubmodule/src/cxx/autotools/Healpix_cxx/udgrade_harmonic_cxx_module.cc
healpixsubmodule/src/cxx/autotools/c_utils/c_utils.c
healpixsubmodule/src/cxx/autotools/c_utils/c_utils.h
healpixsubmodule/src/cxx/autotools/c_utils/planck.make
healpixsubmodule/src/cxx/autotools/c_utils/sse_utils.h
healpixsubmodule/src/cxx/autotools/c_utils/walltime_c.c
healpixsubmodule/src/cxx/autotools/c_utils/walltime_c.h
healpixsubmodule/src/cxx/autotools/cxxsupport/alloc_utils.h
healpixsubmodule/src/cxx/autotools/cxxsupport/announce.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/announce.h
healpixsubmodule/src/cxx/autotools/cxxsupport/arr.h
healpixsubmodule/src/cxx/autotools/cxxsupport/bstream.h
healpixsubmodule/src/cxx/autotools/cxxsupport/colour.h
healpixsubmodule/src/cxx/autotools/cxxsupport/compress_utils.h
healpixsubmodule/src/cxx/autotools/cxxsupport/cxxsupport.dox
healpixsubmodule/src/cxx/autotools/cxxsupport/datatypes.h
healpixsubmodule/src/cxx/autotools/cxxsupport/error_handling.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/error_handling.h
healpixsubmodule/src/cxx/autotools/cxxsupport/fftpack_support.h
healpixsubmodule/src/cxx/autotools/cxxsupport/fitshandle.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/fitshandle.h
healpixsubmodule/src/cxx/autotools/cxxsupport/font_data.inc
healpixsubmodule/src/cxx/autotools/cxxsupport/geom_utils.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/geom_utils.h
healpixsubmodule/src/cxx/autotools/cxxsupport/levels_facilities.h
healpixsubmodule/src/cxx/autotools/cxxsupport/linear_map.h
healpixsubmodule/src/cxx/autotools/cxxsupport/ls_image.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/ls_image.h
healpixsubmodule/src/cxx/autotools/cxxsupport/lsconstants.h
healpixsubmodule/src/cxx/autotools/cxxsupport/math_utils.h
healpixsubmodule/src/cxx/autotools/cxxsupport/openmp_support.h
healpixsubmodule/src/cxx/autotools/cxxsupport/paramfile.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/paramfile.h
healpixsubmodule/src/cxx/autotools/cxxsupport/planck.make
healpixsubmodule/src/cxx/autotools/cxxsupport/planck_rng.h
healpixsubmodule/src/cxx/autotools/cxxsupport/pointing.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/pointing.h
healpixsubmodule/src/cxx/autotools/cxxsupport/rangeset.h
healpixsubmodule/src/cxx/autotools/cxxsupport/rotmatrix.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/rotmatrix.h
healpixsubmodule/src/cxx/autotools/cxxsupport/safe_cast.h
healpixsubmodule/src/cxx/autotools/cxxsupport/safe_ptr.h
healpixsubmodule/src/cxx/autotools/cxxsupport/share_utils.h
healpixsubmodule/src/cxx/autotools/cxxsupport/sort_utils.h
healpixsubmodule/src/cxx/autotools/cxxsupport/sse_utils_cxx.h
healpixsubmodule/src/cxx/autotools/cxxsupport/string_utils.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/string_utils.h
healpixsubmodule/src/cxx/autotools/cxxsupport/trafos.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/trafos.h
healpixsubmodule/src/cxx/autotools/cxxsupport/vec3.h
healpixsubmodule/src/cxx/autotools/cxxsupport/walltimer.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/walltimer.h
healpixsubmodule/src/cxx/autotools/cxxsupport/wigner.cc
healpixsubmodule/src/cxx/autotools/cxxsupport/wigner.h
healpixsubmodule/src/cxx/autotools/cxxsupport/xcomplex.h
healpixsubmodule/src/cxx/autotools/libfftpack/README
healpixsubmodule/src/cxx/autotools/libfftpack/bluestein.c
healpixsubmodule/src/cxx/autotools/libfftpack/bluestein.h
healpixsubmodule/src/cxx/autotools/libfftpack/fftpack.c
healpixsubmodule/src/cxx/autotools/libfftpack/fftpack.h
healpixsubmodule/src/cxx/autotools/libfftpack/fftpack_inc.c
healpixsubmodule/src/cxx/autotools/libfftpack/libfftpack.dox
healpixsubmodule/src/cxx/autotools/libfftpack/ls_fft.c
healpixsubmodule/src/cxx/autotools/libfftpack/ls_fft.h
healpixsubmodule/src/cxx/autotools/libfftpack/planck.make
healpixsubmodule/src/cxx/autotools/libsharp/libsharp.dox
healpixsubmodule/src/cxx/autotools/libsharp/planck.make
healpixsubmodule/src/cxx/autotools/libsharp/sharp.c
healpixsubmodule/src/cxx/autotools/libsharp/sharp.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_almhelpers.c
healpixsubmodule/src/cxx/autotools/libsharp/sharp_almhelpers.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_complex_hacks.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_core.c
healpixsubmodule/src/cxx/autotools/libsharp/sharp_core.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_core_inc.c
healpixsubmodule/src/cxx/autotools/libsharp/sharp_core_inc2.c
healpixsubmodule/src/cxx/autotools/libsharp/sharp_core_inchelper.c
healpixsubmodule/src/cxx/autotools/libsharp/sharp_cxx.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_geomhelpers.c
healpixsubmodule/src/cxx/autotools/libsharp/sharp_geomhelpers.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_internal.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_lowlevel.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_vecsupport.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_vecutil.h
healpixsubmodule/src/cxx/autotools/libsharp/sharp_ylmgen_c.c
healpixsubmodule/src/cxx/autotools/libsharp/sharp_ylmgen_c.h
healpixsubmodule/src/cxx/autotools/m4/libtool.m4
healpixsubmodule/src/cxx/autotools/m4/ltoptions.m4
healpixsubmodule/src/cxx/autotools/m4/ltsugar.m4
healpixsubmodule/src/cxx/autotools/m4/ltversion.m4
healpixsubmodule/src/cxx/autotools/m4/lt~obsolete.m4
healpixsubmodule/src/cxx/autotools/m4/m4_ax_create_pkgconfig_info.m4
healpy/__init__.py
healpy/cookbook.py
healpy/fitsfunc.py
healpy/newvisufunc.py
healpy/pixelfunc.py
healpy/projaxes.py
healpy/projector.py
healpy/rotator.py
healpy/sphtfunc.py
healpy/version.py
healpy/visufunc.py
healpy/zoomtool.py
healpy.egg-info/PKG-INFO
healpy.egg-info/SOURCES.txt
healpy.egg-info/dependency_links.txt
healpy.egg-info/requires.txt
healpy.egg-info/top_level.txt
healpy/data/pixel_window_n0002.fits
healpy/data/pixel_window_n0004.fits
healpy/data/pixel_window_n0008.fits
healpy/data/pixel_window_n0016.fits
healpy/data/pixel_window_n0032.fits
healpy/data/pixel_window_n0064.fits
healpy/data/pixel_window_n0128.fits
healpy/data/pixel_window_n0256.fits
healpy/data/pixel_window_n0512.fits
healpy/data/pixel_window_n1024.fits
healpy/data/pixel_window_n2048.fits
healpy/data/pixel_window_n4096.fits
healpy/data/pixel_window_n8192.fits
healpy/data/totcls.dat
healpy/data/weight_ring_n00002.fits
healpy/data/weight_ring_n00004.fits
healpy/data/weight_ring_n00008.fits
healpy/data/weight_ring_n00016.fits
healpy/data/weight_ring_n00032.fits
healpy/data/weight_ring_n00064.fits
healpy/data/weight_ring_n00128.fits
healpy/data/weight_ring_n00256.fits
healpy/data/weight_ring_n00512.fits
healpy/data/weight_ring_n01024.fits
healpy/data/weight_ring_n02048.fits
healpy/data/weight_ring_n04096.fits
healpy/data/weight_ring_n08192.fits
healpy/src/_common.pxd
healpy/src/_healpy_fitsio_lib.cc
healpy/src/_healpy_pixel_lib.cc
healpy/src/_healpy_sph_transform_lib.cc
healpy/src/_healpy_utils.h
healpy/src/_pixelfunc.cpp
healpy/src/_pixelfunc.pyx
healpy/src/_query_disc.cpp
healpy/src/_query_disc.pyx
healpy/src/_sphtools.cpp
healpy/src/_sphtools.pyx
healpy/test/__init__.py
healpy/test/test_doctest_cython.py
healpy/test/test_fitsfunc.py
healpy/test/test_pixelfunc.py
healpy/test/test_query_disc.py
healpy/test/test_sphtfunc.py
healpy/test/test_spinfunc.py
healpy/test/test_visufunc.py
healpy/test/data/anafast_3_11_config_test_anafast.par
healpy/test/data/anafast_3_11_config_test_anafast_nomask.par
healpy/test/data/anafast_3_11_config_test_anafast_xspectra.par
healpy/test/data/cl_wmap_band_iqumap_r9_7yr_WVxspec_v4_udgraded32_II_lmax64_rmmono_3iter.fits
healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter.fits
healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_II_lmax64_rmmono_3iter_nomask.fits
healpy/test/data/cl_wmap_band_iqumap_r9_7yr_W_v4_udgraded32_IQU_lmax64_rmmono_3iter.fits
healpy/test/data/gaussbeam_10arcmin_lmax512_pol.fits
healpy/test/data/map_synfast_seed12345.fits
healpy/test/data/smoothing_3_11_config_test_smoothing_masked.par
healpy/test/data/smoothing_3_11_config_test_smoothing_notmasked.par
healpy/test/data/synfast_3_11_config_test_synfast.par
healpy/test/data/wmap_band_iqumap_r9_7yr_V_v4_udgraded32.fits
healpy/test/data/wmap_band_iqumap_r9_7yr_V_v4_udgraded32_masked.fits
healpy/test/data/wmap_band_iqumap_r9_7yr_W_v4_udgraded32.fits
healpy/test/data/wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked.fits
healpy/test/data/wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked_smoothed10deg_fortran.fits
healpy/test/data/wmap_band_iqumap_r9_7yr_W_v4_udgraded32_smoothed10deg_fortran.fits
healpy/test/data/wmap_temperature_analysis_mask_r9_7yr_v4_udgraded32.fitshealpy-1.10.3/healpy.egg-info/dependency_links.txt0000664000175000017500000000000113031130323022335 0ustar  zoncazonca00000000000000
healpy-1.10.3/healpy.egg-info/requires.txt0000664000175000017500000000003513031130323020665 0ustar  zoncazonca00000000000000matplotlib
numpy
six
astropy
healpy-1.10.3/healpy.egg-info/top_level.txt0000664000175000017500000000000713031130323021016 0ustar  zoncazonca00000000000000healpy
healpy-1.10.3/CHANGELOG.rst0000664000175000017500000001027013010376214015344 0ustar  zoncazonca00000000000000Release 1.10.1, 8 Nov 2016

* Removed support for Python 2.6
* Implemented Lambert azimuthal equal-area projection 
* Bugfix: write multiple alms 
* Depend on `astropy` instead of `pyfits` 

Release 1.9.1, 17 Nov 2015, Last version to support Python 2.6

* Remove C++ 11 features 
* Streamlined setup.py 
* Plotting fixes for Python 3 , 
* Numpy 1.10 fix 

Release 1.9.0, 17 Sep 2015

* updated healpix CXX to 786 (trunk) 
* drop support for Python 2.6 
* option to read all fields with `read_map` 
* `write_map` and `read_map` support for partial sky maps 
* Allow `read_map` to also take an HDUList or HDU instance 

Release 1.8.6, 23 Apr 2015

* Renamed `get_neighbours` to `get_interp_weights` 
* Updated HEALPix C++ to fix bug in `query_disc` 

Release 1.8.4, 16 Jan 2015

* Fixed another permission issue on install-sh

Release 1.8.3, 16 Jan 2015

* Fix permission issue in the release tarball 

Release 1.8.2, 13 Jan 2015

* Several fixes in the build process
* Support for `astropy.fits` 

Release 1.8.1, 22 Jun 2014 

* Added `common.pxd` to source tarball
* Check that nside is less than 2^30 

Release 1.8.0, 21 Jun 2014 

* Python 3 support 
* Fixed bug in `get_interpol_ring`: 
* Performance improvements in `_query_disc.pyx`: 

Release 1.7.4, 26 Feb 2014 

* Fix bug for MAC OS X build 

Release 1.7.3, 28 Jan 2014 

* Minor cleanup for submitting debian package

Release 1.7.2, 27 Jan 2014 

* now package does not require autotools, fixes #155

Release 1.7.1, 23 Jan 2014 

* bugfix for Anaconda/Canopy on MAC OSX #152, #153
* fixed packaging issue #154

Release 1.7.0, 14 Jan 2014 

* rewritten spherical armonics unit tests, now it uses low res maps included in the repository
* fix in HEALPix C++ build flags allows easier install on MAC-OSX and other python environments (e.g. anaconda)
* orthview: orthografic projection
* fixed bug in monopole removal in anafast

Release 1.6.3, 26 Aug 2013:

* updated C++ sources to 3.11
* verbose=True default for most functions

Release 1.6.2, 11 Jun 2013:

* ez_setup, switch from distribute to the new setuptools

Release 1.6.0, 15th March 2013:

* support for NSIDE>8192, this broke compatibility with 32bit systems
* using the new autotools based build system of healpix_cxx
* pkg-config based install for cfitsio and healpix_cxx
* common definition file for cython modules
* test build script
* new matplotlib based mollview in healpy.newvisufunc

Release 1.5.0, 16th January 2013:

* Healpix C++ sources and cython compiled files removed from the repository,
they are however added for the release tarballs
* Added back support for CFITSIO_EXT_INC and CFITSIO_EXT_LIB, but with
same definition of HealPix
* gauss_beam: gaussian beam transfer function

Release 1.4.1, 5th November 2012:

* Removed support for CFITSIO_EXT_INC and CFITSIO_EXT_LIB
* Support for linking with libcfitsio.so or libcfitsio.dyn

Release 1.4, 4th September 2012:

* Support for building using an external HealPix library, by Leo Singer
* fixes on masked array maps

Release 1.3, 21th August 2012:

* all functions covered with unit testing or doctests
* rewrote setup.py using distutils, by Leo Singer
* all functions accept and return masked arrays created with `hp.ma`
* `read_cl` and `write_cl` support polarization
* matplotlib imported only after first plotting function is called
healpy-1.10.3/CITATION0000664000175000017500000000222313010374155014461 0ustar  zoncazonca00000000000000Use of the HEALPix/healpy software package should be explicitly acknowledged in all publications in the following form:

* an acknowledgment statement – "Some of the results in this paper have been derived using the HEALPix (K.M. Górski et al., 2005, ApJ, 622, p759) package"
* at the first use of the HEALPix acronym, a footnote placed in the main body of the paper referring to the HEALPix website – currently http://healpix.sourceforge.net

BibTeX record:

@ARTICLE{2005ApJ...622..759G,
   author = {{G{\'o}rski}, K.~M. and {Hivon}, E. and {Banday}, A.~J. and 
	{Wandelt}, B.~D. and {Hansen}, F.~K. and {Reinecke}, M. and 
	{Bartelmann}, M.},
    title = "{HEALPix: A Framework for High-Resolution Discretization and Fast Analysis of Data Distributed on the Sphere}",
  journal = {\apj},
   eprint = {arXiv:astro-ph/0409513},
 keywords = {Cosmology: Cosmic Microwave Background, Cosmology: Observations, Methods: Statistical},
     year = 2005,
    month = apr,
   volume = 622,
    pages = {759-771},
      doi = {10.1086/427976},
   adsurl = {http://adsabs.harvard.edu/abs/2005ApJ...622..759G},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}
healpy-1.10.3/COPYING0000664000175000017500000004313313010374155014364 0ustar  zoncazonca00000000000000		    GNU GENERAL PUBLIC LICENSE
		       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

			    Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

			    NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

		     END OF TERMS AND CONDITIONS

	    How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    
    Copyright (C)   

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA


Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

  , 1 April 1989
  Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.
healpy-1.10.3/INSTALL.rst0000664000175000017500000001004613010375075015170 0ustar  zoncazonca00000000000000Installation procedure for Healpy
=================================

Requirements
------------

Healpy depends on the HEALPix C++ and cfitsio C libraries. Source code for both
is included with Healpy and is built automatically, so you do not need to
install them yourself.
Only Linux and MAC OS X are supported, not Windows.

Binary installation with conda
-----------------------

The `OpenAstronomy `_ collaboration provides a `conda
channel `_ with a pre-compiled version of ``healpy``
for linux 64bit and MAC OS X platforms, you can install it in Anaconda with:

    conda install -c openastronomy healpy

Source installation with Pip
---------------------------

It is possible to build the latest ``healpy`` with `pip `_ ::

    pip install --user healpy

If you have installed with ``pip``, you can keep your installation up to date
by upgrading from time to time::

    pip install --user --upgrade healpy

Installation on Mac OS with MacPorts
-------------------------------------------------

If you are using a Mac and have the `MacPorts `_
package manager, it's even easer to install Healpy with::

    sudo port install py27-healpy

Binary `apt-get` style packages are also available in the development versions of 
`Debian (sid) `_ and
`Ubuntu (utopic) `_.

Almost-as-quick installation from official source release
---------------------------------------------------------

Healpy is also available in the
`Python Package Index (PyPI) `_. You can
download it with::

    curl -O https://pypi.python.org/packages/source/h/healpy/healpy-1.7.4.tar.gz

and build it with::

    tar -xzf healpy-1.7.4.tar.gz
    pushd healpy-1.7.4
    python setup.py install --user
    popd

If everything goes fine, you can test it::

    python
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> import healpy as hp 
>>> hp.mollview(np.arange(12))
>>> plt.show()

or run the test suite with nose::

    cd healpy-1.7.4 && python setup.py test

Building against external Healpix and cfitsio
---------------------------------------------

Healpy uses pkg-config to detect the presence of the Healpix and cfitsio
libraries. pkg-config is available on most systems. If you do not have
pkg-config installed, then Healpy will download and use (but not install) a
Python clone called pykg-config.

If you want to provide your own external builds of Healpix and cfitsio, then
download the following packages:

* `pkg-config `_

* `HEALPix
  `_
  autotools-style C++ package

* `cfitsio `_

If you are going to install the packages in a nonstandard location (say,
``--prefix=/path/to/local``), then you should set the environment variable
``PKG_CONFIG_PATH=/path/to/local/lib/pkgconfig`` when building. No other
environment variable settings are necessary, and you do not need to set
``PKG_CONFIG_PATH`` to use Healpy after you have built it.

Then, unpack each of the above packages and build them with the usual
``configure; make; make install`` recipe.

Development install
-------------------

Developers building from a snapshot of the github repository need:

* ``autoconf`` and ``libtool`` (in Debian or Ubuntu:
  ``sudo apt-get install autoconf automake libtool pkg-config``)

* `cython` > 0.16

* run ``git submodule init`` and ``git submodule update`` to get the bundled
  HEALPix sources

the best way to install healpy if you plan to develop is to build the C++
extensions in place with::

    python setup.py build_ext --inplace

then add the ``healpy/healpy`` folder to your ``PYTHONPATH``.

Clean
-----

When you run "python setup.py", temporary build products are placed in the
"build" directory. If you want to clean out and remove the ``build`` directory,
then run::

    python setup.py clean --all
healpy-1.10.3/MANIFEST.in0000664000175000017500000000117613010374155015070 0ustar  zoncazonca00000000000000recursive-include healpy/data *.fits
recursive-include healpy/test/data *
exclude healpy/test/data/ipython*
exclude cfitsio/*pdf cfitsio/*ps cfitsio/*doc cfitsio/*tex
prune cfitsio/docs
exclude *.so
exclude *.a
exclude .gitignore .gitmodules .travis.yml clean.sh
include COPYING CITATION INSTALL.rst README.rst MANIFEST.in CHANGELOG.rst ez_setup.py run_pykg_config.py
include healpy/src/_healpy_utils.h
include healpy/src/_query_disc.cpp
include healpy/src/_sphtools.cpp
include healpy/src/_pixelfunc.cpp
include healpy/src/_common.pxd
include healpy/src/_query_disc.pyx
include healpy/src/_sphtools.pyx
include healpy/src/_pixelfunc.pyx
healpy-1.10.3/README.rst0000664000175000017500000001422513010375075015022 0ustar  zoncazonca00000000000000====================================
Healpy, a python wrapper for healpix
====================================

.. image:: https://travis-ci.org/healpy/healpy.png?branch=master
   :target: https://travis-ci.org/healpy/healpy

.. image:: https://readthedocs.org/projects/healpy/badge/?version=latest
   :target: https://readthedocs.org/projects/healpy/?badge=latest
   :alt: Documentation Status

Description
-----------

Healpy provides a python package to manipulate healpix maps. It is based on the
standard numeric and visualisation tools for Python, Numpy and matplotlib.

To find more information about HEALPix, please visit its home page at
http://healpix.sourceforge.net/.

The documentation can be found at https://healpy.readthedocs.io, tutorial at
https://healpy.readthedocs.io/en/latest/tutorial.html.

Characteristics
---------------

* pixelisation manipulation (ang2pix, pix2ang, *etc.*)

* spherical harmonic transforms (map2alm, alm2map, synfast, anafast, *etc.*
  both for temperature and polarisation)

* plotting capabilities (mollweide and gnomonic projection)

* reading and writing of HEALPix FITS maps and alm

Requirements
------------

* `Python `_ 2.7, 3.2, 3.3, 3.4 or 3.5

* `Numpy `_ (tested with version >=1.5.0)

* `Matplotlib `_ 

* Python development package is required for some distribution (e.g.,
  python-dev package for Ubuntu)

* `Astropy `_

Quick installation with Pip
---------------------------

The quickest way to install Healpy is with `pip `_
(>= 1.4.2), which automatically fetches the latest version of Healpy and any
missing dependencies::

    pip install --user healpy

If you have installed with ``pip``, you can keep your installation up to date
by upgrading from time to time::

    pip install --user --upgrade healpy

See `INSTALL.rst `_
for further details and other installation options.

Optional
--------

Healpy depends on the HEALPix C++ and cfitsio C libraries. Source code is
include with Healpy and you do not have to install them separately.

However, if you have them installed already, Healpy should detect and reuse
them instead of building them from source. To use your own installations of
HEALPix and cfitsio, you will also need:

* `pkg-config `_

* `HEALPix
  `_
  autotools-style C++ package

* `cfitsio `_

See `INSTALL.rst `_
for further instructions.

Known issues
------------

* Building with OpenMP support: the underlying HEALPix C++ library can be built
  to use `OpenMP `_ to speed up some operations on
  systems with multiple cores. Most, but not all, modern C/C++ compilers support
  OpenMP, `the notable exception being clang `_.

  If your Healpy build fails with an error message about being unable to link
  against `-lgomp`, then this typically means that Healpy detected an
  already-installed HEALPix C++ library that was built with OpenMP support, but
  you are trying to build Healpy with a compiler that does not support OpenMP.
  Try cleaning the build with `python setup.py clean --all`, and set the
  environment variables `CC` and `CXX` to point to an OpenMP-capable compiler,
  such as gcc/g++.

* Healpy does not currently support Windows.
  See https://github.com/healpy/healpy/issues/25.

* Incompatibility with ``cfitisio`` from ``HEASOFT``: due to a conflict of
  header file names it is currently not possible to use the cfitsio library
  provided with the HEASOFT package for compilation of HEALPix C++. HEASOFT's
  include directory contains a file called "rotmatrix.h" which clashes with
  HEALPix's own rotmatrix.h.

* Compilation problems in the C++ package: some gcc versions (we have reports
  for 4.4.5 and 4.4.6) crash with an internal compiler error during compilation
  of libsharp. Unfortunately we have not found a workaround for this compiler
  problem. To our knowledge, it has been fixed in gcc 4.4.7 and in the 4.5.x
  and newer versions.

* Healpy pixel functions, e.g. ``ang2pix``, do not support 32-bit platforms.
  See https://github.com/healpy/healpy/issues/194.

Support
-------

For specific *HOWTO* questions please create a question on StackOverflow_ and
tag it with the `healpy` tag, so that answers will be easily searchable on
google.

If you think you found a bug or you have install issues, open an issue on GitHub:
https://github.com/healpy/healpy/issues

For more general discussion, you can write to the healpy mailing list:
https://groups.google.com/d/forum/healpy

.. _StackOverflow: http://stackoverflow.com/questions/ask

Contribute
----------

Project development takes place on github, http://github.com/healpy/healpy,
please open an issue over there for reporting bugs or suggest improvements.
Collaboration is very welcome, just fork the project on github and send pull
requests back to the main repository.

Developers
----------
Core developers:

* Cyrille Rosset
* Andrea Zonca
* Martin Reinecke
* Leo Singer 

List of contributors: https://github.com/healpy/healpy/graphs/contributors

Acknowledgements
----------------

Note that, as stated `here `_
publications based on work using the HEALPix software package should include
both of the following:

1. an acknowledgment statement: "Some of the results in this paper have been
   derived using the HEALPix (Górski et al., 2005) package". The complete
   reference is:

      Górski, K.M., E. Hivon, A.J. Banday, B.D. Wandelt, F.K. Hansen,
      M. Reinecke, and M. Bartelmann, HEALPix: A Framework for
      High-resolution Discretization and Fast Analysis of Data
      Distributed on the Sphere, Ap.J., 622, 759-771, 2005.

2. at the first use of the HEALPix acronym, a footnote placed in the main body
   of the paper referring to the HEALPix web site, currently
   http://healpix.sf.net

As healpy is based on HEALPix Software (the C++ library), the same
condition applies to it.
healpy-1.10.3/ez_setup.py0000664000175000017500000002625213010374155015544 0ustar  zoncazonca00000000000000#!/usr/bin/env python

"""
Setuptools bootstrapping installer.

Run this script to install or upgrade setuptools.
"""

import os
import shutil
import sys
import tempfile
import zipfile
import optparse
import subprocess
import platform
import textwrap
import contextlib
import warnings

from distutils import log

try:
    from urllib.request import urlopen
except ImportError:
    from urllib2 import urlopen

try:
    from site import USER_SITE
except ImportError:
    USER_SITE = None

DEFAULT_VERSION = "14.3.1"
DEFAULT_URL = "https://pypi.python.org/packages/source/s/setuptools/"
DEFAULT_SAVE_DIR = os.curdir


def _python_cmd(*args):
    """
    Execute a command.

    Return True if the command succeeded.
    """
    args = (sys.executable,) + args
    return subprocess.call(args) == 0


def _install(archive_filename, install_args=()):
    """Install Setuptools."""
    with archive_context(archive_filename):
        # installing
        log.warn('Installing Setuptools')
        if not _python_cmd('setup.py', 'install', *install_args):
            log.warn('Something went wrong during the installation.')
            log.warn('See the error message above.')
            # exitcode will be 2
            return 2


def _build_egg(egg, archive_filename, to_dir):
    """Build Setuptools egg."""
    with archive_context(archive_filename):
        # building an egg
        log.warn('Building a Setuptools egg in %s', to_dir)
        _python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)
    # returning the result
    log.warn(egg)
    if not os.path.exists(egg):
        raise IOError('Could not build the egg.')


class ContextualZipFile(zipfile.ZipFile):

    """Supplement ZipFile class to support context manager for Python 2.6."""

    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        self.close()

    def __new__(cls, *args, **kwargs):
        """Construct a ZipFile or ContextualZipFile as appropriate."""
        if hasattr(zipfile.ZipFile, '__exit__'):
            return zipfile.ZipFile(*args, **kwargs)
        return super(ContextualZipFile, cls).__new__(cls)


@contextlib.contextmanager
def archive_context(filename):
    """
    Unzip filename to a temporary directory, set to the cwd.

    The unzipped target is cleaned up after.
    """
    tmpdir = tempfile.mkdtemp()
    log.warn('Extracting in %s', tmpdir)
    old_wd = os.getcwd()
    try:
        os.chdir(tmpdir)
        with ContextualZipFile(filename) as archive:
            archive.extractall()

        # going in the directory
        subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
        os.chdir(subdir)
        log.warn('Now working in %s', subdir)
        yield

    finally:
        os.chdir(old_wd)
        shutil.rmtree(tmpdir)


def _do_download(version, download_base, to_dir, download_delay):
    """Download Setuptools."""
    egg = os.path.join(to_dir, 'setuptools-%s-py%d.%d.egg'
                       % (version, sys.version_info[0], sys.version_info[1]))
    if not os.path.exists(egg):
        archive = download_setuptools(version, download_base,
                                      to_dir, download_delay)
        _build_egg(egg, archive, to_dir)
    sys.path.insert(0, egg)

    # Remove previously-imported pkg_resources if present (see
    # https://bitbucket.org/pypa/setuptools/pull-request/7/ for details).
    if 'pkg_resources' in sys.modules:
        del sys.modules['pkg_resources']

    import setuptools
    setuptools.bootstrap_install_from = egg


def use_setuptools(
        version=DEFAULT_VERSION, download_base=DEFAULT_URL,
        to_dir=DEFAULT_SAVE_DIR, download_delay=15):
    """
    Ensure that a setuptools version is installed.

    Return None. Raise SystemExit if the requested version
    or later cannot be installed.
    """
    to_dir = os.path.abspath(to_dir)

    # prior to importing, capture the module state for
    # representative modules.
    rep_modules = 'pkg_resources', 'setuptools'
    imported = set(sys.modules).intersection(rep_modules)

    try:
        import pkg_resources
        pkg_resources.require("setuptools>=" + version)
        # a suitable version is already installed
        return
    except ImportError:
        # pkg_resources not available; setuptools is not installed; download
        pass
    except pkg_resources.DistributionNotFound:
        # no version of setuptools was found; allow download
        pass
    except pkg_resources.VersionConflict as VC_err:
        if imported:
            _conflict_bail(VC_err, version)

        # otherwise, unload pkg_resources to allow the downloaded version to
        #  take precedence.
        del pkg_resources
        _unload_pkg_resources()

    return _do_download(version, download_base, to_dir, download_delay)


def _conflict_bail(VC_err, version):
    """
    Setuptools was imported prior to invocation, so it is
    unsafe to unload it. Bail out.
    """
    conflict_tmpl = textwrap.dedent("""
        The required version of setuptools (>={version}) is not available,
        and can't be installed while this script is running. Please
        install a more recent version first, using
        'easy_install -U setuptools'.

        (Currently using {VC_err.args[0]!r})
        """)
    msg = conflict_tmpl.format(**locals())
    sys.stderr.write(msg)
    sys.exit(2)


def _unload_pkg_resources():
    del_modules = [
        name for name in sys.modules
        if name.startswith('pkg_resources')
    ]
    for mod_name in del_modules:
        del sys.modules[mod_name]


def _clean_check(cmd, target):
    """
    Run the command to download target.

    If the command fails, clean up before re-raising the error.
    """
    try:
        subprocess.check_call(cmd)
    except subprocess.CalledProcessError:
        if os.access(target, os.F_OK):
            os.unlink(target)
        raise


def download_file_powershell(url, target):
    """
    Download the file at url to target using Powershell.

    Powershell will validate trust.
    Raise an exception if the command cannot complete.
    """
    target = os.path.abspath(target)
    ps_cmd = (
        "[System.Net.WebRequest]::DefaultWebProxy.Credentials = "
        "[System.Net.CredentialCache]::DefaultCredentials; "
        "(new-object System.Net.WebClient).DownloadFile(%(url)r, %(target)r)"
        % vars()
    )
    cmd = [
        'powershell',
        '-Command',
        ps_cmd,
    ]
    _clean_check(cmd, target)


def has_powershell():
    """Determine if Powershell is available."""
    if platform.system() != 'Windows':
        return False
    cmd = ['powershell', '-Command', 'echo test']
    with open(os.path.devnull, 'wb') as devnull:
        try:
            subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
        except Exception:
            return False
    return True
download_file_powershell.viable = has_powershell


def download_file_curl(url, target):
    cmd = ['curl', url, '--silent', '--output', target]
    _clean_check(cmd, target)


def has_curl():
    cmd = ['curl', '--version']
    with open(os.path.devnull, 'wb') as devnull:
        try:
            subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
        except Exception:
            return False
    return True
download_file_curl.viable = has_curl


def download_file_wget(url, target):
    cmd = ['wget', url, '--quiet', '--output-document', target]
    _clean_check(cmd, target)


def has_wget():
    cmd = ['wget', '--version']
    with open(os.path.devnull, 'wb') as devnull:
        try:
            subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
        except Exception:
            return False
    return True
download_file_wget.viable = has_wget


def download_file_insecure(url, target):
    """Use Python to download the file, without connection authentication."""
    src = urlopen(url)
    try:
        # Read all the data in one block.
        data = src.read()
    finally:
        src.close()

    # Write all the data in one block to avoid creating a partial file.
    with open(target, "wb") as dst:
        dst.write(data)
download_file_insecure.viable = lambda: True


def get_best_downloader():
    downloaders = (
        download_file_powershell,
        download_file_curl,
        download_file_wget,
        download_file_insecure,
    )
    viable_downloaders = (dl for dl in downloaders if dl.viable())
    return next(viable_downloaders, None)


def download_setuptools(
        version=DEFAULT_VERSION, download_base=DEFAULT_URL,
        to_dir=DEFAULT_SAVE_DIR, delay=15,
        downloader_factory=get_best_downloader):
    """
    Download setuptools from a specified location and return its filename.

    `version` should be a valid setuptools version number that is available
    as an sdist for download under the `download_base` URL (which should end
    with a '/'). `to_dir` is the directory where the egg will be downloaded.
    `delay` is the number of seconds to pause before an actual download
    attempt.

    ``downloader_factory`` should be a function taking no arguments and
    returning a function for downloading a URL to a target.
    """
    # making sure we use the absolute path
    to_dir = os.path.abspath(to_dir)
    zip_name = "setuptools-%s.zip" % version
    url = download_base + zip_name
    saveto = os.path.join(to_dir, zip_name)
    if not os.path.exists(saveto):  # Avoid repeated downloads
        log.warn("Downloading %s", url)
        downloader = downloader_factory()
        downloader(url, saveto)
    return os.path.realpath(saveto)


def _build_install_args(options):
    """
    Build the arguments to 'python setup.py install' on the setuptools package.

    Returns list of command line arguments.
    """
    return ['--user'] if options.user_install else []


def _parse_args():
    """Parse the command line for options."""
    parser = optparse.OptionParser()
    parser.add_option(
        '--user', dest='user_install', action='store_true', default=False,
        help='install in user site package (requires Python 2.6 or later)')
    parser.add_option(
        '--download-base', dest='download_base', metavar="URL",
        default=DEFAULT_URL,
        help='alternative URL from where to download the setuptools package')
    parser.add_option(
        '--insecure', dest='downloader_factory', action='store_const',
        const=lambda: download_file_insecure, default=get_best_downloader,
        help='Use internal, non-validating downloader'
    )
    parser.add_option(
        '--version', help="Specify which version to download",
        default=DEFAULT_VERSION,
    )
    parser.add_option(
    	'--to-dir',
    	help="Directory to save (and re-use) package",
    	default=DEFAULT_SAVE_DIR,
    )
    options, args = parser.parse_args()
    # positional arguments are ignored
    return options


def _download_args(options):
	"""Return args for download_setuptools function from cmdline args."""
	return dict(
		version=options.version,
		download_base=options.download_base,
		downloader_factory=options.downloader_factory,
		to_dir=options.to_dir,
	)


def main():
    """Install or upgrade setuptools and EasyInstall."""
    options = _parse_args()
    archive = download_setuptools(**_download_args(options))
    return _install(archive, _build_install_args(options))

if __name__ == '__main__':
    sys.exit(main())
healpy-1.10.3/run_pykg_config.py0000664000175000017500000000042413010374155017062 0ustar  zoncazonca00000000000000# Helper to run pykg-config, whether it is installed or lives in a zipped egg.
from setuptools import Distribution
from pkg_resources import run_script
requirement = 'pykg-config >= 1.2.0'
Distribution().fetch_build_eggs(requirement)
run_script(requirement, 'pykg-config.py')
healpy-1.10.3/setup.py0000775000175000017500000004517213010375075015055 0ustar  zoncazonca00000000000000#!/usr/bin/env python

# Bootstrap setuptools installation. We require setuptools >= 3.2 because of a
# bug in earlier versions regarding C++ sources generated with Cython. See:
#    https://pypi.python.org/pypi/setuptools/3.6#id171
try:
    import pkg_resources
    pkg_resources.require("setuptools >= 3.2")
except pkg_resources.ResolutionError:
    from ez_setup import use_setuptools
    use_setuptools()

import os
import errno
import fnmatch
import sys
import shlex
from distutils.sysconfig import get_config_var, get_config_vars
from subprocess import check_output, CalledProcessError, check_call
from setuptools import setup
from setuptools.dist import Distribution
from setuptools.command.test import test as TestCommand
from distutils.command.build_clib import build_clib
from distutils.errors import DistutilsExecError
from distutils.dir_util import mkpath
from distutils.file_util import copy_file
from distutils import log

# Apple switched default C++ standard libraries (from gcc's libstdc++ to
# clang's libc++), but some pre-packaged Python environments such as Anaconda
# are built against the old C++ standard library. Luckily, we don't have to
# actually detect which C++ standard library was used to build the Python
# interpreter. We just have to propagate MACOSX_DEPLOYMENT_TARGET from the
# configuration variables to the environment.
#
# This workaround fixes .
if get_config_var('MACOSX_DEPLOYMENT_TARGET') and not 'MACOSX_DEPLOYMENT_TARGET' in os.environ:
    os.environ['MACOSX_DEPLOYMENT_TARGET'] = get_config_var('MACOSX_DEPLOYMENT_TARGET')


# If the Cython-generated C++ files are absent, then fetch and install Cython
# as an egg. If the Cython-generated files are present, then only use Cython if
# a sufficiently new version of Cython is already present on the system.
cython_require = 'Cython >= 0.16'
log.info('checking if Cython-generated files have been built')
try:
    open('healpy/src/_query_disc.cpp')
except IOError:
    log.info('Cython-generated files are absent; installing Cython locally')
    Distribution().fetch_build_eggs(cython_require)
else:
    log.info('Cython-generated files are present')
try:
    log.info('Checking for %s', cython_require)
    pkg_resources.require(cython_require)
except pkg_resources.ResolutionError:
    log.info('%s is not installed; not using Cython')
    from setuptools.command.build_ext import build_ext
    from setuptools import Extension
else:
    log.info('%s is installed; using Cython')
    from Cython.Distutils import build_ext, Extension


class build_external_clib(build_clib):
    """Subclass of Distutils' standard build_clib subcommand. Adds support for
    libraries that are installed externally and detected with pkg-config, with
    an optional fallback to build from a local configure-make-install style
    distribution."""

    def __init__(self, dist):
        build_clib.__init__(self, dist)
        self.build_args = {}

    def autotools_path(self):
        """
        Install Autotools locally if we are building on Read The Docs, because
        we will be building from git and need to generate the healpix_cxx build
        system.
        """
        on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
        if not on_rtd:
            return None

        log.info("checking if autotools is installed")
        try:
            check_output(['autoreconf', '--version'])
        except OSError as e:
            if e.errno != errno.ENOENT:
                raise
            log.info("autotools is not installed")
        else:
            log.info("autotools is already installed")
            return None

        urls = [
            'https://ftp.gnu.org/gnu/m4/m4-1.4.17.tar.gz',
            'https://ftp.gnu.org/gnu/libtool/libtool-2.4.6.tar.gz',
            'https://ftp.gnu.org/gnu/autoconf/autoconf-2.69.tar.gz',
            'https://ftp.gnu.org/gnu/automake/automake-1.15.tar.gz',
            'https://pkg-config.freedesktop.org/releases/pkg-config-0.29.1.tar.gz'
        ]

        # Use a subdirectory of build_temp as the build directory.
        build_temp = os.path.realpath(self.build_temp)
        prefix = os.path.join(build_temp, 'autotools')
        mkpath(prefix)

        env = dict(os.environ)
        path = os.path.join(prefix, 'bin')
        try:
            path += ':' + env['PATH']
        except KeyError:
            pass
        env['PATH'] = path

        # Check again if autotools is available, now that we have added the
        # temporary path.
        try:
            check_output(['autoreconf', '--version'], env=env)
        except OSError as e:
            if e.errno != errno.ENOENT:
                raise
            log.info("building autotools from source")
        else:
            log.info("using autotools built from source")
            return path

        # Otherwise, build from source.
        for url in urls:
            _, _, tarball = url.rpartition('/')
            pkg_version = tarball.replace('.tar.gz', '')
            log.info('downloading %s', url)
            check_call(['curl', '-O', url], cwd=build_temp)
            log.info('extracting %s', tarball)
            check_call(['tar', '-xzf', tarball], cwd=build_temp)
            cwd = os.path.join(build_temp, pkg_version)
            log.info('configuring %s', pkg_version)
            check_call(['./configure', '--prefix', prefix, '--with-internal-glib'], env=env, cwd=cwd)
            log.info('making %s', pkg_version)
            check_call(['make', 'install'], env=env, cwd=cwd)
        return path

    def env(self):
        """Construct an environment dictionary suitable for having pkg-config
        pick up .pc files in the build_clib directory."""
        # Test if pkg-config is present. If not, fall back to pykg-config.
        try:
            env = self._env
        except AttributeError:
            env = dict(os.environ)

            path = self.autotools_path()
            if path is not None:
                env['PATH'] = path

            try:
                check_output(['pkg-config', '--version'])
            except OSError as e:
                if e.errno != errno.ENOENT:
                    raise
                log.warn('pkg-config is not installed, falling back to pykg-config')
                env['PKG_CONFIG'] = sys.executable + ' ' + os.path.abspath('run_pykg_config.py')
            else:
                env['PKG_CONFIG'] = 'pkg-config'

            build_clib = os.path.realpath(self.build_clib)
            pkg_config_path = (
                os.path.join(build_clib, 'lib64', 'pkgconfig') +
                ':' + os.path.join(build_clib, 'lib', 'pkgconfig'))
            try:
                pkg_config_path += ':' + env['PKG_CONFIG_PATH']
            except KeyError:
                pass
            env['PKG_CONFIG_PATH'] = pkg_config_path

            self._env = env
        return env

    def pkgconfig(self, *packages):
        env = self.env()
        PKG_CONFIG = tuple(shlex.split(
            env['PKG_CONFIG'], posix=(os.sep == '/')))
        kw = {}
        index_key_flag = (
            (2, '--cflags-only-I', ('include_dirs',)),
            (0, '--cflags-only-other', ('extra_compile_args', 'extra_link_args')),
            (2, '--libs-only-L', ('library_dirs', 'runtime_library_dirs')),
            (2, '--libs-only-l', ('libraries',)),
            (0, '--libs-only-other', ('extra_link_args',)))
        for index, flag, keys in index_key_flag:
            cmd = PKG_CONFIG + (flag,) + tuple(packages)
            log.debug('%s', ' '.join(cmd))
            args = [token[index:].decode() for token in check_output(cmd, env=env).split()]
            if args:
                for key in keys:
                    kw.setdefault(key, []).extend(args)
        return kw

    def finalize_options(self):
        """Run 'autoreconf -i' for any bundled libraries to generate the
        configure script."""
        build_clib.finalize_options(self)
        env = self.env()

        for lib_name, build_info in self.libraries:
            if 'sources' not in build_info:
                log.info("checking if configure script for library '%s' exists", lib_name)
                if not os.path.exists(os.path.join(build_info['local_source'], 'configure')):
                    log.info("running 'autoreconf -i' for library '%s'", lib_name)
                    check_call(['autoreconf', '-i'], cwd=build_info['local_source'], env=env)

    def build_library(self, library, pkg_config_name, local_source=None, supports_non_srcdir_builds=True):
        log.info("checking if library '%s' is installed", library)
        try:
            build_args = self.pkgconfig(pkg_config_name)
            log.info("found '%s' installed, using it", library)
        except CalledProcessError:

            # If local_source is not specified, then immediately fail.
            if local_source is None:
                raise DistutilsExecError("library '%s' is not installed", library)

            log.info("building library '%s' from source", library)

            env = self.env()

            # Determine which compilers we are to use, and what flags.
            # This is based on what distutils.sysconfig.customize_compiler()
            # does, but that function has a problem that it doesn't produce
            # necessary (e.g. architecture) flags for C++ compilers.
            cc, cxx, opt, cflags = get_config_vars('CC', 'CXX', 'OPT', 'CFLAGS')
            cxxflags = cflags

            if 'CC' in env:
                cc = env['CC']
            if 'CXX' in env:
                cxx = env['CXX']
            if 'CFLAGS' in env:
                cflags = opt + ' ' + env['CFLAGS']
            if 'CXXFLAGS' in env:
                cxxflags = opt + ' ' + env['CXXFLAGS']

            # Use a subdirectory of build_temp as the build directory.
            build_temp = os.path.realpath(os.path.join(self.build_temp, library))

            # Destination for headers and libraries is build_clib.
            build_clib = os.path.realpath(self.build_clib)

            # Create build directories if they do not yet exist.
            mkpath(build_temp)
            mkpath(build_clib)

            if not supports_non_srcdir_builds:
                self._stage_files_recursive(local_source, build_temp)

            # Run configure.
            cmd = ['/bin/sh', os.path.join(os.path.realpath(local_source), 'configure'),
                '--prefix=' + build_clib,
                '--disable-shared',
                '--with-pic',
                '--disable-maintainer-mode']

            log.info('%s', ' '.join(cmd))
            check_call(cmd, cwd=build_temp, env=dict(env,
                CC=cc, CXX=cxx, CFLAGS=cflags, CXXFLAGS=cxxflags))

            # Run make install.
            cmd = ['make', 'install']
            log.info('%s', ' '.join(cmd))
            check_call(cmd, cwd=build_temp, env=env)

            build_args = self.pkgconfig(pkg_config_name)

        return build_args
        # Done!

    @staticmethod
    def _list_files_recursive(path, skip=('.*', '*.o', 'autom4te.cache')):
        """Yield paths to all of the files contained within the given path,
        following symlinks. If skip is a tuple of fnmatch()-style wildcard
        strings, skip any directory or filename matching any of the patterns in
        skip."""
        for dirpath, dirnames, filenames in os.walk(path, followlinks=True):
            if not any(any(fnmatch.fnmatch(p, s) for s in skip) for p in dirpath.split(os.sep)):
                for filename in filenames:
                    if not any(fnmatch.fnmatch(filename, s) for s in skip):
                        yield os.path.join(dirpath, filename)

    @staticmethod
    def _stage_files_recursive(src, dest, skip=None):
        """Hard link or copy all of the files in the path src into the path dest.
        Subdirectories are created as needed, and files in dest are overwritten."""
        # Use hard links if they are supported on this system.
        if hasattr(os, 'link'):
            link='hard'
        elif hasattr(os, 'symlink'):
            link='sym'
        else:
            link=None

        for dirpath, dirnames, filenames in os.walk(src, followlinks=True):
            if not any(p.startswith('.') for p in dirpath.split(os.sep)):
                dest_dirpath = os.path.join(dest, dirpath.split(src, 1)[1].lstrip(os.sep))
                mkpath(dest_dirpath)
                for filename in filenames:
                    if not filename.startswith('.'):
                        src_path = os.path.join(dirpath, filename)
                        dest_path = os.path.join(dest_dirpath, filename)
                        if not os.path.exists(dest_path):
                            copy_file(os.path.join(dirpath, filename), os.path.join(dest_dirpath, filename))

    def get_source_files(self):
        """Copied from Distutils' own build_clib, but modified so that it is not
        an error for a build_info dictionary to lack a 'sources' key. If there
        is no 'sources' key, then all files contained within the path given by
        the 'local_sources' value are returned."""
        self.check_library_list(self.libraries)
        filenames = []
        for (lib_name, build_info) in self.libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                sources = list(self._list_files_recursive(build_info['local_source']))

            filenames.extend(sources)
        return filenames

    def build_libraries(self, libraries):
        # Build libraries that have no 'sources' key, accumulating the output
        # from pkg-config.
        for lib_name, build_info in libraries:
            if 'sources' not in build_info:
                for key, value in self.build_library(lib_name, **build_info).items():
                    if key in self.build_args:
                        self.build_args[key].extend(value)
                    else:
                        self.build_args[key] = value

        # Use parent method to build libraries that have a 'sources' key.
        build_clib.build_libraries(self, ((lib_name, build_info)
            for lib_name, build_info in libraries if 'sources' in build_info))


class custom_build_ext(build_ext):
    def finalize_options(self):
        build_ext.finalize_options(self)

        # Make sure that Numpy is importable
        # (does the same thing as setup_requires=['numpy'])
        self.distribution.fetch_build_eggs('numpy')
        # Prevent numpy from thinking it is still in its setup process:
        # See http://stackoverflow.com/questions/19919905
        __builtins__.__NUMPY_SETUP__ = False

        # Add Numpy header search path path
        import numpy
        self.include_dirs.append(numpy.get_include())

    def run(self):
        # If we were asked to build any C/C++ libraries, add the directory
        # where we built them to the include path. (It's already on the library
        # path.)
        if self.distribution.has_c_libraries():
            self.run_command('build_clib')
            build_clib = self.get_finalized_command('build_clib')
            for key, value in build_clib.build_args.items():
                for ext in self.extensions:
                    if not hasattr(ext, key) or getattr(ext, key) is None:
                        setattr(ext, key, value)
                    else:
                        getattr(ext, key).extend(value)
        build_ext.run(self)


class PyTest(TestCommand):
    """Custom Setuptools test command to run doctests with py.test. Based on
    http://pytest.org/latest/goodpractises.html#integration-with-setuptools-test-commands"""

    def finalize_options(self):
        TestCommand.finalize_options(self)
        self.test_args.insert(0, '--doctest-modules')

    def run_tests(self):
        import pytest
        sys.exit(pytest.main(self.test_args))


exec(open('healpy/version.py').read())


setup(name='healpy',
      version=__version__,
      description='Healpix tools package for Python',
      classifiers=[
          'Development Status :: 5 - Production/Stable',
          'Environment :: Console',
          'Intended Audience :: Science/Research',
          'License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)',
          'Operating System :: POSIX',
          'Programming Language :: C++',
          'Programming Language :: Python :: 2.7',
          'Programming Language :: Python :: 3.2',
          'Programming Language :: Python :: 3.3',
          'Programming Language :: Python :: 3.4',
          'Programming Language :: Python :: 3.5',
          'Topic :: Scientific/Engineering :: Astronomy',
          'Topic :: Scientific/Engineering :: Visualization'
      ],
      author='C. Rosset, A. Zonca',
      author_email='cyrille.rosset@apc.univ-paris-diderot.fr',
      url='http://github.com/healpy',
      packages=['healpy','healpy.test'],
      libraries=[
          ('cfitsio', {
           'pkg_config_name': 'cfitsio',
           'local_source': 'cfitsio',
           'supports_non_srcdir_builds': False}),
          ('healpix_cxx', {
           'pkg_config_name': 'healpix_cxx >= 3.30.0',
           'local_source': 'healpixsubmodule/src/cxx/autotools'})
      ],
      py_modules=['healpy.pixelfunc','healpy.sphtfunc',
                  'healpy.visufunc','healpy.fitsfunc',
                  'healpy.projector','healpy.rotator',
                  'healpy.projaxes','healpy.version'],
      cmdclass={
          'build_ext': custom_build_ext,
          'build_clib': build_external_clib,
          'test': PyTest
      },
      ext_modules=[
          Extension('healpy._healpy_pixel_lib',
                    sources=['healpy/src/_healpy_pixel_lib.cc'],
                    language='c++'),
          Extension('healpy._healpy_sph_transform_lib',
                    sources=['healpy/src/_healpy_sph_transform_lib.cc'],
                    language='c++'),
          Extension('healpy._healpy_fitsio_lib',
                    sources=['healpy/src/_healpy_fitsio_lib.cc'],
                    language='c++'),
          Extension("healpy._query_disc",
                    ['healpy/src/_query_disc.pyx'],
                    language='c++',
                    cython_directives=dict(embedsignature=True)),
          Extension("healpy._sphtools",
                    ['healpy/src/_sphtools.pyx'],
                    language='c++',
                    cython_directives=dict(embedsignature=True)),
          Extension("healpy._pixelfunc",
                    ['healpy/src/_pixelfunc.pyx'],
                    language='c++',
                    cython_directives=dict(embedsignature=True))
      ],
      package_data = {'healpy': ['data/*.fits', 'data/totcls.dat', 'test/data/*.fits', 'test/data/*.sh']},
      install_requires=['matplotlib', 'numpy', 'six', 'astropy'],
      tests_require=['pytest'],
      test_suite='healpy',
      license='GPLv2'
      )
healpy-1.10.3/PKG-INFO0000664000175000017500000000165413031130324014417 0ustar  zoncazonca00000000000000Metadata-Version: 1.1
Name: healpy
Version: 1.10.3
Summary: Healpix tools package for Python
Home-page: http://github.com/healpy
Author: C. Rosset, A. Zonca
Author-email: cyrille.rosset@apc.univ-paris-diderot.fr
License: GPLv2
Description: UNKNOWN
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
Classifier: Operating System :: POSIX
Classifier: Programming Language :: C++
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Topic :: Scientific/Engineering :: Astronomy
Classifier: Topic :: Scientific/Engineering :: Visualization
healpy-1.10.3/setup.cfg0000664000175000017500000000007313031130324015135 0ustar  zoncazonca00000000000000[egg_info]
tag_build = 
tag_date = 0
tag_svn_revision = 0